u-foo 2.3.32 → 2.4.1

package/src/ui/{components → ink}/ChatApp.js

@@ -1,11 +1,9 @@
 "use strict";
 
 /**
- * Ink-based chat TUI. Behaviourally equivalent to runChatBlessed in
- * src/chat/index.js but rendered via React + ink.
+ * Ink-based chat TUI rendered via React + ink.
  *
- * Activation: Ink is the default chat TUI. Set UFOO_TUI=blessed to use the
- * legacy blessed renderer while it remains available as a fallback.
+ * Activation: this is the only chat TUI.
  *
  * Coverage today: layout shell + dashboard bar (5 modes: projects, agents,
  * mode, provider, cron) + multiline editor + status line +
@@ -27,15 +25,15 @@ const { createDashboardBar } = require("./DashboardBar");
 const { reducer, createInitialState } = require("./chatReducer");
 
 function bootstrapEnvironment(projectRoot, options = {}) {
-  // Mirror of the early section of runChatBlessed: ensure ufoo dirs exist
-  // and that we have a stable subscriber ID. We deliberately keep the
+  // Ensure ufoo dirs exist and that we have a stable subscriber ID.
+  // We deliberately keep the
   // non-UI side-effects in their own helper so unit tests can assert on
   // them without importing ink.
-  const { canonicalProjectRoot } = require("../../projects");
-  const { getUfooPaths } = require("../../ufoo/paths");
-  const UfooInit = require("../../init");
-  const { isRunning } = require("../../daemon");
-  const { startDaemon } = require("../../chat/transport");
+  const { canonicalProjectRoot } = require("../../runtime/projects");
+  const { getUfooPaths } = require("../../coordination/state/paths");
+  const UfooInit = require("../../app/cli/features/init");
+  const { isRunning } = require("../../runtime/daemon");
+  const { startDaemon } = require("../../app/chat/transport");
 
   const globalMode = options && options.globalMode === true;
   let activeProjectRoot = projectRoot;
@@ -67,7 +65,7 @@ function bootstrapEnvironment(projectRoot, options = {}) {
 
 async function ensureSubscriberId(projectRoot) {
   if (process.env.UFOO_SUBSCRIBER_ID) return;
-  const { getUfooPaths } = require("../../ufoo/paths");
+  const { getUfooPaths } = require("../../coordination/state/paths");
   const sessionFile = path.join(getUfooPaths(projectRoot).ufooDir, "chat", "session-id.txt");
   const sessionDir = path.dirname(sessionFile);
   fs.mkdirSync(sessionDir, { recursive: true });
@@ -82,7 +80,7 @@ async function ensureSubscriberId(projectRoot) {
 }
 
 function inputHistoryFilePath(projectRoot, options = {}) {
-  const { getUfooPaths } = require("../../ufoo/paths");
+  const { getUfooPaths } = require("../../coordination/state/paths");
   const { globalMode } = options || {};
   if (globalMode) {
     const os = require("os");
@@ -95,7 +93,7 @@ function inputHistoryFilePath(projectRoot, options = {}) {
 }
 
 function chatHistoryFilePath(projectRoot, options = {}) {
-  const { getUfooPaths } = require("../../ufoo/paths");
+  const { getUfooPaths } = require("../../coordination/state/paths");
   const { globalMode } = options || {};
   if (globalMode) {
     const os = require("os");
@@ -109,13 +107,48 @@ function chatHistoryFilePath(projectRoot, options = {}) {
 
 function projectRootToId(projectRoot) {
   try {
-    const { buildProjectId } = require("../../projects");
+    const { buildProjectId } = require("../../runtime/projects");
     return buildProjectId(projectRoot || process.cwd());
   } catch {
     return crypto.createHash("sha256").update(String(projectRoot || "")).digest("hex").slice(0, 16);
   }
 }
 
+function resolveInjectSockPathForAgent(projectRoot, agentId) {
+  const { getUfooPaths } = require("../../coordination/state/paths");
+  const { subscriberToSafeName } = require("../../coordination/bus/utils");
+  const safeName = subscriberToSafeName(agentId);
+  return path.join(getUfooPaths(projectRoot || process.cwd()).busQueuesDir, safeName, "inject.sock");
+}
+
+function createInkMultiWindowToggle({
+  getController = () => null,
+  setActive = () => {},
+  logMessage = () => {},
+} = {}) {
+  return () => {
+    const controller = typeof getController === "function" ? getController() : null;
+    if (!controller || typeof controller.enter !== "function" || typeof controller.exit !== "function") {
+      logMessage("error", "✗ Multi-window mode is not available");
+      return false;
+    }
+
+    if (typeof controller.isActive === "function" && controller.isActive()) {
+      controller.exit();
+      setActive(false);
+      return true;
+    }
+
+    setActive(true);
+    if (!controller.enter()) {
+      setActive(false);
+      logMessage("info", "No active agents for multi-window mode");
+      return false;
+    }
+    return true;
+  };
+}
+
 function loadChatHistory(projectRoot, cap = 200, options = {}) {
   const file = chatHistoryFilePath(projectRoot, options);
   try {
@@ -205,6 +238,11 @@ function chatHistoryOptionsForScope({ globalMode = false, globalScope = "control
 }
 
 function getAgentLabelFor(meta, agentId) {
+  // Prefer the project-stripped display nickname so the dashboard never shows
+  // the scoped form ("neptune-builder"); fall back to the raw nickname (which
+  // may itself be unscoped depending on write path) and finally to a short
+  // form of the subscriber id.
+  if (meta && meta.display_nickname) return meta.display_nickname;
   if (meta && meta.nickname) return meta.nickname;
   if (!agentId) return "";
   const colon = agentId.indexOf(":");
@@ -224,7 +262,7 @@ function buildActiveAgentLabelMap(activeAgents = [], activeAgentMeta = new Map()
 }
 
 function resolveActiveAgentId(label, activeAgents = [], activeAgentMeta = new Map()) {
-  const { resolveAgentId } = require("../../chat/agentDirectory");
+  const { resolveAgentId } = require("../../app/chat/agentDirectory");
   const metaMap = activeAgentMeta instanceof Map ? activeAgentMeta : new Map();
   return resolveAgentId({
     label,
@@ -258,7 +296,7 @@ function buildDirectBusSendRequest({
     };
   }
 
-  const { parseAtTarget } = require("../../chat/commands");
+  const { parseAtTarget } = require("../../app/chat/commands");
   const atTarget = parseAtTarget(trimmed);
   if (!atTarget || !atTarget.message) return null;
   const target = resolveActiveAgentId(atTarget.target, activeAgents, activeAgentMeta) || atTarget.target;
@@ -284,7 +322,7 @@ function resolveAgentEnterRequest({
     ? settings.launchMode
     : "";
   const launchMode = String(meta.launch_mode || meta.launchMode || configuredLaunchMode || "").trim();
-  const { createTerminalAdapterRouter } = require("../../terminal/adapterRouter");
+  const { createTerminalAdapterRouter } = require("../../runtime/terminal/adapterRouter");
   const adapter = createTerminalAdapterRouter().getAdapter({ launchMode, agentId: id, meta });
   const caps = adapter && adapter.capabilities ? adapter.capabilities : {};
 
@@ -299,8 +337,26 @@ function resolveAgentEnterRequest({
   };
 }
 
+function resolveDashboardAgentEnterAction(enterRequest = {}) {
+  if (!enterRequest || typeof enterRequest !== "object") return "none";
+  if (enterRequest.useBus) return "internal";
+  if (enterRequest.supportsActivate) return "activate";
+  return "agent-view";
+}
+
+function buildEmptyProjectsDownActions(state = {}, displayAgents = []) {
+  if (!state.emptyProjectsDownArmed) {
+    return [{ type: "projects/armEmptyDown" }];
+  }
+  const actions = [{ type: "view/set", view: "agents" }];
+  if (displayAgents.length > 0 && state.selectedAgentIndex < 0) {
+    actions.push({ type: "agents/select", index: 0 });
+  }
+  return actions;
+}
+
 function buildPromptIpcRequest(text) {
-  const { IPC_REQUEST_TYPES } = require("../../shared/eventContract");
+  const { IPC_REQUEST_TYPES } = require("../../runtime/contracts/eventContract");
   return {
     type: IPC_REQUEST_TYPES.PROMPT,
     text,
@@ -323,6 +379,46 @@ function normalizeInkLogLines(text = "") {
   return clean.split(/\r?\n/);
 }
 
+function stripMarkdownDecorators(text = "") {
+  return String(text || "")
+    .replace(/\*\*([^*]+)\*\*/g, "$1")
+    .replace(/`([^`]+)`/g, "$1");
+}
+
+function classifyChatLogLine(text = "") {
+  const raw = stripBlessedTags(text).replace(/\r/g, "");
+  const clean = stripMarkdownDecorators(raw);
+  const trimmed = clean.trim();
+  if (!trimmed) return { kind: "spacer", marker: " ", speaker: "", body: " " };
+  if (/^[█▀▄ ]+$/.test(trimmed) || /^ufoo chat/i.test(trimmed)) {
+    return { kind: "banner", marker: " ", speaker: "", body: clean };
+  }
+  if (/^───.*───$/.test(trimmed)) {
+    return { kind: "divider", marker: "─", speaker: "", body: clean };
+  }
+  if (/^(error:|✗|failed\b)/i.test(trimmed)) {
+    return { kind: "error", marker: "!", speaker: "error", body: clean.replace(/^(error:\s*)/i, "") };
+  }
+  if (/^(✓|✔|done\b|closed\b)/i.test(trimmed)) {
+    return { kind: "success", marker: "✓", speaker: "", body: clean.replace(/^[✓✔]\s*/, "") };
+  }
+  const dotMatch = clean.match(/^([^·:\n]{1,42})\s+·\s+(.*)$/);
+  if (dotMatch) {
+    const speaker = dotMatch[1].trim();
+    const lower = speaker.toLowerCase();
+    const kind = lower === "ufoo" ? "assistant" : "agent";
+    return { kind, marker: kind === "assistant" ? "◆" : "●", speaker, body: dotMatch[2] || " " };
+  }
+  const colonMatch = clean.match(/^([A-Za-z0-9_.:@/-]{1,42}):\s+(.*)$/);
+  if (colonMatch) {
+    return { kind: "agent", marker: "●", speaker: colonMatch[1], body: colonMatch[2] || " " };
+  }
+  if (/^(CHAT|UCODE)\s+·/i.test(trimmed)) {
+    return { kind: "meta", marker: "·", speaker: "", body: clean };
+  }
+  return { kind: "plain", marker: "│", speaker: "", body: clean };
+}
+
 function createInkStreamState({
   dispatch,
   appendHistory,
@@ -661,7 +757,7 @@ function createInternalAgentViewState({
 } = {}) {
   let history = [];
   try {
-    const { loadInternalAgentLogHistory } = require("../../chat/internalAgentLogHistory");
+    const { loadInternalAgentLogHistory } = require("../../app/chat/internalAgentLogHistory");
     history = loadInternalAgentLogHistory(projectRoot || process.cwd(), agentId, {
       maxEvents: 400,
       maxLines: 1000,
@@ -838,7 +934,7 @@ function resolveProjectRowRoot(row = {}) {
   const raw = String((row && (row.root || row.project_root)) || "").trim();
   if (!raw) return "";
   try {
-    const { canonicalProjectRoot } = require("../../projects");
+    const { canonicalProjectRoot } = require("../../runtime/projects");
     return canonicalProjectRoot(raw);
   } catch {
     return path.resolve(raw);
@@ -851,7 +947,7 @@ function loadGlobalProjectRows(activeProjectRoot = "") {
     filterVisibleProjectRuntimes,
     isGlobalControllerProjectRoot,
     markProjectStopped,
-  } = require("../../projects");
+  } = require("../../runtime/projects");
   let rows = listProjectRuntimes({ validate: true, cleanupTmp: true }) || [];
   for (const row of rows) {
     const status = String((row && row.status) || "").trim().toLowerCase();
@@ -874,8 +970,8 @@ function loadGlobalProjectRows(activeProjectRoot = "") {
 function readProjectAgentSnapshot(projectRoot = "") {
   if (!projectRoot) return { agents: [], metaMap: new Map() };
   try {
-    const { buildStatus } = require("../../daemon/status");
-    const { buildAgentMaps } = require("../../chat/agentDirectory");
+    const { buildStatus } = require("../../runtime/daemon/status");
+    const { buildAgentMaps } = require("../../app/chat/agentDirectory");
     const status = buildStatus(projectRoot);
     const activeIds = Array.isArray(status.active) ? status.active : [];
     const metaList = Array.isArray(status.active_meta) ? status.active_meta : [];
@@ -900,6 +996,49 @@ function readProjectAgentSnapshot(projectRoot = "") {
   }
 }
 
+function isCJK(ch) {
+  if (!ch) return false;
+  const code = ch.codePointAt(0);
+  return (code >= 0x2e80 && code <= 0x9fff) ||
+    (code >= 0xac00 && code <= 0xd7af) ||
+    (code >= 0xf900 && code <= 0xfaff) ||
+    (code >= 0xfe30 && code <= 0xfe4f) ||
+    (code >= 0x20000 && code <= 0x2fa1f);
+}
+
+function inferStatusType(text = "", requestedType = "") {
+  const type = String(requestedType || "").trim().toLowerCase();
+  if (type === "done" || type === "success" || type === "error" || type === "idle") return type;
+  const clean = stripBlessedTags(String(text || "")).trim();
+  if (/^[✓✔]/.test(clean) || /\bdone\b/i.test(clean) || /\bprocessed\b/i.test(clean)) return "done";
+  if (/^[✗!]/.test(clean) || /\berror\b/i.test(clean) || /\bfailed\b/i.test(clean)) return "error";
+  return type || "typing";
+}
+
+function isAnimatedStatusType(type = "") {
+  const value = String(type || "").trim().toLowerCase();
+  return value !== "done" && value !== "success" && value !== "error" && value !== "idle" && value !== "none";
+}
+
+function inkKeyToRaw(input, key) {
+  if (key.ctrl && input) {
+    const code = input.charCodeAt(0) - 96;
+    if (code >= 1 && code <= 26) return String.fromCharCode(code);
+    return "";
+  }
+  if (key.return) return "\r";
+  if (key.escape) return "\x1b";
+  if (key.backspace || key.delete) return "\x7f";
+  if (key.tab) return "\t";
+  if (key.upArrow) return "\x1b[A";
+  if (key.downArrow) return "\x1b[B";
+  if (key.rightArrow) return "\x1b[C";
+  if (key.leftArrow) return "\x1b[D";
+  if (input && !key.meta) return input;
+  if (key.meta && input) return `\x1b${input}`;
+  return "";
+}
+
 function createChatApp({ React, ink, props, interactive = true }) {
   const { useReducer, useEffect, useState, useCallback, useRef } = React;
   const { Box, Text, Static, useInput, useApp, useStdout } = ink;
@@ -933,9 +1072,18 @@ function createChatApp({ React, ink, props, interactive = true }) {
     const [spinnerTick, setSpinnerTick] = useState(0);
     const [currentProjectRoot, setCurrentProjectRoot] = useState(props.activeProjectRoot || props.projectRoot || "");
     const [internalAgentView, setInternalAgentView] = useState(() => createInternalAgentViewState());
+    const [multiWindowActive, setMultiWindowActive] = useState(false);
+    const [mwCursor, setMwCursor] = useState(0);
+    const [mwTerminalFocused, setMwTerminalFocused] = useState(false);
+    const mwTerminalFocusedRef = useRef(false);
+    const mwLastInputRef = useRef({ char: "", time: 0 });
     const stateRef = useRef(state);
+    const sizeRef = useRef(size);
     const currentProjectRootRef = useRef(currentProjectRoot);
     const internalAgentViewRef = useRef(internalAgentView);
+    const multiWindowControllerRef = useRef(null);
+    const multiWindowChromeRef = useRef({ statusText: "", promptPrefix: "› ", draft: "", dashboardLines: [] });
+    const multiWindowWatchedInternalAgentsRef = useRef(new Set());
     const pendingRef = useRef(null);
     const streamStateRef = useRef(null);
     const historyScopeRef = useRef(null);
@@ -952,6 +1100,10 @@ function createChatApp({ React, ink, props, interactive = true }) {
       stateRef.current = state;
     }, [state]);
 
+    useEffect(() => {
+      sizeRef.current = size;
+    }, [size]);
+
     useEffect(() => {
       currentProjectRootRef.current = currentProjectRoot;
     }, [currentProjectRoot]);
@@ -975,7 +1127,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
         type: "status/set",
         payload: {
           message: clean,
-          type: options.type || "typing",
+          type: inferStatusType(clean, options.type || "typing"),
           showTimer: options.showTimer === true,
           startedAt: options.startedAt || Date.now(),
         },
@@ -1009,6 +1161,151 @@ function createChatApp({ React, ink, props, interactive = true }) {
       });
     }
 
+    const getMultiWindowController = useCallback(() => {
+      if (multiWindowControllerRef.current) return multiWindowControllerRef.current;
+      const processStdout = stdout || (typeof process !== "undefined" ? process.stdout : null);
+      if (!processStdout || typeof processStdout.write !== "function") return null;
+
+      const originalWrite = processStdout.write.bind(processStdout);
+      const { createMultiWindowController } = require("../../app/chat/multiWindow");
+      multiWindowControllerRef.current = createMultiWindowController({
+        processStdout: { write: originalWrite, rows: processStdout.rows, columns: processStdout.columns },
+        getRows: () => {
+          const currentSize = sizeRef.current || {};
+          return currentSize.rows || processStdout.rows || 24;
+        },
+        getCols: () => {
+          const currentSize = sizeRef.current || {};
+          return currentSize.cols || processStdout.columns || 80;
+        },
+        getInjectSockPath: (agentId) =>
+          resolveInjectSockPathForAgent(currentProjectRootRef.current || props.projectRoot, agentId),
+        getActiveAgents: () => {
+          const current = stateRef.current || {};
+          return Array.isArray(current.agents) ? current.agents : [];
+        },
+        getAgentPaneOptions: (agentId) => {
+          const current = stateRef.current || {};
+          const enterRequest = resolveAgentEnterRequest({
+            agentId,
+            projectRoot: currentProjectRootRef.current || props.projectRoot,
+            activeAgentMeta: current.activeAgentMeta,
+            settings: current.settings,
+          });
+          if (!enterRequest || !enterRequest.useBus) return { mode: "socket" };
+          const metaMap = current.activeAgentMeta instanceof Map ? current.activeAgentMeta : new Map();
+          const agentMeta = metaMap.get(agentId) || {};
+          let initialLines = [];
+          try {
+            const { loadInternalAgentLogHistory } = require("../../app/chat/internalAgentLogHistory");
+            initialLines = loadInternalAgentLogHistory(currentProjectRootRef.current || props.projectRoot, agentId, {
+              maxEvents: 200,
+              maxLines: 200,
+            });
+          } catch { initialLines = []; }
+          return {
+            mode: "internal",
+            initialLines: [
+              `ufoo internal agent · ${getAgentLabelFor(agentMeta, agentId)}`,
+              `agent: ${agentId}`,
+              "",
+              ...initialLines,
+            ],
+          };
+        },
+        getChatLogLines: () => {
+          const current = stateRef.current || {};
+          return Array.isArray(current.logLines)
+            ? current.logLines.map((item) => String((item && item.text) || ""))
+            : [];
+        },
+        getStatusText: () => {
+          const chrome = multiWindowChromeRef.current;
+          return chrome ? chrome.statusText : "";
+        },
+        getPromptPrefix: () => {
+          const chrome = multiWindowChromeRef.current;
+          return chrome ? chrome.promptPrefix : "› ";
+        },
+        getCurrentDraft: () => {
+          const chrome = multiWindowChromeRef.current;
+          return chrome ? chrome.draft : "";
+        },
+        getCursorPos: () => {
+          const chrome = multiWindowChromeRef.current;
+          return chrome ? chrome.cursor : 0;
+        },
+        getCompletions: () => {
+          const chrome = multiWindowChromeRef.current;
+          if (!chrome || !chrome.completions || chrome.completions.length === 0) {
+            return { items: [], index: -1, windowStart: 0, pageSize: 8 };
+          }
+          return {
+            items: chrome.completions,
+            index: chrome.completionIndex,
+            windowStart: chrome.completionWindowStart,
+            pageSize: chrome.completionPageSize || 8,
+          };
+        },
+        getAgentLabel: (id) => {
+          const current = stateRef.current || {};
+          const metaMap = current.activeAgentMeta || new Map();
+          return getAgentLabelFor(metaMap.get(id), id);
+        },
+        getInternalPaneInfo: (id) => {
+          const current = stateRef.current || {};
+          const metaMap = current.activeAgentMeta instanceof Map ? current.activeAgentMeta : new Map();
+          const meta = metaMap.get(id) || {};
+          const status = internalStatusLabel(meta.activity_state || meta.state || "");
+          const detail = String(meta.activity_detail || meta.detail || meta.status_text || "").trim();
+          return {
+            status,
+            detail,
+            input: "",
+            cursor: 0,
+          };
+        },
+        getDashboardLines: () => {
+          const chrome = multiWindowChromeRef.current;
+          return chrome ? chrome.dashboardLines : [];
+        },
+        getTerminalFocused: () => mwTerminalFocusedRef.current,
+        freezeScreen: (frozen) => {
+          if (frozen) {
+            processStdout.write = () => true;
+          } else {
+            processStdout.write = originalWrite;
+          }
+        },
+        restoreTerminal: () => {
+          const rows = processStdout.rows || 24;
+          originalWrite(`\x1b[1;${rows}r`);
+          originalWrite("\x1b[2J\x1b[H");
+        },
+        onInternalSubmit: (agentId, message) => {
+          sendInternalAgentMessage(agentId, message);
+        },
+        onExit: () => {
+          setMultiWindowActive(false);
+        },
+      });
+      return multiWindowControllerRef.current;
+    }, [props.projectRoot, stdout]);
+
+    const toggleMultiWindow = useCallback(() => createInkMultiWindowToggle({
+      getController: getMultiWindowController,
+      setActive: setMultiWindowActive,
+      logMessage: logInkMessage,
+    })(), [getMultiWindowController, logInkMessage]);
+
+    useEffect(() => () => {
+      const controller = multiWindowControllerRef.current;
+      if (controller && typeof controller.exit === "function") {
+        try { controller.exit(); } catch { /* ignore */ }
+      }
+      multiWindowControllerRef.current = null;
+    }, []);
+
     useEffect(() => {
       internalAgentViewRef.current = internalAgentView;
     }, [internalAgentView]);
@@ -1034,7 +1331,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
     const sendInternalAgentWatch = (agentId, enabled) => {
       if (!agentId || !props.daemonConnection || typeof props.daemonConnection.send !== "function") return;
       try {
-        const { IPC_REQUEST_TYPES } = require("../../shared/eventContract");
+        const { IPC_REQUEST_TYPES } = require("../../runtime/contracts/eventContract");
         props.daemonConnection.send({
           type: IPC_REQUEST_TYPES.BUS_WATCH,
           agent_id: agentId,
@@ -1043,10 +1340,49 @@ function createChatApp({ React, ink, props, interactive = true }) {
       } catch { /* ignore */ }
     };
 
+    const reconcileMultiWindowInternalWatches = useCallback(() => {
+      const current = stateRef.current || {};
+      const agents = Array.isArray(current.agents) ? current.agents : [];
+      const next = new Set();
+      if (multiWindowActive) {
+        for (const agentId of agents) {
+          const enterRequest = resolveAgentEnterRequest({
+            agentId,
+            projectRoot: currentProjectRootRef.current || props.projectRoot,
+            activeAgentMeta: current.activeAgentMeta,
+            settings: current.settings,
+          });
+          if (enterRequest && enterRequest.useBus) next.add(agentId);
+        }
+      }
+      const previous = multiWindowWatchedInternalAgentsRef.current;
+      for (const agentId of next) {
+        if (!previous.has(agentId)) sendInternalAgentWatch(agentId, true);
+      }
+      for (const agentId of previous) {
+        if (!next.has(agentId)) sendInternalAgentWatch(agentId, false);
+      }
+      multiWindowWatchedInternalAgentsRef.current = next;
+    }, [multiWindowActive, props.projectRoot, props.daemonConnection]);
+
+    useEffect(() => {
+      if (!multiWindowActive) return;
+      const controller = multiWindowControllerRef.current;
+      if (!controller) return;
+      reconcileMultiWindowInternalWatches();
+      if (typeof controller.syncAgents === "function") controller.syncAgents();
+      if (typeof controller.renderAll === "function") controller.renderAll();
+    }, [multiWindowActive, state.agents, state.logLines, state.draft, state.status, size.cols, size.rows, mwCursor, state.focusMode, state.dashboardView, state.selectedAgentIndex, state.selectedProjectIndex, state.selectedModeIndex, state.selectedProviderIndex, state.selectedCronIndex, mwTerminalFocused, reconcileMultiWindowInternalWatches]);
+
+    useEffect(() => {
+      if (multiWindowActive) return;
+      reconcileMultiWindowInternalWatches();
+    }, [multiWindowActive, reconcileMultiWindowInternalWatches]);
+
     const sendInternalAgentMessage = (agentId, message) => {
       if (!agentId || !message || !props.daemonConnection || typeof props.daemonConnection.send !== "function") return;
       try {
-        const { IPC_REQUEST_TYPES } = require("../../shared/eventContract");
+        const { IPC_REQUEST_TYPES } = require("../../runtime/contracts/eventContract");
         props.daemonConnection.send({
           type: IPC_REQUEST_TYPES.BUS_SEND,
           target: agentId,
@@ -1070,6 +1406,74 @@ function createChatApp({ React, ink, props, interactive = true }) {
       return aliases.has(text);
     };
 
+    const buildInternalAgentAliases = (agentId) => {
+      const current = stateRef.current || {};
+      const metaMap = current.activeAgentMeta instanceof Map ? current.activeAgentMeta : new Map();
+      const meta = metaMap.get(agentId) || {};
+      return new Set([
+        agentId,
+        meta.nickname,
+        meta.scoped_nickname,
+        meta.display_nickname,
+        meta.fullId,
+      ].filter(Boolean).map(String));
+    };
+
+    const writeMultiWindowInternalEvent = useCallback((data = {}) => {
+      const controller = multiWindowControllerRef.current;
+      if (!multiWindowActive || !controller || typeof controller.writeToPane !== "function") return false;
+      const watched = multiWindowWatchedInternalAgentsRef.current;
+      if (!watched || watched.size === 0) return false;
+
+      let handled = false;
+      for (const agentId of watched) {
+        const aliases = buildInternalAgentAliases(agentId);
+        const publisher = String(data.publisher || (data.event === "broadcast" ? "broadcast" : "bus"));
+        const target = String(data.target || data.subscriber || "");
+        const fromAgent = aliases.has(publisher);
+        const toAgent = aliases.has(target) || aliases.has(String(data.subscriber || ""));
+        if (!fromAgent && !toAgent) continue;
+        if (data.silent) {
+          handled = true;
+          continue;
+        }
+        if (data.source === "chat-internal-agent-view" && toAgent && !fromAgent) {
+          handled = true;
+          continue;
+        }
+        if (data.event === "activity_state_changed") {
+          const state = internalStatusLabel(data.state || data.activity_state || "");
+          const detail = String(data.detail || (data.data && data.data.detail) || data.message || "").trim();
+          controller.writeToPane(agentId, `\r\n[${state}${detail ? ` · ${detail}` : ""}]\r\n`);
+          handled = true;
+          continue;
+        }
+
+        const { displayMessage, streamPayload } = parseInternalBusPayload(data.message || "");
+        if (streamPayload) {
+          if (!fromAgent) {
+            handled = true;
+            continue;
+          }
+          const delta = typeof streamPayload.delta === "string"
+            ? streamPayload.delta.replace(/\\r\\n/g, "\n").replace(/\\n/g, "\n").replace(/\\r/g, "\n")
+            : "";
+          if (delta) controller.writeToPane(agentId, delta);
+          if (streamPayload.done) controller.writeToPane(agentId, "\r\n");
+          handled = true;
+          continue;
+        }
+        if (!displayMessage) {
+          handled = true;
+          continue;
+        }
+        const prefix = fromAgent ? "* " : "> ";
+        controller.writeToPane(agentId, `${prefix}${displayMessage.replace(/\n/g, `\r\n  `)}\r\n`);
+        handled = true;
+      }
+      return handled;
+    }, [multiWindowActive]);
+
     const handleInternalStatus = (data = {}) => {
       const view = internalAgentViewRef.current;
       if (!view || !view.agentId) return;
@@ -1168,7 +1572,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
 
     const requestDaemonStatus = useCallback(() => {
       try {
-        const { IPC_REQUEST_TYPES } = require("../../shared/eventContract");
+        const { IPC_REQUEST_TYPES } = require("../../runtime/contracts/eventContract");
         const conn = props.daemonConnection;
         if (conn && typeof conn.send === "function") conn.send({ type: IPC_REQUEST_TYPES.STATUS });
       } catch { /* ignore */ }
@@ -1177,7 +1581,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
     const updateDashboardFromStatus = useCallback((data = {}) => {
       const activeIds = Array.isArray(data.active) ? data.active : [];
       const metaList = Array.isArray(data.active_meta) ? data.active_meta : [];
-      const { buildAgentMaps } = require("../../chat/agentDirectory");
+      const { buildAgentMaps } = require("../../app/chat/agentDirectory");
       const { labelMap, metaMap } = buildAgentMaps(activeIds, metaList);
       const agentsForDispatch = activeIds.map((id) => {
         const meta = metaMap.get(id) || {};
@@ -1210,8 +1614,8 @@ function createChatApp({ React, ink, props, interactive = true }) {
       if (!conn || typeof conn.connect !== "function" || typeof setHandler !== "function") {
         return undefined;
       }
-      const { IPC_RESPONSE_TYPES } = require("../../shared/eventContract");
-      const { createDaemonMessageRouter } = require("../../chat/daemonMessageRouter");
+      const { IPC_RESPONSE_TYPES } = require("../../runtime/contracts/eventContract");
+      const { createDaemonMessageRouter } = require("../../app/chat/daemonMessageRouter");
       const streamState = streamStateRef.current;
       const router = createDaemonMessageRouter({
         escapeBlessed: (value) => String(value == null ? "" : value),
@@ -1227,7 +1631,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
           });
         },
         enqueueBusStatus: (item = {}) => setStatusText(item.text || "Processing bus message", { type: "typing" }),
-        resolveBusStatus: (item = {}) => setStatusText(item.text || "Bus message processed", { type: "typing" }),
+        resolveBusStatus: (item = {}) => setStatusText(item.text || "Bus message processed", { type: "done" }),
         getPending: () => pendingRef.current,
         setPending: (value) => { pendingRef.current = value || null; },
         resolveAgentDisplayName: (value) => {
@@ -1306,13 +1710,16 @@ function createChatApp({ React, ink, props, interactive = true }) {
           requestDaemonStatus();
           return;
         }
+        if (msg.type === IPC_RESPONSE_TYPES.BUS) {
+          writeMultiWindowInternalEvent(msg.data || {});
+        }
         router.handleMessage(msg);
       });
       conn.connect();
       return () => {
         try { if (typeof conn.close === "function") conn.close(); } catch { /* ignore */ }
       };
-    }, [interactive, logInkMessage, requestDaemonStatus, setStatusText, updateDashboardFromStatus]);
+    }, [interactive, logInkMessage, requestDaemonStatus, setStatusText, updateDashboardFromStatus, writeMultiWindowInternalEvent]);
 
     // commandExecutor wiring. The blessed implementation reuses this
     // module to dispatch every slash command (~30 callbacks). We adapt
@@ -1323,10 +1730,10 @@ function createChatApp({ React, ink, props, interactive = true }) {
     const commandExecutorRef = useRef(null);
     useEffect(() => {
       if (!interactive) return undefined;
-      const { createCommandExecutor } = require("../../chat/commandExecutor");
-      const { parseCommand: parseCmd } = require("../../chat/commands");
-      const { startDaemon: transportStartDaemon, stopDaemon: transportStopDaemon } = require("../../chat/transport");
-      const AgentActivator = require("../../bus/activate");
+      const { createCommandExecutor } = require("../../app/chat/commandExecutor");
+      const { parseCommand: parseCmd } = require("../../app/chat/commands");
+      const { startDaemon: transportStartDaemon, stopDaemon: transportStopDaemon } = require("../../app/chat/transport");
+      const AgentActivator = require("../../coordination/bus/activate");
       const conn = props.daemonConnection;
 
       try {
@@ -1338,6 +1745,31 @@ function createChatApp({ React, ink, props, interactive = true }) {
           logMessage: logInkMessage,
           resolveStatusLine: (text) => setStatusText(text),
           renderScreen: () => {},
+          clearLog: () => {
+            // Clear the persisted chat history file so reopening the chat
+            // doesn't reload old messages.
+            try {
+              const root = currentProjectRootRef.current || props.projectRoot;
+              const historyOptions = chatHistoryOptionsForScope({
+                globalMode: props.globalMode,
+                globalScope: (stateRef.current && stateRef.current.globalScope) || "controller",
+              });
+              const file = chatHistoryFilePath(root, historyOptions);
+              if (file && fs.existsSync(file)) fs.writeFileSync(file, "");
+            } catch { /* ignore */ }
+            // ink redraws by erasing only as many lines as the last frame
+            // emitted. After log/clear the next frame is shorter, so the
+            // older log lines remain in the terminal scrollback. Wipe the
+            // visible screen + scrollback first, then dispatch — ink will
+            // repaint the (now small) frame onto a clean buffer.
+            try {
+              const out = (typeof process !== "undefined" && process.stdout) || null;
+              if (out && out.isTTY && typeof out.write === "function") {
+                out.write("\x1b[2J\x1b[3J\x1b[H");
+              }
+            } catch { /* ignore */ }
+            dispatch({ type: "log/clear" });
+          },
           getActiveAgents: () => (stateRef.current && stateRef.current.agents) || [],
           getActiveAgentMetaMap: () => (stateRef.current && stateRef.current.activeAgentMeta) || new Map(),
           getAgentLabel: (id) => {
@@ -1372,7 +1804,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
           requestStatus: requestDaemonStatus,
           requestCron: (payload = {}) => {
             try {
-              const { IPC_REQUEST_TYPES } = require("../../shared/eventContract");
+              const { IPC_REQUEST_TYPES } = require("../../runtime/contracts/eventContract");
               if (conn && typeof conn.send === "function") {
                 conn.send({ type: IPC_REQUEST_TYPES.CRON, ...payload });
               }
@@ -1399,12 +1831,13 @@ function createChatApp({ React, ink, props, interactive = true }) {
             }
             return switchProject(targetRoot, { focusInput: true });
           },
+          toggleMultiWindow,
         });
       } catch (err) {
         dispatch({ type: "log/append", text: `Error: command executor unavailable (${err && err.message ? err.message : err})` });
       }
       return undefined;
-    }, [interactive, logInkMessage, requestDaemonStatus, setStatusText]);
+    }, [interactive, logInkMessage, requestDaemonStatus, setStatusText, toggleMultiWindow]);
 
     // Periodic STATUS poll to keep the agents footer fresh, mirroring
     // blessed's requestStatus on a timer.
@@ -1412,7 +1845,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
       if (!interactive) return undefined;
       const conn = props.daemonConnection;
       if (!conn || typeof conn.send !== "function") return undefined;
-      const { IPC_REQUEST_TYPES } = require("../../shared/eventContract");
+      const { IPC_REQUEST_TYPES } = require("../../runtime/contracts/eventContract");
       const tick = () => {
         try { conn.send({ type: IPC_REQUEST_TYPES.STATUS }); } catch { /* ignore */ }
       };
@@ -1448,7 +1881,8 @@ function createChatApp({ React, ink, props, interactive = true }) {
     useEffect(() => {
       const internalStatus = state.viewingAgentId ? internalStatusLabel(internalAgentView.status) : "ready";
       const internalActive = internalStatus !== "ready";
-      if ((!state.status.message || state.status.type === "none") && !internalActive) return undefined;
+      const statusAnimated = state.status.message && isAnimatedStatusType(state.status.type);
+      if ((!statusAnimated) && !internalActive) return undefined;
       const timer = setInterval(() => setSpinnerTick((t) => t + 1), 100);
       return () => clearInterval(timer);
     }, [state.status.message, state.status.type, state.viewingAgentId, internalAgentView.status]);
@@ -1498,7 +1932,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
 
     const clearUfooAgentIdentity = useCallback(() => {
       try {
-        const { getUfooPaths } = require("../../ufoo/paths");
+        const { getUfooPaths } = require("../../coordination/state/paths");
         const agentDir = getUfooPaths(props.projectRoot).agentDir;
         fs.rmSync(path.join(agentDir, "ufoo-agent.json"), { force: true });
         fs.rmSync(path.join(agentDir, "ufoo-agent.history.jsonl"), { force: true });
@@ -1526,7 +1960,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
     const sendCronStop = useCallback((taskId) => {
       if (!taskId || !props.daemonConnection || typeof props.daemonConnection.send !== "function") return;
       try {
-        const { IPC_REQUEST_TYPES } = require("../../shared/eventContract");
+        const { IPC_REQUEST_TYPES } = require("../../runtime/contracts/eventContract");
         props.daemonConnection.send({ type: IPC_REQUEST_TYPES.CRON, operation: "stop", id: taskId });
       } catch (err) {
         dispatch({ type: "log/append", text: `Error: ${err && err.message ? err.message : err}` });
@@ -1538,7 +1972,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
       if (!root) return { ok: false, error: "project root unavailable" };
       if (props.globalMode && props.env && typeof props.env.isRunning === "function" && !props.env.isRunning(root)) {
         try {
-          const { markProjectStopped } = require("../../projects");
+          const { markProjectStopped } = require("../../runtime/projects");
           markProjectStopped(root);
         } catch { /* ignore */ }
         refreshGlobalProjects(currentProjectRoot);
@@ -1565,7 +1999,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
         dispatch({ type: "log/appendMany", lines: persisted });
       }
       if (props.daemonCoordinator && typeof props.daemonCoordinator.switchProject === "function") {
-        const { socketPath } = require("../../daemon");
+        const { socketPath } = require("../../runtime/daemon");
         const res = await Promise.resolve(props.daemonCoordinator.switchProject({
           projectRoot: root,
           sockPath: socketPath(root),
@@ -1586,7 +2020,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
       refreshGlobalProjects(root);
       if (focusInput) dispatch({ type: "focus/set", mode: "input" });
       try {
-        const { IPC_REQUEST_TYPES } = require("../../shared/eventContract");
+        const { IPC_REQUEST_TYPES } = require("../../runtime/contracts/eventContract");
         if (props.daemonConnection && typeof props.daemonConnection.send === "function") {
           props.daemonConnection.send({ type: IPC_REQUEST_TYPES.STATUS });
         }
@@ -1610,7 +2044,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
       const root = props.activeProjectRoot || props.projectRoot || "";
       if (!root) return { ok: false, error: "controller root unavailable" };
       if (props.daemonCoordinator && typeof props.daemonCoordinator.switchProject === "function") {
-        const { socketPath } = require("../../daemon");
+        const { socketPath } = require("../../runtime/daemon");
         const res = await Promise.resolve(props.daemonCoordinator.switchProject({
           projectRoot: root,
           sockPath: socketPath(root),
@@ -1643,7 +2077,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
       const snapshot = readProjectAgentSnapshot(root);
       dispatch({ type: "agents/set", list: snapshot.agents.map((id) => snapshot.metaMap.get(id) || { fullId: id }) });
       try {
-        const { IPC_REQUEST_TYPES } = require("../../shared/eventContract");
+        const { IPC_REQUEST_TYPES } = require("../../runtime/contracts/eventContract");
         if (props.daemonConnection && typeof props.daemonConnection.send === "function") {
           props.daemonConnection.send({ type: IPC_REQUEST_TYPES.STATUS });
         }
@@ -1682,7 +2116,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
             dispatch({ type: "log/append", text: "Error: project switching unavailable" });
             return;
           }
-          const { socketPath } = require("../../daemon");
+          const { socketPath } = require("../../runtime/daemon");
           const switched = await Promise.resolve(props.daemonCoordinator.switchProject({
             projectRoot: fallback,
             sockPath: socketPath(fallback),
@@ -1697,8 +2131,8 @@ function createChatApp({ React, ink, props, interactive = true }) {
           dispatch({ type: "scope/set", scope: "project" });
         }
 
-        const { stopDaemon } = require("../../chat/transport");
-        const { isRunning } = require("../../daemon");
+        const { stopDaemon } = require("../../app/chat/transport");
+        const { isRunning } = require("../../runtime/daemon");
         stopDaemon(targetRoot, { source: `ink-project-close:${targetRoot}` });
         refreshGlobalProjects(activeRoot);
         if (isRunning(targetRoot)) {
@@ -1726,12 +2160,12 @@ function createChatApp({ React, ink, props, interactive = true }) {
         if (!switched || switched.ok !== true) return;
       }
       dispatch({ type: "draft/clear" });
-      const { createInputSubmitHandler } = require("../../chat/inputSubmitHandler");
-      const { parseAtTarget } = require("../../chat/commands");
-      const { resolveAgentId } = require("../../chat/agentDirectory");
-      const { subscriberToSafeName } = require("../../bus/utils");
-      const { getUfooPaths } = require("../../ufoo/paths");
-      const { createTerminalAdapterRouter } = require("../../terminal/adapterRouter");
+      const { createInputSubmitHandler } = require("../../app/chat/inputSubmitHandler");
+      const { parseAtTarget } = require("../../app/chat/commands");
+      const { resolveAgentId } = require("../../app/chat/agentDirectory");
+      const { subscriberToSafeName } = require("../../coordination/bus/utils");
+      const { getUfooPaths } = require("../../coordination/state/paths");
+      const { createTerminalAdapterRouter } = require("../../runtime/terminal/adapterRouter");
       const submitState = {};
       Object.defineProperties(submitState, {
         targetAgent: {
@@ -1814,7 +2248,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
           return createTerminalAdapterRouter().getAdapter({ launchMode, agentId, meta });
         },
         activateAgent: async (agentId) => {
-          const AgentActivator = require("../../bus/activate");
+          const AgentActivator = require("../../coordination/bus/activate");
           const activator = new AgentActivator(currentProjectRoot || props.projectRoot);
           await activator.activate(agentId);
         },
@@ -1831,7 +2265,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
         renderScreen: () => {},
         getShellCwd: () => activeChatHistoryRoot,
         runShellCommand: async (shellCommand, options = {}) => {
-          const { runShellCommand } = require("../../chat/shellCommand");
+          const { runShellCommand } = require("../../app/chat/shellCommand");
           return runShellCommand(shellCommand, options);
         },
       });
@@ -1927,7 +2361,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
     // with "/" or "@". Tab/Enter accept the highlighted entry, ↑↓ move the
     // selection. The list reuses the pure buildCompletions helper from
     // src/ui/format so jest can pin the source list without rendering ink.
-    const { COMMAND_REGISTRY, COMMAND_TREE } = require("../../chat/commands");
+    const { COMMAND_REGISTRY, COMMAND_TREE } = require("../../app/chat/commands");
     const agentLabels = displayAgents.map((id) =>
       getAgentLabelFor(displayAgentMeta.get(id), id)
     );
@@ -1938,7 +2372,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
     if (!dynamicSourcesRef.current) {
       const sources = { groupTemplates: [], soloProfiles: [] };
       try {
-        const { loadTemplateRegistry } = require("../../group/templates");
+        const { loadTemplateRegistry } = require("../../orchestration/groups/templates");
         const reg = typeof loadTemplateRegistry === "function" ? loadTemplateRegistry(props.projectRoot) : null;
         if (reg && Array.isArray(reg.templates)) {
           sources.groupTemplates = reg.templates.map((item) => ({
@@ -1950,8 +2384,8 @@ function createChatApp({ React, ink, props, interactive = true }) {
         }
       } catch { /* ignore */ }
       try {
-        const { loadPromptProfileRegistry } = require("../../group/promptProfiles");
-        const { buildPromptProfileCandidates } = require("../../solo/commands");
+        const { loadPromptProfileRegistry } = require("../../orchestration/groups/promptProfiles");
+        const { buildPromptProfileCandidates } = require("../../orchestration/solo/commands");
         const reg = typeof loadPromptProfileRegistry === "function" ? loadPromptProfileRegistry(props.projectRoot) : null;
         if (reg && typeof buildPromptProfileCandidates === "function") {
           sources.soloProfiles = buildPromptProfileCandidates(reg) || [];
@@ -1995,6 +2429,9 @@ function createChatApp({ React, ink, props, interactive = true }) {
         setCompletionWindowStart(Math.max(0, completions.length - POPUP_PAGE_SIZE));
       }
     }, [completions.length, completionIndex, completionWindowStart]);
+    useEffect(() => {
+      if (multiWindowActive) setMwCursor(String(state.draft || "").length);
+    }, [draftVersion]);
     const completionsOpen = completions.length > 0 && state.draft !== completionSuppressedDraft;
     const acceptCompletion = useCallback(() => {
       if (!completionsOpen) return false;
@@ -2028,6 +2465,18 @@ function createChatApp({ React, ink, props, interactive = true }) {
       };
     };
 
+    const activateExternalAgent = (agentId) => {
+      const id = String(agentId || "").trim();
+      if (!id) return;
+      try {
+        const AgentActivator = require("../../coordination/bus/activate");
+        const activator = new AgentActivator(currentProjectRoot || props.projectRoot);
+        void activator.activate(id);
+      } catch (err) {
+        logInkMessage("error", `✗ Failed to activate ${id}: ${err && err.message ? err.message : "unknown error"}`);
+      }
+    };
+
     const enterInternalAgentView = (enterRequest = {}) => {
       const agentId = String(enterRequest.agentId || "").trim();
       if (!agentId) return;
@@ -2049,7 +2498,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
       dispatch({ type: "agents/clearTarget" });
       sendInternalAgentWatch(agentId, true);
       try {
-        const { IPC_REQUEST_TYPES } = require("../../shared/eventContract");
+        const { IPC_REQUEST_TYPES } = require("../../runtime/contracts/eventContract");
         if (props.daemonConnection && typeof props.daemonConnection.send === "function") {
           props.daemonConnection.send({ type: IPC_REQUEST_TYPES.STATUS });
         }
@@ -2120,10 +2569,19 @@ function createChatApp({ React, ink, props, interactive = true }) {
           return true;
         }
         const payload = buildAgentEnterPayload(agentId);
-        if (payload && payload.useBus) {
+        const action = resolveDashboardAgentEnterAction(payload);
+        if (action === "internal") {
           enterInternalAgentView(payload);
           return true;
         }
+        if (action === "activate") {
+          if (state.viewingAgentId) sendInternalAgentWatch(state.viewingAgentId, false);
+          dispatch({ type: "agentView/exit" });
+          dispatch({ type: "view/set", view: "agents" });
+          dispatch({ type: "focus/set", mode: "input" });
+          activateExternalAgent(agentId);
+          return true;
+        }
         if (payload && typeof props.requestEnterAgentView === "function") {
           if (state.viewingAgentId) sendInternalAgentWatch(state.viewingAgentId, false);
           props.requestEnterAgentView(agentId, payload);
@@ -2136,7 +2594,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
         const agentId = displayAgents[currentIndex - 1];
         if (!agentId) return true;
         try {
-          const { IPC_REQUEST_TYPES } = require("../../shared/eventContract");
+          const { IPC_REQUEST_TYPES } = require("../../runtime/contracts/eventContract");
           if (props.daemonConnection && typeof props.daemonConnection.send === "function") {
             props.daemonConnection.send({ type: IPC_REQUEST_TYPES.CLOSE_AGENT, agent_id: agentId });
           }
@@ -2248,6 +2706,58 @@ function createChatApp({ React, ink, props, interactive = true }) {
     };
 
     useInput((input, key) => {
+      if (multiWindowActive) {
+        const controller = multiWindowControllerRef.current;
+        const termFocused = mwTerminalFocusedRef.current;
+        if (key.ctrl && input === "q") {
+          if (controller && typeof controller.handleKey === "function") {
+            controller.handleKey({ name: "q", ctrl: true, sequence: "" });
+          }
+          mwTerminalFocusedRef.current = false;
+          setMwTerminalFocused(false);
+          return;
+        }
+        if (key.ctrl && input === "w") {
+          const agents = controller ? controller.getAgentIds() : [];
+          if (agents.length === 0) return;
+          if (!termFocused) {
+            if (controller) controller.focusAgent(agents[0]);
+            mwTerminalFocusedRef.current = true;
+            setMwTerminalFocused(true);
+          } else {
+            const current = controller ? controller.getFocused() : null;
+            const idx = current ? agents.indexOf(current) : -1;
+            if (idx >= 0 && idx < agents.length - 1) {
+              controller.focusAgent(agents[idx + 1]);
+            } else {
+              mwTerminalFocusedRef.current = false;
+              setMwTerminalFocused(false);
+              if (controller) controller.focusAgent(agents[0]);
+            }
+          }
+          if (controller) controller.renderAll();
+          return;
+        }
+        if (termFocused && controller && typeof controller.sendInput === "function") {
+          const now = Date.now();
+          const last = mwLastInputRef.current;
+          if (input === " " && !key.ctrl && !key.meta && isCJK(last.char) && now - last.time < 150) {
+            return;
+          }
+          const raw = inkKeyToRaw(input, key);
+          if (raw) {
+            const cleaned = raw.length > 1 && /[⺀-鿿가-힯豈-﫿︰-﹏]/.test(raw)
+              ? raw.replace(/ +$/, "")
+              : raw;
+            if (cleaned) {
+              controller.sendInput(cleaned);
+              const lastChar = cleaned[cleaned.length - 1];
+              mwLastInputRef.current = { char: lastChar, time: now };
+            }
+          }
+          return;
+        }
+      }
       if (key.ctrl && input === "c") { exit(); return; }
       if (key.ctrl && input === "o") { dispatch({ type: "merge/expand" }); return; }
       if (state.viewingAgentId) {
@@ -2323,14 +2833,33 @@ function createChatApp({ React, ink, props, interactive = true }) {
           && state.agentSelectionMode
           && state.selectedAgentIndex >= 0) {
         const agentId = displayAgents[state.selectedAgentIndex];
-        if (agentId && typeof props.requestEnterAgentView === "function") {
+        if (agentId && multiWindowActive) {
+          const controller = multiWindowControllerRef.current;
+          if (controller && typeof controller.focusAgent === "function") {
+            controller.focusAgent(agentId);
+          }
+          setMwTerminalFocused(true);
+          mwTerminalFocusedRef.current = true;
+          dispatch({ type: "focus/set", mode: "input" });
+          return;
+        }
+        if (agentId) {
           const enterPayload = buildAgentEnterPayload(agentId);
-          if (enterPayload.useBus) {
+          const action = resolveDashboardAgentEnterAction(enterPayload);
+          if (action === "internal") {
             enterInternalAgentView(enterPayload);
             return;
           }
-          props.requestEnterAgentView(agentId, enterPayload);
-          exit();
+          if (action === "activate") {
+            dispatch({ type: "agents/clearTarget" });
+            dispatch({ type: "focus/set", mode: "input" });
+            activateExternalAgent(agentId);
+            return;
+          }
+          if (typeof props.requestEnterAgentView === "function") {
+            props.requestEnterAgentView(agentId, enterPayload);
+            exit();
+          }
         }
         return;
       }
@@ -2339,10 +2868,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
       // Ctrl+X stops it.
       if (state.focusMode === "dashboard" && state.dashboardView === "projects" && state.projects.length === 0) {
         if (key.downArrow) {
-          dispatch({ type: "view/set", view: "agents" });
-          if (displayAgents.length > 0 && state.selectedAgentIndex < 0) {
-            dispatch({ type: "agents/select", index: 0 });
-          }
+          for (const action of buildEmptyProjectsDownActions(state, displayAgents)) dispatch(action);
           return;
         }
         if (key.upArrow || key.return || key.escape) {
@@ -2444,7 +2970,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
 
       // Dashboard focus on agents/mode/provider/cron — ↑↓ flip between
       // sibling views, ←/→ pick within the active view, Esc returns to
-      // the input. Mirrors the blessed handlers in dashboardKeyController.
+      // the input.
       if (state.focusMode === "dashboard"
           && (state.dashboardView === "agents"
               || state.dashboardView === "mode"
@@ -2470,7 +2996,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
             if (state.selectedAgentIndex >= 0 && state.selectedAgentIndex < displayAgents.length) {
               const agentId = displayAgents[state.selectedAgentIndex];
               try {
-                const { IPC_REQUEST_TYPES } = require("../../shared/eventContract");
+                const { IPC_REQUEST_TYPES } = require("../../runtime/contracts/eventContract");
                 if (props.daemonConnection && typeof props.daemonConnection.send === "function") {
                   props.daemonConnection.send({ type: IPC_REQUEST_TYPES.CLOSE_AGENT, agent_id: agentId });
                 }
@@ -2573,16 +3099,188 @@ function createChatApp({ React, ink, props, interactive = true }) {
           if (key.return) { dispatch({ type: "focus/set", mode: "input" }); return; }
         }
       }
+
+      // Multi-window typing handler: replicates MultilineInput's key handling
+      // so both modes share the same input behavior.
+      if (multiWindowActive && state.focusMode !== "dashboard") {
+        const intercepted = completionsOpen && (key.upArrow || key.downArrow || key.leftArrow || key.rightArrow || key.return);
+        if (intercepted) return;
+        if (key.return) {
+          if (key.meta) {
+            const before = (state.draft || "").slice(0, mwCursor);
+            const after = (state.draft || "").slice(mwCursor);
+            dispatch({ type: "draft/set", value: `${before}\n${after}` });
+            setMwCursor(mwCursor + 1);
+            return;
+          }
+          const value = String(state.draft || "").trim();
+          if (value) { submit(value); setMwCursor(0); }
+          return;
+        }
+        if (key.escape) {
+          if (state.agentSelectionMode) { dispatch({ type: "agents/clearTarget" }); return; }
+          if (state.draft) { dispatch({ type: "draft/clear" }); setMwCursor(0); }
+          else if (state.status && state.status.message) { dispatch({ type: "status/idle" }); }
+          return;
+        }
+        if (key.ctrl) {
+          if (input === "a") { setMwCursor(fmt.moveCursorToVisualLineBoundary({ cursorPos: mwCursor, inputValue: state.draft || "", width: inputWidth, boundary: "start" })); return; }
+          if (input === "e") { setMwCursor(fmt.moveCursorToVisualLineBoundary({ cursorPos: mwCursor, inputValue: state.draft || "", width: inputWidth, boundary: "end" })); return; }
+          if (input === "b") { setMwCursor(fmt.moveCursorHorizontally(mwCursor, state.draft || "", "left")); return; }
+          if (input === "f") { setMwCursor(fmt.moveCursorHorizontally(mwCursor, state.draft || "", "right")); return; }
+          if (input === "d") { const d = state.draft || ""; if (mwCursor < d.length) { dispatch({ type: "draft/set", value: d.slice(0, mwCursor) + d.slice(mwCursor + 1) }); } return; }
+          if (input === "h") { const d = state.draft || ""; if (mwCursor > 0) { dispatch({ type: "draft/set", value: d.slice(0, mwCursor - 1) + d.slice(mwCursor) }); setMwCursor(mwCursor - 1); } return; }
+          if (input === "k") { dispatch({ type: "draft/set", value: (state.draft || "").slice(0, mwCursor) }); return; }
+          if (input === "u") { dispatch({ type: "draft/set", value: (state.draft || "").slice(mwCursor) }); setMwCursor(0); return; }
+          if (input === "w") { const r = fmt.deleteWordBeforeCursor(state.draft || "", mwCursor); dispatch({ type: "draft/set", value: r.value }); setMwCursor(r.cursorPos); return; }
+          return;
+        }
+        if (key.meta) {
+          if (input === "b") { setMwCursor(fmt.moveCursorByWord(state.draft || "", mwCursor, "backward")); return; }
+          if (input === "f") { setMwCursor(fmt.moveCursorByWord(state.draft || "", mwCursor, "forward")); return; }
+          if (input === "d") { const end = fmt.moveCursorByWord(state.draft || "", mwCursor, "forward"); const d = state.draft || ""; dispatch({ type: "draft/set", value: d.slice(0, mwCursor) + d.slice(end) }); return; }
+        }
+        if (key.backspace || key.delete) {
+          const d = state.draft || "";
+          if (key.meta || key.ctrl) { const r = fmt.deleteWordBeforeCursor(d, mwCursor); dispatch({ type: "draft/set", value: r.value }); setMwCursor(r.cursorPos); }
+          else if (mwCursor > 0) { dispatch({ type: "draft/set", value: d.slice(0, mwCursor - 1) + d.slice(mwCursor) }); setMwCursor(mwCursor - 1); }
+          return;
+        }
+        if (key.leftArrow) {
+          if (!state.draft && typeof onArrowSideAtEmpty === "function") { onArrowSideAtEmpty("left"); return; }
+          setMwCursor(fmt.moveCursorHorizontally(mwCursor, state.draft || "", "left"));
+          return;
+        }
+        if (key.rightArrow) {
+          if (!state.draft && typeof onArrowSideAtEmpty === "function") { onArrowSideAtEmpty("right"); return; }
+          setMwCursor(fmt.moveCursorHorizontally(mwCursor, state.draft || "", "right"));
+          return;
+        }
+        if (key.upArrow) { onArrowUpAtTop(); return; }
+        if (key.downArrow) { onArrowDownAtBottom(state.draft); return; }
+        if (input && !key.ctrl && !key.meta) {
+          const filtered = input.replace(/[\x00-\x08\x0b-\x0c\x0e-\x1f\x7f]/g, "");
+          if (filtered) {
+            const d = state.draft || "";
+            dispatch({ type: "draft/set", value: d.slice(0, mwCursor) + filtered + d.slice(mwCursor) });
+            setMwCursor(mwCursor + filtered.length);
+          }
+          return;
+        }
+        return;
+      }
     }, { isActive: interactive });
 
     const statusText = computeStatusText(state.status, spinnerTick);
     const inputWidth = Math.max(20, (size.cols || 80) - 4);
     const promptPrefix = (() => {
       const projectPrefix = inCommittedProjectScope && currentProjectLabel ? `${currentProjectLabel} ` : "";
-      if (targetAgentLabel) return `${projectPrefix}›@${targetAgentLabel} `;
+      const visibleTargetAgentLabel = state.focusMode === "dashboard" && state.dashboardView !== "agents"
+        ? ""
+        : targetAgentLabel;
+      if (visibleTargetAgentLabel) return `${projectPrefix}›@${visibleTargetAgentLabel} `;
       return `${projectPrefix}› `;
     })();
 
+    if (multiWindowActive) {
+      const { renderDashboardLines } = require("./DashboardBar");
+      const clampedCursor = fmt.clampCursorPos(mwCursor, state.draft || "");
+      multiWindowChromeRef.current = {
+        statusText,
+        promptPrefix,
+        draft: state.draft || "",
+        cursor: clampedCursor,
+        completions: completionsOpen ? completions : [],
+        completionIndex: completionsOpen ? completionIndex : -1,
+        completionWindowStart: completionsOpen ? completionWindowStart : 0,
+        completionPageSize: POPUP_PAGE_SIZE,
+        dashboardLines: renderDashboardLines({
+          dashboardView: state.dashboardView,
+          focusMode: state.focusMode,
+          globalMode: state.globalMode,
+          globalScope: state.globalScope,
+          activeAgents: displayAgents,
+          activeAgentMeta: displayAgentMeta,
+          activeAgentId: targetAgentId || "",
+          selectedAgentIndex: state.selectedAgentIndex,
+          agentListWindowStart: state.agentListWindowStart,
+          projectListWindowStart: state.projectListWindowStart,
+          maxProjectWindow: 5,
+          maxWidth: Math.max(20, size.cols || 80),
+          getAgentLabel: (id) => getAgentLabelFor(displayAgentMeta.get(id), id),
+          getAgentState: (id) => {
+            const meta = displayAgentMeta.get(id);
+            return meta && typeof meta.activity_state === "string" ? meta.activity_state : "";
+          },
+          launchMode: state.settings.launchMode,
+          agentProvider: state.settings.agentProvider,
+          modeOptions: state.modeOptions,
+          selectedModeIndex: state.selectedModeIndex,
+          providerOptions: state.providerOptions,
+          selectedProviderIndex: state.selectedProviderIndex,
+          cronTasks: state.cronTasks,
+          selectedCronIndex: state.selectedCronIndex,
+          projects: state.projects,
+          selectedProjectIndex: state.selectedProjectIndex,
+          activeProjectRoot: currentProjectRoot,
+          dashHints: buildDashHints(state, targetAgentLabel),
+        }),
+      };
+    }
+
+    useEffect(() => {
+      if (!multiWindowActive) return;
+      const controller = multiWindowControllerRef.current;
+      if (controller && typeof controller.renderAll === "function") {
+        controller.renderAll();
+      }
+    }, [multiWindowActive, completionsOpen, completions.length, completionIndex, completionWindowStart]);
+
+    if (multiWindowActive) {
+      return null;
+    }
+
+    const renderChatLogLine = (item) => {
+      const row = classifyChatLogLine((item && item.text) || "");
+      const key = item && item.id ? item.id : `log-${row.body}`;
+      if (row.kind === "spacer") {
+        return h(Text, { key, color: "gray" }, " ");
+      }
+      const palette = {
+        assistant: { marker: "cyan", speaker: "white", body: undefined, bold: true },
+        agent: { marker: "cyan", speaker: "cyan", body: undefined, bold: false },
+        error: { marker: "red", speaker: "red", body: "red", bold: true },
+        success: { marker: "green", speaker: "green", body: "green", bold: false },
+        divider: { marker: "gray", speaker: "gray", body: "gray", bold: false },
+        banner: { marker: "cyan", speaker: "cyan", body: "cyan", bold: true },
+        meta: { marker: "gray", speaker: "gray", body: "gray", bold: false },
+        plain: { marker: "gray", speaker: "gray", body: undefined, bold: false },
+      };
+      const colors = palette[row.kind] || palette.plain;
+      if (row.kind === "divider") {
+        return h(Box, { key, marginBottom: 1 },
+          h(Text, { color: colors.body, wrap: "truncate" }, row.body),
+        );
+      }
+      if (row.kind === "banner") {
+        return h(Box, { key, marginBottom: 1 },
+          h(Text, { color: colors.body, bold: true, wrap: "truncate" }, row.body),
+        );
+      }
+      return h(Box, { key, width: "100%", marginBottom: 1 },
+        h(Box, { width: 2 },
+          h(Text, { color: colors.marker, bold: row.kind === "error" }, row.marker || " "),
+        ),
+        row.speaker
+          ? h(Text, { color: colors.speaker, bold: colors.bold }, row.speaker)
+          : null,
+        row.speaker
+          ? h(Text, { color: "gray" }, " · ")
+          : null,
+        h(Text, { color: colors.body, wrap: "wrap" }, row.body || " "),
+      );
+    };
+
     if (state.viewingAgentId) {
       const maxWidth = Math.max(20, size.cols || 80);
       const logRows = Math.max(1, (size.rows || 24) - 5);
@@ -2659,7 +3357,7 @@ function createChatApp({ React, ink, props, interactive = true }) {
 
     return h(Box, { flexDirection: "column", width: "100%" },
       h(Box, { flexDirection: "column", width: "100%" },
-        ...state.logLines.map((item) => h(Text, { key: item.id }, item.text || " ")),
+        ...state.logLines.map(renderChatLogLine),
       ),
       state.activeMerge ? h(Box, null,
         h(Text, { color: state.activeMerge.entries.some((e) => e.isError) ? "red" : "cyan" },
@@ -2671,10 +3369,10 @@ function createChatApp({ React, ink, props, interactive = true }) {
           const prefix = state.activeStream.publisher
             ? `${state.activeStream.publisher}: `
             : "";
-          return lines.map((line, idx) => h(Text, {
-            key: `s-${idx}`,
-            color: "cyan",
-          }, idx === 0 ? `${prefix}${line}` : `  ${line}`));
+          return lines.map((line, idx) => renderChatLogLine({
+            id: `s-${idx}`,
+            text: idx === 0 ? `${prefix}${line}` : `  ${line}`,
+          }));
         })(),
       ) : null,
       h(Box, { marginTop: 1, width: "100%" },
@@ -2739,6 +3437,15 @@ function createChatApp({ React, ink, props, interactive = true }) {
           interceptArrowsAndEnter: completionsOpen,
           placeholder: "",
           promptPrefix,
+          // Dashboard renders 2 rows in global mode (always shows the
+          // projects rail) or when an agents/mode/provider/cron view is
+          // focused; otherwise it's a single summary row. Telling
+          // MultilineInput how many UI rows live below it lets the IME
+          // composition popup follow the on-screen caret instead of
+          // appearing at the bottom-right of the terminal.
+          linesBelowInput: props.globalMode
+            ? 2
+            : (state.focusMode === "dashboard" ? 2 : 1),
         }),
       ),
       h(DashboardBar, {
@@ -2795,6 +3502,15 @@ function computeStatusText(status, spinnerTick) {
   const message = String((status && status.message) || "");
   if (!message) return "CHAT · Ready";
   const type = String((status && status.type) || "thinking");
+  if (type === "done" || type === "success") {
+    const clean = stripBlessedTags(message).trim();
+    return /^[✓✔]/.test(clean) ? clean : `✓ ${clean}`;
+  }
+  if (type === "error") {
+    const clean = stripBlessedTags(message).trim();
+    return /^[✗!]/.test(clean) ? clean : `✗ ${clean}`;
+  }
+  if (!isAnimatedStatusType(type)) return stripBlessedTags(message).trim() || "CHAT · Ready";
   const indicators = fmt.STATUS_INDICATORS[type] || fmt.STATUS_INDICATORS.thinking;
   const indicator = indicators[Math.max(0, Math.floor(Number(spinnerTick) || 0)) % indicators.length];
   const startedAt = Number.isFinite(status && status.startedAt) ? status.startedAt : 0;
@@ -2823,12 +3539,12 @@ async function runChatInk(projectRoot, options = {}) {
     env.startDaemon(projectRoot);
   }
 
-  const { socketPath } = require("../../daemon");
-  const { connectWithRetry } = require("../../chat/transport");
-  const { createDaemonTransport } = require("../../chat/daemonTransport");
-  const { createDaemonConnection } = require("../../chat/daemonConnection");
-  const { createDaemonCoordinator } = require("../../chat/daemonCoordinator");
-  const { startDaemon, stopDaemon } = require("../../chat/transport");
+  const { socketPath } = require("../../runtime/daemon");
+  const { connectWithRetry } = require("../../app/chat/transport");
+  const { createDaemonTransport } = require("../../app/chat/daemonTransport");
+  const { createDaemonConnection } = require("../../app/chat/daemonConnection");
+  const { createDaemonCoordinator } = require("../../app/chat/daemonCoordinator");
+  const { startDaemon, stopDaemon } = require("../../app/chat/transport");
   const { loadConfig } = require("../../config");
   const { startAgentMirror, startInternalAgentMirror } = require("./agentMirror");
   const sock = socketPath(projectRoot);
@@ -2939,10 +3655,18 @@ module.exports = {
   buildDirectBusSendRequest,
   buildPromptIpcRequest,
   chatHistoryOptionsForScope,
+  classifyChatLogLine,
+  createInkMultiWindowToggle,
   resolveActiveAgentId,
+  resolveInjectSockPathForAgent,
   resolveAgentEnterRequest,
+  resolveDashboardAgentEnterAction,
+  buildEmptyProjectsDownActions,
   buildInternalLogRows,
+  computeStatusText,
   computeInternalStatusText,
+  inferStatusType,
+  isAnimatedStatusType,
   resolveInternalKeyName,
   isInternalViewingAgent,
   applyInternalAgentTermWrite,