march-cli 0.1.9 → 0.1.11

package/src/cli/tui/output-buffer.mjs

@@ -4,6 +4,7 @@ import { renderMarkdown, renderStreamingMarkdown } from "./markdown-renderer.mjs
 import { renderEditDiffBlock } from "./tui-diff-rendering.mjs";
 import { OutputScrollState } from "./output/scroll-state.mjs";
 import { appendTextLines, wrapLine } from "./output/text-line-renderer.mjs";
+import { sliceLinesWithTail } from "./output/visible-lines.mjs";
 
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 
@@ -72,6 +73,7 @@ export class OutputBuffer {
     this.overlayStatus = null;
     this.scrollState = new OutputScrollState();
     this._segmentLinesCache = new Map();
+    this._baseLinesCache = new Map();
   }
 
   get scrollOffset() {
@@ -89,6 +91,7 @@ export class OutputBuffer {
     this.overlayStatus = null;
     this.scrollState.clear();
     this._segmentLinesCache = new Map();
+    this._baseLinesCache = new Map();
   }
 
   write(text) {
@@ -101,6 +104,7 @@ export class OutputBuffer {
 
   _writeText(text, markdown) {
     this.overlayStatus = null;
+    this._invalidateBaseLines();
     const current = this.currentText.at(-1);
     if (current.markdown !== markdown && current.text !== "") {
       this.currentText.push({ text: "", markdown });
@@ -114,6 +118,7 @@ export class OutputBuffer {
 
   writeln(text) {
     this.overlayStatus = null;
+    this._invalidateBaseLines();
     this.currentText[this.currentText.length - 1].text += text;
     this.currentText.push({ text: "", markdown: false });
   }
@@ -122,6 +127,7 @@ export class OutputBuffer {
     const current = this.currentText.at(-1);
     if (!current || current.text === "") return false;
     this.currentText.push({ text: "", markdown: false });
+    this._invalidateBaseLines();
     return true;
   }
 
@@ -141,12 +147,14 @@ export class OutputBuffer {
     if (lastIdx >= 0) this._activeThinking.content[lastIdx] += parts[0];
     else this._activeThinking.content.push(parts[0]);
     for (let i = 1; i < parts.length; i++) this._activeThinking.content.push(parts[i]);
+    this._invalidateBaseLines();
   }
 
   endThinking(tokens) {
     if (this._activeThinking) {
       this._activeThinking.tokens = tokens;
       this._activeThinking = null;
+      this._invalidateSegmentLines();
     }
   }
 
@@ -166,10 +174,12 @@ export class OutputBuffer {
 
   setOverlayStatus(lines) {
     this.overlayStatus = Array.isArray(lines) ? { type: "status", lines } : null;
+    this._invalidateBaseLines();
   }
 
   clearOverlayStatus() {
     this.overlayStatus = null;
+    this._invalidateBaseLines();
   }
 
   sealCurrentText() {
@@ -232,34 +242,33 @@ export class OutputBuffer {
 
   _invalidateSegmentLines() {
     this._segmentLinesCache.clear();
+    this._invalidateBaseLines();
+  }
+
+  _invalidateBaseLines() {
+    this._baseLinesCache.clear();
   }
 
   render(width) {
-    const allLines = this._computeLines(width);
-    this._cachedTotalLines = allLines.length;
-    this.scrollState.setTotalLines(allLines.length);
-    const range = this.scrollState.sliceRange();
-    if (!range) return allLines;
-    const { start, end } = range;
-    return allLines.slice(start, end);
+    const baseLines = this._renderBaseLines(width);
+    const tailLine = this.spinning ? this._spinnerLine() : null;
+    this.scrollState.setTotalLines(baseLines.length + (tailLine == null ? 0 : 1));
+    return sliceLinesWithTail(baseLines, tailLine, this.scrollState.sliceRange());
+  }
+
+  _spinnerLine() {
+    return brightBlack(`${SPINNER_FRAMES[this.spinnerIdx]} ${this.spinnerText}`);
   }
 
-  _computeLines(width) {
+  _renderBaseLines(width) {
+    const cached = this._baseLinesCache.get(width);
+    if (cached) return cached;
     const lines = [...this._renderCachedSegmentLines(width)];
     const dynamicStart = this._cachedSegmentPrefixCount();
-    for (const seg of this.segments.slice(dynamicStart)) {
-      for (const line of renderBlock(seg, width)) lines.push(line);
-    }
-    for (const block of currentTextToBlocks(this.currentText, false, this.currentTextCache)) {
-      for (const line of renderBlock(block, width)) lines.push(line);
-    }
-    if (this.overlayStatus) {
-      for (const line of renderBlock(this.overlayStatus, width)) lines.push(line);
-    }
-    if (this.spinning) {
-      const frame = SPINNER_FRAMES[this.spinnerIdx];
-      lines.push(brightBlack(`${frame} ${this.spinnerText}`));
-    }
+    for (const seg of this.segments.slice(dynamicStart)) for (const line of renderBlock(seg, width)) lines.push(line);
+    for (const block of currentTextToBlocks(this.currentText, false, this.currentTextCache)) for (const line of renderBlock(block, width)) lines.push(line);
+    if (this.overlayStatus) for (const line of renderBlock(this.overlayStatus, width)) lines.push(line);
+    this._baseLinesCache.set(width, lines);
     return lines;
   }
 

package/src/cli/tui/render/stream-delta-buffer.mjs

@@ -0,0 +1,46 @@
+export function createStreamDeltaBuffer({
+  writeText,
+  writeThinking,
+  renderSoon,
+  delayMs = 16,
+  setTimeoutImpl = setTimeout,
+  clearTimeoutImpl = clearTimeout,
+} = {}) {
+  const queued = [];
+  let timer = null;
+
+  function append(kind, delta) {
+    if (!delta) return;
+    const last = queued.at(-1);
+    if (last?.kind === kind) last.text += delta;
+    else queued.push({ kind, text: delta });
+    schedule();
+  }
+
+  function schedule() {
+    if (timer) return;
+    timer = setTimeoutImpl(() => flush(), delayMs);
+    timer.unref?.();
+  }
+
+  function flush({ notify = true } = {}) {
+    if (timer) {
+      clearTimeoutImpl(timer);
+      timer = null;
+    }
+    if (!queued.length) return false;
+    const batch = queued.splice(0);
+    for (const item of batch) {
+      if (item.kind === "thinking") writeThinking(item.text);
+      else writeText(item.text);
+    }
+    if (notify) renderSoon();
+    return true;
+  }
+
+  return {
+    text: (delta) => append("text", delta),
+    thinking: (delta) => append("thinking", delta),
+    flush,
+  };
+}

package/src/cli/tui/selection-screen.mjs

@@ -10,16 +10,19 @@ export class ScreenSelection {
     this.anchor = null;
     this.focus = null;
     this.lines = [];
+    this._plainLines = [];
     this.viewport = { topRow: 0, leftCol: 0, width: Infinity, height: 0 };
   }
 
   setLines(lines) {
-    this.lines = lines.map((line) => stripAnsi(line));
+    this.lines = [...lines];
+    this._plainLines = [];
     this.viewport = { topRow: 0, leftCol: 0, width: Infinity, height: this.lines.length };
   }
 
   setViewport({ topRow = 0, leftCol = 0, width = Infinity, lines = [] } = {}) {
-    this.lines = lines.map((line) => stripAnsi(line));
+    this.lines = lines;
+    this._plainLines = [];
     this.viewport = {
       topRow: Math.max(0, Math.trunc(topRow)),
       leftCol: Math.max(0, Math.trunc(leftCol)),
@@ -68,7 +71,7 @@ export class ScreenSelection {
     if (!range) return "";
     const selected = [];
     for (let row = range.start.row; row <= range.end.row; row += 1) {
-      const line = this.lines[row] ?? "";
+      const line = this._plainLine(row);
       const startCol = row === range.start.row ? range.start.col : 0;
       const endCol = row === range.end.row ? range.end.col : visibleWidth(line);
       selected.push(sliceColumns(line, startCol, endCol));
@@ -81,7 +84,7 @@ export class ScreenSelection {
     if (!range) return lines;
     return lines.map((line, row) => {
       if (row < range.start.row || row > range.end.row) return line;
-      const plain = stripAnsi(line);
+      const plain = this._plainLine(row);
       const startCol = row === range.start.row ? range.start.col : 0;
       const endCol = row === range.end.row ? range.end.col : visibleWidth(plain);
       if (endCol <= startCol) return line;
@@ -89,6 +92,11 @@ export class ScreenSelection {
     });
   }
 
+  _plainLine(row) {
+    if (this._plainLines[row] == null) this._plainLines[row] = stripAnsi(this.lines[row] ?? "");
+    return this._plainLines[row];
+  }
+
   range() {
     if (!this.anchor || !this.focus) return null;
     const [start, end] = comparePoints(this.anchor, this.focus) <= 0

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

@@ -55,7 +55,7 @@ export function formatToolStartLine(name, args = {}) {
   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 === "web_search") return joinToolParts("◆", name, [quoteCompact(args?.query ?? "")]);
+  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") {

package/src/cli/ui.mjs

@@ -24,6 +24,7 @@ import { writeMemoryHint } 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";
+import { createStreamDeltaBuffer } from "./tui/render/stream-delta-buffer.mjs";
 import { writeTranscriptToOutput } from "../session/transcript.mjs";
 
 export { buildMarchCommands, MarchAutocompleteProvider } from "./input/autocomplete.mjs";
@@ -61,8 +62,9 @@ export function createTuiUI({
   let toolsExpanded = false;
   const activeToolBlocks = [];
   const renderScheduler = createRenderScheduler({ requestRender: () => tui.requestRender() });
-  const requestRender = renderScheduler.renderNow;
-
+  const streamDeltas = createStreamDeltaBuffer({ writeText: (delta) => output.writeMarkdown(delta), writeThinking: (delta) => output.appendThinking(delta), renderSoon: renderScheduler.renderSoon });
+  const flushStreamDeltas = () => streamDeltas.flush({ notify: false });
+  const requestRender = () => { flushStreamDeltas(); renderScheduler.renderNow(); };
   const spinnerStatus = createSpinnerStatusController({ output, requestRender });
   const retryStatus = createRetryStatusController({ output, requestRender, stopSpinner: spinnerStatus.stop });
   const shellDrawerControls = createShellDrawerControls({ shellDrawer, output, requestRender });
@@ -169,12 +171,10 @@ export function createTuiUI({
       retryStatus.stop(); output.startThinking(); requestRender();
     },
 
-    thinkingDelta: (delta) => {
-      output.appendThinking(delta);
-      renderScheduler.renderSoon();
-    },
+    thinkingDelta: (delta) => streamDeltas.thinking(delta),
 
     thinkingEnd: (tokens) => {
+      flushStreamDeltas();
       output.endThinking(tokens);
       requestRender();
     },
@@ -186,7 +186,7 @@ export function createTuiUI({
     toggleLastThinking: () => false,
 
     toolStart: (name, args) => {
-      ensureStarted(); retryStatus.stop(); spinnerStatus.stop(); activeToolBlocks.push(writeToolStart({ output, name, args })); requestRender();
+      ensureStarted(); flushStreamDeltas(); retryStatus.stop(); spinnerStatus.stop(); activeToolBlocks.push(writeToolStart({ output, name, args })); requestRender();
     },
 
     toolEnd: (name, isError, result) => {
@@ -194,30 +194,26 @@ export function createTuiUI({
     },
 
     textDelta: (delta) => {
-      ensureStarted(); retryStatus.stop(); spinnerStatus.stop();
-      output.writeMarkdown(delta);
-      renderScheduler.renderSoon();
+      ensureStarted(); retryStatus.stop(); spinnerStatus.stop(); streamDeltas.text(delta);
     },
     assistantReplyEnd: () => {
       ensureStarted();
+      flushStreamDeltas();
       const changed = output.ensureNewline();
       if (output.sealCurrentText() || changed) requestRender();
     },
     status: (text) => {
-      ensureStarted(); retryStatus.stop(); spinnerStatus.stop(); output.setOverlayStatus([brightBlack(`● ${text}`)]); requestRender();
+      ensureStarted(); flushStreamDeltas(); retryStatus.stop(); spinnerStatus.stop(); output.setOverlayStatus([brightBlack(`● ${text}`)]); requestRender();
     },
     memoryHint: ({ hints }) => {
-      ensureStarted(); retryStatus.stop(); spinnerStatus.stop(); output.ensureNewline(); writeMemoryHint({ output, hints }); requestRender();
+      ensureStarted(); flushStreamDeltas(); retryStatus.stop(); spinnerStatus.stop(); output.ensureNewline(); writeMemoryHint({ output, hints }); requestRender();
     },
 
     clearOutput: () => {
-      ensureStarted(); spinnerStatus.stop(); retryStatus.stop(); output.clear(); requestRender();
+      ensureStarted(); flushStreamDeltas(); spinnerStatus.stop(); retryStatus.stop(); output.clear(); requestRender();
     },
-
     restoreTranscript: (turns) => {
-      ensureStarted(); spinnerStatus.stop(); retryStatus.stop(); output.clear();
-      writeTranscriptToOutput(output, turns);
-      requestRender();
+      ensureStarted(); flushStreamDeltas(); spinnerStatus.stop(); retryStatus.stop(); output.clear(); writeTranscriptToOutput(output, turns); requestRender();
     },
 
     setStatusBar: (text) => {
@@ -229,6 +225,7 @@ export function createTuiUI({
     },
 
     turnEnd: () => {
+      flushStreamDeltas();
       const changed = output.ensureNewline();
       if (output.sealCurrentText() || changed) requestRender();
     },
@@ -238,6 +235,7 @@ export function createTuiUI({
 
     editDiff: (path, diffLines) => {
       ensureStarted();
+      flushStreamDeltas();
       spinnerStatus.stop();
       writeEditDiff({ output, path, diffLines });
       requestRender();
@@ -278,6 +276,7 @@ export function createTuiUI({
     toggleShellDrawer: () => shellDrawerControls.toggle(),
     requestExit: () => inputController.requestExit(),
     close: async () => {
+      flushStreamDeltas();
       renderScheduler.clearPending();
       spinnerStatus.stop();
       retryStatus.stop();

package/src/config/loader.mjs

@@ -46,13 +46,20 @@ function mergeLayers(layers) {
     serviceTier: null,
     providers: {},
     webSearch: { provider: null, providers: {} },
+    hostedTools: {
+      openai: { webSearch: "auto" },
+      openaiCodex: { webSearch: "auto" },
+      azureOpenai: { webSearch: "auto" },
+      anthropic: { webSearch: "auto" },
+      google: { webSearch: "auto" },
+      xai: { webSearch: "auto", xSearch: "auto" },
+    },
     network: { proxy: "system", ca: "system" },
     maxTurns: null,
     trimBatch: null,
     memoryRoot: null,
     notifications: { turnEnd: true, desktop: true, bell: false, command: null, minDurationMs: 0, sound: true },
   };
-
   for (const layer of layers) {
     if (!layer) continue;
     if (layer.model != null) result.model = layer.model;
@@ -64,6 +71,9 @@ function mergeLayers(layers) {
     if (layer.webSearch && typeof layer.webSearch === "object" && !Array.isArray(layer.webSearch)) {
       result.webSearch = mergeWebSearch(result.webSearch, layer.webSearch);
     }
+    if (layer.hostedTools && typeof layer.hostedTools === "object" && !Array.isArray(layer.hostedTools)) {
+      result.hostedTools = mergeHostedTools(result.hostedTools, layer.hostedTools);
+    }
     if (layer.notifications && typeof layer.notifications === "object" && !Array.isArray(layer.notifications)) {
       result.notifications = {
         ...result.notifications,
@@ -99,6 +109,23 @@ function mergeWebSearch(current, next) {
   return merged;
 }
 
+function mergeHostedTools(current, next) {
+  const merged = {
+    openai: { ...(current.openai ?? {}) },
+    openaiCodex: { ...(current.openaiCodex ?? {}) },
+    azureOpenai: { ...(current.azureOpenai ?? {}) },
+    anthropic: { ...(current.anthropic ?? {}) },
+    google: { ...(current.google ?? {}) },
+    xai: { ...(current.xai ?? {}) },
+  };
+  for (const provider of ["openai", "openaiCodex", "azureOpenai", "anthropic", "google", "xai"]) {
+    if (next[provider] && typeof next[provider] === "object" && !Array.isArray(next[provider])) {
+      merged[provider] = { ...merged[provider], ...next[provider] };
+    }
+  }
+  return merged;
+}
+
 function mergeProviders(current, next) {
   const merged = { ...current };
   for (const [id, profile] of Object.entries(next)) {

package/src/context/system-core/base.md

@@ -58,7 +58,7 @@ The user primarily asks for software engineering work: fixing bugs, adding behav
 - To edit an existing memory, use memory_open(id) to get its path, then edit_file with mode="patch" for targeted edits.
 - Use memory_save() to create memories or update whole fields. Before creating a new memory, first search/open related memories and merge updates into an existing memory when they share the same topic, project, or decision thread; prefer modifying the existing memory file over creating a scattered new one. Tags are the primary retrieval key for future recall. Prefer lowercase kebab-case tags like 'march-cli', 'tooling', 'permissions'.
 - When learning multiple related external workflows or skills, maintain memory as an evolving domain library: start with the specific source name when only one item exists, then rename and rewrite the memory title/description as the scope grows; merge new related learnings into the same memory, preserving each source's unique traits while distilling reusable principles.
-- Distinguish "migrating a Skill to memory" from "learning a Skill": migration preserves the complete Skill folder under memory_root/skills/ and creates a memory index with purpose, source, entry files, and local path; learning only reads and internalizes the Skill's methods, scenarios, and principles into ordinary memory without copying source files. Infer the action from the user's wording, and ask when ambiguous.
+- Distinguish "migrating a Skill to memory" from "learning a Skill": migration preserves the complete Skill folder under memory_root/skills/ and creates a memory entry as its index; that memory should describe what the Skill is for and reference the copied Skill folder path so future recall knows how to use it. Learning only reads and internalizes the Skill's methods, scenarios, and principles into ordinary memory without copying source files. Infer the action from the user's wording, and ask when ambiguous.
 - Unlike memory hints, this system-core center is always visible in every model call. Only update the center for instructions that must always be followed; use memory for contextual, project-specific, or recall-dependent knowledge.
 - If execution takes a meaningful detour, create or update a memory after the task. A detour means the initial plan or assumption failed, multiple approaches were tried, and the final successful path contains reusable project knowledge. Record the failed assumption, what was tried, and the successful approach. Prefer updating an existing related memory over creating a new one.
 </memory_system>

package/src/debug/logger.mjs

@@ -0,0 +1,141 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const LEVELS = Object.freeze({ debug: 10, info: 20, warn: 30, error: 40, silent: 99 });
+const REDACTED = "[redacted]";
+const MAX_STRING_LENGTH = 2000;
+const MAX_ARRAY_LENGTH = 50;
+const MAX_OBJECT_KEYS = 80;
+const SENSITIVE_KEY = /(api[-_]?key|authorization|auth|token|secret|password|cookie|credential|b64|base64|image)/i;
+
+export function createLogger({
+  enabled = process.env.MARCH_LOG !== "0",
+  level = process.env.MARCH_LOG_LEVEL ?? "info",
+  logDir = defaultLogDir(),
+  now = () => new Date(),
+  pid = process.pid,
+} = {}) {
+  const threshold = normalizeLevel(level);
+  const path = join(logDir, `${dateStamp(now())}-march-${pid}.jsonl`);
+  const base = { enabled: Boolean(enabled), level: levelName(threshold), path };
+
+  function write(levelNameValue, event, fields = {}) {
+    if (!base.enabled || normalizeLevel(levelNameValue) < threshold) return;
+    const entry = {
+      ts: now().toISOString(),
+      level: levelNameValue,
+      event,
+      pid,
+      ...sanitize(fields),
+    };
+    try {
+      mkdirSync(logDir, { recursive: true });
+      appendFileSync(path, `${JSON.stringify(entry)}\n`, "utf8");
+    } catch {
+      // Logging must never change CLI behavior.
+    }
+  }
+
+  const logger = {
+    ...base,
+    event: (event, fields) => write("info", event, fields),
+    debug: (event, fields) => write("debug", event, fields),
+    warn: (event, fields) => write("warn", event, fields),
+    error: (event, fields) => write("error", event, fields),
+    child(extraFields = {}) {
+      return createChildLogger(logger, sanitize(extraFields));
+    },
+  };
+  return logger;
+}
+
+export function createHeartbeat({ logger, event = "heartbeat", intervalMs = 10_000, getFields = () => ({}) } = {}) {
+  if (!logger?.enabled || intervalMs <= 0) return { stop() {} };
+  const timer = setInterval(() => logger.event(event, getFields()), intervalMs);
+  timer.unref?.();
+  return {
+    stop() { clearInterval(timer); },
+  };
+}
+
+export function installProcessLogHandlers(logger) {
+  if (!logger?.enabled) return;
+  process.once("uncaughtException", (err) => {
+    logger.error("process.uncaughtException", { error: formatError(err) });
+  });
+  process.once("unhandledRejection", (reason) => {
+    logger.error("process.unhandledRejection", { error: formatError(reason) });
+  });
+}
+
+export function formatError(err) {
+  if (err instanceof Error) {
+    return {
+      name: err.name,
+      message: err.message,
+      stack: err.stack,
+    };
+  }
+  return { message: String(err) };
+}
+
+export function sanitize(value, seen = new WeakSet(), key = "") {
+  if (SENSITIVE_KEY.test(key)) return REDACTED;
+  if (value == null || typeof value === "number" || typeof value === "boolean") return value;
+  if (typeof value === "string") return truncateString(value);
+  if (typeof value === "bigint") return String(value);
+  if (typeof value === "function" || typeof value === "symbol") return `[${typeof value}]`;
+  if (value instanceof Error) return sanitize(formatError(value), seen);
+  if (typeof value !== "object") return String(value);
+  if (seen.has(value)) return "[circular]";
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const items = value.slice(0, MAX_ARRAY_LENGTH).map((item) => sanitize(item, seen));
+    if (value.length > MAX_ARRAY_LENGTH) items.push(`[${value.length - MAX_ARRAY_LENGTH} more items]`);
+    return items;
+  }
+  const entries = Object.entries(value).slice(0, MAX_OBJECT_KEYS);
+  const out = {};
+  for (const [entryKey, entryValue] of entries) out[entryKey] = sanitize(entryValue, seen, entryKey);
+  const omitted = Object.keys(value).length - entries.length;
+  if (omitted > 0) out.__omittedKeys = omitted;
+  return out;
+}
+
+function createChildLogger(parent, extraFields) {
+  function withFields(fields) {
+    return { ...extraFields, ...(fields ?? {}) };
+  }
+  return {
+    enabled: parent.enabled,
+    level: parent.level,
+    path: parent.path,
+    event: (event, fields) => parent.event(event, withFields(fields)),
+    debug: (event, fields) => parent.debug(event, withFields(fields)),
+    warn: (event, fields) => parent.warn(event, withFields(fields)),
+    error: (event, fields) => parent.error(event, withFields(fields)),
+    child: (fields = {}) => createChildLogger(parent, withFields(sanitize(fields))),
+  };
+}
+
+function defaultLogDir() {
+  return join(homedir(), ".march", "logs");
+}
+
+function dateStamp(now) {
+  return now.toISOString().slice(0, 10);
+}
+
+function truncateString(value) {
+  if (value.length <= MAX_STRING_LENGTH) return value;
+  return `${value.slice(0, MAX_STRING_LENGTH)}...[truncated ${value.length - MAX_STRING_LENGTH} chars]`;
+}
+
+function normalizeLevel(level) {
+  return LEVELS[String(level).toLowerCase()] ?? LEVELS.info;
+}
+
+function levelName(value) {
+  return Object.entries(LEVELS).find(([, level]) => level === value)?.[0] ?? "info";
+}

package/src/lsp/client.mjs

@@ -1,5 +1,5 @@
-import { spawn } from "node:child_process";
 import { pathToFileURL } from "node:url";
+import { spawnCommand } from "../platform/spawn-command.mjs";
 import { extname } from "node:path";
 import { readFileSync } from "node:fs";
 
@@ -36,7 +36,7 @@ export class LspClient {
   }
 
   async start() {
-    this.process = spawn(this.command, this.args, {
+    this.process = spawnCommand(this.command, this.args, {
       cwd: this.cwd,
       env: process.env,
       stdio: ["pipe", "pipe", "pipe"],

package/src/lsp/diagnostic-store.mjs

@@ -1,4 +1,5 @@
 import { fileURLToPath } from "node:url";
+import { lspPathKey } from "./path-match.mjs";
 
 export class LspDiagnosticStore {
   constructor() {
@@ -13,7 +14,7 @@ export class LspDiagnosticStore {
       serverId,
       path,
     }));
-    this.byPath.set(path, {
+    this.byPath.set(lspPathKey(path), {
       path,
       updatedAt: Date.now(),
       diagnostics: normalized,
@@ -22,10 +23,12 @@ export class LspDiagnosticStore {
 
   snapshot() {
     const diagnostics = [];
+    const files = [];
     for (const entry of this.byPath.values()) {
       diagnostics.push(...entry.diagnostics);
+      files.push({ path: entry.path, updatedAt: entry.updatedAt, diagnostics: entry.diagnostics.length });
     }
-    return diagnostics;
+    return { diagnostics, files };
   }
 }
 

package/src/lsp/diagnostics-format.mjs

@@ -1,3 +1,5 @@
+import { sameLspPath } from "./path-match.mjs";
+
 const MAX_DIAGNOSTICS = 20;
 
 export function formatLspDiagnostics({ snapshot } = {}) {
@@ -20,7 +22,7 @@ export function formatLspDiagnostics({ snapshot } = {}) {
 export function formatLspDiagnosticsForPath({ snapshot, path } = {}) {
   const targetPath = String(path ?? "");
   if (!targetPath) return "";
-  const diagnostics = (snapshot?.diagnostics ?? []).filter((diagnostic) => diagnostic.path === targetPath);
+  const diagnostics = (snapshot?.diagnostics ?? []).filter((diagnostic) => sameLspPath(diagnostic.path, targetPath));
   if (diagnostics.length === 0) return "";
   return formatLspDiagnostics({
     snapshot: {