@iceinvein/agent-skills 0.23.4 → 0.23.7

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

@@ -62,6 +62,106 @@ if [ -n "$input" ]; then
 	sid="$(printf '%s' "$input" | jq -r '.session_id // empty' 2>/dev/null || true)"
 	transcript="$(printf '%s' "$input" | jq -r '.transcript_path // empty' 2>/dev/null || true)"
 fi
+
+# The run the session's own tree answers for, and only that: the state beside
+# it, or the state it forwarded into a worktree when `move` sent the run on
+# without the session. status.sh also lets a tree with no run of its own read
+# the main worktree's, and that one is not taken here: a Stop in such a tree may
+# be an unrelated session, and a remedy printed to it would reach into somebody
+# else's run.
+#
+# The forward is read here rather than left to status.sh's resolution because
+# the two questions differ. Resolution answers "which run can this tree read",
+# 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.
+#
+# Sets top to the stop's tree and run_tree to the tree holding that run, or
+# leaves run_tree empty when there is none. One function for the run guard and
+# the board, so the run that keeps a deep session off the board is the run the
+# guard would refuse over.
+top=""
+run_tree=""
+resolved=""
+resolve_run_tree() {
+	local main session_tree="" forward=""
+	resolved=1
+	run_tree=""
+	top="$(git -C "$cwd" rev-parse --show-toplevel 2>/dev/null)"
+	[ -n "$top" ] || top="$cwd"
+	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
+		run_tree="$top"
+	elif [ -n "$session_tree" ]; then
+		run_tree="$session_tree"
+	elif [ -f "$top/.sluice/run.at" ]; then
+		IFS= read -r forward <"$top/.sluice/run.at" 2>/dev/null || return 0
+		# A note outliving the run it named is stale, not a run to refuse a stop over.
+		[ -n "$forward" ] && [ -f "$forward/.sluice/run.json" ] || return 0
+		run_tree="$forward"
+	fi
+}
+
+# A stop let through is the session handing back, so the board marks it. A
+# trap rather than a call before each exit: the hook lets a stop through from
+# a dozen places, and a new one added later is covered without anyone having
+# to remember the board. Every block decision sets refused first, since a
+# refused stop is the session still working. The board's output and failure
+# are dropped: stdout carries the decision, and the hook always exits 0.
+#
+# A deep session whose run is live keeps its entry, because the board draws the
+# run's bar for it. Whether the run is live is asked here rather than taken
+# from the run guard, since most exits come before the guard runs, and a deep
+# session mid-run must not read as handed back on any of them. Resolving costs
+# git calls on every stop, so it is skipped for a session with no entry, and
+# not repeated when the run guard already did it.
+#
+# The run resolved is only the one this tree can reach, which through a forward
+# or a shared tree may be another session's; that run's bar is not this
+# session's work, so the entry is kept only for a run that names this session.
+# A run naming no session is no session's own, as the board draws it, and a
+# state file that cannot be read names nobody it can be kept for.
+refused=""
+board_handback() {
+	local keep="" root owner
+	[ -z "$refused" ] && [ -n "$sid" ] || return 0
+	case "$sid" in */* | .*) return 0 ;; esac
+	# Must match the root board-index.sh and board.sh resolve.
+	if [ -n "${SLUICE_BOARD_DIR:-}" ]; then
+		root="$SLUICE_BOARD_DIR"
+	elif [ -n "${CLAUDE_CONFIG_DIR:-}" ]; then
+		root="$CLAUDE_CONFIG_DIR/sluice/board"
+	elif [ -n "${HOME:-}" ]; then
+		root="$HOME/.claude/sluice/board"
+	else
+		return 0
+	fi
+	[ -f "$root/sessions/$sid.json" ] || return 0
+	[ -n "$resolved" ] || resolve_run_tree
+	if [ -n "$run_tree" ] && owner="$(jq -r '.session // empty' "$run_tree/.sluice/run.json" 2>/dev/null)" \
+		&& [ "$owner" = "$sid" ]; then
+		keep="--keep-deep"
+	fi
+	bash "$here/board-index.sh" handback "$sid" $keep >/dev/null 2>&1 || true
+}
+trap board_handback EXIT
+
 [ "$active" = "true" ] && exit 0
 [ -d "$cwd" ] || exit 0
 
@@ -175,6 +275,7 @@ entry_nudge() {
 
 	mkdir -p "$root/nudged" 2>/dev/null || true
 	: >"$root/nudged/$sid" 2>/dev/null || true
+	refused=1
 	jq -n '{
 		decision: "block",
 		reason: "sluice: this session has changed the tree since it opened and no channel was ever announced, so the work is running with none of the rules that its shape calls for and nothing to meter it from. Invoke the sluice skill now, route what you have been doing, and say which channel it is. If it genuinely changed nothing you own (a scratch file, or an edit that was not yours), say so and stop; this will not ask twice."
@@ -225,6 +326,7 @@ verify_gate() {
 	[ -f "$moved_tree/.sluice/verified" ] && recorded="$(sed -n '1p' "$moved_tree/.sluice/verified" 2>/dev/null)"
 	[ "$recorded" = "$now" ] && return 0
 
+	refused=1
 	jq -n --arg channel "$channel" '{
 		decision: "block",
 		reason: ("sluice: this \($channel) session has changed the tree and no passing check is recorded against it as it stands now, so the handback would carry a change nothing has proved. Run the check that proves it through the recorder: status.sh verify -- <cmd> (the tests, the build, whatever exercises this change). If no check can cover it (docs, config), record why: status.sh verify --none \"<reason>\". Then hand back.")
@@ -305,6 +407,7 @@ test_gate() {
 
 	# Paths land in a reason the harness prints, so control bytes are stripped
 	# as the run guard strips them from the topic and tree.
+	refused=1
 	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: "
@@ -320,50 +423,9 @@ fi
 
 [ -f "$STATUS" ] || exit 0
 
-# The run the session's own tree answers for, and only that: the state beside
-# it, or the state it forwarded into a worktree when `move` sent the run on
-# without the session. status.sh also lets a tree with no run of its own read
-# the main worktree's, and that one is not taken here: a Stop in such a tree may
-# be an unrelated session, and a remedy printed to it would reach into somebody
-# else's run.
-#
-# The forward is read here rather than left to status.sh's resolution because
-# the two questions differ. Resolution answers "which run can this tree read",
-# 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
-	# A note outliving the run it named is stale, not a run to refuse a stop over.
-	[ -n "$tree" ] && [ -f "$tree/.sluice/run.json" ] || exit 0
-else
-	exit 0
-fi
+resolve_run_tree
+[ -n "$run_tree" ] || exit 0
+tree="$run_tree"
 
 run="$(bash "$STATUS" show --json --dir "$tree" 2>/dev/null)" || exit 0
 [ -n "$run" ] || exit 0
@@ -413,6 +475,7 @@ verdict="$(printf '%s' "$run" | jq -c --argjson now "$(date -u +%s)" --arg tree
 # anyone into. What replaces it is the step `move` could not take -- the session
 # following the run -- because a controller guarded here is a controller sitting
 # in the tree its own run left.
+refused=1
 printf '%s' "$verdict" | jq 2>/dev/null '{
 	decision: "block",
 	reason: ("sluice: the deep run \(.topic) is \(.progress) done with tasks still to go and nothing marked blocked or paused, so ending the turn here hands a live run back with nothing for your partner to decide. Still open: \(.open)."

package/skills/sluice/skill.json

@@ -1,7 +1,7 @@
 {
   "name": "sluice",
-  "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.",
+  "version": "0.26.1",
+  "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), lists every live deep run and routed fast or main session on the machine in one board.sh view (drawn once, watched, or as JSON), 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",
   "tools": [