@iceinvein/agent-skills 0.18.0 → 0.18.2

package/dist/cli/index.js

@@ -468,6 +468,7 @@ async function wireSessionStartHook(settingsPath, skillName, directive, scriptPa
   const legacy = `echo ${shq(directive)}`;
   let adopted = false;
   let custom = false;
+  let customRunsScript = false;
   let changed = false;
   for (const group of settings.hooks.SessionStart) {
     const kept = [];
@@ -479,6 +480,8 @@ async function wireSessionStartHook(settingsPath, skillName, directive, scriptPa
       const plain = hook.skill !== undefined || hook.command === legacy;
       if (!plain) {
         custom = true;
+        if (scriptPath && hook.command?.includes(scriptPath))
+          customRunsScript = true;
         kept.push(hook);
         continue;
       }
@@ -499,7 +502,7 @@ async function wireSessionStartHook(settingsPath, skillName, directive, scriptPa
   }
   settings.hooks.SessionStart = settings.hooks.SessionStart.filter((group) => !group.hooks || group.hooks.length > 0);
   if (adopted || custom) {
-    if (custom && !adopted && scriptPath) {
+    if (custom && !adopted && scriptPath && !customRunsScript) {
       console.warn(`${skillName}: a hand-edited SessionStart hook already carries its directive, so it was left as is and ${scriptPath} was not wired; add it to that entry yourself if you want it.`);
     }
     if (changed) {

package/package.json

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

package/skills/index.json

@@ -283,7 +283,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 seven 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.",
     "type": "prompt",
-    "version": "0.19.0"
+    "version": "0.19.2"
   },
   {
     "name": "temporal-coupling-detector",

package/skills/sluice/references/deep-channel.md

@@ -180,8 +180,15 @@ your sign-off and Task 1 begins.
 **Review.** Name the tasks the table below sends to a reviewer, each with the
 trigger that qualified it, and say how many of the rest skip with a ledger
 line. Then offer the choice: dispatch a reviewer at each of them, dispatch
-only at tier 3, or hand back with those tasks listed as
-review outstanding. The options are what makes the cost legible.
+only at tier 3, or hand back with the whole tier table skipped. The options are
+what makes the cost legible.
+
+Whichever comes back, record it with `status.sh preflight --review`. That row is
+what turns the tasks it skips into a coverage level rather than a debt: the count
+stays, because the code is the same either way, but `show`, the bar and `close`
+then name it as the level your partner chose. Unrecorded,
+the same tasks read as unreviewed to the end of the run, which is a nag about a
+decision that was already made. `references/status.md` has the two readings.
 "Four of nine need a reviewer" is a decision your partner can price; "I will
 review where appropriate" is not.
 
@@ -251,9 +258,10 @@ intending to, and the questions are still cheap here and unaskable an hour from
 now.
 
 A session that forbids subagents does not skip this; it changes what the
-review options are. Skipping it is how "review outstanding" first appears in
+review options are. Skipping it is how the unreviewed count first appears in
 the closing summary, at the one moment your partner can no longer do anything
-about it.
+about it, and with no answer on file it stays worded as a debt rather than as
+the level anyone chose.
 
 ## Dispatch rules
 
@@ -285,8 +293,10 @@ reads the run state rather than the plan: it sees what has actually landed.
   implementer back into them. `done --commit <sha> --reviewed` when the review
   clears, or `done --commit <sha>` alone for a tier 0 task, which was owed a
   stat read and no dispatch, and for a task whose dispatch pre-flight declined;
-  the debt count counts the second kind and not the first. That state outlives
-  compaction; your memory doesn't.
+  the count counts the second kind and not the first. A declined dispatch is
+  meant to show up there, because the count describes the artifact rather than
+  the decision, and the recorded pre-flight answer is what makes it read as
+  coverage rather than debt. That state outlives compaction; your memory doesn't.
 - Each task goes to a fresh agent carrying the brief below and nothing this
   session accumulated. What you hold is yours to hold, not theirs.
 - **The run never ends a turn between pre-flight and the handback.** A
@@ -405,9 +415,10 @@ One thing does not change: the work still owes a review. Reading your own diff
 is not one, and the table below still names which tasks needed the stronger
 tier. Name those tasks at pre-flight, not at handback, so the choice of what
 to do about them is still open: shrink the plan, take the flip on its own, or
-accept the gap knowingly. Whatever is left then gets listed as review
-outstanding rather than review passed, and twice is the cap on saying so here
-too: `references/review.md` has that rule. A `deep` run that ships with nobody
+accept the gap knowingly. Record the answer with `preflight --review` and say at
+the handback what was covered and how, rather than claiming those tasks passed a
+review; twice is the cap on saying so here too, and `references/review.md` has
+that rule. A `deep` run that ships with nobody
 having read it has become a `fast` run with a design document attached, and
 your partner is entitled to know that while it can still change the plan.
 
@@ -471,12 +482,17 @@ dispatch, the tasks are interleaved rather than ordered, and reordering them
 is cheaper than reviewing them.
 
 **Mark each review with `status.sh task <id> --reviewed` when it comes back.**
-What that buys is a count of what this table promised and nobody delivered: tasks
-that are done, that qualified for a dispatch, and that carry no mark. `show` and
-the statusline both carry it from the moment it exists, which is the whole point.
-Unmarked, the count sits permanently non-zero and stops being a signal, and
-"review outstanding" goes back to first appearing in the closing summary, at the
-one moment your partner can no longer do anything about it.
+What that buys is a count of the tasks this table sent to a reviewer and nobody
+marked: done, qualified for a dispatch, and carrying no mark. `show` and the
+statusline both carry it from the moment it exists, which is the whole point.
+Unmarked, the count sits permanently non-zero and stops being a signal, and it
+goes back to first appearing in the closing summary, at the one moment your
+partner can no longer do anything about it.
+
+With the pre-flight answer on file the same count is the coverage this run
+bought, worded as such and drawn dim. Without it the count is a debt and stays in
+the warning colour. Neither wording shrinks it: what changes is whether the
+number reads as spent or as owed.
 
 Reviews are reads, so they are always parallel. Every review a wave earned
 goes out in one message, and they run while the next wave's implementers work:

package/skills/sluice/references/finish.md

@@ -43,12 +43,16 @@ the one list of them. In order:
 2. The ledger, `scripts/run-stats.sh --tests "<that result>"`, pasted
    unedited. `references/meter.md`
 3. In `deep`, `status.sh show`, pasted, so "four of nine, task five blocked,
-   two unreviewed, final review pending" is on the page rather than in your
-   account of it. `references/status.md`
+   two done at tier 1+ with no dispatch, final review pending" is on the page
+   rather than in your account of it. `references/status.md`
 4. One clause on review: dispatched and clear, dispatched with findings still
    open, or not dispatched and why. In `deep` that clause covers the per-task
-   tiers and the final review separately, because the debt count carries one
-   and not the other.
+   tiers and the final review separately, because the count carries one and not
+   the other. Where pre-flight priced the level, say what was covered and how,
+   not that review is outstanding: "reviewed at the level you chose, a
+   controller stat read plus the final whole-plan pass rather than a per-task
+   dispatch" is the accurate line, and it is a coverage level rather than a
+   debt. Where nothing was priced, it is a debt and says so.
 5. The three options, and nothing after them.
 
 A `deep` run closes when the work stops being yours to act on: after a local

package/skills/sluice/references/status.md

@@ -36,16 +36,20 @@ worktree>` finds nothing. Statuses
 are `todo`, `active`, `review`, `done` and `blocked`. A new id needs `--name`;
 after that every call is a bare flip, so keeping it current costs one command
 per transition rather than a paragraph. `close` archives the run under
-`.sluice/archive/`, prints one line saying what it archived, progress, review
-debt and whether the final review landed, and frees the tree for the next one.
+`.sluice/archive/`, prints one line saying what it archived, progress, how many
+tasks shipped without a dispatch and whether the final review landed, and frees
+the tree for the next one.
 
 The controller writes every row. An implementer reports its SHA in its reply
 and touches nothing under `.sluice/`; the brief in `references/deep-channel.md`
 says so to it. `active` is the dispatch, `review` is the commit in and a
 reviewer out, with the task's paths still held because a finding may send the
 implementer back into them, and `done` is the end: with `--reviewed` when a
-review cleared it, without when the tier owed one and pre-flight declined it,
-which is the row the debt count counts.
+review cleared it, without when the tier qualified for one and pre-flight
+declined it, which is the row the no-dispatch count counts. Declining is meant
+to show up there: the count describes the artifact, not the decision, and a
+chosen skip that erased itself would leave a number that only ever recorded
+accidents.
 
 A task going `active` with no `--base` takes the HEAD of the tree the command
 is pointed at, `--dir` if given and the current tree otherwise, once; a base
@@ -148,8 +152,8 @@ have gone that way. Those are different claims.
 ## Reading it back
 
 `show` prints the whole run: channel, topic, how many tasks are done, the plan
-and record paths, how long it has sat idle once that passes a day, the review
-debt, the final review, the pre-flight answers, and a row per task with its
+and record paths, how long it has sat idle once that passes a day, the tasks
+that shipped without a dispatch, the final review, the pre-flight answers, and a row per task with its
 base, commit, tier and model. Run it after compaction instead of reconstructing the
 run from what you remember, and run it in the message that hands the work back,
 where "four of nine, task five blocked" is a fact your partner can act on.
@@ -170,9 +174,9 @@ from what the whole bar would occupy, gaps included, rather than from the task
 count: keyed off the count alone the schedule was not monotonic, and thirty tasks
 at two cells each ran wider than twelve at three.
 
-**A done task still owed a review trails the review glyph**, `▰▰▨` against
-`▰▰▰`. Debt then reads in position rather than only as a count at the end of the
-row, which is the difference between knowing how much there is and knowing where.
+**A done task that got no dispatch trails the review glyph**, `▰▰▨` against
+`▰▰▰`. The gap then reads in position rather than only as a count at the end of
+the row, which is the difference between knowing how much there is and knowing where.
 Tier 0 was never owed a dispatch, so it reads as plainly done. On a plan long
 enough to narrow cells to one, there is no trailing cell to give up and the
 positional reading stops: the count in the third row is then the only carrier,
@@ -186,16 +190,40 @@ flips and `import` clears a stale one, so the bar is only ever asked to draw the
 single legal case.
 
 The third row carries the progress count, whichever task wants attention, and the
-review debt. A blocked task displaces the active one there, being the one of the
-two worth interrupting for, and a `+n` follows when more than one task shares that
-state, since a plan running four wide has four actives by design.
+no-dispatch count. A blocked task displaces the active one there, being the one of
+the two worth interrupting for, and a `+n` follows when more than one task shares
+that state, since a plan running four wide has four actives by design.
 
 Mark a review with `task <id> --reviewed` when a reviewer comes back. What that
-buys is the debt count: a task that is done, that the tier table owed a dispatch,
-and that nobody marked. Tier 0 is excluded, having only ever been owed a stat
-read. Without it "review outstanding" first appears in the closing summary, at
-the one moment your partner can no longer do anything about it, and `show` and
-the statusline both carry it from the moment it exists.
+buys is the count: a task that is done, that the tier table qualified for a
+dispatch, and that nobody marked. Tier 0 is excluded, having only ever been owed
+a stat read. Without it that count first appears in the closing summary, at the
+one moment your partner can no longer do anything about it, and `show` and the
+statusline both carry it from the moment it exists.
+
+## Coverage against debt
+
+The same count reads two ways, and which one it gets turns on whether
+`preflight --review` has an answer on file.
+
+With an answer, the level was priced at the stop and the tasks it skipped were
+spent rather than forgotten. `show` calls it `coverage`, with the answer itself
+on the `pre-flight` row three lines below rather than repeated beside the count;
+the bar says `⟲ 9 at the chosen level` dim rather than in the warning colour, and
+`close` says `9 at the chosen review level`. That is a fact about how
+far review reached, not a thing still to do, and a run that keeps calling it
+outstanding is nagging your partner about a decision they already made.
+
+With no answer on file, nobody priced anything. `show` calls it `unreviewed`, the
+bar and `close` say the same, and the warning colour stays: the dispatches the
+tier table promised are genuinely owed, and the absence of a pre-flight answer is
+the evidence that nobody weighed them.
+
+What never changes is the number. Nine tasks that shipped without a second pair
+of eyes carry the same risk whether the skip was chosen or forgotten, and the
+count is there to say how far coverage reached. Erasing a chosen skip would turn
+it into a measure of diligence, which is not what anyone reads it for. So the
+word moves and the number does not.
 
 ## The next wave
 

package/skills/sluice/scripts/postinstall.sh

@@ -31,6 +31,52 @@ CONFIGURED="$(jq -r '.statusLine.command // empty' "$SETTINGS" 2>/dev/null || tr
 [ -n "$CONFIGURED" ] || exit 0
 
 RENDER="$(cd "$(dirname "$RENDER")" && pwd)/$(basename "$RENDER")"
+# Physical, and so is every candidate below it: a tmpdir or a home reached
+# through a symlink resolves one way from here and the other way out of a
+# settings string, and the containment check below compares the two.
+CONFIG="$(cd "$BUNDLE/../.." && pwd -P)"
+
+# Someone who pasted the two lines a release ago has nothing left to do, and
+# saying it again on every update is the one thing they cannot switch off. So
+# the script the slot runs is read before anything is printed.
+#
+# It is recovered rather than known: settings.json holds a shell command, so
+# every token carrying a slash is tried as a path, with the two variables a
+# config path is ever written through expanded by substitution. Not by eval,
+# which on a settings file means running its contents. A token that resolves to
+# nothing is skipped and the instructions print as they did before, so a command
+# this cannot read costs a notice rather than a wrong silence.
+#
+# Only paths inside the config directory this skill installed into are opened.
+# The slot is someone elses shell string and may name anything; a postinstall
+# that followed it wherever it pointed would be reading arbitrary files off a
+# line it does not control.
+statusline_script() {
+	local tok path dir
+	for tok in $(printf '%s' "$1" | tr -s "\"'| \t" '\n'); do
+		case "$tok" in */*) ;; *) continue ;; esac
+		path="$tok"
+		path="${path//\$\{CLAUDE_CONFIG_DIR:-\$HOME\/.claude\}/$CONFIG}"
+		path="${path//\$\{CLAUDE_CONFIG_DIR\}/$CONFIG}"
+		path="${path//\$CLAUDE_CONFIG_DIR/$CONFIG}"
+		path="${path//\$\{HOME\}/$HOME}"
+		path="${path//\$HOME/$HOME}"
+		case "$path" in "~/"*) path="$HOME/${path#\~/}" ;; esac
+		[ -f "$path" ] || continue
+		dir="$(cd "$(dirname "$path")" 2>/dev/null && pwd -P)"
+		[ -n "$dir" ] || continue
+		path="$dir/$(basename "$path")"
+		case "$path" in "$CONFIG"/*) ;; *) continue ;; esac
+		printf '%s\n' "$path"
+		return 0
+	done
+	return 1
+}
+
+SLOT_SCRIPT="$(statusline_script "$CONFIGURED" || true)"
+if [ -n "$SLOT_SCRIPT" ] && grep -q "skills/sluice/scripts/statusline.sh" "$SLOT_SCRIPT" 2>/dev/null; then
+	exit 0
+fi
 
 # The slot points at the bundled command: the install claimed it and there is
 # nothing for anyone to paste. Say so rather than print instructions that would

package/skills/sluice/scripts/status.sh

@@ -189,22 +189,23 @@ if [ "$SUB" = "line" ]; then
 		def clean: if type == "string" then gsub("[\u0000-\u001f\u007f]"; "") else . end;
 		def paint($c; $t): "\($esc)[\($c)m\($t)\($esc)[0m";
 		def join_parts: map(select(. != null and . != "")) | join(" \($esc)[2m·\($esc)[0m ");
-		# Done splits in two. A task that is done and was owed a review nobody has
-		# marked keeps the done shape but trails the review glyph, so the debt reads
-		# in position rather than only as a count. Tier 0 was never owed a dispatch,
-		# so it is plainly done.
-		def cellgroup($w):
+		# Done splits in two. A task that is done and got no dispatch keeps the done
+		# shape but trails the review glyph, so where the gap is reads in position
+		# rather than only as a count. Tier 0 was never owed a dispatch, so it is
+		# plainly done. $mark is the marker colour: a level pre-flight chose is a
+		# fact about coverage and draws dim, one nobody priced is a warning.
+		def cellgroup($w; $mark):
 			(.status == "done"
 			 and (.tier // 0) >= 1
-			 and (.reviewed // false) == false) as $owed
+			 and (.reviewed // false) == false) as $nodispatch
 			| (if   .status == "done"    then ["32", "▰"]
 			   elif .status == "active"  then ["96", "◈"]
 			   elif .status == "review"  then ["33", "▨"]
 			   elif .status == "blocked" then ["91", "▮"]
 			   else ["2", "▱"]
 			   end) as $s
-			| if $owed and $w > 1
-			  then paint($s[0]; ($s[1] * ($w - 1))) + paint("33"; "▨")
+			| if $nodispatch and $w > 1
+			  then paint($s[0]; ($s[1] * ($w - 1))) + paint($mark; "▨")
 			  else paint($s[0]; ($s[1] * $w))
 			  end;
 
@@ -219,7 +220,12 @@ if [ "$SUB" = "line" ]; then
 		   else 1 end) as $w
 		| (if $w > 1 then " " else "" end) as $gap
 		| ([.tasks[]? | select(.status == "done")] | length) as $done
-		| ([.tasks[]? | select(.status == "done" and (.tier // 0) >= 1 and (.reviewed // false) == false)] | length) as $debt
+		| ([.tasks[]? | select(.status == "done" and (.tier // 0) >= 1 and (.reviewed // false) == false)] | length) as $nodispatch
+		# A pre-flight review answer on file means the stop happened and the level
+		# was priced, so the tasks it skipped were spent rather than forgotten. The
+		# count is the same either way, because the gap in the code is the same; the
+		# word is not, and "unreviewed" on a level someone chose reads as a nag.
+		| (((.preflight.review // "") | length) > 0) as $priced
 		| [.tasks[]? | select(.status == "blocked")] as $blockedAll
 		| [.tasks[]? | select(.status == "active")] as $activeAll
 		| ($blockedAll | first) as $blocked
@@ -257,14 +263,17 @@ if [ "$SUB" = "line" ]; then
 		  # what the flip means, and a name in the header could not say it.
 		  ( "  " + ([ .tasks[]?
 		              | (if .flips then paint("95"; "┃") + $gap else "" end)
-		                + cellgroup($w)
+		                + cellgroup($w; (if $priced then "2" else "33" end))
 		            ] | join($gap)) ),
 		  ( "  " + ([ paint("1"; "\($done)/\(.tasks | length)") + " done",
 		              (if   $blocked then paint("1;91"; "!T\($blocked.id) \($blocked.name // "" | clean)")
 		               elif $active  then paint("96"; "▸T\($active.id)") + " " + ($active.name // "" | clean)
 		               else "" end)
 		              + (if $attn > 1 then paint("2"; " +\($attn - 1)") else "" end),
-		              (if $debt > 0 then paint("33"; "⟲ \($debt) unreviewed") else "" end)
+		              (if $nodispatch == 0 then ""
+		               elif $priced then paint("2"; "⟲ \($nodispatch) at the chosen level")
+		               else paint("33"; "⟲ \($nodispatch) unreviewed")
+		               end)
 		            ] | join_parts)
 		  )
 	' "$STATE" 2>/dev/null || exit 0
@@ -607,8 +616,17 @@ case "$SUB" in
 			            end
 			     end)
 			+ (if .paused then ["paused        \(.paused | clean)"] else [] end)
-			+ (([.tasks[]? | select(.status == "done" and (.tier // 0) >= 1 and (.reviewed // false) == false)] | length) as $debt
-			   | if $debt == 0 then [] else ["unreviewed    \($debt) done, owed a review the tier table promised"] end)
+			# Same count, two readings. A pre-flight review answer on file says the
+			# level was priced at the stop, so what it skipped is the coverage of this
+			# run. With no answer on file nobody priced anything and the dispatches in
+			# the tier table are still owed. The answer itself is not repeated here:
+			# the pre-flight row below carries it, three lines down.
+			+ (([.tasks[]? | select(.status == "done" and (.tier // 0) >= 1 and (.reviewed // false) == false)] | length) as $nodispatch
+			   | if $nodispatch == 0 then []
+			     elif ((.preflight.review // "") | length) > 0
+			     then ["coverage      \($nodispatch) done at tier 1+, no dispatch"]
+			     else ["unreviewed    \($nodispatch) done at tier 1+, owed a review and no pre-flight answer"]
+			     end)
 			+ ["final review  " + (if .final_review then "done" else "pending" end)]
 			+ ["pre-flight    " + (
 				if (.preflight // {} | length) == 0 then "not recorded"
@@ -793,9 +811,13 @@ case "$SUB" in
 		# allowed to stop the archive.
 		summary="$(jq -r '
 			([.tasks[]? | select(.status == "done")] | length) as $done
-			| ([.tasks[]? | select(.status == "done" and (.tier // 0) >= 1 and (.reviewed // false) == false)] | length) as $debt
+			| ([.tasks[]? | select(.status == "done" and (.tier // 0) >= 1 and (.reviewed // false) == false)] | length) as $nodispatch
+			| (((.preflight.review // "") | length) > 0) as $priced
 			| [ "closed \(.topic // "run"): \($done)/\(.tasks | length) done",
-			    (if $debt > 0 then "\($debt) unreviewed" else empty end),
+			    (if   $nodispatch == 0 then empty
+			     elif $priced then "\($nodispatch) at the chosen review level"
+			     else "\($nodispatch) unreviewed"
+			     end),
 			    "final review \(if .final_review then "done" else "pending" end)"
 			  ] | join(" · ")
 		' "$STATE" 2>/dev/null || true)"

package/skills/sluice/skill.json

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