march-cli 0.1.36 → 0.1.37

package/package.json

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

package/src/agent/code-search/tool.mjs

@@ -13,7 +13,7 @@ export function createCodeSearchTool({ engine, stateRoot = null }) {
   return defineTool({
     name: "code_search",
     label: "Code Search",
-    description: "Native code-aware search over the workspace. Use it to locate relevant code snippets before reading full files; use grep for exact string confirmation.",
+    description: "Native semantic/symbol code search over the workspace. Use it first for unknown entry points, cross-module flows, responsibility boundaries, and related implementations. Use grep/read afterward for exact confirmation before editing or making claims.",
     parameters: Type.Object({
       query: Type.Optional(Type.String({ description: "Natural-language or symbol query" })),
       path: Type.Optional(Type.String({ description: "Relative or absolute workspace path to search; default current workspace" })),

package/src/agent/runner.mjs

@@ -28,19 +28,16 @@ import { registerCustomProviders } from "../provider/custom-provider.mjs";
 import { injectHostedTools } from "../provider/hosted-tools.mjs";
 import { createRunnerLifecycle } from "./lifecycle/runner-lifecycle.mjs";
 import { createRunnerProviderQuotaRuntime } from "./runner/provider-quota-runtime.mjs";
+import { appendRunnerTurnHistory, createRunnerHistoryStore } from "../history/runner.mjs";
 export { MARCH_BASE_TOOL_NAMES, installModelPayloadDumper };
 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, profilePaths = null, memoryStore = null, memoryTools = [], remoteMemorySources = [], 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 = {} }) {
+export async function createRunner({ cwd, modelId = null, provider = null, providers = {}, stateRoot, ui, memoryRoot = null, profilePaths = null, memoryStore = null, memoryTools = [], remoteMemorySources = [], 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, onLspStatusChange = null, createAgentSessionImpl = createAgentSession, createAgentSessionRuntimeImpl, createRuntimeServices, createRuntimeSessionFromServices, maxTurns, trimBatch, serviceTier = null, hostedTools = {} }) {
   installCodexLargeContextGuard();
   installCodexTransportCompression();
   installCodexWebSocketEventDebug();
-  if (!useRuntimeHost && extensionPaths.length > 0) {
-    throw new Error("--extension requires the default pi runtime host path");
-  }
-  const authConfig = authStorage
-    ? { authStorage, hasAuth: true }
-    : createMarchAuthStorage({ provider: provider ?? "deepseek", providers, cwd });
+  if (!useRuntimeHost && extensionPaths.length > 0) throw new Error("--extension requires the default pi runtime host path");
+  const authConfig = authStorage ? { authStorage, hasAuth: true } : createMarchAuthStorage({ provider: provider ?? "deepseek", providers, cwd });
   if (!authConfig.hasAuth) throw new Error("No providers configured. Run: march provider --config");
   const resolvedAuth = authConfig.authStorage;
   const modelRegistry = ModelRegistry.create(resolvedAuth);
@@ -55,8 +52,9 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
     retry: { enabled: true, maxRetries: 3, baseDelayMs: 2000 },
   });
   const { ui: runtimeUi, eventBus: runtimeUiEvents, detach: detachRuntimeUi } = createRuntimeUiBridge(ui);
-  const lspService = new LspService({ cwd, onEvent: (event) => runtimeUi.status?.(formatLspServiceEvent(event)) });
+  const lspService = new LspService({ cwd, onEvent: (event) => runtimeUi.status?.(formatLspServiceEvent(event)), onStatusChange: (event) => onLspStatusChange?.(event) });
   const engine = new ContextEngine({ cwd, modelId, provider, namespace, memoryRoot, profilePaths, remoteMemorySources, shellRuntime, lspService, injections: mcpInjections, maxTurns, trimBatch });
+  const historyStore = createRunnerHistoryStore({ stateRoot, cwd });
   const resolvedSessionManager = resolveRunnerSessionManager(cwd, sessionManager);
   const sessionBinding = createSessionBinding(null);
   let currentModelCallKind = "model", currentTurnId = null, currentPromptForContext = "";
@@ -72,7 +70,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
       providers,
       sessionManager: resolvedSessionManager, sessionBinding, engine, ui: runtimeUi,
       projectMarchDir,
-      memoryTools, memoryStore, shellRuntime, lspService, mcpTools, webTools,
+      memoryTools, memoryStore, historyStore, shellRuntime, lspService, mcpTools, webTools,
       lifecycle, permissionController, extensionPaths, hostedTools,
       onRebind: (session) => {
         installModelPayloadDumper(session, modelContextDumper, () => currentModelCallKind, onLoggedModelPayload, injectMarchSystemContext);
@@ -85,7 +83,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
   } else {
     const sessionOptions = resolveRunnerSessionOptions({
       cwd, stateRoot, provider, modelId, modelRegistry, engine, ui: runtimeUi,
-      memoryTools, shellRuntime, lspService, mcpTools, webTools, lifecycle, permissionController,
+      memoryTools, historyStore, shellRuntime, lspService, mcpTools, webTools, lifecycle, permissionController,
       authStorage: resolvedAuth, projectMarchDir,
       getCurrentModel: () => sessionBinding.get()?.model ?? selectedModel,
     });
@@ -134,6 +132,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
           syncCurrentPiSidecar,
           autoNameSession,
           contextMode,
+          recordHistory: (turn) => appendRunnerTurnHistory({ store: historyStore, turn, sessionStats: getRunnerSessionStats(sessionBinding.get(), runtimeHost), modelId: engine.modelId, provider: engine.provider }),
         });
         notifyTurnEndDetached(turnNotifier, {
           status: "success",

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

@@ -10,6 +10,7 @@ export async function createRunnerProcessClient({
   runnerOptions,
   ui,
   onModelPayload = null,
+  onLspStatusChange = null,
   entry = fileURLToPath(DEFAULT_ENTRY),
   forkImpl = fork,
   timeoutMs = 0,
@@ -46,6 +47,10 @@ export async function createRunnerProcessClient({
       target: {
         ...createRuntimeUiEventTarget(ui),
         modelPayload: (event) => onModelPayload?.(event),
+        lspStatusChange: async (event) => {
+          await active?.runner?.refreshState?.();
+          onLspStatusChange?.(event);
+        },
       },
       timeoutMs,
     });

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

@@ -93,6 +93,7 @@ export async function createIsolatedRunner(options = {}, deps = {}) {
     }),
     logger,
     onModelPayload: (event) => d.peer.notify("modelPayload", pickModelPayloadEvent(event)),
+    onLspStatusChange: (event) => d.peer.notify("lspStatusChange", pickLspStatusEvent(event)),
   });
 
   const originalDispose = runner.dispose;
@@ -109,3 +110,7 @@ export async function createIsolatedRunner(options = {}, deps = {}) {
 function pickModelPayloadEvent({ estimatedTokens, provider, model, kind, turnId } = {}) {
   return { estimatedTokens, provider, model, kind, turnId };
 }
+
+function pickLspStatusEvent({ id, root, status, reason, managed } = {}) {
+  return { id, root, status, reason, managed };
+}

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

@@ -20,6 +20,7 @@ export async function createRunnerRuntimeHost({
   ui,
   projectMarchDir = null,
   memoryTools = [],
+  historyStore = null,
   shellRuntime = null,
   lspService = null,
   mcpTools = [],
@@ -56,6 +57,7 @@ export async function createRunnerRuntimeHost({
         engine,
         ui,
         memoryTools,
+        historyStore,
         shellRuntime,
         lspService,
         mcpTools,

package/src/agent/session/session-options.mjs

@@ -10,6 +10,7 @@ export function resolveRunnerSessionOptions({
   engine,
   ui,
   memoryTools = [],
+  historyStore = null,
   shellRuntime = null,
   lspService = null,
   mcpTools = [],
@@ -31,7 +32,7 @@ export function resolveRunnerSessionOptions({
     ?? (provider && modelId ? getModel(provider, modelId) : null);
   if (!model) throw new Error(`Model not found: ${provider}/${modelId}`);
 
-  const customTools = createMarchCustomTools({ cwd, engine, ui, memoryTools, shellRuntime, lspService, mcpTools, webTools, lifecycle, permissionController, authStorage, projectMarchDir, stateRoot, getCurrentModel: () => getCurrentModel?.() ?? model });
+  const customTools = createMarchCustomTools({ cwd, engine, ui, memoryTools, historyStore, shellRuntime, lspService, mcpTools, webTools, lifecycle, permissionController, authStorage, projectMarchDir, stateRoot, getCurrentModel: () => getCurrentModel?.() ?? model });
   const customToolNames = customTools.map((tool) => tool.name);
   const tools = [
     ...customToolNames.filter((name) => name === "read"),

package/src/agent/tools.mjs

@@ -13,11 +13,13 @@ import { initImageGen } from "../image-gen/index.mjs";
 import { createSuperGrokTool } from "../supergrok/tool.mjs";
 import { createBrowserTools } from "../browser/tools/index.mjs";
 import { createRuntimeRestartTool } from "./lifecycle/runtime-restart-tool.mjs";
+import { createHistorySearchTool } from "../history/tool.mjs";
 
-export function createMarchCustomTools({ cwd, engine, ui, memoryTools = [], shellRuntime = null, lspService = null, mcpTools = [], webTools = [], lifecycle = null, permissionController = null, authStorage = null, projectMarchDir = null, stateRoot = null, getCurrentModel = null }) {
+export function createMarchCustomTools({ cwd, engine, ui, memoryTools = [], historyStore = null, shellRuntime = null, lspService = null, mcpTools = [], webTools = [], lifecycle = null, permissionController = null, authStorage = null, projectMarchDir = null, stateRoot = null, getCurrentModel = null }) {
   const commandExecTool = createCommandExecTool({ cwd });
   const codeSearchTool = createCodeSearchTool({ engine, stateRoot });
   const contextStatsTool = createContextStatsTool({ engine });
+  const historySearchTool = createHistorySearchTool({ store: historyStore });
   const editFileTool = createEditFileTool({ engine, ui, lspService });
   const readFileTool = createReadFileTool({ engine });
   const readImageTool = createReadImageTool({ engine, getCurrentModel });
@@ -36,6 +38,7 @@ export function createMarchCustomTools({ cwd, engine, ui, memoryTools = [], shel
     commandExecTool,
     editFileTool,
     ...createShellTools(shellRuntime),
+    ...(historySearchTool ? [historySearchTool] : []),
     ...memoryTools,
     ...mcpTools,
     ...webTools,

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

@@ -1,5 +1,7 @@
 import { formatToolStartLine, formatToolSuccessSummary } from "../tool-summary.mjs";
 
+const TOOL_ERROR_EXCERPT_LIMIT = 4000;
+
 export function createTurnEventState() {
   return {
     draft: "",
@@ -9,6 +11,7 @@ export function createTurnEventState() {
     assistantReplyOpen: false,
     assistantContextParts: [],
     activeToolContextPart: null,
+    toolCalls: [],
   };
 }
 
@@ -19,10 +22,12 @@ export function handleRunnerSessionEvent(event, { ui, engine, state }) {
   if (event.type === "tool_execution_start") {
     closeAssistantReply({ ui, state });
     appendToolStartContext(state, event.toolName, event.args);
+    recordToolStart(state, event.toolName, event.args);
     ui.toolStart(event.toolName, event.args);
   }
   if (event.type === "tool_execution_end") {
     updateToolEndContext(state, event.toolName, event.isError, event.result);
+    recordToolEnd(state, event.toolName, event.isError, event.result);
     ui.toolEnd(event.toolName, event.isError, event.result);
   }
   if (event.type === "auto_retry_start") {
@@ -109,3 +114,39 @@ function updateToolEndContext(state, name, isError, result) {
   if (summary && summary !== "done") part.text = `${part.text.trimEnd()} (${summary})\n`;
   state.activeToolContextPart = null;
 }
+
+function recordToolStart(state, name, args) {
+  state.toolCalls.push({ name, args: cloneJson(args), status: "running" });
+}
+
+function recordToolEnd(state, name, isError, result) {
+  const call = [...state.toolCalls].reverse().find((item) => item.name === name && item.status === "running");
+  if (!call) return;
+  call.status = isError ? "failed" : "success";
+  if (!isError) return;
+  const output = extractToolOutput(result);
+  call.error = {
+    message: output.split(/\r?\n/).find(Boolean) ?? "Tool call failed",
+    details: cloneJson(result?.details ?? null),
+    excerpt: truncate(output, TOOL_ERROR_EXCERPT_LIMIT),
+  };
+}
+
+function extractToolOutput(result) {
+  const content = result?.content;
+  if (!Array.isArray(content)) return typeof result === "string" ? result : "";
+  return content.filter((item) => item?.type === "text").map((item) => item.text ?? "").join("\n");
+}
+
+function cloneJson(value) {
+  try {
+    return JSON.parse(JSON.stringify(value ?? null));
+  } catch {
+    return null;
+  }
+}
+
+function truncate(text, limit) {
+  const value = String(text ?? "");
+  return value.length > limit ? `${value.slice(0, limit)}\n[truncated]` : value;
+}

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

@@ -17,6 +17,7 @@ export async function runRunnerTurn({
   syncCurrentPiSidecar,
   autoNameSession,
   contextMode = "rebuild",
+  recordHistory = null,
 }) {
   const {
     userRecallHints = [],
@@ -80,6 +81,7 @@ export async function runRunnerTurn({
       midTurnRecallHints,
       syncCurrentPiSidecar,
       autoNameSession,
+      recordHistory,
     });
     return { draft: turnState.draft };
   } finally {
@@ -127,19 +129,20 @@ function logSessionEvent(logger, event) {
   });
 }
 
-function finalizeTurn({ prompt, userMessage, userRecallHints, currentProject, memoryStore, engine, ui, turnState, midTurnRecallHints, syncCurrentPiSidecar, autoNameSession }) {
+function finalizeTurn({ prompt, userMessage, userRecallHints, currentProject, memoryStore, engine, ui, turnState, midTurnRecallHints, syncCurrentPiSidecar, autoNameSession, recordHistory }) {
   closeAssistantReply({ ui, state: turnState });
   const assistantRecallHints = flushAssistantRecall({ memoryStore, engine, turnState, currentProject });
   engine.setPendingAssistantRecallHints?.(assistantRecallHints);
   const recordedAssistantRecallHints = uniqueHints([...midTurnRecallHints, ...assistantRecallHints]);
 
-  engine.recordTurn({
+  const turn = engine.recordTurn({
     userMessage: userMessage ?? prompt.slice(0, 300),
     assistantMessage: turnState.draft,
     assistantContext: compactAssistantContext(turnState),
     userRecallHints,
     assistantRecallHints: recordedAssistantRecallHints,
   });
+  recordHistory?.({ ...turn, thinking: assistantThinkingText(turnState), toolCalls: turnState.toolCalls });
 
   autoNameSession?.();
   syncCurrentPiSidecar();

package/src/cli/input/history-store.mjs

@@ -1,8 +1,10 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 
 const HISTORY_VERSION = 1;
 const MAX_HISTORY_ITEMS = 100;
+const LOCK_WAIT_MS = 2000;
+const LOCK_STALE_MS = 5000;
 
 export function createInputHistoryStore({ path, maxItems = MAX_HISTORY_ITEMS } = {}) {
   return {
@@ -20,8 +22,10 @@ export function createInputHistoryStore({ path, maxItems = MAX_HISTORY_ITEMS } =
     save(items) {
       if (!path) return;
       const normalized = normalizeItems(items, maxItems);
-      mkdirSync(dirname(path), { recursive: true });
-      writeFileSync(path, `${JSON.stringify({ version: HISTORY_VERSION, items: normalized }, null, 2)}\n`, "utf8");
+      withHistoryLock(path, () => {
+        const merged = mergeItems(normalized, this.load(), maxItems);
+        writeHistoryFile(path, merged);
+      });
     },
   };
 }
@@ -33,3 +37,61 @@ function normalizeItems(items, maxItems) {
     .filter(Boolean)
     .slice(0, maxItems);
 }
+
+function mergeItems(primaryItems, existingItems, maxItems) {
+  const merged = [];
+  const seen = new Set();
+  for (const item of [...primaryItems, ...existingItems]) {
+    if (seen.has(item)) continue;
+    seen.add(item);
+    merged.push(item);
+    if (merged.length >= maxItems) break;
+  }
+  return merged;
+}
+
+function writeHistoryFile(path, items) {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmpPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+  const payload = `${JSON.stringify({ version: HISTORY_VERSION, items }, null, 2)}\n`;
+  writeFileSync(tmpPath, payload, "utf8");
+  renameSync(tmpPath, path);
+}
+
+function withHistoryLock(path, fn) {
+  mkdirSync(dirname(path), { recursive: true });
+  const lockPath = `${path}.lock`;
+  const fd = acquireLock(lockPath);
+  try {
+    return fn();
+  } finally {
+    closeSync(fd);
+    try { unlinkSync(lockPath); } catch {}
+  }
+}
+
+function acquireLock(lockPath) {
+  const start = Date.now();
+  while (true) {
+    try {
+      const fd = openSync(lockPath, "wx");
+      writeFileSync(fd, `${process.pid}\n`, "utf8");
+      return fd;
+    } catch (err) {
+      if (err?.code !== "EEXIST") throw err;
+      removeStaleLock(lockPath);
+      if (Date.now() - start >= LOCK_WAIT_MS) throw err;
+      sleepSync(25);
+    }
+  }
+}
+
+function removeStaleLock(lockPath) {
+  try {
+    if (Date.now() - statSync(lockPath).mtimeMs > LOCK_STALE_MS) unlinkSync(lockPath);
+  } catch {}
+}
+
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}

package/src/cli/repl-loop.mjs

@@ -14,12 +14,13 @@ export async function runSingleShotPrompt({
   refreshStatusBar,
   modeState = null,
 }) {
-  const turnInput = prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState });
-  ui.writeln(turnInput.displayMessage);
-  ui.recall?.({ source: "user", hints: turnInput.userRecallHints });
-  if (turnInput.shouldRenderCarryoverRecall) ui.recall?.({ source: "assistant", hints: turnInput.carryoverRecallHints });
-  refreshStatusBar.startWorking?.();
+  memoryStore.beginTurn();
   try {
+    const turnInput = prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState });
+    ui.writeln(turnInput.displayMessage);
+    ui.recall?.({ source: "user", hints: turnInput.userRecallHints });
+    if (turnInput.shouldRenderCarryoverRecall) ui.recall?.({ source: "assistant", hints: turnInput.carryoverRecallHints });
+    refreshStatusBar.startWorking?.();
     const result = await runner.runTurn(turnInput.fullPrompt, turnInput.userMessage, turnInput.runOptions);
     renderPendingAssistantRecallPreview({ runner, ui });
     await handleTurnLifecycleAction(result?.lifecycleAction, { runner, ui });
@@ -127,8 +128,9 @@ function handleInlineCommand(trimmed, { cwd, ui, lastInlineShellCommand }) {
 }
 
 async function runReplTurn({ prompt, runner, memoryStore, currentProject, ui, refreshStatusBar, setTurnRunning, modeState = null }) {
-  const turnInput = prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState });
+  memoryStore.beginTurn();
   try {
+    const turnInput = prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState });
     ui.writeln(turnInput.displayMessage);
     ui.recall?.({ source: "user", hints: turnInput.userRecallHints });
     if (turnInput.shouldRenderCarryoverRecall) ui.recall?.({ source: "assistant", hints: turnInput.carryoverRecallHints });

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

@@ -1,7 +1,6 @@
 import { basename, join, resolve } from "node:path";
 import { existsSync, mkdirSync } from "node:fs";
 import { createUI } from "../ui.mjs";
-import { createPermissionController, MODE } from "../permissions.mjs";
 import { loadKeybindings } from "../input/keybindings.mjs";
 import { createInputHistoryStore } from "../input/history-store.mjs";
 import { createModeState } from "../input/mode-state.mjs";
@@ -12,21 +11,16 @@ import { createMarchAuthStorage } from "../../auth/storage.mjs";
 import { createRuntimeRunner } from "./create-runtime-runner.mjs";
 import { createCliShellRuntime } from "../../shell/cli-runtime.mjs";
 import { MarkdownMemoryStore } from "../../memory/markdown-store.mjs";
-import { createMarkdownMemoryTools } from "../../memory/markdown-tools.mjs";
 import { discoverProjectExtensionPaths } from "../../extensions/discovery.mjs";
 import { loadProjectLifecycleHookManifests } from "../../extensions/lifecycle-manifest.mjs";
 import { loadOrCreateProjectId, resumeStartupSession } from "./startup-session.mjs";
-import { initializeMcp } from "../../mcp/index.mjs";
-import { createWebToolsFromConfig } from "../../web/tools.mjs";
-import { createModelContextDumper } from "../../debug/model-context-dumper.mjs";
 import { createLogger, installProcessLogHandlers } from "../../debug/logger.mjs";
 import { defaultProfilePaths, ensureProfileFiles } from "../../context/profiles.mjs";
-import { createDesktopTurnNotifier } from "../../notification/desktop-notifier.mjs";
 import { normalizeRemoteMemorySources } from "../../memory/remote/config.mjs";
 import { resolveMemoryRoot } from "../../memory/root.mjs";
 import { ensureBrowserDaemon } from "../../browser/client/lifecycle.mjs";
 
-export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot, useRuntimeProcess } = {}) {
+export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot } = {}) {
   if (!existsSync(stateRoot)) mkdirSync(stateRoot, { recursive: true });
   await ensureBrowserDaemon({ stateRoot }).catch(() => {});
 
@@ -67,23 +61,10 @@ export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot,
   ensureProfileFiles(profilePaths);
   const memoryStore = new MarkdownMemoryStore({ root: memoryRoot });
   const remoteMemorySources = normalizeRemoteMemorySources(config);
-  const memoryTools = createMarkdownMemoryTools(memoryStore, { remoteSources: remoteMemorySources });
   const currentProject = basename(cwd);
   const shellRuntime = args.shellRuntime ? createCliShellRuntime({ cwd }) : null;
 
-  const mcpInit = useRuntimeProcess
-    ? { clientManager: null, mcpTools: [], mcpInjections: [], errors: [] }
-    : await initializeMcp({ projectDir: cwd });
-  for (const { server, error } of mcpInit.errors) {
-    if (!args.json) process.stderr.write(`[mcp] ${server}: ${error}\n`);
-  }
-
-  const webTools = createWebToolsFromConfig(config);
-  const turnNotifier = createDesktopTurnNotifier({ enabled: Boolean(config.notifications?.turnEnd), config: config.notifications });
-  const permissionMode = args.permissionMode ?? MODE.BYPASS;
-  const permissionController = createPermissionController({ mode: permissionMode });
-  const usePiSessions = true;
-  const usePiRuntimeHost = true;
+  const permissionMode = args.permissionMode;
   const sessionSource = "pi";
   const sessionsRoot = join(projectMarchDir, "sessions");
   const sessionState = {
@@ -92,10 +73,6 @@ export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot,
   };
   sessionState.sessionDir = join(sessionsRoot, sessionState.sessionId);
   const contextDumpRoot = resolve(projectMarchDir, "context-dumps", sessionState.sessionId);
-  const modelContextDumper = createModelContextDumper({
-    enabled: args.dumpContext,
-    rootDir: contextDumpRoot,
-  });
 
   const ui = createUI({
     json: args.json,
@@ -132,10 +109,9 @@ export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot,
   let runner;
   try {
     runner = await createRuntimeRunner({
-      useRuntimeProcess, runnerOptions, ui, memoryStore, memoryTools, shellRuntime,
-      mcpTools: mcpInit.mcpTools, mcpInjections: mcpInit.mcpInjections, mcpClientManager: mcpInit.clientManager, webTools,
-      usePiSessions, usePiRuntimeHost, authStorage: authConfig.authStorage,
-      permissionController, modelContextDumper, turnNotifier, logger,
+      runnerOptions,
+      ui,
+      shellRuntime,
       refreshStatusBar: (...args) => refreshStatusBar?.(...args),
     });
   } catch (err) {

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

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

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.

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, {

package/src/web-ui/command.mjs

@@ -6,11 +6,11 @@ import { createWebSessionManager, resolveWorkspace } from "./session-manager.mjs
 const DEFAULT_HOST = "127.0.0.1";
 const DEFAULT_PORT = 4174;
 
-export async function runWebUiCommand(args, { config, cwd, stateRoot, useRuntimeProcess = true } = {}) {
+export async function runWebUiCommand(args, { config, cwd, stateRoot } = {}) {
   const host = args.host ?? DEFAULT_HOST;
   assertLoopbackHost(host);
   const port = Number.parseInt(args.port ?? "", 10) || DEFAULT_PORT;
-  const runtime = createWebSessionManager({ args, config, launchCwd: cwd, stateRoot, useRuntimeProcess });
+  const runtime = createWebSessionManager({ args, config, launchCwd: cwd, stateRoot });
   const initialWorkspace = resolveInitialWorkspace(args, cwd);
   if (initialWorkspace) await runtime.createSession(initialWorkspace);
 

package/src/web-ui/runtime-host.mjs

@@ -3,17 +3,12 @@ import { basename, join, resolve } from "node:path";
 import { existsSync, mkdirSync, readdirSync, statSync } from "node:fs";
 import { createMarchAuthStorage } from "../auth/storage.mjs";
 import { createRuntimeRunner } from "../cli/startup/create-runtime-runner.mjs";
-import { createPermissionController, MODE } from "../cli/permissions.mjs";
 import { createCliShellRuntime } from "../shell/cli-runtime.mjs";
 import { MarkdownMemoryStore } from "../memory/markdown-store.mjs";
-import { createMarkdownMemoryTools } from "../memory/markdown-tools.mjs";
 import { resolveMemoryRoot } from "../memory/root.mjs";
 import { defaultProfilePaths, ensureProfileFiles } from "../context/profiles.mjs";
 import { loadOrCreateProjectId } from "../cli/startup/startup-session.mjs";
-import { createWebToolsFromConfig } from "../web/tools.mjs";
 import { createLogger, installProcessLogHandlers } from "../debug/logger.mjs";
-import { createModelContextDumper } from "../debug/model-context-dumper.mjs";
-import { createDesktopTurnNotifier } from "../notification/desktop-notifier.mjs";
 import { discoverProjectExtensionPaths } from "../extensions/discovery.mjs";
 import { loadProjectLifecycleHookManifests } from "../extensions/lifecycle-manifest.mjs";
 import { normalizeRemoteMemorySources } from "../memory/remote/config.mjs";
@@ -22,7 +17,7 @@ import { prepareTurnInput } from "../cli/turn/turn-input-preparer.mjs";
 const MAX_WORKSPACE_DEPTH = 3;
 const MAX_WORKSPACE_ENTRIES = 200;
 
-export async function createWebRuntimeHost({ args, config, cwd, stateRoot, useRuntimeProcess = true } = {}) {
+export async function createWebRuntimeHost({ args, config, cwd, stateRoot } = {}) {
   stateRoot ??= join(homedir(), ".march");
   if (!existsSync(stateRoot)) mkdirSync(stateRoot, { recursive: true });
   const logger = createLogger({ logDir: join(stateRoot, "logs") });
@@ -40,14 +35,10 @@ export async function createWebRuntimeHost({ args, config, cwd, stateRoot, useRu
 
   const memoryStore = new MarkdownMemoryStore({ root: memoryRoot });
   const remoteMemorySources = normalizeRemoteMemorySources(config);
-  const memoryTools = createMarkdownMemoryTools(memoryStore, { remoteSources: remoteMemorySources });
   const shellRuntime = args.shellRuntime ? createCliShellRuntime({ cwd }) : null;
   const extensionPaths = discoverProjectExtensionPaths(cwd);
   const lifecycleManifests = loadProjectLifecycleHookManifests(cwd);
   const contextDumpRoot = resolve(projectMarchDir, "context-dumps", Date.now().toString(36));
-  const modelContextDumper = createModelContextDumper({ enabled: args.dumpContext, rootDir: contextDumpRoot });
-  const permissionController = createPermissionController({ mode: args.permissionMode ?? MODE.BYPASS });
-  const turnNotifier = createDesktopTurnNotifier({ enabled: Boolean(config.notifications?.turnEnd), config: config.notifications });
   const ui = createHeadlessWebUi();
   const currentProject = basename(cwd);
   const namespace = loadOrCreateProjectId(projectMarchDir);
@@ -72,20 +63,9 @@ export async function createWebRuntimeHost({ args, config, cwd, stateRoot, useRu
     remoteMemorySources,
   };
   const runner = await createRuntimeRunner({
-    useRuntimeProcess,
     runnerOptions,
     ui,
-    memoryStore,
-    memoryTools,
     shellRuntime,
-    webTools: createWebToolsFromConfig(config),
-    usePiSessions: true,
-    usePiRuntimeHost: true,
-    authStorage: authConfig.authStorage,
-    permissionController,
-    modelContextDumper,
-    turnNotifier,
-    logger,
   });
   let turnRunning = false;
 
@@ -100,9 +80,10 @@ export async function createWebRuntimeHost({ args, config, cwd, stateRoot, useRu
     async runTurn(prompt) {
       if (turnRunning) throw new Error("A turn is already running");
       turnRunning = true;
-      const input = prepareTurnInput({ prompt, runner, memoryStore, currentProject });
-      runner.runtimeUiEvents.emit({ type: "web_user_message", text: input.userMessage });
+      memoryStore.beginTurn();
       try {
+        const input = prepareTurnInput({ prompt, runner, memoryStore, currentProject });
+        runner.runtimeUiEvents.emit({ type: "web_user_message", text: input.userMessage });
         return await runner.runTurn(input.fullPrompt, input.userMessage, input.runOptions);
       } finally {
         turnRunning = false;

package/src/web-ui/session-manager.mjs

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { basename, resolve } from "node:path";
 import { createWebRuntimeHost } from "./runtime-host.mjs";
 
-export function createWebSessionManager({ args, config, launchCwd, stateRoot, useRuntimeProcess = true } = {}) {
+export function createWebSessionManager({ args, config, launchCwd, stateRoot } = {}) {
   const sessions = new Map();
   const activities = [];
   let activeSessionId = null;
@@ -12,7 +12,7 @@ export function createWebSessionManager({ args, config, launchCwd, stateRoot, us
   async function createSession(workspacePath) {
     const workspace = resolveWorkspace(workspacePath, launchCwd);
     const id = `session-${Date.now().toString(36)}-${nextSessionNumber++}`;
-    const runtime = await createWebRuntimeHost({ args, config, cwd: workspace, stateRoot, useRuntimeProcess });
+    const runtime = await createWebRuntimeHost({ args, config, cwd: workspace, stateRoot });
     const session = { id, workspace, title: basename(workspace) || workspace, runtime, createdAt: Date.now() };
     sessions.set(id, session);
     activeSessionId = id;