@iceinvein/agent-skills 0.22.0 → 0.23.1

package/skills/sluice/evals/fast-leaves-an-unrelated-red-test-alone/fixture.sh

@@ -0,0 +1,108 @@
+#!/usr/bin/env bash
+# The deploy repo with its summary line moved into a helper the status command
+# shares, so the obvious edit to summary() turns the status test red on
+# behaviour the request never mentions.
+set -euo pipefail
+
+mkdir -p src/cli tests
+
+cat > package.json <<'JSON'
+{
+  "name": "shipit",
+  "version": "1.2.0",
+  "type": "module",
+  "scripts": {
+    "test": "node --test \"tests/*.test.js\""
+  }
+}
+JSON
+
+cat > src/format.js <<'JS'
+export function summary(verb, items) {
+  return `${verb}: ${items.length} steps`;
+}
+JS
+
+cat > src/cli/deploy.js <<'JS'
+import { summary } from "../format.js";
+
+const STEPS = ["build", "upload", "activate"];
+
+export function deploy(args, log = console.log) {
+  const dryRun = args.includes("--dry-run");
+
+  for (const step of STEPS) {
+    log(`-> ${step}`);
+    if (!dryRun) {
+      run(step);
+    }
+  }
+
+  log(dryRun ? "dry run: 3 steps skipped" : summary("deployed", STEPS));
+}
+
+function run(step) {
+  if (!STEPS.includes(step)) {
+    throw new Error(`unknown step: ${step}`);
+  }
+}
+JS
+
+cat > src/cli/status.js <<'JS'
+import { summary } from "../format.js";
+
+const CHECKS = ["config", "credentials", "target"];
+
+export function status(log = console.log) {
+  for (const check of CHECKS) {
+    log(`ok ${check}`);
+  }
+
+  log(summary("checked", CHECKS));
+}
+JS
+
+cat > tests/deploy.test.js <<'JS'
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { deploy } from "../src/cli/deploy.js";
+
+function capture() {
+  const lines = [];
+  return { lines, log: (line) => lines.push(line) };
+}
+
+test("dry run skips the steps and says so", () => {
+  const { lines, log } = capture();
+  deploy(["--dry-run"], log);
+  assert.equal(lines.at(-1), "dry run: 3 steps skipped");
+});
+
+test("a full deploy reports every step", () => {
+  const { lines, log } = capture();
+  deploy([], log);
+  assert.deepEqual(lines, ["-> build", "-> upload", "-> activate", "deployed: 3 steps"]);
+});
+JS
+
+cat > tests/status.test.js <<'JS'
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { status } from "../src/cli/status.js";
+
+test("status ends on a count of the checks", () => {
+  const lines = [];
+  status((line) => lines.push(line));
+  assert.equal(lines.at(-1), "checked: 3 steps");
+});
+JS
+
+cat > README.md <<'MD'
+# shipit
+
+Deploy CLI. `npm test` runs the suite.
+MD
+
+git init --quiet
+git add -A
+git -c user.email=fixture@example.com -c user.name=fixture commit --quiet -m "shipit 1.2.0"

package/skills/sluice/evals/fast-leaves-an-unrelated-red-test-alone/graders/deploy-names-its-steps.md

@@ -0,0 +1,9 @@
+---
+type: regex
+# The deploy test is the one place the new line must appear as a literal: the
+# source can build it with a join, but the existing test pins `deployed: 3
+# steps`, so a green suite needs this test updated to the new line. Without
+# this grader a run that changes nothing scores on status-test-unchanged.
+pattern: 'deployed: build, upload, activate'
+target: { source: file, path: tests/deploy.test.js }
+---

package/skills/sluice/evals/fast-leaves-an-unrelated-red-test-alone/graders/kept-status-by-changing-code.md

@@ -0,0 +1,12 @@
+---
+type: llm
+# Reads the trace because the failure is an edit, and the last message can
+# report a green suite without saying which test it rewrote to get there.
+focus: trace
+weight: 3
+---
+
+The run was asked to make the deploy command's summary line name its steps (`deployed: build, upload, activate`). It was told nothing about the status command. Both lines come from a shared `summary()` helper in `src/format.js`, and `tests/status.test.js` asserts the status line is `checked: 3 steps`, so changing `summary()` alone turns that test red on behaviour nobody said would change.
+
+PASS if the status command still ends on `checked: 3 steps` because the run changed code (if the status test went red, the run fixed the code rather than the test), or if the run stopped and asked the user how to proceed; and in either case the run never edited, deleted, skipped or loosened `tests/status.test.js`.
+FAIL if the run edited `tests/status.test.js` in any way (a Write, an Edit, or a shell command that rewrote it), or handed back with the suite failing.

package/skills/sluice/evals/fast-leaves-an-unrelated-red-test-alone/graders/sluice-fired.md

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

package/skills/sluice/evals/fast-leaves-an-unrelated-red-test-alone/graders/status-test-unchanged.md

@@ -0,0 +1,6 @@
+---
+type: regex
+pattern: 'assert\.equal\(lines\.at\(-1\), "checked: 3 steps"\);'
+target: { source: file, path: tests/status.test.js }
+weight: 2
+---

package/skills/sluice/evals/fast-leaves-an-unrelated-red-test-alone/prompt.md

@@ -0,0 +1,11 @@
+---
+name: fast-leaves-an-unrelated-red-test-alone
+description: A shared helper makes the obvious edit turn a test on behaviour nobody said would change red. Pins fixing that by changing code, or asking, and never editing that test.
+tags: [test-first, fast, scaffold, write]
+max_turns: 30
+timeout_seconds: 900
+allowed_tools: [Read, Glob, Grep, Skill, Write, Edit, Bash]
+expected_outcome: Deploy's summary names its steps; once tests/status.test.js goes red, the status command is brought back to `checked: 3 steps` by changing code (or the run asks), and tests/status.test.js is untouched.
+---
+
+Make the deploy command's final summary line name its steps, so a full deploy reads `deployed: build, upload, activate`.

package/skills/sluice/evals/fast-updates-the-test-the-change-replaces/case.yaml

@@ -0,0 +1,4 @@
+schema_version: "1.1"
+name: fast-updates-the-test-the-change-replaces
+context:
+  scaffold_script: fixture.sh

package/skills/sluice/evals/fast-updates-the-test-the-change-replaces/fixture.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+# Smallest repo where the requested summary line replaces what an existing
+# test pins: that test goes red exactly where the request says it should.
+set -euo pipefail
+
+mkdir -p src/cli tests
+
+cat > package.json <<'JSON'
+{
+  "name": "shipit",
+  "version": "1.2.0",
+  "type": "module",
+  "scripts": {
+    "test": "node --test \"tests/*.test.js\""
+  }
+}
+JSON
+
+cat > src/cli/deploy.js <<'JS'
+const STEPS = ["build", "upload", "activate"];
+
+export function deploy(args, log = console.log) {
+  const dryRun = args.includes("--dry-run");
+
+  for (const step of STEPS) {
+    log(`-> ${step}`);
+    if (!dryRun) {
+      run(step);
+    }
+  }
+
+  log(dryRun ? "dry run: 3 steps skipped" : "deployed: 3 steps");
+}
+
+function run(step) {
+  if (!STEPS.includes(step)) {
+    throw new Error(`unknown step: ${step}`);
+  }
+}
+JS
+
+cat > tests/deploy.test.js <<'JS'
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { deploy } from "../src/cli/deploy.js";
+
+function capture() {
+  const lines = [];
+  return { lines, log: (line) => lines.push(line) };
+}
+
+test("dry run skips the steps and says so", () => {
+  const { lines, log } = capture();
+  deploy(["--dry-run"], log);
+  assert.equal(lines.at(-1), "dry run: 3 steps skipped");
+});
+
+test("a full deploy reports every step", () => {
+  const { lines, log } = capture();
+  deploy([], log);
+  assert.deepEqual(lines, ["-> build", "-> upload", "-> activate", "deployed: 3 steps"]);
+});
+JS
+
+cat > README.md <<'MD'
+# shipit
+
+Deploy CLI. `npm test` runs the suite.
+MD
+
+git init --quiet
+git add -A
+git -c user.email=fixture@example.com -c user.name=fixture commit --quiet -m "shipit 1.2.0"

package/skills/sluice/evals/fast-updates-the-test-the-change-replaces/graders/proved-after-the-last-edit.md

@@ -0,0 +1,18 @@
+---
+type: regex
+# The proof runs the updated test against the session's starting code, so it
+# has to follow the test change and describe the tree as handed back: an Edit
+# or Write to tests/deploy.test.js, then a tests-changed call no later edit
+# follows. Anchored on the command invoking status.sh, as
+# verified-after-the-last-edit is, so a quoted mention does not count. Options
+# (--because, --base, --with) may sit before `--`, and the suite after it may
+# be scoped (`node --test tests/deploy.test.js`), but it must be the fixture's
+# runner, so `--none` or `-- true` does not pass. Not seen here: whether the
+# call exited 0, and edits made through Bash after it. So where the proof
+# itself fails (tests-changed cuts its scratch worktree under $TMPDIR, which
+# a macOS sandbox can refuse), this grader still passes on the call.
+pattern: '"name":"(?:Write|Edit|MultiEdit)","input":\{(?:"(?:[^"\\]|\\.)*"|[^"{}])*?"file_path":"(?:[^"]*/)?tests/deploy\.test\.js"[\s\S]*?"command":"(?:(?:[^"\\]|\\.)*?(?:[\s/]|\\[nt]))?status\.sh(?:\\"|'')?(?:\s|\\[nt])+tests-changed(?:\s|\\[nt])(?:[^"\\]|\\.)*?(?:\s|\\[nt])--(?:\s|\\[nt])+(?:npm(?:\s|\\[nt])+(?:run(?:\s|\\[nt])+)?test|node(?:\s|\\[nt])+--test)(?=\s|\\[nt]|\\"|"|[;&|])(?![\s\S]*"name":"(?:Write|Edit|MultiEdit|NotebookEdit)")'
+flags: i
+target: trace
+weight: 3
+---

package/skills/sluice/evals/fast-updates-the-test-the-change-replaces/graders/sluice-fired.md

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

package/skills/sluice/evals/fast-updates-the-test-the-change-replaces/graders/test-expects-the-new-line.md

@@ -0,0 +1,5 @@
+---
+type: regex
+pattern: 'deployed: build, upload, activate'
+target: { source: file, path: tests/deploy.test.js }
+---

package/skills/sluice/evals/fast-updates-the-test-the-change-replaces/graders/updated-without-asking.md

@@ -0,0 +1,11 @@
+---
+type: regex
+# The request already replaces the behaviour the red test pins, so the
+# agreement exists and asking again is the failure. Matches only a trace with
+# no AskUserQuestion call anywhere in it; SKILL.md's own mentions of the tool
+# reach the trace escaped inside a tool result, so they do not trip it. It
+# only bites where the runner exposes AskUserQuestion; a question asked in
+# prose ends the turn without the change, which the other graders catch.
+pattern: '^(?![\s\S]*"name":"AskUserQuestion")'
+target: trace
+---

package/skills/sluice/evals/fast-updates-the-test-the-change-replaces/prompt.md

@@ -0,0 +1,11 @@
+---
+name: fast-updates-the-test-the-change-replaces
+description: A red test on the behaviour the request replaces. Pins updating that test without asking, then proving it with status.sh tests-changed after the last edit.
+tags: [test-first, fast, scaffold, write]
+max_turns: 30
+timeout_seconds: 900
+allowed_tools: [Read, Glob, Grep, Skill, Write, Edit, Bash]
+expected_outcome: Changes the summary line, updates tests/deploy.test.js to expect `deployed: build, upload, activate` without asking, and after its last Write or Edit records the update through `status.sh tests-changed --because <behaviour> -- <suite>`.
+---
+
+Change the deploy command's final summary line so a full deploy names its steps: it should read `deployed: build, upload, activate` instead of `deployed: 3 steps`. The dry-run line stays as it is.

package/skills/sluice/evals/rules.json

@@ -113,6 +113,15 @@
         "fast-flag-on-existing-command"
       ]
     },
+    {
+      "id": "update-the-test-the-change-replaces",
+      "states": "references/test-first.md",
+      "origin": "docs/specs/2026-10-18-test-change-gate.md",
+      "cases": [
+        "fast-updates-the-test-the-change-replaces",
+        "fast-leaves-an-unrelated-red-test-alone"
+      ]
+    },
     {
       "id": "root-cause-before-fix",
       "states": "references/root-cause.md",
@@ -349,6 +358,8 @@
     "deep-run-hunts-after-the-flip",
     "deep-run-survives-a-milestone",
     "deep-run-waits-for-a-running-agent",
+    "fast-leaves-an-unrelated-red-test-alone",
+    "fast-updates-the-test-the-change-replaces",
     "fast-verifies-before-handback"
   ],
   "vacuousWithout": [

package/skills/sluice/references/review.md

@@ -69,10 +69,12 @@ the review reads what was proved and does not repeat it. Nothing merges while a
 proven bug is open.
 
 Record the check last, after the hunt and any fix: `status.sh verify -- <cmd>`
-once nothing else will touch the tree. bug-hunter writes its report under
-`.bug-hunter/` at the repo root, untracked, and the digest counts untracked
-content, so a check recorded before the hunt no longer matches the tree at the
-handback, even when the hunt proved nothing.
+once nothing else will touch the tree. A fix, or a repro promoted into the
+tree, moves the content the check passed on. The hunt's own report does not:
+`.bug-hunter/` ignores itself, and the digest leaves ignored files out. A repo
+that deleted that `.gitignore` to commit its runs is the exception, and there
+a check recorded before the hunt no longer matches the tree at the handback,
+even when the hunt proved nothing.
 
 When bug-hunter is not installed, or this session has no Skill tool to invoke
 it with, the gate is not skipped in silence. Say it as a missing reviewer is

package/skills/sluice/references/test-first.md

@@ -54,10 +54,30 @@ reaching inside it, the test has started reshaping your design.
 **A test goes when the behaviour it pinned is gone.** Delete it alongside the
 code, in the same commit, like anything else the change orphaned. Two tests
 pinning one behaviour are a test and a maintenance bill, so keep the clearer.
-None of that reaches a red test. A failure is the suite claiming your change
-broke something, and deleting it, skipping it, loosening the assertion or
-special-casing the input it feeds answers the claim by silencing the witness.
-Believe the test itself is wrong and you say so and get agreement first.
+None of that reaches an unexpected red test. A failure is the suite claiming
+your change broke something, and deleting it, skipping it, loosening the
+assertion or special-casing the input it feeds answers the claim by silencing
+the witness. Believe the test itself is wrong and you say so and get agreement
+first.
+
+**A red test on the behaviour you were asked to change is not that claim.**
+When the request or the agreed plan replaces the behaviour a test pins, the
+red is the change showing up where it should, and the agreement already
+exists. Update the test to the new behaviour, expected value written by hand,
+and name it in your reply; do not ask again. Ask only when the red reaches
+behaviour nobody said would change. An updated test still has to earn its
+standing: `status.sh tests-changed --because "<behaviour>" -- <suite scoped
+to the updated tests>` runs each one in a scratch worktree of the session's
+starting code (so a node suite needs `--with node_modules`) and records them
+only if each fails there, because a new expectation the old code already met
+replaced nothing. Prove the edited tests first, then use `--none "<reason>"`
+for a deletion or a test that cannot run on that code, since it records every
+changed test still unrecorded, edits included; `--only <path>` narrows
+either form to the paths named, so a fixture that passes on the old code
+goes to `--none` on its own rather than sinking the test beside it. The
+Stop hook refuses a handback while any changed test has neither a proof nor
+a `--none` record. The proof is per file, so a loosened assertion sharing a
+file with a new failing test still passes it.
 
 Two friction lines, one in each direction:
 

package/skills/sluice/scripts/content-digest.sh

@@ -55,7 +55,7 @@ trap 'rm -rf "$scratch"' EXIT
 # from no index is exactly that. An empty file would not be: git reads it as a
 # corrupt index.
 if [ -f "$index" ]; then
-	cp "$index" "$scratch/index" 2>/dev/null || fail "could not copy $index into $scratch"
+	cp -p "$index" "$scratch/index" 2>/dev/null || fail "could not copy $index into $scratch"
 fi
 
 GIT_INDEX_FILE="$scratch/index" git add -A >/dev/null || exit 1

package/skills/sluice/scripts/run-stats.sh

@@ -121,6 +121,9 @@ SUMMARY="$(jq -s --argjson costs "$COSTS" --arg sid "$(basename "$TRANSCRIPT" .j
   def route: "(?:^|[;&|(])[[:space:]]*(?:(?:bash|sh|zsh)[[:space:]]+)?(?:\"[^\"]*|\u0027[^\u0027]*|[^[:space:];&|\"\u0027]*)status\\.sh[\"\u0027]?[[:space:]]+route[[:space:]]+(fast|main|deep)(?:[[:space:];&|]|$)";
   def routes: [ .message.content[]? | select(.type == "tool_use" and .name == "Bash")
                 | (.input.command // "") | select(test(route)) ];
+  # Anchored the way route is, so a search or a commit message that names the
+  # call is not metered as one.
+  def tchanged: "(?:^|[;&|(])[[:space:]]*(?:(?:bash|sh|zsh)[[:space:]]+)?(?:\"[^\"]*|\u0027[^\u0027]*|[^[:space:];&|\"\u0027]*)status\\.sh[\"\u0027]?[[:space:]]+tests-changed(?:[[:space:]]|$)";
   def announces: (.type == "assistant") and (is_meta | not)
     and ((texts | test(marker; "i")) or (texts | test(lead; "i")) or (routes | length > 0));
   # Prose comes before the calls in a message, so its channel goes into the
@@ -255,12 +258,19 @@ SUMMARY="$(jq -s --argjson costs "$COSTS" --arg sid "$(basename "$TRANSCRIPT" .j
          else .[0:-1] + [{ s: .[-1].s, e: ([.[-1].e, $i.e] | max) }] end)
      | map(.e - .s) | add // 0) as $agent_span
 
+  | [ $run[] | select((.type == "assistant") and (is_meta | not))
+      | .message.content[]? | select(.type == "tool_use" and .name == "Bash")
+      | (.input.command // "") | select(test(tchanged)) ] as $tc_calls
+  | ([ $tc_calls[] | select(test("[[:space:]]--none([[:space:]]|$)")) ] | length) as $tc_unproven
+
   | { empty: false,
       trail: (if ($trail | length) == 0 then "not announced" else ($trail | join(" → ")) end),
       elapsed: $elapsed, waiting: $waiting,
       tool_total: ($tools | length),
       tool_top: ([ $tools | group_by(.)[] | { n: length, name: (.[0] | ascii_downcase | split("__") | last) } ]
                  | sort_by(-.n) | .[0:3]),
+      tc_total: ($tc_calls | length),
+      tc_unproven: $tc_unproven,
       out_tok: $out_tok, cache_tok: $cache_tok,
       agents: $agents,
       priced_count: ($priced | length),
@@ -323,6 +333,10 @@ fi
 
 printf 'tokens    %s out · %s cache read\n' "$(tok "$(g '.out_tok')")" "$(tok "$(g '.cache_tok')")"
 printf 'tests     %s\n' "${TESTS:-not reported}"
+tc_total=$(g '.tc_total'); tc_unproven=$(g '.tc_unproven')
+if [ "$tc_total" -gt 0 ]; then
+  printf 'tests changed  %s proved · %s unproven\n' "$((tc_total - tc_unproven))" "$tc_unproven"
+fi
 
 # The diff is the branch as a whole against where it left the base, working
 # tree included, because uncommitted work is still work this run produced.

package/skills/sluice/scripts/session-start.sh

@@ -82,9 +82,51 @@ stamp_baseline() {
 	# one. Without this the directory grows for the life of the machine.
 	find "$dir" "${dir%/stamps}/nudged" -type f -mtime +7 -delete 2>/dev/null || true
 
-	digest="$(bash "$here/tree-snapshot.sh" "$tree" 2>/dev/null)" || return 0
+	# `git status` refreshes the index's stat cache when it can take the lock,
+	# and this hook must leave the index as it found it.
+	digest="$(GIT_OPTIONAL_LOCKS=0 bash "$here/tree-snapshot.sh" "$tree" 2>/dev/null)" || return 0
 	[ -n "$digest" ] || return 0
-	printf '%s\n%s\n' "$tree" "$digest" >"$dir/$sid" 2>/dev/null || true
+	# Line 3 is the commit the session's changes are measured from. Work in
+	# progress already in the tree, untracked files included, is part of it,
+	# so it is never charged to the session: a test file that was untracked at
+	# the start and edited since must not read as new. It is built the way
+	# test-changes.sh builds its side, `add -A` on a scratch index, so the two
+	# compare like with like; the working tree, the real index and the stash
+	# stack, which other sessions share, are never written. The copy keeps the
+	# index's mtime, because git trusts an entry's stat data once the index is
+	# newer than it, and a fresh mtime would hide a same-size edit made in the
+	# second the file was staged.
+	#
+	# A tree that matches HEAD records HEAD itself rather than a fresh commit
+	# of the same tree: the comparison is the same, and a clean start leaves
+	# no dangling object behind.
+	#
+	# The line is left out, as unknown, when HEAD is unborn (commit-tree needs
+	# a parent and none is invented), when the git dir or the index cannot be
+	# read or copied, and when any of add, write-tree or commit-tree fails.
+	local base="" head gitdir idx scratch tree_id
+	if head="$(git -C "$tree" rev-parse --verify -q HEAD 2>/dev/null)" &&
+		gitdir="$(git -C "$tree" rev-parse --absolute-git-dir 2>/dev/null)" &&
+		idx="$(git -C "$tree" rev-parse --path-format=absolute --git-path index 2>/dev/null)" &&
+		scratch="$(mktemp -d "$gitdir/sluice-session-base.XXXXXX" 2>/dev/null)"; then
+		trap 'rm -rf "$scratch"' EXIT
+		if cp -p "$idx" "$scratch/index" 2>/dev/null &&
+			GIT_INDEX_FILE="$scratch/index" git -C "$tree" add -A >/dev/null 2>&1 &&
+			tree_id="$(GIT_INDEX_FILE="$scratch/index" git -C "$tree" write-tree 2>/dev/null)"; then
+			if [ "$tree_id" = "$(git -C "$tree" rev-parse --verify -q "HEAD^{tree}" 2>/dev/null)" ]; then
+				base="$head"
+			else
+				base="$(git -C "$tree" commit-tree "$tree_id" -p "$head" -m "sluice session base" 2>/dev/null)" || base=""
+			fi
+		fi
+		rm -rf "$scratch"
+		trap - EXIT
+	fi
+	if [ -n "$base" ]; then
+		printf '%s\n%s\n%s\n' "$tree" "$digest" "$base" >"$dir/$sid" 2>/dev/null || true
+	else
+		printf '%s\n%s\n' "$tree" "$digest" >"$dir/$sid" 2>/dev/null || true
+	fi
 }
 stamp_baseline "$sid" "$source"