diff --git a/src/domain/phase.test.ts b/src/domain/phase.test.ts
index e0a82a0..bf5aaf4 100644
--- a/src/domain/phase.test.ts
+++ b/src/domain/phase.test.ts
@@ -10,16 +10,24 @@ describe("phaseAt", () => {
 
     expect(phaseAt(durationMs - 1, routine)).toMatchObject({
       status: "running",
+      phaseKind: "work",
       displayMs: 1,
+      remainingInPhaseMs: 1,
       elapsedMs: durationMs - 1,
+      round: 1,
+      totalRounds: 1,
+      nextPhaseKind: "done",
     });
     expect(phaseAt(durationMs, routine)).toMatchObject({
       status: "done",
+      phaseKind: "done",
       displayMs: 0,
       elapsedMs: durationMs,
+      round: 1,
     });
     expect(phaseAt(durationMs + 1, routine)).toMatchObject({
       status: "done",
+      phaseKind: "done",
       displayMs: 0,
       elapsedMs: durationMs + 1,
     });
@@ -48,4 +56,85 @@ describe("phaseAt", () => {
       elapsedMs: 0,
     });
   });
+
+  it.each([
+    {
+      name: "Tabata",
+      routine: countdown(20_000, 10_000, 8),
+      phases: [
+        "work",
+        "rest",
+        "work",
+        "rest",
+        "work",
+        "rest",
+        "work",
+        "rest",
+        "work",
+        "rest",
+        "work",
+        "rest",
+        "work",
+        "rest",
+        "work",
+        "rest",
+      ],
+    },
+    {
+      name: "EMOM",
+      routine: countdown(60_000, 0, 10),
+      phases: ["work", "work", "work", "work", "work", "work", "work", "work", "work", "work"],
+    },
+    {
+      name: "Pomodoro",
+      routine: countdown(25 * 60_000, 5 * 60_000, 4),
+      phases: ["work", "rest", "work", "rest", "work", "rest", "work", "rest"],
+    },
+  ])("derives the $name phase sequence from elapsed time", ({ routine, phases }) => {
+    let elapsed = 0;
+    const actual: string[] = [];
+
+    for (let round = 1; round <= routine.rounds; round += 1) {
+      actual.push(phaseAt(elapsed, routine).phaseKind);
+      elapsed += routine.durationMs;
+      if (routine.restMs > 0) {
+        actual.push(phaseAt(elapsed, routine).phaseKind);
+        elapsed += routine.restMs;
+      }
+    }
+
+    expect(actual).toEqual(phases);
+    expect(phaseAt(elapsed, routine)).toMatchObject({ status: "done", phaseKind: "done" });
+  });
+
+  it("changes phase only at exact boundaries", () => {
+    const routine = countdown(20_000, 10_000, 2);
+
+    expect(phaseAt(19_999, routine)).toMatchObject({
+      phaseKind: "work",
+      round: 1,
+      remainingInPhaseMs: 1,
+    });
+    expect(phaseAt(20_000, routine)).toMatchObject({
+      phaseKind: "rest",
+      round: 1,
+      remainingInPhaseMs: 10_000,
+    });
+    expect(phaseAt(29_999, routine)).toMatchObject({
+      phaseKind: "rest",
+      round: 1,
+      remainingInPhaseMs: 1,
+    });
+    expect(phaseAt(30_000, routine)).toMatchObject({
+      phaseKind: "work",
+      round: 2,
+      remainingInPhaseMs: 20_000,
+    });
+    expect(phaseAt(59_999, routine)).toMatchObject({
+      phaseKind: "rest",
+      round: 2,
+      remainingInPhaseMs: 1,
+    });
+    expect(phaseAt(60_000, routine)).toMatchObject({ status: "done", phaseKind: "done", round: 2 });
+  });
 });
diff --git a/src/domain/phase.ts b/src/domain/phase.ts
index dd99381..74b6f8d 100644
--- a/src/domain/phase.ts
+++ b/src/domain/phase.ts
@@ -1,25 +1,100 @@
 import { MAX_DURATION_MS, type Routine } from "./routine.ts";
 
+export type PhaseKind = "prepare" | "work" | "rest" | "done";
 export type TimerStatus = "running" | "done";
 
 export type TimerState = {
   status: TimerStatus;
+  phaseKind: PhaseKind;
+  remainingInPhaseMs: number;
+  elapsedInPhaseMs: number;
+  phaseProgress: number;
+  round: number;
+  totalRounds: number;
+  nextPhaseKind: PhaseKind | null;
+  totalElapsedMs: number;
+  /** Compatibility aliases used by the existing display and clock screens. */
   displayMs: number;
   elapsedMs: number;
 };
 
+const doneState = (
+  elapsedMs: number,
+  totalRounds: number,
+  totalElapsedMs: number,
+  displayMs = 0,
+): TimerState => ({
+  status: "done",
+  phaseKind: "done",
+  remainingInPhaseMs: 0,
+  elapsedInPhaseMs: 0,
+  phaseProgress: 1,
+  round: totalRounds,
+  totalRounds,
+  nextPhaseKind: null,
+  totalElapsedMs,
+  displayMs,
+  elapsedMs,
+});
+
 /**
  * Derive display state from elapsed time. No ticking state lives here, so a delayed frame still lands
- * on the correct value and exact countdown zero can end the Routine without rendering a negative time.
+ * on the correct value and exact phase boundaries never drift.
  */
 export const phaseAt = (rawElapsedMs: number, routine: Routine): TimerState => {
-  const elapsedMs = Math.max(0, rawElapsedMs);
+  const elapsedMs = Number.isFinite(rawElapsedMs) ? Math.max(0, rawElapsedMs) : 0;
 
-  if (routine.direction === "down") {
-    const displayMs = Math.max(0, routine.durationMs - elapsedMs);
-    return { status: displayMs === 0 ? "done" : "running", displayMs, elapsedMs };
+  if (routine.direction === "up") {
+    const displayMs = Math.min(MAX_DURATION_MS, elapsedMs);
+    return displayMs === MAX_DURATION_MS
+      ? doneState(elapsedMs, 1, MAX_DURATION_MS, MAX_DURATION_MS)
+      : {
+          status: "running",
+          phaseKind: "work",
+          remainingInPhaseMs: elapsedMs,
+          elapsedInPhaseMs: elapsedMs,
+          phaseProgress: 0,
+          round: 1,
+          totalRounds: 1,
+          nextPhaseKind: null,
+          totalElapsedMs: elapsedMs,
+          displayMs,
+          elapsedMs,
+        };
   }
 
-  const displayMs = Math.min(MAX_DURATION_MS, elapsedMs);
-  return { status: displayMs === MAX_DURATION_MS ? "done" : "running", displayMs, elapsedMs };
+  const roundLengthMs = routine.durationMs + routine.restMs;
+  const totalDurationMs = roundLengthMs * routine.rounds;
+  if (elapsedMs >= totalDurationMs) return doneState(elapsedMs, routine.rounds, totalDurationMs);
+
+  const round = Math.floor(elapsedMs / roundLengthMs) + 1;
+  const elapsedInRoundMs = elapsedMs % roundLengthMs;
+  const inRest = routine.restMs > 0 && elapsedInRoundMs >= routine.durationMs;
+  const phaseKind: PhaseKind = inRest ? "rest" : "work";
+  const phaseDurationMs = inRest ? routine.restMs : routine.durationMs;
+  const elapsedInPhaseMs = inRest ? elapsedInRoundMs - routine.durationMs : elapsedInRoundMs;
+  const remainingInPhaseMs = phaseDurationMs - elapsedInPhaseMs;
+  const nextPhaseKind: PhaseKind = inRest
+    ? round < routine.rounds
+      ? "work"
+      : "done"
+    : routine.restMs > 0
+      ? "rest"
+      : round < routine.rounds
+        ? "work"
+        : "done";
+
+  return {
+    status: "running",
+    phaseKind,
+    remainingInPhaseMs,
+    elapsedInPhaseMs,
+    phaseProgress: elapsedInPhaseMs / phaseDurationMs,
+    round,
+    totalRounds: routine.rounds,
+    nextPhaseKind,
+    totalElapsedMs: elapsedMs,
+    displayMs: remainingInPhaseMs,
+    elapsedMs,
+  };
 };
diff --git a/src/domain/routine.test.ts b/src/domain/routine.test.ts
index b452350..49172b0 100644
--- a/src/domain/routine.test.ts
+++ b/src/domain/routine.test.ts
@@ -1,16 +1,25 @@
 import { describe, expect, it } from "vitest";
 import {
+  clampRounds,
   countdown,
   DEFAULT_DURATION_MS,
   durationFromParts,
   MAX_DURATION_MS,
+  MAX_ROUNDS,
   MIN_DURATION_MS,
+  MIN_ROUNDS,
   stepDuration,
+  stepRounds,
 } from "./routine.ts";
 
 describe("countdown duration", () => {
   it("defaults to five minutes", () => {
-    expect(countdown()).toEqual({ direction: "down", durationMs: DEFAULT_DURATION_MS });
+    expect(countdown()).toEqual({
+      direction: "down",
+      durationMs: DEFAULT_DURATION_MS,
+      restMs: 0,
+      rounds: 1,
+    });
   });
 
   it("carries seconds into minutes", () => {
@@ -38,4 +47,20 @@ describe("countdown duration", () => {
     expect(durationFromParts(99, 60)).toBe(MAX_DURATION_MS);
     expect(durationFromParts(Number.NaN, Number.POSITIVE_INFINITY)).toBe(MIN_DURATION_MS);
   });
+
+  it("allows rest to be disabled at zero", () => {
+    expect(countdown(20_000, 0, 8)).toMatchObject({ restMs: 0, rounds: 8 });
+    expect(durationFromParts(0, 0, true)).toBe(0);
+    expect(stepDuration(0, "seconds", -1, true)).toBe(0);
+    expect(stepDuration(1000, "seconds", -1, true)).toBe(0);
+  });
+
+  it("clamps rounds and steps them one at a time", () => {
+    expect(clampRounds(0)).toBe(MIN_ROUNDS);
+    expect(clampRounds(MAX_ROUNDS + 1)).toBe(MAX_ROUNDS);
+    expect(clampRounds(Number.NaN)).toBe(MIN_ROUNDS);
+    expect(stepRounds(1, -1)).toBe(MIN_ROUNDS);
+    expect(stepRounds(MAX_ROUNDS, 1)).toBe(MAX_ROUNDS);
+    expect(stepRounds(8, 1)).toBe(9);
+  });
 });
diff --git a/src/domain/routine.ts b/src/domain/routine.ts
index 07d3912..0d0727e 100644
--- a/src/domain/routine.ts
+++ b/src/domain/routine.ts
@@ -1,9 +1,11 @@
-/** A Routine chooses count direction and, for countdowns, its configured duration. */
+/** A Routine chooses count direction and, for countdowns, its configured phases and rounds. */
 export type CountDirection = "up" | "down";
 
 export type Routine = {
   direction: CountDirection;
   durationMs: number;
+  restMs: number;
+  rounds: number;
 };
 
 export type DurationUnit = "minutes" | "seconds";
@@ -11,25 +13,51 @@ export type DurationUnit = "minutes" | "seconds";
 export const MIN_DURATION_MS = 1_000;
 export const MAX_DURATION_MS = 99 * 60_000 + 59_000;
 export const DEFAULT_DURATION_MS = 5 * 60_000;
+export const MIN_ROUNDS = 1;
+export const MAX_ROUNDS = 99;
 
-export const chrono = (): Routine => ({ direction: "up", durationMs: 0 });
-
-export const clampDuration = (durationMs: number): number => {
+const clampPhaseDuration = (durationMs: number, allowZero: boolean): number => {
   const rounded = Number.isFinite(durationMs) ? Math.round(durationMs) : MIN_DURATION_MS;
-  return Math.min(MAX_DURATION_MS, Math.max(MIN_DURATION_MS, rounded));
+  const minimum = allowZero ? 0 : MIN_DURATION_MS;
+  return Math.min(MAX_DURATION_MS, Math.max(minimum, rounded));
 };
 
-export const countdown = (durationMs = DEFAULT_DURATION_MS): Routine => ({
+export const clampDuration = (durationMs: number): number => clampPhaseDuration(durationMs, false);
+export const clampRestDuration = (durationMs: number): number =>
+  clampPhaseDuration(durationMs, true);
+
+export const clampRounds = (rounds: number): number => {
+  const whole = Number.isFinite(rounds) ? Math.trunc(rounds) : MIN_ROUNDS;
+  return Math.min(MAX_ROUNDS, Math.max(MIN_ROUNDS, whole));
+};
+
+export const chrono = (): Routine => ({ direction: "up", durationMs: 0, restMs: 0, rounds: 1 });
+
+export const countdown = (
+  durationMs = DEFAULT_DURATION_MS,
+  restMs = 0,
+  rounds = MIN_ROUNDS,
+): Routine => ({
   direction: "down",
   durationMs: clampDuration(durationMs),
+  restMs: clampRestDuration(restMs),
+  rounds: clampRounds(rounds),
 });
 
 /** Parse URL parts with the same carry and bounds as steppers. */
-export const durationFromParts = (minutes: number, seconds: number): number => {
+export const durationFromParts = (minutes: number, seconds: number, allowZero = false): number => {
   const whole = (value: number) => (Number.isFinite(value) ? Math.trunc(value) : 0);
-  return clampDuration((whole(minutes) * 60 + whole(seconds)) * 1000);
+  return clampPhaseDuration((whole(minutes) * 60 + whole(seconds)) * 1000, allowZero);
 };
 
 /** Step one labelled unit and carry between seconds and minutes naturally. */
-export const stepDuration = (durationMs: number, unit: DurationUnit, amount: number): number =>
-  clampDuration(durationMs + (unit === "minutes" ? 60_000 : 1_000) * amount);
+export const stepDuration = (
+  durationMs: number,
+  unit: DurationUnit,
+  amount: number,
+  allowZero = false,
+): number =>
+  clampPhaseDuration(durationMs + (unit === "minutes" ? 60_000 : 1_000) * amount, allowZero);
+
+/** Step rounds by one and keep them within the displayable range. */
+export const stepRounds = (rounds: number, amount: number): number => clampRounds(rounds + amount);
diff --git a/src/pages/configuration.astro b/src/pages/configuration.astro
index 98cf10c..04a4f89 100644
--- a/src/pages/configuration.astro
+++ b/src/pages/configuration.astro
@@ -8,8 +8,8 @@ import AppLayout from "../layouts/AppLayout.astro";
     <AppBar title="Configuration" backHref="/" backLabel="Up" />
 
     <form class="configuration-form" data-configuration-form>
-      <fieldset class="duration-settings">
-        <legend>Countdown duration</legend>
+      <fieldset class="duration-settings" data-phase-settings="work">
+        <legend>Work</legend>
         <time datetime="PT5M" data-display aria-live="off" aria-label="5 minutes">
           <span data-minutes aria-hidden="true">05</span><span class="separator" aria-hidden="true">:</span><span data-seconds aria-hidden="true">00</span>
         </time>
@@ -19,17 +19,47 @@ import AppLayout from "../layouts/AppLayout.astro";
         </div>
         <div class="stepper-row">
           <div class="stepper-group">
-            <button type="button" data-step="minutes" data-amount="1" aria-label="Increase countdown minutes by one">+</button>
-            <button type="button" data-step="minutes" data-amount="-1" aria-label="Decrease countdown minutes by one">−</button>
+            <button type="button" data-step="minutes" data-amount="1" aria-label="Increase work minutes by one">+</button>
+            <button type="button" data-step="minutes" data-amount="-1" aria-label="Decrease work minutes by one">−</button>
           </div>
           <div class="stepper-group">
-            <button type="button" data-step="seconds" data-amount="1" aria-label="Increase countdown seconds by one">+</button>
-            <button type="button" data-step="seconds" data-amount="-1" aria-label="Decrease countdown seconds by one">−</button>
+            <button type="button" data-step="seconds" data-amount="1" aria-label="Increase work seconds by one">+</button>
+            <button type="button" data-step="seconds" data-amount="-1" aria-label="Decrease work seconds by one">−</button>
           </div>
         </div>
       </fieldset>
 
-      <button type="button" data-action="accept">Accept</button>
+      <fieldset class="duration-settings" data-phase-settings="rest">
+        <legend>Rest <small>(0 means none)</small></legend>
+        <time datetime="PT0S" data-display aria-live="off" aria-label="0 seconds">
+          <span data-minutes aria-hidden="true">00</span><span class="separator" aria-hidden="true">:</span><span data-seconds aria-hidden="true">00</span>
+        </time>
+        <div class="duration-labels" aria-hidden="true">
+          <span>min</span>
+          <span>sec</span>
+        </div>
+        <div class="stepper-row">
+          <div class="stepper-group">
+            <button type="button" data-step="minutes" data-amount="1" aria-label="Increase rest minutes by one">+</button>
+            <button type="button" data-step="minutes" data-amount="-1" aria-label="Decrease rest minutes by one">−</button>
+          </div>
+          <div class="stepper-group">
+            <button type="button" data-step="seconds" data-amount="1" aria-label="Increase rest seconds by one">+</button>
+            <button type="button" data-step="seconds" data-amount="-1" aria-label="Decrease rest seconds by one">−</button>
+          </div>
+        </div>
+      </fieldset>
+
+      <fieldset class="round-settings">
+        <legend>Rounds</legend>
+        <output data-rounds aria-label="1 round">1</output>
+        <div class="stepper-group">
+          <button type="button" data-step="rounds" data-amount="1" aria-label="Increase rounds by one">+</button>
+          <button type="button" data-step="rounds" data-amount="-1" aria-label="Decrease rounds by one">−</button>
+        </div>
+      </fieldset>
+
+      <button type="button" data-action="start">Start</button>
     </form>
 
     <p class="visually-hidden" role="status" data-announcer></p>
@@ -39,29 +69,43 @@ import AppLayout from "../layouts/AppLayout.astro";
 <script>
   import { announceElapsed, formatElapsed } from "../domain/format.ts";
   import {
+    clampRounds,
     DEFAULT_DURATION_MS,
     durationFromParts,
     stepDuration,
+    stepRounds,
     type DurationUnit,
   } from "../domain/routine.ts";
 
-  const display = document.querySelector<HTMLTimeElement>("[data-display]")!;
-  const minutes = document.querySelector<HTMLElement>("[data-minutes]")!;
-  const seconds = document.querySelector<HTMLElement>("[data-seconds]")!;
-  const acceptButton = document.querySelector<HTMLButtonElement>('[data-action="accept"]')!;
+  const params = new URLSearchParams(location.search);
+  const workSettings = document.querySelector<HTMLElement>('[data-phase-settings="work"]')!;
+  const restSettings = document.querySelector<HTMLElement>('[data-phase-settings="rest"]')!;
+  const roundsDisplay = document.querySelector<HTMLOutputElement>("[data-rounds]")!;
+  const startButton = document.querySelector<HTMLButtonElement>('[data-action="start"]')!
   const announcer = document.querySelector<HTMLElement>("[data-announcer]")!;
   const stepButtons = document.querySelectorAll<HTMLButtonElement>("[data-step]");
 
-  const params = new URLSearchParams(location.search);
-  let durationMs = params.has("minutes") || params.has("seconds")
-    ? durationFromParts(Number(params.get("minutes") ?? 0), Number(params.get("seconds") ?? 0))
+  const param = (...names: string[]) => names.find((name) => params.has(name));
+  const workMinutes = param("workMinutes", "minutes");
+  const workSeconds = param("workSeconds", "seconds");
+  const restMinutes = param("restMinutes");
+  const restSeconds = param("restSeconds");
+  let workMs = workMinutes || workSeconds
+    ? durationFromParts(Number(params.get(workMinutes ?? "")), Number(params.get(workSeconds ?? "")))
     : DEFAULT_DURATION_MS;
+  let restMs = restMinutes || restSeconds
+    ? durationFromParts(Number(params.get(restMinutes ?? "")), Number(params.get(restSeconds ?? "")), true)
+    : 0;
+  let rounds = clampRounds(Number(params.get("rounds") ?? 1));
 
   const announce = (message: string) => {
     announcer.textContent = message;
   };
 
-  const render = () => {
+  const renderDuration = (settings: HTMLElement, durationMs: number) => {
+    const display = settings.querySelector<HTMLTimeElement>("[data-display]")!;
+    const minutes = settings.querySelector<HTMLElement>("[data-minutes]")!;
+    const seconds = settings.querySelector<HTMLElement>("[data-seconds]")!;
     const visible = formatElapsed(durationMs);
     const [mm, ss] = visible.split(":");
     minutes.textContent = mm;
@@ -70,18 +114,49 @@ import AppLayout from "../layouts/AppLayout.astro";
     display.setAttribute("aria-label", announceElapsed(durationMs));
   };
 
+  const render = () => {
+    renderDuration(workSettings, workMs);
+    renderDuration(restSettings, restMs);
+    roundsDisplay.textContent = String(rounds);
+    roundsDisplay.setAttribute("aria-label", `${rounds} ${rounds === 1 ? "round" : "rounds"}`);
+  };
+
   stepButtons.forEach((button) => {
     button.addEventListener("click", () => {
-      durationMs = stepDuration(durationMs, button.dataset.step as DurationUnit, Number(button.dataset.amount));
-      announce(`Countdown duration ${announceElapsed(durationMs)}.`);
+      const step = button.dataset.step;
+      const amount = Number(button.dataset.amount);
+      if (step === "rounds") {
+        rounds = stepRounds(rounds, amount);
+        announce(`Rounds: ${rounds}.`);
+      } else {
+        const settings = button.closest<HTMLElement>("[data-phase-settings]")!;
+        const isRest = settings.dataset.phaseSettings === "rest";
+        const duration = isRest ? restMs : workMs;
+        const next = stepDuration(duration, step as DurationUnit, amount, isRest);
+        if (isRest) restMs = next;
+        else workMs = next;
+        announce(`${isRest ? "Rest" : "Work"}: ${announceElapsed(next)}.`);
+      }
       render();
     });
   });
 
-  acceptButton.addEventListener("click", () => {
-    const minutesPart = Math.floor(durationMs / 60_000);
-    const secondsPart = Math.floor((durationMs % 60_000) / 1000);
-    location.href = `/down?minutes=${minutesPart}&seconds=${secondsPart}&paused=true`;
+  startButton.addEventListener("click", () => {
+    const parts = (durationMs: number) => ({
+      minutes: String(Math.floor(durationMs / 60_000)),
+      seconds: String(Math.floor(durationMs / 1000) % 60),
+    });
+    const work = parts(workMs);
+    const rest = parts(restMs);
+    const query = new URLSearchParams({
+      minutes: work.minutes,
+      seconds: work.seconds,
+      restMinutes: rest.minutes,
+      restSeconds: rest.seconds,
+      rounds: String(rounds),
+      paused: "true",
+    });
+    location.href = `/down?${query}`;
   });
 
   render();
diff --git a/src/pages/down.astro b/src/pages/down.astro
index 936e7aa..3fd249e 100644
--- a/src/pages/down.astro
+++ b/src/pages/down.astro
@@ -12,8 +12,14 @@ import AppLayout from "../layouts/AppLayout.astro";
     <p class="wake-lock-error" data-wake-lock-error role="alert" hidden></p>
     <p class="audio-note" data-audio-note hidden>Tap Start to enable sound.</p>
 
+    <p class="phase-status" data-phase-status data-phase="work" aria-live="polite">
+      <strong data-phase-kind>Work</strong>
+      <span>Round <span data-round>1</span> of <span data-total-rounds>1</span></span>
+      <span data-next-phase></span>
+    </p>
+
     <p class="finished" data-finished aria-hidden="true">
-      Done count down: <time data-configured-duration>05:00</time>
+      Done: <span data-completed-rounds>1</span> of <span data-summary-rounds>1</span> rounds
     </p>
 
     <div class="controls">
@@ -28,18 +34,30 @@ import AppLayout from "../layouts/AppLayout.astro";
 <script>
   import { elapsedMs, isRunning, pause, reset, resume, start, stopped } from "../domain/clock.ts";
   import type { Clock } from "../domain/clock.ts";
-  import { announceElapsed, formatElapsed, formatRemaining } from "../domain/format.ts";
-  import { countdown, DEFAULT_DURATION_MS, durationFromParts } from "../domain/routine.ts";
+  import { announceElapsed, formatRemaining } from "../domain/format.ts";
+  import {
+    clampRounds,
+    countdown,
+    DEFAULT_DURATION_MS,
+    durationFromParts,
+  } from "../domain/routine.ts";
   import { phaseAt } from "../domain/phase.ts";
   import { createCompletionSound } from "../client/completion-sound.ts";
   import { createScreenWakeLock, type ScreenWakeLockManager } from "../client/wake-lock.ts";
 
   const params = new URLSearchParams(location.search);
-  const hasDuration = params.has("minutes") || params.has("seconds");
-  const durationMs = hasDuration
-    ? durationFromParts(Number(params.get("minutes") ?? 0), Number(params.get("seconds") ?? 0))
+  const workMinutes = params.get("workMinutes") ?? params.get("minutes");
+  const workSeconds = params.get("workSeconds") ?? params.get("seconds");
+  const hasWorkDuration = workMinutes !== null || workSeconds !== null;
+  const durationMs = hasWorkDuration
+    ? durationFromParts(Number(workMinutes ?? 0), Number(workSeconds ?? 0))
     : DEFAULT_DURATION_MS;
-  const routine = countdown(durationMs);
+  const restMs = params.has("restMinutes") || params.has("restSeconds")
+    ? durationFromParts(Number(params.get("restMinutes") ?? 0), Number(params.get("restSeconds") ?? 0), true)
+    : 0;
+  const rounds = clampRounds(Number(params.get("rounds") ?? 1));
+  const routine = countdown(durationMs, restMs, rounds);
+  const totalDurationMs = (routine.durationMs + routine.restMs) * routine.rounds;
   const startsDone = params.has("done");
 
   const display = document.querySelector<HTMLTimeElement>("[data-display]")!;
@@ -48,7 +66,13 @@ import AppLayout from "../layouts/AppLayout.astro";
   const primary = document.querySelector<HTMLButtonElement>('[data-action="primary"]')!;
   const resetButton = document.querySelector<HTMLButtonElement>('[data-action="reset"]')!;
   const finished = document.querySelector<HTMLElement>("[data-finished]")!;
-  const configuredDuration = document.querySelector<HTMLTimeElement>("[data-configured-duration]")!;
+  const phaseStatus = document.querySelector<HTMLElement>("[data-phase-status]")!;
+  const phaseKind = document.querySelector<HTMLElement>("[data-phase-kind]")!;
+  const round = document.querySelector<HTMLElement>("[data-round]")!;
+  const totalRounds = document.querySelector<HTMLElement>("[data-total-rounds]")!;
+  const nextPhase = document.querySelector<HTMLElement>("[data-next-phase]")!;
+  const completedRounds = document.querySelector<HTMLElement>("[data-completed-rounds]")!;
+  const summaryRounds = document.querySelector<HTMLElement>("[data-summary-rounds]")!;
   const announcer = document.querySelector<HTMLElement>("[data-announcer]")!;
   const wakeLockError = document.querySelector<HTMLElement>("[data-wake-lock-error]")!;
   const audioNote = document.querySelector<HTMLElement>("[data-audio-note]")!;
@@ -100,7 +124,7 @@ import AppLayout from "../layouts/AppLayout.astro";
 
   const scheduleSound = (resumeExisting = false) => {
     const request = ++soundRequest;
-    const remainingMs = routine.durationMs - elapsedMs(clock, Date.now());
+    const remainingMs = totalDurationMs - elapsedMs(clock, Date.now());
     const schedule = resumeExisting ? completionSound.resume(remainingMs) : completionSound.start(remainingMs);
     void schedule.then((enabled) => {
       if (request !== soundRequest || isFinished || !isRunning(clock)) return;
@@ -120,19 +144,28 @@ import AppLayout from "../layouts/AppLayout.astro";
     history.replaceState(null, "", url);
   };
 
+  const labelPhase = (kind: string) => kind.charAt(0).toUpperCase() + kind.slice(1);
+
   const render = () => {
-    const state = phaseAt(elapsedMs(clock, Date.now()), routine);
-    const visible = formatRemaining(state.displayMs);
+    const state = isFinished ? phaseAt(totalDurationMs, routine) : phaseAt(elapsedMs(clock, Date.now()), routine);
+    const visible = formatRemaining(state.remainingInPhaseMs);
     const [mm, ss] = visible.split(":");
+    const currentPhase = isFinished ? "done" : state.phaseKind;
     minutes.textContent = mm;
     seconds.textContent = ss;
-    display.dateTime = `PT${state.displayMs / 1000}S`;
-    display.setAttribute("aria-label", announceElapsed(Math.ceil(state.displayMs / 1000) * 1000));
-    configuredDuration.textContent = formatElapsed(durationMs);
-    configuredDuration.dateTime = `PT${durationMs / 1000}S`;
+    display.dateTime = `PT${state.remainingInPhaseMs / 1000}S`;
+    display.setAttribute("aria-label", isFinished ? "Done" : `${labelPhase(state.phaseKind)}, ${announceElapsed(Math.ceil(state.remainingInPhaseMs / 1000) * 1000)}`);
+    phaseStatus.dataset.phase = currentPhase;
+    phaseKind.textContent = labelPhase(currentPhase);
+    round.textContent = String(state.round);
+    totalRounds.textContent = String(state.totalRounds);
+    nextPhase.textContent = state.nextPhaseKind && state.nextPhaseKind !== "done" ? `Next: ${labelPhase(state.nextPhaseKind)}` : "";
+    completedRounds.textContent = String(state.round);
+    summaryRounds.textContent = String(state.totalRounds);
     const status = isFinished ? "Done" : isRunning(clock) ? "Running" : clock.startedAt === null ? "" : "Paused";
     document.body.dataset.routineActive = String(!isFinished && clock.startedAt !== null);
-    const nextTitle = status ? `${status} · ${visible} - Down Timer` : `${visible} - Down Timer`;
+    const phaseLabel = isFinished ? "Done" : `${labelPhase(state.phaseKind)} · Round ${state.round} of ${state.totalRounds}`;
+    const nextTitle = status ? `${status} · ${phaseLabel} · ${visible} - Timer` : `${visible} - Timer`;
     if (nextTitle !== pageTitle) {
       pageTitle = nextTitle;
       document.title = nextTitle;
@@ -155,7 +188,7 @@ import AppLayout from "../layouts/AppLayout.astro";
     releaseWakeLock();
     stopTicking();
     setUrlState("done");
-    announce(`Done count down: ${announceElapsed(durationMs)}.`);
+    announce(`Done. ${routine.rounds} ${routine.rounds === 1 ? "round" : "rounds"} completed.`);
     paint();
     window.dispatchEvent(new Event("timer:counter-inactive"));
   };
@@ -183,7 +216,9 @@ import AppLayout from "../layouts/AppLayout.astro";
     scheduleSound();
     void refreshWakeLock();
     stopTicking();
-    announce(`Started. ${announceElapsed(durationMs)} configured.`);
+    announce(
+      `Started. ${announceElapsed(routine.durationMs)} work${routine.restMs > 0 ? `, ${announceElapsed(routine.restMs)} rest` : ""}, ${routine.rounds} ${routine.rounds === 1 ? "round" : "rounds"}.`,
+    );
     paint();
     tick();
   };
@@ -234,8 +269,11 @@ import AppLayout from "../layouts/AppLayout.astro";
 
   const configurationUrl = new URL("/configuration", location.origin);
   configurationUrl.search = new URLSearchParams({
-    minutes: String(Math.floor(durationMs / 60_000)),
-    seconds: String(Math.floor(durationMs / 1000) % 60),
+    minutes: String(Math.floor(routine.durationMs / 60_000)),
+    seconds: String(Math.floor(routine.durationMs / 1000) % 60),
+    restMinutes: String(Math.floor(routine.restMs / 60_000)),
+    restSeconds: String(Math.floor(routine.restMs / 1000) % 60),
+    rounds: String(routine.rounds),
   }).toString();
   configurationLink.href = `${configurationUrl.pathname}${configurationUrl.search}`;
 
diff --git a/src/styles/app.css b/src/styles/app.css
index 7263174..acaba0a 100644
--- a/src/styles/app.css
+++ b/src/styles/app.css
@@ -205,6 +205,35 @@ body > main {
   outline-offset: 2px;
 }
 
+.round-settings {
+  width: min(100%, 48rem);
+  margin: 0;
+  border: 0;
+  padding: 0;
+  text-align: center;
+}
+
+.round-settings legend {
+  width: 100%;
+}
+
+.round-settings output {
+  display: block;
+  color: var(--digit-colour);
+  font-size: 3rem;
+  font-variant-numeric: tabular-nums;
+  font-weight: 700;
+  line-height: 1;
+  text-shadow:
+    0 0 0.06em var(--digit-glow),
+    0 0 0.22em var(--digit-glow);
+}
+
+.round-settings .stepper-group {
+  width: min(100%, 16rem);
+  margin: 0.75rem auto 0;
+}
+
 .configuration-form {
   display: grid;
   align-content: start;
@@ -217,6 +246,34 @@ body > main {
   width: 100%;
 }
 
+.phase-status {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: center;
+  gap: 0.75rem;
+  min-height: 1.5rem;
+  margin: 0;
+  font-variant-numeric: tabular-nums;
+}
+
+.phase-status[data-phase="work"] {
+  color: #4ade80;
+}
+
+.phase-status[data-phase="rest"] {
+  color: #ff7b7b;
+}
+
+.phase-status[data-phase="done"] {
+  color: var(--pico-muted-color);
+}
+
+.phase-status strong {
+  font-weight: 800;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
 .wake-lock-error,
 .audio-note {
   margin: 0;