amicus 1.0.0 → 1.2.0

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,
   });
 }
 

package/src/sidecar/fanout.js

@@ -14,6 +14,7 @@ const fs = require('fs');
 const path = require('path');
 const { logger } = require('../utils/logger');
 const { runLeg } = require('./fanout-leg');
+const { ERROR_CODES } = require('../utils/error-doc');
 
 /** Default max legs per wave (env-overridable). */
 const DEFAULT_MAX_LEGS = 10;
@@ -48,38 +49,39 @@ function deriveLegIds(waveId, count) {
 async function validateFanoutModels(modelsArg, opts = {}) {
   const raw = parseModelsList(modelsArg);
   if (raw.length === 0) {
-    return { error: 'Error: --models requires a comma-separated list (e.g. gemini,gpt,deepseek)' };
+    return { error: 'Error: --models requires a comma-separated list (e.g. gemini,gpt,deepseek)', code: 'BAD_ARGS' };
   }
   // Invalid or non-positive AMICUS_FANOUT_MAX_LEGS (0, negative, garbage) falls back to the default.
   const envCap = Number(process.env.AMICUS_FANOUT_MAX_LEGS);
   const maxLegs = (Number.isInteger(envCap) && envCap > 0) ? envCap : DEFAULT_MAX_LEGS;
   if (raw.length > maxLegs) {
-    return { error: `Error: --models exceeds the fan-out cap of ${maxLegs} legs (set AMICUS_FANOUT_MAX_LEGS to raise)` };
+    return { error: `Error: --models exceeds the fan-out cap of ${maxLegs} legs (set AMICUS_FANOUT_MAX_LEGS to raise)`, code: 'BAD_ARGS' };
   }
 
   const { tryResolveModel } = require('../utils/config');
   const { validateApiKey } = require('../utils/validators');
   const { validateAgainstCatalog } = require('../utils/model-validator');
+  const { lookupPricing } = require('../utils/pricing');
   const legs = [];
   for (const modelInput of raw) {
     const resolved = tryResolveModel(modelInput);
     if (resolved.error) {
-      return { error: `Error: model '${modelInput}': ${resolved.error}` };
+      return { error: `Error: model '${modelInput}': ${resolved.error}`, code: 'BAD_MODEL' };
     }
     let model = resolved.model;
     const keyCheck = validateApiKey(model);
     if (!keyCheck.valid) {
-      return { error: keyCheck.error };
+      return { error: keyCheck.error, code: 'MISSING_KEY' };
     }
     if (!opts.noValidateModel) {
       const alias = modelInput.includes('/') ? undefined : modelInput;
       try {
         model = await validateAgainstCatalog(model, alias);
       } catch (err) {
-        return { error: err.message };
+        return { error: err.message, code: 'BAD_MODEL' };
       }
     }
-    legs.push({ modelInput, model });
+    legs.push({ modelInput, model, pricing: lookupPricing(model) });
   }
   return { legs };
 }
@@ -131,11 +133,36 @@ async function runFanout(options) {
     return { wave: doc, exitCode: 1 };
   };
 
+  const failPre = (code, message, hint) => {
+    if (!options.quiet) {
+      if (options.json) {
+        const { buildErrorDoc } = require('../utils/error-doc');
+        console.log(JSON.stringify(buildErrorDoc({ code, message, hint }), null, 2));
+      } else {
+        console.error(hint ? `${message}\n${hint}` : message);
+      }
+    }
+    return { wave: null, errorDoc: { code, message }, exitCode: 1 };
+  };
+
   // 1. Fail-fast validation
   const validated = await validateFanoutModels(options.models, { noValidateModel: options.noValidateModel });
-  if (validated.error) { return errorWave(options.waveId, validated.error); }
+  if (validated.error) { return failPre(validated.code || 'BAD_ARGS', validated.error); }
   const legs = validated.legs;
 
+  // 1b. Budget gate (pre-creation; refuse before spending)
+  if (!options.noCostGate) {
+    const { checkBudget, formatBudgetError } = require('./budget');
+    const { loadConfig } = require('../utils/config');
+    const cfg = loadConfig() || {};
+    const maxCostPerMtok = options.maxCostPerMtok !== undefined ? options.maxCostPerMtok : cfg.maxCostPerMtok;
+    const promptChars = (options.promptMeta && options.promptMeta.chars) || (options.prompt ? options.prompt.length : 0);
+    const budget = checkBudget(legs, { maxCostPerMtok, maxCost: options.maxCost !== null && options.maxCost !== undefined ? options.maxCost : cfg.maxCost, promptChars });
+    if (!budget.ok) {
+      return failPre(ERROR_CODES.BUDGET_EXCEEDED, 'Error: budget gate refused the wave', formatBudgetError(budget));
+    }
+  }
+
   // 2. Wave record
   const waveId = options.waveId || generateTaskId();
   const legIds = deriveLegIds(waveId, legs.length);

package/src/sidecar/interactive-mirror.js

@@ -0,0 +1,66 @@
+// src/sidecar/interactive-mirror.js
+'use strict';
+
+const path = require('path');
+const { createMirrorState, mirrorMessages, logMessage } = require('./conversation-mirror');
+const { writeProgress } = require('./progress');
+const { sumPerMessageUsage } = require('../utils/pricing');
+const { logger } = require('../utils/logger');
+
+/**
+ * Poll the OpenCode session and mirror it to conversation.jsonl + progress.json
+ * live, exactly like headless. Best-effort and non-blocking — a poll/write error
+ * never throws into the GUI session.
+ *
+ * @param {object} opts
+ * @param {() => Promise<Array>} opts.getMessages
+ * @param {string} opts.sessionDir
+ * @param {number} [opts.intervalMs=2000]
+ * @param {() => void} [opts.onActivity]
+ * @param {() => string} [opts.now]
+ * @returns {{ stop: () => Promise<{usage: object|null}> }}
+ */
+function startInteractiveMirror({ getMessages, sessionDir, intervalMs = 2000, onActivity, now }) {
+  const state = createMirrorState();
+  const conversationPath = path.join(sessionDir, 'conversation.jsonl');
+  let timer = null;
+  let stopped = false;
+
+  async function pollOnce() {
+    try {
+      const messages = await getMessages();
+      const mr = mirrorMessages(messages, state, { now });
+      mr.appendLines.forEach(line => logMessage(conversationPath, line));
+      mr.progressUpdates.forEach(p => writeProgress(sessionDir, p.stage, p.extra));
+      if (mr.appendLines.length > 0 && onActivity) { onActivity(); }
+    } catch (err) {
+      logger.debug('Interactive mirror poll failed (best-effort)', { error: err.message });
+    }
+  }
+
+  const schedule = () => {
+    if (stopped) { return; }
+    timer = setTimeout(tick, intervalMs);
+    if (timer.unref) { timer.unref(); }
+  };
+  async function tick() {
+    if (stopped) { return; }
+    await pollOnce();
+    schedule();
+  }
+  schedule();
+
+  return {
+    async stop() {
+      stopped = true;
+      if (timer) { clearTimeout(timer); timer = null; }
+      await pollOnce(); // final flush
+      try { writeProgress(sessionDir, 'complete'); } catch { /* best-effort */ }
+      let usage = null;
+      try { usage = sumPerMessageUsage(state.usageByMsg); } catch { /* best-effort */ }
+      return { usage };
+    },
+  };
+}
+
+module.exports = { startInteractiveMirror };

package/src/sidecar/interactive.js

@@ -7,10 +7,12 @@ const path = require('path');
 const { spawn } = require('child_process');
 
 const { startOpenCodeServer } = require('./session-utils');
-const { createSession, sendPromptAsync } = require('../opencode-client');
+const { createSession, sendPromptAsync, getMessages } = require('../opencode-client');
 const { mapAgentToOpenCode } = require('../utils/agent-mapping');
 const { logger } = require('../utils/logger');
 const { getCompatEnv } = require('../utils/env-compat');
+const { startInteractiveMirror } = require('./interactive-mirror');
+const { getSessionDir } = require('../session-manager');
 
 /** Get the Electron binary path via require('electron').
  *  Works in all install contexts (global, local, npx hoisted).
@@ -151,15 +153,35 @@ async function runInteractive(model, systemPrompt, userMessage, taskId, project,
 
   const serverPort = new URL(server.url).port;
 
-  // Start idle watchdog for interactive mode (60-min default timeout)
+  // Start idle watchdog for interactive mode (60-min default timeout).
+  // The real teardown handler is installed BEFORE start() (closes the startup
+  // race) and references a closure that is assigned once Electron spawns.
   const { IdleWatchdog } = require('../utils/idle-watchdog');
+  const { createActivityPoller, killIfAlive } = require('../utils/activity-poller');
+  const { getSessionStatus } = require('../opencode-client');
+  let electronProcess = null;
   const watchdog = new IdleWatchdog({
     mode: 'interactive',
     onTimeout: () => {
       logger.info('Interactive idle timeout - shutting down', { taskId });
+      killIfAlive(electronProcess);
     },
   }).start();
 
+  // Keep the idle clock from killing an actively-working session: poll OpenCode
+  // session status and touch the watchdog on any non-idle (busy/retry) state.
+  const activityPoller = createActivityPoller({
+    getStatus: () => getSessionStatus(ocClient, sessionId),
+    onActivity: () => watchdog.touch(),
+  });
+
+  const sessionDir = getSessionDir(project, taskId);
+  const mirror = startInteractiveMirror({
+    getMessages: () => getMessages(ocClient, sessionId),
+    sessionDir,
+    onActivity: () => watchdog.touch(),
+  });
+
   return new Promise((resolve, _reject) => {
     const electronPath = getElectronPath();
     const mainPath = path.join(__dirname, '..', '..', 'electron', 'main.js');
@@ -170,40 +192,32 @@ async function runInteractive(model, systemPrompt, userMessage, taskId, project,
       taskId, model, project, nodeModulesBin, existingPath,
       { agent, isResume, conversation, mcp, client }
     );
-
-    // Pass OpenCode server info to Electron
     env.AMICUS_OPENCODE_PORT = serverPort;
     env.AMICUS_SESSION_ID = sessionId;
 
     const debugPort = getCompatEnv('DEBUG_PORT') || '9222';
     logger.debug('Launching Electron', { taskId, model, debugPort, serverPort, sessionId });
 
-    const electronProcess = spawn(electronPath, [
+    electronProcess = spawn(electronPath, [
       `--remote-debugging-port=${debugPort}`,
       mainPath
     ], { cwd: project, env, stdio: ['ignore', 'pipe', 'pipe'] });
 
-    // Touch watchdog on Electron stdout activity
-    electronProcess.stdout.on('data', () => {
-      watchdog.touch();
-    });
-
-    // Update watchdog onTimeout now that electronProcess is available
-    watchdog.onTimeout = () => {
-      logger.info('Interactive idle timeout - shutting down', { taskId });
-      if (!electronProcess.killed) {
-        electronProcess.kill('SIGTERM');
-      }
-    };
+    // Belt-and-suspenders: also touch on raw Electron stdout activity.
+    electronProcess.stdout.on('data', () => { watchdog.touch(); });
 
-    // Clean up server when Electron exits
-    const originalResolve = resolve;
-    handleElectronProcess(electronProcess, taskId, (result) => {
+    // Clean up server + timers when Electron exits.
+    handleElectronProcess(electronProcess, taskId, async (result) => {
       watchdog.cancel();
+      activityPoller.stop();
+      try {
+        const { usage } = await mirror.stop();
+        if (usage) { result.usage = usage; }
+      } catch (err) { logger.debug('mirror stop failed', { error: err.message }); }
       server.close();
       logger.debug('OpenCode server closed after Electron exit');
       result.opencodeSessionId = sessionId;
-      originalResolve(result);
+      resolve(result);
     });
   });
 }

package/src/sidecar/models.js

@@ -1,7 +1,7 @@
 /**
  * `amicus models` (F5) — list/search the catalog, refresh it, audit aliases.
  *
- *   amicus models                  list (curated aliases marked)
+ *   amicus models                  list (effective aliases marked)
  *   amicus models --search <q>     substring filter over id+name
  *   amicus models --refresh        force-refresh the cache
  *   amicus models --check          stale-alias audit (exit = stale count, max 100)
@@ -15,14 +15,17 @@
 const { getCatalogInfo, refreshCatalog, catalogPath } = require('../utils/model-catalog');
 const { collectAliasSources, findStaleAliases, suggestReplacements } = require('../utils/alias-audit');
 const { buildCatalogDoc, buildAuditDoc } = require('../utils/result-schema');
+const { getFamilies } = require('../utils/curated-models');
+const { pickCurrent } = require('../utils/quick-picks');
 
 const CHECK_EXIT_CAP = 100;
 
-/** '0.000003' per token → '3.00' per Mtok; '—' when unknown */
+/** '0.000003' per token → '3.00' per Mtok; '—' when unknown or variable (-1) */
 function perMtok(perToken) {
   if (perToken === null || perToken === undefined) { return '—'; }
   const n = Number(perToken);
-  return Number.isNaN(n) ? '—' : (n * 1e6).toFixed(2);
+  if (Number.isNaN(n) || n < 0) { return '—'; }
+  return (n * 1e6).toFixed(2);
 }
 
 function fmtRow(m, aliasesById) {
@@ -34,11 +37,11 @@ function fmtRow(m, aliasesById) {
   return `${aliasCol}${m.id}\n    ${m.name}  ctx ${ctx}  $/Mtok in ${pIn} out ${pOut}`;
 }
 
-/** alias marks: id → comma-joined alias names (defaults only — the curated view) */
+/** alias marks: id → comma-joined alias names (effective user aliases) */
 function aliasMarks() {
-  const { getDefaultAliases } = require('../utils/config');
+  const { getEffectiveAliases } = require('../utils/config');
   const map = new Map();
-  for (const [alias, model] of Object.entries(getDefaultAliases())) {
+  for (const [alias, model] of Object.entries(getEffectiveAliases())) {
     map.set(model, map.has(model) ? `${map.get(model)},${alias}` : alias);
   }
   return map;
@@ -57,10 +60,10 @@ async function runList(args) {
     return 0;
   }
   const marks = aliasMarks();
-  // Curated (alias-marked) rows first, then the rest.
-  const curated = filtered.filter(m => marks.has(m.id));
+  // Effective aliases (alias-marked) rows first, then the rest.
+  const marked = filtered.filter(m => marks.has(m.id));
   const rest = filtered.filter(m => !marks.has(m.id));
-  for (const m of [...curated, ...rest]) {
+  for (const m of [...marked, ...rest]) {
     process.stdout.write(fmtRow(m, marks) + '\n');
   }
   const when = fetchedAt ? new Date(fetchedAt).toISOString() : 'never';
@@ -105,8 +108,13 @@ async function runCheck(args) {
     }), null, 2) + '\n');
     return Math.min(stale.length, CHECK_EXIT_CAP);
   }
+  const driftLines = buildFallbackDriftReport(catalog);
   if (stale.length === 0) {
     process.stdout.write(`All aliases resolve to catalog models (${sources.length} checked).\n`);
+    if (driftLines.length > 0) {
+      process.stdout.write('Pinned fallback drift:\n');
+      for (const l of driftLines) { process.stdout.write(l + '\n'); }
+    }
     return 0;
   }
   for (const s of stale) {
@@ -118,9 +126,32 @@ async function runCheck(args) {
       process.stdout.write('  no same-vendor candidates in catalog\n');
     }
   }
+  if (driftLines.length > 0) {
+    process.stdout.write('Pinned fallback drift:\n');
+    for (const l of driftLines) { process.stdout.write(l + '\n'); }
+  }
   return Math.min(stale.length, CHECK_EXIT_CAP);
 }
 
+/**
+ * Non-blocking drift report: pinned family fallbacks vs live resolution.
+ * Empty catalog → [] (cannot check). Never affects the exit code.
+ * @param {Array<{id:string}>} catalog
+ * @returns {string[]} human-readable warning lines
+ */
+function buildFallbackDriftReport(catalog) {
+  if (!catalog || catalog.length === 0) { return []; }
+  const lines = [];
+  for (const f of getFamilies()) {
+    const live = pickCurrent(catalog, 'openrouter/', f.vendorPath, f.idPattern);
+    if (live && f.fallback.openrouter && live !== f.fallback.openrouter) {
+      lines.push(
+        `  pinned fallback drift: ${f.alias} → ${f.fallback.openrouter} (live: ${live}) — update curated-models.js`);
+    }
+  }
+  return lines;
+}
+
 /** @param {object} args parsed CLI args @returns {Promise<number>} exit code */
 async function handleModels(args) {
   if (args.search === true) {
@@ -132,4 +163,4 @@ async function handleModels(args) {
   return runList(args);
 }
 
-module.exports = { handleModels };
+module.exports = { handleModels, buildFallbackDriftReport };

package/src/sidecar/session-finalize.js

@@ -0,0 +1,26 @@
+'use strict';
+
+/**
+ * Map a runHeadless result to the canonical terminal status + process exit code.
+ * Single source of truth so start.js, the signal handler, and the idle backstop
+ * never disagree. Error wins over all other flags; signal callers pass the signal
+ * name for the 130/143 convention.
+ *
+ * @param {{completed?:boolean,timedOut?:boolean,aborted?:boolean,error?:any}|null} result
+ * @param {string} [signal] - 'SIGINT' | 'SIGTERM' | 'SIGBREAK' for signal aborts
+ * @returns {{status:'complete'|'error'|'timed-out'|'aborted', exitCode:number}}
+ */
+function resolveTerminalState(result, signal) {
+  if (!result || result.error) { return { status: 'error', exitCode: 1 }; }
+  if (result.aborted) {
+    const exitCode = signal === 'SIGINT' ? 130
+      : (signal === 'SIGTERM' || signal === 'SIGBREAK') ? 143
+      : 2;
+    return { status: 'aborted', exitCode };
+  }
+  if (result.timedOut) { return { status: 'timed-out', exitCode: 2 }; }
+  if (result.completed) { return { status: 'complete', exitCode: 0 }; }
+  return { status: 'error', exitCode: 1 };
+}
+
+module.exports = { resolveTerminalState };

package/src/sidecar/session-utils.js

@@ -90,12 +90,12 @@ function finalizeSession(sessionDir, summary, project, metadata, opts = {}) {
   // Save summary
   fs.writeFileSync(SessionPaths.summaryFile(sessionDir), summary, { mode: 0o600 });
 
-  // Update metadata to complete
-  metadata.status = 'complete';
+  // Update metadata to the resolved terminal status (default complete).
+  metadata.status = opts.status || 'complete';
   metadata.completedAt = new Date().toISOString();
   fs.writeFileSync(metaPath, JSON.stringify(metadata, null, 2), { mode: 0o600 });
 
-  logger.info('Session complete', { taskId: metadata.taskId });
+  logger.info('Session finalized', { taskId: metadata.taskId, status: metadata.status });
 }
 
 /** Output summary to stdout with standard formatting */
@@ -122,9 +122,9 @@ function createHeartbeat(interval = HEARTBEAT_INTERVAL, sessionDir) {
     if (sessionDir) {
       const { readProgress } = require('./progress');
       const progress = readProgress(sessionDir);
-      process.stderr.write(`[sidecar] ${ts} | ${progress.messages} messages | ${progress.latest}\n`);
+      process.stderr.write(`[amicus] ${ts} | ${progress.messages} messages | ${progress.latest}\n`);
     } else {
-      process.stderr.write(`[sidecar] still running... ${ts} elapsed\n`);
+      process.stderr.write(`[amicus] still running... ${ts} elapsed\n`);
     }
   }, interval);