refactor(controller): centralize engine/model tracking in MonitorService

Remove engine/model from ControllerConfig persistence and consistently use MonitorService as single source of truth
Add error handling for controller view execution
Update all controller-related components to fetch engine/model from MonitorService

Author: moazbuilds

src/cli/tui/routes/workflow/hooks/use-workflow-events.ts

@@ -7,6 +7,7 @@
 import { onMount, onCleanup, createSignal, type Accessor } from "solid-js"
 import { OpenTUIAdapter } from "../adapters/opentui"
 import { loadControllerConfig } from "../../../../../workflows/controller/config.js"
+import { AgentMonitorService } from "../../../../../agents/monitoring/index.js"
 import { debug } from "../../../../../shared/logging/logger.js"
 import path from "path"
 import type { WorkflowEventBus } from "../../../../../workflows/events/index.js"
@@ -79,12 +80,17 @@ export function useWorkflowEvents(options: UseWorkflowEventsOptions): UseWorkflo
     // This enables 'C' key to return to controller even after restart/resume
     if (controllerState?.controllerConfig?.agentId) {
       debug('onMount - setting controllerState in UI from persisted config')
+      // Get engine/model from MonitorService (single source of truth)
+      const monitor = AgentMonitorService.getInstance()
+      const monitoringId = Number(controllerState.controllerConfig.monitoringId) || undefined
+      const controllerAgent = monitoringId ? monitor.getAgent(monitoringId) : undefined
       actions.setControllerState({
         id: controllerState.controllerConfig.agentId,
         name: controllerState.controllerConfig.agentId, // Name may not be persisted, use agentId as fallback
-        engine: 'unknown', // Engine info not persisted in controller config
+        engine: controllerAgent?.engine ?? 'unknown',
+        model: controllerAgent?.modelName,
         telemetry: { tokensIn: 0, tokensOut: 0 }, // Default telemetry, will be updated if controller runs
-        monitoringId: Number(controllerState.controllerConfig.monitoringId) || undefined,
+        monitoringId,
       })
     }
 

src/shared/workflows/template.ts

@@ -26,15 +26,12 @@ export interface StepData {
 
 /**
  * Controller configuration for autonomous mode
+ * Note: engine/model are NOT persisted here - read from MonitorService instead
  */
 export interface ControllerConfig {
   agentId: string;
   sessionId: string;
   monitoringId: number;
-  /** Engine used for this controller session (for resume) */
-  engine?: string;
-  /** Model used for this controller session (for resume) */
-  model?: string;
 }
 
 interface TemplateTracking {

src/workflows/controller/init.ts

@@ -92,13 +92,11 @@ export async function initControllerAgent(
   const resolvedModel = agent.modelName;
   debug('[Controller] Resolved engine=%s model=%s from MonitorService', resolvedEngine, resolvedModel);
 
-  // Build config (include engine/model for resume)
+  // Build config for persistence (engine/model NOT saved - read from MonitorService)
   const config: ControllerConfig = {
     agentId,
     sessionId: agent.sessionId,
     monitoringId: result.agentId!,
-    engine: resolvedEngine,
-    model: resolvedModel,
   };
   debug('[Controller] Built config: %o', config);
 
@@ -107,6 +105,7 @@ export async function initControllerAgent(
   await saveControllerConfig(cmRoot, config);
   debug('[Controller] Controller config saved successfully');
 
+  // Return includes engine/model from MonitorService for UI display
   return {
     ...config,
     engine: resolvedEngine,

src/workflows/controller/view.ts

@@ -90,11 +90,14 @@ export async function runControllerView(
 
     // Return controller info for deferred emission (after workflow:started)
     // This enables the 'c' key to return to controller even while step agent executes
+    // Get engine/model from MonitorService (single source of truth)
+    const monitor = AgentMonitorService.getInstance();
+    const controllerAgent = monitor.getAgent(existingConfig.controllerConfig.monitoringId);
     const controllerInfo = controller ? {
       id: definition.agentId,
       name: (controller.name as string | undefined) ?? controller.id,
-      engine: existingConfig.controllerConfig.engine || 'unknown',
-      model: existingConfig.controllerConfig.model,
+      engine: controllerAgent?.engine ?? 'unknown',
+      model: controllerAgent?.modelName,
     } : undefined;
 
     // Transition to executing view with autonomous mode

src/workflows/indexing/types.ts

@@ -88,13 +88,10 @@ export interface TemplateTracking {
 
 /**
  * Controller configuration for autonomous mode
+ * Note: engine/model are NOT persisted here - read from MonitorService instead
  */
 export interface ControllerConfig {
   agentId: string;
   sessionId: string;
   monitoringId: number;
-  /** Engine used for this controller session (for resume) */
-  engine?: string;
-  /** Model used for this controller session (for resume) */
-  model?: string;
 }

src/workflows/input/providers/controller.ts

@@ -18,7 +18,6 @@ import {
 import { controllerTemplateReview } from '../../../shared/prompts/index.js';
 import type { ControllerConfig } from '../../../shared/workflows/template.js';
 import type { WorkflowEventEmitter } from '../../events/index.js';
-import { registry } from '../../../infra/engines/index.js';
 import type {
   InputProvider,
   InputContext,
@@ -123,11 +122,11 @@ export class ControllerInputProvider implements InputProvider {
       const agentConfig = await loadAgentConfig(config.agentId, this.cmRoot);
       const controllerName = agentConfig.name || config.agentId;
 
-      // Resolve engine and model from config or defaults
-      const defaultEngine = registry.getDefault();
-      const resolvedEngine = (agentConfig.engine as string) ?? defaultEngine?.metadata.id ?? 'unknown';
-      const engineModule = registry.get(resolvedEngine);
-      const resolvedModel = (agentConfig.model as string | undefined) ?? engineModule?.metadata.defaultModel;
+      // Get engine/model from MonitorService (single source of truth)
+      const monitor = AgentMonitorService.getInstance();
+      const controllerAgent = monitor.getAgent(config.monitoringId);
+      const resolvedEngine = controllerAgent?.engine ?? 'unknown';
+      const resolvedModel = controllerAgent?.modelName ?? 'unknown';
 
       // Emit controller info to UI
       if (this.workflowEmitter) {
@@ -146,8 +145,8 @@ export class ControllerInputProvider implements InputProvider {
       // Resume controller session - reuse existing monitoring entry to avoid duplicate agent/log registration
       const result = await executeWithActions(config.agentId, prompt, {
         workingDir: this.cwd,
-        engine: config.engine,
-        model: config.model,
+        engine: resolvedEngine !== 'unknown' ? resolvedEngine : undefined,
+        model: resolvedModel !== 'unknown' ? resolvedModel : undefined,
         resumeSessionId: config.sessionId,
         resumeMonitoringId: config.monitoringId,
         resumePrompt: prompt,

src/workflows/run.ts

@@ -219,13 +219,23 @@ export async function runWorkflow(options: RunWorkflowOptions = {}): Promise<voi
 
   // Run controller view FIRST if needed (blocks until controller done + user confirms)
   // Timeline population happens AFTER controller view since it's only visible in executing view
-  const controllerResult = await runControllerView({
-    cwd,
-    cmRoot,
-    template,
-    emitter,
-    eventBus,
-  });
+  let controllerResult;
+  try {
+    controllerResult = await runControllerView({
+      cwd,
+      cmRoot,
+      template,
+      emitter,
+      eventBus,
+    });
+  } catch (error) {
+    debug('[Workflow] Controller view error: %s', (error as Error).message);
+    emitter.setWorkflowStatus('error');
+    (process as NodeJS.EventEmitter).emit('workflow:error', {
+      reason: (error as Error).message,
+    });
+    throw error;
+  }
 
   // If controller ran, adjust start index to skip the controller agent step
   let actualStartIndex = startIndex;

src/workflows/signals/handlers/return.ts

@@ -9,8 +9,9 @@ import { debug } from '../../../shared/logging/logger.js'
 import { loadControllerConfig, setAutonomousMode } from '../../controller/config.js'
 import { setControllerView } from '../../../shared/workflows/template.js'
 import { formatUserInput } from '../../../shared/formatters/outputMarkers.js'
-import { AgentLoggerService } from '../../../agents/monitoring/index.js'
+import { AgentLoggerService, AgentMonitorService } from '../../../agents/monitoring/index.js'
 import { executeAgent } from '../../../agents/runner/runner.js'
+import { loadAgentConfig } from '../../../agents/runner/config.js'
 import type { SignalContext } from '../manager/types.js'
 
 /**
@@ -76,6 +77,18 @@ export async function handleReturnToControllerSignal(ctx: SignalContext): Promis
   ctx.emitter.updateControllerStatus('awaiting')
   debug('[ReturnToControllerSignal] After updateControllerStatus')
 
+  // Emit controller info with engine from MonitorService (single source of truth)
+  const monitor = AgentMonitorService.getInstance()
+  const controllerAgent = monitor.getAgent(config.monitoringId)
+  const agentConfig = await loadAgentConfig(config.agentId, ctx.cmRoot)
+  const controllerName = agentConfig.name || config.agentId
+  ctx.emitter.setControllerInfo(
+    config.agentId,
+    controllerName,
+    controllerAgent?.engine ?? 'unknown',
+    controllerAgent?.modelName ?? 'unknown'
+  )
+
   // Set autonomous mode to never for conversation (file persistence)
   await setAutonomousMode(ctx.cmRoot, 'never')
 
@@ -132,13 +145,15 @@ export async function handleReturnToControllerSignal(ctx: SignalContext): Promis
         const formatted = formatUserInput(data.prompt)
         AgentLoggerService.getInstance().write(config.monitoringId, `\n${formatted}\n`)
 
+        // Get engine/model from MonitorService for resume
+        const agentInfo = monitor.getAgent(config.monitoringId)
         await executeAgent(config.agentId, data.prompt, {
           workingDir: ctx.cwd,
           resumeSessionId: config.sessionId,
           resumePrompt: data.prompt,
           resumeMonitoringId: config.monitoringId,
-          engine: config.engine,
-          model: config.model,
+          engine: agentInfo?.engine,
+          model: agentInfo?.modelName,
         })
 
         // After response, go back to awaiting input