march-cli 0.1.12 → 0.1.13

package/src/agent/runtime/runner-process-entry.mjs

@@ -0,0 +1,93 @@
+import { join } from "node:path";
+import { createRunner } from "../runner.mjs";
+import { createProcessRuntimeIpcPeer } from "./ipc/process-ipc-transport.mjs";
+import { createRemoteRuntimeUiClient } from "./remote-ui-client.mjs";
+import { createRunnerIpcTarget } from "./runner-ipc-target.mjs";
+import { createMarchAuthStorage } from "../../auth/storage.mjs";
+import { createCliShellRuntime } from "../../shell/cli-runtime.mjs";
+import { MarkdownMemoryStore } from "../../memory/markdown-store.mjs";
+import { createMarkdownMemoryTools } from "../../memory/markdown-tools.mjs";
+import { initializeMcp } from "../../mcp/index.mjs";
+import { createWebToolsFromConfig } from "../../web/tools.mjs";
+import { createPermissionController } from "../../cli/permissions.mjs";
+import { resolvePiSessionManager } from "../../session/pi-manager.mjs";
+import { createModelContextDumper } from "../../debug/model-context-dumper.mjs";
+import { createLogger, installProcessLogHandlers } from "../../debug/logger.mjs";
+import { createDesktopTurnNotifier } from "../../notification/desktop-notifier.mjs";
+
+const peer = createProcessRuntimeIpcPeer({
+  target: createRunnerIpcTarget({ createRunnerImpl: createIsolatedRunner }),
+});
+
+process.once("disconnect", () => peer.dispose());
+
+async function createIsolatedRunner(options = {}) {
+  const ui = createRemoteRuntimeUiClient(peer);
+  const memoryStore = new MarkdownMemoryStore({ root: options.memoryRoot });
+  const memoryTools = createMarkdownMemoryTools(memoryStore);
+  const shellRuntime = options.shellRuntime ? createCliShellRuntime({ cwd: options.cwd }) : null;
+  const mcpInit = await initializeMcp({ projectDir: options.cwd });
+  const logger = createLogger({ logDir: options.logDir ?? (options.stateRoot ? join(options.stateRoot, "logs") : undefined) });
+  installProcessLogHandlers(logger);
+
+  const runner = await createRunner({
+    cwd: options.cwd,
+    modelId: options.modelId,
+    provider: options.provider,
+    serviceTier: options.serviceTier,
+    providers: options.providers,
+    stateRoot: options.stateRoot,
+    ui,
+    memoryRoot: options.memoryRoot,
+    profilePaths: options.profilePaths,
+    memoryStore,
+    memoryTools,
+    shellRuntime,
+    mcpTools: mcpInit.mcpTools,
+    mcpInjections: mcpInit.mcpInjections,
+    mcpClientManager: mcpInit.clientManager,
+    webTools: createWebToolsFromConfig(options.config ?? {}),
+    namespace: options.namespace,
+    projectMarchDir: options.projectMarchDir,
+    extensionPaths: options.extensionPaths ?? [],
+    sessionManager: resolvePiSessionManager({
+      cwd: options.cwd,
+      projectMarchDir: options.projectMarchDir,
+      enabled: true,
+    }),
+    useRuntimeHost: true,
+    syncPiSidecar: true,
+    lifecycleHooks: options.lifecycleHooks ?? [],
+    lifecycleDiagnostics: options.lifecycleDiagnostics ?? [],
+    authStorage: createMarchAuthStorage({
+      provider: options.provider ?? "deepseek",
+      providers: options.providers,
+      cwd: options.cwd,
+    }).authStorage,
+    maxTurns: options.config?.maxTurns ?? undefined,
+    trimBatch: options.config?.trimBatch ?? undefined,
+    hostedTools: options.config?.hostedTools,
+    permissionController: createPermissionController({ mode: options.permissionMode }),
+    modelContextDumper: createModelContextDumper(options.modelContextDumper ?? { enabled: false }),
+    turnNotifier: createDesktopTurnNotifier({
+      enabled: Boolean(options.config?.notifications?.turnEnd),
+      config: options.config?.notifications,
+    }),
+    logger,
+    onModelPayload: (event) => peer.notify("modelPayload", pickModelPayloadEvent(event)),
+  });
+
+  const originalDispose = runner.dispose;
+  runner.dispose = async () => {
+    try {
+      await originalDispose.call(runner);
+    } finally {
+      memoryStore.close?.();
+    }
+  };
+  return runner;
+}
+
+function pickModelPayloadEvent({ estimatedTokens, provider, model, kind, turnId } = {}) {
+  return { estimatedTokens, provider, model, kind, turnId };
+}

package/src/agent/runtime/ui-event-bridge.mjs

@@ -0,0 +1,85 @@
+export function createRuntimeUiEventTarget(ui) {
+  return {
+    uiEvent: (event) => dispatchRuntimeUiEvent(ui, event),
+    uiRequest: (event) => dispatchRuntimeUiEvent(ui, event),
+  };
+}
+
+export function createRuntimeUiEventBus() {
+  const listeners = new Set();
+  return {
+    on(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    emit(event) {
+      for (const listener of [...listeners]) listener(event);
+    },
+    async request(event) {
+      let response;
+      for (const listener of [...listeners]) {
+        const result = await listener(event);
+        if (response === undefined && result !== undefined) response = result;
+      }
+      return response;
+    },
+  };
+}
+
+export function createRuntimeUiBridge(ui, { eventBus = createRuntimeUiEventBus() } = {}) {
+  const detach = eventBus.on((event) => dispatchRuntimeUiEvent(ui, event));
+  return {
+    ui: createRuntimeUiClient(eventBus),
+    eventBus,
+    detach,
+  };
+}
+
+export function createRuntimeUiClient(eventBus) {
+  return {
+    turnStart: () => eventBus.emit({ type: "turn_start" }),
+    turnEnd: () => eventBus.emit({ type: "turn_end" }),
+    assistantReplyEnd: () => eventBus.emit({ type: "assistant_reply_end" }),
+    textDelta: (delta) => eventBus.emit({ type: "text_delta", delta }),
+    thinkingStart: () => eventBus.emit({ type: "thinking_start" }),
+    thinkingDelta: (delta) => eventBus.emit({ type: "thinking_delta", delta }),
+    thinkingEnd: (tokens) => eventBus.emit({ type: "thinking_end", tokens }),
+    toolStart: (name, args) => eventBus.emit({ type: "tool_start", name, args }),
+    toolEnd: (name, isError, result) => eventBus.emit({ type: "tool_end", name, isError, result }),
+    retryStart: (event) => eventBus.emit({ type: "retry_start", ...event }),
+    retryEnd: (event) => eventBus.emit({ type: "retry_end", ...event }),
+    status: (text) => eventBus.emit({ type: "status", text }),
+    memoryHint: ({ source, hints }) => eventBus.emit({ type: "memory_hint", source, hints }),
+    editDiff: (path, diffLines) => eventBus.emit({ type: "edit_diff", path, diffLines }),
+    requestPermission: (request) => eventBus.request({ type: "permission_request", ...request }),
+  };
+}
+
+export function dispatchRuntimeUiEvent(ui, event) {
+  switch (event.type) {
+    case "turn_start": return ui.turnStart?.();
+    case "turn_end": return ui.turnEnd?.();
+    case "assistant_reply_end": return ui.assistantReplyEnd?.();
+    case "text_delta": return ui.textDelta?.(event.delta);
+    case "thinking_start": return ui.thinkingStart?.();
+    case "thinking_delta": return ui.thinkingDelta?.(event.delta);
+    case "thinking_end": return ui.thinkingEnd?.(event.tokens);
+    case "tool_start": return ui.toolStart?.(event.name, event.args);
+    case "tool_end": return ui.toolEnd?.(event.name, event.isError, event.result);
+    case "retry_start": return ui.retryStart?.(pickRetryStart(event));
+    case "retry_end": return ui.retryEnd?.(pickRetryEnd(event));
+    case "status": return ui.status?.(event.text);
+    case "memory_hint": return ui.memoryHint?.({ source: event.source, hints: event.hints });
+    case "edit_diff": return ui.editDiff?.(event.path, event.diffLines);
+    case "permission_request": return ui.requestPermission?.({ toolName: event.toolName, params: event.params, category: event.category });
+    default: return undefined;
+  }
+}
+
+function pickRetryStart({ attempt, maxAttempts, delayMs, errorMessage }) {
+  return { attempt, maxAttempts, delayMs, errorMessage };
+}
+
+function pickRetryEnd({ success, attempt, finalError }) {
+  return { success, attempt, finalError };
+}

package/src/agent/tool-summary.mjs

@@ -0,0 +1,112 @@
+export function formatToolStartLine(name, args = {}) {
+  if (name === "edit_file") {
+    const path = compactPath(args?.path ?? "");
+    const editCount = Array.isArray(args?.edits) ? args.edits.length : 0;
+    const mode = args?.mode ?? "patch";
+    const summary = mode === "patch" ? `${editCount} edit${editCount === 1 ? "" : "s"}` : mode;
+    return joinToolParts("◆", name, [path, summary]);
+  }
+  if (name === "command_exec") return joinToolParts("◆", name, [compactText(args?.command ?? "")]);
+  if (name === "terminal_send") return joinToolParts("◆", name, [args?.shell_id, formatTerminalSendAction(args)]);
+  if (name?.startsWith?.("terminal_")) return joinToolParts("◆", name, [args?.shell_id, formatTerminalDetails(args)]);
+  if (name === "external_web_search") return joinToolParts("◆", name, [quoteCompact(args?.query ?? "")]);
+  if (name === "web_fetch") return joinToolParts("◆", name, [compactText(args?.url ?? "")]);
+  if (name === "context_stats") return joinToolParts("◆", name, []);
+  if (name === "read") {
+    const path = compactPath(args?.path ?? args?.filePath ?? "");
+    return joinToolParts("→", name, [path, formatReadRange(args)]);
+  }
+  if (name === "grep") {
+    const path = compactPath(args?.path ?? "");
+    return joinToolParts("✱", name, [quoteCompact(args?.pattern ?? ""), path]);
+  }
+  if (name === "glob") {
+    const path = compactPath(args?.path ?? "");
+    return joinToolParts("✱", name, [quoteCompact(args?.pattern ?? ""), path]);
+  }
+  if (name === "find") {
+    const path = compactPath(args?.path ?? "");
+    return joinToolParts("✱", name, [quoteCompact(args?.pattern ?? ""), path]);
+  }
+  return joinToolParts("◆", name, [formatSmallOptions(args)]);
+}
+
+export function formatToolSuccessSummary(name, result, out = "") {
+  if (name === "grep") {
+    const matches = result?.details?.results?.length ?? countMatchLines(out);
+    return `${matches} match${matches === 1 ? "" : "es"}`;
+  }
+  if (name === "glob") {
+    const matches = Array.isArray(result?.details?.matches) ? result.details.matches.length : countNonEmptyLines(out);
+    return `${matches} file${matches === 1 ? "" : "s"}`;
+  }
+  if (name === "find") {
+    const matches = result?.details?.count ?? countNonEmptyLines(out);
+    return `${matches} file${matches === 1 ? "" : "s"}`;
+  }
+  if (name === "memory_open") {
+    return compactText(result?.details?.entry?.name ?? compactPath(result?.details?.path ?? ""));
+  }
+  return "";
+}
+
+function joinToolParts(icon, name, parts) {
+  const clean = parts.map((part) => String(part ?? "").trim()).filter(Boolean);
+  return `${icon} ${name}${clean.length ? ` · ${clean.join(" · ")}` : ""}`;
+}
+
+function formatReadRange(args = {}) {
+  if (args.offset == null && args.limit == null) return "";
+  if (args.offset != null && args.limit != null) return `lines ${args.offset}-${Number(args.offset) + Number(args.limit) - 1}`;
+  if (args.offset != null) return `from line ${args.offset}`;
+  return `limit ${args.limit}`;
+}
+
+function formatTerminalSendAction(args = {}) {
+  const hasText = typeof args.text === "string" && args.text.length > 0;
+  const key = args.key ? String(args.key) : "";
+  if (hasText && key) return `text+${key}`;
+  if (hasText) return args.text.includes("\n") || args.text.includes("\r") ? "text+enter" : "text";
+  return key || "send";
+}
+
+function formatTerminalDetails(args = {}) {
+  const details = [];
+  if (args.pattern) details.push(quoteCompact(args.pattern));
+  if (args.cols && args.rows) details.push(`${args.cols}x${args.rows}`);
+  if (args.command) details.push(compactText(args.command));
+  return details.join(" · ");
+}
+
+function formatSmallOptions(args = {}) {
+  const parts = [];
+  for (const [key, value] of Object.entries(args ?? {})) {
+    if (value == null || typeof value === "object") continue;
+    parts.push(`${key}=${compactText(value)}`);
+    if (parts.length >= 2) break;
+  }
+  return parts.join(", ");
+}
+
+function compactPath(path) {
+  return String(path ?? "").split(/[/\\]/).filter(Boolean).slice(-4).join("\\");
+}
+
+function quoteCompact(value) {
+  return JSON.stringify(compactText(value));
+}
+
+function compactText(value, limit = 80) {
+  const text = String(value ?? "").replace(/\s+/g, " ").trim();
+  return text.length > limit ? `${text.slice(0, limit - 1)}…` : text;
+}
+
+function countMatchLines(text) {
+  const match = String(text ?? "").match(/(\d+)\s+matches?\b/i);
+  if (match) return Number(match[1]);
+  return countNonEmptyLines(text);
+}
+
+function countNonEmptyLines(text) {
+  return String(text ?? "").split("\n").filter(Boolean).length;
+}

package/src/agent/turn/turn-events.mjs

@@ -1,3 +1,5 @@
+import { formatToolStartLine, formatToolSuccessSummary } from "../tool-summary.mjs";
+
 export function createTurnEventState() {
   return {
     draft: "",
@@ -5,6 +7,8 @@ export function createTurnEventState() {
     thinkingAccumulator: "",
     recallCursor: { draftLength: 0, thinkingLength: 0 },
     assistantReplyOpen: false,
+    assistantContextParts: [],
+    activeToolContextPart: null,
   };
 }
 
@@ -14,9 +18,11 @@ export function handleRunnerSessionEvent(event, { ui, engine, state }) {
   }
   if (event.type === "tool_execution_start") {
     closeAssistantReply({ ui, state });
+    appendToolStartContext(state, event.toolName, event.args);
     ui.toolStart(event.toolName, event.args);
   }
   if (event.type === "tool_execution_end") {
+    updateToolEndContext(state, event.toolName, event.isError, event.result);
     ui.toolEnd(event.toolName, event.isError, event.result);
   }
   if (event.type === "auto_retry_start") {
@@ -45,6 +51,7 @@ export function closeAssistantReply({ ui, state }) {
 function handleAssistantMessageEvent(event, { ui, state }) {
   if (event.type === "text_delta") {
     state.draft += event.delta;
+    appendAssistantContextText(state, event.delta, "output");
     state.assistantReplyOpen = true;
     ui.textDelta(event.delta);
   }
@@ -54,6 +61,7 @@ function handleAssistantMessageEvent(event, { ui, state }) {
   }
   if (event.type === "thinking_delta") {
     state.thinkingText += event.delta;
+    appendAssistantContextText(state, event.delta, "thinking");
     ui.thinkingDelta(event.delta);
   }
   if (event.type === "thinking_end" && state.thinkingText) {
@@ -63,3 +71,41 @@ function handleAssistantMessageEvent(event, { ui, state }) {
     state.thinkingText = "";
   }
 }
+
+export function compactAssistantContext(state) {
+  return (state?.assistantContextParts ?? [])
+    .map((part) => part?.text ?? "")
+    .join("")
+    .replace(/[ \t]+\n/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+function appendAssistantContextText(state, text, type) {
+  if (!text) return;
+  const parts = state.assistantContextParts;
+  const last = parts.at(-1);
+  if (last?.type === type) {
+    last.text += text;
+    return;
+  }
+  if (last && !last.text.endsWith("\n")) last.text += "\n";
+  parts.push({ type, text });
+}
+
+function appendToolStartContext(state, name, args) {
+  const parts = state.assistantContextParts;
+  const last = parts.at(-1);
+  if (last && !last.text.endsWith("\n")) last.text += "\n";
+  const part = { type: "tool", name, text: `${formatToolStartLine(name, args)}\n` };
+  parts.push(part);
+  state.activeToolContextPart = part;
+}
+
+function updateToolEndContext(state, name, isError, result) {
+  const part = state.activeToolContextPart;
+  if (!part || part.name !== name) return;
+  const summary = isError ? "failed" : formatToolSuccessSummary(name, result, "");
+  if (summary && summary !== "done") part.text = `${part.text.trimEnd()} (${summary})\n`;
+  state.activeToolContextPart = null;
+}

package/src/agent/turn/turn-runner.mjs

@@ -1,5 +1,5 @@
 import { resolveImageAttachmentReferences } from "../../session/attachment-references.mjs";
-import { closeAssistantReply, createTurnEventState, handleRunnerSessionEvent } from "./turn-events.mjs";
+import { closeAssistantReply, compactAssistantContext, createTurnEventState, handleRunnerSessionEvent } from "./turn-events.mjs";
 
 export async function runRunnerTurn({
   prompt,
@@ -122,6 +122,7 @@ function finalizeTurn({ prompt, userMessage, userRecallHints, currentProject, me
   engine.recordTurn({
     userMessage: userMessage ?? prompt.slice(0, 300),
     assistantMessage: turnState.draft,
+    assistantContext: compactAssistantContext(turnState),
     userRecallHints,
     assistantRecallHints: recordedAssistantRecallHints,
   });

package/src/cli/commands/copy-command.mjs

@@ -61,13 +61,27 @@ export function writeSystemClipboardAsync(text, { platform = process.platform }
   });
 }
 
-function clipboardCommand(platform) {
+export function clipboardCommand(platform) {
   if (platform === "win32") {
     return {
       bin: "powershell.exe",
-      args: ["-NoProfile", "-Command", "Set-Clipboard -Value ([Console]::In.ReadToEnd())"],
+      args: ["-NoProfile", "-EncodedCommand", encodePowerShellCommand(readUtf8StdinToClipboardScript())],
     };
   }
   if (platform === "darwin") return { bin: "pbcopy", args: [] };
   return { bin: "sh", args: ["-lc", "command -v wl-copy >/dev/null && wl-copy || xclip -selection clipboard || xsel --clipboard --input"] };
 }
+
+function readUtf8StdinToClipboardScript() {
+  return [
+    "$stdin = [Console]::OpenStandardInput()",
+    "$memory = New-Object System.IO.MemoryStream",
+    "$stdin.CopyTo($memory)",
+    "$text = [System.Text.Encoding]::UTF8.GetString($memory.ToArray())",
+    "Set-Clipboard -Value $text",
+  ].join("; ");
+}
+
+function encodePowerShellCommand(script) {
+  return Buffer.from(script, "utf16le").toString("base64");
+}

package/src/cli/commands/status-command.mjs

@@ -1,6 +1,6 @@
 import { spawnSync } from "node:child_process";
 import { MODES, formatModeLabel } from "../input/mode-state.mjs";
-import { PREFIX, R } from "../tui/ui-theme.mjs";
+import { modeLabel, PREFIX, R } from "../tui/ui-theme.mjs";
 
 export function statusCommand({
   runner,
@@ -78,9 +78,7 @@ export function formatStatusBarLine({
 
   const C = PREFIX; // foreground-only color prefixes (no reset)
   const DIM = C.brightBlack;
-  const OK = "\x1b[32m";  // green, no reset
-  const WARN = "\x1b[33m"; // yellow, no reset
-  const modeSegment = `${mode === MODES.DISCUSS ? WARN : OK}${formatModeLabel(mode)}`;
+  const modeSegment = formatModeSegment(mode);
   const runtime = `${C.cyan}${model}${DIM}·${thinking}`;
   const segments = [modeSegment, runtime];
   const lspText = formatLspSegment(lspStatus);
@@ -94,6 +92,11 @@ export function formatStatusBarLine({
   return `${inner}${R}`;
 }
 
+function formatModeSegment(mode) {
+  const label = formatModeLabel(mode);
+  return (modeLabel[mode] ?? modeLabel.fallback)(label);
+}
+
 export function formatLspSegment(lspStatus) {
   if (!lspStatus) return "";
   const servers = lspStatus.servers ?? [];

package/src/cli/commands/thinking-command.mjs

@@ -55,9 +55,9 @@ export async function handleThinkingCommand(parsed, { runner, ui = null } = {})
       runner.getThinkingLevel?.(),
     );
   }
-  if (parsed.type === "select") return [selectThinkingByIndex(parsed.index, { runner })];
+  if (parsed.type === "select") return [await selectThinkingByIndexAsync(parsed.index, { runner })];
   if (parsed.type === "set") {
-    const level = runner.setThinkingLevel(parsed.level);
+    const level = await runner.setThinkingLevel(parsed.level);
     return [`thinking: ${level}`];
   }
   if (parsed.type === "error") return [`Error: ${parsed.message}`];
@@ -76,5 +76,12 @@ async function selectThinkingInteractively({ runner, ui }) {
     suppressInitialConfirm: true,
   });
   if (!item) return "thinking: unchanged";
-  return `thinking: ${runner.setThinkingLevel(item.level)}`;
+  return `thinking: ${await runner.setThinkingLevel(item.level)}`;
+}
+
+async function selectThinkingByIndexAsync(index, { runner }) {
+  const levels = runner.getAvailableThinkingLevels?.() || THINKING_LEVELS;
+  const level = levels[index - 1];
+  if (!level) return `Error: thinking index out of range: ${index}`;
+  return `thinking: ${await runner.setThinkingLevel(level)}`;
 }

package/src/cli/repl-loop.mjs

@@ -119,7 +119,9 @@ export async function runInteractiveRepl({
 export function contextTokenRefreshOptions(slashResult, runner) {
   if (!slashResult?.refreshContextTokens) return undefined;
   if (typeof runner.estimateContextTokens !== "function") return undefined;
-  return { contextTokens: runner.estimateContextTokens("") };
+  const contextTokens = runner.estimateContextTokens("");
+  if (contextTokens && typeof contextTokens.then === "function") return undefined;
+  return { contextTokens };
 }
 
 function handleInlineCommand(trimmed, { cwd, ui, lastInlineShellCommand }) {

package/src/cli/startup/create-runtime-runner.mjs

@@ -0,0 +1,61 @@
+import { createRunner } from "../../agent/runner.mjs";
+import { createRunnerProcessClient } from "../../agent/runtime/runner-process-client.mjs";
+import { resolvePiSessionManager } from "../../session/pi-manager.mjs";
+
+export async function createRuntimeRunner({
+  useRuntimeProcess = false,
+  runnerOptions,
+  ui,
+  memoryStore,
+  memoryTools,
+  shellRuntime,
+  mcpTools,
+  mcpInjections,
+  mcpClientManager,
+  webTools,
+  usePiSessions,
+  usePiRuntimeHost,
+  authStorage,
+  permissionController,
+  modelContextDumper,
+  turnNotifier,
+  logger,
+  refreshStatusBar,
+} = {}) {
+  const onModelPayload = ({ estimatedTokens }) => {
+    refreshStatusBar?.({ contextTokens: estimatedTokens });
+  };
+
+  const runner = useRuntimeProcess
+    ? (await createRunnerProcessClient({ runnerOptions, ui, onModelPayload })).runner
+    : await createRunner({
+      ...runnerOptions,
+      ui,
+      memoryStore,
+      memoryTools,
+      shellRuntime,
+      mcpTools,
+      mcpInjections,
+      mcpClientManager,
+      webTools,
+      sessionManager: resolvePiSessionManager({
+        cwd: runnerOptions.cwd,
+        projectMarchDir: runnerOptions.projectMarchDir,
+        enabled: usePiSessions,
+      }),
+      useRuntimeHost: usePiRuntimeHost,
+      syncPiSidecar: usePiSessions || usePiRuntimeHost,
+      authStorage,
+      maxTurns: runnerOptions.config?.maxTurns ?? undefined,
+      trimBatch: runnerOptions.config?.trimBatch ?? undefined,
+      hostedTools: runnerOptions.config?.hostedTools,
+      permissionController,
+      modelContextDumper,
+      turnNotifier,
+      logger,
+      onModelPayload,
+    });
+
+  runner.shellRuntime ??= shellRuntime;
+  return runner;
+}

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

@@ -1,17 +1,71 @@
-import { MODES } from "../input/mode-state.mjs";
-import { bold, brightBlack, cyan } from "../tui/ui-theme.mjs";
+import { createRequire } from "node:module";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { MODES, formatModeLabel } from "../input/mode-state.mjs";
+import { brightBlack, cyan, modeLabel, white } from "../tui/ui-theme.mjs";
+
+const CARD_WIDTH = 76;
+const ANSI_RE = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+const { version: packageVersion = "0.1" } = createRequire(import.meta.url)("../../../package.json");
 
 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`);
+  const nextMode = mode === MODES.DISCUSS ? MODES.DO : MODES.DISCUSS;
+  const tip = dumpContextPath
+    ? `${brightBlack("Tip:")} ${cyan("dumps:")} ${brightBlack(dumpContextPath)}`
+    : `${brightBlack("Tip:")} ${brightBlack("Tab to")} ${formatModeTip(nextMode)} ${brightBlack("·")} ${cyan("/help")} ${brightBlack("for commands")}`;
   return [
-    `${cyan("  █▙  ▟█")}   ${bold("March")}`,
-    `${cyan("  █▜▙▟▛█")}   ${brightBlack(`${modelId} · ${thinkingLevel}`)}`,
-    `${cyan("  ▀    ▀")}   ${brightBlack(cwd ?? "")}`,
     "",
-    `  ${hint}`,
+    ...renderStartupCard([
+      `${cyan("  █▙  ▟█")}   ${white("March")} ${brightBlack(`v${packageVersion}`)}`,
+      `${cyan("  █▜▙▟▛█")}   ${brightBlack("Describe a task to get started.")}`,
+      `${cyan("  ▀    ▀")}`,
+      "",
+      tip,
+      brightBlack("March uses AI. Check for mistakes."),
+    ]),
     "",
   ];
 }
+
+function formatModeTip(mode) {
+  const label = formatModeLabel(mode);
+  return (modeLabel[mode] ?? modeLabel.fallback)(label);
+}
+
+function renderStartupCard(contentLines, width = CARD_WIDTH) {
+  const safeWidth = Math.max(24, Math.trunc(width));
+  const innerWidth = safeWidth - 4;
+  return [
+    white(`╭${"─".repeat(safeWidth - 2)}╮`),
+    ...contentLines.map((line) => white("│ ") + padAnsi(line, innerWidth) + white(" │")),
+    white(`╰${"─".repeat(safeWidth - 2)}╯`),
+  ];
+}
+
+function padAnsi(text, width) {
+  const clipped = clipAnsi(text, width);
+  const padding = Math.max(0, width - visibleWidth(stripAnsi(clipped)));
+  return `${clipped}${" ".repeat(padding)}`;
+}
+
+function clipAnsi(text, width) {
+  let output = "";
+  let plainWidth = 0;
+  let inAnsi = false;
+  for (const ch of Array.from(String(text ?? ""))) {
+    if (ch === "\x1b") inAnsi = true;
+    if (inAnsi) {
+      output += ch;
+      if (/[@-~]/.test(ch)) inAnsi = false;
+      continue;
+    }
+    const charWidth = visibleWidth(ch);
+    if (plainWidth + charWidth > width) break;
+    output += ch;
+    plainWidth += charWidth;
+  }
+  return output;
+}
+
+function stripAnsi(text) {
+  return String(text ?? "").replace(ANSI_RE, "");
+}

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

@@ -9,19 +9,28 @@ export class MainPaneLayout {
 
   render(width) {
     const safeWidth = Math.max(1, Math.trunc(width));
-    const statusLines = this.statusBar.render(safeWidth);
-    const editorLines = this.editor.render(safeWidth);
-    const fixedHeight = statusLines.length + editorLines.length;
+    const statusTopLines = this.statusBar.renderTop?.(safeWidth) ?? this.statusBar.render(safeWidth);
+    const rawEditorLines = this.editor.render(safeWidth);
+    const editorLines = this.statusBar.renderInputLines?.(rawEditorLines, safeWidth)
+      ?? rawEditorLines.map((line) => this.statusBar.renderInputLine?.(line, safeWidth) ?? line);
+    const statusBottomLines = this.statusBar.renderBottom?.(safeWidth) ?? [];
+    const fixedHeight = statusTopLines.length + editorLines.length + statusBottomLines.length;
     const viewportHeight = Math.max(1, (this.terminal?.rows || 30) - fixedHeight);
     this.output.setViewportHeight(viewportHeight);
     const outputLines = this.output.render(safeWidth);
     const outputTop = Math.max(0, viewportHeight - outputLines.length);
-    this.selection?.setViewport({ topRow: outputTop, leftCol: 0, width: safeWidth, lines: outputLines });
-    const selectedOutputLines = this.selection?.apply(outputLines) ?? outputLines;
+    const editorTop = viewportHeight + statusTopLines.length;
+    this.selection?.setRegions?.([
+      { id: "output", topRow: outputTop, leftCol: 0, width: safeWidth, lines: outputLines },
+      { id: "editor", topRow: editorTop, leftCol: 0, width: safeWidth, lines: editorLines },
+    ]);
+    const selectedOutputLines = this.selection?.applyRegion?.("output", outputLines) ?? outputLines;
+    const selectedEditorLines = this.selection?.applyRegion?.("editor", editorLines) ?? editorLines;
     return [
       ...padToHeight(selectedOutputLines, viewportHeight),
-      ...statusLines,
-      ...editorLines,
+      ...statusTopLines,
+      ...selectedEditorLines,
+      ...statusBottomLines,
     ];
   }