chainlesschain 0.162.183 → 0.162.184

package/src/lib/session-usage.js

@@ -32,6 +32,33 @@ function toNumber(v) {
   return Number.isFinite(n) ? n : 0;
 }
 
+const MAX_OBSERVED_DURATION_MS = 7 * 24 * 60 * 60 * 1000;
+
+function observedDuration(value) {
+  if (value === null || value === undefined || value === "") return null;
+  const number = Number(value);
+  if (!Number.isFinite(number) || number < 0) return null;
+  return Math.min(MAX_OBSERVED_DURATION_MS, Math.round(number));
+}
+
+function eventDuration(event) {
+  return observedDuration(
+    event?.data?.duration_ms ??
+      event?.data?.durationMs ??
+      event?.data?.result?.toolTelemetryRecord?.durationMs,
+  );
+}
+
+function addObservedDuration(row, durationMs) {
+  if (durationMs === null) return;
+  row.durationMs = (row.durationMs || 0) + durationMs;
+  row.timedCalls = (row.timedCalls || 0) + 1;
+}
+
+function addObservedRetry(row) {
+  row.retries = (row.retries || 0) + 1;
+}
+
 /**
  * Extract the optional usage-attribution frame (用量归因) persisted alongside
  * a token_usage event's data: `{ origin, skill?, subagentId?, role?,
@@ -209,6 +236,56 @@ function _isToolResultError(event) {
   );
 }
 
+/**
+ * Aggregate compact `llm_retry` events. Each event represents one failed
+ * streaming attempt that the runtime actually retried and includes only a
+ * controlled reason plus its elapsed time — never the raw provider error.
+ */
+export function aggregateLlmRetries(events) {
+  const byReason = new Map();
+  const byModel = new Map();
+  let totalRetries = 0;
+  let durationMs = 0;
+
+  const add = (map, key, seed, elapsed) => {
+    const row = map.get(key) || { ...seed, retries: 0, durationMs: 0 };
+    row.retries++;
+    row.durationMs += elapsed;
+    map.set(key, row);
+  };
+
+  for (const event of events || []) {
+    if (event?.type !== "llm_retry") continue;
+    const data = event.data || {};
+    const elapsed = eventDuration(event) ?? 0;
+    const reason =
+      typeof data.reason === "string" && data.reason ? data.reason : "unknown";
+    const provider =
+      typeof data.provider === "string" && data.provider ? data.provider : null;
+    const model =
+      typeof data.model === "string" && data.model ? data.model : null;
+    totalRetries++;
+    durationMs += elapsed;
+    add(byReason, reason, { reason }, elapsed);
+    add(
+      byModel,
+      `${provider || "?"}/${model || "?"}`,
+      { provider, model },
+      elapsed,
+    );
+  }
+
+  if (totalRetries === 0) return null;
+  const byRetriesDesc = (a, b) =>
+    b.retries - a.retries || b.durationMs - a.durationMs;
+  return {
+    totalRetries,
+    durationMs,
+    byReason: Array.from(byReason.values()).sort(byRetriesDesc),
+    byModel: Array.from(byModel.values()).sort(byRetriesDesc),
+  };
+}
+
 /**
  * Aggregate the transcript's tool events: per-tool call/error counts, an MCP
  * server bucket (`mcp__<server>__*`), and a turn-associated token figure.
@@ -232,6 +309,9 @@ export function aggregateToolCalls(events) {
   const byPlugin = new Map();
   let totalCalls = 0;
   let totalErrors = 0;
+  let totalDurationMs = 0;
+  let timedCalls = 0;
+  let retryCalls = 0;
 
   const bumpTool = (name) => {
     let t = byTool.get(name);
@@ -276,6 +356,8 @@ export function aggregateToolCalls(events) {
   let turnPlugins = new Set();
   let turnTokens = 0;
   let pendingPlugin = null;
+  let pendingObservation = null;
+  let failedToolsInTurn = new Set();
   const flushTurn = () => {
     if (turnTokens > 0) {
       for (const name of turnTools) bumpTool(name).turnTokens += turnTokens;
@@ -291,6 +373,8 @@ export function aggregateToolCalls(events) {
     turnPlugins = new Set();
     turnTokens = 0;
     pendingPlugin = null;
+    pendingObservation = null;
+    failedToolsInTurn = new Set();
   };
 
   for (const evt of events || []) {
@@ -301,20 +385,35 @@ export function aggregateToolCalls(events) {
     }
     if (evt.type === "tool_call") {
       const name = evt.data?.tool || "?";
+      const durationMs = eventDuration(evt);
+      const isRetry = failedToolsInTurn.has(name);
       totalCalls++;
       const t = bumpTool(name);
       t.calls++;
       const isErr = evt.data?.is_error === true;
+      if (durationMs !== null) {
+        totalDurationMs += durationMs;
+        timedCalls++;
+        addObservedDuration(t, durationMs);
+      }
+      if (isRetry) {
+        retryCalls++;
+        addObservedRetry(t);
+      }
       if (isErr) {
         totalErrors++;
         t.errors++;
       }
+      if (isErr) failedToolsInTurn.add(name);
+      else failedToolsInTurn.delete(name);
       turnTools.add(name);
       const server = mcpServerOf(name);
       if (server) {
         const s = bumpServer(server);
         s.calls++;
         if (isErr) s.errors++;
+        addObservedDuration(s, durationMs);
+        if (isRetry) addObservedRetry(s);
         turnServers.add(server);
       }
       const plugin =
@@ -326,24 +425,43 @@ export function aggregateToolCalls(events) {
           ? evt.data.plugin_version
           : null;
       pendingPlugin = { tool: name, plugin, version: pluginVersion };
+      pendingObservation = {
+        tool: name,
+        durationCounted: durationMs !== null,
+        errorCounted: isErr,
+      };
       if (plugin) {
         const p = bumpPlugin(plugin, pluginVersion);
         p.calls++;
         if (isErr) p.errors++;
+        addObservedDuration(p, durationMs);
+        if (isRetry) addObservedRetry(p);
         turnPlugins.add(`${plugin}@${pluginVersion || "?"}`);
       }
       continue;
     }
     if (evt.type === "tool_result") {
       const name = evt.data?.tool || "?";
+      const durationMs = eventDuration(evt);
       turnTools.add(name);
       const server = mcpServerOf(name);
       if (server) turnServers.add(server);
-      if (_isToolResultError(evt)) {
+      const isErr = _isToolResultError(evt);
+      const pairedObservation =
+        pendingObservation?.tool === name ? pendingObservation : null;
+      if (isErr && !pairedObservation?.errorCounted) {
         totalErrors++;
         bumpTool(name).errors++;
         if (server) bumpServer(server).errors++;
       }
+      if (isErr) failedToolsInTurn.add(name);
+      else failedToolsInTurn.delete(name);
+      if (durationMs !== null && !pairedObservation?.durationCounted) {
+        totalDurationMs += durationMs;
+        timedCalls++;
+        addObservedDuration(bumpTool(name), durationMs);
+        if (server) addObservedDuration(bumpServer(server), durationMs);
+      }
       const extracted = extractPluginUsageAttribution(evt.data?.result);
       const plugin =
         typeof evt.data?.plugin === "string" && evt.data.plugin
@@ -360,10 +478,14 @@ export function aggregateToolCalls(events) {
           pendingPlugin?.plugin === plugin &&
           (pendingPlugin?.version || null) === (pluginVersion || null);
         if (!countedByCall) p.calls++;
-        if (_isToolResultError(evt) && !countedByCall) p.errors++;
+        if (isErr && !countedByCall) p.errors++;
+        if (!countedByCall || !pairedObservation?.durationCounted) {
+          addObservedDuration(p, durationMs);
+        }
         turnPlugins.add(`${plugin}@${pluginVersion || "?"}`);
       }
       pendingPlugin = null;
+      pendingObservation = null;
       continue;
     }
     const u = extractUsage(evt);
@@ -375,6 +497,8 @@ export function aggregateToolCalls(events) {
   return {
     totalCalls,
     totalErrors,
+    ...(timedCalls > 0 ? { totalDurationMs, timedCalls } : {}),
+    ...(retryCalls > 0 ? { retryCalls } : {}),
     byTool: Array.from(byTool.values()).sort(byCallsDesc),
     byMcpServer: Array.from(byServer.values()).sort(byCallsDesc),
     byPlugin: Array.from(byPlugin.values()).sort(byCallsDesc),
@@ -386,9 +510,11 @@ export function aggregateToolCalls(events) {
  * roll-ups + the tool/MCP call aggregation. Pure.
  */
 export function sessionAttribution(events) {
+  const retries = aggregateLlmRetries(events);
   return {
     ...aggregateUsageAttribution(events),
     tools: aggregateToolCalls(events),
+    ...(retries ? { retries } : {}),
   };
 }
 
@@ -519,8 +645,15 @@ export function allSessionsUsage({ limit = 1000 } = {}) {
   const gTool = new Map();
   const gServer = new Map();
   const gPlugin = new Map();
+  const gRetryReason = new Map();
+  const gRetryModel = new Map();
   let gToolCalls = 0;
   let gToolErrors = 0;
+  let gToolDurationMs = 0;
+  let gTimedToolCalls = 0;
+  let gToolRetryCalls = 0;
+  let gLlmRetries = 0;
+  let gLlmRetryDurationMs = 0;
   const mergeRow = (map, key, row, seed) => {
     const entry = map.get(key) || { ...seed, ..._newSums() };
     _addSums(entry, row);
@@ -545,6 +678,9 @@ export function allSessionsUsage({ limit = 1000 } = {}) {
     const tools = a.tools || {};
     gToolCalls += tools.totalCalls || 0;
     gToolErrors += tools.totalErrors || 0;
+    gToolDurationMs += tools.totalDurationMs || 0;
+    gTimedToolCalls += tools.timedCalls || 0;
+    gToolRetryCalls += tools.retryCalls || 0;
     for (const row of tools.byTool || []) {
       const entry = gTool.get(row.tool) || {
         tool: row.tool,
@@ -556,6 +692,12 @@ export function allSessionsUsage({ limit = 1000 } = {}) {
       entry.calls += row.calls || 0;
       entry.errors += row.errors || 0;
       entry.turnTokens += row.turnTokens || 0;
+      if (row.durationMs !== undefined) {
+        entry.durationMs = (entry.durationMs || 0) + (row.durationMs || 0);
+        entry.timedCalls = (entry.timedCalls || 0) + (row.timedCalls || 0);
+      }
+      if (row.retries !== undefined)
+        entry.retries = (entry.retries || 0) + (row.retries || 0);
       gTool.set(row.tool, entry);
     }
     for (const row of tools.byMcpServer || []) {
@@ -568,6 +710,12 @@ export function allSessionsUsage({ limit = 1000 } = {}) {
       entry.calls += row.calls || 0;
       entry.errors += row.errors || 0;
       entry.turnTokens += row.turnTokens || 0;
+      if (row.durationMs !== undefined) {
+        entry.durationMs = (entry.durationMs || 0) + (row.durationMs || 0);
+        entry.timedCalls = (entry.timedCalls || 0) + (row.timedCalls || 0);
+      }
+      if (row.retries !== undefined)
+        entry.retries = (entry.retries || 0) + (row.retries || 0);
       gServer.set(row.server, entry);
     }
     for (const row of tools.byPlugin || []) {
@@ -582,10 +730,45 @@ export function allSessionsUsage({ limit = 1000 } = {}) {
       entry.calls += row.calls || 0;
       entry.errors += row.errors || 0;
       entry.turnTokens += row.turnTokens || 0;
+      if (row.durationMs !== undefined) {
+        entry.durationMs = (entry.durationMs || 0) + (row.durationMs || 0);
+        entry.timedCalls = (entry.timedCalls || 0) + (row.timedCalls || 0);
+      }
+      if (row.retries !== undefined)
+        entry.retries = (entry.retries || 0) + (row.retries || 0);
       gPlugin.set(key, entry);
     }
+    const retries = a.retries || null;
+    if (retries) {
+      gLlmRetries += retries.totalRetries || 0;
+      gLlmRetryDurationMs += retries.durationMs || 0;
+      for (const row of retries.byReason || []) {
+        const entry = gRetryReason.get(row.reason) || {
+          reason: row.reason,
+          retries: 0,
+          durationMs: 0,
+        };
+        entry.retries += row.retries || 0;
+        entry.durationMs += row.durationMs || 0;
+        gRetryReason.set(row.reason, entry);
+      }
+      for (const row of retries.byModel || []) {
+        const key = `${row.provider || "?"}/${row.model || "?"}`;
+        const entry = gRetryModel.get(key) || {
+          provider: row.provider || null,
+          model: row.model || null,
+          retries: 0,
+          durationMs: 0,
+        };
+        entry.retries += row.retries || 0;
+        entry.durationMs += row.durationMs || 0;
+        gRetryModel.set(key, entry);
+      }
+    }
   }
   const byCallsDesc = (a, b) => b.calls - a.calls;
+  const byRetriesDesc = (a, b) =>
+    b.retries - a.retries || b.durationMs - a.durationMs;
 
   return {
     sessions: perSession,
@@ -601,10 +784,27 @@ export function allSessionsUsage({ limit = 1000 } = {}) {
       tools: {
         totalCalls: gToolCalls,
         totalErrors: gToolErrors,
+        ...(gTimedToolCalls > 0
+          ? {
+              totalDurationMs: gToolDurationMs,
+              timedCalls: gTimedToolCalls,
+            }
+          : {}),
+        ...(gToolRetryCalls > 0 ? { retryCalls: gToolRetryCalls } : {}),
         byTool: Array.from(gTool.values()).sort(byCallsDesc),
         byMcpServer: Array.from(gServer.values()).sort(byCallsDesc),
         byPlugin: Array.from(gPlugin.values()).sort(byCallsDesc),
       },
+      ...(gLlmRetries > 0
+        ? {
+            retries: {
+              totalRetries: gLlmRetries,
+              durationMs: gLlmRetryDurationMs,
+              byReason: Array.from(gRetryReason.values()).sort(byRetriesDesc),
+              byModel: Array.from(gRetryModel.values()).sort(byRetriesDesc),
+            },
+          }
+        : {}),
     },
   };
 }

package/src/lib/stream-retry.js

@@ -81,3 +81,32 @@ export function isRetryableStreamError(err, signal) {
     msg,
   );
 }
+
+/**
+ * Reduce a retryable stream failure to a small, secret-free reason vocabulary
+ * suitable for persisted usage telemetry. Never persist the provider's raw
+ * error message: it can contain a request URL, tenant id, or proxy details.
+ */
+export function classifyStreamRetryReason(err) {
+  const code = String(err?.code || err?.cause?.code || "").toUpperCase();
+  if (code === "ETIMEDOUT") return "timeout";
+  if (["EAI_AGAIN", "ENOTFOUND"].includes(code)) return "dns";
+  if (code === "ECONNREFUSED") return "connection_refused";
+  if (code === "ENETUNREACH") return "network_unreachable";
+  if (["ECONNRESET", "EPIPE", "UND_ERR_SOCKET"].includes(code)) {
+    return "connection_reset";
+  }
+  const msg = String(err?.message || err || "").toLowerCase();
+  if (/timed?\s*out|etimedout/.test(msg)) return "timeout";
+  if (/eai_again|enotfound|dns/.test(msg)) return "dns";
+  if (/econnrefused/.test(msg)) return "connection_refused";
+  if (/network unreachable|enetunreach/.test(msg)) return "network_unreachable";
+  if (
+    /econnreset|socket hang ?up|terminated|fetch failed|network error|premature close/.test(
+      msg,
+    )
+  ) {
+    return "connection_reset";
+  }
+  return "unknown";
+}

package/src/repl/agent-repl.js

@@ -48,10 +48,12 @@ import {
   appendCompactEvent,
   appendTokenUsage,
   appendToolCallCompact,
+  appendLlmRetryCompact,
   appendEvent,
   rebuildMessages,
   sessionExists,
 } from "../harness/jsonl-session-store.js";
+import { classifyStreamRetryReason } from "../lib/stream-retry.js";
 import { CLISkillLoader } from "../lib/skill-loader.js";
 import { storeMemory, consolidateMemory } from "../lib/hierarchical-memory.js";
 import { CLIContextEngineering } from "../lib/cli-context-engineering.js";
@@ -353,13 +355,25 @@ export async function agentLoop(messages, options) {
         chalk.gray(`  ⎌ checkpoint ${event.id} (before ${event.tool})\n`),
       );
     } else if (event.type === "tool-executing") {
-      _lastExec = { tool: event.tool, args: event.args };
+      _lastExec = {
+        tool: event.tool,
+        args: event.args,
+        startedAt: options.now ? options.now() : Date.now(),
+      };
       process.stdout.write(
         chalk.gray(
           `  [${event.tool}] ${formatToolArgs(event.tool, event.args)}\n`,
         ),
       );
     } else if (event.type === "tool-result") {
+      const durationMs =
+        event.result?.toolTelemetryRecord?.durationMs ??
+        (_lastExec?.tool === event.tool
+          ? Math.max(
+              0,
+              (options.now ? options.now() : Date.now()) - _lastExec.startedAt,
+            )
+          : undefined);
       // 用量归因: persist a compact tool_call record (name + error flag +
       // skill/plugin hints — never args, which can carry whole file bodies)
       // so `cc session usage --by tool|mcp|plugin` and `cc insights` can
@@ -375,6 +389,7 @@ export async function agentLoop(messages, options) {
                 ? _lastExec.args?.skill_name
                 : undefined,
             ...extractPluginUsageAttribution(event.result),
+            durationMs,
           });
         } catch (_e) {
           // persistence is best-effort — never break the turn
@@ -5570,12 +5585,26 @@ export async function startAgentRepl(options = {}) {
         // streaming call hits a transient connection drop and retries, tell the
         // user instead of leaving them staring at a silent pause. To stderr so
         // it never corrupts the streamed answer on stdout.
-        onStreamRetry: (attempt) =>
+        onStreamRetry: (attempt, error, telemetry = {}) => {
           process.stderr.write(
             chalk.dim(
               `  ⟳ connection dropped — retrying (attempt ${attempt})…\n`,
             ),
-          ),
+          );
+          if (useJsonl && sessionId) {
+            try {
+              appendLlmRetryCompact(sessionId, {
+                attempt,
+                durationMs: telemetry.durationMs,
+                provider: telemetry.provider || provider,
+                model: telemetry.model || activeModel,
+                reason: classifyStreamRetryReason(error),
+              });
+            } catch {
+              /* usage telemetry is best-effort */
+            }
+          }
+        },
         // Stream-stall hint (Claude-Code 2.1.185): the connection is alive but
         // the API has gone silent mid-response — tell the user we're still
         // waiting instead of leaving a frozen spinner. stderr so it never

package/src/runtime/agent-core.js

@@ -6742,7 +6742,15 @@ export async function chatWithTools(rawMessages, options) {
             options.streamStallMs,
             options.streamStallTimeoutMs,
           ),
-        { signal, onRetry: options.onStreamRetry },
+        {
+          signal,
+          onRetry: (attempt, error, telemetry) =>
+            options.onStreamRetry?.(attempt, error, {
+              ...telemetry,
+              provider: "ollama",
+              model: model || null,
+            }),
+        },
       );
     }
     const response = await fetch(apiUrl, {
@@ -6868,7 +6876,15 @@ export async function chatWithTools(rawMessages, options) {
             options.streamStallMs,
             options.streamStallTimeoutMs,
           ),
-        { signal, onRetry: options.onStreamRetry },
+        {
+          signal,
+          onRetry: (attempt, error, telemetry) =>
+            options.onStreamRetry?.(attempt, error, {
+              ...telemetry,
+              provider: "anthropic",
+              model: effModel,
+            }),
+        },
       );
     }
 
@@ -6972,7 +6988,15 @@ export async function chatWithTools(rawMessages, options) {
           options.streamStallMs,
           options.streamStallTimeoutMs,
         ),
-      { signal, onRetry: options.onStreamRetry },
+      {
+        signal,
+        onRetry: (attempt, error, telemetry) =>
+          options.onStreamRetry?.(attempt, error, {
+            ...telemetry,
+            provider,
+            model: model || defaultModels[provider] || "gpt-4o-mini",
+          }),
+      },
     );
   }
 
@@ -7171,8 +7195,10 @@ export async function _retryStreamingChat(streamFn, opts = {}) {
   const base = opts.baseDelayMs ?? STREAM_RETRY_BASE_MS;
   const signal = opts.signal;
   const sleep = opts.sleep || ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const now = typeof opts.now === "function" ? opts.now : Date.now;
   let attempt = 0;
   for (;;) {
+    const attemptStartedAt = now();
     try {
       return await streamFn();
     } catch (err) {
@@ -7181,7 +7207,9 @@ export async function _retryStreamingChat(streamFn, opts = {}) {
       attempt++;
       if (typeof opts.onRetry === "function") {
         try {
-          opts.onRetry(attempt, err);
+          opts.onRetry(attempt, err, {
+            durationMs: Math.max(0, now() - attemptStartedAt),
+          });
         } catch {
           /* the retry notice is best-effort; never let it mask the retry */
         }

package/src/runtime/headless-runner.js

@@ -43,6 +43,7 @@ import {
   appendAssistantMessage as jsonlAppendAssistantMessage,
   appendTokenUsage as jsonlAppendTokenUsage,
   appendToolCallCompact as jsonlAppendToolCallCompact,
+  appendLlmRetryCompact as jsonlAppendLlmRetryCompact,
   appendCompactEvent as jsonlAppendCompactEvent,
   appendEvent as jsonlAppendEvent,
   readEvents as jsonlReadEvents,
@@ -51,6 +52,7 @@ import {
   getLastSessionId as jsonlGetLastSessionId,
   verifySession as jsonlVerifySession,
 } from "../harness/jsonl-session-store.js";
+import { classifyStreamRetryReason } from "../lib/stream-retry.js";
 import {
   SideEffectLedger,
   reconcileSideEffects,
@@ -503,6 +505,8 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     appendTokenUsage: deps.appendTokenUsage || jsonlAppendTokenUsage,
     appendToolCallCompact:
       deps.appendToolCallCompact || jsonlAppendToolCallCompact,
+    appendLlmRetryCompact:
+      deps.appendLlmRetryCompact || jsonlAppendLlmRetryCompact,
     appendCompactEvent: deps.appendCompactEvent || jsonlAppendCompactEvent,
     appendEvent: deps.appendEvent || jsonlAppendEvent,
     readEvents: deps.readEvents || jsonlReadEvents,
@@ -1626,6 +1630,22 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     // while a human watching a long `cc agent -p` run learns we're still waiting
     // and, when a hard inactivity timeout is set, when it will auto-retry. Plain
     // text (no chalk) since headless stderr is frequently piped/non-TTY.
+    onStreamRetry: (attempt, error, telemetry = {}) => {
+      writeErr(`  ⟳ connection dropped — retrying (attempt ${attempt})…\n`);
+      if (persist) {
+        try {
+          store.appendLlmRetryCompact(sessionId, {
+            attempt,
+            durationMs: telemetry.durationMs,
+            provider: telemetry.provider || provider,
+            model: telemetry.model || model,
+            reason: classifyStreamRetryReason(error),
+          });
+        } catch {
+          /* usage telemetry is best-effort */
+        }
+      }
+    },
     onStall: (ms, timeoutMs) => {
       const silent = Math.round(ms / 1000);
       const retryIn = timeoutMs > ms ? Math.round((timeoutMs - ms) / 1000) : 0;
@@ -1678,6 +1698,11 @@ export async function runAgentHeadless(options = {}, deps = {}) {
 
   const startedAt = deps.now ? deps.now() : Date.now();
   const toolCalls = [];
+  // The core normally attaches a precise toolTelemetryRecord on success.
+  // Keep an event-boundary fallback for denials/early throws that settle
+  // before that record is produced. Tools are serial in this loop, so one
+  // timestamp is sufficient and never leaks into the result envelope.
+  let currentToolStartedAt = null;
   // Policy denials (blocked tool calls) collected for an end-of-run summary,
   // so a non-interactive run surfaces what got blocked the way the REPL's
   // `/permissions denials` does (Claude-Code 2.1.193 denial reasons).
@@ -1970,6 +1995,7 @@ export async function runAgentHeadless(options = {}, deps = {}) {
             break;
           }
           case "tool-executing": {
+            currentToolStartedAt = deps.now ? deps.now() : Date.now();
             const line = `  [${event.tool}] ${formatToolArgs(event.tool, event.args)}`;
             if (isText) writeErr(line + "\n");
             emitStream({
@@ -2057,11 +2083,21 @@ export async function runAgentHeadless(options = {}, deps = {}) {
             if (toolCalls.length > 0) {
               const settledCall = toolCalls[toolCalls.length - 1];
               settledCall.is_error = Boolean(err);
+              settledCall.durationMs =
+                event.result?.toolTelemetryRecord?.durationMs ??
+                (currentToolStartedAt === null
+                  ? undefined
+                  : Math.max(
+                      0,
+                      (deps.now ? deps.now() : Date.now()) -
+                        currentToolStartedAt,
+                    ));
               Object.assign(
                 settledCall,
                 extractPluginUsageAttribution(event.result),
               );
             }
+            currentToolStartedAt = null;
             // Track policy denials (not plain tool failures) for the end-of-run
             // summary. The preceding tool-executing pushed the args.
             if (err) {
@@ -2540,6 +2576,7 @@ export async function runAgentHeadless(options = {}, deps = {}) {
             tc.tool === "run_skill" ? tc.args?.skill_name || null : undefined,
           plugin: tc.plugin || undefined,
           pluginVersion: tc.pluginVersion || undefined,
+          durationMs: tc.durationMs,
         });
       }
       // Attributed child-loop usage first (chronology: it happened during