u-foo 3.0.9 → 3.0.11

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",
@@ -190,7 +211,13 @@ function buildCommandRegistry(tree) {
     .sort(sortCommands)
     .map((cmd) => {
       const node = tree[cmd] || {};
-      return { cmd, ...mapNode(node) };
+      const entry = { cmd, ...mapNode(node) };
+      // Stamp priority so buildCompletions keeps launch → group → bus → ctx
+      // at the top of the `/` popup instead of falling back to A–Z.
+      if (COMMAND_ORDER_MAP.has(cmd)) {
+        entry.order = COMMAND_ORDER_MAP.get(cmd);
+      }
+      return entry;
     });
 }
 
@@ -309,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 {

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

@@ -0,0 +1,93 @@
+"use strict";
+
+/**
+ * Convert a virtual-terminal screen into ANSI-styled text lines suitable for
+ * shipping over `multi.pane.frame`. Rust decodes these with `ansi-to-tui`.
+ *
+ * The colour/attribute-to-ANSI logic mirrors renderer.js so the rendered
+ * frame matches the Ink multi-window presentation.
+ */
+
+const MAX_LINE_BYTES = 4096;
+
+function attrToAnsi(attr) {
+  const parts = [];
+  if (attr.bold) parts.push("1");
+  if (attr.dim) parts.push("2");
+  if (attr.italic) parts.push("3");
+  if (attr.underline) parts.push("4");
+  if (attr.inverse) parts.push("7");
+  if (attr.fgRgb) {
+    parts.push(`38;2;${attr.fgRgb[0]};${attr.fgRgb[1]};${attr.fgRgb[2]}`);
+  } else if (attr.fg !== 7) {
+    if (attr.fg < 8) parts.push(String(30 + attr.fg));
+    else if (attr.fg < 16) parts.push(String(90 + attr.fg - 8));
+    else parts.push(`38;5;${attr.fg}`);
+  }
+  if (attr.bgRgb) {
+    parts.push(`48;2;${attr.bgRgb[0]};${attr.bgRgb[1]};${attr.bgRgb[2]}`);
+  } else if (attr.bg > 0) {
+    if (attr.bg < 8) parts.push(String(40 + attr.bg));
+    else if (attr.bg < 16) parts.push(String(100 + attr.bg - 8));
+    else parts.push(`48;5;${attr.bg}`);
+  }
+  return parts.length > 0 ? `\x1b[${parts.join(";")}m` : "";
+}
+
+function truncateLineBytes(line, maxBytes) {
+  if (!line) return "";
+  if (Buffer.byteLength(line, "utf8") <= maxBytes) return line;
+  const buf = Buffer.from(line, "utf8");
+  return buf.slice(0, maxBytes).toString("utf8");
+}
+
+function vtScreenToAnsiLines(vt, options = {}) {
+  if (!vt || typeof vt.getScreen !== "function") return [];
+  const { buffer, rows, cols, cursorRow, cursorCol } = vt.getScreen();
+  const maxRows = Number.isFinite(options.maxRows) && options.maxRows > 0
+    ? Math.floor(options.maxRows)
+    : rows;
+  const maxCols = Number.isFinite(options.maxCols) && options.maxCols > 0
+    ? Math.floor(options.maxCols)
+    : cols;
+  const cursorInverse = Boolean(options.cursorInverse);
+  const reset = "\x1b[0m";
+  const limit = Math.min(rows, maxRows);
+  const out = [];
+  for (let r = 0; r < limit; r++) {
+    const row = buffer[r] || [];
+    let line = "";
+    let lastAttr = "";
+    let col = 0;
+    let c = 0;
+    while (col < maxCols && c < cols) {
+      const cell = row[c];
+      if (!cell) {
+        line += " ";
+        col += 1;
+        c += 1;
+        continue;
+      }
+      if (cell.wideContinuation) {
+        c += 1;
+        continue;
+      }
+      const isCursor = cursorInverse && r === cursorRow && c === cursorCol;
+      const attr = isCursor ? { ...cell.attr, inverse: !cell.attr.inverse } : cell.attr;
+      const ansi = attrToAnsi(attr);
+      if (ansi !== lastAttr) {
+        if (lastAttr) line += reset;
+        line += ansi;
+        lastAttr = ansi;
+      }
+      line += cell.char || " ";
+      col += 1;
+      c += 1;
+    }
+    if (lastAttr) line += reset;
+    out.push(truncateLineBytes(line, MAX_LINE_BYTES));
+  }
+  return out;
+}
+
+module.exports = { vtScreenToAnsiLines, MAX_LINE_BYTES };