march-cli 0.1.35 → 0.1.37

package/src/cli/tui/input/history-navigation-controller.mjs

@@ -0,0 +1,56 @@
+import { matchesKey } from "@earendil-works/pi-tui";
+
+export function createHistoryNavigationController({ editor, requestRender, isAutocompleteOpen = () => false, hasOverlay = () => false } = {}) {
+  let draftText = null;
+
+  return {
+    handleInput(data) {
+      if (isAutocompleteOpen() || hasOverlay()) return undefined;
+
+      if (matchesKey(data, "alt+up")) return moveWithinInput(-1);
+      if (matchesKey(data, "alt+down")) return moveWithinInput(1);
+      if (matchesKey(data, "up")) return navigateHistory(-1);
+      if (matchesKey(data, "down")) return navigateHistory(1);
+
+      return undefined;
+    },
+  };
+
+  function navigateHistory(direction) {
+    const history = Array.isArray(editor?.history) ? editor.history : [];
+    const currentIndex = Number.isInteger(editor?.historyIndex) ? editor.historyIndex : -1;
+    const nextIndex = currentIndex - direction;
+    if (nextIndex < -1 || nextIndex >= history.length) return undefined;
+
+    if (currentIndex === -1) draftText = editor.getText?.() ?? "";
+    editor.lastAction = null;
+    editor.historyIndex = nextIndex;
+    setEditorTextPreservingHistory(nextIndex === -1 ? draftText ?? "" : history[nextIndex] ?? "");
+    if (nextIndex === -1) draftText = null;
+    requestRender?.();
+    return { consume: true };
+  }
+
+  function moveWithinInput(direction) {
+    editor.lastAction = null;
+    if (direction < 0) {
+      if (editor.isOnFirstVisualLine?.()) editor.moveToLineStart?.();
+      else editor.moveCursor?.(-1, 0);
+    } else {
+      if (editor.isOnLastVisualLine?.()) editor.moveToLineEnd?.();
+      else editor.moveCursor?.(1, 0);
+    }
+    requestRender?.();
+    return { consume: true };
+  }
+
+  function setEditorTextPreservingHistory(text) {
+    if (typeof editor.setTextInternal === "function") {
+      editor.setTextInternal(text);
+      return;
+    }
+    const historyIndex = editor.historyIndex;
+    editor.setText?.(text);
+    editor.historyIndex = historyIndex;
+  }
+}

package/src/cli/turn/turn-input-preparer.mjs

@@ -5,7 +5,6 @@ import { formatMessageAttachmentsForDisplay } from "../../session/attachment-dis
 import { formatShellHints } from "../../shell/hints.mjs";
 
 export function prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState = null }) {
-  memoryStore.beginTurn();
   const engine = runner.engine ?? {};
   const carryoverAlreadyRendered = engine.hasRenderedPendingAssistantRecallHints?.() ?? false;
   const carryoverRecallHints = engine.takePendingAssistantRecallHints?.() ?? [];

package/src/cli/ui.mjs

@@ -16,6 +16,7 @@ import { showEditorSelectList } from "./tui/select/editor-select-list.mjs";
 import { StatusBar } from "./tui/status/status-bar.mjs";
 import { MainPaneLayout } from "./tui/layout/main-pane-layout.mjs";
 import { SafeRenderBoundary } from "./tui/layout/safe-render-boundary.mjs";
+import { createHistoryNavigationController } from "./tui/input/history-navigation-controller.mjs";
 import { createMouseSelectionController } from "./tui/input/mouse-selection-controller.mjs";
 import { ScreenSelection } from "./tui/selection-screen.mjs";
 import { writeEditDiff } from "./tui/tui-diff-rendering.mjs";
@@ -68,6 +69,12 @@ export function createTuiUI({
   const retryStatus = createRetryStatusController({ output, requestRender, stopSpinner: spinnerStatus.stop });
   const shellDrawerControls = createShellDrawerControls({ shellDrawer, output, requestRender });
   const mouseSelectionController = createMouseSelectionController({ terminal, output, shellDrawer, shellDrawerControls, selection, writeClipboard, requestRender });
+  const historyNavigationController = createHistoryNavigationController({
+    editor,
+    requestRender,
+    isAutocompleteOpen: () => editor.isShowingAutocomplete(),
+    hasOverlay: () => tui.hasOverlay(),
+  });
 
   let onEscapeHandler = null, onCtrlCHandler = null, onShiftTabHandler = null;
   let onCtrlTHandler = null, onCtrlLHandler = null, onPasteImageHandler = null, onToggleModeHandler = null;
@@ -108,6 +115,8 @@ export function createTuiUI({
           requestRender();
           return { consume: true };
         }
+        const historyNavigationResult = historyNavigationController.handleInput(data);
+        if (historyNavigationResult) return historyNavigationResult;
       });
       terminal.write("\x1b[?1049h");
       terminal.write("\x1b[?1002h\x1b[?1006h");

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.
@@ -103,6 +106,11 @@ The user primarily asks for software engineering work: fixing bugs, adding behav
 - Use memory_save() to create memories or update whole metadata fields on an existing memory. 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 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.
+- Do not proactively modify the agent profile. Update `agent.md` only when the user explicitly asks to change persistent agent behavior.
+- Proactively maintain the user profile when stable, reusable user preferences, working style, goals, or identity signals appear in conversation.
+- For user profile updates, distinguish explicit facts from inferred preferences. Write explicit facts directly; write inferred items as preferences or tendencies, and avoid overstating confidence.
+- Do not store transient task details, sensitive information, or one-off opinions in the user profile. Use memory for project-specific reusable knowledge and current conversation for short-lived context.
+- When a user profile update is non-obvious or potentially sensitive, ask before writing; otherwise update it as part of normal task completion and mention it briefly in the final summary.
 - Unlike recall blocks, 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/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 }];

package/src/lsp/service.mjs

@@ -3,9 +3,10 @@ import { LspDiagnosticStore } from "./diagnostic-store.mjs";
 import { resolveLspServerStatus } from "./servers.mjs";
 
 export class LspService {
-  constructor({ cwd, onEvent = null }) {
+  constructor({ cwd, onEvent = null, onStatusChange = null }) {
     this.cwd = cwd;
     this.onEvent = onEvent;
+    this.onStatusChange = onStatusChange;
     this.store = new LspDiagnosticStore();
     this.clients = new Map();
     this.spawning = new Map();
@@ -19,6 +20,7 @@ export class LspService {
     if (result.status === "unavailable") {
       this.unavailable.set(result.id, result);
       this.#emitOnce(`unavailable:${result.id}:${result.reason}`, result);
+      this.#emitStatusChange(result);
       return result;
     }
 
@@ -34,7 +36,9 @@ export class LspService {
       return { status: "starting", id: server.id, root: server.root };
     }
 
-    this.#emitOnce(`starting:${key}`, { status: "starting", id: server.id, root: server.root, managed: server.managed });
+    const startingEvent = { status: "starting", id: server.id, root: server.root, managed: server.managed };
+    this.#emitOnce(`starting:${key}`, startingEvent);
+    this.#emitStatusChange(startingEvent);
     const task = this.#startClient(server, key).then((client) => {
       client?.touchFile(path);
       return client;
@@ -76,18 +80,22 @@ export class LspService {
       cwd: server.root,
       initialization: server.initialization,
       store: this.store,
+      onStatusChange: (event) => this.#emitStatusChange(event),
     });
     try {
       await client.start();
       this.clients.set(key, client);
       this.unavailable.delete(server.id);
-      this.#emitOnce(`attached:${key}`, { status: "attached", id: server.id, root: server.root, managed: server.managed });
+      const attachedEvent = { status: "attached", id: server.id, root: server.root, managed: server.managed };
+      this.#emitOnce(`attached:${key}`, attachedEvent);
+      this.#emitStatusChange(attachedEvent);
       return client;
     } catch (err) {
       client.status = "failed";
       const event = { status: "failed", id: server.id, root: server.root, reason: err.message };
       this.unavailable.set(server.id, event);
       this.#emitOnce(`failed:${key}:${err.message}`, event);
+      this.#emitStatusChange(event);
       return null;
     }
   }
@@ -97,6 +105,10 @@ export class LspService {
     this.announced.add(key);
     this.onEvent?.(event);
   }
+
+  #emitStatusChange(event) {
+    this.onStatusChange?.(event);
+  }
 }
 
 function summarizeStatus(servers) {

package/src/main.mjs

@@ -26,13 +26,12 @@ export async function run(argv) {
 
   const config = loadConfig(cwd);
   const stateRoot = join(homedir(), ".march");
-  const useRuntimeProcess = process.env.MARCH_RUNTIME_PROCESS !== "0";
   installNetworkEnvironment(config.network);
 
   const earlyCommand = await runEarlyCliCommand(args, { config, cwd, stateRoot });
   if (earlyCommand.handled) return earlyCommand.code;
 
-  const app = await createCliAppRuntime({ args, config, cwd, argv, stateRoot, useRuntimeProcess });
+  const app = await createCliAppRuntime({ args, config, cwd, argv, stateRoot });
   if (!app.ok) return app.code;
 
   const gatewayDaemonCommand = await maybeRunGatewayDaemonCommand(args, {