fix(workflow): handle chained prompts on resume when promptQueue is empty

fix(agent): only mark agent as completed on fresh execution, not resume
refactor(workflow): improve input provider selection logic in wait state
feat(mistral): add session ID recovery from files on abort or completion

Author: moazbuilds

src/agents/runner/runner.ts

@@ -433,17 +433,22 @@ export async function executeAgent(
 
     debug(`[AgentRunner] Engine execution completed, outputLength=%d`, totalStdout.length);
 
-    // Mark agent as completed
-    if (monitor && monitoringAgentId !== undefined) {
+    // Determine if this is a resume (conversational loop) vs fresh execution
+    const isResume = resumeSessionId !== undefined;
+
+    // Mark agent as completed (only for fresh execution, not resume)
+    // During resume, the agent stays in running/awaiting state for continued conversation
+    if (!isResume && monitor && monitoringAgentId !== undefined) {
       debug(`[AgentRunner] Marking agent %d as completed`, monitoringAgentId);
       await monitor.complete(monitoringAgentId);
       // Note: Don't close stream here - workflow may write more messages
       // Streams will be closed by cleanup handlers or monitoring service shutdown
+    } else if (isResume) {
+      debug(`[AgentRunner] Resume mode - agent %d stays running for continued conversation`, monitoringAgentId ?? -1);
     }
 
     // Load chained prompts if configured
-    // Always load on fresh execution; on resume, workflow.ts decides whether to use them
-    // based on chain resume state (chainResumeInfo)
+    // Always load - the workflow runner decides whether to use them based on promptQueue state
     let chainedPrompts: ChainedPrompt[] | undefined;
     debug(`[AgentRunner] ChainedPrompts path: %s`, agentConfig.chainedPromptsPath ?? '(none)');
     if (agentConfig.chainedPromptsPath) {

src/infra/engines/providers/mistral/execution/runner.ts

@@ -1,4 +1,5 @@
 import * as path from 'node:path';
+import * as fs from 'node:fs';
 import { homedir } from 'node:os';
 
 import { spawnProcess } from '../../../../process/spawn.js';
@@ -41,6 +42,43 @@ export interface RunMistralResult {
 
 const ANSI_ESCAPE_SEQUENCE = new RegExp(String.raw`\u001B\[[0-9;?]*[ -/]*[@-~]`, 'g');
 
+/**
+ * Find the most recent session file created after startTime
+ * Session files are stored in VIBE_HOME/logs/session/ with format:
+ *   session_{date}_{time}_{short_id}.json
+ * The full session_id is in the metadata.session_id field inside the file.
+ */
+function findLatestSessionId(vibeHome: string, startTime: number): string | null {
+  const sessionDir = path.join(vibeHome, 'logs', 'session');
+
+  try {
+    if (!fs.existsSync(sessionDir)) {
+      return null;
+    }
+
+    const files = fs.readdirSync(sessionDir)
+      .filter(f => f.startsWith('session_') && f.endsWith('.json'))
+      .map(f => ({
+        name: f,
+        path: path.join(sessionDir, f),
+        mtime: fs.statSync(path.join(sessionDir, f)).mtimeMs,
+      }))
+      .filter(f => f.mtime >= startTime)
+      .sort((a, b) => b.mtime - a.mtime);
+
+    if (files.length === 0) {
+      return null;
+    }
+
+    // Read the most recent session file and extract session_id from metadata
+    const content = fs.readFileSync(files[0].path, 'utf-8');
+    const json = JSON.parse(content);
+    return json.metadata?.session_id || null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Build the final resume prompt combining steering instruction with user message
  */
@@ -236,6 +274,9 @@ export async function runMistral(options: RunMistralOptions): Promise<RunMistral
   let capturedError: string | null = null;
   let sessionIdCaptured = false;
 
+  // Record start time to find session files created during this run
+  const startTime = Date.now();
+
   let result;
   try {
     result = await spawnProcess({
@@ -315,14 +356,25 @@ export async function runMistral(options: RunMistralOptions): Promise<RunMistral
       timeout,
     });
   } catch (error) {
-    const err = error as unknown as { code?: string; message?: string };
+    const err = error as unknown as { code?: string; message?: string; name?: string };
     const message = err?.message ?? '';
     const notFound = err?.code === 'ENOENT' || /not recognized as an internal or external command/i.test(message) || /command not found/i.test(message);
     if (notFound) {
       const install = metadata.installCommand;
       const name = metadata.name;
       throw new Error(`'${command}' is not available on this system. Please install ${name} first:\n  ${install}`);
     }
+
+    // Try to capture session ID even on abort - vibe saves session on exit
+    // This is important for pause/resume functionality
+    if (err?.name === 'AbortError' && !sessionIdCaptured && onSessionId) {
+      const sessionId = findLatestSessionId(vibeHome, startTime);
+      if (sessionId) {
+        sessionIdCaptured = true;
+        onSessionId(sessionId);
+      }
+    }
+
     throw error;
   }
 
@@ -377,6 +429,16 @@ export async function runMistral(options: RunMistralOptions): Promise<RunMistral
     throw new Error(errorMessage);
   }
 
+  // If session ID wasn't captured from streaming output, try to find it from session files
+  // Vibe doesn't include session_id in streaming JSON output, but saves it to session files
+  if (!sessionIdCaptured && onSessionId) {
+    const sessionId = findLatestSessionId(vibeHome, startTime);
+    if (sessionId) {
+      sessionIdCaptured = true;
+      onSessionId(sessionId);
+    }
+  }
+
   // Log captured telemetry
   telemetryCapture.logCapturedTelemetry(result.exitCode);
 

src/workflows/runner/wait.ts

@@ -29,15 +29,22 @@ export async function handleWaiting(ctx: RunnerContext, callbacks: WaitCallbacks
   debug('[Runner] Handling waiting state, autoMode=%s, paused=%s, promptQueue=%d items, queueIndex=%d',
     machineCtx.autoMode, machineCtx.paused, machineCtx.promptQueue.length, machineCtx.promptQueueIndex);
 
-  // If paused, force user input provider (not controller)
-  const provider = machineCtx.paused ? ctx.getUserInput() : ctx.getActiveProvider();
+  // Determine input provider:
+  // - If paused → always use user input
+  // - If manual mode (autoMode=false) → always use user input
+  // - If auto mode (autoMode=true) and not paused → use active provider (controller)
+  const useUserInput = machineCtx.paused || !machineCtx.autoMode;
+  const provider = useUserInput ? ctx.getUserInput() : ctx.getActiveProvider();
   if (machineCtx.paused) {
     debug('[Runner] Workflow is paused, using user input provider');
+  } else if (!machineCtx.autoMode) {
+    debug('[Runner] Manual mode, using user input provider');
   }
 
-  if (!machineCtx.paused && machineCtx.promptQueue.length === 0) {
-    // No chained prompts and not paused - auto-advance to next step
-    debug('[Runner] No chained prompts, auto-advancing to next step');
+  if (!machineCtx.paused && machineCtx.promptQueue.length === 0 && machineCtx.autoMode) {
+    // No chained prompts, not paused, and in auto mode - auto-advance to next step
+    // In manual mode, we wait for user input before advancing
+    debug('[Runner] No chained prompts (auto mode), auto-advancing to next step');
     await markStepCompleted(ctx.cmRoot, machineCtx.currentStepIndex);
     ctx.machine.send({ type: 'INPUT_RECEIVED', input: '' });
     return;

src/workflows/step/run.ts

@@ -267,6 +267,14 @@ export async function runStepResume(
     };
     machineCtx.currentMonitoringId = output.monitoringId;
 
+    // If promptQueue is empty but we got chained prompts, populate it
+    // This happens when initial execution was aborted before completion
+    if (machineCtx.promptQueue.length === 0 && output.chainedPrompts && output.chainedPrompts.length > 0) {
+      debug('[step/run] Resume: Populating promptQueue with %d chained prompts (initial exec was aborted)', output.chainedPrompts.length);
+      machineCtx.promptQueue = output.chainedPrompts;
+      machineCtx.promptQueueIndex = 0;
+    }
+
     const stepOutput: StateStepOutput = {
       output: output.output,
       monitoringId: output.monitoringId,