march-cli 0.1.9 → 0.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "march-cli",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "March CLI — terminal-native coding agent with context reconstruction",
   "type": "module",
   "main": "./src/main.mjs",

package/src/agent/editing/lsp-report.mjs

@@ -0,0 +1,69 @@
+import { formatLspDiagnosticsForPath } from "../../lsp/diagnostics-format.mjs";
+import { sameLspPath } from "../../lsp/path-match.mjs";
+
+export async function waitForLspReport({ lspService, path, lspResult, since = Date.now(), timeoutMs = 3000, intervalMs = 150 }) {
+  const immediate = formatLspResultMessage(lspResult);
+  if (!lspService?.snapshot || !path || lspResult?.status === "unsupported") return immediate;
+  if (lspResult?.status === "unavailable" || lspResult?.status === "failed") return immediate;
+
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    const snapshot = lspService.snapshot();
+    const diagnostics = formatCurrentLspDiagnosticsForPath({ snapshot, path, since });
+    if (diagnostics) return diagnostics;
+    if (hasCurrentDiagnosticPublish({ snapshot, path, since })) return formatNoLspDiagnostics({ snapshot });
+
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) return formatLatestLspMessage({ snapshot, lspResult });
+    await sleep(Math.min(intervalMs, remaining));
+  }
+}
+
+function formatLspResultMessage(result, { timedOut = false } = {}) {
+  if (!result || result.status === "unsupported") return "";
+  if (result.status === "unavailable" || result.status === "failed") {
+    return `<lsp status="${result.status}" server="${result.id ?? "unknown"}">${result.reason ?? "unavailable"}</lsp>`;
+  }
+  if (result.status === "starting") {
+    const detail = timedOut ? "diagnostics still pending; server continues in background" : "diagnostics pending";
+    return `<lsp status="starting" server="${result.id}">${detail}</lsp>`;
+  }
+  return "";
+}
+
+function formatCurrentLspDiagnosticsForPath({ snapshot, path, since }) {
+  const diagnostics = formatLspDiagnosticsForPath({ snapshot, path });
+  if (!diagnostics) return "";
+  if (!Array.isArray(snapshot?.files)) return diagnostics;
+  return hasCurrentDiagnosticPublish({ snapshot, path, since }) ? diagnostics : "";
+}
+
+function hasCurrentDiagnosticPublish({ snapshot, path, since }) {
+  return (snapshot?.files ?? []).some((file) => sameLspPath(file.path, path) && (file.updatedAt ?? 0) >= since);
+}
+
+function formatNoLspDiagnostics({ snapshot }) {
+  const lines = ["[diagnostics]", "source: lsp"];
+  if (snapshot?.status) lines.push(`status: ${snapshot.status}`);
+  lines.push("summary: 0 diagnostics");
+  return lines.join("\n");
+}
+
+function formatLatestLspMessage({ snapshot, lspResult }) {
+  const server = latestServerForResult(snapshot, lspResult);
+  if (server?.status === "failed" || server?.status === "unavailable") {
+    return formatLspResultMessage({ ...lspResult, ...server });
+  }
+  if (server?.status === "idle" || server?.status === "ready") return formatNoLspDiagnostics({ snapshot });
+  return formatLspResultMessage(lspResult, { timedOut: lspResult?.status === "starting" });
+}
+
+function latestServerForResult(snapshot, lspResult) {
+  const servers = snapshot?.servers ?? [];
+  return servers.find((server) => server.id === lspResult?.id && server.root === lspResult?.root)
+    ?? servers.find((server) => server.id === lspResult?.id);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/agent/file-edit-tool.mjs

@@ -5,7 +5,7 @@ import { Type } from "typebox";
 import { toolText } from "./tool-result.mjs";
 import { applyReplaceTextPatch, applyReplaceRangePatch } from "./editing/diff-apply.mjs";
 import { formatAppliedDiff, formatDiff } from "./editing/diff-format.mjs";
-import { formatLspDiagnosticsForPath } from "../lsp/diagnostics-format.mjs";
+import { waitForLspReport } from "./editing/lsp-report.mjs";
 
 export { formatDiff } from "./editing/diff-format.mjs";
 
@@ -72,10 +72,11 @@ async function writeFullFile({ absPath, path, content, mode, engine, ui, lspServ
   try {
     mkdirSync(dirname(absPath), { recursive: true });
     writeFileSync(absPath, content, "utf8");
-    lspService?.touchFile?.(absPath);
+    const lspTouchedAt = Date.now();
+    const lspResult = await lspService?.touchFile?.(absPath);
     ui.editDiff(absPath, diffLines);
 
-    return await toolTextWithDiagnostics(`${mode === WRITE_MODE ? "Wrote" : "Overwrote"} ${path}\n\n${formatAppliedDiff([{ oldText, newText: content, startLine: 1 }])}`, { path: absPath }, { lspService, path: absPath });
+    return await toolTextWithDiagnostics(`${mode === WRITE_MODE ? "Wrote" : "Overwrote"} ${path}\n\n${formatAppliedDiff([{ oldText, newText: content, startLine: 1 }])}`, { path: absPath }, { lspService, path: absPath, lspResult, since: lspTouchedAt });
   } catch (err) {
     return toolText(`Error writing ${absPath}: ${err.message}`, { error: true });
   }
@@ -100,33 +101,18 @@ async function patchFile({ absPath, path, edits, engine, ui, lspService }) {
   try {
     mkdirSync(dirname(absPath), { recursive: true });
     writeFileSync(absPath, newContent, "utf8");
-    lspService?.touchFile?.(absPath);
+    const lspTouchedAt = Date.now();
+    const lspResult = await lspService?.touchFile?.(absPath);
     ui.editDiff(absPath, prepared.edits.flatMap((edit) => formatDiff(edit.oldText, edit.newText, { startLine: edit.startLine })));
-    return await toolTextWithDiagnostics(`Edited ${absPath}\n\n${formatAppliedDiff(prepared.edits)}`, { path: absPath, edits: prepared.edits.length }, { lspService, path: absPath });
+    return await toolTextWithDiagnostics(`Edited ${absPath}\n\n${formatAppliedDiff(prepared.edits)}`, { path: absPath, edits: prepared.edits.length }, { lspService, path: absPath, lspResult, since: lspTouchedAt });
   } catch (err) {
     return toolText(`Error writing ${absPath}: ${err.message}`, { error: true });
   }
 }
 
-async function toolTextWithDiagnostics(text, details, { lspService, path, timeoutMs = 3000, intervalMs = 150 } = {}) {
-  const diagnostics = await waitForDiagnosticsForPath({ lspService, path, timeoutMs, intervalMs });
-  return toolText(diagnostics ? `${text}\n\n${diagnostics}` : text, details);
-}
-
-async function waitForDiagnosticsForPath({ lspService, path, timeoutMs, intervalMs }) {
-  if (!lspService?.snapshot || !path) return "";
-  const deadline = Date.now() + timeoutMs;
-  for (;;) {
-    const diagnostics = formatLspDiagnosticsForPath({ snapshot: lspService.snapshot(), path });
-    if (diagnostics) return diagnostics;
-    const remaining = deadline - Date.now();
-    if (remaining <= 0) return "";
-    await sleep(Math.min(intervalMs, remaining));
-  }
-}
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+async function toolTextWithDiagnostics(text, details, { lspService, path, lspResult, since = Date.now(), timeoutMs = 3000, intervalMs = 150 } = {}) {
+  const lspReport = await waitForLspReport({ lspService, path, lspResult, since, timeoutMs, intervalMs });
+  return toolText(lspReport ? `${text}\n\n${lspReport}` : text, details);
 }
 
 export function preparePatchEdits(content, edits, path = "file") {

package/src/agent/model-payload-dumper.mjs

@@ -170,24 +170,31 @@ function formatContentPart(part) {
 }
 
 function formatToolSummary(tool) {
-  const name = tool?.function?.name ?? tool?.name ?? "unnamed_tool";
+  const name = tool?.function?.name ?? tool?.name ?? tool?.type ?? googleToolName(tool) ?? "unnamed_tool";
   const description = tool?.function?.description ?? tool?.description ?? "";
   return description ? `${name}: ${description}` : name;
 }
 
 function extractPayloadTools(payload) {
+
   if (!payload || typeof payload !== "object") return null;
   if (Array.isArray(payload.tools)) return payload.tools;
-  if (payload.body && typeof payload.body === "object" && Array.isArray(payload.body.tools)) return payload.body.tools;
+  if (Array.isArray(payload.config?.tools)) return payload.config.tools;
+  if (payload.body && typeof payload.body === "object") return extractPayloadTools(payload.body);
   if (typeof payload.body === "string") {
     try {
-      const body = JSON.parse(payload.body);
-      if (Array.isArray(body.tools)) return body.tools;
+      return extractPayloadTools(JSON.parse(payload.body));
     } catch {}
   }
   return null;
 }
 
+function googleToolName(tool) {
+  if (tool?.googleSearch) return "googleSearch";
+  if (tool?.googleSearchRetrieval) return "googleSearchRetrieval";
+  return null;
+}
+
 function textChars(value) {
   if (value == null) return 0;
   if (typeof value === "string") return value.length;

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

@@ -0,0 +1,18 @@
+export function providerContextToPayload(providerContext) {
+  return {
+    messages: [
+      { role: "system", content: providerContext.system },
+      ...(providerContext.userMessages ?? []).map((message) => ({ role: "user", content: message.content })),
+    ],
+  };
+}
+
+export async function notifyTurnEndBestEffort(turnNotifier, event) {
+  if (!turnNotifier?.notifyTurnEnd) return { ok: false, reason: "not-configured", results: [] };
+  try {
+    return await turnNotifier.notifyTurnEnd(event);
+  } catch (err) {
+    // Notification must never change turn behavior.
+    return { ok: false, reason: err?.message ?? String(err), results: [] };
+  }
+}

package/src/agent/runner.mjs

@@ -15,21 +15,22 @@ import { resolveInitialModel, resolveRunnerSessionManager } from "./runner/runne
 import { runRunnerCleanup } from "./runner/runner-cleanup.mjs";
 import { createRunnerRuntimeHost } from "./runtime/runner-runtime-host.mjs";
 import { getRunnerSessionStats, syncEngineSessionState } from "./runner/runner-session-state.mjs";
+import { notifyTurnEndBestEffort, providerContextToPayload } from "./runner/runner-utils.mjs";
 import { resolveRunnerSessionOptions } from "./session/session-options.mjs";
 import { createSessionBinding } from "./session/session-binding.mjs";
 import { maybeAutoNameSession } from "./session/session-auto-name.mjs";
 import { MARCH_BASE_TOOL_NAMES } from "./tool-names.mjs";
 import { runRunnerTurn } from "./turn/turn-runner.mjs";
+import { beginLoggedTurn } from "./turn/turn-logging.mjs";
 import { appendFastVariants, createFastModelEntry, fromFastEntryModel, isFastProvider } from "./runner/fast-model.mjs";
 import { registerSuperGrokProvider } from "../supergrok/provider.mjs";
 import { registerCustomProviders } from "../provider/custom-provider.mjs";
-
+import { injectHostedTools } from "../provider/hosted-tools.mjs";
 export { MARCH_BASE_TOOL_NAMES };
 export { installModelPayloadDumper } from "./model-payload-dumper.mjs";
 export { createDefaultSessionManager, resolveRunnerSessionManager } from "./runner/runner-init.mjs";
 export { getRunnerSessionStats, syncEngineSessionState } from "./runner/runner-session-state.mjs";
-
-export async function createRunner({ cwd, modelId = null, provider = null, providers = {}, stateRoot, ui, memoryRoot = null, centerMemoryPath = null, memoryStore = null, memoryTools = [], shellRuntime = null, mcpTools = [], mcpInjections = [], mcpClientManager = null, webTools = [], namespace = "", sessionManager = null, useRuntimeHost = false, projectMarchDir = null, syncPiSidecar = false, extensionPaths = [], lifecycleHooks = [], lifecycleDiagnostics = [], authStorage = null, permissionController = null, modelContextDumper = null, turnNotifier = null, onModelPayload = null, createAgentSessionImpl = createAgentSession, createAgentSessionRuntimeImpl, createRuntimeServices, createRuntimeSessionFromServices, maxTurns, trimBatch, serviceTier = null }) {
+export async function createRunner({ cwd, modelId = null, provider = null, providers = {}, stateRoot, ui, memoryRoot = null, centerMemoryPath = null, memoryStore = null, memoryTools = [], shellRuntime = null, mcpTools = [], mcpInjections = [], mcpClientManager = null, webTools = [], namespace = "", sessionManager = null, useRuntimeHost = false, projectMarchDir = null, syncPiSidecar = false, extensionPaths = [], lifecycleHooks = [], lifecycleDiagnostics = [], authStorage = null, permissionController = null, modelContextDumper = null, turnNotifier = null, logger = null, onModelPayload = null, createAgentSessionImpl = createAgentSession, createAgentSessionRuntimeImpl, createRuntimeServices, createRuntimeSessionFromServices, maxTurns, trimBatch, serviceTier = null, hostedTools = {} }) {
   if (!useRuntimeHost && extensionPaths.length > 0) {
     throw new Error("--extension requires the default pi runtime host path");
   }
@@ -53,7 +54,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
   const engine = new ContextEngine({ cwd, modelId, provider, namespace, memoryRoot, centerMemoryPath, shellRuntime, lspService, injections: mcpInjections, maxTurns, trimBatch });
   const resolvedSessionManager = resolveRunnerSessionManager(cwd, sessionManager);
   const sessionBinding = createSessionBinding(null);
-  let currentModelCallKind = "model";
+  let currentModelCallKind = "model", currentTurnId = null;
   let currentPromptForContext = "";
   let currentTurnContextMode = "rebuild";
   let nextTurnContextMode = "rebuild";
@@ -70,9 +71,9 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
       sessionManager: resolvedSessionManager, sessionBinding, engine, ui,
       projectMarchDir,
       memoryTools, memoryStore, shellRuntime, lspService, mcpTools, webTools,
-      permissionController, extensionPaths,
+      permissionController, extensionPaths, hostedTools,
       onRebind: (session) => {
-        installModelPayloadDumper(session, modelContextDumper, () => currentModelCallKind, onModelPayload, injectMarchSystemContext);
+        installModelPayloadDumper(session, modelContextDumper, () => currentModelCallKind, onLoggedModelPayload, injectMarchSystemContext);
         syncEngineSessionState(engine, session);
       },
       createAgentSessionRuntimeImpl,
@@ -91,7 +92,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
       sessionManager: resolvedSessionManager, settingsManager,
     });
     sessionBinding.set(session);
-    installModelPayloadDumper(session, modelContextDumper, () => currentModelCallKind, onModelPayload, injectMarchSystemContext);
+    installModelPayloadDumper(session, modelContextDumper, () => currentModelCallKind, onLoggedModelPayload, injectMarchSystemContext);
   }
   syncEngineSessionState(engine, sessionBinding.get());
   lifecycleAdapter = createMarchLifecycleAdapter({
@@ -115,11 +116,14 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
       nextTurnContextMode = "rebuild";
       pendingMidTurnRecallHints = [];
       const turnStartedAt = Date.now();
+      const turnLog = beginLoggedTurn({ logger, engine, modelId, provider, contextMode, userMessage, userRecallHints, startedAt: turnStartedAt }); currentTurnId = turnLog.turnId;
       try {
         const result = await runRunnerTurn({
           prompt, userMessage, options: { userRecallHints, currentProject },
           sessionBinding, engine, ui, projectMarchDir, memoryStore,
           setModelCallKind: (kind) => { currentModelCallKind = kind; },
+          logger: turnLog.logger,
+          setPhase: turnLog.setPhase,
           onMidTurnRecallHints: (hints) => { pendingMidTurnRecallHints.push(...hints); },
           syncCurrentPiSidecar,
           autoNameSession,
@@ -131,6 +135,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
           draft: result?.draft ?? "",
           durationMs: Date.now() - turnStartedAt,
         });
+        turnLog.endSuccess(result);
         return result;
       } catch (err) {
         lastNotificationResult = await notifyTurnEndBestEffort(turnNotifier, {
@@ -139,8 +144,10 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
           errorMessage: err?.message ?? String(err),
           durationMs: Date.now() - turnStartedAt,
         });
+        turnLog.endError(err);
         throw err;
       } finally {
+        currentTurnId = null;
         currentTurnContextMode = "rebuild";
       }
     },
@@ -265,11 +272,22 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
       },
     });
   }
-  function injectMarchSystemContext(payload, { kind } = {}) {
+  function onLoggedModelPayload(event) {
+    logger?.event("model.payload", {
+      kind: event.kind,
+      provider: event.model?.provider,
+      model: event.model?.id,
+      estimatedTokens: event.estimatedTokens,
+      turnId: currentTurnId,
+    });
+    onModelPayload?.(event);
+  }
+  function injectMarchSystemContext(payload, { kind, model } = {}) {
     if (kind !== "user") return payload;
     let nextPayload = currentTurnContextMode === "continueExistingPiTranscript"
       ? payload
       : replaceProviderContextMessages(payload, engine.buildProviderContext(currentPromptForContext));
+    nextPayload = injectHostedTools(nextPayload, model, hostedTools);
     if (_currentFastEntry) nextPayload = { ...nextPayload, service_tier: "priority" };
     if (pendingMidTurnRecallHints.length > 0) {
       nextPayload = appendProviderUserMessage(nextPayload, formatRecallHints("assistant", pendingMidTurnRecallHints));
@@ -278,22 +296,3 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
     return nextPayload;
   }
 }
-
-function providerContextToPayload(providerContext) {
-  return {
-    messages: [
-      { role: "system", content: providerContext.system },
-      ...(providerContext.userMessages ?? []).map((message) => ({ role: "user", content: message.content })),
-    ],
-  };
-}
-
-async function notifyTurnEndBestEffort(turnNotifier, event) {
-  if (!turnNotifier?.notifyTurnEnd) return { ok: false, reason: "not-configured", results: [] };
-  try {
-    return await turnNotifier.notifyTurnEnd(event);
-  } catch (err) {
-    // Notification must never change turn behavior.
-    return { ok: false, reason: err?.message ?? String(err), results: [] };
-  }
-}

package/src/agent/runtime/runner-runtime-host.mjs

@@ -26,6 +26,7 @@ export async function createRunnerRuntimeHost({
   webTools = [],
   permissionController = null,
   extensionPaths = [],
+  hostedTools = {},
   onRebind = null,
   createAgentSessionRuntimeImpl = createAgentSessionRuntime,
   createServices,
@@ -60,6 +61,7 @@ export async function createRunnerRuntimeHost({
         permissionController,
         authStorage,
         projectMarchDir,
+        hostedTools,
       });
     },
   });

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

@@ -0,0 +1,30 @@
+import { createHeartbeat, formatError } from "../../debug/logger.mjs";
+
+export function beginLoggedTurn({ logger, engine, modelId, provider, contextMode, userMessage, userRecallHints, startedAt = Date.now() } = {}) {
+  const turnId = `${startedAt.toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  let phase = "starting";
+  const turnLogger = logger?.child?.({ turnId, sessionName: engine?.sessionName, modelId, provider });
+  const heartbeat = createHeartbeat({
+    logger: turnLogger,
+    event: "turn.heartbeat",
+    getFields: () => ({ phase, elapsedMs: Date.now() - startedAt }),
+  });
+  turnLogger?.event("turn.start", {
+    userMessageLength: String(userMessage ?? "").length,
+    contextMode,
+    userRecallHintCount: userRecallHints?.length ?? 0,
+  });
+  return {
+    turnId,
+    logger: turnLogger,
+    setPhase(value) { phase = value; },
+    endSuccess(result) {
+      heartbeat.stop();
+      turnLogger?.event("turn.end", { status: "success", durationMs: Date.now() - startedAt, draftLength: result?.draft?.length ?? 0 });
+    },
+    endError(err) {
+      heartbeat.stop();
+      turnLogger?.error("turn.error", { durationMs: Date.now() - startedAt, phase, error: formatError(err) });
+    },
+  };
+}

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

@@ -11,6 +11,8 @@ export async function runRunnerTurn({
   projectMarchDir,
   memoryStore,
   setModelCallKind,
+  logger = null,
+  setPhase = null,
   onMidTurnRecallHints,
   syncCurrentPiSidecar,
   autoNameSession,
@@ -24,8 +26,16 @@ export async function runRunnerTurn({
   const turnState = createTurnEventState();
   const midTurnRecallHints = [];
   ui.turnStart();
+  setPhase?.("subscribed");
+  logger?.event("turn.ui.start");
 
   const unsubscribe = activeSession.subscribe((event) => {
+    logSessionEvent(logger, event);
+    if (event.type === "tool_execution_start") setPhase?.(`tool_running:${event.toolName ?? "unknown"}`);
+    if (event.type === "tool_execution_end") setPhase?.("model_streaming");
+    if (event.type === "auto_retry_start") setPhase?.("retry_wait");
+    if (event.type === "auto_retry_end") setPhase?.("model_streaming");
+    if (event.type === "message_update") setPhase?.("model_streaming");
     handleRunnerSessionEvent(event, { ui, engine, state: turnState });
     if (event.type === "tool_execution_start") {
       const hints = flushAssistantRecall({ memoryStore, engine, turnState, currentProject });
@@ -42,7 +52,10 @@ export async function runRunnerTurn({
       text: userMessage ?? prompt,
       projectMarchDir,
     });
+    logger?.event("turn.attachments.resolved", { imageCount: attachmentReferences.images.length });
     setModelCallKind("user");
+    setPhase?.("model_request");
+    logger?.event("model.prompt.start", { contextMode });
     try {
       if (contextMode === "rebuild") resetPiMessageHistory(activeSession);
       await activeSession.prompt(
@@ -51,8 +64,10 @@ export async function runRunnerTurn({
       );
     } finally {
       setModelCallKind("model");
+      logger?.event("model.prompt.end");
     }
 
+    setPhase?.("finalizing");
     finalizeTurn({
       prompt,
       userMessage,
@@ -68,11 +83,36 @@ export async function runRunnerTurn({
     });
     return { draft: turnState.draft };
   } finally {
+    logger?.event("turn.ui.end");
     ui.turnEnd();
     unsubscribe();
   }
 }
 
+function logSessionEvent(logger, event) {
+  if (!logger) return;
+  if (event.type === "message_update") {
+    const messageEvent = event.assistantMessageEvent;
+    logger.debug("session.event", {
+      type: event.type,
+      assistantMessageType: messageEvent?.type,
+      deltaLength: messageEvent?.delta?.length,
+    });
+    return;
+  }
+  logger.event("session.event", {
+    type: event.type,
+    toolName: event.toolName,
+    isError: event.isError,
+    attempt: event.attempt,
+    maxAttempts: event.maxAttempts,
+    delayMs: event.delayMs,
+    success: event.success,
+    errorMessage: event.errorMessage,
+    finalError: event.finalError,
+  });
+}
+
 function finalizeTurn({ prompt, userMessage, userRecallHints, currentProject, memoryStore, engine, ui, turnState, midTurnRecallHints, syncCurrentPiSidecar, autoNameSession }) {
   closeAssistantReply({ ui, state: turnState });
   const assistantRecallHints = flushAssistantRecall({ memoryStore, engine, turnState, currentProject });

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 { accent, text, PREFIX, R } from "../tui/ui-theme.mjs";
+import { PREFIX, R } from "../tui/ui-theme.mjs";
 
 export function statusCommand({
   runner,
@@ -23,11 +23,6 @@ export function statusCommand({
 
 export function statusBarLine({
   runner,
-  sessionState,
-  sessionSource = "pi",
-  extensionDiagnostics = [],
-  lifecycleState = null,
-  gitBranch = getGitBranch(runner.engine.cwd),
   mode = MODES.DO,
   contextTokens = null,
   activity = null,
@@ -35,12 +30,6 @@ export function statusBarLine({
 }) {
   return formatStatusBarLine({
     engine: runner.engine,
-    sessionState,
-    sessionStats: runner.getSessionStats?.() ?? null,
-    sessionSource,
-    extensionDiagnostics,
-    lifecycleState,
-    gitBranch,
     mode,
     contextTokens,
     activity,
@@ -122,12 +111,11 @@ function buildLspStatusParts(servers) {
     byId.set(id, mergeLspStatus(byId.get(id), server.status));
   }
   return [...byId.entries()]
-    .filter(([, status]) => status !== "unavailable")
     .map(([id, status]) => `${id}${formatLspStatusMark(status)}`);
 }
 
 function mergeLspStatus(current, next) {
-  const rank = { failed: 4, starting: 3, busy: 2, ready: 1, idle: 1, unavailable: 0 };
+  const rank = { failed: 5, installing: 4, starting: 3, busy: 2, ready: 1, idle: 1, unavailable: 0 };
   if (!current) return next ?? "unavailable";
   const currentRank = rank[current] ?? 0;
   const nextRank = rank[next] ?? 0;
@@ -136,8 +124,8 @@ function mergeLspStatus(current, next) {
 
 function formatLspStatusMark(status) {
   if (status === "failed") return "!";
-  if (status === "starting") return "…";
-  if (status === "unavailable") return "";
+  if (status === "starting" || status === "installing") return "…";
+  if (status === "unavailable") return "?";
   return "✓";
 }
 

package/src/cli/permissions.mjs

@@ -40,7 +40,7 @@ const DEFAULT_CATEGORIES = {
   terminal_search: PERM.COMMAND_EXEC,
   terminal_read: PERM.COMMAND_EXEC,
   terminal_snapshot: PERM.COMMAND_EXEC,
-  web_search: PERM.NETWORK_EXTERNAL,
+  external_web_search: PERM.NETWORK_EXTERNAL,
   web_fetch: PERM.NETWORK_EXTERNAL,
 };
 

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

@@ -137,7 +137,7 @@ export class ShellDrawer {
 
   getOutputLines(shellId = this.getSelectedShell()?.id) {
     if (!shellId || !this.shellRuntime) return [];
-    const snapshot = this.shellRuntime.snapshotShell(shellId);
+    const snapshot = this.shellRuntime.snapshotShellScreen?.(shellId) ?? this.shellRuntime.snapshotShell(shellId);
     return formatAnsiLines(snapshot);
   }
 

package/src/cli/startup/runtime-close.mjs

@@ -0,0 +1,23 @@
+export async function closeMarchRuntime({ runner, memoryStore, ui, logger = null, blankLine = false }) {
+  let firstError = null;
+  try {
+    await runner.dispose();
+  } catch (err) {
+    firstError ??= err;
+  }
+  try {
+    memoryStore.close();
+  } catch (err) {
+    firstError ??= err;
+  }
+  try {
+    if (blankLine) ui.writeln("");
+    await ui.close();
+  } catch (err) {
+    firstError ??= err;
+  }
+  if (firstError) {
+    logger?.error("process.close.error", { error: firstError });
+    throw firstError;
+  }
+}

package/src/cli/tui/output/visible-lines.mjs

@@ -0,0 +1,8 @@
+export function sliceLinesWithTail(baseLines, tailLine, range) {
+  if (!range) return tailLine == null ? baseLines : [...baseLines, tailLine];
+
+  const { start, end } = range;
+  const visible = baseLines.slice(start, Math.min(end, baseLines.length));
+  if (tailLine != null && end > baseLines.length) visible.push(tailLine);
+  return visible;
+}