feat(controller): improve controller input handling and session management

- Add cmRoot to controller options for config persistence
- Enhance prompt building with cleaned step output and reminders
- Update session ID handling to maintain persistence
- Improve logging in workflow emitter and agent runner
- Add debug logging to log stream hook
- Refactor controller prompt extraction and color marker removal
- Update PO controller prompt with detailed instructions

Author: moazbuilds

config/main.agents.js

@@ -77,7 +77,7 @@ module.exports = [
     name: 'PO - Product Owner',
     description: 'BMAD product owner controller for autonomous mode',
     role: 'controller',
-    promptPath: path.join(promptsDir, 'bmad', 'controller', 'system.md'),
+    promptPath: path.join(promptsDir, 'bmad', 'controller', 'PO.md'),
   },
 
   // BMAD agents

prompts/templates/bmad/controller/PO.md

@@ -0,0 +1,68 @@
+# Product Owner Controller
+
+You are a Product Owner for {project_name}. You represent the user's business interests and collaborate with the working agent.
+
+## PROJECT SPECIFICATIONS
+
+```
+{specifications}
+```
+
+## FIRST MESSAGE
+
+Say only: "I am ready!"
+
+Then wait for the agent.
+
+## HOW TO RESPOND
+
+### When Agent Asks Questions
+
+Answer from business perspective using your specifications knowledge:
+
+- Give clear, decisive answers
+- Share business context and requirements
+- Help the agent understand what users need
+- Don't ask questions back - make decisions
+
+Example:
+Agent: "Who are the target users?"
+You: "Individual professionals and students who need simple personal task management. No team features needed for MVP."
+
+### When Agent Presents Work
+
+If work meets business needs:
+- Say why it's acceptable (business perspective)
+- Say `ACTION: NEXT`
+
+Example:
+"This covers the core CRUD functionality our users need. Simple and focused on MVP scope.
+
+ACTION: NEXT"
+
+If work needs changes:
+- Say what's wrong (business perspective)
+- Say what you expect instead
+
+Example:
+"Too complex for MVP. Users just need basic add/edit/delete/complete. Remove the project management features."
+
+### When Step is Complete
+
+After agent confirms step completion and saves artifacts:
+- Acknowledge the deliverable
+- Say `ACTION: NEXT` to proceed
+
+## ACTION COMMANDS
+
+| Command | When to Use |
+|---------|-------------|
+| `ACTION: NEXT` | Step complete, proceed to next |
+| `ACTION: STOP` | Fatal error, cannot continue |
+
+## RULES
+
+1. Text responses only - never use tools
+2. Be decisive - don't ask questions, make decisions
+3. Answer from BUSINESS perspective, not technical
+4. First message is always "I am ready!"

prompts/templates/bmad/controller/system.md

@@ -1 +1 @@
-You are Test Agent 1. You will say your name.
+You are Test Agent 1. Ask the user: "What is the user asked you for?"

prompts/templates/test-workflows/test-agent-1.md

@@ -207,18 +207,26 @@ export async function executeAgent(
 ): Promise<AgentExecutionOutput> {
   const { workingDir, projectRoot, engine: engineOverride, model: modelOverride, logger, stderrLogger, onTelemetry, abortSignal, timeout, parentId, disableMonitoring, ui, uniqueAgentId, displayPrompt, resumeMonitoringId, resumePrompt, resumeSessionId: resumeSessionIdOption, selectedConditions } = options;
 
+  debug(`[AgentRunner] executeAgent called: agentId=%s promptLength=%d`, agentId, prompt.length);
+  debug(`[AgentRunner] Options: workingDir=%s engineOverride=%s modelOverride=%s parentId=%s`,
+    workingDir, engineOverride ?? '(none)', modelOverride ?? '(none)', parentId ?? '(none)');
+  debug(`[AgentRunner] Resume options: resumeMonitoringId=%s resumeSessionId=%s resumePrompt=%s`,
+    resumeMonitoringId ?? '(none)', resumeSessionIdOption ?? '(none)', resumePrompt ? resumePrompt.slice(0, 50) + '...' : '(none)');
+
   // If resuming, use direct sessionId or look up from monitor
   let resumeSessionId: string | undefined = resumeSessionIdOption;
   if (!resumeSessionId && resumeMonitoringId !== undefined) {
     const monitor = AgentMonitorService.getInstance();
     const resumeAgent = monitor.getAgent(resumeMonitoringId);
+    debug(`[AgentRunner] Looking up sessionId from monitoringId=%d, found agent=%s`,
+      resumeMonitoringId, resumeAgent ? 'yes' : 'no');
     if (resumeAgent?.sessionId) {
       resumeSessionId = resumeAgent.sessionId;
-      debug(`[RESUME] Using sessionId ${resumeSessionId} from monitoringId ${resumeMonitoringId}`);
+      debug(`[AgentRunner] Using sessionId %s from monitoringId %d`, resumeSessionId, resumeMonitoringId);
     }
   }
   if (resumeSessionId) {
-    debug(`[RESUME] Resuming with sessionId: ${resumeSessionId}`);
+    debug(`[AgentRunner] Will resume with sessionId: %s`, resumeSessionId);
   }
 
   // Load agent config to determine engine and model
@@ -284,18 +292,21 @@ export async function executeAgent(
     if (resumeMonitoringId !== undefined) {
       // RESUME: Use existing monitoring entry (skip registration, use existing log file)
       monitoringAgentId = resumeMonitoringId;
-      debug(`[RESUME] Using existing monitoringId ${monitoringAgentId}, skipping registration`);
+      debug(`[AgentRunner] RESUME: Using existing monitoringId=%d, skipping registration`, monitoringAgentId);
 
       // Mark as running again (was paused)
       await monitor.markRunning(monitoringAgentId);
+      debug(`[AgentRunner] RESUME: Marked agent as running`);
 
       // Register monitoring ID with UI so it can load existing logs
       if (ui && uniqueAgentId) {
+        debug(`[AgentRunner] RESUME: Registering monitoringId=%d with UI (uniqueAgentId=%s)`, monitoringAgentId, uniqueAgentId);
         ui.registerMonitoringId(uniqueAgentId, monitoringAgentId);
       }
     } else {
       // NEW EXECUTION: Register new monitoring entry
       const promptForDisplay = displayPrompt || prompt;
+      debug(`[AgentRunner] NEW: Registering new monitoring entry for agentId=%s`, agentId);
       monitoringAgentId = await monitor.register({
         name: agentId,
         prompt: promptForDisplay, // This gets truncated in monitor for memory efficiency
@@ -304,13 +315,15 @@ export async function executeAgent(
         engineProvider: engineType,
         modelName: model,
       });
+      debug(`[AgentRunner] NEW: Registered with monitoringId=%d`, monitoringAgentId);
 
       // Store FULL prompt for debug mode logging (not the display prompt)
       // In debug mode, we want to see the complete composite prompt with template + input files
       loggerService.storeFullPrompt(monitoringAgentId, prompt);
 
       // Register monitoring ID with UI immediately so it can load logs
       if (ui && uniqueAgentId && monitoringAgentId !== undefined) {
+        debug(`[AgentRunner] NEW: Registering monitoringId=%d with UI (uniqueAgentId=%s)`, monitoringAgentId, uniqueAgentId);
         ui.registerMonitoringId(uniqueAgentId, monitoringAgentId);
       }
     }
@@ -324,6 +337,8 @@ export async function executeAgent(
   // Get engine and execute
   // NOTE: Prompt is already complete - no template loading or building here
   const engine = getEngine(engineType);
+  debug(`[AgentRunner] Starting engine execution: engine=%s model=%s resumeSessionId=%s`,
+    engineType, model, resumeSessionId ?? '(new session)');
 
   let totalStdout = '';
 
@@ -416,8 +431,11 @@ export async function executeAgent(
       timestamp: new Date().toISOString(),
     });
 
+    debug(`[AgentRunner] Engine execution completed, outputLength=%d`, totalStdout.length);
+
     // Mark agent as completed
     if (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
@@ -427,7 +445,7 @@ export async function executeAgent(
     // Always load on fresh execution; on resume, workflow.ts decides whether to use them
     // based on chain resume state (chainResumeInfo)
     let chainedPrompts: ChainedPrompt[] | undefined;
-    debug(`[ChainedPrompts] agentConfig.chainedPromptsPath: ${agentConfig.chainedPromptsPath}`);
+    debug(`[AgentRunner] ChainedPrompts path: %s`, agentConfig.chainedPromptsPath ?? '(none)');
     if (agentConfig.chainedPromptsPath) {
       chainedPrompts = await loadChainedPrompts(
         agentConfig.chainedPromptsPath,
@@ -439,21 +457,30 @@ export async function executeAgent(
       debug(`[ChainedPrompts] No chainedPromptsPath for agent '${agentId}'`);
     }
 
+    debug(`[AgentRunner] Returning result: monitoringAgentId=%d chainedPrompts=%d`,
+      monitoringAgentId ?? -1, chainedPrompts?.length ?? 0);
+
     return {
       output: stdout,
       agentId: monitoringAgentId,
       chainedPrompts,
     };
-  } catch (error) {
+  } catch (err) {
+    debug(`[AgentRunner] Error during execution: %s`, (err as Error).message);
+
     // Mark agent as failed (unless already paused - that means intentional abort)
     if (monitor && monitoringAgentId !== undefined) {
       const agent = monitor.getAgent(monitoringAgentId);
+      debug(`[AgentRunner] Agent status: %s`, agent?.status ?? '(not found)');
       if (agent?.status !== 'paused') {
-        await monitor.fail(monitoringAgentId, error as Error);
+        debug(`[AgentRunner] Marking agent %d as failed`, monitoringAgentId);
+        await monitor.fail(monitoringAgentId, err as Error);
+      } else {
+        debug(`[AgentRunner] Agent is paused, not marking as failed`);
       }
       // Note: Don't close stream here - workflow may write more messages
       // Streams will be closed by cleanup handlers or monitoring service shutdown
     }
-    throw error;
+    throw err;
   }
 }

src/agents/runner/runner.ts

@@ -112,6 +112,19 @@ export function OutputWindow(props: OutputWindowProps) {
 
     // Running but not waiting for input
     if (status === "running" || status === "stopping") {
+      // Preserve chained step info even when agent is working
+      if (inputState?.queuedPrompts && inputState.queuedPrompts.length > 0) {
+        const idx = inputState.currentIndex ?? 0
+        const prompt = inputState.queuedPrompts[idx]
+        return {
+          mode: "passive",
+          chainedStep: {
+            name: prompt?.name ?? "next step",
+            index: idx + 1,
+            total: inputState.queuedPrompts.length,
+          },
+        }
+      }
       return { mode: "passive" }
     }
 

src/cli/tui/routes/workflow/components/output/output-window.tsx

@@ -22,7 +22,7 @@ type PendingPaste = { placeholder: string; content: string }
 
 export type PromptLineState =
   | { mode: "disabled" }
-  | { mode: "passive" }
+  | { mode: "passive"; chainedStep?: { name: string; index: number; total: number } }
   | { mode: "active"; reason?: "paused" | "chaining" }
   | { mode: "chained"; name: string; description: string; index: number; total: number }
 
@@ -306,6 +306,11 @@ export function PromptLine(props: PromptLineProps) {
   }
 
   const getHint = () => {
+    // Show chained step info even in passive mode
+    if (props.state.mode === "passive" && props.state.chainedStep) {
+      const step = props.state.chainedStep
+      return `Step ${step.index}/${step.total}: ${step.name}`
+    }
     if (!isInteractive()) return null
     if (props.state.mode === "chained") {
       return `Step ${props.state.index}/${props.state.total}: ${props.state.name}`