codingbuddy 5.0.0 → 5.1.0

package/dist/src/tui-bundle.mjs

@@ -1371,12 +1371,12 @@ var require_eventemitter2 = __commonJS({
 });
 
 // src/tui/index.tsx
-import React12 from "react";
+import React16 from "react";
 import { render } from "ink";
 
 // src/tui/dashboard-app.tsx
-import React9, { useMemo as useMemo4 } from "react";
-import { Box as Box9 } 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 };
@@ -1497,7 +1514,11 @@ var TUI_EVENTS = Object.freeze({
   OBJECTIVE_SET: "objective:set",
   SESSION_RESET: "session:reset",
   CONTEXT_UPDATED: "context:updated",
-  DISCUSSION_ROUND_ADDED: "discussion:round-added"
+  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
@@ -2151,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(
@@ -2630,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";
 
@@ -2754,7 +2885,7 @@ var CustomService = class {
   }
 };
 CustomService = __decorateClass([
-  Injectable5()
+  Injectable6()
 ], CustomService);
 
 // src/custom/custom.module.ts
@@ -2771,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";
@@ -2916,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(),
@@ -3777,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
@@ -3953,7 +4088,7 @@ var ConfigDiffService = class {
   }
 };
 ConfigDiffService = __decorateClass([
-  Injectable7()
+  Injectable8()
 ], ConfigDiffService);
 
 // src/config/config.module.ts
@@ -3972,8 +4107,8 @@ var RulesModule = class {
 RulesModule = __decorateClass([
   Module3({
     imports: [CustomModule, CodingBuddyConfigModule],
-    providers: [RulesService],
-    exports: [RulesService]
+    providers: [RulesService, RuleInsightsService],
+    exports: [RulesService, RuleInsightsService]
   })
 ], RulesModule);
 
@@ -4037,7 +4172,14 @@ function createInitialDashboardState() {
     contextNotes: [],
     contextMode: null,
     contextStatus: null,
-    discussionRounds: []
+    discussionRounds: [],
+    tddCurrentPhase: null,
+    tddSteps: [],
+    reviewResults: [],
+    connectionStatus: "connected",
+    sessionStartedAt: Date.now(),
+    modeTransitions: [],
+    fileChanges: { created: 0, modified: 0, deleted: 0 }
   };
 }
 function cloneAgents(agents) {
@@ -4105,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 = {
@@ -4170,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":
@@ -4243,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":
@@ -4271,6 +4448,10 @@ function useDashboardState(eventBus) {
     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);
@@ -4285,6 +4466,10 @@ function useDashboardState(eventBus) {
     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);
@@ -4300,6 +4485,10 @@ function useDashboardState(eventBus) {
       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(() => {
@@ -4539,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) {
@@ -5038,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,
@@ -5058,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) {
@@ -5088,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,
@@ -5097,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,
@@ -5112,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,
@@ -5124,163 +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/AgentDiscussionPanel.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/agent-discussion-panel.pure.ts
-var CROSS_REVIEW_VERBS = {
-  approve: "agrees",
-  concern: "notes",
-  reject: "disagrees"
-};
-function renderOpinionLine(opinion, stanceHistory) {
-  const avatar = getAgentAvatar(opinion.agentName);
-  const icon = STANCE_ICONS[opinion.stance];
-  let suffix = "";
-  if (stanceHistory && stanceHistory.length > 1) {
-    const lastStance = stanceHistory[stanceHistory.length - 1];
-    const prevStance = stanceHistory[stanceHistory.length - 2];
-    if (lastStance !== prevStance) {
-      suffix = ` (${prevStance === "reject" || prevStance === "concern" ? "revised" : "alt"})`;
-    }
-  }
-  return {
-    text: `${avatar} ${opinion.agentName}  ${icon} ${opinion.stance}${suffix}: "${opinion.reasoning}"`,
-    type: "opinion"
-  };
-}
-function renderCrossReviewLine(review, agentNames) {
-  const fromAvatar = getAgentAvatar(agentNames[review.fromAgentId] ?? "unknown");
-  const fromName = agentNames[review.fromAgentId] ?? review.fromAgentId;
-  const toAvatar = getAgentAvatar(agentNames[review.toAgentId] ?? "unknown");
-  const toName = agentNames[review.toAgentId] ?? review.toAgentId;
-  const verb = CROSS_REVIEW_VERBS[review.stance];
-  return {
-    text: `${fromAvatar} ${fromName} \u2192 ${toAvatar} ${toName} ${verb}: "${review.comment}"`,
-    type: "cross-review"
-  };
-}
-function renderConsensusLine(consensus) {
-  const icon = consensus.reached ? "\u2705" : "\u274C";
-  return {
-    text: `${icon} Consensus: ${consensus.approveCount}/${consensus.totalAgents} | Critical: ${consensus.criticalCount}`,
-    type: "consensus"
-  };
-}
-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 renderDiscussionPanel(rounds, _width) {
-  if (rounds.length === 0) {
-    return [{ text: "No agent discussion yet", type: "empty" }];
-  }
-  const lines = [];
-  const agentNames = buildAgentNameMap(rounds);
-  const stanceHistories = buildStanceHistories(rounds);
-  const latestRound = rounds[rounds.length - 1];
-  lines.push({ text: `\u2500\u2500 Agent Discussion \u2500\u2500`, type: "header" });
-  for (const opinion of latestRound.opinions) {
-    lines.push(renderOpinionLine(opinion, stanceHistories[opinion.agentId]));
-  }
-  for (const review of latestRound.crossReviews) {
-    lines.push(renderCrossReviewLine(review, agentNames));
-  }
-  const consensus = calculateConsensus(latestRound.opinions);
-  lines.push(renderConsensusLine(consensus));
-  return lines;
+// 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}`));
 }
-
-// src/tui/components/AgentDiscussionPanel.tsx
-var LINE_COLORS = {
-  opinion: "white",
-  "cross-review": "cyan",
-  consensus: "green",
-  header: "magenta",
-  empty: "gray"
-};
-function AgentDiscussionPanel({
-  rounds,
+function ModeScreenRouter({
+  state,
+  layoutMode,
   width,
-  height
+  height,
+  tick,
+  now
 }) {
-  const lines = useMemo2(
-    () => renderDiscussionPanel(rounds, width),
-    [rounds, width]
+  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
   );
-  const maxLines = Math.max(0, height - 2);
-  const visibleLines = lines.slice(0, maxLines);
-  return /* @__PURE__ */ React3.createElement(
-    Box3,
+  return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", width, height }, /* @__PURE__ */ React7.createElement(DisconnectBanner, { status: state.connectionStatus, width }), screen === "plan" && /* @__PURE__ */ React7.createElement(
+    PlanModeScreen,
     {
-      flexDirection: "column",
+      agents: state.agents,
+      rounds: state.discussionRounds,
       width,
-      height,
-      borderStyle: "round",
-      borderColor: BORDER_COLORS.panel
-    },
-    visibleLines.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
-    ))
-  );
+      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 React5 from "react";
-import { Box as Box5, Text as Text5 } 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) {
@@ -5326,8 +6028,8 @@ function formatEnhancedChecklist(tasks, maxItems = 6) {
 }
 
 // src/tui/components/ContextSection.tsx
-import React4 from "react";
-import { Box as Box4, Text as Text4 } 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) {
@@ -5357,27 +6059,27 @@ function ContextSection({
   const hasDecisions = decisions.length > 0;
   const hasNotes = notes.length > 0;
   if (!hasDecisions && !hasNotes) return null;
-  return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, hasDecisions && /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true, bold: true }, "Decisions"), formatContextDecisions(decisions)?.split("\n").map((line, i) => /* @__PURE__ */ React4.createElement(Text4, { key: i, color: "cyan" }, line))), hasNotes && /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true, bold: true }, "Notes"), formatContextNotes(notes)?.split("\n").map((line, i) => /* @__PURE__ */ React4.createElement(Text4, { 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__ */ React5.createElement(Text5, { color: "magenta" }, formatSectionDivider(title));
+  return /* @__PURE__ */ React9.createElement(Text9, { color: "magenta" }, formatSectionDivider(title));
 }
 function LogSection({
   logs,
   eventLog
 }) {
-  if (!logs) return /* @__PURE__ */ React5.createElement(Text5, { 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__ */ React5.createElement(React5.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__ */ React5.createElement(Box5, { key: i, gap: 1 }, /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, timestamp), /* @__PURE__ */ React5.createElement(Text5, { 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({
@@ -5393,8 +6095,8 @@ function FocusedAgentPanel({
   height
 }) {
   if (!agent) {
-    return /* @__PURE__ */ React5.createElement(
-      Box5,
+    return /* @__PURE__ */ React9.createElement(
+      Box9,
       {
         borderStyle: "single",
         borderColor: BORDER_COLORS.panel,
@@ -5402,7 +6104,7 @@ function FocusedAgentPanel({
         width,
         height
       },
-      /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "No agent focused")
+      /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, "No agent focused")
     );
   }
   const avatar = getAgentAvatar(agent.name);
@@ -5415,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__ */ React5.createElement(
-    Box5,
+  return /* @__PURE__ */ React9.createElement(
+    Box9,
     {
       borderStyle: "single",
       borderColor: BORDER_COLORS.panel,
@@ -5424,22 +6126,22 @@ function FocusedAgentPanel({
       width,
       height
     },
-    /* @__PURE__ */ React5.createElement(Box5, { gap: 2 }, /* @__PURE__ */ React5.createElement(Text5, null, avatar), /* @__PURE__ */ React5.createElement(Text5, { bold: true }, agent.name), showSpinner ? /* @__PURE__ */ React5.createElement(Text5, { color: "cyan" }, spinnerFrame(tick)) : /* @__PURE__ */ React5.createElement(Text5, { color: statusColor, bold: true }, icon), /* @__PURE__ */ React5.createElement(Text5, { color: statusColor }, statusLabel), showElapsed && /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, formatElapsed(agent.startedAt, now)), /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, agent.stage)),
-    /* @__PURE__ */ React5.createElement(Box5, { gap: 1 }, /* @__PURE__ */ React5.createElement(Text5, { color: "magenta" }, progressBar.bar), /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, progressBar.label)),
-    /* @__PURE__ */ React5.createElement(SectionDivider, { title: "Objective" }),
-    objective ? /* @__PURE__ */ React5.createElement(Text5, null, objective) : /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "No objectives"),
-    /* @__PURE__ */ React5.createElement(SectionDivider, { title: "Skills" }),
-    activeSkills.length > 0 ? activeSkills.map((s, i) => /* @__PURE__ */ React5.createElement(Text5, { key: i }, " ", s)) : /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "No skills"),
-    /* @__PURE__ */ React5.createElement(SectionDivider, { title: "Context" }),
-    contextDecisions.length > 0 || contextNotes.length > 0 ? /* @__PURE__ */ React5.createElement(ContextSection, { decisions: contextDecisions, notes: contextNotes, width }) : /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "No context"),
-    /* @__PURE__ */ React5.createElement(SectionDivider, { title: "Event Log" }),
-    /* @__PURE__ */ React5.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 React6 from "react";
-import { Box as Box6, Text as Text6 } 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) {
@@ -5467,8 +6169,8 @@ function ChecklistPanel({
 }) {
   const resolvedTasks = resolveChecklistTasks(tasks, contextDecisions, contextNotes);
   const checklist = formatEnhancedChecklist(resolvedTasks);
-  return /* @__PURE__ */ React6.createElement(
-    Box6,
+  return /* @__PURE__ */ React10.createElement(
+    Box10,
     {
       borderStyle: "single",
       borderColor: BORDER_COLORS.panel,
@@ -5476,17 +6178,17 @@ function ChecklistPanel({
       width,
       height
     },
-    /* @__PURE__ */ React6.createElement(Text6, { 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__ */ React6.createElement(Text6, { 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 React7 from "react";
-import { Box as Box7, Text as Text7 } 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) {
@@ -5554,29 +6256,29 @@ function StageStatDisplay({
   const parts = [];
   if (stats.running > 0)
     parts.push(
-      /* @__PURE__ */ React7.createElement(Text7, { 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__ */ React7.createElement(Text7, { 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__ */ React7.createElement(Text7, { 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__ */ React7.createElement(Text7, { 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__ */ React7.createElement(Text7, { 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__ */ React7.createElement(Text7, { key: "idle", dimColor: true }, " ", "idle")
+      /* @__PURE__ */ React11.createElement(Text11, { key: "idle", dimColor: true }, " ", "idle")
     );
-  return /* @__PURE__ */ React7.createElement(Box7, null, /* @__PURE__ */ React7.createElement(Text7, { color, bold: true }, mode, ":"), parts);
+  return /* @__PURE__ */ React11.createElement(Box11, null, /* @__PURE__ */ React11.createElement(Text11, { color, bold: true }, mode, ":"), parts);
 }
 function StageHealthBar({
   stageHealth,
@@ -5590,24 +6292,24 @@ function StageHealthBar({
   now: _now
 }) {
   const hasActivity = activityHistory && activityHistory.length > 0;
-  return /* @__PURE__ */ React7.createElement(
-    Box7,
+  return /* @__PURE__ */ React11.createElement(
+    Box11,
     {
       borderStyle: "double",
       borderColor: BORDER_COLORS.panel,
       width,
       flexDirection: "column"
     },
-    /* @__PURE__ */ React7.createElement(Box7, null, hasActivity && /* @__PURE__ */ React7.createElement(Box7, { gap: 1, marginRight: 1 }, /* @__PURE__ */ React7.createElement(Text7, { 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__ */ React7.createElement(Text7, { dimColor: true }, computeThroughput(activityHistory))), /* @__PURE__ */ React7.createElement(Box7, { gap: 2 }, ["PLAN", "ACT", "EVAL"].map((mode) => /* @__PURE__ */ React7.createElement(StageStatDisplay, { key: mode, mode, stats: stageHealth[mode] }))), /* @__PURE__ */ React7.createElement(Box7, { flexGrow: 1 }), /* @__PURE__ */ React7.createElement(Box7, { gap: 2 }, bottlenecks.length > 0 && /* @__PURE__ */ React7.createElement(Text7, { color: "red", bold: true }, "\u26A1 Bottlenecks: ", bottlenecks.join(" / ")), /* @__PURE__ */ React7.createElement(Text7, { dimColor: true }, "\u{1F916} ", formatCount(agentCount)), /* @__PURE__ */ React7.createElement(Text7, { dimColor: true }, "\u2699 ", formatCount(skillCount)), /* @__PURE__ */ React7.createElement(Text7, { 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 React8, { useMemo as useMemo3 } from "react";
-import { Box as Box8, Text as Text8 } 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) {
@@ -5776,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 = useMemo3(
+  const treeLines = useMemo6(
     () => renderAgentTree(agents, edges, activeSkills, Math.max(1, treeWidth - 2), contentHeight),
     [agents, edges, activeSkills, treeWidth, contentHeight]
   );
-  const cardLines = useMemo3(
+  const cardLines = useMemo6(
     () => renderAgentStatusCard(
       focusedAgent,
       currentMode,
@@ -5792,10 +6494,10 @@ function ActivityVisualizer({
     [focusedAgent, currentMode, objectives, activeSkills, cardWidth, contentHeight]
   );
   if (width <= 0 || height <= 0) {
-    return /* @__PURE__ */ React8.createElement(Box8, null);
+    return /* @__PURE__ */ React12.createElement(Box12, null);
   }
-  return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "row", width, height }, /* @__PURE__ */ React8.createElement(
-    Box8,
+  return /* @__PURE__ */ React12.createElement(Box12, { flexDirection: "row", width, height }, /* @__PURE__ */ React12.createElement(
+    Box12,
     {
       borderStyle: "single",
       borderColor: BORDER_COLORS.panel,
@@ -5803,9 +6505,9 @@ function ActivityVisualizer({
       width: treeWidth,
       height
     },
-    treeLines.map((line, i) => /* @__PURE__ */ React8.createElement(Text8, { key: i }, line))
-  ), /* @__PURE__ */ React8.createElement(
-    Box8,
+    treeLines.map((line, i) => /* @__PURE__ */ React12.createElement(Text12, { key: i }, line))
+  ), /* @__PURE__ */ React12.createElement(
+    Box12,
     {
       borderStyle: "single",
       borderColor: BORDER_COLORS.panel,
@@ -5813,7 +6515,7 @@ function ActivityVisualizer({
       width: cardWidth,
       height
     },
-    cardLines.map((line, i) => /* @__PURE__ */ React8.createElement(Text8, { key: i }, line))
+    cardLines.map((line, i) => /* @__PURE__ */ React12.createElement(Text12, { key: i }, line))
   ));
 }
 
@@ -5900,17 +6602,17 @@ function DashboardApp({
 }) {
   const { columns, rows, layoutMode } = useTerminalSize();
   const tick = useTick(1e3);
-  const now = useMemo4(() => 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 = useMemo4(() => computeStageHealth(state.agents), [state.agents]);
-  const bottlenecks = useMemo4(() => detectBottlenecks(state.eventLog), [state.eventLog]);
-  const grid = useMemo4(
+  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__ */ React9.createElement(Box9, { flexDirection: "column", width: grid.total.width, height: grid.total.height }, /* @__PURE__ */ React9.createElement(
+  return /* @__PURE__ */ React13.createElement(Box13, { flexDirection: "column", width: grid.total.width, height: grid.total.height }, /* @__PURE__ */ React13.createElement(
     HeaderBar,
     {
       workspace: workspaceProp ?? state.workspace,
@@ -5921,7 +6623,7 @@ function DashboardApp({
       tick,
       now
     }
-  ), layoutMode === "narrow" ? /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column" }, grid.checklistPanel.height > 0 && /* @__PURE__ */ React9.createElement(
+  ), layoutMode === "narrow" ? /* @__PURE__ */ React13.createElement(Box13, { flexDirection: "column" }, grid.checklistPanel.height > 0 && /* @__PURE__ */ React13.createElement(
     ChecklistPanel,
     {
       tasks: state.tasks,
@@ -5930,7 +6632,7 @@ function DashboardApp({
       width: grid.checklistPanel.width,
       height: grid.checklistPanel.height
     }
-  ), /* @__PURE__ */ React9.createElement(
+  ), /* @__PURE__ */ React13.createElement(
     FocusedAgentPanel,
     {
       agent: focusedAgent,
@@ -5944,52 +6646,34 @@ function DashboardApp({
       tick,
       now
     }
-  ), state.discussionRounds.length > 0 ? /* @__PURE__ */ React9.createElement(
-    AgentDiscussionPanel,
+  ), /* @__PURE__ */ React13.createElement(
+    ModeScreenRouter,
     {
-      rounds: state.discussionRounds,
-      width: grid.flowMap.width,
-      height: grid.flowMap.height
-    }
-  ) : /* @__PURE__ */ React9.createElement(
-    FlowMap,
-    {
-      agents: state.agents,
-      edges: state.edges,
+      state,
       layoutMode,
       width: grid.flowMap.width,
       height: grid.flowMap.height,
-      activeStage: state.currentMode,
       tick,
       now
     }
-  )) : /* @__PURE__ */ React9.createElement(
-    Box9,
+  )) : /* @__PURE__ */ React13.createElement(
+    Box13,
     {
       flexDirection: "row",
       width: grid.total.width,
       height: grid.checklistPanel.height + grid.focusedAgent.height
     },
-    /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", width: grid.flowMap.width }, state.discussionRounds.length > 0 ? /* @__PURE__ */ React9.createElement(
-      AgentDiscussionPanel,
-      {
-        rounds: state.discussionRounds,
-        width: grid.flowMap.width,
-        height: grid.flowMap.height
-      }
-    ) : /* @__PURE__ */ React9.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__ */ React9.createElement(
+    ), /* @__PURE__ */ React13.createElement(
       ActivityVisualizer,
       {
         currentMode: state.currentMode,
@@ -6002,7 +6686,7 @@ function DashboardApp({
         height: grid.monitorPanel.height
       }
     )),
-    /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", width: grid.checklistPanel.width }, /* @__PURE__ */ React9.createElement(
+    /* @__PURE__ */ React13.createElement(Box13, { flexDirection: "column", width: grid.checklistPanel.width }, /* @__PURE__ */ React13.createElement(
       ChecklistPanel,
       {
         tasks: state.tasks,
@@ -6011,7 +6695,7 @@ function DashboardApp({
         width: grid.checklistPanel.width,
         height: grid.checklistPanel.height
       }
-    ), /* @__PURE__ */ React9.createElement(
+    ), /* @__PURE__ */ React13.createElement(
       FocusedAgentPanel,
       {
         agent: focusedAgent,
@@ -6026,7 +6710,7 @@ function DashboardApp({
         now
       }
     ))
-  ), /* @__PURE__ */ React9.createElement(
+  ), /* @__PURE__ */ React13.createElement(
     StageHealthBar,
     {
       stageHealth,
@@ -6043,8 +6727,8 @@ function DashboardApp({
 }
 
 // src/tui/multi-session-app.tsx
-import React11, { useMemo as useMemo5, useCallback as useCallback2 } from "react";
-import { Box as Box11, 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
@@ -6200,8 +6884,8 @@ function useMultiSessionState(manager) {
 }
 
 // src/tui/components/SessionTabBar.tsx
-import React10 from "react";
-import { Box as Box10, Text as Text9 } 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 = {
@@ -6255,14 +6939,14 @@ function SessionTabBar({
   if (formatted === "") {
     return null;
   }
-  return /* @__PURE__ */ React10.createElement(Box10, { width, height: 1 }, /* @__PURE__ */ React10.createElement(Text9, 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 = useMemo5(() => {
+  const tabs = useMemo8(() => {
     let index = 0;
     const result = [];
     for (const [pid, sessionState] of sessions) {
@@ -6277,13 +6961,13 @@ function MultiSessionApp({ manager }) {
     }
     return result;
   }, [sessions, activeSessionPid]);
-  const activeEventBus = useMemo5(() => {
+  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 = useMemo5(() => {
+  const activeProjectRoot = useMemo8(() => {
     if (activeSessionPid === null) return void 0;
     return sessions.get(activeSessionPid)?.projectRoot;
   }, [sessions, activeSessionPid]);
@@ -6305,7 +6989,7 @@ function MultiSessionApp({ manager }) {
     [switchNext, switchPrev, switchByIndex]
   );
   useInput(handleInput);
-  return /* @__PURE__ */ React11.createElement(Box11, { flexDirection: "column" }, /* @__PURE__ */ React11.createElement(SessionTabBar, { sessions: tabs, width: columns, layoutMode }), /* @__PURE__ */ React11.createElement(
+  return /* @__PURE__ */ React15.createElement(Box15, { flexDirection: "column" }, /* @__PURE__ */ React15.createElement(SessionTabBar, { sessions: tabs, width: columns, layoutMode }), /* @__PURE__ */ React15.createElement(
     DashboardApp,
     {
       key: activeSessionPid ?? "none",
@@ -6353,19 +7037,22 @@ function createDefaultAgentState(params) {
 // src/tui/index.tsx
 function startTui(options) {
   const renderOptions = options.stdout ? { stdout: options.stdout } : {};
-  return render(/* @__PURE__ */ React12.createElement(DashboardApp, { eventBus: options.eventBus }), renderOptions);
+  return render(/* @__PURE__ */ React16.createElement(DashboardApp, { eventBus: options.eventBus }), renderOptions);
 }
 function renderMultiSession(options) {
-  return render(/* @__PURE__ */ React12.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,