crewforth 3.1.0-rc.3 → 3.1.0-rc.5

package/kit/hooks/prompt-approval.sh

@@ -8,8 +8,8 @@
 # yes, and this hook is the only thing that turns it into a record.
 #
 # WHAT COUNTS. The WHOLE message, trimmed, is one of (letter case does not matter):
-#     approve: commit      approve: push      approve: commit+push
-#     onay: commit         onay: push         onay: commit+push
+#     /crew-approve commit      /crew-approve push      /crew-approve commit+push
+# and, as the release candidates of 3.1.0 had it, `approve: <what>` or `onay: <what>`.
 # A sentence that contains those words is not an approval, and neither is a message with a second line: text
 # that was pasted, quoted or relayed from somewhere else never has that shape by accident.
 #
@@ -51,8 +51,13 @@ _CREW_LOCALE="${LC_ALL:-${LC_CTYPE:-${LANG:-}}}"
 case "$_CREW_LOCALE" in C|POSIX) _CREW_LOCALE="" ;; esac
 export LC_ALL=C
 # ---- /CREW-LOCALE
-IFS= read -r -d '' INPUT || true
-case "$INPUT" in *'"hook_event_name"'*UserPromptSubmit*) ;; *) exit 0 ;; esac
+# guard-schedule.sh SOURCES this file for one thing, _crew_appr_op: which text is an approval is decided here and
+# nowhere else. Sourced, the file defines its functions and returns before anything is read or written.
+_PA_LIB=0; [ "${BASH_SOURCE[0]}" != "$0" ] && _PA_LIB=1
+if [ "$_PA_LIB" = 0 ]; then
+  IFS= read -r -d '' INPUT || true
+  case "$INPUT" in *'"hook_event_name"'*UserPromptSubmit*) ;; *) exit 0 ;; esac
+fi
 # ---- CREW-JSON-PARSE ------------------------------------------------------------------------------------
 _json_find(){  # $1 = text, $2 = a literal -> _JF = the offset of its first occurrence, -1 when there is none
   # `${text%%"$literal"*}` gives the same offset and costs the DISTANCE to the occurrence times the length of the
@@ -351,6 +356,38 @@ _crew_appr_path(){  # $1 = a directory -> _AP: the record's path in that worktre
 }
 # ---- /CREW-APPROVAL-PATH ---------------------------------------------------------------------------------
 
+# ---- WHICH TEXT IS AN APPROVAL: one function, asked here of the user's prompt and by guard-schedule.sh of a
+# prompt a tool is about to schedule ---------------------------------------------------------------------------
+_crew_appr_op(){  # $1 = a text, decoded -> OP: commit | push | commit+push, or "" when the text is not an approval
+  local P="$1" _k _v LC_ALL=C
+  OP=""
+  P="${P//$'\r'/}"
+  while :; do case "$P" in [$' \t\n']*) P="${P:1}" ;; *) break ;; esac; done
+  while :; do case "$P" in *[$' \t\n']) P="${P%?}" ;; *) break ;; esac; done
+  [ "${#P}" -le 40 ] || return 0
+  case "$P" in
+    *$'\n'*) return 0 ;;
+    # THE COMMAND: `/crew-approve <what>`, or `/<plugin>:crew-approve <what>` as a plugin names its commands. Measured
+    # on Claude Code 2.1.284: a command the user types reaches UserPromptSubmit with `prompt` as typed, and a skill
+    # the model starts with the Skill tool raises PreToolUse and PostToolUse only, never that event.
+    /*) _k="${P%%[$' \t']*}"; [ "$_k" != "$P" ] || return 0
+        _v="${P:${#_k}}"; _k="${_k#/}"; _k="@${_k##*:}" ;;      # `@`: a command, so `crew-approve: commit` as text is not one
+    # The text form of 3.1.0's release candidates, kept: `approve: <what>` and `onay: <what>`.
+    *:*) _k="${P%%:*}"; _v="${P#*:}" ;;
+    *) return 0 ;;
+  esac
+  _k="${_k//[$' \t']/}"; _v="${_v//[$' \t']/}"
+  # In the C locale: under tr_TR an upper-case I does not fold to i, and `ONAY: COMMIT` was not an approval (review).
+  shopt -s nocasematch
+  case "$_k" in
+    @crew-approve|approve|onay)
+      case "$_v" in commit) OP=commit ;; push) OP=push ;; commit+push) OP=commit+push ;; esac ;;
+  esac
+  shopt -u nocasematch
+}
+
+[ "$_PA_LIB" = 1 ] && return 0
+
 # A second "prompt" key cannot come from the text of a prompt (inside a JSON string every quote is escaped), so
 # more than one means the payload is not the shape this hook knows, and nothing is read from it.
 _json_keycount "$INPUT" prompt; _n_prompt=$_KC
@@ -384,23 +421,8 @@ if [ -n "$REC" ] && [ -s "$REC" ]; then : > "$REC" 2>/dev/null || true; fi
 # ---- is this message an approval? ------------------------------------------------------------------------
 [ "$_n_prompt" = 1 ] || exit 0
 [ "${#RAW}" -le 120 ] || exit 0        # an approval is a few words; a pasted page is not decoded to find that out
-_json_unescape "$RAW" >/dev/null; P="$_JU"
-P="${P//$'\r'/}"
-while :; do case "$P" in [$' \t\n']*) P="${P:1}" ;; *) break ;; esac; done
-while :; do case "$P" in *[$' \t\n']) P="${P%?}" ;; *) break ;; esac; done
-[ "${#P}" -le 40 ] || exit 0
-case "$P" in *$'\n'*) exit 0 ;; *:*) ;; *) exit 0 ;; esac
-_k="${P%%:*}"; _v="${P#*:}"
-_k="${_k//[$' \t']/}"; _v="${_v//[$' \t']/}"
-OP=""
-# In the C locale: under tr_TR an upper-case I does not fold to i, and `ONAY: COMMIT` was not an approval (review).
-_pa_match(){ local LC_ALL=C; shopt -s nocasematch
-  case "$_k" in
-    approve|onay)
-      case "$_v" in commit) OP=commit ;; push) OP=push ;; commit+push) OP=commit+push ;; esac ;;
-  esac
-  shopt -u nocasematch; }
-_pa_match
+_json_unescape "$RAW" >/dev/null
+_crew_appr_op "$_JU"
 [ -n "$OP" ] || exit 0
 
 # From here on the message IS an approval, so every way of not recording it says why - to the user and to the
@@ -420,6 +442,31 @@ case "$PM" in
 esac
 [ -n "$REC" ] || no "this directory is not inside a git repository."
 
+# A PERSON, IN A SESSION THAT HAS SHOWN THEM SOMETHING. A session can start another one and hand it the approval as
+# its prompt: `claude -p "/crew-approve commit"`, or an interactive one driven through a pseudo-terminal. That
+# session's only message is the approval, this hook would record it, and the session would then commit: the first
+# session has approved for the user. Measured on Claude Code 2.1.294 (macOS), from a hook that printed what it saw:
+#   started how                                CLAUDE_CODE_SESSION_ATTENDED   the transcript file when this hook runs
+#   claude -p, from a session's Bash           0 (set to 1 by the caller: still 0)   not there (first message)
+#   claude -p, from an emptied environment     0                               not there (first message)
+#   interactive, in a pty, from a session      1                               not there, and never written: a
+#                                                                              session started inside another keeps none
+#   interactive, in a pty, emptied environment 1                               not there at the first message; there after
+#   the desktop app, a conversation under way  1                               there
+# Nothing else told them apart: the payload has the same fields, CLAUDECODE and CLAUDE_CODE_CHILD_SESSION are 1 in
+# all of them, CLAUDE_CODE_ENTRYPOINT is inherited from the outer session, and no hook has a terminal on stdin.
+# So two things are asked. Neither is a documented contract, and both fail towards NOT recording:
+#   1. the session is not a headless one;
+#   2. the session's transcript is already on disk when the approval arrives, so the approval is not the session's
+#      first message and the session is not one that keeps no transcript.
+# HONEST SCOPE: a session started with an emptied environment and driven through a pseudo-terminal for a second
+# message passes both. guard-bash.sh refuses the forms of that it can read; a program that types is past it.
+case "${CLAUDE_CODE_SESSION_ATTENDED-}" in
+  0) no "this session has nobody in front of it (it was started with -p, or by a program), and an approval is what a person types into their own session." ;;
+esac
+_json_slice "$INPUT" transcript_path >/dev/null; _json_unescape "$_JS" >/dev/null; TP="${_JU//\\//}"
+{ [ -n "$TP" ] && [ -s "$TP" ]; } || no "this is the first message of this session, or the session keeps no transcript (one started from inside another session keeps none). An approval answers a commit message the session has shown: have it shown, then approve."
+
 # The session the user is writing in. guard-bash.sh accepts the record only from that one: a session started by a
 # command can be handed any prompt.
 _json_slice "$INPUT" session_id >/dev/null; SID="$_JS"

package/kit/settings.json

@@ -86,6 +86,28 @@
             "timeout": 600
           }
         ]
+      },
+      {
+        "matcher": "CronCreate|ScheduleWakeup|RemoteTrigger|mcp__.*([Tt]rigger|[Ss]chedul|[Cc]ron|[Ll]ater).*",
+        "hooks": [
+          {
+            "type": "command",
+            "shell": "bash",
+            "command": "cd \"$CLAUDE_PROJECT_DIR\" 2>/dev/null; bash .claude/hooks/guard-schedule.sh",
+            "timeout": 600
+          }
+        ]
+      },
+      {
+        "matcher": "Agent|Task",
+        "hooks": [
+          {
+            "type": "command",
+            "shell": "bash",
+            "command": "cd \"$CLAUDE_PROJECT_DIR\" 2>/dev/null; bash .claude/hooks/guard-agent-model.sh",
+            "timeout": 600
+          }
+        ]
       }
     ],
     "UserPromptSubmit": [

package/kit/skills/crew-approve/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: crew-approve
+description: Approve the commit or push Claude just showed you (auto and dontAsk modes).
+argument-hint: "[commit | push | commit+push]"
+disable-model-invocation: true
+metadata:
+  kind: command
+---
+# /crew-approve
+Argument: $ARGUMENTS
+
+The user typed this command. Typing it is the approval: `hooks/prompt-approval.sh` read the message itself and
+recorded it, tied to what is staged, to `HEAD` and to this session, for 30 minutes or until the user's next
+message. Nothing in this text records anything, and you cannot give this approval for the user.
+
+Read the line Crewforth added to this turn and do what it says:
+
+- **"approval recorded"**: run exactly what it names, each command alone in its call. A commit is
+  `git commit -m '…'` with the message you showed (single-quoted, or from a here-document with a quoted delimiter);
+  a push is `git push <remote> <branch>`. The review record of §4.6 is still required.
+- **"approval NOT recorded"**: tell the user the reason it gives, and run nothing.
+- **No such line**: the session is in a mode where the gate asks the user itself (`default`, `acceptEdits`), or
+  the argument was not `commit`, `push` or `commit+push`. Say which, and in the first case run the command and let
+  the gate's own prompt ask.
+
+Force-push and the rest of §4.5 are not opened by this.

package/kit/studio/server/index.js

@@ -205,7 +205,7 @@ async function handle(req, res) {
       const session = await findSession(id);
       if (!session) continue;                 // a session on another machine: not read here, and not guessed
       const u = await cachedUsage(session);
-      usage[id] = { durationMs: u.durationMs, workedMs: u.workedMs, tokens: u.tokens.total, cost: u.cost, unpriced: u.unpriced };
+      usage[id] = { durationMs: u.durationMs, workedMs: u.workedMs, startedAt: u.startedAt, tokens: u.tokens.fresh, cost: u.cost, unpriced: u.unpriced };
     }
     return sendJson(res, 200, { measured: true, usage });
   }

package/kit/studio/server/lib/graph.js

@@ -19,7 +19,7 @@ import path from 'node:path';
 
 import { readAll, contextFill } from './transcript.js';
 import { agentMetaFiles } from './projects.js';
-import { Usage, timesOf } from './usage.js';
+import { Usage, withTimes } from './usage.js';
 import { detailOf } from './permissions.js';
 
 const SESSION_NODE = 'session';
@@ -60,6 +60,74 @@ function harvestCompletions(text, into, at = null) {
   }
 }
 
+// The line the model gate (kit/hooks/guard-agent-model.sh) refuses a call with starts with this, whatever follows.
+const MODEL_GATE = 'GUARD (agent model):';
+
+/**
+ * What the model gate said when it refused a call, or null when the text is not its refusal.
+ * `floor` is the model it says the agent runs on "or above", when it says one; nothing is read into a sentence
+ * that does not say it.
+ */
+export function refusalOf(text) {
+  const at = typeof text === 'string' ? text.indexOf(MODEL_GATE) : -1;
+  if (at === -1) return null;
+  const line = text.slice(at).split('\n')[0].trim();
+  const floor = line.match(/ runs on ([a-z0-9.-]+) or above/);
+  return { text: line.slice(0, 400), floor: floor ? floor[1] : null };
+}
+
+// Which of two models is the larger, for the two questions asked of it: was a call repeated on a higher model,
+// and which is "one model up". A name this does not know has no rank, and nothing is concluded from it.
+const FAMILY = ['haiku', 'sonnet', 'opus', 'fable'];
+export function modelRank(model) {
+  if (typeof model !== 'string') return null;
+  const i = FAMILY.findIndex((f) => model === f || model.includes(`-${f}-`) || model.startsWith(`${f}-`) || model.endsWith(`-${f}`));
+  return i === -1 ? null : i;
+}
+
+/** How a report says it ended: the `confidence: high|low` line a crew agent closes with, or null. */
+export function confidenceOf(text) {
+  const m = typeof text === 'string' ? text.trimEnd().match(/(?:^|\n)\W*confidence:\s*(high|low)\W*$/i) : null;
+  return m ? m[1].toLowerCase() : null;
+}
+
+/**
+ * Tie each agent call to what came before it, where the transcript says so.
+ *
+ * `firstTry` — the gate refused a call and the session made the same call again (same agent, same task): the
+ * call that ran carries what was asked first and why it was refused.
+ * Returns nothing; it writes onto the calls.
+ */
+export function linkRetries(calls) {
+  const list = [...calls.values()].sort((a, b) => a.order - b.order);
+  list.forEach((c, i) => {
+    if (!c.refused) return;
+    const again = list.slice(i + 1).find((n) => n.subagentType === c.subagentType && n.description === c.description);
+    if (!again) return;
+    // A call refused twice keeps the first thing that was asked.
+    again.firstTry = c.firstTry ?? { asked: c.model, floor: c.refused.floor, text: c.refused.text };
+  });
+}
+
+/**
+ * `escalatedFrom` / `escalatedTo` — an agent's report closed with `confidence: low`, and the next call to the same
+ * agent after it reported asked for a higher model: the same work, done again one model up. Read from the order
+ * of the calls, the two reports and the two models; where any of the three is missing nothing is linked.
+ */
+export function linkEscalations(nodes) {
+  const agents = nodes.filter((n) => n.kind === 'agent' && n.order != null).sort((a, b) => a.order - b.order);
+  agents.forEach((low, i) => {
+    if (low.confidence !== 'low' || low.reportedAt == null) return;
+    const from = modelRank(low.model ?? low.modelAsked);
+    if (from === null) return;
+    const again = agents.slice(i + 1).find((n) => n.agentType === low.agentType && n.calledAt != null && n.calledAt >= low.reportedAt);
+    const to = again ? modelRank(again.modelAsked ?? again.model) : null;
+    if (to === null || to <= from || again.escalatedFrom) return;
+    again.escalatedFrom = { id: low.id, from: low.model ?? low.modelAsked, to: again.modelAsked ?? again.model };
+    low.escalatedTo = again.id;
+  });
+}
+
 function scanMain(records) {
   const out = {
     cwd: null, gitBranch: null, version: null, model: null,
@@ -67,6 +135,7 @@ function scanMain(records) {
     agentCalls: new Map(),   // toolUseId -> { subagentType, description }
     links: new Map(),        // toolUseId -> { agentId, status, model }
     completions: new Map(),  // task id (an agent's, or a background command's) -> { status, at }
+    waves: new Map(),        // assistant message id -> wave number, in the order the messages were written
     commands: new Map(),     // toolUseId -> the command a Bash call ran
     background: new Map(),   // background task id -> { toolUseId, startedAt }
     owners: new Map(),       // toolUseId -> owner node id
@@ -97,10 +166,20 @@ function scanMain(records) {
           if (c?.type === 'tool_use' && c.id) {
             out.owners.set(c.id, SESSION_NODE);
             if (typeof c.input?.command === 'string') out.commands.set(c.id, c.input.command);
-            if (c.name === 'Agent') {
+            if (c.name === 'Agent' || c.name === 'Task') {
+              // The order the session called its agents in, and which calls were made together: the calls of one
+              // assistant message are one wave. A message is written as several records, one per block, and they
+              // share its id — so the wave is the message id, not the record.
+              const mid = r.message?.id ?? `record:${out.agentCalls.size}`;
+              if (!out.waves.has(mid)) out.waves.set(mid, out.waves.size + 1);
               out.agentCalls.set(c.id, {
                 subagentType: c.input?.subagent_type ?? null,
                 description: c.input?.description ?? null,
+                order: out.agentCalls.size + 1,
+                wave: out.waves.get(mid),
+                calledAt: at,
+                // The model the call asked for: its own `model` field. Absent, the agent runs on its default.
+                model: typeof c.input?.model === 'string' ? c.input.model : null,
               });
             }
           }
@@ -110,6 +189,12 @@ function scanMain(records) {
     }
 
     if (r?.type === 'user') {
+      // A call the model gate refused: the answer is an error that carries the gate's own line. No agent started.
+      for (const c of Array.isArray(r.message?.content) ? r.message.content : []) {
+        if (c?.type !== 'tool_result' || c.is_error !== true || !out.agentCalls.has(c.tool_use_id)) continue;
+        const said = refusalOf(textOf(typeof c.content === 'string' ? [{ type: 'text', text: c.content }] : c.content));
+        if (said) out.agentCalls.get(c.tool_use_id).refused = said;
+      }
       out.userTurns += 1;
       harvestCompletions(textOf(r.message?.content), out.completions, at);
     }
@@ -119,7 +204,8 @@ function scanMain(records) {
     if (tur && typeof tur === 'object' && tur.agentId) {
       const id = r.message?.content?.find?.((c) => c?.type === 'tool_result')?.tool_use_id
         ?? r.toolUseID ?? null;
-      const entry = { agentId: tur.agentId, status: tur.status ?? null, model: tur.resolvedModel ?? null };
+      // `at` is when the answer was written: for a call the session waited on, that is when the agent reported.
+      const entry = { agentId: tur.agentId, status: tur.status ?? null, model: tur.resolvedModel ?? null, at };
       if (id) out.links.set(id, entry);
       else out.links.set(`agent:${tur.agentId}`, entry);
     }
@@ -195,11 +281,13 @@ export function openCalls(records) {
 }
 
 /** Roll one agent's own transcript into the numbers its node shows. */
-async function scanAgent(file, usage = null) {
+async function scanAgent(file, usage = null, agentId = null) {
   const { records } = await readAll(file);
-  usage?.add(records);
+  usage?.add(records, agentId ?? 'agents:unnamed');
   const stats = {
     tools: {}, toolCount: 0, lastTool: null, errors: 0,
+    model: null,      // the model its own transcript names: what it actually ran on
+    lastText: null,   // the end of the last thing it said, for the line a report closes with
     tokens: null, startedAt: null, endedAt: null, turns: 0,
     owns: [], // tool_use ids this agent emitted — how nesting is resolved
   };
@@ -214,6 +302,10 @@ async function scanAgent(file, usage = null) {
     }
     if (r?.type === 'assistant') {
       stats.turns += 1;
+      const mdl = r.message?.model;
+      if (typeof mdl === 'string' && mdl && mdl !== '<synthetic>') stats.model = mdl;
+      const said = textOf(r.message?.content);
+      if (said.trim()) stats.lastText = said.slice(-400);
       const u = r.message?.usage;
       if (u && u.cache_read_input_tokens != null) {
         stats.tokens = (u.input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0);
@@ -264,7 +356,7 @@ async function readAgentDir(subagentsDir, usage = null) {
     // `stats` needs the transcript read; a missing file is a normal state (the
     // agent has not written yet), so absence is a null rather than a throw.
     let stats = null;
-    if (mtime !== null) stats = await scanAgent(jsonl, usage);
+    if (mtime !== null) stats = await scanAgent(jsonl, usage, agentId);
 
     out.push({
       agentId,
@@ -300,6 +392,7 @@ export async function buildGraph(session, { staleMs = STALE_MS } = {}) {
   const { records, malformed } = await readAll(session.file);
   const main = scanMain(records);
   // What the session spent, its agents' tokens included and each response counted once.
+  linkRetries(main.agentCalls);
   const usage = new Usage().add(records);
   const agents = await readAgentDir(session.subagentsDir, usage);
   const now = Date.now();
@@ -314,6 +407,8 @@ export async function buildGraph(session, { staleMs = STALE_MS } = {}) {
   // toolUseId -> agentId, from the returning result record.
   const byToolUse = new Map();
   for (const [k, v] of main.links) if (!k.startsWith('agent:')) byToolUse.set(k, v);
+  const callOf = new Map();
+  for (const [k, v] of byToolUse) callOf.set(v.agentId, k);
 
   const nodes = [{
     id: SESSION_NODE,
@@ -329,7 +424,7 @@ export async function buildGraph(session, { staleMs = STALE_MS } = {}) {
     tokens: contextFill(records),
     startedAt: main.startedAt,
     endedAt: main.updatedAt,
-    usage: { ...usage.result(), ...timesOf(records) },
+    usage: withTimes(usage, records),
     // Commands sent to the background that no notice has ended, oldest first. A session that is over has none
     // running whatever this says: the page shows them only while the session is live.
     backgroundCommands: [...main.background]
@@ -345,8 +440,10 @@ export async function buildGraph(session, { staleMs = STALE_MS } = {}) {
   const edges = [];
 
   for (const a of agents) {
-    const call = a.toolUseId ? main.agentCalls.get(a.toolUseId) : null;
-    const link = a.toolUseId ? byToolUse.get(a.toolUseId) : null;
+    // The call that started it: named by its own meta file, or found from the answer that named the agent.
+    const callId = a.toolUseId ?? callOf.get(a.agentId) ?? null;
+    const call = callId ? main.agentCalls.get(callId) : null;
+    const link = callId ? byToolUse.get(callId) : null;
     const notice = main.completions.get(a.agentId) ?? null;
     const completion = noticeStands(notice, a.stats?.endedAt ?? null) ? notice.status : null;
 
@@ -380,7 +477,16 @@ export async function buildGraph(session, { staleMs = STALE_MS } = {}) {
       spawnDepth: a.spawnDepth,
       workflow: a.workflow,
       toolUseId: a.toolUseId,
-      model: link?.model ?? null,
+      // The model it ran on: what its own transcript names, and failing that what the launch answer resolved.
+      model: a.stats?.model ?? link?.model ?? null,
+      // The model the call asked for; null when the call named none and the agent ran on its default.
+      modelAsked: call?.model ?? null,
+      // Set when the model gate refused this call the first time it was made: what was asked then, and why not.
+      firstTry: call?.firstTry ?? null,
+      // `confidence: high|low`, the line a crew agent's report closes with; null when it has none.
+      confidence: confidenceOf(a.stats?.lastText ?? null),
+      // Its own share of the session's tokens, and what they cost at list price.
+      usage: usage.of(a.agentId),
       launchStatus: link?.status ?? null,
       // Started in the background, and its transcript stops in the middle of a turn. Such an agent can be quiet
       // for a long time inside one tool call; whether it is still working is the live session's to say, so the
@@ -398,11 +504,22 @@ export async function buildGraph(session, { staleMs = STALE_MS } = {}) {
       endedAt: a.stats?.endedAt ?? null,
       durationMs: a.stats?.durationMs ?? null,
       updatedAt: a.mtime,
+      // Where it stands among the agents the session called: its place in the order of the calls, the wave it
+      // was called in, and when. Null for an agent the session's own transcript did not call (one a workflow
+      // started): nothing is known about its place from here.
+      order: call?.order ?? null,
+      wave: call?.wave ?? null,
+      calledAt: call?.calledAt ?? null,
+      // When it handed its result back: the answer to a call the session waited on, or the notice that ended a
+      // background agent. Null while it has not, and when no time was recorded.
+      reportedAt: link?.status === 'completed' ? (link.at ?? null) : (completion ? (notice.at ?? null) : null),
     });
 
     edges.push({ id: `${parentId}->${a.agentId}`, source: parentId, target: a.agentId, kind: 'spawn' });
   }
 
+  linkEscalations(nodes);
+
   // A workflow run is a real container, not a rendering trick: its agents were
   // spawned by one orchestration script, not by the session directly. Hanging
   // 243 of them straight off the root produced a graph nobody could read, and

package/kit/studio/server/lib/usage.js

@@ -36,55 +36,115 @@ export function usageOfRecord(r) {
   };
 }
 
-export class Usage {
+const KINDS = ['input', 'output', 'cacheWrite', 'cacheRead'];
+
+/** One running sum: tokens by kind, what they cost, and which models had no price. */
+class Tally {
   constructor() {
-    this.seen = new Set();
     this.tokens = { input: 0, output: 0, cacheWrite: 0, cacheRead: 0 };
     this.usd = 0;
     this.responses = 0;
-    this.priced = new Set();
     this.unpriced = new Set();
   }
 
-  /** Add a transcript's records. A response already counted, from this file or another, is not counted again. */
-  add(records) {
+  take(u, usd) {
+    this.responses += 1;
+    this.tokens.input += u.input;
+    this.tokens.output += u.output;
+    this.tokens.cacheWrite += u.cacheWrite5m + u.cacheWrite1h;
+    this.tokens.cacheRead += u.cacheRead;
+    if (usd === null) this.unpriced.add(u.model ?? 'unknown model');
+    else this.usd += usd;
+  }
+
+  /**
+   * `fresh` is what was sent and written for the first time: input, output and cache writes. `cacheRead` is the
+   * same context read back from the cache on every later response, which is why it dwarfs the rest in a long
+   * session and is kept out of the headline. `cost` is null when any of the tokens came from a model the price
+   * table has no row for — a sum that leaves some of them out would read as the whole.
+   */
+  result() {
+    const t = this.tokens;
+    return {
+      tokens: { ...t, fresh: t.input + t.output + t.cacheWrite, total: KINDS.reduce((a, k) => a + t[k], 0) },
+      responses: this.responses,
+      cost: this.unpriced.size ? null : this.usd,
+      unpriced: [...this.unpriced].sort(),
+    };
+  }
+}
+
+export class Usage {
+  constructor() {
+    this.seen = new Set();
+    this.all = new Tally();
+    this.who = new Map();      // 'session', or an agent's id -> Tally
+    this.model = new Map();    // model id -> Tally
+    this.first = null;         // the earliest and the latest record of any file added
+    this.last = null;
+  }
+
+  #tally(map, key) {
+    if (!map.has(key)) map.set(key, new Tally());
+    return map.get(key);
+  }
+
+  /**
+   * Add a transcript's records. A response already counted, from this file or another, is not counted again.
+   * @param who  'session' for the session's own transcript, or the id of the agent whose transcript this is.
+   *             A record the session's transcript marks as an agent's (`isSidechain`) is counted as an agent's.
+   */
+  add(records, who = 'session') {
     for (const r of records ?? []) {
+      const t = r?.timestamp ? Date.parse(r.timestamp) : NaN;
+      if (Number.isFinite(t)) {
+        if (this.first === null || t < this.first) this.first = t;
+        if (this.last === null || t > this.last) this.last = t;
+      }
       const u = usageOfRecord(r);
       if (!u) continue;
       if (u.id) { if (this.seen.has(u.id)) continue; this.seen.add(u.id); }
-      const total = u.input + u.output + u.cacheWrite5m + u.cacheWrite1h + u.cacheRead;
-      if (!total) continue;                    // a record the harness made up for itself carries no tokens
-      this.responses += 1;
-      this.tokens.input += u.input;
-      this.tokens.output += u.output;
-      this.tokens.cacheWrite += u.cacheWrite5m + u.cacheWrite1h;
-      this.tokens.cacheRead += u.cacheRead;
+      if (!(u.input + u.output + u.cacheWrite5m + u.cacheWrite1h + u.cacheRead)) continue;   // a record the harness made up carries no tokens
       const usd = costOf(u);
-      if (usd === null) this.unpriced.add(u.model ?? 'unknown model');
-      else { this.usd += usd; this.priced.add(u.model); }
+      this.all.take(u, usd);
+      this.#tally(this.who, who === 'session' && r.isSidechain === true ? 'agents:inline' : who).take(u, usd);
+      this.#tally(this.model, u.model ?? 'unknown model').take(u, usd);
     }
     return this;
   }
 
+  /** One agent's own share, or null when its transcript carried no usage. */
+  of(who) { return this.who.get(who)?.result() ?? null; }
+
   /**
-   * @returns tokens by kind and in total; `cost` in USD at list price, or null when any of the tokens came from
-   *          a model the table has no row for — a sum that leaves some of them out would read as the whole.
+   * @returns the whole session's tally, and the same split two ways: `parts.session` is what the session's own
+   *          transcript spent and `parts.agents` everything its agents did; `byModel` is one tally per model.
    */
   result() {
-    const t = this.tokens;
+    const agents = new Tally();
+    for (const [who, t] of this.who) {
+      if (who === 'session') continue;
+      for (const k of KINDS) agents.tokens[k] += t.tokens[k];
+      agents.usd += t.usd;
+      agents.responses += t.responses;
+      for (const m of t.unpriced) agents.unpriced.add(m);
+    }
+    const all = this.all.result();
     return {
-      tokens: { ...t, total: t.input + t.output + t.cacheWrite + t.cacheRead },
-      responses: this.responses,
-      cost: this.unpriced.size ? null : this.usd,
-      models: [...this.priced].sort(),
-      unpriced: [...this.unpriced].sort(),
+      ...all,
+      models: [...this.model.keys()].filter((m) => !all.unpriced.includes(m)).sort(),
+      parts: { session: (this.who.get('session') ?? new Tally()).result(), agents: agents.result() },
+      byModel: Object.fromEntries([...this.model].map(([m, t]) => [m, t.result()]).sort((a, b) => b[1].tokens.total - a[1].tokens.total)),
+      startedAt: this.first,
+      lastAt: this.last,
       priceSource: SOURCE,
     };
   }
 }
 
 /**
- * How long a session took, two ways. `durationMs` is from its first record to its last, pauses included.
+ * How long a session's own transcript says it took. `durationMs` is from its first record to its last, pauses
+ * included; with its agents' transcripts counted too, that span is `Usage`'s `startedAt` to `lastAt`.
  * `workedMs` is the turns Claude Code timed itself (`system` / `turn_duration` records), added up; zero when it
  * recorded none, and a turn that is still running is not in it.
  */
@@ -107,6 +167,16 @@ export function timesOf(records) {
   return { durationMs: first !== null && last !== null ? last - first : null, workedMs, turns };
 }
 
+/**
+ * The usage with the times beside it. The span runs to the last record of ANY of the session's files: an agent
+ * can be writing long after the session's own transcript last moved.
+ */
+export function withTimes(usage, mainRecords) {
+  const u = usage.result();
+  const t = timesOf(mainRecords);
+  return { ...u, workedMs: t.workedMs, turns: t.turns, durationMs: u.startedAt !== null && u.lastAt !== null ? u.lastAt - u.startedAt : null };
+}
+
 /** A session's usage with its agents', and how long it took. */
 export async function sessionUsage(session) {
   const usage = new Usage();
@@ -114,9 +184,10 @@ export async function sessionUsage(session) {
   usage.add(records);
   for (const meta of await agentMetaFiles(session.subagentsDir)) {
     const jsonl = meta.replace(/\.meta\.json$/, '.jsonl');
-    try { usage.add((await readAll(jsonl)).records); } catch { /* an agent that has not written yet */ }
+    const agentId = path.basename(jsonl).slice('agent-'.length, -'.jsonl'.length);
+    try { usage.add((await readAll(jsonl)).records, agentId); } catch { /* an agent that has not written yet */ }
   }
-  return { ...usage.result(), ...timesOf(records) };
+  return withTimes(usage, records);
 }
 
 // One answer per session, kept until one of its files changes. The key is what the stream's own signature