@cat-factory/executor-harness 1.50.18 → 1.52.2

package/README.md

@@ -35,6 +35,19 @@ are surfaced as `progress` while a job runs. The exact request/response shapes
 cat-factory sends are documented in
 [`docs/runner-pool-integration.md`](../../docs/runner-pool-integration.md).
 
+`GET /jobs/{id}` is also the harness's observability channel: `spans`, `followUps`
+and `callMetrics` are **drain-on-read** — each poll returns what accumulated since
+the previous one and clears the buffer. That is deliberate. A job that dies before
+it can return a terminal result (an evicted container, an OOM-killed process) has
+still reported the tool spans it ran and the model calls it paid for. Each drained
+`callMetrics` entry carries a job-scoped `seq`, and the terminal result repeats the
+complete list, so the backend can take both channels without double-counting a call.
+
+Because the backend records a call as soon as it drains it (and ignores the terminal
+repeat), a drained call is FINAL. A call whose tokens are still open — a CLI that reports
+only a cumulative total, costed at the end — is withheld from the drain until it is
+complete; see `createCallMetricPublisher` in `src/pi.ts`.
+
 ## What a job does
 
 The implementation job (`POST /run`) is the canonical sequence:

package/dist/agent-runner.js

@@ -3,9 +3,11 @@ import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { homedir, tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { claudeAssistantContent, claudeCallUsage, isObject, numberOf, redactBody, } from './claude-stream.js';
+import { createCallMetricPublisher, publishCallMetric, } from './pi.js';
 import { killChildProcess, spawnDetached } from './process.js';
 import { redact, secretsToRedact } from './redact.js';
-import { createSliceTracker, pickProgress, startSubagentWatcher } from './subagents.js';
+import { createSliceTracker, startSubagentWatcher } from './subagents.js';
+import { createTaskPlanTracker, normalizeStatus, pickProgress, toProgress, todosToProgress, } from './progress.js';
 import { assertOnboardingKeysCurrent, writeOnboardingPreseed } from './onboarding-preseed.js';
 import { retainSessionTranscripts } from './transcript-retention.js';
 /**
@@ -219,19 +221,28 @@ export async function runClaudeCode(opts) {
             { role: 'user', content: opts.userPrompt },
         ];
     const calls = [];
+    // Streams each call as the CLI yields it, EXCEPT one whose tokens `attributeCumulativeUsage`
+    // may still rewrite below (a published call must be final — see the publisher).
+    const publisher = createCallMetricPublisher(calls, opts.onCallMetric);
     // ADR 0026 D2.1 + ADR 0027 Defect B: surface live slice progress from TWO reconciled
-    // sources. The parent's `Task` dispatches + their terminal tool_results DO appear on this
+    // sources. The parent's subagent dispatches + their terminal tool_results DO appear on this
     // stream (only a subagent's intermediate turns don't), so `sliceTracker` derives per-slice
-    // progress for the parallel-subagent shape; a parent `TodoWrite` plan (the sequential
-    // shape) is tracked in `lastTodo`. `pickProgress` picks whichever is further along on each
-    // update, so neither masks the other — the pr-reviewer prompt writes its todo plan ONCE
-    // and never marks it done, which used to gate the slice signal off and pin progress at 0%.
+    // progress for the parallel shape; the parent's own plan (the sequential shape) is tracked
+    // by `planTracker` + `lastTodo`. `pickProgress` picks whichever is further along on each
+    // update, so neither masks the other — the pr-reviewer prompt writes its plan ONCE and never
+    // marks it done, which used to gate the slice signal off and pin progress at 0%.
+    //
+    // The plan arrives in one of two tool vocabularies depending on the bundled CLI build:
+    // `TodoWrite` (whole-list snapshots, tracked in `lastTodo`) or the incremental
+    // `TaskCreate`/`TaskUpdate` pair (tracked by `planTracker`, which needs the tool RESULTS too
+    // because the task id is minted there). Both are read — see ./progress.ts.
     const sliceTracker = createSliceTracker();
+    const planTracker = createTaskPlanTracker();
     let lastTodo;
     const emitProgress = () => {
         if (!opts.onProgress)
             return;
-        const progress = pickProgress(lastTodo, sliceTracker.progress());
+        const progress = pickProgress(pickProgress(lastTodo, planTracker.progress()), sliceTracker.progress());
         if (progress)
             opts.onProgress(progress);
     };
@@ -251,12 +262,13 @@ export async function runClaudeCode(opts) {
                 }
             }
             sliceTracker.onAssistant(content);
+            planTracker.onAssistant(content);
             emitProgress();
             // Record this call BEFORE appending its turn: the prompt is the history that
             // produced this response. The append-only array keeps each call's prompt a strict
             // prefix of the next, so the backend's telemetry chain delta-compresses cleanly.
             const u = claudeCallUsage(message.usage);
-            calls.push({
+            publisher.publish({
                 ...(typeof message.model === 'string' ? { model: message.model } : {}),
                 promptText: redactBody(JSON.stringify(messages), secrets),
                 messageCount: messages.length,
@@ -274,6 +286,7 @@ export async function runClaudeCode(opts) {
             const content = event.message.content;
             if (Array.isArray(content)) {
                 sliceTracker.onUser(content);
+                planTracker.onUser(content);
                 emitProgress();
                 messages.push({ role: 'tool', content });
             }
@@ -333,6 +346,7 @@ export async function runClaudeCode(opts) {
             ...(opts.onActivity ? { onActivity: opts.onActivity } : {}),
             secrets,
             model: opts.model,
+            ...(opts.onCallMetric ? { onCallMetric: opts.onCallMetric } : {}),
             ...(opts.log ? { log: opts.log } : {}),
         })
         : undefined;
@@ -355,7 +369,15 @@ export async function runClaudeCode(opts) {
                 ...appendArgs,
             ],
         }, prompt, opts, env, opts.subscriptionToken ? secretsToRedact(opts.subscriptionToken) : [], onEvent);
-        return await assembleClaudeOutcome({ summary, stats, stderrTail, calls, usage, subagents });
+        return await assembleClaudeOutcome({
+            summary,
+            stats,
+            stderrTail,
+            calls,
+            publisher,
+            usage,
+            subagents,
+        });
     }
     finally {
         await subagents?.stop();
@@ -401,10 +423,14 @@ function buildClaudeEnv(opts, configHome) {
  * {@link runClaudeCode} verbatim to keep its cyclomatic complexity down.
  */
 async function assembleClaudeOutcome(args) {
-    const { summary, stats, stderrTail, calls, usage, subagents } = args;
+    const { summary, stats, stderrTail, calls, publisher, usage, subagents } = args;
     // The parent's cumulative-usage fallback applies to the PARENT calls only (before the
     // subagent calls, which carry their own per-turn tokens, are concatenated).
     attributeCumulativeUsage(calls, usage);
+    // The withheld calls are final only NOW, so stream them: the completion poll drains them
+    // alongside the result, and the backend records the attributed numbers rather than the zeros
+    // they carried while the run was in flight.
+    publisher.flush();
     // Final drain of any subagent transcript writes that landed after the last poll, then
     // fold the subagents' usage + per-call telemetry into the run's outcome.
     await subagents?.stop();
@@ -425,25 +451,6 @@ async function assembleClaudeOutcome(args) {
         ...(mergedCalls.length ? { callMetrics: mergedCalls } : {}),
     };
 }
-/** Map Claude Code's `TodoWrite` todos array onto subtask counts. */
-function todosToProgress(todos) {
-    if (!Array.isArray(todos))
-        return undefined;
-    const items = todos.filter(isObject).map((t) => ({
-        label: typeof t.content === 'string' ? t.content : String(t.content ?? ''),
-        status: normalizeStatus(t.status),
-    }));
-    const completed = items.filter((i) => i.status === 'completed').length;
-    const inProgress = items.filter((i) => i.status === 'in_progress').length;
-    return { completed, inProgress, total: items.length, items };
-}
-function normalizeStatus(status) {
-    if (status === 'completed')
-        return 'completed';
-    if (status === 'in_progress')
-        return 'in_progress';
-    return 'pending';
-}
 function claudeUsage(raw) {
     if (!isObject(raw))
         return undefined;
@@ -537,7 +544,7 @@ export async function runCodex(opts) {
         // assistant text seen since the previous turn as one telemetry call.
         const perTurn = codexLastTurnUsage(event);
         if (perTurn) {
-            calls.push({
+            publishCallMetric(calls, {
                 model: opts.model,
                 promptText: redactBody(JSON.stringify(messages), secrets),
                 messageCount: messages.length,
@@ -547,7 +554,7 @@ export async function runCodex(opts) {
                 cachedInputTokens: perTurn.cachedInputTokens,
                 outputTokens: perTurn.outputTokens,
                 finishReason: null,
-            });
+            }, opts.onCallMetric);
             if (pendingText)
                 messages.push({ role: 'assistant', content: pendingText });
             pendingText = '';
@@ -571,7 +578,7 @@ export async function runCodex(opts) {
         // Fallback for a CLI/version that never emits per-turn `last_token_usage`: record a
         // single call from the cumulative total + final text so the run is still observable.
         if (calls.length === 0 && (usage || summary)) {
-            calls.push({
+            publishCallMetric(calls, {
                 model: opts.model,
                 promptText: redactBody(JSON.stringify(messages), secrets),
                 messageCount: messages.length,
@@ -581,7 +588,7 @@ export async function runCodex(opts) {
                 cachedInputTokens: 0,
                 outputTokens: usage?.outputTokens ?? 0,
                 finishReason: null,
-            });
+            }, opts.onCallMetric);
         }
         return {
             summary,
@@ -653,9 +660,7 @@ function codexPlanProgress(event) {
     }));
     if (items.length === 0)
         return undefined;
-    const completed = items.filter((i) => i.status === 'completed').length;
-    const inProgress = items.filter((i) => i.status === 'in_progress').length;
-    return { completed, inProgress, total: items.length, items };
+    return toProgress(items);
 }
 /**
  * Best-effort: pull token usage out of a Codex usage event. Codex `exec --json`

package/dist/pi-workspace.js

@@ -147,6 +147,10 @@ export async function runAgentInWorkspace(spec, opts = {}) {
             signal: opts.signal,
             onActivity: opts.onActivity,
             onProgress: opts.onProgress,
+            // Stream this run's per-call telemetry to the job's live drain. The subscription
+            // harnesses are the only producers of `callMetrics` (Pi's calls are metered by the LLM
+            // proxy as they happen), so this is the only path that needs the hook.
+            onCallMetric: opts.onCallMetric,
             ...(opts.log ? { log: opts.log } : {}),
         });
         return withEffortReport(spec.dir, subOutcome);

package/dist/pi.js

@@ -344,6 +344,65 @@ export async function writeWebToolsConfig(config) {
 function isObject(value) {
     return typeof value === 'object' && value !== null;
 }
+/**
+ * Publish one captured model call: append it to the run's list (which becomes the terminal
+ * result's `callMetrics`) AND hand the SAME object to the live stream, where the job registry
+ * stamps its {@link HarnessCallMetric.seq} and buffers it for the next poll to drain.
+ *
+ * Every producer goes through here rather than a bare `calls.push`, so the two channels can't
+ * drift: a call that reaches the terminal list but never the live stream would be invisible
+ * until the job ends, and one that reaches only the live stream would go unrecorded if the
+ * poll response were lost.
+ *
+ * A published call must be FINAL. The backend records it the moment the drain reaches it and
+ * IGNORES the terminal repeat (first write wins, so its stored prompt delta stays valid against
+ * the chain tip it was written against), which means a field mutated after publishing never
+ * reaches the store. A producer whose calls can still change (the cumulative-usage fallback,
+ * whose totals arrive with the CLI's terminal `result` event) publishes through
+ * {@link createCallMetricPublisher} instead, which withholds exactly those.
+ */
+export function publishCallMetric(calls, call, onCallMetric) {
+    calls.push(call);
+    onCallMetric?.(call);
+}
+/**
+ * A {@link publishCallMetric} wrapper for a producer whose per-call tokens may be filled in at
+ * the END of the run: a CLI that reports only a cumulative total leaves every turn at zero, and
+ * `attributeCumulativeUsage` pins the total onto the last call once the terminal `result` event
+ * arrives.
+ *
+ * Since a published call must be final (the backend stores it on the drain and ignores the
+ * terminal repeat), a call the CLI did NOT cost is appended to the list but WITHHELD from the
+ * live stream — otherwise it records as a zero-token row and the attributed numbers never land.
+ * The withholding window closes the moment any call IS costed: attribution can no longer fire, so
+ * everything held is final and released at once, in capture order, and every later call streams
+ * immediately whatever its tokens. {@link flush} covers the run that was never costed at all.
+ */
+export function createCallMetricPublisher(calls, onCallMetric) {
+    const withheld = [];
+    let anyCosted = false;
+    const flush = () => {
+        for (const call of withheld)
+            onCallMetric?.(call);
+        withheld.length = 0;
+    };
+    return {
+        publish(call) {
+            const costed = call.inputTokens > 0 || call.outputTokens > 0;
+            if (!costed && !anyCosted) {
+                publishCallMetric(calls, call);
+                withheld.push(call);
+                return;
+            }
+            if (costed)
+                anyCosted = true;
+            // Released BEFORE this call so the live sequence stays in capture order.
+            flush();
+            publishCallMetric(calls, call, onCallMetric);
+        },
+        flush,
+    };
+}
 /**
  * Pull the `todo` tool's result `details` out of a Pi `--mode json` event, or
  * undefined if the event isn't a successful `todo` tool result.

package/dist/progress.js

@@ -0,0 +1,217 @@
+import { isObject } from './claude-stream.js';
+// The parent agent's own PLAN, as progress counts. This is one of the two redundant views a
+// pr-reviewer run produces (the other is the parallel-subagent dispatch view in
+// `subagents.ts`); {@link pickProgress} reconciles them.
+//
+// The Claude Code CLI exposes the plan through TWO different tool vocabularies, and which one
+// a run uses depends on the CLI build, not on anything the harness controls:
+//
+//  - `TodoWrite` — one call carrying the WHOLE list (`todos[]`), each entry with its own
+//    status. Every call is a complete snapshot, so the last one wins.
+//  - `TaskCreate` / `TaskUpdate` — an incremental, id-keyed task list. `TaskCreate` appends a
+//    task and the CLI assigns its id in the tool RESULT; `TaskUpdate` moves one task by id.
+//
+// Both are live in the shipped schema (`sdk-tools.d.ts` in `@anthropic-ai/claude-code` declares
+// `TodoWriteInput` AND `TaskCreateInput`/`TaskUpdateInput`), so the harness tracks both rather
+// than betting on one. Reading only `TodoWrite` is what pinned a CLI 2.1.x pr-review at 0%:
+// the run planned entirely through `TaskCreate`/`TaskUpdate` and the harness saw nothing.
+//
+// Everything here is best-effort and defensive: an unknown status, a missing id, or a result
+// string the CLI reworded degrades to "no progress from this signal" rather than throwing. The
+// tool vocabulary is not a stable contract, so this module may only ever ADD signal.
+/** Statuses a plan entry can carry; anything unrecognised is treated as not-yet-started. */
+export function normalizeStatus(status) {
+    if (status === 'completed')
+        return 'completed';
+    if (status === 'in_progress')
+        return 'in_progress';
+    return 'pending';
+}
+/** Roll a label+status list up into the counts the board renders. Shared by every plan shape. */
+export function toProgress(items) {
+    return {
+        completed: items.filter((i) => i.status === 'completed').length,
+        inProgress: items.filter((i) => i.status === 'in_progress').length,
+        total: items.length,
+        items,
+    };
+}
+/** Map a `TodoWrite` call's `todos` array onto subtask counts. Each call is a full snapshot. */
+export function todosToProgress(todos) {
+    if (!Array.isArray(todos))
+        return undefined;
+    return toProgress(todos.filter(isObject).map((t) => ({
+        label: typeof t.content === 'string' ? t.content : String(t.content ?? ''),
+        status: normalizeStatus(t.status),
+    })));
+}
+/**
+ * The id the CLI assigned to a just-created task, read from `TaskCreate`'s tool RESULT.
+ *
+ * `TaskCreate`'s INPUT carries only `{subject, description}` — the id is minted by the CLI and
+ * comes back on the result, so pairing a later `TaskUpdate({taskId})` to the task it created
+ * requires reading the result text. The CLI's shipped `TaskCreateOutput` is
+ * `{task: {id, subject}}`, but the parent stream's `tool_result` block carries the rendered
+ * STRING (`"Task #1 created successfully: <subject>"`), so both shapes are accepted.
+ */
+export function parseCreatedTaskId(content) {
+    if (isObject(content)) {
+        const task = isObject(content.task) ? content.task : undefined;
+        const id = task?.id;
+        if (typeof id === 'string' && id.trim())
+            return id.trim();
+        if (typeof id === 'number')
+            return String(id);
+    }
+    const text = typeof content === 'string'
+        ? content
+        : Array.isArray(content)
+            ? content
+                .filter(isObject)
+                .map((b) => (typeof b.text === 'string' ? b.text : ''))
+                .join('\n')
+            : '';
+    return /\bTask\s+#(\d+)\b/i.exec(text)?.[1];
+}
+export function createTaskPlanTracker() {
+    // Insertion-ordered so `items` render in plan order.
+    const tasks = new Map();
+    // tool_use id of an unresolved `TaskCreate` -> the synthetic key it was filed under, so the
+    // task can be re-keyed to its real id once the result lands.
+    const pendingCreates = new Map();
+    // Updates that arrived before their target was bound (the CLI can interleave), replayed on bind.
+    const orphanUpdates = new Map();
+    // `deleted` tombstones for a task id whose create has not bound yet, replayed on bind — else a
+    // delete that races ahead of its create leaves the task in the plan forever.
+    const pendingDeletes = new Set();
+    const apply = (task, patch) => {
+        if (patch.label)
+            task.label = patch.label;
+        if (patch.status)
+            task.status = patch.status;
+    };
+    // Drop a tombstoned task. When it isn't present yet (its create hasn't bound), remember the
+    // tombstone so the bind drops it rather than leaving it stuck in the plan forever.
+    const markDeleted = (taskId) => {
+        if (!tasks.delete(taskId))
+            pendingDeletes.add(taskId);
+        orphanUpdates.delete(taskId);
+    };
+    return {
+        onAssistant(content) {
+            if (!Array.isArray(content))
+                return;
+            for (const block of content) {
+                if (!isObject(block) || block.type !== 'tool_use')
+                    continue;
+                const input = isObject(block.input) ? block.input : {};
+                if (block.name === 'TaskCreate') {
+                    const toolUseId = typeof block.id === 'string' ? block.id : undefined;
+                    if (!toolUseId || pendingCreates.has(toolUseId))
+                        continue;
+                    const label = (typeof input.subject === 'string' && input.subject.trim()) ||
+                        (typeof input.description === 'string' && input.description.trim()) ||
+                        `Task ${tasks.size + 1}`;
+                    const key = `pending:${toolUseId}`;
+                    tasks.set(key, { id: key, label, status: 'pending' });
+                    pendingCreates.set(toolUseId, key);
+                }
+                else if (block.name === 'TaskUpdate') {
+                    const taskId = typeof input.taskId === 'string' ? input.taskId : undefined;
+                    if (!taskId)
+                        continue;
+                    const patch = {};
+                    if (typeof input.subject === 'string' && input.subject.trim())
+                        patch.label = input.subject.trim();
+                    if (input.status === 'deleted') {
+                        // `deleted` is a tombstone, not a status — drop the task from the live list.
+                        markDeleted(taskId);
+                        continue;
+                    }
+                    if (input.status !== undefined)
+                        patch.status = normalizeStatus(input.status);
+                    const task = tasks.get(taskId);
+                    if (task)
+                        apply(task, patch);
+                    else
+                        orphanUpdates.set(taskId, { ...orphanUpdates.get(taskId), ...patch });
+                }
+            }
+        },
+        onUser(content) {
+            if (!Array.isArray(content))
+                return;
+            for (const block of content) {
+                if (!isObject(block) || block.type !== 'tool_result')
+                    continue;
+                const toolUseId = typeof block.tool_use_id === 'string' ? block.tool_use_id : undefined;
+                const key = toolUseId ? pendingCreates.get(toolUseId) : undefined;
+                if (!key)
+                    continue;
+                const taskId = parseCreatedTaskId(block.content);
+                pendingCreates.delete(toolUseId);
+                const task = tasks.get(key);
+                // No parsable id ⇒ leave it filed under its synthetic key: it still counts toward the
+                // plan total, it just can never be advanced by a later `TaskUpdate`. A parsed id that
+                // already names a live task (a duplicate / misparse) is also left under the synthetic key
+                // rather than overwriting that task — the rebuild below would otherwise drop a row and
+                // undercount `total`.
+                if (!taskId || !task || taskId === key || tasks.has(taskId))
+                    continue;
+                // Re-key in place. Rebuilding the map preserves insertion order, which `items` relies on.
+                const entries = [...tasks.entries()];
+                tasks.clear();
+                for (const [k, v] of entries) {
+                    if (k !== key)
+                        tasks.set(k, v);
+                    else
+                        tasks.set(taskId, { ...v, id: taskId });
+                }
+                // A tombstone that raced ahead of this bind drops the task now that it exists.
+                if (pendingDeletes.delete(taskId)) {
+                    tasks.delete(taskId);
+                    orphanUpdates.delete(taskId);
+                    continue;
+                }
+                const pendingPatch = orphanUpdates.get(taskId);
+                if (pendingPatch) {
+                    const bound = tasks.get(taskId);
+                    if (bound)
+                        apply(bound, pendingPatch);
+                    orphanUpdates.delete(taskId);
+                }
+            }
+        },
+        progress() {
+            if (tasks.size === 0)
+                return undefined;
+            return toProgress([...tasks.values()].map((t) => ({ label: t.label, status: t.status })));
+        },
+    };
+}
+/**
+ * Reconcile the redundant views of the same work into the one to surface (ADR 0027 Defect B).
+ * A pr-reviewer run has BOTH a parent plan (`TodoWrite` or `TaskCreate`/`TaskUpdate`) and the
+ * `SliceTracker`'s subagent-dispatch view. The sequential shape advances the plan; the parallel
+ * shape advances ONLY the slice tracker (the reviewer writes its plan once and the parallel
+ * subagents report in-flight/complete). Neither alone covers both shapes, and gating the slice
+ * tracker off whenever a plan exists (the original behaviour) pinned parallel runs at 0%.
+ *
+ * So prefer whichever view is further along: more `completed`, then more `inProgress` (an
+ * all-pending plan must not beat live in-flight slices), then more `total` (the richer view — a
+ * plan can carry an extra "aggregate" entry), else the plan. Pure + total; returns whichever
+ * single input is present when only one is.
+ */
+export function pickProgress(todo, slice) {
+    if (!todo)
+        return slice;
+    if (!slice)
+        return todo;
+    if (slice.completed !== todo.completed)
+        return slice.completed > todo.completed ? slice : todo;
+    if (slice.inProgress !== todo.inProgress)
+        return slice.inProgress > todo.inProgress ? slice : todo;
+    if (slice.total !== todo.total)
+        return slice.total > todo.total ? slice : todo;
+    return todo;
+}

package/dist/runner.js

@@ -30,7 +30,7 @@ export function loadRunnerLimits(env = process.env) {
     };
 }
 function toView(entry) {
-    const { promise: _promise, spanBuffer: _spanBuffer, followUpBuffer: _followUpBuffer, abort: _abort, ...view } = entry;
+    const { promise: _promise, spanBuffer: _spanBuffer, followUpBuffer: _followUpBuffer, callMetricBuffer: _callMetricBuffer, callMetricSeq: _callMetricSeq, abort: _abort, ...view } = entry;
     return { ...view };
 }
 /**
@@ -75,15 +75,18 @@ export class JobRegistry {
             promise: Promise.resolve(),
             spanBuffer: [],
             followUpBuffer: [],
+            callMetricBuffer: [],
+            callMetricSeq: 0,
         };
         this.jobs.set(id, entry);
         entry.promise = this.drive(entry, job);
         return toView(entry);
     }
     /**
-     * Poll the job — and DRAIN its tool-span buffer (drain-on-read). The GET /jobs/{id}
-     * handler is the sole caller, so each poll returns the spans accumulated since the
-     * previous poll and clears them, bounding the harness buffer to one poll interval.
+     * Poll the job — and DRAIN its observability buffers (drain-on-read). The GET /jobs/{id}
+     * handler is the sole caller, so each poll returns the spans / follow-ups / call metrics
+     * accumulated since the previous poll and clears them, bounding the harness buffers to one
+     * poll interval.
      */
     get(id) {
         const entry = this.jobs.get(id);
@@ -98,6 +101,10 @@ export class JobRegistry {
             view.followUps = entry.followUpBuffer;
             entry.followUpBuffer = [];
         }
+        if (entry.callMetricBuffer.length > 0) {
+            view.callMetrics = entry.callMetricBuffer;
+            entry.callMetricBuffer = [];
+        }
         return view;
     }
     /**
@@ -206,6 +213,13 @@ export class JobRegistry {
                 onFollowUp: (items) => {
                     entry.followUpBuffer.push(...items);
                 },
+                onCallMetric: (call) => {
+                    // Stamp the job-scoped sequence on the metric OBJECT: the handler keeps the same
+                    // instance for its terminal result, so both channels carry the same `seq` and the
+                    // backend mints one stable row id per call.
+                    call.seq = entry.callMetricSeq++;
+                    entry.callMetricBuffer.push(call);
+                },
                 onPhase: (next) => markPhase(next),
                 log: jobLog,
             });