@iceinvein/agent-skills 0.23.3 → 0.23.4

package/package.json

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

package/skills/index.json

@@ -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.4"
   },
   {
     "name": "temporal-coupling-detector",

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.4",
   "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",