plumbbob 0.12.0 → 0.13.0

package/skills/verify/SKILL.md

@@ -76,6 +76,7 @@ this skill verifies it the same way: **it reads the diff, not the author**
    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 ...
@@ -113,28 +114,47 @@ this skill verifies it the same way: **it reads the diff, not the author**
    `## Log` 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
+   *Paste the turn.* Run `plumbbob handoff <n>`, naming the step you reviewed, and paste
+   its output whole, verbatim, at top level, trailing blank line included, then end the
+   turn. The number is what lets a diff built outside `/plumbbob:build` reach its pause:
+   nothing is in flight for that diff, and a bare `handoff` would read the moment as a
+   boundary and render no Your Call block. Never nest it inside a fence of
+   your own; it carries fences of its own and they cannot nest. It prints the Now line
+   naming the step you reviewed, 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. Run it once: a second run at an
+   unchanged pause prints the one-line reminder instead of the card, so if that line comes
+   back where the card belongs (you ran handoff earlier in this turn), run
+   `plumbbob handoff <n> --full` and paste that. 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 the build-log's `## Log` for an older step, 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`.
+   "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 the build-log's `## Log` for an older step,
+   never from recall, then run `plumbbob handoff <n>` and paste its output beneath your
+   answer, whole and verbatim. The turn is your answer, then that output, and nothing after
+   it. The pause renders its card once
+   ([D87 (pause-once)](https://github.com/robmclarty/plumbbob/blob/main/docs/decisions.md#d87)):
+   while nothing about it has changed, handoff prints one line,
+   `**Next Up**: Back to Step <N> of <M> - <title>`, in place of the card the human already
+   read, so your answer stays on screen. The CLI picks the form, never you: paste whichever
+   one it prints, and never retype the card or reach for `--full` to put it beneath an
+   answer.
+
+   Two moments bring the whole card back, and in both you run `plumbbob handoff <n> --full`
+   and paste its output whole, with nothing written around it: the human asks to see the
+   pause (`show the pause`, or any wording of it), or the card is not in this conversation
+   (a fresh session, or one after `/clear`, that finds the step still at its pause). 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
@@ -194,7 +214,7 @@ When this session runs under plumbbob's turn hook, `plumbbob checkpoint` **refus
 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: write the file, run
-`plumbbob handoff`, paste its block as step 5 says, **end the turn there**, and the
+`plumbbob handoff <n>`, 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
@@ -220,8 +240,8 @@ instead.**
   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*: write the file, run `plumbbob
-  handoff`, paste its block, **end the turn there**, and let the human's next message
+  hook a same-turn checkpoint is refused *by design*: write the file, run
+  `plumbbob handoff <n>`, 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

package/templates/intent.md

@@ -79,6 +79,15 @@ auto-syncs it), and use `/plumbbob:refine` to repair the whole plan when a block
 2. [ ] <step>, **done when:** <criterion>
    - seam: `<file>`
 
+## Build order
+
+*(Optional. The sequence to build the steps in once it stops being their numbering: one
+line of comma-separated step numbers, such as `7, 8, 5, 10, 6`; empty means document
+order. `plumbbob order 7 8 5 10 6` (`/plumbbob:order`) writes it, and `status`, `build`,
+`checkpoint`, and `handoff` all read it, so the dashboard's `← next`, a bare
+`/plumbbob:build`, and the card's Next Up agree. A step keeps its number for life; this
+line is where the sequence lives.)*
+
 ## Open questions
 
 *(Holes you could NOT resolve on paper: the one section that expands rather than