@iceinvein/agent-skills 0.23.8 → 0.23.12

package/package.json

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

package/skills/index.json

@@ -227,7 +227,7 @@
     "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 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.5"
+    "version": "0.16.0"
   },
   {
     "name": "migrate",
@@ -293,9 +293,9 @@
   },
   {
     "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), lists every live deep run and routed fast or main session on the machine in one board.sh view (drawn once, watched, or as JSON), 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.",
+    "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. Deep runs read the repo before designing, map the spec's intent to its decisions, and check spec against intent and plan against spec with a fresh reader, with plan.sh validate enforcing that every decision is covered. 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), lists every live deep run and routed fast or main session on the machine in one board.sh view (drawn once, watched, or as JSON), 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.27.0"
+    "version": "0.28.2"
   },
   {
     "name": "temporal-coupling-detector",

package/skills/magpie/README.md

@@ -35,7 +35,7 @@ If you cloned this repo and want to run from source, you can also invoke `./inst
 
 Inside Claude Code, ask: "Review PR 1234" (or paste a PR URL). The agent reads SKILL.md and walks the pipeline; the CLI runs as `magpie setup`, `magpie serve`, etc.
 
-An implementing or orchestrating agent can also ask for a review of its own branch before a PR exists: local mode (`magpie setup <run-dir> --local [--base <ref>]`) reviews the merge base to working tree diff in place and hands the ranked findings back as terminal text via `magpie handoff`, with no server, report or posting.
+An implementing or orchestrating agent can also ask for a review of its own branch before a PR exists: local mode (`magpie setup <run-dir> --local [--base <ref>]`) reviews the merge base to working tree diff in place and hands the ranked findings back as terminal text via `magpie handoff`, with no server, report or posting. `/magpie` with no arguments runs local mode; pass a PR number or URL to review a PR.
 
 ## Development
 

package/skills/magpie/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: magpie
 description: Use when the user asks to review a GitHub pull request (a PR number, PR URL, or "review this PR"), or to self-review the current branch diff before a PR exists, typically requested by an implementing or orchestrating agent, with findings handed back in the terminal. Interactive PR review pipeline; five parallel specialist subagents, dedupe, critic, codex/Claude peer review, and an interactive HTML report for posting selected findings via gh. Follow the stage walkthrough in this skill; the description is not the procedure.
-argument-hint: "[<pr#>|<pr-url>|local] [--base <ref>] [--intent-file <path>]"
+argument-hint: "[<pr#>|<pr-url>|local (default)] [--base <ref>] [--intent-file <path>]"
 ---
 
 # Magpie
@@ -16,7 +16,7 @@ Stop reading and follow these steps in order. Do not skip stages. Use the exact
 
 ### 0. Identify the PR
 
-A request with no PR that asks to review the current branch, the working tree, or work in progress, or arguments starting `local` (any `--base` or `--intent-file` after it go to setup), is local mode: follow "Local mode" below in place of this step and stages 1 and 2, then run stages 3 to 7 as written, taking `TARGET` from Local mode.
+A bare invocation (no arguments and no PR named), a request with no PR that asks to review the current branch, the working tree, or work in progress, or arguments starting `local` or `--` (any `--base` or `--intent-file` go to setup), is local mode: follow "Local mode" below in place of this step and stages 1 and 2, then run stages 3 to 7b as written, taking `TARGET` from Local mode.
 
 Parse the user's request for a PR number, URL, or "this PR" (current branch). If ambiguous, ask one clarifying terminal question. Capture the PR number into `$PR_NUMBER` and the repo path into `$REPO` (default: the current working directory).
 
@@ -54,14 +54,12 @@ Setup then splits the filtered diff into shards, writing `$RUN_DIR/shards/manife
 and, when more than one shard results, `$RUN_DIR/shards/shard-<n>.patch`. `diff.patch`
 itself is never modified: shards are views over it. Re-split with a different budget
 using `magpie shard "$RUN_DIR" --budget <lines> --max-files <n>` (defaults: 6000 patch
-lines, 80 files). Re-splitting invalidates every existing
-`findings/<focus>.shard-<n>.json`, since a shard id then names a different file set:
-delete those files first, or stage 4's resume rule counts a pair as covered that
-nothing reviewed.
+lines, 80 files). Delete every `findings/<focus>.shard-<n>.json` before re-splitting:
+shard ids then name different files, and stage 4's resume rule would trust them.
 
-When a prior run exists for the same PR (active or archived under `~/.magpie/`), setup writes `$RUN_DIR/incremental.json` with `{previousRunId, previousSha, currentSha, sameSha}`. The post stage surfaces this as a "Incremental review since `<sha>`" trailer on the summary comment.
+Setup writes `pr-activity.json` (checks, review threads, comments) and, on a re-review, `incremental.json` and `previous-findings.json` (last run's posted findings, whether their quoted code changed, and its dismissals).
 
-Setup also runs a deterministic test-coverage check: when the diff contains zero test or spec files anywhere, each non-test source file with `>= 10` added code lines gets a `domain: "tests"` finding in `$RUN_DIR/findings/tests.json`. That domain flows through dedupe/critic/peer-review like the LLM findings; no subagent is dispatched for it.
+Setup also runs a deterministic test-coverage check: when the diff contains zero test or spec files anywhere, each non-test source file with `>= 10` added code lines gets a `domain: "tests"` finding in `$RUN_DIR/findings/tests.json`, reviewed downstream like the rest; no subagent is dispatched for it.
 
 ### 2. Serve
 
@@ -71,9 +69,9 @@ Start the HTML server in the background using the Bash tool with `run_in_backgro
 magpie serve "$RUN_DIR"
 ```
 
-Read `$RUN_DIR/state/server-info` for the URL; the server writes it asynchronously, so if it is missing, wait a moment and re-read (it appears within ~1s). Print to the user: "Open <url> in your browser to follow along."
+Read `$RUN_DIR/state/server-info` for the URL (written within ~1s; re-read if missing). Print to the user: "Open <url> in your browser to follow along."
 
-The server shuts down after 30 idle minutes (an open report tab keeps it up) and deletes `state/server-info`. Nothing in the pipeline depends on it: re-run `magpie serve "$RUN_DIR"` to bring the report back.
+The server stops after 30 idle minutes (an open report tab keeps it up); nothing depends on it, so re-run `magpie serve "$RUN_DIR"` to bring the report back.
 
 Render the first progress paint:
 
@@ -96,9 +94,11 @@ Append `{stage: context, status: done}` and re-render progress. If the scout wro
 Read `references/specialists.md` now, before dispatching anything: it holds the five focus blocks and the output contract every specialist prompt is built from. Assemble prompts from that file verbatim; written from memory they drift off the JSON contract, and `magpie dedupe` drops findings it cannot parse.
 
 Append `{stage: specialists, status: running}` to `$RUN_DIR/log.jsonl` and re-render
-progress, so the served page shows the stage as active rather than "Paused". Then read
+progress. Then read
 `$RUN_DIR/shards/manifest.json`.
 
+Run `magpie history "$RUN_DIR"` once; any output is part 6 of every specialist prompt.
+
 **One shard, zero shards, or no manifest** (a diff filtered down to nothing, e.g. a
 lockfile-only PR, yields `shards: []` in an otherwise normal manifest; a run predating
 this feature has no manifest at all): dispatch the five specialists in a single message,
@@ -118,14 +118,11 @@ many small files is split by the 80-file cap, so a larger `--budget` alone chang
 nothing); or review only the highest-risk shards, which means appending
 `{stage: shard-coverage, status: partial, reviewed: [<ids>], skipped: [<ids>]}` to
 `$RUN_DIR/log.jsonl` and telling the user in the terminal which shards go unreviewed.
-That log entry is the only record of the gap: the report has no unreviewed marker.
-Wait for the answer. This is the only interactive gate in the pipeline before the
-report, and it exists so that neither the cost nor a coverage gap is ever silent.
+The report, summary comment and handoff name the skipped shards from that entry.
+Wait for the answer; neither cost nor a coverage gap is ever silent.
 
 Dispatch by wave, one shard per wave, the five focuses in parallel within a wave,
-re-rendering progress between waves. That holds in-flight agents at five and makes a
-crash cheap to resume: only the `(focus, shard)` pairs whose findings file is missing
-need re-dispatching.
+re-rendering progress between waves. That holds in-flight agents at five.
 
 After each subagent returns, append
 `{stage: specialist, focus: <focus>, shard: <n>, status: done, findings: <count>}` to
@@ -204,13 +201,17 @@ If codex returns non-zero on a batch, do not abort: record `{stage: peer-review,
 
 **Apply the verdicts (both paths).** Parse the merged verdicts and apply the `update` / `add` entries (an empty array means no change). A peer `fields.severity` (or `finding.severity` on an `add`) is ignored: severity is derived from `risk.impact`. Mint each `add`'s `id` as above before merging, since the peer contract does not carry ids. Then write `findings.final.json`. Re-render progress.
 
+### 7b. Proof
+
+Append `{stage: proof, status: running}` and re-render progress. `magpie proof-prompt "$RUN_DIR"` fills `references/proof.md` for up to 8 serious findings, printing `<prompt path>\t<output path>` each. On a PR run with any printed, first install `$WORKTREE`'s dependencies once with the repo's frozen-lockfile command (`npm ci`, `uv sync --frozen`, ...); on failure log `{stage: proof-deps, status: skipped, error}` and go on. Dispatch the prompts as stage 6 does its batches, then `magpie proof-apply "$RUN_DIR"`: it drops disproved findings to `proof-dropped.json`, marks the rest and logs `done`. On a non-zero exit, delete only the `proof-<id>.json` files or leftovers stderr names, then re-dispatch or re-apply.
+
 ### 8. Report
 
 ```
 magpie render "$RUN_DIR" findings
 ```
 
-The report shows the top 10 recommended (`must-fix`/`should-fix`, highest score first) and folds the rest. `--top <n>` is not saved (the stage 9 re-render and `magpie serve`'s auto-refresh show 10 again), so use it only when nothing will re-render.
+The report shows the top 10 recommended (`must-fix`/`should-fix`, highest score first) and folds the rest. `--top <n>` is not saved, so use it only when nothing will re-render.
 
 Append `{stage: report, status: done}` to `$RUN_DIR/log.jsonl` and re-render progress (the render CLI does not log this itself, and `magpie status` needs the `done` entry to resume past `report`).
 
@@ -294,9 +295,9 @@ The JSON output tells you `lastCompleted` and `next`. Resume from `next`:
 - Local run at `next: cleanup`: if the caller has not been sent the findings, re-run `magpie handoff` first (it only reads files).
 - 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:
-  read `shards/manifest.json`, and re-dispatch only the pairs with no
-  `findings/<focus>.shard-<n>.json`. Never re-shard mid-run without deleting those
-  files first (stage 1): the check would otherwise trust ids that moved.
+  re-dispatch only the pairs with no `findings/<focus>.shard-<n>.json`, skipping
+  shards a `shard-coverage: partial` entry skipped. Never re-shard mid-run without
+  deleting those files first (stage 1): shard ids move.
 - Non-null `error` means the run stopped on a failed stage. Report which stage to the user and confirm before re-running it.
 
 The original server is gone. Restart it with `magpie serve "$RUN_DIR"` (step 2) before re-rendering, so the user gets a live URL again.

package/skills/magpie/bin/magpie.ts

@@ -13,6 +13,8 @@ Subcommands:
                              (default origin/HEAD), committed and uncommitted
   target <run-dir>           Print the directory findings are anchored against
   handoff <run-dir>          Print local review findings as a ranked list
+  history <run-dir>          Print what is already on the PR (open threads, comments,
+                             dismissals, failing checks) for the specialist prompts
   serve <run-dir-or-id>      Start the HTML server (accepts active or archived run id)
   dedupe <run-dir>           Merge specialist findings into deduped set
   critic-prompt <run-dir> [--batch-size N]
@@ -20,13 +22,20 @@ Subcommands:
   critic-apply <run-dir> [--design-cap N]
                              Apply critic verdicts, write findings.kept.json (no cap on
                              code-smells + architecture keeps unless --design-cap is given)
+  proof-prompt <run-dir>     Write one proof prompt per serious finding, print prompt and
+                             output paths
+  proof-apply <run-dir>      Fold proof results into findings.final.json, drop the disproved
   shard <run-dir> [--budget N] [--max-files N]
-                             Re-split diff.patch into budgeted shards
+                             Re-split diff.patch into budgeted shards (and the
+                             impact map's per-shard files, when impact.json exists)
+  impact <run-dir>           Write impact.json and impact*.md: what outside the diff
+                             the change touches
   render <run-dir> <page> [--top N]
                              Render progress.html or findings.html (findings recommends
                              the top N, default 10, and folds the rest)
   labels <run-dir>           Write labels.json (posted, dismissed, ignored per finding)
-  cleanup <run-dir>          Remove worktree, stop server, write labels, archive run
+  cleanup <run-dir>          Remove worktree, stop server, write labels, archive run,
+                             delete saved refs of closed PRs
   status <run-dir>           Print highest completed stage
   open [id]                  Open findings.html in your browser (defaults to latest run)
   post <run-dir> --ids a,b   Post the given finding ids via gh (rich body + optional summary)
@@ -244,6 +253,24 @@ const HANDLERS: Record<string, Handler> = {
     const { runCriticApply } = await import('../scripts/critic-cmd.ts')
     return runCriticApply(runDir, designCap !== undefined ? { designCap } : {})
   },
+  'proof-prompt': async (args) => {
+    const runDir = args[0]
+    if (!runDir) {
+      process.stderr.write('proof-prompt: missing <run-dir>\n')
+      return 2
+    }
+    const { runProofPrompt } = await import('../scripts/proof-cmd.ts')
+    return runProofPrompt(runDir)
+  },
+  'proof-apply': async (args) => {
+    const runDir = args[0]
+    if (!runDir) {
+      process.stderr.write('proof-apply: missing <run-dir>\n')
+      return 2
+    }
+    const { runProofApply } = await import('../scripts/proof-cmd.ts')
+    return runProofApply(runDir)
+  },
   shard: async (args) => {
     const runDir = args[0]
     if (!runDir) {
@@ -283,8 +310,25 @@ const HANDLERS: Record<string, Handler> = {
     process.stdout.write(
       `${manifest.shards.length} shard(s), ${manifest.totalFiles} files, ${manifest.totalLines} patch lines\n`,
     )
+    // The impact map's per-shard files name shard ids, which the re-split just renumbered.
+    // runImpact reports its own outcome; the split itself has already succeeded.
+    const { existsSync } = await import('node:fs')
+    const { join } = await import('node:path')
+    if (existsSync(join(runDir, 'impact.json'))) {
+      const { runImpact } = await import('../scripts/impact-cmd.ts')
+      await runImpact(runDir)
+    }
     return 0
   },
+  impact: async (args) => {
+    const runDir = args[0]
+    if (!runDir || runDir.startsWith('-')) {
+      process.stderr.write('impact: missing <run-dir>\n')
+      return 2
+    }
+    const { runImpact } = await import('../scripts/impact-cmd.ts')
+    return runImpact(runDir)
+  },
   render: async (args) => {
     const runDir = args[0]
     const page = args[1]
@@ -306,6 +350,22 @@ const HANDLERS: Record<string, Handler> = {
     const { runRender } = await import('../scripts/render-cmd.ts')
     return runRender(runDir, page, topN !== undefined ? { topN } : {})
   },
+  history: async (args) => {
+    const runDir = args[0]
+    if (!runDir || runDir.startsWith('-')) {
+      process.stderr.write('history: missing <run-dir>\n')
+      return 2
+    }
+    const { readHistory, renderHistory } = await import('../scripts/history.ts')
+    try {
+      const text = renderHistory(await readHistory(runDir))
+      if (text !== '') process.stdout.write(`${text}\n`)
+    } catch (err) {
+      process.stderr.write(`history: ${err instanceof Error ? err.message : String(err)}\n`)
+      return 1
+    }
+    return 0
+  },
   labels: async (args) => {
     const runDir = args[0]
     if (!runDir) {
@@ -335,6 +395,7 @@ const HANDLERS: Record<string, Handler> = {
       runDir,
       repoPath,
       gitBin: process.env.MAGPIE_GIT_BIN || 'git',
+      ghBin: process.env.MAGPIE_GH_BIN || 'gh',
       killGraceMs,
     })
   },

package/skills/magpie/evals/README.md

@@ -1,7 +1,7 @@
 # magpie evals
 
-Six cases for `claude plugin eval`. Every one starts mid-pipeline, because the
-decisions this skill owns are the ones between the CLI calls: `scripts/__tests__/`
+Seven cases for `claude plugin eval`. Each starts at a decision rather than at
+the top of a run, most of them mid-pipeline, because the decisions this skill owns are the ones between the CLI calls: `scripts/__tests__/`
 already pins what `magpie setup`, `dedupe`, `shard`, `post` and `status` compute.
 What no unit test can reach is whether the agent stops where the walkthrough says
 stop, falls back where it says fall back, and keeps its hands off the things it
@@ -15,6 +15,7 @@ must not touch.
 | `post-folds-selection-events` | The user typed `post` after re-ticking | Folds `state/events` last-event-wins, posts `bugs-1,perf-1` only |
 | `resume-finds-active-run` | A fresh review ask on a PR with a live run | Checks `--list-runs` first, never calls `setup`, surfaces the interrupted run |
 | `local-mode-hands-back` | A local run resumed after peer review | Runs `handoff` then `cleanup`, replies with both finding titles, never serves, renders, posts or calls `gh` |
+| `bare-invocation-goes-local` | A bare `/magpie` on a branch with an open PR | Runs `setup --local`, never `--pr`, never calls `gh` |
 
 ## Running
 
@@ -59,8 +60,8 @@ bun run eval:fresh accept skills/magpie <result.json>
 
 `rules.json` maps each rule the skill states to the cases that pin it, or says
 why none does; `diff` reads it to name rules at risk or ready to expire. What
-each verdict means is in `skills/sluice/evals/README.md`. No baseline has been
-accepted yet.
+each verdict means is in `skills/sluice/evals/README.md`. The accepted baseline
+is `baselines/claude-opus-5-5.json`.
 
 ## How the fixtures fake the pipeline
 
@@ -121,6 +122,16 @@ reported as pass/fail indicators, because they can never pass without the
 plugin. They are there to tell you whether a score came from magpie or from the
 model's own habits.
 
+`bare-invocation-goes-local` has no such grader. Its prompt is `/magpie`, which
+the child expands as a slash command, so the skill loads without a `Skill` call
+and the trace does not record the load. `setup-ran-local` stands in for it: only
+SKILL.md tells the agent to run `magpie setup --local`.
+
+That case needs git in the child for the branch slug, and the xcrun shim at
+`/usr/bin/git` fails in the sandbox, so its fixture puts a `git` wrapper on the
+shims path that execs `/Library/Developer/CommandLineTools/usr/bin/git`. On a
+machine without the Command Line Tools, point the wrapper at that machine's git.
+
 **Every `llm` grader carries `focus: last_message`.** Without it the judge is
 handed a window of the whole trace, and in a case that reads a 40,000-line diff
 the handback falls outside that window: the shard-gate rubric voted FAIL nine
@@ -175,7 +186,10 @@ Its default effort is `medium` where Claude Opus 5's is `high`, so a rubric that
 starts failing there is worth reading as a real behavioural difference before
 it is loosened.
 
-Not yet known: no case has been run with the no-plugin baseline arm, so the
-ablation delta is unmeasured, and no case other than the shard gate has been
-repeated within one invocation, so the per-case variance is only bounded by
-those two clean passes.
+The current baseline (skill 0.15.0, CLI 2.1.306, 2026-10-21) ran every case
+three times in both arms on Claude Opus 5.5, USD 10.31 and nine and a half
+minutes at `-j 3`. Every case scored 1.00 with the plugin on all three runs
+except `local-mode-hands-back`, which scored 0.80 once: the judge failed
+`reply-lists-both-findings` 3/3 on that run, and its trace was not kept. Without
+the plugin the cases score 0.40 to 0.78, so each one measures the skill rather
+than the model's habits.

package/skills/magpie/evals/bare-invocation-goes-local/case.yaml

@@ -0,0 +1,4 @@
+schema_version: "1.1"
+name: bare-invocation-goes-local
+context:
+  scaffold_script: fixture.sh

package/skills/magpie/evals/bare-invocation-goes-local/fixture.sh

@@ -0,0 +1,159 @@
+#!/usr/bin/env bash
+# A bare /magpie on a feature branch that already has an open PR. With no PR
+# named, the walkthrough routes to local mode, so the open PR is a lure: the
+# gh fake answers `gh pr view` with it, and the case passes only if gh is never
+# asked.
+#
+# The branch is an orphan history (it was imported, not branched from main), so
+# no base has a merge base with it and the real `setup --local` fails in
+# localBranchDiff. The walkthrough stops on a failed setup, which keeps the case
+# to the routing decision: nothing past setup is dispatched or graded.
+set -euo pipefail
+
+BRANCH="feat/tenant-settings-cache"
+CALLS="$PWD/.magpie-calls.log"
+REPO="$PWD"
+
+mkdir -p "$HOME/shims" "$HOME/tmp"
+: > "$CALLS"
+
+cat > "$HOME/shim-config" <<EOF
+CALLS="$CALLS"
+REPO="$REPO"
+EOF
+
+# The real magpie and gh are outside the eval sandbox and cannot be executed
+# from inside it, so the child gets fakes rather than exit 126.
+cat > "$HOME/.zshenv" <<'RC'
+export PATH="$HOME/shims:/usr/bin:/bin:/usr/sbin:/sbin"
+export TMPDIR="$HOME/tmp"
+RC
+
+# /usr/bin/git is the xcrun shim, which cannot write its cache in the sandbox,
+# and local mode needs git for the branch slug. The Command Line Tools binary
+# runs when called by full path (skills/sluice/evals/README.md has the details).
+cat > "$HOME/shims/git" <<'SHIM'
+#!/bin/sh
+exec /Library/Developer/CommandLineTools/usr/bin/git "$@"
+SHIM
+chmod +x "$HOME/shims/git"
+
+# setup --local makes the checks scripts/local-diff.ts makes, with the same
+# messages, and writes what setup-cmd.ts writes for a local run when they pass.
+# The PR path is not faked: reaching it fails the case.
+cat > "$HOME/shims/magpie" <<'SHIM'
+#!/usr/bin/env bash
+. "$HOME/shim-config"
+echo "magpie $*" >> "$CALLS"
+case "${1:-}" in
+  --list-runs) ;;
+  setup)
+    shift
+    run_dir="$1"; shift
+    local_mode=0 base="origin/HEAD" repo="$PWD"
+    while [ $# -gt 0 ]; do
+      case "$1" in
+        --local) local_mode=1 ;;
+        --base) base="$2"; shift ;;
+        --repo) repo="$2"; shift ;;
+        --intent-file) shift ;;
+      esac
+      shift
+    done
+    if [ "$local_mode" = 0 ]; then
+      echo "fake magpie: PR setup is not faked" >&2
+      exit 64
+    fi
+    mkdir -p "$run_dir/findings"
+    if ! git -C "$repo" rev-parse --verify -q "$base^{commit}" > /dev/null; then
+      echo "{\"stage\":\"local-diff\",\"status\":\"error\",\"error\":\"cannot resolve base ref $base to a commit\"}" >> "$run_dir/log.jsonl"
+      echo "magpie: cannot resolve base ref $base to a commit" >&2
+      exit 4
+    fi
+    if ! merge_base=$(git -C "$repo" merge-base "$base" HEAD); then
+      echo "{\"stage\":\"local-diff\",\"status\":\"error\",\"error\":\"no merge base between $base and HEAD: \"}" >> "$run_dir/log.jsonl"
+      echo "magpie: no merge base between $base and HEAD: " >&2
+      exit 4
+    fi
+    head=$(git -C "$repo" rev-parse HEAD)
+    branch=$(git -C "$repo" symbolic-ref --short -q HEAD || true)
+    git -C "$repo" diff --no-color --no-ext-diff "$merge_base" > "$run_dir/diff.patch"
+    printf '{ "mode": "local", "root": "%s" }\n' "$repo" > "$run_dir/target.json"
+    git -C "$repo" log --format=%H%x1f%s%x1f%b%x1e "$merge_base..HEAD" |
+      python3 -c '
+import json, sys
+branch, base, merge_base, head = sys.argv[1:]
+commits = []
+for record in sys.stdin.read().split("\x1e"):
+    if record.strip():
+        oid, headline, body = record.strip("\n").split("\x1f")
+        commits.append({"oid": oid, "headline": headline, "body": body.strip()})
+print(json.dumps({"branch": branch or None, "baseRef": base, "mergeBase": merge_base, "head": head,
+                  "dirty": False, "author": "Asha Platform", "commits": commits, "intentFile": None}, indent=2))
+' "$branch" "$base" "$merge_base" "$head" > "$run_dir/local.json"
+    echo '[]' > "$run_dir/findings/tests.json"
+    printf '%s\n' '{"stage":"preflight","status":"done","missingOptional":["codex"]}' '{"stage":"setup","status":"done"}' > "$run_dir/log.jsonl"
+    echo "magpie: codex not found; peer review will use a Claude subagent"
+    echo "setup done: $run_dir"
+    ;;
+  target)
+    python3 -c 'import json, sys; print(json.load(open(sys.argv[1]))["root"])' "${2}/target.json"
+    ;;
+  *) echo "fake magpie: unsupported subcommand: $*" >&2; exit 64 ;;
+esac
+SHIM
+chmod +x "$HOME/shims/magpie"
+
+cat > "$HOME/shims/gh" <<'SHIM'
+#!/usr/bin/env bash
+. "$HOME/shim-config"
+echo "gh $*" >> "$CALLS"
+if [ "${1:-} ${2:-}" = "pr view" ] || [ "${1:-} ${2:-}" = "pr list" ]; then
+  echo '{"number":1337,"title":"feat: cache tenant settings","headRefName":"feat/tenant-settings-cache","state":"OPEN"}'
+  exit 0
+fi
+echo "fake gh: no request was made" >&2
+exit 1
+SHIM
+chmod +x "$HOME/shims/gh"
+
+export GIT_CONFIG_NOSYSTEM=1 GIT_CONFIG_GLOBAL=/dev/null
+git init -q -b main .
+git config commit.gpgsign false
+printf '.magpie-calls.log\n' >> .git/info/exclude
+export GIT_AUTHOR_NAME="Asha Platform" GIT_AUTHOR_EMAIL="asha@example.com"
+export GIT_COMMITTER_NAME="Asha Platform" GIT_COMMITTER_EMAIL="asha@example.com"
+mkdir -p src/settings
+
+cat > src/settings/cache.ts <<'TS'
+const store = new Map<string, Settings>()
+
+export function clear() {
+  store.clear()
+}
+TS
+
+git add src
+git commit -q -m "feat: tenant settings store"
+git update-ref refs/remotes/origin/main HEAD
+git symbolic-ref refs/remotes/origin/HEAD refs/remotes/origin/main
+git checkout -q --orphan "$BRANCH"
+
+cat > src/settings/cache.ts <<'TS'
+const store = new Map<string, Settings>()
+
+export function put(tenantId: string, settings: Settings) {
+  store.set(tenantId, settings)
+}
+
+export function get(tenantId: string): Settings | undefined {
+  return store.get(tenantId)
+}
+
+export function clear() {
+  store.clear()
+}
+TS
+
+git add src
+git commit -q -m "feat: cache tenant settings in the request path"

package/skills/magpie/evals/bare-invocation-goes-local/graders/branch-was-reachable.md

@@ -0,0 +1,5 @@
+---
+type: regex
+pattern: 'export function put\(tenantId'
+target: { source: file, path: src/settings/cache.ts }
+---

package/skills/magpie/evals/bare-invocation-goes-local/graders/never-went-to-a-pr.md

@@ -0,0 +1,7 @@
+---
+type: regex
+pattern: 'magpie setup .*--pr|(^|\n)gh '
+match: not_contains
+target: { source: file, path: .magpie-calls.log }
+weight: 2
+---

package/skills/magpie/evals/bare-invocation-goes-local/graders/setup-ran-local.md

@@ -0,0 +1,6 @@
+---
+type: regex
+pattern: '(^|\n)magpie setup \S+ (\S+ )*--local'
+target: { source: file, path: .magpie-calls.log }
+weight: 3
+---

package/skills/magpie/evals/bare-invocation-goes-local/prompt.md

@@ -0,0 +1,11 @@
+---
+name: bare-invocation-goes-local
+description: A bare /magpie on a branch that already has an open PR reviews the branch in local mode. It never looks the PR up or sets up a PR run.
+tags: [magpie, local, routing, scaffold]
+max_turns: 15
+timeout_seconds: 600
+allowed_tools: [Read, Glob, Grep, Skill, Write, Edit, Bash, Task]
+expected_outcome: Runs magpie setup with --local against the workspace, never --pr, and never calls gh. The branch shares no history with any base, so setup fails and the run stops there, surfacing the error.
+---
+
+/magpie

package/skills/magpie/evals/baselines/claude-opus-5-5.json

@@ -1,10 +1,22 @@
 {
   "model": "claude-opus-5-5",
   "judgeModel": "claude-opus-5-5",
-  "claudeVersion": "2.1.300",
-  "skillVersion": "0.13.0",
-  "date": "2026-10-15T14:11:31.564Z",
+  "claudeVersion": "2.1.306",
+  "skillVersion": "0.15.0",
+  "date": "2026-10-21T16:36:32.144Z",
   "cases": {
+    "bare-invocation-goes-local": {
+      "with": [
+        1,
+        1,
+        1
+      ],
+      "without": [
+        0.5,
+        0.5,
+        0.5
+      ]
+    },
     "codex-missing-falls-back": {
       "with": [
         1,
@@ -17,6 +29,18 @@
         0.5
       ]
     },
+    "local-mode-hands-back": {
+      "with": [
+        1,
+        1,
+        0.8
+      ],
+      "without": [
+        0.4,
+        0.4,
+        0.4
+      ]
+    },
     "post-folds-selection-events": {
       "with": [
         1,