march-cli 0.1.42 → 0.1.46

package/package.json

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

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

@@ -1,11 +1,13 @@
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { chunkFile } from "./chunker.mjs";
+import { readCodeFileContent } from "./scanner.mjs";
 import { Bm25Index } from "./retrieval/bm25.mjs";
+import { describeVectorizer } from "./retrieval/resilient-vectorizer.mjs";
 import { LocalVectorIndex, defaultVectorizer } from "./retrieval/vector.mjs";
 
 const DEFAULT_MAX_FILE_ENTRIES = 8_000;
-const DEFAULT_MAX_INDEX_ENTRIES = 24;
+const DEFAULT_MAX_INDEX_ENTRIES = 6;
 
 export class CodeSearchIndexCache {
   constructor({
@@ -24,7 +26,7 @@ export class CodeSearchIndexCache {
     this.dirty = false;
   }
 
-  async build(files) {
+  async build(files, { includeVector = true } = {}) {
     await this.load();
     const chunks = [];
     let reusedFiles = 0;
@@ -38,7 +40,9 @@ export class CodeSearchIndexCache {
         reusedFiles += 1;
         continue;
       }
-      const fileChunks = await chunkFile(file);
+      const content = await readCodeFileContent(file.absPath);
+      if (content === null) continue;
+      const fileChunks = await chunkFile({ ...file, content });
       this.fileChunks.set(key, { signature, chunks: fileChunks });
       this.dirty = true;
       chunks.push(...fileChunks);
@@ -48,21 +52,26 @@ export class CodeSearchIndexCache {
     this.pruneFileCache();
     await this.persist();
 
-    const indexSignature = [this.vectorizer.id, ...files.map(fileSignature)].join("\n");
+    const indexSignature = this.indexSignature(files, { includeVector });
     const cachedIndex = this.indices.get(indexSignature);
     if (cachedIndex) {
       this.indices.delete(indexSignature);
       this.indices.set(indexSignature, cachedIndex);
-      return { chunks, index: cachedIndex, reusedFiles, indexedFiles, reusedIndex: true, vectorizer: this.vectorizer.id };
+      return { chunks, index: cachedIndex, reusedFiles, indexedFiles, reusedIndex: true, ...describeVectorizer(this.vectorizer) };
     }
 
     const index = {
       lexical: new Bm25Index(chunks),
-      vector: await LocalVectorIndex.create(chunks, { vectorizer: this.vectorizer }),
+      vector: includeVector ? await LocalVectorIndex.create(chunks, { vectorizer: this.vectorizer }) : null,
     };
     this.indices.set(indexSignature, index);
     this.pruneIndexCache();
-    return { chunks, index, reusedFiles, indexedFiles, reusedIndex: false, vectorizer: this.vectorizer.id };
+    return { chunks, index, reusedFiles, indexedFiles, reusedIndex: false, ...describeVectorizer(this.vectorizer) };
+  }
+
+  indexSignature(files, { includeVector }) {
+    const vectorKey = includeVector ? this.vectorizer.id : "lexical";
+    return [vectorKey, ...files.map(fileSignature)].join("\n");
   }
 
   clear() {

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

@@ -22,7 +22,7 @@ export async function searchCode(options = {}) {
   if (!normalizedQuery && !related_to) return { results: [], stats: { files: 0, chunks: 0 } };
 
   const files = await scanCodeFiles({ root, path });
-  const built = await activeCache.build(files);
+  const built = await activeCache.build(files, { includeVector: needsVectorIndex({ mode, related_to }) });
   const related = related_to ? relatedQuery(built.chunks, related_to, normalizedQuery) : null;
   const queryText = related?.query ?? normalizedQuery;
   const retrieved = await retrieveChunks(built.index, queryText, mode);
@@ -38,7 +38,7 @@ export async function searchCode(options = {}) {
 async function retrieveChunks(index, queryText, mode) {
   const lexical = index.lexical.search(queryText, { limit: RETRIEVAL_LIMIT });
   if (mode === "lexical" || mode === "symbol") return lexical;
-  const semantic = await index.vector.search(queryText, { limit: RETRIEVAL_LIMIT });
+  const semantic = index.vector ? await index.vector.search(queryText, { limit: RETRIEVAL_LIMIT }) : [];
   if (mode === "semantic") return semantic;
   return rrfFuse([
     { results: lexical, weight: 1.2 },
@@ -46,6 +46,11 @@ async function retrieveChunks(index, queryText, mode) {
   ], { limit: RETRIEVAL_LIMIT });
 }
 
+function needsVectorIndex({ mode, related_to }) {
+  if (related_to) return true;
+  return mode !== "lexical" && mode !== "symbol";
+}
+
 function resultMode({ related_to, mode }) {
   if (related_to) return "related";
   if (mode === "symbol") return "symbol";
@@ -79,6 +84,8 @@ function formatStats(files, built, mode) {
     indexed_files: built.indexedFiles,
     reused_index: built.reusedIndex,
     vectorizer: built.vectorizer,
+    vectorizer_status: built.vectorizer_status,
+    vectorizer_warning: built.vectorizer_warning,
   };
 }
 

package/src/agent/code-search/retrieval/resilient-vectorizer.mjs

@@ -0,0 +1,59 @@
+import { HashingVectorizer } from "./vector.mjs";
+
+export class ResilientVectorizer {
+  constructor({ primary, fallback = new HashingVectorizer(), label = "embedding" } = {}) {
+    if (!primary) throw new Error("ResilientVectorizer requires primary");
+    this.primary = primary;
+    this.fallback = fallback;
+    this.label = label;
+    this.id = `resilient:${primary.id}->${fallback.id}`;
+    this.active = primary;
+    this.status = "primary";
+    this.warning = null;
+  }
+
+  get dimensions() {
+    return this.active.dimensions;
+  }
+
+  get activeId() {
+    return this.active.id;
+  }
+
+  async load() {
+    if (this.status === "fallback") return false;
+    try {
+      if (typeof this.primary.load === "function") await this.primary.load();
+      else await this.primary.encode([`${this.label} warmup`]);
+      return true;
+    } catch (err) {
+      this.#activateFallback(err);
+      return false;
+    }
+  }
+
+  async encode(texts) {
+    if (this.status === "fallback") return this.fallback.encode(texts);
+    try {
+      return await this.primary.encode(texts);
+    } catch (err) {
+      this.#activateFallback(err);
+      return this.fallback.encode(texts);
+    }
+  }
+
+  #activateFallback(err) {
+    this.active = this.fallback;
+    this.status = "fallback";
+    const message = err?.message ?? String(err);
+    this.warning = `${this.label} Model2Vec unavailable; using local hashing fallback: ${message}`;
+  }
+}
+
+export function describeVectorizer(vectorizer) {
+  return {
+    vectorizer: vectorizer?.activeId ?? vectorizer?.id ?? "unknown",
+    vectorizer_status: vectorizer?.status ?? "primary",
+    vectorizer_warning: vectorizer?.warning ?? null,
+  };
+}

package/src/agent/code-search/retrieval/safetensors.mjs

@@ -16,34 +16,40 @@ export async function readSafetensors(filePath) {
 }
 
 export function parseSafetensors(buffer) {
-  const data = toArrayBuffer(buffer);
-  const headerLength = Number(new DataView(data, 0, HEADER_BYTES).getBigUint64(0, true));
+  const source = toByteSource(buffer);
+  const headerLength = Number(new DataView(source.buffer, source.byteOffset, HEADER_BYTES).getBigUint64(0, true));
   const headerStart = HEADER_BYTES;
   const headerEnd = headerStart + headerLength;
-  const headerJson = new TextDecoder().decode(new Uint8Array(data, headerStart, headerLength));
+  const headerJson = new TextDecoder().decode(new Uint8Array(source.buffer, source.byteOffset + headerStart, headerLength));
   const header = JSON.parse(headerJson);
   return {
     names: Object.keys(header).filter((name) => name !== "__metadata__"),
     getTensor(name) {
       const descriptor = header[name];
       if (!descriptor) throw new Error(`Missing safetensors tensor: ${name}`);
-      return readTensor(data, headerEnd, descriptor);
+      return readTensor(source, headerEnd, descriptor);
     },
   };
 }
 
-function readTensor(data, dataStart, descriptor) {
+function readTensor(source, dataStart, descriptor) {
   const reader = DTYPE_READERS[descriptor.dtype];
   if (!reader) throw new Error(`Unsupported safetensors dtype: ${descriptor.dtype}`);
   const [start, end] = descriptor.data_offsets;
-  const byteOffset = dataStart + start;
-  const length = (end - start) / reader.size;
-  const view = new DataView(data, byteOffset, end - start);
+  const byteOffset = source.byteOffset + dataStart + start;
+  const byteLength = end - start;
+  const length = byteLength / reader.size;
+  if (descriptor.dtype === "F32" && byteOffset % Float32Array.BYTES_PER_ELEMENT === 0) {
+    return { values: new Float32Array(source.buffer, byteOffset, length), shape: descriptor.shape, dtype: descriptor.dtype };
+  }
+  const view = new DataView(source.buffer, byteOffset, byteLength);
   const values = new Float32Array(length);
   for (let index = 0; index < length; index += 1) values[index] = reader.read(view, index * reader.size);
   return { values, shape: descriptor.shape, dtype: descriptor.dtype };
 }
 
-function toArrayBuffer(buffer) {
-  return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+function toByteSource(buffer) {
+  if (buffer instanceof ArrayBuffer) return { buffer, byteOffset: 0, byteLength: buffer.byteLength };
+  if (ArrayBuffer.isView(buffer)) return { buffer: buffer.buffer, byteOffset: buffer.byteOffset, byteLength: buffer.byteLength };
+  throw new TypeError("safetensors input must be an ArrayBuffer or typed array view");
 }

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

@@ -26,13 +26,11 @@ export async function scanCodeFiles({ root, path = ".", maxFiles = DEFAULT_MAX_F
     let info;
     try { info = await stat(absPath); } catch { continue; }
     if (!info.isFile() || info.size > maxFileBytes) continue;
-    const content = await readUtf8Text(absPath);
-    if (content === null) continue;
+    if (await isSymlink(absPath)) continue;
     files.push({
       absPath,
       relPath: relPath.replace(/\\/g, "/"),
       language: languageForPath(relPath),
-      content,
       size: info.size,
       mtimeMs: info.mtimeMs,
     });
@@ -40,6 +38,7 @@ export async function scanCodeFiles({ root, path = ".", maxFiles = DEFAULT_MAX_F
   return files;
 }
 
+
 async function listCandidateFiles(root, base) {
   const fromRipgrep = await listRipgrepFiles(root, base);
   if (fromRipgrep) return fromRipgrep;
@@ -72,9 +71,8 @@ async function listFilesRecursively(root, dir) {
   return files;
 }
 
-async function readUtf8Text(path) {
+export async function readCodeFileContent(path) {
   try {
-    if ((await lstat(path)).isSymbolicLink()) return null;
     const buffer = await readFile(path);
     if (buffer.includes(0)) return null;
     return buffer.toString("utf8");
@@ -82,3 +80,11 @@ async function readUtf8Text(path) {
     return null;
   }
 }
+
+async function isSymlink(path) {
+  try {
+    return (await lstat(path)).isSymbolicLink();
+  } catch {
+    return true;
+  }
+}

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

@@ -5,6 +5,7 @@ import { toolText } from "../tool-result.mjs";
 import { CodeSearchIndexCache } from "./cache.mjs";
 import { searchCode } from "./engine.mjs";
 import { Model2VecVectorizer, POTION_CODE_MODEL_ID } from "./retrieval/model2vec.mjs";
+import { ResilientVectorizer } from "./retrieval/resilient-vectorizer.mjs";
 
 const persistentCaches = new Map();
 
@@ -23,7 +24,7 @@ export function createCodeSearchTool({ engine, stateRoot = null }) {
         Type.Literal("symbol"),
         Type.Literal("lexical"),
         Type.Literal("semantic"),
-      ], { description: "Search mode. auto uses BM25 + Model2Vec retrieval with RRF fusion." })),
+      ], { description: "Search mode. auto uses BM25 + Model2Vec retrieval with RRF fusion; falls back to local hashing if the model is unavailable." })),
       include_tests: Type.Optional(Type.Boolean({ description: "Include test/spec paths without penalty; default false" })),
       related_to: Type.Optional(Type.Object({
         file_path: Type.String({ description: "Workspace-relative file path containing the known code" }),
@@ -53,7 +54,10 @@ function persistentCacheFor(stateRoot) {
   if (!cache) {
     cache = new CodeSearchIndexCache({
       storagePath,
-      vectorizer: new Model2VecVectorizer({ modelDir }),
+      vectorizer: new ResilientVectorizer({
+        primary: new Model2VecVectorizer({ modelDir }),
+        label: "code_search",
+      }),
     });
     persistentCaches.set(cacheKey, cache);
   }
@@ -61,13 +65,15 @@ function persistentCacheFor(stateRoot) {
 }
 
 function formatSearchOutput({ results, stats }) {
-  const header = `--- code_search (${results.length} results, ${stats.files} files, ${stats.chunks} chunks, ${stats.mode}) ---`;
-  if (results.length === 0) return `${header}\nNo matching code snippets found.`;
+  const mode = stats.vectorizer_status === "fallback" ? `${stats.mode}-fallback` : stats.mode;
+  const header = `--- code_search (${results.length} results, ${stats.files} files, ${stats.chunks} chunks, ${mode}) ---`;
+  const warning = stats.vectorizer_warning ? `\nwarning: ${stats.vectorizer_warning}` : "";
+  if (results.length === 0) return `${header}${warning}\nNo matching code snippets found.`;
   const body = results.map((result, index) => [
     `${index + 1}. ${result.file_path}:${result.start_line}-${result.end_line} score=${result.score} kind=${result.kind}${result.symbols.length ? ` symbols=${result.symbols.join(",")}` : ""}`,
     fenceSnippet(result.snippet),
   ].join("\n")).join("\n\n");
-  return `${header}\n${body}`;
+  return `${header}${warning}\n${body}`;
 }
 
 function fenceSnippet(snippet) {

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

@@ -14,7 +14,7 @@ export function installModelPayloadDumper(session, modelContextDumper, getKind =
     const originalEffectivePayload = replacement === undefined ? payload : replacement;
     const kind = getKind();
     const effectivePayload = typeof transformPayload === "function"
-      ? transformPayload(originalEffectivePayload, { kind, model })
+      ? await transformPayload(originalEffectivePayload, { kind, model })
       : originalEffectivePayload;
     onModelPayload?.({
       payload: effectivePayload,

package/src/agent/runner/payload/provider-payload-transform.mjs

@@ -0,0 +1,59 @@
+import { injectHostedTools } from "../../../provider/hosted-tools.mjs";
+import { replaceProviderContextMessages } from "../../model-payload-dumper.mjs";
+import { applyCodexLargeContextGuardToPayload } from "../codex-large-context-guard.mjs";
+
+export function createRunnerProviderPayloadTransform({
+  engine,
+  sessionBinding,
+  hostedTools,
+  getCurrentPrompt,
+  getContextMode,
+  getFastEntry,
+  waitForMidTurnRecall = null,
+  getMidTurnRecallMessages = null,
+}) {
+  let didReplaceProviderContext = false;
+
+  return {
+    resetTurn() {
+      didReplaceProviderContext = false;
+    },
+    async transform(payload, { kind, model } = {}) {
+      if (kind !== "user") return payload;
+      const shouldReplaceProviderContext = getContextMode() !== "continueExistingPiTranscript"
+        && !didReplaceProviderContext;
+      let nextPayload = payload;
+      if (shouldReplaceProviderContext) {
+        nextPayload = replaceProviderContextMessages(payload, engine.buildProviderContext(getCurrentPrompt()));
+        didReplaceProviderContext = true;
+      } else {
+        await waitForMidTurnRecall?.();
+        nextPayload = appendMissingMidTurnRecallMessages(nextPayload, getMidTurnRecallMessages?.() ?? []);
+      }
+      nextPayload = injectHostedTools(nextPayload, model, hostedTools);
+      nextPayload = applyCodexLargeContextGuardToPayload(nextPayload, { model, session: sessionBinding.get() });
+      if (getFastEntry()) nextPayload = { ...nextPayload, service_tier: "priority" };
+      return nextPayload;
+    },
+  };
+}
+
+function appendMissingMidTurnRecallMessages(payload, recallMessages) {
+  if (!Array.isArray(payload?.messages) || recallMessages.length === 0) return payload;
+  const existingText = payload.messages.map((message) => providerMessageText(message)).join("\n");
+  const missing = recallMessages.filter((content) => content && !existingText.includes(content));
+  if (missing.length === 0) return payload;
+  return {
+    ...payload,
+    messages: [
+      ...payload.messages,
+      ...missing.map((content) => ({ role: "user", content })),
+    ],
+  };
+}
+
+function providerMessageText(message) {
+  if (typeof message?.content === "string") return message.content;
+  if (Array.isArray(message?.content)) return message.content.map((part) => part?.text ?? "").join("");
+  return "";
+}

package/src/agent/runner/recall/mid-turn-recall-bridge.mjs

@@ -0,0 +1,23 @@
+export function createMidTurnRecallBridge() {
+  const messages = [];
+  const tasks = new Set();
+  return {
+    reset() {
+      messages.length = 0;
+      tasks.clear();
+    },
+    track({ content, task } = {}) {
+      if (content && !messages.includes(content)) messages.push(content);
+      if (!task?.finally) return;
+      tasks.add(task);
+      task.finally(() => tasks.delete(task));
+    },
+    async wait() {
+      if (tasks.size === 0) return;
+      await Promise.allSettled([...tasks]);
+    },
+    messages() {
+      return [...messages];
+    },
+  };
+}

package/src/agent/runner.mjs

@@ -5,15 +5,17 @@ import { createMarchLifecycleAdapter } from "../extensions/lifecycle-adapter.mjs
 import { syncMarchSessionState } from "../session/state/march-session-sync.mjs";
 import { LspService } from "../lsp/service.mjs";
 import { formatLspServiceEvent } from "../lsp/status-message.mjs";
-import { estimateProviderPayloadTokens, installModelPayloadDumper, replaceProviderContextMessages } from "./model-payload-dumper.mjs";
+import { estimateProviderPayloadTokens, installModelPayloadDumper } from "./model-payload-dumper.mjs";
 import { resolveInitialModel, resolveRunnerSessionManager } from "./runner/runner-init.mjs";
 import { runRunnerCleanup } from "./runner/runner-cleanup.mjs";
 import { createRunnerRuntimeHost } from "./runtime/runner-runtime-host.mjs";
+import { createMarchPiResourceLoader } from "./runtime/resource/context-resource-loader.mjs";
 import { createRuntimeUiBridge } from "./runtime/ui-event-bridge.mjs";
 import { getRunnerSessionStats, syncEngineSessionState } from "./runner/runner-session-state.mjs";
 import { buildNotificationActivation, installRunnerProcessGuards, notifyTurnEndBestEffort, notifyTurnEndDetached, providerContextToPayload } from "./runner/runner-utils.mjs";
 import { dumpCodexTransportDebug, getCodexTransportDebugSnapshot } from "./runner/codex-transport-debug.mjs";
-import { applyCodexLargeContextGuardToPayload } from "./runner/codex-large-context-guard.mjs";
+import { createRunnerProviderPayloadTransform } from "./runner/payload/provider-payload-transform.mjs";
+import { createMidTurnRecallBridge } from "./runner/recall/mid-turn-recall-bridge.mjs";
 import { resolveRunnerSessionOptions } from "./session/session-options.mjs";
 import { createSessionBinding } from "./session/session-binding.mjs";
 import { maybeAutoNameSession } from "./session/session-auto-name.mjs";
@@ -23,13 +25,11 @@ import { beginLoggedTurn } from "./turn/turn-logging.mjs";
 import { appendFastVariants, createFastModelEntry, fromFastEntryModel, isFastProvider } from "./runner/fast-model.mjs";
 import { registerSuperGrokProvider } from "../supergrok/provider.mjs";
 import { registerCustomProviders } from "../provider/custom-provider.mjs";
-import { injectHostedTools } from "../provider/hosted-tools.mjs";
 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 { 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, syncMarchSessionState: syncMarchSessionStateEnabled = false, syncPiSidecar = syncMarchSessionStateEnabled, extensionPaths = [], lifecycleHooks = [], lifecycleDiagnostics = [], authStorage = null, modelContextDumper = null, turnNotifier = null, logger = null, onModelPayload = null, onLspStatusChange = null, createAgentSessionImpl = createAgentSession, createAgentSessionRuntimeImpl, createRuntimeServices, createRuntimeSessionFromServices, maxTurns, trimBatch, serviceTier = null, hostedTools = {}, notificationContext = null }) {
   installRunnerProcessGuards();
   if (!useRuntimeHost && extensionPaths.length > 0) throw new Error("--extension requires the default pi runtime host path");
@@ -43,10 +43,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
   if (!selectedModel) throw new Error("No authenticated models available. Run: march provider --config");
   provider = selectedModel.provider;
   modelId = selectedModel.id;
-  const settingsManager = SettingsManager.inMemory({
-    compaction: { enabled: false },
-    retry: { enabled: true, maxRetries: 3, baseDelayMs: 2000 },
-  });
+  const settingsManager = SettingsManager.inMemory({ compaction: { enabled: false }, retry: { enabled: true, maxRetries: 3, baseDelayMs: 2000, provider: { timeoutMs: 20000, maxRetries: 3, maxRetryDelayMs: 60000 } } });
   const { ui: runtimeUi, eventBus: runtimeUiEvents, detach: detachRuntimeUi } = createRuntimeUiBridge(ui);
   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 });
@@ -54,11 +51,18 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
   const resolvedSessionManager = resolveRunnerSessionManager(cwd, sessionManager);
   const sessionBinding = createSessionBinding(null);
   let currentModelCallKind = "model", currentTurnId = null, currentPromptForContext = "";
+  const midTurnRecallBridge = createMidTurnRecallBridge();
   const lifecycle = createRunnerLifecycle();
-  let currentTurnContextMode = "rebuild";
-  let nextTurnContextMode = "rebuild";
-  let lastNotificationResult = null, runtimeHost = null, lifecycleAdapter = null;
-  let _currentFastEntry = null;
+  let currentTurnContextMode = "rebuild", nextTurnContextMode = "rebuild";
+  let lastNotificationResult = null, runtimeHost = null, lifecycleAdapter = null, _currentFastEntry = null;
+  const providerPayloadTransform = createRunnerProviderPayloadTransform({
+    engine, sessionBinding, hostedTools,
+    getCurrentPrompt: () => currentPromptForContext,
+    getContextMode: () => currentTurnContextMode,
+    getFastEntry: () => _currentFastEntry,
+    waitForMidTurnRecall: () => midTurnRecallBridge.wait(),
+    getMidTurnRecallMessages: () => midTurnRecallBridge.messages(),
+  });
   if (useRuntimeHost) {
     runtimeHost = await createRunnerRuntimeHost({
       cwd, stateRoot, provider, modelId,
@@ -69,7 +73,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
       memoryTools, memoryStore, historyStore, shellRuntime, lspService, mcpTools, webTools,
       lifecycle, extensionPaths, hostedTools,
       onRebind: (session) => {
-        installModelPayloadDumper(session, modelContextDumper, () => currentModelCallKind, onLoggedModelPayload, injectMarchSystemContext);
+        installModelPayloadDumper(session, modelContextDumper, () => currentModelCallKind, onLoggedModelPayload, providerPayloadTransform.transform);
         syncEngineSessionState(engine, session);
       },
       createAgentSessionRuntimeImpl,
@@ -83,13 +87,18 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
       authStorage: resolvedAuth, projectMarchDir,
       getCurrentModel: () => sessionBinding.get()?.model ?? selectedModel,
     });
+    const resourceLoader = await createMarchPiResourceLoader({
+      cwd,
+      agentDir: stateRoot,
+      settingsManager,
+    });
     const { session } = await createAgentSessionImpl({
       cwd, agentDir: stateRoot, ...sessionOptions,
       authStorage: resolvedAuth, modelRegistry,
-      sessionManager: resolvedSessionManager, settingsManager,
+      sessionManager: resolvedSessionManager, settingsManager, resourceLoader,
     });
     sessionBinding.set(session);
-    installModelPayloadDumper(session, modelContextDumper, () => currentModelCallKind, onLoggedModelPayload, injectMarchSystemContext);
+    installModelPayloadDumper(session, modelContextDumper, () => currentModelCallKind, onLoggedModelPayload, providerPayloadTransform.transform);
   }
   syncEngineSessionState(engine, sessionBinding.get());
   lifecycleAdapter = createMarchLifecycleAdapter({
@@ -113,6 +122,8 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
       currentPromptForContext = prompt;
       const contextMode = nextTurnContextMode;
       currentTurnContextMode = contextMode;
+      providerPayloadTransform.resetTurn();
+      midTurnRecallBridge.reset();
       nextTurnContextMode = "rebuild";
       lifecycle.clearPendingAction();
       const turnStartedAt = Date.now();
@@ -129,6 +140,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
           autoNameSession,
           contextMode,
           recordHistory: (turn) => appendRunnerTurnHistory({ store: historyStore, turn, sessionStats: getRunnerSessionStats(sessionBinding.get(), runtimeHost), modelId: engine.modelId, provider: engine.provider }),
+          trackMidTurnRecallInjection: (injection) => midTurnRecallBridge.track(injection),
         });
         notifyTurnEndDetached(turnNotifier, {
           status: "success",
@@ -256,7 +268,6 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
       ]);
     },
   };
-  return runner;
   function syncCurrentMarchSessionState() {
     return syncMarchSessionState({
       enabled: syncPiSidecar || syncMarchSessionStateEnabled, projectMarchDir, engine,
@@ -285,14 +296,4 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
     });
     onModelPayload?.(event);
   }
-  function injectMarchSystemContext(payload, { kind, model } = {}) {
-    if (kind !== "user") return payload;
-    let nextPayload = currentTurnContextMode === "continueExistingPiTranscript"
-      ? payload
-      : replaceProviderContextMessages(payload, engine.buildProviderContext(currentPromptForContext));
-    nextPayload = injectHostedTools(nextPayload, model, hostedTools);
-    nextPayload = applyCodexLargeContextGuardToPayload(nextPayload, { model, session: sessionBinding.get() });
-    if (_currentFastEntry) nextPayload = { ...nextPayload, service_tier: "priority" };
-    return nextPayload;
-  }
 }

package/src/agent/runtime/remote-ui-client.mjs

@@ -13,7 +13,7 @@ export function createRemoteRuntimeUiClient(peer) {
     retryEnd: (event) => peer.notify("uiEvent", { type: "retry_end", ...event }),
     status: (text) => peer.notify("uiEvent", { type: "status", text }),
     debugLines: (lines) => peer.notify("uiEvent", { type: "debug_lines", lines }),
-    recall: ({ source, hints }) => peer.notify("uiEvent", { type: "recall", source, hints }),
+    recall: ({ hints, report, variant }) => peer.notify("uiEvent", { type: "recall", hints, report, variant }),
     editDiff: (path, diffLines) => peer.notify("uiEvent", { type: "edit_diff", path, diffLines }),
   };
 }

package/src/agent/runtime/resource/context-resource-loader.mjs

@@ -0,0 +1,17 @@
+import { DefaultResourceLoader } from "@earendil-works/pi-coding-agent";
+
+export const MARCH_PI_RESOURCE_LOADER_OPTIONS = Object.freeze({
+  noContextFiles: true,
+});
+
+export async function createMarchPiResourceLoader({ cwd, agentDir, settingsManager, extraOptions = {} }) {
+  const resourceLoader = new DefaultResourceLoader({
+    ...MARCH_PI_RESOURCE_LOADER_OPTIONS,
+    ...extraOptions,
+    cwd,
+    agentDir,
+    settingsManager,
+  });
+  await resourceLoader.reload();
+  return resourceLoader;
+}

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

@@ -2,6 +2,7 @@ import {
   createAgentSessionFromServices,
   createAgentSessionServices,
 } from "@earendil-works/pi-coding-agent";
+import { MARCH_PI_RESOURCE_LOADER_OPTIONS } from "./resource/context-resource-loader.mjs";
 
 export function createMarchRuntimeFactory({
   agentDir,
@@ -24,7 +25,10 @@ export function createMarchRuntimeFactory({
       authStorage,
       settingsManager,
       modelRegistry,
-      resourceLoaderOptions,
+      resourceLoaderOptions: {
+        ...MARCH_PI_RESOURCE_LOADER_OPTIONS,
+        ...resourceLoaderOptions,
+      },
     });
     const sessionOptions = await resolveSessionOptions({ cwd, services });
     const result = await createFromServices({

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

@@ -13,6 +13,7 @@ export function createRunnerStateSnapshot(runner) {
       remoteMemorySources: engine.remoteMemorySources ?? [],
       turns: engine.turns ?? [],
       pendingAssistantRecallHints: engine.peekPendingAssistantRecallHints?.() ?? engine.pendingAssistantRecallHints ?? [],
+      pendingAssistantRecallReport: engine.peekPendingAssistantRecallReport?.() ?? engine.pendingAssistantRecallReport ?? null,
       pendingAssistantRecallHintsRendered: engine.hasRenderedPendingAssistantRecallHints?.() ?? engine.pendingAssistantRecallHintsRendered ?? false,
       recentRecallMemoryIds: [...(engine.getRecentRecallMemoryIds?.() ?? [])],
     },
@@ -41,23 +42,29 @@ export function createRunnerEngineStateFacade({ getState, setState }) {
     peekPendingAssistantRecallHints() {
       return engineState(getState()).pendingAssistantRecallHints ?? [];
     },
+    peekPendingAssistantRecallReport() {
+      return engineState(getState()).pendingAssistantRecallReport ?? null;
+    },
     hasRenderedPendingAssistantRecallHints() {
       return Boolean(engineState(getState()).pendingAssistantRecallHintsRendered);
     },
     markPendingAssistantRecallHintsRendered() {
       updateEngineState(getState, setState, (engine) => {
-        if ((engine.pendingAssistantRecallHints ?? []).length > 0) {
+        if ((engine.pendingAssistantRecallHints ?? []).length > 0 || engine.pendingAssistantRecallReport) {
           engine.pendingAssistantRecallHintsRendered = true;
         }
       });
     },
     takePendingAssistantRecallHints() {
-      const hints = engineState(getState()).pendingAssistantRecallHints ?? [];
+      const state = engineState(getState());
+      const hints = state.pendingAssistantRecallHints ?? [];
+      const report = state.pendingAssistantRecallReport ?? null;
       updateEngineState(getState, setState, (engine) => {
         engine.pendingAssistantRecallHints = [];
+        engine.pendingAssistantRecallReport = null;
         engine.pendingAssistantRecallHintsRendered = false;
       });
-      return hints;
+      return { hints, report };
     },
     getRecentRecallMemoryIds() {
       return engineState(getState()).recentRecallMemoryIds ?? [];