@iceinvein/agent-skills 0.23.1 → 0.23.3

package/README.md

@@ -22,14 +22,30 @@ bunx @iceinvein/agent-skills install                         # no args: opens pi
 
 Auto-detects Claude Code, Cursor, Codex, or Gemini CLI. Use `--tool claude` to target one, `-g` to install globally.
 
+### Claude Code plugin
+
+Each skill is also a plugin in the `iceinvein-skills` marketplace:
+
+```
+/plugin marketplace add iceinvein/agent-skills
+/plugin install <skill>@iceinvein-skills
+```
+
+- Plugin skills are namespaced: invoke them as `/<skill>:<skill>` (e.g. `/sluice:sluice`).
+- Third-party marketplaces do not auto-update by default. Update from `/plugin`.
+- Activation modes do not apply: sluice's hooks always run while the plugin is enabled, and terse is never auto-activated.
+- Do not install sluice through both routes, or its hooks run twice. Its statusline segment is bunx-only.
+- magpie, migrate and scope-estimate need Bun on PATH.
+- improve-my-codebase's plugin carries every audit, so under the plugin route its audits do not need installing separately.
+
 ## Skills
 
 ### Migration
 
 | Skill | What it does |
 |-------|--------------|
-| **migrate** | Walks a legacy codebase through probe, enumerate, seam, extract, parity, queue, adjudicate and handoff: measured surface coverage, an empirically derived capability seam, cited requirements, a parity plan, a batch decision queue, and work items emitted to markdown, GitHub or a flow target with coverage and forecast read back. Bundles a Bun CLI that enforces the coverage arithmetic and phase ordering instead of trusting it. |
-| **scope-estimate** | The lighter path for a proposal: read-only discovery, a capability register with status and disposition, sized functional requirements, contracts-first work packages, and a build schedule across engineers x worktrees at fast, planning and floor rates. Bundles a Bun scheduler that refuses a plan missing or double-counting a requirement, so every figure comes from one reproducible run. |
+| **migrate** | Walks a legacy codebase through probe, enumerate, seam, extract, parity, queue, adjudicate and handoff: measured surface coverage, an empirically derived capability seam, cited requirements, a parity plan, a batch decision queue, and work items emitted to markdown, GitHub or a flow target with coverage and forecast read back. Bundles a Bun CLI that enforces the coverage arithmetic and phase ordering instead of trusting it. Claude Code only. |
+| **scope-estimate** | The lighter path for a proposal: read-only discovery, a capability register with status and disposition, sized functional requirements, contracts-first work packages, and a build schedule across engineers x worktrees at fast, planning and floor rates. Bundles a Bun scheduler that refuses a plan missing or double-counting a requirement, so every figure comes from one reproducible run. Claude Code only. |
 
 ### Code Architecture
 
@@ -84,7 +100,7 @@ Skills that check code does what it was meant to do, with evidence rather than o
 
 | Skill | Based on | What it does |
 |-------|----------|--------------|
-| **bug-hunter** | QA scenario testing; intent-first reproduction | Proves logic bugs with failing repros checked against stated intent. Writes scenarios before reading the code, and reports bugs, ambiguities, and covered scenarios. |
+| **bug-hunter** | QA scenario testing; intent-first reproduction | Proves logic bugs with failing repros checked against stated intent. Writes scenarios before reading the code, and reports bugs, ambiguities, and covered scenarios. Claude Code only. |
 
 ### Communication
 
@@ -112,7 +128,7 @@ Skills that shape how work gets done rather than analyzing code.
 
 | Skill | What it does |
 |-------|--------------|
-| **sluice** | Routes work by change shape into four channels (`bypass`, `fast`, `main`, `deep`) and applies only the rules each channel needs, so a one-line fix does not pay the cost of a multi-subsystem build. Seven rules live as one-liners in the router; the full treatment sits in references read only on friction. Each run closes with a ledger read out of the session transcript: elapsed, tools, tokens, and what every dispatched agent cost. Claude Code only. Conflicts with the superpowers plugin, which requires its own fixed pipeline up front for anything that adds to or changes what the software does, not just code edits; disable superpowers before installing. |
+| **sluice** | Routes work by change shape into four channels (`bypass`, `fast`, `main`, `deep`) and applies only the rules each channel needs, so a one-line fix does not pay the cost of a multi-subsystem build. Eight rules live as one-liners in the router; the full treatment sits in references read only on friction. Each run closes with a ledger read out of the session transcript: elapsed, tools, tokens, and what every dispatched agent cost. Claude Code only. Conflicts with the superpowers plugin, which requires its own fixed pipeline up front for anything that adds to or changes what the software does, not just code edits; disable superpowers before installing. |
 
 ### Orchestration
 
@@ -121,7 +137,7 @@ Skills that compose the other audit skills into higher-level workflows.
 | Skill | What it does |
 |-------|--------------|
 | **improve-my-codebase** | Runs every applicable audit skill in parallel against your codebase, ranks findings by convergence (multiple audits agreeing) and per-file rollup, and writes a prioritized improvement report. Default sweeps everything; positional args switch modes (`quick`, `diff`, `interactive`) or narrow scope (`focus <area>`, `module <path>`). |
-| **magpie** | Interactive PR review pipeline. Runs five parallel specialist subagents (security, bugs, performance, code-smells, architecture), dedupes findings, applies a critic rubric, peer-reviews via `codex exec`, and serves an interactive HTML report for selecting findings to post via `gh`. A local mode reviews the current branch diff before a PR exists and hands the findings back in the terminal. |
+| **magpie** | Interactive PR review pipeline. Runs five parallel specialist subagents (security, bugs, performance, code-smells, architecture), dedupes findings, applies a critic rubric, peer-reviews via `codex exec`, and serves an interactive HTML report for selecting findings to post via `gh`. A local mode reviews the current branch diff before a PR exists and hands the findings back in the terminal. Claude Code only. |
 
 ## Commands
 
@@ -158,7 +174,7 @@ bunx @iceinvein/agent-skills list               # show installed versions
 After any command other than `update`, the CLI runs a background freshness check (at most once every 24 hours) and prints a one-line notice if anything is out of date:
 
 ```
-some-skill (v0.2.0 → v0.3.0)
+⚠ Updates available: some-skill (v0.2.0 → v0.3.0)
   Run: agent-skills update --all
 ```
 
@@ -179,12 +195,7 @@ If a skill declares activation support and you're installing for Claude Code int
 
 ## Supported Tools
 
-| Tool | Prompt Skills | MCP Skills |
-|------|:---:|:---:|
-| Claude Code | Yes | Yes |
-| Cursor | Yes | Yes |
-| Codex | Yes | – |
-| Gemini CLI | Yes | Yes |
+Claude Code, Cursor, Codex and Gemini CLI. Most skills install into all four; bug-hunter, magpie, migrate, scope-estimate and sluice are Claude Code only, and the CLI skips the other tools for them.
 
 ## How It Works
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iceinvein/agent-skills",
-  "version": "0.23.1",
+  "version": "0.23.3",
   "description": "Install agent skills into AI coding tools",
   "author": "iceinvein",
   "license": "MIT",

package/skills/improve-my-codebase/skill.json

@@ -1,9 +1,12 @@
 {
   "name": "improve-my-codebase",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Orchestrator skill that runs every applicable audit skill in parallel and produces a prioritized, convergence-ranked improvement report",
   "author": "iceinvein",
   "type": "prompt",
+  "plugin": {
+    "bundleSiblings": true
+  },
   "tools": [
     "claude",
     "cursor",

package/skills/index.json

@@ -211,7 +211,7 @@
     "name": "improve-my-codebase",
     "description": "Orchestrator skill that runs every applicable audit skill in parallel and produces a prioritized, convergence-ranked improvement report",
     "type": "prompt",
-    "version": "1.1.0"
+    "version": "1.1.1"
   },
   {
     "name": "integration-pattern-auditor",
@@ -225,15 +225,15 @@
   },
   {
     "name": "magpie",
-    "description": "Interactive PR review pipeline. Runs five parallel specialist subagents (security, bugs, performance, code-smells, architecture) plus a once-per-PR checks pass that finds tests and controls able to pass without proving their purpose, drops findings whose quoted evidence is not in the code, dedupes, runs critic subagents that re-check each finding against the worktree and set its risk label, peer-reviews via codex exec (falling back to a Claude second opinion when codex is unavailable), and serves an interactive HTML report for selecting or dismissing findings to post via gh, recording the outcome per finding as labels. Bundles a Bun CLI installed onto PATH via the skill's postinstall step. Use when the user asks to review a GitHub pull request. Local mode (setup --local) runs the same pipeline on the current branch's diff from its merge base, uncommitted and untracked work included, against the caller's live tree, with no server or posting, and hands the ranked findings back in the terminal for an implementing or orchestrating agent to address. Splits oversized diffs into budgeted shards and rebuilds the diff from the local clone when gh pr diff refuses it.",
+    "description": "Interactive PR review pipeline. Runs five parallel specialist subagents (security, bugs, performance, code-smells, architecture) plus a once-per-PR checks pass that finds tests and controls able to pass without proving their purpose, drops findings whose quoted evidence is not in the code, dedupes, runs critic subagents that re-check each finding against the worktree and set its risk label, peer-reviews via codex exec (falling back to a Claude second opinion when codex is unavailable), and serves an interactive HTML report for selecting or dismissing findings to post via gh, recording the outcome per finding as labels. Bundles a Bun CLI put on PATH by the skill's postinstall step under a bunx install, or by the plugin's bin/ under a Claude Code plugin install. Use when the user asks to review a GitHub pull request. Local mode (setup --local) runs the same pipeline on the current branch's diff from its merge base, uncommitted and untracked work included, against the caller's live tree, with no server or posting, and hands the ranked findings back in the terminal for an implementing or orchestrating agent to address. Splits oversized diffs into budgeted shards and rebuilds the diff from the local clone when gh pr diff refuses it.",
     "type": "prompt",
-    "version": "0.14.1"
+    "version": "0.14.5"
   },
   {
     "name": "migrate",
     "description": "Source-agnostic legacy migration mapping. Walks a legacy codebase through probe, enumerate, seam, extract, parity, queue, adjudicate and handoff, building an auditable requirements ledger with mandatory citations and a `migrate check` gate in place of self-reported completeness. Use when the user asks to migrate, re-specify, replatform, or map a legacy system onto a new stack, to hand mapped requirements to a delivery team, or to resume, check, report, or forecast a mapping run already under way.",
     "type": "prompt",
-    "version": "0.4.1"
+    "version": "0.4.3"
   },
   {
     "name": "module-secret-auditor",
@@ -269,7 +269,7 @@
     "name": "scope-estimate",
     "description": "Scopes and estimates a rebuild or respec of an existing system for a proposal: read-only discovery agents write cited inventories, a capability register gives every capability a status and a proposed disposition, area agents turn it into sized functional requirements, and a bundled Bun scheduler groups them into slices and contracts-first work packages and schedules them across engineers x worktrees at fast, planning and floor rates. The scheduler refuses a plan that misses or double-counts a requirement or has a dependency cycle, so every figure in the docs comes from one reproducible run. Also covers current and target architecture pages, proposal review, and a two-week calibration before committing to a date. Lighter than migrate: no store and no phase gates.",
     "type": "prompt",
-    "version": "0.1.1"
+    "version": "0.1.3"
   },
   {
     "name": "seam-finder",
@@ -295,7 +295,7 @@
     "name": "sluice",
     "description": "Routes work by change shape into four channels (bypass, fast, main, deep) and applies only the rules each channel needs, so a one-line fix does not pay the cost of a multi-subsystem build. Carries nine rules as one-liners in the router and the full treatment in references read only on friction. Checks the finished plan with plan.sh validate rather than trusting it to memory, seeds the run state from it, keeps a deep run's task breakdown in .sluice/run.json so a statusline segment, one status command and a SessionStart hook can answer where the run is (the hook prints a live run at every session start, compaction included), and closes each run with a ledger read out of the session transcript: elapsed, tools, tokens, and what each dispatched agent cost where the transcript recorded it. Two Stop hooks hold a handback: one refuses a tree that moved since its last recorded check, the other refuses a changed existing test not proven to fail on the session's starting code (or recorded with a reason). Claude Code only; stands down where the superpowers pipeline governs the repo.",
     "type": "prompt",
-    "version": "0.25.1"
+    "version": "0.25.3"
   },
   {
     "name": "temporal-coupling-detector",

package/skills/magpie/README.md

@@ -19,7 +19,15 @@ Given a GitHub PR number, dispatches five specialist subagents in parallel (secu
 bunx @iceinvein/agent-skills install magpie -g
 ```
 
-This skill ships in two parts: the prompt (SKILL.md) and a companion Bun CLI (bin + scripts). The agent-skills installer writes both into `~/.claude/skills/magpie/` and then runs the bundled `install.sh` as a postinstall step, which symlinks `bin/magpie` onto your PATH (preferring `/usr/local/bin`, falling back to `~/.local/bin`). Removing the skill with `agent-skills remove magpie -g` runs `uninstall.sh` first to undo the PATH symlink.
+As a Claude Code plugin, after `/plugin marketplace add iceinvein/agent-skills`:
+
+```
+/plugin install magpie@iceinvein-skills
+```
+
+This skill ships in two parts: the prompt (SKILL.md) and a companion Bun CLI (bin + scripts). The agent-skills installer writes both into `~/.claude/skills/magpie/` and then runs the bundled `install.sh` as a postinstall step, which symlinks `bin/magpie` onto your PATH (preferring `/usr/local/bin`, falling back to `~/.local/bin`). Set `MAGPIE_BIN_DIR` to link into that directory instead; it is created if missing, and install.sh fails rather than falling back when it cannot link there. Removing the skill with `agent-skills remove magpie -g` runs `uninstall.sh` first to undo the PATH symlink.
+
+Under a Claude Code plugin install, the plugin's `bin/` puts `magpie` on your PATH, and `bin/magpie` installs its runtime dependencies on first run (Bun required). `install.sh` and `MAGPIE_BIN_DIR` apply only to the bunx install.
 
 If you cloned this repo and want to run from source, you can also invoke `./install.sh` directly: it does the PATH-link step against the local source tree.
 

package/skills/magpie/bin/magpie

@@ -12,4 +12,21 @@ while [ -L "$SCRIPT" ]; do
   fi
 done
 DIR="$(cd -P "$(dirname "$SCRIPT")" && pwd)"
+ROOT="$(dirname "$DIR")"
+
+# A plugin install puts bin/ on PATH without running install.sh, so the
+# first run has to fetch runtime dependencies itself. Progress goes to stderr
+# because callers parse magpie's stdout. The gate is a marker written after
+# success, not node_modules itself, because a failed or killed install leaves
+# node_modules behind and the next run would skip straight to a crash.
+MARKER="$ROOT/node_modules/.magpie-deps-installed"
+if [ -f "$ROOT/package.json" ] && [ ! -f "$MARKER" ]; then
+  echo "Installing magpie runtime dependencies..." >&2
+  (cd "$ROOT" && bun install --production --silent) >&2 || {
+    echo "magpie: bun install failed in $ROOT" >&2
+    exit 1
+  }
+  touch "$MARKER"
+fi
+
 exec bun "$DIR/magpie.ts" "$@"

package/skills/magpie/install.sh

@@ -18,14 +18,18 @@ chmod +x "$BIN_SOURCE" || true
 
 # Magpie has runtime dependencies (shiki, etc.) declared in package.json.
 # node_modules is not shipped via npm, so we populate it here. Use bun if
-# available; fall back to a clear error otherwise.
-if [ -f "$SOURCE_DIR/package.json" ] && [ ! -d "$SOURCE_DIR/node_modules" ]; then
+# available; fall back to a clear error otherwise. The gate and marker match
+# bin/magpie's first-run install, so the wrapper does not install again, and a
+# failed install here leaves no marker and is retried on the next run.
+MARKER="$SOURCE_DIR/node_modules/.magpie-deps-installed"
+if [ -f "$SOURCE_DIR/package.json" ] && [ ! -f "$MARKER" ]; then
   if command -v bun >/dev/null 2>&1; then
     echo "Installing magpie runtime dependencies..."
     (cd "$SOURCE_DIR" && bun install --production --silent) || {
       echo "magpie postinstall: bun install failed in $SOURCE_DIR" >&2
       exit 1
     }
+    touch "$MARKER"
   else
     echo "magpie postinstall: bun not found on PATH; install Bun (https://bun.sh) and rerun this script." >&2
     exit 1
@@ -56,7 +60,21 @@ install_link() {
 echo "Installing magpie CLI on PATH:"
 
 CLI_INSTALL_DIR=""
-if install_link "/usr/local/bin"; then
+# An explicit MAGPIE_BIN_DIR is the only place the caller wants the link, so a
+# failure there is an error rather than a cue to try the default locations.
+if [ -n "${MAGPIE_BIN_DIR:-}" ]; then
+  # The recorded path is read by uninstall.sh from any cwd, so it must be absolute.
+  case "$MAGPIE_BIN_DIR" in
+    /*) ;;
+    *) MAGPIE_BIN_DIR="$PWD/$MAGPIE_BIN_DIR" ;;
+  esac
+  if install_link "$MAGPIE_BIN_DIR"; then
+    CLI_INSTALL_DIR="$MAGPIE_BIN_DIR"
+  else
+    echo "magpie postinstall: could not link magpie into MAGPIE_BIN_DIR ($MAGPIE_BIN_DIR)" >&2
+    exit 1
+  fi
+elif install_link "/usr/local/bin"; then
   CLI_INSTALL_DIR="/usr/local/bin"
 elif install_link "$HOME/.local/bin"; then
   CLI_INSTALL_DIR="$HOME/.local/bin"

package/skills/magpie/skill.json

@@ -1,7 +1,7 @@
 {
   "name": "magpie",
-  "version": "0.14.1",
-  "description": "Interactive PR review pipeline. Runs five parallel specialist subagents (security, bugs, performance, code-smells, architecture) plus a once-per-PR checks pass that finds tests and controls able to pass without proving their purpose, drops findings whose quoted evidence is not in the code, dedupes, runs critic subagents that re-check each finding against the worktree and set its risk label, peer-reviews via codex exec (falling back to a Claude second opinion when codex is unavailable), and serves an interactive HTML report for selecting or dismissing findings to post via gh, recording the outcome per finding as labels. Bundles a Bun CLI installed onto PATH via the skill's postinstall step. Use when the user asks to review a GitHub pull request. Local mode (setup --local) runs the same pipeline on the current branch's diff from its merge base, uncommitted and untracked work included, against the caller's live tree, with no server or posting, and hands the ranked findings back in the terminal for an implementing or orchestrating agent to address. Splits oversized diffs into budgeted shards and rebuilds the diff from the local clone when gh pr diff refuses it.",
+  "version": "0.14.5",
+  "description": "Interactive PR review pipeline. Runs five parallel specialist subagents (security, bugs, performance, code-smells, architecture) plus a once-per-PR checks pass that finds tests and controls able to pass without proving their purpose, drops findings whose quoted evidence is not in the code, dedupes, runs critic subagents that re-check each finding against the worktree and set its risk label, peer-reviews via codex exec (falling back to a Claude second opinion when codex is unavailable), and serves an interactive HTML report for selecting or dismissing findings to post via gh, recording the outcome per finding as labels. Bundles a Bun CLI put on PATH by the skill's postinstall step under a bunx install, or by the plugin's bin/ under a Claude Code plugin install. Use when the user asks to review a GitHub pull request. Local mode (setup --local) runs the same pipeline on the current branch's diff from its merge base, uncommitted and untracked work included, against the caller's live tree, with no server or posting, and hands the ranked findings back in the terminal for an implementing or orchestrating agent to address. Splits oversized diffs into budgeted shards and rebuilds the diff from the local clone when gh pr diff refuses it.",
   "author": "iceinvein",
   "type": "prompt",
   "tools": [

package/skills/migrate/README.md

@@ -185,6 +185,12 @@ writing.
 bunx @iceinvein/agent-skills install migrate -g
 ```
 
+As a Claude Code plugin, after `/plugin marketplace add iceinvein/agent-skills`:
+
+```
+/plugin install migrate@iceinvein-skills
+```
+
 This skill ships in two parts: the prompt (`SKILL.md`) and a companion Bun
 CLI (`bin` + `scripts`). The agent-skills installer writes both into
 `~/.claude/skills/migrate/` and then runs the bundled `install.sh` as a

package/skills/migrate/SKILL.md

@@ -7,7 +7,8 @@ description: Source-agnostic legacy migration mapping. Walks a legacy codebase t
 
 ## Prerequisites
 
-- `migrate` on `PATH`, put there by this skill's `install.sh`.
+- `migrate` on `PATH`, put there by this skill's `install.sh` under a bunx
+  install, or by the plugin's `bin/` under a Claude Code plugin install.
 - A read-only checkout of the legacy source. `migrate check`'s `citations` and
   `source` gates read it; nothing here writes to it, and every writer in the CLI
   refuses a path that resolves inside it.

package/skills/migrate/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "migrate",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Source-agnostic legacy migration mapping. Walks a legacy codebase through probe, enumerate, seam, extract, parity, queue, adjudicate and handoff, building an auditable requirements ledger with mandatory citations and a `migrate check` gate in place of self-reported completeness. Use when the user asks to migrate, re-specify, replatform, or map a legacy system onto a new stack, to hand mapped requirements to a delivery team, or to resume, check, report, or forecast a mapping run already under way.",
   "author": "iceinvein",
   "type": "prompt",

package/skills/scope-estimate/README.md

@@ -37,7 +37,7 @@ It updates the requirements, re-runs the scheduler and every page that quotes
 a figure.
 
 **Scheduler on its own:**
-`bun .claude/skills/scope-estimate/scripts/schedule.ts build-plan/requirements build-plan/plan.json --json build-plan/schedule.json`
+`bun <skill-dir>/scripts/schedule.ts build-plan/requirements build-plan/plan.json --json build-plan/schedule.json`
 (`--help` lists the `plan.json` fields).
 
 **Say when presenting:** status is from reading code, not running it; rates
@@ -52,6 +52,12 @@ bunx @iceinvein/agent-skills install scope-estimate        # this project
 bunx @iceinvein/agent-skills install scope-estimate -g     # every project
 ```
 
+As a Claude Code plugin, after `/plugin marketplace add iceinvein/agent-skills`:
+
+```
+/plugin install scope-estimate@iceinvein-skills
+```
+
 Needs [Bun](https://bun.sh) for the scheduler. Claude Code only.
 
 ## Starting a run
@@ -118,15 +124,16 @@ stays a local file until you say otherwise.
 ## The scheduler
 
 ```
-bun .claude/skills/scope-estimate/scripts/schedule.ts <requirements-dir> <plan.json> [--json <out.json>]
+bun <skill-dir>/scripts/schedule.ts <requirements-dir> <plan.json> [--json <out.json>]
 ```
 
-Use `~/.claude/skills/...` for a global install. It prints totals, gated
-totals, per-slice requirements and planning days, the engineers x worktrees
-matrix at planning rates, the headline fast, planning and floor weeks, the
-longest dependency chain, packages sized by assumption and dependencies that
-resolved to nothing. `--json` adds the full report, including the lane order
-for every team combination.
+`<skill-dir>` is the skill's install directory (e.g.
+`.claude/skills/scope-estimate` for a bunx project install). It prints
+totals, gated totals, per-slice requirements and planning days, the
+engineers x worktrees matrix at planning rates, the headline fast, planning
+and floor weeks, the longest dependency chain, packages sized by assumption
+and dependencies that resolved to nothing. `--json` adds the full report,
+including the lane order for every team combination.
 
 It refuses a plan that misses or double-counts a requirement, reuses a
 package id, names an unknown package or undeclared layer, has a dependency

package/skills/scope-estimate/SKILL.md

@@ -131,19 +131,20 @@ Complete `build-plan/plan.json` (slices, foundation packages, any split or
 ordered product packages) and run:
 
 ```
-bun .claude/skills/scope-estimate/scripts/schedule.ts build-plan/requirements build-plan/plan.json --json build-plan/schedule.json
+bun <skill-dir>/scripts/schedule.ts build-plan/requirements build-plan/plan.json --json build-plan/schedule.json
 ```
 
-(Use `~/.claude/skills/...` if the skill was installed globally.) It refuses a
-plan that does not account for every requirement exactly once, reuses a
-package id, names an unknown package or undeclared layer, lets scheduled work
-wait on gated work, or has a dependency cycle (naming the requirement behind
-each edge). It prints totals, gated totals, per-slice counts and planning
-days, the engineers x worktrees matrix at planning rates, the headline
-fast/planning/floor range, the critical chain, assumed sizes and unresolved
-dependencies. Fix the plan, not the output. **Every number in the docs comes
-from this output.** Re-run it after any requirement, rate or team change and
-update every page that quotes a figure. Reference: `references/schedule.md`.
+(`<skill-dir>` is this skill's base directory, stated when the skill loads.) It
+refuses a plan that does not account for every requirement exactly once,
+reuses a package id, names an unknown package or undeclared layer, lets
+scheduled work wait on gated work, or has a dependency cycle (naming the
+requirement behind each edge). It prints totals, gated totals, per-slice
+counts and planning days, the engineers x worktrees matrix at planning rates,
+the headline fast/planning/floor range, the critical chain, assumed sizes and
+unresolved dependencies. Fix the plan, not the output. **Every number in the
+docs comes from this output.** Re-run it after any requirement, rate or team
+change and update every page that quotes a figure. Reference:
+`references/schedule.md`.
 
 ### 5. Architecture and proposal checks
 

package/skills/scope-estimate/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "scope-estimate",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Scopes and estimates a rebuild or respec of an existing system for a proposal: read-only discovery agents write cited inventories, a capability register gives every capability a status and a proposed disposition, area agents turn it into sized functional requirements, and a bundled Bun scheduler groups them into slices and contracts-first work packages and schedules them across engineers x worktrees at fast, planning and floor rates. The scheduler refuses a plan that misses or double-counts a requirement or has a dependency cycle, so every figure in the docs comes from one reproducible run. Also covers current and target architecture pages, proposal review, and a two-week calibration before committing to a date. Lighter than migrate: no store and no phase gates.",
   "author": "iceinvein",
   "type": "prompt",

package/skills/sluice/references/deep-channel.md

@@ -431,7 +431,8 @@ reads the run state rather than the plan: it sees what has actually landed.
   task with no `Effort` line goes out on this session's model and effort, and a
   downshift that was neither marked nor ratified is a saving your partner never
   agreed to. A task ratified at `Effort: low` goes out with
-  `subagent_type: sluice-implementer-low`, the agent sluice installs with
+  `subagent_type: sluice-implementer-low` (`sluice:sluice-implementer-low`
+  under a Claude Code plugin install), the agent sluice installs with
   `effort: low` and `model: inherit`: the Agent tool takes a model and no
   effort, so an agent definition is the one place a dispatch's effort can be
   set. Reviewers are the
@@ -533,7 +534,8 @@ something stronger would be promising what is already in use. What a tier buys
 is a dispatch. The one effort rule that holds across all of them is that a
 review never runs below the effort that built the task, so tiers 1 and 2 over
 an `Effort: low` task go out at this session's effort rather than on
-`sluice-implementer-low`.
+`sluice-implementer-low` (`sluice:sluice-implementer-low` under a Claude Code
+plugin install).
 
 **Where the repo carries review tiering of its own, this table governs.** It is
 the more specific of the two: wired into `Flips`, the `Effort` marks and the

package/skills/sluice/references/status.md

@@ -145,6 +145,16 @@ the run it names is really there. `close` removes a note naming its own tree,
 because a note that outlived its run would hand the next run opened in that
 tree to whoever reads the main tree.
 
+One note cannot serve a repo whose own rules cut worktrees by hand, outside the
+repo, where no worktree tool will enter them: every controller sits in the main
+tree at once, each with its own run elsewhere, and none of them ran `move`. So
+`init` also records the session that opened the run (`--session`, defaulting to
+`$CLAUDE_CODE_SESSION_ID`) and leaves `.sluice/sessions/<id>` at the main
+worktree naming the run's tree. A tree with no run of its own follows that
+pointer before the note, only while the run there is still that session's.
+`move` points it at the new tree and `close` removes it, so the statusline, the
+SessionStart hook and the Stop hook each find the run of the session asking.
+
 One file for several writers is one file to contend on, so `init`, `task`,
 `preflight`, `final`, `pause`, `resume`, `close` and `move` take a lock first, `move` taking the
 destination tree's as well as its own: two flips issued at the same moment
@@ -380,10 +390,10 @@ is live and contends with nothing for width when one is, which is what lets the
 bar be wide and the task carry its name rather than only its number.
 
 Capture it wherever the statusline command builds its other lines, passing the
-directory the session is in and nothing else:
+directory the session is in and the session's id, and nothing else:
 
 ```bash
-sluice_line=$(bash "$HOME/.claude/skills/sluice/scripts/statusline.sh" --dir "$cwd" 2>/dev/null)
+sluice_line=$(bash "$HOME/.claude/skills/sluice/scripts/statusline.sh" --dir "$cwd" --session "$session_id" 2>/dev/null)
 ```
 
 then print it last, after whatever else the command emits:
@@ -392,10 +402,12 @@ then print it last, after whatever else the command emits:
 if [ -n "$sluice_line" ]; then printf '%s\n' "$sluice_line"; fi
 ```
 
-`$cwd` is `workspace.current_dir` from the JSON the harness sends on stdin.
-Substitute the install path: `${CLAUDE_CONFIG_DIR:-$HOME/.claude}` where a
-session may set one, or `$cwd/.claude/skills/sluice/scripts/statusline.sh` for a
-project-local install.
+`$cwd` is `workspace.current_dir` and `$session_id` is `session_id`, both from
+the JSON the harness sends on stdin. The id is what finds a run this session
+opened in a worktree it never entered, which is every run in a repo that cuts
+its worktrees by hand. Substitute the install path:
+`${CLAUDE_CONFIG_DIR:-$HOME/.claude}` where a session may set one, or
+`$cwd/.claude/skills/sluice/scripts/statusline.sh` for a project-local install.
 
 Those two lines are the whole contract, and they are deliberately empty of
 judgement. Whether a run is visible from a given directory is a question about

package/skills/sluice/scripts/postinstall.sh

@@ -96,11 +96,12 @@ sluice: to show a live run on your status line, add these to your statusline
 command. The first goes wherever it builds its other lines, the second last of
 all, after everything else it prints:
 
-  sluice_line=\$(bash "$RENDER" --dir "\$cwd" 2>/dev/null)
+  sluice_line=\$(bash "$RENDER" --dir "\$cwd" --session "\$session_id" 2>/dev/null)
 
   if [ -n "\$sluice_line" ]; then printf '%s\\n' "\$sluice_line"; fi
 
-\$cwd is workspace.current_dir from the JSON the harness sends on stdin. Those
-two lines carry no knowledge of where a run lives, so they stay correct as this
-skill changes; every install updates the script behind them.
+\$cwd is workspace.current_dir and \$session_id is session_id, both from the JSON
+the harness sends on stdin. Those two lines carry no knowledge of where a run
+lives, so they stay correct as this skill changes; every install updates the
+script behind them.
 EOF

package/skills/sluice/scripts/session-start.sh

@@ -137,7 +137,7 @@ stamp_baseline "$sid" "$source"
 [ -d "$cwd" ] || exit 0
 [ -f "$STATUS" ] || exit 0
 
-shown="$(bash "$STATUS" show --dir "$cwd" 2>/dev/null)" || exit 0
+shown="$(bash "$STATUS" show --dir "$cwd" ${sid:+--session "$sid"} 2>/dev/null)" || exit 0
 [ -n "$shown" ] || exit 0
 
 echo "A sluice run is live. Its state, from .sluice/run.json:"

package/skills/sluice/scripts/status.sh

@@ -43,6 +43,11 @@
 # neither records anything. Its exit 1 also covers a tree whose changed tests
 # cannot be read.
 #
+# --session <id> names the session asking (default: $CLAUDE_CODE_SESSION_ID).
+# `init` records it in the run and leaves <main tree>/.sluice/sessions/<id>
+# naming the tree the run is in, so that session finds its run from the main
+# tree however many other runs the set holds.
+#
 # A flag value may not begin with `--`: unchecked, an omitted value silently
 # becomes the next flag and the field holds a flag name.
 
@@ -95,6 +100,7 @@ in_set() {
 # subcommand's own flag loop ever sees it. Everything after `--` is verify's
 # command, kept verbatim: a `--dir` in it belongs to that command, not to us.
 DIR="$PWD"
+SESSION="${CLAUDE_CODE_SESSION_ID-}"
 ARGS=()
 while [ $# -gt 0 ]; do
 	case "$1" in
@@ -108,6 +114,11 @@ while [ $# -gt 0 ]; do
 			DIR="$2"
 			shift 2
 			;;
+		--session)
+			need_value --session $# "${2-}"
+			SESSION="$2"
+			shift 2
+			;;
 		*)
 			ARGS+=("$1")
 			shift
@@ -116,6 +127,12 @@ while [ $# -gt 0 ]; do
 done
 set -- "${ARGS[@]+"${ARGS[@]}"}"
 
+# The id becomes a file name under .sluice/sessions, so one that could climb out
+# of that directory is refused rather than followed.
+case "$SESSION" in
+	*/* | .*) err "session id $SESSION is not a file name"; exit 4 ;;
+esac
+
 SUB="${1-}"
 [ $# -gt 0 ] && shift
 if [ -z "$SUB" ]; then
@@ -132,6 +149,40 @@ main_tree() { # <dir>
 	git -C "$1" worktree list --porcelain 2>/dev/null | sed -n '1s/^worktree //p'
 }
 
+# The tree a session's run is in, from the pointer `init` left at the main tree.
+# `run.at` cannot answer this: it is one note for the whole set, and a repo that
+# cuts worktrees by hand has every controller sitting in the main tree at once,
+# each with its own run elsewhere. Followed only while the run there is still
+# that session's, so a pointer that outlived its run never hands over the next
+# one opened in that tree. Empty when there is no such run.
+session_run() { # <main tree>
+	[ -n "$SESSION" ] && [ -n "$1" ] && [ -f "$1/.sluice/sessions/$SESSION" ] || return 0
+	local at=""
+	IFS= read -r at <"$1/.sluice/sessions/$SESSION" 2>/dev/null || true
+	[ -n "$at" ] && [ -f "$at/.sluice/run.json" ] || return 0
+	[ "$(jq -r '.session // empty' "$at/.sluice/run.json" 2>/dev/null)" = "$SESSION" ] || return 0
+	printf '%s\n' "$at"
+}
+
+# Like `leave_note`, a pointer that could not be written is a blank statusline
+# for one session rather than a failed command, so the caller reports it.
+point_session() { # <main tree> <session id> <tree the run is in>
+	mkdir -p "$1/.sluice/sessions" 2>/dev/null || return 1
+	[ -e "$1/.sluice/.gitignore" ] || printf '*\n' >"$1/.sluice/.gitignore" 2>/dev/null || true
+	printf '%s\n' "$3" >"$1/.sluice/sessions/$2" 2>/dev/null
+}
+
+# The session a run was opened by, read back from the run itself rather than
+# from whoever is asking: `move` and `close` may come from another session.
+run_owner() { # <state file>
+	local owner
+	owner="$(jq -r '.session // empty' "$1" 2>/dev/null)"
+	case "$owner" in
+		*/* | .*) return 0 ;;
+	esac
+	printf '%s' "$owner"
+}
+
 # A tree's own run comes first, and only a tree with none reads the set's. Two
 # layouts share this script and pull opposite ways. A deep run plans in the main
 # tree and cuts implementer worktrees after the plan: the run directory ignores
@@ -155,8 +206,18 @@ main_tree() { # <dir>
 ORIG_DIR="$DIR"
 if [ "$SUB" != "init" ] && [ ! -f "$DIR/.sluice/run.json" ] \
 	&& [ "$(git -C "$DIR" rev-parse --is-inside-work-tree 2>/dev/null)" = "true" ]; then
+	# The tree's own run lives at its top, not at whatever subdirectory the
+	# session is sitting in. Testing only $DIR sent a session in a worktree's
+	# package straight past that worktree's run to the main tree's.
+	OWN_TREE="$(git -C "$DIR" rev-parse --show-toplevel 2>/dev/null)"
 	MAIN_TREE="$(main_tree "$DIR")"
-	if [ -n "${MAIN_TREE:-}" ] && [ -d "$MAIN_TREE" ]; then
+	# The session's own run outranks the set's, which may be anybody's.
+	SESSION_TREE="$(session_run "${MAIN_TREE:-}")"
+	if [ -n "${OWN_TREE:-}" ] && [ -f "$OWN_TREE/.sluice/run.json" ]; then
+		DIR="$OWN_TREE"
+	elif [ -n "$SESSION_TREE" ]; then
+		DIR="$SESSION_TREE"
+	elif [ -n "${MAIN_TREE:-}" ] && [ -d "$MAIN_TREE" ]; then
 		DIR="$MAIN_TREE"
 
 		# Then forward, where the main tree's run has moved on into a worktree.
@@ -835,12 +896,20 @@ case "$SUB" in
 			--arg channel "$CHANNEL" \
 			--arg started "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
 			--arg plan "$PLAN" \
-			--arg record "$RECORD" '
+			--arg record "$RECORD" \
+			--arg session "$SESSION" '
 			{schema: 1, topic: $topic, channel: $channel, started: $started}
 			+ (if $plan == "" then {} else {plan: $plan} end)
 			+ (if $record == "" then {} else {record: $record} end)
+			+ (if $session == "" then {} else {session: $session} end)
 			+ {tasks: []}
-		' | write_state
+		' | write_state || exit $?
+
+		POINTER_TREE="$(main_tree "$DIR")"
+		if [ -n "$SESSION" ] && [ -n "$POINTER_TREE" ] && [ -d "$POINTER_TREE" ] \
+			&& ! point_session "$POINTER_TREE" "$SESSION" "$(cd "$DIR" && pwd -P)"; then
+			err "note: the run is open, but $POINTER_TREE/.sluice/sessions/$SESSION could not be written, so this session reads no run from $POINTER_TREE"
+		fi
 		;;
 
 	task)
@@ -1257,6 +1326,20 @@ case "$SUB" in
 			elif ! leave_note "$NOTE_TREE" "$TO"; then
 				err "note: the run moved, but $NOTE_TREE/.sluice/run.at could not be written, so a session in $NOTE_TREE will read no run until it moves to $TO"
 			fi
+			# The note above names only the last run moved; the owner's pointer
+			# keeps finding this one after another run is moved past it. Only a
+			# pointer still naming the tree left behind follows the run: one
+			# naming elsewhere is on a later run the same session opened.
+			OWNER="$(run_owner "$DEST_STATE")"
+			if [ -n "$OWNER" ]; then
+				AT=""
+				[ -f "$NOTE_TREE/.sluice/sessions/$OWNER" ] \
+					&& IFS= read -r AT <"$NOTE_TREE/.sluice/sessions/$OWNER" 2>/dev/null
+				if { [ -z "$AT" ] || [ "$AT" = "$(cd "$DIR" && pwd -P)" ]; } \
+					&& ! point_session "$NOTE_TREE" "$OWNER" "$TO"; then
+					err "note: the run moved, but $NOTE_TREE/.sluice/sessions/$OWNER could not be written"
+				fi
+			fi
 		fi
 
 		echo "moved $(jq -r '.topic // "run"' "$DEST_STATE" 2>/dev/null || echo run) to $TO"
@@ -1294,6 +1377,7 @@ case "$SUB" in
 		# file aside intact rather than leaving it wedged in the tree.
 		started="$(jq -r '.started // empty' "$STATE" 2>/dev/null)"
 		topic="$(jq -r '.topic // empty' "$STATE" 2>/dev/null)"
+		owner="$(run_owner "$STATE")"
 		stamp="$(printf '%s' "$started" | tr -cd '0-9TZ')"
 		slug="$(printf '%s' "${topic:-run}" | tr -cs 'A-Za-z0-9._-' '-')"
 		[ -n "$stamp" ] || stamp="unknown"
@@ -1322,6 +1406,13 @@ case "$SUB" in
 			IFS= read -r AT <"$NOTE_TREE/.sluice/run.at" 2>/dev/null || true
 			[ "$AT" = "$(cd "$DIR" && pwd -P)" ] && rm -f "$NOTE_TREE/.sluice/run.at"
 		fi
+		# The same holds for the owner's pointer, which may by now name a later
+		# run the same session opened elsewhere.
+		if [ -n "$NOTE_TREE" ] && [ -n "$owner" ] && [ -f "$NOTE_TREE/.sluice/sessions/$owner" ]; then
+			AT=""
+			IFS= read -r AT <"$NOTE_TREE/.sluice/sessions/$owner" 2>/dev/null || true
+			[ "$AT" = "$(cd "$DIR" && pwd -P)" ] && rm -f "$NOTE_TREE/.sluice/sessions/$owner"
+		fi
 		# The summary needs parseable state and close is the one command that
 		# does not, so an unreadable run still gets a line naming where it went.
 		[ -n "$summary" ] || summary="closed $(basename "$dest"): state was unreadable, no summary"

package/skills/sluice/scripts/statusline-command.sh

@@ -36,7 +36,13 @@ IFS= read -r -d "" -t 2 input || true
 # `cwd` is the older spelling of the same field and both are still sent, so it
 # is a fallback rather than a bug. Neither present is not an error worth a row:
 # it means this is not the JSON we were written against.
-dir="$(printf '%s' "$input" | jq -r '.workspace.current_dir // .cwd // empty' 2>/dev/null || true)"
-[ -n "$dir" ] || exit 0
+#
+# One jq for both fields, a line each: the render budget has no room for a
+# second fork, and a newline cannot appear in either value.
+{
+	IFS= read -r dir
+	IFS= read -r session
+} < <(printf '%s' "$input" | jq -r '(.workspace.current_dir // .cwd // ""), (.session_id // "")' 2>/dev/null || true)
+[ -n "${dir:-}" ] || exit 0
 
-bash "$RENDER" --dir "$dir" 2>/dev/null || exit 0
+bash "$RENDER" --dir "$dir" ${session:+--session "$session"} 2>/dev/null || exit 0

package/skills/sluice/scripts/statusline.sh

@@ -3,12 +3,13 @@
 # call. The caller passes the directory the session is in and prints whatever
 # comes back.
 #
-#   statusline.sh [--dir <path>]
+#   statusline.sh [--dir <path>] [--session <id>]
 #
-# --dir defaults to $PWD. Always exits 0 in silence on anything it cannot
-# render: a status bar draws on every keystroke and has nowhere to put an error,
-# so a message here would be permanent clutter rather than a report anyone acts
-# on.
+# --dir defaults to $PWD. --session is the harness's session_id, which finds the
+# run that session opened in another worktree while it sits in the main tree.
+# Always exits 0 in silence on anything it cannot render: a status bar draws on
+# every keystroke and has nowhere to put an error, so a message here would be
+# permanent clutter rather than a report anyone acts on.
 #
 # Why this exists as its own script rather than as a snippet in the caller.
 # Whether a run is visible from a given directory is a question about sluice's
@@ -36,6 +37,7 @@ here="$(cd "$(dirname "$0")" && pwd)"
 STATUS="$here/status.sh"
 
 DIR="$PWD"
+SESSION=""
 while [ $# -gt 0 ]; do
 	case "$1" in
 		--dir)
@@ -44,6 +46,11 @@ while [ $# -gt 0 ]; do
 			DIR="$2"
 			shift 2
 			;;
+		--session)
+			[ $# -ge 2 ] && [ "${2#--}" = "$2" ] || exit 0
+			SESSION="$2"
+			shift 2
+			;;
 		*) exit 0 ;;
 	esac
 done
@@ -65,11 +72,13 @@ done
 d="$(cd "$DIR" 2>/dev/null && pwd -P)" || exit 0
 [ -n "$d" ] || exit 0
 
-# Five answers end the walk. A state file is a run, wherever it was found. So is
+# Six answers end the walk. A state file is a run, wherever it was found. So is
 # a forwarding note beside where one used to be: the run moved out into a
 # worktree, this tree is where the session that moved it is still sitting, and
 # testing only the state file blanked its bar on a live run -- ahead of the
-# `.git` directory below, which would otherwise answer for this tree first. A
+# `.git` directory below, which would otherwise answer for this tree first. So
+# is this session's pointer, for a run it opened in a worktree it never
+# entered, which is the same blank bar reached without a `move`. A
 # `.git` that is a regular file is a linked worktree or a submodule, which may
 # hold no state of its own and still belong to a set that does, so it is a maybe
 # and status.sh resolves it. A `.git` that is a directory is the top of an
@@ -83,6 +92,7 @@ d="$(cd "$DIR" 2>/dev/null && pwd -P)" || exit 0
 while :; do
 	[ -f "$d/.sluice/run.json" ] && break
 	[ -f "$d/.sluice/run.at" ] && break
+	[ -n "$SESSION" ] && [ -f "$d/.sluice/sessions/$SESSION" ] && break
 	[ -f "$d/.git" ] && break
 	[ -d "$d/.git" ] && exit 0
 	[ "$d" = "${HOME:-}" ] && exit 0
@@ -100,6 +110,8 @@ done
 # already coloured: the mapping from state to colour belongs next to the state,
 # and a caller that applied it would have to re-derive each cell's meaning from
 # its glyph.
-rendered="$(bash "$STATUS" line --full --dir "$DIR" 2>/dev/null)" || exit 0
+# --session only when given, so a caller passing none leaves status.sh its own
+# default rather than an empty override.
+rendered="$(bash "$STATUS" line --full --dir "$DIR" ${SESSION:+--session "$SESSION"} 2>/dev/null)" || exit 0
 [ -n "$rendered" ] || exit 0
 printf '%s\n' "$rendered"

package/skills/sluice/scripts/stop-guard.sh

@@ -319,10 +319,30 @@ fi
 # which is the right question for a render and the wrong one for a refusal. The
 # tree named in the note is then passed as `--dir`, so what follows asks about
 # one named tree and carries no layout knowledge of its own.
+#
+# The run this session opened in a worktree it never entered is its own too,
+# found through the pointer `init` left at the main tree, and it comes ahead of
+# the forward: the forward names whichever run was moved last, which with
+# several controllers in the main tree may be another session's.
 top="$(git -C "$cwd" rev-parse --show-toplevel 2>/dev/null)"
 [ -n "$top" ] || top="$cwd"
+session_tree=""
+case "$sid" in
+	"" | */* | .*) ;;
+	*)
+		main="$(git -C "$cwd" worktree list --porcelain 2>/dev/null | sed -n '1s/^worktree //p')"
+		[ -n "$main" ] && [ -f "$main/.sluice/sessions/$sid" ] \
+			&& IFS= read -r session_tree <"$main/.sluice/sessions/$sid" 2>/dev/null
+		if [ -z "$session_tree" ] || [ ! -f "$session_tree/.sluice/run.json" ] \
+			|| [ "$(jq -r '.session // empty' "$session_tree/.sluice/run.json" 2>/dev/null)" != "$sid" ]; then
+			session_tree=""
+		fi
+		;;
+esac
 if [ -f "$top/.sluice/run.json" ]; then
 	tree="$top"
+elif [ -n "$session_tree" ]; then
+	tree="$session_tree"
 elif [ -f "$top/.sluice/run.at" ]; then
 	tree=""
 	IFS= read -r tree <"$top/.sluice/run.at" 2>/dev/null || exit 0

package/skills/sluice/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "sluice",
-  "version": "0.25.1",
+  "version": "0.25.3",
   "description": "Routes work by change shape into four channels (bypass, fast, main, deep) and applies only the rules each channel needs, so a one-line fix does not pay the cost of a multi-subsystem build. Carries nine rules as one-liners in the router and the full treatment in references read only on friction. Checks the finished plan with plan.sh validate rather than trusting it to memory, seeds the run state from it, keeps a deep run's task breakdown in .sluice/run.json so a statusline segment, one status command and a SessionStart hook can answer where the run is (the hook prints a live run at every session start, compaction included), and closes each run with a ledger read out of the session transcript: elapsed, tools, tokens, and what each dispatched agent cost where the transcript recorded it. Two Stop hooks hold a handback: one refuses a tree that moved since its last recorded check, the other refuses a changed existing test not proven to fail on the session's starting code (or recorded with a reason). Claude Code only; stands down where the superpowers pipeline governs the repo.",
   "author": "iceinvein",
   "type": "prompt",