plumbbob 0.3.0 → 0.4.2

package/skills/{pb-verify → verify}/SKILL.md

@@ -1,22 +1,22 @@
 ---
-name: pb-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.
+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
 model: opus
-allowed-tools: Read, Bash(__PLUMBBOB_BIN__ status:*), Bash(__PLUMBBOB_BIN__ check:*), Bash(__PLUMBBOB_BIN__ checkpoint:*), Bash(git diff:*), Bash(git status:*)
+allowed-tools: Read, Bash(plumbbob status:*), Bash(plumbbob check:*), Bash(plumbbob checkpoint:*), Bash(git diff:*), Bash(git status:*)
 ---
 
 # Plumbbob — verify a step (the tick)
 
-Current session state (injected when this skill runs): !`__PLUMBBOB_BIN__ status`
+Current session state (injected when this skill runs): !`plumbbob status 2>/dev/null || echo "plumbbob CLI not found - install the dep and re-run: npm i -g plumbbob && plumbbob init"`
 
 This is the **tick** — the one beat where the human is the clock. Whatever produced
-the current diff — `/pb-build`, your own hands, a vibe session, another harness —
+the current diff — `/plumbbob:build`, your own hands, a vibe session, another harness —
 this skill verifies it the same way: **it reads the diff, not the author** (D3).
 
 ## What this skill does, in order
 
-1. **Check.** Run `__PLUMBBOB_BIN__ check` (the heavy gate). If it comes back
+1. **Check.** Run `plumbbob check` (the heavy gate). If it comes back
    **red**, stop here: report what failed and do **not** pause for approval — there
    is nothing to approve yet. The human fixes it and re-invokes.
 2. **Self-review** *(a single structured read, D16)*. Read `git diff` and
@@ -31,7 +31,7 @@ this skill verifies it the same way: **it reads the diff, not the author** (D3).
    the human is the clock. Never checkpoint without it.
 5. **Checkpoint** *(only after approval)*. Commit the work — the human's
    commit-with-TIL skill for a rich message, or let `checkpoint` make the WIP commit
-   — then run `__PLUMBBOB_BIN__ checkpoint` to record the SHA, flip the step to done,
+   — then run `plumbbob checkpoint` to record the SHA, flip the step to done,
    and return to DESIGN. Do **not** bump the version or touch the changelog — that is
    the human's `/version` call.
 
@@ -40,7 +40,7 @@ this skill verifies it the same way: **it reads the diff, not the author** (D3).
 - **Never skip the pause.** Check → self-review → validate, then wait. Approval is
   the only thing that triggers the checkpoint.
 - **Read the diff, not the author** (D3). Verify identically whether the code was
-  built by `/pb-build`, by hand, vibed, or by another harness.
+  built by `/plumbbob:build`, by hand, vibed, or by another harness.
 - **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

package/skills/{pb-reset → wrap}/SKILL.md

@@ -1,16 +1,16 @@
 ---
-name: pb-reset
-description: Close out the build — write the report (what shipped, decisions, parked/harvested items, deferred tangents), then archive intent + build-log + report and clear for a fresh goal. Report by default, no gate.
+name: wrap
+description: Wrap up the build — write the report (what shipped, decisions, parked/harvested items, deferred tangents), then safely archive intent + build-log + report before clearing for a fresh goal. Archive-then-clear, never destroy. Report by default, no gate.
 disable-model-invocation: true
 model: opus
-allowed-tools: Read, Write, Bash(__PLUMBBOB_BIN__ status:*), Bash(__PLUMBBOB_BIN__ reset:*)
+allowed-tools: Read, Write, Bash(plumbbob status:*), Bash(plumbbob wrap:*)
 ---
 
-# Plumbbob — reset for a new goal (the close-out)
+# Plumbbob — wrap the build (the close-out)
 
-Current session state (injected when this skill runs): !`__PLUMBBOB_BIN__ status`
+Current session state (injected when this skill runs): !`plumbbob status 2>/dev/null || echo "plumbbob CLI not found - install the dep and re-run: npm i -g plumbbob && plumbbob init"`
 
-`/pb-reset` ends the build: it captures what happened, archives it, and clears the
+`/plumbbob:wrap` ends the build: it captures what happened, archives it, and clears the
 sidecar for the next goal. **Report by default** (D9) — no refuse-without-report gate,
 and no separate docs phase.
 
@@ -23,11 +23,11 @@ and no separate docs phase.
    - **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.
-2. **Archive & clear.** Run `__PLUMBBOB_BIN__ reset`, which appends the checkpoint SHAs
+2. **Archive & clear.** Run `plumbbob wrap`, which appends the checkpoint SHAs
    to the report, archives intent + build-log + report to
    `.plumbbob/archive/<date>-<slug>/`, and clears the sidecar (STATE last). Git is not
    touched.
-3. **Point at the next goal** — `/pb-plan` to frame the next one.
+3. **Point at the next goal** — `/plumbbob:plan` to frame the next one.
 
 ## The hard contracts
 

package/templates/build-log.md

@@ -4,8 +4,8 @@ step boundaries. The antidote to "my plan got lost in the noise."
 
   Steps     : where you are. One step in flight at a time.
   Park list : where ideas go so you do not chase them. CAPTURE, never act inline.
-  Triage    : the boundary ritual that keeps you on one branch.
-  Log       : the audit trail. Feeds /plumbbob-report, then gets archived.
+  Harvest   : the boundary ritual that keeps you on one branch.
+  Log       : the audit trail. Feeds the /plumbbob:wrap report, then gets archived.
 -->
 
 # Build log — {{TITLE}}
@@ -16,7 +16,8 @@ step boundaries. The antidote to "my plan got lost in the noise."
 ## Steps
 
 *(Mirror of intent.md's Steps, with live status. Only ONE step is in flight. A step
-is done only after `plumbbob done` — check green + checkpoint taken.)*
+is done only after a checkpoint — check green + checkpoint taken, via `/plumbbob:verify` or
+`/plumbbob:build`.)*
 
 - ☐ 1. <step>
 
@@ -24,31 +25,30 @@ is done only after `plumbbob done` — check green + checkpoint taken.)*
 
 > Mid-step, every new problem / idea / "ooh what if" lands HERE, untouched, and you
 > go straight back to the step. Acting the instant an idea arrives is the disease.
-> Capture is one line (`/park` composes it, or raw `plumbbob park`). Triage happens
-> only at the boundary.
+> Capture is one line (`/plumbbob:park` composes it). Harvest happens only at the boundary.
 
-## Triage  *(run at each step boundary, after green)*
+## Harvest  *(run `/plumbbob:harvest` at each step boundary, after green)*
 
 Classify each parked item as exactly ONE. Naming it before acting is what keeps you
 from sprawling across branches.
 
-| Class            | Meaning                                   | Action                        |
-|------------------|-------------------------------------------|-------------------------------|
-| **blocker**      | Plan was wrong/incomplete; can't proceed  | `revert`, fold into intent.md |
-| **tangent**      | A different path, not clearly better      | Defer or kill. Default here.  |
-| **pivot signal** | Evidence the whole approach is wrong      | Stop. Replan deliberately.    |
+| Class            | Meaning                                   | Action                          |
+|------------------|-------------------------------------------|---------------------------------|
+| **blocker**      | Plan was wrong/incomplete; can't proceed  | `/plumbbob:revert`, fold into intent  |
+| **tangent**      | A different path, not clearly better      | Defer or kill. Default here.    |
+| **pivot signal** | Evidence the whole approach is wrong      | Stop. Replan deliberately.      |
 
 > Reality check: almost everything that *feels* like a pivot is a tangent. Require a
 > failed assumption, not a shinier idea, before you pivot.
 
-Triage results this boundary:
+Harvest results this boundary:
 
 - (none yet)
 
 ## Log
 
 *(Append-only. One decision or event per line, dated. What you point at to say "I
-did that — the LLM helped, but those were my calls." `/plumbbob-report` reads this;
-`plumbbob finish` archives it under `.plumbbob/archive/`.)*
+did that — the LLM helped, but those were my calls." `/plumbbob:wrap` reads this for the
+report; `plumbbob wrap` archives it under `.plumbbob/archive/`.)*
 
 - <date> — <decision / event / what shipped this step>

package/templates/intent.md

@@ -33,25 +33,29 @@ open. If the implementor (you-later, or the LLM) has to guess, the doc failed.
 ## Decisions
 
 *(One line each. Settled, not re-litigated in the chat. Grows as you resolve the
-holes the interrogation surfaces, and as blockers fold in during BUILD.)*
+holes `/plumbbob:refine` surfaces, and as blockers fold in during BUILD.)*
 
 - D1: <decision> — *because* <the one reason that mattered>
 
 ## Constraints
 
-*(Hard rules the build must honor. Triage and review read against these.)*
+*(Hard rules the build must honor. `/plumbbob:verify` and `/plumbbob:refine` read against these.)*
 
 - C1: <e.g. functional/procedural only; no new dependencies>
 
 ## Steps
 
-*(The build plan. Each step carries its own seam — the paths `plumbbob build <n>`
-writes into `.plumbbob/SEAM` and the seam-guard enforces. Keep each step small
-enough to verify in one review pass. A blocker may rewrite a step's seam: fold the
-new decision, revise the seam here, then `build <n>` again.)*
+*(The build plan. `/plumbbob:plan` authors the **whole list up front** — each step a small,
+verifiable increment with its own **done-when** and **seam** (the paths it will touch,
+which `/plumbbob:build` records in `.plumbbob/SEAM` for orientation — awareness, not a lock
+in v2). Then drive `/plumbbob:build` until done. Later steps may be fuzzier than the first;
+sharpen the next one just-in-time with `/plumbbob:step` (empty input auto-syncs it), and use
+`/plumbbob:refine` to repair the whole plan when a blocker rewrites it.)*
 
 1. [ ] <step> — **done when:** <criterion, ideally a test or check result>
    - seam: `<file>`, `<file>`
+2. [ ] <step> — **done when:** <criterion>
+   - seam: `<file>`
 
 ## Open questions
 

package/dist/lib/settings.js

@@ -1,83 +0,0 @@
-// Claude Code settings.json hook registration (D27). A pure-TS JSON merge (zero
-// runtime deps, node builtins only — C2): strip our entries, then re-add them, so
-// a re-run is byte-identical. The same logic serves all three D27 scopes — only
-// the settings file path and the command-path representation differ, both chosen
-// by the `setup` verb. Functional/procedural, no classes (C1).
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname } from 'node:path';
-// A registration entry is "ours" iff one of its hook commands points into our
-// hooks dir. This marker matches every command form we emit: the global
-// `~/.claude/plumbbob/hooks/...` copy and the self-contained
-// `$CLAUDE_PROJECT_DIR/node_modules/plumbbob/hooks/...` reference both contain
-// `plumbbob/hooks/`, so uninstall finds either.
-const OURS_MARKER = 'plumbbob/hooks/';
-// The edit matcher covers all four editing tools (D5); v2 uses it for the
-// post-edit feedback hook (the only edit-time hook left).
-const EDIT_MATCHER = 'Edit|Write|MultiEdit|NotebookEdit';
-// The single hook Plumbbob v2 registers: the PostToolUse light feedback (D11/D25).
-// v1's PreToolUse muzzle + bash-guard are gone (D1/D13); the merge still STRIPS any
-// leftover PreToolUse entry from an older install, it just no longer adds one. Two
-// command forms:
-//   global       — a direct absolute path to the +x copy under ~/.claude.
-//   self (viaSh) — `sh "<dir>/<file>"` against the package's hooks/ under
-//                  node_modules, addressed through `$CLAUDE_PROJECT_DIR` so the
-//                  committed/portable form carries no machine-absolute path and
-//                  needs no execute bit (pnpm's store may not preserve one).
-function registrationEntries(hooksDir, viaSh) {
-    const dir = hooksDir.endsWith('/') ? hooksDir.slice(0, -1) : hooksDir;
-    const command = (file) => (viaSh ? `sh "${dir}/${file}"` : `${dir}/${file}`);
-    const entry = (matcher, file) => ({
-        matcher,
-        hooks: [{ type: 'command', command: command(file) }],
-    });
-    return { PostToolUse: [entry(EDIT_MATCHER, 'post-edit.sh')] };
-}
-function isOurs(entry) {
-    return (entry.hooks ?? []).some((h) => h.command.includes(OURS_MARKER));
-}
-function stripOurs(list) {
-    return (list ?? []).filter((e) => !isOurs(e));
-}
-// Merge our registration into a parsed settings object (strip-then-add). Returns
-// a new object; every unrelated key and unrelated hook is preserved, and key
-// order is stable across runs so a second merge is byte-identical.
-export function mergeRegistration(settings, hooksDir, viaSh = false) {
-    const entries = registrationEntries(hooksDir, viaSh);
-    const existing = settings.hooks ?? {};
-    const hooks = { ...existing };
-    // Strip any leftover v1 PreToolUse muzzle/bash-guard from an older install, but
-    // add back only the PostToolUse feedback hook — v2 registers no PreToolUse.
-    if (existing.PreToolUse !== undefined) {
-        hooks.PreToolUse = stripOurs(existing.PreToolUse);
-    }
-    hooks.PostToolUse = [...stripOurs(existing.PostToolUse), ...entries.PostToolUse];
-    return { ...settings, hooks };
-}
-// Remove only our entries from the two events we manage, leaving everything else
-// untouched (uninstall, and the idempotent strip half of a re-install).
-export function stripRegistration(settings) {
-    const existing = settings.hooks;
-    if (existing === undefined) {
-        return settings;
-    }
-    const hooks = { ...existing };
-    if (existing.PreToolUse !== undefined) {
-        hooks.PreToolUse = stripOurs(existing.PreToolUse);
-    }
-    if (existing.PostToolUse !== undefined) {
-        hooks.PostToolUse = stripOurs(existing.PostToolUse);
-    }
-    return { ...settings, hooks };
-}
-export function readSettings(path) {
-    try {
-        return JSON.parse(readFileSync(path, 'utf8'));
-    }
-    catch {
-        return {};
-    }
-}
-export function writeSettings(path, settings) {
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, `${JSON.stringify(settings, null, 2)}\n`);
-}

package/dist/verbs/setup.js

@@ -1,141 +0,0 @@
-// `plumbbob setup` — the installer. Two install shapes:
-//
-//   self-contained (default when plumbbob is a project-local dep; --local /
-//     --project to force) — NOTHING is written under ~/.claude. The hooks are
-//     referenced in place at $CLAUDE_PROJECT_DIR/node_modules/plumbbob/hooks/,
-//     and the skills are copied into <repo>/.claude/skills/ with their bin
-//     invocation pointed at $CLAUDE_PROJECT_DIR/node_modules/.bin/plumbbob. The
-//     registration lands in:
-//       --local   (default) <repo>/.claude/settings.local.json  — personal, untracked
-//       --project           <repo>/.claude/settings.json         — committable, enrolls the team
-//     This is the "run it from the project root, no global install" shape.
-//
-//   global (--global, or the auto default when plumbbob is NOT a project-local
-//     dep) — the original behavior: copy the hooks to ~/.claude/plumbbob/hooks/
-//     and the skills to ~/.claude/skills/, register absolute command paths in
-//     ~/.claude/settings.json, and leave the skills calling a bare `plumbbob`.
-//
-// `--uninstall` strips the registration from whichever settings file the same
-// resolution selects; installed/copied files are left in place. The hooks are
-// session-gated, so any registration is safe in every repo (C7).
-import { chmodSync, cpSync, existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join, sep } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { findRepoRoot } from "../lib/git.js";
-import { mergeRegistration, readSettings, stripRegistration, writeSettings } from "../lib/settings.js";
-const HOOK_FILES = ['post-edit.sh'];
-// The placeholder every skill carries in place of its `plumbbob` invocation;
-// setup substitutes it with the form the chosen install shape resolves.
-const BIN_PLACEHOLDER = '__PLUMBBOB_BIN__';
-// Self-contained installs address everything through Claude Code's project-root
-// variable so committed/portable files carry no machine-absolute path.
-const SELF_HOOKS_DIR = '$CLAUDE_PROJECT_DIR/node_modules/plumbbob/hooks';
-const SELF_BIN = '$CLAUDE_PROJECT_DIR/node_modules/.bin/plumbbob';
-export function setup(cwd, args) {
-    const home = process.env.HOME ?? homedir();
-    const mode = resolveMode(cwd, home, args);
-    if (mode === null) {
-        process.stderr.write('plumbbob: a project-scoped install writes <repo>/.claude/, but this is not a git repository. ' +
-            'Run setup from inside the repo, or use --global to install under ~/.claude.\n');
-        return 1;
-    }
-    if (args.includes('--uninstall')) {
-        writeSettings(mode.settingsFile, stripRegistration(readSettings(mode.settingsFile)));
-        process.stdout.write(`plumbbob: removed the hook registration from ${mode.settingsFile}. The installed/copied hooks and skills were left in place.\n`);
-        return 0;
-    }
-    return mode.kind === 'global' ? installGlobal(home, mode.settingsFile) : installSelfContained(mode);
-}
-// The original shape: hooks + skills copied under ~/.claude, absolute command
-// paths, skills calling a bare `plumbbob` (which the global npm install puts on
-// PATH).
-function installGlobal(home, settingsFile) {
-    const hooksDir = join(home, '.claude', 'plumbbob', 'hooks');
-    const skillsDir = join(home, '.claude', 'skills');
-    cpSync(packageDir('hooks'), hooksDir, { recursive: true });
-    for (const file of HOOK_FILES) {
-        chmodSync(join(hooksDir, file), 0o755);
-    }
-    cpSync(packageDir('skills'), skillsDir, { recursive: true });
-    substituteSkillBins(skillsDir, 'plumbbob');
-    writeSettings(settingsFile, mergeRegistration(readSettings(settingsFile), hooksDir));
-    process.stdout.write(`plumbbob: installed hooks → ${hooksDir}, skills → ${skillsDir}.\n` +
-        `plumbbob: registered the hooks in ${settingsFile} (global scope).\n` +
-        'plumbbob: restart Claude Code (or reload settings) for the hooks to take effect.\n' +
-        "plumbbob: the skills call a bare `plumbbob`; the npm install puts it (and `pb`) on PATH. From a dev checkout add `alias plumbbob='node <repo>/src/cli.ts'`.\n");
-    return 0;
-}
-// The self-contained shape: nothing under ~/.claude. Hooks are referenced in
-// place inside node_modules; only the skills are copied into the repo (Claude
-// Code discovers skills under .claude/skills/, never from node_modules), with
-// their bin invocation rewritten to the project-local binary.
-function installSelfContained(mode) {
-    const skillsDir = join(mode.repoRoot, '.claude', 'skills');
-    cpSync(packageDir('skills'), skillsDir, { recursive: true });
-    substituteSkillBins(skillsDir, SELF_BIN);
-    writeSettings(mode.settingsFile, mergeRegistration(readSettings(mode.settingsFile), SELF_HOOKS_DIR, true));
-    const note = existsSync(join(mode.repoRoot, 'node_modules', 'plumbbob', 'hooks'))
-        ? ''
-        : 'plumbbob: note — node_modules/plumbbob/ is not present in this repo yet. Add plumbbob as a dependency (e.g. `pnpm add -D plumbbob`) so the registered hooks resolve.\n';
-    const scope = mode.settingsFile.endsWith('settings.local.json') ? 'local' : 'project';
-    process.stdout.write(`plumbbob: copied skills → ${skillsDir} (bin → ${SELF_BIN}). Nothing was written under ~/.claude.\n` +
-        `plumbbob: referenced the hooks at ${SELF_HOOKS_DIR} and registered them in ${mode.settingsFile} (${scope} scope).\n` +
-        note +
-        'plumbbob: restart Claude Code (or reload settings) for the hooks to take effect.\n' +
-        'plumbbob: drive the workflow from the chat with the `pb-*` driver skills. Keep the transition verbs OUT of your settings allowlist — each driver skill self-authorizes its own verb, so a stray model-initiated transition still surfaces a permission prompt.\n');
-    return 0;
-}
-// Resolve which install shape and settings file to use. Explicit flags win;
-// with no flag, auto-detect — a project-local plumbbob installs self-contained
-// (personal, into settings.local.json), anything else installs global. Returns
-// null when a project scope is required but cwd is not in a git repo.
-function resolveMode(cwd, home, args) {
-    const globalFile = join(home, '.claude', 'settings.json');
-    if (args.includes('--global')) {
-        return { kind: 'global', settingsFile: globalFile };
-    }
-    const wantsProject = args.includes('--project');
-    const wantsLocal = args.includes('--local');
-    const auto = !wantsProject && !wantsLocal && isProjectLocal(cwd);
-    if (!wantsProject && !wantsLocal && !auto) {
-        return { kind: 'global', settingsFile: globalFile };
-    }
-    const repoRoot = findRepoRoot(cwd);
-    if (repoRoot === null) {
-        return null;
-    }
-    const file = wantsProject ? 'settings.json' : 'settings.local.json';
-    return { kind: 'self', settingsFile: join(repoRoot, '.claude', file), repoRoot };
-}
-// plumbbob is project-local when its package directory lives inside this repo's
-// node_modules (a `pnpm add` / `npm install` dependency), as opposed to a global
-// install or a dev checkout.
-function isProjectLocal(cwd) {
-    const repoRoot = findRepoRoot(cwd);
-    if (repoRoot === null) {
-        return false;
-    }
-    return packageRoot().startsWith(join(repoRoot, 'node_modules') + sep);
-}
-// Rewrite the bin placeholder in every copied skill (both the `!`...`` status
-// pre-injection and the allowed-tools patterns) to the resolved invocation.
-function substituteSkillBins(skillsDir, bin) {
-    for (const name of readdirSync(skillsDir)) {
-        const file = join(skillsDir, name, 'SKILL.md');
-        if (!statSync(join(skillsDir, name)).isDirectory() || !existsSync(file)) {
-            continue;
-        }
-        const src = readFileSync(file, 'utf8');
-        if (src.includes(BIN_PLACEHOLDER)) {
-            writeFileSync(file, src.split(BIN_PLACEHOLDER).join(bin));
-        }
-    }
-}
-// The plumbbob package root (parent of hooks/ and skills/), off this module's URL.
-function packageRoot() {
-    return fileURLToPath(new URL('../../', import.meta.url));
-}
-function packageDir(name) {
-    return join(packageRoot(), name);
-}

package/skills/pb-build/SKILL.md

@@ -1,49 +0,0 @@
----
-name: pb-build
-description: The optional engine — read the current planned step from intent, implement it (its done-when, seam, Decisions, Constraints), then verify it through to the approval pause. Skip it entirely to implement by hand, vibed, or with another harness.
-disable-model-invocation: true
-model: opus
-allowed-tools: Read, Edit, Write, Bash(__PLUMBBOB_BIN__ status:*), Bash(__PLUMBBOB_BIN__ build:*), Bash(__PLUMBBOB_BIN__ check:*), Bash(__PLUMBBOB_BIN__ checkpoint:*), Bash(git diff:*)
----
-
-# Plumbbob — build a step (the optional engine)
-
-Current session state (injected when this skill runs): !`__PLUMBBOB_BIN__ status`
-
-This is the **bundled executor** — one way to turn a planned step into code. It is
-**optional** (D3): you can implement any step by hand, in a vibe session, or with
-another harness and go straight to `/pb-verify` instead — plumbbob does not care how
-the diff appeared. When you do run it, it reads the plan, writes the step, and
-carries straight through to the verify pause.
-
-## 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.
-2. **Enter the step.** Run `__PLUMBBOB_BIN__ build <n>` (records the in-flight STEP +
-   SEAM so `/pb-status` shows the step in flight; in v2 the seam is awareness, not a
-   lock).
-3. **Read the plan.** Read the step's **done-when**, its **seam**, and the
-   **Decisions** and **Constraints** in `intent.md`. Build to *that* — the deciding
-   already happened, off the chat.
-4. **Implement** the step, and only that step, staying within the declared seam. A
-   new problem or "ooh what if" that surfaces mid-build is a `/pb-park`, **not** an
-   edit — capture it and stay on the step. If you genuinely cannot finish without
-   touching more than the seam, that is scope drift: surface it to the human rather
-   than sprawling.
-5. **Verify, through to the pause.** Run the verify tick exactly as `/pb-verify`
-   does: `__PLUMBBOB_BIN__ check` → self-review the diff against the done-when, the
-   Decisions, and the Constraints (a single structured read, D16) → validate → **PAUSE
-   for the human's approval** → only on approval, checkpoint with
-   `__PLUMBBOB_BIN__ checkpoint`. Do **not** bump the version or changelog — that is
-   the human's `/version` call.
-
-## The hard contracts
-
-- **Optional, never required.** The loop works without this skill; `/pb-verify`
-  checkpoints a hand-built or vibed diff just the same (D3).
-- **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.
-- **Always end at the pause.** Implement → verify → wait for approval. Never
-  checkpoint without it; the human is the clock.

package/skills/pb-plan/SKILL.md

@@ -1,38 +0,0 @@
----
-name: pb-plan
-description: Frame a fresh goal — scaffold the session and author the intent's Frame, Decisions, and Constraints before any code. Steps stay empty; they come one at a time from /pb-step.
-disable-model-invocation: true
-model: opus
-allowed-tools: Read, Edit, Write, Bash(__PLUMBBOB_BIN__ status:*), Bash(__PLUMBBOB_BIN__ start:*)
----
-
-# Plumbbob — frame a goal (the whole-goal move)
-
-Current session state (injected when this skill runs): !`__PLUMBBOB_BIN__ status`
-
-`/pb-plan` is the **whole-goal** move — it opens a session and gets the deciding out
-of your head and onto `intent.md` *before* any code. (Planning a single increment is
-the separate `/pb-step` move; do not confuse the two.)
-
-## What this skill does
-
-1. **Scaffold.** If there is no active session, run `__PLUMBBOB_BIN__ start "<title>"`
-   to create `.plumbbob/` (STATE=DESIGN, baseline recorded). If a session already
-   exists, say so and edit the existing `intent.md` rather than starting over.
-2. **Frame** (`.plumbbob/intent.md`), with the human: the **Problem** in plain words,
-   the **smallest thing** that solves it, what **done looks like**, and what you are
-   **explicitly NOT doing**. This is the human's convergence — propose wording, but
-   the human decides every line.
-3. **Decisions & Constraints.** Record the settled calls (one line each, with the
-   *because*) and the hard rules the build must honor. An unresolved hole goes to
-   **Open questions**, never guessed into a Decision.
-4. **Leave `## Steps` empty.** Steps are planned just-in-time (D6) — one at a time
-   with `/pb-step` — so do not write the build plan here.
-
-## The hard contracts
-
-- **Deciding before code.** `/pb-plan` writes `intent.md` only — never source.
-- **The human converges.** You surface options and draft wording; the human picks.
-  An unresolved hole is an Open question, not a guessed Decision.
-- **Size to the work.** A small change fills Frame + a couple of Decisions and stops;
-  ceremony on a one-liner is the failure mode, not thoroughness.

package/skills/pb-step/SKILL.md

@@ -1,37 +0,0 @@
----
-name: pb-step
-description: Plan the next increment — propose one small step with a done-when criterion and a seam, get the human's OK, and append it to intent's ## Steps. One by default; several only if the human already knows them.
-disable-model-invocation: true
-model: opus
-allowed-tools: Read, Edit, Bash(__PLUMBBOB_BIN__ status:*)
----
-
-# Plumbbob — plan the next step (the single-increment move)
-
-Current session state (injected when this skill runs): !`__PLUMBBOB_BIN__ status`
-
-`/pb-step` plans the **next increment** just-in-time (D6) — the smallest verifiable
-piece of the framed goal, planned only when you reach it. (Framing the whole goal is
-the separate `/pb-plan` move.)
-
-## What this skill does
-
-1. **Read the plan.** Read `intent.md`'s Frame, Decisions, Constraints, and the steps
-   already done, to see what the *next* increment should be.
-2. **Propose one step.** Draft a single step:
-   - a one-line **title**,
-   - a **done-when** criterion — ideally a test or check result, something
-     `/pb-verify` can actually validate,
-   - a **seam**: the specific files it should touch (exact paths, or a `dir/` grant).
-   Keep it small enough to verify in one review pass.
-3. **Get the human's OK**, then **append** it to `## Steps` in the standard format —
-   `N. [ ] <title> — **done when:** <criterion>` with a `- seam:` sub-line. Default
-   to **one** step; plan several only when the human already knows them.
-
-## The hard contracts
-
-- **One verifiable increment.** Each step carries a done-when `/pb-verify` can check
-  and a seam small enough to review in one pass.
-- **Append to `## Steps` only**, in the standard format `status` and `build` parse —
-  never the Roadmap, never loose prose.
-- **The human approves the step** before it lands. You propose; they decide.

package/skills/plumbbob-interrogate/SKILL.md

@@ -1,33 +0,0 @@
----
-name: plumbbob-interrogate
-description: DESIGN-phase frame interrogation — attack the plan for holes and append them as Open questions, without deciding anything.
-disable-model-invocation: true
-model: opus
-allowed-tools: Read, Edit, Bash(__PLUMBBOB_BIN__ status:*)
----
-
-# Plumbbob — interrogate the frame
-
-Current session state (injected when this skill runs): !`__PLUMBBOB_BIN__ status`
-
-## Wrong-state refusal
-
-This skill runs in **DESIGN only**. Read the state injected above and **stop before touching anything** if it is not `DESIGN`:
-
-- `STATE: BUILD` or `STATE: REVIEW` — you are mid-step. Return to DESIGN first: finish the step with `plumbbob done`, or drop a half-built step with `plumbbob revert`. Then re-invoke.
-- `STATE: SPIKE` — close the experiment with `plumbbob spike done` first.
-- `STATE: FINISH` — the session is wrapping up; there is nothing left to interrogate.
-- `NO ACTIVE SESSION` — start one with `plumbbob start "<title>"`.
-
-When the state is wrong, refuse in one line naming the verb above, and edit nothing.
-
-## What this skill does
-
-Hand the frame (the **Frame** and **Architecture sketch** in `intent.md`) a cold, adversarial read and **attack it for holes** — ambiguities, unhandled edge cases, hidden assumptions, and collisions with the existing code. This is the one place early divergence is wanted, and it is divergence in the **problem space only**: surface what is unclear, never propose a solution and never pick between options.
-
-## The one hard contract
-
-- Append every hole as a bullet under `intent.md`'s `## Open questions` section, and **nowhere else**.
-- **Never append to `## Decisions`** — resolving a hole is the human's convergence, not yours (D13). You surface; you do not decide.
-- One question per hole, phrased as a question, each standing on its own.
-- Once the Open questions are appended, **end your turn**. Do not answer them, do not start the next step, do not slide from interrogating into deciding.