@iceinvein/agent-skills 0.6.0 → 0.8.0

package/package.json

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

package/skills/index.json

@@ -221,7 +221,7 @@
     "name": "magpie",
     "description": "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 (falling back to a Claude second opinion when codex is unavailable), and serves an interactive HTML report for selecting findings to post via gh. Bundles a Bun CLI installed onto PATH via the skill's postinstall step. Use when the user asks to review a GitHub pull request. Splits oversized diffs into budgeted shards and rebuilds the diff from the local clone when gh pr diff refuses it.",
     "type": "prompt",
-    "version": "0.10.0"
+    "version": "0.10.1"
   },
   {
     "name": "migrate",
@@ -281,9 +281,9 @@
   },
   {
     "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, and closes each run 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.",
+    "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, 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.3.0"
+    "version": "0.5.0"
   },
   {
     "name": "temporal-coupling-detector",

package/skills/magpie/scripts/__tests__/cleanup-cmd.test.ts

@@ -105,7 +105,11 @@ test('killServer escalates to SIGKILL when SIGTERM is ignored', async () => {
   expect(result.outcome).toBe('sigkill')
   expect(result.pid).toBe(child.pid)
   await child.exited
-})
+  // Everything asserted here is bounded: killServer polls to a 200ms deadline
+  // and then signals. The clock this test can actually run out of is subprocess
+  // startup, seven git spawns in beforeEach plus a cold `node`, which on a
+  // shared runner has overrun the 5s default and failed a release.
+}, 30_000)
 
 test('runCleanup logs kill outcome to log.jsonl', async () => {
   await writeFile(join(runDir, 'log.jsonl'), '')

package/skills/magpie/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "magpie",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "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 (falling back to a Claude second opinion when codex is unavailable), and serves an interactive HTML report for selecting findings to post via gh. Bundles a Bun CLI installed onto PATH via the skill's postinstall step. Use when the user asks to review a GitHub pull request. Splits oversized diffs into budgeted shards and rebuilds the diff from the local clone when gh pr diff refuses it.",
   "author": "iceinvein",
   "type": "prompt",

package/skills/sluice/SKILL.md

@@ -33,15 +33,18 @@ are examples, not fixed copy, and a channel with a two-part signal should say
 which part applied. `bypass` says nothing at all, because a question that gets
 announced stops being a question.
 
-**`root-cause`, `finish` and `meter` are not channel-assigned.** The code
-misbehaving triggers the first: a bug report, a red test, behaviour you cannot
-account for. An integration event, merging, pushing, or opening a PR, triggers
-the second. Handing the work back triggers the third, whether or not it ever
-reaches an integration event. The first two fire in every channel, `bypass`
-included; `meter` cannot, because `bypass` announces nothing to measure from.
-A question that turns on how something looks is triggered the same way and in
-any channel: `references/show-or-say.md` decides whether to show it or say it,
-and `bypass` is where it comes up most.
+**`root-cause`, `finish`, `meter` and `show-or-say` are not channel-assigned.**
+The code misbehaving triggers the first: a bug report, a red test, behaviour you
+cannot account for. An integration event, merging, pushing, or opening a PR,
+triggers the second. Handing the work back triggers the third, whether or not it
+ever reaches an integration event. A question that turns on how something looks
+rather than on what it means triggers the fourth: say it where a sentence would
+settle it, show it where the candidates have to sit side by side for an eye to
+compare them. `references/show-or-say.md`
+
+The first, second and fourth fire in every channel, `bypass` included, and
+`bypass` is where the fourth comes up most. `meter` does not, because `bypass`
+announces nothing to measure from.
 
 ## The rules
 
@@ -63,8 +66,10 @@ yourself wanting to skip the rule, or arguing that this one is the exception.
   something anyone else can check. `references/verify.md`
 - **Review** before merge. Dispatch a reviewer with fresh context and put the
   diff on disk for it to read, so those bytes fill their context instead of
-  yours. Cannot dispatch one? Say so in the announcement and again at the
-  merge, and nowhere in between. `references/review.md`
+  yours. A session that dispatches only when asked has not refused you one, so
+  ask rather than announce that you cannot. Genuinely without one? Say so in
+  the announcement and again at the merge, and nowhere in between.
+  `references/review.md`
 - **Finish** deliberately. Green suite first, then let your partner pick
   merge, PR, or leave it. Never pick for them. `references/finish.md`
 - **Meter the run** as you hand it back. `scripts/run-stats.sh` reads the
@@ -85,32 +90,32 @@ Design to `docs/specs/YYYY-MM-DD-<topic>.md`, plan to
 `docs/plans/YYYY-MM-DD-<topic>.md`, unless the repo has a convention or
 your partner states a preference. Get the design signed off before code.
 
-The plan gets a stop of its own, whoever executes it. Dispatched agents each
-see only their own task, so nobody reads it whole; executing it yourself is
-the weaker case rather than the exempt one, because then nobody reads it but
-its author.
+The second stop is the plan's, whoever executes it. Dispatched agents each see
+only their own task, so nobody reads it whole; executing it yourself is the
+weaker case rather than the exempt one, because then nobody reads it but its
+author.
 
 Order the plan so the tasks that change nothing come first, and mark the one
 task that turns the new behaviour on. Then a late re-baseline, re-blessed
 snapshots, regenerated fixtures, attributes to that one point instead of to
 the branch at large.
 
-Pre-flight rides in the plan's stop: which flagged tasks get a reviewer, and
+Pre-flight rides in that same stop: which flagged tasks get a reviewer, and
 whether the work runs in a worktree. Ask them as choices with the counts in
-them, never as a paragraph, then end the turn on the answers rather than
-opening Task 1 with them. A session that dispatches only when asked has not
-ruled dispatch out, it has made this question the place to ask. Genuine
-unavailability is the tool not being there at all, which is a different case
-and a different paragraph. Review that turns out to be missing is only
-actionable while the plan can still change.
+them, never as a paragraph, then end the turn. Task 1 opens on their next
+instruction, and an answer that already carries one is that instruction. A
+session that dispatches only when asked has not ruled dispatch out, it has made
+this question the place to ask; genuine unavailability is the tool not being
+there at all, which `references/deep-channel.md` handles separately. Review that
+turns out to be missing is only actionable while the plan can still change.
 
 Read the plan as a graph rather than a list. `Needs` and `Offers` are
 dependency edges and `Touches` says what cannot overlap, so which tasks may
 run at once is derivable rather than guessed. Fan out wherever that graph
 allows; serial is the fallback for where it doesn't, not the default.
 
-Then read `references/deep-channel.md` for the plan format, that stop,
-the dispatch rules, and when a task actually needs a reviewer. Three that
+Then read `references/deep-channel.md` for the plan format, that stop, the run
+record, the dispatch rules, and when a task actually needs a reviewer. Three that
 catch people out: concurrent implementers need a worktree each and the flip
 runs alone, review is tiered rather than automatic, and a `deep` run that
 cannot dispatch has to replace the review tier with something, not quietly

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

@@ -58,15 +58,38 @@ the diff, and they will derive it wrong.
 Two tasks carrying `Flips` means the plan holds two branches' worth of work.
 Split it. A plan with none is not a `deep` plan: nothing in it does anything.
 
+## The run record
+
+A `deep` run outlives its own context, so what it learns has to sit on disk
+rather than in the session. Open one file for the run before pre-flight and
+write it as you go. It holds what a stranger resuming tomorrow would need and
+you would otherwise be recalling: the base each task was dispatched from, each
+task with its status and its commits, the review decisions pre-flight settled
+and the reason each one was settled that way, and any finding belonging to a
+task other than the one that surfaced it.
+
+Where it goes follows the repo if the repo has a convention, and
+`docs/plans/YYYY-MM-DD-<topic>-record.md` if it does not. It belongs to you
+rather than to any task, so it lives in the tree you are working from, no
+task's `Touches` names it, and you commit it yourself alongside the plan.
+Assembling it at handback defeats it: a record written from memory is memory,
+which is the one thing the file exists to replace.
+
+A file only outlives compaction if you go back to it. Read it before the next
+dispatch whenever this session has been summarised, and treat what it says over
+what you remember, including where the two agree. Each task closes by writing
+its commit into the record, which means asking the implementer to report the
+SHA it committed and putting that in the row rather than deriving it later.
+
 ## Pre-flight
 
-Design signed off, plan written, nothing built yet. Before Task 1, hand back
-once and settle two things with your partner. Ask them as questions with
-options, not as a paragraph they have to reply to in prose: what you are after
-is a decision, and a wall of considerations asks them to extract the decision
-from it first.
+Design signed off, plan written, nothing built yet. Before Task 1, stop once
+and settle two things with your partner. Ask them as questions with options,
+not as a paragraph they have to reply to in prose: what you are after is a
+decision, and a wall of considerations asks them to extract the decision from
+it first.
 
-This handback is the plan's sign-off as well, so it ends your turn, and a
+This stop is the plan's sign-off as well, so it ends your turn, and a
 question tool does not end it for you. That tool returns an answer without
 returning control: two options came back, the plan itself did not, and your
 partner reads the summary of it in the same message as Task 1's first edit,
@@ -99,8 +122,8 @@ repo, a lint target that resolves through a symlink, a build that needs its own
 install, belongs in the option text where it can affect the answer, not in a
 footnote after they have chosen.
 
-If one of the two has only one live answer, say which and ask the other. A
-checkpoint down to a single question is still a checkpoint.
+If one of the two has only one live answer, say which and ask the other. A stop
+down to a single question is still a stop.
 
 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
@@ -121,8 +144,8 @@ 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.
 
-- One `TaskCreate` per task, marked in progress then complete. That state
-  outlives compaction; your memory doesn't.
+- One line per task in the run record, marked in progress then complete as it
+  moves. That state outlives compaction; your memory doesn't.
 - Each task goes to a fresh agent with that task's text and nothing else.
   What this session accumulated is yours to hold, not theirs.
 - **Fan out wherever the graph allows.** Work that does not write is always
@@ -169,10 +192,11 @@ say so is the routing announcement, where your partner can still act on it,
 not the summary at the end where it reads as an excuse.
 
 Three things change. The plan stops being a brief for strangers and becomes
-your own worklist, which makes its handback the only outside read it will ever
-get rather than a formality on the way to dispatch. Task isolation is gone, so
-`TaskCreate` now carries all of the state that outlives compaction and matters
-more, not less. And fresh context is unavailable, which was the entire thing
+your own worklist, so its stop is no longer buying alignment with the agents
+who will carry it out, only your partner's read of work you will do yourself.
+Task isolation is gone, so
+the run record now carries all of the state that outlives compaction and
+matters more, not less. And fresh context is unavailable, which was the entire thing
 review was buying.
 
 One thing does not change: the work still owes a review. Reading your own diff
@@ -225,8 +249,8 @@ a reviewer writes nothing, so it collides with nothing. The final review is
 the only one that waits, because it is the only one that needs everything to
 have landed.
 
-Record the base in the task's `TaskCreate` entry when you dispatch, before the
-agent's first commit lands. Recovering it afterwards is archaeology, and the
+Record the base against that task in the run record when you dispatch, before
+the agent's first commit lands. Recovering it afterwards is archaeology, and the
 answer you will guess at is `HEAD~1`, which `references/review.md` already
 names as the standing mistake.
 
@@ -260,8 +284,8 @@ Contracts mean tasks are built blind, so a reviewer reading Task 6 will
 sometimes be right about Task 2. That finding fits neither destination: Task
 6's agent cannot act on it, and it does not quietly become yours to fix.
 
-Record it on the earlier task's `TaskCreate` entry, and send it to that task's
-agent as well if that agent is still live. If it invalidates an `Offers` that
+Record it against the earlier task in the run record, and send it to that
+task's agent as well if that agent is still live. If it invalidates an `Offers` that
 later tasks have already built against, it has stopped being a finding and
 become a plan change, which is your partner's call rather than something to
 absorb into the next task's brief.

package/skills/sluice/references/meter.md

@@ -14,10 +14,13 @@ leave it off entirely if no suite ran, which prints "not reported" rather
 than a number nobody checked. `--base <ref>` overrides the diff base when the
 merge-base with `main` or `master` is not where this branch actually began.
 
-The run starts at your channel announcement, not at the session, so three
-unrelated tasks in one session report as three runs. A previous ledger closes
-the run before it. `bypass` announces nothing, so there is nothing to meter
-and the script exits quietly.
+The run starts at your channel announcement, or at the point this skill was
+invoked by name when that came first, not at the session. Three unrelated tasks
+in one session therefore report as three runs, and a previous ledger closes the
+run before it. `bypass` announces nothing, so there is nothing there to meter,
+and the rule does not fire; if you run the script anyway in a session that
+loaded the skill, it will happily print a ledger headed `not announced`, which
+is a measurement of nothing you were asked to account for.
 
 What the ledger is for: the cost of a channel is otherwise invisible, and a
 channel nobody can price is a channel nobody can choose between. Six agents
@@ -31,26 +34,40 @@ summed, over the span those agents actually occupied. 1.0× means every agent
 had the clock to itself. That is the right number for a plan whose graph was a
 chain and a finding for one whose graph was not, so read it against the plan
 rather than on its own. Nine agents at 1.0× on a plan with four independent
-tasks in it is a run that took four times longer than it needed to.
+tasks in it is a run that took four times longer than it needed to. Both
+figures cover only the agents the harness timed, so a run whose agents were all
+dispatched into the background shows neither.
 
-An agent dispatched into the background is handed back before it runs, so the
-result the session sees carries no cost at all. The ledger reads that agent's
-own transcript instead, which is why a plan run entirely on dispatched agents
-still prices. Agent rows count output tokens, the same unit the run reports for
-itself, so they can be read against each other and against the run.
+Agents are priced from two different sources, and the line keeps them apart
+rather than adding them. Where the harness priced an agent itself, that is the
+figure: it is the accounting the session was billed by and it covers input as
+well as output. An agent dispatched into the background is handed back before
+it runs, so the harness never priced it at all, and the only record left is the
+agent's own transcript. Those rows are marked `~`, count output tokens only,
+and carry no wall-clock, because a log holds no duration: its span runs from
+first message to last and swallows the idle whenever an agent was resumed.
+Adding a `~` figure to a harness figure would produce a number that means
+nothing, which is why you will see two totals on one line and never one.
 
-Where that log has been cleaned up the row reads "cost not reported", the
-totals leave it out, and the agent line carries the count. That is a gap in
-what could be measured rather than a cheap run, and it needs a sentence from
-you: a smaller total must not be allowed to stand for the whole.
+An agent nothing priced reads "cost not reported" and the totals leave it out,
+with the count on the agent line. That is a gap in what could be measured
+rather than a cheap run, and it needs a sentence from you: a smaller total must
+not be allowed to stand for the whole.
 
 Read it before you paste it. A row showing an agent that errored, or an agent
 whose token count dwarfs every other row, is a finding about the run and
-belongs in your prose, not left for your partner to spot in a table.
+belongs in your prose, not left for your partner to spot in a table. A row
+whose figure is missing or marked is a finding about the ledger, and saying
+which of the two you are looking at is the whole job here.
 
 Exit 2 means neither an announcement nor an invocation of this skill was found,
 so there was no run to report. That is a fact about the work, not a failure: do
-not synthesise a ledger to fill the gap.
+not synthesise a ledger to fill the gap. It can also mean your announcement was
+worded in a shape the script does not recognise, so check that it is not simply
+missing you before you report the run as nothing. Any other non-zero exit is a
+broken tool, not a fact about the work: it prints its reason on stderr, and the
+answer is to say the ledger could not be produced rather than to describe the
+run from memory.
 
 The friction line: "I know roughly what this cost." Roughly is the problem.
 Every number here is already on disk, and the remembered version is reliably

package/skills/sluice/references/review.md

@@ -21,9 +21,12 @@ wrong still gets raised, then argued.
 
 Every finding has one of two destinations. Either it goes back to the agent
 that wrote the code and the work stays where it is until the fix lands, or it
-goes onto the task's record, which is what the final review reads. Reviewers
-grade findings Critical, Important or Minor, and the grade picks between the
-two: only Minor may wait for the record, and anything above it blocks.
+is written down against the task and waits. In `deep` that is the run record
+`references/deep-channel.md` sets up, and it is what the final review reads. In
+`main` there is no plan and no record, so a finding that waits waits in the
+message you hand back, named there rather than carried silently to the merge.
+Reviewers grade findings Critical, Important or Minor, and the grade picks
+between the two: only Minor may wait, and anything above it blocks.
 
 The grade is the sort, and it has to be load-bearing. The alternative is you
 reading every finding to decide where it goes, which is an adjudication pass

package/skills/sluice/scripts/run-stats.sh

@@ -8,7 +8,9 @@
 # Usage: run-stats.sh [--tests "<what the suite reported>"] [--base <git-ref>]
 #                     [--transcript <path>]
 #
-# Exit 0 printed a ledger, 1 could not read a transcript, 2 no run to report.
+# Exit 0 printed a ledger, 2 no run to report. Any other non-zero is the tool
+# failing rather than a fact about the run: no jq, no readable transcript, an
+# unknown argument, an unresolvable session id. Each prints its reason first.
 
 set -uo pipefail
 
@@ -46,32 +48,43 @@ if [ -z "$TRANSCRIPT" ] || [ ! -f "$TRANSCRIPT" ]; then
   exit 1
 fi
 
-# An agent handed back before it ran leaves no cost on its tool result, but it
+# An agent the harness never priced leaves no cost on its tool result, but it
 # keeps a transcript of its own beside the session. That file is the only place
-# a backgrounded agent's cost is ever written down, so read it rather than
-# reporting the work as free.
+# such an agent is ever written down, so read it rather than reporting the work
+# as free. Only ids this transcript actually mentions are read: a long-lived
+# session accumulates far more logs than any one run dispatched.
+#
+# No duration is taken from a log. Its span is first timestamp to last, which
+# covers the idle between rounds whenever the agent was resumed, and that is
+# not a measure of work. Tokens are summed per message rather than per line,
+# because one message is written as several lines carrying the same cumulative
+# usage, and summing the lines counts the message more than once.
 SUBS="$(dirname "$TRANSCRIPT")/$(basename "$TRANSCRIPT" .jsonl)/subagents"
 COSTS='{}'
 if [ -d "$SUBS" ]; then
   COSTS="$(
-    for f in "$SUBS"/agent-*.jsonl; do
-      [ -e "$f" ] || continue
-      id="$(basename "$f" .jsonl)"; id="${id#agent-}"
+    jq -r 'select((.toolUseResult | type) == "object")
+           | .toolUseResult.agentId // empty' "$TRANSCRIPT" 2>/dev/null | sort -u |
+    while IFS= read -r id; do
+      [ -n "$id" ] || continue
+      f="$SUBS/agent-$id.jsonl"
+      [ -f "$f" ] || continue
       jq -s --arg id "$id" '
-        def ts: sub("\\.[0-9]+Z$"; "Z") | fromdateiso8601;
-        [ .[] | select(.timestamp) ] as $t
-        | { ($id): {
-            tokens: ([ .[] | .message.usage.output_tokens // 0 ] | add // 0),
+        [ .[] | select(.message.usage) ] as $u
+        | if ($u | length) == 0 then {} else
+          { ($id): {
+            tokens: ([ $u[] | { k: (.message.id // "?"),
+                                v: (.message.usage.output_tokens // 0) } ]
+                     | group_by(.k) | map(map(.v) | max) | add // 0),
             tools: ([ .[] | .message.content[]? | select(.type == "tool_use") ] | length),
-            model: ([ .[] | .message.model // empty ] | last // "?"),
-            starts: (if ($t | length) > 0 then ($t[0].timestamp | ts) else 0 end),
-            ends: (if ($t | length) > 0 then ($t[-1].timestamp | ts) else 0 end) } }' "$f"
-    done | jq -s 'add // {}'
+            model: ([ .[] | .message.model // empty ] | last // "?") } }
+          end' "$f" 2>/dev/null
+    done | jq -s 'add // {}' 2>/dev/null
   )"
 fi
 [ -n "$COSTS" ] || COSTS='{}'
 
-SUMMARY="$(jq -s --argjson costs "$COSTS" '
+SUMMARY="$(jq -s --argjson costs "$COSTS" --arg sid "$(basename "$TRANSCRIPT" .jsonl)" '
   # ---- what counts as a real turn ----------------------------------------
   # Transcript stamps carry milliseconds, which fromdateiso8601 will not take.
   def ts: sub("\\.[0-9]+Z$"; "Z") | fromdateiso8601;
@@ -82,22 +95,30 @@ SUMMARY="$(jq -s --argjson costs "$COSTS" '
   # merely discusses a channel, which a session about sluice is full of.
   def marker: "^[*_#>[:space:]]*(?<c>fast|main|deep)[[:space:]]+channel";
   # Real announcements carry a lead-in the anchor above misses: "Sluice: **deep
-  # channel**", "Tier 2 (new contract surface) = **deep channel**". Emphasis is
-  # what still separates one from prose naming a channel, and holding it to the
-  # opening line keeps a session reviewing sluice from starting a run per quote.
-  def emph: "\\*\\*[[:space:]]*(?<c>fast|main|deep)[[:space:]]+channel";
-  def head_line: texts | split("\n") | (.[0] // "");
+  # channel**", "Tier 2 (new contract surface) = **deep channel**". What makes
+  # those announcements and not prose is that a label introduces them, so the
+  # channel has to follow a colon or an equals directly. Emphasis alone will not
+  # do: a closing ** reads the same as an opening one, which let "not a **big**
+  # deep channel job" announce. The lead-in cannot cross a sentence or a line,
+  # which is what keeps a session reviewing sluice from starting a run per quote.
+  def lead: "^[^.!?\n]{0,100}[:=][[:space:]]*[*_]*(?<c>fast|main|deep)[[:space:]]+channel";
   def announces: (.type == "assistant") and (is_meta | not)
-    and ((texts | test(marker; "i")) or (head_line | test(emph; "i")));
+    and ((texts | test(marker; "i")) or (texts | test(lead; "i")));
   def chan: (if (texts | test(marker; "i")) then (texts | capture(marker; "i"))
-             else (head_line | capture(emph; "i")) end) | .c | ascii_downcase;
+             else (texts | capture(lead; "i")) end) | .c | ascii_downcase;
   def invokes_sluice: (.type == "assistant") and (is_meta | not) and ([
       .message.content[]? | select(.type == "tool_use" and .name == "Skill")
       | select((.input.skill // "") == "sluice")
     ] | length > 0);
+  # A call carrying --transcript is reading another run rather than closing this
+  # one, unless the transcript it names is this session, which is a documented
+  # and legitimate way to meter yourself. Without the exception, a session
+  # working on the ledger clips its own run at the last session it tested.
   def is_stats_call: (.type == "assistant") and ([
       .message.content[]? | select(.type == "tool_use" and .name == "Bash")
-      | select((.input.command // "") | test("run-stats\\.sh"))
+      | (.input.command // "") as $cmd
+      | select($cmd | test("run-stats\\.sh"))
+      | select(($cmd | test("--transcript") | not) or ($cmd | test($sid)))
     ] | length > 0);
   # Waiting is any turn the partner had to take: a prompt, or an answer to a
   # question you put to them. Leaving the latter out understates the wait on
@@ -112,9 +133,11 @@ SUMMARY="$(jq -s --argjson costs "$COSTS" '
   | [ range(0; $all | length) ] as $ix
   | [ $ix[] | select($all[.] | announces) ] as $said
   # A run whose announcement never matched is still a run when the skill was
-  # invoked by name. Anchoring there beats reporting the work as nothing.
+  # invoked by name. Both kinds of anchor go in together rather than the
+  # invocations being a fallback for the whole file: a session where run 1
+  # announced and run 2 did not still has to report run 2 on its own.
   | [ $ix[] | select($all[.] | invokes_sluice) ] as $called
-  | (if ($said | length) > 0 then $said else $called end) as $ann
+  | (($said + $called) | sort) as $ann
   | if ($ann | length) == 0 then { empty: true } else
 
   # A previous ledger closes the run before it. The call running right now has
@@ -142,10 +165,18 @@ SUMMARY="$(jq -s --argjson costs "$COSTS" '
   # ---- tools and tokens, main loop only ----------------------------------
   | [ $run[] | select((.type == "assistant") and (is_meta | not))
       | .message.content[]? | select(.type == "tool_use") | .name ] as $tools
+  # One message is written as several lines, each repeating the same cumulative
+  # usage, so these are summed per message rather than per line. Summed per line
+  # the figure for this run roughly doubles, and it is the one most likely to
+  # be read.
   | ([ $run[] | select((.type == "assistant") and (is_meta | not))
-       | .message.usage.output_tokens // 0 ] | add // 0) as $out_tok
-  | ([ $run[] | select((.type == "assistant") and (is_meta | not))
-       | .message.usage.cache_read_input_tokens // 0 ] | add // 0) as $cache_tok
+       | select(.message.usage)
+       | { k: (.message.id // .uuid // "?"),
+           o: (.message.usage.output_tokens // 0),
+           c: (.message.usage.cache_read_input_tokens // 0) } ]
+     | group_by(.k)) as $usage
+  | ([ $usage[] | map(.o) | max ] | add // 0) as $out_tok
+  | ([ $usage[] | map(.c) | max ] | add // 0) as $cache_tok
 
   # ---- dispatched agents -------------------------------------------------
   | ([ $run[] | select(.type == "assistant") | .message.content[]?
@@ -155,37 +186,44 @@ SUMMARY="$(jq -s --argjson costs "$COSTS" '
   # toolUseResult is whatever the tool returned: object, array or string.
   | [ $run[] | select((.toolUseResult | type) == "object") | select(.toolUseResult.agentId)
       | . as $e
-      # Inline cost when the agent ran to completion here, its own transcript
-      # when it was handed back before it ran, and neither only when the file
-      # has been cleaned up. Priced at zero it would understate the run and drag
-      # the concurrency factor to a number the ledger has no meaning for.
+      # Where the harness priced the agent, that is the number: it is the
+      # accounting the session itself was billed by, and it covers input as well
+      # as output. The log is the fallback for agents the harness never priced,
+      # and it holds output tokens only, so the two are different units and the
+      # totals below never add one to the other.
       | ($costs[$e.toolUseResult.agentId] // null) as $c
-      # The log wins where there is one. The two sources count different things,
-      # the inline total being the harness accounting and the log being output
-      # tokens, and rows drawn from different bases cannot be read against each
-      # other. Output tokens is also the unit the run reports for itself.
-      | (if $c == null then $e.toolUseResult.totalDurationMs
-         else (($c.ends - $c.starts) * 1000) end) as $ms
-      | ($c.tokens // $e.toolUseResult.totalTokens) as $tokens
-      | { label: ($labels[[ $e.message.content[]? | select(.type == "tool_result") | .tool_use_id ][0]]
-                  // $e.toolUseResult.commandName // "agent"),
-          model: ($c.model // $e.toolUseResult.resolvedModel // "?"),
+      | (if ($e.toolUseResult.totalTokens != null)
+             or ($e.toolUseResult.totalDurationMs != null) then "inline"
+         elif $c != null then "log"
+         else "none" end) as $src
+      # Indexing with null throws, and a result without a tool_result block is
+      # not worth failing the whole ledger over.
+      | (([ $e.message.content[]? | select(.type == "tool_result") | .tool_use_id ][0]) // "") as $tid
+      | { label: ($labels[$tid] // $e.toolUseResult.commandName // "agent"),
+          src: $src,
           status: ($e.toolUseResult.status // "?"),
-          measured: (($ms != null) or ($tokens != null)),
-          tokens: ($tokens // 0),
-          ms: ($ms // 0),
+          # Model, tool count and cost all come from whichever source priced the
+          # agent, so a row never mixes one source with another.
+          model: (if $src == "log" then $c.model
+                  else $e.toolUseResult.resolvedModel end // "?"),
+          tokens: (if $src == "log" then $c.tokens
+                   else $e.toolUseResult.totalTokens end // 0),
+          tools: (if $src == "log" then $c.tools
+                  else $e.toolUseResult.totalToolUseCount end // 0),
+          ms: ($e.toolUseResult.totalDurationMs // 0),
           # The session transcript timestamps when an agent returned, not when
-          # it began, so that start is back-derived from its own duration. An
-          # agent log of its own carries both ends directly.
-          ends: (if $c != null then $c.ends else ($e.timestamp | ts) end),
-          starts: (if $c != null then $c.starts
-                   else (($e.timestamp | ts) - (($ms // 0) / 1000)) end),
-          tools: ($c.tools // $e.toolUseResult.totalToolUseCount // 0) } ] as $agents
+          # it began, so the start is back-derived from its own duration.
+          ends: ($e.timestamp | ts),
+          starts: (($e.timestamp | ts)
+                   - (($e.toolUseResult.totalDurationMs // 0) / 1000)) } ] as $agents
 
-  | [ $agents[] | select(.measured) ] as $priced
+  | [ $agents[] | select(.src == "inline") ] as $priced
+  | [ $agents[] | select(.src == "log") ] as $logged
+  | [ $agents[] | select(.src == "none") ] as $unpriced
 
   # Union of the agent intervals: sum the merged runs rather than the raw ones,
-  # so overlapping agents are counted once against the clock they shared.
+  # so overlapping agents are counted once against the clock they shared. Only
+  # agents the harness timed are in here; a log carries no duration to add.
   | ([ $priced[] | { s: .starts, e: .ends } ] | sort_by(.s)
      | reduce .[] as $i ([];
          if (length == 0) or (.[-1].e < $i.s)
@@ -201,8 +239,11 @@ SUMMARY="$(jq -s --argjson costs "$COSTS" '
                  | sort_by(-.n) | .[0:3]),
       out_tok: $out_tok, cache_tok: $cache_tok,
       agents: $agents,
-      unmeasured: (($agents | length) - ($priced | length)),
+      priced_count: ($priced | length),
+      logged_count: ($logged | length),
+      unpriced_count: ($unpriced | length),
       agent_tokens: ([ $priced[].tokens ] | add // 0),
+      logged_tokens: ([ $logged[].tokens ] | add // 0),
       agent_ms: ([ $priced[].ms ] | add // 0),
       concurrency: (if $agent_span > 0
                     then (([ $priced[].ms ] | add // 0) / 1000) / $agent_span
@@ -289,41 +330,60 @@ if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
 fi
 
 count=$(g '.agents | length')
-unmeasured=$(g '.unmeasured')
+priced=$(g '.priced_count')
+logged=$(g '.logged_count')
+unpriced=$(g '.unpriced_count')
 if [ "$count" -eq 0 ]; then
   printf 'agents    none dispatched\n'
 else
-  if [ "$count" -eq "$unmeasured" ]; then
-    # Every agent was handed back before it ran, so there is no cost to report
-    # and none to invent. Saying so beats a row of zeroes that reads as a total.
-    printf 'agents    %s dispatched · cost not reported\n' "$count"
-  else
+  printf 'agents    %s dispatched' "$count"
+  if [ "$priced" -gt 0 ]; then
     # 1.0× means every agent had the clock to itself. On a plan whose graph had
     # independent tasks in it, that number is the finding.
-    printf 'agents    %s dispatched · %s tok · %s wall · %s× concurrent' \
-      "$count" "$(tok "$(g '.agent_tokens')")" "$(dur "$(( $(g '.agent_ms') / 1000 ))")" \
+    printf ' · %s tok · %s wall · %s× concurrent' \
+      "$(tok "$(g '.agent_tokens')")" "$(dur "$(( $(g '.agent_ms') / 1000 ))")" \
       "$(printf '%.1f' "$(g '.concurrency')")"
-    [ "$unmeasured" -gt 0 ] && printf ' · %s unmeasured' "$unmeasured"
-    printf '\n'
   fi
+  if [ "$logged" -gt 1 ]; then
+    printf ' · %s out from %s logs' "$(tok "$(g '.logged_tokens')")" "$logged"
+  elif [ "$logged" -eq 1 ]; then
+    printf ' · %s out from 1 log' "$(tok "$(g '.logged_tokens')")"
+  fi
+  if [ "$priced" -eq 0 ] && [ "$logged" -eq 0 ]; then
+    # Nothing priced any of them, so there is no cost to report and none to
+    # invent. Saying so beats a row of zeroes that reads as a total, and beats
+    # a count of unpriced agents when the count is all of them.
+    printf ' · cost not reported'
+  elif [ "$unpriced" -gt 0 ]; then
+    printf ' · %s unpriced' "$unpriced"
+  fi
+  printf '\n'
 
   # Up to a dozen rows read as the narrative of the plan. Past that the order
   # stops helping, so show what the run actually spent on and say what is cut.
   if [ "$count" -le 12 ]; then rows='.agents[]'; else rows='(.agents | sort_by(-.tokens) | .[0:10][])'; fi
-  while IFS=$'\t' read -r label model status tokens ms tools measured; do
+  while IFS=$'\t' read -r label model status tokens ms tools src; do
     model="${model#claude-}"; model="$(sed 's/-[0-9]\{8\}$//' <<<"$model")"
     [ "$status" = "completed" ] && status="" || status="  ($status)"
-    if [ "$measured" = "true" ]; then
-      printf '  %-22.22s %-10s %6s  %7s  %s tools%s\n' \
-        "$label" "$model" "$(tok "$tokens")" "$(dur "$((ms / 1000))")" "$tools" "$status"
-    else
-      printf '  %-22.22s %-10s %6s  %7s  %s%s\n' \
-        "$label" "$model" "-" "-" "cost not reported" "$status"
-    fi
-  done < <(g "$rows | [.label, .model, .status, .tokens, .ms, .tools, .measured] | @tsv")
+    case "$src" in
+      inline) printf '  %-22.22s %-10s %6s  %7s  %s tools%s\n' \
+                "$label" "$model" "$(tok "$tokens")" "$(dur "$((ms / 1000))")" "$tools" "$status" ;;
+      # A tilde marks the other unit, and the dash is the duration a log cannot
+      # give. Both are explained by the footnote below.
+      log)    printf '  %-22.22s %-10s %6s  %7s  %s tools%s\n' \
+                "$label" "$model" "~$(tok "$tokens")" "-" "$tools" "$status" ;;
+      *)      printf '  %-22.22s %-10s %6s  %7s  %s%s\n' \
+                "$label" "$model" "-" "-" "cost not reported" "$status" ;;
+    esac
+  done < <(g "$rows | [.label, .model, .status, .tokens, .ms, .tools, .src] | @tsv")
+
+  [ "$logged" -gt 0 ] && printf '  ~ output tokens from the agent log; the harness never priced these\n'
 
   if [ "$count" -gt 12 ]; then
-    printf '  +%s more · %s tok (dearest 10 shown)\n' \
-      "$((count - 10))" "$(tok "$(g '(.agents | sort_by(-.tokens) | .[10:] | map(.tokens) | add) // 0')")"
+    cut_priced="$(g '(.agents | sort_by(-.tokens) | .[10:] | map(select(.src == "inline") | .tokens) | add) // 0')"
+    cut_unpriced="$(g '(.agents | sort_by(-.tokens) | .[10:] | map(select(.src != "inline")) | length)')"
+    printf '  +%s more · %s tok (dearest 10 shown)' "$((count - 10))" "$(tok "$cut_priced")"
+    [ "$cut_unpriced" -gt 0 ] && printf ', %s of them unpriced' "$cut_unpriced"
+    printf '\n'
   fi
 fi

package/skills/sluice/skill.json

@@ -1,7 +1,7 @@
 {
   "name": "sluice",
-  "version": "0.3.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, and closes each run 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.",
+  "version": "0.5.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, 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",
   "tools": [