mstro-app 0.2.0 → 0.3.0

package/server/cli/headless/claude-invoker.ts

@@ -26,6 +26,17 @@ export interface ClaudeInvokerOptions {
   runningProcesses: Map<number, ChildProcess>;
 }
 
+// ========== Signal Helpers ==========
+
+/** Map a Node.js signal name to its numeric value for exit code computation */
+function signalToNumber(signal: string): number | undefined {
+  const map: Record<string, number> = {
+    SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGABRT: 6,
+    SIGKILL: 9, SIGTERM: 15, SIGUSR1: 10, SIGUSR2: 12,
+  };
+  return map[signal];
+}
+
 // ========== Stall Detection Helpers ==========
 
 /** Summarize a tool's input for stall assessment context */
@@ -261,6 +272,12 @@ interface StreamHandlerContext {
   resumeAssessmentActive: boolean;
   /** Buffered assistant text during resume assessment */
   resumeAssessmentBuffer: string;
+  /** Cumulative API token usage from message_start/message_delta events */
+  apiTokenUsage: { inputTokens: number; outputTokens: number };
+  /** Tracks cumulative output_tokens within the current step (message_delta is cumulative per-step) */
+  currentStepOutputTokens: number;
+  /** Timestamp of the last token usage change (tokens still flowing = process alive) */
+  lastTokenActivityTime: number;
 }
 
 function handleSessionCapture(
@@ -428,6 +445,9 @@ function handleToolComplete(event: any, ctx: StreamHandlerContext): void {
     startTime: toolBuffer.startTime
   });
 
+  // Clean up the input buffer — it's no longer needed after accumulation
+  ctx.toolInputBuffers.delete(index);
+
   if (ctx.config.toolUseCallback) {
     ctx.config.toolUseCallback({
       type: 'tool_complete',
@@ -439,6 +459,80 @@ function handleToolComplete(event: any, ctx: StreamHandlerContext): void {
   }
 }
 
+/** Accumulate input tokens from a message_start event. Returns true if any tokens were added. */
+function handleMessageStartTokens(event: any, ctx: StreamHandlerContext): boolean {
+  if (event.type !== 'message_start' || !event.message?.usage) return false;
+  const usage = event.message.usage;
+  ctx.currentStepOutputTokens = 0;
+  let changed = false;
+  if (typeof usage.input_tokens === 'number') {
+    ctx.apiTokenUsage.inputTokens += usage.input_tokens;
+    changed = true;
+  }
+  if (typeof usage.cache_creation_input_tokens === 'number') {
+    ctx.apiTokenUsage.inputTokens += usage.cache_creation_input_tokens;
+    changed = true;
+  }
+  if (typeof usage.cache_read_input_tokens === 'number') {
+    ctx.apiTokenUsage.inputTokens += usage.cache_read_input_tokens;
+    changed = true;
+  }
+  verboseLog(ctx.config.verbose,
+    `[TOKENS] message_start: input=${usage.input_tokens ?? 0} cache_create=${usage.cache_creation_input_tokens ?? 0} cache_read=${usage.cache_read_input_tokens ?? 0} → total_input=${ctx.apiTokenUsage.inputTokens}`);
+  return changed;
+}
+
+/** Accumulate output tokens from a message_delta event. Returns true if any tokens were added.
+ * message_delta carries CUMULATIVE output token count for the current step.
+ * Per Anthropic docs: "The token counts shown in the usage field of the
+ * message_delta event are cumulative" and there can be "one or more message_delta
+ * events" per message. We track the delta from the previous value to avoid
+ * double-counting when multiple message_delta events fire per step. */
+function handleMessageDeltaTokens(event: any, ctx: StreamHandlerContext): boolean {
+  if (event.type !== 'message_delta' || !event.usage) return false;
+  if (typeof event.usage.output_tokens !== 'number') return false;
+  const increment = event.usage.output_tokens - ctx.currentStepOutputTokens;
+  verboseLog(ctx.config.verbose,
+    `[TOKENS] message_delta: output=${event.usage.output_tokens} (step_prev=${ctx.currentStepOutputTokens} increment=${increment}) → total_output=${ctx.apiTokenUsage.outputTokens + Math.max(increment, 0)}`);
+  if (increment <= 0) return false;
+  ctx.apiTokenUsage.outputTokens += increment;
+  ctx.currentStepOutputTokens = event.usage.output_tokens;
+  return true;
+}
+
+function handleTokenUsage(event: any, ctx: StreamHandlerContext): void {
+  const changed = handleMessageStartTokens(event, ctx) || handleMessageDeltaTokens(event, ctx);
+  if (changed) {
+    ctx.lastTokenActivityTime = Date.now();
+    ctx.config.tokenUsageCallback?.({ ...ctx.apiTokenUsage });
+  }
+}
+
+/**
+ * Extract definitive token usage from the result event emitted at the end of a Claude session.
+ * The result event's `usage` field contains the authoritative total — it overrides any
+ * accumulated stream-based counts which may be incomplete (e.g., when extended thinking
+ * suppresses stream_event emissions).
+ */
+function handleResultTokenUsage(parsed: any, ctx: StreamHandlerContext): void {
+  if (!parsed.usage) return;
+  const u = parsed.usage;
+  const input = (typeof u.input_tokens === 'number' ? u.input_tokens : 0)
+    + (typeof u.cache_creation_input_tokens === 'number' ? u.cache_creation_input_tokens : 0)
+    + (typeof u.cache_read_input_tokens === 'number' ? u.cache_read_input_tokens : 0);
+  const output = typeof u.output_tokens === 'number' ? u.output_tokens : 0;
+
+  if (input > 0 || output > 0) {
+    verboseLog(ctx.config.verbose,
+      `[TOKENS] Result event usage: input=${input} output=${output} ` +
+      `(stream accumulated: input=${ctx.apiTokenUsage.inputTokens} output=${ctx.apiTokenUsage.outputTokens})`);
+    // Replace with authoritative counts from the result event
+    ctx.apiTokenUsage = { inputTokens: input, outputTokens: output };
+    ctx.lastTokenActivityTime = Date.now();
+    ctx.config.tokenUsageCallback?.({ ...ctx.apiTokenUsage });
+  }
+}
+
 function handleToolResult(parsed: any, ctx: StreamHandlerContext): void {
   if (parsed.type !== 'user' || !parsed.message?.content) {
     return;
@@ -497,11 +591,14 @@ function processStreamEvent(parsed: any, ctx: StreamHandlerContext): void {
     return;
   }
 
-  // Handle result events that contain error info
-  if (parsed.type === 'result' && parsed.is_error) {
-    const errorMessage = parsed.error || parsed.result || 'Unknown error in result';
-    ctx.config.outputCallback?.(`\n[[MSTRO_ERROR:CLAUDE_RESULT_ERROR]] ${errorMessage}\n`);
-    return;
+  // Handle result events — extract definitive token usage and surface errors
+  if (parsed.type === 'result') {
+    handleResultTokenUsage(parsed, ctx);
+    if (parsed.is_error) {
+      const errorMessage = parsed.error || parsed.result || 'Unknown error in result';
+      ctx.config.outputCallback?.(`\n[[MSTRO_ERROR:CLAUDE_RESULT_ERROR]] ${errorMessage}\n`);
+      return;
+    }
   }
 
   if (parsed.type === 'stream_event' && parsed.event) {
@@ -511,6 +608,7 @@ function processStreamEvent(parsed: any, ctx: StreamHandlerContext): void {
     handleToolStart(event, ctx);
     handleToolInputDelta(event, ctx);
     handleToolComplete(event, ctx);
+    handleTokenUsage(event, ctx);
   }
   handleToolResult(parsed, ctx);
 }
@@ -672,11 +770,13 @@ async function runStallCheckTick(
     claudeProcess: ChildProcess;
     stallCheckInterval: ReturnType<typeof setInterval>;
     config: ResolvedHeadlessConfig;
+    lastTokenActivityTime: number;
   },
 ): Promise<void> {
   const now = Date.now();
   const silenceMs = now - state.lastActivityTime;
   const totalElapsed = now - opts.perfStart;
+  const tokenSilenceMs = now - opts.lastTokenActivityTime;
 
   if (totalElapsed >= opts.stallHardCapMs) {
     terminateStallProcess(opts.claudeProcess, opts.stallCheckInterval, opts.config,
@@ -685,6 +785,13 @@ async function runStallCheckTick(
     return;
   }
 
+  // Token activity pushes the kill deadline forward — tokens flowing means
+  // the process is alive even if stdout is silent (e.g. silent thinking).
+  if (tokenSilenceMs < 60_000 && now < state.currentKillDeadline) {
+    const killMs = opts.config.stallKillMs ?? 1_800_000;
+    state.currentKillDeadline = Math.max(state.currentKillDeadline, now + killMs);
+  }
+
   if (now >= state.currentKillDeadline) {
     terminateStallProcess(opts.claudeProcess, opts.stallCheckInterval, opts.config,
       `\n[[MSTRO_ERROR:EXECUTION_STALLED]] No output for ${Math.round(silenceMs / 60_000)} minutes. Terminating process.\n`
@@ -703,6 +810,7 @@ async function runStallCheckTick(
     pendingToolNames: new Set(opts.pendingTools.values()),
     totalToolCalls: opts.totalToolCalls,
     elapsedTotalMs: totalElapsed,
+    tokenSilenceMs,
   };
 
   if (opts.stallAssessEnabled && state.extensionsGranted < opts.maxExtensions) {
@@ -847,8 +955,12 @@ function setupToolTracking(
     ? new ToolWatchdog({
         profiles: config.toolTimeoutProfiles,
         verbose: config.verbose,
-        onTiebreaker: async (toolName, toolInput, elapsedMs) => {
-          return assessToolTimeout(toolName, toolInput, elapsedMs, config.claudeCommand, config.verbose);
+        onTiebreaker: async (toolName, toolInput, elapsedMs, tokenSilenceMs) => {
+          return assessToolTimeout(toolName, toolInput, elapsedMs, config.claudeCommand, config.verbose, tokenSilenceMs);
+        },
+        getTokenSilenceMs: () => {
+          const last = ctx.lastTokenActivityTime;
+          return last > 0 ? Date.now() - last : undefined;
         },
       })
     : null;
@@ -978,6 +1090,9 @@ export async function executeClaudeCommand(
     nativeTimeoutDetector: new NativeTimeoutDetector(),
     resumeAssessmentActive: isResumeMode,
     resumeAssessmentBuffer: '',
+    apiTokenUsage: { inputTokens: 0, outputTokens: 0 },
+    currentStepOutputTokens: 0,
+    lastTokenActivityTime: Date.now(),
   };
 
   // Stall detection state (mutable object shared with runStallCheckTick)
@@ -1044,7 +1159,7 @@ export async function executeClaudeCommand(
     runStallCheckTick(stallState, {
       perfStart, stallWarningMs, stallHardCapMs, maxExtensions, stallAssessEnabled,
       toolWatchdogActive, prompt, pendingTools, lastToolInputSummary: toolCounters.lastToolInputSummary, totalToolCalls: toolCounters.totalToolCalls,
-      claudeProcess, stallCheckInterval, config,
+      claudeProcess, stallCheckInterval, config, lastTokenActivityTime: ctx.lastTokenActivityTime,
     });
   }, 10_000);
 
@@ -1052,38 +1167,47 @@ export async function executeClaudeCommand(
   toolTracking.setKillContext(claudeProcess, stallCheckInterval);
 
   return new Promise((resolve, reject) => {
-    claudeProcess.on('close', async (code) => {
+    claudeProcess.on('close', async (code, signal) => {
       clearInterval(stallCheckInterval);
       watchdog?.clearAll();
-
-      const postTimeout = flushNativeTimeoutBuffers(ctx);
       await classifyUnmatchedStderr(stderr, errorAlreadySurfaced, code, config);
-      const resumeBuffered = ctx.resumeAssessmentActive ? (ctx.resumeAssessmentBuffer || undefined) : undefined;
-
-      if (claudeProcess.pid) {
-        runningProcesses.delete(claudeProcess.pid);
-      }
-      resolve({
-        output: stdout,
-        error: stderr || undefined,
-        exitCode: code || 0,
-        assistantResponse: ctx.accumulatedAssistantResponse || undefined,
-        thinkingOutput: ctx.accumulatedThinking || undefined,
-        toolUseHistory: ctx.accumulatedToolUse.length > 0 ? ctx.accumulatedToolUse : undefined,
-        claudeSessionId: sessionCapture.claudeSessionId,
-        nativeTimeoutCount: ctx.nativeTimeoutDetector.timeoutCount || undefined,
-        postTimeoutOutput: postTimeout,
-        resumeBufferedOutput: resumeBuffered,
-      });
+      if (claudeProcess.pid) runningProcesses.delete(claudeProcess.pid);
+      resolve(buildCloseResult(ctx, stdout, stderr, code, signal, sessionCapture));
     });
 
     claudeProcess.on('error', (error: NodeJS.ErrnoException) => {
       clearInterval(stallCheckInterval);
       watchdog?.clearAll();
-      if (claudeProcess.pid) {
-        runningProcesses.delete(claudeProcess.pid);
-      }
+      if (claudeProcess.pid) runningProcesses.delete(claudeProcess.pid);
       handleSpawnError(error, config, reject);
     });
   });
 }
+
+function buildCloseResult(
+  ctx: StreamHandlerContext,
+  stdout: string,
+  stderr: string,
+  code: number | null,
+  signal: NodeJS.Signals | null,
+  sessionCapture: { claudeSessionId?: string },
+): ExecutionResult {
+  const postTimeout = flushNativeTimeoutBuffers(ctx);
+  const resumeBuffered = ctx.resumeAssessmentActive ? (ctx.resumeAssessmentBuffer || undefined) : undefined;
+  const exitCode = code ?? (signal ? 128 + (signalToNumber(signal) ?? 0) : 0);
+  const hasTokenUsage = ctx.apiTokenUsage.inputTokens > 0 || ctx.apiTokenUsage.outputTokens > 0;
+  return {
+    output: stdout,
+    error: stderr || undefined,
+    exitCode,
+    signalName: signal || undefined,
+    assistantResponse: ctx.accumulatedAssistantResponse || undefined,
+    thinkingOutput: ctx.accumulatedThinking || undefined,
+    toolUseHistory: ctx.accumulatedToolUse.length > 0 ? ctx.accumulatedToolUse : undefined,
+    claudeSessionId: sessionCapture.claudeSessionId,
+    nativeTimeoutCount: ctx.nativeTimeoutDetector.timeoutCount || undefined,
+    postTimeoutOutput: postTimeout,
+    resumeBufferedOutput: resumeBuffered,
+    apiTokenUsage: hasTokenUsage ? { ...ctx.apiTokenUsage } : undefined,
+  };
+}

package/server/cli/headless/output-utils.test.ts

@@ -0,0 +1,225 @@
+import { describe, expect, it } from 'vitest';
+import {
+  detectErrorInStderr,
+  estimateTokensFromOutput,
+  extractCleanOutput,
+  extractModifiedFiles,
+} from './output-utils.js';
+
+// ========== extractCleanOutput ==========
+
+describe('extractCleanOutput', () => {
+  it('filters out JSON lines with "type" field', () => {
+    const input = [
+      '{"type": "system", "data": "init"}',
+      'Hello world',
+      '{"type": "assistant", "text": "hi"}',
+      'Some output',
+    ].join('\n');
+    expect(extractCleanOutput(input)).toBe('Hello world\nSome output');
+  });
+
+  it('strips ANSI color codes', () => {
+    const input = '\x1b[32mgreen text\x1b[0m and \x1b[1;31mred bold\x1b[0m';
+    expect(extractCleanOutput(input)).toBe('green text and red bold');
+  });
+
+  it('normalizes CRLF to LF', () => {
+    const input = 'line1\r\nline2\r\nline3';
+    expect(extractCleanOutput(input)).toBe('line1\nline2\nline3');
+  });
+
+  it('trims whitespace', () => {
+    const input = '  \n  Hello  \n  ';
+    expect(extractCleanOutput(input)).toBe('Hello');
+  });
+
+  it('filters empty lines', () => {
+    const input = 'line1\n\n\nline2';
+    expect(extractCleanOutput(input)).toBe('line1\nline2');
+  });
+
+  it('returns empty string for all-JSON input', () => {
+    const input = '{"type": "system"}\n{"type": "result"}';
+    expect(extractCleanOutput(input)).toBe('');
+  });
+
+  it('handles combined ANSI + JSON + CRLF', () => {
+    const input = '{"type": "system"}\r\n\x1b[33mwarning\x1b[0m\r\n{"type": "result"}';
+    expect(extractCleanOutput(input)).toBe('warning');
+  });
+});
+
+// ========== estimateTokensFromOutput ==========
+
+describe('estimateTokensFromOutput', () => {
+  it('estimates tokens as length / 4', () => {
+    expect(estimateTokensFromOutput('12345678')).toBe(2);
+    expect(estimateTokensFromOutput('1234')).toBe(1);
+  });
+
+  it('floors the result', () => {
+    expect(estimateTokensFromOutput('12345')).toBe(1); // 5/4 = 1.25 → 1
+    expect(estimateTokensFromOutput('123')).toBe(0);   // 3/4 = 0.75 → 0
+  });
+
+  it('returns 0 for empty string', () => {
+    expect(estimateTokensFromOutput('')).toBe(0);
+  });
+});
+
+// ========== extractModifiedFiles ==========
+
+describe('extractModifiedFiles', () => {
+  it('extracts files from "wrote" pattern', () => {
+    const output = 'wrote file "src/index.ts" successfully';
+    expect(extractModifiedFiles(output)).toContain('src/index.ts');
+  });
+
+  it('extracts files from "modified" pattern', () => {
+    const output = 'modified utils.js in place';
+    expect(extractModifiedFiles(output)).toContain('utils.js');
+  });
+
+  it('extracts files from "created" pattern', () => {
+    const output = "created file 'new-file.tsx'";
+    expect(extractModifiedFiles(output)).toContain('new-file.tsx');
+  });
+
+  it('extracts files from "edited" pattern', () => {
+    const output = 'edited config.json';
+    expect(extractModifiedFiles(output)).toContain('config.json');
+  });
+
+  it('deduplicates files', () => {
+    const output = 'wrote src/index.ts\nmodified src/index.ts';
+    const files = extractModifiedFiles(output);
+    expect(files.filter(f => f === 'src/index.ts')).toHaveLength(1);
+  });
+
+  it('returns empty array when no files found', () => {
+    expect(extractModifiedFiles('no files mentioned here')).toEqual([]);
+  });
+
+  it('extracts multiple different files', () => {
+    const output = 'wrote src/a.ts\ncreated src/b.ts\nedited src/c.ts';
+    const files = extractModifiedFiles(output);
+    expect(files).toContain('src/a.ts');
+    expect(files).toContain('src/b.ts');
+    expect(files).toContain('src/c.ts');
+  });
+});
+
+// ========== detectErrorInStderr ==========
+
+describe('detectErrorInStderr', () => {
+  it('detects auth errors', () => {
+    const result = detectErrorInStderr('Error: not logged in to Claude');
+    expect(result).not.toBeNull();
+    expect(result!.errorCode).toBe('AUTH_REQUIRED');
+  });
+
+  it('detects session expired', () => {
+    const result = detectErrorInStderr('Your session has expired, please re-authenticate');
+    expect(result).not.toBeNull();
+    expect(result!.errorCode).toBe('AUTH_REQUIRED');
+  });
+
+  it('detects account not found', () => {
+    const result = detectErrorInStderr('account not found for this user');
+    expect(result).not.toBeNull();
+    expect(result!.errorCode).toBe('ACCOUNT_NOT_FOUND');
+  });
+
+  it('detects API key errors', () => {
+    const result = detectErrorInStderr('invalid api key provided');
+    expect(result).not.toBeNull();
+    expect(result!.errorCode).toBe('API_KEY_INVALID');
+  });
+
+  it('detects quota exceeded', () => {
+    const result = detectErrorInStderr('quota exceeded for your subscription');
+    expect(result).not.toBeNull();
+    expect(result!.errorCode).toBe('QUOTA_EXCEEDED');
+  });
+
+  it('detects billing issues', () => {
+    const result = detectErrorInStderr('payment required to continue');
+    expect(result).not.toBeNull();
+    expect(result!.errorCode).toBe('QUOTA_EXCEEDED');
+  });
+
+  it('detects rate limiting', () => {
+    const result = detectErrorInStderr('rate limit exceeded, retry after 30s');
+    expect(result).not.toBeNull();
+    expect(result!.errorCode).toBe('RATE_LIMITED');
+  });
+
+  it('detects 429 status', () => {
+    const result = detectErrorInStderr('HTTP 429 too many requests');
+    expect(result).not.toBeNull();
+    expect(result!.errorCode).toBe('RATE_LIMITED');
+  });
+
+  it('detects network errors', () => {
+    const result = detectErrorInStderr('ECONNREFUSED 127.0.0.1:443');
+    expect(result).not.toBeNull();
+    expect(result!.errorCode).toBe('NETWORK_ERROR');
+  });
+
+  it('detects DNS failures', () => {
+    const result = detectErrorInStderr('ENOTFOUND api.anthropic.com');
+    expect(result).not.toBeNull();
+    expect(result!.errorCode).toBe('NETWORK_ERROR');
+  });
+
+  it('detects SSL errors', () => {
+    const result = detectErrorInStderr('CERT_HAS_EXPIRED for api.example.com');
+    expect(result).not.toBeNull();
+    expect(result!.errorCode).toBe('SSL_ERROR');
+  });
+
+  it('detects service unavailable', () => {
+    const result = detectErrorInStderr('service unavailable, try again later');
+    expect(result).not.toBeNull();
+    expect(result!.errorCode).toBe('SERVICE_UNAVAILABLE');
+  });
+
+  it('detects 503 status', () => {
+    const result = detectErrorInStderr('HTTP 503 from upstream');
+    expect(result).not.toBeNull();
+    expect(result!.errorCode).toBe('SERVICE_UNAVAILABLE');
+  });
+
+  it('detects internal errors', () => {
+    const result = detectErrorInStderr('internal server error occurred');
+    expect(result).not.toBeNull();
+    expect(result!.errorCode).toBe('INTERNAL_ERROR');
+  });
+
+  it('detects context too long', () => {
+    const result = detectErrorInStderr('context too long, exceeds 200k tokens');
+    expect(result).not.toBeNull();
+    expect(result!.errorCode).toBe('CONTEXT_TOO_LONG');
+  });
+
+  it('detects session not found', () => {
+    const result = detectErrorInStderr('session not found, please create a new one');
+    expect(result).not.toBeNull();
+    expect(result!.errorCode).toBe('SESSION_NOT_FOUND');
+  });
+
+  it('returns null for non-matching stderr', () => {
+    expect(detectErrorInStderr('Processing file...')).toBeNull();
+    expect(detectErrorInStderr('Warning: deprecated API usage')).toBeNull();
+    expect(detectErrorInStderr('')).toBeNull();
+  });
+
+  it('returns user-friendly messages', () => {
+    const result = detectErrorInStderr('not logged in');
+    expect(result).not.toBeNull();
+    expect(result!.message).toContain('authentication');
+    // Should not expose raw error
+    expect(result!.message).not.toContain('not logged in');
+  });
+});

package/server/cli/headless/runner.ts

@@ -89,6 +89,29 @@ export class HeadlessRunner {
     const result = await this.executePromptCommand(enrichedPrompt, 'main', 1);
 
     if (result.exitCode !== 0) {
+      // Signal exits (128+) with meaningful output are successful completions —
+      // Claude finished its work but the process was killed by signal (e.g., stall watchdog SIGTERM)
+      const isSignalExit = result.exitCode >= 128;
+      const hasOutput = !!(result.assistantResponse || (result.toolUseHistory && result.toolUseHistory.length > 0));
+
+      if (isSignalExit && hasOutput) {
+        const tokens = estimateTokensFromOutput(result.output);
+        return {
+          completed: true,
+          needsHandoff: false,
+          totalTokens: tokens,
+          sessionId,
+          signalName: result.signalName,
+          assistantResponse: result.assistantResponse,
+          thinkingOutput: result.thinkingOutput,
+          toolUseHistory: result.toolUseHistory,
+          claudeSessionId: result.claudeSessionId,
+          nativeTimeoutCount: result.nativeTimeoutCount,
+          postTimeoutOutput: result.postTimeoutOutput,
+          resumeBufferedOutput: result.resumeBufferedOutput,
+        };
+      }
+
       // Build meaningful error: prefer stderr, fall back to non-JSON stdout lines
       let errorMessage = result.error;
       if (!errorMessage && result.output) {
@@ -106,6 +129,7 @@ export class HeadlessRunner {
         totalTokens: 0,
         sessionId,
         error: errorMessage || `Claude exited with code ${result.exitCode}`,
+        signalName: result.signalName,
         assistantResponse: result.assistantResponse,
         thinkingOutput: result.thinkingOutput,
         toolUseHistory: result.toolUseHistory,
@@ -123,6 +147,7 @@ export class HeadlessRunner {
       needsHandoff: false,
       totalTokens: tokens,
       sessionId,
+      signalName: result.signalName,
       assistantResponse: result.assistantResponse,
       thinkingOutput: result.thinkingOutput,
       toolUseHistory: result.toolUseHistory,