@iceinvein/agent-skills 0.23.2 → 0.23.4

package/README.md

@@ -44,8 +44,8 @@ Each skill is also a plugin in the `iceinvein-skills` marketplace:
 
 | Skill | What it does |
 |-------|--------------|
-| **migrate** | Walks a legacy codebase through probe, enumerate, seam, extract, parity, queue, adjudicate and handoff: measured surface coverage, an empirically derived capability seam, cited requirements, a parity plan, a batch decision queue, and work items emitted to markdown, GitHub or a flow target with coverage and forecast read back. Bundles a Bun CLI that enforces the coverage arithmetic and phase ordering instead of trusting it. |
-| **scope-estimate** | The lighter path for a proposal: read-only discovery, a capability register with status and disposition, sized functional requirements, contracts-first work packages, and a build schedule across engineers x worktrees at fast, planning and floor rates. Bundles a Bun scheduler that refuses a plan missing or double-counting a requirement, so every figure comes from one reproducible run. |
+| **migrate** | Walks a legacy codebase through probe, enumerate, seam, extract, parity, queue, adjudicate and handoff: measured surface coverage, an empirically derived capability seam, cited requirements, a parity plan, a batch decision queue, and work items emitted to markdown, GitHub or a flow target with coverage and forecast read back. Bundles a Bun CLI that enforces the coverage arithmetic and phase ordering instead of trusting it. Claude Code only. |
+| **scope-estimate** | The lighter path for a proposal: read-only discovery, a capability register with status and disposition, sized functional requirements, contracts-first work packages, and a build schedule across engineers x worktrees at fast, planning and floor rates. Bundles a Bun scheduler that refuses a plan missing or double-counting a requirement, so every figure comes from one reproducible run. Claude Code only. |
 
 ### Code Architecture
 
@@ -100,7 +100,7 @@ Skills that check code does what it was meant to do, with evidence rather than o
 
 | Skill | Based on | What it does |
 |-------|----------|--------------|
-| **bug-hunter** | QA scenario testing; intent-first reproduction | Proves logic bugs with failing repros checked against stated intent. Writes scenarios before reading the code, and reports bugs, ambiguities, and covered scenarios. |
+| **bug-hunter** | QA scenario testing; intent-first reproduction | Proves logic bugs with failing repros checked against stated intent. Writes scenarios before reading the code, and reports bugs, ambiguities, and covered scenarios. Claude Code only. |
 
 ### Communication
 
@@ -128,7 +128,7 @@ Skills that shape how work gets done rather than analyzing code.
 
 | Skill | What it does |
 |-------|--------------|
-| **sluice** | 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. Seven rules live as one-liners in the router; the full treatment sits in references read only on friction. Each run closes with a ledger read out of the session transcript: elapsed, tools, tokens, and what every dispatched agent cost. Claude Code only. Conflicts with the superpowers plugin, which requires its own fixed pipeline up front for anything that adds to or changes what the software does, not just code edits; disable superpowers before installing. |
+| **sluice** | 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. Eight rules live as one-liners in the router; the full treatment sits in references read only on friction. Each run closes with a ledger read out of the session transcript: elapsed, tools, tokens, and what every dispatched agent cost. Claude Code only. Conflicts with the superpowers plugin, which requires its own fixed pipeline up front for anything that adds to or changes what the software does, not just code edits; disable superpowers before installing. |
 
 ### Orchestration
 
@@ -137,7 +137,7 @@ Skills that compose the other audit skills into higher-level workflows.
 | Skill | What it does |
 |-------|--------------|
 | **improve-my-codebase** | Runs every applicable audit skill in parallel against your codebase, ranks findings by convergence (multiple audits agreeing) and per-file rollup, and writes a prioritized improvement report. Default sweeps everything; positional args switch modes (`quick`, `diff`, `interactive`) or narrow scope (`focus <area>`, `module <path>`). |
-| **magpie** | Interactive PR review pipeline. Runs five parallel specialist subagents (security, bugs, performance, code-smells, architecture), dedupes findings, applies a critic rubric, peer-reviews via `codex exec`, and serves an interactive HTML report for selecting findings to post via `gh`. A local mode reviews the current branch diff before a PR exists and hands the findings back in the terminal. |
+| **magpie** | Interactive PR review pipeline. Runs five parallel specialist subagents (security, bugs, performance, code-smells, architecture), dedupes findings, applies a critic rubric, peer-reviews via `codex exec`, and serves an interactive HTML report for selecting findings to post via `gh`. A local mode reviews the current branch diff before a PR exists and hands the findings back in the terminal. Claude Code only. |
 
 ## Commands
 
@@ -174,7 +174,7 @@ bunx @iceinvein/agent-skills list               # show installed versions
 After any command other than `update`, the CLI runs a background freshness check (at most once every 24 hours) and prints a one-line notice if anything is out of date:
 
 ```
-some-skill (v0.2.0 → v0.3.0)
+⚠ Updates available: some-skill (v0.2.0 → v0.3.0)
   Run: agent-skills update --all
 ```
 
@@ -195,12 +195,7 @@ If a skill declares activation support and you're installing for Claude Code int
 
 ## Supported Tools
 
-| Tool | Prompt Skills | MCP Skills |
-|------|:---:|:---:|
-| Claude Code | Yes | Yes |
-| Cursor | Yes | Yes |
-| Codex | Yes | – |
-| Gemini CLI | Yes | Yes |
+Claude Code, Cursor, Codex and Gemini CLI. Most skills install into all four; bug-hunter, magpie, migrate, scope-estimate and sluice are Claude Code only, and the CLI skips the other tools for them.
 
 ## How It Works
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iceinvein/agent-skills",
-  "version": "0.23.2",
+  "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.2"
+    "version": "0.25.4"
   },
   {
     "name": "temporal-coupling-detector",

package/skills/sluice/references/status.md

@@ -145,6 +145,16 @@ the run it names is really there. `close` removes a note naming its own tree,
 because a note that outlived its run would hand the next run opened in that
 tree to whoever reads the main tree.
 
+One note cannot serve a repo whose own rules cut worktrees by hand, outside the
+repo, where no worktree tool will enter them: every controller sits in the main
+tree at once, each with its own run elsewhere, and none of them ran `move`. So
+`init` also records the session that opened the run (`--session`, defaulting to
+`$CLAUDE_CODE_SESSION_ID`) and leaves `.sluice/sessions/<id>` at the main
+worktree naming the run's tree. A tree with no run of its own follows that
+pointer before the note, only while the run there is still that session's.
+`move` points it at the new tree and `close` removes it, so the statusline, the
+SessionStart hook and the Stop hook each find the run of the session asking.
+
 One file for several writers is one file to contend on, so `init`, `task`,
 `preflight`, `final`, `pause`, `resume`, `close` and `move` take a lock first, `move` taking the
 destination tree's as well as its own: two flips issued at the same moment
@@ -380,10 +390,10 @@ is live and contends with nothing for width when one is, which is what lets the
 bar be wide and the task carry its name rather than only its number.
 
 Capture it wherever the statusline command builds its other lines, passing the
-directory the session is in and nothing else:
+directory the session is in and the session's id, and nothing else:
 
 ```bash
-sluice_line=$(bash "$HOME/.claude/skills/sluice/scripts/statusline.sh" --dir "$cwd" 2>/dev/null)
+sluice_line=$(bash "$HOME/.claude/skills/sluice/scripts/statusline.sh" --dir "$cwd" --session "$session_id" 2>/dev/null)
 ```
 
 then print it last, after whatever else the command emits:
@@ -392,10 +402,12 @@ then print it last, after whatever else the command emits:
 if [ -n "$sluice_line" ]; then printf '%s\n' "$sluice_line"; fi
 ```
 
-`$cwd` is `workspace.current_dir` from the JSON the harness sends on stdin.
-Substitute the install path: `${CLAUDE_CONFIG_DIR:-$HOME/.claude}` where a
-session may set one, or `$cwd/.claude/skills/sluice/scripts/statusline.sh` for a
-project-local install.
+`$cwd` is `workspace.current_dir` and `$session_id` is `session_id`, both from
+the JSON the harness sends on stdin. The id is what finds a run this session
+opened in a worktree it never entered, which is every run in a repo that cuts
+its worktrees by hand. Substitute the install path:
+`${CLAUDE_CONFIG_DIR:-$HOME/.claude}` where a session may set one, or
+`$cwd/.claude/skills/sluice/scripts/statusline.sh` for a project-local install.
 
 Those two lines are the whole contract, and they are deliberately empty of
 judgement. Whether a run is visible from a given directory is a question about

package/skills/sluice/scripts/postinstall.sh

@@ -96,11 +96,12 @@ sluice: to show a live run on your status line, add these to your statusline
 command. The first goes wherever it builds its other lines, the second last of
 all, after everything else it prints:
 
-  sluice_line=\$(bash "$RENDER" --dir "\$cwd" 2>/dev/null)
+  sluice_line=\$(bash "$RENDER" --dir "\$cwd" --session "\$session_id" 2>/dev/null)
 
   if [ -n "\$sluice_line" ]; then printf '%s\\n' "\$sluice_line"; fi
 
-\$cwd is workspace.current_dir from the JSON the harness sends on stdin. Those
-two lines carry no knowledge of where a run lives, so they stay correct as this
-skill changes; every install updates the script behind them.
+\$cwd is workspace.current_dir and \$session_id is session_id, both from the JSON
+the harness sends on stdin. Those two lines carry no knowledge of where a run
+lives, so they stay correct as this skill changes; every install updates the
+script behind them.
 EOF

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

@@ -137,7 +137,7 @@ stamp_baseline "$sid" "$source"
 [ -d "$cwd" ] || exit 0
 [ -f "$STATUS" ] || exit 0
 
-shown="$(bash "$STATUS" show --dir "$cwd" 2>/dev/null)" || exit 0
+shown="$(bash "$STATUS" show --dir "$cwd" ${sid:+--session "$sid"} 2>/dev/null)" || exit 0
 [ -n "$shown" ] || exit 0
 
 echo "A sluice run is live. Its state, from .sluice/run.json:"

package/skills/sluice/scripts/status.sh

@@ -43,6 +43,11 @@
 # neither records anything. Its exit 1 also covers a tree whose changed tests
 # cannot be read.
 #
+# --session <id> names the session asking (default: $CLAUDE_CODE_SESSION_ID).
+# `init` records it in the run and leaves <main tree>/.sluice/sessions/<id>
+# naming the tree the run is in, so that session finds its run from the main
+# tree however many other runs the set holds.
+#
 # A flag value may not begin with `--`: unchecked, an omitted value silently
 # becomes the next flag and the field holds a flag name.
 
@@ -95,6 +100,7 @@ in_set() {
 # subcommand's own flag loop ever sees it. Everything after `--` is verify's
 # command, kept verbatim: a `--dir` in it belongs to that command, not to us.
 DIR="$PWD"
+SESSION="${CLAUDE_CODE_SESSION_ID-}"
 ARGS=()
 while [ $# -gt 0 ]; do
 	case "$1" in
@@ -108,6 +114,11 @@ while [ $# -gt 0 ]; do
 			DIR="$2"
 			shift 2
 			;;
+		--session)
+			need_value --session $# "${2-}"
+			SESSION="$2"
+			shift 2
+			;;
 		*)
 			ARGS+=("$1")
 			shift
@@ -116,6 +127,12 @@ while [ $# -gt 0 ]; do
 done
 set -- "${ARGS[@]+"${ARGS[@]}"}"
 
+# The id becomes a file name under .sluice/sessions, so one that could climb out
+# of that directory is refused rather than followed.
+case "$SESSION" in
+	*/* | .*) err "session id $SESSION is not a file name"; exit 4 ;;
+esac
+
 SUB="${1-}"
 [ $# -gt 0 ] && shift
 if [ -z "$SUB" ]; then
@@ -132,6 +149,40 @@ main_tree() { # <dir>
 	git -C "$1" worktree list --porcelain 2>/dev/null | sed -n '1s/^worktree //p'
 }
 
+# The tree a session's run is in, from the pointer `init` left at the main tree.
+# `run.at` cannot answer this: it is one note for the whole set, and a repo that
+# cuts worktrees by hand has every controller sitting in the main tree at once,
+# each with its own run elsewhere. Followed only while the run there is still
+# that session's, so a pointer that outlived its run never hands over the next
+# one opened in that tree. Empty when there is no such run.
+session_run() { # <main tree>
+	[ -n "$SESSION" ] && [ -n "$1" ] && [ -f "$1/.sluice/sessions/$SESSION" ] || return 0
+	local at=""
+	IFS= read -r at <"$1/.sluice/sessions/$SESSION" 2>/dev/null || true
+	[ -n "$at" ] && [ -f "$at/.sluice/run.json" ] || return 0
+	[ "$(jq -r '.session // empty' "$at/.sluice/run.json" 2>/dev/null)" = "$SESSION" ] || return 0
+	printf '%s\n' "$at"
+}
+
+# Like `leave_note`, a pointer that could not be written is a blank statusline
+# for one session rather than a failed command, so the caller reports it.
+point_session() { # <main tree> <session id> <tree the run is in>
+	mkdir -p "$1/.sluice/sessions" 2>/dev/null || return 1
+	[ -e "$1/.sluice/.gitignore" ] || printf '*\n' >"$1/.sluice/.gitignore" 2>/dev/null || true
+	printf '%s\n' "$3" >"$1/.sluice/sessions/$2" 2>/dev/null
+}
+
+# The session a run was opened by, read back from the run itself rather than
+# from whoever is asking: `move` and `close` may come from another session.
+run_owner() { # <state file>
+	local owner
+	owner="$(jq -r '.session // empty' "$1" 2>/dev/null)"
+	case "$owner" in
+		*/* | .*) return 0 ;;
+	esac
+	printf '%s' "$owner"
+}
+
 # A tree's own run comes first, and only a tree with none reads the set's. Two
 # layouts share this script and pull opposite ways. A deep run plans in the main
 # tree and cuts implementer worktrees after the plan: the run directory ignores
@@ -160,8 +211,12 @@ if [ "$SUB" != "init" ] && [ ! -f "$DIR/.sluice/run.json" ] \
 	# package straight past that worktree's run to the main tree's.
 	OWN_TREE="$(git -C "$DIR" rev-parse --show-toplevel 2>/dev/null)"
 	MAIN_TREE="$(main_tree "$DIR")"
+	# The session's own run outranks the set's, which may be anybody's.
+	SESSION_TREE="$(session_run "${MAIN_TREE:-}")"
 	if [ -n "${OWN_TREE:-}" ] && [ -f "$OWN_TREE/.sluice/run.json" ]; then
 		DIR="$OWN_TREE"
+	elif [ -n "$SESSION_TREE" ]; then
+		DIR="$SESSION_TREE"
 	elif [ -n "${MAIN_TREE:-}" ] && [ -d "$MAIN_TREE" ]; then
 		DIR="$MAIN_TREE"
 
@@ -541,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
@@ -575,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'}"
@@ -699,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
@@ -841,12 +909,20 @@ case "$SUB" in
 			--arg channel "$CHANNEL" \
 			--arg started "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
 			--arg plan "$PLAN" \
-			--arg record "$RECORD" '
+			--arg record "$RECORD" \
+			--arg session "$SESSION" '
 			{schema: 1, topic: $topic, channel: $channel, started: $started}
 			+ (if $plan == "" then {} else {plan: $plan} end)
 			+ (if $record == "" then {} else {record: $record} end)
+			+ (if $session == "" then {} else {session: $session} end)
 			+ {tasks: []}
-		' | write_state
+		' | write_state || exit $?
+
+		POINTER_TREE="$(main_tree "$DIR")"
+		if [ -n "$SESSION" ] && [ -n "$POINTER_TREE" ] && [ -d "$POINTER_TREE" ] \
+			&& ! point_session "$POINTER_TREE" "$SESSION" "$(cd "$DIR" && pwd -P)"; then
+			err "note: the run is open, but $POINTER_TREE/.sluice/sessions/$SESSION could not be written, so this session reads no run from $POINTER_TREE"
+		fi
 		;;
 
 	task)
@@ -1263,6 +1339,20 @@ case "$SUB" in
 			elif ! leave_note "$NOTE_TREE" "$TO"; then
 				err "note: the run moved, but $NOTE_TREE/.sluice/run.at could not be written, so a session in $NOTE_TREE will read no run until it moves to $TO"
 			fi
+			# The note above names only the last run moved; the owner's pointer
+			# keeps finding this one after another run is moved past it. Only a
+			# pointer still naming the tree left behind follows the run: one
+			# naming elsewhere is on a later run the same session opened.
+			OWNER="$(run_owner "$DEST_STATE")"
+			if [ -n "$OWNER" ]; then
+				AT=""
+				[ -f "$NOTE_TREE/.sluice/sessions/$OWNER" ] \
+					&& IFS= read -r AT <"$NOTE_TREE/.sluice/sessions/$OWNER" 2>/dev/null
+				if { [ -z "$AT" ] || [ "$AT" = "$(cd "$DIR" && pwd -P)" ]; } \
+					&& ! point_session "$NOTE_TREE" "$OWNER" "$TO"; then
+					err "note: the run moved, but $NOTE_TREE/.sluice/sessions/$OWNER could not be written"
+				fi
+			fi
 		fi
 
 		echo "moved $(jq -r '.topic // "run"' "$DEST_STATE" 2>/dev/null || echo run) to $TO"
@@ -1300,6 +1390,7 @@ case "$SUB" in
 		# file aside intact rather than leaving it wedged in the tree.
 		started="$(jq -r '.started // empty' "$STATE" 2>/dev/null)"
 		topic="$(jq -r '.topic // empty' "$STATE" 2>/dev/null)"
+		owner="$(run_owner "$STATE")"
 		stamp="$(printf '%s' "$started" | tr -cd '0-9TZ')"
 		slug="$(printf '%s' "${topic:-run}" | tr -cs 'A-Za-z0-9._-' '-')"
 		[ -n "$stamp" ] || stamp="unknown"
@@ -1328,6 +1419,13 @@ case "$SUB" in
 			IFS= read -r AT <"$NOTE_TREE/.sluice/run.at" 2>/dev/null || true
 			[ "$AT" = "$(cd "$DIR" && pwd -P)" ] && rm -f "$NOTE_TREE/.sluice/run.at"
 		fi
+		# The same holds for the owner's pointer, which may by now name a later
+		# run the same session opened elsewhere.
+		if [ -n "$NOTE_TREE" ] && [ -n "$owner" ] && [ -f "$NOTE_TREE/.sluice/sessions/$owner" ]; then
+			AT=""
+			IFS= read -r AT <"$NOTE_TREE/.sluice/sessions/$owner" 2>/dev/null || true
+			[ "$AT" = "$(cd "$DIR" && pwd -P)" ] && rm -f "$NOTE_TREE/.sluice/sessions/$owner"
+		fi
 		# The summary needs parseable state and close is the one command that
 		# does not, so an unreadable run still gets a line naming where it went.
 		[ -n "$summary" ] || summary="closed $(basename "$dest"): state was unreadable, no summary"

package/skills/sluice/scripts/statusline-command.sh

@@ -36,7 +36,13 @@ IFS= read -r -d "" -t 2 input || true
 # `cwd` is the older spelling of the same field and both are still sent, so it
 # is a fallback rather than a bug. Neither present is not an error worth a row:
 # it means this is not the JSON we were written against.
-dir="$(printf '%s' "$input" | jq -r '.workspace.current_dir // .cwd // empty' 2>/dev/null || true)"
-[ -n "$dir" ] || exit 0
+#
+# One jq for both fields, a line each: the render budget has no room for a
+# second fork, and a newline cannot appear in either value.
+{
+	IFS= read -r dir
+	IFS= read -r session
+} < <(printf '%s' "$input" | jq -r '(.workspace.current_dir // .cwd // ""), (.session_id // "")' 2>/dev/null || true)
+[ -n "${dir:-}" ] || exit 0
 
-bash "$RENDER" --dir "$dir" 2>/dev/null || exit 0
+bash "$RENDER" --dir "$dir" ${session:+--session "$session"} 2>/dev/null || exit 0

package/skills/sluice/scripts/statusline.sh

@@ -3,12 +3,13 @@
 # call. The caller passes the directory the session is in and prints whatever
 # comes back.
 #
-#   statusline.sh [--dir <path>]
+#   statusline.sh [--dir <path>] [--session <id>]
 #
-# --dir defaults to $PWD. Always exits 0 in silence on anything it cannot
-# render: a status bar draws on every keystroke and has nowhere to put an error,
-# so a message here would be permanent clutter rather than a report anyone acts
-# on.
+# --dir defaults to $PWD. --session is the harness's session_id, which finds the
+# run that session opened in another worktree while it sits in the main tree.
+# Always exits 0 in silence on anything it cannot render: a status bar draws on
+# every keystroke and has nowhere to put an error, so a message here would be
+# permanent clutter rather than a report anyone acts on.
 #
 # Why this exists as its own script rather than as a snippet in the caller.
 # Whether a run is visible from a given directory is a question about sluice's
@@ -36,6 +37,7 @@ here="$(cd "$(dirname "$0")" && pwd)"
 STATUS="$here/status.sh"
 
 DIR="$PWD"
+SESSION=""
 while [ $# -gt 0 ]; do
 	case "$1" in
 		--dir)
@@ -44,6 +46,11 @@ while [ $# -gt 0 ]; do
 			DIR="$2"
 			shift 2
 			;;
+		--session)
+			[ $# -ge 2 ] && [ "${2#--}" = "$2" ] || exit 0
+			SESSION="$2"
+			shift 2
+			;;
 		*) exit 0 ;;
 	esac
 done
@@ -65,11 +72,13 @@ done
 d="$(cd "$DIR" 2>/dev/null && pwd -P)" || exit 0
 [ -n "$d" ] || exit 0
 
-# Five answers end the walk. A state file is a run, wherever it was found. So is
+# Six answers end the walk. A state file is a run, wherever it was found. So is
 # a forwarding note beside where one used to be: the run moved out into a
 # worktree, this tree is where the session that moved it is still sitting, and
 # testing only the state file blanked its bar on a live run -- ahead of the
-# `.git` directory below, which would otherwise answer for this tree first. A
+# `.git` directory below, which would otherwise answer for this tree first. So
+# is this session's pointer, for a run it opened in a worktree it never
+# entered, which is the same blank bar reached without a `move`. A
 # `.git` that is a regular file is a linked worktree or a submodule, which may
 # hold no state of its own and still belong to a set that does, so it is a maybe
 # and status.sh resolves it. A `.git` that is a directory is the top of an
@@ -83,6 +92,7 @@ d="$(cd "$DIR" 2>/dev/null && pwd -P)" || exit 0
 while :; do
 	[ -f "$d/.sluice/run.json" ] && break
 	[ -f "$d/.sluice/run.at" ] && break
+	[ -n "$SESSION" ] && [ -f "$d/.sluice/sessions/$SESSION" ] && break
 	[ -f "$d/.git" ] && break
 	[ -d "$d/.git" ] && exit 0
 	[ "$d" = "${HOME:-}" ] && exit 0
@@ -100,6 +110,8 @@ done
 # already coloured: the mapping from state to colour belongs next to the state,
 # and a caller that applied it would have to re-derive each cell's meaning from
 # its glyph.
-rendered="$(bash "$STATUS" line --full --dir "$DIR" 2>/dev/null)" || exit 0
+# --session only when given, so a caller passing none leaves status.sh its own
+# default rather than an empty override.
+rendered="$(bash "$STATUS" line --full --dir "$DIR" ${SESSION:+--session "$SESSION"} 2>/dev/null)" || exit 0
 [ -n "$rendered" ] || exit 0
 printf '%s\n' "$rendered"

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
 }
@@ -319,10 +332,30 @@ fi
 # which is the right question for a render and the wrong one for a refusal. The
 # tree named in the note is then passed as `--dir`, so what follows asks about
 # one named tree and carries no layout knowledge of its own.
+#
+# The run this session opened in a worktree it never entered is its own too,
+# found through the pointer `init` left at the main tree, and it comes ahead of
+# the forward: the forward names whichever run was moved last, which with
+# several controllers in the main tree may be another session's.
 top="$(git -C "$cwd" rev-parse --show-toplevel 2>/dev/null)"
 [ -n "$top" ] || top="$cwd"
+session_tree=""
+case "$sid" in
+	"" | */* | .*) ;;
+	*)
+		main="$(git -C "$cwd" worktree list --porcelain 2>/dev/null | sed -n '1s/^worktree //p')"
+		[ -n "$main" ] && [ -f "$main/.sluice/sessions/$sid" ] \
+			&& IFS= read -r session_tree <"$main/.sluice/sessions/$sid" 2>/dev/null
+		if [ -z "$session_tree" ] || [ ! -f "$session_tree/.sluice/run.json" ] \
+			|| [ "$(jq -r '.session // empty' "$session_tree/.sluice/run.json" 2>/dev/null)" != "$sid" ]; then
+			session_tree=""
+		fi
+		;;
+esac
 if [ -f "$top/.sluice/run.json" ]; then
 	tree="$top"
+elif [ -n "$session_tree" ]; then
+	tree="$session_tree"
 elif [ -f "$top/.sluice/run.at" ]; then
 	tree=""
 	IFS= read -r tree <"$top/.sluice/run.at" 2>/dev/null || exit 0

package/skills/sluice/skill.json

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