@pellux/goodvibes-tui 0.18.4

package/src/runtime/bootstrap-hook-bridge.ts

@@ -0,0 +1,271 @@
+import type { ConversationManager } from '../core/conversation.ts';
+import type { HookDispatcher } from '../hooks/index.ts';
+import type { HookCategory, HookEventPath, HookPhase } from '@pellux/goodvibes-sdk/platform/hooks/types';
+import type { MutableRuntimeState } from './context.ts';
+import type { AgentEvent, OpsEvent, RuntimeEventBus, WorkflowEvent } from './events/index.ts';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { emitSessionResumed } from './emitters/index.ts';
+import { HelperModel } from '../config/helper-model.ts';
+import type { ConfigManager } from '../config/manager.ts';
+import { formatReturnContextForDisplay, getReturnContextMode, maybeAssistReturnContextSummary } from './session-return-context.ts';
+import type { SharedSessionBroker } from '../control-plane/index.ts';
+import type { SessionManager } from '../sessions/manager.ts';
+import type { PanelManager } from '../panels/panel-manager.ts';
+import type { ProviderRegistry } from '../providers/registry.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+
+interface FireHookOptions {
+  readonly hookDispatcher: HookDispatcher;
+  readonly runtime: MutableRuntimeState;
+}
+
+function fireHook(
+  options: FireHookOptions,
+  path: HookEventPath,
+  phase: HookPhase,
+  category: HookCategory,
+  specific: string,
+  payload: Record<string, unknown>,
+): void {
+  options.hookDispatcher.fire({
+    path,
+    phase,
+    category,
+    specific,
+    sessionId: options.runtime.sessionId,
+    timestamp: Date.now(),
+    payload,
+  }).catch((err: unknown) => logger.debug('Hook bridge fire error', { path, error: summarizeError(err) }));
+}
+
+export interface ResumeSessionOptions {
+  readonly runtimeBus: RuntimeEventBus;
+  readonly runtime: MutableRuntimeState;
+  readonly conversation: ConversationManager;
+  readonly requestRender: () => void;
+  readonly onSessionIdChanged?: (sessionId: string) => void;
+  readonly sharedSessionBroker: Pick<SharedSessionBroker, 'reopenSession'>;
+  readonly writeLastSessionPointer: (sessionId: string) => void;
+  readonly hookDispatcher: HookDispatcher;
+  readonly sessionManager: SessionManager;
+  readonly panelManager: PanelManager;
+  readonly configManager: Pick<ConfigManager, 'get' | 'getCategory'>;
+  readonly providerRegistry: Pick<ProviderRegistry, 'get' | 'getCurrentModel' | 'getForModel'>;
+}
+
+export function createResumeSessionHandler(options: ResumeSessionOptions): (sessionId: string) => void {
+  const fireOptions: FireHookOptions = {
+    hookDispatcher: options.hookDispatcher,
+    runtime: options.runtime,
+  };
+  return (sessionId: string): void => {
+    try {
+      const { messages, meta } = options.sessionManager.load(sessionId);
+      emitSessionResumed(options.runtimeBus, {
+        sessionId: options.runtime.sessionId,
+        traceId: `${options.runtime.sessionId}:session-resume:${sessionId}`,
+        source: 'bootstrap',
+      }, {
+        sessionId,
+        turnCount: messages.length,
+      });
+      options.conversation.fromJSON({
+        messages: messages as Parameters<typeof options.conversation.fromJSON>[0]['messages'],
+        title: meta.title,
+        titleSource: meta.titleSource,
+      });
+      options.runtime.sessionId = sessionId;
+      options.onSessionIdChanged?.(sessionId);
+      if (meta?.model) options.runtime.model = meta.model;
+      if (meta?.provider) options.runtime.provider = meta.provider;
+      options.writeLastSessionPointer(sessionId);
+      void options.sharedSessionBroker.reopenSession(sessionId).catch(() => {});
+      options.conversation.log(`Resumed session: ${sessionId}`, { fg: '135' });
+      const reopenedPanels: string[] = [];
+      if (meta.returnContext?.openPanels?.length) {
+        for (const panelId of meta.returnContext.openPanels.slice(0, 4)) {
+          try {
+            options.panelManager.open(panelId);
+            reopenedPanels.push(panelId);
+          } catch {
+            // Ignore unavailable panels during restore.
+          }
+        }
+        if (reopenedPanels.length > 0) options.panelManager.show();
+      }
+      const returnContextMode = getReturnContextMode(options.configManager);
+      if (returnContextMode !== 'off' && meta.returnContext) {
+        for (const line of formatReturnContextForDisplay(meta.returnContext)) {
+          options.conversation.log(`Resume: ${line}`, { fg: '244' });
+        }
+        if (reopenedPanels.length > 0) {
+          options.conversation.log(`Resume: Reopened panels: ${reopenedPanels.join(', ')}`, { fg: '244' });
+        }
+        if ((meta.returnContext.remoteRunners?.length ?? 0) > 0) {
+          options.conversation.log(`Resume: Remote re-entry -> /remote recover ${meta.returnContext.remoteRunners![0]}`, { fg: '244' });
+        }
+        if ((meta.returnContext.worktreePaths?.length ?? 0) > 0) {
+          options.conversation.log('Resume: Worktree re-entry -> /worktree review', { fg: '244' });
+        }
+        if (returnContextMode === 'assisted') {
+          const helperModel = new HelperModel({
+            configManager: options.configManager,
+            providerRegistry: options.providerRegistry,
+          });
+          void maybeAssistReturnContextSummary(options.configManager, helperModel, meta.returnContext).then((assisted) => {
+            if (!assisted.assistedNarrative) return;
+            options.conversation.log(`Resume: ${assisted.assistedNarrative}`, { fg: '244' });
+            options.requestRender();
+          });
+        }
+      }
+      fireHook(fireOptions, 'Lifecycle:session:load', 'Lifecycle', 'session', 'load', { sessionId });
+    } catch (error) {
+      logger.debug('resumeSession failed', { error: summarizeError(error) });
+      options.conversation.log('Failed to resume session.', { fg: '#ef4444' });
+    }
+    options.requestRender();
+  };
+}
+
+export interface HookBridgeRegistrationOptions {
+  readonly runtimeBus: RuntimeEventBus;
+  readonly hookDispatcher: HookDispatcher;
+  readonly runtime: MutableRuntimeState;
+}
+
+export function registerBootstrapHookBridge(
+  options: HookBridgeRegistrationOptions,
+): Array<() => void> {
+  const fireOptions: FireHookOptions = {
+    hookDispatcher: options.hookDispatcher,
+    runtime: options.runtime,
+  };
+  const unsubs: Array<() => void> = [];
+  const { runtimeBus } = options;
+
+  unsubs.push(runtimeBus.on<Extract<AgentEvent, { type: 'AGENT_SPAWNING' }>>('AGENT_SPAWNING', ({ payload }) => {
+    fireHook(fireOptions, 'Lifecycle:agent:spawned', 'Lifecycle', 'agent', 'spawned', { agentId: payload.agentId, task: payload.task });
+  }));
+  unsubs.push(runtimeBus.on<Extract<AgentEvent, { type: 'AGENT_COMPLETED' }>>('AGENT_COMPLETED', ({ payload }) => {
+    fireHook(fireOptions, 'Lifecycle:agent:completed', 'Lifecycle', 'agent', 'completed', {
+      agentId: payload.agentId,
+      result: {
+        durationMs: payload.durationMs,
+        ...(payload.output !== undefined ? { output: payload.output } : {}),
+        ...(payload.toolCallsMade !== undefined ? { toolCallsMade: payload.toolCallsMade } : {}),
+      },
+    });
+  }));
+  unsubs.push(runtimeBus.on<Extract<AgentEvent, { type: 'AGENT_FAILED' }>>('AGENT_FAILED', ({ payload }) => {
+    const specific = payload.error === 'Agent cancelled' || payload.error.includes('cancelled') ? 'cancelled' : 'failed';
+    fireHook(fireOptions, `Lifecycle:agent:${specific}` as HookEventPath, 'Lifecycle', 'agent', specific, { agentId: payload.agentId, error: payload.error });
+  }));
+
+  unsubs.push(runtimeBus.on<Extract<WorkflowEvent, { type: 'WORKFLOW_CHAIN_CREATED' }>>('WORKFLOW_CHAIN_CREATED', ({ payload }) => {
+    fireHook(fireOptions, 'Lifecycle:workflow:started', 'Lifecycle', 'workflow', 'started', { chainId: payload.chainId, task: payload.task });
+  }));
+  unsubs.push(runtimeBus.on<Extract<WorkflowEvent, { type: 'WORKFLOW_CHAIN_PASSED' }>>('WORKFLOW_CHAIN_PASSED', ({ payload }) => {
+    fireHook(fireOptions, 'Lifecycle:workflow:completed', 'Lifecycle', 'workflow', 'completed', { chainId: payload.chainId });
+  }));
+  unsubs.push(runtimeBus.on<Extract<WorkflowEvent, { type: 'WORKFLOW_CHAIN_FAILED' }>>('WORKFLOW_CHAIN_FAILED', ({ payload }) => {
+    fireHook(fireOptions, 'Lifecycle:workflow:failed', 'Lifecycle', 'workflow', 'failed', { chainId: payload.chainId, reason: payload.reason });
+  }));
+  unsubs.push(runtimeBus.on<Extract<WorkflowEvent, { type: 'WORKFLOW_REVIEW_COMPLETED' }>>('WORKFLOW_REVIEW_COMPLETED', ({ payload }) => {
+    fireHook(fireOptions, 'Lifecycle:workflow:reviewed', 'Lifecycle', 'workflow', 'reviewed', {
+      chainId: payload.chainId,
+      score: payload.score,
+      passed: payload.passed,
+    });
+  }));
+  unsubs.push(runtimeBus.on<Extract<WorkflowEvent, { type: 'WORKFLOW_FIX_ATTEMPTED' }>>('WORKFLOW_FIX_ATTEMPTED', ({ payload }) => {
+    fireHook(fireOptions, 'Lifecycle:workflow:fix-attempted', 'Lifecycle', 'workflow', 'fix-attempted', {
+      chainId: payload.chainId,
+      attempt: payload.attempt,
+      maxAttempts: payload.maxAttempts,
+    });
+  }));
+  unsubs.push(runtimeBus.on<Extract<WorkflowEvent, { type: 'WORKFLOW_GATE_RESULT' }>>('WORKFLOW_GATE_RESULT', ({ payload }) => {
+    fireHook(fireOptions, 'Lifecycle:workflow:gate-result', 'Lifecycle', 'workflow', 'gate-result', {
+      chainId: payload.chainId,
+      gate: payload.gate,
+      passed: payload.passed,
+    });
+  }));
+  unsubs.push(runtimeBus.on<Extract<import('@pellux/goodvibes-sdk/platform/runtime/events/orchestration').OrchestrationEvent, { type: 'ORCHESTRATION_GRAPH_CREATED' }>>('ORCHESTRATION_GRAPH_CREATED', ({ payload }) => {
+    fireHook(fireOptions, 'Lifecycle:orchestration:graph-created', 'Lifecycle', 'orchestration', 'graph-created', {
+      graphId: payload.graphId,
+      title: payload.title,
+      mode: payload.mode,
+    });
+  }));
+  unsubs.push(runtimeBus.on<Extract<import('@pellux/goodvibes-sdk/platform/runtime/events/orchestration').OrchestrationEvent, { type: 'ORCHESTRATION_NODE_STARTED' }>>('ORCHESTRATION_NODE_STARTED', ({ payload }) => {
+    fireHook(fireOptions, 'Lifecycle:orchestration:node-started', 'Lifecycle', 'orchestration', 'node-started', {
+      graphId: payload.graphId,
+      nodeId: payload.nodeId,
+      ...(payload.taskId !== undefined ? { taskId: payload.taskId } : {}),
+      ...(payload.agentId !== undefined ? { agentId: payload.agentId } : {}),
+    });
+  }));
+  unsubs.push(runtimeBus.on<Extract<import('@pellux/goodvibes-sdk/platform/runtime/events/orchestration').OrchestrationEvent, { type: 'ORCHESTRATION_NODE_COMPLETED' }>>('ORCHESTRATION_NODE_COMPLETED', ({ payload }) => {
+    fireHook(fireOptions, 'Lifecycle:orchestration:node-completed', 'Lifecycle', 'orchestration', 'node-completed', {
+      graphId: payload.graphId,
+      nodeId: payload.nodeId,
+      ...(payload.summary !== undefined ? { summary: payload.summary } : {}),
+    });
+  }));
+  unsubs.push(runtimeBus.on<Extract<import('@pellux/goodvibes-sdk/platform/runtime/events/orchestration').OrchestrationEvent, { type: 'ORCHESTRATION_NODE_FAILED' }>>('ORCHESTRATION_NODE_FAILED', ({ payload }) => {
+    fireHook(fireOptions, 'Lifecycle:orchestration:node-failed', 'Lifecycle', 'orchestration', 'node-failed', {
+      graphId: payload.graphId,
+      nodeId: payload.nodeId,
+      error: payload.error,
+    });
+  }));
+  unsubs.push(runtimeBus.on<Extract<import('@pellux/goodvibes-sdk/platform/runtime/events/orchestration').OrchestrationEvent, { type: 'ORCHESTRATION_RECURSION_GUARD_TRIGGERED' }>>('ORCHESTRATION_RECURSION_GUARD_TRIGGERED', ({ payload }) => {
+    fireHook(fireOptions, 'Change:orchestration:recursion-guard', 'Change', 'orchestration', 'recursion-guard', {
+      graphId: payload.graphId,
+      ...(payload.nodeId !== undefined ? { nodeId: payload.nodeId } : {}),
+      depth: payload.depth,
+      activeAgents: payload.activeAgents,
+      reason: payload.reason,
+    });
+  }));
+  unsubs.push(runtimeBus.on<Extract<import('@pellux/goodvibes-sdk/platform/runtime/events/communication').CommunicationEvent, { type: 'COMMUNICATION_SENT' }>>('COMMUNICATION_SENT', ({ payload }) => {
+    fireHook(fireOptions, 'Lifecycle:communication:sent', 'Lifecycle', 'communication', 'sent', {
+      messageId: payload.messageId,
+      fromId: payload.fromId,
+      toId: payload.toId,
+      scope: payload.scope,
+      kind: payload.kind,
+      ...(payload.fromRole !== undefined ? { fromRole: payload.fromRole } : {}),
+      ...(payload.toRole !== undefined ? { toRole: payload.toRole } : {}),
+    });
+  }));
+  unsubs.push(runtimeBus.on<Extract<import('@pellux/goodvibes-sdk/platform/runtime/events/communication').CommunicationEvent, { type: 'COMMUNICATION_DELIVERED' }>>('COMMUNICATION_DELIVERED', ({ payload }) => {
+    fireHook(fireOptions, 'Lifecycle:communication:delivered', 'Lifecycle', 'communication', 'delivered', {
+      messageId: payload.messageId,
+      fromId: payload.fromId,
+      toId: payload.toId,
+      scope: payload.scope,
+      kind: payload.kind,
+    });
+  }));
+  unsubs.push(runtimeBus.on<Extract<import('@pellux/goodvibes-sdk/platform/runtime/events/communication').CommunicationEvent, { type: 'COMMUNICATION_BLOCKED' }>>('COMMUNICATION_BLOCKED', ({ payload }) => {
+    fireHook(fireOptions, 'Change:communication:blocked', 'Change', 'communication', 'blocked', {
+      messageId: payload.messageId,
+      fromId: payload.fromId,
+      toId: payload.toId,
+      scope: payload.scope,
+      kind: payload.kind,
+      reason: payload.reason,
+      ...(payload.fromRole !== undefined ? { fromRole: payload.fromRole } : {}),
+      ...(payload.toRole !== undefined ? { toRole: payload.toRole } : {}),
+    });
+  }));
+  unsubs.push(runtimeBus.on<Extract<OpsEvent, { type: 'OPS_CONTEXT_WARNING' }>>('OPS_CONTEXT_WARNING', ({ payload: { usage, threshold } }) => {
+    const specific = usage >= threshold ? 'exceeded' : 'warning';
+    fireHook(fireOptions, `Change:budget:${specific}` as HookEventPath, 'Change', 'budget', specific, { usage, threshold });
+  }));
+
+  return unsubs;
+}

package/src/runtime/bootstrap-runtime-events.ts

@@ -0,0 +1,254 @@
+import type { ConfigManager } from '../config/manager.ts';
+import type { SystemMessageRouter } from '../core/system-message-router.ts';
+import type { ConversationFollowUpItem } from '@pellux/goodvibes-sdk/platform/core/conversation-follow-ups';
+import type { AgentEvent, ProviderEvent, RuntimeEventBus, WorkflowEvent } from './events/index.ts';
+import type { createDomainDispatch } from './store/index.ts';
+import type { WrfcController } from '../agents/wrfc-controller.ts';
+import type { AgentManager } from '../tools/agent/index.ts';
+
+const AGENT_STATUS_INTERVAL_MS = 30_000;
+
+export interface BootstrapRuntimeEventBridgeOptions {
+  readonly runtimeBus: RuntimeEventBus;
+  readonly domainDispatch: ReturnType<typeof createDomainDispatch>;
+  readonly getSystemMessageRouter: () => SystemMessageRouter | null;
+  readonly queueConversationFollowUp?: (item: ConversationFollowUpItem) => void;
+  readonly requestRender: () => void;
+  readonly configManager: ConfigManager;
+  readonly agentManager: AgentManager;
+  readonly wrfcController: WrfcController;
+}
+
+function withRouter(
+  getSystemMessageRouter: () => SystemMessageRouter | null,
+  action: (router: SystemMessageRouter) => void,
+): void {
+  const router = getSystemMessageRouter();
+  if (router) action(router);
+}
+
+function buildCohortReport(agentManager: AgentManager, cohort: string): string {
+  const agents = agentManager.listByCohort(cohort);
+  if (agents.length === 0) return `[Agents] Cohort '${cohort}' complete (no agents found).`;
+  const completed = agents.filter((agent) => agent.status === 'completed').length;
+  const failed = agents.filter((agent) => agent.status === 'failed').length;
+  const cancelled = agents.filter((agent) => agent.status === 'cancelled').length;
+  const lines: string[] = [
+    `[Agents] Cohort '${cohort}' complete: ${completed} completed, ${failed} failed, ${cancelled} cancelled (${agents.length} total)`,
+  ];
+  for (const agent of agents) {
+    const durationSeconds = agent.completedAt !== undefined ? Math.round((agent.completedAt - agent.startedAt) / 1000) : 0;
+    const icon = agent.status === 'completed' ? '\u2713' : agent.status === 'failed' ? '\u2717' : '~';
+    const errorSuffix = agent.error ? ` \u2014 ${agent.error.slice(0, 60)}` : '';
+    lines.push(`  ${icon} ${agent.id.slice(-8)}: ${agent.status} in ${durationSeconds}s (${agent.toolCallCount} tool calls)${errorSuffix}`);
+  }
+  return lines.join('\n');
+}
+
+function buildCohortFollowUp(agentManager: AgentManager, cohort: string): ConversationFollowUpItem {
+  const agents = agentManager.listByCohort(cohort);
+  const completed = agents.filter((agent) => agent.status === 'completed').length;
+  const failed = agents.filter((agent) => agent.status === 'failed').length;
+  const cancelled = agents.filter((agent) => agent.status === 'cancelled').length;
+  return {
+    key: `cohort:${cohort}:complete`,
+    summary: `Agent cohort "${cohort}" finished with ${completed} completed, ${failed} failed, and ${cancelled} cancelled out of ${agents.length} total agents.`,
+  };
+}
+
+function checkCohortCompletion(
+  agentManager: AgentManager,
+  wrfcController: WrfcController,
+  record: { cohort?: string } | null,
+  getSystemMessageRouter: () => SystemMessageRouter | null,
+  queueConversationFollowUp?: (item: ConversationFollowUpItem) => void,
+): void {
+  if (!record?.cohort) return;
+  const cohortAgents = agentManager.listByCohort(record.cohort);
+  const allAgentsDone = cohortAgents.every((agent) => agent.status !== 'running' && agent.status !== 'pending');
+  if (!allAgentsDone) return;
+
+  const allChains = wrfcController.listChains();
+  const cohortAgentIds = new Set(cohortAgents.map((agent) => agent.id));
+  const cohortChains = allChains.filter((chain) =>
+    (chain.engineerAgentId && cohortAgentIds.has(chain.engineerAgentId))
+      || (chain.reviewerAgentId && cohortAgentIds.has(chain.reviewerAgentId))
+      || (chain.fixerAgentId && cohortAgentIds.has(chain.fixerAgentId)),
+  );
+  const terminalStates = new Set(['passed', 'failed']);
+  const allChainsDone = cohortChains.every((chain) => terminalStates.has(chain.state));
+  if (!allChainsDone) return;
+
+  withRouter(getSystemMessageRouter, (router) => {
+    router.low(buildCohortReport(agentManager, record.cohort!));
+  });
+  queueConversationFollowUp?.(buildCohortFollowUp(agentManager, record.cohort));
+}
+
+export function registerBootstrapRuntimeEvents(
+  options: BootstrapRuntimeEventBridgeOptions,
+): { unsubs: Array<() => void>; agentStatusIntervalRef: { value: ReturnType<typeof setInterval> | null } } {
+  const {
+    runtimeBus,
+    domainDispatch,
+    getSystemMessageRouter,
+    queueConversationFollowUp,
+    requestRender,
+    configManager,
+    agentManager,
+    wrfcController,
+  } = options;
+  const unsubs: Array<() => void> = [];
+
+  unsubs.push(runtimeBus.onDomain('turn', (env) => {
+    domainDispatch.dispatchTurnEvent(env.payload);
+  }));
+  unsubs.push(runtimeBus.onDomain('agents', (env) => {
+    domainDispatch.dispatchAgentEvent(env.payload);
+  }));
+  unsubs.push(runtimeBus.onDomain('orchestration', (env) => {
+    domainDispatch.dispatchOrchestrationEvent(env.payload);
+  }));
+  unsubs.push(runtimeBus.onDomain('communication', (env) => {
+    domainDispatch.dispatchCommunicationEvent(env.payload);
+  }));
+  unsubs.push(runtimeBus.onDomain('compaction', (env) => {
+    domainDispatch.dispatchCompactionEvent(env.payload);
+  }));
+  unsubs.push(runtimeBus.onDomain('transport', (env) => {
+    domainDispatch.dispatchTransportEvent(env.payload);
+  }));
+
+  unsubs.push(runtimeBus.on<Extract<WorkflowEvent, { type: 'WORKFLOW_CASCADE_ABORTED' }>>('WORKFLOW_CASCADE_ABORTED', ({ payload }) => {
+    withRouter(getSystemMessageRouter, (router) => {
+      router.wrfc(`[WRFC] Cascade abort: ${payload.reason} (chain ${payload.chainId})`);
+    });
+    requestRender();
+  }));
+
+  unsubs.push(runtimeBus.on<Extract<ProviderEvent, { type: 'MODEL_FALLBACK' }>>('MODEL_FALLBACK', ({ payload }) => {
+    withRouter(getSystemMessageRouter, (router) => {
+      router.high(`[Model] ${payload.from} exhausted across all providers. Automatically falling back to ${payload.to} via ${payload.provider}.`);
+    });
+    requestRender();
+  }));
+
+  unsubs.push(runtimeBus.on<Extract<WorkflowEvent, { type: 'WORKFLOW_CHAIN_CREATED' }>>('WORKFLOW_CHAIN_CREATED', ({ payload }) => {
+    withRouter(getSystemMessageRouter, (router) => {
+      router.wrfc(`[WRFC] Chain ${payload.chainId} started: ${payload.task}`);
+    });
+    requestRender();
+  }));
+
+  unsubs.push(runtimeBus.on<Extract<WorkflowEvent, { type: 'WORKFLOW_REVIEW_COMPLETED' }>>('WORKFLOW_REVIEW_COMPLETED', ({ payload }) => {
+    const icon = payload.passed ? '\u2713' : '\u2717';
+    const threshold = configManager.get('wrfc.scoreThreshold') as number;
+    const suffix = payload.passed ? '' : ` - Minimum score is ${threshold}/10, spawning a fix agent ...`;
+    withRouter(getSystemMessageRouter, (router) => {
+      router.wrfc(`[WRFC] ${icon} Review ${payload.chainId.slice(0, 12)}: ${payload.score}/10${suffix}`);
+    });
+    requestRender();
+  }));
+
+  unsubs.push(runtimeBus.on<Extract<WorkflowEvent, { type: 'WORKFLOW_CHAIN_PASSED' }>>('WORKFLOW_CHAIN_PASSED', ({ payload }) => {
+    withRouter(getSystemMessageRouter, (router) => {
+      router.wrfc(`[WRFC] \u2713 Chain ${payload.chainId.slice(0, 12)} PASSED \u2014 all gates clear`);
+    });
+    queueConversationFollowUp?.({
+      key: `wrfc:${payload.chainId}:passed`,
+      summary: `WRFC chain ${payload.chainId.slice(0, 12)} passed all gates.`,
+    });
+    const chain = wrfcController.getChain(payload.chainId);
+    if (chain?.engineerAgentId) {
+      const record = agentManager.getStatus(chain.engineerAgentId);
+      checkCohortCompletion(agentManager, wrfcController, record ?? null, getSystemMessageRouter, queueConversationFollowUp);
+    }
+    requestRender();
+  }));
+
+  unsubs.push(runtimeBus.on<Extract<WorkflowEvent, { type: 'WORKFLOW_CHAIN_FAILED' }>>('WORKFLOW_CHAIN_FAILED', ({ payload }) => {
+    withRouter(getSystemMessageRouter, (router) => {
+      router.wrfc(`[WRFC] \u2717 Chain ${payload.chainId.slice(0, 12)} FAILED: ${payload.reason.slice(0, 80)}`);
+    });
+    queueConversationFollowUp?.({
+      key: `wrfc:${payload.chainId}:failed`,
+      summary: `WRFC chain ${payload.chainId.slice(0, 12)} failed: ${payload.reason.slice(0, 120)}`,
+    });
+    const chain = wrfcController.getChain(payload.chainId);
+    if (chain?.engineerAgentId) {
+      const record = agentManager.getStatus(chain.engineerAgentId);
+      checkCohortCompletion(agentManager, wrfcController, record ?? null, getSystemMessageRouter, queueConversationFollowUp);
+    }
+    requestRender();
+  }));
+
+  unsubs.push(runtimeBus.on<Extract<WorkflowEvent, { type: 'WORKFLOW_AUTO_COMMITTED' }>>('WORKFLOW_AUTO_COMMITTED', ({ payload }) => {
+    const suffix = payload.commitHash ? ` (${payload.commitHash.slice(0, 7)})` : '';
+    withRouter(getSystemMessageRouter, (router) => {
+      router.wrfc(`[WRFC] Auto-committed chain ${payload.chainId.slice(0, 12)}${suffix}`);
+    });
+    requestRender();
+  }));
+
+  unsubs.push(runtimeBus.on<Extract<WorkflowEvent, { type: 'WORKFLOW_GATE_RESULT' }>>('WORKFLOW_GATE_RESULT', ({ payload }) => {
+    const icon = payload.passed ? '\u2713' : '\u2717';
+    withRouter(getSystemMessageRouter, (router) => {
+      router.wrfc(`[WRFC]   ${icon} Gate: ${payload.gate} ${payload.passed ? 'passed' : 'FAILED'}`);
+    });
+    requestRender();
+  }));
+
+  unsubs.push(runtimeBus.on<Extract<AgentEvent, { type: 'AGENT_STREAM_DELTA' }>>('AGENT_STREAM_DELTA', () => {
+    requestRender();
+  }));
+  unsubs.push(runtimeBus.on<Extract<AgentEvent, { type: 'AGENT_PROGRESS' }>>('AGENT_PROGRESS', () => {
+    requestRender();
+  }));
+
+  unsubs.push(runtimeBus.on<Extract<AgentEvent, { type: 'AGENT_COMPLETED' }>>('AGENT_COMPLETED', ({ payload }) => {
+    const record = agentManager.getStatus(payload.agentId);
+    if (record) {
+      const durationSeconds = record.completedAt !== undefined ? Math.round((record.completedAt - record.startedAt) / 1000) : 0;
+      const taskSnippet = record.task.length > 50 ? `${record.task.slice(0, 50)}\u2026` : record.task;
+      withRouter(getSystemMessageRouter, (router) => {
+        router.low(`[Agents] \u2713 ${record.template} ${payload.agentId.slice(-8)}: "${taskSnippet}" \u2014 completed in ${durationSeconds}s (${record.toolCallCount} tool calls)`);
+      });
+      queueConversationFollowUp?.({
+        key: `agent:${payload.agentId}:completed`,
+        summary: `${record.template} agent ${payload.agentId.slice(-8)} completed "${taskSnippet}" in ${durationSeconds}s after ${record.toolCallCount} tool calls.`,
+      });
+    }
+    checkCohortCompletion(agentManager, wrfcController, record ?? null, getSystemMessageRouter, queueConversationFollowUp);
+    requestRender();
+  }));
+
+  unsubs.push(runtimeBus.on<Extract<AgentEvent, { type: 'AGENT_FAILED' }>>('AGENT_FAILED', ({ payload }) => {
+    const record = agentManager.getStatus(payload.agentId);
+    if (record && record.status !== 'cancelled') {
+      const durationSeconds = record.completedAt !== undefined ? Math.round((record.completedAt - record.startedAt) / 1000) : 0;
+      const taskSnippet = record.task.length > 50 ? `${record.task.slice(0, 50)}\u2026` : record.task;
+      withRouter(getSystemMessageRouter, (router) => {
+        router.low(`[Agents] \u2717 ${record.template} ${payload.agentId.slice(-8)}: "${taskSnippet}" \u2014 failed in ${durationSeconds}s: ${payload.error.slice(0, 80)}`);
+      });
+      queueConversationFollowUp?.({
+        key: `agent:${payload.agentId}:failed`,
+        summary: `${record.template} agent ${payload.agentId.slice(-8)} failed after ${durationSeconds}s while working on "${taskSnippet}": ${payload.error.slice(0, 120)}`,
+      });
+    }
+    checkCohortCompletion(agentManager, wrfcController, record ?? null, getSystemMessageRouter, queueConversationFollowUp);
+    requestRender();
+  }));
+
+  const agentStatusIntervalRef: { value: ReturnType<typeof setInterval> | null } = { value: null };
+  agentStatusIntervalRef.value = setInterval(() => {
+    const running = agentManager.list().filter((agent) => agent.status === 'running');
+    if (running.length === 0) return;
+    const lines = running.map((agent) => `  ${agent.id.slice(-8)}: ${agent.progress ?? agent.status}`);
+    withRouter(getSystemMessageRouter, (router) => {
+      router.low(`[Agents] ${running.length} running:\n${lines.join('\n')}`);
+    });
+    requestRender();
+  }, AGENT_STATUS_INTERVAL_MS);
+
+  return { unsubs, agentStatusIntervalRef };
+}