@aiwayds/dsh-tui-pi 0.8.2 → 0.9.0

package/lib/session.js

@@ -14,8 +14,9 @@ import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { settingsNamespace, SettingsConflictError } from '@deepseek-ai/dsh-settings';
 import { SessionId } from '@deepseek-ai/dsh-session';
 import { readAppendSystem } from "./append-system.js";
-import { isAgentEnd, isAgentStart, isLlmRetry, isSubagentDescriptor } from "./dsh-events.js";
+import { isAgentEnd, isAgentStart, isDcpCompactionNotice, isLlmRetry, isSubagentDescriptor } from "./dsh-events.js";
 import { installSpawnToolFence } from "./subagent-policy.js";
+import { estimateContentTokens, estimateTextTokens } from "./tokens.js";
 /**
  * Register the APPEND_SYSTEM.md section on ONE agent's scoped context, so the
  * user's orchestrator identity applies to the TUI's main agent ONLY. A section
@@ -45,18 +46,45 @@ function installAppendSystem(agentCtx) {
  */
 const CHILD_LOG_CAP = 2000;
 /**
- * Cadence of the per-child turn-count reconcile. The TUI's discovery and fold
- * assume child `session/event` streams bubble here, but in some deployments
- * a subagent's own events never reach this plugin — the child shows up only
- * through the parent's `tool-workflow/agent-start`, so "rounds" stays 0 and
- * the `maxRounds` policy never fires. The reconcile re-derives each child's
- * turn count from its authoritative session log (`ctx.sessions`) as a
- * fallback; it only ever moves the count UP past what streamed events already
- * recorded, so the two sources never double count.
+ * Cadence of the per-child round-count reconcile. The TUI's discovery and
+ * fold assume child `session/event` streams bubble here, but in some
+ * deployments a subagent's own events never reach this plugin — the child
+ * shows up only through the parent's `tool-workflow/agent-start`, so
+ * "rounds" stays 0 and the `maxRounds` policy never fires. The reconcile
+ * re-derives each child's round count from its authoritative session log
+ * (`ctx.sessions`) as a fallback; it only ever moves the count UP past what
+ * streamed events already recorded, so the two sources never double count.
+ * Rounds are counted on `assistant/message` events (one per LLM round-trip) —
+ * a one-shot child never advances `turn/end` while it works.
  */
-const TURN_RECONCILE_MS = 600;
+const ROUND_RECONCILE_MS = 600;
 /** Tail marker for `llm/retry` events (no text content — the row shows it is re-working). */
 const RETRY_MARKER = '↻ retry';
+/**
+ * Estimated tokens of a `tool/result` event's text payload (the tool output
+ * that enters the next request). Defensive: reads through an `unknown` shape
+ * and never throws. The result body lives in `data.message.content[*].content`
+ * as `{ type: 'text', text }` blocks (plus any inline `isError` marker).
+ */
+function estimateToolResultTokens(data) {
+    const content = data.message?.content;
+    if (!Array.isArray(content))
+        return 0;
+    const parts = [];
+    for (const block of content) {
+        if (block === null || typeof block !== 'object')
+            continue;
+        const inner = block.content;
+        if (!Array.isArray(inner))
+            continue;
+        for (const item of inner) {
+            const b = item;
+            if (b.type === 'text' && typeof b.text === 'string')
+                parts.push(b.text);
+        }
+    }
+    return estimateTextTokens(parts.join('\n'));
+}
 /**
  * Bound of a child's live streaming buffer (text + reasoning deltas): enough
  * to extract the last content line of any real stream, bounded so a runaway
@@ -149,7 +177,23 @@ export class DshSessionBridge {
         cacheWriteTokens: 0,
         msgCount: 0,
         toolCallCount: 0,
+        contextTokens: 0,
     };
+    /**
+     * Usage snapshot of the LATEST assistant/message — the exact billed context
+     * of the last request (input = uncached, cache read/write billed on top;
+     * output = that request's own output). The footer's context segment prices
+     * this plus `pendingTokens` (see BridgeStats.contextTokens). `undefined`
+     * until the first assistant/message arrives.
+     */
+    lastUsage;
+    /**
+     * CJK-estimated tokens of every message appended AFTER the latest
+     * assistant/message (user prompts, tool results, streamed text deltas) —
+     * they enter the next request. Reset to 0 by the next assistant/message,
+     * whose usage snapshot then covers them exactly.
+     */
+    pendingTokens = 0;
     /** Live subagent rows keyed by child session id. */
     agentViews = new Map();
     /** Child session ids whose own events we fold into the agent views. */
@@ -168,14 +212,49 @@ export class DshSessionBridge {
      * line and deletes the entry.
      */
     childStreams = new Map();
-    /** Per-child completed turn count — the "rounds" the policy caps. */
-    turnCounts = new Map();
     /**
-     * Per-child session-log length already reconciled (see reconcileChildTurns).
-     * Incremental high-water, so the reconcile scans only newly-appended events.
+     * Per-child assistant-message count — the "rounds" the policy caps. One
+     * increment per `assistant/message` (an LLM round-trip), counted on the
+     * child's OWN events. Settled children keep counting (a continuable child
+     * resumes later), so the count stays authoritative for the viewer and the
+     * wrap-up policy.
+     */
+    roundCounts = new Map();
+    /**
+     * The EVENT path's own absolute per-child assistant-message count — its
+     * ledger of streamed `assistant/message` events it has actually received.
+     * The reconcile derives its own count from the session log; the displayed
+     * "rounds" is `max(streamed, reconciled)` (see foldTracked). Keeping the
+     * two ledgers separate is what makes a message the reconcile already
+     * counted immune to a second count when its streamed event arrives late.
+     */
+    streamedRoundCounts = new Map();
+    /**
+     * Per-child usage snapshot of the latest assistant/message (see
+     * `lastUsage` for the main session) — the exact billed context of the
+     * child's last request, the `contextTokens` baseline.
+     */
+    childUsage = new Map();
+    /**
+     * Per-child CJK-estimated tokens of messages appended after the latest
+     * assistant/message (see `pendingTokens` for the main session) — the
+     * `contextTokens` increment that makes the compact `X/Y` follow live.
+     */
+    childPending = new Map();
+    /**
+     * Per-child dsh-dcp compaction count — one per `user/message` notice whose
+     * source is `{ kind: 'plugin', plugin: 'dsh-dcp', form: 'notice' }`. The
+     * viewer's picker rows read this via `getChildCompactionCount` so the user
+     * sees at a glance whether DCP actually compacted inside a child.
+     */
+    childCompactionCounts = new Map();
+    /**
+     * Per-child session-log length already reconciled (see
+     * reconcileChildRounds). Incremental high-water, so the reconcile scans
+     * only newly-appended events.
      */
     reconciledLen = new Map();
-    /** Per-child turn count derived from the session log by the reconcile. */
+    /** Per-child round count derived from the session log by the reconcile. */
     reconciledCount = new Map();
     /**
      * Session ids that can own tracked children (this session first, then every
@@ -203,20 +282,40 @@ export class DshSessionBridge {
             const sessionKey = String(session.id);
             // Discover subagent children by session header — the deployment may
             // never emit tool-workflow events (the firehose is not scope-filtered,
-            // so child sessions arrive here too). Any session whose parent is a
-            // tracked session is a child; the descriptor event later refines the
-            // label/provider.
+            // so child sessions arrive here too). A session whose parent is a
+            // tracked session AND is marked as delegated is a child; the descriptor
+            // event later refines the label/provider.
+            //
+            // Guard: a child is `origin: 'subagent'` OR a delegation budget
+            // `delegationDepth > 0`. Both markers are written together by dsh's
+            // childSessionMeta (spawn AND in-process fork children alike), so in
+            // practice the origin alone carries the decision; the budget clause
+            // only future-proofs the gate against a child that carries the budget
+            // without the origin. The budget test MUST be a VALUE test, not a
+            // field-presence test: the jsonl persistence backend materialises
+            // `delegationDepth: 0` on every restored header (write `?? 0`, read
+            // unconditionally), so a presence test would pull user-facing
+            // `Session.fork` conversations and other non-child restored sessions
+            // onto the live board / Ctrl+G.
             const header = session.header;
-            if (header?.origin === 'subagent' && header.parentSession !== undefined
+            if (header?.parentSession !== undefined
+                && (header.origin === 'subagent' || (header.delegationDepth ?? 0) > 0)
                 && this.trackedSessions.has(String(header.parentSession))
                 && !this.agentViews.has(sessionKey)) {
                 this.agentViews.set(sessionKey, {
                     childId: sessionKey,
                     parentSession: String(header.parentSession),
-                    label: `subagent ${sessionKey.slice(0, 8)}`,
+                    // Current dsh children always carry the origin, so in practice the
+                    // label is `subagent <id8>`; the `fork` label only fires for the
+                    // defensive budget-without-origin shape above.
+                    label: header.origin === undefined
+                        ? `fork ${sessionKey.slice(0, 8)}`
+                        : `subagent ${sessionKey.slice(0, 8)}`,
                     startedAt: event.time,
                     tokens: 0,
+                    rounds: 0,
                     retries: 0,
+                    contextTokens: 0,
                 });
                 this.childSessions.add(sessionKey);
                 this.trackedSessions.add(sessionKey);
@@ -243,33 +342,36 @@ export class DshSessionBridge {
             this.running = status === 'running';
             this.callbacks.onStatus(status);
         }));
-        // Turn-count reconcile fallback: keep "rounds" and the maxRounds policy live
-        // even when a child's own events never bubble to this plugin (see
-        // TURN_RECONCILE_MS). Runs regardless of whether the viewer is open — the
+        // Round-count reconcile fallback: keep "rounds" and the maxRounds policy
+        // live even when a child's own events never bubble to this plugin (see
+        // ROUND_RECONCILE_MS). Runs regardless of whether the viewer is open — the
         // cap must still fire while the child works in the background.
         const reconcile = setInterval(() => {
             try {
-                this.reconcileChildTurns();
+                this.reconcileChildRounds();
             }
             catch {
                 // A throwing reconcile must never take the process down.
             }
-        }, TURN_RECONCILE_MS);
+        }, ROUND_RECONCILE_MS);
         reconcile.unref?.();
         this.disposers.push(() => clearInterval(reconcile));
     }
     /**
-     * Re-derive each tracked child's turn count from its own session log
+     * Re-derive each tracked child's round count from its own session log
      * (`ctx.sessions`), the authoritative append-only facts. The firehose
      * assumption behind discovery/fold is unreliable in some deployments — a
      * child is listed from the parent's `tool-workflow/agent-start` but its own
-     * `turn/end` never arrives, which leaves both the rounds display and the
-     * `maxRounds` policy dead at 0. This corrects the count UP past whatever the
-     * streamed events already recorded (never down, never re-adding what events
-     * counted), and fires `onTurnCount` so the cap still guards a child whose
-     * events were never delivered. Scans only newly-appended events per child.
+     * `assistant/message` events never arrive, which leaves both the rounds
+     * display and the `maxRounds` policy dead at 0. This corrects the count UP
+     * past whatever the streamed events already recorded (never down, never
+     * re-adding what events counted), and fires `onRoundCount` so the cap still
+     * guards a child whose events were never delivered. Rounds are counted on
+     * `assistant/message` (one per LLM round-trip — `turn/end` is structurally
+     * inert for a one-shot child that never leaves its single turn). Scans only
+     * newly-appended events per child.
      */
-    reconcileChildTurns() {
+    reconcileChildRounds() {
         const sessions = this.ctx.sessions;
         if (sessions === undefined)
             return;
@@ -290,16 +392,16 @@ export class DshSessionBridge {
                 continue;
             let added = 0;
             for (let i = from; i < len; i++) {
-                if (events[i].type === 'turn/end')
+                if (events[i].type === 'assistant/message')
                     added += 1;
             }
             const absolute = (this.reconciledCount.get(childId) ?? 0) + added;
             this.reconciledLen.set(childId, len);
             this.reconciledCount.set(childId, absolute);
-            const current = this.turnCounts.get(childId) ?? 0;
+            const current = this.roundCounts.get(childId) ?? 0;
             if (absolute > current) {
-                this.turnCounts.set(childId, absolute);
-                this.callbacks.onTurnCount?.(childId, absolute);
+                this.roundCounts.set(childId, absolute);
+                this.callbacks.onRoundCount?.(childId, absolute);
             }
         }
     }
@@ -323,9 +425,13 @@ export class DshSessionBridge {
     getChildLog(childId) {
         return this.childLogs.get(childId) ?? [];
     }
-    /** Completed turn count of one child ("rounds"). */
-    getTurnCount(childId) {
-        return this.turnCounts.get(childId) ?? 0;
+    /** Assistant-message count of one child ("rounds" — the policy cap unit). */
+    getRoundCount(childId) {
+        return this.roundCounts.get(childId) ?? 0;
+    }
+    /** dsh-dcp compaction count of one child (viewer picker rows). */
+    getChildCompactionCount(childId) {
+        return this.childCompactionCounts.get(childId) ?? 0;
     }
     /** Whether one child settled (a continuable child may resume later). */
     isChildSettled(childId) {
@@ -399,7 +505,11 @@ export class DshSessionBridge {
         this.childSessions.clear();
         this.childLogs.clear();
         this.childStreams.clear();
-        this.turnCounts.clear();
+        this.roundCounts.clear();
+        this.streamedRoundCounts.clear();
+        this.childUsage.clear();
+        this.childPending.clear();
+        this.childCompactionCounts.clear();
         this.reconciledLen.clear();
         this.reconciledCount.clear();
         this.trackedSessions.clear();
@@ -428,11 +538,18 @@ export class DshSessionBridge {
         this.stats.msgCount = 0;
         this.stats.toolCallCount = 0;
         this.stats.cacheHitRate = undefined;
+        this.stats.contextTokens = 0;
+        this.lastUsage = undefined;
+        this.pendingTokens = 0;
         this.agentViews.clear();
         this.childSessions.clear();
         this.childLogs.clear();
         this.childStreams.clear();
-        this.turnCounts.clear();
+        this.roundCounts.clear();
+        this.streamedRoundCounts.clear();
+        this.childUsage.clear();
+        this.childPending.clear();
+        this.childCompactionCounts.clear();
         this.reconciledLen.clear();
         this.reconciledCount.clear();
         this.trackedSessions.clear();
@@ -514,6 +631,9 @@ export class DshSessionBridge {
         this.stats.msgCount = 0;
         this.stats.toolCallCount = 0;
         this.stats.cacheHitRate = undefined;
+        this.stats.contextTokens = 0;
+        this.lastUsage = undefined;
+        this.pendingTokens = 0;
         const sessionId = this.sessionId;
         for (const event of events) {
             if (event.type === 'assistant/chunk')
@@ -533,6 +653,9 @@ export class DshSessionBridge {
         switch (event.type) {
             case 'user/message':
                 this.stats.msgCount += 1;
+                // The prompt enters the NEXT request — priced into the occupancy now.
+                this.pendingTokens += estimateContentTokens(event.data.content);
+                this.stats.contextTokens = this.contextTokens();
                 break;
             case 'assistant/message': {
                 this.stats.msgCount += 1;
@@ -541,22 +664,83 @@ export class DshSessionBridge {
                         this.stats.toolCallCount += 1;
                 }
                 const usage = event.data.usage;
-                if (usage === undefined)
-                    break;
-                this.stats.inputTokens += usage.inputTokens;
-                this.stats.outputTokens += usage.outputTokens;
-                this.stats.cacheReadTokens += usage.cacheReadTokens ?? 0;
-                this.stats.cacheWriteTokens += usage.cacheWriteTokens ?? 0;
-                const billedInput = this.stats.inputTokens + this.stats.cacheReadTokens + this.stats.cacheWriteTokens;
-                this.stats.cacheHitRate = billedInput > 0
-                    ? (this.stats.cacheReadTokens / billedInput) * 100
-                    : undefined;
+                if (usage !== undefined) {
+                    // The assembled message finalizes the request: its usage snapshot is
+                    // now the exact billed context (input + cache + output) and the
+                    // pending estimate restarts from what follows it. A usage-less
+                    // message (adapter reported none) leaves the baseline untouched —
+                    // pending already holds the streamed chunk estimate accumulated for
+                    // this message, a reasonable stand-in until the next billed message.
+                    this.lastUsage = usage;
+                    this.pendingTokens = 0;
+                    this.stats.inputTokens += usage.inputTokens;
+                    this.stats.outputTokens += usage.outputTokens;
+                    this.stats.cacheReadTokens += usage.cacheReadTokens ?? 0;
+                    this.stats.cacheWriteTokens += usage.cacheWriteTokens ?? 0;
+                    const billedInput = this.stats.inputTokens + this.stats.cacheReadTokens + this.stats.cacheWriteTokens;
+                    this.stats.cacheHitRate = billedInput > 0
+                        ? (this.stats.cacheReadTokens / billedInput) * 100
+                        : undefined;
+                }
+                this.stats.contextTokens = this.contextTokens();
+                break;
+            }
+            case 'assistant/chunk': {
+                // Streamed output of the in-flight request — the next request's
+                // context grows with it, so the occupancy follows the stream live.
+                // Both text and reasoning deltas are priced: usage.outputTokens
+                // includes reasoning tokens at snapshot time, so the live estimate
+                // must count reasoning too to match that accounting (the next billed
+                // assistant/message corrects the final value anyway).
+                const chunk = event.data.chunk;
+                if ((chunk?.type === 'text-delta' || chunk?.type === 'reasoning-delta') && chunk.text !== '') {
+                    this.pendingTokens += estimateTextTokens(chunk.text ?? '');
+                    this.stats.contextTokens = this.contextTokens();
+                }
                 break;
             }
+            case 'tool/result':
+                // Tool results enter the next request — priced into the occupancy.
+                this.pendingTokens += estimateToolResultTokens(event.data);
+                this.stats.contextTokens = this.contextTokens();
+                break;
             default:
                 break;
         }
     }
+    /**
+     * The current context-occupancy estimate: the latest assistant/message's
+     * billed input (uncached + cache read + cache write) and output, plus the
+     * CJK estimate of every message appended after it. Before the first
+     * assistant/message the pending estimate alone stands in for the whole
+     * current context.
+     */
+    contextTokens() {
+        if (this.lastUsage === undefined)
+            return this.pendingTokens;
+        return this.lastUsage.inputTokens
+            + (this.lastUsage.cacheReadTokens ?? 0)
+            + (this.lastUsage.cacheWriteTokens ?? 0)
+            + this.lastUsage.outputTokens
+            + this.pendingTokens;
+    }
+    /**
+     * The current context-occupancy estimate of one child (the `X` in the
+     * compact line's `X/Y`): the child's latest assistant/message billed input
+     * + output plus the CJK estimate of messages appended after it. Before the
+     * child's first assistant/message the pending estimate alone stands in.
+     */
+    childContextTokens(childId) {
+        const usage = this.childUsage.get(childId);
+        const pending = this.childPending.get(childId) ?? 0;
+        if (usage === undefined)
+            return pending;
+        return usage.inputTokens
+            + (usage.cacheReadTokens ?? 0)
+            + (usage.cacheWriteTokens ?? 0)
+            + usage.outputTokens
+            + pending;
+    }
     /**
      * Fold one event of a tracked session into the agent views (workflow events
      * of the parent log + the child's own log). O(1) per event — Maps/Sets only,
@@ -573,7 +757,9 @@ export class DshSessionBridge {
                     label: event.data.label,
                     startedAt: event.time,
                     tokens: 0,
+                    rounds: 0,
                     retries: 0,
+                    contextTokens: 0,
                 });
                 this.runSeqToChild.set(`${event.data.runId}:${event.data.seq}`, event.data.childId);
                 this.childSessions.add(event.data.childId);
@@ -594,13 +780,6 @@ export class DshSessionBridge {
             }
         }
         if (this.childSessions.has(sessionId)) {
-            // Round counting is view-independent: every completed turn of the child
-            // is one round, even once the view settled (continuable children resume).
-            if (event.type === 'turn/end') {
-                const count = (this.turnCounts.get(sessionId) ?? 0) + 1;
-                this.turnCounts.set(sessionId, count);
-                this.callbacks.onTurnCount?.(sessionId, count);
-            }
             const view = this.agentViews.get(sessionId);
             if (view !== undefined) {
                 if (isSubagentDescriptor(event)) {
@@ -617,22 +796,60 @@ export class DshSessionBridge {
                     }
                 }
                 else if (event.type === 'assistant/message') {
+                    // Round counting is view-independent: every assistant message of the
+                    // child is one round (one LLM round-trip), counted even once the
+                    // view settled — continuable children resume. `turn/end` is NOT the
+                    // round unit: a one-shot child never leaves its single turn, so its
+                    // rounds would stay frozen at 0 while it works.
+                    // The event path keeps its OWN absolute streamed count and merges
+                    // it with the reconcile's log-derived count by max() — the two
+                    // ledgers never double count. A message the reconcile already
+                    // counted (its `assistant/message` reached the session log first)
+                    // must not be counted AGAIN when that same event arrives late here:
+                    // the reconcile only moves the count up, so a naive `current + 1`
+                    // would inflate it permanently. Caveat: "absolute" holds only while
+                    // the firehose delivers each event at most once — there is no seq
+                    // de-dup, so a redelivered `assistant/message` inflates the
+                    // streamed ledger permanently (the previous `current + 1` counter
+                    // had the same exposure).
+                    const streamed = (this.streamedRoundCounts.get(sessionId) ?? 0) + 1;
+                    this.streamedRoundCounts.set(sessionId, streamed);
+                    const count = Math.max(streamed, this.roundCounts.get(sessionId) ?? 0);
+                    if (count !== (this.roundCounts.get(sessionId) ?? 0)) {
+                        this.roundCounts.set(sessionId, count);
+                        this.callbacks.onRoundCount?.(sessionId, count);
+                    }
                     const usage = event.data.usage;
                     const delta = usage === undefined
                         ? 0
                         : usage.inputTokens + usage.outputTokens
                             + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0);
+                    // The assembled message finalizes the child's request: its usage is
+                    // now the exact billed context baseline and the pending estimate
+                    // restarts from what follows it. A usage-less message leaves both
+                    // untouched — pending still holds the streamed chunk estimate
+                    // accumulated for this message, a reasonable approximation until the
+                    // next billed message replaces it.
+                    if (usage !== undefined) {
+                        this.childUsage.set(sessionId, usage);
+                        this.childPending.set(sessionId, 0);
+                    }
                     const lastLine = lastTextLine(event.data);
                     const tokensChanged = delta > 0;
                     const lineChanged = lastLine !== undefined && lastLine !== view.lastLine;
-                    if (tokensChanged || lineChanged) {
-                        // One set: neither delta nor lastLine may clobber the other. The
-                        // assembled message is authoritative for the content tail — its
-                        // streaming buffer is spent.
+                    const roundsChanged = count !== view.rounds;
+                    const contextTokens = this.childContextTokens(sessionId);
+                    const contextChanged = contextTokens !== view.contextTokens;
+                    if (tokensChanged || lineChanged || roundsChanged || contextChanged) {
+                        // One set: neither delta nor lastLine nor rounds nor contextTokens
+                        // may clobber the others. The assembled message is authoritative
+                        // for the content tail — its streaming buffer is spent.
                         this.agentViews.set(sessionId, {
                             ...view,
                             ...(tokensChanged ? { tokens: view.tokens + delta } : {}),
                             ...(lineChanged ? { lastLine } : {}),
+                            ...(roundsChanged ? { rounds: count } : {}),
+                            ...(contextChanged ? { contextTokens } : {}),
                         });
                         changed = true;
                     }
@@ -651,13 +868,54 @@ export class DshSessionBridge {
                             const buffer = bumpChildStream(this.childStreams.get(sessionId) ?? '', delta);
                             this.childStreams.set(sessionId, buffer);
                             const lastLine = lastBufferLine(buffer);
-                            if (lastLine !== undefined && lastLine !== view.lastLine) {
-                                this.agentViews.set(sessionId, { ...view, lastLine });
+                            // Streamed output (text AND reasoning) grows the child's current
+                            // context too — usage.outputTokens includes reasoning tokens at
+                            // snapshot, so the live estimate prices both; the compact X/Y
+                            // follows live.
+                            const wasPending = this.childPending.get(sessionId) ?? 0;
+                            const lineChanged = lastLine !== undefined && lastLine !== view.lastLine;
+                            // The outer guard already narrowed to text/reasoning deltas, so
+                            // this branch is unconditional.
+                            this.childPending.set(sessionId, wasPending + estimateTextTokens(delta));
+                            const contextTokens = this.childContextTokens(sessionId);
+                            const contextChanged = contextTokens !== view.contextTokens;
+                            if (lineChanged || contextChanged) {
+                                this.agentViews.set(sessionId, {
+                                    ...view,
+                                    ...(lineChanged ? { lastLine } : {}),
+                                    ...(contextChanged ? { contextTokens } : {}),
+                                });
                                 changed = true;
                             }
                         }
                     }
                 }
+                else if (event.type === 'user/message') {
+                    // The child's own prompts/injects enter its next request — the
+                    // occupancy follows (the content tail is never touched here). A
+                    // dsh-dcp compaction notice (plugin `notice` form) also tallies the
+                    // per-child compaction count the viewer's picker rows read.
+                    if (isDcpCompactionNotice(event)) {
+                        this.childCompactionCounts.set(sessionId, (this.childCompactionCounts.get(sessionId) ?? 0) + 1);
+                    }
+                    this.childPending.set(sessionId, (this.childPending.get(sessionId) ?? 0)
+                        + estimateContentTokens(event.data.content));
+                    const contextTokens = this.childContextTokens(sessionId);
+                    if (contextTokens !== view.contextTokens) {
+                        this.agentViews.set(sessionId, { ...view, contextTokens });
+                        changed = true;
+                    }
+                }
+                else if (event.type === 'tool/result') {
+                    // Tool results enter the child's next request — the occupancy
+                    // follows (the content tail shows the child's own output only).
+                    this.childPending.set(sessionId, (this.childPending.get(sessionId) ?? 0) + estimateToolResultTokens(event.data));
+                    const contextTokens = this.childContextTokens(sessionId);
+                    if (contextTokens !== view.contextTokens) {
+                        this.agentViews.set(sessionId, { ...view, contextTokens });
+                        changed = true;
+                    }
+                }
                 else if (isLlmRetry(event)) {
                     // No text content — surface a fixed marker so the row shows the
                     // child is (re)working. Merged into one set so the retry counters