march-cli 0.1.27 → 0.1.29

package/src/browser/extension/background.js

@@ -0,0 +1,225 @@
+import { buildExecCode } from "./execute-code.js";
+import { serializeError } from "./errors.js";
+
+const DAEMON_WS = "ws://127.0.0.1:4328/extension";
+let socket = null;
+let reconnectTimer = null;
+let connecting = false;
+
+startBridge();
+chrome.runtime.onStartup.addListener(startBridge);
+chrome.runtime.onInstalled.addListener(startBridge);
+chrome.alarms.onAlarm.addListener((alarm) => {
+  if (alarm.name === "march-browser-reconnect") connect();
+  if (alarm.name === "march-browser-keepalive") keepAlive();
+});
+
+function startBridge() {
+  connect();
+  chrome.alarms.create("march-browser-reconnect", { periodInMinutes: 0.5 });
+}
+
+function connect() {
+  if (connecting || socket?.readyState === WebSocket.OPEN || socket?.readyState === WebSocket.CONNECTING) return;
+  connecting = true;
+  try {
+    socket = new WebSocket(DAEMON_WS);
+  } catch {
+    connecting = false;
+    scheduleReconnect();
+    return;
+  }
+  socket.onopen = () => {
+    connecting = false;
+    setBadge("on");
+    scheduleKeepAlive();
+  };
+  socket.onmessage = (event) => handleMessage(event.data);
+  socket.onclose = scheduleReconnect;
+  socket.onerror = () => socket?.close();
+}
+
+function keepAlive() {
+  if (socket?.readyState === WebSocket.OPEN) {
+    send({ type: "ping" });
+    scheduleKeepAlive();
+  } else {
+    scheduleReconnect();
+  }
+}
+
+function scheduleKeepAlive() {
+  chrome.alarms.create("march-browser-keepalive", { delayInMinutes: 0.4 });
+}
+
+function scheduleReconnect() {
+  connecting = false;
+  setBadge("off");
+  if (reconnectTimer) return;
+  reconnectTimer = setTimeout(() => {
+    reconnectTimer = null;
+    connect();
+  }, 1000);
+}
+
+async function handleMessage(data) {
+  const request = JSON.parse(data);
+  if (!request.id) return;
+  try {
+    const result = await dispatch(request.method, request.params ?? {});
+    send({ id: request.id, ok: true, result });
+  } catch (err) {
+    send({ id: request.id, ok: false, error: serializeError(err) });
+  }
+}
+
+function send(payload) {
+  if (socket?.readyState === WebSocket.OPEN) socket.send(JSON.stringify(payload));
+}
+
+function setBadge(state) {
+  chrome.action.setBadgeText({ text: state === "on" ? "ON" : "" });
+  chrome.action.setBadgeBackgroundColor({ color: "#16a34a" });
+}
+
+async function dispatch(method, params) {
+  if (method === "tabs") return { tabs: (await chrome.tabs.query({})).map(formatTab) };
+  if (method === "open") return await openTab(params);
+  if (method === "read") return await readTab(params);
+  if (method === "script") return await runScript(params);
+  throw new Error(`Unknown browser method: ${method}`);
+}
+
+async function openTab(params) {
+  const action = params.action;
+  const tabId = parseTabId(params.tabId);
+  if (action === "new") return { tab: formatTab(await chrome.tabs.create({ url: requiredUrl(params.url), active: params.active ?? true })) };
+  if (!tabId) throw new Error(`${action} requires tabId`);
+  if (action === "navigate") return { tab: formatTab(await chrome.tabs.update(tabId, { url: requiredUrl(params.url), active: params.active })) };
+  if (action === "focus") return await focusTab(tabId);
+  if (action === "close") { await chrome.tabs.remove(tabId); return { closed: String(tabId) }; }
+  if (action === "reload") { await chrome.tabs.reload(tabId); return { reloaded: String(tabId) }; }
+  if (action === "back" || action === "forward") return await navHistory(tabId, action);
+  throw new Error(`Unknown open action: ${action}`);
+}
+
+async function focusTab(tabId) {
+  const tab = await chrome.tabs.update(tabId, { active: true });
+  if (tab.windowId) await chrome.windows.update(tab.windowId, { focused: true });
+  return { tab: formatTab(tab) };
+}
+
+async function navHistory(tabId, action) {
+  await executePageCode(tabId, action === "back" ? "history.back(); true" : "history.forward(); true");
+  return { tabId: String(tabId), action };
+}
+
+async function readTab(params) {
+  const tabId = requireTabId(params.tabId, "read");
+  const include = params.include ?? { text: true, elements: true };
+  const page = await executePageCode(tabId, buildReadCode(include));
+  const tab = await chrome.tabs.get(tabId);
+  return { tab: formatTab(tab), page };
+}
+
+async function runScript(params) {
+  const tabId = requireTabId(params.tabId, "script");
+  const result = await executePageCode(tabId, String(params.code ?? ""));
+  return { tabId: String(tabId), result };
+}
+
+async function executePageCode(tabId, code) {
+  const wrapped = buildExecCode(code);
+  const injected = await executeViaScripting(tabId, wrapped).catch((err) => ({ ok: false, csp: true, error: serializeError(err) }));
+  if (injected?.ok) return injected.data;
+  if (!injected?.csp) throwErrorResult(injected);
+  const cdp = await executeViaCdp(tabId, wrapped).catch((err) => ({ ok: false, error: serializeError(err) }));
+  if (cdp?.ok) return cdp.data;
+  throwErrorResult(cdp);
+}
+
+async function executeViaScripting(tabId, source) {
+  const [injection] = await chrome.scripting.executeScript({
+    target: { tabId },
+    world: "MAIN",
+    func: (script) => eval(script),
+    args: [source],
+  });
+  if (!injection) return { ok: false, error: { message: `No script injection result for tab ${tabId}` } };
+  if (injection.result == null) return { ok: false, csp: true, error: { message: "Script returned no value" } };
+  return injection.result;
+}
+
+async function executeViaCdp(tabId, expression) {
+  const target = { tabId };
+  let attached = false;
+  try {
+    await chrome.debugger.attach(target, "1.3");
+    attached = true;
+    const response = await chrome.debugger.sendCommand(target, "Runtime.evaluate", {
+      expression,
+      awaitPromise: true,
+      returnByValue: true,
+    });
+    if (response.exceptionDetails) {
+      return { ok: false, error: { message: response.exceptionDetails.exception?.description || "CDP Runtime.evaluate failed" } };
+    }
+    return response.result?.value ?? { ok: true, data: undefined };
+  } finally {
+    if (attached) await chrome.debugger.detach(target).catch(() => {});
+  }
+}
+
+function buildReadCode(include) {
+  return `return (() => {
+    const include = ${JSON.stringify(include)};
+    const page = { title: document.title, url: location.href };
+    if (include.text !== false) page.text = document.body?.innerText || "";
+    if (include.html) page.html = document.documentElement?.outerHTML || "";
+    if (include.elements !== false) page.elements = Array.from(document.querySelectorAll("a,button,input,textarea,select,[role=button],[role=link],[contenteditable=true]")).slice(0, 300).map((el, index) => {
+      const tag = el.tagName.toLowerCase();
+      const text = (el.innerText || el.value || el.getAttribute("aria-label") || "").trim().slice(0, 200);
+      return { index, tag, type: el.getAttribute("type") || undefined, role: el.getAttribute("role") || undefined, text, placeholder: el.getAttribute("placeholder") || undefined, href: el.href || undefined, selector: selectorFor(el) };
+    });
+    return page;
+    function selectorFor(el) {
+      if (el.id) return "#" + CSS.escape(el.id);
+      const name = el.getAttribute("name");
+      if (name) return tagName(el) + "[name=\\\"" + CSS.escape(name) + "\\\"]";
+      const parts = [];
+      for (let node = el; node && node.nodeType === Node.ELEMENT_NODE && parts.length < 4; node = node.parentElement) {
+        const tag = tagName(node);
+        const siblings = Array.from(node.parentElement?.children || []).filter((child) => child.tagName === node.tagName);
+        parts.unshift(siblings.length > 1 ? tag + ":nth-of-type(" + (siblings.indexOf(node) + 1) + ")" : tag);
+      }
+      return parts.join(" > ");
+    }
+    function tagName(el) { return el.tagName.toLowerCase(); }
+  })()`;
+}
+
+function throwErrorResult(result) {
+  const error = result?.error;
+  if (typeof error === "string") throw new Error(error);
+  throw new Error(error?.stack || error?.message || "Browser script failed");
+}
+
+function formatTab(tab) {
+  return { id: String(tab.id), windowId: tab.windowId, active: tab.active, title: tab.title, url: tab.url, status: tab.status };
+}
+
+function requireTabId(value, action) {
+  const tabId = parseTabId(value);
+  if (!tabId) throw new Error(`${action} requires tabId`);
+  return tabId;
+}
+
+function parseTabId(value) {
+  const id = Number(value);
+  return Number.isFinite(id) ? id : null;
+}
+
+function requiredUrl(url) {
+  if (!url) throw new Error("url is required");
+  return url;
+}

package/src/browser/extension/errors.js

@@ -0,0 +1,19 @@
+export function serializeError(err) {
+  if (!err) return { message: "Unknown error" };
+  if (typeof err === "string") return { message: err };
+  const name = typeof err.name === "string" && err.name ? err.name : "Error";
+  const stack = typeof err.stack === "string" ? err.stack : "";
+  const message = readableErrorMessage(err);
+  return { name, message, stack };
+}
+
+function readableErrorMessage(err) {
+  if (typeof err?.message === "string" && err.message && err.message !== "[object Object]") return err.message;
+  if (typeof err?.message === "object") return safeStringify(err.message);
+  const json = safeStringify(err);
+  return json === "{}" ? String(err) : json;
+}
+
+function safeStringify(value) {
+  try { return JSON.stringify(value); } catch { return String(value); }
+}

package/src/browser/extension/execute-code.js

@@ -0,0 +1,53 @@
+export function buildExecCode(code) {
+  return `(async () => {
+    function smartResult(value) {
+      if (value == null || typeof value !== "object") return value;
+      try { if (value.window === value && value.document) return "[Window: " + (value.location?.href || "about:blank") + "]"; } catch {}
+      if (typeof Node !== "undefined" && value.nodeType === Node.ELEMENT_NODE) return value.outerHTML;
+      if (typeof NodeList !== "undefined" && (value instanceof NodeList || value instanceof HTMLCollection)) {
+        return Array.from(value).slice(0, 300).map((item) => item?.nodeType === Node.ELEMENT_NODE ? item.outerHTML : String(item));
+      }
+      try {
+        return JSON.parse(JSON.stringify(value, (_key, item) => {
+          if (item && typeof item === "object") {
+            if (typeof Node !== "undefined" && item.nodeType === Node.ELEMENT_NODE) return item.outerHTML;
+            try { if (item.window === item && item.document) return "[Window]"; } catch {}
+          }
+          return item;
+        }));
+      } catch (err) {
+        return "[Unserializable: " + (err?.message || String(err)) + "]";
+      }
+    }
+    function executable(source) {
+      const lines = source.split(/\\r?\\n/);
+      let index = lines.length - 1;
+      while (index >= 0 && !lines[index].trim()) index--;
+      if (index < 0) return source;
+      const last = lines[index].trim();
+      if (/^(return\\b|let\\b|const\\b|var\\b|if\\b|for\\b|while\\b|switch\\b|try\\b|throw\\b|class\\b|function\\b|async\\b|import\\b|export\\b|\\/\\/|})/.test(last)) return source;
+      lines[index] = lines[index].match(/^(\\s*)/)[1] + "return " + last;
+      return lines.join("\\n");
+    }
+    try {
+      const source = ${JSON.stringify(code)}.trim();
+      const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
+      let value;
+      if (/^return\\b/.test(source) || /\\n\\s*return\\b/.test(source)) {
+        value = await (new AsyncFunction(source))();
+      } else {
+        try {
+          value = eval(source);
+          if (value && typeof value.then === "function") value = await value;
+        } catch (err) {
+          if (err instanceof SyntaxError) value = await (new AsyncFunction(executable(source)))();
+          else throw err;
+        }
+      }
+      return { ok: true, data: smartResult(value) };
+    } catch (err) {
+      const message = err?.message || String(err);
+      return { ok: false, csp: /unsafe-eval|Content Security Policy|Refused to evaluate/i.test(message), error: { name: err?.name || "Error", message, stack: err?.stack || "" } };
+    }
+  })()`;
+}

package/src/browser/extension/manifest.json

@@ -0,0 +1,15 @@
+{
+  "manifest_version": 3,
+  "name": "March Browser Bridge",
+  "version": "0.1.0",
+  "description": "Connects the user's browser tabs to March CLI.",
+  "permissions": ["tabs", "scripting", "webNavigation", "storage", "alarms", "debugger"],
+  "host_permissions": ["<all_urls>"],
+  "background": {
+    "service_worker": "background.js",
+    "type": "module"
+  },
+  "action": {
+    "default_title": "March Browser Bridge"
+  }
+}

package/src/browser/extension-install.mjs

@@ -0,0 +1,21 @@
+import { cpSync, existsSync, rmSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export function sourceBrowserExtensionPath() {
+  const path = resolve(dirname(fileURLToPath(import.meta.url)), "extension");
+  if (!existsSync(path)) throw new Error(`Browser extension not found: ${path}`);
+  return path;
+}
+
+export function installedBrowserExtensionPath(stateRoot) {
+  return resolve(stateRoot, "browser-extension");
+}
+
+export function syncBrowserExtensionInstall(stateRoot) {
+  const source = sourceBrowserExtensionPath();
+  const target = installedBrowserExtensionPath(stateRoot);
+  rmSync(target, { recursive: true, force: true });
+  cpSync(source, target, { recursive: true });
+  return target;
+}

package/src/browser/tools/index.mjs

@@ -0,0 +1,89 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { toolText } from "../../agent/tool-result.mjs";
+import { callBrowserDaemon } from "../client/rpc.mjs";
+
+export function createBrowserTools({ stateRoot = join(homedir(), ".march") } = {}) {
+  return [
+    browserTabsTool(stateRoot),
+    browserOpenTool(stateRoot),
+    browserReadTool(stateRoot),
+    browserScriptTool(stateRoot),
+  ];
+}
+
+function browserTabsTool(stateRoot) {
+  return defineTool({
+    name: "browser_tabs",
+    label: "Browser Tabs",
+    description: "List all tabs visible to the March browser extension. Use this first to choose a tabId.",
+    parameters: Type.Object({}),
+    execute: async () => safeToolJson(() => callBrowserDaemon({ stateRoot, method: "tabs" })),
+  });
+}
+
+function browserOpenTool(stateRoot) {
+  return defineTool({
+    name: "browser_open",
+    label: "Browser Open",
+    description: "Create, navigate, focus, close, reload, back, or forward browser tabs. Returns the affected tab when available.",
+    parameters: Type.Object({
+      action: Type.String({ enum: ["new", "navigate", "focus", "close", "reload", "back", "forward"] }),
+      url: Type.Optional(Type.String({ description: "URL for new or navigate actions." })),
+      tabId: Type.Optional(Type.String({ description: "Target tab id for existing-tab actions." })),
+      active: Type.Optional(Type.Boolean({ description: "Whether a new tab should become active. Default true." })),
+    }),
+    execute: async (_id, params) => safeToolJson(() => callBrowserDaemon({ stateRoot, method: "open", params })),
+  });
+}
+
+function browserReadTool(stateRoot) {
+  return defineTool({
+    name: "browser_read",
+    label: "Browser Read",
+    description: "Read content from a specific browser tab. Defaults to visible text and interactive elements; can include HTML.",
+    parameters: Type.Object({
+      tabId: Type.String({ description: "Target tab id from browser_tabs or browser_open." }),
+      include: Type.Optional(Type.Object({
+        text: Type.Optional(Type.Boolean()),
+        html: Type.Optional(Type.Boolean()),
+        elements: Type.Optional(Type.Boolean()),
+      })),
+    }),
+    execute: async (_id, params) => safeToolJson(() => callBrowserDaemon({ stateRoot, method: "read", params })),
+  });
+}
+
+function browserScriptTool(stateRoot) {
+  return defineTool({
+    name: "browser_script",
+    label: "Browser Script",
+    description: "Execute arbitrary JavaScript in a specific browser tab. The code may return a JSON-serializable value or a Promise.",
+    parameters: Type.Object({
+      tabId: Type.String({ description: "Target tab id from browser_tabs or browser_open." }),
+      code: Type.String({ description: "JavaScript function body. Use return to send a result back." }),
+      awaitPromise: Type.Optional(Type.Boolean({ description: "Await a returned Promise. Default true." })),
+      timeoutMs: Type.Optional(Type.Number({ description: "Request timeout in milliseconds. Default 30000." })),
+    }),
+    execute: async (_id, params) => safeToolJson(() => callBrowserDaemon({
+      stateRoot,
+      method: "script",
+      params,
+      timeoutMs: params.timeoutMs ?? 30000,
+    })),
+  });
+}
+
+async function safeToolJson(run) {
+  try {
+    return toolJson(await run());
+  } catch (err) {
+    return toolJson({ ok: false, error: err.message }, { error: true });
+  }
+}
+
+function toolJson(payload, details = {}) {
+  return toolText(JSON.stringify(payload, null, 2), details);
+}

package/src/cli/args.mjs

@@ -28,7 +28,7 @@ export function parseCliArgs(argv) {
     allowPositionals: true,
   });
 
-  const commandName = ["login", "provider", "websearch", "memory"].includes(positionals[0]) ? positionals[0] : null;
+  const commandName = ["login", "provider", "websearch", "memory", "browser"].includes(positionals[0]) ? positionals[0] : null;
 
   return {
     command: commandName ? { name: commandName, args: positionals.slice(1) } : null,
@@ -70,6 +70,9 @@ Usage:
   march memory add <url>
   march memory list
   march memory remove <name>
+  march browser install    Install the developer browser extension
+  march browser status     Show browser daemon/extension status
+  march browser restart    Restart the browser daemon
 
 Options:
   -m, --model <id>     Initial model ID override

package/src/cli/fallback-ui.mjs

@@ -1,6 +1,6 @@
 import { stdout } from "node:process";
 import { extractToolOutput } from "./tool-output.mjs";
-import { formatMemoryHintLines } from "./tui/recall-rendering.mjs";
+import { formatRecallLines } from "./tui/recall-rendering.mjs";
 import { formatToolStartLine } from "./tui/tool-rendering.mjs";
 import { brightBlack, dim, red, green, yellow } from "./tui/ui-theme.mjs";
 
@@ -32,7 +32,7 @@ export function createJsonUI() {
       stdout.write(delta);
     },
     status: () => {},
-    memoryHint: () => {},
+    recall: () => {},
     clearOutput: () => {},
     restoreTranscript: () => {},
     setStatusBar: () => {},
@@ -111,9 +111,9 @@ export function createPlainUI() {
     },
     textDelta: writeText,
     status: (text) => { ensureNewline(); stdout.write(`${brightBlack(`● ${text}`)}\n`); },
-    memoryHint: ({ hints }) => {
+    recall: ({ hints }) => {
       ensureNewline();
-      for (const line of formatMemoryHintLines(hints)) stdout.write(`${brightBlack(line)}\n`);
+      for (const line of formatRecallLines(hints)) stdout.write(`${brightBlack(line)}\n`);
     },
     clearOutput: () => {},
     restoreTranscript: () => {},

package/src/cli/repl-loop.mjs

@@ -27,8 +27,8 @@ export async function runSingleShotPrompt({
   const modePrompt = appendModeReminder(prompt, modeState?.get?.());
   const fullPrompt = appendPromptBlocks(modePrompt, recallBlock, carryoverRecallBlock, shellHints);
   ui.writeln(formatUserDisplayMessage(prompt));
-  ui.memoryHint?.({ source: "user", hints: userRecallHints });
-  if (carryoverRecallHints.length > 0 && !carryoverAlreadyRendered) ui.memoryHint?.({ source: "assistant", hints: carryoverRecallHints });
+  ui.recall?.({ source: "user", hints: userRecallHints });
+  if (carryoverRecallHints.length > 0 && !carryoverAlreadyRendered) ui.recall?.({ source: "assistant", hints: carryoverRecallHints });
   refreshStatusBar.startWorking?.();
   try {
     await runner.runTurn(fullPrompt, prompt, { userRecallHints, currentProject });
@@ -149,8 +149,8 @@ async function runReplTurn({ prompt, args, runner, memoryStore, currentProject,
   const fullPrompt = appendPromptBlocks(modePrompt, recallBlock, carryoverRecallBlock, shellHints);
   try {
     ui.writeln(formatUserDisplayMessage(prompt));
-    ui.memoryHint?.({ source: "user", hints: userRecallHints });
-    if (carryoverRecallHints.length > 0 && !carryoverAlreadyRendered) ui.memoryHint?.({ source: "assistant", hints: carryoverRecallHints });
+    ui.recall?.({ source: "user", hints: userRecallHints });
+    if (carryoverRecallHints.length > 0 && !carryoverAlreadyRendered) ui.recall?.({ source: "assistant", hints: carryoverRecallHints });
     setTurnRunning(true);
     refreshStatusBar.startWorking?.();
     await runner.runTurn(fullPrompt, prompt, { userRecallHints, currentProject });
@@ -178,6 +178,6 @@ function renderPendingAssistantRecallPreview({ runner, ui }) {
   if (runner.engine.hasRenderedPendingAssistantRecallHints?.()) return;
   const hints = runner.engine.peekPendingAssistantRecallHints?.() ?? [];
   if (hints.length === 0) return;
-  ui.memoryHint?.({ source: "assistant", hints });
+  ui.recall?.({ source: "assistant", hints });
   runner.engine.markPendingAssistantRecallHintsRendered?.();
 }

package/src/cli/tui/layout/main-pane-layout.mjs

@@ -10,7 +10,8 @@ export class MainPaneLayout {
   render(width) {
     const safeWidth = Math.max(1, Math.trunc(width));
     const statusTopLines = this.statusBar.renderTop?.(safeWidth) ?? this.statusBar.render(safeWidth);
-    const rawEditorLines = this.editor.render(safeWidth);
+    const editorWidth = this.statusBar.inputContentWidth?.(safeWidth) ?? safeWidth;
+    const rawEditorLines = this.editor.render(Math.max(1, editorWidth));
     const editorLines = this.statusBar.renderInputLines?.(rawEditorLines, safeWidth)
       ?? rawEditorLines.map((line) => this.statusBar.renderInputLine?.(line, safeWidth) ?? line);
     const statusBottomLines = this.statusBar.renderBottom?.(safeWidth) ?? [];

package/src/cli/tui/output/tool-card-renderer.mjs

@@ -1,5 +1,5 @@
 import { visibleWidth } from "@earendil-works/pi-tui";
-import { R, brightBlack, dim, red } from "../ui-theme.mjs";
+import { R, brightBlack, dim, red, warmAmber } from "../ui-theme.mjs";
 
 export function renderToolCardBlock(block, width) {
   const lines = [];
@@ -7,7 +7,7 @@ export function renderToolCardBlock(block, width) {
   const marker = block.state === "running" ? "▶" : block.expanded ? "▾" : "▸";
   const summary = block.summary ? ` · ${block.summary}` : "";
   const head = `${marker} ${block.title}${summary}`;
-  appendCardWrapped(lines, border, (block.isError ? red : dim)(head), width);
+  appendCardWrapped(lines, border, colorToolHead(block)(head), width);
 
   if (block.expanded && block.bodyLines?.length) {
     lines.push(border);
@@ -16,6 +16,12 @@ export function renderToolCardBlock(block, width) {
   return lines;
 }
 
+function colorToolHead(block) {
+  if (block.isError) return red;
+  if (block.name === "memory_open") return warmAmber;
+  return dim;
+}
+
 function appendCardWrapped(lines, border, text, width, indent = "") {
   const prefix = `${border} ${indent}`;
   const contentWidth = Math.max(8, width - visibleWidth(prefix));

package/src/cli/tui/recall-rendering.mjs

@@ -1,8 +1,8 @@
-import { brightBlack, warmAmber } from "./ui-theme.mjs";
+import { brightBlack } from "./ui-theme.mjs";
 
 const RECALL_ICON = "✦";
 
-export function formatMemoryHintLines(hints = []) {
+export function formatRecallLines(hints = []) {
   if (!hints.length) return [];
   const noun = hints.length === 1 ? "note" : "notes";
   return [
@@ -11,11 +11,10 @@ export function formatMemoryHintLines(hints = []) {
   ];
 }
 
-export function writeMemoryHint({ output, hints = [] }) {
-  const lines = formatMemoryHintLines(hints);
-  lines.forEach((line, index) => {
-    if (index === 0) output.writeln(warmAmber(line));
-    else if (line.startsWith("    ")) output.writeln(brightBlack(line));
+export function writeRecall({ output, hints = [] }) {
+  const lines = formatRecallLines(hints);
+  lines.forEach((line) => {
+    if (line.startsWith("    ")) output.writeln(brightBlack(line));
     else output.writeln(line);
   });
 }

package/src/cli/tui/status/status-bar.mjs

@@ -45,6 +45,10 @@ export class StatusBar {
     return [`${left}${line}${right}`, ""];
   }
 
+  inputContentWidth(width) {
+    return maxInputContentWidth(width);
+  }
+
   renderInputLines(lines, width) {
     if (width <= 0) return [""];
     const { left, innerWidth, right } = insetForWidth(width);
@@ -62,9 +66,7 @@ export class StatusBar {
     if (width <= 0) return "";
     const paintWidth = inputPaintWidth(width);
     const prompt = isFirst ? statusBar.prompt(INPUT_PROMPT) : "  ";
-    const promptWidth = visibleWidth(stripAnsi(INPUT_PROMPT));
-    const maxContentWidth = Math.max(0, paintWidth - promptWidth - 2);
-    const content = clipToWidth(line, maxContentWidth);
+    const content = clipToWidth(line, maxInputContentWidth(width));
     return applyInputBackground(padToWidth(`${prompt}${content}`, paintWidth));
   }
 
@@ -108,6 +110,12 @@ function inputPaintWidth(width) {
   return safeWidth > 1 ? safeWidth - 1 : safeWidth;
 }
 
+function maxInputContentWidth(width) {
+  const paintWidth = inputPaintWidth(width);
+  const promptWidth = visibleWidth(stripAnsi(INPUT_PROMPT));
+  return Math.max(0, paintWidth - promptWidth - 2);
+}
+
 function applyInputBackground(line) {
   return `${INPUT_BG}${String(line).replaceAll(R, `${R}${INPUT_BG}`)}${R}`;
 }

package/src/cli/tui/tui-input-controller.mjs

@@ -1,6 +1,6 @@
 import { resolveAttachmentTokens, uniqueAttachmentToken, withLeadingSpace } from "../input/attachment-tokens.mjs";
 
-export function createTuiInputController({ editor, requestRender, historyStore = null }) {
+export function createTuiInputController({ editor, requestRender, historyStore = null, onSubmit = null }) {
   let onSubmitResolve = null;
   const attachmentTokens = new Map();
 
@@ -17,6 +17,7 @@ export function createTuiInputController({ editor, requestRender, historyStore =
           }
           clearSubmitState();
           attachmentTokens.clear();
+          onSubmit?.();
           resolve(resolvedText);
         };
       });

package/src/cli/ui.mjs

@@ -20,7 +20,7 @@ import { createMouseSelectionController } from "./tui/input/mouse-selection-cont
 import { ScreenSelection } from "./tui/selection-screen.mjs";
 import { writeEditDiff } from "./tui/tui-diff-rendering.mjs";
 import { createTuiInputController } from "./tui/tui-input-controller.mjs";
-import { writeMemoryHint } from "./tui/recall-rendering.mjs";
+import { writeRecall } from "./tui/recall-rendering.mjs";
 import { writeToolEnd, writeToolStart } from "./tui/tool-rendering.mjs";
 import { EDITOR_THEME, brightBlack } from "./tui/ui-theme.mjs";
 import { createRenderScheduler } from "./tui/render/render-scheduler.mjs";
@@ -104,12 +104,6 @@ export function createTuiUI({
         if (copyKeyResult) return copyKeyResult;
         const dispatched = keybindingDispatcher.dispatch(data);
         if (dispatched) return dispatched;
-        // When output is scrolled up, the next render has fewer lines.
-        // On new input, reset scroll to tail so the editor stays at bottom.
-        if (output.scrollOffset > 0) {
-          output.resetScroll();
-          requestRender();
-        }
         if (shellDrawer.isInputActive()) {
           shellDrawer.sendInput(data);
           requestRender();
@@ -150,7 +144,12 @@ export function createTuiUI({
     retryStatus.end({ success, attempt, finalError });
   }
 
-  const inputController = createTuiInputController({ editor, requestRender, historyStore });
+  const resetOutputScrollOnSubmit = () => {
+    if (output.scrollOffset <= 0) return;
+    output.resetScroll();
+    requestRender();
+  };
+  const inputController = createTuiInputController({ editor, requestRender, historyStore, onSubmit: resetOutputScrollOnSubmit });
 
   return {
     readline: (_prompt) => {
@@ -205,8 +204,8 @@ export function createTuiUI({
     status: (text) => {
       ensureStarted(); flushStreamDeltas(); retryStatus.stop(); spinnerStatus.stop(); output.setOverlayStatus([brightBlack(`● ${text}`)]); requestRender();
     },
-    memoryHint: ({ hints }) => {
-      ensureStarted(); flushStreamDeltas(); retryStatus.stop(); spinnerStatus.stop(); output.ensureNewline(); writeMemoryHint({ output, hints }); requestRender();
+    recall: ({ hints }) => {
+      ensureStarted(); flushStreamDeltas(); retryStatus.stop(); spinnerStatus.stop(); output.ensureNewline(); writeRecall({ output, hints }); requestRender();
     },
 
     clearOutput: () => {