plumbbob 0.6.3 → 0.6.5

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "plumbbob",
   "displayName": "PlumbBob",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "Attention-first build process — driver skills + a CLI that keep you the decider; guidance, not enforcement.",
   "author": { "name": "Rob McLarty", "email": "hello@robmclarty.com", "url": "https://robmclarty.com" },
   "homepage": "https://github.com/robmclarty/plumbbob#readme",

package/README.md

@@ -121,7 +121,7 @@ nothing else:
 | Skill <img alt="" width="110" height="1"> | Does |
 |------------------------------------|------|
 | `/pb-plan` | plan the whole goal — open the session and author intent's Frame, Decisions, Constraints, **and all Steps** |
-| `/pb-build` | implement the next planned step, then verify it to the pause — `--auto` self-approves and chains to done |
+| `/pb-build` | implement the next planned step, then verify it to the pause — `--auto` self-approves and chains to done; a range like `1-3` self-approves through step 3, then pauses |
 | `/pb-finish` | finish up — write the report, make the final commit, clear for a fresh goal |
 
 **Plan-shaping moves** — optional, for when the plan needs work mid-flight:

package/dist/lib/buildlog.js

@@ -27,7 +27,7 @@ export function appendToSection(content, heading, line) {
 }
 // The Log line `checkpoint` writes for a landed step: dated, names the step (its
 // title when intent.md still carries it), and carries the short SHA. One line of the
-// build's history — `/plumbbob:pb-finish` reads these instead of re-narrating the build.
+// build's history — `/pb-finish` reads these instead of re-narrating the build.
 export function checkpointLogLine(date, step, sha, title) {
     const head = `- ${date} — step ${step} checkpointed · ${sha.slice(0, 9)}`;
     return title !== null && title.length > 0 ? `${head} — ${title}` : head;

package/dist/lib/orient.js

@@ -77,7 +77,7 @@ export function parseOpenQuestions(intent) {
         .length;
 }
 // Open parked items: `- [ ]` lines under `## Park list` (the `park` verb's format).
-// A harvested item is flipped to `- [x]` by `/plumbbob:pb-harvest` and no longer counts; the
+// A harvested item is flipped to `- [x]` by `/pb-harvest` and no longer counts; the
 // `(none yet)` placeholder and the blockquote instructions never match.
 export function parseParked(buildLog) {
     return sectionLines(buildLog, '## Park list').filter((l) => /^-\s+\[ \]\s+\S/.test(l.trim())).length;
@@ -101,22 +101,22 @@ function nextMove(spiking, steps, inFlight, parked) {
         return 'close the spike — `plumbbob spike done`';
     }
     if (inFlight !== null) {
-        return `finish step ${inFlight} — \`/plumbbob:pb-verify\` (or keep editing, then \`/plumbbob:pb-verify\`)`;
+        return `finish step ${inFlight} — \`/pb-verify\` (or keep editing, then \`/pb-verify\`)`;
     }
     // At the boundary (DESIGN): the move follows from the steps.
     const nextUndone = steps.find((s) => !s.done);
     if (nextUndone === undefined) {
         if (steps.length === 0) {
-            return 'plan the first step — `/plumbbob:pb-step`';
+            return 'plan the first step — `/pb-step`';
         }
         // Batch-default: the steps were planned up front, so finishing them usually
-        // means "finish up" — but `/plumbbob:pb-step` can still add an increment if reality grew.
-        const harvest = parked > 0 ? `harvest ${parked} parked idea${parked === 1 ? '' : 's'} — \`/plumbbob:pb-harvest\`; then ` : '';
-        return `${harvest}finish up — \`/plumbbob:pb-finish\` (or \`/plumbbob:pb-step\` to add another increment)`;
+        // means "finish up" — but `/pb-step` can still add an increment if reality grew.
+        const harvest = parked > 0 ? `harvest ${parked} parked idea${parked === 1 ? '' : 's'} — \`/pb-harvest\`; then ` : '';
+        return `${harvest}finish up — \`/pb-finish\` (or \`/pb-step\` to add another increment)`;
     }
     return nextUndone.planned
-        ? `build step ${nextUndone.n} — \`/plumbbob:pb-build\` (or \`/plumbbob:pb-step\` to revise it first)`
-        : `plan step ${nextUndone.n} — \`/plumbbob:pb-step\``;
+        ? `build step ${nextUndone.n} — \`/pb-build\` (or \`/pb-step\` to revise it first)`
+        : `plan step ${nextUndone.n} — \`/pb-step\``;
 }
 export function orient(input) {
     const steps = parseSteps(input.intent);
@@ -146,7 +146,7 @@ export function formatOrientation(o) {
         if (s !== nextUndone) {
             return head;
         }
-        // Surface the next step's detail so the human can review it (and `/plumbbob:pb-step`-
+        // Surface the next step's detail so the human can review it (and `/pb-step`-
         // revise) before building. Only what's present — a rough step shows neither.
         const detail = [];
         if (o.nextDoneWhen !== null) {

package/dist/verbs/build.js

@@ -13,6 +13,13 @@ export function build(cwd, args) {
     }
     const { build: slug, rest } = resolveBuild(root, args);
     const raw = rest.find((a) => !a.startsWith('--'));
+    // A step range like `1-3` is a `/pb-build` skill affordance (auto-approve
+    // through the range, then pause), not a CLI capability — the CLI records one
+    // in-flight step at a time. Name it rather than bounce off the generic usage.
+    if (raw !== undefined && /^\d+-\d*$/.test(raw)) {
+        process.stderr.write(`plumbbob: build takes one step number; \`${raw}\` step ranges are a \`/pb-build\` feature (auto-approve through the range, then pause). Try \`plumbbob build ${raw.split('-')[0]}\`.\n`);
+        return 1;
+    }
     if (raw === undefined || !/^\d+$/.test(raw) || Number(raw) < 1) {
         process.stderr.write('plumbbob: build needs a step number. Try: plumbbob build 2.\n');
         return 1;

package/dist/verbs/check.js

@@ -1,5 +1,5 @@
 // `plumbbob check` — run the heavy gate (D16/D24/D32) and report, with NO state
-// change. The read-only half of the verify tick: `/plumbbob:pb-verify` runs this before the
+// change. The read-only half of the verify tick: `/pb-verify` runs this before the
 // pause so the human approves on a known-green check. Exits with the check's own
 // code (0 = green, 1 = red, 2 = the gate itself broke).
 //

package/dist/verbs/checkpoint.js

@@ -5,7 +5,7 @@
 // is already clean — the human's commit skill may have committed first), records the
 // SHA, flips the intent checkbox to `[x]`, and clears any STEP/SEAM (which returns
 // the dashboard to the DESIGN boundary). The diff's author is irrelevant:
-// `/plumbbob:pb-build`, your hands, a vibe session, or another harness all checkpoint
+// `/pb-build`, your hands, a vibe session, or another harness all checkpoint
 // the same way.
 import { appendFileSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { commit, findRepoRoot, headSha, isDirty, stageAll, stagePath, stagedPaths, stagedStat } from "../lib/git.js";
@@ -108,7 +108,7 @@ function warnScopeDrift(root, step) {
     const outside = scopeDrift(stagedPaths(root), seam);
     if (outside.length > 0) {
         process.stderr.write(`plumbbob: heads-up — staged paths outside step ${step}'s seam: ${outside.join(', ')}. ` +
-            `The checkpoint captures them; if that's real scope drift, the plan may need a \`/plumbbob:pb-step\` revision.\n`);
+            `The checkpoint captures them; if that's real scope drift, the plan may need a \`/pb-step\` revision.\n`);
     }
 }
 // The seam tokens for the in-flight step: the normalized SEAM file `build` wrote

package/dist/verbs/doctor.js

@@ -5,7 +5,7 @@
 //    Code loads it in place as a plugin (skills `/plumbbob:*`, the post-edit hook from
 //    hooks.json). doctor verifies the link resolves to a package carrying the manifest,
 //    the skills, and the hook — and names the fix for anything missing. The failure
-//    class it exists for is SILENT (a `/plumbbob:pb-status` that opens an empty dashboard
+//    class it exists for is SILENT (a `/pb-status` that opens an empty dashboard
 //    because the plugin never linked).
 //
 // 2. The repo sidecar layout. A repo scaffolded by a pre-restructure plumbbob carries a
@@ -419,7 +419,7 @@ export async function doctor(cwd, args = []) {
     out.push(failed === 0
         ? 'plumbbob: all checks passed. If a skill still misbehaves, restart Claude Code (or /reload-plugins).'
         : `plumbbob: ${failed} problem(s) — apply the → fixes, then restart Claude Code.`);
-    out.push('plumbbob: skills shell a bare `plumbbob`. The marketplace plugin puts it on PATH only inside a Claude Code session (via bin/) — there is no terminal `plumbbob`; for one (or the skills-dir install) run `npm i -g plumbbob`. In-session you can also run this as `/plumbbob:pb-doctor`. Sessions are per-project via `plumbbob start`.');
+    out.push('plumbbob: skills shell a bare `plumbbob`. The marketplace plugin puts it on PATH only inside a Claude Code session (via bin/) — there is no terminal `plumbbob`; for one (or the skills-dir install) run `npm i -g plumbbob`. In-session you can also run this as `/pb-doctor`. Sessions are per-project via `plumbbob start`.');
     process.stdout.write(`${out.join('\n')}\n`);
     return failed === 0 ? 0 : 1;
 }

package/dist/verbs/finish.js

@@ -23,7 +23,7 @@ export function finish(cwd, args = []) {
     }
     else {
         process.stderr.write('plumbbob: note — no report.md found; finishing without one ' +
-            '(/plumbbob:pb-finish normally writes the report first). No gate (D9).\n');
+            '(/pb-finish normally writes the report first). No gate (D9).\n');
     }
     // The final commit (D34): stage the report just written plus the build folder's
     // tail (the last step's checkpoint line lands one commit late, D37) and commit it
@@ -49,7 +49,7 @@ export function finish(cwd, args = []) {
     rmSync(join(sidecarDir(root), 'STATE'), { force: true });
     const where = slug === null ? '.plumbbob/' : `.plumbbob/builds/${slug}/`;
     process.stdout.write(`plumbbob: finished — ${sha.slice(0, 9)}. ${where} rides your branch into the PR. ` +
-        'Run `/plumbbob:pb-plan` (or `plumbbob start "<title>"`) to frame the next goal.\n');
+        'Run `/pb-plan` (or `plumbbob start "<title>"`) to frame the next goal.\n');
     return 0;
 }
 // The CLI-owned final-commit subject (D34): `plumbbob: finish — <title>`, mirroring

package/dist/verbs/park.js

@@ -1,5 +1,5 @@
 // `plumbbob park "<text>"` — the dumb capture path: append one raw line under
-// the build-log's Park list. No model turn, no composition (that is /plumbbob:pb-park's job).
+// the build-log's Park list. No model turn, no composition (that is /pb-park's job).
 // Capture is not a transition, so it runs in any context (terminal or in-session).
 import { readFileSync, writeFileSync } from 'node:fs';
 import { findRepoRoot } from "../lib/git.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plumbbob",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "Attention-first build process: 12 skills + a CLI that keep you the decider — guidance, not enforcement.",
   "keywords": [
     "claude-code",

package/skills/pb-build/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: pb-build
-description: The default engine — read the next planned step from intent, implement it (its done-when, seam, Decisions, Constraints), then verify it through to the approval pause. Swappable — build by hand/vibed/another harness and run /pb-verify instead. `--auto` self-approves and chains to done.
-argument-hint: "[step-number] [--auto]"
+description: The default engine — read the next planned step from intent, implement it (its done-when, seam, Decisions, Constraints), then verify it through to the approval pause. Swappable — build by hand/vibed/another harness and run /pb-verify instead. `--auto` self-approves and chains to done; a step range like `1-3` self-approves through step 3, then pauses.
+argument-hint: "[step-number | step-range] [--auto]"
 disable-model-invocation: true
 model: opus
 allowed-tools: Read, Edit, Write, Bash(plumbbob status:*), Bash(plumbbob build:*), Bash(plumbbob check:*), Bash(plumbbob checkpoint:*), Bash(plumbbob agent:*), Bash(git diff:*)
@@ -23,9 +23,11 @@ at the pause for your approval. **Re-firing `/pb-build` is itself the clock tick
 
 ## What this skill does, in order
 
-1. **Pick the step.** Use the number you were invoked with (e.g. `/pb-build 4`), else
-   the next undone, planned step in `.plumbbob/intent.md`. If there is no planned step
-   to build, stop and tell the human to `/pb-step` first.
+1. **Pick the step.** Use the number you were invoked with (e.g. `/pb-build 4`) — or,
+   if you were given a range like `/pb-build 1-3`, start at the first number and treat
+   the second as the auto-approve ceiling (see the range note under `--auto`). With no
+   argument, take the next undone, planned step in `.plumbbob/intent.md`. If there is no
+   planned step to build, stop and tell the human to `/pb-step` first.
 2. **Enter the step.** Run `plumbbob build <n>` (records the in-flight STEP +
    SEAM so `/pb-status` shows the step in flight; the seam is awareness, not a
    lock).
@@ -92,11 +94,34 @@ and approves in the human's place**, and it **chains**:
 - **Stop and hand back to the human** the moment any of these is true: the check is red,
   the self-review finds a mismatch (surface exactly what, and do not checkpoint it), a
   bound agent returns `blocked` or `drift` (unblock-and-re-run, or `/pb-refine` — an
-  agent cannot advance the loop, C6), a new decision is needed, or no planned steps
-  remain.
+  agent cannot advance the loop, C6), a new decision is needed, no planned steps
+  remain, or the top of a requested range is reached.
 
-`--auto` is the only path that checkpoints without a human pause, and only because the
-human asked for it by name. The default — no flag — always ends at the pause.
+`--auto` and a step range are the only paths that checkpoint without a human pause, and
+only because the human asked for it by name; a range re-imposes the pause at its top.
+The default — no flag, no range — always ends at the pause.
+
+### A step range (`N-M`) is a bounded `--auto`
+
+`/pb-build 1-3` self-approves steps 1 through 3 exactly as `--auto` does, then **pauses
+after step 3** instead of chaining to done. The range *is* the opt-in — you do not also
+pass `--auto`. Run it as the `--auto` loop with one extra halt: **stop before building
+any next step whose plan number is past the top of the range.** It adds no machinery —
+just the one more entry already in the halt list above.
+
+- **`N-M` with N ≤ M** — build N…M, self-approving and checkpointing each, then pause at
+  M. `N-N` is just the single step `N` (which already ends at the pause).
+- **N > M** (e.g. `3-1`) — that is not a range you can walk; report it and stop rather
+  than guess the intent.
+- **M past the last planned step** (e.g. `1-9` with three steps) — build through the
+  last planned step and stop; that is the existing "no planned steps remain" halt, not
+  an error.
+- **A step inside the range won't build** (missing, or its seam won't parse) — `plumbbob
+  build <n>` fails exactly as it always does; surface it and stop, the same as a red
+  check. Do not skip past the gap.
+- **N is above the next undone step** — you are jumping over earlier planned work; note
+  that you are skipping the steps before N, then proceed (the same latitude as a
+  single-number jump like `/pb-build 4`).
 
 ## The hard contracts
 
@@ -105,8 +130,9 @@ human asked for it by name. The default — no flag — always ends at the pause
 - **Build the decided step, not a new one.** Implement what `intent.md` settled. A
   new idea mid-build is a `/pb-park`, not an edit.
 - **Default ends at the pause.** Implement → verify → wait for approval; never
-  checkpoint without it. Only an explicit `--auto` lets the agent approve in your place,
-  and it still halts on a red check or any mismatch.
+  checkpoint without it. Only an explicit `--auto` or a step range lets the agent approve
+  in your place, and it still halts on a red check or any mismatch — a range also stops
+  at its top.
 - **Agents feed the beat; they never advance it** (C6/D45). `before` loads context,
   `build` writes the diff, `after` is advisory — none can checkpoint, flip a step, or
   chain. `blocked` → unblock and re-run; `drift` → `/pb-refine`. You are still the one