plumbbob 0.2.3 → 0.3.1

package/skills/pb-reset/SKILL.md

@@ -0,0 +1,39 @@
+---
+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.
+disable-model-invocation: true
+model: opus
+allowed-tools: Read, Write, Bash(__PLUMBBOB_BIN__ status:*), Bash(__PLUMBBOB_BIN__ reset:*)
+---
+
+# Plumbbob — reset for a new goal (the close-out)
+
+Current session state (injected when this skill runs): !`__PLUMBBOB_BIN__ status 2>/dev/null || echo "plumbbob CLI not found - install the dep and re-run: npx plumbbob setup"`
+
+`/pb-reset` 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.
+
+## What this skill does, in order
+
+1. **Write the report** to `.plumbbob/report.md`, from `intent.md` + `build-log.md`:
+   - **What shipped** — the steps completed and what they delivered.
+   - **Decisions and why** — the settled calls that shaped the build.
+   - **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.
+2. **Archive & clear.** Run `__PLUMBBOB_BIN__ reset`, 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.
+
+## The hard contracts
+
+- **Report by default, never a gate.** Always offer the report; never wall the exit. A
+  bug fix's report can be three lines — size it to the work.
+- **Archive-then-clear, never destroy** (C4). The archive is the record; the active
+  files only clear once they are safely copied.
+- **No version bump, no docs phase.** Updating real docs is a separate, explicit ask;
+  cutting a release is the human's `/version`.

package/skills/pb-revert/SKILL.md

@@ -8,7 +8,7 @@ allowed-tools: Bash(__PLUMBBOB_BIN__ status:*), Bash(__PLUMBBOB_BIN__ revert:*)
 
 # Plumbbob — revert to a checkpoint (driver)
 
-Current session state (injected when this skill runs): !`__PLUMBBOB_BIN__ status`
+Current session state (injected when this skill runs): !`__PLUMBBOB_BIN__ status 2>/dev/null || echo "plumbbob CLI not found - install the dep and re-run: npx plumbbob setup"`
 
 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.
 

package/skills/pb-spike/SKILL.md

@@ -8,7 +8,7 @@ allowed-tools: Bash(__PLUMBBOB_BIN__ status:*), Bash(__PLUMBBOB_BIN__ spike:*)
 
 # Plumbbob — spike an experiment (driver)
 
-Current session state (injected when this skill runs): !`__PLUMBBOB_BIN__ status`
+Current session state (injected when this skill runs): !`__PLUMBBOB_BIN__ status 2>/dev/null || echo "plumbbob CLI not found - install the dep and re-run: npx plumbbob setup"`
 
 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.
 

package/skills/pb-status/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: pb-status
+description: Show the orientation dashboard — where you are, what's done, what's parked, and the next move. A thin trigger for `plumbbob status`.
+disable-model-invocation: true
+model: haiku
+allowed-tools: Bash(__PLUMBBOB_BIN__ status:*)
+---
+
+# Plumbbob — orient (the where-am-I move)
+
+Current session state (injected when this skill runs): !`__PLUMBBOB_BIN__ status 2>/dev/null || echo "plumbbob CLI not found - install the dep and re-run: npx plumbbob setup"`
+
+This is a **thin driver** for `__PLUMBBOB_BIN__ status`. The dashboard above is your
+orientation — the intent, the step list, the parked/open-question counts, and the
+inferred next move. Report it verbatim and point the human at that next move. This
+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.
+
+## What it does
+
+1. Surface the injected `status` output — the dashboard and its suggested next move.
+2. If it reads `NO ACTIVE SESSION`, tell the human to `/pb-plan` to frame a goal.

package/skills/pb-step/SKILL.md

@@ -0,0 +1,37 @@
+---
+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 2>/dev/null || echo "plumbbob CLI not found - install the dep and re-run: npx plumbbob setup"`
+
+`/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/pb-verify/SKILL.md

@@ -0,0 +1,47 @@
+---
+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.
+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:*)
+---
+
+# Plumbbob — verify a step (the tick)
+
+Current session state (injected when this skill runs): !`__PLUMBBOB_BIN__ status 2>/dev/null || echo "plumbbob CLI not found - install the dep and re-run: npx plumbbob setup"`
+
+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 —
+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
+   **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
+   `.plumbbob/intent.md`, then in one pass check the diff against:
+   - the current step's **done-when** criterion — is it actually met?
+   - the **Decisions** — does anything contradict a settled call?
+   - the **Constraints** — are any violated?
+   Surface every mismatch plainly. You are reviewing, not building — do not fix anything.
+3. **Validate.** State, yes or no, whether the step's done-when is met, with the evidence.
+4. **PAUSE.** Present the check result, the self-review, 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.
+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,
+   and return to DESIGN. Do **not** bump the version or touch the changelog — that is
+   the human's `/version` call.
+
+## The hard contracts
+
+- **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.
+- **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.

package/skills/plumbbob-interrogate/SKILL.md

@@ -8,7 +8,7 @@ allowed-tools: Read, Edit, Bash(__PLUMBBOB_BIN__ status:*)
 
 # Plumbbob — interrogate the frame
 
-Current session state (injected when this skill runs): !`__PLUMBBOB_BIN__ status`
+Current session state (injected when this skill runs): !`__PLUMBBOB_BIN__ status 2>/dev/null || echo "plumbbob CLI not found - install the dep and re-run: npx plumbbob setup"`
 
 ## Wrong-state refusal
 

package/dist/verbs/done.js

@@ -1,63 +0,0 @@
-// `plumbbob done` — the step gate. Refuses on a red check, then stages the whole
-// step (D8: `git add -A`; the sidecar is git-excluded so it never lands), warns
-// about anything committed outside the SEAM, takes the checkpoint commit, records
-// its SHA, and returns to DESIGN.
-import { appendFileSync, readFileSync, rmSync } from 'node:fs';
-import { commit, findRepoRoot, stageAll, stagedPaths } from "../lib/git.js";
-import { checkpointsPath, hasSession, readState, seamPath, stepPath, writeState } from "../lib/sidecar.js";
-import { runCheck } from "../lib/check.js";
-import { matchesSeam } from "../lib/intent.js";
-export function done(cwd) {
-    const root = findRepoRoot(cwd);
-    if (root === null || !hasSession(root)) {
-        process.stderr.write('plumbbob: no active session. Run `plumbbob start "<title>"` first.\n');
-        return 1;
-    }
-    const state = readState(root);
-    if (state !== 'BUILD' && state !== 'REVIEW') {
-        process.stderr.write(`plumbbob: done runs from BUILD or REVIEW (current state is ${state ?? 'UNKNOWN'}). Run \`plumbbob build <n>\` first.\n`);
-        return 1;
-    }
-    const step = readStepNumber(root);
-    if (step === null) {
-        process.stderr.write('plumbbob: no in-flight step — run `plumbbob build <n>` first.\n');
-        return 1;
-    }
-    if (runCheck(root) !== 0) {
-        process.stderr.write('plumbbob: check failed (red) — done refuses on red. Fix it and re-run `done`.\n');
-        return 1;
-    }
-    stageAll(root);
-    const seam = readSeamTokens(root);
-    const outside = stagedPaths(root).filter((p) => !matchesSeam(p, seam));
-    if (outside.length > 0) {
-        process.stderr.write(`plumbbob: WARNING committed paths outside the SEAM: ${outside.join(', ')}. The checkpoint captures them, but scope drift may mean the plan needs revising.\n`);
-    }
-    const sha = commit(root, `plumbbob: step ${step} done`);
-    appendFileSync(checkpointsPath(root), `step ${step} ${sha}\n`);
-    rmSync(seamPath(root), { force: true });
-    rmSync(stepPath(root), { force: true });
-    writeState(root, 'DESIGN');
-    process.stdout.write(`plumbbob: step ${step} done — checkpoint ${sha.slice(0, 9)}. STATE=DESIGN.\n`);
-    return 0;
-}
-function readStepNumber(root) {
-    try {
-        const raw = readFileSync(stepPath(root), 'utf8').trim();
-        return /^\d+$/.test(raw) ? Number(raw) : null;
-    }
-    catch {
-        return null;
-    }
-}
-function readSeamTokens(root) {
-    try {
-        return readFileSync(seamPath(root), 'utf8')
-            .split('\n')
-            .map((l) => l.trim())
-            .filter((l) => l.length > 0);
-    }
-    catch {
-        return [];
-    }
-}

package/dist/verbs/finish.js

@@ -1,54 +0,0 @@
-// `plumbbob finish` (D19/D20) — the closing gate, symmetric with the step gate.
-// Refuses unless a report exists, appends the checkpoint SHA list to it, archives
-// intent + build-log + report under .plumbbob/archive/, clears the active files,
-// and deletes SEAM, STEP, then STATE LAST (deleting STATE is what switches the
-// muzzle off, so it happens exactly at session end). Never touches git (C5).
-import { appendFileSync, existsSync, readFileSync, rmSync } from 'node:fs';
-import { join, relative } from 'node:path';
-import { findRepoRoot } from "../lib/git.js";
-import { buildLogPath, checkpointsPath, hasSession, intentPath, seamPath, sidecarDir, stepPath, } from "../lib/sidecar.js";
-import { archiveSession, reportPath } from "../lib/archive.js";
-export function finish(cwd) {
-    const root = findRepoRoot(cwd);
-    if (root === null || !hasSession(root)) {
-        process.stderr.write('plumbbob: no active session. Run `plumbbob start "<title>"` first.\n');
-        return 1;
-    }
-    if (!existsSync(reportPath(root))) {
-        process.stderr.write('plumbbob: finish refuses without a report — run `/plumbbob-report` first (it writes .plumbbob/report.md). ' +
-            'The closing gate is symmetric with the step gate: you do not walk away without capturing what happened.\n');
-        return 1;
-    }
-    appendCheckpointShas(root);
-    const archived = archiveSession(root);
-    // Clear the active files — now safely archived.
-    rmSync(intentPath(root), { force: true });
-    rmSync(buildLogPath(root), { force: true });
-    rmSync(reportPath(root), { force: true });
-    // Delete the control files LAST, STATE the very last: while STATE exists the
-    // muzzle is live, so it comes off only once everything else is torn down.
-    rmSync(seamPath(root), { force: true });
-    rmSync(stepPath(root), { force: true });
-    rmSync(join(sidecarDir(root), 'STATE'), { force: true });
-    process.stdout.write(`plumbbob: finished — archived to ${relative(root, archived)}. STATE cleared (muzzle off). ` +
-        'Run `plumbbob start "<title>"` to begin the next task.\n');
-    return 0;
-}
-// Append the recorded checkpoints (baseline + each `step n <sha>`) to the report,
-// so the archived report lists the SHAs (spec: "finish lists the SHAs in the
-// report").
-function appendCheckpointShas(root) {
-    let raw = '';
-    try {
-        raw = readFileSync(checkpointsPath(root), 'utf8');
-    }
-    catch {
-        raw = '';
-    }
-    const lines = raw
-        .split('\n')
-        .map((l) => l.trim())
-        .filter((l) => l.length > 0)
-        .map((l) => `- ${l}`);
-    appendFileSync(reportPath(root), ['', '## Checkpoints', '', ...lines, ''].join('\n'));
-}

package/dist/verbs/mode.js

@@ -1,26 +0,0 @@
-// `plumbbob mode <x>` — the hidden escape hatch: set STATE directly when reality
-// and the machine desync. Not part of the normal flow; the lone human-only verb,
-// so the dispatch refuses it under CLAUDECODE and bash-guard blocks it from the
-// model's shell (D21 revised).
-import { findRepoRoot } from "../lib/git.js";
-import { hasSession, readState, writeState, VALID_STATES } from "../lib/sidecar.js";
-export function mode(cwd, args) {
-    const root = findRepoRoot(cwd);
-    if (root === null || !hasSession(root)) {
-        process.stderr.write('plumbbob: no active session. Run `plumbbob start "<title>"` first.\n');
-        return 1;
-    }
-    const target = args[0];
-    if (target === undefined) {
-        process.stderr.write(`plumbbob: mode needs a state — one of: ${VALID_STATES.join(', ')}.\n`);
-        return 1;
-    }
-    if (!VALID_STATES.includes(target)) {
-        process.stderr.write(`plumbbob: '${target}' is not a valid state — one of: ${VALID_STATES.join(', ')}.\n`);
-        return 1;
-    }
-    const previous = readState(root) ?? 'UNKNOWN';
-    writeState(root, target);
-    process.stdout.write(`STATE: ${previous} -> ${target} (escape hatch — prefer the normal verbs when you can).\n`);
-    return 0;
-}

package/dist/verbs/review.js

@@ -1,24 +0,0 @@
-// `plumbbob review` — run the heavy check from BUILD. Green flips to REVIEW (the
-// muzzle goes back on so reading the diff can't slide into editing). Red stays in
-// BUILD. The state only advances on a green check.
-import { findRepoRoot } from "../lib/git.js";
-import { hasSession, readState, writeState } from "../lib/sidecar.js";
-import { runCheck } from "../lib/check.js";
-export function review(cwd) {
-    const root = findRepoRoot(cwd);
-    if (root === null || !hasSession(root)) {
-        process.stderr.write('plumbbob: no active session. Run `plumbbob start "<title>"` first.\n');
-        return 1;
-    }
-    if (readState(root) !== 'BUILD') {
-        process.stderr.write(`plumbbob: review runs from BUILD (current state is ${readState(root) ?? 'UNKNOWN'}). Run \`plumbbob build <n>\` first.\n`);
-        return 1;
-    }
-    if (runCheck(root) !== 0) {
-        process.stderr.write('plumbbob: check failed (red) — staying in BUILD. Fix it and re-run `review` (or `done` once green).\n');
-        return 1;
-    }
-    writeState(root, 'REVIEW');
-    process.stdout.write('plumbbob: check green — STATE=REVIEW. Read the diff against intent.md (edits muzzled). `build <n>` to re-enter and fix, or `done` to checkpoint.\n');
-    return 0;
-}

package/dist/verbs/wrap.js

@@ -1,28 +0,0 @@
-// `plumbbob wrap` (D19/D28) — the FINISH-entry verb. Sets STATE=FINISH so
-// /plumbbob-report can write report.md and /plumbbob-docs can touch docs/.
-// `finish` stays the closing gate; wrap just opens the one state where
-// documentation may be projected. A transition the human fires — from a terminal
-// or, in-session, via the /pb-wrap driver skill (D21 revised).
-import { findRepoRoot } from "../lib/git.js";
-import { hasSession, readState, writeState } from "../lib/sidecar.js";
-export function wrap(cwd) {
-    const root = findRepoRoot(cwd);
-    if (root === null || !hasSession(root)) {
-        process.stderr.write('plumbbob: no active session. Run `plumbbob start "<title>"` first.\n');
-        return 1;
-    }
-    const state = readState(root);
-    if (state === 'FINISH') {
-        process.stdout.write('plumbbob: already in FINISH. Run `/plumbbob-report`, then `plumbbob finish` to close.\n');
-        return 0;
-    }
-    if (state !== 'DESIGN') {
-        process.stderr.write(`plumbbob: wrap enters FINISH from DESIGN (current state is ${state ?? 'UNKNOWN'}). ` +
-            'Close the current step first — `done` from BUILD/REVIEW, or `spike done` from SPIKE.\n');
-        return 1;
-    }
-    writeState(root, 'FINISH');
-    process.stdout.write('plumbbob: STATE=FINISH. Now `/plumbbob-report` writes the report (and `/plumbbob-docs` may touch docs/); ' +
-        'then `plumbbob finish` archives and closes.\n');
-    return 0;
-}

package/hooks/bash-guard.sh

@@ -1,62 +0,0 @@
-#!/bin/sh
-# bash-guard.sh — Plumbbob's assistive fence (D21), not a wall. PreToolUse on
-# Bash. Session-gated. Blocks shell commands that poke control state or write
-# files outside BUILD/SPIKE, so the muzzle is not trivially bypassed. Full
-# shell-write detection is unsolvable; the residual gap is accepted (D21).
-
-find_root() {
-  d=$(pwd -P)
-  while [ -n "$d" ]; do
-    if [ -f "$d/.plumbbob/STATE" ]; then
-      printf '%s' "$d"
-      return 0
-    fi
-    [ "$d" = "/" ] && break
-    d=$(dirname "$d")
-  done
-  return 1
-}
-
-deny() {
-  printf 'plumbbob: %s\n' "$1" >&2
-  exit 2
-}
-
-root=$(find_root) || exit 0 # no session: allow
-
-input=$(cat)
-command=$(printf '%s' "$input" | jq -r '.tool_input.command // empty' 2>/dev/null)
-[ -z "$command" ] && command=$(printf '%s' "$input" | sed -n 's/.*"command"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -n1)
-[ -z "$command" ] && exit 0
-
-state=$(tr -d '[:space:]' <"$root/.plumbbob/STATE" 2>/dev/null)
-
-# Always: keep the model out of the control files and the escape hatch (D21).
-case "$command" in
-  *.plumbbob/STATE* | *.plumbbob/SEAM*)
-    deny "blocked: do not touch .plumbbob/STATE or SEAM from the shell. Read state with \`plumbbob status\`; transitions are the human's verbs. Do not retry."
-    ;;
-esac
-case "$command" in
-  *"plumbbob mode"* | *"pb mode"* | *"plumbbob mode"*)
-    deny "blocked: \`plumbbob mode\` is the human's escape hatch, not a model action. Do not retry — ask the human."
-    ;;
-esac
-
-# Outside BUILD/SPIKE: block obvious file-writing shell patterns (D21).
-case "$state" in
-  BUILD | SPIKE) ;;
-  *)
-    # Strip redirects that can't write a real file (stderr merges, /dev/null
-    # sinks) so read-only commands aren't over-blocked. Any surviving `>` is a
-    # real write. The residual gap (e.g. `>/dev/nullEVIL`) is accepted (D21).
-    scrubbed=$(printf '%s' "$command" | sed 's/[0-9]*>&[0-9-]//g; s/&\{0,1\}[0-9]*>>* *\/dev\/null//g')
-    case "$scrubbed" in
-      *">"* | *"tee "* | *"sed -i"* | *"git apply"*)
-        deny "blocked: file-writing shell commands are not allowed in ${state:-?} (code edits happen in BUILD). Do not retry — park it or ask the human to \`plumbbob build <n>\`."
-        ;;
-    esac
-    ;;
-esac
-
-exit 0

package/hooks/pre-edit.sh

@@ -1,112 +0,0 @@
-#!/bin/sh
-# pre-edit.sh — Plumbbob muzzle + seam-guard. PreToolUse on
-# Edit|Write|MultiEdit|NotebookEdit. Session-gated: a repo with no .plumbbob/
-# session behaves exactly like plain Claude Code (C7). The dormant check is pure
-# sh (test -f) before any JSON parsing, so a no-session edit pays ~nothing (C3).
-# Built from the verified hooks API (D3): input is JSON on stdin
-# (tool_input.file_path / notebook_path, absolute); deny is exit 2 + stderr.
-
-# Walk up from the hook's physical cwd to the session root, like git finds .git.
-find_root() {
-  d=$(pwd -P)
-  while [ -n "$d" ]; do
-    if [ -f "$d/.plumbbob/STATE" ]; then
-      printf '%s' "$d"
-      return 0
-    fi
-    [ "$d" = "/" ] && break
-    d=$(dirname "$d")
-  done
-  return 1
-}
-
-# Seam membership (D23): exact whole-line match, or a `dir/` line by prefix.
-in_seam() {
-  _rel=$1
-  _seam=$2
-  [ -f "$_seam" ] || return 1
-  grep -qFx "$_rel" "$_seam" && return 0
-  while IFS= read -r _line || [ -n "$_line" ]; do
-    case "$_line" in
-      */)
-        case "$_rel" in
-          "$_line"*) return 0 ;;
-        esac
-        ;;
-    esac
-  done <"$_seam"
-  return 1
-}
-
-deny() {
-  printf 'plumbbob: %s\n' "$1" >&2
-  exit 2
-}
-
-root=$(find_root) || exit 0 # no session anywhere above cwd: allow
-
-input=$(cat)
-path=$(printf '%s' "$input" | jq -r '.tool_input.file_path // .tool_input.notebook_path // empty' 2>/dev/null)
-if [ -z "$path" ]; then
-  path=$(printf '%s' "$input" | sed -n 's/.*"file_path"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -n1)
-  [ -z "$path" ] && path=$(printf '%s' "$input" | sed -n 's/.*"notebook_path"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -n1)
-fi
-[ -z "$path" ] && exit 0 # nothing to guard: allow
-
-state=$(tr -d '[:space:]' <"$root/.plumbbob/STATE" 2>/dev/null)
-
-# Canonicalize the absolute tool path to repo-relative (D4).
-case "$path" in
-  "$root"/*) rel=${path#"$root"/} ;;
-  *) rel=$path ;;
-esac
-
-# 1. The archive is read-only history — never writable (D6/D19).
-case "$rel" in
-  .plumbbob/archive/*)
-    deny "blocked: $rel is archived history (read-only). Do not retry."
-    ;;
-esac
-
-# 2. The three control docs are writable in every state, so DESIGN and FINISH can
-#    do their work. Anchored exact paths — never a bare */intent.md suffix (D6).
-case "$rel" in
-  .plumbbob/intent.md | .plumbbob/build-log.md | .plumbbob/report.md)
-    exit 0
-    ;;
-esac
-
-# 3. docs/ is writable only in FINISH (D19).
-case "$rel" in
-  docs/*)
-    [ "$state" = "FINISH" ] && exit 0
-    deny "blocked: $rel (docs/) is writable only in FINISH — docs are projected at the end. Do not retry; park it or finish the build first."
-    ;;
-esac
-
-# The seam muzzle below governs repo code only (D23). A path *outside* the repo
-# (Claude's own plan-mode scratch in ~/.claude/plans, an editor tmpfile) and a
-# git-ignored path *inside* it (fallow data, dist/, coverage/) are none of its
-# business — never block them. `.plumbbob/` is itself git-ignored but is
-# plumbbob's own control surface, so its non-doc files (STATE/SEAM/...) must stay
-# governed by the muzzle, never skipped here.
-case "$rel" in
-  .plumbbob/*) ;; # control state: stays governed by the muzzle, never skipped
-  *)
-    # git resolves the path via the repo toplevel (robust to symlinked cwds).
-    # check-ignore exit: 0 = ignored, 128 = outside the repo — neither is the
-    # muzzle's business; 1 = in-repo, tracked territory -> fall through to it.
-    git -C "$root" check-ignore -q -- "$path" 2>/dev/null
-    [ "$?" -ne 1 ] && exit 0
-    ;;
-esac
-
-# 4. Everything else is code: allowed only in BUILD, confined to the SEAM (D23).
-#    SPIKE locks the main tree like DESIGN (D18) — spike edits live in dormant
-#    worktrees, so the muzzle never needs to allow SPIKE here.
-if [ "$state" = "BUILD" ]; then
-  in_seam "$rel" "$root/.plumbbob/SEAM" && exit 0
-  deny "blocked: $rel is outside the seam for this step. Do not retry — park it (\`plumbbob park\`), or ask the human to revise the step's seam in intent.md and re-run \`plumbbob build <n>\`."
-fi
-
-deny "blocked: code edits are not allowed in ${state:-?} (they happen in BUILD). Do not retry — if this needs doing it's a decision: park it (\`plumbbob park\`) or ask the human to \`plumbbob build <n>\`."

package/skills/park/SKILL.md

@@ -1,26 +0,0 @@
----
-name: park
-description: Compose one tidy tagged park line, get the human's OK in-turn, then capture it by shelling `plumbbob park` — never by editing a file.
-disable-model-invocation: true
-model: haiku
-allowed-tools: Bash(__PLUMBBOB_BIN__ status:*), Bash(__PLUMBBOB_BIN__ park:*)
----
-
-# Park
-
-Current session state (injected when this skill runs): !`__PLUMBBOB_BIN__ status`
-
-## Wrong-state refusal
-
-Parking needs an **active session** to capture into. Read the state injected above: if it is `NO ACTIVE SESSION`, **refuse** and tell the human to run `plumbbob start "<title>"` first. Every active state (`DESIGN`, `BUILD`, `REVIEW`, `SPIKE`, `FINISH`) is fine — capture is always available, which is the whole point of parking.
-
-## What this skill does
-
-Take the idea, problem, or "ooh what if" the human just had and **compose it into one tidy, tagged line** — short, legible, self-contained, so it still reads cleanly weeks later. 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_BIN__ park "<the approved line>"` via Bash.
-
-## The one hard contract
-
-The capture itself is the **dumb CLI**, never an edit. This skill carries **no Edit and no Write tool** on purpose (D12): you may not append to `build-log.md` yourself. Compose, get approval, then shell `__PLUMBBOB_BIN__ park` — that is the only write path. If approval never comes, capture nothing.

package/skills/pb-done/SKILL.md

@@ -1,18 +0,0 @@
----
-name: pb-done
-description: Human-triggered driver for `plumbbob done` — ensure the check is green, take the checkpoint commit, record its SHA, and return to DESIGN.
-disable-model-invocation: true
-model: haiku
-allowed-tools: Bash(__PLUMBBOB_BIN__ status:*), Bash(__PLUMBBOB_BIN__ done:*)
----
-
-# Plumbbob — finish a step (driver)
-
-Current session state (injected when this skill runs): !`__PLUMBBOB_BIN__ status`
-
-This is a **driver skill** — a chat-side trigger for the mechanical `plumbbob done` 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.
-
-## What it does
-
-1. Run `__PLUMBBOB_BIN__ done` via Bash.
-2. Report the verb's output verbatim — the checkpoint SHA and return to DESIGN, or any refusal (e.g. the check is red).

package/skills/pb-finish/SKILL.md

@@ -1,18 +0,0 @@
----
-name: pb-finish
-description: Human-triggered driver for `plumbbob finish` — refuse unless a report is archived, then archive, clear the session, and switch the muzzle off.
-disable-model-invocation: true
-model: haiku
-allowed-tools: Bash(__PLUMBBOB_BIN__ status:*), Bash(__PLUMBBOB_BIN__ finish:*)
----
-
-# Plumbbob — finish the session (driver)
-
-Current session state (injected when this skill runs): !`__PLUMBBOB_BIN__ status`
-
-This is a **driver skill** — a chat-side trigger for the mechanical `plumbbob finish` 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.
-
-## What it does
-
-1. Run `__PLUMBBOB_BIN__ finish` via Bash.
-2. Report the verb's output verbatim. It is the closing gate — it **refuses unless `.plumbbob/report.md` exists**. If it refuses, relay that and tell the human to run `/plumbbob-report` first; do not write the report yourself from here.

package/skills/pb-review/SKILL.md

@@ -1,18 +0,0 @@
----
-name: pb-review
-description: Human-triggered driver for `plumbbob review` — run the heavy check and, if green, flip to REVIEW (muzzle back on) to read the diff cold.
-disable-model-invocation: true
-model: haiku
-allowed-tools: Bash(__PLUMBBOB_BIN__ status:*), Bash(__PLUMBBOB_BIN__ review:*)
----
-
-# Plumbbob — review a step (driver)
-
-Current session state (injected when this skill runs): !`__PLUMBBOB_BIN__ status`
-
-This is a **driver skill** — a chat-side trigger for the mechanical `plumbbob review` 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.
-
-## What it does
-
-1. Run `__PLUMBBOB_BIN__ review` via Bash.
-2. Report the verb's output verbatim. If the heavy check is red the verb stays in BUILD and prints the failures — relay them and stop; fixing them is the human's call, not an automatic retry.