feat(workflow): add auto mode continuation prompt handling

- Add DEFAULT_CONTINUATION_PROMPT constant for auto mode recovery and delegation
- Track continuationPromptSent in workflow context to prevent duplicate prompts
- Send continuation prompt when first entering delegated state in auto mode
- Handle mode switches during prompt execution in delegated state

Author: moazbuilds

src/shared/prompts/continuation.ts

@@ -0,0 +1,15 @@
+/**
+ * Continuation Prompts for Auto Mode
+ *
+ * Shared prompts used when continuing workflow execution in auto mode.
+ */
+
+/**
+ * Default continuation prompt for auto mode
+ *
+ * Used when:
+ * 1. Crash recovery in auto mode - to resume agent where it left off
+ * 2. Entering delegated state - to prompt agent before controller decides
+ */
+export const DEFAULT_CONTINUATION_PROMPT =
+  'Continue where you left off. Review what was accomplished and proceed with the next logical step.';

src/shared/prompts/index.ts

@@ -1 +1,2 @@
 export { processPrompt, processPromptString } from './replacement/processor.js';
+export { DEFAULT_CONTINUATION_PROMPT } from './continuation.js';

src/workflows/recovery/index.ts

@@ -6,6 +6,7 @@
  */
 
 import { debug } from '../../shared/logging/logger.js';
+import { DEFAULT_CONTINUATION_PROMPT } from '../../shared/prompts/index.js';
 import type { StepData } from '../indexing/types.js';
 import type { WorkflowEventEmitter } from '../events/index.js';
 import type { StepIndexManager } from '../indexing/index.js';
@@ -140,7 +141,6 @@ export async function handleCrashRecovery(
 
   // 3. Handle recovery based on mode
   const isAutoMode = machine.context.autoMode;
-  const recoveryPrompt = 'Continue where you left off. Review what was accomplished and proceed with the next logical step.';
 
   if (isAutoMode) {
     // Auto mode: Send recovery prompt directly before transitioning
@@ -152,12 +152,15 @@ export async function handleCrashRecovery(
     debug('[recovery] Auto mode: sending recovery prompt to agent');
     emitter.updateAgentStatus(uniqueAgentId, 'running');
 
+    // Mark continuation prompt as sent to prevent handleDelegated from sending again
+    machine.context.continuationPromptSent = true;
+
     // Transition to running state before sending prompt
     machine.send({ type: 'RESUME' });
 
     // Send recovery prompt and wait for agent response
     await options.sendRecoveryPrompt({
-      resumePrompt: recoveryPrompt,
+      resumePrompt: DEFAULT_CONTINUATION_PROMPT,
       resumeMonitoringId: stepData?.monitoringId,
       source: 'controller',
     });

src/workflows/runner/delegated.ts

@@ -6,6 +6,7 @@
  */
 
 import { debug } from '../../shared/logging/logger.js';
+import { DEFAULT_CONTINUATION_PROMPT } from '../../shared/prompts/index.js';
 import type { InputContext } from '../input/index.js';
 import { getUniqueAgentId } from '../context/index.js';
 import { runStepResume } from '../step/run.js';
@@ -81,10 +82,61 @@ export async function handleDelegated(ctx: RunnerContext, callbacks: DelegatedCa
   debug('[Runner:delegated] Scenario=%d, shouldWait=%s, runAutonomousLoop=%s',
     behavior.scenario, behavior.shouldWait, behavior.runAutonomousLoop);
 
+  // Auto mode continuation: Send continuation prompt FIRST before any scenario handling
+  // This ensures agent gets a chance to continue when auto mode is enabled
+  if (!machineCtx.continuationPromptSent && machineCtx.currentOutput) {
+    debug('[Runner:delegated] Sending continuation prompt (first entry into auto mode)');
+
+    // Mark as sent to prevent re-sending on next entry
+    machineCtx.continuationPromptSent = true;
+
+    // Update status and transition to running
+    ctx.emitter.updateAgentStatus(stepUniqueAgentId, 'running');
+    ctx.machine.send({ type: 'RESUME' });
+
+    // Track mode switch during execution (so pause works mid-turn)
+    let modeSwitchRequested: 'manual' | null = null;
+    const modeChangeHandler = (data: { autonomousMode: boolean }) => {
+      if (!data.autonomousMode) {
+        debug('[Runner:delegated] Mode change to manual during continuation prompt');
+        modeSwitchRequested = 'manual';
+        ctx.getAbortController()?.abort();
+      }
+    };
+    process.on('workflow:mode-change', modeChangeHandler);
+
+    try {
+      // Send continuation prompt and wait for agent response
+      await runStepResume(ctx, {
+        resumePrompt: DEFAULT_CONTINUATION_PROMPT,
+        resumeMonitoringId: machineCtx.currentMonitoringId,
+        source: 'controller',
+      });
+
+      debug('[Runner:delegated] Continuation prompt sent, agent responded');
+    } catch (error) {
+      if (error instanceof Error && error.name === 'AbortError') {
+        if (modeSwitchRequested === 'manual') {
+          debug('[Runner:delegated] Continuation prompt aborted due to mode switch to manual');
+          ctx.emitter.updateAgentStatus(stepUniqueAgentId, 'awaiting');
+          await callbacks.setAutoMode(false);
+        }
+        return;
+      }
+      throw error;
+    } finally {
+      process.removeListener('workflow:mode-change', modeChangeHandler);
+    }
+
+    // After agent responds, state machine transitions back to delegated
+    // Next call to handleDelegated will proceed with scenario handling
+    return;
+  }
+
   // Handle Scenario 5: Fully autonomous prompt loop (interactive:false + autoMode + chainedPrompts)
   if (behavior.runAutonomousLoop) {
     debug('[Runner:delegated] Running autonomous prompt loop (Scenario 5)');
-    await runAutonomousPromptLoop(ctx);
+    await runAutonomousPromptLoop(ctx, callbacks);
     return;
   }
 
@@ -263,7 +315,7 @@ export async function handleDelegated(ctx: RunnerContext, callbacks: DelegatedCa
  *
  * Automatically sends the next chained prompt without controller involvement.
  */
-async function runAutonomousPromptLoop(ctx: RunnerContext): Promise<void> {
+async function runAutonomousPromptLoop(ctx: RunnerContext, callbacks: DelegatedCallbacks): Promise<void> {
   const machineCtx = ctx.machine.context;
   const stepIndex = machineCtx.currentStepIndex;
   const step = ctx.moduleSteps[stepIndex];
@@ -375,11 +427,37 @@ async function runAutonomousPromptLoop(ctx: RunnerContext): Promise<void> {
 
   // Resume step with the prompt
   ctx.machine.send({ type: 'RESUME' });
-  await runStepResume(ctx, {
-    resumePrompt: nextPrompt.content,
-    resumeMonitoringId: machineCtx.currentMonitoringId,
-    source: 'controller',
-  });
+
+  // Track mode switch during execution (so pause works mid-turn)
+  let modeSwitchRequested: 'manual' | null = null;
+  const modeChangeHandler = (data: { autonomousMode: boolean }) => {
+    if (!data.autonomousMode) {
+      debug('[Runner:delegated:autonomous] Mode change to manual during prompt execution');
+      modeSwitchRequested = 'manual';
+      ctx.getAbortController()?.abort();
+    }
+  };
+  process.on('workflow:mode-change', modeChangeHandler);
+
+  try {
+    await runStepResume(ctx, {
+      resumePrompt: nextPrompt.content,
+      resumeMonitoringId: machineCtx.currentMonitoringId,
+      source: 'controller',
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === 'AbortError') {
+      if (modeSwitchRequested === 'manual') {
+        debug('[Runner:delegated:autonomous] Prompt execution aborted due to mode switch to manual');
+        ctx.emitter.updateAgentStatus(uniqueAgentId, 'awaiting');
+        await callbacks.setAutoMode(false);
+      }
+      return;
+    }
+    throw error;
+  } finally {
+    process.removeListener('workflow:mode-change', modeChangeHandler);
+  }
 }
 
 /**

src/workflows/state/machine.ts

@@ -127,6 +127,7 @@ export function createWorkflowMachine(initialContext: Partial<WorkflowContext> =
     paused: false,
     cwd: process.cwd(),
     cmRoot: '',
+    continuationPromptSent: false,
     ...initialContext,
   };
 
@@ -196,6 +197,7 @@ export function createWorkflowMachine(initialContext: Partial<WorkflowContext> =
               guard: (ctx) => ctx.currentStepIndex < ctx.totalSteps - 1,
               action: (ctx) => {
                 ctx.currentStepIndex += 1;
+                ctx.continuationPromptSent = false;
                 debug('[FSM] Skipped during run, advancing to step %d', ctx.currentStepIndex + 1);
               },
             },
@@ -246,6 +248,7 @@ export function createWorkflowMachine(initialContext: Partial<WorkflowContext> =
               action: (ctx, event) => {
                 if (event.type === 'INPUT_RECEIVED') {
                   ctx.currentStepIndex += 1;
+                  ctx.continuationPromptSent = false;
                   debug('[FSM] Input received, advancing to step %d', ctx.currentStepIndex + 1);
                 }
               },
@@ -267,6 +270,7 @@ export function createWorkflowMachine(initialContext: Partial<WorkflowContext> =
               guard: (ctx) => ctx.currentStepIndex < ctx.totalSteps - 1,
               action: (ctx) => {
                 ctx.currentStepIndex += 1;
+                ctx.continuationPromptSent = false;
                 debug('[FSM] Skipped, advancing to step %d', ctx.currentStepIndex + 1);
               },
             },
@@ -291,6 +295,7 @@ export function createWorkflowMachine(initialContext: Partial<WorkflowContext> =
             target: 'awaiting',
             action: (ctx) => {
               ctx.autoMode = false;
+              ctx.continuationPromptSent = false; // Reset so next auto mode entry sends prompt
               debug('[FSM] Mode switched to manual, transitioning to awaiting');
             },
           },
@@ -301,6 +306,7 @@ export function createWorkflowMachine(initialContext: Partial<WorkflowContext> =
               action: (ctx, event) => {
                 if (event.type === 'INPUT_RECEIVED') {
                   ctx.currentStepIndex += 1;
+                  ctx.continuationPromptSent = false;
                   debug('[FSM] Controller input received, advancing to step %d', ctx.currentStepIndex + 1);
                 }
               },
@@ -319,6 +325,7 @@ export function createWorkflowMachine(initialContext: Partial<WorkflowContext> =
               guard: (ctx) => ctx.currentStepIndex < ctx.totalSteps - 1,
               action: (ctx) => {
                 ctx.currentStepIndex += 1;
+                ctx.continuationPromptSent = false;
                 debug('[FSM] Controller skipped, advancing to step %d', ctx.currentStepIndex + 1);
               },
             },
@@ -332,6 +339,7 @@ export function createWorkflowMachine(initialContext: Partial<WorkflowContext> =
             action: (ctx) => {
               ctx.autoMode = false;
               ctx.paused = true;
+              ctx.continuationPromptSent = false; // Reset so next auto mode entry sends prompt
               debug('[FSM] Controller paused - switching to manual mode');
             },
           },

src/workflows/state/types.ts

@@ -70,6 +70,10 @@ export interface WorkflowContext {
 
   // Error tracking
   lastError?: Error;
+
+  // Auto mode continuation tracking
+  // When true, continuation prompt has been sent for current step in delegated state
+  continuationPromptSent?: boolean;
 }
 
 /**