mstro-app 0.2.0 → 0.3.0

package/server/cli/headless/tool-watchdog.ts

@@ -56,41 +56,44 @@ export const DEFAULT_TOOL_TIMEOUT_PROFILES: Record<string, ToolTimeoutProfile> =
     useAdaptive: false,
     useHaikuTiebreaker: true,
   },
-  // Local filesystem tools — adaptive EMA learns actual durations, short cold starts
+  // Local filesystem tools — these go through Claude Code's streaming stdio protocol,
+  // NOT direct filesystem I/O. Large files/results can take 30-60s+ to stream.
+  // Read/Grep have bimodal distributions (tiny vs huge responses) that defeat EMA,
+  // so adaptive is disabled for them. Floors are generous to prevent premature kills.
   Read: {
-    coldStartMs: 60_000,       // 1 min — local reads should be fast
-    floorMs: 15_000,           // 15s minimum
-    ceilingMs: 300_000,        // 5 min ceiling (large files, slow mounts)
-    useAdaptive: true,
-    useHaikuTiebreaker: false, // local ops don't need AI assessment
+    coldStartMs: 120_000,      // 2 min — large files stream slowly through stdio protocol
+    floorMs: 60_000,           // 1 min minimum — prevents EMA-driven premature kills
+    ceilingMs: 300_000,        // 5 min ceiling (very large files, slow mounts)
+    useAdaptive: false,        // bimodal: 1-line file vs 2000-line file defeats EMA
+    useHaikuTiebreaker: true,  // safety net: assess before killing the whole process
   },
   Grep: {
-    coldStartMs: 60_000,
-    floorMs: 15_000,
-    ceilingMs: 300_000,
-    useAdaptive: true,
-    useHaikuTiebreaker: false,
+    coldStartMs: 120_000,      // 2 min — broad searches return large result sets
+    floorMs: 60_000,           // 1 min minimum
+    ceilingMs: 300_000,        // 5 min ceiling
+    useAdaptive: false,        // bimodal: single-file vs codebase-wide search
+    useHaikuTiebreaker: true,  // safety net before killing
   },
   Glob: {
-    coldStartMs: 30_000,       // 30s — pattern matching is fast
-    floorMs: 10_000,
-    ceilingMs: 120_000,
+    coldStartMs: 60_000,       // 1 min — pattern matching can be slow on large trees
+    floorMs: 30_000,           // 30s minimum
+    ceilingMs: 180_000,        // 3 min ceiling
     useAdaptive: true,
-    useHaikuTiebreaker: false,
+    useHaikuTiebreaker: true,
   },
   Edit: {
-    coldStartMs: 30_000,
-    floorMs: 10_000,
-    ceilingMs: 120_000,
+    coldStartMs: 60_000,       // 1 min — edits go through streaming protocol too
+    floorMs: 30_000,           // 30s minimum
+    ceilingMs: 180_000,        // 3 min ceiling
     useAdaptive: true,
-    useHaikuTiebreaker: false,
+    useHaikuTiebreaker: true,
   },
   Write: {
-    coldStartMs: 30_000,
-    floorMs: 10_000,
-    ceilingMs: 120_000,
+    coldStartMs: 60_000,       // 1 min
+    floorMs: 30_000,           // 30s minimum
+    ceilingMs: 180_000,        // 3 min ceiling
     useAdaptive: true,
-    useHaikuTiebreaker: false,
+    useHaikuTiebreaker: true,
   },
 };
 
@@ -106,7 +109,9 @@ export interface ToolWatchdogOptions {
   profiles?: Record<string, Partial<ToolTimeoutProfile>>;
   verbose?: boolean;
   /** Called before killing — if returns 'extend', reschedule with extensionMs */
-  onTiebreaker?: (toolName: string, toolInput: Record<string, unknown>, elapsedMs: number) => Promise<{ action: 'extend' | 'kill'; extensionMs: number; reason: string }>;
+  onTiebreaker?: (toolName: string, toolInput: Record<string, unknown>, elapsedMs: number, tokenSilenceMs?: number) => Promise<{ action: 'extend' | 'kill'; extensionMs: number; reason: string }>;
+  /** Returns ms since last token activity. Called at tiebreaker time for fresh data. */
+  getTokenSilenceMs?: () => number | undefined;
 }
 
 interface ActiveWatch {
@@ -124,10 +129,12 @@ export class ToolWatchdog {
   private activeWatches: Map<string, ActiveWatch> = new Map();
   private verbose: boolean;
   private onTiebreaker?: ToolWatchdogOptions['onTiebreaker'];
+  private getTokenSilenceMs?: () => number | undefined;
 
   constructor(options: ToolWatchdogOptions = {}) {
     this.verbose = options.verbose ?? false;
     this.onTiebreaker = options.onTiebreaker;
+    this.getTokenSilenceMs = options.getTokenSilenceMs;
 
     // Merge user profiles with defaults
     this.profiles = { ...DEFAULT_TOOL_TIMEOUT_PROFILES };
@@ -254,7 +261,8 @@ export class ToolWatchdog {
     }
 
     try {
-      const verdict = await this.onTiebreaker!(toolName, toolInput, elapsedMs);
+      const tokenSilenceMs = this.getTokenSilenceMs?.();
+      const verdict = await this.onTiebreaker!(toolName, toolInput, elapsedMs, tokenSilenceMs);
 
       if (verdict.action === 'extend') {
         if (this.verbose) {

package/server/cli/headless/types.ts

@@ -97,6 +97,8 @@ export interface HeadlessConfig {
   outputCallback?: (text: string) => void;
   thinkingCallback?: (text: string) => void;
   toolUseCallback?: (event: ToolUseEvent) => void;
+  /** Called with cumulative API token counts as they arrive from the stream */
+  tokenUsageCallback?: (usage: { inputTokens: number; outputTokens: number }) => void;
   directPrompt?: string;
   promptContext?: PromptContext;
   continueSession?: boolean;
@@ -137,6 +139,8 @@ export interface SessionResult {
   totalTokens: number;
   sessionId: string;
   error?: string;
+  /** Signal name if Claude process was killed (e.g., 'SIGTERM', 'SIGKILL') */
+  signalName?: string;
   conflicts?: Array<{
     filePath: string;
     modifiedBy: string[];
@@ -180,6 +184,8 @@ export interface ExecutionResult {
   output: string;
   error?: string;
   exitCode: number;
+  /** Signal name if process was killed (e.g., 'SIGTERM', 'SIGKILL') */
+  signalName?: string;
   assistantResponse?: string;
   thinkingOutput?: string;
   toolUseHistory?: ToolUseAccumulator[];
@@ -192,13 +198,16 @@ export interface ExecutionResult {
   /** Assistant text buffered during resume assessment — held back until thinking/tool activity
    *  confirms Claude has context. Undefined when not in resume mode or buffer was flushed. */
   resumeBufferedOutput?: string;
+  /** Actual API token usage from Claude Code stream events (summed across all turns) */
+  apiTokenUsage?: { inputTokens: number; outputTokens: number };
 }
 
 /** Resolved config with all defaults applied */
-export type ResolvedHeadlessConfig = Omit<Required<HeadlessConfig>, 'outputCallback' | 'thinkingCallback' | 'toolUseCallback' | 'continueSession' | 'claudeSessionId' | 'imageAttachments' | 'model' | 'toolTimeoutProfiles' | 'onToolTimeout' | 'sandboxed'> & {
+export type ResolvedHeadlessConfig = Omit<Required<HeadlessConfig>, 'outputCallback' | 'thinkingCallback' | 'toolUseCallback' | 'tokenUsageCallback' | 'continueSession' | 'claudeSessionId' | 'imageAttachments' | 'model' | 'toolTimeoutProfiles' | 'onToolTimeout' | 'sandboxed'> & {
   outputCallback?: (text: string) => void;
   thinkingCallback?: (text: string) => void;
   toolUseCallback?: (event: ToolUseEvent) => void;
+  tokenUsageCallback?: (usage: { inputTokens: number; outputTokens: number }) => void;
   continueSession?: boolean;
   claudeSessionId?: string;
   imageAttachments?: ImageAttachment[];

package/server/cli/improvisation-session-manager.ts

@@ -59,6 +59,7 @@ export interface MovementRecord {
   toolUseHistory?: ToolUseRecord[];// Tool invocations + results
   errorOutput?: string;            // Any errors
   durationMs?: number;             // Execution duration in milliseconds
+  retryLog?: RetryLogEntry[];      // Auto-retry events during execution
 }
 
 export interface SessionHistory {
@@ -71,6 +72,15 @@ export interface SessionHistory {
 }
 
 
+/** Entry in the retry log for debugging recovery paths */
+interface RetryLogEntry {
+  retryNumber: number;
+  path: string;
+  reason: string;
+  timestamp: number;
+  durationMs?: number;
+}
+
 /** Mutable state for the retry loop in executePrompt */
 interface RetryLoopState {
   currentPrompt: string;
@@ -83,6 +93,7 @@ interface RetryLoopState {
   lastWatchdogCheckpoint: ExecutionCheckpoint | null;
   timedOutTools: Array<{ toolName: string; input: Record<string, unknown>; timeoutMs: number }>;
   bestResult: HeadlessRunResult | null;
+  retryLog: RetryLogEntry[];
 }
 
 /** Type alias for HeadlessRunner execution result */
@@ -119,6 +130,8 @@ export class ImprovisationSessionManager extends EventEmitter {
   private _executionStartTimestamp: number | undefined;
   /** Buffered events during current execution, for replay on reconnect */
   private executionEventLog: Array<{ type: string; data: any; timestamp: number }> = [];
+  /** Set by cancel() to signal the retry loop to exit */
+  private _cancelled: boolean = false;
 
   /**
    * Resume from a historical session.
@@ -304,9 +317,10 @@ export class ImprovisationSessionManager extends EventEmitter {
    * Each tab maintains its own claudeSessionId for proper isolation
    * Supports file attachments: text files prepended to prompt, images via stream-json multimodal
    */
-  async executePrompt(userPrompt: string, attachments?: FileAttachment[], options?: { sandboxed?: boolean }): Promise<MovementRecord> {
+  async executePrompt(userPrompt: string, attachments?: FileAttachment[], options?: { sandboxed?: boolean; workingDir?: string }): Promise<MovementRecord> {
     const _execStart = Date.now();
     this._isExecuting = true;
+    this._cancelled = false;
     this._executionStartTimestamp = _execStart;
     this.executionEventLog = [];
 
@@ -341,38 +355,24 @@ export class ImprovisationSessionManager extends EventEmitter {
         lastWatchdogCheckpoint: null,
         timedOutTools: [],
         bestResult: null,
+        retryLog: [],
       };
 
-      const maxRetries = 3;
-      let result: HeadlessRunResult;
-
-      // eslint-disable-next-line no-constant-condition
-      while (true) {
-        this.resetIterationState(state);
+      let result = await this.runRetryLoop(state, sequenceNumber, promptWithAttachments, imageAttachments, options?.sandboxed, options?.workingDir);
 
-        const { useResume, resumeSessionId } = this.determineResumeStrategy(state);
-        const runner = this.createExecutionRunner(state, sequenceNumber, useResume, resumeSessionId, imageAttachments, options?.sandboxed);
-        this.currentRunner = runner;
-        result = await runner.run();
-        this.currentRunner = null;
-
-        this.updateBestResult(state, result);
-        const nativeTimeouts = result.nativeTimeoutCount ?? 0;
-        this.detectResumeContextLoss(result, state, useResume, maxRetries, nativeTimeouts);
-        await this.detectNativeTimeoutContextLoss(result, state, maxRetries, nativeTimeouts);
-        this.flushPostTimeoutOutput(result, state);
-
-        if (this.shouldRetryContextLoss(result, state, useResume, nativeTimeouts, maxRetries, promptWithAttachments)) continue;
-        if (this.applyToolTimeoutRetry(state, maxRetries, promptWithAttachments)) continue;
-        break;
+      // If cancelled, emit a minimal movement and return early
+      if (this._cancelled) {
+        return this.handleCancelledExecution(result, userPrompt, sequenceNumber, _execStart);
       }
 
       if (state.contextLost) this.claudeSessionId = undefined;
-      result = await this.selectBestResult(state, result, userPrompt);
+      // result is guaranteed assigned here: the loop always runs at least once (if _cancelled was
+      // true before the loop, we returned in the block above; otherwise runner.run() assigned it).
+      result = await this.selectBestResult(state, result!, userPrompt);
       this.captureSessionAndSurfaceErrors(result);
       this.isFirstPrompt = false;
 
-      const movement = this.buildMovementRecord(result, userPrompt, sequenceNumber, _execStart);
+      const movement = this.buildMovementRecord(result, userPrompt, sequenceNumber, _execStart, state.retryLog);
       this.handleConflicts(result);
       this.persistMovement(movement);
 
@@ -405,6 +405,85 @@ export class ImprovisationSessionManager extends EventEmitter {
 
   // ========== Extracted helpers for executePrompt ==========
 
+  private handleCancelledExecution(
+    result: HeadlessRunResult | undefined,
+    userPrompt: string,
+    sequenceNumber: number,
+    execStart: number,
+  ): MovementRecord {
+    this._isExecuting = false;
+    this._executionStartTimestamp = undefined;
+    this.executionEventLog = [];
+    this.currentRunner = null;
+
+    const cancelledMovement: MovementRecord = {
+      id: `prompt-${sequenceNumber}`,
+      sequenceNumber,
+      userPrompt,
+      timestamp: new Date().toISOString(),
+      tokensUsed: result ? result.totalTokens : 0,
+      summary: '',
+      filesModified: [],
+      assistantResponse: result?.assistantResponse,
+      thinkingOutput: result?.thinkingOutput,
+      toolUseHistory: result?.toolUseHistory?.map(t => ({
+        toolName: t.toolName,
+        toolId: t.toolId,
+        toolInput: t.toolInput,
+        result: t.result,
+      })),
+      errorOutput: 'Execution cancelled by user',
+      durationMs: Date.now() - execStart,
+    };
+    this.persistMovement(cancelledMovement);
+    const fallbackResult = {
+      completed: false, needsHandoff: false, totalTokens: 0, sessionId: '',
+      output: '', exitCode: 1, signalName: 'SIGTERM',
+    } as HeadlessRunResult;
+    this.emitMovementComplete(cancelledMovement, result ?? fallbackResult, execStart, sequenceNumber);
+    return cancelledMovement;
+  }
+
+  private async runRetryLoop(
+    state: RetryLoopState,
+    sequenceNumber: number,
+    promptWithAttachments: string,
+    imageAttachments: FileAttachment[] | undefined,
+    sandboxed: boolean | undefined,
+    workingDirOverride: string | undefined,
+  ): Promise<HeadlessRunResult | undefined> {
+    const maxRetries = 3;
+    let result: HeadlessRunResult | undefined;
+
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      if (this._cancelled) break;
+      this.resetIterationState(state);
+
+      const { useResume, resumeSessionId } = this.determineResumeStrategy(state);
+      const runner = this.createExecutionRunner(state, sequenceNumber, useResume, resumeSessionId, imageAttachments, sandboxed, workingDirOverride);
+      this.currentRunner = runner;
+      result = await runner.run();
+      this.currentRunner = null;
+
+      if (this._cancelled) break;
+
+      this.updateBestResult(state, result);
+      const nativeTimeouts = result.nativeTimeoutCount ?? 0;
+      this.detectResumeContextLoss(result, state, useResume, maxRetries, nativeTimeouts);
+      await this.detectNativeTimeoutContextLoss(result, state, maxRetries, nativeTimeouts);
+      this.flushPostTimeoutOutput(result, state);
+
+      // Signal crashes checked first: they use --resume (lighter), and context loss
+      // recovery would clear the session ID, preventing future --resume attempts.
+      if (this.shouldRetrySignalCrash(result, state, maxRetries, promptWithAttachments)) continue;
+      if (this.shouldRetryContextLoss(result, state, useResume, nativeTimeouts, maxRetries, promptWithAttachments)) continue;
+      if (this.applyToolTimeoutRetry(state, maxRetries, promptWithAttachments)) continue;
+      break;
+    }
+    return result;
+  }
+
   /** Prepare prompt with attachments and limit image count */
   private preparePromptAndAttachments(
     userPrompt: string,
@@ -455,9 +534,10 @@ export class ImprovisationSessionManager extends EventEmitter {
     resumeSessionId: string | undefined,
     imageAttachments: FileAttachment[] | undefined,
     sandboxed: boolean | undefined,
+    workingDirOverride?: string,
   ): HeadlessRunner {
     return new HeadlessRunner({
-      workingDir: this.options.workingDir,
+      workingDir: workingDirOverride || this.options.workingDir,
       tokenBudgetThreshold: this.options.tokenBudgetThreshold,
       maxSessions: this.options.maxSessions,
       verbose: this.options.verbose,
@@ -482,6 +562,9 @@ export class ImprovisationSessionManager extends EventEmitter {
         this.emit('onToolUse', event);
         this.flushOutputQueue();
       },
+      tokenUsageCallback: (usage) => {
+        this.emit('onTokenUsage', usage);
+      },
       directPrompt: state.currentPrompt,
       imageAttachments,
       promptContext: (state.retryNumber === 0 && this.isResumedSession && this.isFirstPrompt)
@@ -544,7 +627,15 @@ export class ImprovisationSessionManager extends EventEmitter {
   ): Promise<void> {
     if (state.contextLost) return;
 
-    const toolsWithoutResult = result.toolUseHistory?.filter(t => t.result === undefined).length ?? 0;
+    // Deduplicate by toolId: if a toolId has at least one entry with a result,
+    // its orphaned duplicates are Claude Code internal retries, not actual timeouts.
+    const succeededIds = new Set<string>();
+    const allIds = new Set<string>();
+    for (const t of result.toolUseHistory ?? []) {
+      allIds.add(t.toolId);
+      if (t.result !== undefined) succeededIds.add(t.toolId);
+    }
+    const toolsWithoutResult = [...allIds].filter(id => !succeededIds.has(id)).length;
     const effectiveTimeouts = Math.max(nativeTimeouts, toolsWithoutResult);
 
     if (effectiveTimeouts === 0 || !result.assistantResponse || state.checkpointRef.value || state.retryNumber >= maxRetries) {
@@ -593,6 +684,13 @@ export class ImprovisationSessionManager extends EventEmitter {
     }
     this.accumulateToolResults(result, state);
     state.retryNumber++;
+    const path = (useResume && nativeTimeouts === 0) ? 'InterMovementRecovery' : 'NativeTimeoutRecovery';
+    state.retryLog.push({
+      retryNumber: state.retryNumber,
+      path,
+      reason: `Context lost (${nativeTimeouts} timeouts, ${state.accumulatedToolResults.length} tools preserved)`,
+      timestamp: Date.now(),
+    });
     if (useResume && nativeTimeouts === 0) {
       this.applyInterMovementRecovery(state, promptWithAttachments);
     } else {
@@ -601,7 +699,11 @@ export class ImprovisationSessionManager extends EventEmitter {
     return true;
   }
 
-  /** Accumulate completed tool results from a run into the retry state */
+  /** Accumulate completed tool results from a run into the retry state.
+   *  Caps at MAX_ACCUMULATED_RESULTS to prevent recovery prompts from exceeding context limits.
+   *  When the cap is reached, older results are evicted (FIFO) to make room for newer ones. */
+  private static readonly MAX_ACCUMULATED_RESULTS = 50;
+
   private accumulateToolResults(result: HeadlessRunResult, state: RetryLoopState): void {
     if (!result.toolUseHistory) return;
     for (const t of result.toolUseHistory) {
@@ -616,11 +718,18 @@ export class ImprovisationSessionManager extends EventEmitter {
         });
       }
     }
+    // Evict oldest results if over the cap
+    const cap = ImprovisationSessionManager.MAX_ACCUMULATED_RESULTS;
+    if (state.accumulatedToolResults.length > cap) {
+      state.accumulatedToolResults = state.accumulatedToolResults.slice(-cap);
+    }
   }
 
   /** Handle inter-movement context loss recovery (resume session expired) */
   private applyInterMovementRecovery(state: RetryLoopState, promptWithAttachments: string): void {
-    this.claudeSessionId = undefined;
+    // Preserve session ID so --resume remains available on subsequent retries.
+    // The fresh recovery prompt will be used, but if this attempt also fails,
+    // the next retry can still try --resume via shouldRetrySignalCrash.
     const historicalResults = this.extractHistoricalToolResults();
     const allResults = [...historicalResults, ...state.accumulatedToolResults];
 
@@ -668,7 +777,7 @@ export class ImprovisationSessionManager extends EventEmitter {
       );
       this.flushOutputQueue();
       state.freshRecoveryMode = true;
-      state.currentPrompt = this.buildFreshRecoveryPrompt(promptWithAttachments, state.accumulatedToolResults);
+      state.currentPrompt = this.buildFreshRecoveryPrompt(promptWithAttachments, state.accumulatedToolResults, state.timedOutTools);
     }
   }
 
@@ -692,6 +801,12 @@ export class ImprovisationSessionManager extends EventEmitter {
     });
 
     const canResumeSession = cp.inProgressTools.length === 0 && !!cp.claudeSessionId;
+    state.retryLog.push({
+      retryNumber: state.retryNumber,
+      path: 'ToolTimeout',
+      reason: `${cp.hungTool.toolName} timed out after ${cp.hungTool.timeoutMs}ms, ${cp.completedTools.length} tools completed, ${canResumeSession ? 'resuming' : 'fresh start'}`,
+      timestamp: Date.now(),
+    });
     this.emit('onAutoRetry', {
       retryNumber: state.retryNumber,
       maxRetries,
@@ -721,6 +836,127 @@ export class ImprovisationSessionManager extends EventEmitter {
     return true;
   }
 
+  /**
+   * Detect and retry after a signal crash (e.g., SIGTERM exit code 143).
+   * When the Claude process is killed externally (OOM, system signal, internal timeout
+   * that bypasses our watchdog), no existing recovery path catches it because contextLost
+   * is never set and no checkpoint is created. This adds a dedicated recovery path.
+   */
+  private shouldRetrySignalCrash(
+    result: HeadlessRunResult,
+    state: RetryLoopState,
+    maxRetries: number,
+    promptWithAttachments: string,
+  ): boolean {
+    // Only trigger for signal-killed processes (exit code 128+) that weren't already
+    // handled by context-loss or tool-timeout recovery paths.
+    // Must have an actual signal name — regular errors (e.g., auth failures, exit code 1)
+    // should NOT be retried as signal crashes.
+    const isSignalCrash = !!result.signalName;
+    const exitCodeSignal = !result.completed && !result.signalName && result.error?.match(/exited with code (1[2-9]\d|[2-9]\d{2})/);
+    if ((!isSignalCrash && !exitCodeSignal) || state.retryNumber >= maxRetries) {
+      return false;
+    }
+    // Don't re-trigger if tool timeout watchdog already handled this iteration
+    // (contextLost is NOT checked here — signal crash takes priority over context loss
+    // because it uses --resume which is lighter and avoids re-sending accumulated results)
+    if (state.checkpointRef.value) {
+      return false;
+    }
+
+    this.accumulateToolResults(result, state);
+    state.retryNumber++;
+
+    const completedCount = state.accumulatedToolResults.length;
+    const signalInfo = result.signalName || 'unknown signal';
+    const useResume = !!result.claudeSessionId && state.retryNumber === 1;
+
+    state.retryLog.push({
+      retryNumber: state.retryNumber,
+      path: 'SignalCrash',
+      reason: `Process killed (${signalInfo}), ${completedCount} tools preserved, ${useResume ? 'resuming' : 'fresh start'}`,
+      timestamp: Date.now(),
+    });
+
+    this.emit('onAutoRetry', {
+      retryNumber: state.retryNumber,
+      maxRetries,
+      toolName: `SignalCrash(${signalInfo})`,
+      completedCount,
+    });
+
+    trackEvent(AnalyticsEvents.IMPROVISE_AUTO_RETRY, {
+      retry_number: state.retryNumber,
+      hung_tool: `signal_crash:${signalInfo}`,
+      completed_tools: completedCount,
+      resume_attempted: useResume,
+    });
+
+    // If we have a session ID, try resuming first (preserves full context)
+    if (useResume) {
+      this.queueOutput(
+        `\n[[MSTRO_SIGNAL_RECOVERY]] Process killed (${signalInfo}) — resuming session with ${completedCount} preserved results (retry ${state.retryNumber}/${maxRetries}).\n`
+      );
+      this.flushOutputQueue();
+      state.contextRecoverySessionId = result.claudeSessionId;
+      this.claudeSessionId = result.claudeSessionId;
+      state.currentPrompt = this.buildSignalCrashRecoveryPrompt(promptWithAttachments, true);
+    } else {
+      // Fresh start with accumulated results injected
+      this.queueOutput(
+        `\n[[MSTRO_SIGNAL_RECOVERY]] Process killed (${signalInfo}) — restarting with ${completedCount} preserved results (retry ${state.retryNumber}/${maxRetries}).\n`
+      );
+      this.flushOutputQueue();
+      state.freshRecoveryMode = true;
+      const allResults = [...this.extractHistoricalToolResults(), ...state.accumulatedToolResults];
+      state.currentPrompt = this.buildSignalCrashRecoveryPrompt(promptWithAttachments, false, allResults);
+    }
+
+    return true;
+  }
+
+  /** Build a recovery prompt after signal crash */
+  private buildSignalCrashRecoveryPrompt(
+    originalPrompt: string,
+    isResume: boolean,
+    toolResults?: ToolUseRecord[],
+  ): string {
+    const parts: string[] = [];
+
+    if (isResume) {
+      parts.push('Your previous execution was interrupted by a system signal (the process was killed externally).');
+      parts.push('Your full conversation history is preserved — including all successful tool results.');
+      parts.push('');
+      parts.push('Review your conversation history above and continue from where you left off.');
+    } else {
+      parts.push('## AUTOMATIC RETRY — Previous Execution Interrupted');
+      parts.push('');
+      parts.push('The previous execution was interrupted by a system signal (process killed).');
+      if (toolResults && toolResults.length > 0) {
+        parts.push(`${toolResults.length} tool results were preserved from prior work.`);
+        parts.push('');
+        parts.push('### Preserved results:');
+        for (const t of toolResults.slice(-20)) {
+          const inputSummary = JSON.stringify(t.toolInput).slice(0, 120);
+          const resultPreview = (t.result ?? '').slice(0, 200);
+          parts.push(`- **${t.toolName}**(${inputSummary}): ${resultPreview}`);
+        }
+      }
+    }
+
+    parts.push('');
+    parts.push('### Original task:');
+    parts.push(originalPrompt);
+    parts.push('');
+    parts.push('INSTRUCTIONS:');
+    parts.push('1. Use the results above -- do not re-fetch content you already have');
+    parts.push('2. Continue from where you left off');
+    parts.push('3. Prefer multiple small, focused tool calls over single large ones');
+    parts.push('4. Do NOT spawn Task subagents — do work inline to avoid further interruptions');
+
+    return parts.join('\n');
+  }
+
   /** Select the best result across retries using Haiku assessment */
   private async selectBestResult(
     state: RetryLoopState,
@@ -798,6 +1034,7 @@ export class ImprovisationSessionManager extends EventEmitter {
     userPrompt: string,
     sequenceNumber: number,
     execStart: number,
+    retryLog?: RetryLogEntry[],
   ): MovementRecord {
     return {
       id: `prompt-${sequenceNumber}`,
@@ -819,6 +1056,7 @@ export class ImprovisationSessionManager extends EventEmitter {
       })),
       errorOutput: result.error,
       durationMs: Date.now() - execStart,
+      retryLog: retryLog && retryLog.length > 0 ? retryLog : undefined,
     };
   }
 
@@ -1023,7 +1261,11 @@ export class ImprovisationSessionManager extends EventEmitter {
    * Injects all accumulated tool results from previous attempts so Claude can continue
    * the task without re-fetching data it already gathered.
    */
-  private buildFreshRecoveryPrompt(originalPrompt: string, toolResults: ToolUseRecord[]): string {
+  private buildFreshRecoveryPrompt(
+    originalPrompt: string,
+    toolResults: ToolUseRecord[],
+    timedOutTools?: Array<{ toolName: string; input: Record<string, unknown>; timeoutMs: number }>,
+  ): string {
     const parts: string[] = [
       '## CONTINUING LONG-RUNNING TASK',
       '',
@@ -1032,6 +1274,10 @@ export class ImprovisationSessionManager extends EventEmitter {
       '',
     ];
 
+    if (timedOutTools && timedOutTools.length > 0) {
+      parts.push(...this.formatTimedOutTools(timedOutTools), '');
+    }
+
     parts.push(...this.formatToolResults(toolResults));
 
     parts.push('### Original task:');
@@ -1225,6 +1471,7 @@ export class ImprovisationSessionManager extends EventEmitter {
    * Cancel current execution
    */
   cancel(): void {
+    this._cancelled = true;
     if (this.currentRunner) {
       this.currentRunner.cleanup();
       this.currentRunner = null;

package/server/index.ts

@@ -290,10 +290,6 @@ async function startServer() {
 
   const PORT = await findAvailablePort(REQUESTED_PORT, 20)
 
-  if (PORT !== REQUESTED_PORT) {
-    console.log(`⚠️  Port ${REQUESTED_PORT} in use, using port ${PORT}`)
-  }
-
   _currentInstance = instanceRegistry.register(PORT, WORKING_DIR)
 
   // Create HTTP server with Hono