@iceinvein/agent-skills 0.22.0 → 0.23.0

package/skills/sluice/scripts/status.sh

@@ -23,6 +23,7 @@
 #   status.sh close
 #   status.sh route <fast|main|deep>
 #   status.sh verify -- <cmd> [args...] | verify --none <reason>
+#   status.sh tests-changed --because <t> [--base <ref>] [--only <path>]... {[--with <path>]... -- <cmd> | --none <reason>}
 #
 # --dir <path> selects the tree to read (default: $PWD). State lives at
 # <dir>/.sluice/run.json and closed runs at <dir>/.sluice/archive/. A tree the
@@ -37,6 +38,10 @@
 # `line` is exempt and always exits 0 in silence, because a statusline renders
 # on every keystroke and has nowhere to put an error. `verify -- <cmd>` exits
 # with the command's own code, so a failing check reads as that failure.
+# `tests-changed` adds 7, a flagged test passes on the old code, and 8, the
+# command failed on the old code with the flagged tests at their old version;
+# neither records anything. Its exit 1 also covers a tree whose changed tests
+# cannot be read.
 #
 # A flag value may not begin with `--`: unchecked, an omitted value silently
 # becomes the next flag and the field holds a flag name.
@@ -406,6 +411,294 @@ if [ "$SUB" = "verify" ]; then
 	exit 0
 fi
 
+# Records why the session's changed tests are allowed to ask what they now ask,
+# for the test-change gate. A changed test is proved when it fails on the code
+# it was changed against: one that still passes there does not pin the change.
+# The runs happen in a scratch worktree at the base, so the partner's tree is
+# never touched. Like verify it needs no run and reads ORIG_DIR.
+if [ "$SUB" = "tests-changed" ]; then
+	TREE="$(git -C "$ORIG_DIR" rev-parse --show-toplevel 2>/dev/null)"
+	[ -n "$TREE" ] || { err "tests-changed needs a git work tree, and $ORIG_DIR is not in one"; exit 4; }
+	BECAUSE=""
+	BASE=""
+	REASON=""
+	NONE=0
+	RUN=0
+	WITH=()
+	ONLY=""
+	while [ $# -gt 0 ]; do
+		case "$1" in
+			--only) need_value --only $# "${2-}"; ONLY="$ONLY$2"$'\n'; shift 2 ;;
+			--because) need_value --because $# "${2-}"; BECAUSE="$2"; shift 2 ;;
+			--base) need_value --base $# "${2-}"; BASE="$2"; shift 2 ;;
+			--with) need_value --with $# "${2-}"; WITH+=("$2"); shift 2 ;;
+			--none) need_value --none $# "${2-}"; REASON="$2"; NONE=1; shift 2 ;;
+			--) shift; RUN=1; break ;;
+			*) err "tests-changed: unknown argument $1"; exit 4 ;;
+		esac
+	done
+	[ -n "$BECAUSE" ] || { err "tests-changed needs --because <text>"; exit 4; }
+	if [ "$RUN" -eq "$NONE" ]; then
+		err "tests-changed needs one of -- <cmd> [args...] or --none <reason>"
+		exit 4
+	fi
+	[ "$RUN" -eq 0 ] || [ $# -gt 0 ] || { err "tests-changed -- needs a command to run"; exit 4; }
+	[ "$NONE" -eq 0 ] || [ -n "$REASON" ] || { err "tests-changed --none needs a reason"; exit 4; }
+	[ "$NONE" -eq 0 ] || [ "${#WITH[@]}" -eq 0 ] || { err "--with only applies to a run, not to --none"; exit 4; }
+	for p in "${WITH[@]+"${WITH[@]}"}"; do
+		# The link has to land inside the scratch worktree and point inside the tree.
+		case "/$p/" in
+			//* | */../*) err "--with takes a path inside the tree, and $p is not one"; exit 4 ;;
+		esac
+		[ -e "$TREE/$p" ] || { err "--with $p: no such path in $TREE"; exit 4; }
+	done
+	# A command that names the tree or the main checkout by absolute path runs
+	# their files, not the scratch worktree's, so both runs would run the new
+	# code. Compared after resolving symlinks, since git reports physical paths
+	# (/private/var on macOS) and a caller usually passes logical ones.
+	if [ "$RUN" -eq 1 ]; then
+		ROOTS="$(cd "$TREE" && pwd -P)"
+		# The first entry of the list is the main checkout, unless the repo is
+		# bare: then it is the git dir, and its parent holds no checkout at all.
+		FIRST="$(git -C "$TREE" worktree list --porcelain 2>/dev/null | sed '/^$/q')"
+		[ -n "$FIRST" ] || { err "could not list the worktrees of $TREE"; exit 1; }
+		case $'\n'"$FIRST"$'\n' in
+			*$'\n'bare$'\n'*) ;;
+			*)
+				MAIN_ROOT="$(printf '%s\n' "$FIRST" | sed -n '1s/^worktree //p')"
+				[ -d "$MAIN_ROOT" ] && ROOTS="$ROOTS
+$(cd "$MAIN_ROOT" && pwd -P)"
+				;;
+		esac
+		for a in "$@"; do
+			case "$a" in
+				/*) ;;
+				*) continue ;;
+			esac
+			d="$a"
+			rest=""
+			while [ ! -d "$d" ]; do
+				rest="/$(basename "$d")$rest"
+				d="$(dirname "$d")"
+			done
+			resolved="$(cd "$d" && pwd -P)$rest"
+			while IFS= read -r root; do
+				case "$resolved/" in
+					"$root"/*) err "the command names $a, inside $root, so both runs would run the new code; name it relative to the top of the tree"; exit 4 ;;
+				esac
+			done <<<"$ROOTS"
+		done
+	fi
+
+	# An explicit base wins; otherwise the session's own, from line 3 of its
+	# stamp. A missing line or one gc has pruned is unknown, and guessing a base
+	# would prove the tests against code they were never changed from.
+	if [ -z "$BASE" ]; then
+		SID="${CLAUDE_CODE_SESSION_ID-}"
+		[ -n "$SID" ] || { err "tests-changed needs --base <ref> when CLAUDE_CODE_SESSION_ID is not set"; exit 4; }
+		case "$SID" in
+			*/* | .*) err "session id $SID is not a stamp name; pass --base <ref>"; exit 4 ;;
+		esac
+		BASE="$(sed -n 3p "${CLAUDE_CONFIG_DIR:-$HOME/.claude}/sluice/stamps/$SID" 2>/dev/null)"
+		[ -n "$BASE" ] || { err "the session stamp holds no base commit, so the base is unknown; pass --base <ref>"; exit 4; }
+	fi
+	BASE_SHA="$(git -C "$TREE" rev-parse --verify --quiet "$BASE^{commit}" 2>/dev/null)"
+	[ -n "$BASE_SHA" ] || { err "base $BASE no longer resolves to a commit here, so the base is unknown; pass --base <ref>"; exit 4; }
+
+	TEST_CHANGES="$(dirname "$0")/test-changes.sh"
+	FLAGGED="$(bash "$TEST_CHANGES" "$TREE" "$BASE_SHA")" || {
+		err "could not read the changed tests in $TREE against $BASE_SHA, so nothing was recorded"
+		exit 1
+	}
+	# --only narrows what this call proves or records to the named paths. A
+	# flagged path left out is then just another changed file: present at its
+	# current version in every run, so a test reading an edited fixture sees it,
+	# and a fixture that passes on the base cannot sink the test beside it.
+	if [ -n "$ONLY" ]; then
+		while IFS= read -r p; do
+			[ -n "$p" ] || continue
+			case $'\n'"$FLAGGED"$'\n' in
+				*$'\n'"$p"$'\n'*) ;;
+				*) err "--only $p: not a flagged test path, so there is nothing to record for it"; exit 4 ;;
+			esac
+		done <<<"$ONLY"
+		NAMED=""
+		while IFS= read -r p; do
+			case $'\n'"$ONLY" in
+				*$'\n'"$p"$'\n'*) NAMED="$NAMED$p"$'\n' ;;
+			esac
+		done <<<"$FLAGGED"
+		FLAGGED="${NAMED%$'\n'}"
+	fi
+	if [ -z "$FLAGGED" ]; then
+		echo "sluice: no changed test needs a record"
+		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
+	}
+
+	# 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
+	# deletion, here, in proof mode and in the gate alike: it cannot be hashed,
+	# and read as unreadable it could never be recorded.
+	current_blob() { # <path>: its blob, or - when it is gone
+		local sha
+		if [ -f "$TREE/$1" ]; then
+			sha="$(git -C "$TREE" hash-object -- "$1" 2>/dev/null)"
+			[ -n "$sha" ] || { err "could not read $TREE/$1, so nothing was recorded"; exit 1; }
+			printf '%s\n' "$sha"
+		else
+			printf '%s\n' "-"
+		fi
+	}
+
+	STATUS=proved
+	WHY="$BECAUSE"
+	SKIPPED=""
+	if [ "$NONE" -eq 1 ]; then
+		STATUS=unproven
+		WHY="$BECAUSE (unproven: $REASON)"
+		# A path already recorded at its current content needs nothing more, so
+		# --none after a proof adds only the deletions, and a repeat adds nothing.
+		UNRECORDED=""
+		while IFS= read -r p; do
+			sha="$(current_blob "$p")" || exit 1
+			found=""
+			if [ -f "$TREE/.sluice/tests-changed" ]; then
+				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
+			[ -n "$found" ] || UNRECORDED="$UNRECORDED$p"$'\n'
+		done <<<"$FLAGGED"
+		FLAGGED="${UNRECORDED%$'\n'}"
+		if [ -z "$FLAGGED" ]; then
+			echo "sluice: every flagged test already has a record at its current content"
+			exit 0
+		fi
+	else
+		# Removing a test can only make a suite pass, and a command naming the
+		# missing file fails on "not found", so no run can prove a deletion. The
+		# deletions are left for --none and the edits beside them proved as usual.
+		REMAINING=""
+		while IFS= read -r p; do
+			if [ -f "$TREE/$p" ]; then
+				REMAINING="$REMAINING$p"$'\n'
+			else
+				SKIPPED="$SKIPPED${SKIPPED:+, }$p"
+			fi
+		done <<<"$FLAGGED"
+		FLAGGED="${REMAINING%$'\n'}"
+		if [ -z "$FLAGGED" ]; then
+			err "every flagged test was deleted ($SKIPPED), and no run can prove a deletion; record them with --none <reason>. Nothing was recorded"
+			exit 4
+		fi
+		LISTED="$(bash "$TEST_CHANGES" --list "$TREE" "$BASE_SHA")" || {
+			err "could not list the changed tests in $TREE against $BASE_SHA, so nothing was recorded"
+			exit 1
+		}
+		# Outside the repo, so nothing the command resolves by walking up from the
+		# worktree (node_modules, a config file) can come from the tree or the
+		# main checkout instead of from the base.
+		WT="$(mktemp -d "${TMPDIR:-/tmp}/sluice-tc.XXXXXX" 2>/dev/null)" || { err "could not make a scratch directory in ${TMPDIR:-/tmp}"; exit 1; }
+		trap 'git -C "$TREE" worktree remove --force "$WT" >/dev/null 2>&1; rm -rf "$WT"; git -C "$TREE" worktree prune >/dev/null 2>&1' EXIT
+		# Bash skips the EXIT trap on a signal it has no trap for.
+		trap 'exit 130' INT
+		trap 'exit 143' TERM
+		ADD_ERR="$(git -C "$TREE" worktree add --detach "$WT" "$BASE_SHA" 2>&1 >/dev/null)" || {
+			err "could not check out $BASE_SHA to run on: $ADD_ERR"
+			exit 1
+		}
+		# Ignored dependencies never reach a fresh checkout.
+		for p in "${WITH[@]+"${WITH[@]}"}"; do
+			[ ! -e "$WT/$p" ] && [ ! -L "$WT/$p" ] || { err "--with $p is tracked at the base, so there is nothing to link"; exit 4; }
+			mkdir -p "$(dirname "$WT/$p")" && ln -s "$TREE/$p" "$WT/$p" || { err "could not link $p into the scratch worktree"; exit 1; }
+		done
+
+		# A directory that replaced a file only removes the file here: its
+		# contents are listed paths of their own, sorted after it.
+		overlay() { # <path>: puts the tree's current version of it over the base
+			if [ -f "$TREE/$1" ] || [ -L "$TREE/$1" ]; then
+				mkdir -p "$(dirname "$WT/$1")" && cp -P "$TREE/$1" "$WT/$1" || { err "could not copy $1 onto the base"; exit 1; }
+			else
+				rm -f "$WT/$1" || { err "could not delete $1 from the base"; exit 1; }
+			fi
+		}
+
+		# The control run is the base with every changed test but the flagged ones
+		# brought forward, and each proof run differs from it by one flagged path,
+		# so a proof run's failure is that path's. Bringing them all forward at
+		# once let any new test that fails on old code prove every flagged path.
+		# The unit is the file: one file that loosens an assertion and adds a new
+		# failing test is still proved, and so is a flagged test that newly imports
+		# source the base lacks, since it fails on the base for that alone.
+		#
+		# Rebuilt from the base before every run, because a run writes into the
+		# worktree (fixtures, databases, caches) and what one leaves would decide
+		# the next. -x takes ignored residue too; the --with links are kept.
+		control_tree() {
+			local excludes=() w listed
+			for w in "${WITH[@]+"${WITH[@]}"}"; do
+				excludes+=(-e "/$w")
+			done
+			git -C "$WT" checkout -q HEAD -- . && git -C "$WT" clean -fdxq "${excludes[@]+"${excludes[@]}"}" || {
+				err "could not reset the scratch worktree to $BASE_SHA"
+				exit 1
+			}
+			while IFS= read -r listed; do
+				[ -n "$listed" ] || continue
+				case $'\n'"$FLAGGED"$'\n' in
+					*$'\n'"$listed"$'\n'*) continue ;;
+				esac
+				overlay "$listed"
+			done <<<"$LISTED"
+		}
+
+		control_tree
+
+		# Without this a suite that cannot run on the base at all (a missing
+		# dependency, a new test for code the base lacks, a test already red there)
+		# would fail every proof run and read as proved. Every run's stdin is
+		# /dev/null: the proof loop's list arrives on stdin, so a command that
+		# reads it would swallow the paths still to be proved, and a runner
+		# waiting on input would hang the call.
+		if ! (cd "$WT" && "$@") </dev/null; then
+			err "the command failed on $BASE_SHA with the flagged tests left as they were, so it cannot prove anything here; link an ignored dependency with --with <path>, narrow the command to the flagged files, or record with --none <reason>. Nothing was recorded"
+			exit 8
+		fi
+
+		while IFS= read -r p; do
+			control_tree
+			overlay "$p"
+			if (cd "$WT" && "$@") </dev/null; then
+				err "$p passes on $BASE_SHA, the code it was changed against, so it does not pin the change. Nothing was recorded"
+				exit 7
+			fi
+		done <<<"$FLAGGED"
+	fi
+
+	LINES=""
+	COUNT=0
+	while IFS= read -r p; do
+		SHA="$(current_blob "$p")" || exit 1
+		LINES="$LINES$SHA	$p	$STATUS	$WHY
+"
+		COUNT=$((COUNT + 1))
+	done <<<"$FLAGGED"
+	printf '%s' "$LINES" >>"$TREE/.sluice/tests-changed" || { err "could not write $TREE/.sluice/tests-changed"; 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
+fi
+
 command -v jq >/dev/null 2>&1 || { err "jq is required"; exit 5; }
 
 require_run() {

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

@@ -16,10 +16,12 @@
 # fired this turn, which is what keeps this from looping. One refusal per turn, then:
 # a nudge with the state in it rather than a wall.
 #
-# Two checks run ahead of the run guard, both keyed on the tree having moved
-# since the session opened: an entry check for a session that never routed,
-# and a verification gate refusing a fast or main handback with no passing
-# check recorded against the tree as it stands (see their own sections).
+# Three checks run ahead of the run guard, all keyed on the tree having moved
+# since the session opened: an entry check for a session that never routed, a
+# verification gate refusing a fast or main handback with no passing check
+# recorded against the tree as it stands, and a test gate refusing a handback
+# that weakened an existing test with no record of why (see their own
+# sections).
 #
 # Reads the harness's stop JSON on stdin for `cwd` and `stop_hook_active`. To
 # refuse, prints {"decision":"block","reason":...} on stdout. Always exits 0.
@@ -70,6 +72,7 @@ fi
 # moved_tree only when it moved; it stays empty when it did not or when that
 # cannot be told.
 moved_tree=""
+moved_stamp=""
 read_moved() {
 	local stamp tree line_tree line_digest now
 	[ -n "$sid" ] || return 0
@@ -89,12 +92,14 @@ read_moved() {
 
 	# A tree that cannot be read is unknown, not moved. Losing git's exit
 	# status here would turn a held lock or a rebase in flight into a refused
-	# turn over a tree nobody touched.
-	now="$(bash "$here/tree-snapshot.sh" "$tree" 2>/dev/null)" || return 0
+	# turn over a tree nobody touched. Without optional locks for the reason
+	# session-start.sh gives: a hook must leave the index as it found it.
+	now="$(GIT_OPTIONAL_LOCKS=0 bash "$here/tree-snapshot.sh" "$tree" 2>/dev/null)" || return 0
 	[ -n "$now" ] || return 0
 	[ "$now" = "$line_digest" ] && return 0
 
 	moved_tree="$tree"
+	moved_stamp="$stamp"
 }
 read_moved
 
@@ -231,6 +236,75 @@ if ! verify_gate; then
 	exit 0
 fi
 
+# ---- test gate -------------------------------------------------------------
+# 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
+# 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
+# test only asks more of the code, so it needs nothing.
+#
+# The base is line 3 of the stamp read_moved found. A stamp without one, or
+# one gc has pruned, is unknown, and test-changes.sh fails on a base it cannot
+# read, so either way this stays silent. It applies in every channel, after
+# the verify gate so one attempt carries one refusal, and once per turn comes
+# from the `stop_hook_active` exit at the top.
+test_gate() {
+	local base flagged missing p sha rec_sha rec_path rest found
+	[ -n "$moved_tree" ] || return 0
+	base="$(sed -n '3p' "$moved_stamp" 2>/dev/null)"
+	[ -n "$base" ] || return 0
+	base="$(git -C "$moved_tree" rev-parse --verify --quiet "$base^{commit}" 2>/dev/null)" || return 0
+	[ -n "$base" ] || return 0
+	flagged="$(bash "$here/test-changes.sh" "$moved_tree" "$base" 2>/dev/null)" || return 0
+	[ -n "$flagged" ] || return 0
+
+	missing=""
+	while IFS= read -r p; do
+		if [ -f "$moved_tree/$p" ]; then
+			# Hashed the way status.sh records it, path-aware so filters apply.
+			# A file that cannot be hashed has no record status.sh could have
+			# written either, so it is named as unreadable rather than letting
+			# one path silence the gate for every other. A directory where the
+			# file was is its deletion, as status.sh reads it.
+			sha="$(git -C "$moved_tree" hash-object -- "$p" 2>/dev/null)"
+			if [ -z "$sha" ]; then
+				missing="$missing$p (cannot be read)"$'\n'
+				continue
+			fi
+		else
+			sha="-"
+		fi
+		found=""
+		if [ -f "$moved_tree/.sluice/tests-changed" ]; then
+			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
+		[ -n "$found" ] || missing="$missing$p"$'\n'
+	done <<<"$flagged"
+	[ -n "$missing" ] || return 0
+
+	# Paths land in a reason the harness prints, so control bytes are stripped
+	# as the run guard strips them from the topic and tree.
+	jq -n --arg paths "$missing" --arg base "$base" '{
+		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.")
+	}'
+	return 1
+}
+
+if ! test_gate; then
+	exit 0
+fi
+
 [ -f "$STATUS" ] || exit 0
 
 # The run the session's own tree answers for, and only that: the state beside

package/skills/sluice/scripts/test-changes.sh

@@ -0,0 +1,135 @@
+#!/usr/bin/env bash
+# Print the test paths a session changed in a way that needs a record, for the
+# test-change gate.
+#
+# Usage: test-changes.sh [--list] <tree> <base>
+# Without --list, prints each test path needing a record, one per line, sorted;
+# empty output means none does. With --list, prints every test path that
+# differs from base (added, modified, deleted, and both ends of a rename), for
+# the proof run to copy or, where the path is gone now, delete. Exit 0 printed
+# the answer, exit 1 the tree or base could not be read, and then nothing is
+# printed: an unreadable tree is "unknown", never "changed", and the caller
+# stays silent.
+#
+# A test that only grows is a test that only asks more of the code, so it
+# passes. What needs a record is a test that asks less, or asks nothing:
+#
+#   - a modified file with any removed line, since an edited assertion is a
+#     removed line plus an added one;
+#   - a deleted file;
+#   - an added line carrying a skip or focus marker, in a new file or an old
+#     one, since `it.skip(` switches a test off without removing a line, and
+#     `.only(` switches every other test off.
+#
+# A 100% rename moves a test without changing what it asks, so it passes.
+#
+# The comparison is base against the working tree as `git add -A` would stage
+# it, so untracked test files count. It is staged into a copy of the index, as
+# content-digest.sh does it: staging the partner's work in the real index to
+# read it would be a change of its own.
+
+set -uo pipefail
+
+mode=records
+if [ "${1-}" = "--list" ]; then
+	mode=list
+	shift
+fi
+tree="${1-}"
+base="${2-}"
+[ -n "$tree" ] && [ -n "$base" ] || exit 1
+cd "$tree" 2>/dev/null || exit 1
+git rev-parse --show-toplevel >/dev/null 2>&1 || exit 1
+cd "$(git rev-parse --show-toplevel)" 2>/dev/null || exit 1
+git rev-parse --verify --quiet "$base^{commit}" >/dev/null 2>&1 || exit 1
+index="$(git rev-parse --git-path index 2>/dev/null)" || exit 1
+[ -n "$index" ] || exit 1
+
+markers='\.(skip|only)\(|\bx(it|describe|test)\(|@pytest\.mark\.(skip|xfail)|pytest\.skip\(|\bt\.Skip|@Disabled|@Ignore|#\[ignore\]'
+
+# The list comes from the base rather than HEAD or the working tree: a session
+# commits, so HEAD is its to move, and it should not be able to move its own
+# tests out of view by editing .sluice-test-paths.
+pathspecs=()
+if git cat-file -e "$base:.sluice-test-paths" 2>/dev/null; then
+	listed="$(git cat-file blob "$base:.sluice-test-paths" 2>/dev/null)" || exit 1
+	while IFS= read -r line; do
+		line="${line%$'\r'}"
+		case "$line" in
+		'' | '#'*) continue ;;
+		esac
+		pathspecs+=(":(glob)$line")
+	done <<<"$listed"
+	# A list of nothing but comments would otherwise diff every path.
+	[ "${#pathspecs[@]}" -gt 0 ] || exit 0
+else
+	for glob in '**/test/**' '**/tests/**' '**/__tests__/**' '**/spec/**' \
+		'**/*.test.*' '**/*.spec.*' '**/*_test.*' '**/test_*.*' \
+		'**/__snapshots__/**' '**/*.snap' '**/testdata/**' '**/golden/**'; do
+		pathspecs+=(":(glob)$glob")
+	done
+fi
+
+# The scratch index lives in the git dir for content-digest.sh's reason: a
+# sandbox can refuse the temp dir, and git add has to write the git dir anyway.
+gitdir="$(git rev-parse --absolute-git-dir 2>/dev/null)" || exit 1
+scratch="$(mktemp -d "$gitdir/sluice-test-changes.XXXXXX" 2>/dev/null)" || exit 1
+trap 'rm -rf "$scratch"' EXIT
+# -p keeps the index's own mtime. A fresh one would make git trust the stat
+# data of a file edited in the same second it was staged, and miss a same-size
+# edit to it.
+if [ -f "$index" ]; then
+	cp -p "$index" "$scratch/index" 2>/dev/null || exit 1
+fi
+export GIT_INDEX_FILE="$scratch/index"
+git add -A >/dev/null 2>&1 || exit 1
+
+# The repo's colour, external diff and textconv settings would all change the
+# lines the marker grep reads, so every diff turns them off.
+plain=(--no-color --no-ext-diff --no-textconv)
+
+# NUL-separated, because git C-quotes a name holding a quote, backslash, tab or
+# newline in any other form, and a variable cannot hold a NUL.
+git diff --cached "${plain[@]}" -M100% --name-status -z "$base" -- "${pathspecs[@]}" >"$scratch/statuses" || exit 1
+
+flagged=""
+while IFS= read -r -d '' status; do
+	IFS= read -r -d '' path || exit 1
+	source_path=""
+	case "$status" in
+	R*)
+		source_path="$path"
+		IFS= read -r -d '' path || exit 1
+		;;
+	esac
+	if [ "$mode" = list ]; then
+		# The source too: it is gone now, and the proof's overlay has to remove it
+		# from the base, or a file moved into a directory of its own name blocks
+		# that directory.
+		flagged="$flagged$source_path${source_path:+$'\n'}$path"$'\n'
+		continue
+	fi
+	case "$status" in
+	D | T) flagged="$flagged$path"$'\n' ;;
+	A | M)
+		# A binary file reports "-" for its line counts, and a changed binary
+		# snapshot is as much an edit as a changed text one. A new file has
+		# nothing to remove, binary or not.
+		if [ "$status" = M ]; then
+			numstat="$(git diff --cached "${plain[@]}" --numstat "$base" -- ":(literal)$path")" || exit 1
+			removed="$(printf '%s\n' "$numstat" | cut -f2)"
+			if [ "$removed" != 0 ]; then
+				flagged="$flagged$path"$'\n'
+				continue
+			fi
+		fi
+		diff="$(git diff --cached "${plain[@]}" -U0 "$base" -- ":(literal)$path")" || exit 1
+		if printf '%s\n' "$diff" | sed -n '/^@@/,$p' | grep '^+' | grep -Eq "$markers"; then
+			flagged="$flagged$path"$'\n'
+		fi
+		;;
+	esac
+done <"$scratch/statuses"
+
+printf '%s' "$flagged" | grep -v '^$' | LC_ALL=C sort -u
+exit 0

package/skills/sluice/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "sluice",
-  "version": "0.24.1",
+  "version": "0.25.0",
   "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. Claude Code only; stands down where the superpowers pipeline governs the repo.",
   "author": "iceinvein",
   "type": "prompt",