march-cli 0.1.36 → 0.1.38

package/src/cli/workspace/command.mjs

@@ -0,0 +1,147 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { brightBlack } from "../tui/ui-theme.mjs";
+import { registerProject, listRegisteredProjects } from "../../workspace/project-registry.mjs";
+import { buildWorkspaceSessionSelectItems, listWorkspaceSessions, workspaceSessionSearchText } from "../../workspace/session-index.mjs";
+import { resumePiSessionById } from "../session/pi-session-switch-command.mjs";
+import { loadPiSessionTranscriptTurns } from "../../session/transcript.mjs";
+
+export const WORKSPACE_SLASH_COMMANDS = [
+  {
+    metadata: [
+      { name: "project", description: "List registered projects" },
+      { name: "project add", helpSyntax: "project add <path>", description: "Register a project root" },
+    ],
+    match: (trimmed) => {
+      const parsed = parseProjectCommand(trimmed);
+      return parsed.type === "none" ? null : { parsed };
+    },
+    run: async (ctx, command) => writeLines(ctx.ui, await handleProjectCommand(command, ctx)),
+  },
+  {
+    metadata: [{ name: "switch", description: "Open cross-project session switcher" }],
+    match: (trimmed) => trimmed === "/switch" ? { parsed: { type: "switch" } } : null,
+    run: handleSwitchCommand,
+  },
+];
+
+export function parseProjectCommand(trimmed) {
+  if (trimmed === "/project" || trimmed === "/project list") return { type: "list" };
+  if (trimmed.startsWith("/project add ")) return { type: "add", path: trimmed.slice("/project add ".length).trim() };
+  return { type: "none" };
+}
+
+export async function handleProjectCommand(command, { stateRoot }) {
+  if (!stateRoot) return ["Error: workspace registry is not available."];
+  if (command.type === "add") {
+    const rootPath = resolve(command.path);
+    if (!existsSync(rootPath)) return [`Error: project path does not exist: ${rootPath}`];
+    const project = registerProject({ stateRoot, rootPath });
+    return [`Registered project: ${project.displayName}`, brightBlack(project.rootPath)];
+  }
+
+  const projects = listRegisteredProjects({ stateRoot });
+  if (projects.length === 0) return ["No registered projects."];
+  return ["Registered projects:", ...projects.map((project) => `- ${project.displayName}  ${brightBlack(project.rootPath)}`)];
+}
+
+export async function handleSwitchCommand({ stateRoot, currentProjectId, projectMarchDir, runner, workspaceSupervisor, workspaceOutputRouter, ui }) {
+  if (!stateRoot) {
+    ui.writeln("Session switcher is not available: workspace registry is missing.");
+    return { handled: true };
+  }
+  const projects = await listWorkspaceSessions({ stateRoot, currentProjectId });
+  const currentSessionId = runner.getSessionStats?.().sessionId ?? null;
+  const runtimeSummaries = workspaceSupervisor?.getRuntimeSummaries?.() ?? [];
+  const items = annotateWorkspaceItems(buildWorkspaceSessionSelectItems(projects, currentSessionId), runtimeSummaries);
+  if (items.length === 0) {
+    ui.writeln("No registered projects. Start March in a project or run /project add <path>.");
+    return { handled: true };
+  }
+  if (!ui.selectList) {
+    ui.writeln("Session switcher is only available in TUI.");
+    return { handled: true };
+  }
+  const selectedIndex = Math.max(0, items.findIndex((item) => item.project.current && item.session?.id === currentSessionId));
+  const item = await ui.selectList({
+    items,
+    selectedIndex,
+    width: 90,
+    suppressInitialConfirm: true,
+    searchable: true,
+    getSearchText: workspaceSessionSearchText,
+  });
+  if (!item) {
+    ui.writeln("Session unchanged.");
+    return { handled: true };
+  }
+  if (!item.session) {
+    if (!workspaceSupervisor?.startNewWorkspaceSession) {
+      ui.writeln("New session creation requires the workspace supervisor.");
+      return { handled: true };
+    }
+    try {
+      const { result } = await workspaceSupervisor.startNewWorkspaceSession(item.project);
+      ui.restoreTranscript?.([]);
+      ui.writeln(`Created session: ${item.project.displayName} / ${result?.sessionId ?? "new session"}`);
+      return { handled: true, refreshContextTokens: true, activeChanged: true };
+    } catch (err) {
+      ui.writeln(`Error: ${err.message}`);
+      return { handled: true };
+    }
+  }
+  if (workspaceSupervisor) {
+    try {
+      await workspaceSupervisor.activateWorkspaceSession({ project: item.project, session: item.session });
+      restoreTranscriptFromSession(item.session, ui);
+      const replayed = ctxReplayBufferedOutput({ workspaceOutputRouter, projectId: item.project.projectId, sessionId: item.session.id });
+      ui.writeln(`Switched to session: ${item.project.displayName} / ${item.session.name || item.session.id}${replayed ? ` (${replayed} buffered events replayed)` : ""}`);
+      return { handled: true, refreshContextTokens: true, activeChanged: true };
+    } catch (err) {
+      ui.writeln(`Error: ${err.message}`);
+      return { handled: true };
+    }
+  }
+  if (!item.project.current) {
+    ui.writeln(`Project switch target indexed: ${item.project.displayName}`);
+    ui.writeln(brightBlack("Cross-project attach requires the workspace supervisor."));
+    return { handled: true };
+  }
+  const sessions = projects.find((project) => project.current)?.sessions ?? [];
+  const lines = await resumePiSessionById(item.session.id, { runner, sessions, projectMarchDir });
+  if (isResumeSuccess(lines)) restoreTranscriptFromSession(item.session, ui);
+  for (const line of lines) ui.writeln(line);
+  return { handled: true, refreshContextTokens: isResumeSuccess(lines) };
+}
+
+function annotateWorkspaceItems(items, runtimeSummaries) {
+  if (!runtimeSummaries.length) return items;
+  const running = new Set(runtimeSummaries.filter((runtime) => runtime.running).map((runtime) => `${runtime.projectId}:${runtime.sessionId}`));
+  return items.map((item) => {
+    if (!item.session) return item;
+    if (!running.has(`${item.project.projectId}:${item.session.id}`)) return item;
+    return { ...item, description: `running · ${item.description}` };
+  });
+}
+
+function ctxReplayBufferedOutput({ workspaceOutputRouter, projectId, sessionId }) {
+  return workspaceOutputRouter?.replayBufferedCalls?.(projectId, sessionId) ?? 0;
+}
+
+function restoreTranscriptFromSession(session, ui) {
+  if (typeof ui.restoreTranscript !== "function") return;
+  try {
+    ui.restoreTranscript(loadPiSessionTranscriptTurns(session.path));
+  } catch (err) {
+    ui.writeln(`Warning: failed to restore session transcript: ${err.message}`);
+  }
+}
+
+function writeLines(ui, lines) {
+  for (const line of lines) ui.writeln(line);
+  return { handled: true };
+}
+
+function isResumeSuccess(lines) {
+  return Array.isArray(lines) && lines.some((line) => String(line).startsWith("Resumed pi session:"));
+}

package/src/cli/workspace/output-router.mjs

@@ -0,0 +1,108 @@
+const BACKGROUND_METHODS_TO_BUFFER = new Set([
+  "turnStart",
+  "turnEnd",
+  "assistantReplyEnd",
+  "textDelta",
+  "thinkingStart",
+  "thinkingDelta",
+  "thinkingEnd",
+  "toolStart",
+  "toolEnd",
+  "retryStart",
+  "retryEnd",
+  "status",
+  "debugLines",
+  "recall",
+  "providerQuotaSnapshot",
+  "editDiff",
+  "writeln",
+]);
+
+export function createWorkspaceOutputRouter({ ui, activeProjectId, activeSessionId = null }) {
+  let active = routeKey(activeProjectId, activeSessionId);
+  const buffers = new Map();
+
+  return {
+    setActiveProject(projectId) {
+      active = routeKey(projectId, null);
+    },
+    setActiveSession(projectId, sessionId) {
+      active = routeKey(projectId, sessionId);
+    },
+    getActiveRouteKey() {
+      return active;
+    },
+    getActiveProject() {
+      return parseRouteKey(active).projectId;
+    },
+    createProjectUi(projectId, getSessionId = null) {
+      return this.createSessionUi({ projectId, getSessionId });
+    },
+    createSessionUi({ projectId, sessionId = null, getSessionId = null }) {
+      return new Proxy({}, {
+        get(_target, prop) {
+          if (prop === "__projectId") return projectId;
+          const value = ui[prop];
+          if (typeof value !== "function") return value;
+          return (...args) => {
+            const key = routeKey(projectId, typeof getSessionId === "function" ? getSessionId() : sessionId);
+            if (isActiveRoute(key) || !BACKGROUND_METHODS_TO_BUFFER.has(prop)) return value.apply(ui, args);
+            bufferBackgroundCall(key, prop, args);
+            return undefined;
+          };
+        },
+        set(_target, prop, value) {
+          ui[prop] = value;
+          return true;
+        },
+        has(_target, prop) {
+          return prop in ui;
+        },
+      });
+    },
+    getBufferedCalls(projectId, sessionId = null) {
+      return [...(buffers.get(routeKey(projectId, sessionId)) ?? [])];
+    },
+    getBufferedCallCount(projectId, sessionId = null) {
+      return buffers.get(routeKey(projectId, sessionId))?.length ?? 0;
+    },
+    replayBufferedCalls(projectId, sessionId = null) {
+      const key = routeKey(projectId, sessionId);
+      const calls = buffers.get(key) ?? [];
+      buffers.delete(key);
+      for (const call of calls) replayBufferedCall(call);
+      return calls.length;
+    },
+    clearBufferedCalls(projectId, sessionId = null) {
+      buffers.delete(routeKey(projectId, sessionId));
+    },
+  };
+
+  function isActiveRoute(key) {
+    if (key === active) return true;
+    const current = parseRouteKey(active);
+    const candidate = parseRouteKey(key);
+    return current.sessionId == null && current.projectId === candidate.projectId;
+  }
+
+  function replayBufferedCall({ method, args }) {
+    const value = ui[method];
+    if (typeof value === "function") value.apply(ui, args);
+  }
+
+  function bufferBackgroundCall(key, method, args) {
+    const calls = buffers.get(key) ?? [];
+    calls.push({ method, args, at: Date.now() });
+    if (calls.length > 2000) calls.splice(0, calls.length - 2000);
+    buffers.set(key, calls);
+  }
+}
+
+export function routeKey(projectId, sessionId = null) {
+  return `${projectId ?? ""}:${sessionId ?? ""}`;
+}
+
+function parseRouteKey(key) {
+  const [projectId, sessionId = ""] = String(key ?? "").split(":", 2);
+  return { projectId: projectId || null, sessionId: sessionId || null };
+}

package/src/cli/workspace/project-runtime.mjs

@@ -0,0 +1,92 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { createRuntimeRunner } from "../startup/create-runtime-runner.mjs";
+import { createCliShellRuntime } from "../../shell/cli-runtime.mjs";
+import { createMarchAuthStorage } from "../../auth/storage.mjs";
+import { discoverProjectExtensionPaths } from "../../extensions/discovery.mjs";
+import { loadProjectLifecycleHookManifests } from "../../extensions/lifecycle-manifest.mjs";
+import { loadKeybindings } from "../input/keybindings.mjs";
+import { loadPromptTemplates } from "../input/prompt-templates.mjs";
+import { loadOrCreateProjectId } from "../../workspace/project-id.mjs";
+
+export async function createWorkspaceProjectRuntime({
+  project,
+  args,
+  config,
+  stateRoot,
+  memoryRoot,
+  profilePaths,
+  createMemoryStore,
+  provider,
+  serviceTier,
+  model,
+  remoteMemorySources,
+  createUi,
+  refreshStatusBar,
+  onNotificationActivation = null,
+}) {
+  const cwd = project.rootPath;
+  const projectMarchDir = resolve(cwd, ".march");
+  if (!existsSync(projectMarchDir)) mkdirSync(projectMarchDir, { recursive: true });
+
+  const authConfig = createMarchAuthStorage({ provider: provider ?? "deepseek", providers: config.providers, cwd });
+  if (!authConfig.hasAuth) throw new Error(`no providers configured for project: ${cwd}`);
+
+  const namespace = loadOrCreateProjectId(projectMarchDir);
+  const extensionPaths = [
+    ...discoverProjectExtensionPaths(cwd),
+    ...args.extensions.map((extensionPath) => resolve(cwd, extensionPath)),
+  ];
+  const lifecycleManifests = loadProjectLifecycleHookManifests(cwd);
+  const keybindingConfig = loadKeybindings(cwd);
+  const promptTemplateConfig = loadPromptTemplates(cwd);
+  const projectShellRuntime = args.shellRuntime ? createCliShellRuntime({ cwd }) : null;
+  const sessionsRoot = join(projectMarchDir, "sessions");
+  const sessionState = { sessionId: Date.now().toString(36), sessionDir: null };
+  sessionState.sessionDir = join(sessionsRoot, sessionState.sessionId);
+  const contextDumpRoot = resolve(projectMarchDir, "context-dumps", sessionState.sessionId);
+  const memoryStore = createMemoryStore();
+  const ui = createUi(sessionState);
+  const runner = await createRuntimeRunner({
+    runnerOptions: {
+      cwd,
+      modelId: model,
+      provider,
+      serviceTier,
+      providers: config.providers,
+      config,
+      stateRoot,
+      memoryRoot,
+      profilePaths,
+      namespace,
+      projectMarchDir,
+      extensionPaths,
+      shellRuntime: Boolean(projectShellRuntime),
+      lifecycleHooks: lifecycleManifests.hooks,
+      lifecycleDiagnostics: lifecycleManifests.diagnostics,
+      modelContextDumper: { enabled: args.dumpContext, rootDir: contextDumpRoot },
+      remoteMemorySources,
+      notificationContext: { projectId: project.projectId },
+    },
+    ui,
+    shellRuntime: projectShellRuntime,
+    refreshStatusBar,
+    onNotificationActivation,
+  });
+
+  return {
+    project,
+    cwd,
+    currentProject: basename(cwd),
+    runner,
+    ui,
+    memoryStore,
+    sessionState,
+    sessionsRoot,
+    projectMarchDir,
+    extensionPaths,
+    keybindingConfig,
+    promptTemplateConfig,
+    contextDumpRoot,
+  };
+}

package/src/config/features.mjs

@@ -7,7 +7,6 @@ const DEFAULTS = Object.freeze({
   "experimental.web_search": true,
   "experimental.web_fetch": true,
   "experimental.shell": true,
-  "experimental.permissions": true,
   "ui.markdown_rendering": false,
   "ui.tool_expand_per_card": false,
   "agent.plan_mode": false,

package/src/context/engine.mjs

@@ -71,18 +71,20 @@ export class ContextEngine {
   }
 
   recordTurn({ userMessage, assistantMessage, assistantContext = "", userRecallHints = [], assistantRecallHints = [] }) {
-    this.turns.push({
+    const turn = {
       index: this.turns.length + 1,
       userMessage,
       assistantMessage: assistantMessage ?? "",
       assistantContext: assistantContext ?? "",
       userRecallHints,
       assistantRecallHints,
-    });
+    };
+    this.turns.push(turn);
     if (this.turns.length > this.maxTurns) {
       const keep = Math.max(1, this.maxTurns - this.trimBatch);
       this.turns = this.turns.slice(-keep);
     }
+    return turn;
   }
 
   getRecentRecallMemoryIds() {

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

@@ -69,7 +69,10 @@ The user primarily asks for software engineering work: fixing bugs, adding behav
 
 <editing_contract>
 - Use read(path) for file inspection with 1-based line numbers.
-- Use grep(pattern), find(pattern), and ls(path) to explore the project before editing.
+- Use code_search first when locating unknown implementations, responsibility boundaries, cross-module flows, or concept-level behavior.
+- Use grep(pattern) and find(pattern) for exact symbol, string, filename, or call-site confirmation.
+- Use ls(path) to inspect directory shape when structure matters.
+- Treat code_search as a semantic map, not proof; verify important results with grep/read before editing or concluding.
 - Prefer dedicated read/search/edit tools over shell commands for file inspection and modification.
 - Use command_exec for one-shot commands. Use terminal_* only for interactive programs, long-running processes, or when preserving terminal state matters.
 - Keep the working directory stable; use paths instead of cd unless the user asks otherwise.

package/src/extensions/lifecycle-adapter.mjs

@@ -109,7 +109,7 @@ export function createMarchLifecycleAdapter({
             type: "info",
             message: hooks.size === 0
               ? "March lifecycle hook adapter is read-only; no March hooks are registered."
-              : "March lifecycle hook adapter is read-only; registered hooks are permission-gated.",
+              : "March lifecycle hook adapter is read-only; registered hooks are policy-gated.",
           },
           ...adapterDiagnostics,
           ...getRuntimeDiagnostics(),

package/src/history/runner.mjs

@@ -0,0 +1,11 @@
+import { join } from "node:path";
+import { HistoryStore } from "./store.mjs";
+
+export function createRunnerHistoryStore({ stateRoot, cwd } = {}) {
+  if (!stateRoot) return null;
+  return new HistoryStore({ root: join(stateRoot, "history"), cwd });
+}
+
+export function appendRunnerTurnHistory({ store, turn, sessionStats, modelId, provider }) {
+  return store?.appendTurn({ turn, sessionStats, runtime: { modelId, provider } });
+}

package/src/history/store.mjs

@@ -0,0 +1,129 @@
+import { appendFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { basename, join } from "node:path";
+import { searchMarkdownRoot } from "../memory/search.mjs";
+
+const DEFAULT_HISTORY_LIMIT = 20;
+const MAX_HISTORY_LIMIT = 50;
+
+export class HistoryStore {
+  constructor({ root, cwd, now = () => new Date() } = {}) {
+    if (!root) throw new Error("history root is required");
+    this.root = root;
+    this.cwd = cwd;
+    this.now = now;
+  }
+
+  appendTurn({ turn, sessionStats = {}, runtime = {} } = {}) {
+    if (!turn) return null;
+    const sessionId = sanitizeId(sessionStats.sessionId ?? sessionStats.sessionFile ?? "session");
+    const filePath = join(this.#projectDir(), `${sessionId}.md`);
+    mkdirSync(this.#projectDir(), { recursive: true });
+    if (!existsSync(filePath)) writeFileSync(filePath, this.#fileHeader({ sessionId, sessionStats }), "utf8");
+    appendFileSync(filePath, this.#formatTurn({ turn, sessionId, sessionStats, runtime }), "utf8");
+    return filePath;
+  }
+
+  searchRipgrep(query, { allProjects = false, sessionId = null, limit = DEFAULT_HISTORY_LIMIT, context = 2, syntax = "regex", case: caseMode = "smart" } = {}) {
+    const root = allProjects ? this.root : this.#projectDir();
+    const glob = sessionId ? [`**/${sanitizeId(sessionId)}.md`] : [];
+    return searchMarkdownRoot({
+      root,
+      query,
+      limit: clampInt(limit, 1, MAX_HISTORY_LIMIT, DEFAULT_HISTORY_LIMIT),
+      context,
+      syntax,
+      caseMode,
+      glob,
+    });
+  }
+
+  #projectDir() {
+    return join(this.root, "projects", cwdHash(this.cwd));
+  }
+
+  #fileHeader({ sessionId, sessionStats }) {
+    return [
+      `# March History · ${sessionId}`,
+      "",
+      `- cwd: ${this.cwd}`,
+      `- project: ${basename(this.cwd) || this.cwd}`,
+      sessionStats.sessionFile ? `- session_file: ${sessionStats.sessionFile}` : null,
+      "",
+    ].filter(Boolean).join("\n");
+  }
+
+  #formatTurn({ turn, sessionId, sessionStats, runtime }) {
+    const now = this.now().toISOString();
+    return [
+      `\n## Turn ${turn.index ?? "?"} · ${now}`,
+      "",
+      "metadata:",
+      `- session: ${sessionId}`,
+      `- cwd: ${this.cwd}`,
+      runtime.provider ? `- provider: ${runtime.provider}` : null,
+      runtime.modelId ? `- model: ${runtime.modelId}` : null,
+      sessionStats.sessionName ? `- session_name: ${sessionStats.sessionName}` : null,
+      "",
+      "### User",
+      safeBlock(turn.userMessage),
+      formatRecallSection("User memory recall", turn.userRecallHints),
+      "### Assistant",
+      safeBlock(turn.assistantMessage),
+      turn.thinking ? ["### Thinking", safeBlock(turn.thinking)].join("\n") : null,
+      "### Tool calls",
+      formatToolCalls(turn.toolCalls),
+      formatRecallSection("Assistant memory recall", turn.assistantRecallHints),
+      "",
+    ].filter(Boolean).join("\n");
+  }
+}
+
+function formatToolCalls(calls = []) {
+  if (!Array.isArray(calls) || calls.length === 0) return "(none)";
+  return calls.map((call) => {
+    const lines = [`- ${call.name ?? "unknown"} status=${call.status ?? "unknown"}`];
+    const args = JSON.stringify(call.args ?? null);
+    if (args && args !== "null") lines.push(`  args: ${args}`);
+    if (call.status === "failed") {
+      lines.push("  error:");
+      if (call.error?.message) lines.push(`  message: ${escapeSingleLine(call.error.message)}`);
+      if (call.error?.details) lines.push(`  details: ${JSON.stringify(call.error.details)}`);
+      if (call.error?.excerpt) lines.push("  excerpt:", fence(call.error.excerpt));
+    }
+    return lines.join("\n");
+  }).join("\n");
+}
+
+function formatRecallSection(title, hints = []) {
+  if (!Array.isArray(hints) || hints.length === 0) return null;
+  return [`### ${title}`, ...hints.map((hint) => `- ${hint.id ?? "unknown"} | ${hint.name ?? hint.title ?? ""} | ${hint.description ?? ""}`)].join("\n");
+}
+
+function safeBlock(value) {
+  const text = String(value ?? "").trim();
+  return text || "(empty)";
+}
+
+function fence(value) {
+  return "  ```text\n" + String(value ?? "").trimEnd() + "\n  ```";
+}
+
+function sanitizeId(value) {
+  const raw = String(value ?? "session").trim() || "session";
+  return raw.replace(/[^a-zA-Z0-9_.-]+/g, "_").slice(0, 120) || "session";
+}
+
+function cwdHash(cwd) {
+  return createHash("sha1").update(String(cwd ?? "")).digest("hex").slice(0, 16);
+}
+
+function escapeSingleLine(value) {
+  return JSON.stringify(String(value ?? "").replace(/\s+/g, " "));
+}
+
+function clampInt(value, min, max, fallback) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return fallback;
+  return Math.min(max, Math.max(min, Math.floor(number)));
+}

package/src/history/tool.mjs

@@ -0,0 +1,39 @@
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { toolText } from "../agent/tool-result.mjs";
+
+export function createHistorySearchTool({ store } = {}) {
+  if (!store) return null;
+  return defineTool({
+    name: "history_search",
+    label: "History Search",
+    description: "Search archived March turn history with ripgrep. Use it when you need details from previous sessions or earlier turns. History stores user/assistant text, visible thinking, tool call metadata, memory recall hints, and failed tool error excerpts; successful tool results are not stored.",
+    parameters: Type.Object({
+      query: Type.String({ description: "Ripgrep query/pattern to search in archived turn history" }),
+      allProjects: Type.Optional(Type.Boolean({ description: "Search all project histories instead of the current cwd history. Default false." })),
+      sessionId: Type.Optional(Type.String({ description: "Limit search to a specific session id when known" })),
+      syntax: Type.Optional(Type.Union([Type.Literal("regex"), Type.Literal("literal")], { description: "Pattern syntax. Default: regex" })),
+      case: Type.Optional(Type.Union([Type.Literal("smart"), Type.Literal("sensitive"), Type.Literal("insensitive")], { description: "Case matching mode. Default: smart" })),
+      context: Type.Optional(Type.Number({ description: "Context lines around each match. Default: 2" })),
+      limit: Type.Optional(Type.Number({ description: "Maximum matches to return. Default: 20, max: 50" })),
+    }),
+    execute: async (_toolCallId, params) => {
+      try {
+        const results = store.searchRipgrep(params.query, params);
+        if (results.length === 0) return toolText(`history_search found no matches for ${JSON.stringify(params.query)}.`);
+        return toolText(formatHistorySearchResults(results), { results });
+      } catch (err) {
+        return toolText(`Error: ${err.message}`, { error: true });
+      }
+    },
+  });
+}
+
+function formatHistorySearchResults(results) {
+  const lines = [`history_search found ${results.length} match${results.length === 1 ? "" : "es"}.`];
+  results.forEach((result, index) => {
+    lines.push("", `[${index + 1}] ${result.path}:${result.line}`);
+    if (result.excerpt?.text) lines.push(result.excerpt.text);
+  });
+  return lines.join("\n");
+}

package/src/lsp/client.mjs

@@ -73,13 +73,14 @@ export function languageIdForPath(path) {
 }
 
 export class LspClient {
-  constructor({ serverId, command, args = [], cwd, initialization = {}, store }) {
+  constructor({ serverId, command, args = [], cwd, initialization = {}, store, onStatusChange = null }) {
     this.serverId = serverId;
     this.command = command;
     this.args = args;
     this.cwd = cwd;
     this.initialization = initialization;
     this.store = store;
+    this.onStatusChange = onStatusChange;
     this.status = "starting";
     this.process = null;
     this.buffer = Buffer.alloc(0);
@@ -98,7 +99,7 @@ export class LspClient {
     });
     this.process.stdout.on("data", (chunk) => this.#onData(chunk));
     this.process.on("exit", () => {
-      this.status = "failed";
+      this.#setStatus("failed");
       for (const pending of this.pending.values()) pending.reject(new Error("LSP exited"));
       this.pending.clear();
     });
@@ -124,7 +125,7 @@ export class LspClient {
     }), INITIALIZE_TIMEOUT_MS);
     this.syncKind = getSyncKind(initialized?.capabilities);
     this.#notify("initialized", {});
-    this.status = "ready";
+    this.#setStatus("ready");
   }
 
   touchFile(path) {
@@ -132,7 +133,7 @@ export class LspClient {
     const text = readFileSync(path, "utf8");
     const uri = pathToFileURL(path).href;
     const existing = this.documents.get(path);
-    this.status = "busy";
+    this.#setStatus("busy");
     if (existing) {
       const version = existing.version + 1;
       this.documents.set(path, { version, text });
@@ -199,7 +200,7 @@ export class LspClient {
         uri: message.params?.uri,
         diagnostics: message.params?.diagnostics ?? [],
       });
-      this.status = "idle";
+      this.#setStatus("idle");
       return;
     }
 
@@ -208,6 +209,12 @@ export class LspClient {
     }
   }
 
+  #setStatus(status) {
+    if (this.status === status) return;
+    this.status = status;
+    this.onStatusChange?.({ id: this.serverId, root: this.cwd, status });
+  }
+
   #requestResult(method) {
     if (method === "workspace/configuration") return [];
     if (method === "workspace/workspaceFolders") return [{ name: "workspace", uri: pathToFileURL(this.cwd).href }];