@iceinvein/agent-skills 0.9.0 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iceinvein/agent-skills",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "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 and one status command can answer where the run is, 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.10.0"
+    "version": "0.12.0"
   },
   {
     "name": "temporal-coupling-detector",

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

@@ -91,9 +91,11 @@ pre-flight settled. `scripts/status.sh` writes and reads it, and
 `references/status.md` carries the commands and the statusline segment that
 makes a run visible without anyone asking. Open it with `init` when you open the
 record, seed the rows with `scripts/plan.sh import <plan>` rather than typing a
-command per task, then flip each task as it moves. Import is safe to re-run: it
-sets names, model marks and the flip, and leaves a status already recorded
-alone, so resuming after a compaction cannot rewind the run.
+command per task, then flip each task as it moves. It carries the ids, the names,
+the flip, the model marks and the tiers, the last of these floored off `Touches`
+and the contract graph rather than guessed. Import is safe to re-run: a status, a
+review mark or a ratified model already recorded is left alone and a tier is only
+ever raised, so resuming after a compaction cannot rewind the run.
 
 The record is the other file, and it holds what a status cannot: the reason
 review went the way it did, the reason a task was downshifted, the reason the
@@ -234,14 +236,22 @@ about it.
 Read the plan as a graph before you read it as a list. `Needs` and `Offers`
 are dependency edges, not only blindness insurance: a task is ready when every
 `Needs` it names is offered by a task already done, and any two ready tasks
-with disjoint `Touches` can go at the same time. Do that read once, before
-Task 1. A plan run in the order it happened to be written is a plan whose
+with disjoint `Touches` can go at the same time.
+
+**`scripts/status.sh ready` does that read.** It prints the ready set, names which
+of them share a path and so cannot go together, says which tasks are still waiting
+on a contract and what for, and holds the flip out of every wave. Run it before
+each wave rather than deriving it again by hand, and note that it also checks the
+candidates against whatever is already `active` or in `review`: those hold their
+paths too, and a wave checked only against itself reads as safe while colliding
+with work in flight. A plan run in the order it happened to be written is a plan whose
 graph nobody looked at, and inert-first ordering tends to put the independent
 tasks at the front, so the opportunity is usually real.
 
 Derive the sets at dispatch rather than writing wave numbers into the plan. A
 declared schedule is wrong the moment one task lands late or comes back with a
-blocking finding. A derived one just recomputes.
+blocking finding. A derived one just recomputes, which is the whole reason `ready`
+reads the run state rather than the plan: it sees what has actually landed.
 
 - One row per task in `run.json`, flipped to `active` and then `done` as it
   moves. That state outlives compaction; your memory doesn't.
@@ -365,6 +375,14 @@ or four dispatches rather than nine. If most of your plan qualifies for a
 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.
+
 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:
 a reviewer writes nothing, so it collides with nothing. The final review is

package/skills/sluice/references/status.md

@@ -15,9 +15,12 @@ bash <skill-dir>/scripts/status.sh init --topic <t> --channel deep \
 bash <skill-dir>/scripts/status.sh task 3 --name "adapter seam" --tier 1 --model cheap
 bash <skill-dir>/scripts/status.sh task 3 --status active --base 75014c9
 bash <skill-dir>/scripts/status.sh task 3 --status done --commit 2c7f261
+bash <skill-dir>/scripts/status.sh task 3 --reviewed
 bash <skill-dir>/scripts/status.sh preflight --review "tier 3 only" --model "6 of 9 cheap" \
      --workspace "one worktree per implementer"
 bash <skill-dir>/scripts/status.sh show
+bash <skill-dir>/scripts/status.sh ready
+bash <skill-dir>/scripts/status.sh line --full
 bash <skill-dir>/scripts/status.sh close
 ```
 
@@ -39,13 +42,24 @@ which is the file that does get committed.
 
 Open it with `init` when you open the run record, at the same point and for the
 same reason, then seed the rows with `plan.sh import <plan>` rather than a
-command per task. The ids, names, the flip, the `Model` marks and the one tier
-the plan settles are all fixed the moment the plan is written and are already in
-the file, so typing them again is transcription with a chance of error in it.
+command per task. The ids, names, the flip, the `Model` marks and the tiers are
+all fixed the moment the plan is written and are already in the file, so typing
+them again is transcription with a chance of error in it.
+
+The tier import writes is a floor read off `Touches`: an `(edit)` means existing
+code changed, no `(test)` means nothing executable covers the task, and `Flips`
+or a `Review` flag is tier 3 outright. Raise one by hand with `--tier` where the
+work is more delicate than its paths suggest; nothing lowers it for you, because
+the tier table takes the highest row a task matches.
 
 Re-importing is safe and is the right move after the plan changes. It refreshes
-names, the flip and the tier, and it leaves a status or a ratified model already
-recorded alone, so resuming after a compaction cannot rewind the run.
+names, the contract graph and the flip, moving the flip when the plan moved it,
+and it raises a tier without ever lowering one. A status, a review mark or a model
+ratified at pre-flight is left alone, so resuming after a compaction cannot rewind
+the run. The one consequence worth knowing: adding a missing `(test)` to a plan
+will not drop a task from tier 2 back to tier 1, because the tier table takes the
+highest row a task matches and nothing here can tell a correction from a
+regression. Lower it by hand with `--tier` if that is what you mean.
 
 ## What goes where
 
@@ -70,15 +84,86 @@ 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.
 
-`show --json` is the same state for another reader. `line` is the one-line form,
-and it exits 0 in silence on a missing run, unreadable state or a missing jq,
-because its caller is a status bar with nowhere to put an error.
+`show --json` is the same state for another reader. `line` is the compact
+one-line form and `line --full` the wide one; both exit 0 in silence on a missing
+run, unreadable state or a missing jq, because their caller is a status bar with
+nowhere to put an error.
+
+`line --full` renders three rows: the run and its clock, the bar alone, then the
+detail. The bar gets a row to itself so it never competes with text for width,
+which is what lets a cell be wide enough to read as a block rather than a tick.
+
+A group of cells per task, one repeated glyph each: `▰` done, `◈` active, `▨` in
+review, `▮` blocked, `▱` still to do. The glyphs are distinct before they are
+coloured, so the rows survive having their colour stripped. The width is chosen
+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.
+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,
+which is why it is printed whether or not the bar could show the same thing.
+
+**The flip draws as a rule, `┃`, before its task.** Everything left of it is inert
+and safe to leave landed; everything right of it is not. That is what the flip
+means, and it is a boundary between tasks rather than a property of one, so a
+name in the header could not say it. `plan.sh validate` rejects a plan with two
+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.
+
+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.
+
+## The next wave
+
+`ready` answers the one question the other commands do not: not what the state is,
+but what may go now. A task is ready when every symbol it `Needs` is offered by a
+task already done, and two ready tasks are safe together when their `Touches` are
+disjoint.
+
+```
+6 ready now · a worktree each
+  T1  extract the bundle writer              src/cli/adapters/bundle.ts, …
+  T4  record what the harness offers         skills/sluice/scripts/status.sh, …
+  T4 and T5 share skills/sluice/scripts/status.sh, so not together
+
+2 waiting on a contract
+  T2  cursor and gemini write bundles        needs writeBundle
+
+the flip runs alone
+  T8  sluice installs on four harnesses
+```
+
+It reads the graph `plan.sh import` recorded, so a run seeded before that existed
+says so and tells you to re-import rather than reporting everything ready. The
+flip is held out of every wave whatever the graph says, because the invariant it
+establishes is what the tasks after it are checked against.
+
+Derive the wave here rather than writing wave numbers into the plan. A declared
+schedule is wrong the moment one task lands late; this recomputes.
 
 ## Statusline
 
-This is the part that makes a run visible without anyone asking. The segment
-goes in the Claude Code statusline command, keyed off the state file existing so
-a session with no run in flight spawns nothing:
+This is the part that makes a run visible without anyone asking. Give it rows of
+its own rather than a segment among the badges: it then costs nothing when no run
+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, keyed off the
+state file existing so a session with no run spawns no process at all:
 
 ```bash
 sluice_line=""
@@ -86,16 +171,34 @@ if [ -n "$cwd" ] && [ -f "$cwd/.sluice/run.json" ]; then
   for sluice_sh in "$cwd/.claude/skills/sluice/scripts/status.sh" \
                    "$HOME/.claude/skills/sluice/scripts/status.sh"; do
     [ -f "$sluice_sh" ] || continue
-    sluice_line=$(bash "$sluice_sh" line --dir "$cwd" 2>/dev/null)
+    sluice_line=$(bash "$sluice_sh" line --full --dir "$cwd" 2>/dev/null)
     break
   done
 fi
-[ -n "$sluice_line" ] && printf ' %s' "$sluice_line"
 ```
 
-`$cwd` is `workspace.current_dir` from the JSON the harness sends on stdin. It
-renders as `sluice deep 4/9 ▸T5`, or `!T5` where a task is blocked, which is
-the one state worth colouring as a warning rather than as progress.
+then print it last, after whatever else the command emits:
+
+```bash
+if [ -n "$sluice_line" ]; then printf '%s\n' "$sluice_line"; fi
+```
+
+`if` rather than `[ ... ] &&`: as the last command of a statusline script the
+short form makes it exit 1 on every render with no run live, which is the common
+case. `%s` rather than `%b`: the render already carries real escape bytes, and
+`%b` would reinterpret a backslash inside a task name. `$cwd` is
+`workspace.current_dir` from the JSON the harness sends on stdin. It renders as:
+
+```
+⧗ deep · sluice-cross-harness   ◷ 38m
+  ▰▰▰ ▰▰▨ ▨▨▨ ◈◈◈ ▱▱▱ ▮▮▮ ▱▱▱ ┃ ▱▱▱ ▱▱▱
+  2/9 done · !T6 model tiers rather than model names +1 · ⟲1 unreviewed
+```
+
+The colour comes out of the script rather than being applied by the caller,
+because the mapping from state to colour belongs next to the state. A caller that
+coloured the line itself would have to re-derive each cell's meaning from its
+glyph, which is the same fact stored twice.
 
 A run that is only visible to the session running it is a run your partner
 cannot redirect. That is the same argument the channel announcement makes, and

package/skills/sluice/scripts/plan.sh

@@ -14,9 +14,9 @@
 # validate prints one line per finding. An error means the plan cannot be
 # dispatched as written; a warning is a judgement call left to its author.
 # import seeds the run state's task rows from the plan, so the ids, names, the
-# flip, the model marks and the one tier the plan settles come from the file
-# rather than from a dozen hand-typed commands. It is safe to re-run: a status or
-# a ratified model already recorded is left alone.
+# flip, the model marks and the tiers come from the file rather than from a dozen
+# hand-typed commands. It is safe to re-run: a status, a review mark or a
+# ratified model already recorded is left alone, and a tier is only ever raised.
 #
 # Exit: 0 no errors, 2 errors found, 4 bad arguments, 5 jq missing (import only).
 
@@ -24,24 +24,40 @@ set -uo pipefail
 
 err() { echo "plan.sh: $*" >&2; }
 
+# ASCII unit separator. Tab would be merged by `read`; see the parser comment.
+SEP="$(printf '\037')"
+
 usage() {
 	echo "usage:" >&2
 	sed -n '/^#   plan.sh validate/,/^# Exit:/p' "$0" | sed 's/^# \{0,2\}//' >&2
 }
 
-# The parser. Emits tab-separated rows on stdout:
+# The parser. Emits rows on stdout separated by 0x1f, the ASCII unit separator,
+# NOT by a tab. Tab is an IFS *whitespace* character, so `read` merges runs of it
+# and drops empty fields: one task with an empty Needs then shifts every later
+# field left, which is how the graph columns silently swapped. 0x1f is
+# non-whitespace, so empty columns survive.
+#
+# Rows:
 #   summary <task count> <flip task or 0>
 #   error|warn  <message>
-#   task  <id>  <name>  <tier 3 or ->  <model 1|0>  <flips 1|0>
+#   task  <id>  <name>  <tier 0-3>  <model 1|0>  <flips 1|0>  <needs>  <offers>  <touches>
+#
+# The last three are space-separated and are what answers "which tasks may go
+# now": a task is ready when every Needs it names is offered by something already
+# done, and two ready tasks are safe together when their Touches are disjoint.
 #
-# Only tier 3 is derivable from the plan: Flips and a Review flag are the two
-# triggers the plan itself settles. The rest turn on task shape and stay for the
-# tier table to decide.
+# The tier is a floor derived from what the plan actually settles: an (edit) in
+# Touches means existing code changed, no (test) means nothing executable covers
+# the task, and Flips or a Review flag is tier 3 outright. A task matching more
+# than one row takes the highest, per the tier table.
 #
 # One pass, line-oriented, because the plan format is a strict skeleton rather
 # than free markdown. Fenced blocks are skipped: a plan carries signatures and
 # commands in them, and a `- [ ]` inside a fence is an example, not a step.
 PARSER='
+BEGIN { SEP = sprintf("%c", 31) }
+
 function trim(s) { gsub(/^[ \t]+|[ \t]+$/, "", s); return s }
 
 # Symbols on one side of a Contract line. The two sides are read differently
@@ -54,7 +70,16 @@ function trim(s) { gsub(/^[ \t]+|[ \t]+$/, "", s); return s }
 #
 # Demand (Needs) is strict, because an extra symbol here is a false error:
 # backticked names and signatures only, falling back to the leading identifier
-# of each comma-separated part when the half carries neither.
+# of each comma-separated part when the half carries neither. Primitive type
+# names are dropped from it: a return shape drags in whatever it is spelled with,
+# and no task in any plan creates `string`.
+function is_primitive(w) {
+	return (w == "string" || w == "number" || w == "boolean" || w == "bool" ||
+	        w == "void" || w == "any" || w == "unknown" || w == "never" ||
+	        w == "null" || w == "undefined" || w == "int" || w == "float" ||
+	        w == "object" || w == "Promise" || w == "Array")
+}
+
 function symbols(half, out, generous,   count, rest, tok, lower, n, parts, i, chunk) {
 	lower = half
 	gsub(/`/, "", lower)
@@ -76,28 +101,43 @@ function symbols(half, out, generous,   count, rest, tok, lower, n, parts, i, ch
 	while (match(rest, /`[^`]*`/)) {
 		chunk = substr(rest, RSTART + 1, RLENGTH - 2)
 		rest = substr(rest, RSTART + RLENGTH)
-		if (match(chunk, /[A-Za-z_][A-Za-z0-9_]*/))
-			out[++count] = substr(chunk, RSTART, RLENGTH)
+		# The leading identifier of a backticked chunk, unless that is a wrapper
+		# like Promise<Config> or Array<TaskRow>: then the dependency is what it
+		# wraps, and taking the leading one both misses the real symbol and
+		# invents a false one.
+		while (match(chunk, /[A-Za-z_][A-Za-z0-9_]*/)) {
+			tok = substr(chunk, RSTART, RLENGTH)
+			chunk = substr(chunk, RSTART + RLENGTH)
+			if (!is_primitive(tok)) { out[++count] = tok; break }
+		}
 	}
 	rest = half
 	gsub(/`/, "", rest)
 	while (match(rest, /[A-Za-z_][A-Za-z0-9_]*\(/)) {
 		tok = substr(rest, RSTART, RLENGTH - 1)
-		out[++count] = tok
+		if (!is_primitive(tok)) out[++count] = tok
 		rest = substr(rest, RSTART + RLENGTH)
 	}
 	if (count == 0) {
 		rest = half
 		gsub(/`/, "", rest)
 		n = split(rest, parts, /[,;]/)
-		for (i = 1; i <= n; i++)
-			if (match(parts[i], /[A-Za-z_][A-Za-z0-9_]*/))
-				out[++count] = substr(parts[i], RSTART, RLENGTH)
+		for (i = 1; i <= n; i++) {
+			chunk = parts[i]
+			# Guarded like the strict rules above. Unguarded, a half whose every
+			# candidate was a primitive fell through to here and the filter was
+			# undone by the code meant to back it up.
+			while (match(chunk, /[A-Za-z_][A-Za-z0-9_]*/)) {
+				tok = substr(chunk, RSTART, RLENGTH)
+				chunk = substr(chunk, RSTART + RLENGTH)
+				if (!is_primitive(tok)) { out[++count] = tok; break }
+			}
+		}
 	}
 	return count
 }
 
-function finding(sev, msg) { out[++nout] = sev "\t" msg }
+function finding(sev, msg) { out[++nout] = sev SEP msg }
 
 /^[ \t]*```/ { fenced = 1 - fenced; next }
 fenced { next }
@@ -166,6 +206,7 @@ in_rules && /^- / { nrules++ }
 	n = symbols(oh, syms, 1)
 	for (i = 1; i <= n; i++) {
 		if (!(syms[i] in offered_by) || cur < offered_by[syms[i]]) offered_by[syms[i]] = cur
+		offers[cur] = offers[cur] " " syms[i]
 	}
 	next
 }
@@ -175,15 +216,34 @@ in_rules && /^- / { nrules++ }
 	body = substr($0, length("**Touches:**") + 1)
 	n = split(body, parts, /\|/)
 	for (i = 1; i <= n; i++) {
+		# The path is everything before the first parenthesis. Stripping only a
+		# trailing annotation left the rest of a mid-field one in the path, and
+		# those fragments then read as real paths: two tasks with disjoint files
+		# came out sharing "(edit)" and were serialised for nothing.
 		p = parts[i]
-		sub(/\([^)]*\)[ \t]*$/, "", p)
+		if (index(p, "(") > 0) p = substr(p, 1, index(p, "(") - 1)
 		p = trim(p)
 		if (p == "") continue
+		# The annotation is what the tier table turns on, so it is kept rather
+		# than stripped and forgotten: an (edit) means existing code changed, and
+		# the absence of any (test) means nothing executable covers the task.
+		if (parts[i] ~ /\(edit\)/) has_edit[cur] = 1
+		if (parts[i] ~ /\(test\)/) has_test[cur] = 1
+		if (parts[i] ~ /\(new\)/)  has_new[cur] = 1
+		# Under-tiering is the unsafe direction: an unrecognised annotation, or a
+		# missing one, reads as "nothing was edited here" and the task then owes
+		# no review. Say so rather than deriving from a spelling nobody checked.
+		if (parts[i] !~ /\((new|edit|test)\)/)
+			finding("warn", "task " cur " Touches " p " with no (new), (edit) or (test) annotation, so its tier is derived as if nothing was edited")
+		else if (parts[i] !~ /\((new|edit|test)\)[ \t]*$/)
+			finding("warn", "task " cur " Touches " p " with text after its annotation; the tier reads correctly but the line is not the format")
 		# Accumulated rather than assigned: with three tasks on one path,
 		# reporting a single pair leaves the reader serialising two of them and
 		# still running the third alongside.
 		if (index(" " owners[p] " ", " " cur " ") == 0)
 			owners[p] = owners[p] (owners[p] == "" ? "" : " ") cur
+		if (index(" " paths[cur] " ", " " p " ") == 0)
+			paths[cur] = paths[cur] (paths[cur] == "" ? "" : " ") p
 	}
 	next
 }
@@ -259,14 +319,55 @@ END {
 		finding("warn", "tasks " list " " (n == 2 ? "both" : "all") " touch " p ", so they cannot run at the same time")
 	}
 
+	# A task matching more than one row takes the highest of them, which is what
+	# the tier table says and the reason this is a max rather than a chain of
+	# elses. Computed once, ahead of both the histogram and the task rows.
+	# The LAST task demanding each symbol, so "later tasks build on it" answers
+	# for any consumer rather than only the earliest. Kept as a minimum, one early
+	# consumer hid every later one and the producer three tasks were built blind
+	# against came out owing no review at all.
+	for (i = 1; i <= ntasks; i++) {
+		n = split(needs[order[i]], want, " ")
+		for (j = 1; j <= n; j++)
+			if (want[j] != "" && (!(want[j] in last_demand) || order[i] > last_demand[want[j]]))
+				last_demand[want[j]] = order[i]
+	}
+
+	for (i = 1; i <= ntasks; i++) {
+		id = order[i]
+		t = 0
+		if (id in has_edit) t = 1
+		# A task whose only path is a test is changing a suite that already
+		# exists: the format offers no "(test) (edit)" spelling, so the annotation
+		# cannot say so, and reading it as a creation leaves the task owing
+		# nothing. Under-tiering is the unsafe direction.
+		if ((id in has_test) && !(id in has_new) && !(id in has_edit)) t = 1
+		n = split(offers[id], mine, " ")
+		for (j = 1; j <= n; j++)
+			if (mine[j] != "" && (mine[j] in last_demand) && last_demand[mine[j]] > id) t = (t > 1 ? t : 1)
+		if (!(id in has_test)) t = (t > 2 ? t : 2)
+		if ((id in has_flips) || (id in has_review)) t = 3
+		tier_of[id] = t
+	}
+
 	flip = 0
 	for (i = 1; i <= ntasks; i++) if (order[i] in has_flips) { flip = order[i]; break }
-	print "summary\t" ntasks "\t" flip
+	# The histogram is what prices the review question at pre-flight: "four of
+	# nine need a reviewer" is a decision a partner can weigh, and counting it
+	# by hand off a nine-task plan is how the count comes out wrong.
+	hist = ""
+	for (t = 0; t <= 3; t++) {
+		c = 0
+		for (i = 1; i <= ntasks; i++) if (tier_of[order[i]] == t) c++
+		if (c > 0) hist = hist (hist == "" ? "" : " ") t ":" c
+	}
+	print "summary" SEP ntasks SEP flip SEP hist
 	for (i = 1; i <= nout; i++) print out[i]
 	for (i = 1; i <= ntasks; i++) {
 		id = order[i]
-		tier = ((id in has_flips) || (id in has_review)) ? "3" : "-"
-		print "task\t" id "\t" name[id] "\t" tier "\t" ((id in has_model) ? 1 : 0) "\t" ((id in has_flips) ? 1 : 0)
+		tier = tier_of[id]
+		print "task" SEP id SEP name[id] SEP tier SEP ((id in has_model) ? 1 : 0) SEP ((id in has_flips) ? 1 : 0) \
+			SEP trim(needs[id]) SEP trim(offers[id]) SEP trim(paths[id])
 	}
 }
 '
@@ -279,13 +380,14 @@ parse_plan() {
 	raw="$(awk "$PARSER" "$plan")" || { err "could not read $plan"; exit 4; }
 
 	local summary
-	summary="$(printf '%s\n' "$raw" | grep '^summary	' | head -1)"
-	NTASKS="$(printf '%s' "$summary" | cut -f2)"
-	FLIP="$(printf '%s' "$summary" | cut -f3)"
-	FINDINGS="$(printf '%s\n' "$raw" | grep -E '^(error|warn)	' || true)"
-	TASKROWS="$(printf '%s\n' "$raw" | grep '^task	' || true)"
-	NERR="$(printf '%s\n' "$FINDINGS" | grep -c '^error	' || true)"
-	NWARN="$(printf '%s\n' "$FINDINGS" | grep -c '^warn	' || true)"
+	summary="$(printf '%s\n' "$raw" | grep "^summary$SEP" | head -1)"
+	NTASKS="$(printf '%s' "$summary" | cut -d"$SEP" -f2)"
+	FLIP="$(printf '%s' "$summary" | cut -d"$SEP" -f3)"
+	TIERS="$(printf '%s' "$summary" | cut -d"$SEP" -f4)"
+	FINDINGS="$(printf '%s\n' "$raw" | grep -E "^(error|warn)$SEP" || true)"
+	TASKROWS="$(printf '%s\n' "$raw" | grep "^task$SEP" || true)"
+	NERR="$(printf '%s\n' "$FINDINGS" | grep -c "^error$SEP" || true)"
+	NWARN="$(printf '%s\n' "$FINDINGS" | grep -c "^warn$SEP" || true)"
 }
 
 # "1 error" / "2 errors", so the header does not read as a template.
@@ -310,6 +412,7 @@ case "$SUB" in
 
 		head="$(basename "$PLAN"): $(plural "$NTASKS" task)"
 		[ "$FLIP" != "0" ] && head="$head, flip at task $FLIP"
+		[ -n "$TIERS" ] && head="$head, tiers $TIERS"
 		if [ "$NERR" = "0" ] && [ "$NWARN" = "0" ]; then
 			echo "$head, no errors"
 			exit 0
@@ -321,9 +424,9 @@ case "$SUB" in
 		echo
 		# Errors before warnings. Within each, the parser's own order, which
 		# follows the file.
-		{ printf '%s\n' "$FINDINGS" | grep '^error	' || true
-		  printf '%s\n' "$FINDINGS" | grep '^warn	' || true
-		} | while IFS="$(printf '\t')" read -r sev msg; do
+		{ printf '%s\n' "$FINDINGS" | grep "^error$SEP" || true
+		  printf '%s\n' "$FINDINGS" | grep "^warn$SEP" || true
+		} | while IFS="$SEP" read -r sev msg; do
 			[ -n "$sev" ] || continue
 			printf '  %-5s  %s\n' "$sev" "$msg"
 		done
@@ -375,15 +478,37 @@ case "$SUB" in
 		HAS_MODEL=" $(bash "$STATUS" show --json --dir "$DIR" 2>/dev/null |
 			jq -r '[.tasks[]? | select(.model != null) | .id] | join(" ")' 2>/dev/null) "
 
-		printf '%s\n' "$TASKROWS" | while IFS="$(printf '\t')" read -r _ id name tier model flips; do
+		# The tier table takes the highest row a task matches, so a tier raised by
+		# hand is a decision and re-import may only ever raise. Lowering it back
+		# silently un-decides it and drops the task out of the review debt it was
+		# owed, which is the opposite of what re-import is for.
+		RECORDED_TIERS="$(bash "$STATUS" show --json --dir "$DIR" 2>/dev/null |
+			jq -r '[.tasks[]? | select(.tier != null) | "\(.id):\(.tier)"] | join(" ")' 2>/dev/null)"
+
+		printf '%s\n' "$TASKROWS" | while IFS="$SEP" read -r _ id name tier model flips needs offers touches; do
 			[ -n "${id:-}" ] || continue
 			set -- task "$id" --name "$name" --dir "$DIR"
-			[ "$flips" = "1" ] && set -- "$@" --flips
-			[ "$tier" != "-" ] && [ -n "$tier" ] && set -- "$@" --tier "$tier"
+			# The flip is a plan fact rather than a run decision, so import is
+			# authoritative on it both ways. Add-only left a moved flip set on two
+			# tasks, and the render then named the wrong milestone.
+			if [ "$flips" = "1" ]; then set -- "$@" --flips; else set -- "$@" --no-flips; fi
+			if [ -n "$tier" ] && [ "$tier" != "-" ]; then
+				recorded=""
+				for pair in $RECORDED_TIERS; do
+					case "$pair" in "$id:"*) recorded="${pair#*:}" ;; esac
+				done
+				if [ -z "$recorded" ] || [ "$tier" -gt "$recorded" ]; then
+					set -- "$@" --tier "$tier"
+				fi
+			fi
 			case "$HAS_MODEL" in
 				*" $id "*) ;;
 				*) [ "$model" = "1" ] && set -- "$@" --model cheap ;;
 			esac
+			# Passed unconditionally, empty included: the graph is a plan fact like
+			# the flip, so an edge the plan dropped has to be cleared rather than
+			# left behind reporting a contract that no longer exists.
+			set -- "$@" --needs "${needs:-}" --offers "${offers:-}" --touches "${touches:-}"
 			bash "$STATUS" "$@" || exit 1
 		done || exit 1
 		imported="$NTASKS"

package/skills/sluice/scripts/status.sh

@@ -9,10 +9,13 @@
 #
 #   status.sh init --topic <t> --channel <c> [--plan <p>] [--record <p>] [--force]
 #   status.sh task <id> [--name <n>] [--status <s>] [--base <sha>]
-#                       [--commit <sha>] [--tier 0-3] [--model <m>] [--flips]
+#                       [--commit <sha>] [--tier 0-3] [--model <m>]
+#                       [--flips | --no-flips] [--reviewed]
+#                       [--needs <syms>] [--offers <syms>] [--touches <paths>]
 #   status.sh preflight [--review <t>] [--model <t>] [--workspace <t>]
 #   status.sh show [--json]
-#   status.sh line
+#   status.sh ready
+#   status.sh line [--full]
 #   status.sh close
 #
 # --dir <path> selects the tree to read (default: $PWD). State lives at
@@ -94,17 +97,110 @@ ARCHIVE="$DIR/.sluice/archive"
 # `line` swallows everything: a missing jq, unreadable state, no run at all.
 # Any of those printing would put permanent clutter in the status bar.
 if [ "$SUB" = "line" ]; then
-	[ $# -eq 0 ] || { err "line takes no arguments"; exit 4; }
+	FULL=0
+	while [ $# -gt 0 ]; do
+		case "$1" in
+			--full) FULL=1; shift ;;
+			*) err "unknown flag: $1"; exit 4 ;;
+		esac
+	done
 	command -v jq >/dev/null 2>&1 || exit 0
 	[ -f "$STATE" ] || exit 0
-	jq -r '
-		([.tasks[]? | select(.status == "done")] | length) as $done
-		| [ "sluice",
-		    (.channel // "?"),
-		    "\($done)/\(.tasks | length)",
-		    ([.tasks[]? | select(.status == "active") | "▸T\(.id)"] | first // empty),
-		    ([.tasks[]? | select(.status == "blocked") | "!T\(.id)"] | first // empty)
-		  ] | join(" ")
+
+	if [ "$FULL" -eq 0 ]; then
+		jq -r '
+			([.tasks[]? | select(.status == "done")] | length) as $done
+			| [ "sluice",
+			    (.channel // "?"),
+			    "\($done)/\(.tasks | length)",
+			    ([.tasks[]? | select(.status == "active") | "▸T\(.id)"] | first // empty),
+			    ([.tasks[]? | select(.status == "blocked") | "!T\(.id)"] | first // empty)
+			  ] | join(" ")
+		' "$STATE" 2>/dev/null || exit 0
+		exit 0
+	fi
+
+	# The wide render, three rows: the run and its clock, the bar alone, then the
+	# detail. The bar gets a row to itself so it never competes with text for
+	# width, which is what lets a cell be wide enough to read as a block.
+	#
+	# The flip draws as a rule in the bar rather than a name in the first row: it
+	# is a boundary between tasks, not a property of one, and the first row cannot
+	# say how much of the plan is still reversible.
+	#
+	# Elapsed is passed in rather than computed here, jq having no clock, and
+	# fromdateiso8601 raises rather than returning null, so a bad start time must
+	# cost the clock cell and not the render.
+	jq -r \
+		--argjson now "$(date -u +%s)" \
+		--arg esc "$(printf '\033')" '
+		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):
+			(.status == "done"
+			 and (.tier // 0) >= 1
+			 and (.reviewed // false) == false) as $owed
+			| (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"; "▨")
+			  else paint($s[0]; ($s[1] * $w))
+			  end;
+
+		# Three cells read as a block, one reads as a tick. The width is chosen from
+		# what the whole bar would occupy, gaps and the flip boundary included, so
+		# the schedule is monotonic in the task count. Keyed off the count alone it
+		# was not: thirty tasks at two wide ran wider than twelve at three.
+		(.tasks | length) as $n
+		| (if $n == 0 then 3
+		   elif ($n * 4 + 2) <= 74 then 3
+		   elif ($n * 3 + 2) <= 74 then 2
+		   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 == "blocked")] as $blockedAll
+		| [.tasks[]? | select(.status == "active")] as $activeAll
+		| ($blockedAll | first) as $blocked
+		| ($activeAll | first) as $active
+		| (if ($blockedAll | length) > 0 then ($blockedAll | length) else ($activeAll | length) end) as $attn
+		| ((.started // "" | try fromdateiso8601 catch 0) as $t
+		   | if $t == 0 then ""
+		     else (($now - $t) / 60 | floor) as $m
+		          | if $m < 1 then "◷ <1m"
+		            elif $m < 60 then "◷ \($m)m"
+		            else "◷ \($m / 60 | floor)h\($m % 60)m"
+		            end
+		     end) as $clock
+		| ( paint("1;96"; "⧗") + " "
+		    + ([ paint("1;96"; (.channel // "?")),
+		         paint("2"; (.topic // ""))
+		       ] | join_parts)
+		    + (if $clock == "" then "" else "   " + paint("2"; $clock) end)
+		  ),
+		  # The flip is drawn as a rule before its task: everything left of it is
+		  # inert and safe to leave landed, everything right of it is not. That is
+		  # 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)
+		            ] | join($gap)) ),
+		  ( "  " + ([ paint("1"; "\($done)/\(.tasks | length)") + " done",
+		              (if   $blocked then paint("1;91"; "!T\($blocked.id) \($blocked.name // "")")
+		               elif $active  then paint("96"; "▸T\($active.id)") + " " + ($active.name // "")
+		               else "" end)
+		              + (if $attn > 1 then paint("2"; " +\($attn - 1)") else "" end),
+		              (if $debt > 0 then paint("33"; "⟲\($debt) unreviewed") else "" end)
+		            ] | join_parts)
+		  )
 	' "$STATE" 2>/dev/null || exit 0
 	exit 0
 fi
@@ -189,7 +285,8 @@ case "$SUB" in
 			*[!0-9]* | 0 ) err "task id must be a positive integer, got: $ID"; exit 4 ;;
 		esac
 
-		NAME="" STATUS="" BASE="" COMMIT="" TIER="" MODEL="" FLIPS=false
+		NAME="" STATUS="" BASE="" COMMIT="" TIER="" MODEL="" FLIPS=false UNFLIP=false REVIEWED=false
+		NEEDS="" OFFERS="" TOUCHES="" GRAPH=0
 		while [ $# -gt 0 ]; do
 			case "$1" in
 				--name) need_value --name $# "${2-}"; NAME="$2"; shift 2 ;;
@@ -199,10 +296,19 @@ case "$SUB" in
 				--tier) need_value --tier $# "${2-}"; TIER="$2"; shift 2 ;;
 				--model) need_value --model $# "${2-}"; MODEL="$2"; shift 2 ;;
 				--flips) FLIPS=true; shift ;;
+				--no-flips) UNFLIP=true; shift ;;
+				--reviewed) REVIEWED=true; shift ;;
+				--needs) need_value --needs $# "${2-}"; NEEDS="$2"; GRAPH=1; shift 2 ;;
+				--offers) need_value --offers $# "${2-}"; OFFERS="$2"; GRAPH=1; shift 2 ;;
+				--touches) need_value --touches $# "${2-}"; TOUCHES="$2"; GRAPH=1; shift 2 ;;
 				*) err "unknown flag: $1"; exit 4 ;;
 			esac
 		done
 
+		if [ "$FLIPS" = true ] && [ "$UNFLIP" = true ]; then
+			err "--flips and --no-flips were both given; they contradict"
+			exit 4
+		fi
 		if [ -n "$STATUS" ]; then
 			in_set "$STATUS" "$STATUSES" || { err "unknown status: $STATUS (one of: $STATUSES)"; exit 4; }
 		fi
@@ -235,7 +341,13 @@ case "$SUB" in
 		patch="$(jq -n \
 			--arg name "$NAME" --arg status "$STATUS" --arg base "$BASE" \
 			--arg commit "$COMMIT" --arg tier "$TIER" --arg model "$MODEL" \
-			--argjson flips "$FLIPS" '
+			--argjson flips "$FLIPS" --argjson unflip "$UNFLIP" --argjson reviewed "$REVIEWED" \
+			--arg needs "$NEEDS" --arg offers "$OFFERS" --arg touches "$TOUCHES" \
+			--argjson graph "$GRAPH" '
+			def words: split(" ") | map(select(. != "")) | unique;
+			# A given-but-empty column clears the key: the caller passing the graph
+			# is authoritative on it, so a dropped edge does not survive.
+			def edge($v): if $v == "" then null else ($v | words) end;
 			{}
 			+ (if $name   == "" then {} else {name: $name} end)
 			+ (if $status == "" then {} else {status: $status} end)
@@ -244,15 +356,23 @@ case "$SUB" in
 			+ (if $tier   == "" then {} else {tier: ($tier | tonumber)} end)
 			+ (if $model  == "" then {} else {model: $model} end)
 			+ (if $flips then {flips: true} else {} end)
+			+ (if $unflip then {flips: null} else {} end)
+			+ (if $reviewed then {reviewed: true} else {} end)
+			+ (if $graph == 0 then {}
+			   else {needs: edge($needs), offers: edge($offers), touches: edge($touches)}
+			   end)
 		')"
 
 		jq --argjson id "$ID" --argjson patch "$patch" '
 			.tasks = (
 				if any(.tasks[]?; .id == $id)
-				then [.tasks[] | if .id == $id then . + $patch else . end]
+				then [.tasks[] | if .id == $id then (. + $patch) else . end]
 				else .tasks + [{id: $id, status: "todo"} + $patch]
 				end
 			)
+			# A null in the patch means clear, not store: leaving it would make
+			# every reader test for absent and for null.
+			| .tasks |= map(with_entries(select(.value != null)))
 			| .tasks |= sort_by(.id)
 		' "$STATE" | write_state
 		;;
@@ -314,6 +434,8 @@ case "$SUB" in
 			| ["sluice \(.channel) · \(.topic) · \($done)/\(.tasks | length) done"]
 			+ ["plan        \(.plan | dash)"]
 			+ ["record      \(.record | dash)"]
+			+ (([.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)
 			+ ["pre-flight  " + (
 				if (.preflight // {} | length) == 0 then "not recorded"
 				else [(.preflight | to_entries[] | "\(.key)=\(.value)")] | join("; ")
@@ -329,6 +451,68 @@ case "$SUB" in
 		' "$STATE"
 		;;
 
+	ready)
+		[ $# -eq 0 ] || { err "ready takes no arguments"; exit 4; }
+		require_run
+		require_readable
+
+		# The wave question, which is a graph query rather than a status display:
+		# a task is ready when every symbol it Needs is offered by something
+		# already done, and two ready tasks are safe together when their Touches
+		# are disjoint. Nothing goes concurrent with the flip whatever the graph
+		# says, because the invariant it establishes is what later tasks are
+		# checked against.
+		jq -r '
+			# Clipped with a marker, so a cut name does not read as the whole name,
+			# and always followed by a gap so it cannot run into the next column.
+			def pad($n):
+				if length > $n then .[0:$n - 1] + "… "
+				else . + (" " * ($n - length + 1))
+				end;
+			[.tasks[]? | select(.status == "done") | (.offers // [])[]] as $supplied
+			| [.tasks[]? | select(((.needs // []) | length) > 0 or ((.touches // []) | length) > 0)] as $withgraph
+			| [.tasks[]? | select(.status == "todo" and (.flips // false) == false)] as $pending
+			# Active and in-review tasks still hold their paths. Checked only
+			# against each other, a wave reads as safe while colliding with work
+			# already running, which is worse than not checking at all: the output
+			# says "a worktree each".
+			| [.tasks[]? | select(.status == "active" or .status == "review")] as $inflight
+			| [$pending[] | select([(.needs // [])[] | select(. as $s | $supplied | index($s) == null)] | length == 0)] as $ready
+			| [$pending[] | select([(.needs // [])[] | select(. as $s | $supplied | index($s) == null)] | length > 0)] as $waiting
+			| ([.tasks[]? | select(.flips)] | first) as $flip
+
+			| if ($withgraph | length) == 0 then
+			    "no contract graph in the run state.",
+			    "re-run `plan.sh import <plan>` to record Needs, Offers and Touches."
+			  else
+			    (
+			      "\($ready | length) ready now"
+			      + (if ($ready | length) > 1 then " · a worktree each" else "" end)
+			    ),
+			    ($ready[] | "  T\(.id)  \(.name // "" | pad(38))\((.touches // []) | join(", "))"),
+			    # A shared path is what rules two ready tasks out of the same wave,
+			    # so it is named rather than left to be noticed.
+			    ( [ $ready[] as $a | ($ready + $inflight)[] as $b
+			        | select($a.id != $b.id)
+			        | select(($b.status != "todo") or ($a.id < $b.id))
+			        | [(($a.touches // [])[] | select(. as $p | ($b.touches // []) | index($p)))] as $clash
+			        | select(($clash | length) > 0)
+			        | if $b.status == "todo"
+			          then "  T\($a.id) and T\($b.id) share \($clash | join(", ")), so not together"
+			          else "  T\($a.id) shares \($clash | join(", ")) with T\($b.id), already \($b.status)"
+			          end
+			      ] | unique | .[] ),
+			    (if ($waiting | length) > 0 then
+			       "", "\($waiting | length) waiting on a contract",
+			       ($waiting[] | "  T\(.id)  \(.name // "" | pad(38))needs \([(.needs // [])[] | select(. as $s | $supplied | index($s) == null)] | join(", "))")
+			     else empty end),
+			    (if $flip != null and $flip.status != "done" then
+			       "", "the flip runs alone", "  T\($flip.id)  \($flip.name // "")"
+			     else empty end)
+			  end
+		' "$STATE"
+		;;
+
 	close)
 		[ $# -eq 0 ] || { err "close takes no arguments"; exit 4; }
 		require_run

package/skills/sluice/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "sluice",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "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 and one status command can answer where the run is, 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",