mstro-app 0.4.39 → 0.4.44

package/server/cli/headless/retry-strategies.ts

@@ -0,0 +1,330 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Shared retry strategy functions for headless execution.
+ *
+ * Pure decision functions that evaluate a SessionResult and RetryState,
+ * returning a RetryDecision when a retry should happen or null to skip.
+ * Used by both PM board execution (issue-retry) and Chat view (improvisation-retry).
+ */
+
+import {
+  buildFreshRecoveryPrompt,
+  buildResumeRetryPrompt,
+  buildRetryPrompt,
+  buildSignalCrashRecoveryPrompt,
+} from '../prompt-builders.js';
+import { hlog } from './headless-logger.js';
+import { assessContextLoss, assessPrematureCompletion } from './stall-assessor.js';
+import type { ExecutionCheckpoint, SessionResult } from './types.js';
+
+export interface ToolRecord {
+  toolName: string;
+  toolId: string;
+  toolInput: Record<string, unknown>;
+  result?: string;
+  isError?: boolean;
+  duration?: number;
+}
+
+export interface RetryState {
+  retryNumber: number;
+  maxRetries: number;
+  originalPrompt: string;
+  accumulatedToolResults: ToolRecord[];
+  timedOutTools: Array<{ toolName: string; input: Record<string, unknown>; timeoutMs: number }>;
+  checkpoint: ExecutionCheckpoint | null;
+  bestResult: SessionResult | null;
+}
+
+export interface RetryDecision {
+  nextPrompt: string;
+  useResume: boolean;
+  resumeSessionId?: string;
+  path: string;
+  reason: string;
+}
+
+export interface RetryConfig {
+  enableContextLossDetection: boolean;
+  enableBestResultSelection: boolean;
+  verbose: boolean;
+}
+
+const MAX_ACCUMULATED_RESULTS = 50;
+
+export function createRetryState(originalPrompt: string, maxRetries: number): RetryState {
+  return {
+    retryNumber: 0,
+    maxRetries,
+    originalPrompt,
+    accumulatedToolResults: [],
+    timedOutTools: [],
+    checkpoint: null,
+    bestResult: null,
+  };
+}
+
+export function accumulateToolResults(result: SessionResult, state: RetryState): void {
+  if (!result.toolUseHistory) return;
+  for (const t of result.toolUseHistory) {
+    if (t.result !== undefined) {
+      state.accumulatedToolResults.push({
+        toolName: t.toolName,
+        toolId: t.toolId,
+        toolInput: t.toolInput,
+        result: t.result,
+        isError: t.isError,
+        duration: t.duration,
+      });
+    }
+  }
+  if (state.accumulatedToolResults.length > MAX_ACCUMULATED_RESULTS) {
+    state.accumulatedToolResults = state.accumulatedToolResults.slice(-MAX_ACCUMULATED_RESULTS);
+  }
+}
+
+export function scoreResult(r: SessionResult): number {
+  const toolCount = r.toolUseHistory?.filter(t => t.result !== undefined && !t.isError).length ?? 0;
+  const responseLen = Math.min((r.assistantResponse?.length ?? 0) / 50, 100);
+  const hasThinking = r.thinkingOutput ? 20 : 0;
+  return toolCount * 10 + responseLen + hasThinking;
+}
+
+export function isResponseAbandoned(result: SessionResult): boolean {
+  const thinkingLen = result.thinkingOutput?.length ?? 0;
+  const responseLen = result.assistantResponse?.length ?? 0;
+  const toolCallsInResponse = result.toolUseHistory?.filter(t => t.result !== undefined).length ?? 0;
+
+  if (thinkingLen < 500 || responseLen > 1000) return false;
+  if (toolCallsInResponse > 0 && responseLen > 200) return false;
+
+  return thinkingLen >= responseLen * 3;
+}
+
+export function extractFinalTextBlock(response: string, maxLen: number): string {
+  const lastBreak = response.lastIndexOf('\n\n');
+  if (lastBreak !== -1 && response.length - lastBreak > 20) {
+    return response.slice(lastBreak + 2).slice(-maxLen);
+  }
+  return response.slice(-maxLen);
+}
+
+export function tryToolTimeout(_result: SessionResult, state: RetryState): RetryDecision | null {
+  if (!state.checkpoint || state.retryNumber >= state.maxRetries) return null;
+
+  const cp = state.checkpoint;
+  state.retryNumber++;
+
+  state.timedOutTools.push({
+    toolName: cp.hungTool.toolName,
+    input: cp.hungTool.input ?? {},
+    timeoutMs: cp.hungTool.timeoutMs,
+  });
+
+  const canResume = cp.inProgressTools.length === 0 && !!cp.claudeSessionId;
+  const reason = `${cp.hungTool.toolName} timed out after ${Math.round(cp.hungTool.timeoutMs / 1000)}s, ${cp.completedTools.length} tools completed, ${canResume ? 'resuming' : 'fresh start'}`;
+
+  hlog(`[RETRY] Tool timeout: ${reason} (retry ${state.retryNumber}/${state.maxRetries})`);
+
+  if (canResume) {
+    return {
+      nextPrompt: buildResumeRetryPrompt(cp, state.timedOutTools),
+      useResume: true,
+      resumeSessionId: cp.claudeSessionId,
+      path: 'ToolTimeout',
+      reason,
+    };
+  }
+
+  return {
+    nextPrompt: buildRetryPrompt(cp, state.originalPrompt, state.timedOutTools),
+    useResume: false,
+    path: 'ToolTimeout',
+    reason,
+  };
+}
+
+export function trySignalCrash(result: SessionResult, state: RetryState): RetryDecision | null {
+  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) return null;
+  if (state.retryNumber >= state.maxRetries) return null;
+  if (state.checkpoint) return null;
+
+  accumulateToolResults(result, state);
+  state.retryNumber++;
+
+  const signalInfo = result.signalName || 'unknown signal';
+  const useResume = !!result.claudeSessionId && state.retryNumber === 1;
+  const reason = `Process killed (${signalInfo}), ${state.accumulatedToolResults.length} tools preserved, ${useResume ? 'resuming' : 'fresh start'}`;
+
+  hlog(`[RETRY] Signal crash: ${reason} (retry ${state.retryNumber}/${state.maxRetries})`);
+
+  if (useResume) {
+    return {
+      nextPrompt: buildSignalCrashRecoveryPrompt(state.originalPrompt, true),
+      useResume: true,
+      resumeSessionId: result.claudeSessionId,
+      path: 'SignalCrash',
+      reason,
+    };
+  }
+
+  return {
+    nextPrompt: buildSignalCrashRecoveryPrompt(state.originalPrompt, false, state.accumulatedToolResults),
+    useResume: false,
+    path: 'SignalCrash',
+    reason,
+  };
+}
+
+function detectContextLossHeuristic(result: SessionResult, verbose: boolean): boolean {
+  if (!result.assistantResponse || result.assistantResponse.trim().length === 0) {
+    if (verbose) hlog('[RETRY] Context loss heuristic: null/empty response');
+    return true;
+  }
+  if (result.resumeBufferedOutput !== undefined) {
+    if (verbose) hlog('[RETRY] Context loss heuristic: buffer never flushed (no thinking/tools)');
+    return true;
+  }
+  if (
+    (!result.toolUseHistory || result.toolUseHistory.length === 0) &&
+    !result.thinkingOutput &&
+    result.assistantResponse.length < 500
+  ) {
+    if (verbose) hlog('[RETRY] Context loss heuristic: no tools, no thinking, short response');
+    return true;
+  }
+  return false;
+}
+
+function computeEffectiveTimeouts(result: SessionResult): number {
+  const nativeTimeouts = result.nativeTimeoutCount ?? 0;
+  if (nativeTimeouts === 0) return 0;
+
+  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 = Array.from(allIds).filter(id => !succeededIds.has(id)).length;
+  return Math.max(nativeTimeouts, toolsWithoutResult);
+}
+
+async function detectContextLossViaHaiku(
+  result: SessionResult,
+  effectiveTimeouts: number,
+  verbose: boolean,
+): Promise<boolean> {
+  if (effectiveTimeouts === 0 || !result.assistantResponse) return false;
+
+  const writeToolNames = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit']);
+  const claudeCmd = process.env.CLAUDE_COMMAND || 'claude';
+  try {
+    const verdict = await assessContextLoss({
+      assistantResponse: result.assistantResponse,
+      effectiveTimeouts,
+      nativeTimeoutCount: result.nativeTimeoutCount ?? 0,
+      successfulToolCalls: result.toolUseHistory?.filter(t => t.result !== undefined && !t.isError).length ?? 0,
+      thinkingOutputLength: result.thinkingOutput?.length ?? 0,
+      hasSuccessfulWrite: result.toolUseHistory?.some(
+        t => writeToolNames.has(t.toolName) && t.result !== undefined && !t.isError
+      ) ?? false,
+    }, claudeCmd, verbose);
+    if (verbose) hlog(`[RETRY] Haiku context loss verdict: ${verdict.contextLost ? 'LOST' : 'OK'} — ${verdict.reason}`);
+    return verdict.contextLost;
+  } catch {
+    if (verbose) hlog('[RETRY] Haiku context loss assessment failed, assuming OK');
+    return false;
+  }
+}
+
+export async function tryContextLoss(
+  result: SessionResult,
+  state: RetryState,
+  config: RetryConfig,
+): Promise<RetryDecision | null> {
+  if (!config.enableContextLossDetection) return null;
+  if (state.checkpoint || state.retryNumber >= state.maxRetries) return null;
+
+  const heuristicLost = detectContextLossHeuristic(result, config.verbose);
+  const haikuLost = heuristicLost
+    ? false
+    : await detectContextLossViaHaiku(result, computeEffectiveTimeouts(result), config.verbose);
+
+  if (!heuristicLost && !haikuLost) return null;
+
+  accumulateToolResults(result, state);
+  state.retryNumber++;
+
+  const reason = `Context lost, ${state.accumulatedToolResults.length} tools preserved`;
+  hlog(`[RETRY] Context loss: ${reason} (retry ${state.retryNumber}/${state.maxRetries})`);
+
+  return {
+    nextPrompt: buildFreshRecoveryPrompt(state.originalPrompt, state.accumulatedToolResults, state.timedOutTools),
+    useResume: false,
+    path: 'ContextLoss',
+    reason,
+  };
+}
+
+async function isEndTurnIncomplete(result: SessionResult, verbose: boolean): Promise<boolean> {
+  if (isResponseAbandoned(result)) {
+    if (verbose) hlog('[RETRY] Response abandoned heuristic triggered');
+    return true;
+  }
+  if (!result.assistantResponse) return false;
+
+  const claudeCmd = process.env.CLAUDE_COMMAND || 'claude';
+  try {
+    const verdict = await assessPrematureCompletion({
+      responseTail: extractFinalTextBlock(result.assistantResponse, 800),
+      successfulToolCalls: result.toolUseHistory?.filter(t => t.result !== undefined && !t.isError).length ?? 0,
+      hasThinking: !!result.thinkingOutput,
+      responseLength: result.assistantResponse.length,
+    }, claudeCmd, verbose);
+    if (verbose) {
+      hlog(`[RETRY] Premature completion verdict: ${verdict.isIncomplete ? 'INCOMPLETE' : 'COMPLETE'} — ${verdict.reason}`);
+    }
+    return verdict.isIncomplete;
+  } catch {
+    if (verbose) hlog('[RETRY] Premature completion assessment failed, assuming complete');
+    return false;
+  }
+}
+
+function isPrematureCompletionCandidate(result: SessionResult, state: RetryState): boolean {
+  if (!result.completed || result.signalName || !result.stopReason) return false;
+  if (state.retryNumber >= state.maxRetries) return false;
+  if (state.checkpoint) return false;
+  if (!result.claudeSessionId) return false;
+  return result.stopReason === 'max_tokens' || result.stopReason === 'end_turn';
+}
+
+export async function tryPrematureCompletion(
+  result: SessionResult,
+  state: RetryState,
+  config: RetryConfig,
+): Promise<RetryDecision | null> {
+  if (!isPrematureCompletionCandidate(result, state)) return null;
+
+  const isMaxTokens = result.stopReason === 'max_tokens';
+
+  if (!isMaxTokens && !(await isEndTurnIncomplete(result, config.verbose))) return null;
+
+  state.retryNumber++;
+  const reason = isMaxTokens ? 'Output limit reached' : 'Task appears unfinished (AI assessment)';
+
+  hlog(`[RETRY] Premature completion: ${reason}, resuming session (retry ${state.retryNumber}/${state.maxRetries})`);
+
+  return {
+    nextPrompt: 'continue',
+    useResume: true,
+    resumeSessionId: result.claudeSessionId,
+    path: 'PrematureCompletion',
+    reason,
+  };
+}

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

@@ -239,6 +239,11 @@ export async function assessToolTimeout(
     Task: 'spawns a subagent that runs autonomously with its own tools',
     Agent: 'spawns a subagent that runs autonomously with its own tools',
     Bash: 'executes a shell command',
+    Write: 'writes file content that may be very large; content streams token-by-token through stdio before disk write',
+    Edit: 'applies string replacements to a file; streams through stdio protocol',
+    Read: 'reads file contents that may be very large; result streams through stdio protocol',
+    Grep: 'searches file contents with regex; large codebases produce large result streams',
+    Glob: 'finds files by pattern; large directory trees take time to scan',
   };
   const toolDesc = toolDescriptions[toolName] || `executes the ${toolName} tool`;
 

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

@@ -98,10 +98,10 @@ export const DEFAULT_TOOL_TIMEOUT_PROFILES: Record<string, ToolTimeoutProfile> =
     useHaikuTiebreaker: true,
   },
   Write: {
-    coldStartMs: 60_000,       // 1 min
-    floorMs: 30_000,           // 30s minimum
-    ceilingMs: 180_000,        // 3 min ceiling
-    useAdaptive: true,
+    coldStartMs: 300_000,      // 5 min — large docs stream slowly through stdio; model generates content inline
+    floorMs: 120_000,          // 2 min minimum — prevents premature kills on big writes
+    ceilingMs: 600_000,        // 10 min hard cap
+    useAdaptive: false,        // bimodal: 1-line config vs 50KB research doc defeats EMA
     useHaikuTiebreaker: true,
   },
 };
@@ -244,6 +244,22 @@ export class ToolWatchdog {
 
     const elapsedMs = Date.now() - watch.startTime;
 
+    // Activity-gated auto-extension: if data is actively streaming, extend without
+    // consuming the one-shot Haiku tiebreaker. Respects ceiling to prevent runaway.
+    const tokenSilenceMs = this.getTokenSilenceMs?.();
+    if (tokenSilenceMs !== undefined && tokenSilenceMs < 60_000) {
+      const remainingToCeiling = profile.ceilingMs - elapsedMs;
+      if (remainingToCeiling > 0) {
+        const extensionMs = Math.min(5 * 60_000, remainingToCeiling);
+        if (this.verbose) {
+          hlog(`[WATCHDOG] ${toolName} (${toolId}) hit timeout after ${Math.round(elapsedMs / 1000)}s, but stream active ${Math.round(tokenSilenceMs / 1000)}s ago — auto-extending ${Math.round(extensionMs / 1000)}s`);
+        }
+        this.scheduleActivityGatedTimeout(watch, toolId, toolName, toolInput, profile, extensionMs, onTimeout);
+        watch.timeoutMs = elapsedMs + extensionMs;
+        return true;
+      }
+    }
+
     if (!profile.useHaikuTiebreaker || !this.onTiebreaker || watch.tiebreakerAttempted) {
       if (this.verbose) {
         hlog(`[WATCHDOG] ${toolName} (${toolId}) timed out after ${Math.round(elapsedMs / 1000)}s, killing`);
@@ -294,6 +310,26 @@ export class ToolWatchdog {
     return false;
   }
 
+  /** Schedule an activity-gated timeout that re-enters the full timeout handler */
+  private scheduleActivityGatedTimeout(
+    watch: ActiveWatch,
+    toolId: string,
+    toolName: string,
+    toolInput: Record<string, unknown>,
+    profile: ToolTimeoutProfile,
+    extensionMs: number,
+    onTimeout: () => void,
+  ): void {
+    watch.timer = setTimeout(async () => {
+      const w = this.activeWatches.get(toolId);
+      if (!w) return;
+      const extended = await this.handleTimeoutWithTiebreaker(toolId, toolName, toolInput, profile, onTimeout);
+      if (!extended) {
+        onTimeout();
+      }
+    }, extensionMs);
+  }
+
   /** Schedule a post-extension timeout that kills without another tiebreaker */
   private scheduleExtensionTimeout(
     watch: ActiveWatch,

package/server/cli/improvisation-retry.ts

@@ -9,6 +9,7 @@
 import { AnalyticsEvents, trackEvent } from '../services/analytics.js';
 import { hlog } from './headless/headless-logger.js';
 import { HeadlessRunner } from './headless/index.js';
+import { extractFinalTextBlock, isResponseAbandoned } from './headless/retry-strategies.js';
 import { assessBestResult, assessContextLoss, assessPrematureCompletion, type ContextLossContext } from './headless/stall-assessor.js';
 import type { ExecutionCheckpoint } from './headless/types.js';
 import type { FileAttachment, HeadlessRunResult, ImprovisationOptions, MovementRecord, RetryLoopState, SessionHistory } from './improvisation-types.js';
@@ -455,38 +456,6 @@ function isPrematureCompletionCandidate(
   return result.stopReason === 'max_tokens' || result.stopReason === 'end_turn';
 }
 
-/**
- * Fast heuristic: detect response abandonment without a Haiku call.
- * When thinking is significantly longer than the response and the response
- * contains no tool calls, Claude likely planned work it never executed.
- * This pattern occurs after context compaction or heavy parallel tool results.
- */
-function isResponseAbandoned(result: HeadlessRunResult): boolean {
-  const thinkingLen = result.thinkingOutput?.length ?? 0;
-  const responseLen = result.assistantResponse?.length ?? 0;
-  const toolCallsInResponse = result.toolUseHistory?.filter(t => t.result !== undefined).length ?? 0;
-
-  if (thinkingLen < 500 || responseLen > 1000) return false;
-  if (toolCallsInResponse > 0 && responseLen > 200) return false;
-
-  return thinkingLen >= responseLen * 3;
-}
-
-/**
- * Extract the final text block from a concatenated response.
- * The assistantResponse concatenates all text deltas including interleaved
- * progress messages between tool calls. The final paragraph (after the last
- * double-newline break) is the actual conclusion — earlier fragments are
- * progress updates that were already acted on via tool calls.
- */
-function extractFinalTextBlock(response: string, maxLen: number): string {
-  const lastBreak = response.lastIndexOf('\n\n');
-  if (lastBreak !== -1 && response.length - lastBreak > 20) {
-    return response.slice(lastBreak + 2).slice(-maxLen);
-  }
-  return response.slice(-maxLen);
-}
-
 /** Use Haiku to assess whether an end_turn response is genuinely complete */
 async function assessEndTurnCompletion(result: HeadlessRunResult, verbose: boolean): Promise<boolean> {
   if (!result.assistantResponse) return false;

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

@@ -201,7 +201,7 @@ export class ImprovisationSessionManager extends EventEmitter {
 
       let result = await this.runRetryLoop(state, sequenceNumber, promptWithAttachments, imageAttachments, options?.workingDir);
 
-      if (this._cancelled) {
+      if (this._cancelled || this._cancelCompleteEmitted) {
         return this.handleCancelledExecution(result, displayPrompt, sequenceNumber, _execStart);
       }
 
@@ -218,7 +218,9 @@ export class ImprovisationSessionManager extends EventEmitter {
       this._executionStartTimestamp = undefined;
       this.executionEventLog = [];
 
-      this.emitMovementComplete(movement, result, _execStart, sequenceNumber);
+      if (!this._cancelCompleteEmitted) {
+        this.emitMovementComplete(movement, result, _execStart, sequenceNumber);
+      }
       this.maybeAutoContinue(result, userPrompt);
 
       return movement;
@@ -271,9 +273,15 @@ export class ImprovisationSessionManager extends EventEmitter {
     let result: HeadlessRunResult | undefined;
     const callbacks = this.buildRetryCallbacks();
 
+    const RETRY_BACKOFF_MS = [1000, 5000, 30000];
     // eslint-disable-next-line no-constant-condition
     while (true) {
       if (this._cancelled) break;
+      if (state.retryNumber > 0) {
+        const delay = RETRY_BACKOFF_MS[Math.min(state.retryNumber - 1, RETRY_BACKOFF_MS.length - 1)];
+        await new Promise(r => setTimeout(r, delay));
+        if (this._cancelled) break;
+      }
       const iteration = await this.executeRetryIteration(state, callbacks, sequenceNumber, imageAttachments, workingDirOverride);
       result = iteration.result;
       if (this._cancelled) break;
@@ -580,6 +588,8 @@ export class ImprovisationSessionManager extends EventEmitter {
       this.currentRunner = null;
     }
 
+    this.destroyQueueTimer();
+
     if (this._isExecuting && !this._cancelCompleteEmitted) {
       this._cancelCompleteEmitted = true;
       const execStart = this._executionStartTimestamp || Date.now();
@@ -609,11 +619,15 @@ export class ImprovisationSessionManager extends EventEmitter {
     this.flushOutputQueue();
   }
 
-  destroy(): void {
+  private destroyQueueTimer(): void {
     if (this.queueTimer) {
       clearInterval(this.queueTimer);
       this.queueTimer = null;
     }
+  }
+
+  destroy(): void {
+    this.destroyQueueTimer();
     this.flushOutputQueue();
   }
 

package/server/cli/prompt-builders.ts

@@ -22,13 +22,27 @@ export function summarizeToolInput(input: Record<string, unknown>): string {
   return JSON.stringify(input).slice(0, 100);
 }
 
+const NETWORK_TOOLS = new Set(['WebFetch', 'WebSearch']);
+
 /** Format a list of timed-out tools for retry prompts */
 export function formatTimedOutTools(tools: Array<{ toolName: string; input: Record<string, unknown>; timeoutMs: number }>): string[] {
   const lines: string[] = [];
-  lines.push('### Tools/resources that have timed out (DO NOT retry these):');
-  for (const t of tools) {
-    const inputSummary = summarizeToolInput(t.input);
-    lines.push(`- **${t.toolName}**(${inputSummary}) — timed out after ${Math.round(t.timeoutMs / 1000)}s`);
+  const networkTools = tools.filter(t => NETWORK_TOOLS.has(t.toolName));
+  const localTools = tools.filter(t => !NETWORK_TOOLS.has(t.toolName));
+
+  if (networkTools.length > 0) {
+    lines.push('### Network resources that timed out (DO NOT retry these URLs):');
+    for (const t of networkTools) {
+      const inputSummary = summarizeToolInput(t.input);
+      lines.push(`- **${t.toolName}**(${inputSummary}) — timed out after ${Math.round(t.timeoutMs / 1000)}s`);
+    }
+  }
+  if (localTools.length > 0) {
+    lines.push('### Tools that previously timed out (OK to retry with same or smaller content):');
+    for (const t of localTools) {
+      const inputSummary = summarizeToolInput(t.input);
+      lines.push(`- **${t.toolName}**(${inputSummary}) — timed out after ${Math.round(t.timeoutMs / 1000)}s`);
+    }
   }
   return lines;
 }
@@ -211,17 +225,24 @@ export function buildResumeRetryPrompt(
     `Your previous ${checkpoint.hungTool.toolName} call timed out after ${Math.round(checkpoint.hungTool.timeoutMs / 1000)}s${checkpoint.hungTool.url ? ` fetching: ${checkpoint.hungTool.url}` : ''}.`
   );
 
-  if (allTimedOut && allTimedOut.length > 1) {
+  if (allTimedOut && allTimedOut.length > 0) {
+    const networkTools = allTimedOut.filter(t => NETWORK_TOOLS.has(t.toolName));
+    const localTools = allTimedOut.filter(t => !NETWORK_TOOLS.has(t.toolName));
     parts.push('');
-    parts.push('All timed-out tools/resources (DO NOT retry any of these):');
-    for (const t of allTimedOut) {
-      const inputSummary = summarizeToolInput(t.input);
-      parts.push(`- ${t.toolName}(${inputSummary})`);
+    if (networkTools.length > 0) {
+      parts.push('Network resources that timed out (DO NOT retry these URLs):');
+      for (const t of networkTools) {
+        parts.push(`- ${t.toolName}(${summarizeToolInput(t.input)})`);
+      }
+    }
+    if (localTools.length > 0) {
+      parts.push('Tools that previously timed out (OK to retry):');
+      for (const t of localTools) {
+        parts.push(`- ${t.toolName}(${summarizeToolInput(t.input)})`);
+      }
     }
-  } else {
-    parts.push('This URL/resource is unreachable. DO NOT retry the same URL or query.');
   }
-  parts.push('Continue your task — find an alternative source or proceed with the results you already have.');
+  parts.push('Continue your task — find alternative sources for network failures, or proceed with the results you already have.');
 
   return parts.join('\n');
 }

package/server/index.ts

@@ -27,7 +27,6 @@ import {
 import { createPlatformRelayContext, ensureClaudeSettings, setTerminalTitle, wrapWebSocket } from './server-setup.js'
 import { AnalyticsEvents, initAnalytics, shutdownAnalytics, trackEvent } from './services/analytics.js'
 import { AuthService } from './services/auth.js'
-import { createAiBrokerRoutes, setDeployHealthUpdateListener, setDeployUsageReportListener } from './services/deploy/ai-broker.js'
 import { FileService } from './services/files.js'
 import { InstanceRegistry, type MstroInstance } from './services/instances.js'
 import { PlatformConnection } from './services/platform.js'
@@ -82,7 +81,7 @@ app.use('*', cors({
 app.use('*', logger())
 
 const authMiddleware = async (c: Context, next: Next) => {
-  const publicPaths = ['/health', '/api/config', '/api/deploy/ai']
+  const publicPaths = ['/health', '/api/config']
   if (publicPaths.some(path => c.req.path.startsWith(path))) {
     return next()
   }
@@ -105,7 +104,6 @@ app.route('/api/shutdown', createShutdownRoute(instanceRegistry))
 app.route('/api/improvise', createImproviseRoutes(WORKING_DIR))
 app.route('/api/files', createFileRoutes(fileService))
 app.route('/api/notifications', createNotificationRoutes(WORKING_DIR))
-app.route('/api/deploy/ai', createAiBrokerRoutes())
 
 app.post('/api/reload-pty', async (c) => {
   const success = await reloadPty()
@@ -195,12 +193,6 @@ async function startServer() {
       wsHandler.setUsageReporter((report) => {
         platformConnection.send({ type: 'reportUsage', data: report })
       })
-      setDeployUsageReportListener((report) => {
-        platformConnection.send({ type: 'deployUsageReport', data: report })
-      })
-      setDeployHealthUpdateListener((update) => {
-        platformConnection.send({ type: 'deployAiHealthUpdate', data: update })
-      })
     },
     onDisconnected: () => {
       if (platformRelayContext) {

package/server/mcp/bouncer-cli.ts

@@ -29,14 +29,14 @@ function buildOperation(toolName: string, toolInput: Record<string, unknown>): s
 
 async function evaluate(rawInput: string): Promise<{ decision: string; reason: string }> {
   if (!rawInput.trim()) {
-    return { decision: 'allow', reason: 'Empty input' };
+    return { decision: 'deny', reason: 'Empty input — cannot evaluate safety' };
   }
 
   let parsed: { tool_name?: string; toolName?: string; input?: Record<string, unknown>; toolInput?: Record<string, unknown> };
   try {
     parsed = JSON.parse(rawInput);
   } catch {
-    return { decision: 'allow', reason: 'Invalid JSON input' };
+    return { decision: 'deny', reason: 'Invalid JSON input — cannot evaluate safety' };
   }
 
   const toolName = parsed.tool_name || parsed.toolName || 'unknown';
@@ -68,6 +68,7 @@ async function main(): Promise<void> {
   console.log(JSON.stringify(result));
 }
 
-main().catch(() => {
-  console.log(JSON.stringify({ decision: 'allow', reason: 'Bouncer crash' }));
+main().catch((err) => {
+  console.error('[Bouncer] Fatal error:', err);
+  console.log(JSON.stringify({ decision: 'deny', reason: 'Bouncer crash — denying for safety' }));
 });

package/server/mcp/bouncer-haiku.ts

@@ -95,7 +95,7 @@ export async function analyzeWithHaiku(
   return new Promise((resolve, reject) => {
     const userRequest = request.context?.userRequest;
     const userContextBlock = userRequest
-      ? `\nUSER'S ORIGINAL REQUEST (what the user actually asked Claude to do):\n"${userRequest}"\n`
+      ? `\nUSER'S ORIGINAL REQUEST (what the user actually asked Claude to do):\n<user_request>\n${userRequest}\n</user_request>\n`
       : '';
 
     const prompt = loadSkillPrompt('check-injection', {