feat(ui): improve prompt queue persistence and status display

- Persist prompt queue state across emissions in input emitter
- Update status footer text for autonomous mode toggle
- Preserve queue info when clearing input state for UI visibility
- Emit queue state immediately in controller for better UX

Author: moazbuilds

src/cli/tui/routes/workflow/components/output/status-footer.tsx

@@ -21,7 +21,7 @@ export function StatusFooter(props: StatusFooterProps) {
   return (
     <box paddingLeft={1} paddingRight={1}>
       <text fg={themeCtx.theme.textMuted}>
-        [↑↓] Navigate  [ENTER] Expand/View  [Tab] Toggle Panel  [H] History  [P] Pause  [Ctrl+S] Skip  [Esc] Stop{props.autonomousMode ? '  [Shift+Tab] Disable Auto' : ''}
+        [↑↓] Navigate  [ENTER] Expand/View  [Tab] Toggle Panel  [H] History  [P] Pause  [Ctrl+S] Skip  [Esc] Stop  [Shift+Tab] {props.autonomousMode ? 'Disable' : 'Enable'} Auto
       </text>
     </box>
   )

src/cli/tui/routes/workflow/context/ui-state/actions/workflow-actions.ts

@@ -44,10 +44,22 @@ export function createWorkflowActions(ctx: WorkflowActionsContext) {
 
   function setInputState(inputState: InputState | null): void {
     const state = ctx.getState()
-    ctx.setState({ ...state, inputState })
-    if (inputState && inputState.active) {
+    const prevQueue = state.inputState?.queuedPrompts
+    const prevIndex = state.inputState?.currentIndex
+
+    // Persist queue from previous state if new state doesn't have one
+    let mergedState = inputState
+    if (inputState && !inputState.queuedPrompts && prevQueue && prevQueue.length > 0) {
+      mergedState = { ...inputState, queuedPrompts: prevQueue, currentIndex: prevIndex }
+    } else if (!inputState && prevQueue && prevQueue.length > 0) {
+      // Even when clearing, preserve queue info for UI display
+      mergedState = { active: false, queuedPrompts: prevQueue, currentIndex: prevIndex }
+    }
+
+    ctx.setState({ ...state, inputState: mergedState })
+    if (mergedState && mergedState.active) {
       // Only show "Paused" for manual pause (no queue), not for chained prompts
-      const hasQueue = inputState.queuedPrompts && inputState.queuedPrompts.length > 0
+      const hasQueue = mergedState.queuedPrompts && mergedState.queuedPrompts.length > 0
       if (!hasQueue) {
         setWorkflowStatus("paused")
       }

src/workflows/input/emitter.ts

@@ -17,19 +17,27 @@ import type {
  * Create an input event emitter that uses the workflow event bus
  */
 export function createInputEmitter(workflowEmitter: WorkflowEventEmitter): InputEventEmitter {
+  // Persist queue state across emissions - only clear on explicit cancel/workflow end
+  let persistedQueue: { name: string; label: string; content: string }[] = [];
+  let persistedIndex = 0;
+
   return {
     emitWaiting(data: WaitingEventData): void {
       debug('[InputEmitter] Emitting waiting: step=%d, queueLength=%d',
         data.stepIndex, data.promptQueue.length);
 
+      // Update persisted queue
+      persistedQueue = data.promptQueue.map(p => ({
+        name: p.name,
+        label: p.label,
+        content: p.content,
+      }));
+      persistedIndex = data.promptQueueIndex;
+
       workflowEmitter.setInputState({
         active: true,
-        queuedPrompts: data.promptQueue.map(p => ({
-          name: p.name,
-          label: p.label,
-          content: p.content,
-        })),
-        currentIndex: data.promptQueueIndex,
+        queuedPrompts: persistedQueue,
+        currentIndex: persistedIndex,
         monitoringId: data.monitoringId,
       });
     },
@@ -38,27 +46,33 @@ export function createInputEmitter(workflowEmitter: WorkflowEventEmitter): Input
       debug('[InputEmitter] Emitting received: source=%s, inputLength=%d',
         data.source, data.input.length);
 
-      // Preserve queue info with active=false so step indicator shows while agent runs
+      // Update persisted state if queue provided
       if (data.promptQueue && data.promptQueue.length > 0) {
-        workflowEmitter.setInputState({
-          active: false,
-          queuedPrompts: data.promptQueue.map(p => ({
-            name: p.name,
-            label: p.label,
-            content: p.content,
-          })),
-          currentIndex: data.promptQueueIndex ?? 0,
-        });
-      } else {
-        // No queue - clear input state
-        workflowEmitter.setInputState(null);
+        persistedQueue = data.promptQueue.map(p => ({
+          name: p.name,
+          label: p.label,
+          content: p.content,
+        }));
+        persistedIndex = data.promptQueueIndex ?? 0;
+      } else if (data.promptQueueIndex !== undefined) {
+        // Just update index if provided
+        persistedIndex = data.promptQueueIndex;
       }
+
+      // Always emit with persisted queue (never clear mid-workflow)
+      workflowEmitter.setInputState({
+        active: false,
+        queuedPrompts: persistedQueue,
+        currentIndex: persistedIndex,
+      });
     },
 
     emitCanceled(): void {
       debug('[InputEmitter] Emitting canceled');
 
-      // Clear input state
+      // Clear persisted state and input state
+      persistedQueue = [];
+      persistedIndex = 0;
       workflowEmitter.setInputState(null);
     },
   };

src/workflows/input/providers/controller.ts

@@ -68,6 +68,16 @@ export class ControllerInputProvider implements InputProvider {
   async getInput(context: InputContext): Promise<InputResult> {
     this.aborted = false;
 
+    // Emit queue state immediately so UI shows step info while controller runs
+    if (context.promptQueue.length > 0) {
+      this.emitter.emitWaiting({
+        stepIndex: context.stepIndex,
+        promptQueue: context.promptQueue,
+        promptQueueIndex: context.promptQueueIndex,
+        monitoringId: context.stepOutput.monitoringId,
+      });
+    }
+
     const config = await this.getControllerConfig();
     if (!config) {
       debug('[Controller] No controller config, falling back to skip');