@iceinvein/agent-skills 0.23.7 → 0.23.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iceinvein/agent-skills",
-  "version": "0.23.7",
+  "version": "0.23.9",
   "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.15.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.26.1"
+    "version": "0.28.0"
   },
   {
     "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 7 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).
 

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,

package/skills/magpie/evals/rules.json

@@ -149,6 +149,14 @@
       "cases": [],
       "unpinned": "Only local-mode-hands-back runs cleanup, and local cleanup prints no view-later line by design; no PR case reaches stage 10, and the PR fakes have no cleanup subcommand."
     },
+    {
+      "id": "bare-invocation-is-local-mode",
+      "states": "SKILL.md: 0. Identify the PR",
+      "origin": "commit:fdda718",
+      "cases": [
+        "bare-invocation-goes-local"
+      ]
+    },
     {
       "id": "local-mode-hands-back-via-handoff",
       "states": "SKILL.md: Local mode",

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

@@ -212,6 +212,14 @@ test('SKILL.md sends each stage to the reference file it needs', async () => {
   expect(section('### 7. Peer review')).toContain('references/peer-review.md')
 })
 
+test('a bare /magpie is routed to local mode and the hint says so', async () => {
+  const text = await readFile(SKILL, 'utf8')
+  expect(text).toMatch(/^argument-hint: ".*local \(default\).*"$/m)
+  const start = text.indexOf('### 0. Identify the PR')
+  const routing = text.slice(start, text.indexOf('\n### ', start + 1))
+  expect(routing).toMatch(/bare invocation \(no arguments and no PR named\)[^.]*is local mode/)
+})
+
 test('SKILL.md no longer inlines the prompt bodies it moved out', async () => {
   const text = await readFile(SKILL, 'utf8')
   for (const tag of ['magpie-specialist-', 'magpie-critic', 'magpie-peer-review', 'magpie-scout']) {

package/skills/magpie/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "magpie",
-  "version": "0.14.5",
+  "version": "0.15.0",
   "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",

package/skills/sluice/SKILL.md

@@ -132,6 +132,25 @@ the design's shape turns on a fork only your partner can settle, ask that one
 question through `AskUserQuestion`, with your recommendation, before the design
 is written. `references/deep-channel.md` has the test for what counts.
 
+Read the repo before the walk and before any fork question: prior designs, the
+code beside the path and the stated constraints, each cited by path in the
+spec's `## Context`. A prior spec
+often settles the fork, and nothing can be settled from a repo nobody read.
+`references/deep-channel.md` has it under `## The ground`.
+
+The design carries a `## Trace` section before it goes up for sign-off: the
+request's own example, quoted, walked through the data as it stands, with what
+each reused function requires and writes read from the code. Per-task reviews
+never run that example and the hunt runs it only once every task is built, so
+a design checked only against the shape of the code is wrong for a whole plan
+before anything catches it.
+`references/deep-channel.md` has what the section holds.
+
+Each stop gets a fresh reader first: the intent check before sign-off, the plan
+check after `plan.sh validate` and before pre-flight, because an author reads
+past the gap between what was meant and what was written.
+`references/deep-channel.md` has the briefs under `## The alignment checks`.
+
 Take the design stop through the harness's plan mode where there is one. Its
 gate is enforced rather than requested and it holds edits shut while it is open,
 so nothing gets built against a design nobody signed. It carries the first stop
@@ -160,11 +179,13 @@ plan:
 
 ```
 # Plan: <topic>
+**Spec:** <path to the signed-off design>
 ## Ground Rules
 - <exact value>
 ### Task N: <name>
 **Contract:** Needs: <sig> | Offers: <sig>
 **Touches:** <path> (new) | <path> (edit) | <path> (test)
+**Builds:** <D<n>, ..., or none and why>
 **Flips:** <what changes, from what, or omit>
 **Review:** <reason, or omit>
 **Effort:** <low, and why the work is mechanical, or omit>

package/skills/sluice/evals/README.md

@@ -1,6 +1,6 @@
 # sluice evals
 
-Twenty-one cases for `claude plugin eval`. Fourteen pin the routing decision: which
+Twenty-five cases for `claude plugin eval`. Eighteen pin the routing decision: which
 channel the run names, and whether the behaviour that channel owes actually
 happened. Seven pin what a deep run does after pre-flight, where the question is
 no longer which channel but whether the run keeps going.
@@ -12,6 +12,10 @@ no longer which channel but whether the run keeps going.
 | `main-new-interface` | Adds a port the repo does not have | Main channel; shape stated with a recommendation before building |
 | `deep-plan-across-subsystems` | A plan asked for, three subsystems | Deep channel; design written to `docs/specs/`; stops before code |
 | `deep-plan-asks-the-fork` | The same plan with nothing saying where the counters can live | One question with a recommendation before any design; no spec yet |
+| `deep-plan-traces-the-example` | A ticket whose own example the obvious design fails: the lookup it says to reuse matches accepted slides, and the smoke deck has none | A `## Trace` section in the spec that walks the example through the smoke deck, a lookup designed around what it found, and no write under `src/` or `tests/` |
+| `deep-plan-reads-the-prior-spec` | A ticket whose obvious design keeps a counter in memory, against an earlier spec the prompt never names that settled counters in a file | The new spec cites `2026-09-01-counters.md`, the design keeps the counter in that file or asks whether to supersede it, and no write under `src/` or `tests/` |
+| `deep-plan-checks-the-intent` | A ticket with three numbered asks | An Intent section that quotes the ticket and maps each ask to a decision or to Out of scope, an Agent dispatch naming the draft and its Intent after the draft is first written, and a sign-off message that says what the check found |
+| `deep-plan-checks-the-plan` | A signed-off spec with D1 to D3, and the plan asked for | A `**Spec:**` line and a Builds line on every task covering D1 to D3, `plan.sh validate` run, a dispatch naming both files after the first validate, and a stop at the pre-flight questions with no task started |
 | `explicit-instruction-collapses-to-fast` | Main-shaped work plus "just do it" | Collapses to fast; no design, no proposal |
 | `superpowers-conflict-stands-down` | Repo mandates the superpowers sequence | Stands down once, names no channel |
 | `announcement-reaches-the-ledger` | A flag that a surface test turns into a new export | `status.sh route main` before any write under `src/` and before any fast or deep route |
@@ -36,7 +40,7 @@ Execution, where the run is already past both stops:
 
 ## Running
 
-Twenty cases scaffold a small Node repo and then change it, so they need the
+Twenty-four cases scaffold a small Node repo and then change it, so they need the
 scaffold flag and a tool grant. Pin the model, because the eval child does not
 inherit it, and pin the judge, because `--model` does not reach it and the
 `llm` graders otherwise run on Haiku. From the repo root:

package/skills/sluice/evals/deep-plan-checks-the-intent/case.yaml

@@ -0,0 +1,4 @@
+schema_version: "1.1"
+name: deep-plan-checks-the-intent
+context:
+  scaffold_script: fixture.sh

package/skills/sluice/evals/deep-plan-checks-the-intent/fixture.sh

@@ -0,0 +1,124 @@
+#!/usr/bin/env bash
+# A relay whose CLI, webhook handler and worker all reach one upstream client,
+# so a ticket touching retries is a three-subsystem change. The ticket carries
+# three numbered asks, and each one fixes its own numbers, so the run has no
+# fork to ask about and the case reaches the written design, where it pins the
+# Intent map and the fresh-context check of the spec against it. The README
+# fixes where the design goes, so the graders can read it.
+set -euo pipefail
+
+mkdir -p src/cli src/webhook src/worker src/upstream tests docs/specs
+
+cat > package.json <<'JSON'
+{
+  "name": "relay",
+  "version": "0.6.0",
+  "type": "module",
+  "scripts": {
+    "test": "node --test \"tests/*.test.js\""
+  }
+}
+JSON
+
+cat > src/upstream/client.js <<'JS'
+const BASE = "https://api.upstream.example";
+
+export async function call(path, body, fetchImpl = fetch) {
+  const response = await fetchImpl(`${BASE}${path}`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    throw new Error(`upstream ${response.status} on ${path}`);
+  }
+
+  return response.json();
+}
+JS
+
+cat > src/cli/push.js <<'JS'
+import { call } from "../upstream/client.js";
+
+export async function push(records, log = console.log) {
+  for (const record of records) {
+    await call("/v1/records", record);
+    log(`pushed ${record.id}`);
+  }
+}
+JS
+
+cat > src/cli/main.js <<'JS'
+import { readFileSync } from "node:fs";
+import { push } from "./push.js";
+
+const [file] = process.argv.slice(2);
+await push(JSON.parse(readFileSync(file, "utf8")));
+JS
+
+cat > src/webhook/handler.js <<'JS'
+import { call } from "../upstream/client.js";
+
+export async function handle(event) {
+  const result = await call("/v1/events", { type: event.type, payload: event.payload });
+  return { status: 202, id: result.id };
+}
+JS
+
+cat > src/worker/backfill.js <<'JS'
+import { call } from "../upstream/client.js";
+
+export async function backfill(queue, log = console.log) {
+  let sent = 0;
+
+  while (queue.length > 0) {
+    await call("/v1/records", queue.shift());
+    sent += 1;
+  }
+
+  log(`backfill sent ${sent}`);
+  return sent;
+}
+JS
+
+cat > tests/upstream.test.js <<'JS'
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { call } from "../src/upstream/client.js";
+
+function fakeFetch(ok, body) {
+  return async () => ({ ok, status: ok ? 200 : 429, json: async () => body });
+}
+
+test("a successful call returns the parsed body", async () => {
+  const result = await call("/v1/records", { id: "a" }, fakeFetch(true, { id: "a" }));
+  assert.deepEqual(result, { id: "a" });
+});
+
+test("a rejected call reports the status and the path", async () => {
+  await assert.rejects(
+    () => call("/v1/records", { id: "a" }, fakeFetch(false)),
+    /upstream 429 on \/v1\/records/,
+  );
+});
+JS
+
+cat > README.md <<'MD'
+# relay
+
+Three callers, one upstream API: `src/cli/push.js`, `src/webhook/handler.js`
+and `src/worker/backfill.js` all go through `src/upstream/client.js`. Each
+caller logs through the `log` it is handed, which defaults to `console.log`.
+`npm test` runs the suite.
+
+## Designs
+
+A ticket's design goes in `docs/specs/<ticket>.md`, for example
+`docs/specs/OPS-12.md`, and its plan in `docs/plans/<ticket>.md`.
+MD
+touch docs/specs/.gitkeep
+
+git init --quiet
+git add -A
+git -c user.email=fixture@example.com -c user.name=fixture commit --quiet -m "relay 0.6.0"

package/skills/sluice/evals/deep-plan-checks-the-intent/graders/announces-deep-channel.md

@@ -0,0 +1,12 @@
+---
+type: regex
+# The trace carries SKILL.md's own routing table, which names every channel, so
+# `contains` passes whenever the skill loads. Anchor on the two ways the agent
+# routes instead, the same ones run-stats.sh meters: a Bash call that invokes
+# `status.sh route deep` (a quoted mention, as in a grep, does not count), or the
+# words opening an assistant message or following a label such as "Sluice:".
+pattern: '"command":"(?:(?:[^"\\]|\\.)*?(?:[\s/]|\\[nt]))?status\.sh(?:\\"|'')?(?:\s|\\[nt])+route(?:\s|\\[nt])+deep(?:\s|\\[nt]|[;&|]|")|"text":"(?:[^.!?\n"]{0,100}[:=]\s*)?[\s*_#>\\]*deep channel'
+flags: i
+target: trace
+weight: 2
+---

package/skills/sluice/evals/deep-plan-checks-the-intent/graders/checker-dispatched.md

@@ -0,0 +1,12 @@
+---
+type: tool_order
+# The check reads a drafted design in a fresh context, so it comes after the
+# first Write of the draft: the spec file, or the harness's plan file under plan
+# mode, which is where the reference says the draft lives until sign-off. Its
+# brief names that draft and the Intent it checks against. The ground read goes
+# out before any draft exists; were its brief also to name the spec's path and
+# the word Intent, it would be the first after-match and fail the case.
+before: { tool: Write, input_match: '"file_path"\s*:\s*"[^"]*(?:docs/specs/OPS-12\.md|/\.claude/plans/[^"]*\.md)"' }
+after: { tool: Agent, input_match: '^(?=[\s\S]*(?:OPS-12\.md|/\.claude/plans/))(?=[\s\S]*Intent)' }
+weight: 2
+---