diff --git a/app/timer/page.tsx b/app/timer/page.tsx
index 1e97efe..0bdad2d 100644
--- a/app/timer/page.tsx
+++ b/app/timer/page.tsx
@@ -348,7 +348,7 @@ export default function TimerPage() {
         e.preventDefault();
         // On a break the one thing Space can mean is ending it. Pausing a
         // break is a control nobody reaches for and it reads as stopping. The
-        // next block then waits for another Space to start it.
+        // next block starts running.
         if (onBreak) endBreak();
         else if (liveActive.isPaused) resume();
         else pause();
diff --git a/lib/timer-context.tsx b/lib/timer-context.tsx
index 88ace82..45f3713 100644
--- a/lib/timer-context.tsx
+++ b/lib/timer-context.tsx
@@ -703,10 +703,9 @@ function toBreakState(state: TimerState, atMs: number, breakSeconds: number, fro
 }
 
 /**
- * End the break and set out the next block, at the same length as the last,
- * held at zero. It starts when the reader starts it, not when the break
- * ends: a block that began ticking the moment rest stopped was counting the
- * walk back to the desk as work.
+ * End the break and start the next block, at the same length as the last,
+ * running from zero. Pressing End break is the reader saying they are back,
+ * so the clock does not wait for a second press.
  */
 function toFocusState(state: TimerState, atMs: number): TimerState {
   return {
@@ -716,8 +715,8 @@ function toFocusState(state: TimerState, atMs: number): TimerState {
     startedAt: atMs,
     stretchStartedAt: atMs,
     accumulatedMs: 0,
-    isPaused: true,
-    pausedAt: atMs,
+    isPaused: false,
+    pausedAt: null,
     lastSeenAt: atMs,
     lastInputAt: atMs,
   };
@@ -1257,7 +1256,7 @@ export function TimerProvider({ children }: { children: React.ReactNode }) {
     [applyActive],
   );
 
-  /** End the break, set out the next block held at the same length as the last. */
+  /** End the break and start the next block at the same length as the last. */
   const endBreak = useCallback(() => {
     const running = activeRef.current;
     if (!running || running.phase !== 'break') return;
diff --git a/readmedesign.md b/readmedesign.md
index e7da45c..a1dc767 100644
--- a/readmedesign.md
+++ b/readmedesign.md
@@ -1644,13 +1644,10 @@ digits in mono, the words in the serif) and a smaller muted figure beside the
 dock's digits. Before the first break the two would be the same number
 twice, so it is not drawn.
 
-Nothing starts on its own after a break either. **End break** (one tap, or
-the space bar, or `P`) closes the rest and sets out the next block at the
-same length, held at zero: the clock reads `· ready` instead of `· paused`
-and the solid button says **Start**. The block begins when that is pressed,
-and its stretch in the chain starts there, not when the break ended. A block
-that ran the moment rest stopped was counting the walk back to the desk as
-work.
+**End break** (one tap, or the space bar, or `P`) closes the rest and starts
+the next block at once, at the same length, running from zero. Pressing it
+is the reader saying they are back, so the clock does not ask for a second
+press. The block's stretch in the chain starts there.
 
 ### The pause
 A pause and a break stay two things. Pause is "I have stepped away, count
@@ -2329,7 +2326,7 @@ back to their book. The timer's own keys (Space, F) only exist on the
 timer screen, which is the one screen a reader mid-chapter is least likely to
 be looking at, so stopping meant finding the dock with a mouse. `P` and `K`
 reach the clock from wherever they are: `P` holds it or lets it go, and means
-**end break** while a break runs (the next block then waits for another `P`); `K` finishes the sitting and the log sheet
+**end break** while a break runs (the next block starts running); `K` finishes the sitting and the log sheet
 opens on the spot, because `PageShell` already carries one on every tab. On
 the few screens that carry neither sheet nor shell, `K` opens the timer
 instead, so the key never ends a sitting with nothing to show for it.