@iceinvein/agent-skills 0.10.1 → 0.11.0

package/package.json

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

package/skills/index.json

@@ -221,7 +221,7 @@
     "name": "magpie",
     "description": "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 (falling back to a Claude second opinion when codex is unavailable), and serves an interactive HTML report for selecting findings to post via gh. Bundles a Bun CLI installed onto PATH via the skill's postinstall step. Use when the user asks to review a GitHub pull request. Splits oversized diffs into budgeted shards and rebuilds the diff from the local clone when gh pr diff refuses it.",
     "type": "prompt",
-    "version": "0.10.1"
+    "version": "0.11.0"
   },
   {
     "name": "migrate",
@@ -283,7 +283,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 seven 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 and one status command can answer where the run is, 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. Claude Code only; stands down where the superpowers pipeline governs the repo.",
     "type": "prompt",
-    "version": "0.12.1"
+    "version": "0.12.2"
   },
   {
     "name": "temporal-coupling-detector",

package/skills/magpie/README.md

@@ -12,7 +12,7 @@ Given a GitHub PR number, dispatches five specialist subagents in parallel (secu
 - `gh` on PATH, authenticated (`gh auth status`)
 - `git` on PATH
 - `codex` on PATH, authenticated (optional; if absent the peer-review stage falls back to a Claude second-opinion subagent)
-- the code-intelligence MCP server, with a completed index for the repo under review (optional; if absent the specialists review from the diff and worktree alone)
+- code intelligence, with a completed index for the repo under review (optional; if absent the specialists review from the diff and worktree alone). Either interface works: the `code-intel` CLI on PATH, which is preferred because it takes `--repo` per call and needs no session binding, or the code-intelligence MCP server
 
 ## Install
 

package/skills/magpie/SKILL.md

@@ -7,7 +7,7 @@ description: Use when the user asks to review a GitHub pull request (a PR number
 
 ## Prerequisites
 
-The skill pre-flights `bun`, `gh`, `git` (required) and `codex` (optional). A missing required binary aborts the run with a single install hint line. Without `codex` the run continues and peer review falls back to a Claude second-opinion subagent (setup prints a one-line notice and logs `{stage: preflight, status: done, missingOptional: ["codex"]}`).
+The skill pre-flights `bun`, `gh`, `git` (required) and `codex` (optional). A missing required binary aborts the run with a single install hint line. Code intelligence is not pre-flighted: stage 3 probes for it, over either the `code-intel` CLI or the code-intelligence MCP server, and the run continues without it. Without `codex` the run continues and peer review falls back to a Claude second-opinion subagent (setup prints a one-line notice and logs `{stage: preflight, status: done, missingOptional: ["codex"]}`).
 
 ## Stage walkthrough
 
@@ -85,16 +85,17 @@ magpie render "$RUN_DIR" progress
 
 Append `{stage: context, status: running}` to `$RUN_DIR/log.jsonl` and re-render progress. This stage has two steps and never aborts the run.
 
-**Bind probe.** If the `mcp__code-intelligence__*` tools are not in your tool list, skip straight to the scout with `CODE_INTELLIGENCE=unavailable`. Otherwise call `bind_workspace` with `$RUN_DIR/worktree`: it is a linked git worktree, so an already-indexed base repo seeds its index instead of re-indexing.
+**Probe.** Code intelligence reaches the same on-device daemon through two interfaces. Prefer the `code-intel` CLI: it takes `--repo` on every call, so it holds no session binding to leak past cleanup and the specialists can query in parallel without clobbering each other's workspace. `$RUN_DIR/worktree` is a linked git worktree either way, so an already-indexed base repo seeds its index instead of re-indexing.
 
-- `consent_required` means the base repo has never completed an index. **Never call `approve_indexing`**: that is a full GPU pass the user did not ask for. Set `CODE_INTELLIGENCE=unavailable`, and print one line: "Code intelligence is unavailable (the base repo has no index); specialists will review from the diff alone."
-- `indexing_started` or `indexing_in_progress` means the seed took. Poll `get_index_stats` every 5s for at most 60s, then set `CODE_INTELLIGENCE=available` either way. Do not block the pipeline on completion; the specialist contract handles a still-indexing tool.
-- A ready result sets `CODE_INTELLIGENCE=available`.
-- Any other error sets `CODE_INTELLIGENCE=unavailable`. Do not retry.
+- **CLI**, when `command -v code-intel` succeeds. Run `code-intel index status --repo "$RUN_DIR/worktree" --json` and read `.status`: `ok` sets `CODE_INTELLIGENCE=cli`. `indexing_started` or `indexing_in_progress` means the seed took, so poll the same command every 5s for at most 60s and set `CODE_INTELLIGENCE=cli` either way. Exit 3 is a stopped daemon: run `code-intel start`, re-probe once. **Never run `code-intel index approve`.**
+- **MCP**, when the CLI is absent but `mcp__code-intelligence__*` tools are in your tool list. Call `bind_workspace` with `$RUN_DIR/worktree` and apply the same rules, polling `get_index_stats` instead, to set `CODE_INTELLIGENCE=mcp`. **Never call `approve_indexing`.**
+- `consent_required` on either interface means the base repo has never completed an index, and starting one is a full GPU pass the user did not ask for. That, no interface at all, or any other error that survives one retry, sets `CODE_INTELLIGENCE=unavailable`; print one line: "Code intelligence is unavailable (<reason>); specialists will review from the diff alone."
+
+Never block the pipeline on a still-running index. The scout and specialist contracts both handle a tool that is not ready yet.
 
 **Scout.** Read `references/scout.md` and dispatch one subagent (Agent tool, `general-purpose`) carrying the `magpie-scout` block with `<<RUN_DIR>>`, `<<PR_NUMBER>>`, and `<<CODE_INTELLIGENCE>>` substituted. It writes `$RUN_DIR/brief.json`.
 
-Append `{stage: context, status: done, codeIntelligence: true|false}` and re-render progress. If the scout returned without writing `brief.json`, append `{stage: context, status: skipped, codeIntelligence: true|false}` instead and continue: the brief is optional everywhere it is read. Both entries carry the probe's result, which is known whatever the scout did.
+Append `{stage: context, status: done, codeIntelligence: true|false, interface: "cli"|"mcp"|"none"}` and re-render progress. If the scout returned without writing `brief.json`, append `{stage: context, status: skipped, codeIntelligence: true|false, interface: ...}` instead and continue: the brief is optional everywhere it is read. Both entries carry the probe's result, which is known whatever the scout did, and `interface` is what stage 10 reads to decide whether there is a session to rebind.
 
 ### 4. Specialists
 
@@ -147,8 +148,8 @@ gate is expected to have none. `magpie dedupe` re-checks this against the manife
 names every missing pair on stdout, as a backstop rather than a substitute.
 
 If every specialist fails (no findings files written), log
-`{stage: specialists, status: error}`, rebind code intelligence to `$REPO` if bound
-(stage 10), and stop. Otherwise mark `{stage: specialists, status: done}`.
+`{stage: specialists, status: error}`, rebind code intelligence to `$REPO` if
+`CODE_INTELLIGENCE=mcp` (stage 10), and stop. Otherwise mark `{stage: specialists, status: done}`.
 
 ### 5. Dedupe
 
@@ -240,7 +241,7 @@ magpie render "$RUN_DIR" findings
 magpie cleanup "$RUN_DIR" --repo "$REPO"
 ```
 
-If the context stage bound code intelligence, rebind the session now: call `bind_workspace` with `$REPO`. Binding is per session with no per-call override, so ending a run without this leaves the session pointed at a worktree `cleanup` just deleted. The daemon prunes the seeded index once the worktree is gone.
+If the context stage set `CODE_INTELLIGENCE=mcp`, rebind the session now: call `bind_workspace` with `$REPO`. MCP binding is per session with no per-call override, so ending a run without this leaves the session pointed at a worktree `cleanup` just deleted. A `cli` run has nothing to rebind, because `--repo` names the workspace on every call. Either way the daemon prunes the seeded index once the worktree is gone.
 
 The run directory is renamed to `<run-dir>.archived-<timestamp>` and the worktree is removed. The CLI prints two lines on success: `archived to <path>` and `view later: magpie open <archived-id>`. Surface that second line verbatim so the user has a one-command path back to the report.
 
@@ -261,7 +262,7 @@ magpie status "$RUN_DIR"
 
 The JSON output tells you `lastCompleted` and `next`. Resume from `next`:
 
-- `context` re-runs by redoing the bind probe, then dispatching the scout only if `$RUN_DIR/brief.json` is missing. The seeded index survives a crash, so the rebind is near-instant.
+- `context` re-runs by redoing the probe, then dispatching the scout only if `$RUN_DIR/brief.json` is missing. The seeded index survives a crash, so the rebind is near-instant.
 - Any other stage: run it as written in the walkthrough.
 - If a specialist focus has no findings file but its sibling stages are done,
   re-dispatch only that focus. On a sharded run the unit is the `(focus, shard)` pair:
@@ -274,4 +275,4 @@ The original server is gone. Restart it with `magpie serve "$RUN_DIR"` (step 2)
 
 ## Aborting
 
-If the user types `abort` mid-run, rebind code intelligence to `$REPO` if bound (stage 10), then run `magpie cleanup` and exit.
+If the user types `abort` mid-run, rebind code intelligence to `$REPO` if `CODE_INTELLIGENCE=mcp` (stage 10), then run `magpie cleanup` and exit.

package/skills/magpie/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magpie",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "private": true,
   "type": "module",
   "scripts": {

package/skills/magpie/references/scout.md

@@ -6,9 +6,10 @@ with `<<RUN_DIR>>` and `<<PR_NUMBER>>` replaced by the real values first. The
 subagent has no shell variables from your session, so an unexpanded path means it
 writes the brief where nothing will read it.
 
-Substitute `<<CODE_INTELLIGENCE>>` with `available` when the bind probe succeeded and
-`unavailable` otherwise. The scout still runs when code-intelligence is unavailable;
-only the subsystem map degrades.
+Substitute `<<CODE_INTELLIGENCE>>` with the value stage 3's probe assigned: `cli` for
+the `code-intel` CLI, `mcp` for the code-intelligence MCP tools, `unavailable` for
+neither. The scout still runs when code intelligence is unavailable; only the
+subsystem map degrades.
 
 ```magpie-scout
 You are a senior engineer building the orienting brief that five specialist
@@ -30,19 +31,33 @@ Code intelligence: <<CODE_INTELLIGENCE>>
 
 ## Code intelligence
 
-When the line above says `available`, the code-intelligence MCP tools are indexed
-against `<<RUN_DIR>>/worktree`, seeded from the base repository. Call `bind_workspace`
-with `<<RUN_DIR>>/worktree` before your first query. Use them to map where the change
-lands:
-
-- `get_module_summary` on each directory the diff touches, to name the subsystem and
-  say what it is responsible for.
-- `explore_dependency_graph` on the touched modules, to say what depends on them.
-
-If a tool returns `indexing_in_progress`, finish reading the diff and retry once. If
-it still is not ready, or the line above says `unavailable`, write `"subsystems": []`
-and carry on. Never call `approve_indexing`. Never call `refresh_index`. Triggering a
-full index is a consent-gated operation that is not yours to start.
+Unless the line above says `unavailable`, an index of `<<RUN_DIR>>/worktree`, seeded
+from the base repository, is queryable. Use it for two things only: name the subsystem
+each touched directory belongs to and what it is responsible for, then say what depends
+on those modules.
+
+When the line says `cli`, run the `code-intel` CLI. Every call names the workspace, so
+there is nothing to bind first:
+
+    code-intel investigate --repo <<RUN_DIR>>/worktree --mode module --file-path <dir> \
+      --json "what is this module responsible for"
+    code-intel dependency-graph --repo <<RUN_DIR>>/worktree --json <symbol>
+
+`code-intel repo-map --repo <<RUN_DIR>>/worktree --json` is the cheaper first look when
+you do not yet know which directories matter. Exit 5 means no results, which is an
+answer. Exit 3 means the daemon is down: stop querying and write `"subsystems": []`.
+
+When the line says `mcp`, call `bind_workspace` with `<<RUN_DIR>>/worktree` before your
+first query, then `get_module_summary` on each touched directory and
+`explore_dependency_graph` on the touched modules.
+
+If a query reports `indexing_in_progress` (the CLI returns
+`error.code: workspace_unavailable` with that prefix), finish reading the diff and retry
+once. If it still is not ready, or the line above says `unavailable`, write
+`"subsystems": []` and carry on. Never call `approve_indexing` and never run
+`code-intel index approve`; never call `refresh_index` and never run
+`code-intel index refresh`. Triggering a full index is a consent-gated operation that
+is not yours to start.
 
 ## How to reason
 

package/skills/magpie/references/specialists.md

@@ -41,9 +41,11 @@ in an excluded file (a migration implies a model snapshot, a schema change impli
 generated types), open it and cross-check rather than treating it as out of scope.
 ```
 
-5. The `magpie-codebase-intelligence` block below, verbatim, **only** when the context
-   stage logged `codeIntelligence: true`. Omit it entirely otherwise: telling a
-   specialist to use tools it does not have wastes a turn per specialist on discovery.
+5. One `magpie-codebase-intelligence-*` block below, verbatim, **only** when the
+   context stage logged `codeIntelligence: true`: the `-cli` block for
+   `interface: "cli"`, the `-mcp` block for `interface: "mcp"`. Omit it entirely
+   otherwise, and never send both: telling a specialist to use tools it does not have
+   wastes a turn per specialist on discovery.
 6. The brief, when `<RUN_DIR>/brief.json` exists, rendered as:
 
 ```
@@ -130,7 +132,7 @@ Good:
 - `Observation: <one idea, what the diff actually does and where>`
 - `Why it matters: <impact at realistic scale or on a real user path>`
 - `Suggested direction: <one concrete next step, optional if the fix isn't obvious>`
-- `Needs verification: <what you couldn't confirm from the bundle, optional, low/medium severity only>` This labelled paragraph is the only channel for uncertainty: never hedge inside another section, and never raise `severity` to compensate for what you couldn't verify (a blocker/high you cannot stand behind is not a blocker/high). Use the exact `Needs verification:` prefix, not inline phrasing. When the codebase-intelligence tools are available and one of them could answer the question, look before you hedge. A question you resolved is not a `Needs verification:` paragraph, it is evidence: cite the file:line you found under `Observation:` and omit the paragraph entirely.
+- `Needs verification: <what you couldn't confirm from the bundle, optional, low/medium severity only>` This labelled paragraph is the only channel for uncertainty: never hedge inside another section, and never raise `severity` to compensate for what you couldn't verify (a blocker/high you cannot stand behind is not a blocker/high). Use the exact `Needs verification:` prefix, not inline phrasing. When codebase intelligence is available, over either interface, and one query could answer the question, look before you hedge. A question you resolved is not a `Needs verification:` paragraph, it is evidence: cite the file:line you found under `Observation:` and omit the paragraph entirely.
 
 One idea per paragraph. Do not collapse them into a single wall of text. Do not invent extra labels. If a section doesn't apply, omit it. The interactive report and the GitHub comment both parse these labels and render them as section headers, so missing labels degrade the output.
 
@@ -145,9 +147,67 @@ If you have no findings, write []. Return as your final tool result a single lin
 
 ## Codebase intelligence
 
-Include this block as part 5 only when the context stage logged `codeIntelligence: true`.
+Include one of these blocks as part 5 when the context stage logged
+`codeIntelligence: true`: the `-cli` block when it logged `interface: "cli"`, the
+`-mcp` block when it logged `interface: "mcp"`. Both reach the same index. Never send
+both: a specialist told about a verb it cannot invoke wastes turns discovering that.
 
-```magpie-codebase-intelligence
+```magpie-codebase-intelligence-cli
+## Codebase intelligence
+
+The `code-intel` CLI queries an index of this exact worktree, including the PR's own
+changes. Every invocation names the workspace with `--repo <RUN_DIR>/worktree`, so
+there is nothing to bind and nothing another agent can change under you. Always pass
+`--json`.
+
+These answer the cross-file questions a diff cannot:
+
+    code-intel ask --repo <RUN_DIR>/worktree --json "<question>"
+      A natural-language question answered with grounded evidence. Start here when you
+      do not yet know which symbol to pivot on.
+    code-intel search --repo <RUN_DIR>/worktree --context snippets --json "<query>"
+      Hybrid semantic and literal search. Use to check whether something already
+      exists before claiming the PR should add it. Hits carry `id`s.
+    code-intel hydrate --repo <RUN_DIR>/worktree --ids <id,id> --json
+      The exact bodies behind ids a search returned, without re-reading whole files.
+    code-intel definition --repo <RUN_DIR>/worktree --json <symbol>
+      The body of a symbol the diff calls but does not show.
+    code-intel references --repo <RUN_DIR>/worktree --json <symbol>
+    code-intel call-hierarchy --repo <RUN_DIR>/worktree --json <symbol>
+      Who calls this, and what does it call. Use for reachability: is the path you are
+      worried about actually reachable. Add `--direction callers|callees`, `--depth N`.
+    code-intel investigate --repo <RUN_DIR>/worktree --mode impact --target <symbol> --json "<question>"
+      The reverse-dependency set for a symbol. Use for blast radius before claiming a
+      change is safe or unsafe.
+    code-intel investigate --repo <RUN_DIR>/worktree --mode data --target <symbol> --json "<question>"
+      Follow a value from its origin to where it is used. Use to confirm that
+      untrusted input actually reaches the sink you are worried about.
+    code-intel dependency-graph --repo <RUN_DIR>/worktree --json <symbol>
+      Module-level edges. Use for cycles and boundaries.
+
+There is no test-coverage command: to find out whether the symbol you are flagging is
+covered, run `references` on it and read the paths for test files.
+
+Exit codes are the contract, not the prose: 5 means no results, which is an answer and
+not a reason to fall back to grep. 3 means the daemon is down and 4 means the workspace
+is not queryable; either way, stop querying and review from the diff and worktree.
+
+Rules:
+
+- Cite what you find as ordinary `file:line` evidence under `Observation:`. Do not
+  say "code intelligence told me"; the location is the evidence.
+- Verify before you report. A finding you could have refuted with one query and did
+  not is worse than no finding: it costs the author trust and the critic a slot.
+- Verify before you hedge. If a query can answer the question, a `Needs verification:`
+  paragraph is a failure to look, not honest uncertainty.
+- If a command fails with `error.code: workspace_unavailable` and an
+  `indexing_in_progress` message, finish reading the diff and retry once. If it is
+  still not ready, review from the diff and worktree alone. Do not block.
+- Never run `code-intel index approve`. Never run `code-intel index refresh`. Starting
+  a full index is a consent-gated operation that is not yours to start.
+```
+
+```magpie-codebase-intelligence-mcp
 ## Codebase intelligence
 
 You have code-intelligence MCP tools against an index of this exact worktree,
@@ -237,7 +297,7 @@ For each potential finding:
 2. Identify the trust boundary: is this crossing from untrusted to trusted context?
 3. Assess exploitability: can an attacker realistically trigger this?
 4. Evaluate impact: what's the blast radius if exploited?
-5. Confirm the flow with `trace_data_flow` from the entry point to the sink before reporting. A taint path you asserted but did not trace is a guess.
+5. Confirm the flow from the entry point to the sink before reporting, with `code-intel investigate --mode data --target <symbol>` or `trace_data_flow` depending on which interface your intelligence block describes. A taint path you asserted but did not trace is a guess.
 
 **Risk guide:**
 - blocker: Realistic path to remote code execution, auth bypass, data breach, or privilege escalation
@@ -302,7 +362,7 @@ For each potential bug:
 3. What's the consequence: crash, data corruption, silent wrong behavior?
 4. Is there an existing guard I'm not seeing?
 
-Question 4 is answerable: `get_call_hierarchy` on the changed symbol shows every caller, and `find_references` shows where the guard would have to live. Check before you file.
+Question 4 is answerable: a call hierarchy on the changed symbol shows every caller, and its references show where the guard would have to live (`code-intel call-hierarchy` / `code-intel references`, or `get_call_hierarchy` / `find_references` on MCP). Check before you file.
 
 **Risk guide:**
 - blocker: Data loss, data corruption, broken auth/session behavior, or consistently crashing a major workflow
@@ -362,7 +422,7 @@ For each potential issue:
 2. How often does this code path execute? (once on init vs. every keystroke)
 3. What's the measurable impact? (milliseconds vs. seconds)
 4. Is the optimization worth the complexity cost?
-5. Establish the call frequency with `find_affected_code` before claiming a path is hot. "Called from one cold init path" and "called per keystroke" are different findings.
+5. Establish the call frequency before claiming a path is hot, with `code-intel investigate --mode impact --target <symbol>` or `find_affected_code`. "Called from one cold init path" and "called per keystroke" are different findings.
 
 **Risk guide:**
 - blocker: Change can make a major workflow unusable or cause unbounded production resource exhaustion
@@ -424,7 +484,7 @@ For each potential smell:
 2. Confirm the smell is introduced or materially worsened by this PR, not merely pre-existing nearby code.
 3. Suggest the smallest refactor that fits the surrounding codebase patterns.
 4. Weigh the cost: do not ask for a new abstraction unless it reduces real duplication, coupling, or reasoning burden now.
-5. Before claiming the PR duplicates something or should reuse an existing helper, find it with `search_code`. Name the file:line of the thing it should have reused, or do not make the claim.
+5. Before claiming the PR duplicates something or should reuse an existing helper, find it: `code-intel search --context snippets` or `search_code`. Name the file:line of the thing it should have reused, or do not make the claim.
 
 **Risk guide:**
 - blocker: Smell creates a high-risk maintenance trap likely to cause defects across modules soon
@@ -483,7 +543,7 @@ For each potential issue:
 2. Is this coupling necessary or incidental?
 3. Would a new team member understand where to make changes?
 4. Is this over-engineered for the current requirements, or appropriately future-proofed?
-5. Confirm boundary and cycle claims with `explore_dependency_graph` on the touched modules. A cycle you inferred from import statements in the diff may already be broken by an interface you cannot see.
+5. Confirm boundary and cycle claims on the touched modules with `code-intel dependency-graph` or `explore_dependency_graph`. A cycle you inferred from import statements in the diff may already be broken by an interface you cannot see.
 
 **Risk guide:**
 - blocker: Change introduces a serious boundary violation or contract break likely to cascade across subsystems

package/skills/magpie/scripts/__tests__/skill-lint.test.ts

@@ -117,16 +117,63 @@ test('SKILL.md no longer inlines the prompt bodies it moved out', async () => {
     expect(text).not.toContain(`\`\`\`${tag}`)
   }
   // The walkthrough is the always-read part; keep it small enough to be cheap.
-  // Raised from 2600 when the sharded-dispatch and fallback-diff prose was added:
-  // that's real, load-bearing procedure, not bloat.
-  expect(text.split(/\s+/).length).toBeLessThan(3000)
+  // Raised from 2600 when the sharded-dispatch and fallback-diff prose was added,
+  // then from 3000 for the two code-intelligence interfaces: that's real,
+  // load-bearing procedure, not bloat.
+  expect(text.split(/\s+/).length).toBeLessThan(3250)
 })
 
 test('SKILL.md never instructs the agent to approve indexing', async () => {
   const text = await readFile(SKILL, 'utf8')
   // A full index is a consent-gated GPU pass. The context stage degrades instead.
+  // Both interfaces expose the same footgun under different names, so both are named.
   expect(text).toContain('approve_indexing')
   expect(text).toMatch(/never call `approve_indexing`|do not call `approve_indexing`/i)
+  expect(text).toMatch(
+    /never run `code-intel index approve`|do not run `code-intel index approve`/i,
+  )
+})
+
+test('SKILL.md stage 3 probes the code-intel CLI before the MCP tools', async () => {
+  const text = await readFile(SKILL, 'utf8')
+  const start = text.indexOf('### 3. Context')
+  expect(start).toBeGreaterThan(-1)
+  const section = text.slice(start, text.indexOf('\n### 4.', start))
+  // Both interfaces drive the same daemon, but the CLI names the workspace on every
+  // call, so it carries no session binding to leak past cleanup. Prefer it.
+  expect(section).toContain('command -v code-intel')
+  expect(section).toContain('mcp__code-intelligence__')
+  expect(section.indexOf('code-intel')).toBeLessThan(section.indexOf('mcp__code-intelligence__'))
+})
+
+test('SKILL.md gives CODE_INTELLIGENCE a value per interface', async () => {
+  const text = await readFile(SKILL, 'utf8')
+  // The scout and specialist prompts branch on this, so all three values must be
+  // spelled out where the probe assigns them.
+  for (const value of [
+    'CODE_INTELLIGENCE=cli',
+    'CODE_INTELLIGENCE=mcp',
+    'CODE_INTELLIGENCE=unavailable',
+  ]) {
+    expect(text).toContain(value)
+  }
+})
+
+test('the rebind instruction is scoped to the MCP interface everywhere it appears', async () => {
+  const text = await readFile(SKILL, 'utf8')
+  // A CLI run holds no session binding, so an unconditional rebind sends the agent
+  // after an MCP tool that is not in its tool list.
+  const spans: ReadonlyArray<readonly [string, string]> = [
+    ['### 4. Specialists', '\n### 5.'],
+    ['### 10. Cleanup', '\n## '],
+    ['## Aborting', ''],
+  ]
+  for (const [from, to] of spans) {
+    const start = text.indexOf(from)
+    expect(start).toBeGreaterThan(-1)
+    const section = to ? text.slice(start, text.indexOf(to, start)) : text.slice(start)
+    expect(section).toMatch(/CODE_INTELLIGENCE=mcp|MCP path/)
+  }
 })
 
 test('SKILL.md logs codeIntelligence on both the done and skipped context outcomes', async () => {
@@ -295,34 +342,69 @@ test('SKILL.md has the stage walkthrough', async () => {
   expect(text).toMatch(/magpie cleanup/)
 })
 
-test('references/specialists.md carries the codebase-intelligence block', async () => {
+const intelligenceBlock = (text: string, iface: 'cli' | 'mcp') => {
+  const fence = `\`\`\`magpie-codebase-intelligence-${iface}`
+  const start = text.indexOf(fence)
+  expect(start).toBeGreaterThan(-1)
+  return text.slice(start, text.indexOf('\n```', start + fence.length))
+}
+
+test('references/specialists.md carries a codebase-intelligence block per interface', async () => {
+  const text = await readFile(ref('specialists.md'), 'utf8')
+  for (const iface of ['cli', 'mcp'] as const) {
+    const block = intelligenceBlock(text, iface)
+    expect(block).toContain('indexing_in_progress')
+    // The one operation a specialist must never perform, under either name.
+    expect(block).toMatch(/never (call `approve_indexing`|run `code-intel index approve`)/i)
+  }
+})
+
+test('the CLI intelligence block names the workspace per call instead of binding', async () => {
+  const text = await readFile(ref('specialists.md'), 'utf8')
+  const block = intelligenceBlock(text, 'cli')
+  // The CLI has no bind_workspace: every invocation carries --repo, which is what
+  // lets the five specialists query the same worktree in parallel without a
+  // session binding they could clobber for each other.
+  expect(block).not.toContain('bind_workspace')
+  expect(block).toContain('--repo')
+  expect(block).toContain('--json')
+})
+
+test('the MCP intelligence block still binds the workspace first', async () => {
   const text = await readFile(ref('specialists.md'), 'utf8')
-  expect(text).toContain('```magpie-codebase-intelligence')
-  const start = text.indexOf('```magpie-codebase-intelligence')
-  const block = text.slice(start, text.indexOf('```', start + 32))
-  expect(block).toContain('bind_workspace')
-  expect(block).toContain('indexing_in_progress')
-  // The one operation a specialist must never perform.
-  expect(block).toMatch(/never call `approve_indexing`|do not call `approve_indexing`/i)
+  expect(intelligenceBlock(text, 'mcp')).toContain('bind_workspace')
 })
 
-test('every focus block names the code-intelligence tool for its focus', async () => {
+test('every focus block names its intelligence capability on both interfaces', async () => {
   const text = await readFile(ref('specialists.md'), 'utf8')
-  const tools: Record<(typeof FOCUSES)[number], string> = {
-    security: 'trace_data_flow',
-    bugs: 'get_call_hierarchy',
-    performance: 'find_affected_code',
-    'code-smells': 'search_code',
-    architecture: 'explore_dependency_graph',
+  // A focus block reaches whichever interface the probe found, so naming only the
+  // MCP tool leaves a CLI specialist with a verb it cannot invoke.
+  const tools: Record<(typeof FOCUSES)[number], readonly [string, string]> = {
+    security: ['trace_data_flow', 'investigate --mode data'],
+    bugs: ['get_call_hierarchy', 'code-intel call-hierarchy'],
+    performance: ['find_affected_code', 'investigate --mode impact'],
+    'code-smells': ['search_code', 'code-intel search'],
+    architecture: ['explore_dependency_graph', 'code-intel dependency-graph'],
   }
   for (const focus of FOCUSES) {
     const fence = `\`\`\`magpie-specialist-${focus}`
     const start = text.indexOf(fence)
     const block = text.slice(start, text.indexOf('```', start + fence.length))
-    expect(block).toContain(tools[focus])
+    for (const tool of tools[focus]) expect(block).toContain(tool)
   }
 })
 
+test('references/scout.md documents both intelligence interfaces', async () => {
+  const text = await readFile(ref('scout.md'), 'utf8')
+  // The scout is dispatched with the same <<CODE_INTELLIGENCE>> value the
+  // specialists get, so it has to know what `cli` and `mcp` each mean.
+  expect(text).toContain('`cli`')
+  expect(text).toContain('`mcp`')
+  expect(text).toContain('code-intel ')
+  expect(text).toContain('bind_workspace')
+  expect(text).toMatch(/never (call `approve_indexing`|run `code-intel index approve`)/i)
+})
+
 test('the output contract tells specialists to look before they hedge', async () => {
   const text = await readFile(ref('specialists.md'), 'utf8')
   const contract = text.slice(0, text.indexOf('```magpie-specialist-'))

package/skills/magpie/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "magpie",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "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 (falling back to a Claude second opinion when codex is unavailable), and serves an interactive HTML report for selecting findings to post via gh. Bundles a Bun CLI installed onto PATH via the skill's postinstall step. Use when the user asks to review a GitHub pull request. Splits oversized diffs into budgeted shards and rebuilds the diff from the local clone when gh pr diff refuses it.",
   "author": "iceinvein",
   "type": "prompt",

package/skills/sluice/references/status.md

@@ -36,9 +36,11 @@ follow from that being worth guaranteeing: a value beginning with `--` is
 rejected rather than accepted as a value, and a flag with no value at all is
 rejected rather than taking the next flag as one.
 
-Gitignore `.sluice/`. It is working state, and everything durable in it lands
-somewhere else anyway: the commits are in git and the reasons are in the record,
-which is the file that does get committed.
+The directory ignores itself: `init` drops a `.gitignore` holding `*` next to
+the state, so no project has to add a line of its own. It is working state, and
+everything durable in it lands somewhere else anyway: the commits are in git and
+the reasons are in the record, which is the file that does get committed. Delete
+that `.gitignore` if you want a run tracked; it is only written when absent.
 
 Open it with `init` when you open the run record, at the same point and for the
 same reason, then seed the rows with `plan.sh import <plan>` rather than a

package/skills/sluice/scripts/status.sh

@@ -19,7 +19,8 @@
 #   status.sh close
 #
 # --dir <path> selects the tree to read (default: $PWD). State lives at
-# <dir>/.sluice/run.json and closed runs at <dir>/.sluice/archive/.
+# <dir>/.sluice/run.json and closed runs at <dir>/.sluice/archive/. The
+# directory ignores itself, so no project needs a .gitignore line for it.
 #
 # Exit: 0 ok, 1 the state could not be written, 2 no live run, 3 a run is
 # already live, 4 bad arguments, 5 jq missing, 6 the state file is unreadable.
@@ -220,6 +221,17 @@ require_readable() {
 	}
 }
 
+# The run state is working state, not history: the run record is what gets
+# committed. So the directory ignores itself, rather than every repo sluice ever
+# runs in having to add a line to its own .gitignore. `*` matches the .gitignore
+# file too, so the whole directory drops out of `git status`. An existing file is
+# left alone, and a tree that refuses the write still gets its run.
+mk_dir() { # <directory to create under .sluice>
+	mkdir -p "$1" || { err "could not create $1"; exit 1; }
+	local ignore="$DIR/.sluice/.gitignore"
+	[ -e "$ignore" ] || printf '*\n' >"$ignore" 2>/dev/null || true
+}
+
 # Written through a temporary file so an interrupted write cannot leave the
 # run state half-serialised, which would read as a corrupted run rather than
 # as a failed command.
@@ -263,7 +275,7 @@ case "$SUB" in
 			exit 3
 		fi
 
-		mkdir -p "$DIR/.sluice"
+		mk_dir "$DIR/.sluice"
 		jq -n \
 			--arg topic "$TOPIC" \
 			--arg channel "$CHANNEL" \
@@ -526,7 +538,7 @@ case "$SUB" in
 		stamp="$(printf '%s' "$started" | tr -cd '0-9TZ')"
 		slug="$(printf '%s' "${topic:-run}" | tr -cs 'A-Za-z0-9._-' '-')"
 		[ -n "$stamp" ] || stamp="unknown"
-		mkdir -p "$ARCHIVE"
+		mk_dir "$ARCHIVE"
 
 		# The archive holds the only copy of a closed run, and two runs sharing a
 		# start second and a topic name the same file. mv would leave one of them,

package/skills/sluice/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "sluice",
-  "version": "0.12.1",
+  "version": "0.12.2",
   "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 seven 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 and one status command can answer where the run is, 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. Claude Code only; stands down where the superpowers pipeline governs the repo.",
   "author": "iceinvein",
   "type": "prompt",