@iceinvein/agent-skills 0.23.4 → 0.23.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iceinvein/agent-skills",
-  "version": "0.23.4",
+  "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.4"
+    "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/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "sluice",
-  "version": "0.25.4",
+  "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",