plumbbob 0.3.1 → 0.4.2

package/skills/refine/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: refine
+description: Keep intent.md true — attack the plan for holes (append as Open questions) and refine or repair the Frame, Decisions, Constraints, and Steps to match reality. Usable at any point; you propose, the human approves.
+disable-model-invocation: true
+model: opus
+allowed-tools: Read, Edit, Bash(plumbbob status:*)
+---
+
+# Plumbbob — refine the plan
+
+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"`
+
+`/plumbbob:refine` keeps `intent.md` honest. Use it at **any point** — right after `/plumbbob:plan`
+to stress-test a fresh frame, or mid-build to repair a plan that drifted from what the
+code is actually doing. It is the document-level complement to `/plumbbob:step` (which only
+sharpens the *next* step): `/plumbbob:refine` works the *whole* plan.
+
+## No-session refusal
+
+This skill refines an existing plan, so it needs one. Read the state injected above: if
+it is `NO ACTIVE SESSION`, **refuse** in one line and tell the human to run
+`plumbbob start "<title>"` (or `/plumbbob:plan`) first, and edit nothing. Every active state
+is fine — refining is always available.
+
+## Two modes
+
+- **Attack (diverge in the problem space).** Hand the **Frame**, **Decisions**, and
+  **Architecture sketch** a cold, adversarial read and surface holes — ambiguities,
+  unhandled edge cases, hidden assumptions, collisions with the existing code. Append
+  each as a one-line question under `## Open questions`, **never** as a Decision:
+  resolving a hole is the human's convergence, not yours. This mode surfaces; it does
+  not decide.
+- **Repair (re-sync to reality).** When the plan has drifted — a Decision was overtaken
+  by what you built, a Constraint changed, a Step no longer matches the seam — propose
+  the edits that bring `intent.md` back in line with the truth. Show the before/after for
+  each, and **write only what the human approves**.
+
+## The hard contracts
+
+- **You propose; the human converges.** Surface holes and draft repairs, but the human
+  approves every change to `intent.md`. Never guess a hole into a Decision.
+- **Open questions for holes, edits for drift.** New uncertainty goes to
+  `## Open questions`; settled drift gets repaired in place once the human OKs it.
+- **Refine the plan, not the code.** `/plumbbob:refine` touches `intent.md` only — turning a
+  decision into a diff is `/plumbbob:build` or your own hands, never this skill.

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

@@ -1,19 +1,19 @@
 ---
-name: pb-revert
+name: revert
 description: Human-triggered driver for `plumbbob revert` — git reset --hard to a checkpoint SHA (discarding the half-done step) and return to DESIGN.
 disable-model-invocation: true
 model: haiku
-allowed-tools: Bash(__PLUMBBOB_BIN__ status:*), Bash(__PLUMBBOB_BIN__ revert:*)
+allowed-tools: Bash(plumbbob status:*), Bash(plumbbob revert:*)
 ---
 
 # Plumbbob — revert to a checkpoint (driver)
 
-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"`
+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 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.
 
 ## What it does
 
-1. Read an optional target step from the way you were invoked (e.g. `/pb-revert --to 2` → step `2`). With no target, revert goes to the last done-checkpoint.
-2. Run `__PLUMBBOB_BIN__ revert` (or `__PLUMBBOB_BIN__ revert --to <n>`) via Bash. This is a `git reset --hard` — it discards the current in-progress step. Run it exactly as the human asked; do not add or drop the `--to` on your own.
+1. Read an optional target step from the way you were invoked (e.g. `/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. 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.

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

@@ -1,19 +1,19 @@
 ---
-name: pb-spike
+name: spike
 description: Human-triggered driver for `plumbbob spike` — open a throwaway worktree experiment for a genuine fork, or tear it down with `spike done`.
 disable-model-invocation: true
 model: haiku
-allowed-tools: Bash(__PLUMBBOB_BIN__ status:*), Bash(__PLUMBBOB_BIN__ spike:*)
+allowed-tools: Bash(plumbbob status:*), Bash(plumbbob spike:*)
 ---
 
 # Plumbbob — spike an experiment (driver)
 
-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"`
+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 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.
 
 ## What it does
 
-1. Read the spike target from the way you were invoked: a slug to open one (e.g. `/pb-spike redis-cache`), or the literal `done` to tear the current spike down (`/pb-spike done`). If neither is present, ask which and run nothing.
-2. Run `__PLUMBBOB_BIN__ spike "<slug>"` or `__PLUMBBOB_BIN__ spike done` via Bash.
+1. Read the spike target from the way you were invoked: a slug to open one (e.g. `/plumbbob:spike redis-cache`), or the literal `done` to tear the current spike down (`/plumbbob:spike done`). If neither is present, ask which and run nothing.
+2. Run `plumbbob spike "<slug>"` or `plumbbob spike done` via Bash.
 3. Report the verb's output verbatim — the worktree it created or removed, or any refusal.

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

@@ -1,16 +1,16 @@
 ---
-name: pb-status
+name: 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:*)
+allowed-tools: Bash(plumbbob 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"`
+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 a **thin driver** for `__PLUMBBOB_BIN__ status`. The dashboard above is your
+This is a **thin driver** for `plumbbob 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
@@ -19,4 +19,4 @@ skill carries **no Edit and no Write tool**: the CLI is the source of truth, so
 ## 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.
+2. If it reads `NO ACTIVE SESSION`, tell the human to `/plumbbob:plan` to frame a goal.

package/skills/step/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: step
+description: Revise the next increment just-in-time — sharpen the next undone step against what's now true, or (with input) re-cut, split, or add a step. Empty input runs an automatic sharpen. One at a time; the human approves.
+disable-model-invocation: true
+model: opus
+allowed-tools: Read, Edit, Bash(plumbbob status:*)
+---
+
+# Plumbbob — revise the next step (the single-increment move)
+
+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"`
+
+`/plumbbob:plan` authors the **whole** step list up front, so `/plumbbob:step` is the
+**just-in-time revision** move: it keeps the *next* undone step honest against what the
+build has actually taught you, right before you `/plumbbob:build` it. (Framing the whole goal
+is the separate `/plumbbob:plan` move.) It can also add or re-cut a step when scope genuinely
+grew — but its everyday job is to sharpen, not to invent.
+
+## Two ways to fire it
+
+- **`/plumbbob:step` (no input) → automatic sharpen.** Re-examine the next undone step
+  against the completed code, the Decisions, the Constraints, and the build-log, then
+  make the obvious revisions to its **done-when** and **seam** so it matches reality —
+  e.g. a file moved, a decision narrowed the scope, an earlier step already did part of
+  it. This is the zero-effort "keep my next step in sync" move: if the human does
+  nothing else, the next step stays current.
+- **`/plumbbob:step <what changed>` → directed revision.** Take the human's input and propose
+  the matching change: tighten the done-when, adjust the seam, split the step in two, or
+  add a new increment the plan was missing.
+
+## What this skill does
+
+1. **Read the plan and the reality.** Read `intent.md`'s Frame, Decisions, Constraints,
+   and the steps already done, plus the next undone step, to see what it *should* now be.
+2. **Propose the revision** (or the new/split step): a one-line **title**, a **done-when**
+   `/plumbbob:verify` can validate, and a **seam** (exact paths, or a `dir/` grant). Keep it
+   small enough to verify in one review pass. Show the before/after so the human can see
+   what you changed and why.
+3. **Get the human's OK**, then write it into `## Steps` in the standard format —
+   `N. [ ] <title> — **done when:** <criterion>` with a `- seam:` sub-line. Revise the
+   existing step in place; only append when you are genuinely adding an increment.
+
+## The hard contracts
+
+- **One verifiable increment.** Each step carries a done-when `/plumbbob:verify` can check
+  and a seam small enough to review in one pass.
+- **Edit `## Steps` only**, in the standard format `status` and `build` parse — never
+  the Roadmap, never loose prose. A done step (`[x]`) is history; do not rewrite it.
+- **The human approves the revision** before it lands. You propose; they decide.

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 2>/dev/null || echo "plumbbob CLI not found - install the dep and re-run: npx plumbbob setup"`
+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 2>/dev/null || echo "plumbbob CLI not found - install the dep and re-run: npx plumbbob setup"`
+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,163 +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/. A skill's bin
-//     invocation can NOT use $CLAUDE_PROJECT_DIR — that variable is defined only
-//     in Claude Code's hook context and expands EMPTY in a skill's bash — so
-//     setup resolves the bin at install time (see selfBin): --local bakes the
-//     absolute path to <repo>/node_modules/.bin/plumbbob (personal + untracked,
-//     so a machine path is fine); --project uses a bare `plumbbob` (committed +
-//     shared, so it stays portable — Claude Code resolves it from the project's
-//     node_modules/.bin, which it prepends to PATH). 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__';
-// The hook is registered in settings.json, whose `command` runs in Claude Code's
-// hook context — the one place $CLAUDE_PROJECT_DIR is defined — so the portable
-// project-root variable resolves correctly here. (A skill's bash does NOT get
-// that variable; the skill bin is resolved separately, by selfBin.)
-const SELF_HOOKS_DIR = '$CLAUDE_PROJECT_DIR/node_modules/plumbbob/hooks';
-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');
-    const bin = selfBin(mode);
-    cpSync(packageDir('skills'), skillsDir, { recursive: true });
-    substituteSkillBins(skillsDir, 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 → ${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 the bin string baked into the copied skills. A skill's `!`...``
-// injection and its allowed-tools prefix can NOT rely on $CLAUDE_PROJECT_DIR (a
-// hooks-only variable that expands empty in a skill's bash context), so we
-// resolve at install time. --local is personal and untracked, so bake the
-// absolute path to the project-local binary — fully resolved, no runtime
-// lookup. --project is committed and shared, so a machine-absolute path can't
-// travel; fall back to a bare `plumbbob`, which Claude Code resolves from the
-// project's node_modules/.bin (it prepends that to PATH). A repo path with
-// whitespace can't sit unquoted in the injection or an allowed-tools prefix
-// either, so use the PATH-resolved bare form there too.
-function selfBin(mode) {
-    const committed = !mode.settingsFile.endsWith('settings.local.json');
-    const abs = join(mode.repoRoot, 'node_modules', '.bin', 'plumbbob');
-    return committed || /\s/.test(abs) ? 'plumbbob' : abs;
-}
-// 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);
-}