u-foo 2.3.32 → 2.4.0

package/src/{chat → app/chat}/commands.js

@@ -35,6 +35,7 @@ const COMMAND_TREE = {
       stop: { desc: "Stop cron task by id or all" },
     },
   },
+  "/clear": { desc: "Clear chat log on screen" },
   "/group": {
     desc: "Agent group orchestration",
     children: {
@@ -47,13 +48,15 @@ const COMMAND_TREE = {
     },
   },
   "/init": { desc: "Initialize modules" },
+  "/multi": { desc: "Toggle multi-window agent view" },
   "/open": { desc: "Open project path in global mode" },
   "/launch": {
     desc: "Launch new agent",
     children: {
-      claude: { desc: "Launch Claude agent" },
-      codex: { desc: "Launch Codex agent" },
-      ucode: { desc: "Launch ucode core agent" },
+      claude: { desc: "Launch Claude agent", order: 1 },
+      codex: { desc: "Launch Codex agent", order: 2 },
+      agy: { desc: "Launch Antigravity (agy) agent", order: 3 },
+      ucode: { desc: "Launch ucode core agent", order: 4 },
     },
   },
   "/project": {
@@ -136,7 +139,7 @@ const COMMAND_TREE = {
     },
   },
   "/status": { desc: "Status display" },
-  "/ufoo": { desc: "ufoo protocol (session marker)" },
+  "/ufoo": { desc: "ufoo protocol" },
 };
 
 const COMMAND_ORDER = ["/launch", "/group", "/bus", "/ctx"];
@@ -196,10 +199,120 @@ function parseCommand(text) {
   return { command, args };
 }
 
+function parseCommandOptions(args = []) {
+  const options = {};
+  const positional = [];
+  for (const arg of args) {
+    const raw = String(arg || "").trim();
+    if (!raw) continue;
+    if (raw.includes("=")) {
+      const [key, value] = raw.split("=", 2);
+      options[String(key || "").trim().toLowerCase()] = String(value || "").trim();
+    } else {
+      positional.push(raw);
+    }
+  }
+  return { options, positional };
+}
+
+function normalizeAgentLabel(value = "") {
+  const raw = String(value || "").trim().toLowerCase();
+  if (raw === "claude" || raw === "uclaude") return "claude";
+  if (raw === "codex" || raw === "ucodex") return "codex";
+  if (raw === "agy" || raw === "antigravity" || raw === "uagy") return "agy";
+  if (raw === "ucode" || raw === "ufoo") return "ufoo";
+  return raw || "agent";
+}
+
+function describeCommandForChat(text) {
+  const parsed = parseCommand(String(text || "").trim());
+  if (!parsed) return "";
+  const command = String(parsed.command || "").trim().toLowerCase();
+  const args = parsed.args || [];
+  const sub = String(args[0] || "").trim().toLowerCase();
+  const { options, positional } = parseCommandOptions(args);
+
+  if (command === "launch") {
+    const agent = normalizeAgentLabel(args[0]);
+    const nickname = options.nickname || options.nick || options.name || "";
+    const profile = options.profile || options.prompt_profile || "";
+    const count = parseInt(options.count || "1", 10);
+    const scope = options.scope || options.launch_scope || positional.slice(1).find((item) =>
+      /^(window|new-window|separate|inplace|same|current|tab|pane)$/i.test(item)
+    ) || "";
+    const base = nickname
+      ? `Launching a ${agent} named ${nickname}`
+      : (Number.isFinite(count) && count > 1 ? `Launching ${count} ${agent} agents` : `Launching a ${agent} agent`);
+    return `${base}${profile ? ` with profile ${profile}` : ""}${/^(window|new-window|separate)$/i.test(scope) ? " in a new window" : ""}`;
+  }
+
+  if (command === "group") {
+    if (sub === "run") return `Launching group ${args[1] || "template"}`;
+    if (sub === "status") return `Checking group ${args[1] || "status"}`;
+    if (sub === "stop") return `Stopping group ${args[1] || "run"}`;
+    if (sub === "diagram") return `Showing group diagram${args[1] ? ` for ${args[1]}` : ""}`;
+    if (sub === "template" || sub === "templates") return "Browsing group templates";
+    return "Managing agent groups";
+  }
+
+  if (command === "bus") {
+    if (sub === "send") return `Sending a message to ${args[1] || "an agent"}`;
+    if (sub === "rename") return `Renaming ${args[1] || "an agent"}${args[2] ? ` to ${args[2]}` : ""}`;
+    if (sub === "activate") return `Activating ${args[1] || "an agent"}`;
+    if (sub === "list") return "Listing active agents";
+    if (sub === "status") return "Checking bus status";
+    return "Using the event bus";
+  }
+
+  if (command === "daemon") {
+    if (sub === "start") return "Starting the ufoo daemon";
+    if (sub === "stop") return "Stopping the ufoo daemon";
+    if (sub === "restart") return "Restarting the ufoo daemon";
+    if (sub === "status") return "Checking daemon status";
+    return "Managing the ufoo daemon";
+  }
+
+  if (command === "project") {
+    if (sub === "switch") return `Switching to project ${args[1] || ""}`.trim();
+    if (sub === "current") return "Showing current project";
+    if (sub === "list") return "Listing running projects";
+    return "Managing projects";
+  }
+
+  if (command === "solo") {
+    if (sub === "run") return `Launching solo role ${args[1] || "agent"}`;
+    if (sub === "list") return "Listing solo roles";
+    return "Managing solo agents";
+  }
+
+  if (command === "role") {
+    if (sub === "assign") return `Assigning role ${args[2] || ""}${args[1] ? ` to ${args[1]}` : ""}`.trim();
+    if (sub === "list") return "Listing roles";
+    return "Managing roles";
+  }
+
+  if (command === "cron") {
+    if (sub === "start") return "Creating a cron task";
+    if (sub === "stop") return `Stopping cron task ${args[1] || ""}`.trim();
+    if (sub === "list") return "Listing cron tasks";
+    return "Managing cron tasks";
+  }
+
+  if (command === "settings") return !sub || sub === "show" ? "Showing settings" : "Updating settings";
+  if (command === "ctx") return `Checking context${sub ? ` ${sub}` : ""}`;
+  if (command === "doctor") return "Running ufoo diagnostics";
+  if (command === "clear") return "Clearing the chat log";
+  if (command === "multi") return "Toggling multi-pane view";
+  if (command === "open") return `Opening project ${args[0] || ""}`.trim();
+  if (command === "resume") return args[0] === "list" ? "Listing recoverable agents" : `Resuming ${args[0] || "agents"}`;
+  if (command === "init") return "Initializing ufoo modules";
+
+  return `Running /${command}`;
+}
+
 function shouldEchoCommandInChat(text) {
   const parsed = parseCommand(String(text || "").trim());
   if (!parsed) return true;
-  if (parsed.command === "group" && parsed.args[0] === "run") return false;
   return true;
 }
 
@@ -222,6 +335,7 @@ module.exports = {
   sortCommands,
   buildCommandRegistry,
   parseCommand,
+  describeCommandForChat,
   shouldEchoCommandInChat,
   parseAtTarget,
 };

package/src/{chat → app/chat}/daemonConnection.js

@@ -1,4 +1,4 @@
-const { IPC_REQUEST_TYPES } = require("../shared/eventContract");
+const { IPC_REQUEST_TYPES } = require("../../runtime/contracts/eventContract");
 
 function createDaemonConnection(options = {}) {
   const {

package/src/{chat → app/chat}/daemonMessageRouter.js

@@ -1,5 +1,5 @@
-const { IPC_RESPONSE_TYPES, BUS_STATUS_PHASES } = require("../shared/eventContract");
-const { renderMarkdownLines } = require("../shared/markdownRenderer");
+const { IPC_RESPONSE_TYPES, BUS_STATUS_PHASES } = require("../../runtime/contracts/eventContract");
+const { renderMarkdownLines } = require("../../ui/format/markdownRenderer");
 const { decodeEscapedNewlines } = require("./text");
 
 function createDaemonMessageRouter(options = {}) {
@@ -47,6 +47,45 @@ function createDaemonMessageRouter(options = {}) {
     return `{cyan-fg}${escapedLabel}{/cyan-fg} {gray-fg}·{/gray-fg} `;
   }
 
+  function launchTargetLabel(result = {}, renameResult = null) {
+    const nickname = (renameResult && renameResult.ok && renameResult.nickname)
+      || result.nickname
+      || "";
+    if (nickname) return nickname;
+    const ids = Array.isArray(result.subscriber_ids) ? result.subscriber_ids : [];
+    return ids[0] || result.agent_id || "";
+  }
+
+  function buildLifecycleSummary(payload = {}, msg = {}) {
+    const ops = Array.isArray(payload.ops) ? payload.ops : [];
+    const results = Array.isArray(msg.opsResults) ? msg.opsResults : [];
+    if (ops.length === 0) return "";
+    const launchOp = ops.find((op) => op && op.action === "launch");
+    if (launchOp) {
+      const launchResult = results.find((item) => item && item.action === "launch") || {};
+      const renameResult = results.find((item) => item && item.action === "rename" && item.ok);
+      if (launchResult.ok === false) {
+        return `Launch failed: ${launchResult.error || "unknown error"}`;
+      }
+      const agent = String(launchResult.agent || launchOp.agent || "agent").trim();
+      const count = Number(launchResult.count || launchOp.count || 1);
+      const ids = Array.isArray(launchResult.subscriber_ids) ? launchResult.subscriber_ids.filter(Boolean) : [];
+      const target = launchTargetLabel(launchResult, renameResult);
+      if (launchResult.skipped && target) return `Reused ${agent}:${target}`;
+      if (ids.length > 1) return `Launched ${ids.length} ${agent} agents: ${ids.join(", ")}`;
+      if (target) return `Launched ${agent}:${target}`;
+      if (count > 1) return `Launched ${count} ${agent} agents`;
+      return `Launched a ${agent} agent`;
+    }
+    const closeOp = ops.find((op) => op && op.action === "close");
+    if (closeOp) {
+      const closeResult = results.find((item) => item && item.action === "close") || {};
+      if (closeResult.ok === false) return `Close failed: ${closeResult.error || "unknown error"}`;
+      return `Closed ${closeResult.agent_id || closeOp.agent_id || closeOp.target || "agent"}`;
+    }
+    return "";
+  }
+
   function normalizeDisplayMessage(raw) {
     let displayMessage = raw || "";
     let streamPayload = null;
@@ -223,7 +262,10 @@ function createDaemonMessageRouter(options = {}) {
         /^Group started\b/i.test(replyText)
       );
       // Suppress lifecycle confirmations from chat history — status line plus structured payload is enough.
-      if (!isLifecycleStatusOnly && !isGroupStartedConfirmation) {
+      if (isLifecycleStatusOnly) {
+        const summary = buildLifecycleSummary(payload, msg);
+        if (summary) logMessage("reply", `${speakerPrefix("ufoo", "white")}${escapeBlessed(summary)}`);
+      } else if (!isGroupStartedConfirmation) {
         logMessage("reply", `${speakerPrefix("ufoo", "white")}${escapeBlessed(replyText)}`);
       }
     }

package/src/{chat → app/chat}/dashboardView.js

@@ -1,9 +1,10 @@
 const { clampAgentWindowWithSelection } = require("./agentDirectory");
 
-const DEFAULT_MODE_OPTIONS = ["auto", "host", "terminal", "tmux", "internal-pty", "internal"];
+const DEFAULT_MODE_OPTIONS = ["auto", "host", "terminal", "tmux", "internal"];
 
 function providerLabel(value) {
   if (value === "claude-cli") return "claude";
+  if (value === "agy-cli" || value === "agy" || value === "antigravity") return "agy";
   if (value === "ucode" || value === "ufoo" || value === "ufoo-code") return "ucode";
   return "codex";
 }

package/src/app/chat/index.js

@@ -0,0 +1,6 @@
+async function runChat(projectRoot, options = {}) {
+  const { runChatInk } = require("../../ui/ink/ChatApp");
+  return runChatInk(projectRoot, options);
+}
+
+module.exports = { runChat };

package/src/{chat → app/chat}/inputSubmitHandler.js

@@ -1,6 +1,6 @@
-const { IPC_REQUEST_TYPES } = require("../shared/eventContract");
+const { IPC_REQUEST_TYPES } = require("../../runtime/contracts/eventContract");
 const { decodeEscapedNewlines } = require("./text");
-const { shouldEchoCommandInChat } = require("./commands");
+const { describeCommandForChat, shouldEchoCommandInChat } = require("./commands");
 const { parseShellCommand, runShellCommand: defaultRunShellCommand } = require("./shellCommand");
 
 function createInputSubmitHandler(options = {}) {
@@ -20,8 +20,6 @@ function createInputSubmitHandler(options = {}) {
     enterAgentView = () => {},
     getAgentAdapter = () => null,
     activateAgent = async () => {},
-    getInjectSockPath = () => "",
-    existsSync = () => false,
     commitInputHistory = () => {},
     focusInput = () => {},
     renderScreen = () => {},  // Add renderScreen callback
@@ -42,17 +40,9 @@ function createInputSubmitHandler(options = {}) {
   async function tryActivateTargetAgent(agentId) {
     const adapter = getAgentAdapter(agentId);
     const capabilities = adapter && adapter.capabilities ? adapter.capabilities : null;
-    const sockPath = getInjectSockPath(agentId);
-    const supportsSocket = Boolean(capabilities && capabilities.supportsSocketProtocol);
     const supportsActivate = Boolean(capabilities && capabilities.supportsActivate);
     const supportsInternalQueue = Boolean(capabilities && capabilities.supportsInternalQueueLoop);
 
-    if (existsSync(sockPath) && supportsSocket) {
-      clearTargetAgent();
-      enterAgentView(agentId);
-      return true;
-    }
-
     if (supportsActivate) {
       clearTargetAgent();
       try {
@@ -179,7 +169,8 @@ function createInputSubmitHandler(options = {}) {
 
     if (text.startsWith("/")) {
       if (shouldEchoCommandInChat(text)) {
-        logMessage("user", userEcho(text));
+        const commandSummary = describeCommandForChat(text);
+        logMessage("user", userEcho(commandSummary || text));
         renderScreen();  // Render slash command immediately
       }
       try {

package/src/{chat → app/chat}/internalAgentLogHistory.js

@@ -2,7 +2,7 @@
 
 const fs = require("fs");
 const path = require("path");
-const { getUfooPaths } = require("../ufoo/paths");
+const { getUfooPaths } = require("../../coordination/state/paths");
 
 function stripAnsi(text = "") {
   return String(text || "").replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "")

package/src/app/chat/multiWindow/index.js

@@ -0,0 +1,268 @@
+const { calculatePaneLayout } = require("./paneLayout");
+const { createPaneManager } = require("./paneManager");
+const { createRenderer } = require("./renderer");
+
+function createMultiWindowController(options = {}) {
+  const {
+    processStdout = process.stdout,
+    getRows = () => process.stdout.rows || 24,
+    getCols = () => process.stdout.columns || 80,
+    getInjectSockPath = () => "",
+    getActiveAgents = () => [],
+    getAgentPaneOptions = () => ({}),
+    getChatLogLines = () => [],
+    getStatusText = () => "",
+    getPromptPrefix = () => "› ",
+    getCurrentDraft = () => "",
+    getCursorPos = () => 0,
+    getCompletions = () => ({ items: [], index: -1, windowStart: 0, pageSize: 8 }),
+    getAgentLabel = (id) => id,
+    getInternalPaneInfo = () => ({}),
+    getDashboardLines = () => [],
+    getTerminalFocused = () => false,
+    freezeScreen = () => {},
+    restoreTerminal = () => {},
+    onExit = () => {},
+    onFocusAgent = () => {},
+    onInternalSubmit = () => {},
+  } = options;
+
+  let active = false;
+  let renderThrottleTimer = null;
+  let dirtyPanes = new Set();
+  let lastCompletionPopup = null;
+  const renderer = createRenderer({ write: (d) => processStdout.write(d) });
+  const paneManager = createPaneManager({
+    getInjectSockPath,
+    onInternalSubmit,
+    onPaneOutput: (agentId) => {
+      if (!active) return;
+      if (getTerminalFocused()) {
+        renderSinglePane(agentId);
+      } else {
+        dirtyPanes.add(agentId);
+        if (!renderThrottleTimer) {
+          renderThrottleTimer = setTimeout(() => {
+            renderThrottleTimer = null;
+            const panes = [...dirtyPanes];
+            dirtyPanes.clear();
+            for (const id of panes) renderSinglePane(id);
+          }, 200);
+        }
+      }
+    },
+  });
+
+  function enter() {
+    const agents = getActiveAgents();
+    if (agents.length === 0) return false;
+    if (active) return false;
+    active = true;
+    freezeScreen(true);
+    renderer.hideCursor();
+    renderer.clear();
+    syncAgents();
+    renderAll();
+    return true;
+  }
+
+  function exit() {
+    if (!active) return;
+    active = false;
+    if (renderThrottleTimer) {
+      clearTimeout(renderThrottleTimer);
+      renderThrottleTimer = null;
+      dirtyPanes.clear();
+    }
+    paneManager.disconnectAll();
+    renderer.showCursor();
+    restoreTerminal();
+    freezeScreen(false);
+    onExit();
+  }
+
+  function syncAgents() {
+    const agents = getActiveAgents();
+    const current = new Set(paneManager.getAgentIds());
+    const layout = calculatePaneLayout(getCols(), getRows(), agents.length);
+
+    for (let i = 0; i < agents.length; i++) {
+      const id = agents[i];
+      const pane = layout.agentPanes[i];
+      if (!pane) continue;
+      const innerW = Math.max(1, pane.width - 2);
+      const innerH = Math.max(1, pane.height - 2);
+      if (!current.has(id)) {
+        paneManager.addAgent(id, innerW, innerH, getAgentPaneOptions(id) || {});
+      } else {
+        paneManager.sendResize(id, innerW, innerH);
+      }
+    }
+    for (const id of current) {
+      if (!agents.includes(id)) {
+        paneManager.removeAgent(id);
+      }
+    }
+  }
+
+  function renderSinglePane(agentId) {
+    if (!active) return;
+    try {
+      const agents = paneManager.getAgentIds();
+      const layout = calculatePaneLayout(getCols(), getRows(), agents.length);
+      const idx = agents.indexOf(agentId);
+      if (idx < 0 || !layout.agentPanes[idx]) return;
+      const pane = paneManager.getPane(agentId);
+      if (!pane) return;
+      const isFocused = getTerminalFocused() && agentId === paneManager.getFocused();
+      if (pane.mode === "internal" && typeof renderer.renderInternalPane === "function") {
+        renderer.renderInternalPane(pane.vt, layout.agentPanes[idx], isFocused, {
+          label: getAgentLabel(agentId),
+          ...(getInternalPaneInfo(agentId) || {}),
+          input: pane.internalInput || "",
+          cursor: pane.internalCursor || 0,
+        });
+      } else {
+        renderer.renderPane(pane.vt, layout.agentPanes[idx], isFocused, getAgentLabel(agentId));
+      }
+    } catch {
+      // swallow render errors to prevent crash
+    }
+  }
+
+  function renderAll() {
+    if (!active) return;
+    try {
+      const agents = paneManager.getAgentIds();
+      const layout = calculatePaneLayout(getCols(), getRows(), agents.length);
+      const cols = getCols();
+
+      renderer.renderChatLog(layout.chatPane, getChatLogLines());
+
+      const focused = getTerminalFocused() ? paneManager.getFocused() : null;
+      for (let i = 0; i < agents.length; i++) {
+        const pane = paneManager.getPane(agents[i]);
+        if (!pane || !layout.agentPanes[i]) continue;
+        if (pane.mode === "internal" && typeof renderer.renderInternalPane === "function") {
+          renderer.renderInternalPane(pane.vt, layout.agentPanes[i], agents[i] === focused, {
+            label: getAgentLabel(agents[i]),
+            ...(getInternalPaneInfo(agents[i]) || {}),
+            input: pane.internalInput || "",
+            cursor: pane.internalCursor || 0,
+          });
+        } else {
+          renderer.renderPane(pane.vt, layout.agentPanes[i], agents[i] === focused, getAgentLabel(agents[i]));
+        }
+      }
+
+      const chatFocused = !getTerminalFocused();
+      if (layout.separatorPane) {
+        renderer.renderSeparator(layout.separatorPane, chatFocused);
+      }
+      if (layout.statusPane) {
+        renderer.renderStatusLine(layout.statusPane, getStatusText());
+      }
+      if (layout.inputPane) {
+        renderer.renderInputPrompt(layout.inputPane, getPromptPrefix(), getCurrentDraft(), getCursorPos());
+      }
+      if (layout.inputSepPane) {
+        renderer.renderSeparator(layout.inputSepPane, chatFocused);
+      }
+      if (layout.dashboardPane) {
+        const lines = getDashboardLines();
+        renderer.renderDashboard(layout.dashboardPane, lines);
+      }
+
+      const cmp = getCompletions();
+      let nextCompletionPopup = null;
+      if (lastCompletionPopup && typeof renderer.clearRows === "function") {
+        renderer.clearRows(
+          lastCompletionPopup.top,
+          lastCompletionPopup.height,
+          lastCompletionPopup.width,
+          lastCompletionPopup.left || 0
+        );
+      }
+      if (cmp && Array.isArray(cmp.items) && cmp.items.length > 0 && layout.inputPane) {
+        const start = Math.min(cmp.windowStart || 0, Math.max(0, cmp.items.length - (cmp.pageSize || 8)));
+        const end = Math.min(cmp.items.length, start + (cmp.pageSize || 8));
+        const visible = cmp.items.slice(start, end);
+        const popupTop = layout.inputPane.top - visible.length - 1;
+        if (popupTop >= 0) {
+          nextCompletionPopup = { top: popupTop, left: 0, width: cols, height: visible.length + 1 };
+          renderer.renderSeparator({ top: popupTop, left: 0, width: cols });
+          for (let i = 0; i < visible.length; i++) {
+            const idx = start + i;
+            const selected = idx === cmp.index;
+            const label = visible[i].label || "";
+            const desc = visible[i].description || "";
+            const line = selected
+              ? `\x1b[7;36m${label}\x1b[0m  \x1b[90m${desc}\x1b[0m`
+              : `\x1b[90m${label}  ${desc}\x1b[0m`;
+            const pad = Math.max(0, cols - renderer.visibleLength(line));
+            renderer.write(renderer.moveTo(popupTop + 1 + i, 0) + line + " ".repeat(pad) + "\x1b[0m");
+          }
+        }
+      }
+      lastCompletionPopup = nextCompletionPopup;
+    } catch {
+      // swallow render errors to prevent crash
+    }
+  }
+
+  function handleKey(key) {
+    if (!active) return false;
+
+    if (key.name === "c" && key.ctrl) {
+      return false;
+    }
+
+    if (key.name === "w" && key.ctrl) {
+      paneManager.cycleFocus();
+      renderAll();
+      return true;
+    }
+
+    if (key.name === "q" && key.ctrl) {
+      exit();
+      return true;
+    }
+
+    return false;
+  }
+
+  function focusAgent(agentId) {
+    if (!active) return;
+    const agents = paneManager.getAgentIds();
+    if (!agents.includes(agentId)) return;
+    paneManager.setFocused(agentId);
+    onFocusAgent(agentId);
+    renderAll();
+  }
+
+  function handleResize() {
+    if (!active) return;
+    syncAgents();
+    renderer.clear();
+    renderAll();
+  }
+
+  function isActive() { return active; }
+
+  return {
+    enter,
+    exit,
+    isActive,
+    handleKey,
+    handleResize,
+    syncAgents,
+    renderAll,
+    focusAgent,
+    sendInput: (data) => paneManager.sendInput(data),
+    writeToPane: (agentId, data) => paneManager.writeToPane(agentId, data),
+    getFocused: () => paneManager.getFocused(),
+    getAgentIds: () => paneManager.getAgentIds(),
+  };
+}
+
+module.exports = { createMultiWindowController };

package/src/app/chat/multiWindow/paneLayout.js

@@ -0,0 +1,84 @@
+function calculatePaneLayout(termCols, termRows, agentCount) {
+  const bottomRows = 5;
+  const safeRows = termRows - 1;
+  const contentHeight = Math.max(1, safeRows - bottomRows);
+  const bottomTop = contentHeight;
+
+  const statusPane = { top: bottomTop, left: 0, width: termCols };
+  const separatorPane = { top: bottomTop + 1, left: 0, width: termCols };
+  const inputPane = { top: bottomTop + 2, left: 0, width: termCols };
+  const inputSepPane = { top: bottomTop + 3, left: 0, width: termCols };
+  const dashboardPane = { top: bottomTop + 4, left: 0, width: termCols };
+
+  if (agentCount <= 0) {
+    return {
+      separatorPane,
+      statusPane,
+      inputPane,
+      inputSepPane,
+      dashboardPane,
+      chatPane: { top: 0, left: 0, width: termCols, height: contentHeight },
+      agentPanes: [],
+    };
+  }
+
+  const chatWidth = Math.floor(termCols / 3);
+  const rightLeft = chatWidth + 1;
+  const rightWidth = termCols - chatWidth - 1;
+
+  const chatPane = { top: 0, left: 0, width: chatWidth, height: contentHeight };
+
+  if (rightWidth < 4 || contentHeight < 3) {
+    return {
+      separatorPane,
+      statusPane,
+      inputPane,
+      inputSepPane,
+      dashboardPane,
+      chatPane: { top: 0, left: 0, width: termCols, height: contentHeight },
+      agentPanes: [],
+    };
+  }
+
+  const agentPanes = layoutAgentPanes(rightLeft, rightWidth, contentHeight, agentCount, 0);
+  return { separatorPane, statusPane, inputPane, inputSepPane, dashboardPane, chatPane, agentPanes };
+}
+
+function layoutAgentPanes(left, width, height, count, topOffset = 0) {
+  if (count === 1) {
+    return [{ top: topOffset, left, width, height }];
+  }
+  if (count === 2) {
+    const h1 = Math.floor(height / 2);
+    return [
+      { top: topOffset, left, width, height: h1 },
+      { top: topOffset + h1, left, width, height: height - h1 },
+    ];
+  }
+
+  const rowCount = Math.ceil(count / 2);
+  const rowHeight = Math.floor(height / rowCount);
+  const panes = [];
+  let placed = 0;
+
+  for (let row = 0; row < rowCount; row++) {
+    const rowTop = topOffset + row * rowHeight;
+    const actualHeight = row === rowCount - 1 ? height - row * rowHeight : rowHeight;
+    const remaining = count - placed;
+    const isOddRow = remaining % 2 === 1 && row === 0 && count % 2 === 1;
+
+    if (isOddRow) {
+      panes.push({ top: rowTop, left, width, height: actualHeight });
+      placed++;
+    } else {
+      const halfWidth = Math.floor(width / 2);
+      panes.push({ top: rowTop, left, width: halfWidth, height: actualHeight });
+      panes.push({ top: rowTop, left: left + halfWidth + 1, width: width - halfWidth - 1, height: actualHeight });
+      placed += 2;
+    }
+  }
+
+  return panes;
+}
+
+module.exports = { calculatePaneLayout };