plumbbob 0.10.3 → 0.11.0

package/skills/finish/SKILL.md

@@ -21,15 +21,19 @@ record.
    (`.plumbbob/builds/<slug>/report.md`), from `intent.md` + `build-log.md`.
    The build-log's `## Log` is already the chronological history; `plumbbob checkpoint`
    wrote a dated line for every step as it landed. **Read it as the spine; do not
-   re-narrate it.** The report adds only what the log does not already carry:
-   - **What shipped**: summarize from the `## Log` timeline; don't rebuild it step by step.
-   - **Decisions and why**: the settled calls that shaped the build (the *why* behind
+   re-narrate it.** The report adds only what the log does not already carry, one `##`
+   section apiece, in this order:
+   - `## What shipped`: summarize from the `## Log` timeline; don't rebuild it step by step.
+   - `## Decisions and why`: the settled calls that shaped the build (the *why* behind
      the log). Copy each one's `D# (slug)` from `intent.md` (never a bare `D#`) so
      the report reads without flipping back to the intent.
-   - **Parked & harvested**: what was captured and how each was classified.
-   - **Final status**: done or partial, and what is left.
-   - **Deferred tangents**: the harvested items that become future work.
-   This is the "yeah, I did that" artifact. Write it by default; the human may edit it.
+   - `## Parked & harvested`: what was captured and how each was classified.
+   - `## Final status`: done or partial, and what is left.
+   - `## Deferred tangents`: the harvested items that become future work.
+   Stop there. `plumbbob finish` appends `## Checkpoints` (the baseline and step SHAs) and
+   `## Stats` (the per-step receipts) itself, so do **not** hand-write either; a report
+   that spells them out collides with the CLI's own tail. This is the "yeah, I did that"
+   artifact. Write it by default; the human may edit it.
 2. **Finish.** Run `plumbbob finish`, which appends the checkpoint SHAs to the
    report and makes the final commit (subject `chore(<scope>): finish`, its body
    led by a `plumbbob finish` marker plus an optional proportional `--body`), then
@@ -51,7 +55,14 @@ record.
    always reads stdin. Under an agent harness that stdin is a socket, and `--body` now
    refuses rather than blocking on one; the refusal names this exact heredoc form. Omit
    `--body` entirely and the commit carries the `plumbbob finish` marker subject only.
-3. **Point at the next goal**: `/plumbbob:plan` to frame the next one.
+3. **Point at the next goal.** Relay `plumbbob finish`'s output verbatim, blank lines
+   included: its lead line, which names the branch the tracked folder now rides into the
+   PR, any advisory beneath it, and `**Next Up**: Nothing planned - /plumbbob:plan`. That
+   is the orientation tier's close (the
+   [turn anatomy](https://github.com/robmclarty/plumbbob/blob/main/docs/presentation.md)):
+   the lead line, then the forward pointer. `finish` renders that pointer itself rather
+   than leaving it to `plumbbob handoff`, because finish has just cleared the session
+   handoff would read one from. Relay the block and write nothing after it.
 
 ## The hard contracts
 

package/skills/park/SKILL.md

@@ -27,12 +27,26 @@ is fine; capture is always available, which is the whole point of parking.
 Take the idea, problem, or "ooh what if" the human just had and **compose it into one
 tidy, tagged line**: short, legible, self-contained, and carrying a **one-clause why**
 (what it is *and* why it's worth revisiting), so it still reads cleanly weeks later when
-harvest triages it cold. Then:
+harvest triages it cold. **The tag rides the tail, in brackets**, so the line spends its
+one colon on the `parked:` prefix and reads the same in the chat as in the ledger:
+
+```text
+should /password-reset get the same throttle? (tangent)
+```
+
+Then:
 
 1. **Show the composed line to the human** and wait for **in-turn approval**: they
    confirm it as-is or edit the wording.
 2. **Only after** that approval, capture it by running `plumbbob park "<the
    approved line>"` via Bash.
+3. **Relay the block, then get back to the step.** `plumbbob park` prints its whole
+   ending: `**Parked**: <text> (tag)`, a blank line, and the pointer back at the step in
+   flight (`**Next Up**: Back to Step N`). Relay that output verbatim and run no second
+   command. Park is a driver turn (the [turn anatomy](https://github.com/robmclarty/plumbbob/blob/main/docs/presentation.md)):
+   the capture plus that one pointer are the whole turn, and both are the CLI's to render,
+   never yours to compose from the dashboard. The capture is a one-beat interruption; the
+   step keeps its focus.
 
 ## The one hard contract
 

package/skills/plan/SKILL.md

@@ -3,7 +3,7 @@ name: plan
 description: "Frame a fresh goal and author the whole plan (Frame, Decisions, Constraints, and all Steps) before any code. Three input modes: no arg interviews you; a file path (or @-mention) absorbs a spec; any other text expands your inline intent."
 argument-hint: "[spec-path | intent]"
 disable-model-invocation: true
-allowed-tools: Read, Edit, Write, Bash(plumbbob status:*), Bash(plumbbob start:*), Bash(plumbbob checkpoint:*), Bash(plumbbob agent list:*)
+allowed-tools: Read, Edit, Write, Bash(plumbbob status:*), Bash(plumbbob handoff:*), Bash(plumbbob start:*), Bash(plumbbob checkpoint:*), Bash(plumbbob agent list:*)
 ---
 
 # PlumbBob: plan a goal (the whole-goal move)
@@ -144,6 +144,14 @@ an agent can follow with `/plumbbob:build`. The argument only seeds how you get
    baseline → plan → steps. Pass a proportional `--body` (the single-quoted stdin
    heredoc) when the rationale is worth carrying; skip it for a small plan. Do this
    only on the human's approval; the plan is their convergence.
+   - **The plan pause is a decision turn.** Present the framed plan for the human's call,
+     then relay `plumbbob handoff --plan`'s plan-pause card: the CLI renders the your-call
+     block with the two moves that apply before anything is recorded (the decision tier of
+     the [turn anatomy](https://github.com/robmclarty/plumbbob/blob/main/docs/presentation.md)),
+     so the moves are relayed, never hand-composed. *looks good* marks the plan decided and
+     starts `/plumbbob:build` at the first undone step; *needs work* sends you back to sharpen
+     it, which is cheap now, before any code. The revert move vanishes there on its own:
+     nothing has landed to wind back.
    - **The plan commit is latched too.** Once the turn ledger exists, `checkpoint
      --plan` refuses to land in the same turn `start` stamped it: present the plan,
      **end the turn**, and the human's approving message is the tick that lets it
@@ -152,6 +160,11 @@ an agent can follow with `/plumbbob:build`. The argument only seeds how you get
      session runs `start` *before* the turn hook has ever ticked, so that single
      commit predates the ledger and stays guidance-governed; it lands without a
      refusal.)
+   - **The plan commit prints its own close.** `plumbbob checkpoint --plan` emits the
+     whole boundary ending: `**Plan**: committed (<sha>)`, any advisory, and the pointer at
+     the step the build starts on. Relay that block whole and run no second command; the
+     plan-pause card above is the one place `handoff` is still called, because no verb has
+     run yet there.
    - **Say what the commit publishes.** The close-out line names the tracked folder:
      `.plumbbob/builds/<slug>/` now rides this branch into the PR, so teammates will
      see the plan and build record in review. In the same breath, offer the way out:

package/skills/recover/SKILL.md

@@ -4,14 +4,14 @@ description: "Human-triggered driver for `plumbbob recover`; reconcile the contr
 argument-hint: "[--fix]"
 disable-model-invocation: true
 model: haiku
-allowed-tools: Bash(plumbbob status:*), Bash(plumbbob recover:*)
+allowed-tools: Bash(plumbbob status:*), Bash(plumbbob recover:*), Bash(plumbbob handoff:*)
 ---
 
 # PlumbBob: reconcile the control plane (driver)
 
 Current session state (injected when this skill runs): !`plumbbob status 2>/dev/null || echo "plumbbob CLI not on PATH in this session. Marketplace install: confirm the plugin is enabled in /plugin, then /reload-plugins. Skills-dir/global install: npm i -g plumbbob && plumbbob init."`
 
-This is a **driver skill**: a chat-side trigger for the mechanical `plumbbob recover` verb, so the whole workflow runs from the agent window instead of a terminal. It is `disable-model-invocation: true`: only the human fires it. It carries **no Edit and no Write tool**; its only action is to shell the verb and report the verb's output verbatim, including any refusal. The CLI is the source of truth: never retry a refused transition, and never edit a file to work around one.
+This is a **driver skill**: a chat-side trigger for the mechanical `plumbbob recover` verb, so the whole workflow runs from the agent window instead of a terminal. It is `disable-model-invocation: true`: only the human fires it. It carries **no Edit and no Write tool**; it shells the verb, relays its output verbatim (including any refusal), and closes on `plumbbob handoff`'s next-up pointer for the turn. The CLI is the source of truth: never retry a refused transition, and never edit a file to work around one.
 
 Reach for it when the dashboard and reality disagree: `status` shows a build you thought you finished, or an empty plan for a build you know you wrote, or a step in flight you have no memory of starting. Those are the shapes a crashed session, a lost context window, or a mid-step build switch leaves behind. `/plumbbob:doctor` answers "is plumbbob installed correctly"; this answers "is this session's own state telling the truth".
 
@@ -20,6 +20,7 @@ Reach for it when the dashboard and reality disagree: `status` shows a build you
 1. Run `plumbbob recover` via Bash. It reads the control plane (the active-build cursor, the step and spike markers, the latch's stamp, the agent handoff ledger, and any leftover spike worktrees) and prints one line per check.
 2. Report that output verbatim, `✓` and `✗` lines alike. Every problem carries a `→` line naming the fix; relay those as written rather than paraphrasing them into your own advice.
 3. **Only if the human asks for the repair**, run `plumbbob recover --fix`. It clears stale untracked control files and re-points a cursor when exactly one build survives. It never touches intent.md, the build log, the checkpoints ledger, a report, or git history, and it never lands or advances a step.
+4. Close on `plumbbob handoff --driver`'s next-up line (the driver tier of the [turn anatomy](https://github.com/robmclarty/plumbbob/blob/main/docs/presentation.md)): a readout that just told the human their state was off ends on one pointer to reorient them, back at the open step when one survives and forward from the boundary otherwise.
 
 ## What it will not do for you
 

package/skills/revert/SKILL.md

@@ -11,10 +11,11 @@ allowed-tools: Bash(plumbbob status:*), Bash(plumbbob revert:*)
 
 Current session state (injected when this skill runs): !`plumbbob status 2>/dev/null || echo "plumbbob CLI not on PATH in this session. Marketplace install: confirm the plugin is enabled in /plugin, then /reload-plugins. Skills-dir/global install: npm i -g plumbbob && plumbbob init."`
 
-This is a **driver skill**: a chat-side trigger for the mechanical `plumbbob revert` verb, so the whole workflow runs from the agent window instead of a terminal. It is `disable-model-invocation: true`: only the human fires it. It carries **no Edit and no Write tool**; its only action is to shell the verb and report the verb's output verbatim, including any refusal. The CLI is the source of truth: never retry a refused transition, and never edit a file to work around one.
+This is a **driver skill**: a chat-side trigger for the mechanical `plumbbob revert` verb, so the whole workflow runs from the agent window instead of a terminal. It is `disable-model-invocation: true`: only the human fires it. It carries **no Edit and no Write tool**; it shells the verb and relays its output verbatim, refusal included. A successful transition prints its whole ending, pointer and all, so one command is the whole turn. The CLI is the source of truth: never retry a refused transition, and never edit a file to work around one.
 
 ## What it does
 
 1. Read an optional target step from the way you were invoked (for example `/plumbbob:revert --to 2` → step `2`). With no target, revert goes to the last done-checkpoint.
 2. Run `plumbbob revert` (or `plumbbob revert --to <n>`) via Bash. This is a `git reset --hard`; it discards the current in-progress step *and its work*. If the human wants to drop the step but keep the working-tree diff, that is `/plumbbob:abandon`, not revert. Run it exactly as the human asked; do not add or drop the `--to` on your own.
 3. Report the verb's output verbatim: which checkpoint it reset to, or any refusal.
+4. A successful revert prints its own ending (the driver tier of the [turn anatomy](https://github.com/robmclarty/plumbbob/blob/main/docs/presentation.md)): the lead line, a blank line, and the pointer forward from the boundary, since the in-flight step is wound back. Relay that block whole and run no second command. A refusal is not a transition; it carries no pointer, so relay it and stop.

package/skills/spike/SKILL.md

@@ -11,13 +11,14 @@ allowed-tools: Bash(plumbbob status:*), Bash(plumbbob spike:*)
 
 Current session state (injected when this skill runs): !`plumbbob status 2>/dev/null || echo "plumbbob CLI not on PATH in this session. Marketplace install: confirm the plugin is enabled in /plugin, then /reload-plugins. Skills-dir/global install: npm i -g plumbbob && plumbbob init."`
 
-This is a **driver skill**: a chat-side trigger for the mechanical `plumbbob spike` verb, so the whole workflow runs from the agent window instead of a terminal. It is `disable-model-invocation: true`: only the human fires it. It carries **no Edit and no Write tool**; its only action is to shell the verb and report the verb's output verbatim, including any refusal. The CLI is the source of truth: never retry a refused transition, and never edit a file to work around one.
+This is a **driver skill**: a chat-side trigger for the mechanical `plumbbob spike` verb, so the whole workflow runs from the agent window instead of a terminal. It is `disable-model-invocation: true`: only the human fires it. It carries **no Edit and no Write tool**; it shells the verb and relays its output verbatim, refusal included. A successful transition prints its whole ending, pointer and all, so one command is the whole turn. The CLI is the source of truth: never retry a refused transition, and never edit a file to work around one.
 
 ## What it does
 
 1. Read the spike target from the way you were invoked: a slug to open one (for example `/plumbbob:spike redis-cache`), `report <slug>` to scaffold a report without worktrees (`/plumbbob:spike report auth-store`), or the literal `done` to tear the current spike down (`/plumbbob:spike done`). If none is present, ask which and run nothing.
 2. Run `plumbbob spike "<slug>"`, `plumbbob spike report "<slug>"`, or `plumbbob spike done` via Bash.
-3. Report the verb's output verbatim: the worktree it created or removed, the spike report it scaffolded, or any refusal. When the verb names a `spike-NN-<slug>.md` report, point the human at it; when `spike done` nudges that a verdict is unrecorded, relay that nudge verbatim.
+3. Report the verb's output verbatim: the worktree it created or removed, the spike report it scaffolded, or any refusal. When the verb names a `spike-NN-<slug>.md` report, point the human at it; when `spike done` nudges that a verdict is unrecorded, that nudge is already inside the block, so relay it there rather than restating it.
+4. A successful transition prints its own ending (the driver tier of the [turn anatomy](https://github.com/robmclarty/plumbbob/blob/main/docs/presentation.md)): the lead line, any nudge, and the pointer, which names closing the spike while one is live and points forward from the boundary once `spike done` closes it. Relay that block whole and run no second command. A refusal is not a transition; it carries no pointer, so relay it and stop.
 
 ## The spike report ([D70 (spike-reports)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d70))
 

package/skills/status/SKILL.md

@@ -16,11 +16,19 @@ inferred next move. Report it verbatim and point the human at that next move. Th
 skill carries **no Edit and no Write tool**: the CLI is the source of truth, so
 **never retry**, and never edit a file to change what the orientation says.
 
+Status is an orientation turn (the
+[turn anatomy](https://github.com/robmclarty/plumbbob/blob/main/docs/presentation.md)):
+the dashboard is the whole output, relayed verbatim. Everything the human needs is
+already in those bytes: the step in flight, the next step's done-when, seam, and `model:`
+recommendation, the counts, and the one next move. You relay it; you do not re-compose or
+annotate it.
+
 ## What it does
 
-1. Surface the injected `status` output: the dashboard and its suggested next move.
-2. If the next step's detail carries a `model:` line, point it out: it is the
-   plan's recommendation of the smallest model that can carry that step, so the human
-   can switch (for example `/model sonnet`) before firing `/plumbbob:build`, or ignore it. Guidance,
-   never a gate.
+1. Surface the injected `status` output verbatim: the dashboard and its suggested next move.
+2. The dashboard already prints the next step's `model:` recommendation in its detail
+   rows when the plan set one: the smallest model that can carry that step, so the human
+   can switch (for example `/model sonnet`) before firing `/plumbbob:build`, or ignore it.
+   Guidance, never a gate. You relay that line; you do not re-state it on top of the
+   verbatim dashboard.
 3. If it reads `NO ACTIVE SESSION`, tell the human to `/plumbbob:plan` to frame a goal.

package/skills/verify/SKILL.md

@@ -2,7 +2,7 @@
 name: verify
 description: "The verify tick: run the check, self-review the diff against intent, validate the step's done-when, pause for your approval, then checkpoint. Executor-agnostic: it reads the diff, not who wrote it."
 disable-model-invocation: true
-allowed-tools: Read, Bash(plumbbob status:*), Bash(plumbbob handoff:*), Bash(plumbbob check:*), Bash(plumbbob checkpoint:*), Bash(plumbbob agent:*), Bash(git diff:*), Bash(git status:*)
+allowed-tools: Read, Write, Bash(plumbbob status:*), Bash(plumbbob handoff:*), Bash(plumbbob check:*), Bash(plumbbob checkpoint:*), Bash(plumbbob agent:*), Bash(git diff:*), Bash(git status:*)
 ---
 
 # PlumbBob: verify a step (the tick)
@@ -40,20 +40,109 @@ this skill verifies it the same way: **it reads the diff, not the author**
    - the **Decisions**: does anything contradict a settled call?
    - the **Constraints**: are any violated?
    - any **`after`-agent findings** from step 2: advisory, weigh them, don't defer to them.
-   Surface every mismatch plainly, and when you cite a Decision or Constraint, carry its
-   slug from `intent.md` (`C1 (no-new-deps)`, never a bare `C1`) so each finding reads
-   on its own. You are reviewing, not building; do not fix anything.
-4. **Validate.** State, yes or no, whether the step's done-when is met, with the evidence.
-5. **PAUSE.** Present the check result, the self-review (with any `after`-agent
-   findings), and the validation, then
-   **stop and wait for the human's explicit approval.** This is the convergence beat;
-   the human is the clock. Never checkpoint without it.
+   A mismatch surfaces in exactly two places: as the failing word in its recap row, and
+   as one highlight with its full story in a detail section, never as a freeform
+   paragraph. When you cite a Decision or Constraint, carry its slug from `intent.md`
+   (`C1 (no-new-deps)`, never a bare `C1`) so each finding reads on its own. You are
+   reviewing, not building; do not fix anything.
+4. **Validate.** Decide, yes or no, whether the step's done-when is met. That verdict and
+   its evidence become the recap's `done-when` row, stated there and nowhere else.
+5. **PAUSE.** Write the file, run handoff, paste, then **stop and wait for the human's
+   explicit approval**. This is the convergence beat; the human is the clock. Never
+   checkpoint without it. A verify pause is a decision turn, and the
+   [turn anatomy](https://github.com/robmclarty/plumbbob/blob/main/docs/presentation.md)
+   fixes it as one block. You author none of it in the chat. Your judgment goes into
+   `.plumbbob/detail.md`; `plumbbob handoff` renders the whole turn from that file and its
+   own measurements; you paste its output and write nothing before or after it. The rule
+   is positional on purpose: with the relay as the turn's whole text, no line is left for
+   "here is the pause", for reading the check verdict back in prose, or for a closing
+   courtesy. Each fact appears once, in its part.
+
+   *Write the detail file.* Before you call `plumbbob handoff`, overwrite
+   `.plumbbob/detail.md`. It is the wire handoff parses, and it is the only path by which
+   the judgment you formed in steps 2 through 4 reaches the turn:
+
+   ```markdown
+   # Detail · Step <N> · <the step title>
+
+   ── recap · step <N> of <M> ──
+   done-when    met
+   decisions    honored: D1 (some-slug), D2 (another-slug)
+   constraints  all honored
+
+   ## Summary
+
+   <what the diff does, not the activity: one sentence when one will do, a
+   short paragraph when the step needs explaining>
+
+   ## 1 <the first highlight: one sentence, one move>
+   <the full story: what moved, why, what was tried and dropped>
+
+   ## 2 ...
+
+   ## Recommendation
+
+   <The move.> <The reason, one or two sentences.>
+   ```
+
+   The three rows under the header rule are yours, and only those three; `check`, `seam`,
+   `diff`, and `spent` are measured by the CLI, and a row you wrote for them would be
+   overwritten. Keep the rows contiguous (the first blank line ends them). Each opens with
+   a verdict word from the closed set in the turn anatomy (`met`, `not met`, `drift`;
+   `honored`, `none exercised`, `bent`, `drift`; `all honored`, `bent`, `drift`); a cited
+   decision or constraint carries its slug (`C1 (no-new-deps)`, never a bare `C1`); a row
+   that cannot apply vanishes. A green row collapses to its word or its count and a red one
+   names the one offender in a short clause, which is what keeps the whole row inside the
+   fence's 80 columns (13 of label, 67 of value); two or more items break onto indented
+   continuation lines opening with `-`, and a red row's evidence onto an indented `→` line.
+
+   The `## Summary` lead and the `## <n>` section titles are the turn's opening block:
+   handoff prints the lead behind the `**Summary**:` label, appends the `(details: …)`
+   bracket, and renders the titles as the numbered highlights, so you type neither the path
+   nor the list. Five highlights at most, each one move in plain English, drawn from the
+   self-review. The numbers are handles: "expand 2" opens `## 2`, so every highlight has a
+   section behind it. A judgment or a flag (a stray the seam row will name, a decision the
+   diff bent, a doubt about the done-when) is one of those highlights, never a paragraph of
+   its own. The recommendation is the last section: the move you would take as its own
+   sentence, closed by a period, then the reason as a capitalized sentence or two. The lead
+   and the recommendation are flowing prose and handoff unwraps both to the renderer's
+   width, so never hard-wrap them; handoff also prepends the bold `**Recommendation**:`
+   label, which you never type. This is the **one** file `/plumbbob:verify` writes, and it
+   is turn presentation, never the diff under review; the author-blind contract below still
+   holds. `checkpoint` folds this file into the commit body and then truncates it (the
+   detail plane in the
+   [turn anatomy](https://github.com/robmclarty/plumbbob/blob/main/docs/presentation.md)).
+
+   *Paste the turn.* Run `plumbbob handoff` and paste its output whole, verbatim, at top
+   level, trailing blank line included, then end the turn. Never nest it inside a fence of
+   your own; it carries fences of its own and they cannot nest. It prints the Summary and
+   its highlights, the Readout fence (its measured `check`, `seam`, `diff`, and `spent`
+   rows folded with your three), a `diff` fence when the change is 20 lines or fewer, the
+   Verdict folded worst-of from the same rows, Next Up, Your Call, and your recommendation
+   last. At the pause the check row reads green, since a red one stopped you back at step
+   1. The gate verdict's one home is that row: no standalone verdict line exists, and you
+   never restate the verdict in prose. A narrowed run names the slots it skipped there
+   (`· without test`), and that named narrowing is the whole disclosure. The notice
+   checkride's Stop hook appends after your turn is not yours to relay or repeat; the
+   trailing blank line you kept is what lands it on its own line. Relayed CLI strings keep
+   their em-dashes; your own lines never use one, the write-versus-relay line of
+   [D78 (em-dash-ban)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d78).
+
+   *Then read the reply as an ask or a direction.* A message that **asks** ("expand 2",
+   "what does that mean?", "why did the seam row flag that?") is an expand: answer it from the detail file, from
+   `git diff`, or from `git show`, never from recall, then run `plumbbob handoff` again and
+   paste it. The step is still in flight, so it renders the same pause, and the Your Call
+   block stays the CLI's to render rather than yours to retype. A message that **directs**
+   is needs-work: take it as what to change, and nothing lands until the human says
+   `looks good`.
+
    - **Reconcile a drifted subject here, in the open.** The planned title *is* the
      checkpoint subject ([D68 (conventional-subjects)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d68)). If the diff drifted from it (the
      step landed something the title no longer describes), the body pass may propose a
-     corrected subject, but it **presents** it at this pause for explicit approval: show
-     `planned title → proposed subject`, one line, as part of what the human OKs. This is
-     the exception, not the default: with **nothing presented**, the deterministic
+     corrected subject, but it **presents** it at this pause for explicit approval: one
+     highlight reading `planned title → proposed subject`, part of what the human OKs.
+     That highlight is a `## <n>` section title in the detail file like any other.
+     This is the exception, not the default: with **nothing presented**, the deterministic
      title-derived subject lands untouched. A silent `-m` swap is exactly the
      agent-authored subject [D68 (conventional-subjects)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d68) refuses, so a reconcile is
      *only ever* the visible, approved kind.
@@ -67,7 +156,7 @@ this skill verifies it the same way: **it reads the diff, not the author**
 
    ```bash
    plumbbob checkpoint <n> --body <<'BODY'
-   <your proportional body — what changed and why, no ceremony>
+   <your proportional body: what changed and why, no ceremony>
    BODY
    ```
 
@@ -84,22 +173,26 @@ this skill verifies it the same way: **it reads the diff, not the author**
    overriding the title-derived default for this one commit; unpresented, the CLI's
    deterministic subject stands.
 7. **Hand off with the next model** *(once the checkpoint lands)*. `plumbbob checkpoint`
-   returns to DESIGN; then run `plumbbob handoff` and relay its boundary block. With the
-   step gone from in-flight it renders `step N checkpointed — back at the boundary` and
-   points at the **next undone step**, carrying that step's `- model:` recommendation (the
-   plan's smallest-model-that-fits call) so the human knows which `/model` to select before
-   running `/plumbbob:build` again. This matters most across a context boundary: a fresh window
-   inherits the *session's* model, not the plan's suggestion, so this line is what carries
-   the recommendation over. The CLI owns the block, so it can't drift from what `plumbbob
-   status` reports; no `- model:` line means any model will do. Guidance, never a gate.
+   returns to DESIGN and prints the whole boundary ending itself: `**Checkpoint**: Step N
+   complete (<sha>)`, the Verdict the step earned, any advisory (a staged path outside the
+   seam is the common one), and Next Up. Relay that block whole, run no second command,
+   and write nothing around it. It is the orientation tier (no Your Call block, no
+   recommendation), and it points at the **next undone step**, carrying that step's
+   `- model:` recommendation (the plan's smallest-model-that-fits call) so the human knows
+   which `/model` to select before running `/plumbbob:build` again. This matters most across a
+   context boundary: a fresh window inherits the *session's* model, not the plan's
+   suggestion, so this line is what carries the recommendation over. The CLI owns the
+   block, so it can't drift from what `plumbbob status` reports; no `- model:` line means
+   any model will do. Guidance, never a gate.
 
 ## The latch makes the pause real
 
 When this session runs under plumbbob's turn hook, `plumbbob checkpoint` **refuses to
 land a step in the same turn it was entered**, and that refusal **is** this pause, not
 an error to route around. If the checkpoint prints `checkpoint refused — no human turn
-since this step began`, you have reached the pause the hard way: present the diff and
-the self-review, **end the turn**, and the human's next message is the tick that lets
+since this step began`, you have reached the pause the hard way: write the file, run
+`plumbbob handoff`, paste its block as step 5 says, **end the turn there**, and the
+human's next message is the tick that lets
 the checkpoint land when you run it again. **Never reach for a raw `git commit` to force the
 land**; that forges the very record the latch exists to keep honest, and the
 commit-ask hook asks the human about it anyway. The refusal is a healthy latch doing its
@@ -118,15 +211,18 @@ instead.**
 - **Red means stop, not pause.** A failing check is not an approval decision; report
   it and end your turn.
 - **You review; you do not build.** If the self-review finds a problem, surface it
-  and stop; fixing is a new build beat, not part of verify.
+  and stop; fixing is a new build beat, not part of verify. The one file the tick writes
+  is `.plumbbob/detail.md`, the turn's presentation; it never edits the diff under review.
 - **`after`-agents advise; they never gate**. Their output feeds the
   self-review; checkride gates, the human approves. `blocked` → unblock and re-run;
   `drift` → `/plumbbob:refine` before checkpointing. No code path makes them blocking.
 - **A refused checkpoint is the pause, never a workaround.** Under the turn
-  hook a same-turn checkpoint is refused *by design*: present the diff, **end the
-  turn**, and let the human's next message re-tick it. Never route around it with a raw
-  `git commit`; the latch guards the record, not the work.
-- **Close with the next model.** After the checkpoint lands, run `plumbbob handoff` and
-  relay its block; it cites the completed step and the next undone step, and surfaces that
-  next step's `- model:` recommendation when it has one, which is what a fresh context
-  window needs to pick the right `/model`. Guidance, never a gate.
+  hook a same-turn checkpoint is refused *by design*: write the file, run `plumbbob
+  handoff`, paste its block, **end the turn there**, and let the human's next message
+  re-tick it. Never route around it with a
+  raw `git commit`; the latch guards the record, not the work.
+- **Close with the next model.** When the checkpoint lands it prints the whole boundary
+  ending; relay it with nothing written around it and no second command. It cites the
+  completed step and the next undone step, and surfaces that next step's `- model:`
+  recommendation when it has one, which is what a fresh context window needs to pick the
+  right `/model`. Guidance, never a gate.