u-foo 1.0.3 → 1.1.9

package/src/chat/index.js

@@ -1,534 +1,269 @@
-const net = require("net");
 const path = require("path");
 const blessed = require("blessed");
-const { spawn, spawnSync } = 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 AgentActivator = require("../bus/activate");
+const { subscriberToSafeName } = require("../bus/utils");
+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");
 
-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) {
-  const daemonBin = resolveProjectFile(projectRoot, path.join("bin", "ufoo.js"), path.join("bin", "ufoo.js"));
-  const child = spawn(process.execPath, [daemonBin, "daemon", "--start"], {
-    detached: true,
-    stdio: "ignore",
-    cwd: projectRoot,
-  });
-  child.unref();
-}
+async function runChat(projectRoot) {
+  if (!fs.existsSync(getUfooPaths(projectRoot).ufooDir)) {
+    const repoRoot = path.join(__dirname, "..", "..");
+    const init = new UfooInit(repoRoot);
+    await init.init({ modules: "context,bus", project: projectRoot });
+  }
 
-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,
-  });
-}
+  // Ensure subscriber ID exists for chat (persistent across restarts)
+  if (!process.env.UFOO_SUBSCRIBER_ID) {
+    const crypto = require("crypto");
+    const sessionFile = path.join(getUfooPaths(projectRoot).ufooDir, "chat", "session-id.txt");
+    const sessionDir = path.dirname(sessionFile);
+    fs.mkdirSync(sessionDir, { recursive: true });
 
-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));
+    let sessionId;
+    if (fs.existsSync(sessionFile)) {
+      sessionId = fs.readFileSync(sessionFile, "utf8").trim();
+    } else {
+      sessionId = crypto.randomBytes(4).toString("hex");
+      fs.writeFileSync(sessionFile, sessionId, "utf8");
     }
+    // Chat 模式默认使用 claude-code 类型
+    process.env.UFOO_SUBSCRIBER_ID = `claude-code:${sessionId}`;
   }
-  return null;
-}
 
-async function runChat(projectRoot) {
-  if (!fs.existsSync(path.join(projectRoot, ".ufoo"))) {
-    const initScript = resolveProjectFile(projectRoot, path.join("scripts", "init.sh"), path.join("scripts", "init.sh"));
-    spawnSync("bash", [initScript, "--modules", "context,bus", "--project", projectRoot], {
-      stdio: "inherit",
-    });
-  }
   if (!isRunning(projectRoot)) {
     startDaemon(projectRoot);
   }
 
-  const daemonBin = resolveProjectFile(projectRoot, path.join("bin", "ufoo.js"), path.join("bin", "ufoo.js"));
   const sock = socketPath(projectRoot);
-  let client = null;
-
-  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);
-      }
-      newClient = await connectWithRetry(sock, 50, 200);
-    }
-    return newClient;
-  };
-
-  client = await connectClient();
-  if (!client) {
-    // Check if daemon failed to start
-    if (!isRunning(projectRoot)) {
-      const logFile = path.join(projectRoot, ".ufoo", "run", "ufoo-daemon.log");
-      // 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,
-    // Allow terminal native copy by not fully grabbing mouse
-    // Hold Option/Alt to use native selection in most terminals
-    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,
   });
 
   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: { ch: "│", style: { fg: "cyan" } },
-    keys: true,
-    vi: true,
-    // Enable mouse wheel scrolling in log area (use Option/Alt for native selection)
-    mouse: true,
-  });
-
-  // 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(projectRoot, ".ufoo", "chat");
+  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) {
-    return SPACED_TYPES.has(type);
-  }
+  const chatLogController = createChatLogController({
+    logBox,
+    fsModule: fs,
+    historyDir,
+    historyFile,
+  });
 
-  function writeSpacer(writeHistory) {
-    if (lastLogWasSpacer || !hasLoggedAny) return;
-    logBox.log(" ");
-    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) {
-    if (type !== "spacer" && shouldSpace(type)) {
-      writeSpacer(writeHistory);
-    }
-    logBox.log(text);
-    if (writeHistory) {
-      appendHistory({
-        ts: new Date().toISOString(),
-        type,
-        text,
-        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);
+    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) {
-          logBox.log(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;
-
-  function formatProcessingText(text) {
-    if (!text) return text;
-    if (text.includes("{")) return text;
-    if (!/processing/i.test(text)) return text;
-    return `{yellow-fg}⏳{/yellow-fg} ${text}`;
-  }
-
-  function renderStatusLine() {
-    let content = primaryStatusText || "";
-    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 setPrimaryStatus(text) {
-    primaryStatusText = text || "";
-    renderStatusLine();
+    if (!inputHistoryController) return;
+    inputHistoryController.loadInputHistory(limit);
   }
 
-  function queueStatusLine(text) {
-    const formatted = formatProcessingText(text);
-    pendingStatusLines.push(formatted);
-    if (pendingStatusLines.length === 1) {
-      setPrimaryStatus(formatted);
-      screen.render();
-    }
-  }
-
-  function resolveStatusLine(text) {
-    if (pendingStatusLines.length > 0) {
-      pendingStatusLines.shift();
-    }
-    if (pendingStatusLines.length > 0) {
-      setPrimaryStatus(pendingStatusLines[0]);
-    } else {
-      setPrimaryStatus(text || "");
-    }
-    screen.render();
-  }
-
-  function enqueueBusStatus(item) {
-    if (!item || !item.text) return;
-    const key = item.key || item.text;
-    const formatted = formatProcessingText(item.text);
-    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 key = item.key || item.text;
-    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,
-    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,
-  });
-
-  // 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" },
+  const statusLineController = createStatusLineController({
+    statusLine,
+    bannerText,
+    renderScreen: () => screen.render(),
   });
 
-  // Prompt indicator
-  const promptBox = blessed.box({
-    parent: screen,
-    bottom: 2,
-    left: 0,
-    width: 2,
-    height: currentInputHeight - 3,
-    content: ">",
-    style: { fg: "cyan" },
-  });
-
-  // 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;
 
-  // 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() {
+    return inputMath.getWrapWidth(input, getInnerWidth());
   }
 
-  // Count lines considering both wrapping and newlines
   function countLines(text, width) {
-    if (width <= 0) return 1;
-    const lines = text.split("\n");
-    let total = 0;
-    for (const line of lines) {
-      const lineWidth = input.strWidth(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 lines = before.split("\n");
-    let row = 0;
-    for (let i = 0; i < lines.length - 1; i++) {
-      const lineWidth = input.strWidth(lines[i]);
-      row += Math.max(1, Math.ceil(lineWidth / width));
-    }
-    const lastLine = lines[lines.length - 1] || "";
-    const lastWidth = input.strWidth(lastLine);
-    row += Math.floor(lastWidth / width);
-    const col = lastWidth % width;
-    return { row, col };
-  }
-
-  function getLinePosForCol(line, targetCol) {
-    if (targetCol <= 0) return 0;
-    let col = 0;
-    let offset = 0;
-    for (const ch of Array.from(line)) {
-      const w = input.strWidth(ch);
-      if (col + w > targetCol) return offset;
-      col += w;
-      offset += ch.length;
-    }
-    return offset;
+    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 = input.strWidth(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 + getLinePosForCol(line, visualCol);
+    return inputMath.getCursorPosForRowCol(
+      text,
+      targetRow,
+      targetCol,
+      width,
+      (value) => input.strWidth(value),
+    );
+  }
+
+  function ensureInputCursorVisible() {
+    const innerWidth = getInnerWidth();
+    if (innerWidth <= 0) return;
+    const totalRows = countLines(input.value, innerWidth);
+    const visibleRows = Math.max(1, input.height || 1);
+    const { row } = getCursorRowCol(input.value, cursorPos, innerWidth);
+    let base = input.childBase || 0;
+    const maxBase = Math.max(0, totalRows - visibleRows);
+    const bottomMargin = visibleRows > 1 ? 1 : 0;
+    const upperLimit = base;
+    const lowerLimit = base + visibleRows - bottomMargin - 1;
+
+    if (row < upperLimit) {
+      base = row;
+    } else if (row > lowerLimit) {
+      base = row - (visibleRows - bottomMargin - 1);
+    }
+
+    if (base > maxBase) base = maxBase;
+    if (base < 0) base = 0;
+    if (base !== input.childBase) {
+      input.childBase = base;
+      if (typeof input.scrollTo === "function") {
+        input.scrollTo(base);
       }
-      pos += line.length + 1;
-      row += wrappedRows;
     }
-    return text.length;
   }
 
   function resetPreferredCol() {
     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() {
@@ -547,6 +282,7 @@ async function runChat(projectRoot) {
     normalizeCommandPrefix();
     resetPreferredCol();
     resizeInput();
+    ensureInputCursorVisible();
     input._updateCursor();
     screen.render();
     updateDraftFromInput();
@@ -557,266 +293,113 @@ async function runChat(projectRoot) {
     cursorPos = input.value.length;
     resetPreferredCol();
     resizeInput();
+    ensureInputCursorVisible();
     input._updateCursor();
     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() {
+    if (daemonCoordinator) {
+      daemonCoordinator.markExit();
+    }
+    cronScheduler.stopAll();
+    exitAgentView();
     if (screen && screen.program && typeof screen.program.decrst === "function") {
       screen.program.decrst(2004);
     }
-    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 = [];
-
-    if ((parts.length > 1 || (endsWithSpace && parts.length === 1)) && parts[0].startsWith("/")) {
-      // Subcommand mode: "/bus rename"
-      const mainCmd = parts[0];
-      const subFilter = parts[1] || "";
-
-      // Find the main command
-      const mainCmdObj = COMMAND_REGISTRY.find(item =>
-        item.cmd.toLowerCase() === mainCmd.toLowerCase()
-      );
-
-      if (mainCmdObj && mainCmdObj.subcommands) {
-        // Filter subcommands
-        commands = mainCmdObj.subcommands
-          .filter(sub => sub.cmd.toLowerCase().startsWith(subFilter.toLowerCase()))
-          .map(sub => ({ ...sub, isSubcommand: true, parentCmd: mainCmd }));
-      }
-    } else {
-      // Main command mode: "/bus"
-      const prefixMatches = COMMAND_REGISTRY.filter(item =>
-        item.cmd.toLowerCase().startsWith(filterText.toLowerCase())
-      );
-      // Also allow fuzzy matches on the command body (e.g. "/b" -> /bus + /ubus)
-      let fuzzyMatches = [];
-      if (filterText.startsWith("/") && parts.length === 1) {
-        const needle = filterText.slice(1).toLowerCase();
-        if (needle) {
-          fuzzyMatches = COMMAND_REGISTRY.filter(item =>
-            item.cmd.toLowerCase().includes(needle)
-          );
-        }
-      }
-      const merged = new Map();
-      for (const item of prefixMatches) merged.set(item.cmd, item);
-      for (const item of fuzzyMatches) merged.set(item.cmd, item);
-      commands = Array.from(merged.values());
-    }
-
-    if (commands.length === 0) {
-      hideCompletion();
-      return;
-    }
-
-    completionCommands = commands;
-    completionActive = true;
-    completionIndex = 0;
-    completionScrollOffset = 0;
-
-    // Calculate panel height (max 8 visible + 1 for top border)
-    const visibleItems = Math.min(8, completionCommands.length);
-    completionPanel.height = visibleItems + 1;
-    completionPanel.bottom = currentInputHeight - 1;
-    completionPanel.hidden = false;
-
-    renderCompletionPanel();
-  }
-
-  function hideCompletion() {
-    completionActive = false;
-    completionCommands = [];
-    completionIndex = 0;
-    completionScrollOffset = 0;
-    completionPanel.hidden = true;
-    screen.render();
-  }
-
-  function renderCompletionPanel() {
-    if (!completionActive || completionCommands.length === 0) return;
-
-    const maxVisible = 8;
-
-    // Adjust scroll offset to keep selected item visible
-    if (completionIndex < completionScrollOffset) {
-      completionScrollOffset = completionIndex;
-    } else if (completionIndex >= completionScrollOffset + maxVisible) {
-      completionScrollOffset = completionIndex - maxVisible + 1;
-    }
-
-    // Calculate visible slice
-    const visibleStart = completionScrollOffset;
-    const visibleEnd = Math.min(completionScrollOffset + maxVisible, completionCommands.length);
-    const visibleCommands = completionCommands.slice(visibleStart, visibleEnd);
-
-    const lines = visibleCommands.map((item, i) => {
-      const actualIndex = visibleStart + i;
-      const cmdPart = actualIndex === completionIndex
-        ? `{inverse}${item.cmd}{/inverse}`
-        : `{cyan-fg}${item.cmd}{/cyan-fg}`;
-      const descPart = `{gray-fg}${item.desc}{/gray-fg}`;
-      // Use promptBox width (2) to align with input position
-      const indent = " ".repeat(promptBox.width || 2);
-      return `${indent}${cmdPart}  ${descPart}`;
-    });
-
-    completionPanel.setContent(lines.join("\n"));
-    screen.render();
-  }
-
-  function completionUp() {
-    if (completionCommands.length === 0) return;
-    completionIndex = completionIndex <= 0
-      ? completionCommands.length - 1
-      : completionIndex - 1;
-    renderCompletionPanel();
-  }
-
-  function completionDown() {
-    if (completionCommands.length === 0) return;
-    completionIndex = completionIndex >= completionCommands.length - 1
-      ? 0
-      : completionIndex + 1;
-    renderCompletionPanel();
-  }
-
-  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();
-  }
+  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(),
+  });
 
-  function handleCompletionKey(ch, key) {
-    if (!completionActive) return false;
+  const pasteController = createPasteController({
+    shouldHandle: () => screen.focused === input && focusMode === "input",
+    normalizePaste,
+    insertTextAtCursor,
+  });
 
-    if (key.name === "up") {
-      completionUp();
-      return true;
-    }
-    if (key.name === "down") {
-      completionDown();
-      return true;
-    }
-    if (key.name === "tab") {
-      confirmCompletion();
-      return true;
-    }
-    if (key.name === "enter" || key.name === "return") {
-      // Enter submits input, doesn't confirm completion
-      hideCompletion();
-      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;
-  }
+  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,
+  });
 
   // Resize input box based on content
   function resizeInput() {
-    const innerWidth = getInnerWidth();
+    const innerWidth = getWrapWidth();
     if (innerWidth <= 0) return;
 
     const numLines = countLines(input.value, innerWidth);
@@ -831,221 +414,31 @@ async function runChat(projectRoot) {
     }
     statusLine.bottom = currentInputHeight;
     // Reposition completion panel if active
-    if (completionActive) {
-      completionPanel.bottom = currentInputHeight - 1;
-    }
+    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();
   }
 
   // Override the internal listener to support cursor movement
   input._listener = function(ch, key) {
-    if (key && key.ctrl && key.name === "c") {
-      exitHandler();
-      return;
-    }
-    if (suppressKeypress) {
-      return;
-    }
-    normalizeCommandPrefix();
-    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;
-    }
-    if (focusMode === "dashboard") {
-      if (handleDashboardKey(key)) return;
-      return;
-    }
-
-    // Command completion mode
-    if (completionActive) {
-      if (handleCompletionKey(ch, key)) 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();
-      this._updateCursor();
-      this.screen.render();
-      return;
-    }
-
-    if (key.name === "right") {
-      if (cursorPos < this.value.length) cursorPos++;
-      resetPreferredCol();
-      this._updateCursor();
-      this.screen.render();
-      return;
-    }
-
-    if (key.name === "home") {
-      cursorPos = 0;
-      resetPreferredCol();
-      this._updateCursor();
-      this.screen.render();
-      return;
-    }
-
-    if (key.name === "end") {
-      cursorPos = this.value.length;
-      resetPreferredCol();
-      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 = getInnerWidth();
-      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);
-      }
-      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();
-        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();
-        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;
-    }
+    inputListenerController.handleKey(ch, key, this);
   };
 
   // Override cursor update to use our cursor position
   input._updateCursor = function() {
     if (this.screen.focused !== this) return;
 
-    const lpos = this._getCoords();
+    let lpos;
+    try { lpos = this._getCoords(); } catch { return; }
     if (!lpos) return;
 
-    const innerWidth = getInnerWidth();
+    const innerWidth = getWrapWidth();
     if (innerWidth <= 0) return;
 
+    ensureInputCursorVisible();
     const { row, col } = getCursorRowCol(this.value, cursorPos, innerWidth);
-    const innerHeight = this.height || 1;
-
-    let scrollOffset = this.childBase || 0;
-    if (row < scrollOffset) {
-      scrollOffset = row;
-    } else if (row >= scrollOffset + innerHeight) {
-      scrollOffset = row - innerHeight + 1;
-    }
-    if (scrollOffset !== this.childBase) {
-      this.childBase = scrollOffset;
-      if (typeof this.scrollTo === "function") {
-        this.scrollTo(scrollOffset);
-      }
-    }
+    const scrollOffset = this.childBase || 0;
 
     const displayRow = row - scrollOffset;
     const safeCol = Math.min(Math.max(0, col), innerWidth - 1);
@@ -1062,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;
@@ -1074,95 +466,283 @@ async function runChat(projectRoot) {
     return originalClearValue();
   };
 
-  let pending = null;
+  let pending = null;
+
+  // 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 = 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" | "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" },
+  ];
+  let selectedProviderIndex = agentProvider === "claude-cli" ? 1 : 0;
+  const assistantOptions = [
+    { label: "auto", value: "auto" },
+    { label: "codex", value: "codex" },
+    { label: "claude", value: "claude" },
+    { label: "ufoo", value: "ufoo" },
+  ];
+  let selectedAssistantIndex = Math.max(
+    0,
+    assistantOptions.findIndex((opt) => opt.value === assistantEngine)
+  );
+  const resumeOptions = [
+    { label: "Resume previous session", value: true },
+    { label: "Start new session", value: false },
+  ];
+  let selectedResumeIndex = autoResume ? 0 : 1;
+  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 getCurrentView() {
+    return agentViewController ? agentViewController.getCurrentView() : "main";
+  }
+
+  function getViewingAgent() {
+    return agentViewController ? agentViewController.getViewingAgent() : "";
+  }
+
+  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 getViewingAgentAdapter() {
+    const viewingAgent = getViewingAgent();
+    if (!viewingAgent) return null;
+    return getAgentAdapter(viewingAgent);
+  }
+
+  function canSendRaw(adapter) {
+    if (!adapter || !adapter.capabilities) return false;
+    return Boolean(
+      adapter.capabilities.supportsSocketProtocol
+      || adapter.capabilities.supportsInternalQueueLoop
+    );
+  }
+
+  function canResize(adapter) {
+    return Boolean(adapter && adapter.capabilities && adapter.capabilities.supportsSocketProtocol);
+  }
+
+  function canSnapshot(adapter) {
+    if (!adapter || !adapter.capabilities) return false;
+    return Boolean(
+      adapter.capabilities.supportsSnapshot
+      || adapter.capabilities.supportsSubscribeScreen
+      || adapter.capabilities.supportsSubscribeFull
+    );
+  }
+
+  function sendRawWithCapabilities(data) {
+    const adapter = getViewingAgentAdapter();
+    if (!canSendRaw(adapter)) return;
+    try {
+      adapter.sendRaw(data);
+    } catch {
+      // ignore unsupported errors
+    }
+  }
+
+  function sendResizeWithCapabilities(cols, rows) {
+    const adapter = getViewingAgentAdapter();
+    if (!canResize(adapter)) return;
+    try {
+      adapter.resize(cols, rows);
+    } catch {
+      // ignore unsupported errors
+    }
+  }
+
+  function requestSnapshotWithCapabilities() {
+    const adapter = getViewingAgentAdapter();
+    if (!canSnapshot(adapter)) return false;
+    try {
+      return adapter.snapshot();
+    } catch {
+      return false;
+    }
+  }
+
+  function isAgentViewUsesBus() {
+    return agentViewController ? agentViewController.isAgentViewUsesBus() : false;
+  }
+
+  function getAgentInputSuppressUntil() {
+    return agentViewController ? agentViewController.getAgentInputSuppressUntil() : 0;
+  }
+
+  function getAgentOutputSuppressed() {
+    return agentViewController ? agentViewController.getAgentOutputSuppressed() : false;
+  }
+
+  function setAgentOutputSuppressed(value) {
+    if (agentViewController) {
+      agentViewController.setAgentOutputSuppressed(value);
+    }
+  }
+
+  function renderAgentDashboard() {
+    if (agentViewController) {
+      agentViewController.renderAgentDashboard();
+    }
+  }
+
+  function setAgentBarVisible(visible) {
+    if (agentViewController) {
+      agentViewController.setAgentBarVisible(visible);
+    }
+  }
+
+  function enterAgentView(agentId, options = {}) {
+    if (agentViewController) {
+      agentViewController.enterAgentView(agentId, options);
+    }
+  }
+
+  function exitAgentView() {
+    if (agentViewController) {
+      agentViewController.exitAgentView();
+    }
+  }
+
+  function sendRawToAgent(data) {
+    if (agentViewController) {
+      agentViewController.sendRawToAgent(data);
+    }
+  }
+
+  function sendResizeToAgent(cols, rows) {
+    if (agentViewController) {
+      agentViewController.sendResizeToAgent(cols, rows);
+    }
+  }
+
+  function requestAgentSnapshot() {
+    if (agentViewController) {
+      agentViewController.requestAgentSnapshot();
+    }
+  }
+
+  function writeToAgentTerm(text) {
+    if (agentViewController) {
+      agentViewController.writeToAgentTerm(text);
+    }
+  }
 
-  // Command completion state
-  let completionActive = false;
-  let completionCommands = [];
-  let completionIndex = 0;
-  let completionScrollOffset = 0;
-
-  const COMMAND_REGISTRY = [
-    { cmd: "/doctor", desc: "Health check diagnostics" },
-    { cmd: "/status", desc: "Status display" },
-    {
-      cmd: "/daemon",
-      desc: "Daemon management",
-      subcommands: [
-        { cmd: "start", desc: "Start daemon" },
-        { cmd: "stop", desc: "Stop daemon" },
-        { cmd: "restart", desc: "Restart daemon" },
-        { cmd: "status", desc: "Daemon status" },
-      ]
-    },
-    { cmd: "/init", desc: "Initialize modules" },
-    {
-      cmd: "/bus",
-      desc: "Event bus operations",
-      subcommands: [
-        { cmd: "send", desc: "Send message to agent" },
-        { cmd: "rename", desc: "Rename agent nickname" },
-        { cmd: "list", desc: "List all agents" },
-        { cmd: "status", desc: "Bus status" },
-      ]
-    },
-    { cmd: "/ctx", desc: "Context management" },
-    { cmd: "/skills", desc: "Skills management" },
-    { cmd: "/ubus", desc: "Check bus messages" },
-    { cmd: "/uctx", desc: "Context status" },
-    { cmd: "/uinit", desc: "Initialize/repair" },
-    { cmd: "/ustatus", desc: "Unified status" },
-  ];
+  function placeAgentCursor(cursor) {
+    if (agentViewController) {
+      agentViewController.placeAgentCursor(cursor);
+    }
+  }
 
-  // Agent selection state
-  let activeAgents = [];
-  let activeAgentLabelMap = new Map();
-  let agentListWindowStart = 0;
-  const MAX_AGENT_WINDOW = 5;
-  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" or "mode"
-  let selectedModeIndex = launchMode === "internal" ? 1 : 0;
-  const providerOptions = [
-    { label: "codex", value: "codex-cli" },
-    { label: "claude", value: "claude-cli" },
-  ];
-  let selectedProviderIndex = agentProvider === "claude-cli" ? 1 : 0;
-  let restartInProgress = false;
+  function handleResizeInAgentView() {
+    if (!agentViewController) return false;
+    return agentViewController.handleResizeInAgentView();
+  }
 
   function getAgentLabel(agentId) {
-    return activeAgentLabelMap.get(agentId) || agentId;
+    return agentDirectory.getAgentLabel(activeAgentLabelMap, agentId);
+  }
+
+  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
+        }
+        return null;
+      },
+    });
+  }
+
+  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 clampAgentWindowWithSelection(selectionIndex) {
+    agentListWindowStart = agentDirectory.clampAgentWindowWithSelection({
+      activeCount: activeAgents.length,
+      maxWindow: MAX_AGENT_WINDOW,
+      windowStart: agentListWindowStart,
+      selectionIndex,
+    });
   }
 
   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;
+    clampAgentWindowWithSelection(selectedAgentIndex);
   }
 
   function send(req) {
-    if (!client || client.destroyed) return;
-    client.write(`${JSON.stringify(req)}\n`);
+    if (!daemonCoordinator) return;
+    daemonCoordinator.send(req);
   }
 
+  cronScheduler = createCronScheduler({
+    dispatch: ({ taskId, target, message }) => {
+      send({
+        type: IPC_REQUEST_TYPES.BUS_SEND,
+        target,
+        message,
+      });
+      queueStatusLine(`cron:${taskId} -> ${target}`);
+    },
+    onChange: () => {
+      renderDashboard();
+      screen.render();
+    },
+  });
+
   function updatePromptBox() {
     if (targetAgent) {
       const label = getAgentLabel(targetAgent);
-      promptBox.setContent(`@${label}>`);
-      promptBox.width = label.length + 3;  // @name>
+      promptBox.setContent(`>@${label}`);
+      promptBox.width = label.length + 3;  // >@name + spacer
       input.left = promptBox.width;
       input.width = `100%-${promptBox.width}`;
     } else {
@@ -1171,8 +751,34 @@ async function runChat(projectRoot) {
       input.left = 2;
       input.width = "100%-2";
     }
+    if (!input.parent || !promptBox.parent) return;
     resizeInput();
-    input._updateCursor();
+    if (typeof input._updateCursor === "function") {
+      input._updateCursor();
+    }
+  }
+
+  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();
+      }
+    } else if (targetAgent) {
+      targetAgent = null;
+      updatePromptBox();
+      screen.render();
+    }
+  }
+
+  function restoreTargetFromSelection() {
+    if (selectedAgentIndex >= 0 && selectedAgentIndex < activeAgents.length) {
+      targetAgent = activeAgents[selectedAgentIndex];
+      updatePromptBox();
+    }
   }
 
   function focusInput() {
@@ -1190,60 +796,90 @@ async function runChat(projectRoot) {
     screen.render();
   }
 
+  let settingsController = null;
+
   function setLaunchMode(mode) {
-    const next = normalizeLaunchMode(mode);
-    if (next === launchMode) return;
-    launchMode = next;
-    selectedModeIndex = launchMode === "internal" ? 1 : 0;
-    saveConfig(projectRoot, { launchMode });
-    logMessage("status", `{magenta-fg}⚙{/magenta-fg} Launch mode: ${launchMode}`);
-    renderDashboard();
-    screen.render();
+    if (settingsController) {
+      settingsController.setLaunchMode(mode);
+    }
   }
 
-  function providerLabel(value) {
-    return value === "claude-cli" ? "claude" : "codex";
+  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 });
   }
 
   function setAgentProvider(provider) {
-    const next = normalizeAgentProvider(provider);
-    if (next === agentProvider) return;
-    agentProvider = next;
-    selectedProviderIndex = agentProvider === "claude-cli" ? 1 : 0;
-    saveConfig(projectRoot, { agentProvider });
-    logMessage("status", `{magenta-fg}⚙{/magenta-fg} ufoo-agent: ${providerLabel(agentProvider)}`);
-    renderDashboard();
-    screen.render();
-    void restartDaemon();
+    if (settingsController) {
+      settingsController.setAgentProvider(provider);
+    }
   }
 
-  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);
-      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 setAssistantEngine(value) {
+    if (settingsController) {
+      settingsController.setAssistantEngine(value);
     }
   }
 
+  function setAutoResume(value) {
+    if (settingsController) {
+      settingsController.setAutoResume(value);
+    }
+  }
+
+  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,
+    getAutoResume: () => autoResume,
+    setAutoResumeState: (value) => {
+      autoResume = value;
+    },
+    setSelectedResumeIndex: (value) => {
+      selectedResumeIndex = value;
+    },
+  });
+
   function clearLog() {
     logBox.setContent("");
     if (typeof logBox.scrollTo === "function") {
@@ -1253,89 +889,76 @@ async function runChat(projectRoot) {
   }
 
   function renderDashboard() {
-    let content = " ";
-    if (focusMode === "dashboard") {
-      if (dashboardView === "mode") {
-        const modes = ["terminal", "internal"];
-        const modeParts = modes.map((mode, i) => {
-          if (i === selectedModeIndex) {
-            return `{inverse}${mode}{/inverse}`;
-          }
-          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}`;
-          }
-          return `{cyan-fg}${opt.label}{/cyan-fg}`;
-        });
-        content += `{gray-fg}Agent:{/gray-fg} ${providerParts.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, ↓ 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) => getAgentLabel(id)).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}`;
-    }
-    dashboard.setContent(content);
+    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);
   }
 
   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 : [];
-    activeAgentLabelMap = new Map();
     let fallbackMap = null;
     if (metaList.length === 0 && activeAgents.length > 0) {
       try {
-        const busPath = path.join(projectRoot, ".ufoo", "bus", "bus.json");
+        const busPath = getUfooPaths(projectRoot).agentsFile;
         const bus = JSON.parse(fs.readFileSync(busPath, "utf8"));
         fallbackMap = new Map();
-        for (const [id, meta] of Object.entries(bus.subscribers || {})) {
+        for (const [id, meta] of Object.entries(bus.agents || {})) {
           if (meta && meta.nickname) fallbackMap.set(id, meta.nickname);
         }
       } catch {
         fallbackMap = null;
       }
     }
-    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);
-    }
+    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;
+    }
+
+    // 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;
+    }
     if (focusMode === "dashboard") {
       if (dashboardView === "agents") {
         if (activeAgents.length === 0) {
@@ -1346,6 +969,7 @@ async function runChat(projectRoot) {
         clampAgentWindow();
       }
     }
+    syncTargetFromSelection();
     renderDashboard();
     screen.render();
   }
@@ -1356,120 +980,96 @@ async function runChat(projectRoot) {
     selectedAgentIndex = activeAgents.length > 0 ? 0 : -1;
     agentListWindowStart = 0;
     clampAgentWindow();
-    selectedModeIndex = launchMode === "internal" ? 1 : 0;
+    selectedModeIndex = launchMode === "internal" ? 2 : (launchMode === "tmux" ? 1 : 0);
     selectedProviderIndex = agentProvider === "claude-cli" ? 1 : 0;
+    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();
   }
 
-  function handleDashboardKey(key) {
-    if (!key || focusMode !== "dashboard") return false;
-    if (dashboardView === "mode") {
-      if (key.name === "left") {
-        selectedModeIndex = selectedModeIndex <= 0 ? 1 : 0;
-        renderDashboard();
-        screen.render();
-        return true;
-      }
-      if (key.name === "right") {
-        selectedModeIndex = selectedModeIndex >= 1 ? 0 : 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";
-        renderDashboard();
-        screen.render();
-        return true;
-      }
-      if (key.name === "enter" || key.name === "return") {
-        const modes = ["terminal", "internal"];
-        setLaunchMode(modes[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 === "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;
-    }
+  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); },
+    },
+  });
 
-    if (key.name === "left") {
-      if (activeAgents.length > 0 && selectedAgentIndex > 0) {
-        selectedAgentIndex--;
-        clampAgentWindow();
-        renderDashboard();
-        screen.render();
-      }
-      return true;
-    }
-    if (key.name === "right") {
-      if (activeAgents.length > 0 && selectedAgentIndex < activeAgents.length - 1) {
-        selectedAgentIndex++;
-        clampAgentWindow();
-        renderDashboard();
-        screen.render();
-      }
-      return true;
-    }
-    if (key.name === "down") {
-      dashboardView = "mode";
-      selectedModeIndex = launchMode === "internal" ? 1 : 0;
-      renderDashboard();
-      screen.render();
-      return true;
-    }
-    if (key.name === "up" || key.name === "escape") {
-      exitDashboardMode(false);
-      return true;
-    }
-    if (key.name === "enter" || key.name === "return") {
-      exitDashboardMode(true);
-      return true;
-    }
-    return false;
+  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) {
@@ -1492,199 +1092,240 @@ async function runChat(projectRoot) {
     screen.render();
   }
 
-  function requestStatus() {
-    send({ type: "status" });
+  function getInjectSockPath(agentId) {
+    const safeName = subscriberToSafeName(agentId);
+    return path.join(getUfooPaths(projectRoot).busQueuesDir, safeName, "inject.sock");
   }
 
-  const detachClient = () => {
-    if (!client) return;
-    client.removeAllListeners("data");
-    client.removeAllListeners("close");
-    try {
-      client.end();
-      client.destroy();
-    } catch {
-      // ignore
-    }
-  };
+  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 attachClient = (newClient) => {
-    if (!newClient) return;
-    detachClient();
-    client = newClient;
-    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 text = data.text || "";
-            const item = { key: data.key, text };
-            if (data.phase === "start") {
-              enqueueBusStatus(item);
-            } else if (data.phase === "done" || data.phase === "error") {
-              resolveBusStatus(item);
-              if (text) {
-                const prefix = data.phase === "error"
-                  ? "{red-fg}✗{/red-fg}"
-                  : "{green-fg}✓{/green-fg}";
-                logMessage("status", `${prefix} ${text}`, data);
-              }
-            } else {
-              enqueueBusStatus(item);
-            }
-            screen.render();
-          } else {
-            updateDashboard(data);
-          }
-        } else if (msg.type === "response") {
-          const payload = msg.data || {};
-          if (payload.reply) {
-            resolveStatusLine(`{green-fg}←{/green-fg} ${payload.reply}`);
-            logMessage("reply", `{green-fg}←{/green-fg} ${payload.reply}`);
-          }
-          if (payload.dispatch && payload.dispatch.length > 0) {
-            logMessage("dispatch", `{blue-fg}→{/blue-fg} Dispatched to: ${payload.dispatch.map(d => d.target || d).join(", ")}`);
-          }
-          if (payload.disambiguate && Array.isArray(payload.disambiguate.candidates) && payload.disambiguate.candidates.length > 0) {
-            pending = { disambiguate: payload.disambiguate, original: pending?.original };
-            resolveStatusLine(`{yellow-fg}?{/yellow-fg} ${payload.disambiguate.prompt || "Choose target:"}`);
-            logMessage("disambiguate", `{yellow-fg}?{/yellow-fg} ${payload.disambiguate.prompt || "Choose target:"}`);
-            payload.disambiguate.candidates.forEach((c, i) => {
-              logMessage("disambiguate", `   {cyan-fg}${i + 1}){/cyan-fg} ${c.agent_id} {gray-fg}— ${c.reason || ""}{/gray-fg}`);
-            });
-          } else {
-            pending = null;
-          }
-          if (!payload.reply && !payload.disambiguate) {
-            resolveStatusLine("{gray-fg}✓{/gray-fg} Done");
-          }
-          if (msg.opsResults && msg.opsResults.length > 0) {
-            logMessage("ops", `{magenta-fg}⚡{/magenta-fg} ${JSON.stringify(msg.opsResults)}`);
-          }
-          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 || "";
-          try {
-            const parsed = JSON.parse(data.message);
-            if (parsed && typeof parsed === "object" && parsed.reply) {
-              displayMessage = parsed.reply;
-            }
-          } catch {
-            // Not JSON, use as-is
-          }
+  function requestStatus() {
+    if (!daemonCoordinator) return;
+    daemonCoordinator.requestStatus();
+  }
 
-          // Extract nickname if publisher is in subscriber:id format
-          let displayName = publisher;
-          if (publisher.includes(":")) {
-            // Try to get nickname from activeAgentLabelMap or bus.json
-            if (activeAgentLabelMap && activeAgentLabelMap.has(publisher)) {
-              displayName = activeAgentLabelMap.get(publisher);
-            } else {
-              // Fallback: read directly from bus.json
-              try {
-                const busPath = path.join(projectRoot, ".ufoo", "bus", "bus.json");
-                const bus = JSON.parse(fs.readFileSync(busPath, "utf8"));
-                const meta = bus.subscribers && bus.subscribers[publisher];
-                if (meta && meta.nickname) {
-                  displayName = meta.nickname;
-                }
-              } catch {
-                // Keep original publisher ID
-              }
-            }
-          }
+  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),
+  });
 
-          const line = `${prefix} {gray-fg}${displayName}{/gray-fg}: ${displayMessage}`;
-          logMessage("bus", line, data);
-          if (data.event === "agent_renamed") {
-            requestStatus();
-          }
-          screen.render();
-        } else if (msg.type === "error") {
-          resolveStatusLine(`{red-fg}✗{/red-fg} Error: ${msg.error}`);
-          logMessage("error", `{red-fg}✗{/red-fg} Error: ${msg.error}`);
-          screen.render();
-        }
-      } catch {
-        // ignore
-      }
+  daemonCoordinator = createDaemonCoordinator({
+    projectRoot,
+    daemonTransport,
+    handleMessage: (msg) => daemonMessageRouter.handleMessage(msg),
+    queueStatusLine,
+    resolveStatusLine,
+    logMessage,
+    stopDaemon,
+    startDaemon,
+  });
+
+  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.");
+  }
+
+  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);
+    },
   });
-    client.on("close", () => {
-      client = null;
-    });
-  };
 
-  attachClient(client);
+  async function executeCommand(text) {
+    return commandExecutor.executeCommand(text);
+  }
 
-  input.on("submit", (value) => {
-    const text = value.trim();
-    input.clearValue();
-    screen.render();
-    if (!text) {
-      input.focus();
-      return;
-    }
-    inputHistory.push(text);
-    appendInputHistory(text);
-    historyIndex = inputHistory.length;
-    historyDraft = "";
+  const submitState = {};
+  Object.defineProperties(submitState, {
+    targetAgent: { get: () => targetAgent, set: (value) => { targetAgent = value; } },
+    pending: { get: () => pending, set: (value) => { pending = value; } },
+    activeAgentMetaMap: { get: () => activeAgentMetaMap },
+  });
 
-    // If target agent is selected, send directly via bus
-    if (targetAgent) {
-      const label = getAgentLabel(targetAgent);
-      logMessage("user", `{cyan-fg}→{/cyan-fg} {magenta-fg}@${label}{/magenta-fg} ${text}`);
-      // Use bus send command
-      const { spawnSync } = require("child_process");
-      spawnSync("ufoo", ["bus", "send", targetAgent, text], { cwd: projectRoot });
-      clearTargetAgent();
-      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", "Invalid selection.");
-      }
-    } else {
-      pending = { original: text };
-      queueStatusLine("ufoo-agent processing");
-      send({ type: "prompt", text });
-      logMessage("user", `{cyan-fg}→{/cyan-fg} ${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() {
+    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 (getCurrentView() === "agent") {
+      if (focusMode === "dashboard") {
+        handleDashboardKey(key);
+        return;
+      }
+      // Suppress input briefly after entering agent view
+      if (Date.now() < getAgentInputSuppressUntil()) {
+        return;
+      }
+      // Ctrl+C exits entire app
+      if (key && key.ctrl && key.name === "c") {
+        return; // handled by screen.key(["C-c"])
+      }
+      // Down arrow: enter agents bar (same pattern as normal chat dashboard)
+      if (key && key.name === "down") {
+        enterAgentDashboardMode();
+        return;
+      }
+      // All other keys (including Esc) go to agent PTY
+      const raw = keyToRaw(ch, key);
+      if (raw) {
+        sendRawToAgent(raw);
+      }
+      return;
+    }
+
+    // Normal mode: dashboard key handling
     handleDashboardKey(key);
   });
 
   screen.key(["tab"], () => {
+    if (getCurrentView() === "agent") return; // Tab goes to PTY via keypress handler
     if (focusMode === "dashboard") {
       exitDashboardMode(false);
     } else {
@@ -1693,10 +1334,13 @@ async function runChat(projectRoot) {
   });
 
   screen.key(["C-k", "M-k"], () => {
+    if (getCurrentView() === "agent") return;
     clearLog();
   });
 
+
   screen.key(["i", "enter"], () => {
+    if (getCurrentView() === "agent") return;
     if (focusMode === "dashboard") return;
     if (screen.focused === input) return;
     focusInput();
@@ -1715,43 +1359,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();
@@ -1759,11 +1367,22 @@ async function runChat(projectRoot) {
   renderDashboard();
   resizeInput();
   requestStatus();
-  setInterval(requestStatus, 2000);
+
+  // 定期刷新 dashboard 状态（兜底，daemon 会主动推送变化）
+  setInterval(() => {
+    if (daemonCoordinator && daemonCoordinator.isConnected()) {
+      requestStatus();
+    }
+  }, 30000);
   screen.on("resize", () => {
+    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();