u-foo 3.0.10 → 3.0.12

package/src/app/chat/agentIdentity.js

@@ -0,0 +1,50 @@
+"use strict";
+
+/**
+ * Agent label / id resolution for chat (Phase 0B extraction).
+ */
+
+function getAgentLabelFor(meta, agentId) {
+  if (meta && meta.display_nickname) return meta.display_nickname;
+  if (meta && meta.nickname) return meta.nickname;
+  if (!agentId) return "";
+  const colon = agentId.indexOf(":");
+  if (colon < 0) return agentId;
+  const head = agentId.slice(0, colon);
+  const tail = agentId.slice(colon + 1).slice(0, 6);
+  return tail ? `${head}:${tail}` : head;
+}
+
+function buildActiveAgentLabelMap(activeAgents = [], activeAgentMeta = new Map()) {
+  const out = new Map();
+  const metaMap = activeAgentMeta instanceof Map ? activeAgentMeta : new Map();
+  for (const id of Array.isArray(activeAgents) ? activeAgents : []) {
+    out.set(id, getAgentLabelFor(metaMap.get(id), id));
+  }
+  return out;
+}
+
+function resolveActiveAgentId(label, activeAgents = [], activeAgentMeta = new Map()) {
+  const { resolveAgentId } = require("./agentDirectory");
+  const metaMap = activeAgentMeta instanceof Map ? activeAgentMeta : new Map();
+  return resolveAgentId({
+    label,
+    activeAgents: Array.isArray(activeAgents) ? activeAgents : [],
+    labelMap: buildActiveAgentLabelMap(activeAgents, metaMap),
+    lookupNickname: (nickname) => {
+      for (const [id, meta] of metaMap.entries()) {
+        if (!meta) continue;
+        if (meta.nickname === nickname || meta.scoped_nickname === nickname || meta.display_nickname === nickname) {
+          return id;
+        }
+      }
+      return null;
+    },
+  });
+}
+
+module.exports = {
+  getAgentLabelFor,
+  buildActiveAgentLabelMap,
+  resolveActiveAgentId,
+};

package/src/app/chat/bootstrap.js

@@ -0,0 +1,66 @@
+"use strict";
+
+/**
+ * Chat bootstrap helpers (Phase 0B extraction from ChatApp).
+ * Headless — safe for ChatController and unit tests without Ink.
+ */
+
+const path = require("path");
+const fs = require("fs");
+const crypto = require("crypto");
+
+function bootstrapEnvironment(projectRoot, options = {}) {
+  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;
+  try {
+    activeProjectRoot = canonicalProjectRoot(projectRoot);
+  } catch {
+    activeProjectRoot = path.resolve(projectRoot || process.cwd());
+  }
+
+  const runtimePaths = getUfooPaths(projectRoot);
+  const contextIndexFile = path.join(runtimePaths.ufooDir, "context", "decisions.jsonl");
+  const needsBootstrap = globalMode && (
+    !fs.existsSync(runtimePaths.ufooDir)
+    || !fs.existsSync(runtimePaths.busDir)
+    || !fs.existsSync(runtimePaths.agentDir)
+    || !fs.existsSync(contextIndexFile)
+  );
+
+  return {
+    activeProjectRoot,
+    globalMode,
+    runtimePaths,
+    needsBootstrap,
+    UfooInit,
+    isRunning,
+    startDaemon,
+  };
+}
+
+async function ensureSubscriberId(projectRoot) {
+  if (process.env.UFOO_SUBSCRIBER_ID) return;
+  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 });
+  let sessionId;
+  if (fs.existsSync(sessionFile)) {
+    sessionId = fs.readFileSync(sessionFile, "utf8").trim();
+  } else {
+    sessionId = crypto.randomBytes(4).toString("hex");
+    fs.writeFileSync(sessionFile, sessionId, "utf8");
+  }
+  process.env.UFOO_SUBSCRIBER_ID = `claude-code:${sessionId}`;
+}
+
+module.exports = {
+  bootstrapEnvironment,
+  ensureSubscriberId,
+};

package/src/app/chat/commandExecutor.js

@@ -9,10 +9,19 @@ const {
   loadGlobalUcodeConfig,
   saveGlobalUcodeConfig,
   normalizeControllerMode,
+  normalizeLaunchMode,
   SETTINGS_MODEL_DEFAULTS,
   defaultAgentModelForProvider,
   defaultRouterModelForProvider,
 } = require("../../config");
+
+const LAUNCH_MODE_OPTIONS = Object.freeze(["auto", "host", "terminal", "tmux", "internal"]);
+const AGENT_PROVIDER_OPTIONS = Object.freeze([
+  { label: "codex", value: "codex-cli" },
+  { label: "claude", value: "claude-cli" },
+  { label: "agy", value: "agy-cli" },
+  { label: "kimi", value: "kimi-cli" },
+]);
 const { resolveTransport } = require("../../code/nativeRunner");
 const { resolveDisplayNickname } = require("../../runtime/daemon/nicknameScope");
 const { parseIntervalMs, formatIntervalMs } = require("./cronScheduler");
@@ -167,6 +176,7 @@ function createCommandExecutor(options = {}) {
     schedule = (fn, ms) => setTimeout(fn, ms),
     clearLog = null,
     fetchModelsImpl = null,
+    applyChatSettings = null,
   } = options;
 
   if (!projectRoot) {
@@ -998,6 +1008,96 @@ function createCommandExecutor(options = {}) {
     return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
   }
 
+  function clearUfooAgentIdentity() {
+    try {
+      const { getUfooPaths } = require("../../coordination/state/paths");
+      const agentDir = getUfooPaths(projectRoot).agentDir;
+      const fsModule = require("fs");
+      fsModule.rmSync(path.join(agentDir, "ufoo-agent.json"), { force: true });
+      fsModule.rmSync(path.join(agentDir, "ufoo-agent.history.jsonl"), { force: true });
+    } catch {
+      // Ignore cleanup failures.
+    }
+  }
+
+  async function notifyChatSettings(patch = {}) {
+    if (typeof applyChatSettings !== "function") return;
+    try {
+      await applyChatSettings(patch);
+    } catch {
+      // Host refresh is best-effort; config is already persisted.
+    }
+  }
+
+  async function handleModeCommand(args = []) {
+    const action = String(args[0] || "").trim().toLowerCase();
+    const config = loadConfig(projectRoot) || {};
+    const current = normalizeLaunchMode(config.launchMode || "auto");
+
+    if (!action || action === "show" || action === "status") {
+      logMessage("system", "{cyan-fg}launch mode:{/cyan-fg}");
+      logMessage("system", `  • current: ${current}`);
+      logMessage("system", `  • options: ${LAUNCH_MODE_OPTIONS.join(", ")}`);
+      logMessage("system", "  • use: /mode <auto|host|terminal|tmux|internal>");
+      return;
+    }
+
+    if (!LAUNCH_MODE_OPTIONS.includes(action)) {
+      logMessage(
+        "error",
+        `{white-fg}✗{/white-fg} Unknown mode: ${action}. Use: ${LAUNCH_MODE_OPTIONS.join("|")}`
+      );
+      return;
+    }
+
+    const next = normalizeLaunchMode(action);
+    if (next === current) {
+      logMessage("system", `{cyan-fg}launch mode:{/cyan-fg} already ${next}`);
+      return;
+    }
+
+    saveConfig(projectRoot, { launchMode: next });
+    logMessage("system", `{white-fg}✓{/white-fg} Launch mode: ${next}`);
+    await notifyChatSettings({ launchMode: next });
+    await restartDaemon(projectRoot);
+  }
+
+  async function handleProviderCommand(args = []) {
+    const action = String(args[0] || "").trim().toLowerCase();
+    const config = loadConfig(projectRoot) || {};
+    const current = normalizeSettingsProvider(config.agentProvider);
+    const labels = AGENT_PROVIDER_OPTIONS.map((opt) => opt.label).join(", ");
+
+    if (!action || action === "show" || action === "status") {
+      logMessage("system", "{cyan-fg}ufoo-agent provider:{/cyan-fg}");
+      logMessage("system", `  • current: ${agentProviderKey(current)}`);
+      logMessage("system", `  • options: ${labels}`);
+      logMessage("system", "  • use: /provider <codex|claude|agy|kimi>");
+      return;
+    }
+
+    const next = normalizeSettingsProvider(action, "");
+    const known = AGENT_PROVIDER_OPTIONS.some((opt) => opt.label === action || opt.value === next);
+    if (!next || !known) {
+      logMessage(
+        "error",
+        `{white-fg}✗{/white-fg} Unknown provider: ${action}. Use: ${AGENT_PROVIDER_OPTIONS.map((opt) => opt.label).join("|")}`
+      );
+      return;
+    }
+
+    if (next === current) {
+      logMessage("system", `{cyan-fg}ufoo-agent:{/cyan-fg} already ${agentProviderKey(next)}`);
+      return;
+    }
+
+    saveConfig(projectRoot, { agentProvider: next });
+    clearUfooAgentIdentity();
+    logMessage("system", `{white-fg}✓{/white-fg} ufoo-agent: ${agentProviderKey(next)}`);
+    await notifyChatSettings({ agentProvider: next });
+    await restartDaemon(projectRoot);
+  }
+
   async function handleCronCommand(args = []) {
     const action = String(args[0] || "").trim().toLowerCase();
     if (action === "list" || action === "ls") {
@@ -1861,6 +1961,12 @@ function createCommandExecutor(options = {}) {
       case "cron":
         await handleCronCommand(args);
         return true;
+      case "mode":
+        await handleModeCommand(args);
+        return true;
+      case "provider":
+        await handleProviderCommand(args);
+        return true;
       case "group":
         await handleGroupCommand(args);
         return true;
@@ -1893,6 +1999,8 @@ function createCommandExecutor(options = {}) {
     handleRoleCommand,
     handleSoloCommand,
     handleCronCommand,
+    handleModeCommand,
+    handleProviderCommand,
     handleGroupCommand,
     handleSettingsCommand,
     handleUcodeConfigCommand,

package/src/app/chat/commands.js

@@ -35,6 +35,27 @@ const COMMAND_TREE = {
       stop: { desc: "Stop cron task by id or all" },
     },
   },
+  "/mode": {
+    desc: "Set agent launch mode",
+    children: {
+      show: { desc: "Show current launch mode", order: 1 },
+      auto: { desc: "Auto-select launch mode", order: 2 },
+      host: { desc: "Launch via host inject", order: 3 },
+      terminal: { desc: "Launch in external terminal", order: 4 },
+      tmux: { desc: "Launch in tmux", order: 5 },
+      internal: { desc: "Launch as internal agent", order: 6 },
+    },
+  },
+  "/provider": {
+    desc: "Set ufoo-agent provider",
+    children: {
+      show: { desc: "Show current agent provider", order: 1 },
+      codex: { desc: "Use Codex", order: 2 },
+      claude: { desc: "Use Claude", order: 3 },
+      agy: { desc: "Use Antigravity (agy)", order: 4 },
+      kimi: { desc: "Use Kimi Code", order: 5 },
+    },
+  },
   "/clear": { desc: "Clear chat log on screen" },
   "/group": {
     desc: "Agent group orchestration",
@@ -315,6 +336,16 @@ function describeCommandForChat(text) {
     return "Managing cron tasks";
   }
 
+  if (command === "mode") {
+    if (!sub || sub === "show" || sub === "status") return "Showing launch mode";
+    return `Setting launch mode to ${sub}`;
+  }
+
+  if (command === "provider") {
+    if (!sub || sub === "show" || sub === "status") return "Showing agent provider";
+    return `Setting agent provider to ${sub}`;
+  }
+
   if (command === "mcp") {
     if (!sub || sub === "status") return "Checking MCP bridge status";
     if (sub === "tools") return "Listing MCP tools";

package/src/app/chat/dashboardView.js

@@ -48,8 +48,11 @@ function buildSummaryLine(options = {}) {
     : "none";
   let line = `{gray-fg}Agents:{/gray-fg} {cyan-fg}${agents}{/cyan-fg}`
     + `  {gray-fg}Mode:{/gray-fg} {cyan-fg}${launchMode}{/cyan-fg}`
-    + `  {gray-fg}Agent:{/gray-fg} {cyan-fg}${providerLabel(agentProvider)}{/cyan-fg}`
-    + `  {gray-fg}Cron:{/gray-fg} {cyan-fg}${Array.isArray(cronTasks) ? cronTasks.length : 0}{/cyan-fg}`;
+    + `  {gray-fg}Agent:{/gray-fg} {cyan-fg}${providerLabel(agentProvider)}{/cyan-fg}`;
+  const cronCount = Array.isArray(cronTasks) ? cronTasks.length : 0;
+  if (cronCount > 0) {
+    line += `  {gray-fg}Cron:{/gray-fg} {cyan-fg}${cronCount}{/cyan-fg}`;
+  }
   const loopPart = formatLoopSummary(loopSummary);
   if (loopPart) {
     line += `  {gray-fg}Loop:{/gray-fg} {cyan-fg}${loopPart}{/cyan-fg}`;
@@ -398,4 +401,5 @@ function computeDashboardContent(options = {}) {
 module.exports = {
   computeDashboardContent,
   providerLabel,
+  formatLoopSummary,
 };

package/src/app/chat/historyStore.js

@@ -0,0 +1,181 @@
+"use strict";
+
+/**
+ * Chat / input history persistence (Phase 0B extraction from ChatApp).
+ */
+
+const path = require("path");
+const fs = require("fs");
+const crypto = require("crypto");
+const { stripBlessedTags } = require("../../ui/chatLogModel");
+
+function projectRootToId(projectRoot) {
+  try {
+    const { buildProjectId } = require("../../runtime/projects");
+    return buildProjectId(projectRoot || process.cwd());
+  } catch {
+    return crypto.createHash("sha256").update(String(projectRoot || "")).digest("hex").slice(0, 16);
+  }
+}
+
+function inputHistoryFilePath(projectRoot, options = {}) {
+  const { getUfooPaths } = require("../../coordination/state/paths");
+  const { globalMode } = options || {};
+  if (globalMode) {
+    const os = require("os");
+    const globalChatRoot = path.join(os.homedir(), ".ufoo", "chat");
+    const globalDir = path.join(globalChatRoot, "global-input-history");
+    const projectId = projectRootToId(projectRoot);
+    return path.join(globalDir, `${projectId}.jsonl`);
+  }
+  return path.join(getUfooPaths(projectRoot || process.cwd()).ufooDir, "chat", "input-history.jsonl");
+}
+
+function chatHistoryFilePath(projectRoot, options = {}) {
+  const { getUfooPaths } = require("../../coordination/state/paths");
+  const { globalMode } = options || {};
+  if (globalMode) {
+    const os = require("os");
+    const globalChatRoot = path.join(os.homedir(), ".ufoo", "chat");
+    const globalDir = path.join(globalChatRoot, "global-history");
+    const projectId = projectRootToId(projectRoot);
+    return path.join(globalDir, `${projectId}.jsonl`);
+  }
+  return path.join(getUfooPaths(projectRoot || process.cwd()).ufooDir, "chat", "history.jsonl");
+}
+
+function normalizeHistoryLogLines(text = "") {
+  const clean = stripBlessedTags(text);
+  return clean.split(/\r?\n/);
+}
+
+function loadChatHistory(projectRoot, cap = 200, options = {}) {
+  const file = chatHistoryFilePath(projectRoot, options);
+  try {
+    if (!fs.existsSync(file)) return [];
+    const raw = fs.readFileSync(file, "utf8");
+    const lines = raw.split(/\r?\n/).filter(Boolean);
+    const out = [];
+    const pushLine = (line = "", sourceType = "") => {
+      const value = String(line || "");
+      if (!value.trim()) {
+        if (out.length > 0) {
+          const last = out[out.length - 1];
+          const lastText = typeof last === "object" ? last.text : last;
+          if (lastText !== "") out.push({ text: "", sourceType: sourceType || "system" });
+        }
+        return;
+      }
+      out.push(sourceType ? { text: value, sourceType } : value);
+    };
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (!entry) continue;
+        if (entry.type === "spacer") {
+          pushLine("", "system");
+          continue;
+        }
+        const text = String(entry.text || "");
+        if (!text) continue;
+        const sourceType = String(entry.type || "");
+        const stripped = text.replace(/\{[^{}]+\}/g, "");
+        for (const renderedLine of normalizeHistoryLogLines(stripped)) {
+          pushLine(renderedLine, sourceType);
+        }
+      } catch {
+        // ignore malformed lines
+      }
+    }
+    while (out.length > 0) {
+      const first = out[0];
+      const firstText = typeof first === "object" ? first.text : first;
+      if (firstText !== "") break;
+      out.shift();
+    }
+    while (out.length > 0) {
+      const last = out[out.length - 1];
+      const lastText = typeof last === "object" ? last.text : last;
+      if (lastText !== "") break;
+      out.pop();
+    }
+    const capped = out.slice(-cap);
+    while (capped.length > 0) {
+      const first = capped[0];
+      const firstText = typeof first === "object" ? first.text : first;
+      if (firstText !== "") break;
+      capped.shift();
+    }
+    return capped;
+  } catch {
+    return [];
+  }
+}
+
+function loadInputHistory(projectRoot, cap = 200, options = {}) {
+  const file = inputHistoryFilePath(projectRoot, options);
+  try {
+    if (!fs.existsSync(file)) return [];
+    const raw = fs.readFileSync(file, "utf8");
+    const lines = raw.split(/\r?\n/).filter(Boolean);
+    const out = [];
+    for (const line of lines) {
+      try {
+        const obj = JSON.parse(line);
+        const value = String((obj && obj.value) || "").trim();
+        if (value) out.push(value);
+      } catch {
+        // ignore malformed entries
+      }
+    }
+    return out.slice(-cap);
+  } catch {
+    return [];
+  }
+}
+
+function appendInputHistory(projectRoot, value, options = {}) {
+  const trimmed = String(value || "").trim();
+  if (!trimmed) return;
+  const file = inputHistoryFilePath(projectRoot, options);
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, `${JSON.stringify({ value: trimmed, ts: Date.now() })}\n`);
+  } catch {
+    // best-effort
+  }
+}
+
+function appendChatHistory(projectRoot, type, text, meta = {}, options = {}) {
+  const value = String(text || "");
+  if (!value && type !== "spacer") return;
+  const file = chatHistoryFilePath(projectRoot, options);
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, `${JSON.stringify({
+      ts: new Date().toISOString(),
+      type,
+      text: value,
+      meta: meta && typeof meta === "object" ? meta : {},
+    })}\n`);
+  } catch {
+    // best-effort
+  }
+}
+
+function chatHistoryOptionsForScope({ globalMode = false, globalScope = "controller" } = {}) {
+  return {
+    globalMode: Boolean(globalMode && globalScope !== "project"),
+  };
+}
+
+module.exports = {
+  projectRootToId,
+  inputHistoryFilePath,
+  chatHistoryFilePath,
+  loadChatHistory,
+  loadInputHistory,
+  appendInputHistory,
+  appendChatHistory,
+  chatHistoryOptionsForScope,
+};

package/src/app/chat/index.js

@@ -1,6 +1,18 @@
 async function runChat(projectRoot, options = {}) {
-  const { runChatInk } = require("../../ui/ink/ChatApp");
-  return runChatInk(projectRoot, options);
+  const { resolveTuiLaunchPlan } = require("../../ui/tuiLauncher");
+  const plan = resolveTuiLaunchPlan({
+    mode: options.tuiMode || process.env.UFOO_TUI,
+  });
+
+  if (plan.mode !== "rust") {
+    const err = new Error(`Rust TUI unavailable (${plan.reason})`);
+    err.code = "UFOO_TUI_UNAVAILABLE";
+    err.plan = plan;
+    throw err;
+  }
+
+  const { runChatRust } = require("../../ui/rustChatHost");
+  return runChatRust(projectRoot, { ...options, tuiMode: "rust" });
 }
 
 module.exports = { runChat };

package/src/app/chat/inputSubmitHandler.js

@@ -20,6 +20,9 @@ function createInputSubmitHandler(options = {}) {
     enterAgentView = () => {},
     getAgentAdapter = () => null,
     activateAgent = async () => {},
+    // When /multi is on: focus the in-window TUI pane instead of OS activate.
+    // Return true if handled.
+    focusMultiPane = null,
     commitInputHistory = () => {},
     focusInput = () => {},
     renderScreen = () => {},  // Add renderScreen callback
@@ -39,6 +42,18 @@ function createInputSubmitHandler(options = {}) {
   }
 
   async function tryActivateTargetAgent(agentId) {
+    if (typeof focusMultiPane === "function") {
+      try {
+        const focused = await focusMultiPane(agentId);
+        if (focused) {
+          clearTargetAgent();
+          return true;
+        }
+      } catch {
+        // Fall through to OS activate / internal view.
+      }
+    }
+
     const adapter = getAgentAdapter(agentId);
     const capabilities = adapter && adapter.capabilities ? adapter.capabilities : null;
     const supportsActivate = Boolean(capabilities && capabilities.supportsActivate);
@@ -47,13 +62,12 @@ function createInputSubmitHandler(options = {}) {
     if (supportsActivate) {
       clearTargetAgent();
       try {
-        if (adapter && typeof adapter.activate === "function") {
-          adapter.activate(agentId);
-        } else {
-          const pendingActivation = activateAgent(agentId);
-          if (pendingActivation && typeof pendingActivation.catch === "function") {
-            pendingActivation.catch(() => {});
-          }
+        // Always use the host-wired activator. Bare adapterRouter adapters
+        // expose activate() that no-ops unless activateTerminal/activateTmux
+        // were injected — which chat hosts do not do.
+        const pendingActivation = activateAgent(agentId);
+        if (pendingActivation && typeof pendingActivation.catch === "function") {
+          pendingActivation.catch(() => {});
         }
       } catch {
         // Best-effort activation.

package/src/app/chat/ipcBuilders.js

@@ -0,0 +1,52 @@
+"use strict";
+
+/**
+ * Chat → daemon IPC request builders (Phase 0B extraction).
+ */
+
+const { resolveActiveAgentId } = require("./agentIdentity");
+
+function buildDirectBusSendRequest({
+  text,
+  targetAgentId = null,
+  activeAgents = [],
+  activeAgentMeta = new Map(),
+} = {}) {
+  const trimmed = String(text || "").trim();
+  if (!trimmed) return null;
+  if (targetAgentId) {
+    return {
+      target: targetAgentId,
+      message: trimmed,
+      source: "chat-direct",
+    };
+  }
+
+  const { parseAtTarget } = require("./commands");
+  const atTarget = parseAtTarget(trimmed);
+  if (!atTarget || !atTarget.message) return null;
+  const target = resolveActiveAgentId(atTarget.target, activeAgents, activeAgentMeta) || atTarget.target;
+  return {
+    target,
+    message: atTarget.message.trim(),
+    source: "chat-direct",
+  };
+}
+
+function buildPromptIpcRequest(text) {
+  const { IPC_REQUEST_TYPES } = require("../../runtime/contracts/eventContract");
+  return {
+    type: IPC_REQUEST_TYPES.PROMPT,
+    text,
+    request_meta: {
+      source: "chat-dialog",
+      dispatch_default_injection_mode: "immediate",
+      allow_relevance_queue: true,
+    },
+  };
+}
+
+module.exports = {
+  buildDirectBusSendRequest,
+  buildPromptIpcRequest,
+};

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

@@ -139,7 +139,15 @@ function createPaneManager(options = {}) {
 
   function sendInput(data) {
     if (!focusedAgent) return;
-    const pane = panes.get(focusedAgent);
+    sendInputToPane(panes.get(focusedAgent), data);
+  }
+
+  function sendInputToAgent(agentId, data) {
+    if (!agentId) return;
+    sendInputToPane(panes.get(agentId), data);
+  }
+
+  function sendInputToPane(pane, data) {
     if (!pane) return;
     if (pane.mode === "internal") {
       handleInternalInput(pane, data);
@@ -284,6 +292,7 @@ function createPaneManager(options = {}) {
     addAgent,
     removeAgent,
     sendInput,
+    sendInputToAgent,
     sendResize,
     cycleFocus,
     getFocused,

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

@@ -3,7 +3,7 @@ const {
   classifyChatLogLine,
   compactContinuationIndent,
   compactDividerLabel,
-} = require("../../../ui/ink/chatLogModel");
+} = require("../../../ui/chatLogModel");
 
 function createRenderer(options = {}) {
   const {