march-cli 0.1.45 → 0.1.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "march-cli",
-  "version": "0.1.45",
+  "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,12 +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({
@@ -25,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;
@@ -39,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);
@@ -49,7 +52,7 @@ 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);
@@ -59,13 +62,18 @@ export class CodeSearchIndexCache {
 
     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, ...describeVectorizer(this.vectorizer) };
   }
 
+  indexSignature(files, { includeVector }) {
+    const vectorKey = includeVector ? this.vectorizer.id : "lexical";
+    return [vectorKey, ...files.map(fileSignature)].join("\n");
+  }
+
   clear() {
     this.fileChunks.clear();
     this.indices.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";

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/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, report }) => peer.notify("uiEvent", { type: "recall", source, hints, report }),
+    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 ?? [];

package/src/agent/runtime/ui-event-bridge.mjs

@@ -50,7 +50,7 @@ export function createRuntimeUiClient(eventBus) {
     retryEnd: (event) => eventBus.emit({ type: "retry_end", ...event }),
     status: (text) => eventBus.emit({ type: "status", text }),
     debugLines: (lines) => eventBus.emit({ type: "debug_lines", lines }),
-    recall: ({ source, hints, report }) => eventBus.emit({ type: "recall", source, hints, report }),
+    recall: ({ hints, report, variant }) => eventBus.emit({ type: "recall", hints, report, variant }),
     providerQuotaSnapshot: (snapshot) => eventBus.emit({ type: "provider_quota_snapshot", snapshot }),
     editDiff: (path, diffLines) => eventBus.emit({ type: "edit_diff", path, diffLines }),
   };
@@ -71,7 +71,7 @@ export function dispatchRuntimeUiEvent(ui, event) {
     case "retry_end": return ui.retryEnd?.(pickRetryEnd(event));
     case "status": return ui.status?.(event.text);
     case "debug_lines": return writeDebugLines(ui, event.lines);
-    case "recall": return ui.recall?.({ hints: event.hints, report: event.report });
+    case "recall": return ui.recall?.({ hints: event.hints, report: event.report, variant: event.variant });
     case "provider_quota_snapshot": return ui.providerQuotaSnapshot?.(event.snapshot);
     case "edit_diff": return ui.editDiff?.(event.path, event.diffLines);
     default: return undefined;

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

@@ -20,6 +20,7 @@ export async function runRunnerTurn({
   autoNameSession,
   contextMode = "rebuild",
   recordHistory = null,
+  trackMidTurnRecallInjection = null,
 }) {
   const {
     userRecallHints = [],
@@ -57,7 +58,8 @@ export async function runRunnerTurn({
     }
     handleRunnerSessionEvent(event, { ui, engine, state: turnState });
     if (event.type === "tool_execution_start") {
-      const task = flushMidTurnAssistantRecall({ memoryStore, engine, turnState, activeSession, ui, logger, midTurnRecallHints });
+      const task = flushMidTurnAssistantRecall({ memoryStore, engine, turnState, activeSession, ui, logger, midTurnRecallHints, trackMidTurnRecallInjection });
+      trackMidTurnRecallInjection?.({ task });
       midTurnRecallTasks.push(task);
     }
   });
@@ -169,16 +171,16 @@ function throwIfAssistantEndedWithError(turnState) {
 
 function queueMidTurnRecallHints(session, hints, logger) {
   const content = formatRecallHints(hints);
-  if (!content) return;
-  const injected = session.sendCustomMessage?.({
+  if (!content) return null;
+  const task = Promise.resolve(session.sendCustomMessage?.({
     customType: "march.recall",
     content,
     display: false,
     details: { type: "recall" },
-  }, { deliverAs: "steer" });
-  void injected?.catch?.((err) => {
+  }, { deliverAs: "steer" })).catch((err) => {
     logger?.debug("memory.mid_turn_recall.inject_failed", { errorMessage: err?.message ?? String(err) });
   });
+  return { content, task };
 }
 
 function logSessionEvent(logger, event) {
@@ -207,9 +209,9 @@ function logSessionEvent(logger, event) {
 
 async function finalizeTurn({ prompt, userMessage, userRecallHints, memoryStore, engine, ui, turnState, midTurnRecallHints, syncCurrentMarchSessionState, autoNameSession, recordHistory }) {
   closeAssistantReply({ ui, state: turnState });
-  const assistantRecallHints = await flushAssistantRecall({ memoryStore, engine, turnState });
-  engine.setPendingAssistantRecallHints?.(assistantRecallHints);
-  const recordedAssistantRecallHints = uniqueHints([...midTurnRecallHints, ...assistantRecallHints]);
+  const assistantRecall = await flushAssistantRecall({ memoryStore, engine, turnState });
+  engine.setPendingAssistantRecallHints?.(assistantRecall.hints, assistantRecall.report);
+  const recordedAssistantRecallHints = uniqueHints([...midTurnRecallHints, ...assistantRecall.hints]);
 
   const turn = engine.recordTurn({
     userMessage: userMessage ?? prompt.slice(0, 300),
@@ -225,22 +227,24 @@ async function finalizeTurn({ prompt, userMessage, userRecallHints, memoryStore,
 }
 
 async function flushAssistantRecall({ memoryStore, engine, turnState }) {
-  if (!memoryStore) return [];
+  if (!memoryStore) return { hints: [], report: null };
   const text = assistantRecallDeltaText(turnState);
   advanceAssistantRecallCursor(turnState);
-  if (!text.trim()) return [];
+  if (!text.trim()) return { hints: [], report: null };
   return await memoryStore.recallForAssistant(text, {
     excludedIds: engine.getRecentRecallMemoryIds?.() ?? [],
   });
 }
 
-async function flushMidTurnAssistantRecall({ memoryStore, engine, turnState, activeSession, ui, logger, midTurnRecallHints }) {
+async function flushMidTurnAssistantRecall({ memoryStore, engine, turnState, activeSession, ui, logger, midTurnRecallHints, trackMidTurnRecallInjection }) {
   try {
-    const hints = await flushAssistantRecall({ memoryStore, engine, turnState });
-    if (hints.length === 0) return;
-    midTurnRecallHints.push(...hints);
-    queueMidTurnRecallHints(activeSession, hints, logger);
-    ui.recall?.({ hints });
+    const { hints, report } = await flushAssistantRecall({ memoryStore, engine, turnState });
+    if (hints.length > 0) {
+      midTurnRecallHints.push(...hints);
+      const injection = queueMidTurnRecallHints(activeSession, hints, logger);
+      if (injection) trackMidTurnRecallInjection?.(injection);
+    }
+    if (report) ui.recall?.({ hints, report, variant: "assistant" });
   } catch (err) {
     logger?.debug("memory.mid_turn_recall.failed", { errorMessage: err?.message ?? String(err) });
   }

package/src/cli/fallback-ui.mjs

@@ -109,9 +109,9 @@ export function createPlainUI() {
     },
     textDelta: writeText,
     status: (text) => { ensureNewline(); stdout.write(`${brightBlack(`● ${text}`)}\n`); },
-    recall: ({ hints, report }) => {
+    recall: ({ hints, report, variant }) => {
       ensureNewline();
-      for (const line of formatRecallLines(hints, report)) stdout.write(`${brightBlack(line)}\n`);
+      for (const line of formatRecallLines(hints, report, { variant })) stdout.write(`${brightBlack(line)}\n`);
     },
     clearOutput: () => {},
     restoreTranscript: () => {},