plumbbob 0.4.4 → 0.4.8

package/.claude-plugin/plugin.json

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

package/README.md

@@ -1,4 +1,4 @@
-# Plumbbob
+# PlumbBob
 
 <p align="center">
   <img src="hero.jpg" alt="A row of plumb bobs of varying shapes hanging from strings" width="600">
@@ -66,55 +66,55 @@ and it cannot be skipped.
 
 You drive the whole loop from your IDE with eight `/plumbbob:*` skills — no step numbers to
 remember, no raw CLI to type. Each is `disable-model-invocation`, so *you* fire
-every move, and `/plumbbob:status` always names your next one.
+every move, and `/plumbbob:pb-status` always names your next one.
 
 | Skill | Does |
 |-------|------|
-| `/plumbbob:plan` | plan the whole goal — scaffold the session + author intent's Frame, Decisions, Constraints, **and all Steps** |
-| `/plumbbob:step` | revise/sharpen the next step (empty input auto-syncs it to reality) |
-| `/plumbbob:build` | *(optional)* implement the next planned step, then verify it to the pause — `--auto` self-approves and chains to done |
-| `/plumbbob:verify` | the tick — check → self-review → validate → **PAUSE** → checkpoint |
-| `/plumbbob:park` | capture an idea without chasing it |
-| `/plumbbob:status` | orient — where you are, the next step's done-when + seam, and the next move |
-| `/plumbbob:harvest` | triage parked ideas at a boundary (blocker / tangent / pivot) |
-| `/plumbbob:wrap` | wrap up — write the report, archive safely, clear for a fresh goal |
-
-Three optional power moves survive for when you need them: `/plumbbob:revert` (recover to
-a checkpoint), `/plumbbob:spike` (throwaway worktree experiment), and `/plumbbob:refine` (attack
+| `/plumbbob:pb-plan` | plan the whole goal — scaffold the session + author intent's Frame, Decisions, Constraints, **and all Steps** |
+| `/plumbbob:pb-step` | revise/sharpen the next step (empty input auto-syncs it to reality) |
+| `/plumbbob:pb-build` | *(optional)* implement the next planned step, then verify it to the pause — `--auto` self-approves and chains to done |
+| `/plumbbob:pb-verify` | the tick — check → self-review → validate → **PAUSE** → checkpoint |
+| `/plumbbob:pb-park` | capture an idea without chasing it |
+| `/plumbbob:pb-status` | orient — where you are, the next step's done-when + seam, and the next move |
+| `/plumbbob:pb-harvest` | triage parked ideas at a boundary (blocker / tangent / pivot) |
+| `/plumbbob:pb-wrap` | wrap up — write the report, archive safely, clear for a fresh goal |
+
+Three optional power moves survive for when you need them: `/plumbbob:pb-revert` (recover to
+a checkpoint), `/plumbbob:pb-spike` (throwaway worktree experiment), and `/plumbbob:pb-refine` (attack
 the frame for holes, or repair the plan when it drifts — usable at any point).
 
 ## The loop
 
-The happy path is **plan the whole thing up front, then drive `/plumbbob:build` until
+The happy path is **plan the whole thing up front, then drive `/plumbbob:pb-build` until
 done** — approving each step at its verify pause:
 
 ```text
-/plumbbob:plan                      author the whole plan (incl. all steps)   (once)
+/plumbbob:pb-plan                      author the whole plan (incl. all steps)   (once)
   └ per step:
-       /plumbbob:status             review the next step (done-when + seam)
-       /plumbbob:step   (optional)  sharpen/revise it first if needed
-       /plumbbob:build  (or DIY)    implement it → verify → PAUSE → checkpoint
-       /plumbbob:park               capture strays mid-build
-       /plumbbob:harvest            triage them at a boundary
-  /plumbbob:wrap                    report + archive + clear                  (once)
+       /plumbbob:pb-status             review the next step (done-when + seam)
+       /plumbbob:pb-step   (optional)  sharpen/revise it first if needed
+       /plumbbob:pb-build  (or DIY)    implement it → verify → PAUSE → checkpoint
+       /plumbbob:pb-park               capture strays mid-build
+       /plumbbob:pb-harvest            triage them at a boundary
+  /plumbbob:pb-wrap                    report + archive + clear                  (once)
 ```
 
-Each `/plumbbob:build` builds the next undone step and stops at the pause for your
-approval — re-firing it is itself the clock tick. (`/plumbbob:build --auto` is the opt-in
+Each `/plumbbob:pb-build` builds the next undone step and stops at the pause for your
+approval — re-firing it is itself the clock tick. (`/plumbbob:pb-build --auto` is the opt-in
 that lets the agent self-approve and chain to done, halting on a red check or any
 mismatch.) For a worked example that walks one goal end to end — planning, building
 each step, wrapping up, archiving, and starting the next task — see
 [`docs/happy-path.md`](docs/happy-path.md).
 
-**Three ways to plan.** `/plumbbob:plan` produces the same artifact — a complete, standalone
+**Three ways to plan.** `/plumbbob:pb-plan` produces the same artifact — a complete, standalone
 `intent.md` — from whichever seed you give it: **no argument** runs a short interview;
 **a file path** absorbs an out-of-band spec (retaining its detail so the plan stands on
 its own); **any other text** expands your inline intent. No quotes required — it
 disambiguates the mode itself.
 
-**The pluggable executor.** `/plumbbob:build` is one way to turn a planned step into code
+**The pluggable executor.** `/plumbbob:pb-build` is one way to turn a planned step into code
 — it is *optional*. Implement by hand, in a vibe session, or with another harness,
-and run `/plumbbob:verify` instead: it reads the *diff, not the author*. Plumbbob is the
+and run `/plumbbob:pb-verify` instead: it reads the *diff, not the author*. Plumbbob is the
 harness-agnostic spine; how the diff appears is a slot you fill however you like.
 
 ## Calibration: size everything to the work
@@ -123,7 +123,7 @@ The fastest way to abandon this is ceremony on a one-liner. The discipline is
 *decisions before code*, not *always produce three files*.
 
 - **Tiny** (typo, one-liner): no session. Just fix it.
-- **Small** (a contained bug/change): `/plumbbob:plan` a frame + 2–3 decisions; one or two
+- **Small** (a contained bug/change): `/plumbbob:pb-plan` a frame + 2–3 decisions; one or two
   steps; build → verify → checkpoint.
 - **Medium** (a feature touching a few modules): the full loop above.
 - **Large / architectural**: that's Ridgeline's job, not Plumbbob's.
@@ -134,7 +134,8 @@ Calibration is the skill. When in doubt, smaller.
 
 - A `plumbbob` CLI (TypeScript, run natively by Node ≥ 22.18, zero runtime
   dependencies) — the dumb mechanical verbs the skills shell out to. You never type
-  it by hand.
+  it by hand (beyond `plumbbob --help` and `plumbbob --version`). The marketplace
+  plugin carries it on PATH via `bin/` shims; `npm i -g` installs it globally.
 - The eight `/plumbbob:*` skills plus the optional power moves, each
   `disable-model-invocation` so *you* fire every move.
 - One session-gated Claude Code hook — `post-edit.sh`, a non-blocking light-feedback
@@ -150,14 +151,14 @@ Calibration is the skill. When in doubt, smaller.
   blocks an edit. It exists only because Claude can't see your editor's LSP, so the
   light tier *serves the model*.
 - **Heavy** — the full `pnpm check` (tsc, oxlint, ast-grep, vitest, knip,
-  markdownlint). Not a hook: it runs *inside* `/plumbbob:verify`, which refuses to
+  markdownlint). Not a hook: it runs *inside* `/plumbbob:pb-verify`, which refuses to
   checkpoint while red. The hard gate lives on the deliberate boundary, not the
   keystroke.
 
 ## STATE is orientation, not a gate
 
 The current position lives in one word in `.plumbbob/STATE` — `DESIGN`, `BUILD`, or
-`SPIKE`. It no longer gates anything. It is read by `/plumbbob:status` to tell you where
+`SPIKE`. It no longer gates anything. It is read by `/plumbbob:pb-status` to tell you where
 you are and what to do next; a wrong state is a mislabeled position on a map, not a
 locked door. The post-edit hook is session-gated: a repo with no `.plumbbob/STATE`
 behaves exactly like plain Claude Code.
@@ -177,7 +178,8 @@ archives plain markdown under `.plumbbob/archive/` and never touches git.
   STATE          # one word: DESIGN | BUILD | SPIKE — orientation, not a gate
   SEAM           # the in-flight step's declared paths (awareness, not a lock)
   STEP           # the in-flight step number
-  checkpoints    # "step N <git-sha>", one per verified step
+  config         # key=value; check=<heavy-check command> (defaults to pnpm run check)
+  checkpoints    # "baseline <sha>" then "step N <sha>", one per verified step
   intent.md      # canonical intent
   build-log.md   # live ledger
   archive/
@@ -189,24 +191,34 @@ archives plain markdown under `.plumbbob/archive/` and never touches git.
 
 ## Install
 
-Plumbbob is a personal tool — install it once, globally, like `gh` or your
-dotfiles. The npm package ships the CLI plus the skills and hook; `plumbbob init`
-links them into Claude Code as an in-place plugin.
+Plumbbob installs **once, globally** — like `gh` or your dotfiles. There are two co-equal,
+mutually-exclusive ways to do it (both register a Claude Code plugin named `plumbbob`;
+running both collides over the `/plumbbob:*` namespace).
+
+**npm global + `init`** — the npm package ships the CLI, the skills, and the hook; `plumbbob
+init` links them into Claude Code as an in-place plugin:
 
 ```sh
 npm i -g plumbbob      # the CLI (also a `pb` shorthand)
 plumbbob init          # link it into Claude Code; --uninstall to undo
 ```
 
-`init` symlinks the package into `~/.claude/skills/plumbbob`, where Claude Code
-loads it as a plugin. Claude Code namespaces a plugin's skills as
-`/plumbbob:<skill>`, so they appear as `/plumbbob:plan`, `/plumbbob:status`, and the
-rest — already clear of built-in and other-plugin commands, no prefix needed. The
-post-edit hook auto-registers from `hooks.json`.
-Nothing else under `~` is touched
-and `settings.json` is left alone — restart Claude Code (or `/reload-plugins`) to
-activate. Because it's a symlink, a later `npm i -g plumbbob@latest` stays live with
-no re-link.
+`init` symlinks the package into `~/.claude/skills/plumbbob`, where Claude Code loads it as a
+plugin; the post-edit hook auto-registers from `hooks.json`. Because it's a symlink, a later
+`npm i -g plumbbob@latest` stays live with no re-link.
+
+**The marketplace plugin** — self-contained: it ships the skills *and* the `plumbbob`/`pb`
+CLI on PATH (via its `bin/` shims), so it needs neither `npm i -g` nor `plumbbob init`:
+
+```text
+/plugin install plumbbob@<marketplace>
+```
+
+Either way, Claude Code namespaces the skills as `/plumbbob:<skill>`, so they appear as
+`/plumbbob:pb-plan`, `/plumbbob:pb-status`, and the rest. Nothing else under `~` is touched
+and `settings.json` is left alone — restart Claude Code (or `/reload-plugins`) to activate.
+If a marketplace plumbbob is already installed, `plumbbob init` refuses rather than create
+the collision (`--force` overrides), and `plumbbob doctor` flags a double-install.
 
 **Sessions are per-project.** Install scope is not session scope: you install the
 tool once, but each goal lives in its own repo — `plumbbob start "<goal>"` writes a
@@ -222,10 +234,11 @@ look. Claude Code is the first, first-class target.
 plumbbob doctor
 ```
 
-`doctor` checks that the link resolves to the plugin manifest, the skills, and the
-hook, and prints the exact fix for anything broken. Run it first if a `/plumbbob:*`
-skill ever opens with an empty dashboard; [`docs/troubleshooting.md`](docs/troubleshooting.md)
-covers the rest.
+`doctor` works for either install path: it confirms a marketplace plugin, or checks that the
+skills-dir link resolves to the plugin manifest, the skills, and the hook — flagging a
+double-install collision — and prints the exact fix for anything broken. Run it first if a
+`/plumbbob:*` skill ever opens with an empty dashboard;
+[`docs/troubleshooting.md`](docs/troubleshooting.md) covers the rest.
 
 ## Development
 

package/bin/pb

@@ -0,0 +1,6 @@
+#!/bin/sh
+# pb — short alias for `plumbbob` (see bin/plumbbob for the full note). Same PATH
+# shim: resolves the bundled CLI relative to this file so the plugin works on PATH
+# without a global install.
+here=$(CDPATH='' cd -- "$(dirname -- "$0")" && pwd)
+exec node "$here/../dist/cli.js" "$@"

package/bin/plumbbob

@@ -0,0 +1,9 @@
+#!/bin/sh
+# plumbbob — PATH shim for the marketplace / plugin install. Claude Code adds this
+# bin/ dir to the Bash tool's PATH while the plugin is enabled (the plugins `bin/`
+# convention), so the driver skills can shell a bare `plumbbob` without a global
+# `npm i -g`. The CLI is resolved relative to this file, so it works from the
+# plugin's install/cache dir wherever that lands. Requires node >=22 on PATH (the
+# same requirement as the published `bin`/`dist/cli.js` shebang).
+here=$(CDPATH='' cd -- "$(dirname -- "$0")" && pwd)
+exec node "$here/../dist/cli.js" "$@"

package/dist/cli-core.js

@@ -2,6 +2,8 @@
 // entry (cli.ts) so the routing/help logic is unit-testable in-process without
 // the top-level process.exit. Zero runtime deps, node: builtins only (D1/C2).
 // Functional/procedural: no classes, no `this`, no default export (C1).
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
 import { start } from "./verbs/start.js";
 import { status } from "./verbs/status.js";
 import { park } from "./verbs/park.js";
@@ -36,6 +38,19 @@ export function formatHelp() {
     const rows = VERBS.map((v) => `  ${v.name.padEnd(width)}  ${v.summary}`);
     return ['plumbbob — attention-first build process', '', 'Usage: plumbbob <verb> [args]', '', 'Verbs:', ...rows, ''].join('\n');
 }
+// The package version, read from the package.json that ships one level above the
+// compiled CLI (dist/cli-core.js → ../package.json; in tests src/cli-core.ts →
+// ../package.json, the repo root). Builtins only (C2); an absent or malformed
+// manifest degrades to 'unknown' rather than throwing, so `--version` never errors.
+export function readVersion() {
+    try {
+        const raw = readFileSync(fileURLToPath(new URL('../package.json', import.meta.url)), 'utf8');
+        return JSON.parse(raw).version ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
 function dispatch(verb, cwd, rest) {
     switch (verb) {
         case 'start':
@@ -72,6 +87,10 @@ export function run(argv) {
         process.stdout.write(`${formatHelp()}\n`);
         return 0;
     }
+    if (verb === 'version' || verb === '--version' || verb === '-v') {
+        process.stdout.write(`plumbbob ${readVersion()}\n`);
+        return 0;
+    }
     try {
         return dispatch(verb, process.cwd(), rest);
     }

package/dist/lib/orient.js

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

package/dist/lib/plugins.js

@@ -0,0 +1,24 @@
+// Detect a marketplace-installed plumbbob plugin from Claude Code's plugin state.
+// Used to keep the skills-dir install (`plumbbob init`) from colliding with a
+// marketplace install: two plugins both named `plumbbob` fight over the
+// `/plumbbob:*` namespace and the skills can drop to flat names (`/pb-status`).
+// Read-only, node builtins only (C1/C2): a missing / unreadable / malformed file
+// means "none installed".
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+// Marketplace plugin ids for plumbbob recorded in installed_plugins.json
+// (e.g. "plumbbob@robmclarty"). Empty when none, or the file is absent/unreadable.
+// `plumbbob@<marketplace>` matches; `plumbbob-spike@x` and the like do not.
+export function marketplacePlumbbob(home) {
+    try {
+        const raw = readFileSync(join(home, '.claude', 'plugins', 'installed_plugins.json'), 'utf8');
+        const plugins = JSON.parse(raw).plugins;
+        if (plugins === undefined || plugins === null) {
+            return [];
+        }
+        return Object.keys(plugins).filter((id) => id === 'plumbbob' || id.startsWith('plumbbob@'));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/verbs/check.js

@@ -1,5 +1,5 @@
 // `plumbbob check` — run the heavy gate (D16/D24) and report, with NO state
-// change. The read-only half of the verify tick: `/plumbbob:verify` runs this before the
+// change. The read-only half of the verify tick: `/plumbbob:pb-verify` runs this before the
 // pause so the human approves on a known-green check. Exits with the check's own
 // code (0 = green).
 import { findRepoRoot } from "../lib/git.js";

package/dist/verbs/checkpoint.js

@@ -4,7 +4,7 @@
 // It gates on a green check, then commits any pending work (or records the existing
 // HEAD when the tree is already clean — the human's commit skill may have committed
 // first), records the SHA, flips the intent checkbox to `[x]`, clears any STEP/SEAM,
-// and returns to DESIGN. The diff's author is irrelevant: `/plumbbob:build`, your hands,
+// and returns to DESIGN. The diff's author is irrelevant: `/plumbbob:pb-build`, your hands,
 // a vibe session, or another harness all checkpoint the same way.
 import { appendFileSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { commit, findRepoRoot, headSha, isDirty, stageAll } from "../lib/git.js";

package/dist/verbs/doctor.js

@@ -4,12 +4,13 @@
 // in place as a plugin (skills `/plumbbob:*`, the post-edit hook from hooks.json).
 // doctor verifies the link resolves to a package carrying the manifest, the skills,
 // and the hook — and names the fix for anything missing. The failure class it
-// exists for is SILENT (a `/plumbbob:status` that opens an empty dashboard because the
+// exists for is SILENT (a `/plumbbob:pb-status` that opens an empty dashboard because the
 // plugin never linked). Functional, node builtins only (C1/C2).
 import { existsSync, lstatSync, readdirSync, readlinkSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { marketplacePlumbbob } from "../lib/plugins.js";
 // The plumbbob package's own skills/ dir (the canonical set), off this module's
 // URL so it resolves the same from src/ (dev) and dist/ (published).
 function packageDir(name) {
@@ -58,8 +59,25 @@ export function doctor() {
     const link = join(home, '.claude', 'skills', 'plumbbob');
     const shipped = listSkills(packageDir('skills'));
     const pkg = linkedPackage(link);
-    const checks = pkg === null ? [{ ok: false, label: `not linked — no plugin at ${link}`, fix: 'run: plumbbob init' }] : buildChecks(link, pkg, shipped);
-    const out = ['plumbbob doctor — global plugin install'];
+    const market = marketplacePlumbbob(home);
+    let checks;
+    if (pkg === null) {
+        checks =
+            market.length > 0
+                ? [{ ok: true, label: `installed via marketplace (${market.join(', ')}) — skills load as /plumbbob:*, the CLI is on PATH from the plugin bin/. No init needed.` }]
+                : [{ ok: false, label: `not linked — no plugin at ${link}`, fix: 'install the marketplace plugin (/plugin install plumbbob@<marketplace>) or run: plumbbob init' }];
+    }
+    else {
+        checks = buildChecks(link, pkg, shipped);
+        if (market.length > 0) {
+            checks.unshift({
+                ok: false,
+                label: `collision — also installed via marketplace (${market.join(', ')}); two plugins named plumbbob fight over /plumbbob:* and skills can drop to flat names`,
+                fix: 'keep one — `plumbbob init --uninstall` to use the marketplace plugin, or `/plugin uninstall` the marketplace one to keep this link',
+            });
+        }
+    }
+    const out = ['plumbbob doctor — plugin install'];
     for (const c of checks) {
         out.push(c.ok ? `  ✓ ${c.label}` : `  ✗ ${c.label}\n      → ${c.fix}`);
     }
@@ -68,7 +86,7 @@ export function doctor() {
     out.push(failed === 0
         ? 'plumbbob: all checks passed. If a skill still misbehaves, restart Claude Code (or /reload-plugins).'
         : `plumbbob: ${failed} problem(s) — apply the → fixes, then restart Claude Code.`);
-    out.push('plumbbob: skills shell a bare `plumbbob` — ensure it is on PATH (`npm i -g plumbbob`). Sessions are per-project via `plumbbob start`.');
+    out.push('plumbbob: skills shell a bare `plumbbob`. The marketplace plugin puts it on PATH via bin/; for the skills-dir/global install run `npm i -g plumbbob`. Sessions are per-project via `plumbbob start`.');
     process.stdout.write(`${out.join('\n')}\n`);
     return failed === 0 ? 0 : 1;
 }

package/dist/verbs/init.js

@@ -1,16 +1,24 @@
-// `plumbbob init [--uninstall]` — link plumbbob into Claude Code as an in-place
-// skills-directory plugin. This is the whole install: it symlinks the installed
-// package into ~/.claude/skills/plumbbob, where Claude Code discovers it as
-// `plumbbob@skills-dir` — the skills load namespaced (`/plumbbob:*`) and the
-// post-edit hook auto-registers from hooks/hooks.json. Global-only by design:
-// plumbbob is a personal tool (like firecrawl/gh), and install scope is NOT
-// session scope — sessions stay per-project via `plumbbob start`. Idempotent +
-// reversible (`--uninstall` drops the link); it NEVER writes settings.json.
-// Functional, node builtins only (C1/C2).
+// `plumbbob init [--uninstall] [--force]` — link plumbbob into Claude Code as an
+// in-place skills-directory plugin. It symlinks the installed package into
+// ~/.claude/skills/plumbbob, where Claude Code discovers it as `plumbbob@skills-dir`
+// — the skills load namespaced (`/plumbbob:*`) and the post-edit hook auto-registers
+// from hooks/hooks.json. This is the deliberate non-marketplace install path — kept
+// first-class, not deprecated: it serves an `npm i -g` global, local dev, and clients
+// predating plugins, and keeps plumbbob usable as a standalone CLI (and, later, under
+// other agents) rather than Claude-marketplace-only. The marketplace plugin is the
+// co-equal self-contained alternative (it ships skills AND the `plumbbob` CLI on PATH
+// via bin/, so it needs neither `npm i -g` nor `init`). The two are mutually
+// exclusive: both register a plugin named `plumbbob`, and a double-install collides
+// over the /plumbbob:* namespace (skills can drop to flat `/pb-status` names). So init
+// REFUSES when a marketplace plumbbob is already installed — `--force` overrides
+// (the dev-install path uses it). Global-only by design: install scope is NOT session
+// scope — sessions stay per-project via `plumbbob start`. Idempotent + reversible
+// (`--uninstall` drops the link); it NEVER writes settings.json. Node builtins only.
 import { lstatSync, mkdirSync, readlinkSync, rmSync, symlinkSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { marketplacePlumbbob } from "../lib/plugins.js";
 // The installed package root (parent of .claude-plugin/, skills/, hooks/, dist/),
 // off this module's URL — the global install when run as the published bin, the
 // checkout in dev. No trailing slash, so it compares clean against a readlink.
@@ -47,6 +55,14 @@ export function init(args) {
     if (args.includes('--uninstall')) {
         return uninstall(link);
     }
+    const market = marketplacePlumbbob(home);
+    if (market.length > 0 && !args.includes('--force')) {
+        process.stderr.write(`plumbbob: a marketplace plumbbob plugin is already installed (${market.join(', ')}).\n` +
+            'plumbbob: it already provides the skills (`/plumbbob:*`) and the `plumbbob` CLI on PATH (the plugin bin/) — no `plumbbob init` needed.\n' +
+            `plumbbob: linking ${link} would register a SECOND plugin named \`plumbbob\`; the two collide over the /plumbbob:* namespace and skills can drop to flat names (\`/pb-status\`).\n` +
+            'plumbbob: to use the skills-dir link instead, first remove the marketplace one (`/plugin uninstall plumbbob@<marketplace>`), or re-run with `--force` if you know what you are doing.\n');
+        return 1;
+    }
     mkdirSync(join(home, '.claude', 'skills'), { recursive: true });
     if (present(link)) {
         const current = symlinkTarget(link);

package/dist/verbs/park.js

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

package/dist/verbs/wrap.js

@@ -1,6 +1,6 @@
 // `plumbbob wrap` (D9) — the v2 close-out, replacing the v1 four-verb
 // finish ceremony. It archives intent + build-log + report
-// (the `/plumbbob:wrap` skill writes the report by default) under .plumbbob/archive/,
+// (the `/plumbbob:pb-wrap` skill writes the report by default) under .plumbbob/archive/,
 // clears the active files, and deletes the control state (STATE last). Unlike v1
 // `finish` there is NO refuse-without-report gate — guidance offers the artifact, it
 // does not wall the exit. Archive-then-clear, never destroy (C4); git untouched (C5).
@@ -20,7 +20,7 @@ export function wrap(cwd) {
     }
     else {
         process.stderr.write('plumbbob: note — no report.md found; archiving intent + build-log without one ' +
-            '(/plumbbob:wrap normally writes the report first). No gate (D9).\n');
+            '(/plumbbob:pb-wrap normally writes the report first). No gate (D9).\n');
     }
     const archived = archiveSession(root);
     // Clear the active files — now safely archived — then the control state, STATE
@@ -32,7 +32,7 @@ export function wrap(cwd) {
     rmSync(stepPath(root), { force: true });
     rmSync(join(sidecarDir(root), 'STATE'), { force: true });
     process.stdout.write(`plumbbob: wrap — archived to ${relative(root, archived)}. Sidecar cleared. ` +
-        'Run `/plumbbob:plan` (or `plumbbob start "<title>"`) to frame the next goal.\n');
+        'Run `/plumbbob:pb-plan` (or `plumbbob start "<title>"`) to frame the next goal.\n');
     return 0;
 }
 // Append the recorded checkpoints (baseline + each `step n <sha>`) to the report so

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plumbbob",
-  "version": "0.4.4",
+  "version": "0.4.8",
   "description": "Attention-first build process: 11 skills + a CLI that keep you the decider — guidance, not enforcement.",
   "keywords": [
     "claude-code",
@@ -25,6 +25,7 @@
   },
   "files": [
     ".claude-plugin",
+    "bin",
     "dist",
     "hooks",
     "skills",

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

@@ -1,5 +1,5 @@
 ---
-name: build
+name: pb-build
 description: The optional engine — read the next planned step from intent, implement it (its done-when, seam, Decisions, Constraints), then verify it through to the approval pause. Skip it to build by hand/vibed/another harness. `--auto` self-approves and chains to done.
 disable-model-invocation: true
 model: opus
@@ -12,31 +12,31 @@ Current session state (injected when this skill runs): !`plumbbob status 2>/dev/
 
 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 `/plumbbob:verify` instead — plumbbob does not care how
+another harness and go straight to `/plumbbob: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.
 
-Since `/plumbbob:plan` lays down the whole step list up front, the happy path is to fire
-`/plumbbob:build` once per step until done — each run builds the next undone step and stops
-at the pause for your approval. **Re-firing `/plumbbob:build` is itself the clock tick.**
+Since `/plumbbob:pb-plan` lays down the whole step list up front, the happy path is to fire
+`/plumbbob:pb-build` once per step until done — each run builds the next undone step and stops
+at the pause for your approval. **Re-firing `/plumbbob:pb-build` is itself the clock tick.**
 
 ## What this skill does, in order
 
-1. **Pick the step.** Use the number you were invoked with (e.g. `/plumbbob:build 4`), else
+1. **Pick the step.** Use the number you were invoked with (e.g. `/plumbbob: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 `/plumbbob:step` first.
+   to build, stop and tell the human to `/plumbbob:pb-step` first.
 2. **Enter the step.** Run `plumbbob build <n>` (records the in-flight STEP +
-   SEAM so `/plumbbob:status` shows the step in flight; in v2 the seam is awareness, not a
+   SEAM so `/plumbbob: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 `/plumbbob:park`, **not** an
+   new problem or "ooh what if" that surfaces mid-build is a `/plumbbob: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 `/plumbbob:verify`
+5. **Verify, through to the pause.** Run the verify tick exactly as `/plumbbob:pb-verify`
    does: `plumbbob 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
@@ -45,7 +45,7 @@ at the pause for your approval. **Re-firing `/plumbbob:build` is itself the cloc
 
 ## `--auto` — let the agent be the clock (opt-in)
 
-`/plumbbob:build --auto` is the explicit escape hatch when the human wants unattended
+`/plumbbob:pb-build --auto` is the explicit escape hatch when the human wants unattended
 progress instead of approving each step. It does the same work, but **the agent reviews
 and approves in the human's place**, and it **chains**:
 
@@ -61,10 +61,10 @@ human asked for it by name. The default — no flag — always ends at the pause
 
 ## The hard contracts
 
-- **Optional, never required.** The loop works without this skill; `/plumbbob:verify`
+- **Optional, never required.** The loop works without this skill; `/plumbbob: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 `/plumbbob:park`, not an edit.
+  new idea mid-build is a `/plumbbob:pb-park`, not an edit.
 - **Default ends at the pause.** Implement → verify → wait for approval; never
   checkpoint without it. Only an explicit `--auto` lets the agent approve in your place,
   and it still halts on a red check or any mismatch.

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

@@ -1,5 +1,5 @@
 ---
-name: harvest
+name: pb-harvest
 description: Triage the park list at a step boundary — propose one class (blocker/tangent/pivot) per parked item, write only after the human confirms each, record under ## Harvest, and fold a confirmed blocker into intent.
 disable-model-invocation: true
 model: opus
@@ -10,7 +10,7 @@ allowed-tools: Read, Edit, Bash(plumbbob 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"`
 
-`/plumbbob:harvest` is the complement of `/plumbbob:park` (D7): you parked ideas as seeds during a
+`/plumbbob:pb-harvest` is the complement of `/plumbbob:pb-park` (D7): you parked ideas as seeds during a
 build; now, at a boundary, you harvest them — decide what each one is.
 
 ## When to run it — wrong-state refusal
@@ -19,7 +19,7 @@ Harvest at a **step boundary**: after a step is checkpointed and you are back in
 DESIGN, not mid-step. Read the state injected above:
 
 - `NO ACTIVE SESSION` — **refuse**; tell the human to `plumbbob start "<title>"` first.
-- `BUILD` — a step is in flight; **refuse** and suggest finishing it with `/plumbbob:verify`
+- `BUILD` — a step is in flight; **refuse** and suggest finishing it with `/plumbbob:pb-verify`
   before harvesting. Chasing parked items mid-step is the disease parking prevents.
 - `DESIGN` (and other settled states) — go ahead.
 
@@ -40,7 +40,7 @@ one line of reasoning, then **wait for the human to confirm or override**. Write
 **only after** per-item confirmation:
 
 - Record each confirmed class in `build-log.md`'s `## Harvest` section.
-- **Flip the harvested item** from `- [ ]` to `- [x]` in the Park list, so `/plumbbob:status`
+- **Flip the harvested item** from `- [ ]` to `- [x]` in the Park list, so `/plumbbob:pb-status`
   stops counting it as open.
 - A confirmed **blocker** also folds its decision into `intent.md`.
 - Never reclassify or resolve an item the human hasn't confirmed, and default every

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

@@ -1,5 +1,5 @@
 ---
-name: park
+name: pb-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. The capture half of the park/harvest loop.
 disable-model-invocation: true
 model: haiku
@@ -10,7 +10,7 @@ allowed-tools: Bash(plumbbob status:*), Bash(plumbbob park:*)
 
 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:park` is the **capture** half of the loop; `/plumbbob:harvest` is where parked items
+`/plumbbob:pb-park` is the **capture** half of the loop; `/plumbbob:pb-harvest` is where parked items
 get triaged later (D7). Capturing the instant an idea arrives — instead of acting on
 it — is the whole point: it protects the step in flight.
 

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

@@ -1,5 +1,5 @@
 ---
-name: plan
+name: pb-plan
 description: "Frame a fresh goal and author the whole plan — Frame, Decisions, Constraints, and all Steps — before any code. Three input modes: no arg interviews you; a file path absorbs a spec; any other text expands your inline intent."
 disable-model-invocation: true
 model: opus
@@ -10,10 +10,10 @@ allowed-tools: Read, Edit, Write, Bash(plumbbob status:*), Bash(plumbbob start:*
 
 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` is the **whole-goal** move — it opens a session and gets the deciding out
+`/plumbbob: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. By default it authors the
 **complete plan, including all the Steps**, so the happy path afterward is just
-`/plumbbob:build` until done. (Revising a single increment later is the separate `/plumbbob:step`
+`/plumbbob:pb-build` until done. (Revising a single increment later is the separate `/plumbbob:pb-step`
 move; do not confuse the two.)
 
 ## Three input modes (disambiguated for you — no quotes needed)
@@ -33,7 +33,7 @@ Look at the argument the human gave and pick the mode yourself:
    genuinely ambiguous.
 
 All three modes converge on the **same artifact**: a complete, standalone `intent.md`
-an agent can follow with `/plumbbob:build`. The argument only seeds how you get there.
+an agent can follow with `/plumbbob:pb-build`. The argument only seeds how you get there.
 
 ## What this skill does
 
@@ -55,11 +55,11 @@ an agent can follow with `/plumbbob:build`. The argument only seeds how you get
       - seam: `<file>`, `<file>`
    ```
 
-   Every step needs a **done-when** `/plumbbob:verify` can check and a **seam** (the exact
+   Every step needs a **done-when** `/plumbbob:pb-verify` can check and a **seam** (the exact
    paths it touches). Later steps may be fuzzier than the first — that's fine; they get
-   sharpened just-in-time when you reach them with `/plumbbob:step`. Keep each small enough to
+   sharpened just-in-time when you reach them with `/plumbbob:pb-step`. Keep each small enough to
    verify in one review pass.
-5. **Offer to stress-test it.** Suggest `/plumbbob:refine` to attack the frame for holes (or
+5. **Offer to stress-test it.** Suggest `/plumbbob:pb-refine` to attack the frame for holes (or
    to repair the plan as it drifts). Optional, the human's call.
 
 ## The interview (mode 1)
@@ -72,11 +72,11 @@ Make it easy and non-intrusive:
   without typing** ("done-when: the 6th request in 60s returns 429 — good?"), while
   taking arbitrary detail when they want to give it, including pointers to other files.
 - **Let them double back.** They will revise as the picture sharpens; that's expected.
-  They can also edit `intent.md` by hand at any time, or call `/plumbbob:refine` to repair it.
+  They can also edit `intent.md` by hand at any time, or call `/plumbbob:pb-refine` to repair it.
 
 ## The hard contracts
 
-- **Deciding before code.** `/plumbbob:plan` writes `intent.md` only — never source.
+- **Deciding before code.** `/plumbbob: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.
 - **Stands on its own.** Whatever the input mode, the finished `intent.md` carries

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

@@ -1,5 +1,5 @@
 ---
-name: refine
+name: pb-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
@@ -10,16 +10,16 @@ allowed-tools: Read, Edit, Bash(plumbbob 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"`
 
-`/plumbbob:refine` keeps `intent.md` honest. Use it at **any point** — right after `/plumbbob:plan`
+`/plumbbob:pb-refine` keeps `intent.md` honest. Use it at **any point** — right after `/plumbbob:pb-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.
+code is actually doing. It is the document-level complement to `/plumbbob:pb-step` (which only
+sharpens the *next* step): `/plumbbob:pb-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
+`plumbbob start "<title>"` (or `/plumbbob:pb-plan`) first, and edit nothing. Every active state
 is fine — refining is always available.
 
 ## Two modes
@@ -41,5 +41,5 @@ is fine — refining is always available.
   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.
+- **Refine the plan, not the code.** `/plumbbob:pb-refine` touches `intent.md` only — turning a
+  decision into a diff is `/plumbbob:pb-build` or your own hands, never this skill.

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

@@ -1,5 +1,5 @@
 ---
-name: revert
+name: pb-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
@@ -14,6 +14,6 @@ This is a **driver skill** — a chat-side trigger for the mechanical `plumbbob
 
 ## What it does
 
-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.
+1. Read an optional target step from the way you were invoked (e.g. `/plumbbob:pb-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/{spike → pb-spike}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: spike
+name: pb-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
@@ -14,6 +14,6 @@ This is a **driver skill** — a chat-side trigger for the mechanical `plumbbob
 
 ## What it does
 
-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.
+1. Read the spike target from the way you were invoked: a slug to open one (e.g. `/plumbbob:pb-spike redis-cache`), or the literal `done` to tear the current spike down (`/plumbbob:pb-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/{status → pb-status}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: status
+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
@@ -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 `/plumbbob:plan` to frame a goal.
+2. If it reads `NO ACTIVE SESSION`, tell the human to `/plumbbob:pb-plan` to frame a goal.

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

@@ -1,5 +1,5 @@
 ---
-name: step
+name: pb-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
@@ -10,21 +10,21 @@ allowed-tools: Read, Edit, Bash(plumbbob 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"`
 
-`/plumbbob:plan` authors the **whole** step list up front, so `/plumbbob:step` is the
+`/plumbbob:pb-plan` authors the **whole** step list up front, so `/plumbbob:pb-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
+build has actually taught you, right before you `/plumbbob:pb-build` it. (Framing the whole goal
+is the separate `/plumbbob:pb-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
+- **`/plumbbob:pb-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
+- **`/plumbbob:pb-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.
 
@@ -33,7 +33,7 @@ grew — but its everyday job is to sharpen, not to invent.
 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
+   `/plumbbob:pb-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 —
@@ -42,7 +42,7 @@ grew — but its everyday job is to sharpen, not to invent.
 
 ## The hard contracts
 
-- **One verifiable increment.** Each step carries a done-when `/plumbbob:verify` can check
+- **One verifiable increment.** Each step carries a done-when `/plumbbob:pb-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.

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

@@ -1,5 +1,5 @@
 ---
-name: verify
+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
@@ -11,7 +11,7 @@ allowed-tools: Read, Bash(plumbbob status:*), Bash(plumbbob check:*), Bash(plumb
 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 — `/plumbbob:build`, your own hands, a vibe session, another harness —
+the current diff — `/plumbbob: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
@@ -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 `/plumbbob:build`, by hand, vibed, or by another harness.
+  built by `/plumbbob: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

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

@@ -1,5 +1,5 @@
 ---
-name: wrap
+name: pb-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
@@ -10,7 +10,7 @@ allowed-tools: Read, Write, Bash(plumbbob status:*), Bash(plumbbob wrap:*)
 
 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:wrap` ends the build: it captures what happened, archives it, and clears the
+`/plumbbob:pb-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.
 
@@ -27,7 +27,7 @@ and no separate docs phase.
    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** — `/plumbbob:plan` to frame the next one.
+3. **Point at the next goal** — `/plumbbob:pb-plan` to frame the next one.
 
 ## The hard contracts
 

package/templates/build-log.md

@@ -5,7 +5,7 @@ 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.
   Harvest   : the boundary ritual that keeps you on one branch.
-  Log       : the audit trail. Feeds the /plumbbob:wrap report, then gets archived.
+  Log       : the audit trail. Feeds the /plumbbob:pb-wrap report, then gets archived.
 -->
 
 # Build log — {{TITLE}}
@@ -16,8 +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 a checkpoint — check green + checkpoint taken, via `/plumbbob:verify` or
-`/plumbbob:build`.)*
+is done only after a checkpoint — check green + checkpoint taken, via `/plumbbob:pb-verify` or
+`/plumbbob:pb-build`.)*
 
 - ☐ 1. <step>
 
@@ -25,16 +25,16 @@ is done only after a checkpoint — check green + checkpoint taken, via `/plumbb
 
 > 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 (`/plumbbob:park` composes it). Harvest happens only at the boundary.
+> Capture is one line (`/plumbbob:pb-park` composes it). Harvest happens only at the boundary.
 
-## Harvest  *(run `/plumbbob:harvest` at each step boundary, after green)*
+## Harvest  *(run `/plumbbob:pb-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  | `/plumbbob:revert`, fold into intent  |
+| **blocker**      | Plan was wrong/incomplete; can't proceed  | `/plumbbob:pb-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.      |
 
@@ -48,7 +48,7 @@ Harvest results this boundary:
 ## 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:wrap` reads this for the
+did that — the LLM helped, but those were my calls." `/plumbbob:pb-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,24 +33,24 @@ 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 `/plumbbob:refine` surfaces, and as blockers fold in during BUILD.)*
+holes `/plumbbob:pb-refine` surfaces, and as blockers fold in during BUILD.)*
 
 - D1: <decision> — *because* <the one reason that mattered>
 
 ## Constraints
 
-*(Hard rules the build must honor. `/plumbbob:verify` and `/plumbbob:refine` read against these.)*
+*(Hard rules the build must honor. `/plumbbob:pb-verify` and `/plumbbob:pb-refine` read against these.)*
 
 - C1: <e.g. functional/procedural only; no new dependencies>
 
 ## Steps
 
-*(The build plan. `/plumbbob:plan` authors the **whole list up front** — each step a small,
+*(The build plan. `/plumbbob:pb-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.)*
+which `/plumbbob:pb-build` records in `.plumbbob/SEAM` for orientation — awareness, not a lock
+in v2). Then drive `/plumbbob:pb-build` until done. Later steps may be fuzzier than the first;
+sharpen the next one just-in-time with `/plumbbob:pb-step` (empty input auto-syncs it), and use
+`/plumbbob:pb-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>`