codingbuddy 4.5.0 → 5.1.0

package/dist/src/tui-bundle.mjs

@@ -1371,12 +1371,12 @@ var require_eventemitter2 = __commonJS({
 });
 
 // src/tui/index.tsx
-import React11 from "react";
+import React16 from "react";
 import { render } from "ink";
 
 // src/tui/dashboard-app.tsx
-import React8, { useMemo as useMemo3 } from "react";
-import { Box as Box8 } from "ink";
+import React13, { useMemo as useMemo7 } from "react";
+import { Box as Box13 } from "ink";
 
 // src/tui/hooks/use-terminal-size.ts
 import { useState, useEffect } from "react";
@@ -1407,6 +1407,23 @@ function createDefaultDashboardNode(params) {
 function createEmptyStageStats() {
   return { running: 0, blocked: 0, waiting: 0, done: 0, error: 0 };
 }
+var TDD_PHASES = Object.freeze(["RED", "GREEN", "REFACTOR"]);
+function createDefaultTddStep(params) {
+  return {
+    agentId: null,
+    status: "pending",
+    ...params
+  };
+}
+function createDefaultReviewResult(params) {
+  return {
+    categories: [],
+    totalScore: 0,
+    maxTotalScore: 100,
+    status: "pending",
+    ...params
+  };
+}
 
 // src/tui/hooks/use-terminal-size.ts
 var DEFAULT_SIZE = { columns: 120, rows: 40 };
@@ -1496,7 +1513,12 @@ var TUI_EVENTS = Object.freeze({
   TOOL_INVOKED: "tool:invoked",
   OBJECTIVE_SET: "objective:set",
   SESSION_RESET: "session:reset",
-  CONTEXT_UPDATED: "context:updated"
+  CONTEXT_UPDATED: "context:updated",
+  DISCUSSION_ROUND_ADDED: "discussion:round-added",
+  TDD_PHASE_CHANGED: "tdd:phase-changed",
+  TDD_STEP_UPDATED: "tdd:step-updated",
+  REVIEW_RESULT_ADDED: "review:result-added",
+  CONNECTION_STATUS_CHANGED: "connection:status-changed"
 });
 
 // src/tui/events/parse-agent.ts
@@ -2150,6 +2172,21 @@ var SUPPORTED_LANGUAGES = {
     name: "Spanish",
     nativeName: "Espa\xF1ol",
     description: "AI responses will be in Spanish"
+  },
+  pt: {
+    name: "Portuguese",
+    nativeName: "Portugu\xEAs",
+    description: "AI responses will be in Portuguese"
+  },
+  de: {
+    name: "German",
+    nativeName: "Deutsch",
+    description: "AI responses will be in German"
+  },
+  fr: {
+    name: "French",
+    nativeName: "Fran\xE7ais",
+    description: "AI responses will be in French"
   }
 };
 var SUPPORTED_LANGUAGE_CODES = Object.keys(
@@ -2629,11 +2666,106 @@ RulesService = __decorateClass([
   Injectable4()
 ], RulesService);
 
+// src/rules/rule-insights.service.ts
+import { Injectable as Injectable5 } from "@nestjs/common";
+var WEEK_MS = 7 * 24 * 60 * 60 * 1e3;
+var MONTH_MS = 30 * 24 * 60 * 60 * 1e3;
+var TOP_RULES_LIMIT = 10;
+var EMERGING_THRESHOLD = 3;
+var SUGGESTION_UNUSED_PREVIEW = 5;
+var RuleInsightsService = class {
+  generateInsights(stats, allRuleNames, now = Date.now()) {
+    const entries = Object.entries(stats);
+    const totalUsageCount = entries.reduce((sum, [, s]) => sum + s.count, 0);
+    const avgCount = entries.length > 0 ? totalUsageCount / entries.length : 0;
+    const topRules = this.buildTopRules(entries, avgCount);
+    const unusedRules = this.findUnusedRules(stats, allRuleNames, now);
+    const activeRules = entries.filter(([, s]) => now - s.lastUsed <= WEEK_MS).length;
+    const staleRules = entries.filter(([, s]) => now - s.lastUsed > MONTH_MS).length;
+    const trends = this.analyzeTrends(entries, avgCount, now);
+    const suggestions = this.generateSuggestions(
+      topRules,
+      unusedRules,
+      trends.declining,
+      entries.length
+    );
+    return {
+      generatedAt: now,
+      summary: {
+        totalRulesTracked: entries.length,
+        totalUsageCount,
+        activeRules,
+        staleRules
+      },
+      topRules: topRules.slice(0, TOP_RULES_LIMIT),
+      unusedRules,
+      trends,
+      suggestions
+    };
+  }
+  buildTopRules(entries, avgCount) {
+    return entries.map(([name, s]) => ({
+      name,
+      count: s.count,
+      lastUsed: s.lastUsed,
+      classification: this.classifyFrequency(s.count, avgCount)
+    })).sort((a, b) => b.count - a.count);
+  }
+  classifyFrequency(count, avgCount) {
+    if (avgCount === 0) return "low";
+    if (count > avgCount * 2) return "high";
+    if (count > avgCount) return "medium";
+    return "low";
+  }
+  findUnusedRules(stats, allRuleNames, now) {
+    return allRuleNames.filter((name) => {
+      const s = stats[name];
+      return !s || now - s.lastUsed > MONTH_MS;
+    });
+  }
+  analyzeTrends(entries, avgCount, now) {
+    const recentlyActive = entries.filter(([, s]) => now - s.lastUsed <= WEEK_MS).map(([name]) => name);
+    const declining = entries.filter(([, s]) => now - s.lastUsed > MONTH_MS && s.count > avgCount).map(([name]) => name);
+    const emerging = entries.filter(([, s]) => now - s.lastUsed <= WEEK_MS && s.count <= EMERGING_THRESHOLD).map(([name]) => name);
+    return { recentlyActive, declining, emerging };
+  }
+  generateSuggestions(topRules, unusedRules, declining, totalTracked) {
+    const suggestions = [];
+    if (totalTracked === 0) {
+      suggestions.push(
+        "No tracking data available yet \u2014 use parse_mode to start collecting rule usage data"
+      );
+      return suggestions;
+    }
+    const highFreq = topRules.filter((r) => r.classification === "high");
+    if (highFreq.length > 0) {
+      suggestions.push(
+        `High-frequency rules [${highFreq.map((r) => r.name).join(", ")}] may need stricter enforcement or developer education`
+      );
+    }
+    if (unusedRules.length > 0) {
+      const preview = unusedRules.slice(0, SUGGESTION_UNUSED_PREVIEW).join(", ");
+      suggestions.push(
+        `${unusedRules.length} unused/stale rules detected \u2014 consider removing or updating: ${preview}`
+      );
+    }
+    if (declining.length > 0) {
+      suggestions.push(
+        `Rules [${declining.join(", ")}] were once active but have declined \u2014 verify they are still relevant`
+      );
+    }
+    return suggestions;
+  }
+};
+RuleInsightsService = __decorateClass([
+  Injectable5()
+], RuleInsightsService);
+
 // src/custom/custom.module.ts
 import { Module } from "@nestjs/common";
 
 // src/custom/custom.service.ts
-import { Injectable as Injectable5, Logger as Logger5 } from "@nestjs/common";
+import { Injectable as Injectable6, Logger as Logger5 } from "@nestjs/common";
 import * as fs from "fs/promises";
 import * as path3 from "path";
 
@@ -2753,7 +2885,7 @@ var CustomService = class {
   }
 };
 CustomService = __decorateClass([
-  Injectable5()
+  Injectable6()
 ], CustomService);
 
 // src/custom/custom.module.ts
@@ -2770,7 +2902,7 @@ CustomModule = __decorateClass([
 import { Module as Module2 } from "@nestjs/common";
 
 // src/config/config.service.ts
-import { Injectable as Injectable6, Logger as Logger6 } from "@nestjs/common";
+import { Injectable as Injectable7, Logger as Logger6 } from "@nestjs/common";
 import { existsSync as existsSync5, statSync } from "fs";
 import { stat, realpath } from "fs/promises";
 import * as path7 from "path";
@@ -2837,6 +2969,22 @@ var TestStrategyConfigSchema = z3.object({
 var AIConfigSchema = z3.object({
   defaultModel: z3.string().optional(),
   primaryAgent: z3.string().optional(),
+  /**
+   * Override default dispatch strength for parallel specialist agents.
+   * - "auto": Always dispatch specialists automatically
+   * - "recommend": Suggest dispatch (default for PLAN/ACT)
+   * - "skip": Do not dispatch specialists
+   *
+   * Default varies by mode: EVAL="auto", PLAN/ACT="recommend"
+   *
+   * @example
+   * ```javascript
+   * ai: {
+   *   dispatchStrength: 'auto',
+   * }
+   * ```
+   */
+  dispatchStrength: z3.enum(["auto", "recommend", "skip"]).optional(),
   /**
    * List of agent names to exclude from automatic resolution.
    * Useful for project-specific exclusions (e.g., exclude mobile-developer for backend-only projects).
@@ -2862,7 +3010,27 @@ var AIConfigSchema = z3.object({
    * }
    * ```
    */
-  maxIncludedSkills: z3.number().int().min(0).max(10).optional()
+  maxIncludedSkills: z3.number().int().min(0).max(10).optional(),
+  /**
+   * Enable/disable automatic plan-reviewer gate after PLAN completion.
+   * When enabled, parse_mode PLAN response includes a planReviewGate recommendation.
+   * Default: true (enabled)
+   *
+   * @example
+   * ```javascript
+   * ai: {
+   *   planReviewGate: false, // disable plan review gate
+   * }
+   * ```
+   */
+  planReviewGate: z3.boolean().optional(),
+  /**
+   * Enable/disable agent discussion integration in EVAL mode.
+   * When enabled, parse_mode EVAL response includes agentDiscussion config
+   * for structuring specialist findings as AgentOpinion protocol.
+   * Default: true (enabled)
+   */
+  agentDiscussion: z3.boolean().optional()
 });
 var AutoConfigSchema = z3.object({
   maxIterations: z3.number().int().min(1).max(10).default(3)
@@ -2879,6 +3047,10 @@ var CodingBuddyConfigSchema = z3.object({
   projectName: z3.string().optional(),
   description: z3.string().optional(),
   repository: z3.string().url().optional(),
+  // Feature Flags
+  eco: z3.boolean().default(true).optional(),
+  tui: z3.boolean().default(true).optional(),
+  tone: z3.enum(["casual", "formal"]).default("casual").optional(),
   // Technical Configuration
   techStack: TechStackConfigSchema.optional(),
   architecture: ArchitectureConfigSchema.optional(),
@@ -2890,6 +3062,8 @@ var CodingBuddyConfigSchema = z3.object({
   auto: AutoConfigSchema.optional(),
   // Context document limits (DoS prevention)
   context: ContextConfigSchema.optional(),
+  // Upstream Repository Mapping (for cross-repo issue creation)
+  upstreamRepos: z3.record(z3.string(), z3.string()).optional(),
   // Additional Context
   keyFiles: z3.array(z3.string()).optional(),
   avoid: z3.array(z3.string()).optional(),
@@ -3738,11 +3912,11 @@ var ConfigService = class {
   }
 };
 ConfigService = __decorateClass([
-  Injectable6()
+  Injectable7()
 ], ConfigService);
 
 // src/config/config-diff.service.ts
-import { Injectable as Injectable7 } from "@nestjs/common";
+import { Injectable as Injectable8 } from "@nestjs/common";
 var ConfigDiffService = class {
   /**
    * Compare project analysis with current config
@@ -3914,7 +4088,7 @@ var ConfigDiffService = class {
   }
 };
 ConfigDiffService = __decorateClass([
-  Injectable7()
+  Injectable8()
 ], ConfigDiffService);
 
 // src/config/config.module.ts
@@ -3933,8 +4107,8 @@ var RulesModule = class {
 RulesModule = __decorateClass([
   Module3({
     imports: [CustomModule, CodingBuddyConfigModule],
-    providers: [RulesService],
-    exports: [RulesService]
+    providers: [RulesService, RuleInsightsService],
+    exports: [RulesService, RuleInsightsService]
   })
 ], RulesModule);
 
@@ -3997,7 +4171,15 @@ function createInitialDashboardState() {
     contextDecisions: [],
     contextNotes: [],
     contextMode: null,
-    contextStatus: null
+    contextStatus: null,
+    discussionRounds: [],
+    tddCurrentPhase: null,
+    tddSteps: [],
+    reviewResults: [],
+    connectionStatus: "connected",
+    sessionStartedAt: Date.now(),
+    modeTransitions: [],
+    fileChanges: { created: 0, modified: 0, deleted: 0 }
   };
 }
 function cloneAgents(agents) {
@@ -4065,7 +4247,16 @@ function dashboardReducer(state, action) {
         }
       }
       const focusedAgentId = selectFocusedAgent(agents, state.focusedAgentId);
-      return { ...state, currentMode: newMode, agents, activeSkills: [], focusedAgentId };
+      const transition = { from, to: newMode, timestamp: Date.now() };
+      const modeTransitions = [...state.modeTransitions, transition];
+      return {
+        ...state,
+        currentMode: newMode,
+        agents,
+        activeSkills: [],
+        focusedAgentId,
+        modeTransitions
+      };
     }
     case "AGENT_RELATIONSHIP": {
       const edge = {
@@ -4130,13 +4321,21 @@ function dashboardReducer(state, action) {
       } else {
         activityHistory = [...history.slice(-59), { timestamp: sec, toolCalls: 1 }];
       }
+      const toolLower = action.payload.toolName.toLowerCase();
+      let fileChanges = state.fileChanges;
+      if (toolLower === "write" || toolLower === "notebookedit") {
+        fileChanges = { ...fileChanges, created: fileChanges.created + 1 };
+      } else if (toolLower === "edit") {
+        fileChanges = { ...fileChanges, modified: fileChanges.modified + 1 };
+      }
       return {
         ...state,
         agents,
         eventLog: [...base, entry],
         toolCalls: [...toolCallsBase, toolCall],
         activityHistory,
-        toolInvokeCount: state.toolInvokeCount + 1
+        toolInvokeCount: state.toolInvokeCount + 1,
+        fileChanges
       };
     }
     case "OBJECTIVE_SET":
@@ -4180,6 +4379,12 @@ function dashboardReducer(state, action) {
         contextStatus: status
       };
     }
+    case "ADD_DISCUSSION_ROUND": {
+      return {
+        ...state,
+        discussionRounds: [...state.discussionRounds, action.payload.round]
+      };
+    }
     case "SESSION_RESET":
       return createInitialDashboardState();
     case "CLEANUP_STALE_AGENTS": {
@@ -4197,6 +4402,24 @@ function dashboardReducer(state, action) {
       const focusedAgentId = selectFocusedAgent(agents, state.focusedAgentId);
       return { ...state, agents, focusedAgentId };
     }
+    case "TDD_PHASE_CHANGED": {
+      return { ...state, tddCurrentPhase: action.payload.phase };
+    }
+    case "TDD_STEP_UPDATED": {
+      const { step } = action.payload;
+      const existing = state.tddSteps.findIndex((s) => s.id === step.id);
+      const tddSteps = existing >= 0 ? state.tddSteps.map((s, i) => i === existing ? step : s) : [...state.tddSteps, step];
+      return { ...state, tddSteps };
+    }
+    case "REVIEW_RESULT_ADDED": {
+      const { result } = action.payload;
+      const idx = state.reviewResults.findIndex((r) => r.agentId === result.agentId);
+      const reviewResults = idx >= 0 ? state.reviewResults.map((r, i) => i === idx ? result : r) : [...state.reviewResults, result];
+      return { ...state, reviewResults };
+    }
+    case "CONNECTION_STATUS_CHANGED": {
+      return { ...state, connectionStatus: action.payload.status };
+    }
     // Reserved: no emitter currently produces PARALLEL_COMPLETED. Subscription kept for forward compatibility.
     case "PARALLEL_COMPLETED":
     case "AGENTS_LOADED":
@@ -4224,6 +4447,11 @@ function useDashboardState(eventBus) {
     const onObjectiveSet = (p) => dispatch({ type: "OBJECTIVE_SET", payload: p });
     const onSessionReset = (p) => dispatch({ type: "SESSION_RESET", payload: p });
     const onContextUpdated = (p) => dispatch({ type: "CONTEXT_UPDATED", payload: p });
+    const onDiscussionRoundAdded = (p) => dispatch({ type: "ADD_DISCUSSION_ROUND", payload: p });
+    const onTddPhaseChanged = (p) => dispatch({ type: "TDD_PHASE_CHANGED", payload: p });
+    const onTddStepUpdated = (p) => dispatch({ type: "TDD_STEP_UPDATED", payload: p });
+    const onReviewResultAdded = (p) => dispatch({ type: "REVIEW_RESULT_ADDED", payload: p });
+    const onConnectionStatusChanged = (p) => dispatch({ type: "CONNECTION_STATUS_CHANGED", payload: p });
     eventBus.on(TUI_EVENTS.AGENT_ACTIVATED, onActivated);
     eventBus.on(TUI_EVENTS.AGENT_DEACTIVATED, onDeactivated);
     eventBus.on(TUI_EVENTS.MODE_CHANGED, onModeChanged);
@@ -4237,6 +4465,11 @@ function useDashboardState(eventBus) {
     eventBus.on(TUI_EVENTS.OBJECTIVE_SET, onObjectiveSet);
     eventBus.on(TUI_EVENTS.SESSION_RESET, onSessionReset);
     eventBus.on(TUI_EVENTS.CONTEXT_UPDATED, onContextUpdated);
+    eventBus.on(TUI_EVENTS.DISCUSSION_ROUND_ADDED, onDiscussionRoundAdded);
+    eventBus.on(TUI_EVENTS.TDD_PHASE_CHANGED, onTddPhaseChanged);
+    eventBus.on(TUI_EVENTS.TDD_STEP_UPDATED, onTddStepUpdated);
+    eventBus.on(TUI_EVENTS.REVIEW_RESULT_ADDED, onReviewResultAdded);
+    eventBus.on(TUI_EVENTS.CONNECTION_STATUS_CHANGED, onConnectionStatusChanged);
     return () => {
       eventBus.off(TUI_EVENTS.AGENT_ACTIVATED, onActivated);
       eventBus.off(TUI_EVENTS.AGENT_DEACTIVATED, onDeactivated);
@@ -4251,6 +4484,11 @@ function useDashboardState(eventBus) {
       eventBus.off(TUI_EVENTS.OBJECTIVE_SET, onObjectiveSet);
       eventBus.off(TUI_EVENTS.SESSION_RESET, onSessionReset);
       eventBus.off(TUI_EVENTS.CONTEXT_UPDATED, onContextUpdated);
+      eventBus.off(TUI_EVENTS.DISCUSSION_ROUND_ADDED, onDiscussionRoundAdded);
+      eventBus.off(TUI_EVENTS.TDD_PHASE_CHANGED, onTddPhaseChanged);
+      eventBus.off(TUI_EVENTS.TDD_STEP_UPDATED, onTddStepUpdated);
+      eventBus.off(TUI_EVENTS.REVIEW_RESULT_ADDED, onReviewResultAdded);
+      eventBus.off(TUI_EVENTS.CONNECTION_STATUS_CHANGED, onConnectionStatusChanged);
     };
   }, [eventBus]);
   useEffect3(() => {
@@ -4490,10 +4728,596 @@ function HeaderBar({
   );
 }
 
-// src/tui/components/FlowMap.tsx
+// src/tui/components/ModeScreenRouter.tsx
+import React7 from "react";
+import { Box as Box7, Text as Text7 } from "ink";
+
+// src/tui/components/PlanModeScreen.tsx
+import React3, { useMemo as useMemo2 } from "react";
+import { Box as Box3, Text as Text3 } from "ink";
+
+// src/collaboration/types.ts
+var STANCES = Object.freeze(["approve", "concern", "reject"]);
+var STANCE_ICONS = Object.freeze({
+  approve: "\u2705",
+  concern: "\u26A0\uFE0F",
+  reject: "\u274C"
+});
+function calculateConsensus(opinions) {
+  const approveCount = opinions.filter((o) => o.stance === "approve").length;
+  const concernCount = opinions.filter((o) => o.stance === "concern").length;
+  const rejectCount = opinions.filter((o) => o.stance === "reject").length;
+  return {
+    totalAgents: opinions.length,
+    approveCount,
+    concernCount,
+    rejectCount,
+    reached: opinions.length > 0 && rejectCount === 0,
+    criticalCount: rejectCount
+  };
+}
+
+// src/tui/components/plan-screen.pure.ts
+function renderAgentSummonList(agents, width) {
+  const lines = [];
+  lines.push({ type: "header", text: "\u{1F4CB} Summoned Agents" });
+  if (agents.size === 0) {
+    lines.push({ type: "empty", text: "  (no agents summoned)" });
+    return lines;
+  }
+  for (const agent of agents.values()) {
+    const statusIcon = getAgentStatusIcon(agent.status);
+    const primaryTag = agent.isPrimary ? " \u2605" : "";
+    const text = `  ${statusIcon} ${agent.name}${primaryTag} [${agent.status}]`;
+    lines.push({ type: "agent", text: text.slice(0, width) });
+  }
+  return lines;
+}
+function getAgentStatusIcon(status) {
+  switch (status) {
+    case "running":
+      return "\u{1F504}";
+    case "done":
+      return "\u2705";
+    case "error":
+      return "\u274C";
+    case "idle":
+      return "\u23F3";
+    case "blocked":
+      return "\u{1F6AB}";
+  }
+}
+function renderConsensusSummary(rounds) {
+  if (rounds.length === 0) {
+    return [{ type: "empty", text: "  (no discussion yet)" }];
+  }
+  const lastRound = rounds[rounds.length - 1];
+  const consensus = calculateConsensus(lastRound.opinions);
+  const lines = [];
+  lines.push({ type: "header", text: `\u{1F5F3}\uFE0F Consensus (Round ${lastRound.roundNumber})` });
+  lines.push({
+    type: "consensus",
+    text: `  ${STANCE_ICONS.approve} ${consensus.approveCount}  ${STANCE_ICONS.concern} ${consensus.concernCount}  ${STANCE_ICONS.reject} ${consensus.rejectCount}`
+  });
+  lines.push({
+    type: "consensus",
+    text: consensus.reached ? "  \u2705 Consensus reached" : "  \u23F3 Consensus not reached"
+  });
+  return lines;
+}
+function renderPlanScreen(agents, rounds, width) {
+  const lines = [];
+  lines.push(...renderAgentSummonList(agents, width));
+  lines.push({ type: "empty", text: "" });
+  lines.push(...renderConsensusSummary(rounds));
+  return lines;
+}
+
+// src/tui/components/AgentDiscussionPanel.tsx
 import React2, { useMemo } from "react";
 import { Box as Box2, Text as Text2 } from "ink";
 
+// src/tui/components/agent-discussion-panel.pure.ts
+var AGENT_PALETTE = [
+  "cyan",
+  "magenta",
+  "yellow",
+  "green",
+  "blue",
+  "red",
+  "white"
+];
+var CROSS_REVIEW_VERBS = {
+  approve: "agrees",
+  concern: "notes",
+  reject: "disagrees"
+};
+function renderStanceHistory(stances) {
+  if (stances.length <= 1) return "";
+  return stances.map((s) => STANCE_ICONS[s]).join(" \u2192 ");
+}
+function assignAgentColors(rounds) {
+  const colors = {};
+  let idx = 0;
+  for (const round of rounds) {
+    for (const opinion of round.opinions) {
+      if (!colors[opinion.agentId]) {
+        colors[opinion.agentId] = AGENT_PALETTE[idx % AGENT_PALETTE.length];
+        idx++;
+      }
+    }
+  }
+  return colors;
+}
+function detectConflicts(opinions) {
+  const hasApprove = opinions.some((o) => o.stance === "approve");
+  const hasReject = opinions.some((o) => o.stance === "reject");
+  if (!hasApprove || !hasReject) return /* @__PURE__ */ new Set();
+  const conflicting = /* @__PURE__ */ new Set();
+  for (const opinion of opinions) {
+    if (opinion.stance === "reject") {
+      conflicting.add(opinion.agentId);
+    }
+  }
+  return conflicting;
+}
+function estimateBlockHeight(block) {
+  switch (block.type) {
+    case "agent-bubble":
+      return 4;
+    // label + border-top + content + border-bottom
+    case "consensus-bar":
+      return 2;
+    default:
+      return 1;
+  }
+}
+function buildAgentNameMap(rounds) {
+  const map = {};
+  for (const round of rounds) {
+    for (const opinion of round.opinions) {
+      map[opinion.agentId] = opinion.agentName;
+    }
+  }
+  return map;
+}
+function buildStanceHistories(rounds) {
+  const histories = {};
+  for (const round of rounds) {
+    for (const opinion of round.opinions) {
+      if (!histories[opinion.agentId]) {
+        histories[opinion.agentId] = [];
+      }
+      histories[opinion.agentId].push(opinion.stance);
+    }
+  }
+  return histories;
+}
+function renderCollaborationBlocks(rounds, _width) {
+  if (rounds.length === 0) {
+    return [{ type: "empty", text: "No agent discussion yet" }];
+  }
+  const blocks = [];
+  const agentNames = buildAgentNameMap(rounds);
+  const agentColors = assignAgentColors(rounds);
+  const stanceHistories = buildStanceHistories(rounds);
+  const latestRound = rounds[rounds.length - 1];
+  const conflicts = detectConflicts(latestRound.opinions);
+  blocks.push({
+    type: "header",
+    text: `\u2500\u2500 Agent Discussion (Round ${latestRound.roundNumber}) \u2500\u2500`
+  });
+  for (const opinion of latestRound.opinions) {
+    const history = stanceHistories[opinion.agentId] ?? [];
+    blocks.push({
+      type: "agent-bubble",
+      agentName: opinion.agentName,
+      agentAvatar: getAgentAvatar(opinion.agentName),
+      color: agentColors[opinion.agentId] ?? "white",
+      stanceIcon: STANCE_ICONS[opinion.stance],
+      reasoning: opinion.reasoning,
+      isConflict: conflicts.has(opinion.agentId),
+      stanceHistoryText: renderStanceHistory(history)
+    });
+  }
+  for (const review of latestRound.crossReviews) {
+    const fromName = agentNames[review.fromAgentId] ?? review.fromAgentId;
+    const toName = agentNames[review.toAgentId] ?? review.toAgentId;
+    blocks.push({
+      type: "cross-review-block",
+      fromName,
+      fromAvatar: getAgentAvatar(fromName),
+      fromColor: agentColors[review.fromAgentId] ?? "white",
+      toName,
+      toAvatar: getAgentAvatar(toName),
+      toColor: agentColors[review.toAgentId] ?? "white",
+      verb: CROSS_REVIEW_VERBS[review.stance],
+      comment: review.comment
+    });
+  }
+  const consensus = calculateConsensus(latestRound.opinions);
+  const percentage = consensus.totalAgents > 0 ? Math.round(consensus.approveCount / consensus.totalAgents * 100) : 0;
+  blocks.push({
+    type: "consensus-bar",
+    approveCount: consensus.approveCount,
+    concernCount: consensus.concernCount,
+    rejectCount: consensus.rejectCount,
+    totalAgents: consensus.totalAgents,
+    reached: consensus.reached,
+    percentage
+  });
+  return blocks;
+}
+
+// src/tui/components/AgentDiscussionPanel.tsx
+function SpeechBubble({
+  block,
+  maxWidth
+}) {
+  const borderColor = block.isConflict ? "red" : block.color;
+  const bubbleWidth = Math.min(maxWidth, 60);
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: block.color, bold: true }, block.agentAvatar, " ", block.agentName), block.isConflict && /* @__PURE__ */ React2.createElement(Text2, { color: "red", bold: true }, " ", "\u26A1"), block.stanceHistoryText !== "" && /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, " (", block.stanceHistoryText, ")")), /* @__PURE__ */ React2.createElement(
+    Box2,
+    {
+      borderStyle: "round",
+      borderColor,
+      paddingLeft: 1,
+      paddingRight: 1,
+      width: bubbleWidth
+    },
+    /* @__PURE__ */ React2.createElement(Text2, { wrap: "truncate" }, block.stanceIcon, " ", block.reasoning)
+  ));
+}
+function ConsensusProgressBar({
+  block,
+  maxWidth
+}) {
+  const barWidth = Math.min(20, Math.max(8, maxWidth - 30));
+  const total = block.totalAgents || 1;
+  const approveLen = Math.round(block.approveCount / total * barWidth);
+  const concernLen = Math.round(block.concernCount / total * barWidth);
+  const remaining = Math.max(0, barWidth - approveLen - concernLen);
+  const filled = "\u2588";
+  const empty = "\u2591";
+  const statusIcon = block.reached ? "\u2705" : "\u23F3";
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true }, statusIcon, " Consensus "), /* @__PURE__ */ React2.createElement(Text2, { color: "green" }, filled.repeat(approveLen)), /* @__PURE__ */ React2.createElement(Text2, { color: "yellow" }, filled.repeat(concernLen)), block.rejectCount > 0 ? /* @__PURE__ */ React2.createElement(Text2, { color: "red" }, filled.repeat(remaining)) : /* @__PURE__ */ React2.createElement(Text2, { color: "gray" }, empty.repeat(remaining)), /* @__PURE__ */ React2.createElement(Text2, { bold: true }, " ", block.percentage, "%")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: "green" }, "\u2705", " ", block.approveCount), /* @__PURE__ */ React2.createElement(Text2, null, " "), /* @__PURE__ */ React2.createElement(Text2, { color: "yellow" }, "\u26A0\uFE0F", " ", block.concernCount), /* @__PURE__ */ React2.createElement(Text2, null, " "), /* @__PURE__ */ React2.createElement(Text2, { color: "red" }, "\u274C", " ", block.rejectCount)));
+}
+function CrossReviewItem({ block }) {
+  return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: block.fromColor }, block.fromAvatar, " ", block.fromName), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, " \u2192 "), /* @__PURE__ */ React2.createElement(Text2, { color: block.toColor }, block.toAvatar, " ", block.toName), /* @__PURE__ */ React2.createElement(Text2, null, " ", block.verb, ": "), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, '"', block.comment, '"'));
+}
+function AgentDiscussionPanel({
+  rounds,
+  width,
+  height
+}) {
+  const blocks = useMemo(() => renderCollaborationBlocks(rounds, width), [rounds, width]);
+  const maxHeight = Math.max(0, height - 2);
+  const visibleBlocks = [];
+  let usedHeight = 0;
+  for (const block of blocks) {
+    const h = estimateBlockHeight(block);
+    if (usedHeight + h > maxHeight) break;
+    visibleBlocks.push(block);
+    usedHeight += h;
+  }
+  const innerWidth = Math.max(10, width - 4);
+  return /* @__PURE__ */ React2.createElement(
+    Box2,
+    {
+      flexDirection: "column",
+      width,
+      height,
+      borderStyle: "round",
+      borderColor: BORDER_COLORS.panel
+    },
+    visibleBlocks.map((block, i) => {
+      switch (block.type) {
+        case "header":
+          return /* @__PURE__ */ React2.createElement(Text2, { key: i, color: "magenta", bold: true }, block.text);
+        case "agent-bubble":
+          return /* @__PURE__ */ React2.createElement(SpeechBubble, { key: i, block, maxWidth: innerWidth });
+        case "cross-review-block":
+          return /* @__PURE__ */ React2.createElement(CrossReviewItem, { key: i, block });
+        case "consensus-bar":
+          return /* @__PURE__ */ React2.createElement(ConsensusProgressBar, { key: i, block, maxWidth: innerWidth });
+        case "empty":
+          return /* @__PURE__ */ React2.createElement(Text2, { key: i, color: "gray", dimColor: true }, block.text);
+      }
+    })
+  );
+}
+
+// src/tui/components/PlanModeScreen.tsx
+var LINE_COLORS = {
+  header: "magenta",
+  agent: "white",
+  discussion: "cyan",
+  consensus: "green",
+  empty: "gray"
+};
+function PlanModeScreen({
+  agents,
+  rounds,
+  width,
+  height
+}) {
+  const summaryLines = useMemo2(
+    () => renderPlanScreen(agents, rounds, width - 2),
+    [agents, rounds, width]
+  );
+  const summaryHeight = Math.max(5, Math.floor(height * 0.4));
+  const discussionHeight = height - summaryHeight;
+  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", width, height }, /* @__PURE__ */ React3.createElement(
+    Box3,
+    {
+      flexDirection: "column",
+      width,
+      height: summaryHeight,
+      borderStyle: "round",
+      borderColor: BORDER_COLORS.panel
+    },
+    summaryLines.slice(0, summaryHeight - 2).map((line, i) => /* @__PURE__ */ React3.createElement(
+      Text3,
+      {
+        key: i,
+        color: LINE_COLORS[line.type],
+        bold: line.type === "header" || line.type === "consensus",
+        dimColor: line.type === "empty",
+        wrap: "truncate"
+      },
+      line.text
+    ))
+  ), rounds.length > 0 && discussionHeight > 3 && /* @__PURE__ */ React3.createElement(AgentDiscussionPanel, { rounds, width, height: discussionHeight }));
+}
+
+// src/tui/components/ActModeScreen.tsx
+import React4, { useMemo as useMemo3 } from "react";
+import { Box as Box4, Text as Text4 } from "ink";
+
+// src/tui/components/act-screen.pure.ts
+var PHASE_ICONS = {
+  RED: "\u{1F534}",
+  GREEN: "\u{1F7E2}",
+  REFACTOR: "\u{1F527}"
+};
+var PHASE_COLORS = {
+  RED: "red",
+  GREEN: "green",
+  REFACTOR: "yellow"
+};
+function renderTddPhaseBar(currentPhase, _width) {
+  const lines = [];
+  lines.push({ type: "header", text: "\u{1F9EA} TDD Cycle" });
+  const phases = ["RED", "GREEN", "REFACTOR"];
+  const parts = phases.map((phase) => {
+    const icon = PHASE_ICONS[phase];
+    const active = phase === currentPhase;
+    const marker = active ? "\u25BA" : " ";
+    return `${marker}${icon} ${phase}`;
+  });
+  lines.push({ type: "phase-bar", text: `  ${parts.join("  \u2192  ")}` });
+  return lines;
+}
+function renderProgressBar(percent, barWidth) {
+  const filled = Math.round(percent / 100 * barWidth);
+  const empty = barWidth - filled;
+  return `[${"\u2588".repeat(filled)}${"\u2591".repeat(empty)}] ${percent}%`;
+}
+function renderTddSteps(steps, width) {
+  const lines = [];
+  lines.push({ type: "header", text: "\u{1F4DD} Steps" });
+  if (steps.length === 0) {
+    lines.push({ type: "empty", text: "  (no steps yet)" });
+    return lines;
+  }
+  for (const step of steps) {
+    const statusIcon = getStepStatusIcon(step.status);
+    const phaseIcon = PHASE_ICONS[step.phase];
+    const agent = step.agentId ? ` [${step.agentId}]` : "";
+    const text = `  ${statusIcon} ${phaseIcon} ${step.label}${agent}`;
+    lines.push({ type: "step", text: text.slice(0, width) });
+  }
+  return lines;
+}
+function getStepStatusIcon(status) {
+  switch (status) {
+    case "pending":
+      return "\u25CB";
+    case "active":
+      return "\u25CF";
+    case "done":
+      return "\u2713";
+    case "failed":
+      return "\u2717";
+  }
+}
+function renderOverallProgress(agents, steps, width) {
+  const lines = [];
+  const totalSteps = steps.length;
+  const doneSteps = steps.filter((s) => s.status === "done").length;
+  const stepPercent = totalSteps > 0 ? Math.round(doneSteps / totalSteps * 100) : 0;
+  const agentArr = Array.from(agents.values()).filter((a) => a.status !== "idle" || a.isParallel);
+  const agentPercent = agentArr.length > 0 ? Math.round(agentArr.reduce((sum, a) => sum + a.progress, 0) / agentArr.length) : 0;
+  const overallPercent = totalSteps > 0 ? stepPercent : agentPercent;
+  const barWidth = Math.max(10, Math.min(40, width - 20));
+  lines.push({ type: "header", text: "\u{1F4CA} Overall Progress" });
+  lines.push({ type: "progress", text: `  ${renderProgressBar(overallPercent, barWidth)}` });
+  if (totalSteps > 0) {
+    lines.push({ type: "progress", text: `  Steps: ${doneSteps}/${totalSteps}` });
+  }
+  return lines;
+}
+function renderActScreen(currentPhase, steps, agents, width) {
+  const lines = [];
+  lines.push(...renderTddPhaseBar(currentPhase, width));
+  lines.push({ type: "empty", text: "" });
+  lines.push(...renderTddSteps(steps, width));
+  lines.push({ type: "empty", text: "" });
+  lines.push(...renderOverallProgress(agents, steps, width));
+  return lines;
+}
+
+// src/tui/components/ActModeScreen.tsx
+function getLineColor(line, currentPhase) {
+  if (line.type === "header") return "magenta";
+  if (line.type === "phase-bar" && currentPhase) return PHASE_COLORS[currentPhase];
+  if (line.type === "progress") return "cyan";
+  if (line.type === "empty") return "gray";
+  return "white";
+}
+function ActModeScreen({
+  currentPhase,
+  steps,
+  agents,
+  width,
+  height
+}) {
+  const lines = useMemo3(
+    () => renderActScreen(currentPhase, steps, agents, width - 2),
+    [currentPhase, steps, agents, width]
+  );
+  const maxLines = Math.max(0, height - 2);
+  const visibleLines = lines.slice(0, maxLines);
+  return /* @__PURE__ */ React4.createElement(
+    Box4,
+    {
+      flexDirection: "column",
+      width,
+      height,
+      borderStyle: "round",
+      borderColor: BORDER_COLORS.panel
+    },
+    visibleLines.map((line, i) => /* @__PURE__ */ React4.createElement(
+      Text4,
+      {
+        key: i,
+        color: getLineColor(line, currentPhase),
+        bold: line.type === "header" || line.type === "phase-bar",
+        dimColor: line.type === "empty",
+        wrap: "truncate"
+      },
+      line.text
+    ))
+  );
+}
+
+// src/tui/components/EvalModeScreen.tsx
+import React5, { useMemo as useMemo4 } from "react";
+import { Box as Box5, Text as Text5 } from "ink";
+
+// src/tui/components/eval-screen.pure.ts
+function renderScoreBar(score, maxScore, barWidth) {
+  const percent = maxScore > 0 ? Math.round(score / maxScore * 100) : 0;
+  const filled = Math.round(percent / 100 * barWidth);
+  const empty = barWidth - filled;
+  return `[${"\u2588".repeat(filled)}${"\u2591".repeat(empty)}] ${score}/${maxScore}`;
+}
+function renderAgentResult(result, width) {
+  const lines = [];
+  const statusIcon = getResultStatusIcon(result.status);
+  const barWidth = Math.max(8, Math.min(20, width - 30));
+  lines.push({
+    type: "agent-result",
+    text: `  ${statusIcon} ${result.agentName}`
+  });
+  for (const cat of result.categories) {
+    const bar = renderScoreBar(cat.score, cat.maxScore, barWidth);
+    lines.push({
+      type: "category",
+      text: `    ${padRight(cat.name, 16)} ${bar}`
+    });
+  }
+  const totalBar = renderScoreBar(result.totalScore, result.maxTotalScore, barWidth);
+  lines.push({
+    type: "total-score",
+    text: `    ${"Total".padEnd(16)} ${totalBar}`
+  });
+  return lines;
+}
+function getResultStatusIcon(status) {
+  switch (status) {
+    case "pending":
+      return "\u23F3";
+    case "in-progress":
+      return "\u{1F504}";
+    case "done":
+      return "\u2705";
+  }
+}
+function padRight(str, len) {
+  return str.length >= len ? str.slice(0, len) : str + " ".repeat(len - str.length);
+}
+function calculateAggregateScore(results) {
+  if (results.length === 0) return { total: 0, max: 0, percent: 0 };
+  const total = results.reduce((sum, r) => sum + r.totalScore, 0);
+  const max = results.reduce((sum, r) => sum + r.maxTotalScore, 0);
+  const percent = max > 0 ? Math.round(total / max * 100) : 0;
+  return { total, max, percent };
+}
+function renderEvalScreen(results, width) {
+  const lines = [];
+  lines.push({ type: "header", text: "\u{1F4CA} Review Results" });
+  if (results.length === 0) {
+    lines.push({ type: "empty", text: "  (no review results yet)" });
+    return lines;
+  }
+  for (const result of results) {
+    lines.push(...renderAgentResult(result, width));
+    lines.push({ type: "empty", text: "" });
+  }
+  const agg = calculateAggregateScore(results);
+  const barWidth = Math.max(8, Math.min(20, width - 30));
+  lines.push({ type: "header", text: "\u{1F3C6} Aggregate Score" });
+  lines.push({
+    type: "total-score",
+    text: `  ${renderScoreBar(agg.total, agg.max, barWidth)} (${agg.percent}%)`
+  });
+  return lines;
+}
+
+// src/tui/components/EvalModeScreen.tsx
+var LINE_COLORS2 = {
+  header: "magenta",
+  "agent-result": "white",
+  category: "cyan",
+  "total-score": "green",
+  empty: "gray"
+};
+function EvalModeScreen({
+  results,
+  width,
+  height
+}) {
+  const lines = useMemo4(() => renderEvalScreen(results, width - 2), [results, width]);
+  const maxLines = Math.max(0, height - 2);
+  const visibleLines = lines.slice(0, maxLines);
+  return /* @__PURE__ */ React5.createElement(
+    Box5,
+    {
+      flexDirection: "column",
+      width,
+      height,
+      borderStyle: "round",
+      borderColor: BORDER_COLORS.panel
+    },
+    visibleLines.map((line, i) => /* @__PURE__ */ React5.createElement(
+      Text5,
+      {
+        key: i,
+        color: LINE_COLORS2[line.type],
+        bold: line.type === "header" || line.type === "total-score",
+        dimColor: line.type === "empty",
+        wrap: "truncate"
+      },
+      line.text
+    ))
+  );
+}
+
+// src/tui/components/FlowMap.tsx
+import React6, { useMemo as useMemo5 } from "react";
+import { Box as Box6, Text as Text6 } from "ink";
+
 // src/tui/utils/color-buffer.ts
 var DEFAULT_CELL = Object.freeze({ char: " ", style: Object.freeze({}) });
 function stylesEqual(a, b) {
@@ -4989,13 +5813,13 @@ function trimTrailingSpaces(cells) {
   }
   return end === cells.length ? cells : cells.slice(0, end);
 }
-var ColorRow = React2.memo(function ColorRow2({
+var ColorRow = React6.memo(function ColorRow2({
   cells
 }) {
   const trimmed = trimTrailingSpaces(cells);
-  if (trimmed.length === 0) return /* @__PURE__ */ React2.createElement(Box2, null);
+  if (trimmed.length === 0) return /* @__PURE__ */ React6.createElement(Box6, null);
   const segments = groupByStyle(trimmed);
-  return /* @__PURE__ */ React2.createElement(Box2, null, segments.map((seg, i) => /* @__PURE__ */ React2.createElement(Text2, { key: i, color: seg.style.fg, bold: seg.style.bold, dimColor: seg.style.dim }, seg.text)));
+  return /* @__PURE__ */ React6.createElement(Box6, null, segments.map((seg, i) => /* @__PURE__ */ React6.createElement(Text6, { key: i, color: seg.style.fg, bold: seg.style.bold, dimColor: seg.style.dim }, seg.text)));
 });
 function FlowMap({
   agents,
@@ -5009,22 +5833,22 @@ function FlowMap({
 }) {
   const contentWidth = Math.max(1, width - 2);
   const contentHeight = Math.max(1, height - 3);
-  const hasRunningAgents = useMemo(
+  const hasRunningAgents = useMemo5(
     () => [...agents.values()].some((a) => a.status === "running"),
     [agents]
   );
   const liveTick = hasRunningAgents ? tick ?? 0 : 0;
   const liveNow = hasRunningAgents ? now : void 0;
-  const compactContent = useMemo(() => {
+  const compactContent = useMemo5(() => {
     if (layoutMode !== "narrow") return null;
     return renderFlowMapCompact(agents);
   }, [agents, layoutMode]);
-  const lines = useMemo(() => {
+  const lines = useMemo5(() => {
     if (layoutMode === "narrow") return null;
     const buf = layoutMode === "wide" ? renderFlowMap(agents, edges, contentWidth, contentHeight, activeStage) : renderFlowMapSimplified(agents, contentWidth, contentHeight);
     return buf.toLinesDirect();
   }, [agents, edges, contentWidth, contentHeight, layoutMode, activeStage]);
-  const liveOverlays = useMemo(() => {
+  const liveOverlays = useMemo5(() => {
     if (liveNow === void 0) return null;
     const overlays = [];
     for (const [id, agent] of agents) {
@@ -5039,8 +5863,8 @@ function FlowMap({
     return overlays.length > 0 ? overlays : null;
   }, [agents, liveTick, liveNow]);
   if (layoutMode === "narrow") {
-    return /* @__PURE__ */ React2.createElement(
-      Box2,
+    return /* @__PURE__ */ React6.createElement(
+      Box6,
       {
         borderStyle: "single",
         borderColor: BORDER_COLORS.panel,
@@ -5048,14 +5872,14 @@ function FlowMap({
         width,
         height
       },
-      /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "cyan" }, "FLOW MAP"),
-      /* @__PURE__ */ React2.createElement(Text2, null, compactContent),
-      liveOverlays?.map((o) => /* @__PURE__ */ React2.createElement(Text2, { key: o.id, color: "yellow" }, o.icon, " ", o.elapsed))
+      /* @__PURE__ */ React6.createElement(Text6, { bold: true, color: "cyan" }, "FLOW MAP"),
+      /* @__PURE__ */ React6.createElement(Text6, null, compactContent),
+      liveOverlays?.map((o) => /* @__PURE__ */ React6.createElement(Text6, { key: o.id, color: "yellow" }, o.icon, " ", o.elapsed))
     );
   }
   if (!lines) {
-    return /* @__PURE__ */ React2.createElement(
-      Box2,
+    return /* @__PURE__ */ React6.createElement(
+      Box6,
       {
         borderStyle: "single",
         borderColor: BORDER_COLORS.panel,
@@ -5063,11 +5887,11 @@ function FlowMap({
         width,
         height
       },
-      /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "cyan" }, "FLOW MAP")
+      /* @__PURE__ */ React6.createElement(Text6, { bold: true, color: "cyan" }, "FLOW MAP")
     );
   }
-  return /* @__PURE__ */ React2.createElement(
-    Box2,
+  return /* @__PURE__ */ React6.createElement(
+    Box6,
     {
       borderStyle: "single",
       borderColor: BORDER_COLORS.panel,
@@ -5075,15 +5899,90 @@ function FlowMap({
       width,
       height
     },
-    /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "cyan" }, "FLOW MAP"),
-    lines.map((row, y) => /* @__PURE__ */ React2.createElement(ColorRow, { key: y, cells: row })),
-    liveOverlays?.map((o) => /* @__PURE__ */ React2.createElement(Text2, { key: o.id, color: "yellow" }, o.icon, " ", o.elapsed))
+    /* @__PURE__ */ React6.createElement(Text6, { bold: true, color: "cyan" }, "FLOW MAP"),
+    lines.map((row, y) => /* @__PURE__ */ React6.createElement(ColorRow, { key: y, cells: row })),
+    liveOverlays?.map((o) => /* @__PURE__ */ React6.createElement(Text6, { key: o.id, color: "yellow" }, o.icon, " ", o.elapsed))
   );
 }
 
+// src/tui/components/ModeScreenRouter.tsx
+function resolveModeScreen(mode, hasDiscussionRounds, hasTddSteps, hasReviewResults) {
+  if (mode === null) return "flow";
+  if (mode === "AUTO") {
+    if (hasReviewResults) return "eval";
+    if (hasTddSteps) return "act";
+    if (hasDiscussionRounds) return "plan";
+    return "plan";
+  }
+  switch (mode) {
+    case "PLAN":
+      return "plan";
+    case "ACT":
+      return "act";
+    case "EVAL":
+      return "eval";
+  }
+}
+function DisconnectBanner({
+  status,
+  width
+}) {
+  if (status === "connected") return null;
+  const icon = status === "reconnecting" ? "\u{1F504}" : "\u26A0\uFE0F";
+  const msg = status === "reconnecting" ? "Reconnecting..." : "Disconnected";
+  return /* @__PURE__ */ React7.createElement(Box7, { width, height: 1 }, /* @__PURE__ */ React7.createElement(Text7, { color: "yellow", bold: true }, `${icon} Event Bridge: ${msg}`));
+}
+function ModeScreenRouter({
+  state,
+  layoutMode,
+  width,
+  height,
+  tick,
+  now
+}) {
+  const bannerHeight = state.connectionStatus !== "connected" ? 1 : 0;
+  const contentHeight = height - bannerHeight;
+  const screen = resolveModeScreen(
+    state.currentMode,
+    state.discussionRounds.length > 0,
+    state.tddSteps.length > 0,
+    state.reviewResults.length > 0
+  );
+  return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", width, height }, /* @__PURE__ */ React7.createElement(DisconnectBanner, { status: state.connectionStatus, width }), screen === "plan" && /* @__PURE__ */ React7.createElement(
+    PlanModeScreen,
+    {
+      agents: state.agents,
+      rounds: state.discussionRounds,
+      width,
+      height: contentHeight
+    }
+  ), screen === "act" && /* @__PURE__ */ React7.createElement(
+    ActModeScreen,
+    {
+      currentPhase: state.tddCurrentPhase,
+      steps: state.tddSteps,
+      agents: state.agents,
+      width,
+      height: contentHeight
+    }
+  ), screen === "eval" && /* @__PURE__ */ React7.createElement(EvalModeScreen, { results: state.reviewResults, width, height: contentHeight }), screen === "flow" && /* @__PURE__ */ React7.createElement(
+    FlowMap,
+    {
+      agents: state.agents,
+      edges: state.edges,
+      layoutMode,
+      width,
+      height: contentHeight,
+      activeStage: state.currentMode,
+      tick,
+      now
+    }
+  ));
+}
+
 // src/tui/components/FocusedAgentPanel.tsx
-import React4 from "react";
-import { Box as Box4, Text as Text4 } from "ink";
+import React9 from "react";
+import { Box as Box9, Text as Text9 } from "ink";
 
 // src/tui/components/focused-agent.pure.ts
 function formatObjective(objectives, maxLines = 3) {
@@ -5129,8 +6028,8 @@ function formatEnhancedChecklist(tasks, maxItems = 6) {
 }
 
 // src/tui/components/ContextSection.tsx
-import React3 from "react";
-import { Box as Box3, Text as Text3 } from "ink";
+import React8 from "react";
+import { Box as Box8, Text as Text8 } from "ink";
 
 // src/tui/components/context-section.pure.ts
 function formatContextDecisions(decisions, maxItems = 5) {
@@ -5160,27 +6059,27 @@ function ContextSection({
   const hasDecisions = decisions.length > 0;
   const hasNotes = notes.length > 0;
   if (!hasDecisions && !hasNotes) return null;
-  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, hasDecisions && /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, { dimColor: true, bold: true }, "Decisions"), formatContextDecisions(decisions)?.split("\n").map((line, i) => /* @__PURE__ */ React3.createElement(Text3, { key: i, color: "cyan" }, line))), hasNotes && /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, { dimColor: true, bold: true }, "Notes"), formatContextNotes(notes)?.split("\n").map((line, i) => /* @__PURE__ */ React3.createElement(Text3, { key: i, dimColor: true }, line))));
+  return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column" }, hasDecisions && /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text8, { dimColor: true, bold: true }, "Decisions"), formatContextDecisions(decisions)?.split("\n").map((line, i) => /* @__PURE__ */ React8.createElement(Text8, { key: i, color: "cyan" }, line))), hasNotes && /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text8, { dimColor: true, bold: true }, "Notes"), formatContextNotes(notes)?.split("\n").map((line, i) => /* @__PURE__ */ React8.createElement(Text8, { key: i, dimColor: true }, line))));
 }
 
 // src/tui/components/FocusedAgentPanel.tsx
 function SectionDivider({ title }) {
-  return /* @__PURE__ */ React4.createElement(Text4, { color: "magenta" }, formatSectionDivider(title));
+  return /* @__PURE__ */ React9.createElement(Text9, { color: "magenta" }, formatSectionDivider(title));
 }
 function LogSection({
   logs,
   eventLog
 }) {
-  if (!logs) return /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "No events");
+  if (!logs) return /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, "No events");
   const logLines = logs.split("\n");
   const offset = eventLog.length - logLines.length;
-  return /* @__PURE__ */ React4.createElement(React4.Fragment, null, logLines.map((line, i) => {
+  return /* @__PURE__ */ React9.createElement(React9.Fragment, null, logLines.map((line, i) => {
     const ev = eventLog[offset + i];
     const isError = ev?.level === "error";
     const spaceIdx = line.indexOf(" ");
     const timestamp = spaceIdx > 0 ? line.slice(0, spaceIdx) : line;
     const message = spaceIdx > 0 ? line.slice(spaceIdx + 1) : "";
-    return /* @__PURE__ */ React4.createElement(Box4, { key: i, gap: 1 }, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, timestamp), /* @__PURE__ */ React4.createElement(Text4, { color: isError ? "red" : void 0 }, message));
+    return /* @__PURE__ */ React9.createElement(Box9, { key: i, gap: 1 }, /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, timestamp), /* @__PURE__ */ React9.createElement(Text9, { color: isError ? "red" : void 0 }, message));
   }));
 }
 function FocusedAgentPanel({
@@ -5196,8 +6095,8 @@ function FocusedAgentPanel({
   height
 }) {
   if (!agent) {
-    return /* @__PURE__ */ React4.createElement(
-      Box4,
+    return /* @__PURE__ */ React9.createElement(
+      Box9,
       {
         borderStyle: "single",
         borderColor: BORDER_COLORS.panel,
@@ -5205,7 +6104,7 @@ function FocusedAgentPanel({
         width,
         height
       },
-      /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "No agent focused")
+      /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, "No agent focused")
     );
   }
   const avatar = getAgentAvatar(agent.name);
@@ -5218,8 +6117,8 @@ function FocusedAgentPanel({
   const isRunning = agent.status === "running";
   const showSpinner = isRunning && tick != null;
   const showElapsed = isRunning && now != null && agent.startedAt != null;
-  return /* @__PURE__ */ React4.createElement(
-    Box4,
+  return /* @__PURE__ */ React9.createElement(
+    Box9,
     {
       borderStyle: "single",
       borderColor: BORDER_COLORS.panel,
@@ -5227,22 +6126,22 @@ function FocusedAgentPanel({
       width,
       height
     },
-    /* @__PURE__ */ React4.createElement(Box4, { gap: 2 }, /* @__PURE__ */ React4.createElement(Text4, null, avatar), /* @__PURE__ */ React4.createElement(Text4, { bold: true }, agent.name), showSpinner ? /* @__PURE__ */ React4.createElement(Text4, { color: "cyan" }, spinnerFrame(tick)) : /* @__PURE__ */ React4.createElement(Text4, { color: statusColor, bold: true }, icon), /* @__PURE__ */ React4.createElement(Text4, { color: statusColor }, statusLabel), showElapsed && /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, formatElapsed(agent.startedAt, now)), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, agent.stage)),
-    /* @__PURE__ */ React4.createElement(Box4, { gap: 1 }, /* @__PURE__ */ React4.createElement(Text4, { color: "magenta" }, progressBar.bar), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, progressBar.label)),
-    /* @__PURE__ */ React4.createElement(SectionDivider, { title: "Objective" }),
-    objective ? /* @__PURE__ */ React4.createElement(Text4, null, objective) : /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "No objectives"),
-    /* @__PURE__ */ React4.createElement(SectionDivider, { title: "Skills" }),
-    activeSkills.length > 0 ? activeSkills.map((s, i) => /* @__PURE__ */ React4.createElement(Text4, { key: i }, " ", s)) : /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "No skills"),
-    /* @__PURE__ */ React4.createElement(SectionDivider, { title: "Context" }),
-    contextDecisions.length > 0 || contextNotes.length > 0 ? /* @__PURE__ */ React4.createElement(ContextSection, { decisions: contextDecisions, notes: contextNotes, width }) : /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "No context"),
-    /* @__PURE__ */ React4.createElement(SectionDivider, { title: "Event Log" }),
-    /* @__PURE__ */ React4.createElement(LogSection, { logs, eventLog })
+    /* @__PURE__ */ React9.createElement(Box9, { gap: 2 }, /* @__PURE__ */ React9.createElement(Text9, null, avatar), /* @__PURE__ */ React9.createElement(Text9, { bold: true }, agent.name), showSpinner ? /* @__PURE__ */ React9.createElement(Text9, { color: "cyan" }, spinnerFrame(tick)) : /* @__PURE__ */ React9.createElement(Text9, { color: statusColor, bold: true }, icon), /* @__PURE__ */ React9.createElement(Text9, { color: statusColor }, statusLabel), showElapsed && /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, formatElapsed(agent.startedAt, now)), /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, agent.stage)),
+    /* @__PURE__ */ React9.createElement(Box9, { gap: 1 }, /* @__PURE__ */ React9.createElement(Text9, { color: "magenta" }, progressBar.bar), /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, progressBar.label)),
+    /* @__PURE__ */ React9.createElement(SectionDivider, { title: "Objective" }),
+    objective ? /* @__PURE__ */ React9.createElement(Text9, null, objective) : /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, "No objectives"),
+    /* @__PURE__ */ React9.createElement(SectionDivider, { title: "Skills" }),
+    activeSkills.length > 0 ? activeSkills.map((s, i) => /* @__PURE__ */ React9.createElement(Text9, { key: i }, " ", s)) : /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, "No skills"),
+    /* @__PURE__ */ React9.createElement(SectionDivider, { title: "Context" }),
+    contextDecisions.length > 0 || contextNotes.length > 0 ? /* @__PURE__ */ React9.createElement(ContextSection, { decisions: contextDecisions, notes: contextNotes, width }) : /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, "No context"),
+    /* @__PURE__ */ React9.createElement(SectionDivider, { title: "Event Log" }),
+    /* @__PURE__ */ React9.createElement(LogSection, { logs, eventLog })
   );
 }
 
 // src/tui/components/ChecklistPanel.tsx
-import React5 from "react";
-import { Box as Box5, Text as Text5 } from "ink";
+import React10 from "react";
+import { Box as Box10, Text as Text10 } from "ink";
 
 // src/tui/components/checklist-panel.pure.ts
 function resolveChecklistTasks(tasks, contextDecisions, contextNotes) {
@@ -5270,8 +6169,8 @@ function ChecklistPanel({
 }) {
   const resolvedTasks = resolveChecklistTasks(tasks, contextDecisions, contextNotes);
   const checklist = formatEnhancedChecklist(resolvedTasks);
-  return /* @__PURE__ */ React5.createElement(
-    Box5,
+  return /* @__PURE__ */ React10.createElement(
+    Box10,
     {
       borderStyle: "single",
       borderColor: BORDER_COLORS.panel,
@@ -5279,17 +6178,17 @@ function ChecklistPanel({
       width,
       height
     },
-    /* @__PURE__ */ React5.createElement(Text5, { bold: true, dimColor: true }, "\u2500\u2500\u2500 Checklist"),
+    /* @__PURE__ */ React10.createElement(Text10, { bold: true, dimColor: true }, "\u2500\u2500\u2500 Checklist"),
     checklist.split("\n").map((line, i) => {
       const isCompleted = line.includes("\u2714");
-      return /* @__PURE__ */ React5.createElement(Text5, { key: i, color: isCompleted ? "green" : void 0 }, line);
+      return /* @__PURE__ */ React10.createElement(Text10, { key: i, color: isCompleted ? "green" : void 0 }, line);
     })
   );
 }
 
 // src/tui/components/StageHealthBar.tsx
-import React6 from "react";
-import { Box as Box6, Text as Text6 } from "ink";
+import React11 from "react";
+import { Box as Box11, Text as Text11 } from "ink";
 
 // src/tui/components/stage-health.pure.ts
 function formatCount(n) {
@@ -5357,29 +6256,29 @@ function StageStatDisplay({
   const parts = [];
   if (stats.running > 0)
     parts.push(
-      /* @__PURE__ */ React6.createElement(Text6, { key: "r", color: "green" }, " ", "\u25CF ", stats.running, " running")
+      /* @__PURE__ */ React11.createElement(Text11, { key: "r", color: "green" }, " ", "\u25CF ", stats.running, " running")
     );
   if (stats.blocked > 0)
     parts.push(
-      /* @__PURE__ */ React6.createElement(Text6, { key: "b", color: "yellow" }, " ", "\u23F8 ", stats.blocked, " blocked")
+      /* @__PURE__ */ React11.createElement(Text11, { key: "b", color: "yellow" }, " ", "\u23F8 ", stats.blocked, " blocked")
     );
   if (stats.waiting > 0)
     parts.push(
-      /* @__PURE__ */ React6.createElement(Text6, { key: "w", dimColor: true }, " ", "\u25CB ", stats.waiting, " waiting")
+      /* @__PURE__ */ React11.createElement(Text11, { key: "w", dimColor: true }, " ", "\u25CB ", stats.waiting, " waiting")
     );
   if (stats.done > 0)
     parts.push(
-      /* @__PURE__ */ React6.createElement(Text6, { key: "d", color: "green" }, " ", "\u2713 ", stats.done)
+      /* @__PURE__ */ React11.createElement(Text11, { key: "d", color: "green" }, " ", "\u2713 ", stats.done)
     );
   if (stats.error > 0)
     parts.push(
-      /* @__PURE__ */ React6.createElement(Text6, { key: "e", color: "red", bold: true }, " ", "! ", stats.error, " err")
+      /* @__PURE__ */ React11.createElement(Text11, { key: "e", color: "red", bold: true }, " ", "! ", stats.error, " err")
     );
   if (parts.length === 0)
     parts.push(
-      /* @__PURE__ */ React6.createElement(Text6, { key: "idle", dimColor: true }, " ", "idle")
+      /* @__PURE__ */ React11.createElement(Text11, { key: "idle", dimColor: true }, " ", "idle")
     );
-  return /* @__PURE__ */ React6.createElement(Box6, null, /* @__PURE__ */ React6.createElement(Text6, { color, bold: true }, mode, ":"), parts);
+  return /* @__PURE__ */ React11.createElement(Box11, null, /* @__PURE__ */ React11.createElement(Text11, { color, bold: true }, mode, ":"), parts);
 }
 function StageHealthBar({
   stageHealth,
@@ -5393,24 +6292,24 @@ function StageHealthBar({
   now: _now
 }) {
   const hasActivity = activityHistory && activityHistory.length > 0;
-  return /* @__PURE__ */ React6.createElement(
-    Box6,
+  return /* @__PURE__ */ React11.createElement(
+    Box11,
     {
       borderStyle: "double",
       borderColor: BORDER_COLORS.panel,
       width,
       flexDirection: "column"
     },
-    /* @__PURE__ */ React6.createElement(Box6, null, hasActivity && /* @__PURE__ */ React6.createElement(Box6, { gap: 1, marginRight: 1 }, /* @__PURE__ */ React6.createElement(Text6, { color: "cyan" }, renderSparkline(
+    /* @__PURE__ */ React11.createElement(Box11, null, hasActivity && /* @__PURE__ */ React11.createElement(Box11, { gap: 1, marginRight: 1 }, /* @__PURE__ */ React11.createElement(Text11, { color: "cyan" }, renderSparkline(
       activityHistory.map((s) => s.toolCalls),
       10
-    )), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, computeThroughput(activityHistory))), /* @__PURE__ */ React6.createElement(Box6, { gap: 2 }, ["PLAN", "ACT", "EVAL"].map((mode) => /* @__PURE__ */ React6.createElement(StageStatDisplay, { key: mode, mode, stats: stageHealth[mode] }))), /* @__PURE__ */ React6.createElement(Box6, { flexGrow: 1 }), /* @__PURE__ */ React6.createElement(Box6, { gap: 2 }, bottlenecks.length > 0 && /* @__PURE__ */ React6.createElement(Text6, { color: "red", bold: true }, "\u26A1 Bottlenecks: ", bottlenecks.join(" / ")), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "\u{1F916} ", formatCount(agentCount)), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "\u2699 ", formatCount(skillCount)), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "\u{1F527} ", formatCount(toolCount))))
+    )), /* @__PURE__ */ React11.createElement(Text11, { dimColor: true }, computeThroughput(activityHistory))), /* @__PURE__ */ React11.createElement(Box11, { gap: 2 }, ["PLAN", "ACT", "EVAL"].map((mode) => /* @__PURE__ */ React11.createElement(StageStatDisplay, { key: mode, mode, stats: stageHealth[mode] }))), /* @__PURE__ */ React11.createElement(Box11, { flexGrow: 1 }), /* @__PURE__ */ React11.createElement(Box11, { gap: 2 }, bottlenecks.length > 0 && /* @__PURE__ */ React11.createElement(Text11, { color: "red", bold: true }, "\u26A1 Bottlenecks: ", bottlenecks.join(" / ")), /* @__PURE__ */ React11.createElement(Text11, { dimColor: true }, "\u{1F916} ", formatCount(agentCount)), /* @__PURE__ */ React11.createElement(Text11, { dimColor: true }, "\u2699 ", formatCount(skillCount)), /* @__PURE__ */ React11.createElement(Text11, { dimColor: true }, "\u{1F527} ", formatCount(toolCount))))
   );
 }
 
 // src/tui/components/ActivityVisualizer.tsx
-import React7, { useMemo as useMemo2 } from "react";
-import { Box as Box7, Text as Text7 } from "ink";
+import React12, { useMemo as useMemo6 } from "react";
+import { Box as Box12, Text as Text12 } from "ink";
 
 // src/tui/utils/display-width.ts
 function isWide(code) {
@@ -5579,11 +6478,11 @@ function ActivityVisualizer({
   const treeWidth = Math.floor(width * 0.6);
   const cardWidth = width - treeWidth;
   const contentHeight = Math.max(1, height - 2);
-  const treeLines = useMemo2(
+  const treeLines = useMemo6(
     () => renderAgentTree(agents, edges, activeSkills, Math.max(1, treeWidth - 2), contentHeight),
     [agents, edges, activeSkills, treeWidth, contentHeight]
   );
-  const cardLines = useMemo2(
+  const cardLines = useMemo6(
     () => renderAgentStatusCard(
       focusedAgent,
       currentMode,
@@ -5595,10 +6494,10 @@ function ActivityVisualizer({
     [focusedAgent, currentMode, objectives, activeSkills, cardWidth, contentHeight]
   );
   if (width <= 0 || height <= 0) {
-    return /* @__PURE__ */ React7.createElement(Box7, null);
+    return /* @__PURE__ */ React12.createElement(Box12, null);
   }
-  return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "row", width, height }, /* @__PURE__ */ React7.createElement(
-    Box7,
+  return /* @__PURE__ */ React12.createElement(Box12, { flexDirection: "row", width, height }, /* @__PURE__ */ React12.createElement(
+    Box12,
     {
       borderStyle: "single",
       borderColor: BORDER_COLORS.panel,
@@ -5606,9 +6505,9 @@ function ActivityVisualizer({
       width: treeWidth,
       height
     },
-    treeLines.map((line, i) => /* @__PURE__ */ React7.createElement(Text7, { key: i }, line))
-  ), /* @__PURE__ */ React7.createElement(
-    Box7,
+    treeLines.map((line, i) => /* @__PURE__ */ React12.createElement(Text12, { key: i }, line))
+  ), /* @__PURE__ */ React12.createElement(
+    Box12,
     {
       borderStyle: "single",
       borderColor: BORDER_COLORS.panel,
@@ -5616,7 +6515,7 @@ function ActivityVisualizer({
       width: cardWidth,
       height
     },
-    cardLines.map((line, i) => /* @__PURE__ */ React7.createElement(Text7, { key: i }, line))
+    cardLines.map((line, i) => /* @__PURE__ */ React12.createElement(Text12, { key: i }, line))
   ));
 }
 
@@ -5703,17 +6602,17 @@ function DashboardApp({
 }) {
   const { columns, rows, layoutMode } = useTerminalSize();
   const tick = useTick(1e3);
-  const now = useMemo3(() => Date.now(), [tick]);
+  const now = useMemo7(() => Date.now(), [tick]);
   const internalState = useDashboardState(externalState ? void 0 : eventBus);
   const state = externalState ?? internalState;
   const focusedAgent = state.focusedAgentId ? state.agents.get(state.focusedAgentId) ?? null : null;
-  const stageHealth = useMemo3(() => computeStageHealth(state.agents), [state.agents]);
-  const bottlenecks = useMemo3(() => detectBottlenecks(state.eventLog), [state.eventLog]);
-  const grid = useMemo3(
+  const stageHealth = useMemo7(() => computeStageHealth(state.agents), [state.agents]);
+  const bottlenecks = useMemo7(() => detectBottlenecks(state.eventLog), [state.eventLog]);
+  const grid = useMemo7(
     () => computeGridLayout(columns, rows, layoutMode),
     [columns, rows, layoutMode]
   );
-  return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", width: grid.total.width, height: grid.total.height }, /* @__PURE__ */ React8.createElement(
+  return /* @__PURE__ */ React13.createElement(Box13, { flexDirection: "column", width: grid.total.width, height: grid.total.height }, /* @__PURE__ */ React13.createElement(
     HeaderBar,
     {
       workspace: workspaceProp ?? state.workspace,
@@ -5724,7 +6623,7 @@ function DashboardApp({
       tick,
       now
     }
-  ), layoutMode === "narrow" ? /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column" }, grid.checklistPanel.height > 0 && /* @__PURE__ */ React8.createElement(
+  ), layoutMode === "narrow" ? /* @__PURE__ */ React13.createElement(Box13, { flexDirection: "column" }, grid.checklistPanel.height > 0 && /* @__PURE__ */ React13.createElement(
     ChecklistPanel,
     {
       tasks: state.tasks,
@@ -5733,7 +6632,7 @@ function DashboardApp({
       width: grid.checklistPanel.width,
       height: grid.checklistPanel.height
     }
-  ), /* @__PURE__ */ React8.createElement(
+  ), /* @__PURE__ */ React13.createElement(
     FocusedAgentPanel,
     {
       agent: focusedAgent,
@@ -5747,38 +6646,34 @@ function DashboardApp({
       tick,
       now
     }
-  ), /* @__PURE__ */ React8.createElement(
-    FlowMap,
+  ), /* @__PURE__ */ React13.createElement(
+    ModeScreenRouter,
     {
-      agents: state.agents,
-      edges: state.edges,
+      state,
       layoutMode,
       width: grid.flowMap.width,
       height: grid.flowMap.height,
-      activeStage: state.currentMode,
       tick,
       now
     }
-  )) : /* @__PURE__ */ React8.createElement(
-    Box8,
+  )) : /* @__PURE__ */ React13.createElement(
+    Box13,
     {
       flexDirection: "row",
       width: grid.total.width,
       height: grid.checklistPanel.height + grid.focusedAgent.height
     },
-    /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", width: grid.flowMap.width }, /* @__PURE__ */ React8.createElement(
-      FlowMap,
+    /* @__PURE__ */ React13.createElement(Box13, { flexDirection: "column", width: grid.flowMap.width }, /* @__PURE__ */ React13.createElement(
+      ModeScreenRouter,
       {
-        agents: state.agents,
-        edges: state.edges,
+        state,
         layoutMode,
         width: grid.flowMap.width,
         height: grid.flowMap.height,
-        activeStage: state.currentMode,
         tick,
         now
       }
-    ), /* @__PURE__ */ React8.createElement(
+    ), /* @__PURE__ */ React13.createElement(
       ActivityVisualizer,
       {
         currentMode: state.currentMode,
@@ -5791,7 +6686,7 @@ function DashboardApp({
         height: grid.monitorPanel.height
       }
     )),
-    /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", width: grid.checklistPanel.width }, /* @__PURE__ */ React8.createElement(
+    /* @__PURE__ */ React13.createElement(Box13, { flexDirection: "column", width: grid.checklistPanel.width }, /* @__PURE__ */ React13.createElement(
       ChecklistPanel,
       {
         tasks: state.tasks,
@@ -5800,7 +6695,7 @@ function DashboardApp({
         width: grid.checklistPanel.width,
         height: grid.checklistPanel.height
       }
-    ), /* @__PURE__ */ React8.createElement(
+    ), /* @__PURE__ */ React13.createElement(
       FocusedAgentPanel,
       {
         agent: focusedAgent,
@@ -5815,7 +6710,7 @@ function DashboardApp({
         now
       }
     ))
-  ), /* @__PURE__ */ React8.createElement(
+  ), /* @__PURE__ */ React13.createElement(
     StageHealthBar,
     {
       stageHealth,
@@ -5832,8 +6727,8 @@ function DashboardApp({
 }
 
 // src/tui/multi-session-app.tsx
-import React10, { useMemo as useMemo4, useCallback as useCallback2 } from "react";
-import { Box as Box10, useInput } from "ink";
+import React15, { useMemo as useMemo8, useCallback as useCallback2 } from "react";
+import { Box as Box15, useInput } from "ink";
 import * as path8 from "path";
 
 // src/tui/hooks/use-multi-session-state.ts
@@ -5989,8 +6884,8 @@ function useMultiSessionState(manager) {
 }
 
 // src/tui/components/SessionTabBar.tsx
-import React9 from "react";
-import { Box as Box9, Text as Text8 } from "ink";
+import React14 from "react";
+import { Box as Box14, Text as Text13 } from "ink";
 
 // src/tui/components/session-tab-bar.pure.ts
 var STATUS_ICONS2 = {
@@ -6044,14 +6939,14 @@ function SessionTabBar({
   if (formatted === "") {
     return null;
   }
-  return /* @__PURE__ */ React9.createElement(Box9, { width, height: 1 }, /* @__PURE__ */ React9.createElement(Text8, null, formatted));
+  return /* @__PURE__ */ React14.createElement(Box14, { width, height: 1 }, /* @__PURE__ */ React14.createElement(Text13, null, formatted));
 }
 
 // src/tui/multi-session-app.tsx
 function MultiSessionApp({ manager }) {
   const { columns, layoutMode } = useTerminalSize();
   const { sessions, activeSessionPid, switchNext, switchPrev, switchByIndex } = useMultiSessionState(manager);
-  const tabs = useMemo4(() => {
+  const tabs = useMemo8(() => {
     let index = 0;
     const result = [];
     for (const [pid, sessionState] of sessions) {
@@ -6066,13 +6961,13 @@ function MultiSessionApp({ manager }) {
     }
     return result;
   }, [sessions, activeSessionPid]);
-  const activeEventBus = useMemo4(() => {
+  const activeEventBus = useMemo8(() => {
     if (activeSessionPid === null) return void 0;
     const managedSessions = manager.getSessions();
     const found = managedSessions.find((s) => s.instance.pid === activeSessionPid);
     return found?.eventBus;
   }, [manager, activeSessionPid]);
-  const activeProjectRoot = useMemo4(() => {
+  const activeProjectRoot = useMemo8(() => {
     if (activeSessionPid === null) return void 0;
     return sessions.get(activeSessionPid)?.projectRoot;
   }, [sessions, activeSessionPid]);
@@ -6094,7 +6989,7 @@ function MultiSessionApp({ manager }) {
     [switchNext, switchPrev, switchByIndex]
   );
   useInput(handleInput);
-  return /* @__PURE__ */ React10.createElement(Box10, { flexDirection: "column" }, /* @__PURE__ */ React10.createElement(SessionTabBar, { sessions: tabs, width: columns, layoutMode }), /* @__PURE__ */ React10.createElement(
+  return /* @__PURE__ */ React15.createElement(Box15, { flexDirection: "column" }, /* @__PURE__ */ React15.createElement(SessionTabBar, { sessions: tabs, width: columns, layoutMode }), /* @__PURE__ */ React15.createElement(
     DashboardApp,
     {
       key: activeSessionPid ?? "none",
@@ -6142,19 +7037,22 @@ function createDefaultAgentState(params) {
 // src/tui/index.tsx
 function startTui(options) {
   const renderOptions = options.stdout ? { stdout: options.stdout } : {};
-  return render(/* @__PURE__ */ React11.createElement(DashboardApp, { eventBus: options.eventBus }), renderOptions);
+  return render(/* @__PURE__ */ React16.createElement(DashboardApp, { eventBus: options.eventBus }), renderOptions);
 }
 function renderMultiSession(options) {
-  return render(/* @__PURE__ */ React11.createElement(MultiSessionApp, { manager: options.manager }));
+  return render(/* @__PURE__ */ React16.createElement(MultiSessionApp, { manager: options.manager }));
 }
 export {
   AGENT_STATUSES,
   DASHBOARD_NODE_STATUSES,
   DashboardApp,
   MultiSessionApp,
+  TDD_PHASES,
   TUI_EVENT_TYPES,
   createDefaultAgentState,
   createDefaultDashboardNode,
+  createDefaultReviewResult,
+  createDefaultTddStep,
   createEmptyStageStats,
   getLayoutMode,
   renderMultiSession,