mstro-app 0.4.51 → 0.5.0

package/server/cli/headless/runner.ts

@@ -13,8 +13,9 @@ import { type ClaudeInvokerOptions, executeClaudeCommand } from './claude-invoke
 import { estimateTokensFromOutput } from './output-utils.js';
 import { enrichPromptWithContext } from './prompt-utils.js';
 import type {
+  ExecutionResult,
   HeadlessConfig,
-  PromptContext, 
+  PromptContext,
   ResolvedHeadlessConfig,
   SessionResult,
 } from './types.js';
@@ -35,6 +36,64 @@ export function killProcessGroup(pid: number, signal: NodeJS.Signals): void {
   }
 }
 
+/** Shared result fields carried over from an ExecutionResult into a SessionResult. */
+function sharedResultFields(result: ExecutionResult) {
+  return {
+    signalName: result.signalName,
+    assistantResponse: result.assistantResponse,
+    thinkingOutput: result.thinkingOutput,
+    toolUseHistory: result.toolUseHistory,
+    claudeSessionId: result.claudeSessionId,
+    nativeTimeoutCount: result.nativeTimeoutCount,
+    postTimeoutOutput: result.postTimeoutOutput,
+    resumeBufferedOutput: result.resumeBufferedOutput,
+    stopReason: result.stopReason,
+  };
+}
+
+/**
+ * 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).
+ */
+function isSignalExitWithOutput(result: ExecutionResult): boolean {
+  if (result.exitCode < 128) return false;
+  return !!(result.assistantResponse || (result.toolUseHistory && result.toolUseHistory.length > 0));
+}
+
+/** Build meaningful error message: prefer stderr, fall back to non-JSON stdout lines. */
+function deriveErrorMessage(result: ExecutionResult): string {
+  if (result.error) return result.error;
+  if (result.output) {
+    const plainLines = result.output.split('\n')
+      .filter(l => l.trim() && !l.trim().startsWith('{'))
+      .join('\n')
+      .trim();
+    if (plainLines) return plainLines.slice(0, 500);
+  }
+  return `Claude exited with code ${result.exitCode}`;
+}
+
+function buildSuccessResult(sessionId: string, result: ExecutionResult): SessionResult {
+  return {
+    completed: true,
+    needsHandoff: false,
+    totalTokens: estimateTokensFromOutput(result.output),
+    sessionId,
+    ...sharedResultFields(result),
+  };
+}
+
+function buildErrorResult(sessionId: string, result: ExecutionResult): SessionResult {
+  return {
+    completed: false,
+    needsHandoff: false,
+    totalTokens: 0,
+    sessionId,
+    error: deriveErrorMessage(result),
+    ...sharedResultFields(result),
+  };
+}
+
 export class HeadlessRunner {
   private config: ResolvedHeadlessConfig;
   private runningProcesses: Map<number, ChildProcess> = new Map();
@@ -62,7 +121,7 @@ export class HeadlessRunner {
       stallKillMs: config.stallKillMs ?? 1_800_000,
       stallAssessEnabled: config.stallAssessEnabled !== false,
       stallMaxExtensions: config.stallMaxExtensions ?? 3,
-      stallHardCapMs: config.stallHardCapMs ?? 3_600_000,
+      stallHardCapMs: config.stallHardCapMs ?? 14_400_000,
       model: config.model,
       effortLevel: config.effortLevel,
       toolTimeoutProfiles: config.toolTimeoutProfiles,
@@ -103,77 +162,13 @@ 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,
-          stopReason: result.stopReason,
-        };
-      }
-
-      // Build meaningful error: prefer stderr, fall back to non-JSON stdout lines
-      let errorMessage = result.error;
-      if (!errorMessage && result.output) {
-        const plainLines = result.output.split('\n')
-          .filter(l => l.trim() && !l.trim().startsWith('{'))
-          .join('\n')
-          .trim();
-        if (plainLines) {
-          errorMessage = plainLines.slice(0, 500);
-        }
-      }
-      return {
-        completed: false,
-        needsHandoff: false,
-        totalTokens: 0,
-        sessionId,
-        error: errorMessage || `Claude exited with code ${result.exitCode}`,
-        signalName: result.signalName,
-        assistantResponse: result.assistantResponse,
-        thinkingOutput: result.thinkingOutput,
-        toolUseHistory: result.toolUseHistory,
-        claudeSessionId: result.claudeSessionId,
-        nativeTimeoutCount: result.nativeTimeoutCount,
-        postTimeoutOutput: result.postTimeoutOutput,
-        resumeBufferedOutput: result.resumeBufferedOutput,
-        stopReason: result.stopReason,
-      };
+    if (result.exitCode === 0) {
+      return buildSuccessResult(sessionId, result);
     }
-
-    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,
-      stopReason: result.stopReason,
-    };
+    if (isSignalExitWithOutput(result)) {
+      return buildSuccessResult(sessionId, result);
+    }
+    return buildErrorResult(sessionId, result);
   }
 
   /**

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

@@ -139,7 +139,7 @@ function buildAssessmentPrompt(ctx: StallContext): string {
   if (fromSkill) return fromSkill;
 
   return [
-    'You are a process health monitor. A Claude Code subprocess has been silent (no stdout) and you must determine if it is working or stalled.',
+    'You are a process health monitor. A Claude Code subprocess has gone silent (no stdout) and you must determine if it is working or stalled.',
     '',
     `Silent for: ${silenceMin} minutes`,
     `Total runtime: ${totalMin} minutes`,
@@ -150,10 +150,15 @@ function buildAssessmentPrompt(ctx: StallContext): string {
     tokenLine,
     `Task being executed: ${promptPreview}`,
     '',
+    'Weigh BOTH silence and total runtime against task complexity.',
+    '- Simple tasks (single Read/Write, one-liner edit, ls a directory) should finish in minutes. If total runtime has already far exceeded what the task should need, verdict STALLED even if silence is short.',
+    '- Complex tasks (agent teams, multi-step migrations, large refactors, dependency installs) can legitimately run hours. Extend generously when pending tool activity or subagents justify it.',
+    '- Recent token activity = process is alive; favor WORKING.',
+    '',
     'Respond in EXACTLY this format (3 lines, no extra text):',
     'VERDICT: WORKING or STALLED',
-    'MINUTES: <number 5-30, only if WORKING, how many more minutes to allow>',
-    'REASON: <brief one-line explanation>',
+    'MINUTES: <integer 5-180, only if WORKING, how many more minutes to allow>',
+    'REASON: <brief one-line explanation that references task complexity vs elapsed time>',
   ].filter(Boolean).join('\n');
 }
 
@@ -169,7 +174,7 @@ function parseAssessmentResponse(output: string): StallVerdict {
       verdict = trimmed.slice('VERDICT:'.length).trim().toUpperCase();
     } else if (trimmed.startsWith('MINUTES:')) {
       const parsed = parseInt(trimmed.slice('MINUTES:'.length).trim(), 10);
-      if (!Number.isNaN(parsed) && parsed >= 1 && parsed <= 60) {
+      if (!Number.isNaN(parsed) && parsed >= 1 && parsed <= 180) {
         minutes = parsed;
       }
     } else if (trimmed.startsWith('REASON:')) {

package/server/cli/headless/types.ts

@@ -108,7 +108,7 @@ export interface HeadlessConfig {
   stallKillMs?: number;      // No stdout before kill (default: 1800000 = 30 min)
   stallAssessEnabled?: boolean; // Use Haiku to assess stalls (default: true)
   stallMaxExtensions?: number;  // Max number of Haiku-granted extensions (default: 3)
-  stallHardCapMs?: number;     // Absolute wall-clock kill cap (default: 3600000 = 60 min)
+  stallHardCapMs?: number;     // Wall-clock backstop; only fires after stall signals have flagged the run (default: 14400000 = 4 h)
   /** Claude model for main execution (e.g., 'opus', 'sonnet'). 'default' = no --model flag. */
   model?: string;
   /**

package/server/cli/improvisation-history-store.ts

@@ -0,0 +1,62 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Persistence helpers for improvisation session history.
+ *
+ * Resolves the `.mstro/history/<timestamp>.json` location for a session
+ * and reads/writes its JSON payload. No in-memory state — callers pass
+ * the current `SessionHistory` object.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { herror } from './headless/headless-logger.js';
+import type { SessionHistory } from './improvisation-types.js';
+
+export interface HistoryPaths {
+  improviseDir: string;
+  historyPath: string;
+}
+
+export function resolveHistoryPaths(workingDir: string, sessionId: string): HistoryPaths {
+  const improviseDir = join(workingDir, '.mstro', 'history');
+  const historyPath = join(improviseDir, `${sessionId.replace('improv-', '')}.json`);
+  return { improviseDir, historyPath };
+}
+
+/** Create the `.mstro/history/` directory if missing. */
+export function ensureHistoryDir(improviseDir: string): void {
+  if (!existsSync(improviseDir)) {
+    mkdirSync(improviseDir, { recursive: true });
+  }
+}
+
+/**
+ * Load a session's history JSON. Returns a fresh empty history if the file
+ * doesn't exist or is unreadable (errors are logged but not thrown).
+ */
+export function loadHistory(historyPath: string, sessionId: string): SessionHistory {
+  if (existsSync(historyPath)) {
+    try {
+      const data = readFileSync(historyPath, 'utf-8');
+      return JSON.parse(data) as SessionHistory;
+    } catch (error) {
+      herror('Failed to load history:', error);
+    }
+  }
+  const now = new Date().toISOString();
+  return {
+    sessionId,
+    startedAt: now,
+    lastActivityAt: now,
+    totalTokens: 0,
+    movements: [],
+  };
+}
+
+/** Write history to disk after bumping `lastActivityAt`. */
+export function saveHistory(historyPath: string, history: SessionHistory): void {
+  history.lastActivityAt = new Date().toISOString();
+  writeFileSync(historyPath, JSON.stringify(history, null, 2));
+}

package/server/cli/improvisation-movements.ts

@@ -0,0 +1,120 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Pure builders for the MovementRecord snapshots that session-manager
+ * writes after each executePrompt outcome — normal completion, user
+ * cancel, hard error — plus the auto-continue decision heuristic.
+ */
+
+import type { HeadlessRunResult, MovementRecord, RetryLogEntry } from './improvisation-types.js';
+
+/**
+ * Fallback `HeadlessRunResult` used when a cancellation fires before any
+ * run produces one. Shape matches the minimum fields the emit helpers
+ * look at downstream.
+ */
+export const CANCELLED_FALLBACK_RESULT: HeadlessRunResult = {
+  completed: false, needsHandoff: false, totalTokens: 0, sessionId: '',
+  output: '', exitCode: 1, signalName: 'SIGTERM',
+} as HeadlessRunResult;
+
+export interface MovementBuildArgs {
+  sequenceNumber: number;
+  userPrompt: string;
+  execStart: number;
+  isAutoContinue?: boolean;
+}
+
+/** Build a MovementRecord representing a successful execution. */
+export function buildSuccessMovement(
+  result: HeadlessRunResult,
+  args: MovementBuildArgs,
+  retryLog: RetryLogEntry[] | undefined,
+): MovementRecord {
+  return {
+    id: `prompt-${args.sequenceNumber}`,
+    sequenceNumber: args.sequenceNumber,
+    userPrompt: args.userPrompt,
+    timestamp: new Date().toISOString(),
+    tokensUsed: result.totalTokens,
+    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, isError: t.isError, duration: t.duration,
+    })),
+    errorOutput: result.error,
+    durationMs: Date.now() - args.execStart,
+    retryLog: retryLog && retryLog.length > 0 ? retryLog : undefined,
+    ...(args.isAutoContinue && { isAutoContinue: true }),
+  };
+}
+
+/** Build a MovementRecord representing a user-initiated cancel mid-run. */
+export function buildCancelledMovement(
+  result: HeadlessRunResult | undefined,
+  args: MovementBuildArgs,
+): MovementRecord {
+  return {
+    id: `prompt-${args.sequenceNumber}`,
+    sequenceNumber: args.sequenceNumber,
+    userPrompt: args.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() - args.execStart,
+  };
+}
+
+/** Build a MovementRecord for a thrown error inside executePrompt. */
+export function buildErrorMovement(errorMessage: string, args: MovementBuildArgs): MovementRecord {
+  return {
+    id: `prompt-${args.sequenceNumber}`,
+    sequenceNumber: args.sequenceNumber,
+    userPrompt: args.userPrompt,
+    timestamp: new Date().toISOString(),
+    tokensUsed: 0,
+    summary: '',
+    filesModified: [],
+    errorOutput: errorMessage,
+    durationMs: Date.now() - args.execStart,
+  };
+}
+
+/**
+ * Heuristic for auto-continuing "end_turn" runs that appear incomplete:
+ * lots of thinking, not much visible output, and no tool work that
+ * already justifies the short response.
+ */
+export function shouldAutoContinue(
+  result: HeadlessRunResult,
+  autoContinueCount: number,
+  maxAutoContinues: number,
+  cancelled: boolean,
+): boolean {
+  if (autoContinueCount >= maxAutoContinues) return false;
+  if (cancelled) return false;
+  if (!result.completed || result.signalName) return false;
+  if (result.stopReason !== 'end_turn') return false;
+
+  const thinkingLen = result.thinkingOutput?.length ?? 0;
+  const responseLen = result.assistantResponse?.length ?? 0;
+  const successfulToolCalls = result.toolUseHistory?.filter(t => t.result !== undefined && !t.isError).length ?? 0;
+
+  if (thinkingLen < 500 || responseLen > 1000) return false;
+  // When the agent executed tool calls and produced a non-trivial response,
+  // long thinking is expected — the work happened in the tools, not the text.
+  if (successfulToolCalls > 0 && responseLen > 200) return false;
+  return thinkingLen >= responseLen * 3;
+}

package/server/cli/improvisation-output-queue.ts

@@ -0,0 +1,42 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Small FIFO output buffer with a fixed-interval flush timer, used by the
+ * improvisation session manager to coalesce rapid stdout writes into
+ * steady `onOutput` emissions.
+ */
+
+const FLUSH_INTERVAL_MS = 50;
+
+export class OutputQueue {
+  private queue: Array<{ text: string; timestamp: number }> = [];
+  private timer: NodeJS.Timeout | null = null;
+
+  constructor(private readonly onEmit: (text: string) => void) {}
+
+  start(): void {
+    if (this.timer) return;
+    this.timer = setInterval(() => { this.flush(); }, FLUSH_INTERVAL_MS);
+  }
+
+  queue_(text: string): void {
+    this.queue.push({ text, timestamp: Date.now() });
+  }
+
+  /** Drain all buffered entries, emitting each via `onEmit` in order. */
+  flush(): void {
+    while (this.queue.length > 0) {
+      const item = this.queue.shift();
+      if (item) this.onEmit(item.text);
+    }
+  }
+
+  /** Stop the flush timer. Does NOT drain; call `flush()` first if needed. */
+  destroy(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+}