u-foo 1.0.6 → 1.2.0

package/src/chat/index.js

@@ -1,64 +1,47 @@
-const net = require("net");
 const path = require("path");
 const blessed = require("blessed");
-const { spawn, spawnSync, execSync } = require("child_process");
+const { execSync } = require("child_process");
 const fs = require("fs");
-const { loadConfig, saveConfig, normalizeLaunchMode, normalizeAgentProvider } = require("../config");
+const {
+  loadConfig,
+  saveConfig,
+  normalizeLaunchMode,
+  normalizeAgentProvider,
+  normalizeAssistantEngine,
+} = require("../config");
 const { socketPath, isRunning } = require("../daemon");
 const UfooInit = require("../init");
-const EventBus = require("../bus");
 const AgentActivator = require("../bus/activate");
-const { getUfooPaths } = require("../ufoo/paths");
 const { subscriberToSafeName } = require("../bus/utils");
-
-function connectSocket(sockPath) {
-  return new Promise((resolve, reject) => {
-    const client = net.createConnection(sockPath, () => resolve(client));
-    client.on("error", reject);
-  });
-}
-
-function resolveProjectFile(projectRoot, relativePath, fallbackRelativePath) {
-  const local = path.join(projectRoot, relativePath);
-  if (fs.existsSync(local)) return local;
-  return path.join(__dirname, "..", "..", fallbackRelativePath);
-}
-
-function startDaemon(projectRoot, options = {}) {
-  const daemonBin = resolveProjectFile(projectRoot, path.join("bin", "ufoo.js"), path.join("bin", "ufoo.js"));
-  const env = options.forceResume
-    ? { ...process.env, UFOO_FORCE_RESUME: "1" }
-    : process.env;
-  const child = spawn(process.execPath, [daemonBin, "daemon", "--start"], {
-    detached: true,
-    stdio: "ignore",
-    cwd: projectRoot,
-    env,
-  });
-  child.unref();
-}
-
-function stopDaemon(projectRoot) {
-  const daemonBin = resolveProjectFile(projectRoot, path.join("bin", "ufoo.js"), path.join("bin", "ufoo.js"));
-  spawnSync(process.execPath, [daemonBin, "daemon", "--stop"], {
-    stdio: "ignore",
-    cwd: projectRoot,
-  });
-}
-
-async function connectWithRetry(sockPath, retries, delayMs) {
-  for (let i = 0; i < retries; i += 1) {
-    try {
-      // eslint-disable-next-line no-await-in-loop
-      const client = await connectSocket(sockPath);
-      return client;
-    } catch {
-      // eslint-disable-next-line no-await-in-loop
-      await new Promise((r) => setTimeout(r, delayMs));
-    }
-  }
-  return null;
-}
+const { getUfooPaths } = require("../ufoo/paths");
+const { startDaemon, stopDaemon, connectWithRetry } = require("./transport");
+const { escapeBlessed, stripBlessedTags, truncateText } = require("./text");
+const { COMMAND_REGISTRY, parseCommand, parseAtTarget } = require("./commands");
+const inputMath = require("./inputMath");
+const { createStreamTracker } = require("./streamTracker");
+const agentDirectory = require("./agentDirectory");
+const { computeAgentBar } = require("./agentBar");
+const { createAgentSockets } = require("./agentSockets");
+const { createDashboardKeyController } = require("./dashboardKeyController");
+const { computeDashboardContent } = require("./dashboardView");
+const { createCommandExecutor } = require("./commandExecutor");
+const { createInputSubmitHandler } = require("./inputSubmitHandler");
+const { keyToRaw } = require("./rawKeyMap");
+const { createCompletionController } = require("./completionController");
+const { createStatusLineController } = require("./statusLineController");
+const { createInputHistoryController } = require("./inputHistoryController");
+const { createInputListenerController } = require("./inputListenerController");
+const { createDaemonMessageRouter } = require("./daemonMessageRouter");
+const { createChatLogController } = require("./chatLogController");
+const { createPasteController } = require("./pasteController");
+const { createCronScheduler } = require("./cronScheduler");
+const { createAgentViewController } = require("./agentViewController");
+const { createSettingsController } = require("./settingsController");
+const { createChatLayout } = require("./layout");
+const { createDaemonCoordinator } = require("./daemonCoordinator");
+const { IPC_REQUEST_TYPES } = require("../shared/eventContract");
+const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
+const { createDaemonTransport } = require("./daemonTransport");
 
 async function runChat(projectRoot) {
   if (!fs.existsSync(getUfooPaths(projectRoot).ufooDir)) {
@@ -89,687 +72,153 @@ async function runChat(projectRoot) {
     startDaemon(projectRoot);
   }
 
-  const daemonBin = resolveProjectFile(projectRoot, path.join("bin", "ufoo.js"), path.join("bin", "ufoo.js"));
   const sock = socketPath(projectRoot);
-  let client = null;
-  let reconnectPromise = null;
-  let exitRequested = false;
-  let connectionLostNotified = false;
-  const pendingRequests = [];
-  const MAX_PENDING_REQUESTS = 50;
-
-  const connectClient = async () => {
-    let newClient = await connectWithRetry(sock, 25, 200);
-    if (!newClient) {
-      // Retry once with a fresh daemon start and longer wait.
-      if (!isRunning(projectRoot)) {
-        startDaemon(projectRoot);
-        // Wait for daemon to write PID file and create socket
-        await new Promise(r => setTimeout(r, 1000));
-      }
-      newClient = await connectWithRetry(sock, 50, 200);
-    }
-    return newClient;
-  };
-
-  function enqueueRequest(req) {
-    if (!req || req.type === "status") return;
-    pendingRequests.push(req);
-    if (pendingRequests.length > MAX_PENDING_REQUESTS) {
-      pendingRequests.shift();
-    }
-  }
-
-  function flushPendingRequests() {
-    if (!client || client.destroyed) return;
-    while (pendingRequests.length > 0) {
-      const req = pendingRequests.shift();
-      client.write(`${JSON.stringify(req)}\n`);
-    }
-  }
-
-  async function ensureConnected() {
-    if (client && !client.destroyed) return true;
-    if (exitRequested) return false;
-    if (reconnectPromise) return reconnectPromise;
-    queueStatusLine("Reconnecting to daemon");
-    logMessage("status", "{magenta-fg}⚙{/magenta-fg} Reconnecting to daemon...");
-    reconnectPromise = (async () => {
-      const newClient = await connectClient();
-      if (!newClient) {
-        resolveStatusLine("{red-fg}✗{/red-fg} Daemon offline");
-        logMessage("error", "{red-fg}✗{/red-fg} Failed to reconnect to daemon");
-        return false;
-      }
-      attachClient(newClient);
-      connectionLostNotified = false;
-      resolveStatusLine("{green-fg}✓{/green-fg} Daemon reconnected");
-      requestStatus();
-      return true;
-    })();
-    try {
-      return await reconnectPromise;
-    } finally {
-      reconnectPromise = null;
-    }
-  }
-
-  client = await connectClient();
-  if (!client) {
-    // Check if daemon failed to start
-    if (!isRunning(projectRoot)) {
-      const logFile = getUfooPaths(projectRoot).ufooDaemonLog;
-      // eslint-disable-next-line no-console
-      console.error("Failed to start ufoo daemon. Check logs at:", logFile);
-      throw new Error("Daemon failed to start. Check the daemon log for details.");
-    }
-    throw new Error("Failed to connect to ufoo daemon (timeout). The daemon may still be starting.");
-  }
-
-  const screen = blessed.screen({
-    smartCSR: true,
-    title: "ufoo chat",
-    fullUnicode: true,
-    // Toggle mouse at runtime to balance copy vs scroll
-    sendFocus: true,
-    mouse: false,
-    // Allow Ctrl+C to exit even when input grabs keys
-    ignoreLocked: ["C-c"],
+  let daemonCoordinator = null;
+  const daemonTransport = createDaemonTransport({
+    projectRoot,
+    sockPath: sock,
+    isRunning,
+    startDaemon,
+    connectWithRetry,
   });
-  // Prefer normal buffer for reliable terminal selection/copy
-  if (screen.program && typeof screen.program.normalBuffer === "function") {
-    screen.program.normalBuffer();
-    if (screen.program.put && typeof screen.program.put.keypad_local === "function") {
-      screen.program.put.keypad_local();
-    }
-    if (typeof screen.program.clear === "function") {
-      screen.program.clear();
-      screen.program.cup(0, 0);
-    }
-  }
 
   const config = loadConfig(projectRoot);
   let launchMode = config.launchMode;
   let agentProvider = config.agentProvider;
+  let assistantEngine = normalizeAssistantEngine(config.assistantEngine);
   let autoResume = config.autoResume !== false;
+  let cronScheduler = {
+    addTask: () => null,
+    listTasks: () => [],
+    stopTask: () => false,
+    stopAll: () => 0,
+  };
 
   // Dynamic input height settings
   // Layout: topLine(1) + content + bottomLine(1) + dashboard(1)
   const MIN_INPUT_HEIGHT = 4;  // 1 content + 3
   const MAX_INPUT_HEIGHT = 9;  // 6 content + 3
   let currentInputHeight = MIN_INPUT_HEIGHT;
-
-  // Log area (no border for cleaner look)
-  const logBox = blessed.log({
-    parent: screen,
-    top: 0,
-    left: 0,
-    width: "100%",
-    height: "100%-5",  // Will be adjusted dynamically
-    tags: true,
-    scrollable: true,
-    alwaysScroll: true,
-    scrollback: 10000,
-    scrollbar: null,
-    keys: true,
-    vi: true,
-    // Mouse handled globally (toggleable) to keep copy working
-    mouse: false,
-  });
-
-  // Status line just above input
-  const statusLine = blessed.box({
-    parent: screen,
-    bottom: currentInputHeight,
-    left: 0,
-    width: "100%",
-    height: 1,
-    style: { fg: "gray" },
-    tags: true,
-    content: "",
-  });
   const pkg = require("../../package.json");
-  const bannerText = `{bold}UFOO{/bold} · Multi-Agent Manager{|}v${pkg.version}`;
-  statusLine.setContent(bannerText);
+  const {
+    screen,
+    logBox,
+    statusLine,
+    bannerText,
+    completionPanel,
+    dashboard,
+    inputBottomLine,
+    promptBox,
+    input,
+    inputTopLine,
+  } = createChatLayout({
+    blessed,
+    currentInputHeight,
+    version: pkg.version,
+  });
 
   const historyDir = path.join(getUfooPaths(projectRoot).ufooDir, "chat");
   const historyFile = path.join(historyDir, "history.jsonl");
   const inputHistoryFile = path.join(historyDir, "input-history.jsonl");
 
-  function appendHistory(entry) {
-    fs.mkdirSync(historyDir, { recursive: true });
-    fs.appendFileSync(historyFile, `${JSON.stringify(entry)}\n`);
-  }
-
-  const SPACED_TYPES = new Set(["user", "reply", "bus", "dispatch", "error"]);
-  let lastLogWasSpacer = false;
-  let lastLogType = null;
-  let hasLoggedAny = false;
-
-  function shouldSpace(type, text) {
-    if (SPACED_TYPES.has(type)) return true;
-    if (text && /daemon/i.test(text)) return true;
-    return false;
-  }
+  const chatLogController = createChatLogController({
+    logBox,
+    fsModule: fs,
+    historyDir,
+    historyFile,
+  });
 
-  function writeSpacer(writeHistory) {
-    if (lastLogWasSpacer || !hasLoggedAny) return;
-    try {
-      logBox.log(" ");
-    } catch {
-      // ignore rendering errors
-    }
-    if (writeHistory) {
-      appendHistory({
-        ts: new Date().toISOString(),
-        type: "spacer",
-        text: "",
-        meta: {},
-      });
-    }
-    lastLogWasSpacer = true;
-    lastLogType = "spacer";
-    hasLoggedAny = true;
-  }
+  const streamTracker = createStreamTracker({
+    logBox,
+    writeSpacer: () => chatLogController.writeSpacer(false),
+    appendHistory: (...args) => chatLogController.appendHistory(...args),
+    escapeBlessed,
+    onStreamStart: () => chatLogController.markStreamStart(),
+  });
 
-  function recordLog(type, text, meta = {}, writeHistory = true) {
-    const lineText = text == null ? "" : String(text);
-    if (type !== "spacer" && shouldSpace(type, text)) {
-      writeSpacer(writeHistory);
-    }
-    appendToLogBox(lineText);
-    if (writeHistory) {
-      appendHistory({
-        ts: new Date().toISOString(),
-        type,
-        text: lineText,
-        meta,
-      });
-    }
-    lastLogWasSpacer = false;
-    lastLogType = type;
-    hasLoggedAny = true;
-  }
+  const beginStream = (...args) => streamTracker.beginStream(...args);
+  const appendStreamDelta = (...args) => streamTracker.appendStreamDelta(...args);
+  const finalizeStream = (...args) => streamTracker.finalizeStream(...args);
+  const markPendingDelivery = (...args) => streamTracker.markPendingDelivery(...args);
+  const getPendingState = (...args) => streamTracker.getPendingState(...args);
+  const consumePendingDelivery = (...args) => streamTracker.consumePendingDelivery(...args);
 
   function logMessage(type, text, meta = {}) {
-    recordLog(type, text, meta, true);
-  }
-
-  // Prevent blessed tag parsing crashes from untrusted text.
-  // blessed parses `{...}` as style tags; certain inputs like `{foo,bar}` can
-  // trigger a blessed bug (Program._attr on unknown comma/semicolon parts).
-  //
-  // Workaround: blessed@0.1.81 has a bug where tags containing comma/semicolon
-  // (e.g. `{foo,bar}`) can crash when the log widget reparses cached lines.
-  // We proactively neutralize any such tag-like sequences so they don't match
-  // blessed's tag regex on subsequent reparses.
-  function neutralizeBlessedCommaTags(text) {
-    if (text == null) return "";
-    const raw = String(text);
-    if (!raw.includes("{")) return raw;
-    return raw.replace(/\{\/?[\w\-,;!#]*[;,][\w\-,;!#]*\}/g, (m) => {
-      // Insert a space after separators so `{foo,bar}` becomes `{foo, bar}`.
-      // This stops blessed from treating it as a tag on future reparses.
-      const inner = m.slice(1, -1).replace(/[,;]/g, (ch) => `${ch} `);
-      return `{${inner}}`;
-    });
-  }
-
-  function escapeBlessed(text) {
-    if (text == null) return "{escape}{/escape}";
-    const raw = neutralizeBlessedCommaTags(text);
-    // Avoid allowing payload to terminate escape mode.
-    const safe = raw.replace(/\{\/escape\}/g, "{open}/escape{close}");
-    return `{escape}${safe}{/escape}`;
-  }
-
-  function appendToLogBox(text) {
-    // Avoid a blessed render-time crash for `{foo,bar}`-like tag sequences.
-    logBox.log(neutralizeBlessedCommaTags(text));
+    chatLogController.logMessage(type, text, meta);
   }
 
   function loadHistory(limit = 2000) {
-    try {
-      const lines = fs.readFileSync(historyFile, "utf8").trim().split(/\r?\n/).filter(Boolean);
-      const items = lines.slice(-limit).map((line) => JSON.parse(line));
-      const hasSpacer = items.some((item) => item && item.type === "spacer");
-      for (const item of items) {
-        if (!item) continue;
-        if (item.type === "spacer") {
-          writeSpacer(false);
-          continue;
-        }
-        if (!item.text) continue;
-        if (hasSpacer) {
-          appendToLogBox(item.text);
-          lastLogWasSpacer = false;
-          lastLogType = item.type || null;
-          hasLoggedAny = true;
-        } else {
-          recordLog(item.type || "unknown", item.text, item.meta || {}, false);
-        }
-      }
-    } catch {
-      // ignore missing/invalid history
-    }
+    chatLogController.loadHistory(limit);
   }
 
-  const inputHistory = [];
-  let historyIndex = 0;
-  let historyDraft = "";
-
-  function appendInputHistory(text) {
-    if (!text) return;
-    fs.mkdirSync(historyDir, { recursive: true });
-    fs.appendFileSync(inputHistoryFile, `${JSON.stringify({ text })}\n`);
-  }
+  let inputHistoryController = null;
 
   function loadInputHistory(limit = 2000) {
-    try {
-      const lines = fs.readFileSync(inputHistoryFile, "utf8").trim().split(/\r?\n/).filter(Boolean);
-      const items = lines.slice(-limit).map((line) => JSON.parse(line));
-      for (const item of items) {
-        if (item && typeof item.text === "string" && item.text.trim() !== "") {
-          inputHistory.push(item.text);
-        }
-      }
-    } catch {
-      // ignore missing/invalid history
-    }
-    historyIndex = inputHistory.length;
-  }
-
-  const pendingStatusLines = [];
-  const busStatusQueue = [];
-  let primaryStatusText = bannerText;
-  let primaryStatusPending = false;
-  const shimmerStart = Date.now();
-  let statusAnimationTimer = null;
-  const STATUS_ANIM_FRAME_MS = 50;
-  const SHIMMER_PADDING = 10;
-  const SHIMMER_BAND_HALF_WIDTH = 5;
-  const SHIMMER_SWEEP_MS = 2000;
-  const SPINNER_PERIOD_MS = 600;
-
-  function formatProcessingText(text) {
-    if (!text) return text;
-    if (text.includes("{")) return text;
-    if (!/processing/i.test(text)) return text;
-    return text;
-  }
-
-  function shimmerText(text, nowMs) {
-    if (!text) return "";
-    if (text.includes("{")) return text;
-    const chars = Array.from(text);
-    const period = chars.length + SHIMMER_PADDING * 2;
-    const pos =
-      Math.floor(((nowMs - shimmerStart) % SHIMMER_SWEEP_MS) / SHIMMER_SWEEP_MS * period);
-    let out = "";
-    for (let i = 0; i < chars.length; i += 1) {
-      const iPos = i + SHIMMER_PADDING;
-      const dist = Math.abs(iPos - pos);
-      let intensity = 0;
-      if (dist <= SHIMMER_BAND_HALF_WIDTH) {
-        const x = Math.PI * (dist / SHIMMER_BAND_HALF_WIDTH);
-        intensity = 0.5 * (1 + Math.cos(x));
-      }
-      const ch = chars[i];
-      if (intensity < 0.2) {
-        out += `{gray-fg}${ch}{/gray-fg}`;
-      } else if (intensity < 0.6) {
-        out += ch;
-      } else {
-        out += `{bold}{white-fg}${ch}{/white-fg}{/bold}`;
-      }
-    }
-    return out;
-  }
-
-  function spinnerFrame(nowMs) {
-    const on = Math.floor((nowMs - shimmerStart) / SPINNER_PERIOD_MS) % 2 === 0;
-    return on
-      ? "{white-fg}•{/white-fg}"
-      : "{gray-fg}◦{/gray-fg}";
-  }
-
-  function renderPendingStatus(text, nowMs) {
-    const spinner = spinnerFrame(nowMs);
-    const shimmer = shimmerText(text, nowMs);
-    if (!shimmer) return spinner;
-    return `${spinner} ${shimmer}`;
+    if (!inputHistoryController) return;
+    inputHistoryController.loadInputHistory(limit);
   }
 
-  function renderStatusLine(nowMs = Date.now()) {
-    let content = primaryStatusText || "";
-    if (primaryStatusPending) {
-      content = renderPendingStatus(primaryStatusText, nowMs);
-    }
-    if (busStatusQueue.length > 0) {
-      const extra = busStatusQueue.length > 1
-        ? ` {gray-fg}(+${busStatusQueue.length - 1}){/gray-fg}`
-        : "";
-      const busText = `${busStatusQueue[0].text}${extra}`;
-      content = content
-        ? `${content} {gray-fg}·{/gray-fg} ${busText}`
-        : busText;
-    }
-    statusLine.setContent(content);
-  }
-
-  function updateStatusAnimation() {
-    if (primaryStatusPending && !statusAnimationTimer) {
-      statusAnimationTimer = setInterval(() => {
-        if (!primaryStatusPending) return;
-        renderStatusLine(Date.now());
-        screen.render();
-      }, STATUS_ANIM_FRAME_MS);
-    } else if (!primaryStatusPending && statusAnimationTimer) {
-      clearInterval(statusAnimationTimer);
-      statusAnimationTimer = null;
-    }
-  }
-
-  function setPrimaryStatus(text, options = {}) {
-    primaryStatusText = text || "";
-    primaryStatusPending = Boolean(options.pending);
-    updateStatusAnimation();
-    renderStatusLine();
-  }
-
-  function queueStatusLine(text) {
-    let raw = text || "";
-    pendingStatusLines.push(raw);
-    if (pendingStatusLines.length === 1) {
-      setPrimaryStatus(raw, { pending: true });
-      screen.render();
-    }
-  }
-
-  function resolveStatusLine(text) {
-    if (pendingStatusLines.length > 0) {
-      pendingStatusLines.shift();
-    }
-    if (pendingStatusLines.length > 0) {
-      setPrimaryStatus(pendingStatusLines[0], { pending: true });
-    } else {
-      setPrimaryStatus(text || "", { pending: false });
-    }
-    screen.render();
-  }
-
-  function enqueueBusStatus(item) {
-    if (!item || !item.text) return;
-    const rawText = item.text == null ? "" : String(item.text);
-    const key = item.key || rawText;
-    const formatted = escapeBlessed(formatProcessingText(rawText));
-    const existing = busStatusQueue.find((entry) => entry.key === key);
-    if (existing) {
-      existing.text = formatted;
-    } else {
-      busStatusQueue.push({ key, text: formatted });
-    }
-    renderStatusLine();
-  }
-
-  function resolveBusStatus(item) {
-    if (!item) return;
-    const rawText = item.text == null ? "" : String(item.text);
-    const key = item.key || rawText;
-    let index = -1;
-    if (key) {
-      index = busStatusQueue.findIndex((entry) => entry.key === key);
-    }
-    if (index === -1 && item.text) {
-      index = busStatusQueue.findIndex((entry) => entry.text === item.text);
-    }
-    if (index === -1) return;
-    busStatusQueue.splice(index, 1);
-    renderStatusLine();
-  }
-
-  // Command completion panel
-  const completionPanel = blessed.box({
-    parent: screen,
-    bottom: currentInputHeight - 1,
-    left: 0,
-    width: "100%",
-    height: 0,
-    hidden: true,
-    wrap: false,
-    border: {
-      type: "line",
-      top: true,
-      left: false,
-      right: false,
-      bottom: false
-    },
-    style: {
-      border: { fg: "yellow" },
-      fg: "white"
-      // No bg - uses terminal default background
-    },
-    padding: {
-      left: 0,
-      right: 0,
-      top: 0,
-      bottom: 0
-    },
-    tags: true,
-  });
-
-  // Dashboard at very bottom
-  const dashboard = blessed.box({
-    parent: screen,
-    bottom: 0,
-    left: 0,
-    width: "100%",
-    height: 1,
-    style: { fg: "gray" },
-    tags: true,
-  });
-
-  // Agent TTY view state
-  let currentView = "main";        // "main" | "agent"
-  let viewingAgent = null;          // subscriber ID of agent being viewed
-  let agentOutputClient = null;     // net.Socket connected to inject.sock
-  let agentOutputBuffer = "";       // partial line buffer for output parsing
-  let agentInputClient = null;      // net.Socket for sending raw input
-  let _detachedChildren = null;     // Screen children saved during agent view
-  let agentInputSuppressUntil = 0;  // Suppress input forwarding until this timestamp
-
-  // Bottom border line for input area (above dashboard)
-  const inputBottomLine = blessed.line({
-    parent: screen,
-    bottom: 1,
-    left: 0,
-    width: "100%",
-    orientation: "horizontal",
-    style: { fg: "cyan" },
-  });
-
-  // Prompt indicator
-  const promptBox = blessed.box({
-    parent: screen,
-    bottom: 2,
-    left: 0,
-    width: 2,
-    height: currentInputHeight - 3,
-    content: ">",
-    style: { fg: "cyan" },
+  const statusLineController = createStatusLineController({
+    statusLine,
+    bannerText,
+    renderScreen: () => screen.render(),
   });
 
-  // Input area without left/right border
-  const input = blessed.textarea({
-    parent: screen,
-    bottom: 2,
-    left: 2,
-    width: "100%-2",
-    height: currentInputHeight - 3,
-    inputOnFocus: true,
-    keys: true,
-  });
-  // Avoid textarea's extra wrap margin (causes a phantom empty column)
-  input.type = "box";
-
-  // Top border line for input area (just above input)
-  const inputTopLine = blessed.line({
-    parent: screen,
-    bottom: currentInputHeight - 1,  // 4-1=3: above input(2) + inputHeight(1)
-    left: 0,
-    width: "100%",
-    orientation: "horizontal",
-    style: { fg: "cyan" },
+  const queueStatusLine = (...args) => statusLineController.queueStatusLine(...args);
+  const resolveStatusLine = (...args) => statusLineController.resolveStatusLine(...args);
+  const enqueueBusStatus = (...args) => statusLineController.enqueueBusStatus(...args);
+  const resolveBusStatus = (...args) => statusLineController.resolveBusStatus(...args);
+
+  let agentViewController = null;
+  let terminalAdapterRouter = null;
+  const agentSockets = createAgentSockets({
+    onTermWrite: (text) => writeToAgentTerm(text),
+    onPlaceCursor: (cursor) => placeAgentCursor(cursor),
+    isAgentView: () => getCurrentView() === "agent",
+    isBusMode: () => isAgentViewUsesBus(),
+    getViewingAgent: () => getViewingAgent(),
+    sendBusRaw: (target, data) => {
+      send({
+        type: IPC_REQUEST_TYPES.BUS_SEND,
+        target,
+        message: JSON.stringify({ raw: true, data }),
+      });
+    },
   });
 
   // Add cursor position tracking
   let cursorPos = 0;
   let preferredCol = null;
-  const unicode = blessed.unicode;
-  const wideRegex = new RegExp(unicode.chars.all.source);
 
-  // Get inner width
   function getInnerWidth() {
-    const lpos = input.lpos || input._getCoords();
-    if (lpos && Number.isFinite(lpos.xl) && Number.isFinite(lpos.xi)) {
-      return Math.max(1, lpos.xl - lpos.xi + 1);
-    }
-    if (typeof input.width === "number") return Math.max(1, input.width);
-    if (typeof input.width === "string") {
-      const match = input.width.match(/^100%-([0-9]+)$/);
-      if (match && typeof screen.width === "number") {
-        return Math.max(1, screen.width - parseInt(match[1], 10));
-      }
-    }
     const promptWidth = typeof promptBox.width === "number" ? promptBox.width : 2;
-    if (typeof screen.width === "number") return Math.max(1, screen.width - promptWidth);
-    if (typeof screen.cols === "number") return Math.max(1, screen.cols - promptWidth);
-    return 1;
+    return inputMath.getInnerWidth({ input, screen, promptWidth });
   }
 
   function getWrapWidth() {
-    if (input._clines && typeof input._clines.width === "number") {
-      return Math.max(1, input._clines.width);
-    }
-    return getInnerWidth();
-  }
-
-  function isWideChar(ch) {
-    return wideRegex.test(ch);
-  }
-
-  function transformChar(ch) {
-    if (ch === "\n") return "\n";
-    if (ch === "\r") return "";
-    if (ch === "\t") return screen.tabc;
-
-    const code = ch.codePointAt(0);
-    if (
-      code <= 0x08
-      || code === 0x0b
-      || code === 0x0c
-      || (code >= 0x0e && code <= 0x1a)
-      || (code >= 0x1c && code <= 0x1f)
-      || code === 0x7f
-    ) {
-      return "";
-    }
-
-    if (ch === "\x1b") return "";
-
-    const isWide = isWideChar(ch);
-
-    if (screen.fullUnicode) {
-      if (screen.program && screen.program.isiTerm2 && unicode.isCombining(ch, 0)) {
-        return "";
-      }
-      if (isWide) return `${ch}\x03`;
-      return ch;
-    }
-
-    if (unicode.isCombining(ch, 0)) return "";
-    if (unicode.isSurrogate(ch, 0)) return "?";
-    if (isWide) return "??";
-    return ch;
-  }
-
-  function transformText(text) {
-    if (!text) return "";
-    const out = [];
-    for (const ch of text) {
-      out.push(transformChar(ch));
-    }
-    return out.join("");
-  }
-
-  function visualLength(text) {
-    return transformText(text).length;
+    return inputMath.getWrapWidth(input, getInnerWidth());
   }
 
-  function originalIndexForVisual(line, visualIndex) {
-    if (visualIndex <= 0) return 0;
-    let visual = 0;
-    let offset = 0;
-    for (const ch of line) {
-      const rep = transformChar(ch);
-      const repLen = rep.length;
-      if (visual + repLen > visualIndex) return offset;
-      visual += repLen;
-      offset += ch.length;
-    }
-    return line.length;
-  }
-
-  // Count lines considering both wrapping and newlines (matches blessed wrap)
   function countLines(text, width) {
-    if (width <= 0) return 1;
-    const lines = (text || "").split("\n");
-    let total = 0;
-    for (const line of lines) {
-      const lineWidth = visualLength(line);
-      total += Math.max(1, Math.ceil(lineWidth / width));
-    }
-    return total;
+    return inputMath.countLines(text, width, (value) => input.strWidth(value));
   }
 
   function getCursorRowCol(text, pos, width) {
-    if (width <= 0) return { row: 0, col: 0 };
-    const before = (text || "").slice(0, pos);
-    const transformed = transformText(before);
-    const lines = transformed.split("\n");
-    let row = 0;
-    for (let i = 0; i < lines.length - 1; i++) {
-      const lineWidth = lines[i].length;
-      row += Math.max(1, Math.ceil(lineWidth / width));
-    }
-    const lastLine = lines[lines.length - 1] || "";
-    const lastWidth = lastLine.length;
-    row += Math.floor(lastWidth / width);
-    const col = lastWidth % width;
-    return { row, col };
+    return inputMath.getCursorRowCol(text, pos, width, (value) => input.strWidth(value));
   }
 
   function getCursorPosForRowCol(text, targetRow, targetCol, width) {
-    if (width <= 0) return 0;
-    const lines = (text || "").split("\n");
-    let row = 0;
-    let pos = 0;
-    for (const line of lines) {
-      const lineWidth = visualLength(line);
-      const wrappedRows = Math.max(1, Math.ceil(lineWidth / width));
-      if (targetRow < row + wrappedRows) {
-        const rowInLine = targetRow - row;
-        const visualCol = rowInLine * width + Math.max(0, targetCol);
-        return pos + originalIndexForVisual(line, Math.min(visualCol, lineWidth));
-      }
-      pos += line.length + 1;
-      row += wrappedRows;
-    }
-    return text.length;
+    return inputMath.getCursorPosForRowCol(
+      text,
+      targetRow,
+      targetCol,
+      width,
+      (value) => input.strWidth(value),
+    );
   }
 
   function ensureInputCursorVisible() {
-    const innerWidth = getWrapWidth();
+    const innerWidth = getInnerWidth();
     if (innerWidth <= 0) return;
     const totalRows = countLines(input.value, innerWidth);
     const visibleRows = Math.max(1, input.height || 1);
@@ -800,33 +249,21 @@ async function runChat(projectRoot) {
     preferredCol = null;
   }
 
-  const PASTE_START = "\x1b[200~";
-  const PASTE_END = "\x1b[201~";
-  let pasteActive = false;
-  let pasteBuffer = "";
-  let pasteRemainder = "";
-  let suppressKeypress = false;
-  let suppressReset = null;
+  function getPreferredCol() {
+    return preferredCol;
+  }
 
-  function scheduleSuppressReset() {
-    suppressKeypress = true;
-    if (suppressReset) clearImmediate(suppressReset);
-    suppressReset = setImmediate(() => {
-      if (!pasteActive) suppressKeypress = false;
-    });
+  function setPreferredCol(value) {
+    preferredCol = value;
   }
 
   function normalizePaste(text) {
-    if (!text) return "";
-    let normalized = text.replace(/\x1b\[200~|\x1b\[201~/g, "");
-    normalized = normalized.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-    return normalized;
+    return inputMath.normalizePaste(text);
   }
 
   function updateDraftFromInput() {
-    if (historyIndex === inputHistory.length) {
-      historyDraft = input.value;
-    }
+    if (!inputHistoryController) return;
+    inputHistoryController.updateDraftFromInput();
   }
 
   function normalizeCommandPrefix() {
@@ -861,639 +298,156 @@ async function runChat(projectRoot) {
     screen.render();
   }
 
+  inputHistoryController = createInputHistoryController({
+    inputHistoryFile,
+    historyDir,
+    setInputValue,
+    getInputValue: () => input.value || "",
+  });
+
   function historyUp() {
-    if (inputHistory.length === 0) return false;
-    if (historyIndex === inputHistory.length) {
-      historyDraft = input.value;
-    }
-    if (historyIndex > 0) {
-      historyIndex -= 1;
-      setInputValue(inputHistory[historyIndex]);
-      return true;
-    }
-    return true;
+    if (!inputHistoryController) return false;
+    return inputHistoryController.historyUp();
   }
 
   function historyDown() {
-    if (inputHistory.length === 0) return false;
-    if (historyIndex < inputHistory.length - 1) {
-      historyIndex += 1;
-      setInputValue(inputHistory[historyIndex]);
-      return true;
-    }
-    if (historyIndex === inputHistory.length - 1) {
-      historyIndex = inputHistory.length;
-      setInputValue(historyDraft || "");
-      return true;
-    }
-    return false;
+    if (!inputHistoryController) return false;
+    return inputHistoryController.historyDown();
   }
 
   function exitHandler() {
-    exitRequested = true;
-    // Clean up agent view connections
-    disconnectAgentOutput();
-    disconnectAgentInput();
+    if (daemonCoordinator) {
+      daemonCoordinator.markExit();
+    }
+    cronScheduler.stopAll();
+    exitAgentView();
     if (screen && screen.program && typeof screen.program.decrst === "function") {
       screen.program.decrst(2004);
     }
-    if (statusAnimationTimer) {
-      clearInterval(statusAnimationTimer);
-      statusAnimationTimer = null;
-    }
-    if (client) {
-      client.end();
+    statusLineController.destroy();
+    if (daemonCoordinator) {
+      daemonCoordinator.close();
     }
     process.exit(0);
   }
 
-  // Command completion functions
-  function showCompletion(filterText) {
-    // Ensure accidental double-prefix doesn't break filtering.
-    normalizeCommandPrefix();
-    if (filterText !== input.value) {
-      filterText = input.value;
-    }
-    if (filterText.startsWith("//")) {
-      filterText = filterText.replace(/^\/+/, "/");
-      input.value = filterText;
-      cursorPos = Math.min(cursorPos, input.value.length);
-    }
-    if (!filterText || filterText === "") {
-      hideCompletion();
-      return;
-    }
-
-    // Trim the filterText to handle trailing spaces for main command mode
-    // But preserve spaces for subcommand mode detection
-    const endsWithSpace = /\s$/.test(filterText);
-    const trimmed = filterText.trim();
-    if (!trimmed) {
-      hideCompletion();
-      return;
-    }
-    filterText = trimmed;
-
-    // Check if we're in subcommand mode
-    const parts = filterText.split(/\s+/);
-    let commands = [];
-
-    const mainCmd = parts[0];
-    const isLaunch = mainCmd && mainCmd.toLowerCase() === "/launch";
-    const wantsSubcommands = (parts.length > 1 || (endsWithSpace && parts.length === 1));
-
-    if ((wantsSubcommands || isLaunch) && mainCmd && mainCmd.startsWith("/")) {
-      // Subcommand mode: "/bus rename"
-      const subFilter = parts[1] || "";
-
-      // Find the main command
-      const mainCmdObj = COMMAND_REGISTRY.find(item =>
-        item.cmd.toLowerCase() === mainCmd.toLowerCase()
-      );
-
-      const fallbackLaunchSubs = [
-        { cmd: "claude", desc: "Launch Claude agent" },
-        { cmd: "codex", desc: "Launch Codex agent" },
-      ];
-
-      if ((mainCmdObj && mainCmdObj.subcommands) || isLaunch) {
-        const baseSubs = mainCmdObj && mainCmdObj.subcommands ? mainCmdObj.subcommands : [];
-        let subs = baseSubs;
-        if (isLaunch) {
-          const merged = new Map();
-          for (const sub of [...baseSubs, ...fallbackLaunchSubs]) {
-            if (!sub || !sub.cmd) continue;
-            merged.set(sub.cmd, sub);
-          }
-          subs = Array.from(merged.values());
-        }
-        if (isLaunch) {
-          // Always show both launch targets for clarity
-          commands = subs
-            .map(sub => ({ ...sub, isSubcommand: true, parentCmd: mainCmd }))
-            .sort((a, b) => a.cmd.localeCompare(b.cmd));
-        } else {
-          // Filter subcommands
-          commands = subs
-            .filter(sub => sub.cmd.toLowerCase().startsWith(subFilter.toLowerCase()))
-            .map(sub => ({ ...sub, isSubcommand: true, parentCmd: mainCmd }))
-            .sort((a, b) => a.cmd.localeCompare(b.cmd));
-        }
-      }
-    } else {
-      // Main command mode: "/bus"
-      const filterLower = filterText.toLowerCase();
-      commands = COMMAND_REGISTRY
-        .filter(item => item.cmd.toLowerCase().startsWith(filterLower))
-        .sort((a, b) => a.cmd.localeCompare(b.cmd, "en", { sensitivity: "base" }));
-    }
+  const completionController = createCompletionController({
+    input,
+    screen,
+    completionPanel,
+    promptBox,
+    commandRegistry: COMMAND_REGISTRY,
+    getMentionCandidates: () => activeAgents.map((id) => ({
+      id,
+      label: getAgentLabel(id),
+    })),
+    normalizeCommandPrefix,
+    truncateText,
+    getCurrentInputHeight: () => currentInputHeight,
+    getCursorPos: () => cursorPos,
+    setCursorPos: (value) => {
+      cursorPos = value;
+    },
+    resetPreferredCol,
+    updateDraftFromInput,
+    renderScreen: () => screen.render(),
+  });
 
-    if (commands.length === 0) {
-      hideCompletion();
-      return;
-    }
+  const pasteController = createPasteController({
+    shouldHandle: () => screen.focused === input && focusMode === "input",
+    normalizePaste,
+    insertTextAtCursor,
+  });
 
-    completionCommands = commands;
-    completionActive = true;
-    completionIndex = 0;
-    completionScrollOffset = 0;
-
-    // Calculate panel height (visible items + 2 for blessed border overhead)
-    // blessed reserves 2 rows for border (iheight) even when only border.top is set
-    const availableHeight = screen.height - currentInputHeight - 1;
-    completionVisibleCount = Math.min(7, completionCommands.length);
-    completionVisibleCount = Math.min(completionVisibleCount, Math.max(1, availableHeight - 2));
-    completionPanel.height = completionVisibleCount + 2;
-    completionPanel.bottom = currentInputHeight - 1;
-    completionPanel.hidden = false;
-
-    renderCompletionPanel();
-  }
-
-  function hideCompletion() {
-    completionActive = false;
-    completionCommands = [];
-    completionIndex = 0;
-    completionScrollOffset = 0;
-    completionVisibleCount = 0;
-    completionPanel.hidden = true;
-    screen.render();
-  }
+  const inputListenerController = createInputListenerController({
+    getCurrentView: () => getCurrentView(),
+    exitHandler,
+    getFocusMode: () => focusMode,
+    getDashboardView: () => dashboardView,
+    getSelectedAgentIndex: () => selectedAgentIndex,
+    getActiveAgents: () => activeAgents,
+    getTargetAgent: () => targetAgent,
+    requestCloseAgent,
+    logMessage,
+    isSuppressKeypress: () => pasteController.isSuppressKeypress(),
+    normalizeCommandPrefix,
+    handleDashboardKey,
+    exitDashboardMode,
+    completionController,
+    getLogHeight: () => logBox.height,
+    scrollLog,
+    insertTextAtCursor,
+    normalizePaste,
+    resetPreferredCol,
+    getCursorPos: () => cursorPos,
+    setCursorPos: (value) => {
+      cursorPos = value;
+    },
+    ensureInputCursorVisible,
+    getWrapWidth,
+    getCursorRowCol,
+    countLines,
+    getCursorPosForRowCol,
+    getPreferredCol,
+    setPreferredCol,
+    historyUp,
+    historyDown,
+    enterDashboardMode,
+    resizeInput,
+    updateDraftFromInput,
+  });
 
-  function renderCompletionPanel() {
-    if (!completionActive || completionCommands.length === 0) return;
+  // Resize input box based on content
+  function resizeInput() {
+    const innerWidth = getWrapWidth();
+    if (innerWidth <= 0) return;
 
-    // blessed reserves 2 rows for border (iheight=2) even with only border.top
-    const panelVisible = Math.max(1, (completionPanel.height || 2) - 2);
-    const maxVisible = completionVisibleCount
-      ? Math.max(1, Math.min(completionVisibleCount, panelVisible))
-      : panelVisible;
+    const numLines = countLines(input.value, innerWidth);
+    const contentHeight = Math.min(MAX_INPUT_HEIGHT - 3, Math.max(1, numLines));
+    const targetHeight = contentHeight + 3; // +1 topLine +1 bottomLine +1 dashboard
 
-    // Adjust scroll offset to keep selected item visible
-    if (completionIndex < completionScrollOffset) {
-      completionScrollOffset = completionIndex;
-    } else if (completionIndex >= completionScrollOffset + maxVisible) {
-      completionScrollOffset = completionIndex - maxVisible + 1;
+    if (targetHeight !== currentInputHeight) {
+      currentInputHeight = targetHeight;
+      input.height = contentHeight;
+      promptBox.height = contentHeight;
+      inputTopLine.bottom = currentInputHeight - 1;  // Just above input area
     }
-
-    // Calculate visible slice
-    const visibleStart = completionScrollOffset;
-    const visibleEnd = Math.min(completionScrollOffset + maxVisible, completionCommands.length);
-    const visibleCommands = completionCommands.slice(visibleStart, visibleEnd);
-
-    const panelWidth = typeof completionPanel.width === "number"
-      ? completionPanel.width
-      : screen.width;
-    const lines = visibleCommands.map((item, i) => {
-      const actualIndex = visibleStart + i;
-      const cmdText = item.cmd;
-      const descText = item.desc || "";
-      const cmdPart = actualIndex === completionIndex
-        ? `{inverse}${cmdText}{/inverse}`
-        : `{cyan-fg}${cmdText}{/cyan-fg}`;
-      const indent = " ".repeat(promptBox.width || 2);
-      const maxDescWidth = Math.max(0, panelWidth - indent.length - cmdText.length - 2);
-      const trimmedDesc = truncateText(descText, maxDescWidth);
-      const descPart = trimmedDesc ? `{gray-fg}${trimmedDesc}{/gray-fg}` : "";
-      // Use promptBox width (2) to align with input position
-      return descPart
-        ? `${indent}${cmdPart}  ${descPart}`
-        : `${indent}${cmdPart}`;
-    });
-
-    completionPanel.setContent(lines.join("\n"));
-    screen.render();
-  }
-
-  function completionPageSize() {
-    const panelVisible = Math.max(1, (completionPanel.height || 2) - 2);
-    return completionVisibleCount
-      ? Math.max(1, Math.min(completionVisibleCount, panelVisible))
-      : panelVisible;
-  }
-
-  function completionUp() {
-    if (completionCommands.length === 0) return;
-    completionIndex = completionIndex <= 0
-      ? completionCommands.length - 1
-      : completionIndex - 1;
-    renderCompletionPanel();
+    statusLine.bottom = currentInputHeight;
+    // Reposition completion panel if active
+    if (completionController.isActive()) completionController.reflow();
+    // dashboard and inputBottomLine stay fixed at bottom 0 and 1
+    logBox.height = Math.max(1, screen.height - currentInputHeight - 1);
+    ensureInputCursorVisible();
   }
 
-  function completionDown() {
-    if (completionCommands.length === 0) return;
-    completionIndex = completionIndex >= completionCommands.length - 1
-      ? 0
-      : completionIndex + 1;
-    renderCompletionPanel();
-  }
+  // Override the internal listener to support cursor movement
+  input._listener = function(ch, key) {
+    inputListenerController.handleKey(ch, key, this);
+  };
 
-  function completionPageUp() {
-    if (completionCommands.length === 0) return;
-    const step = completionPageSize();
-    completionIndex = Math.max(0, completionIndex - step);
-    renderCompletionPanel();
-  }
+  // Override cursor update to use our cursor position
+  input._updateCursor = function() {
+    if (this.screen.focused !== this) return;
 
-  function completionPageDown() {
-    if (completionCommands.length === 0) return;
-    const step = completionPageSize();
-    completionIndex = Math.min(completionCommands.length - 1, completionIndex + step);
-    renderCompletionPanel();
-  }
+    let lpos;
+    try { lpos = this._getCoords(); } catch { return; }
+    if (!lpos) return;
 
-  function completionPreview(selected) {
-    const current = input.value || "";
-    const trimmed = current.trim();
-    const endsWithSpace = /\s$/.test(current);
-    if (selected.isSubcommand) {
-      const parts = trimmed.split(/\s+/);
-      const base = parts[0] || "";
-      const completedCore = base ? `${base} ${selected.cmd}` : selected.cmd;
-      const isComplete = trimmed === completedCore || trimmed.startsWith(`${completedCore} `);
-      return { text: `${completedCore} `, isComplete };
-    }
-    const completedCore = selected.cmd;
-    const hasChildren = selected.subcommands && selected.subcommands.length > 0;
-    const isComplete =
-      (trimmed === completedCore && (!hasChildren || endsWithSpace)) ||
-      trimmed.startsWith(`${completedCore} `);
-    return { text: `${completedCore} `, isComplete };
-  }
+    const innerWidth = getWrapWidth();
+    if (innerWidth <= 0) return;
 
-  function applyCompletionPreview(preview) {
-    input.value = preview.text;
-    cursorPos = input.value.length;
-    resetPreferredCol();
-    input._updateCursor();
-    updateDraftFromInput();
-    screen.render();
-  }
+    ensureInputCursorVisible();
+    const { row, col } = getCursorRowCol(this.value, cursorPos, innerWidth);
+    const scrollOffset = this.childBase || 0;
 
-  function truncateText(text, maxWidth) {
-    if (maxWidth <= 0) return "";
-    if (text.length <= maxWidth) return text;
-    if (maxWidth <= 3) return text.slice(0, maxWidth);
-    return `${text.slice(0, maxWidth - 3)}...`;
-  }
+    const displayRow = row - scrollOffset;
+    const safeCol = Math.min(Math.max(0, col), innerWidth - 1);
+    const cy = lpos.yi + displayRow;
+    const cx = lpos.xi + safeCol;
 
-  function confirmCompletion() {
-    if (!completionActive || completionCommands.length === 0) return;
-
-    const selected = completionCommands[completionIndex];
-
-    if (selected.isSubcommand) {
-      // Subcommand: replace the last word with selected subcommand
-      const parts = input.value.split(/\s+/);
-      parts[parts.length - 1] = selected.cmd;
-      input.value = parts.join(" ") + " ";
-    } else {
-      // Main command
-      input.value = selected.cmd + " ";
-    }
-
-    cursorPos = input.value.length;
-    resetPreferredCol();
-    input._updateCursor();
-    updateDraftFromInput();
-
-    // If selected command has subcommands, trigger subcommand completion immediately
-    if (!selected.isSubcommand && selected.subcommands && selected.subcommands.length > 0) {
-      // Don't hide - directly show subcommand completion
-      showCompletion(input.value);
-    } else {
-      // No subcommands - hide completion
-      hideCompletion();
-    }
-
-    screen.render();
-  }
-
-  function handleCompletionKey(ch, key) {
-    if (!completionActive) return false;
-
-    if (key.name === "up") {
-      completionUp();
-      return true;
-    }
-    if (key.name === "down") {
-      completionDown();
-      return true;
-    }
-    if (key.name === "tab") {
-      confirmCompletion();
-      return true;
-    }
-    if (key.name === "pageup") {
-      completionPageUp();
-      return true;
-    }
-    if (key.name === "pagedown") {
-      completionPageDown();
-      return true;
-    }
-    if (key.name === "enter" || key.name === "return") {
-      if (completionEnterSuppressed) {
-        return true;
-      }
-      const selected = completionCommands[completionIndex];
-      if (selected) {
-        const preview = completionPreview(selected);
-        if (!preview.isComplete) {
-          applyCompletionPreview(preview);
-          if (!selected.isSubcommand && selected.subcommands && selected.subcommands.length > 0) {
-            showCompletion(input.value);
-          } else {
-            hideCompletion();
-          }
-          completionEnterSuppressed = true;
-          if (completionEnterReset) clearImmediate(completionEnterReset);
-          completionEnterReset = setImmediate(() => {
-            completionEnterSuppressed = false;
-          });
-          return true;
-        }
-      }
-      // Already complete; allow normal submit
-      hideCompletion();
-      completionEnterSuppressed = true;
-      if (completionEnterReset) clearImmediate(completionEnterReset);
-      completionEnterReset = setImmediate(() => {
-        completionEnterSuppressed = false;
-      });
-      return false;
-    }
-    if (key.name === "escape") {
-      hideCompletion();
-      return true;
-    }
-    if (ch === " ") {
-      // Check if current input is a command that might have subcommands
-      const currentInput = input.value.trim();
-      if (currentInput.startsWith("/") && !currentInput.includes(" ")) {
-        // Let space be inserted, will trigger subcommand completion
-        return false;
-      }
-      hideCompletion();
-      return false;
-    }
-    // Regular character and backspace - don't intercept, let it be handled normally
-    // Completion will be updated in the main input handler
-    return false;
-  }
-
-  // Resize input box based on content
-  function resizeInput() {
-    const innerWidth = getWrapWidth();
-    if (innerWidth <= 0) return;
-
-    const numLines = countLines(input.value, innerWidth);
-    const contentHeight = Math.min(MAX_INPUT_HEIGHT - 3, Math.max(1, numLines));
-    const targetHeight = contentHeight + 3; // +1 topLine +1 bottomLine +1 dashboard
-
-    if (targetHeight !== currentInputHeight) {
-      currentInputHeight = targetHeight;
-      input.height = contentHeight;
-      promptBox.height = contentHeight;
-      inputTopLine.bottom = currentInputHeight - 1;  // Just above input area
-    }
-    statusLine.bottom = currentInputHeight;
-    // Reposition completion panel if active
-    if (completionActive) {
-      completionPanel.bottom = currentInputHeight - 1;
-      // Re-clamp visible count for new available space
-      const availableHeight = screen.height - currentInputHeight - 1;
-      const maxVisible = Math.min(7, completionCommands.length);
-      completionVisibleCount = Math.min(maxVisible, Math.max(1, availableHeight - 2));
-      completionPanel.height = completionVisibleCount + 2;
-      renderCompletionPanel();
-    }
-    // dashboard and inputBottomLine stay fixed at bottom 0 and 1
-    logBox.height = Math.max(1, screen.height - currentInputHeight - 1);
-    ensureInputCursorVisible();
-  }
-
-  // Override the internal listener to support cursor movement
-  input._listener = function(ch, key) {
-    if (currentView === "agent") return; // Agent view handles keys at screen level
-    if (key && key.ctrl && key.name === "c") {
-      exitHandler();
-      return;
-    }
-    if (suppressKeypress) {
-      return;
-    }
-    normalizeCommandPrefix();
-    if (focusMode === "dashboard") {
-      if (handleDashboardKey(key)) return;
-      // On agents view, printable char auto-exits dashboard keeping @target
-      if (dashboardView === "agents" && ch && ch.length === 1 && !key.ctrl && !key.meta
-          && !/^[\x00-\x1f\x7f]$/.test(ch)) {
-        exitDashboardMode(true);
-        // Fall through to normal input handling so the char is inserted
-      } else {
-        return;
-      }
-    }
-
-    // Command completion mode
-    if (completionActive) {
-      if (handleCompletionKey(ch, key)) return;
-    }
-    if (key && (key.name === "pageup" || key.name === "pagedown")) {
-      const delta = Math.max(1, Math.floor(logBox.height / 2));
-      scrollLog(key.name === "pageup" ? -delta : delta);
-      return;
-    }
-
-    // Treat multi-char input (paste) as insertion, including newlines.
-    if (ch && ch.length > 1 && (!key || !key.name || key.name.length !== 1)) {
-      insertTextAtCursor(normalizePaste(ch));
-      return;
-    }
-    if (ch && (ch.includes("\n") || ch.includes("\r")) && (!key || (key.name !== "return" && key.name !== "enter"))) {
-      insertTextAtCursor(normalizePaste(ch));
-      return;
-    }
-    // Plain enter submits, shift+enter inserts newline
-    if (key.name === "return" || key.name === "enter") {
-      if (key.shift) {
-        // Insert newline at cursor
-        insertTextAtCursor("\n");
-      } else {
-        // Submit
-        resetPreferredCol();
-        this._done(null, this.value);
-      }
-      return;
-    }
-
-    if (key.name === "left") {
-      if (cursorPos > 0) cursorPos--;
-      resetPreferredCol();
-      ensureInputCursorVisible();
-      this._updateCursor();
-      this.screen.render();
-      return;
-    }
-
-    if (key.name === "right") {
-      if (cursorPos < this.value.length) cursorPos++;
-      resetPreferredCol();
-      ensureInputCursorVisible();
-      this._updateCursor();
-      this.screen.render();
-      return;
-    }
-
-    if (key.name === "home") {
-      cursorPos = 0;
-      resetPreferredCol();
-      ensureInputCursorVisible();
-      this._updateCursor();
-      this.screen.render();
-      return;
-    }
-
-    if (key.name === "end") {
-      cursorPos = this.value.length;
-      resetPreferredCol();
-      ensureInputCursorVisible();
-      this._updateCursor();
-      this.screen.render();
-      return;
-    }
-
-    if (key.name === "up") {
-      // Special case: "/" + Up → jump to last command in completion
-      if (completionActive && input.value === "/" && cursorPos === 1) {
-        completionIndex = completionCommands.length - 1;
-        renderCompletionPanel();
-        return;
-      }
-      if (historyUp()) {
-        hideCompletion();
-        return;
-      }
-    }
-    if (key.name === "down") {
-      if (historyDown()) {
-        hideCompletion();
-        return;
-      }
-    }
-    if (key.name === "up" || key.name === "down") {
-      const innerWidth = getWrapWidth();
-      if (innerWidth > 0) {
-        const { row, col } = getCursorRowCol(this.value, cursorPos, innerWidth);
-        if (preferredCol === null) preferredCol = col;
-        const totalRows = countLines(this.value, innerWidth);
-
-        // Down at last row -> enter dashboard mode
-        if (key.name === "down" && row >= totalRows - 1) {
-          enterDashboardMode();
-          return;
-        }
-
-        const targetRow = key.name === "up"
-          ? Math.max(0, row - 1)
-          : Math.min(totalRows - 1, row + 1);
-        cursorPos = getCursorPosForRowCol(this.value, targetRow, preferredCol, innerWidth);
-      }
-      ensureInputCursorVisible();
-      this._updateCursor();
-      this.screen.render();
-      return;
-    }
-
-    if (key.name === "escape") {
-      this._done(null, null);
-      return;
-    }
-
-    if (key.name === "backspace") {
-      if (cursorPos > 0) {
-        this.value = this.value.slice(0, cursorPos - 1) + this.value.slice(cursorPos);
-        cursorPos--;
-        resetPreferredCol();
-        resizeInput();
-        ensureInputCursorVisible();
-        this._updateCursor();
-        updateDraftFromInput();
-
-        // Update or hide completion after backspace
-        if (this.value.startsWith("/")) {
-          showCompletion(this.value);
-        } else {
-          hideCompletion();
-        }
-
-        this.screen.render();
-      }
-      return;
-    }
-
-    if (key.name === "delete") {
-      if (cursorPos < this.value.length) {
-        this.value = this.value.slice(0, cursorPos) + this.value.slice(cursorPos + 1);
-        resetPreferredCol();
-        resizeInput();
-        ensureInputCursorVisible();
-        this._updateCursor();
-        this.screen.render();
-        updateDraftFromInput();
-      }
-      return;
-    }
-
-    // Insert character at cursor position
-    const insertChar = (ch && ch.length === 1)
-      ? ch
-      : (key && key.name && key.name.length === 1 ? key.name : null);
-    if (insertChar && !/^[\x00-\x08\x0b-\x0c\x0e-\x1f\x7f]$/.test(insertChar)) {
-      this.value = this.value.slice(0, cursorPos) + insertChar + this.value.slice(cursorPos);
-      cursorPos++;
-      normalizeCommandPrefix();
-      resetPreferredCol();
-      resizeInput();
-      this._updateCursor();
-      updateDraftFromInput();
-
-      // Update completion filter if typing after "/"
-      if (this.value.startsWith("/")) {
-        showCompletion(this.value);
-      } else if (completionActive) {
-        hideCompletion();
-      }
-
-      this.screen.render();
-      return;
-    }
-  };
-
-  // Override cursor update to use our cursor position
-  input._updateCursor = function() {
-    if (this.screen.focused !== this) return;
-
-    let lpos;
-    try { lpos = this._getCoords(); } catch { return; }
-    if (!lpos) return;
-
-    const innerWidth = getWrapWidth();
-    if (innerWidth <= 0) return;
-
-    ensureInputCursorVisible();
-    const { row, col } = getCursorRowCol(this.value, cursorPos, innerWidth);
-    const scrollOffset = this.childBase || 0;
-
-    const displayRow = row - scrollOffset;
-    const safeCol = Math.min(Math.max(0, col), innerWidth - 1);
-    const cy = lpos.yi + displayRow;
-    const cx = lpos.xi + safeCol;
-
-    this.screen.program.cup(cy, cx);
-    this.screen.program.showCursor();
-  };
+    this.screen.program.cup(cy, cx);
+    this.screen.program.showCursor();
+  };
 
   // Reset cursor and height on clear
   const originalClearValue = input.clearValue.bind(input);
@@ -1501,9 +455,8 @@ async function runChat(projectRoot) {
     cursorPos = 0;
     resetPreferredCol();
     currentInputHeight = MIN_INPUT_HEIGHT;
-    historyIndex = inputHistory.length;
-    historyDraft = "";
-    hideCompletion();
+    if (inputHistoryController) inputHistoryController.setIndexToEnd();
+    completionController.hide();
     const contentHeight = 1; // MIN content height
     input.height = contentHeight;
     promptBox.height = contentHeight;
@@ -1515,1725 +468,841 @@ async function runChat(projectRoot) {
 
   let pending = null;
 
-  // Command completion state
-  let completionActive = false;
-  let completionCommands = [];
-  let completionIndex = 0;
-  let completionScrollOffset = 0;
-  let completionVisibleCount = 0;
-  let completionEnterSuppressed = false;
-  let completionEnterReset = null;
-
-  const COMMAND_TREE = {
-    "/bus": {
-      desc: "Event bus operations",
-      children: {
-        activate: { desc: "Activate agent terminal" },
-        list: { desc: "List all agents" },
-        rename: { desc: "Rename agent nickname" },
-        send: { desc: "Send message to agent" },
-        status: { desc: "Bus status" },
-      },
-    },
-    "/ctx": {
-      desc: "Context management",
-      children: {
-        decisions: { desc: "List all decisions" },
-        doctor: { desc: "Check context integrity" },
-        status: { desc: "Show context status (default)" },
-      },
-    },
-    "/daemon": {
-      desc: "Daemon management",
-      children: {
-        restart: { desc: "Restart daemon" },
-        start: { desc: "Start daemon" },
-        status: { desc: "Daemon status" },
-        stop: { desc: "Stop daemon" },
-      },
-    },
-    "/doctor": { desc: "Health check diagnostics" },
-    "/init": { desc: "Initialize modules" },
-    "/launch": {
-      desc: "Launch new agent",
-      children: {
-        claude: { desc: "Launch Claude agent" },
-        codex: { desc: "Launch Codex agent" },
-      },
-    },
-    "/resume": { desc: "Resume agents (optional nickname)" },
-    "/skills": {
-      desc: "Skills management",
-      children: {
-        install: { desc: "Install skills (use: all or name)" },
-        list: { desc: "List available skills" },
-      },
-    },
-    "/status": { desc: "Status display" },
-  };
-
-  function buildCommandRegistry(tree) {
-    return Object.keys(tree)
-      .sort((a, b) => a.localeCompare(b, "en", { sensitivity: "base" }))
-      .map((cmd) => {
-        const node = tree[cmd] || {};
-        const entry = { cmd, desc: node.desc || "" };
-        if (node.children) {
-          entry.subcommands = Object.keys(node.children)
-            .sort((a, b) => a.localeCompare(b, "en", { sensitivity: "base" }))
-            .map((sub) => ({
-              cmd: sub,
-              desc: (node.children[sub] && node.children[sub].desc) || "",
-            }));
-        }
-        return entry;
-      });
-  }
-
-  const COMMAND_REGISTRY = buildCommandRegistry(COMMAND_TREE);
-
   // Agent selection state
   let activeAgents = [];
   let activeAgentLabelMap = new Map();
   let activeAgentMetaMap = new Map(); // Store full meta including launch_mode
   let agentListWindowStart = 0;
-  const MAX_AGENT_WINDOW = 5;
+  const MAX_AGENT_WINDOW = 4;
   let selectedAgentIndex = -1;  // -1 = not in dashboard selection mode
   let targetAgent = null;       // Selected agent for direct messaging
   let focusMode = "input";      // "input" or "dashboard"
-  let dashboardView = "agents"; // "agents" | "mode" | "provider" | "resume"
-  const launchModes = ["auto", "terminal", "tmux", "internal"];
-  function modeToIndex(m) { const i = launchModes.indexOf(m); return i >= 0 ? i : 0; }
-  let selectedModeIndex = modeToIndex(launchMode);
+  let dashboardView = "agents"; // "agents" | "mode" | "provider" | "assistant" | "cron"
+  let reportPendingTotal = 0;
+  let selectedModeIndex = launchMode === "internal" ? 2 : (launchMode === "tmux" ? 1 : 0);
   const providerOptions = [
     { label: "codex", value: "codex-cli" },
     { label: "claude", value: "claude-cli" },
+    { label: "ucode", value: "ucode" },
+  ];
+  let selectedProviderIndex = Math.max(0, providerOptions.findIndex((opt) => opt.value === agentProvider));
+  const assistantOptions = [
+    { label: "auto", value: "auto" },
+    { label: "codex", value: "codex" },
+    { label: "claude", value: "claude" },
+    { label: "ucode", value: "ufoo" },
   ];
-  let selectedProviderIndex = agentProvider === "claude-cli" ? 1 : 0;
+  let selectedAssistantIndex = Math.max(
+    0,
+    assistantOptions.findIndex((opt) => opt.value === assistantEngine)
+  );
   const resumeOptions = [
-    { label: "Auto", value: true },
-    { label: "Off", value: false },
+    { label: "Resume previous session", value: true },
+    { label: "Start new session", value: false },
   ];
   let selectedResumeIndex = autoResume ? 0 : 1;
-  let restartInProgress = false;
+  const DASH_HINTS = {
+    agents: "←/→ select · Enter · ↓ mode · ↑ back",
+    agentsEmpty: "↓ mode · ↑ back",
+    mode: "←/→ select · Enter · ↓ provider · ↑ back",
+    provider: "←/→ select · Enter · ↓ assistant · ↑ back",
+    assistant: "←/→ select · Enter · ↓ cron · ↑ back",
+    cron: "Ctrl+X close · ↑ back",
+    resume: "",
+  };
+  const AGENT_BAR_HINTS = {
+    normal: "↓ agents",
+    dashboard: "←/→ · Enter · ↑ · ^X",
+  };
 
-  function getAgentLabel(agentId) {
-    return activeAgentLabelMap.get(agentId) || agentId;
+  function getCurrentView() {
+    return agentViewController ? agentViewController.getCurrentView() : "main";
   }
 
-  function clampAgentWindow() {
-    if (activeAgents.length === 0) {
-      agentListWindowStart = 0;
-      return;
-    }
-    const maxItems = Math.max(1, Math.min(MAX_AGENT_WINDOW, activeAgents.length));
-    if (selectedAgentIndex >= 0) {
-      if (selectedAgentIndex < agentListWindowStart) {
-        agentListWindowStart = selectedAgentIndex;
-      } else if (selectedAgentIndex >= agentListWindowStart + maxItems) {
-        agentListWindowStart = selectedAgentIndex - maxItems + 1;
-      }
-    }
-    const maxStart = Math.max(0, activeAgents.length - maxItems);
-    if (agentListWindowStart > maxStart) agentListWindowStart = maxStart;
-    if (agentListWindowStart < 0) agentListWindowStart = 0;
+  function getViewingAgent() {
+    return agentViewController ? agentViewController.getViewingAgent() : "";
   }
 
-  function send(req) {
-    if (!client || client.destroyed) {
-      enqueueRequest(req);
-      void ensureConnected();
-      return;
-    }
-    client.write(`${JSON.stringify(req)}\n`);
+  function getAgentAdapter(agentId) {
+    if (!terminalAdapterRouter) return null;
+    const meta = activeAgentMetaMap ? activeAgentMetaMap.get(agentId) : null;
+    const agentLaunchMode = (meta && meta.launch_mode) || launchMode || "";
+    return terminalAdapterRouter.getAdapter({ launchMode: agentLaunchMode, agentId });
   }
 
-  function updatePromptBox() {
-    if (targetAgent) {
-      const label = getAgentLabel(targetAgent);
-      promptBox.setContent(`@${label}>`);
-      promptBox.width = label.length + 3;  // @name>
-      input.left = promptBox.width;
-      input.width = `100%-${promptBox.width}`;
-    } else {
-      promptBox.setContent(">");
-      promptBox.width = 2;
-      input.left = 2;
-      input.width = "100%-2";
-    }
-    resizeInput();
-    input._updateCursor();
+  function getViewingAgentAdapter() {
+    const viewingAgent = getViewingAgent();
+    if (!viewingAgent) return null;
+    return getAgentAdapter(viewingAgent);
   }
 
-  function focusInput() {
-    input.focus();
-    input._updateCursor();
+  function canSendRaw(adapter) {
+    if (!adapter || !adapter.capabilities) return false;
+    return Boolean(
+      adapter.capabilities.supportsSocketProtocol
+      || adapter.capabilities.supportsInternalQueueLoop
+    );
   }
 
-  function focusLog() {
-    logBox.focus();
-    screen.program.hideCursor();
+  function canResize(adapter) {
+    return Boolean(adapter && adapter.capabilities && adapter.capabilities.supportsSocketProtocol);
   }
 
-  function scrollLog(offset) {
-    logBox.scroll(offset);
-    screen.render();
+  function canSnapshot(adapter) {
+    if (!adapter || !adapter.capabilities) return false;
+    return Boolean(
+      adapter.capabilities.supportsSnapshot
+      || adapter.capabilities.supportsSubscribeScreen
+      || adapter.capabilities.supportsSubscribeFull
+    );
   }
 
-  function setLaunchMode(mode) {
-    const next = normalizeLaunchMode(mode);
-    if (next === launchMode) return;
-    // Check tmux availability before switching
-    if (next === "tmux" && !process.env.TMUX) {
-      logMessage("error", "{red-fg}✗{/red-fg} tmux mode requires running inside a tmux session");
-      return;
+  function sendRawWithCapabilities(data) {
+    const adapter = getViewingAgentAdapter();
+    if (!canSendRaw(adapter)) return;
+    try {
+      adapter.sendRaw(data);
+    } catch {
+      // ignore unsupported errors
     }
-    launchMode = next;
-    selectedModeIndex = modeToIndex(launchMode);
-    saveConfig(projectRoot, { launchMode });
-    logMessage("status", `{magenta-fg}⚙{/magenta-fg} Launch mode: ${launchMode}`);
-    renderDashboard();
-    screen.render();
-    void restartDaemon();
-  }
-
-
-  function providerLabel(value) {
-    return value === "claude-cli" ? "claude" : "codex";
   }
 
-  function clearUfooAgentIdentity() {
-    const agentDir = getUfooPaths(projectRoot).agentDir;
-    const stateFile = path.join(agentDir, "ufoo-agent.json");
-    const historyFile = path.join(agentDir, "ufoo-agent.history.jsonl");
+  function sendResizeWithCapabilities(cols, rows) {
+    const adapter = getViewingAgentAdapter();
+    if (!canResize(adapter)) return;
     try {
-      fs.rmSync(stateFile, { force: true });
+      adapter.resize(cols, rows);
     } catch {
-      // ignore
+      // ignore unsupported errors
     }
+  }
+
+  function requestSnapshotWithCapabilities() {
+    const adapter = getViewingAgentAdapter();
+    if (!canSnapshot(adapter)) return false;
     try {
-      fs.rmSync(historyFile, { force: true });
+      return adapter.snapshot();
     } catch {
-      // ignore
+      return false;
     }
   }
 
-  function setAgentProvider(provider) {
-    const next = normalizeAgentProvider(provider);
-    if (next === agentProvider) return;
-    agentProvider = next;
-    selectedProviderIndex = agentProvider === "claude-cli" ? 1 : 0;
-    saveConfig(projectRoot, { agentProvider });
-    clearUfooAgentIdentity();
-    logMessage("status", `{magenta-fg}⚙{/magenta-fg} ufoo-agent: ${providerLabel(agentProvider)}`);
-    renderDashboard();
-    screen.render();
-    void restartDaemon();
+  function isAgentViewUsesBus() {
+    return agentViewController ? agentViewController.isAgentViewUsesBus() : false;
   }
 
-  function setAutoResume(value) {
-    const next = value !== false;
-    if (next === autoResume) return;
-    autoResume = next;
-    selectedResumeIndex = autoResume ? 0 : 1;
-    saveConfig(projectRoot, { autoResume });
-    const label = autoResume ? "Auto" : "Off";
-    logMessage("status", `{magenta-fg}⚙{/magenta-fg} Resume: ${label}`);
-    renderDashboard();
-    screen.render();
+  function getAgentInputSuppressUntil() {
+    return agentViewController ? agentViewController.getAgentInputSuppressUntil() : 0;
   }
 
-  async function restartDaemon() {
-    if (restartInProgress) return;
-    restartInProgress = true;
-    logMessage("status", "{magenta-fg}⚙{/magenta-fg} Restarting daemon...");
-    try {
-      if (client) {
-        client.removeAllListeners();
-        try {
-          client.end();
-        } catch {
-          // ignore
-        }
-      }
-      stopDaemon(projectRoot);
-      startDaemon(projectRoot, { forceResume: true });
-      const newClient = await connectClient();
-      if (newClient) {
-        attachClient(newClient);
-        logMessage("status", "{green-fg}✓{/green-fg} Daemon reconnected");
-      } else {
-        logMessage("error", "{red-fg}✗{/red-fg} Failed to reconnect to daemon");
-      }
-    } finally {
-      restartInProgress = false;
+  function getAgentOutputSuppressed() {
+    return agentViewController ? agentViewController.getAgentOutputSuppressed() : false;
+  }
+
+  function setAgentOutputSuppressed(value) {
+    if (agentViewController) {
+      agentViewController.setAgentOutputSuppressed(value);
     }
   }
 
-  function clearLog() {
-    logBox.setContent("");
-    if (typeof logBox.scrollTo === "function") {
-      logBox.scrollTo(0);
+  function renderAgentDashboard() {
+    if (agentViewController) {
+      agentViewController.renderAgentDashboard();
     }
-    screen.render();
   }
 
-  function renderDashboard() {
-    let content = " ";
-    if (focusMode === "dashboard") {
-      if (dashboardView === "mode") {
-        const modeParts = launchModes.map((mode, i) => {
-          if (i === selectedModeIndex) {
-            return `{inverse}${mode}{/inverse}`;
-          }
-          if (mode === launchMode) {
-            return `{bold}{cyan-fg}${mode}{/cyan-fg}{/bold}`;
-          }
-          return `{cyan-fg}${mode}{/cyan-fg}`;
-        });
-        content += `{gray-fg}Mode:{/gray-fg} ${modeParts.join("  ")}`;
-        content += "  {gray-fg}│ ←/→ select, Enter confirm, ↓ agent, ↑ back{/gray-fg}";
-      } else if (dashboardView === "provider") {
-        const providerParts = providerOptions.map((opt, i) => {
-          if (i === selectedProviderIndex) {
-            return `{inverse}${opt.label}{/inverse}`;
-          }
-          if (opt.value === agentProvider) {
-            return `{bold}{cyan-fg}${opt.label}{/cyan-fg}{/bold}`;
-          }
-          return `{cyan-fg}${opt.label}{/cyan-fg}`;
-        });
-        content += `{gray-fg}Agent:{/gray-fg} ${providerParts.join("  ")}`;
-        content += "  {gray-fg}│ ←/→ select, Enter confirm, ↓ resume, ↑ back{/gray-fg}";
-      } else if (dashboardView === "resume") {
-        const resumeParts = resumeOptions.map((opt, i) => {
-          if (i === selectedResumeIndex) {
-            return `{inverse}${opt.label}{/inverse}`;
-          }
-          if (opt.value === autoResume) {
-            return `{bold}{cyan-fg}${opt.label}{/cyan-fg}{/bold}`;
-          }
-          return `{cyan-fg}${opt.label}{/cyan-fg}`;
-        });
-        content += `{gray-fg}Resume:{/gray-fg} ${resumeParts.join("  ")}`;
-        content += "  {gray-fg}│ ←/→ select, Enter confirm, ↑ back{/gray-fg}";
-      } else {
-        if (activeAgents.length > 0) {
-          clampAgentWindow();
-          const maxItems = Math.max(1, Math.min(MAX_AGENT_WINDOW, activeAgents.length));
-          const start = agentListWindowStart;
-          const end = start + maxItems;
-          const visibleAgents = activeAgents.slice(start, end);
-          const agentParts = visibleAgents.map((agent, i) => {
-            const absoluteIndex = start + i;
-            const label = getAgentLabel(agent);
-            if (absoluteIndex === selectedAgentIndex) {
-              return `{inverse}${label}{/inverse}`;
-            }
-            return `{cyan-fg}${label}{/cyan-fg}`;
-          });
-          const leftMore = start > 0 ? "{gray-fg}«{/gray-fg} " : "";
-          const rightMore = end < activeAgents.length ? " {gray-fg}»{/gray-fg}" : "";
-          content += `{gray-fg}Agents:{/gray-fg} ${agentParts.join("  ")}`;
-          content = `${content.replace("{gray-fg}Agents:{/gray-fg} ", `{gray-fg}Agents:{/gray-fg} ${leftMore}`)}${rightMore}`;
-          content += "  {gray-fg}│ ←/→ select, Enter confirm, ^X close, ↓ mode, ↑ back{/gray-fg}";
-        } else {
-          content += "{gray-fg}Agents:{/gray-fg} {cyan-fg}none{/cyan-fg}";
-          content += "  {gray-fg}│ ↓ mode, ↑ back{/gray-fg}";
-        }
-      }
-    } else {
-      // Normal dashboard display (input mode)
-      const agents = activeAgents.length > 0
-        ? activeAgents.slice(0, 3).map((id) => {
-            const label = getAgentLabel(id);
-            return label;
-          }).join(", ") + (activeAgents.length > 3 ? ` +${activeAgents.length - 3}` : "")
-        : "none";
-      content += `{gray-fg}Agents:{/gray-fg} {cyan-fg}${agents}{/cyan-fg}`;
-      content += `  {gray-fg}Mode:{/gray-fg} {cyan-fg}${launchMode}{/cyan-fg}`;
-      content += `  {gray-fg}Agent:{/gray-fg} {cyan-fg}${providerLabel(agentProvider)}{/cyan-fg}`;
-      content += `  {gray-fg}Resume:{/gray-fg} {cyan-fg}${autoResume ? "auto" : "off"}{/cyan-fg}`;
+  function setAgentBarVisible(visible) {
+    if (agentViewController) {
+      agentViewController.setAgentBarVisible(visible);
     }
-    dashboard.setContent(content);
   }
 
-  function updateDashboard(status) {
-    activeAgents = status.active || [];
-    const metaList = Array.isArray(status.active_meta) ? status.active_meta : [];
-    activeAgentLabelMap = new Map();
-    activeAgentMetaMap = new Map();
-    let fallbackMap = null;
-    if (metaList.length === 0 && activeAgents.length > 0) {
-      try {
-        const busPath = getUfooPaths(projectRoot).agentsFile;
-        const bus = JSON.parse(fs.readFileSync(busPath, "utf8"));
-        fallbackMap = new Map();
-        for (const [id, meta] of Object.entries(bus.agents || {})) {
-          if (meta && meta.nickname) fallbackMap.set(id, meta.nickname);
-        }
-      } catch {
-        fallbackMap = null;
-      }
+  function enterAgentView(agentId, options = {}) {
+    if (agentViewController) {
+      agentViewController.enterAgentView(agentId, options);
     }
-    for (const id of activeAgents) {
-      const meta = metaList.find((item) => item && item.id === id);
-      const label = meta && meta.nickname
-        ? meta.nickname
-        : (fallbackMap && fallbackMap.get(id)) || id;
-      activeAgentLabelMap.set(id, label);
-      if (meta) {
-        activeAgentMetaMap.set(id, meta);
-      }
-    }
-    clampAgentWindow();
-
-    // Check if viewed agent went offline
-    if (currentView === "agent" && viewingAgent && !activeAgents.includes(viewingAgent)) {
-      writeToAgentTerm("\r\n\x1b[1;31m[Agent went offline]\x1b[0m\r\n");
-      exitAgentView();
-      return;
-    }
-
-    // In agent view, only update the dashboard bar (via ANSI, blessed is frozen)
-    if (currentView === "agent") {
-      if (focusMode === "dashboard") {
-        const totalItems = 1 + activeAgents.length;
-        if (selectedAgentIndex < 0 || selectedAgentIndex >= totalItems) {
-          selectedAgentIndex = 0;
-        }
-      }
-      renderAgentDashboard();
-      return;
-    }
-
-    if (focusMode === "dashboard") {
-      if (dashboardView === "agents") {
-        if (activeAgents.length === 0) {
-          selectedAgentIndex = -1;
-        } else if (selectedAgentIndex < 0 || selectedAgentIndex >= activeAgents.length) {
-          selectedAgentIndex = 0;
-        }
-        clampAgentWindow();
-      }
-    }
-    renderDashboard();
-    screen.render();
   }
 
-  function enterDashboardMode() {
-    focusMode = "dashboard";
-    dashboardView = "agents";
-    selectedAgentIndex = activeAgents.length > 0 ? 0 : -1;
-    agentListWindowStart = 0;
-    clampAgentWindow();
-    selectedModeIndex = modeToIndex(launchMode);
-    selectedProviderIndex = agentProvider === "claude-cli" ? 1 : 0;
-    selectedResumeIndex = autoResume ? 0 : 1;
-    // Immediately set @target when first agent is selected
-    if (selectedAgentIndex >= 0 && selectedAgentIndex < activeAgents.length) {
-      targetAgent = activeAgents[selectedAgentIndex];
-      updatePromptBox();
+  function exitAgentView() {
+    if (agentViewController) {
+      agentViewController.exitAgentView();
     }
-    screen.grabKeys = true;
-    renderDashboard();
-    screen.program.hideCursor();
-    screen.render();
   }
 
-  function handleDashboardKey(key) {
-    if (!key || focusMode !== "dashboard") return false;
-
-    // Agent TTY view dashboard navigation
-    // Items: [ufoo(0), agent1(1), agent2(2), ...]
-    if (currentView === "agent") {
-      const totalItems = 1 + activeAgents.length; // ufoo + agents
-      if (key.name === "left") {
-        if (selectedAgentIndex > 0) {
-          selectedAgentIndex--;
-        }
-        renderAgentDashboard();
-        return true;
-      }
-      if (key.name === "right") {
-        if (selectedAgentIndex < totalItems - 1) {
-          selectedAgentIndex++;
-        }
-        renderAgentDashboard();
-        return true;
-      }
-      if (key.name === "enter" || key.name === "return") {
-        if (selectedAgentIndex === 0) {
-          // "ufoo" selected -> exit agent view back to main chat
-          exitAgentView();
-        } else {
-          // Another agent selected -> switch based on launch mode
-          const agentId = activeAgents[selectedAgentIndex - 1];
-          if (agentId && agentId !== viewingAgent) {
-            const meta = activeAgentMetaMap.get(agentId);
-            const agentLaunchMode = meta?.launch_mode || "";
-
-            if (agentLaunchMode === "tmux" || agentLaunchMode === "terminal") {
-              // Exit PTY view, then activate agent's terminal/pane
-              exitAgentView();
-              try {
-                const activator = new AgentActivator(projectRoot);
-                activator.activate(agentId).catch(() => {});
-              } catch { /* ignore */ }
-            } else {
-              // Internal mode: switch PTY view
-              focusMode = "input";
-              enterAgentView(agentId);
-            }
-          } else {
-            // Same agent, just exit dashboard
-            focusMode = "input";
-            renderAgentDashboard();
-          }
-        }
-        return true;
-      }
-      if (key.name === "up") {
-        // Up exits dashboard back to agent PTY view
-        focusMode = "input";
-        renderAgentDashboard();
-        return true;
-      }
-      if (key.name === "x" && key.ctrl) {
-        // Ctrl+x: close selected agent (not ufoo)
-        if (selectedAgentIndex > 0 && selectedAgentIndex <= activeAgents.length) {
-          const agentId = activeAgents[selectedAgentIndex - 1];
-          const label = getAgentLabel(agentId);
-          // If closing the currently viewed agent, exit view first
-          if (agentId === viewingAgent) {
-            exitAgentView();
-          }
-          closeAgentViaDaemon(agentId, label);
-        }
-        return true;
-      }
-      return true;
-    }
-
-    if (dashboardView === "mode") {
-      const maxMode = launchModes.length - 1;
-      if (key.name === "left") {
-        selectedModeIndex = selectedModeIndex <= 0 ? maxMode : selectedModeIndex - 1;
-        renderDashboard();
-        screen.render();
-        return true;
-      }
-      if (key.name === "right") {
-        selectedModeIndex = selectedModeIndex >= maxMode ? 0 : selectedModeIndex + 1;
-        renderDashboard();
-        screen.render();
-        return true;
-      }
-      if (key.name === "down") {
-        dashboardView = "provider";
-        selectedProviderIndex = agentProvider === "claude-cli" ? 1 : 0;
-        renderDashboard();
-        screen.render();
-        return true;
-      }
-      if (key.name === "up") {
-        dashboardView = "agents";
-        // Restore @target when returning to agents page
-        if (selectedAgentIndex >= 0 && selectedAgentIndex < activeAgents.length) {
-          targetAgent = activeAgents[selectedAgentIndex];
-          updatePromptBox();
-        }
-        renderDashboard();
-        screen.render();
-        return true;
-      }
-      if (key.name === "enter" || key.name === "return") {
-        setLaunchMode(launchModes[selectedModeIndex]);
-        exitDashboardMode(false);
-        return true;
-      }
-      if (key.name === "escape") {
-        exitDashboardMode(false);
-        return true;
-      }
-      return true;
-    }
-    if (dashboardView === "provider") {
-      if (key.name === "left") {
-        selectedProviderIndex = selectedProviderIndex <= 0 ? providerOptions.length - 1 : selectedProviderIndex - 1;
-        renderDashboard();
-        screen.render();
-        return true;
-      }
-      if (key.name === "right") {
-        selectedProviderIndex = selectedProviderIndex >= providerOptions.length - 1 ? 0 : selectedProviderIndex + 1;
-        renderDashboard();
-        screen.render();
-        return true;
-      }
-      if (key.name === "down") {
-        dashboardView = "resume";
-        selectedResumeIndex = autoResume ? 0 : 1;
-        renderDashboard();
-        screen.render();
-        return true;
-      }
-      if (key.name === "up") {
-        dashboardView = "mode";
-        renderDashboard();
-        screen.render();
-        return true;
-      }
-      if (key.name === "enter" || key.name === "return") {
-        const selected = providerOptions[selectedProviderIndex];
-        if (selected) setAgentProvider(selected.value);
-        exitDashboardMode(false);
-        return true;
-      }
-      if (key.name === "escape") {
-        exitDashboardMode(false);
-        return true;
-      }
-      return true;
-    }
-    if (dashboardView === "resume") {
-      if (key.name === "left") {
-        selectedResumeIndex = selectedResumeIndex <= 0 ? resumeOptions.length - 1 : selectedResumeIndex - 1;
-        renderDashboard();
-        screen.render();
-        return true;
-      }
-      if (key.name === "right") {
-        selectedResumeIndex = selectedResumeIndex >= resumeOptions.length - 1 ? 0 : selectedResumeIndex + 1;
-        renderDashboard();
-        screen.render();
-        return true;
-      }
-      if (key.name === "up") {
-        dashboardView = "provider";
-        renderDashboard();
-        screen.render();
-        return true;
-      }
-      if (key.name === "enter" || key.name === "return") {
-        const selected = resumeOptions[selectedResumeIndex];
-        if (selected) {
-          setAutoResume(selected.value);
-          const label = selected.value ? "Auto" : "Off";
-          logMessage("status", `{magenta-fg}⚙{/magenta-fg} Resume: ${label}`);
-        }
-        exitDashboardMode(false);
-        return true;
-      }
-      if (key.name === "escape") {
-        exitDashboardMode(false);
-        return true;
-      }
-      return true;
-    }
-
-    if (key.name === "left") {
-      if (activeAgents.length > 0 && selectedAgentIndex > 0) {
-        selectedAgentIndex--;
-        clampAgentWindow();
-        // Update @target in real-time as user navigates
-        targetAgent = activeAgents[selectedAgentIndex];
-        updatePromptBox();
-        renderDashboard();
-        screen.render();
-      }
-      return true;
-    }
-    if (key.name === "right") {
-      if (activeAgents.length > 0 && selectedAgentIndex < activeAgents.length - 1) {
-        selectedAgentIndex++;
-        clampAgentWindow();
-        // Update @target in real-time as user navigates
-        targetAgent = activeAgents[selectedAgentIndex];
-        updatePromptBox();
-        renderDashboard();
-        screen.render();
-      }
-      return true;
-    }
-    if (key.name === "down") {
-      // Leaving agents page: clear temporary @target
-      clearTargetAgent();
-      dashboardView = "mode";
-      selectedModeIndex = modeToIndex(launchMode);
-      renderDashboard();
-      screen.render();
-      return true;
-    }
-    if (key.name === "up" || key.name === "escape") {
-      // Cancel: clear @target, back to normal chat
-      clearTargetAgent();
-      exitDashboardMode(false);
-      return true;
-    }
-    if (key.name === "x" && key.ctrl) {
-      // Ctrl+x: close selected agent
-      if (selectedAgentIndex >= 0 && selectedAgentIndex < activeAgents.length) {
-        const agentId = activeAgents[selectedAgentIndex];
-        const label = getAgentLabel(agentId);
-        closeAgentViaDaemon(agentId, label);
-        clearTargetAgent();
-        exitDashboardMode(false);
-      }
-      return true;
-    }
-    if (key.name === "enter" || key.name === "return") {
-      // Enter: action depends on agent's launch mode
-      if (selectedAgentIndex >= 0 && selectedAgentIndex < activeAgents.length) {
-        const agentId = activeAgents[selectedAgentIndex];
-        const meta = activeAgentMetaMap.get(agentId);
-        const agentLaunchMode = meta?.launch_mode || "";
-
-        if (agentLaunchMode === "tmux" || agentLaunchMode === "terminal") {
-          // Tmux: select pane; Terminal: activate tab/window by tty
-          clearTargetAgent();
-          exitDashboardMode(false);
-          try {
-            const activator = new AgentActivator(projectRoot);
-            activator.activate(agentId).catch(() => {});
-          } catch { /* ignore */ }
-          return true;
-        }
-
-        // Internal / internal-pty mode: enter PTY view if inject.sock exists
-        const sockPath = getInjectSockPath(agentId);
-        if (fs.existsSync(sockPath)) {
-          clearTargetAgent();
-          focusMode = "input";
-          dashboardView = "agents";
-          selectedAgentIndex = -1;
-          screen.grabKeys = false;
-          enterAgentView(agentId);
-          return true;
-        }
-      }
-      // Fallback: just exit dashboard, keep @target for messaging
-      exitDashboardMode(false);
-      return true;
+  function sendRawToAgent(data) {
+    if (agentViewController) {
+      agentViewController.sendRawToAgent(data);
     }
-    return false;
   }
 
-  function exitDashboardMode(selectAgent = false) {
-    if (selectAgent && selectedAgentIndex >= 0 && selectedAgentIndex < activeAgents.length) {
-      targetAgent = activeAgents[selectedAgentIndex];
-      updatePromptBox();
+  function sendResizeToAgent(cols, rows) {
+    if (agentViewController) {
+      agentViewController.sendResizeToAgent(cols, rows);
     }
-    focusMode = "input";
-    dashboardView = "agents";
-    selectedAgentIndex = -1;
-    screen.grabKeys = false;
-    renderDashboard();
-    focusInput();
-    screen.render();
   }
 
-  function clearTargetAgent() {
-    targetAgent = null;
-    updatePromptBox();
-    screen.render();
-  }
-
-  function getInjectSockPath(agentId) {
-    const safeName = subscriberToSafeName(agentId);
-    return path.join(getUfooPaths(projectRoot).busQueuesDir, safeName, "inject.sock");
-  }
-
-  function closeAgentViaDaemon(agentId, label) {
-    logMessage("system", `{yellow-fg}⚙{/yellow-fg} Closing ${label}...`);
-    const sockFile = socketPath(projectRoot);
-    try {
-      const conn = net.createConnection(sockFile, () => {
-        conn.write(JSON.stringify({ type: "close_agent", agentId }) + "\n");
-      });
-      let buffer = "";
-      conn.on("data", (data) => {
-        buffer += data.toString("utf8");
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          try {
-            const res = JSON.parse(line);
-            if (res.type === "close_agent_ok") {
-              if (res.ok) {
-                logMessage("system", `{green-fg}✓{/green-fg} Closed ${label}`);
-              } else {
-                logMessage("system", `{red-fg}✗{/red-fg} Agent ${label} not found or already stopped`);
-              }
-            }
-          } catch { /* ignore */ }
-        }
-      });
-      conn.on("error", () => {
-        logMessage("error", `{red-fg}✗{/red-fg} Failed to connect to daemon`);
-      });
-      setTimeout(() => { try { conn.destroy(); } catch {} }, 3000);
-    } catch {
-      logMessage("error", `{red-fg}✗{/red-fg} Failed to close ${label}`);
+  function requestAgentSnapshot() {
+    if (agentViewController) {
+      agentViewController.requestAgentSnapshot();
     }
   }
 
-  // Freeze blessed rendering during agent PTY view (direct stdout mode)
-  const _originalRender = screen.render.bind(screen);
-  let renderFrozen = false;
-  screen.render = function() {
-    if (renderFrozen) return;
-    return _originalRender();
-  };
-
-  // Render agent view dashboard bar via ANSI — matches blessed dashboard style
-  function renderAgentDashboard() {
-    const rows = process.stdout.rows || 24;
-    const cols = process.stdout.columns || 80;
-    let bar = " ";
-
-    if (focusMode === "dashboard") {
-      // Dashboard mode: \x1b[90;7m = gray+inverse, matches blessed {inverse} on gray fg widget
-      const ufooItem = selectedAgentIndex === 0
-        ? "\x1b[90;7mufoo\x1b[0m"
-        : "\x1b[36mufoo\x1b[0m";
-      const agentParts = activeAgents.map((agent, i) => {
-        const label = getAgentLabel(agent);
-        const idx = i + 1; // +1 for ufoo at index 0
-        if (idx === selectedAgentIndex) return `\x1b[90;7m${label}\x1b[0m`;
-        if (agent === viewingAgent) return `\x1b[1;36m${label}\x1b[0m`;
-        return `\x1b[36m${label}\x1b[0m`;
-      });
-      bar += `${ufooItem}  ${agentParts.join("  ")}`;
-      bar += `  \x1b[90m│ ←/→ select, Enter switch, ^X close, ↑ back\x1b[0m`;
-    } else {
-      // Normal PTY mode: bold current viewing agent
-      const agentParts = activeAgents.map((agent) => {
-        const label = getAgentLabel(agent);
-        if (agent === viewingAgent) return `\x1b[1;36m${label}\x1b[0m`;
-        return `\x1b[36m${label}\x1b[0m`;
-      });
-      bar += `\x1b[36mufoo\x1b[0m  ${agentParts.join("  ")}`;
-      bar += `  \x1b[90m│ ↓: agents\x1b[0m`;
+  function writeToAgentTerm(text) {
+    if (agentViewController) {
+      agentViewController.writeToAgentTerm(text);
     }
-
-    // Pad to full width
-    const plainLen = bar.replace(/\x1b\[[0-9;]*m/g, "").length;
-    const pad = Math.max(0, cols - plainLen);
-    // Save cursor → move to last row → write bar → restore cursor
-    process.stdout.write(`\x1b7\x1b[${rows};1H${bar}${" ".repeat(pad)}\x1b8`);
   }
 
-  function enterAgentView(agentId) {
-    if (currentView === "agent" && viewingAgent === agentId) return;
-    if (currentView === "agent") {
-      disconnectAgentOutput();
-      disconnectAgentInput();
+  function placeAgentCursor(cursor) {
+    if (agentViewController) {
+      agentViewController.placeAgentCursor(cursor);
     }
-
-    currentView = "agent";
-    viewingAgent = agentId;
-    focusMode = "input";
-
-    // Detach all blessed widgets from screen — nothing left to render
-    _detachedChildren = [...screen.children];
-    for (const child of _detachedChildren) screen.remove(child);
-
-    // Freeze blessed — we take over the terminal with direct stdout
-    renderFrozen = true;
-
-    const rows = process.stdout.rows || 24;
-    const cols = process.stdout.columns || 80;
-    process.stdout.write("\x1b[2J\x1b[H");                // Clear + home
-    process.stdout.write(`\x1b[1;${rows - 1}r`);          // Scroll region
-    process.stdout.write("\x1b[H");                         // Cursor to top
-    process.stdout.write("\x1b[?25h");                      // Show cursor
-
-    // Render dashboard bar
-    renderAgentDashboard();
-
-    // Suppress input forwarding briefly — prevents the Enter that triggered
-    // view switch and any terminal query responses (CPR etc) from leaking
-    agentInputSuppressUntil = Date.now() + 300;
-
-    // Connect to agent's inject.sock for output streaming and input
-    const sockPath = getInjectSockPath(agentId);
-    connectAgentOutput(sockPath);
-    connectAgentInput(sockPath);
-
-    // Resize agent PTY to match our viewport (rows-1 for status bar)
-    setTimeout(() => sendResizeToAgent(cols, rows - 1), 100);
   }
 
-  function exitAgentView() {
-    if (currentView !== "agent") return;
-
-    // Restore agent PTY to full terminal size before disconnecting
-    const rows = process.stdout.rows || 24;
-    const cols = process.stdout.columns || 80;
-    sendResizeToAgent(cols, rows);
-
-    disconnectAgentOutput();
-    disconnectAgentInput();
-
-    currentView = "main";
-    viewingAgent = null;
-
-    // Reset scroll region to full screen
-    process.stdout.write(`\x1b[1;${rows}r`);
-    process.stdout.write("\x1b[2J\x1b[H");
-
-    // Re-attach all blessed widgets to screen
-    if (_detachedChildren) {
-      for (const child of _detachedChildren) screen.append(child);
-      _detachedChildren = null;
-    }
-
-    // Unfreeze blessed and force full redraw
-    renderFrozen = false;
-    focusMode = "input";
-    dashboardView = "agents";
-    selectedAgentIndex = -1;
-    screen.grabKeys = false;
-    clearTargetAgent();
-    renderDashboard();
-    focusInput();
-    resizeInput();
-    screen.alloc();
-    screen.render();
+  function handleResizeInAgentView() {
+    if (!agentViewController) return false;
+    return agentViewController.handleResizeInAgentView();
   }
 
-  function connectAgentOutput(sockPath) {
-    if (agentOutputClient) {
-      disconnectAgentOutput();
-    }
-    agentOutputBuffer = "";
-
-    if (!fs.existsSync(sockPath)) {
-      writeToAgentTerm("\x1b[1;31m[Error]\x1b[0m inject.sock not found\r\n");
-      writeToAgentTerm("\x1b[33m[Hint]\x1b[0m Agent may not be running in terminal mode\r\n");
-      writeToAgentTerm("Press Esc to return\r\n");
-      return;
-    }
-
-    try {
-      agentOutputClient = net.createConnection(sockPath, () => {
-        agentOutputClient.write(JSON.stringify({ type: "subscribe" }) + "\n");
-      });
-
-      // Connection timeout
-      const connectTimeout = setTimeout(() => {
-        if (agentOutputClient && !agentOutputClient.connecting) return;
-        writeToAgentTerm("\x1b[1;31m[Timeout]\x1b[0m Could not connect\r\nPress Esc to return\r\n");
-        disconnectAgentOutput();
-      }, 5000);
-
-      agentOutputClient.on("connect", () => {
-        clearTimeout(connectTimeout);
-      });
+  function getAgentLabel(agentId) {
+    return agentDirectory.getAgentLabel(activeAgentLabelMap, agentId);
+  }
 
-      agentOutputClient.on("data", (data) => {
-        agentOutputBuffer += data.toString("utf8");
-        const lines = agentOutputBuffer.split("\n");
-        agentOutputBuffer = lines.pop() || "";
-
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          try {
-            const msg = JSON.parse(line);
-            if (msg.type === "output" || msg.type === "replay") {
-              if (msg.data) {
-                writeToAgentTerm(msg.data);
-              }
-            }
-          } catch {
-            // ignore malformed messages
+  function resolveAgentId(label) {
+    return agentDirectory.resolveAgentId({
+      label,
+      activeAgents,
+      labelMap: activeAgentLabelMap,
+      lookupNickname: (nickname) => {
+        try {
+          const busPath = getUfooPaths(projectRoot).agentsFile;
+          const bus = JSON.parse(fs.readFileSync(busPath, "utf8"));
+          for (const [id, meta] of Object.entries(bus.agents || {})) {
+            if (meta && meta.nickname === nickname) return id;
           }
+        } catch {
+          // ignore lookup errors
         }
-      });
-
-      agentOutputClient.on("error", (err) => {
-        if (currentView === "agent") {
-          writeToAgentTerm(`\r\n\x1b[1;31m[Connection error]\x1b[0m ${err.message}\r\nPress Esc to return\r\n`);
-        }
-      });
-
-      agentOutputClient.on("close", () => {
-        agentOutputClient = null;
-        if (currentView === "agent") {
-          writeToAgentTerm("\r\n\x1b[1;33m[Agent disconnected]\x1b[0m\r\nPress Esc to return\r\n");
-        }
-      });
-    } catch (err) {
-      writeToAgentTerm(`\x1b[1;31m[Error]\x1b[0m ${err.message}\r\nPress Esc to return\r\n`);
-    }
-  }
-
-  function disconnectAgentOutput() {
-    if (agentOutputClient) {
-      try {
-        agentOutputClient.removeAllListeners();
-        agentOutputClient.destroy();
-      } catch { /* ignore */ }
-      agentOutputClient = null;
-    }
-    agentOutputBuffer = "";
-  }
-
-  function connectAgentInput(sockPath) {
-    if (agentInputClient) {
-      disconnectAgentInput();
-    }
-    try {
-      agentInputClient = net.createConnection(sockPath);
-      agentInputClient.on("error", () => {
-        agentInputClient = null;
-      });
-      agentInputClient.on("close", () => {
-        agentInputClient = null;
-      });
-    } catch {
-      agentInputClient = null;
-    }
-  }
-
-  function disconnectAgentInput() {
-    if (agentInputClient) {
-      try {
-        agentInputClient.removeAllListeners();
-        agentInputClient.destroy();
-      } catch { /* ignore */ }
-      agentInputClient = null;
-    }
+        return null;
+      },
+    });
   }
 
-  function sendRawToAgent(data) {
-    if (!agentInputClient || agentInputClient.destroyed) return;
-    try {
-      agentInputClient.write(JSON.stringify({ type: "raw", data }) + "\n");
-    } catch {
-      // ignore write errors
-    }
+  function resolveAgentDisplayName(publisher) {
+    return agentDirectory.resolveAgentDisplayName({
+      publisher,
+      labelMap: activeAgentLabelMap,
+      lookupNicknameById: (id) => {
+        try {
+          const busPath = getUfooPaths(projectRoot).agentsFile;
+          const bus = JSON.parse(fs.readFileSync(busPath, "utf8"));
+          const meta = bus.agents && bus.agents[id];
+          if (meta && meta.nickname) return meta.nickname;
+        } catch {
+          // Keep original publisher ID
+        }
+        return null;
+      },
+    });
   }
 
-  function sendResizeToAgent(cols, rows) {
-    if (!agentInputClient || agentInputClient.destroyed) return;
-    try {
-      agentInputClient.write(JSON.stringify({ type: "resize", cols, rows }) + "\n");
-    } catch {
-      // ignore write errors
-    }
+  function clampAgentWindowWithSelection(selectionIndex) {
+    agentListWindowStart = agentDirectory.clampAgentWindowWithSelection({
+      activeCount: activeAgents.length,
+      maxWindow: MAX_AGENT_WINDOW,
+      windowStart: agentListWindowStart,
+      selectionIndex,
+    });
   }
 
-  function writeToAgentTerm(text) {
-    if (!text) return;
-    if (currentView === "agent") {
-      // Strip sequences that cause the real terminal to respond, feeding
-      // garbage back into the agent's input:
-      // - OSC queries: \x1b]10;?\x07 etc (color queries)
-      // - CSI DSR: \x1b[6n / \x1b[?6n (cursor position query → CPR response)
-      // - CSI DSR: \x1b[5n (device status query)
-      // - CSI DA:  \x1b[c / \x1b[>c / \x1b[=c (device attributes query)
-      const cleaned = text
-        .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "")
-        .replace(/\x1b\[(?:[?>=]?[0-9]*c|[?]?6n|5n)/g, "");
-      if (cleaned) process.stdout.write(cleaned);
-      // Always re-render dashboard bar — PTY output may overwrite it
-      // via absolute cursor positioning before the resize takes effect
-      renderAgentDashboard();
-    }
+  function clampAgentWindow() {
+    clampAgentWindowWithSelection(selectedAgentIndex);
   }
 
-  function requestStatus() {
-    send({ type: "status" });
+  function send(req) {
+    if (!daemonCoordinator) return;
+    daemonCoordinator.send(req);
   }
 
-  const detachClient = () => {
-    if (!client) return;
-    client.removeAllListeners("data");
-    client.removeAllListeners("close");
-    try {
-      client.end();
-      client.destroy();
-    } catch {
-      // ignore
-    }
-  };
-
-  const attachClient = (newClient) => {
-    if (!newClient) return;
-    detachClient();
-    client = newClient;
-    connectionLostNotified = false;
-    let buffer = "";
-    client.on("data", (data) => {
-      buffer += data.toString("utf8");
-      const lines = buffer.split(/\r?\n/);
-      buffer = lines.pop() || "";
-      for (const line of lines.filter((l) => l.trim())) {
-        try {
-        const msg = JSON.parse(line);
-            if (msg.type === "status") {
-              const data = msg.data || {};
-              if (typeof data.phase === "string") {
-            const rawText = data.text == null ? "" : String(data.text);
-            const item = { key: data.key, text: rawText };
-                if (data.phase === "start") {
-                  enqueueBusStatus(item);
-                } else if (data.phase === "done" || data.phase === "error") {
-                  resolveBusStatus(item);
-                  if (rawText) {
-                    const prefix = data.phase === "error"
-                      ? "{red-fg}✗{/red-fg}"
-                      : "{green-fg}✓{/green-fg}";
-                    logMessage("status", `${prefix} ${escapeBlessed(rawText)}`, data);
-                  }
-                } else {
-                  enqueueBusStatus(item);
-                }
-                screen.render();
-              } else {
-            // 收到 dashboard 状态更新
-            if (process.env.UFOO_DEBUG) {
-              logMessage("debug", `[status] active: ${(data.active || []).length}`);
-            }
-            updateDashboard(data);
-          }
-            } else if (msg.type === "response") {
-              const payload = msg.data || {};
-              if (payload.reply) {
-                resolveStatusLine(`{green-fg}←{/green-fg} ${escapeBlessed(payload.reply)}`);
-                logMessage("reply", `{green-fg}←{/green-fg} ${escapeBlessed(payload.reply)}`);
-              }
-              if (payload.dispatch && payload.dispatch.length > 0) {
-                const targets = payload.dispatch.map((d) => d.target || d).join(", ");
-                logMessage("dispatch", `{blue-fg}→{/blue-fg} Dispatched to: ${escapeBlessed(targets)}`);
-              }
-              if (payload.disambiguate && Array.isArray(payload.disambiguate.candidates) && payload.disambiguate.candidates.length > 0) {
-                pending = { disambiguate: payload.disambiguate, original: pending?.original };
-                const prompt = payload.disambiguate.prompt || "Choose target:";
-                resolveStatusLine(`{yellow-fg}?{/yellow-fg} ${escapeBlessed(prompt)}`);
-                logMessage("disambiguate", `{yellow-fg}?{/yellow-fg} ${escapeBlessed(prompt)}`);
-                payload.disambiguate.candidates.forEach((c, i) => {
-                  const agentId = c.agent_id || "";
-                  const reason = c.reason || "";
-                  logMessage(
-                    "disambiguate",
-                    `   {cyan-fg}${i + 1}){/cyan-fg} ${escapeBlessed(agentId)} {gray-fg}— ${escapeBlessed(reason)}{/gray-fg}`
-                  );
-                });
-              } else {
-                pending = null;
-              }
-          if (!payload.reply && !payload.disambiguate) {
-            resolveStatusLine("{gray-fg}✓{/gray-fg} Done");
-          }
-          // opsResults are noisy JSON; keep them out of the log UI
-          screen.render();
-            } else if (msg.type === "bus") {
-              const data = msg.data || {};
-              const prefix = data.event === "broadcast" ? "{magenta-fg}⇢{/magenta-fg}" : "{blue-fg}↔{/blue-fg}";
-              let publisher = data.publisher && data.publisher !== "unknown"
-                ? data.publisher
-                : (data.event === "broadcast" ? "broadcast" : "bus");
-
-          // Try to parse message as JSON (from internal agents)
-              let displayMessage = data.message == null ? "" : String(data.message);
-              let isStream = false;
-              try {
-                const parsed = JSON.parse(data.message);
-                if (parsed && typeof parsed === "object" && parsed.reply) {
-                  displayMessage = parsed.reply == null ? "" : String(parsed.reply);
-                } else if (parsed && typeof parsed === "object" && parsed.stream) {
-                  displayMessage = typeof parsed.delta === "string" ? parsed.delta : "";
-                  isStream = true;
-                }
-              } catch {
-                // Not JSON, use as-is
-              }
-
-          // Convert literal \n to actual newlines for better display
-          if (typeof displayMessage === "string") {
-            displayMessage = displayMessage.replace(/\\n/g, "\n");
-          }
-
-          // Extract nickname if publisher is in subscriber:id format
-              let displayName = publisher;
-              if (publisher.includes(":")) {
-            // Try to get nickname from activeAgentLabelMap or all-agents.json
-            if (activeAgentLabelMap && activeAgentLabelMap.has(publisher)) {
-              displayName = activeAgentLabelMap.get(publisher);
-            } else {
-              // Fallback: read directly from all-agents.json
-              try {
-                const busPath = getUfooPaths(projectRoot).agentsFile;
-                const bus = JSON.parse(fs.readFileSync(busPath, "utf8"));
-                const meta = bus.agents && bus.agents[publisher];
-                if (meta && meta.nickname) {
-                  displayName = meta.nickname;
-                }
-              } catch {
-                // Keep original publisher ID
-              }
-            }
-              }
-
-              const line = `${prefix} {gray-fg}${escapeBlessed(displayName)}{/gray-fg}: ${escapeBlessed(displayMessage)}`;
-              if (isStream) {
-                recordLog("bus_stream", line, data, true);
-              } else {
-                logMessage("bus", line, data);
-              }
-          if (data.event === "agent_renamed" || data.event === "message") {
-            // 收到消息时刷新 status，更新在线 agent 列表
-            requestStatus();
-          }
-          screen.render();
-            } else if (msg.type === "error") {
-              resolveStatusLine(`{red-fg}✗{/red-fg} Error: ${escapeBlessed(msg.error)}`);
-              logMessage("error", `{red-fg}✗{/red-fg} Error: ${escapeBlessed(msg.error)}`);
-              screen.render();
-            }
-      } catch {
-        // ignore
-      }
-    }
+  cronScheduler = createCronScheduler({
+    dispatch: ({ taskId, target, message }) => {
+      send({
+        type: IPC_REQUEST_TYPES.BUS_SEND,
+        target,
+        message,
+      });
+      queueStatusLine(`cron:${taskId} -> ${target}`);
+    },
+    onChange: () => {
+      renderDashboard();
+      screen.render();
+    },
   });
-    const handleDisconnect = () => {
-      if (client === newClient) {
-        client = null;
-      }
-      if (exitRequested) return;
-      if (!connectionLostNotified) {
-        connectionLostNotified = true;
-        logMessage("status", "{red-fg}✗{/red-fg} Daemon disconnected");
-      }
-      void ensureConnected();
-    };
-    client.on("close", handleDisconnect);
-    client.on("error", handleDisconnect);
-    flushPendingRequests();
-  };
-
-  attachClient(client);
-
-  // Command handlers
-  async function handleDoctorCommand() {
-    logMessage("system", "{yellow-fg}⚙{/yellow-fg} Running health check...");
 
-    // Capture console output safely
-    const originalLog = console.log;
-    const originalError = console.error;
-
-    console.log = (...args) => logMessage("system", args.join(" "));
-    console.error = (...args) => logMessage("error", args.join(" "));
-
-    try {
-      const UfooDoctor = require("../doctor");
-      const doctor = new UfooDoctor(projectRoot);
-      const result = doctor.run();
-
-      if (result) {
-        logMessage("system", "{green-fg}✓{/green-fg} System healthy");
-      } else {
-        logMessage("error", "{red-fg}✗{/red-fg} Health check failed");
-      }
-      screen.render();
-    } catch (err) {
-      logMessage("error", `{red-fg}✗{/red-fg} Doctor check failed: ${err.message}`);
-      screen.render();
-    } finally {
-      console.log = originalLog;
-      console.error = originalError;
+  function updatePromptBox() {
+    if (targetAgent) {
+      const label = getAgentLabel(targetAgent);
+      promptBox.setContent(`>@${label}`);
+      promptBox.width = label.length + 3;  // >@name + spacer
+      input.left = promptBox.width;
+      input.width = `100%-${promptBox.width}`;
+    } else {
+      promptBox.setContent(">");
+      promptBox.width = 2;
+      input.left = 2;
+      input.width = "100%-2";
+    }
+    if (!input.parent || !promptBox.parent) return;
+    resizeInput();
+    if (typeof input._updateCursor === "function") {
+      input._updateCursor();
     }
   }
 
-  async function handleStatusCommand() {
-    // Display current status directly instead of requesting
-    if (activeAgents.length === 0) {
-      logMessage("system", "{cyan-fg}Status:{/cyan-fg} No active agents");
-    } else {
-      logMessage("system", `{cyan-fg}Status:{/cyan-fg} ${activeAgents.length} active agent(s)`);
-      for (const id of activeAgents) {
-        const label = getAgentLabel(id);
-        const meta = activeAgentMetaMap.get(id);
-        const mode = meta?.launch_mode || "unknown";
-        logMessage("system", `  • {cyan-fg}${label}{/cyan-fg} {gray-fg}[${mode}]{/gray-fg}`);
+  function syncTargetFromSelection() {
+    if (focusMode !== "dashboard" || dashboardView !== "agents") return;
+    if (selectedAgentIndex >= 0 && selectedAgentIndex < activeAgents.length) {
+      const nextTarget = activeAgents[selectedAgentIndex];
+      if (nextTarget !== targetAgent) {
+        targetAgent = nextTarget;
+        updatePromptBox();
+        screen.render();
       }
-    }
-
-    // Also show daemon status
-    if (isRunning(projectRoot)) {
-      logMessage("system", "{green-fg}✓{/green-fg} Daemon is running");
-    } else {
-      logMessage("system", "{red-fg}✗{/red-fg} Daemon is not running");
+    } else if (targetAgent) {
+      targetAgent = null;
+      updatePromptBox();
+      screen.render();
     }
   }
 
-  async function handleDaemonCommand(args) {
-    const subcommand = args[0];
-
-    if (subcommand === "start") {
-      if (isRunning(projectRoot)) {
-        logMessage("system", "{yellow-fg}⚠{/yellow-fg} Daemon already running");
-      } else {
-        logMessage("system", "{yellow-fg}⚙{/yellow-fg} Starting daemon...");
-        startDaemon(projectRoot);
-        await new Promise(r => setTimeout(r, 1000));
-        if (isRunning(projectRoot)) {
-          logMessage("system", "{green-fg}✓{/green-fg} Daemon started");
-        } else {
-          logMessage("error", "{red-fg}✗{/red-fg} Failed to start daemon");
-        }
-      }
-    } else if (subcommand === "stop") {
-      logMessage("system", "{yellow-fg}⚙{/yellow-fg} Stopping daemon...");
-      stopDaemon(projectRoot);
-      await new Promise(r => setTimeout(r, 1000));
-      if (!isRunning(projectRoot)) {
-        logMessage("system", "{green-fg}✓{/green-fg} Daemon stopped");
-      } else {
-        logMessage("error", "{red-fg}✗{/red-fg} Failed to stop daemon");
-      }
-    } else if (subcommand === "restart") {
-      logMessage("system", "{yellow-fg}⚙{/yellow-fg} Restarting daemon...");
-      await restartDaemon();
-    } else if (subcommand === "status") {
-      if (isRunning(projectRoot)) {
-        logMessage("system", "{green-fg}✓{/green-fg} Daemon is running");
-      } else {
-        logMessage("system", "{red-fg}✗{/red-fg} Daemon is not running");
-      }
-    } else {
-      logMessage("error", "{red-fg}✗{/red-fg} Unknown daemon command. Use: start, stop, restart, status");
+  function restoreTargetFromSelection() {
+    if (selectedAgentIndex >= 0 && selectedAgentIndex < activeAgents.length) {
+      targetAgent = activeAgents[selectedAgentIndex];
+      updatePromptBox();
     }
   }
 
-  async function handleInitCommand(args) {
-    logMessage("system", "{yellow-fg}⚙{/yellow-fg} Initializing ufoo modules...");
+  function focusInput() {
+    input.focus();
+    input._updateCursor();
+  }
 
-    // Capture console output safely
-    const originalLog = console.log;
-    const originalError = console.error;
-    const logs = [];
+  function focusLog() {
+    logBox.focus();
+    screen.program.hideCursor();
+  }
 
-    console.log = (...args) => {
-      const msg = args.join(" ");
-      logs.push(msg);
-      // Also output to logMessage immediately to avoid UI blocking
-      logMessage("system", msg);
-    };
-    console.error = (...args) => {
-      const msg = args.join(" ");
-      logs.push(`ERROR: ${msg}`);
-      logMessage("error", msg);
-    };
+  function scrollLog(offset) {
+    logBox.scroll(offset);
+    screen.render();
+  }
 
-    try {
-      const repoRoot = path.join(__dirname, "..", "..");
-      const init = new UfooInit(repoRoot);
-      const modules = args.length > 0 ? args.join(",") : "context,bus";
-      await init.init({ modules, project: projectRoot });
+  let settingsController = null;
 
-      logMessage("system", "{green-fg}✓{/green-fg} Initialization complete");
-      screen.render();
-    } catch (err) {
-      logMessage("error", `{red-fg}✗{/red-fg} Init failed: ${err.message}`);
-      if (err.stack) {
-        logMessage("error", err.stack);
-      }
-      screen.render();
-    } finally {
-      console.log = originalLog;
-      console.error = originalError;
+  function setLaunchMode(mode) {
+    if (settingsController) {
+      settingsController.setLaunchMode(mode);
     }
   }
 
-  async function handleBusCommand(args) {
-    const subcommand = args[0];
-
-    try {
-      if (subcommand === "send") {
-        if (args.length < 3) {
-          logMessage("error", "{red-fg}✗{/red-fg} Usage: /bus send <target> <message>");
-          return;
-        }
-        const target = args[1];
-        const message = args.slice(2).join(" ");
-        // Send via daemon to ensure proper publisher ID
-        send({ type: "bus_send", target, message });
-        logMessage("system", `{green-fg}✓{/green-fg} Message sent to ${target}`);
-        return;
-      }
-
-      const bus = new EventBus(projectRoot);
-
-      if (subcommand === "rename") {
-        if (args.length < 3) {
-          logMessage("error", "{red-fg}✗{/red-fg} Usage: /bus rename <agent> <nickname>");
-          return;
-        }
-        const agentId = args[1];
-        const nickname = args[2];
-        await bus.rename(agentId, nickname);
-        logMessage("system", `{green-fg}✓{/green-fg} Renamed ${agentId} to ${nickname}`);
-        requestStatus();
-      } else if (subcommand === "list") {
-        bus.ensureBus();
-        bus.loadBusData();
-        const subscribers = Object.entries(bus.busData.agents || {});
-        if (subscribers.length === 0) {
-          logMessage("system", "{gray-fg}No active agents{/gray-fg}");
-        } else {
-          logMessage("system", "{cyan-fg}Active agents:{/cyan-fg}");
-          for (const [id, meta] of subscribers) {
-            const nickname = meta.nickname ? ` (${meta.nickname})` : "";
-            const status = meta.status || "unknown";
-            logMessage("system", `  • ${id}${nickname} {gray-fg}[${status}]{/gray-fg}`);
-          }
-        }
-      } else if (subcommand === "status") {
-        bus.ensureBus();
-        bus.loadBusData();
-        const count = Object.keys(bus.busData.agents || {}).length;
-        logMessage("system", `{cyan-fg}Bus status:{/cyan-fg} ${count} agent(s) registered`);
-      } else if (subcommand === "activate") {
-        if (args.length < 2) {
-          logMessage("error", "{red-fg}✗{/red-fg} Usage: /bus activate <agent>");
-          return;
-        }
-        const target = args[1];
-        const AgentActivator = require("../bus/activate");
-        const activator = new AgentActivator(projectRoot);
-        await activator.activate(target);
-        logMessage("system", `{green-fg}✓{/green-fg} Activated ${target}`);
-      } else {
-        logMessage("error", "{red-fg}✗{/red-fg} Unknown bus command. Use: send, rename, list, status, activate");
-      }
-    } catch (err) {
-      logMessage("error", `{red-fg}✗{/red-fg} Bus command failed: ${err.message}`);
+  function requestCloseAgent(agentId) {
+    if (!agentId) {
+      logMessage("error", "{white-fg}✗{/white-fg} No agent selected");
+      return;
     }
+    const label = getAgentLabel(agentId);
+    logMessage("status", `{white-fg}⚙{/white-fg} Closing ${label}...`);
+    send({ type: IPC_REQUEST_TYPES.CLOSE_AGENT, agent_id: agentId });
   }
 
-  async function handleCtxCommand(args) {
-    logMessage("system", "{yellow-fg}⚙{/yellow-fg} Running context check...");
+  function setAgentProvider(provider) {
+    if (settingsController) {
+      settingsController.setAgentProvider(provider);
+    }
+  }
 
-    // Capture console output safely
-    const originalLog = console.log;
-    const originalError = console.error;
+  function setAssistantEngine(value) {
+    if (settingsController) {
+      settingsController.setAssistantEngine(value);
+    }
+  }
 
-    console.log = (...args) => logMessage("system", args.join(" "));
-    console.error = (...args) => logMessage("error", args.join(" "));
+  function setAutoResume(value) {
+    if (settingsController) {
+      settingsController.setAutoResume(value);
+    }
+  }
 
-    try {
-      const UfooContext = require("../context");
-      const ctx = new UfooContext(projectRoot);
-
-      if (args.length === 0 || args[0] === "doctor") {
-        await ctx.doctor();
-      } else if (args[0] === "decisions") {
-        await ctx.listDecisions();
-      } else {
-        await ctx.status();
-      }
+  async function restartDaemon() {
+    if (!daemonCoordinator) return;
+    return daemonCoordinator.restart();
+  }
+
+  settingsController = createSettingsController({
+    projectRoot,
+    saveConfig,
+    normalizeLaunchMode,
+    normalizeAgentProvider,
+    normalizeAssistantEngine,
+    fsModule: fs,
+    getUfooPaths,
+    logMessage,
+    renderDashboard,
+    renderScreen: () => screen.render(),
+    restartDaemon,
+    getLaunchMode: () => launchMode,
+    setLaunchModeState: (value) => {
+      launchMode = value;
+    },
+    setSelectedModeIndex: (value) => {
+      selectedModeIndex = value;
+    },
+    getAgentProvider: () => agentProvider,
+    setAgentProviderState: (value) => {
+      agentProvider = value;
+    },
+    setSelectedProviderIndex: (value) => {
+      selectedProviderIndex = value;
+    },
+    getAssistantEngine: () => assistantEngine,
+    setAssistantEngineState: (value) => {
+      assistantEngine = value;
+    },
+    setSelectedAssistantIndex: (value) => {
+      selectedAssistantIndex = value;
+    },
+    assistantOptions,
+    providerOptions,
+    getAutoResume: () => autoResume,
+    setAutoResumeState: (value) => {
+      autoResume = value;
+    },
+    setSelectedResumeIndex: (value) => {
+      selectedResumeIndex = value;
+    },
+  });
 
-      screen.render();
-    } catch (err) {
-      logMessage("error", `{red-fg}✗{/red-fg} Context check failed: ${err.message}`);
-      screen.render();
-    } finally {
-      console.log = originalLog;
-      console.error = originalError;
+  function clearLog() {
+    logBox.setContent("");
+    if (typeof logBox.scrollTo === "function") {
+      logBox.scrollTo(0);
     }
+    screen.render();
   }
 
-  async function handleSkillsCommand(args) {
-    const subcommand = args[0];
-
-    // Capture console output safely
-    const originalLog = console.log;
-    console.log = (...args) => logMessage("system", args.join(" "));
+  function renderDashboard() {
+    const computed = computeDashboardContent({
+      focusMode,
+      dashboardView,
+      activeAgents,
+      selectedAgentIndex,
+      agentListWindowStart,
+      maxAgentWindow: MAX_AGENT_WINDOW,
+      getAgentLabel,
+      launchMode,
+      agentProvider,
+      assistantEngine,
+      autoResume,
+      selectedModeIndex,
+      selectedProviderIndex,
+      selectedAssistantIndex,
+      selectedResumeIndex,
+      cronTasks: cronScheduler.listTasks(),
+      providerOptions,
+      assistantOptions,
+      resumeOptions,
+      pendingReports: reportPendingTotal,
+      dashHints: DASH_HINTS,
+    });
+    agentListWindowStart = computed.windowStart;
+    dashboard.setContent(computed.content);
+  }
 
-    try {
-      const UfooSkills = require("../skills");
-      const skills = new UfooSkills(projectRoot);
-
-      if (subcommand === "list") {
-        const skillList = skills.list();
-        if (skillList.length === 0) {
-          logMessage("system", "{gray-fg}No skills found{/gray-fg}");
-        } else {
-          logMessage("system", `{cyan-fg}Available skills:{/cyan-fg} ${skillList.length}`);
-          for (const skill of skillList) {
-            logMessage("system", `  • ${skill}`);
-          }
+  function updateDashboard(status) {
+    activeAgents = status.active || [];
+    reportPendingTotal = Number.isFinite(status?.reports?.pending_total)
+      ? status.reports.pending_total
+      : 0;
+    const metaList = Array.isArray(status.active_meta) ? status.active_meta : [];
+    let fallbackMap = null;
+    if (metaList.length === 0 && activeAgents.length > 0) {
+      try {
+        const busPath = getUfooPaths(projectRoot).agentsFile;
+        const bus = JSON.parse(fs.readFileSync(busPath, "utf8"));
+        fallbackMap = new Map();
+        for (const [id, meta] of Object.entries(bus.agents || {})) {
+          if (meta && meta.nickname) fallbackMap.set(id, meta.nickname);
         }
-      } else if (subcommand === "install") {
-        const target = args[1] || "all";
-        logMessage("system", `{yellow-fg}⚙{/yellow-fg} Installing skills: ${target}...`);
-        await skills.install(target);
-        logMessage("system", "{green-fg}✓{/green-fg} Skills installed");
-      } else {
-        logMessage("error", "{red-fg}✗{/red-fg} Unknown skills command. Use: list, install");
+      } catch {
+        fallbackMap = null;
       }
-
-      screen.render();
-    } catch (err) {
-      logMessage("error", `{red-fg}✗{/red-fg} Skills command failed: ${err.message}`);
-      screen.render();
-    } finally {
-      console.log = originalLog;
     }
-  }
-
-  async function handleLaunchCommand(args) {
-    if (args.length === 0) {
-      logMessage("error", "{red-fg}✗{/red-fg} Usage: /launch <claude|codex> [nickname=<name>] [count=<n>]");
+    const maps = agentDirectory.buildAgentMaps(activeAgents, metaList, fallbackMap);
+    activeAgentLabelMap = maps.labelMap;
+    activeAgentMetaMap = maps.metaMap;
+    clampAgentWindow();
+    // If viewing agent went offline, exit view
+    const currentView = getCurrentView();
+    const viewingAgent = getViewingAgent();
+    if (currentView === "agent" && viewingAgent && !activeAgents.includes(viewingAgent)) {
+      writeToAgentTerm("\r\n\x1b[1;31m[Agent went offline]\x1b[0m\r\n");
+      exitAgentView();
       return;
     }
 
-    const agentType = args[0];
-    if (agentType !== "claude" && agentType !== "codex") {
-      logMessage("error", "{red-fg}✗{/red-fg} Unknown agent type. Use: claude or codex");
+    // In agent view, only update the dashboard bar (blessed is frozen)
+    if (currentView === "agent") {
+      if (focusMode === "dashboard") {
+        const totalItems = 1 + activeAgents.length;
+        if (selectedAgentIndex < 0 || selectedAgentIndex >= totalItems) {
+          selectedAgentIndex = 0;
+        }
+      }
+      renderAgentDashboard();
       return;
     }
-
-    // Parse options
-    const options = {};
-    for (let i = 1; i < args.length; i++) {
-      const arg = args[i];
-      if (arg.includes("=")) {
-        const [key, value] = arg.split("=", 2);
-        options[key] = value;
+    if (focusMode === "dashboard") {
+      if (dashboardView === "agents") {
+        if (activeAgents.length === 0) {
+          selectedAgentIndex = -1;
+        } else if (selectedAgentIndex < 0 || selectedAgentIndex >= activeAgents.length) {
+          selectedAgentIndex = 0;
+        }
+        clampAgentWindow();
       }
     }
+    syncTargetFromSelection();
+    renderDashboard();
+    screen.render();
+  }
 
-    const nickname = options.nickname || "";
-    const count = parseInt(options.count || "1", 10);
-    if (nickname && count > 1) {
-      logMessage("error", "{red-fg}✗{/red-fg} nickname requires count=1");
-      return;
+  function enterDashboardMode() {
+    focusMode = "dashboard";
+    dashboardView = "agents";
+    selectedAgentIndex = activeAgents.length > 0 ? 0 : -1;
+    agentListWindowStart = 0;
+    clampAgentWindow();
+    selectedModeIndex = launchMode === "internal" ? 2 : (launchMode === "tmux" ? 1 : 0);
+    selectedProviderIndex = Math.max(0, providerOptions.findIndex((opt) => opt.value === agentProvider));
+    selectedAssistantIndex = Math.max(
+      0,
+      assistantOptions.findIndex((opt) => opt.value === assistantEngine)
+    );
+    selectedResumeIndex = autoResume ? 0 : 1;
+    // Immediately set @target when first agent is selected
+    if (selectedAgentIndex >= 0 && selectedAgentIndex < activeAgents.length) {
+      targetAgent = activeAgents[selectedAgentIndex];
+      updatePromptBox();
     }
+    screen.grabKeys = true;
+    renderDashboard();
+    screen.program.hideCursor();
+    screen.render();
+    syncTargetFromSelection();
+  }
+
+  const dashboardState = {};
+  Object.defineProperties(dashboardState, {
+    currentView: { get: () => getCurrentView() },
+    focusMode: { get: () => focusMode, set: (value) => { focusMode = value; } },
+    dashboardView: { get: () => dashboardView, set: (value) => { dashboardView = value; } },
+    selectedAgentIndex: { get: () => selectedAgentIndex, set: (value) => { selectedAgentIndex = value; } },
+    activeAgents: { get: () => activeAgents },
+    viewingAgent: { get: () => getViewingAgent() },
+    activeAgentMetaMap: { get: () => activeAgentMetaMap },
+    selectedModeIndex: { get: () => selectedModeIndex, set: (value) => { selectedModeIndex = value; } },
+    selectedProviderIndex: { get: () => selectedProviderIndex, set: (value) => { selectedProviderIndex = value; } },
+    selectedAssistantIndex: { get: () => selectedAssistantIndex, set: (value) => { selectedAssistantIndex = value; } },
+    selectedResumeIndex: { get: () => selectedResumeIndex, set: (value) => { selectedResumeIndex = value; } },
+    launchMode: { get: () => launchMode },
+    agentProvider: { get: () => agentProvider },
+    assistantEngine: { get: () => assistantEngine },
+    autoResume: { get: () => autoResume },
+    cronTasks: { get: () => cronScheduler.listTasks() },
+    providerOptions: { get: () => providerOptions },
+    assistantOptions: { get: () => assistantOptions },
+    resumeOptions: { get: () => resumeOptions },
+    agentOutputSuppressed: {
+      get: () => getAgentOutputSuppressed(),
+      set: (value) => { setAgentOutputSuppressed(value); },
+    },
+  });
 
-    try {
-      const label = nickname ? ` (${nickname})` : "";
-      logMessage("system", `{yellow-fg}⚙{/yellow-fg} Launching ${agentType}${label}...`);
-      send({
-        type: "launch_agent",
-        agent: agentType,
-        count: Number.isFinite(count) ? count : 1,
-        nickname,
-      });
-      setTimeout(requestStatus, 1000);
-    } catch (err) {
-      logMessage("error", `{red-fg}✗{/red-fg} Launch failed: ${err.message}`);
+  function activateAgent(agentId) {
+    if (!agentId) return;
+    const activator = new AgentActivator(projectRoot);
+    activator.activate(agentId).catch(() => {});
+  }
+
+  terminalAdapterRouter = createTerminalAdapterRouter({
+    activateAgent,
+    sendRaw: (data) => agentSockets.sendRaw(data),
+    sendResize: (cols, rows) => agentSockets.sendResize(cols, rows),
+    requestSnapshot: (mode) => agentSockets.requestSnapshot(mode),
+  });
+
+  const dashboardController = createDashboardKeyController({
+    state: dashboardState,
+    existsSync: fs.existsSync,
+    getInjectSockPath,
+    getAgentAdapter,
+    activateAgent,
+    requestCloseAgent,
+    enterAgentView,
+    exitAgentView,
+    setAgentBarVisible,
+    requestAgentSnapshot,
+    clearTargetAgent,
+    restoreTargetFromSelection,
+    syncTargetFromSelection,
+    exitDashboardMode,
+    setLaunchMode,
+    setAgentProvider,
+    setAssistantEngine,
+    setAutoResume,
+    clampAgentWindow,
+    clampAgentWindowWithSelection,
+    renderDashboard,
+    renderAgentDashboard,
+    renderScreen: () => screen.render(),
+    setScreenGrabKeys: (value) => {
+      screen.grabKeys = Boolean(value);
+    },
+  });
+
+  function handleDashboardKey(key) {
+    return dashboardController.handleDashboardKey(key);
+  }
+
+  function exitDashboardMode(selectAgent = false) {
+    if (selectAgent && selectedAgentIndex >= 0 && selectedAgentIndex < activeAgents.length) {
+      targetAgent = activeAgents[selectedAgentIndex];
+      updatePromptBox();
     }
+    focusMode = "input";
+    dashboardView = "agents";
+    selectedAgentIndex = -1;
+    screen.grabKeys = false;
+    renderDashboard();
+    focusInput();
+    screen.render();
   }
 
-  async function handleResumeCommand(args) {
-    const target = args[0] || "";
-    const label = target ? ` (${target})` : "";
-    logMessage("system", `{yellow-fg}⚙{/yellow-fg} Resuming agents${label}...`);
-    send({ type: "resume_agents", target });
-    setTimeout(requestStatus, 1000);
+  function clearTargetAgent() {
+    targetAgent = null;
+    updatePromptBox();
+    screen.render();
   }
 
-  function parseCommand(text) {
-    if (!text.startsWith("/")) return null;
+  function getInjectSockPath(agentId) {
+    const safeName = subscriberToSafeName(agentId);
+    return path.join(getUfooPaths(projectRoot).busQueuesDir, safeName, "inject.sock");
+  }
 
-    // Split by whitespace, respecting quotes
-    const parts = text.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
-    if (parts.length === 0) return null;
+  agentViewController = createAgentViewController({
+    screen,
+    input,
+    processStdout: process.stdout,
+    computeAgentBar,
+    agentBarHints: AGENT_BAR_HINTS,
+    maxAgentWindow: MAX_AGENT_WINDOW,
+    getFocusMode: () => focusMode,
+    setFocusMode: (value) => {
+      focusMode = value;
+    },
+    getSelectedAgentIndex: () => selectedAgentIndex,
+    setSelectedAgentIndex: (value) => {
+      selectedAgentIndex = value;
+    },
+    getActiveAgents: () => activeAgents,
+    getAgentListWindowStart: () => agentListWindowStart,
+    setAgentListWindowStart: (value) => {
+      agentListWindowStart = value;
+    },
+    getAgentLabel,
+    setDashboardView: (value) => {
+      dashboardView = value;
+    },
+    setScreenGrabKeys: (value) => {
+      screen.grabKeys = Boolean(value);
+    },
+    clearTargetAgent,
+    renderDashboard,
+    focusInput,
+    resizeInput,
+    renderScreen: () => screen.render(),
+    getInjectSockPath,
+    connectAgentOutput: (sockPath) => {
+      agentSockets.connectOutput(sockPath);
+    },
+    disconnectAgentOutput: () => {
+      agentSockets.disconnectOutput();
+    },
+    connectAgentInput: (sockPath) => {
+      agentSockets.connectInput(sockPath);
+    },
+    disconnectAgentInput: () => {
+      agentSockets.disconnectInput();
+    },
+    sendRaw: (data) => {
+      sendRawWithCapabilities(data);
+    },
+    sendResize: (cols, rows) => {
+      sendResizeWithCapabilities(cols, rows);
+    },
+    requestScreenSnapshot: () => {
+      requestSnapshotWithCapabilities();
+    },
+  });
 
-    const command = parts[0].slice(1); // Remove leading /
-    const args = parts.slice(1).map(arg => arg.replace(/^"|"$/g, "")); // Remove quotes
+  function requestStatus() {
+    if (!daemonCoordinator) return;
+    daemonCoordinator.requestStatus();
+  }
+
+  const daemonMessageRouter = createDaemonMessageRouter({
+    escapeBlessed,
+    stripBlessedTags,
+    logMessage,
+    renderScreen: () => screen.render(),
+    updateDashboard,
+    requestStatus,
+    resolveStatusLine,
+    enqueueBusStatus,
+    resolveBusStatus,
+    getPending: () => pending,
+    setPending: (value) => {
+      pending = value;
+    },
+    resolveAgentDisplayName,
+    getCurrentView: () => getCurrentView(),
+    isAgentViewUsesBus: () => isAgentViewUsesBus(),
+    getViewingAgent: () => getViewingAgent(),
+    writeToAgentTerm,
+    consumePendingDelivery,
+    getPendingState,
+    beginStream,
+    appendStreamDelta,
+    finalizeStream,
+    hasStream: (publisher) => streamTracker.hasStream(publisher),
+  });
 
-    return { command, args };
-  }
+  daemonCoordinator = createDaemonCoordinator({
+    projectRoot,
+    daemonTransport,
+    handleMessage: (msg) => daemonMessageRouter.handleMessage(msg),
+    queueStatusLine,
+    resolveStatusLine,
+    logMessage,
+    stopDaemon,
+    startDaemon,
+  });
 
-  async function executeCommand(text) {
-    const parsed = parseCommand(text);
-    if (!parsed) return false;
-
-    const { command, args } = parsed;
-
-    switch (command) {
-      case "doctor":
-        await handleDoctorCommand();
-        return true;
-      case "status":
-        await handleStatusCommand();
-        return true;
-      case "daemon":
-        await handleDaemonCommand(args);
-        return true;
-      case "init":
-        await handleInitCommand(args);
-        return true;
-      case "bus":
-        await handleBusCommand(args);
-        return true;
-      case "ctx":
-        await handleCtxCommand(args);
-        return true;
-      case "skills":
-        await handleSkillsCommand(args);
-        return true;
-      case "launch":
-        await handleLaunchCommand(args);
-        return true;
-      case "resume":
-        await handleResumeCommand(args);
-        return true;
-      default:
-        logMessage("error", `{red-fg}✗{/red-fg} Unknown command: /${command}`);
-        return true;
+  const connected = await daemonCoordinator.connect();
+  if (!connected) {
+    // Check if daemon failed to start
+    if (!isRunning(projectRoot)) {
+      const logFile = getUfooPaths(projectRoot).ufooDaemonLog;
+      // eslint-disable-next-line no-console
+      console.error("Failed to start ufoo daemon. Check logs at:", logFile);
+      throw new Error("Daemon failed to start. Check the daemon log for details.");
     }
+    throw new Error("Failed to connect to ufoo daemon (timeout). The daemon may still be starting.");
   }
 
-  input.on("submit", async (value) => {
-    const text = value.trim();
-    input.clearValue();
-    screen.render();
-    if (!text) {
-      // Empty Enter with @target → enter TTY view
-      if (targetAgent) {
-        const agentId = targetAgent;
-        const sockPath = getInjectSockPath(agentId);
-        if (fs.existsSync(sockPath)) {
-          clearTargetAgent();
-          enterAgentView(agentId);
-          return;
-        }
-      }
-      input.focus();
-      return;
-    }
-    inputHistory.push(text);
-    appendInputHistory(text);
-    historyIndex = inputHistory.length;
-    historyDraft = "";
+  const commandExecutor = createCommandExecutor({
+    projectRoot,
+    parseCommand,
+    escapeBlessed,
+    logMessage,
+    renderScreen: () => screen.render(),
+    getActiveAgents: () => activeAgents,
+    getActiveAgentMetaMap: () => activeAgentMetaMap,
+    getAgentLabel,
+    isDaemonRunning: isRunning,
+    startDaemon,
+    stopDaemon,
+    restartDaemon,
+    send,
+    requestStatus,
+    createCronTask: ({ intervalMs, targets, prompt }) =>
+      cronScheduler.addTask({ intervalMs, targets, prompt }),
+    listCronTasks: () => cronScheduler.listTasks(),
+    stopCronTask: (id) => cronScheduler.stopTask(id),
+    activateAgent: async (target) => {
+      const activator = new AgentActivator(projectRoot);
+      await activator.activate(target);
+    },
+  });
 
-    // If target agent is selected, inject directly into agent's PTY
-    if (targetAgent) {
-      const label = getAgentLabel(targetAgent);
-      logMessage("user", `{magenta-fg}${escapeBlessed(label)}{/magenta-fg}: ${escapeBlessed(text)}`);
-
-      const meta = activeAgentMetaMap.get(targetAgent);
-      const agentMode = meta?.launch_mode || "";
-
-      if (agentMode === "tmux" && meta?.tmux_pane) {
-        // Tmux mode: use tmux send-keys
-        // Send text first, then Enter after a delay (Claude Code needs time to process)
-        const pane = meta.tmux_pane;
-        const textProc = spawn("tmux", ["send-keys", "-t", pane, text]);
-        textProc.on("close", () => {
-          setTimeout(() => {
-            spawn("tmux", ["send-keys", "-t", pane, "Enter"]);
-          }, 150);
-        });
-      } else {
-        // Terminal / internal mode: inject via inject.sock
-        const sockPath = getInjectSockPath(targetAgent);
-        try {
-          const conn = net.createConnection(sockPath, () => {
-            conn.write(JSON.stringify({ type: "raw", data: text }) + "\n");
-            setTimeout(() => {
-              conn.write(JSON.stringify({ type: "raw", data: "\r" }) + "\n");
-              setTimeout(() => conn.destroy(), 500);
-            }, 100);
-          });
-          conn.on("error", () => {});
-        } catch {
-          // ignore connection errors
-        }
-      }
+  async function executeCommand(text) {
+    return commandExecutor.executeCommand(text);
+  }
 
-      clearTargetAgent();
-      input.focus();
-      return;
-    }
+  const submitState = {};
+  Object.defineProperties(submitState, {
+    targetAgent: { get: () => targetAgent, set: (value) => { targetAgent = value; } },
+    pending: { get: () => pending, set: (value) => { pending = value; } },
+    activeAgentMetaMap: { get: () => activeAgentMetaMap },
+  });
 
-    // Check if it's a command
-    if (text.startsWith("/")) {
-      logMessage("user", `{cyan-fg}→{/cyan-fg} ${escapeBlessed(text)}`);
-      try {
-        await executeCommand(text);
-      } catch (err) {
-        logMessage("error", `{red-fg}✗{/red-fg} Command error: ${escapeBlessed(err.message)}`);
-      }
-      input.focus();
-      return;
-    }
+  const inputSubmitHandler = createInputSubmitHandler({
+    state: submitState,
+    parseAtTarget,
+    resolveAgentId,
+    executeCommand,
+    queueStatusLine,
+    send,
+    logMessage,
+    getAgentLabel,
+    escapeBlessed,
+    markPendingDelivery,
+    clearTargetAgent,
+    setTargetAgent: (agentId) => {
+      targetAgent = agentId || null;
+      updatePromptBox();
+      screen.render();
+    },
+    enterAgentView,
+    activateAgent: async (agentId) => {
+      const activator = new AgentActivator(projectRoot);
+      await activator.activate(agentId);
+    },
+    getInjectSockPath,
+    existsSync: fs.existsSync,
+    commitInputHistory: (text) => {
+      if (inputHistoryController) inputHistoryController.commitSubmittedText(text);
+    },
+    focusInput: () => input.focus(),
+    renderScreen: () => screen.render(),  // Add renderScreen callback
+  });
 
-    if (pending && pending.disambiguate) {
-      const idx = parseInt(text, 10);
-      const choice = pending.disambiguate.candidates[idx - 1];
-      if (choice) {
-        queueStatusLine(`ufoo-agent processing (assigning ${choice.agent_id})`);
-        send({
-          type: "prompt",
-          text: `Use agent ${choice.agent_id} to handle: ${pending.original || "the request"}`,
-        });
-        pending = null;
-      } else {
-        logMessage("error", escapeBlessed("Invalid selection."));
-      }
-    } else {
-      pending = { original: text };
-      queueStatusLine("ufoo-agent processing");
-      send({ type: "prompt", text });
-      logMessage("user", `{cyan-fg}→{/cyan-fg} ${escapeBlessed(text)}`);
-    }
-    input.focus();
+  input.on("submit", async (value) => {
+    input.clearValue();
+    screen.render(); // Render cleared input
+    await inputSubmitHandler.handleSubmit(value);
+    // No need for second render - handleSubmit now calls renderScreen() internally
   });
 
   screen.key(["C-c"], exitHandler);
 
   // Agent TTY view: enter dashboard mode
   function enterAgentDashboardMode() {
-    focusMode = "dashboard";
-    dashboardView = "agents";
-    // Find the current viewing agent's index in the [ufoo, ...agents] list
-    selectedAgentIndex = 0; // Default to ufoo for quick exit
-    renderAgentDashboard();
-  }
-
-  // Map key names to ANSI escape sequences for raw PTY passthrough
-  function keyToRaw(ch, key) {
-    if (ch && ch.length === 1) return ch;
-    if (!key) return null;
-    switch (key.name) {
-      case "return": case "enter": return "\r";
-      case "backspace": return "\x7f";
-      case "tab": return "\t";
-      case "escape": return "\x1b";
-      case "up": return "\x1b[A";
-      case "down": return "\x1b[B";
-      case "right": return "\x1b[C";
-      case "left": return "\x1b[D";
-      case "home": return "\x1b[H";
-      case "end": return "\x1b[F";
-      case "pageup": return "\x1b[5~";
-      case "pagedown": return "\x1b[6~";
-      case "delete": return "\x1b[3~";
-      case "insert": return "\x1b[2~";
-      default: return ch || null;
+    if (agentViewController) {
+      agentViewController.enterAgentDashboardMode();
     }
   }
 
   // Dashboard navigation - use screen.on to capture even when input is focused
   screen.on("keypress", (ch, key) => {
     // Agent TTY view: handle keystrokes
-    if (currentView === "agent") {
+    if (getCurrentView() === "agent") {
       if (focusMode === "dashboard") {
         handleDashboardKey(key);
         return;
       }
-      // Suppress input briefly after entering agent view (prevents Enter
-      // leak from dashboard selection and terminal query responses like CPR)
-      if (Date.now() < agentInputSuppressUntil) {
+      // Suppress input briefly after entering agent view
+      if (Date.now() < getAgentInputSuppressUntil()) {
         return;
       }
       // Ctrl+C exits entire app
@@ -3258,7 +1327,7 @@ async function runChat(projectRoot) {
   });
 
   screen.key(["tab"], () => {
-    if (currentView === "agent") return; // Tab goes to PTY via keypress handler
+    if (getCurrentView() === "agent") return; // Tab goes to PTY via keypress handler
     if (focusMode === "dashboard") {
       exitDashboardMode(false);
     } else {
@@ -3267,13 +1336,13 @@ async function runChat(projectRoot) {
   });
 
   screen.key(["C-k", "M-k"], () => {
-    if (currentView === "agent") return;
+    if (getCurrentView() === "agent") return;
     clearLog();
   });
 
 
   screen.key(["i", "enter"], () => {
-    if (currentView === "agent") return;
+    if (getCurrentView() === "agent") return;
     if (focusMode === "dashboard") return;
     if (screen.focused === input) return;
     focusInput();
@@ -3292,43 +1361,7 @@ async function runChat(projectRoot) {
   }
   if (screen.program) {
     screen.program.on("data", (data) => {
-      if (screen.focused !== input || focusMode !== "input") return;
-      const chunk = data.toString("utf8");
-      if (!pasteActive && !chunk.includes(PASTE_START) && !pasteRemainder.includes(PASTE_START)) {
-        const keep = PASTE_START.length - 1;
-        pasteRemainder = (pasteRemainder + chunk).slice(-keep);
-        return;
-      }
-      let buffer = pasteRemainder + chunk;
-      pasteRemainder = "";
-      while (buffer.length > 0) {
-        if (!pasteActive) {
-          const start = buffer.indexOf(PASTE_START);
-          if (start === -1) {
-            const keep = PASTE_START.length - 1;
-            pasteRemainder = buffer.slice(-keep);
-            return;
-          }
-          buffer = buffer.slice(start + PASTE_START.length);
-          pasteActive = true;
-          pasteBuffer = "";
-          scheduleSuppressReset();
-          continue;
-        }
-        const end = buffer.indexOf(PASTE_END);
-        if (end === -1) {
-          pasteBuffer += buffer;
-          scheduleSuppressReset();
-          return;
-        }
-        pasteBuffer += buffer.slice(0, end);
-        buffer = buffer.slice(end + PASTE_END.length);
-        pasteActive = false;
-        scheduleSuppressReset();
-        const normalized = normalizePaste(pasteBuffer);
-        pasteBuffer = "";
-        if (normalized) insertTextAtCursor(normalized);
-      }
+      pasteController.handleProgramData(data);
     });
   }
   loadHistory();
@@ -3339,24 +1372,19 @@ async function runChat(projectRoot) {
 
   // 定期刷新 dashboard 状态（兜底，daemon 会主动推送变化）
   setInterval(() => {
-    if (client && !client.destroyed) {
+    if (daemonCoordinator && daemonCoordinator.isConnected()) {
       requestStatus();
     }
   }, 30000);
-
   screen.on("resize", () => {
-    if (currentView === "agent") {
-      // Update scroll region and agent PTY size for new terminal dimensions
-      const rows = process.stdout.rows || 24;
-      const cols = process.stdout.columns || 80;
-      process.stdout.write(`\x1b[1;${rows - 1}r`);
-      sendResizeToAgent(cols, rows - 1);
-      renderAgentDashboard();
+    if (handleResizeInAgentView()) {
       return;
     }
     resizeInput();
-    if (completionActive) hideCompletion();
+    if (completionController.isActive()) completionController.hide();
     input._updateCursor();
+    // Force recalculate logBox width to match terminal
+    logBox.width = screen.width;
     screen.render();
   });
   screen.render();