@iceinvein/agent-skills 0.23.2 → 0.23.3

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.3",
   "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.3"
   },
   {
     "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"
 
@@ -841,12 +896,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 +1326,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 +1377,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 +1406,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

@@ -319,10 +319,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.3",
   "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",