@iceinvein/agent-skills 0.23.3 → 0.23.5

package/package.json

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

package/skills/bug-hunter/SKILL.md

@@ -74,6 +74,11 @@ command), **ambiguities** (the question for product), **covered** (scenarios
 that passed, with the claim each checked). Write `findings.json` and
 `report.md` with the Write tool, never from a shell command or script.
 
+Run as a dispatched agent, the Write tool may refuse `report.md` and
+`findings.json` as report files. Then put each refused file's full content in
+the hand-back under its path, for the caller to write unchanged with the Write
+tool; never fall back to a shell write.
+
 The `.bug-hunter/` directory is the one path in the caller's tree the skill
 writes. Promoting a repro into the tree as a regression test is the caller's
 job.

package/skills/bug-hunter/evals/README.md

@@ -1,6 +1,6 @@
 # bug-hunter evals
 
-Seven cases for `claude plugin eval`. Each scaffolds a small Node repo with a
+Nine cases for `claude plugin eval`. Each scaffolds a small Node repo with a
 `SPEC.md`, one module and a passing `node --test` suite, committed in two steps
 (the spec, then the module) so the target reads as a change. The prompt asks
 what QA will find in the module, the way a user would, and never names the
@@ -15,6 +15,8 @@ skill.
 | `bug-cites-intent-from-spec` | A coupon that floors where the spec rounds half up | `intent.md` is written, and the bug cites a claim sourced from `SPEC.md`, not from the code's floor |
 | `spec-outranks-target-docstring` | The spec keeps a sealed export on offer when its rewrite fails; the module's docstring and code drop it | A bug citing the spec claim, not an ambiguity between spec and docstring |
 | `impossible-value-is-a-bug` | The spec is silent on rounding; the code shows `60s` and `1m 60s` | A bug for the seconds field of 60, which no rounding rule gives |
+| `false-success-is-a-bug` | Closing a renamed project answers `{ ok: true }` and leaves its workspace | A bug, not an ambiguity about renames |
+| `every-member-of-a-set-claim` | Every dropped cited source is logged, except one cut by the cap after attachments fill the slots | A bug for the unlogged cut, which no existing test reaches |
 
 Every case also has `bug-hunter-fired`, a `tool_used: Skill` grader, so a
 score can be told apart from the model's own habits.
@@ -30,7 +32,7 @@ claude plugin eval skills/bug-hunter --scaffold --allow-tools Bash Write Edit \
 ```
 
 Add `--keep-temp` to keep each run's sandbox and trace, which is the only way
-to read back why a grader failed. `-j 7` runs the seven cases at once.
+to read back why a grader failed. `-j 9` runs the nine cases at once.
 
 To check the skill against its last accepted baseline, use `eval:fresh`:
 
@@ -113,6 +115,28 @@ a file needs its exact path and throws on a glob. So:
 
 ## Baseline
 
+### Skill 0.4.2, Opus 5.5, 2026-10-20: two guards and a field-only rule
+
+A read of 14 hunts in the snowvault transcripts (2026-10-17 to 10-20) found
+three misses. Two became cases, each copying the shape of a real one:
+`false-success-is-a-bug` follows SNO-114, which filed `wt:remove -- SNO-n`
+after a rename as an ambiguity when it exited 0 having released nothing, and
+`every-member-of-a-set-claim` follows SNO-54, which reported 0 bugs on "every
+dropped citation is logged" while one drop site logged nothing. Both scored
+1.00 on the unchanged 0.4.2, two runs each, every judge vote PASS (USD 1.70
+and 1.76, `results/2026-10-20T06-22-11-560Z` and
+`results/2026-10-20T06-22-10-824Z`). As with 0.3.0's cases, the fixture makes
+the defect plain enough that the existing rules catch it, so neither
+reproduces the field miss. They stay as guards, and the skill gained no rule
+for either.
+
+The third miss became the rule that a dispatched agent's refused `report.md`
+and `findings.json` go in its hand-back. Every one of the 10 hunts run as a
+dispatched agent had both Writes refused ("Subagents should return findings
+as text, not write report files"), so `findings.json` existed for 4 of the 14
+runs. No case pins it: an eval runs the skill at the top level, where the
+Write succeeds.
+
 ### Skill 0.4.0, Opus 5.5, 2026-10-13
 
 Same command, `-j 7`. Skill 0.4.0 drops the three dispatched roles for one

package/skills/bug-hunter/evals/every-member-of-a-set-claim/case.yaml

@@ -0,0 +1,4 @@
+schema_version: "1.1"
+name: every-member-of-a-set-claim
+context:
+  scaffold_script: fixture.sh

package/skills/bug-hunter/evals/every-member-of-a-set-claim/fixture.sh

@@ -0,0 +1,116 @@
+#!/usr/bin/env bash
+# A draft-source picker whose spec says every cited source it does not return
+# is logged once with a reason. Sources are dropped at three sites: a cited id
+# with no document, a document with no file name, and the five-slot cap. The
+# cap is applied after the reader's own attachments are merged in first, but
+# over_cap is only logged when the cited sources alone exceed five, so a cited
+# source cut because attachments filled the slots leaves no log line. The
+# existing tests cover each reason on the cited-only path. This is the shape
+# of the snowvault SNO-54 hunt, which was given exactly this claim, checked
+# behaviour against the base with 20,000 random cases, reported 0 bugs, and
+# missed the attachment cut that the reviewer then found.
+set -euo pipefail
+
+mkdir -p src tests
+
+cat > package.json <<'JSON'
+{
+  "name": "draft-sources",
+  "version": "1.4.0",
+  "type": "module",
+  "scripts": {
+    "test": "node --test \"tests/*.test.js\""
+  }
+}
+JSON
+
+cat > SPEC.md <<'MD'
+# Draft sources
+
+`pickSources({ attachments, citedIds, documents, log })` in `src/sources.js`
+picks the documents that seed a draft.
+
+- `attachments` are documents the reader attached; they always come first.
+- `citedIds` are document ids the earlier answer cited, looked up in
+  `documents` (an object keyed by id). Cited sources fill what is left.
+- At most 5 documents are returned in all.
+- A cited document with no `fileName` is not used.
+- Every cited source that is not returned is logged once, as
+  `log({ id, reason })`, where `reason` is one of `not_found`,
+  `no_file_name` or `over_cap`.
+MD
+
+git init --quiet
+git add -A
+git -c user.email=fixture@example.com -c user.name=fixture commit --quiet -m "spec: draft sources"
+
+cat > src/sources.js <<'JS'
+const MAX_SOURCES = 5;
+
+function citedSources(citedIds, documents, log) {
+  const picked = [];
+  for (const id of citedIds) {
+    const doc = documents[id];
+    if (!doc) {
+      log({ id, reason: "not_found" });
+      continue;
+    }
+    if (!doc.fileName) {
+      log({ id, reason: "no_file_name" });
+      continue;
+    }
+    picked.push(doc);
+  }
+  for (const doc of picked.slice(MAX_SOURCES)) {
+    log({ id: doc.id, reason: "over_cap" });
+  }
+  return picked;
+}
+
+export function pickSources({ attachments, citedIds, documents, log }) {
+  const cited = citedSources(citedIds, documents, log);
+  return [...attachments, ...cited].slice(0, MAX_SOURCES);
+}
+JS
+
+cat > tests/sources.test.js <<'JS'
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { pickSources } from "../src/sources.js";
+
+const doc = (id) => ({ id, fileName: `${id}.pdf` });
+
+function run(input) {
+  const lines = [];
+  const picked = pickSources({ attachments: [], documents: {}, ...input, log: (l) => lines.push(l) });
+  return { ids: picked.map((d) => d.id), lines };
+}
+
+test("attachments come before cited sources", () => {
+  const { ids } = run({ attachments: [doc("a1")], citedIds: ["c1"], documents: { c1: doc("c1") } });
+  assert.deepEqual(ids, ["a1", "c1"]);
+});
+
+test("a cited id with no document is logged as not_found", () => {
+  const { ids, lines } = run({ citedIds: ["c9"] });
+  assert.deepEqual(ids, []);
+  assert.deepEqual(lines, [{ id: "c9", reason: "not_found" }]);
+});
+
+test("a cited document with no file name is logged as no_file_name", () => {
+  const { ids, lines } = run({ citedIds: ["c1"], documents: { c1: { id: "c1" } } });
+  assert.deepEqual(ids, []);
+  assert.deepEqual(lines, [{ id: "c1", reason: "no_file_name" }]);
+});
+
+test("cited sources beyond five are logged as over_cap", () => {
+  const ids6 = ["c1", "c2", "c3", "c4", "c5", "c6"];
+  const documents = Object.fromEntries(ids6.map((id) => [id, doc(id)]));
+  const { ids, lines } = run({ citedIds: ids6, documents });
+  assert.deepEqual(ids, ["c1", "c2", "c3", "c4", "c5"]);
+  assert.deepEqual(lines, [{ id: "c6", reason: "over_cap" }]);
+});
+JS
+
+git add -A
+git -c user.email=fixture@example.com -c user.name=fixture commit --quiet -m "feat: pick draft sources"

package/skills/bug-hunter/evals/every-member-of-a-set-claim/graders/bug-for-unlogged-cap-cut.md

@@ -0,0 +1,50 @@
+---
+type: llm
+# As in impossible-value-is-a-bug: the judge cannot run the repro, so "fails
+# in the fixture" is judged against the fixture's code, quoted below.
+focus: trace
+weight: 3
+---
+
+The agent was asked what QA will find in `src/sources.js`. `SPEC.md` says
+attachments come first, cited sources fill what is left, at most 5 documents
+are returned, and every cited source that is not returned is logged once with
+reason `not_found`, `no_file_name` or `over_cap`. The fixture's code is:
+
+```js
+function citedSources(citedIds, documents, log) {
+  const picked = [];
+  for (const id of citedIds) {
+    const doc = documents[id];
+    if (!doc) { log({ id, reason: "not_found" }); continue; }
+    if (!doc.fileName) { log({ id, reason: "no_file_name" }); continue; }
+    picked.push(doc);
+  }
+  for (const doc of picked.slice(MAX_SOURCES)) {
+    log({ id: doc.id, reason: "over_cap" });
+  }
+  return picked;
+}
+
+export function pickSources({ attachments, citedIds, documents, log }) {
+  const cited = citedSources(citedIds, documents, log);
+  return [...attachments, ...cited].slice(0, MAX_SOURCES);
+}
+```
+
+So with, for example, 4 attachments and 2 valid cited sources, the second
+cited source is not returned and no log line names it, because `over_cap` is
+only logged for cited sources beyond five on their own.
+
+Find the `findings.json` the agent wrote under `.bug-hunter/` (its content
+appears in a Write tool call or a shell command in the trace, or, if the Write
+was refused, in the agent's final message). If it was written more than once,
+judge only the last write, with any later Edit to it applied.
+
+PASS if its `bugs` array has an entry for a cited source cut because
+attachments took slots, which is neither returned nor logged, and whose
+`repro` asserts a log line (or a returned source) that the code above does not
+give for that input, so that it fails against the code.
+FAIL if no findings.json content is visible in the trace, if `bugs` has no
+entry for the attachment case, if it appears only in `ambiguities`, or if the
+repro asserts something the code above already does.

package/skills/bug-hunter/evals/every-member-of-a-set-claim/graders/bug-hunter-fired.md

@@ -0,0 +1,5 @@
+---
+type: tool_used
+tool: Skill
+input_match: '"skill"\s*:\s*"(?:[\w-]+:)?bug-hunter"'
+---

package/skills/bug-hunter/evals/every-member-of-a-set-claim/prompt.md

@@ -0,0 +1,11 @@
+---
+name: every-member-of-a-set-claim
+description: A claim that every dropped cited source is logged, held at two of three drop sites. The existing tests cover each reason on the cited-only path; the cap cut after attachments are merged in logs nothing. Pins the hunt checking the claim at every site that drops a source, not only the ones the tests reach.
+tags: [bug, coverage, scaffold, write]
+max_turns: 80
+timeout_seconds: 2400
+allowed_tools: [Read, Glob, Grep, Skill, Write, Edit, Bash, Agent]
+expected_outcome: findings.json under .bug-hunter/ has a bug for a cited source cut by the five-slot cap when attachments fill slots, returned nowhere and logged nowhere, with a repro that fails against the fixture.
+---
+
+Before this goes to QA: what will they find in `src/sources.js`? It's meant to do what `SPEC.md` says.

package/skills/bug-hunter/evals/false-success-is-a-bug/case.yaml

@@ -0,0 +1,4 @@
+schema_version: "1.1"
+name: false-success-is-a-bug
+context:
+  scaffold_script: fixture.sh

package/skills/bug-hunter/evals/false-success-is-a-bug/fixture.sh

@@ -0,0 +1,112 @@
+#!/usr/bin/env bash
+# A project workspace registry whose close step derives the workspace name from
+# the project's current title. The workspace was named from the title at open,
+# so after a rename close removes nothing and still answers { ok: true }. The
+# spec never mentions renaming a project and then closing it, which makes "should close
+# find a workspace opened under the old title?" look like a question for
+# product. It is not: whichever answer product gives, a close that reports
+# success and left the workspace in place is wrong. This is the shape of the
+# snowvault SNO-114 hunt, which filed `wt:remove -- SNO-n` after a rename as an
+# ambiguity; review later found it released nothing and exited 0.
+set -euo pipefail
+
+mkdir -p src tests
+
+cat > package.json <<'JSON'
+{
+  "name": "workspaces",
+  "version": "2.3.0",
+  "type": "module",
+  "scripts": {
+    "test": "node --test \"tests/*.test.js\""
+  }
+}
+JSON
+
+cat > SPEC.md <<'MD'
+# Project workspaces
+
+`src/workspaces.js` keeps a workspace for each open project. A project has a
+key (`P-12`) that never changes and a title that can be renamed at any time.
+
+- `openProject(state, key, title)` registers the project and creates its
+  workspace.
+- `renameProject(state, key, title)` changes the project's title.
+- `closeProject(state, key)` removes the project's workspace and returns
+  `{ ok: true }`. For a key that names no project it returns
+  `{ ok: false, error: "unknown project" }`.
+- `workspaceCount(state)` is the number of workspaces that exist.
+MD
+
+git init --quiet
+git add -A
+git -c user.email=fixture@example.com -c user.name=fixture commit --quiet -m "spec: project workspaces"
+
+cat > src/workspaces.js <<'JS'
+export function createState() {
+  return { projects: new Map(), workspaces: new Set() };
+}
+
+function workspaceName(key, title) {
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return `${key.toLowerCase()}-${slug}`;
+}
+
+export function openProject(state, key, title) {
+  state.projects.set(key, { title });
+  state.workspaces.add(workspaceName(key, title));
+}
+
+export function renameProject(state, key, title) {
+  const project = state.projects.get(key);
+  if (!project) return { ok: false, error: "unknown project" };
+  project.title = title;
+  return { ok: true };
+}
+
+export function closeProject(state, key) {
+  const project = state.projects.get(key);
+  if (!project) return { ok: false, error: "unknown project" };
+  state.workspaces.delete(workspaceName(key, project.title));
+  state.projects.delete(key);
+  return { ok: true };
+}
+
+export function workspaceCount(state) {
+  return state.workspaces.size;
+}
+JS
+
+cat > tests/workspaces.test.js <<'JS'
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { createState, openProject, renameProject, closeProject, workspaceCount } from "../src/workspaces.js";
+
+test("opening a project creates its workspace", () => {
+  const state = createState();
+  openProject(state, "P-1", "Launch plan");
+  assert.equal(workspaceCount(state), 1);
+});
+
+test("closing a project removes its workspace", () => {
+  const state = createState();
+  openProject(state, "P-1", "Launch plan");
+  assert.deepEqual(closeProject(state, "P-1"), { ok: true });
+  assert.equal(workspaceCount(state), 0);
+});
+
+test("renaming a project keeps it open", () => {
+  const state = createState();
+  openProject(state, "P-1", "Launch plan");
+  assert.deepEqual(renameProject(state, "P-1", "Launch plan v2"), { ok: true });
+  assert.equal(workspaceCount(state), 1);
+});
+
+test("closing an unknown key is refused", () => {
+  const state = createState();
+  assert.deepEqual(closeProject(state, "P-9"), { ok: false, error: "unknown project" });
+});
+JS
+
+git add -A
+git -c user.email=fixture@example.com -c user.name=fixture commit --quiet -m "feat: project workspaces"

package/skills/bug-hunter/evals/false-success-is-a-bug/graders/bug-for-close-after-rename.md

@@ -0,0 +1,50 @@
+---
+type: llm
+# As in impossible-value-is-a-bug: the judge cannot run the repro, so "fails
+# in the fixture" is judged against the fixture's code, quoted below.
+focus: trace
+weight: 3
+---
+
+The agent was asked what QA will find in `src/workspaces.js`. `SPEC.md` says a
+project's title can be renamed at any time, and that `closeProject(state, key)`
+removes the project's workspace and returns `{ ok: true }`. It never mentions
+renaming a project and then closing it. The fixture's code is:
+
+```js
+function workspaceName(key, title) {
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return `${key.toLowerCase()}-${slug}`;
+}
+
+export function openProject(state, key, title) {
+  state.projects.set(key, { title });
+  state.workspaces.add(workspaceName(key, title));
+}
+
+export function closeProject(state, key) {
+  const project = state.projects.get(key);
+  if (!project) return { ok: false, error: "unknown project" };
+  state.workspaces.delete(workspaceName(key, project.title));
+  state.projects.delete(key);
+  return { ok: true };
+}
+```
+
+So after `renameProject`, `closeProject` returns `{ ok: true }` while the
+workspace opened under the old title still exists (`workspaceCount` stays 1).
+
+Find the `findings.json` the agent wrote under `.bug-hunter/` (its content
+appears in a Write tool call or a shell command in the trace, or, if the Write
+was refused, in the agent's final message). If it was written more than once,
+judge only the last write, with any later Edit to it applied.
+
+PASS if its `bugs` array has an entry for closing a renamed project that
+reports success but leaves the workspace, and whose `repro` asserts a result
+the code above does not give (for example `workspaceCount` of 0 after rename
+then close, or a result other than `{ ok: true }` with the workspace left), so
+that it fails against the code. An ambiguity about renames may also be present;
+it does not affect the verdict.
+FAIL if no findings.json content is visible in the trace, if close-after-rename
+appears only in `ambiguities` or only in the report's latent notes, or if the
+repro asserts something the code above already does.

package/skills/bug-hunter/evals/false-success-is-a-bug/graders/bug-hunter-fired.md

@@ -0,0 +1,5 @@
+---
+type: tool_used
+tool: Skill
+input_match: '"skill"\s*:\s*"(?:[\w-]+:)?bug-hunter"'
+---

package/skills/bug-hunter/evals/false-success-is-a-bug/prompt.md

@@ -0,0 +1,11 @@
+---
+name: false-success-is-a-bug
+description: A close that answers ok after a rename but leaves the workspace in place. The spec never mentions renaming and then closing, so the case reads like a product question, but a reported success that did not do the work is wrong under every answer. Pins a bug rather than an ambiguity.
+tags: [bug, baseline, scaffold, write]
+max_turns: 80
+timeout_seconds: 2400
+allowed_tools: [Read, Glob, Grep, Skill, Write, Edit, Bash, Agent]
+expected_outcome: "findings.json under .bug-hunter/ has a bug for closing a renamed project, which returns { ok: true } and leaves its workspace, with a repro that fails against the fixture."
+---
+
+Before this goes to QA: what will they find in `src/workspaces.js`? It's meant to do what `SPEC.md` says.

package/skills/bug-hunter/evals/rules.json

@@ -76,7 +76,9 @@
         "correct-code-has-no-bugs",
         "bug-cites-intent-from-spec",
         "spec-outranks-target-docstring",
-        "impossible-value-is-a-bug"
+        "impossible-value-is-a-bug",
+        "false-success-is-a-bug",
+        "every-member-of-a-set-claim"
       ]
     },
     {
@@ -86,7 +88,8 @@
       "cases": [
         "proves-a-spec-boundary-bug",
         "bug-cites-intent-from-spec",
-        "spec-outranks-target-docstring"
+        "spec-outranks-target-docstring",
+        "every-member-of-a-set-claim"
       ]
     },
     {
@@ -109,7 +112,8 @@
       "states": "SKILL.md: What counts as a bug",
       "origin": "commit:23d4466",
       "cases": [
-        "impossible-value-is-a-bug"
+        "impossible-value-is-a-bug",
+        "false-success-is-a-bug"
       ]
     },
     {
@@ -145,6 +149,13 @@
         "correct-code-has-no-bugs"
       ]
     },
+    {
+      "id": "refused-report-writes-go-in-the-hand-back",
+      "states": "SKILL.md: Output",
+      "origin": "skills/bug-hunter/evals/README.md",
+      "cases": [],
+      "unpinned": "The refusal comes from the harness only inside a dispatched agent, and an eval case runs the skill at the top level, where the Write succeeds."
+    },
     {
       "id": "bug-hunter-dir-is-the-only-path-written",
       "states": "SKILL.md: Output",

package/skills/bug-hunter/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "bug-hunter",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Hunts logic and correctness bugs in a change or area and proves each one with a failing reproduction checked against stated intent. One agent collects intent from the request, specs, docs and unchanged code, runs QA-style scenarios from a catalog as repros in the repo's own test runner inside a scratch copy, and re-runs each failure clean before reporting it. Counts a contradicted claim, or a result wrong under every reading, as a bug; keeps ambiguities for questions with more than one acceptable answer; reports latent defects without filing them. No repro, no finding. Writes report.md and findings.json (bugs, ambiguities, covered) to .bug-hunter/<date>-<slug>/ and never modifies the caller's tree. Language-agnostic; ships no per-language scripts.",
   "author": "iceinvein",
   "type": "prompt",

package/skills/index.json

@@ -13,7 +13,7 @@
     "name": "bug-hunter",
     "description": "Hunts logic and correctness bugs in a change or area and proves each one with a failing reproduction checked against stated intent. One agent collects intent from the request, specs, docs and unchanged code, runs QA-style scenarios from a catalog as repros in the repo's own test runner inside a scratch copy, and re-runs each failure clean before reporting it. Counts a contradicted claim, or a result wrong under every reading, as a bug; keeps ambiguities for questions with more than one acceptable answer; reports latent defects without filing them. No repro, no finding. Writes report.md and findings.json (bugs, ambiguities, covered) to .bug-hunter/<date>-<slug>/ and never modifies the caller's tree. Language-agnostic; ships no per-language scripts.",
     "type": "prompt",
-    "version": "0.4.2"
+    "version": "0.4.3"
   },
   {
     "name": "codebase-architecture",
@@ -233,7 +233,7 @@
     "name": "migrate",
     "description": "Source-agnostic legacy migration mapping. Walks a legacy codebase through probe, enumerate, seam, extract, parity, queue, adjudicate and handoff, building an auditable requirements ledger with mandatory citations and a `migrate check` gate in place of self-reported completeness. Use when the user asks to migrate, re-specify, replatform, or map a legacy system onto a new stack, to hand mapped requirements to a delivery team, or to resume, check, report, or forecast a mapping run already under way.",
     "type": "prompt",
-    "version": "0.4.3"
+    "version": "0.4.4"
   },
   {
     "name": "module-secret-auditor",
@@ -295,7 +295,7 @@
     "name": "sluice",
     "description": "Routes work by change shape into four channels (bypass, fast, main, deep) and applies only the rules each channel needs, so a one-line fix does not pay the cost of a multi-subsystem build. Carries nine rules as one-liners in the router and the full treatment in references read only on friction. Checks the finished plan with plan.sh validate rather than trusting it to memory, seeds the run state from it, keeps a deep run's task breakdown in .sluice/run.json so a statusline segment, one status command and a SessionStart hook can answer where the run is (the hook prints a live run at every session start, compaction included), and closes each run with a ledger read out of the session transcript: elapsed, tools, tokens, and what each dispatched agent cost where the transcript recorded it. Two Stop hooks hold a handback: one refuses a tree that moved since its last recorded check, the other refuses a changed existing test not proven to fail on the session's starting code (or recorded with a reason). Claude Code only; stands down where the superpowers pipeline governs the repo.",
     "type": "prompt",
-    "version": "0.25.3"
+    "version": "0.25.5"
   },
   {
     "name": "temporal-coupling-detector",

package/skills/migrate/scripts/__tests__/e2e-express.test.ts

@@ -755,6 +755,7 @@ function readTomlString(text: string, key: string): string {
   return match[1]
 }
 
+// Drives a whole run through several gates; it takes about 5s, which is bun's default limit.
 test('contract-only run driven probe through handoff, ending green at a plain check', async () => {
   const groundTruthPath = join(source, 'GROUND-TRUTH.md')
   const rows = await parseGroundTruth(groundTruthPath)
@@ -1250,4 +1251,4 @@ test('contract-only run driven probe through handoff, ending green at a plain ch
   expect(reopened.out).toContain(QUEUE_ID)
   await writeFile(reopenPath, ruledText)
   expect((await migrate(['check'])).code).toBe(0)
-})
+}, 60000)

package/skills/migrate/scripts/__tests__/e2e-webforms.test.ts

@@ -935,6 +935,7 @@ function readTomlString(text: string, key: string): string {
   return match[1]
 }
 
+// Drives a whole run through several gates; it takes about 4s, close to bun's 5s default limit.
 test('aspnet recipe run driven probe through queue, ending green at check --phase queue', async () => {
   const groundTruthPath = join(source, 'GROUND-TRUTH.md')
   const rows = await parseGroundTruth(groundTruthPath)
@@ -1278,4 +1279,4 @@ test('aspnet recipe run driven probe through queue, ending green at check --phas
   expect(afterRemoval.out).toContain(
     `lens census for ${mutatedSurface} claims in_ledger 0 + added ${claimed} = ${claimed} element(s) in the ledger, but elements.jsonl has ${actual}`,
   )
-})
+}, 60000)

package/skills/migrate/skill.json

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

package/skills/sluice/scripts/status.sh

@@ -596,12 +596,17 @@ $(cd "$MAIN_ROOT" && pwd -P)"
 		exit 0
 	fi
 
-	mk_dir "$TREE/.sluice" "$TREE"
-	# As in verify: a record git can see moves the tree it records.
-	git -C "$TREE" check-ignore -q .sluice/tests-changed || {
-		err "$TREE/.sluice/.gitignore does not ignore tests-changed, so the record would move the tree it records; add * to it"
-		exit 1
-	}
+	# In the repo's common git dir rather than the tree, so every worktree reads
+	# the same records: a test recorded where it was edited still counts in the
+	# tree it is merged into. Inside the git dir it is never content of the tree,
+	# so it cannot move the tree it records. One file per call, because sessions
+	# in several worktrees record at once and bash splits a long append into
+	# several writes that interleave. The tree's own .sluice/tests-changed is
+	# where records were written before, and is still read.
+	COMMON="$(git -C "$TREE" rev-parse --path-format=absolute --git-common-dir 2>/dev/null)"
+	[ -n "$COMMON" ] || { err "could not find the git dir of $TREE, so nothing was recorded"; exit 1; }
+	RECORDS="$COMMON/sluice/tests-changed"
+	mkdir -p "$RECORDS" || { err "could not make $RECORDS"; exit 1; }
 
 	# Hashed path-aware, so filters apply, the way the stop gate hashes it. A
 	# directory where the file was (a fixture split into many) is that file's
@@ -630,14 +635,16 @@ $(cd "$MAIN_ROOT" && pwd -P)"
 		while IFS= read -r p; do
 			sha="$(current_blob "$p")" || exit 1
 			found=""
-			if [ -f "$TREE/.sluice/tests-changed" ]; then
+			for rec in "$RECORDS"/* "$TREE/.sluice/tests-changed"; do
+				[ -f "$rec" ] || continue
 				while IFS=$'\t' read -r rec_sha rec_path rest; do
 					if [ "$rec_sha" = "$sha" ] && [ "$rec_path" = "$p" ]; then
 						found=1
 						break
 					fi
-				done <"$TREE/.sluice/tests-changed"
-			fi
+				done <"$rec"
+				[ -n "$found" ] && break
+			done
 			[ -n "$found" ] || UNRECORDED="$UNRECORDED$p"$'\n'
 		done <<<"$FLAGGED"
 		FLAGGED="${UNRECORDED%$'\n'}"
@@ -754,7 +761,13 @@ $(cd "$MAIN_ROOT" && pwd -P)"
 "
 		COUNT=$((COUNT + 1))
 	done <<<"$FLAGGED"
-	printf '%s' "$LINES" >>"$TREE/.sluice/tests-changed" || { err "could not write $TREE/.sluice/tests-changed"; exit 1; }
+	# Written under a dot name and renamed, so a reader never sees half of it.
+	NEW="$(mktemp "$RECORDS/.XXXXXX")" || { err "could not make a record file in $RECORDS"; exit 1; }
+	printf '%s' "$LINES" >"$NEW" && mv "$NEW" "$RECORDS/${NEW##*/.}" || {
+		rm -f "$NEW"
+		err "could not write a record to $RECORDS"
+		exit 1
+	}
 	echo "sluice: recorded $COUNT changed test(s) as $STATUS"
 	[ -z "$SKIPPED" ] || echo "sluice: not recorded, since no run can prove a deletion: $SKIPPED; record it with --none <reason>"
 	exit 0

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

@@ -240,7 +240,7 @@ fi
 # A test edited until it agrees with the new code proves nothing about that
 # code, and a passing check cannot tell that edit from an honest one. So a
 # changed existing test (a removed line, a deletion, a skip or focus marker,
-# as test-changes.sh decides) needs a line in .sluice/tests-changed naming its
+# as test-changes.sh decides) needs a line in the repo's tests-changed record naming its
 # current content: either proved red on the session's base by
 # `status.sh tests-changed -- <cmd>`, or recorded unproven with a reason. An
 # edit made after its record names other content and is refused again. A new
@@ -261,6 +261,17 @@ test_gate() {
 	flagged="$(bash "$here/test-changes.sh" "$moved_tree" "$base" 2>/dev/null)" || return 0
 	[ -n "$flagged" ] || return 0
 
+	# Records live in the repo's common git dir, one file per status.sh call,
+	# shared by every worktree, so a test recorded in the worktree it was edited
+	# in still counts once merged here. A record names content, not a tree, so it
+	# holds wherever that content is. The tree's own .sluice/tests-changed is
+	# where records were written before, and those still stand.
+	local common records rec
+	common="$(git -C "$moved_tree" rev-parse --path-format=absolute --git-common-dir 2>/dev/null)"
+	records=()
+	[ -n "$common" ] && records+=("$common/sluice/tests-changed"/*)
+	records+=("$moved_tree/.sluice/tests-changed")
+
 	missing=""
 	while IFS= read -r p; do
 		if [ -f "$moved_tree/$p" ]; then
@@ -278,14 +289,16 @@ test_gate() {
 			sha="-"
 		fi
 		found=""
-		if [ -f "$moved_tree/.sluice/tests-changed" ]; then
+		for rec in "${records[@]}"; do
+			[ -f "$rec" ] || continue
 			while IFS=$'\t' read -r rec_sha rec_path rest; do
 				if [ "$rec_sha" = "$sha" ] && [ "$rec_path" = "$p" ]; then
 					found=1
 					break
 				fi
-			done <"$moved_tree/.sluice/tests-changed"
-		fi
+			done <"$rec"
+			[ -n "$found" ] && break
+		done
 		[ -n "$found" ] || missing="$missing$p"$'\n'
 	done <<<"$flagged"
 	[ -n "$missing" ] || return 0
@@ -296,7 +309,7 @@ test_gate() {
 		decision: "block",
 		reason: ("sluice: this session changed existing tests in a way that asks less of the code (an edited or removed assertion, a deleted test, a skip or focus marker), and nothing records why: "
 			+ ($paths | split("\n") | map(select(. != "") | gsub("[\u0000-\u001f\u007f]"; "")) | join(", "))
-			+ ". A test bent to fit new code proves nothing about it, so each one needs a record against the session base \($base). Prove it fails on the old code: status.sh tests-changed --because \"<the behaviour the change replaces>\" -- <the suite, scoped to these files> (the run is in a scratch worktree of the base, so a node suite usually needs --with node_modules). If it cannot run on the old code, record why: status.sh tests-changed --because \"<the behaviour the change replaces>\" --none \"<why it cannot run on the old code>\". No run can prove a deleted test, so prove the edited ones first, then record each deletion with --none. --only <path> proves or records just those paths, so a fixture that cannot be proved can go to --none --only <fixture> on its own. Then name each changed test, and why it changed, in your reply.")
+			+ ". A test bent to fit new code proves nothing about it, so each one needs a record against the session base \($base). Prove it fails on the old code: status.sh tests-changed --because \"<the behaviour the change replaces>\" -- <the suite, scoped to these files> (the run is in a scratch worktree of the base, so a node suite usually needs --with node_modules). If it cannot run on the old code, record why: status.sh tests-changed --because \"<the behaviour the change replaces>\" --none \"<why it cannot run on the old code>\". No run can prove a deleted test, so prove the edited ones first, then record each deletion with --none. --only <path> proves or records just those paths, so a fixture that cannot be proved can go to --none --only <fixture> on its own. Then name each changed test, and why it changed, in your reply. The base is where this tree stood when the session opened, so a test that arrived through a merge of another session into this tree since then is listed too. Do not give a reason for a change that is not yours: record it as what it is, status.sh tests-changed --because \"arrived through the merge of <branch>, not from this session\" --none \"not this session to prove\" --only <path>, and name it in your reply as not from this session.")
 	}'
 	return 1
 }

package/skills/sluice/skill.json

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