march-cli 0.1.0

package/src/cli/shell/shell-drawer-controls.mjs

@@ -0,0 +1,33 @@
+import { brightBlack } from "../tui/ui-theme.mjs";
+
+export function createShellDrawerControls({ shellDrawer, output, requestRender, now = () => Date.now(), toggleDebounceMs = 150 }) {
+  let lastToggleAt = 0;
+
+  return {
+    toggle() {
+      const current = now();
+      if (current - lastToggleAt < toggleDebounceMs) {
+        return shellDrawer.isVisible();
+      }
+      lastToggleAt = current;
+      const visible = shellDrawer.toggle();
+      requestRender();
+      return visible;
+    },
+
+    selectNext() {
+      if (!shellDrawer.isVisible()) return false;
+      const shell = shellDrawer.selectNextShell();
+      if (shell) output.writeln(brightBlack(`● shell: ${shell.name} (${shell.id})`));
+      requestRender();
+      return shell;
+    },
+
+    scroll(delta) {
+      if (!shellDrawer.isVisible()) return false;
+      const state = shellDrawer.scroll(delta);
+      requestRender();
+      return state;
+    },
+  };
+}

package/src/cli/shell/shell-drawer.mjs

@@ -0,0 +1,192 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { PREFIX, R } from "../tui/ui-theme.mjs";
+
+const CONTROL_RE = /\x1b(?:\][^\x07]*(?:\x07|\x1b\\)|\[(?![0-9;]*m)[0-?]*[ -/]*[@-~]|[@-Z\\-_])/g;
+const HEADER = PREFIX.fg250;
+const MUTED = PREFIX.brightBlack;
+const BORDER = PREFIX.fg238;
+const ACTIVE = PREFIX.cyan;
+const RESET = R;
+
+export class ShellDrawer {
+  constructor({ shellRuntime = null, maxOutputLines = 10 } = {}) {
+    this.shellRuntime = shellRuntime;
+    this.maxOutputLines = maxOutputLines;
+    this.visible = false;
+    this.selectedShellId = null;
+    this.scrollOffset = 0;
+    this.shellSizes = new Map();
+  }
+
+  toggle() {
+    this.visible = !this.visible;
+    return this.visible;
+  }
+
+  isVisible() {
+    return this.visible;
+  }
+
+  isInputActive() {
+    return this.visible && Boolean(this.getSelectedShell());
+  }
+
+  sendInput(data) {
+    const shell = this.getSelectedShell();
+    if (!shell || !this.shellRuntime) {
+      return { ok: false, error: "no shell selected" };
+    }
+    return this.shellRuntime.sendShell(shell.id, data);
+  }
+
+  selectNextShell() {
+    const shells = this.getShells();
+    if (!shells.length) {
+      this.selectedShellId = null;
+      return null;
+    }
+    const currentIndex = Math.max(0, shells.findIndex((shell) => shell.id === this.selectedShellId));
+    const next = shells[(currentIndex + 1) % shells.length];
+    this.selectedShellId = next.id;
+    this.scrollOffset = 0;
+    return next;
+  }
+
+  scroll(delta) {
+    const outputLines = this.getOutputLines();
+    const maxOffset = Math.max(0, outputLines.length - this.maxOutputLines);
+    this.scrollOffset = clamp(this.scrollOffset + (delta < 0 ? 1 : -1), 0, maxOffset);
+    return {
+      offset: this.scrollOffset,
+      maxOffset,
+      atTail: this.scrollOffset === 0,
+    };
+  }
+
+  render(width) {
+    if (!this.visible) return [];
+    const safeWidth = Math.max(1, width);
+    const shell = this.getSelectedShell();
+    const lines = [
+      `${BORDER}${"─".repeat(Math.max(1, safeWidth))}${RESET}`,
+    ];
+
+    if (!this.shellRuntime) {
+      lines.push(fit(`${MUTED}shell pane: disabled  focus:editor  started with --no-shell-runtime${RESET}`, safeWidth));
+      return lines;
+    }
+
+    if (!shell) {
+      lines.push(fit(`${MUTED}shell pane: no shells  focus:editor${RESET}`, safeWidth));
+      return lines;
+    }
+
+    const shells = this.getShells();
+
+    // Tab bar: all shells with active highlighted
+    if (shells.length > 1) {
+      const tabs = shells.map((s) => {
+        const label = `${s.status === "running" ? "●" : "○"} ${s.name}`;
+        if (s.id === shell.id) return `${ACTIVE}${label}${MUTED}`;
+        return `${MUTED}${label}`;
+      }).join(` ${BORDER}│${MUTED} `);
+      lines.push(fit(`${MUTED}shells: ${tabs}${RESET}`, safeWidth));
+    }
+
+    const args = shell.args?.length ? ` ${shell.args.join(" ")}` : "";
+    this.syncShellSize(shell.id, safeWidth, this.maxOutputLines);
+    const outputLines = this.getOutputLines(shell.id);
+    const maxOffset = Math.max(0, outputLines.length - this.maxOutputLines);
+    this.scrollOffset = clamp(this.scrollOffset, 0, maxOffset);
+    const shellIndexLabel = `${Math.max(1, shells.findIndex((s) => s.id === shell.id) + 1)}/${shells.length}`;
+    const scrollLabel = this.scrollOffset === 0 ? "tail" : `-${this.scrollOffset}`;
+    const focusLabel = this.isInputActive() ? `${ACTIVE}Alt+S:editor` : `${MUTED}Alt+S:shell`;
+    const statusIcon = shell.status === "running" ? "●" : shell.status === "starting" ? "○" : "×";
+    lines.push(fit(`${HEADER}${statusIcon} ${shell.command}${args} ${MUTED}${shellIndexLabel} ${scrollLabel}  ${focusLabel}${RESET}`, safeWidth));
+
+    if (outputLines.length === 0) {
+      lines.push(fit(`${MUTED}(empty shell output)${RESET}`, safeWidth));
+      return lines;
+    }
+    for (const line of visibleWindow(outputLines, this.maxOutputLines, this.scrollOffset)) {
+      lines.push(fit(line, safeWidth));
+    }
+    return lines;
+  }
+
+  invalidate() {}
+
+  getSelectedShell() {
+    if (!this.shellRuntime) return null;
+    const shells = this.getShells();
+    if (!shells.length) {
+      this.selectedShellId = null;
+      return null;
+    }
+    const selected = shells.find((shell) => shell.id === this.selectedShellId);
+    if (selected) return selected;
+    const running = shells.findLast?.((shell) => shell.status === "running" || shell.status === "starting");
+    const fallback = running ?? shells.at(-1);
+    this.selectedShellId = fallback.id;
+    return fallback;
+  }
+
+  getShells() {
+    return this.shellRuntime?.listShells?.() ?? [];
+  }
+
+  getOutputLines(shellId = this.getSelectedShell()?.id) {
+    if (!shellId || !this.shellRuntime) return [];
+    const snapshot = this.shellRuntime.snapshotShell(shellId);
+    return formatAnsiLines(snapshot);
+  }
+
+  syncShellSize(shellId, cols, rows) {
+    if (!shellId || !this.shellRuntime?.resizeShell) return null;
+    const size = {
+      cols: Math.max(1, Math.trunc(cols)),
+      rows: Math.max(1, Math.trunc(rows)),
+    };
+    const previous = this.shellSizes.get(shellId);
+    if (previous?.cols === size.cols && previous?.rows === size.rows) return null;
+    this.shellSizes.set(shellId, size);
+    return this.shellRuntime.resizeShell(shellId, {
+      cols: size.cols,
+      rows: size.rows,
+    });
+  }
+}
+
+export function formatAnsiLines(snapshot) {
+  const screen = snapshot?.screen;
+  const text = screen ? (screen.ansi || screen.plain || "") : (snapshot?.ansi || snapshot?.plain || "");
+  const lines = sanitizeAnsiForDrawer(text)
+    .replace(/\r/g, "")
+    .split("\n");
+  return screen ? trimTrailingEmptyLines(lines) : lines.filter((line) => line.length > 0);
+}
+
+export function sanitizeAnsiForDrawer(text) {
+  return String(text ?? "").replace(CONTROL_RE, "");
+}
+
+function fit(text, width) {
+  if (visibleWidth(text) <= width) return text;
+  return truncateToWidth(text, width);
+}
+
+function visibleWindow(lines, size, offset) {
+  const end = Math.max(0, lines.length - offset);
+  const start = Math.max(0, end - size);
+  return lines.slice(start, end);
+}
+
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+
+function trimTrailingEmptyLines(lines) {
+  let end = lines.length;
+  while (end > 0 && lines[end - 1] === "") end -= 1;
+  return lines.slice(0, end);
+}

package/src/cli/shell/shell-split-layout.mjs

@@ -0,0 +1,70 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { PREFIX, R } from "../tui/ui-theme.mjs";
+
+const BORDER_PREFIX = PREFIX.fg238;
+const SEPARATOR = `${BORDER_PREFIX}│${R}`;
+const SEPARATOR_WIDTH = 1;
+const MIN_LEFT_WIDTH = 34;
+const MIN_SHELL_WIDTH = 34;
+const MAX_SHELL_WIDTH = 72;
+const SHELL_WIDTH_RATIO = 0.36;
+
+export class ShellSplitLayout {
+  constructor({ mainChildren = [], shellPane, selection = null }) {
+    this.mainChildren = mainChildren;
+    this.shellPane = shellPane;
+    this.selection = selection;
+  }
+
+  render(width) {
+    const safeWidth = Math.max(1, Math.trunc(width));
+    if (!this.shellPane?.isVisible?.() || safeWidth < 3) return renderStack(this.mainChildren, safeWidth);
+
+    const shellWidth = computeShellWidth(safeWidth);
+    const mainWidth = Math.max(1, safeWidth - shellWidth - SEPARATOR_WIDTH);
+    const mainLines = renderStack(this.mainChildren, mainWidth);
+    const shellLines = this.shellPane.render(shellWidth);
+    const rowCount = Math.max(mainLines.length, shellLines.length);
+    const lines = [];
+
+    for (let i = 0; i < rowCount; i += 1) {
+      const left = padToWidth(mainLines[i] ?? "", mainWidth);
+      const right = padToWidth(shellLines[i] ?? "", shellWidth);
+      lines.push(`${left}${SEPARATOR}${right}`);
+    }
+    return lines;
+  }
+
+  invalidate() {
+    for (const child of this.mainChildren) child.invalidate?.();
+    this.shellPane?.invalidate?.();
+  }
+}
+
+export function computeShellWidth(totalWidth) {
+  const available = Math.max(1, Math.trunc(totalWidth) - SEPARATOR_WIDTH);
+  if (available <= 1) return 1;
+  const maxWithLeftFloor = available - MIN_LEFT_WIDTH;
+  if (maxWithLeftFloor < MIN_SHELL_WIDTH) {
+    return Math.max(1, Math.floor(available / 2));
+  }
+  const target = Math.floor(totalWidth * SHELL_WIDTH_RATIO);
+  return clamp(target, MIN_SHELL_WIDTH, Math.min(MAX_SHELL_WIDTH, maxWithLeftFloor));
+}
+
+function renderStack(children, width) {
+  const lines = [];
+  for (const child of children) {
+    for (const line of child.render(width)) lines.push(line);
+  }
+  return lines;
+}
+
+function padToWidth(text, width) {
+  const fitted = visibleWidth(text) > width ? truncateToWidth(text, width) : text;
+  return `${fitted}${" ".repeat(Math.max(0, width - visibleWidth(fitted)))}`;
+}
+
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}

package/src/cli/slash-commands.mjs

@@ -0,0 +1,176 @@
+import { listExtensionPathsCommand } from "./commands/extensions-command.mjs";
+import { handleExportCommand, parseExportCommand } from "./commands/export-command.mjs";
+import { handleModelCommand, listModels, parseModelCommand } from "./commands/model-command.mjs";
+import { formatHotkeysPanel } from "./repl-commands.mjs";
+import { copyLastAssistantMessage } from "./commands/copy-command.mjs";
+import { handleSessionSourceCommand } from "./session/session-source-command.mjs";
+import { statusCommand } from "./commands/status-command.mjs";
+import { handleThinkingCommand, parseThinkingCommand } from "./commands/thinking-command.mjs";
+import { formatPromptTemplateLines } from "./input/prompt-templates.mjs";
+import { handleSettingsCommand, parseSettingsCommand } from "../config/settings-command.mjs";
+import { handleSessionNameCommand, parseSessionNameCommand } from "./session/session-name-command.mjs";
+import { handleShellCommand, parseShellCommand } from "./shell/shell-command.mjs";
+import { handleProviderCommand, parseProviderCommand } from "./commands/provider-command.mjs";
+import { formatHelpLines } from "./commands/help-command.mjs";
+
+export async function handleSlashCommand(trimmed, {
+  ui,
+  runner,
+  sessionState,
+  sessionsRoot,
+  projectMarchDir,
+  sessionSource = "pi",
+  extensionPaths = [],
+  keybindings,
+  keybindingDiagnostics = [],
+  promptTemplates = [],
+  promptTemplateDiagnostics = [],
+  renderStartupBanner = null,
+  settingsHomeDir,
+  configHomeDir = settingsHomeDir,
+  writeClipboard,
+}) {
+  if (trimmed === "/exit" || trimmed === "/quit") {
+    await handleSessionSourceCommand("/save", { ui, runner, sessionState, sessionSource });
+    return { handled: true, exit: true };
+  }
+
+  if (trimmed === "/new") {
+    if (!runner.canSwitchPiSession?.()) {
+      ui.writeln("Error: pi runtime host is not enabled");
+      return { handled: true };
+    }
+    try {
+      const result = await runner.startNewSession();
+      if (result?.cancelled) {
+        ui.writeln("New session cancelled");
+      } else {
+        ui.clearOutput?.();
+        const bannerLines = typeof renderStartupBanner === "function" ? renderStartupBanner() : [];
+        if (bannerLines.length > 0) {
+          for (const line of bannerLines) ui.writeln(line);
+        } else {
+          ui.writeln(`Started new session: ${result.sessionId}`);
+        }
+      }
+    } catch (err) {
+      ui.writeln(`Error: ${err.message}`);
+    }
+    return { handled: true };
+  }
+
+  if (trimmed === "/help") {
+    for (const line of formatHelpLines()) ui.writeln(line);
+    return { handled: true };
+  }
+
+  if (trimmed === "/hotkeys") {
+    for (const line of formatHotkeysPanel(keybindings, keybindingDiagnostics)) ui.writeln(line);
+    return { handled: true };
+  }
+
+  if (trimmed === "/templates") {
+    for (const line of formatPromptTemplateLines(promptTemplates, promptTemplateDiagnostics)) ui.writeln(line);
+    return { handled: true };
+  }
+
+  const exportCommand = parseExportCommand(trimmed);
+  if (exportCommand.type !== "none") {
+    for (const line of await handleExportCommand(exportCommand, { runner, sessionState, sessionSource, projectMarchDir })) ui.writeln(line);
+    return { handled: true };
+  }
+
+  const settingsCommand = parseSettingsCommand(trimmed);
+  if (settingsCommand.type !== "none") {
+    for (const line of handleSettingsCommand(settingsCommand, { cwd: runner.engine.cwd, homeDir: settingsHomeDir })) {
+      ui.writeln(line);
+    }
+    return { handled: true };
+  }
+
+  if (trimmed === "/extensions") {
+    for (const line of listExtensionPathsCommand(
+      extensionPaths,
+      runner.getExtensionDiagnostics?.(),
+      runner.getExtensionLifecycleState?.(),
+    )) ui.writeln(line);
+    return { handled: true };
+  }
+
+  const thinkingCommand = parseThinkingCommand(trimmed);
+  if (thinkingCommand.type !== "none") {
+    for (const line of await handleThinkingCommand(thinkingCommand, { runner, ui })) ui.writeln(line);
+    return { handled: true };
+  }
+
+  if (trimmed === "/mouse") {
+    const on = ui.toggleMouse();
+    ui.writeln(on ? "Mouse tracking: ON (wheel scroll and TUI selection copy enabled)" : "Mouse tracking: OFF (native terminal selection enabled)");
+    return { handled: true };
+  }
+
+  if (trimmed === "/status") {
+    for (const line of statusCommand({
+      runner,
+      sessionState,
+      sessionSource,
+      extensionDiagnostics: runner.getExtensionDiagnostics?.() ?? [],
+      lifecycleState: runner.getExtensionLifecycleState?.() ?? null,
+    })) ui.writeln(line);
+    return { handled: true };
+  }
+
+  const shellCommand = parseShellCommand(trimmed);
+  if (shellCommand.type !== "none") {
+    for (const line of handleShellCommand(shellCommand, { shellRuntime: runner.shellRuntime })) ui.writeln(line);
+    return { handled: true };
+  }
+
+  const nameCommand = parseSessionNameCommand(trimmed);
+  if (nameCommand.type !== "none") {
+    for (const line of handleSessionNameCommand(nameCommand, { runner, sessionState, sessionSource })) ui.writeln(line);
+    return { handled: true };
+  }
+
+  if (trimmed === "/copy") {
+    for (const line of copyLastAssistantMessage({ engine: runner.engine, writeClipboard })) ui.writeln(line);
+    return { handled: true };
+  }
+
+  const sessionSourceCommand = await handleSessionSourceCommand(trimmed, {
+    ui,
+    runner,
+    sessionState,
+    sessionsRoot,
+    projectMarchDir,
+    sessionSource,
+  });
+  if (sessionSourceCommand.handled) return sessionSourceCommand;
+
+  const providerCommand = parseProviderCommand(trimmed);
+  if (providerCommand.type !== "none") {
+    try {
+      ui.writeln(await handleProviderCommand(providerCommand, { ui, runner }));
+    } catch (err) {
+      ui.writeln(`Error: ${err.message}`);
+    }
+    return { handled: true };
+  }
+
+  const modelCommand = parseModelCommand(trimmed);
+  if (modelCommand.type !== "none") {
+    try {
+      ui.writeln(await handleModelCommand(modelCommand, { runner, ui, configHomeDir }));
+    } catch (err) {
+      ui.writeln(`Error: ${err.message}`);
+    }
+    return { handled: true };
+  }
+
+  if (trimmed === "/models") {
+    for (const line of listModels({ runner })) ui.writeln(line);
+    return { handled: true };
+  }
+
+  return { handled: false };
+}

package/src/cli/startup/startup-banner.mjs

@@ -0,0 +1,17 @@
+import { MODES } from "../input/mode-state.mjs";
+import { bold, brightBlack, cyan } from "../tui/ui-theme.mjs";
+
+export function formatStartupBanner({ cwd, modelId = "model?", thinkingLevel = "thinking?", mode = MODES.DO, dumpContextPath = null } = {}) {
+  const nextMode = mode === MODES.DISCUSS ? "Do" : "Discuss";
+  const hint = dumpContextPath
+    ? brightBlack(`dumps: ${dumpContextPath}`)
+    : brightBlack(`Tab to ${nextMode} · /help`);
+  return [
+    `${cyan("  █▙  ▟█")}   ${bold("March")}`,
+    `${cyan("  █▜▙▟▛█")}   ${brightBlack(`${modelId} · ${thinkingLevel}`)}`,
+    `${cyan("  ▀    ▀")}   ${brightBlack(cwd ?? "")}`,
+    "",
+    `  ${hint}`,
+    "",
+  ];
+}

package/src/cli/startup/startup-session.mjs

@@ -0,0 +1,51 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { listPiSessionInfos } from "../../session/pi-manager.mjs";
+import { loadPiSessionTranscriptTurns } from "../../session/transcript.mjs";
+import { resumePiSessionById } from "../session/pi-session-switch-command.mjs";
+
+export function loadOrCreateProjectId(projectMarchDir) {
+  if (!existsSync(projectMarchDir)) mkdirSync(projectMarchDir, { recursive: true });
+  const idFile = resolve(projectMarchDir, "project-id");
+  if (existsSync(idFile)) {
+    return readFileSync(idFile, "utf8").trim();
+  }
+  const id = randomUUID();
+  writeFileSync(idFile, id, "utf8");
+  return id;
+}
+
+export async function resumeStartupSession({
+  resumeId,
+  runner,
+  sessionState,
+  projectMarchDir,
+  ui,
+  listPiSessions = listPiSessionInfos,
+}) {
+  if (!resumeId) return { source: "none", lines: [] };
+
+  const sessions = await listPiSessions({
+    cwd: runner.engine.cwd,
+    projectMarchDir,
+  });
+  const lines = await resumePiSessionById(resumeId, {
+    runner,
+    sessions,
+    projectMarchDir,
+  });
+  for (const line of lines) ui.status(line);
+  return { source: "pi", lines, transcriptTurns: loadResumeTranscriptTurns(resumeId, sessions, lines) };
+}
+
+function loadResumeTranscriptTurns(resumeId, sessions, lines) {
+  if (!Array.isArray(lines) || !lines.some((line) => String(line).startsWith("Resumed pi session:"))) return [];
+  const matches = sessions.filter((session) => session.id.startsWith(resumeId));
+  if (matches.length !== 1) return [];
+  try {
+    return loadPiSessionTranscriptTurns(matches[0].path);
+  } catch {
+    return [];
+  }
+}

package/src/cli/status-line-updater.mjs

@@ -0,0 +1,74 @@
+import { statusBarLine } from "./commands/status-command.mjs";
+
+const WORKING_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const WORKING_INTERVAL_MS = 120;
+
+export function createStatusLineUpdater({
+  ui,
+  runner,
+  sessionState,
+  sessionSource = "pi",
+  getMode = () => undefined,
+}) {
+  let contextTokens = null;
+  let activity = null;
+  let frameIndex = 0;
+  let timer = null;
+
+  const update = (options = {}) => {
+    if (typeof ui.setStatusBar !== "function") return null;
+    if (Object.hasOwn(options, "contextTokens")) contextTokens = options.contextTokens;
+    const line = statusBarLine({
+      runner,
+      sessionState,
+      sessionSource,
+      extensionDiagnostics: runner.getExtensionDiagnostics?.() ?? [],
+      lifecycleState: runner.getExtensionLifecycleState?.() ?? null,
+      mode: getMode(),
+      contextTokens,
+      activity: formatActivity(activity, frameIndex),
+    });
+    ui.setStatusBar(line);
+    return line;
+  };
+
+  update.startWorking = () => {
+    activity = "working";
+    frameIndex = 0;
+    const line = update();
+    if (!timer) {
+      timer = setInterval(() => {
+        frameIndex = (frameIndex + 1) % WORKING_FRAMES.length;
+        update();
+      }, WORKING_INTERVAL_MS);
+      timer.unref?.();
+    }
+    return line;
+  };
+
+  update.stopWorking = () => {
+    if (activity === "working") activity = null;
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+    return update();
+  };
+
+  update.markAborted = () => {
+    activity = "aborted";
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+    return update();
+  };
+
+  return update;
+}
+
+function formatActivity(activity, frameIndex) {
+  if (activity === "working") return { frame: WORKING_FRAMES[frameIndex], label: "Working" };
+  if (activity === "aborted") return { frame: "x", label: "Aborted" };
+  return null;
+}

package/src/cli/tool-output.mjs

@@ -0,0 +1,9 @@
+export function extractToolOutput(result) {
+  try {
+    const content = result?.content;
+    if (Array.isArray(content)) {
+      return content.filter(c => c.type === "text").map(c => c.text).join("\n");
+    }
+  } catch {}
+  return "";
+}

package/src/cli/tui/editor/external-editor-runner.mjs

@@ -0,0 +1,24 @@
+import { getExternalEditorCommand, openTextInExternalEditor } from "../../input/external-editor.mjs";
+import { yellow } from "../ui-theme.mjs";
+
+export function runTuiExternalEditor({ terminal, tui, editor, output, requestRender, mouseOn }) {
+  const editorCommand = getExternalEditorCommand();
+  if (!editorCommand) {
+    output.writeln(yellow(`● No editor configured. Set $VISUAL or $EDITOR.`));
+    requestRender();
+    return;
+  }
+  try {
+    terminal.write("\x1b[?1049l");
+    tui.stop();
+    if (mouseOn()) terminal.write("\x1b[?1002l\x1b[?1006l");
+    const result = openTextInExternalEditor({ text: editor.getText(), editorCommand });
+    if (result.ok) editor.setText(result.text);
+    else output.writeln(yellow(`● ${result.error}`));
+  } finally {
+    tui.start();
+    terminal.write("\x1b[?1049h");
+    if (mouseOn()) terminal.write("\x1b[?1002h\x1b[?1006h");
+    tui.requestRender(true);
+  }
+}