mstro-app 0.3.8 → 0.4.0

package/server/cli/headless/stall-assessor.ts

@@ -17,6 +17,7 @@
  */
 
 import { type ChildProcess, spawn } from 'node:child_process';
+import { hlog } from './headless-logger.js';
 
 export interface StallContext {
   /** The original user prompt being executed */
@@ -48,6 +49,35 @@ export interface StallVerdict {
   reason: string;
 }
 
+/** Check if Task/Agent subagents are currently pending (producing expected silence) */
+function hasSubagentPending(pendingNames: Set<string>, lastToolName: string | undefined, hasPendingTools: boolean): boolean {
+  return pendingNames.has('Task') || pendingNames.has('Agent')
+    || ((lastToolName === 'Task' || lastToolName === 'Agent') && hasPendingTools);
+}
+
+/**
+ * Check if an Agent Teams lead is idle-waiting for teammate notifications.
+ * After spawning teammates (Agent tool calls complete), the lead has no pending
+ * tools but is legitimately waiting for teammate idle events.
+ */
+function checkAgentTeamsWaiting(ctx: StallContext, hasPendingTools: boolean): StallVerdict | null {
+  // The lead may use any tool while waiting (Glob to verify outputs, Bash to
+  // check disk, ToolSearch, etc.), so don't gate on lastToolName. The key
+  // signal is: prompt contains team_name, tools were called, nothing pending.
+  if (
+    !hasPendingTools &&
+    ctx.totalToolCalls > 0 &&
+    ctx.originalPrompt.includes('team_name')
+  ) {
+    return {
+      action: 'extend',
+      extensionMs: 30 * 60_000,
+      reason: 'Agent Teams lead waiting for teammate idle notifications — extending 30 min',
+    };
+  }
+  return null;
+}
+
 /**
  * Fast heuristic for known long-running patterns.
  * Returns a verdict immediately if the pattern is recognized, null otherwise.
@@ -86,11 +116,7 @@ function quickHeuristic(ctx: StallContext, toolWatchdogActive = false): StallVer
 
   // Task/subagent launches are known to produce long silence periods.
   // The parent Claude process emits nothing while waiting for subagent results.
-  // Check pendingToolNames (reliable) first, fall back to lastToolName (legacy).
-  // Claude Code renamed Task → Agent; check both for backward compatibility
-  const hasTaskPending = pendingNames.has('Task') || pendingNames.has('Agent')
-    || ((ctx.lastToolName === 'Task' || ctx.lastToolName === 'Agent') && hasPendingTools);
-  if (hasTaskPending) {
+  if (hasSubagentPending(pendingNames, ctx.lastToolName, hasPendingTools)) {
     const extensionMin = Math.min(30, 10 + ctx.pendingToolCount * 5);
     return {
       action: 'extend',
@@ -99,6 +125,10 @@ function quickHeuristic(ctx: StallContext, toolWatchdogActive = false): StallVer
     };
   }
 
+  // Agent Teams lead waiting for teammate idle notifications (extracted for complexity)
+  const agentTeamsVerdict = checkAgentTeamsWaiting(ctx, hasPendingTools);
+  if (agentTeamsVerdict) return agentTeamsVerdict;
+
   // Multiple parallel tool calls (e.g., parallel Bash, parallel Read/Grep)
   if (ctx.pendingToolCount >= 3) {
     return {
@@ -137,7 +167,7 @@ export async function assessStall(
   const quick = quickHeuristic(ctx, toolWatchdogActive);
   if (quick) {
     if (verbose) {
-      console.log(`[STALL-ASSESS] Heuristic verdict: ${quick.reason}`);
+      hlog(`[STALL-ASSESS] Heuristic verdict: ${quick.reason}`);
     }
     return quick;
   }
@@ -145,12 +175,12 @@ export async function assessStall(
   // Layer 2: Haiku assessment
   try {
     if (verbose) {
-      console.log('[STALL-ASSESS] Running Haiku assessment...');
+      hlog('[STALL-ASSESS] Running Haiku assessment...');
     }
     return await runHaikuAssessment(ctx, claudeCommand, verbose);
   } catch (err) {
     if (verbose) {
-      console.log(`[STALL-ASSESS] Haiku assessment failed: ${err}`);
+      hlog(`[STALL-ASSESS] Haiku assessment failed: ${err}`);
     }
     // If Haiku fails (timeout, auth issue, etc.), extend cautiously
     return {
@@ -220,13 +250,13 @@ export async function assessToolTimeout(
 
   try {
     if (verbose) {
-      console.log(`[TOOL-ASSESS] Running Haiku assessment for ${toolName} (${elapsedSec}s elapsed)...`);
+      hlog(`[TOOL-ASSESS] Running Haiku assessment for ${toolName} (${elapsedSec}s elapsed)...`);
     }
 
     return await spawnHaikuVerdict(prompt, claudeCommand, verbose, 'TOOL-ASSESS');
   } catch (err) {
     if (verbose) {
-      console.log(`[TOOL-ASSESS] Haiku assessment failed: ${err}`);
+      hlog(`[TOOL-ASSESS] Haiku assessment failed: ${err}`);
     }
     // On failure, default to kill (the tool has already exceeded its timeout)
     return {
@@ -295,7 +325,7 @@ export async function assessContextLoss(
 
   try {
     if (verbose) {
-      console.log(`[CONTEXT-ASSESS] Running Haiku assessment (${ctx.effectiveTimeouts} timeouts, ${ctx.successfulToolCalls} successes, ${ctx.thinkingOutputLength} thinking chars)...`);
+      hlog(`[CONTEXT-ASSESS] Running Haiku assessment (${ctx.effectiveTimeouts} timeouts, ${ctx.successfulToolCalls} successes, ${ctx.thinkingOutputLength} thinking chars)...`);
     }
 
     const raw = await spawnHaikuRaw(prompt, claudeCommand, verbose, 'CONTEXT-ASSESS');
@@ -303,13 +333,13 @@ export async function assessContextLoss(
     const contextLost = parsed.verdict === 'STALLED';
 
     if (verbose) {
-      console.log(`[CONTEXT-ASSESS] Verdict: ${contextLost ? 'LOST' : 'CONTINUED'} — ${parsed.reason}`);
+      hlog(`[CONTEXT-ASSESS] Verdict: ${contextLost ? 'LOST' : 'CONTINUED'} — ${parsed.reason}`);
     }
 
     return { contextLost, reason: parsed.reason };
   } catch (err) {
     if (verbose) {
-      console.log(`[CONTEXT-ASSESS] Haiku assessment failed: ${err}`);
+      hlog(`[CONTEXT-ASSESS] Haiku assessment failed: ${err}`);
     }
     // On failure, assume context was lost (safer to retry than to show a confused response)
     return {
@@ -419,7 +449,7 @@ function spawnHaikuRaw(
 
     proc.stderr!.on('data', (data) => {
       if (verbose) {
-        console.log(`[${label}] haiku stderr: ${data.toString().trim()}`);
+        hlog(`[${label}] haiku stderr: ${data.toString().trim()}`);
       }
     });
 
@@ -434,7 +464,7 @@ function spawnHaikuRaw(
       }
 
       if (verbose) {
-        console.log(`[${label}] Haiku response: ${stdout.trim()}`);
+        hlog(`[${label}] Haiku response: ${stdout.trim()}`);
       }
 
       resolve(stdout.trim());
@@ -521,7 +551,7 @@ export async function assessApproval(
 
   try {
     if (verbose) {
-      console.log('[APPROVAL-ASSESS] Running Haiku assessment...');
+      hlog('[APPROVAL-ASSESS] Running Haiku assessment...');
     }
 
     const raw = await spawnHaikuRaw(prompt, claudeCommand, verbose, 'APPROVAL-ASSESS');
@@ -529,19 +559,96 @@ export async function assessApproval(
     const isApproval = parsed.verdict.includes('APPROVAL');
 
     if (verbose) {
-      console.log(`[APPROVAL-ASSESS] Verdict: ${isApproval ? 'APPROVAL' : 'NEW_TASK'} — ${parsed.reason}`);
+      hlog(`[APPROVAL-ASSESS] Verdict: ${isApproval ? 'APPROVAL' : 'NEW_TASK'} — ${parsed.reason}`);
     }
 
     return { isApproval, reason: parsed.reason };
   } catch (err) {
     if (verbose) {
-      console.log(`[APPROVAL-ASSESS] Haiku assessment failed: ${err}`);
+      hlog(`[APPROVAL-ASSESS] Haiku assessment failed: ${err}`);
     }
     // On failure, assume not an approval (safer to treat as new task)
     return { isApproval: false, reason: `Assessment failed: ${err}` };
   }
 }
 
+// ========== Premature Completion Assessment ==========
+
+export interface PrematureCompletionContext {
+  /** The trailing portion of the assistant response (last ~800 chars) */
+  responseTail: string;
+  /** Total number of successful tool calls in this execution */
+  successfulToolCalls: number;
+  /** Whether extended thinking output was produced */
+  hasThinking: boolean;
+  /** Total response length */
+  responseLength: number;
+}
+
+export interface PrematureCompletionVerdict {
+  /** True if the task appears incomplete and should be auto-continued */
+  isIncomplete: boolean;
+  reason: string;
+}
+
+/**
+ * Assess whether a completed Claude execution ended prematurely.
+ * Called when stop_reason is 'end_turn' but the task may not be finished.
+ * Haiku determines if the trailing response text indicates planned-but-unexecuted work.
+ */
+export async function assessPrematureCompletion(
+  ctx: PrematureCompletionContext,
+  claudeCommand: string,
+  verbose: boolean,
+): Promise<PrematureCompletionVerdict> {
+  const prompt = [
+    'You are analyzing the FINAL output of a Claude Code agent that just exited normally.',
+    'Determine whether the agent finished its task or stopped prematurely mid-work.',
+    '',
+    'Session signals:',
+    `- ${ctx.successfulToolCalls} tool calls completed successfully`,
+    `- Response length: ${ctx.responseLength} characters`,
+    `- Extended thinking: ${ctx.hasThinking ? 'YES' : 'NO'}`,
+    '',
+    `Final response text (last ${ctx.responseTail.length} chars):`,
+    ctx.responseTail,
+    '',
+    'INCOMPLETE signals: "Now I\'ll...", "Let me fix...", "Next I\'ll...", "Moving on to...",',
+    '"I\'ll continue with...", announcing next steps that were never executed,',
+    'describing work that will happen next but no tool call followed.',
+    '',
+    'COMPLETE signals: summarizing what was done, confirming changes, reporting results,',
+    'asking the user a question, past-tense descriptions of completed work,',
+    '"all done", "changes applied", referencing finished state.',
+    '',
+    'Respond in EXACTLY this format (2 lines, no extra text):',
+    'VERDICT: COMPLETE or INCOMPLETE',
+    'REASON: <brief one-line explanation>',
+  ].join('\n');
+
+  try {
+    if (verbose) {
+      hlog(`[PREMATURE-ASSESS] Running Haiku assessment (${ctx.successfulToolCalls} tools, ${ctx.responseLength} chars)...`);
+    }
+
+    const raw = await spawnHaikuRaw(prompt, claudeCommand, verbose, 'PREMATURE-ASSESS');
+    const parsed = parseVerdictResponse(raw);
+    const isIncomplete = parsed.verdict.includes('INCOMPLETE');
+
+    if (verbose) {
+      hlog(`[PREMATURE-ASSESS] Verdict: ${isIncomplete ? 'INCOMPLETE' : 'COMPLETE'} — ${parsed.reason}`);
+    }
+
+    return { isIncomplete, reason: parsed.reason };
+  } catch (err) {
+    if (verbose) {
+      hlog(`[PREMATURE-ASSESS] Haiku assessment failed: ${err}`);
+    }
+    // On failure, don't retry — safer to let the user decide than to auto-continue incorrectly
+    return { isIncomplete: false, reason: `Assessment failed: ${err}` };
+  }
+}
+
 // ========== Best Result Comparison ==========
 
 export interface BestResultContext {
@@ -602,7 +709,7 @@ export async function assessBestResult(
 
   try {
     if (verbose) {
-      console.log('[BEST-RESULT] Running Haiku assessment...');
+      hlog('[BEST-RESULT] Running Haiku assessment...');
     }
 
     const raw = await spawnHaikuRaw(prompt, claudeCommand, verbose, 'BEST-RESULT');
@@ -610,13 +717,13 @@ export async function assessBestResult(
     const winner: 'A' | 'B' = parsed.verdict.includes('B') ? 'B' : 'A';
 
     if (verbose) {
-      console.log(`[BEST-RESULT] Verdict: ${winner} — ${parsed.reason}`);
+      hlog(`[BEST-RESULT] Verdict: ${winner} — ${parsed.reason}`);
     }
 
     return { winner, reason: parsed.reason };
   } catch (err) {
     if (verbose) {
-      console.log(`[BEST-RESULT] Haiku assessment failed: ${err}`);
+      hlog(`[BEST-RESULT] Haiku assessment failed: ${err}`);
     }
     // On failure, prefer A (the previously-tracked best result)
     return { winner: 'A', reason: `Assessment failed: ${err}` };
@@ -671,7 +778,7 @@ export async function classifyError(
 
   try {
     if (verbose) {
-      console.log('[ERROR-CLASSIFY] Running Haiku assessment...');
+      hlog('[ERROR-CLASSIFY] Running Haiku assessment...');
     }
 
     const raw = await spawnHaikuRaw(prompt, claudeCommand, verbose, 'ERROR-CLASSIFY');
@@ -691,13 +798,13 @@ export async function classifyError(
     if (category === 'UNKNOWN' || !message) return null;
 
     if (verbose) {
-      console.log(`[ERROR-CLASSIFY] Verdict: ${category} — ${message}`);
+      hlog(`[ERROR-CLASSIFY] Verdict: ${category} — ${message}`);
     }
 
     return { errorCode: category, message };
   } catch (err) {
     if (verbose) {
-      console.log(`[ERROR-CLASSIFY] Haiku assessment failed: ${err}`);
+      hlog(`[ERROR-CLASSIFY] Haiku assessment failed: ${err}`);
     }
     return null;
   }

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

@@ -14,6 +14,7 @@
  * 3. Haiku tiebreaker: optional AI assessment before killing ambiguous cases
  */
 
+import { hlog } from './headless-logger.js';
 import type {
   ExecutionCheckpoint,
   ToolDurationTracker,
@@ -167,7 +168,7 @@ export class ToolWatchdog {
         sampleCount: 1,
       });
       if (this.verbose) {
-        console.log(`[WATCHDOG] ${toolName}: first sample ${durationMs}ms, initial timeout ${this.getTimeout(toolName)}ms`);
+        hlog(`[WATCHDOG] ${toolName}: first sample ${durationMs}ms, initial timeout ${this.getTimeout(toolName)}ms`);
       }
       return;
     }
@@ -178,7 +179,7 @@ export class ToolWatchdog {
     tracker.sampleCount++;
 
     if (this.verbose) {
-      console.log(`[WATCHDOG] ${toolName}: sample #${tracker.sampleCount} ${durationMs}ms, est=${Math.round(tracker.estimatedDuration)}ms, dev=${Math.round(tracker.deviation)}ms, timeout=${this.getTimeout(toolName)}ms`);
+      hlog(`[WATCHDOG] ${toolName}: sample #${tracker.sampleCount} ${durationMs}ms, est=${Math.round(tracker.estimatedDuration)}ms, dev=${Math.round(tracker.deviation)}ms, timeout=${this.getTimeout(toolName)}ms`);
     }
   }
 
@@ -208,7 +209,7 @@ export class ToolWatchdog {
     const profile = this.getProfile(toolName);
 
     if (this.verbose) {
-      console.log(`[WATCHDOG] Starting watch: ${toolName} (${toolId}), timeout=${Math.round(timeoutMs / 1000)}s`);
+      hlog(`[WATCHDOG] Starting watch: ${toolName} (${toolId}), timeout=${Math.round(timeoutMs / 1000)}s`);
     }
 
     const timer = setTimeout(async () => {
@@ -245,7 +246,7 @@ export class ToolWatchdog {
 
     if (!profile.useHaikuTiebreaker || !this.onTiebreaker || watch.tiebreakerAttempted) {
       if (this.verbose) {
-        console.log(`[WATCHDOG] ${toolName} (${toolId}) timed out after ${Math.round(elapsedMs / 1000)}s, killing`);
+        hlog(`[WATCHDOG] ${toolName} (${toolId}) timed out after ${Math.round(elapsedMs / 1000)}s, killing`);
       }
       return false;
     }
@@ -265,7 +266,7 @@ export class ToolWatchdog {
     watch.tiebreakerAttempted = true;
 
     if (this.verbose) {
-      console.log(`[WATCHDOG] ${toolName} (${toolId}) hit timeout after ${Math.round(elapsedMs / 1000)}s, running tiebreaker...`);
+      hlog(`[WATCHDOG] ${toolName} (${toolId}) hit timeout after ${Math.round(elapsedMs / 1000)}s, running tiebreaker...`);
     }
 
     try {
@@ -274,7 +275,7 @@ export class ToolWatchdog {
 
       if (verdict.action === 'extend') {
         if (this.verbose) {
-          console.log(`[WATCHDOG] Tiebreaker: extend ${toolName} by ${Math.round(verdict.extensionMs / 1000)}s — ${verdict.reason}`);
+          hlog(`[WATCHDOG] Tiebreaker: extend ${toolName} by ${Math.round(verdict.extensionMs / 1000)}s — ${verdict.reason}`);
         }
         this.scheduleExtensionTimeout(watch, toolId, toolName, verdict.extensionMs, onTimeout);
         watch.timeoutMs = elapsedMs + verdict.extensionMs;
@@ -282,11 +283,11 @@ export class ToolWatchdog {
       }
 
       if (this.verbose) {
-        console.log(`[WATCHDOG] Tiebreaker: kill ${toolName} — ${verdict.reason}`);
+        hlog(`[WATCHDOG] Tiebreaker: kill ${toolName} — ${verdict.reason}`);
       }
     } catch (err) {
       if (this.verbose) {
-        console.log(`[WATCHDOG] Tiebreaker failed: ${err}, proceeding with kill`);
+        hlog(`[WATCHDOG] Tiebreaker failed: ${err}, proceeding with kill`);
       }
     }
 
@@ -305,7 +306,7 @@ export class ToolWatchdog {
       const w = this.activeWatches.get(toolId);
       if (!w) return;
       if (this.verbose) {
-        console.log(`[WATCHDOG] ${toolName} (${toolId}) still running after extension, killing`);
+        hlog(`[WATCHDOG] ${toolName} (${toolId}) still running after extension, killing`);
       }
       // Don't delete the watch — buildCheckpoint() needs it.
       // handleToolTimeout() calls clearAll() after building the checkpoint.

package/server/cli/headless/types.ts

@@ -121,6 +121,8 @@ export interface HeadlessConfig {
   onToolTimeout?: (checkpoint: ExecutionCheckpoint) => void;
   /** When true, spawn Claude with sanitized env (strips secrets, HOME=workingDir) */
   sandboxed?: boolean;
+  /** Extra environment variables to merge into the spawned Claude process env */
+  extraEnv?: Record<string, string>;
 }
 
 export interface SessionState {
@@ -165,6 +167,8 @@ export interface SessionResult {
   /** 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;
+  /** Claude Code result event stop_reason: 'end_turn', 'max_tokens', or undefined if not captured */
+  stopReason?: string;
 }
 
 export interface ToolUseAccumulator {
@@ -200,10 +204,12 @@ export interface ExecutionResult {
   resumeBufferedOutput?: string;
   /** Actual API token usage from Claude Code stream events (summed across all turns) */
   apiTokenUsage?: { inputTokens: number; outputTokens: number };
+  /** Claude Code result event stop_reason: 'end_turn', 'max_tokens', or undefined if not captured */
+  stopReason?: string;
 }
 
 /** Resolved config with all defaults applied */
-export type ResolvedHeadlessConfig = Omit<Required<HeadlessConfig>, 'outputCallback' | 'thinkingCallback' | 'toolUseCallback' | 'tokenUsageCallback' | 'continueSession' | 'claudeSessionId' | 'imageAttachments' | 'model' | 'toolTimeoutProfiles' | 'onToolTimeout' | 'sandboxed'> & {
+export type ResolvedHeadlessConfig = Omit<Required<HeadlessConfig>, 'outputCallback' | 'thinkingCallback' | 'toolUseCallback' | 'tokenUsageCallback' | 'continueSession' | 'claudeSessionId' | 'imageAttachments' | 'model' | 'toolTimeoutProfiles' | 'onToolTimeout' | 'sandboxed' | 'extraEnv'> & {
   outputCallback?: (text: string) => void;
   thinkingCallback?: (text: string) => void;
   toolUseCallback?: (event: ToolUseEvent) => void;
@@ -215,4 +221,7 @@ export type ResolvedHeadlessConfig = Omit<Required<HeadlessConfig>, 'outputCallb
   toolTimeoutProfiles?: Record<string, Partial<ToolTimeoutProfile>>;
   onToolTimeout?: (checkpoint: ExecutionCheckpoint) => void;
   sandboxed?: boolean;
+  extraEnv?: Record<string, string>;
 };
+
+

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

@@ -12,8 +12,9 @@ import { EventEmitter } from 'node:events';
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { AnalyticsEvents, trackEvent } from '../services/analytics.js';
+import { herror, hlog } from './headless/headless-logger.js';
 import { HeadlessRunner } from './headless/index.js';
-import { assessBestResult, assessContextLoss, type ContextLossContext } from './headless/stall-assessor.js';
+import { assessBestResult, assessContextLoss, assessPrematureCompletion, type ContextLossContext } from './headless/stall-assessor.js';
 import type { ExecutionCheckpoint } from './headless/types.js';
 
 export interface ImprovisationOptions {
@@ -302,7 +303,7 @@ export class ImprovisationSessionManager extends EventEmitter {
         writeFileSync(filePath, Buffer.from(attachment.content, 'base64'));
         paths.push(filePath);
       } catch (err) {
-        console.error(`Failed to persist attachment ${attachment.fileName}:`, err);
+        herror(`Failed to persist attachment ${attachment.fileName}:`, err);
       }
     }
 
@@ -503,6 +504,8 @@ export class ImprovisationSessionManager extends EventEmitter {
       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;
+      // Premature completion: model exited normally but task appears incomplete
+      if (await this.shouldRetryPrematureCompletion(result, state, maxRetries)) continue;
       break;
     }
     return result;
@@ -522,7 +525,7 @@ export class ImprovisationSessionManager extends EventEmitter {
         try {
           attachment.content = readFileSync(attachment.filePath).toString('base64');
         } catch (err) {
-          console.error(`Failed to read pre-uploaded image ${attachment.filePath}:`, err);
+          herror(`Failed to read pre-uploaded image ${attachment.filePath}:`, err);
           attachment.isImage = false;
         }
       }
@@ -662,17 +665,17 @@ export class ImprovisationSessionManager extends EventEmitter {
     }
     if (!result.assistantResponse || result.assistantResponse.trim().length === 0) {
       state.contextLost = true;
-      if (this.options.verbose) console.log('[CONTEXT-RECOVERY] Resume context loss: null/empty response');
+      if (this.options.verbose) hlog('[CONTEXT-RECOVERY] Resume context loss: null/empty response');
     } else if (result.resumeBufferedOutput !== undefined) {
       state.contextLost = true;
-      if (this.options.verbose) console.log('[CONTEXT-RECOVERY] Resume context loss: buffer never flushed (no thinking/tools)');
+      if (this.options.verbose) hlog('[CONTEXT-RECOVERY] Resume context loss: buffer never flushed (no thinking/tools)');
     } else if (
       (!result.toolUseHistory || result.toolUseHistory.length === 0) &&
       !result.thinkingOutput &&
       result.assistantResponse.length < 500
     ) {
       state.contextLost = true;
-      if (this.options.verbose) console.log('[CONTEXT-RECOVERY] Resume context loss: no tools, no thinking, short response');
+      if (this.options.verbose) hlog('[CONTEXT-RECOVERY] Resume context loss: no tools, no thinking, short response');
     }
   }
 
@@ -716,7 +719,7 @@ export class ImprovisationSessionManager extends EventEmitter {
     const verdict = await assessContextLoss(contextLossCtx, claudeCmd, this.options.verbose);
     state.contextLost = verdict.contextLost;
     if (this.options.verbose) {
-      console.log(`[CONTEXT-RECOVERY] Haiku verdict: ${state.contextLost ? 'LOST' : 'OK'} — ${verdict.reason}`);
+      hlog(`[CONTEXT-RECOVERY] Haiku verdict: ${state.contextLost ? 'LOST' : 'OK'} — ${verdict.reason}`);
     }
   }
 
@@ -1015,6 +1018,110 @@ export class ImprovisationSessionManager extends EventEmitter {
     return parts.join('\n');
   }
 
+  /**
+   * Detect premature completion: Claude exited normally (exit code 0, end_turn) but the
+   * response indicates more work was planned. This happens when the model "context-fatigues"
+   * during long multi-step tasks and produces end_turn after completing a subset of the work.
+   *
+   * Two paths:
+   * - max_tokens: always retry (model was forcibly stopped mid-generation)
+   * - end_turn: Haiku assessment determines if the response looks incomplete
+   */
+  private async shouldRetryPrematureCompletion(
+    result: HeadlessRunResult,
+    state: RetryLoopState,
+    maxRetries: number,
+  ): Promise<boolean> {
+    if (!this.isPrematureCompletionCandidate(result, state, maxRetries)) {
+      return false;
+    }
+
+    const stopReason = result.stopReason!;
+    const isMaxTokens = stopReason === 'max_tokens';
+    const isIncomplete = isMaxTokens || await this.assessEndTurnCompletion(result);
+
+    if (!isIncomplete) return false;
+
+    this.applyPrematureCompletionRetry(result, state, maxRetries, stopReason, isMaxTokens);
+    return true;
+  }
+
+  /** Guard checks for premature completion — must pass all to proceed with assessment */
+  private isPrematureCompletionCandidate(
+    result: HeadlessRunResult,
+    state: RetryLoopState,
+    maxRetries: number,
+  ): boolean {
+    // Only trigger for clean exits with a known stop reason
+    if (!result.completed || result.signalName || state.retryNumber >= maxRetries) return false;
+    // Don't re-trigger if other recovery paths already handled this iteration
+    if (state.checkpointRef.value || state.contextLost) return false;
+    // Must have a session ID to resume, and a stop reason to classify
+    if (!result.claudeSessionId || !result.stopReason) return false;
+    // Only act on max_tokens or end_turn
+    return result.stopReason === 'max_tokens' || result.stopReason === 'end_turn';
+  }
+
+  /** Use Haiku to assess whether an end_turn response is genuinely complete */
+  private async assessEndTurnCompletion(result: HeadlessRunResult): Promise<boolean> {
+    if (!result.assistantResponse) return false;
+
+    const claudeCmd = process.env.CLAUDE_COMMAND || 'claude';
+    const verdict = await assessPrematureCompletion({
+      responseTail: result.assistantResponse.slice(-800),
+      successfulToolCalls: result.toolUseHistory?.filter(t => t.result !== undefined && !t.isError).length ?? 0,
+      hasThinking: !!result.thinkingOutput,
+      responseLength: result.assistantResponse.length,
+    }, claudeCmd, this.options.verbose);
+
+    if (this.options.verbose) {
+      hlog(`[PREMATURE-COMPLETION] Haiku verdict: ${verdict.isIncomplete ? 'INCOMPLETE' : 'COMPLETE'} — ${verdict.reason}`);
+    }
+    return verdict.isIncomplete;
+  }
+
+  /** Apply the retry: emit events, update state, set continuation prompt */
+  private applyPrematureCompletionRetry(
+    result: HeadlessRunResult,
+    state: RetryLoopState,
+    maxRetries: number,
+    stopReason: string,
+    isMaxTokens: boolean,
+  ): void {
+    state.retryNumber++;
+    const reason = isMaxTokens ? 'Output limit reached' : 'Task appears unfinished (AI assessment)';
+
+    state.retryLog.push({
+      retryNumber: state.retryNumber,
+      path: 'PrematureCompletion',
+      reason,
+      timestamp: Date.now(),
+    });
+
+    this.emit('onAutoRetry', {
+      retryNumber: state.retryNumber,
+      maxRetries,
+      toolName: `PrematureCompletion(${stopReason})`,
+      completedCount: result.toolUseHistory?.length ?? 0,
+    });
+
+    trackEvent(AnalyticsEvents.IMPROVISE_AUTO_RETRY, {
+      retry_number: state.retryNumber,
+      hung_tool: `premature_completion:${stopReason}`,
+      completed_tools: result.toolUseHistory?.length ?? 0,
+      resume_attempted: true,
+    });
+
+    this.queueOutput(
+      `\n[[MSTRO_AUTO_CONTINUE]] ${reason} — resuming session (retry ${state.retryNumber}/${maxRetries}).\n`
+    );
+    this.flushOutputQueue();
+
+    state.contextRecoverySessionId = result.claudeSessionId;
+    this.claudeSessionId = result.claudeSessionId;
+    state.currentPrompt = 'continue';
+  }
+
   /** Select the best result across retries using Haiku assessment */
   private async selectBestResult(
     state: RetryLoopState,
@@ -1047,10 +1154,10 @@ export class ImprovisationSessionManager extends EventEmitter {
       }, claudeCmd, this.options.verbose);
 
       if (verdict.winner === 'A') {
-        if (this.options.verbose) console.log(`[BEST-RESULT] Haiku picked earlier attempt: ${verdict.reason}`);
+        if (this.options.verbose) hlog(`[BEST-RESULT] Haiku picked earlier attempt: ${verdict.reason}`);
         return this.mergeResultSessionId(state.bestResult, result.claudeSessionId);
       }
-      if (this.options.verbose) console.log(`[BEST-RESULT] Haiku picked final attempt: ${verdict.reason}`);
+      if (this.options.verbose) hlog(`[BEST-RESULT] Haiku picked final attempt: ${verdict.reason}`);
       return result;
     } catch {
       return this.fallbackBestResult(state.bestResult, result);
@@ -1061,7 +1168,7 @@ export class ImprovisationSessionManager extends EventEmitter {
   private fallbackBestResult(bestResult: HeadlessRunResult, result: HeadlessRunResult): HeadlessRunResult {
     if (scoreRunResult(bestResult) > scoreRunResult(result)) {
       if (this.options.verbose) {
-        console.log(`[BEST-RESULT] Haiku unavailable, numeric fallback: earlier attempt (score ${scoreRunResult(bestResult)} vs ${scoreRunResult(result)})`);
+        hlog(`[BEST-RESULT] Haiku unavailable, numeric fallback: earlier attempt (score ${scoreRunResult(bestResult)} vs ${scoreRunResult(result)})`);
       }
       return this.mergeResultSessionId(bestResult, result.claudeSessionId);
     }
@@ -1497,7 +1604,7 @@ export class ImprovisationSessionManager extends EventEmitter {
         const data = readFileSync(this.historyPath, 'utf-8');
         return JSON.parse(data);
       } catch (error) {
-        console.error('Failed to load history:', error);
+        herror('Failed to load history:', error);
       }
     }