amicus 1.1.0 → 1.2.0

package/src/headless.js

@@ -12,6 +12,7 @@ const { ensureNodeModulesBinInPath } = require('./utils/path-setup');
 const { ensurePortAvailable } = require('./utils/server-setup');
 const { mapAgentToOpenCode } = require('./utils/agent-mapping');
 const { writeProgress } = require('./sidecar/progress');
+const { createMirrorState, mirrorMessages, logMessage } = require('./sidecar/conversation-mirror');
 
 /**
  * Fold marker that the agent outputs when done
@@ -190,8 +191,8 @@ async function runHeadless(model, systemPrompt, userMessage, taskId, project, ti
         mode: 'headless',
         onTimeout: () => {
           logger.info('Headless idle timeout - shutting down', { taskId });
-          server.close();
-          process.exit(0);
+          const { idleBackstopTeardown } = require('./utils/session-abort');
+          process.exit(idleBackstopTeardown(sessionDir, server, externalServer));
         },
       }).start();
     }
@@ -244,7 +245,8 @@ async function runHeadless(model, systemPrompt, userMessage, taskId, project, ti
             abortSession(client, sessionId).catch(() => {});
           } catch { /* best-effort */ }
           try { server.close(); } catch { /* best-effort */ }
-          const code = signal === 'SIGINT' ? 130 : 143;
+          const { resolveTerminalState } = require('./sidecar/session-finalize');
+          const code = resolveTerminalState({ aborted: true }, signal).exitCode;
           const t = setTimeout(() => process.exit(code), 300);
           if (t.unref) { t.unref(); }
         },
@@ -294,12 +296,11 @@ async function runHeadless(model, systemPrompt, userMessage, taskId, project, ti
       timeoutMs
     });
 
-    let output = '';
+    const mirror = createMirrorState();
     let completed = false;
     let timedOut = false;
     let aborted = false;
     let sessionError = null; // Captures model/SDK errors from assistant messages
-    const toolCalls = [];
 
     // Poll for completion by checking messages
     const startTime = Date.now();
@@ -317,11 +318,7 @@ async function runHeadless(model, systemPrompt, userMessage, taskId, project, ti
     let stablePolls = 0; // Count polls where nothing has changed
     let lastToolCallCount = 0;
     let lastToolResultCount = 0;
-    const seenToolResultIds = new Set(); // deduplicate tool_result parts across polls
     let lastMessageCount = 0;
-    let receivingReported = false; // Track whether 'receiving' stage was reported
-    const seenTextParts = new Map(); // partId -> last captured text length
-    // seenPartIds reserved for future use (tracking processed non-text parts)
 
     while (!completed && (Date.now() - startTime) < timeoutMs) {
       watchdog.touch();
@@ -360,134 +357,35 @@ async function runHeadless(model, systemPrompt, userMessage, taskId, project, ti
         consecutivePollFailures = 0;
         const messageCount = messages?.length || 0;
 
-        // Find the last assistant message to check if it's complete
-        let currentAssistantMsgId = null;
-        let assistantFinished = false;
-
-        if (messages && Array.isArray(messages)) {
-          for (const msg of messages) {
-            const role = msg.info?.role;
-
-            // Track assistant message state
-            if (role === 'assistant') {
-              currentAssistantMsgId = msg.info.id;
-              // Check for errors — capture for result propagation
-              if (msg.info.error) {
-                sessionError = msg.info.error.data?.message
-                  || msg.info.error.name
-                  || 'Unknown model error';
-                logger.error('Session error detected in assistant message', {
-                  sessionId,
-                  error: msg.info.error.name,
-                  message: msg.info.error.data?.message
-                });
-              }
-            }
-
-            // Only process parts from assistant messages (skip user messages)
-            if (role !== 'assistant' || !msg.parts) {
-              continue;
-            }
-
-            for (const part of msg.parts) {
-              const partId = part.id || `${msg.info.id}:${part.type}:${msg.parts.indexOf(part)}`;
-
-              if (part.type === 'text' && part.text) {
-                const prevLen = seenTextParts.get(partId) || 0;
-                if (part.text.length > prevLen) {
-                  // Append only the new portion (handles streaming growth)
-                  const newText = part.text.slice(prevLen);
-                  output += newText;
-                  seenTextParts.set(partId, part.text.length);
-                  logMessage(conversationPath, {
-                    role: 'assistant',
-                    content: newText,
-                    timestamp: new Date().toISOString()
-                  });
-
-                  // Report 'receiving' stage on first text detection
-                  if (!receivingReported) {
-                    receivingReported = true;
-                    writeProgress(sessionDir, 'receiving', { messagesReceived: 1 });
-                  }
-                }
-              } else if ((part.type === 'tool_use' || part.type === 'tool') && !toolCalls.find(t => t.id === part.id)) {
-                const toolCall = {
-                  id: part.id,
-                  name: part.name,
-                  input: part.input
-                };
-                toolCalls.push(toolCall);
-                logger.debug('Tool call detected (polling)', {
-                  toolName: part.name,
-                  toolId: part.id,
-                  subagentType: part.input?.subagent_type,
-                  model: part.input?.model
-                });
-                logMessage(conversationPath, {
-                  role: 'assistant',
-                  type: 'tool_use',
-                  toolCall,
-                  timestamp: new Date().toISOString()
-                });
-
-                // Update progress on tool_use detection
-                const toolLabel = part.name
-                  ? `Calling tool: ${part.name}`
-                  : 'Executing tool call...';
-                writeProgress(sessionDir, 'receiving', {
-                  messagesReceived: toolCalls.length,
-                  latestTool: part.name || undefined,
-                  stageLabel: toolLabel
-                });
-                receivingReported = true;
-              } else if (part.type === 'tool_result') {
-                if (!seenToolResultIds.has(partId)) {
-                  seenToolResultIds.add(partId);
-                }
-                logger.debug('Tool result received (polling)', {
-                  toolUseId: part.tool_use_id,
-                  isError: part.is_error || false
-                });
-                logMessage(conversationPath, {
-                  role: 'tool',
-                  type: 'tool_result',
-                  toolUseId: part.tool_use_id,
-                  isError: part.is_error || false,
-                  content: part.content,
-                  timestamp: new Date().toISOString()
-                });
-              }
-            }
-          }
-
-          // assistantFinished = true only when the LAST assistant message is complete
-          // (earlier messages may finish while the model continues in new messages)
-          const lastAssistant = messages
-            .filter(m => m.info?.role === 'assistant')
-            .pop();
-          assistantFinished = !!(lastAssistant?.info?.time?.completed);
+        const mr = mirrorMessages(messages, mirror);
+        mr.appendLines.forEach(line => logMessage(conversationPath, line));
+        mr.progressUpdates.forEach(p => writeProgress(sessionDir, p.stage, p.extra));
+        const currentAssistantMsgId = mr.currentAssistantMsgId;
+        const assistantFinished = mr.assistantFinished;
+        if (mr.sessionError) {
+          sessionError = mr.sessionError;
+          logger.error('Session error detected in assistant message', { sessionId, message: mr.sessionError });
         }
 
         logger.debug('Poll status', {
           pollCount,
           messageCount,
           assistantFinished,
-          outputLength: output.length,
+          outputLength: mirror.output.length,
           elapsed: Date.now() - startTime
         });
 
         // Check for completion marker on its own line (not inline in prose).
         // Models may mention [SIDECAR_FOLD] when describing code — only treat
         // it as a signal when it appears as a standalone line.
-        if (/^\s*\[SIDECAR_FOLD\]\s*$/m.test(output)) {
+        if (/^\s*\[SIDECAR_FOLD\]\s*$/m.test(mirror.output)) {
           completed = true;
           break;
         }
 
         // If the model returned an error with no output, exit immediately
         // (don't wait for timeout — the model won't produce anything)
-        if (sessionError && !output && assistantFinished) {
+        if (sessionError && !mirror.output && assistantFinished) {
           logger.error('Model returned error with no output, exiting', {
             sessionError, pollCount
           });
@@ -497,7 +395,7 @@ async function runHeadless(model, systemPrompt, userMessage, taskId, project, ti
         // Authoritative idle signal from the OpenCode SDK (preferred over the heuristic).
         // Gate on real output so a pre-processing 'idle' cannot end the run early.
         // Best-effort: on any error, fall back to the activity heuristic below.
-        if (output.length > 0) {
+        if (mirror.output.length > 0) {
           try {
             const remainingForStatus = deadline - Date.now();
             const statusData = await withTimeout(
@@ -518,12 +416,12 @@ async function runHeadless(model, systemPrompt, userMessage, taskId, project, ti
         // Activity-aware idle detection: ANY of text growth, a new tool call, a new
         // tool result, a new message, or a new assistant message id counts as progress.
         // Only count toward completion when NOTHING changed (genuine idle).
-        const outputGrew = output.length > lastOutputLength;
-        lastOutputLength = output.length;
-        const toolActivity = toolCalls.length > lastToolCallCount;
-        lastToolCallCount = toolCalls.length;
-        const resultActivity = seenToolResultIds.size > lastToolResultCount;
-        lastToolResultCount = seenToolResultIds.size;
+        const outputGrew = mirror.output.length > lastOutputLength;
+        lastOutputLength = mirror.output.length;
+        const toolActivity = mirror.toolCalls.length > lastToolCallCount;
+        lastToolCallCount = mirror.toolCalls.length;
+        const resultActivity = mirror.seenToolResultIds.size > lastToolResultCount;
+        lastToolResultCount = mirror.seenToolResultIds.size;
         const messageActivity = messageCount > lastMessageCount;
         lastMessageCount = messageCount;
         const newAssistant = currentAssistantMsgId !== lastAssistantMsgId;
@@ -533,7 +431,7 @@ async function runHeadless(model, systemPrompt, userMessage, taskId, project, ti
         if (!progressed) {
           // Require real output before counting toward completion — the SDK creates an
           // empty assistant-message placeholder on promptAsync that is NOT a finished response.
-          if (currentAssistantMsgId !== null && output.length > 0) {
+          if (currentAssistantMsgId !== null && mirror.output.length > 0) {
             stablePolls++;
             const threshold = assistantFinished ? stableFinishedPolls : stableIdlePolls;
             if (stablePolls >= threshold) {
@@ -542,7 +440,7 @@ async function runHeadless(model, systemPrompt, userMessage, taskId, project, ti
             }
           } else {
             logger.debug('Waiting for model to produce output', {
-              pollCount, hasAssistantMsg: currentAssistantMsgId !== null, outputLength: output.length
+              pollCount, hasAssistantMsg: currentAssistantMsgId !== null, outputLength: mirror.output.length
             });
           }
         } else {
@@ -576,7 +474,7 @@ async function runHeadless(model, systemPrompt, userMessage, taskId, project, ti
       aborted,
       pollCount,
       stablePolls,
-      outputLength: output.length,
+      outputLength: mirror.output.length,
       elapsed: Date.now() - startTime,
       hasAssistantMsg: lastAssistantMsgId !== null,
       sessionError: sessionError || null
@@ -602,11 +500,11 @@ async function runHeadless(model, systemPrompt, userMessage, taskId, project, ti
     if (!externalServer) { server.close(); }
 
     // Log summary of tool calls for debugging
-    if (toolCalls.length > 0) {
+    if (mirror.toolCalls.length > 0) {
       logger.info('Tool calls summary', {
-        totalToolCalls: toolCalls.length,
-        taskToolCalls: toolCalls.filter(t => t.name === 'Task').length,
-        subagentTypes: toolCalls
+        totalToolCalls: mirror.toolCalls.length,
+        taskToolCalls: mirror.toolCalls.filter(t => t.name === 'Task').length,
+        subagentTypes: mirror.toolCalls
           .filter(t => t.name === 'Task' && t.input?.subagent_type)
           .map(t => ({ type: t.input.subagent_type, model: t.input.model || 'inherited' }))
       });
@@ -616,25 +514,30 @@ async function runHeadless(model, systemPrompt, userMessage, taskId, project, ti
     // a model error alongside streamed output still yields a usable summary),
     // and ALWAYS when the poll loop bailed on consecutive failures (F4: a dead
     // server must never classify as a complete leg, even with partial output).
-    if (sessionError && (!output || pollFailureBail)) {
+    const { sumPerMessageUsage } = require('./utils/pricing');
+    const usage = sumPerMessageUsage(mirror.usageByMsg);
+
+    if (sessionError && (!mirror.output || pollFailureBail)) {
       return {
-        summary: output ? extractSummary(output) : '',
+        summary: mirror.output ? extractSummary(mirror.output) : '',
         completed: false,
         timedOut,
         aborted,
         taskId,
-        toolCalls,
+        toolCalls: mirror.toolCalls,
+        usage,
         error: sessionError
       };
     }
 
     return {
-      summary: extractSummary(output),
+      summary: extractSummary(mirror.output),
       completed,
       timedOut,
       aborted,
       taskId,
-      toolCalls, // Include tool calls in result for verification
+      toolCalls: mirror.toolCalls, // Include tool calls in result for verification
+      usage,
       exitCode: 0
     };
 
@@ -656,12 +559,14 @@ async function runHeadless(model, systemPrompt, userMessage, taskId, project, ti
     if (watchdog) { watchdog.cancel(); }
     if (uninstallSignals) { uninstallSignals(); }
     if (!externalServer) { server.close(); }
+    const { emptyUsageTotals } = require('./utils/pricing');
     return {
       summary: '',
       completed: false,
       timedOut: false,
       aborted: false,
       taskId,
+      usage: emptyUsageTotals(),
       error: error.message
     };
   }
@@ -714,17 +619,6 @@ function formatFoldOutput({ model, sessionId, client, cwd, mode, summary }) {
   ].join('\n');
 }
 
-/**
- * Log a message to the conversation JSONL file
- * Spec Reference: §8.2 - Capture conversation to JSONL in real-time
- *
- * @param {string} conversationPath - Path to conversation.jsonl
- * @param {object} message - Message object with role, content, timestamp
- */
-function logMessage(conversationPath, message) {
-  fs.appendFileSync(conversationPath, JSON.stringify(message) + '\n', { mode: 0o600 });
-}
-
 module.exports = {
   runHeadless,
   waitForServer,

package/src/mcp-server.js

@@ -66,6 +66,12 @@ function spawnSidecarProcess(args, sessionDir) {
     stdio: ['ignore', 'ignore', stderrFd],
     env: { ...process.env, AMICUS_DEBUG_PORT: '9223', LOG_LEVEL: process.env.LOG_LEVEL || 'info' },
   });
+  // The child inherited its own copy of the stderr fd during spawn; close the
+  // parent's copy so we don't leak a descriptor. On Windows an open fd also
+  // blocks deletion of debug.log (e.g. tests that mock spawn then rm the dir).
+  if (typeof stderrFd === 'number') {
+    try { fs.closeSync(stderrFd); } catch { /* best-effort */ }
+  }
   child.unref();
   return child;
 }

package/src/sidecar/budget.js

@@ -0,0 +1,83 @@
+// src/sidecar/budget.js
+'use strict';
+
+/**
+ * @module budget
+ * Pre-flight spend gate (WS-2 #10). Two guards:
+ *  - HARD per-$/Mtok threshold (on by default): refuses a model whose catalog
+ *    price-per-Mtok exceeds the cap. Structural o3-pro / opus-fast guard; no
+ *    output length guess needed.
+ *  - SOFT total-$ ceiling (opt-in via --max-cost): refuses when the summed
+ *    per-leg ESTIMATE exceeds the ceiling. Estimate, not guaranteed.
+ * Unpriced legs (direct providers, pricing:null) are surfaced, never $0.
+ */
+
+// Tuned against the live catalog at implementation time (observed 2026-06-23):
+//   opus (claude-opus-4.8)  ~$25/Mtok out  (allowed)
+//   o3                      ~$8/Mtok out   (allowed)
+//   o3-pro                  ~$80/Mtok out  (blocked)
+//   gemini-pro              ~$12/Mtok out  (allowed)
+//   deepseek-v4-pro         ~$0.87/Mtok out (allowed)
+// Setting 60 blocks o3-pro (80) while allowing the normal council bench.
+const DEFAULT_MAX_COST_PER_MTOK = 60;
+
+// Rough output budget for the soft ceiling estimate (output length is unknown
+// pre-flight). Deliberately conservative; the ceiling is labeled "estimate".
+const ASSUMED_OUTPUT_TOKENS = 4000;
+
+function perMtok(perToken) { return perToken * 1e6; }
+
+/**
+ * @param {Array<{modelInput,model,pricing:{prompt,completion}|null}>} legs
+ * @param {{maxCostPerMtok?,maxCost?,promptChars?,assumedOutputTokens?}} [opts]
+ */
+function checkBudget(legs, opts = {}) {
+  const cap = (typeof opts.maxCostPerMtok === 'number' && opts.maxCostPerMtok > 0)
+    ? opts.maxCostPerMtok : DEFAULT_MAX_COST_PER_MTOK;
+  const inTok = Math.ceil((opts.promptChars || 0) / 4);
+  const outTok = opts.assumedOutputTokens || ASSUMED_OUTPUT_TOKENS;
+  const offending = [];
+  const breakdownLegs = [];
+  let totalEstCost = 0;
+  let unpricedCount = 0;
+
+  for (const leg of legs) {
+    if (!leg.pricing) {
+      breakdownLegs.push({ modelInput: leg.modelInput, model: leg.model, priced: false, perMtok: null, estCost: null });
+      unpricedCount++;
+      continue;
+    }
+    const pm = Math.max(perMtok(leg.pricing.prompt), perMtok(leg.pricing.completion));
+    const estCost = leg.pricing.prompt * inTok + leg.pricing.completion * outTok;
+    totalEstCost += estCost;
+    const overThreshold = pm > cap;
+    breakdownLegs.push({ modelInput: leg.modelInput, model: leg.model, priced: true, perMtok: pm, estCost, overThreshold });
+    if (overThreshold) {
+      offending.push({ modelInput: leg.modelInput, model: leg.model, perMtok: pm,
+        reason: `$${pm.toFixed(2)}/Mtok exceeds the $${cap.toFixed(2)}/Mtok cap` });
+    }
+  }
+
+  const overCeiling = (typeof opts.maxCost === 'number' && opts.maxCost > 0) ? totalEstCost > opts.maxCost : false;
+  const ok = offending.length === 0 && !overCeiling;
+  return { ok, offending, overCeiling, breakdown: { legs: breakdownLegs, totalEstCost, unpricedCount, maxCostPerMtok: cap, maxCost: opts.maxCost || null } };
+}
+
+/** Human-readable refusal text (also used as the error envelope `hint`). */
+function formatBudgetError(result) {
+  const lines = [];
+  if (result.offending.length > 0) {
+    lines.push('Budget gate: model(s) over the per-$/Mtok threshold:');
+    for (const o of result.offending) { lines.push(`  - ${o.modelInput} (${o.model}): ${o.reason}`); }
+  }
+  if (result.overCeiling) {
+    lines.push(`Budget gate: estimated total $${result.breakdown.totalEstCost.toFixed(4)} exceeds --max-cost $${result.breakdown.maxCost.toFixed(4)} (estimate, not guaranteed).`);
+  }
+  if (result.breakdown.unpricedCount > 0) {
+    lines.push(`(${result.breakdown.unpricedCount} unpriced leg(s) — direct provider; cost unknown, not included in the estimate.)`);
+  }
+  lines.push('Override: --max-cost <$> to raise the ceiling, or --no-cost-gate to disable both guards (e.g. an intentional o3 run).');
+  return lines.join('\n');
+}
+
+module.exports = { checkBudget, formatBudgetError, DEFAULT_MAX_COST_PER_MTOK, ASSUMED_OUTPUT_TOKENS };

package/src/sidecar/conversation-mirror.js

@@ -0,0 +1,128 @@
+// src/sidecar/conversation-mirror.js
+'use strict';
+
+/**
+ * @module conversation-mirror
+ * Pure transform of an OpenCode getMessages() snapshot into conversation.jsonl
+ * append-lines + progress.json updates. Extracted from the headless poll loop so
+ * the interactive GUI path can mirror the same way (WS-4 #7). No I/O, no clock
+ * except the injectable `now`.
+ */
+
+/** Fresh cursor for a session's mirror. */
+function createMirrorState() {
+  return {
+    seenTextParts: new Map(),   // partId -> last captured text length
+    toolCalls: [],              // [{id,name,input}]
+    seenToolResultIds: new Set(),
+    receivingReported: false,
+    output: '',                 // accumulated assistant text
+    usageByMsg: new Map(),      // msgId -> {tokens, cost}
+  };
+}
+
+/**
+ * @param {Array} messages getMessages() snapshot
+ * @param {object} state from createMirrorState() (mutated + returned)
+ * @param {{now?: () => string}} [opts]
+ */
+function mirrorMessages(messages, state, opts = {}) {
+  const now = opts.now || (() => new Date().toISOString());
+  const appendLines = [];
+  const progressUpdates = [];
+  let currentAssistantMsgId = null;
+  let assistantFinished = false;
+  let sessionError = null;
+  const list = Array.isArray(messages) ? messages : [];
+  const messageCount = list.length;
+
+  for (const msg of list) {
+    const role = msg.info && msg.info.role;
+
+    // Track assistant message state
+    if (role === 'assistant') {
+      currentAssistantMsgId = msg.info.id;
+      if (msg.info.tokens || typeof msg.info.cost === 'number') {
+        state.usageByMsg.set(msg.info.id, { tokens: msg.info.tokens, cost: msg.info.cost });
+      }
+      // Check for errors — capture for result propagation
+      if (msg.info.error) {
+        sessionError = (msg.info.error.data && msg.info.error.data.message)
+          || msg.info.error.name || 'Unknown model error';
+      }
+    }
+
+    // Only process parts from assistant messages (skip user messages)
+    if (role !== 'assistant' || !msg.parts) { continue; }
+
+    for (const part of msg.parts) {
+      const partId = part.id || `${msg.info.id}:${part.type}:${msg.parts.indexOf(part)}`;
+
+      if (part.type === 'text' && part.text) {
+        const prevLen = state.seenTextParts.get(partId) || 0;
+        if (part.text.length > prevLen) {
+          // Append only the new portion (handles streaming growth)
+          const newText = part.text.slice(prevLen);
+          state.output += newText;
+          state.seenTextParts.set(partId, part.text.length);
+          appendLines.push({ role: 'assistant', content: newText, timestamp: now() });
+
+          // Report 'receiving' stage on first text detection
+          if (!state.receivingReported) {
+            state.receivingReported = true;
+            progressUpdates.push({ stage: 'receiving', extra: { messagesReceived: 1 } });
+          }
+        }
+      } else if ((part.type === 'tool_use' || part.type === 'tool') && !state.toolCalls.find(t => t.id === part.id)) {
+        const toolCall = { id: part.id, name: part.name, input: part.input };
+        state.toolCalls.push(toolCall);
+        appendLines.push({ role: 'assistant', type: 'tool_use', toolCall, timestamp: now() });
+
+        // Update progress on tool_use detection
+        progressUpdates.push({
+          stage: 'receiving',
+          extra: {
+            messagesReceived: state.toolCalls.length,
+            latestTool: part.name || undefined,
+            stageLabel: part.name ? `Calling tool: ${part.name}` : 'Executing tool call...',
+          },
+        });
+        state.receivingReported = true;
+      } else if (part.type === 'tool_result') {
+        // Dedup: append only on first sight (fixes latent double-log bug in headless poll loop)
+        if (!state.seenToolResultIds.has(partId)) {
+          state.seenToolResultIds.add(partId);
+          appendLines.push({
+            role: 'tool',
+            type: 'tool_result',
+            toolUseId: part.tool_use_id,
+            isError: part.is_error || false,
+            content: part.content,
+            timestamp: now(),
+          });
+        }
+      }
+    }
+  }
+
+  // assistantFinished = true only when the LAST assistant message is complete
+  // (earlier messages may finish while the model continues in new messages)
+  const lastAssistant = list.filter(m => m.info && m.info.role === 'assistant').pop();
+  assistantFinished = !!(lastAssistant && lastAssistant.info.time && lastAssistant.info.time.completed);
+
+  return { appendLines, progressUpdates, state, currentAssistantMsgId, assistantFinished, sessionError, messageCount };
+}
+
+const fs = require('fs');
+
+/**
+ * Append one JSONL record to conversation.jsonl (0o600). Relocated here from
+ * headless.js so BOTH the headless loop and the interactive mirror import it from
+ * one place (no cross-module coupling to headless's 750-line surface).
+ * @param {string} conversationPath @param {object} message
+ */
+function logMessage(conversationPath, message) {
+  fs.appendFileSync(conversationPath, JSON.stringify(message) + '\n', { mode: 0o600 });
+}
+
+module.exports = { createMirrorState, mirrorMessages, logMessage };

package/src/sidecar/fanout-leg.js

@@ -87,10 +87,13 @@ async function runLeg({ leg, legId, waveId, project, systemPrompt, userMessage,
   if (summary) {
     fs.writeFileSync(SessionPaths.summaryFile(legDir), summary, { mode: 0o600 });
   }
+  const { resolveUsage } = require('../utils/pricing');
+  const usage = result && result.usage ? resolveUsage({ model: leg.model, usageTotals: result.usage }) : null;
   const finalMeta = writeLegPatch(legDir, {
     status,
     reason: result.error || undefined,
     completedAt: new Date().toISOString(),
+    usage: usage || undefined,
   });
   const effectiveResult = finalMeta.status === 'aborted'
     ? { ...result, aborted: true }
@@ -100,7 +103,7 @@ async function runLeg({ leg, legId, waveId, project, systemPrompt, userMessage,
   }
   return buildRunResult({
     taskId: legId, metadata: finalMeta, result: effectiveResult, summary,
-    modelInput: leg.modelInput, sessionDir: legDir, waveId,
+    modelInput: leg.modelInput, sessionDir: legDir, waveId, usage,
   });
 }