march-cli 0.1.41 → 0.1.45

package/package.json

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

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

@@ -2,6 +2,7 @@ import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { chunkFile } from "./chunker.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;
@@ -53,7 +54,7 @@ export class CodeSearchIndexCache {
     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 = {
@@ -62,7 +63,7 @@ export class CodeSearchIndexCache {
     };
     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) };
   }
 
   clear() {

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

@@ -79,6 +79,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/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/runner.mjs

@@ -18,7 +18,7 @@ import { resolveRunnerSessionOptions } from "./session/session-options.mjs";
 import { createSessionBinding } from "./session/session-binding.mjs";
 import { maybeAutoNameSession } from "./session/session-auto-name.mjs";
 import { MARCH_BASE_TOOL_NAMES } from "./tool-names.mjs";
-import { runRunnerTurn } from "./turn/turn-runner.mjs";
+import { MODEL_STREAM_IDLE_TIMEOUT_CODE, runRunnerTurn } from "./turn/turn-runner.mjs";
 import { beginLoggedTurn } from "./turn/turn-logging.mjs";
 import { appendFastVariants, createFastModelEntry, fromFastEntryModel, isFastProvider } from "./runner/fast-model.mjs";
 import { registerSuperGrokProvider } from "../supergrok/provider.mjs";
@@ -142,6 +142,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
         turnLog.endSuccess(result);
         return result;
       } catch (err) {
+        if (err?.code === MODEL_STREAM_IDLE_TIMEOUT_CODE) nextTurnContextMode = "continueExistingPiTranscript";
         notifyTurnEndDetached(turnNotifier, {
           status: "error",
           sessionName: engine.sessionName,

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: ({ source, hints, report }) => peer.notify("uiEvent", { type: "recall", source, hints, report }),
     editDiff: (path, diffLines) => peer.notify("uiEvent", { type: "edit_diff", path, diffLines }),
   };
 }

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 }) => eventBus.emit({ type: "recall", source, hints }),
+    recall: ({ source, hints, report }) => eventBus.emit({ type: "recall", source, hints, report }),
     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?.({ source: event.source, hints: event.hints });
+    case "recall": return ui.recall?.({ hints: event.hints, report: event.report });
     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-events.mjs

@@ -12,6 +12,8 @@ export function createTurnEventState() {
     assistantContextParts: [],
     activeToolContextPart: null,
     toolCalls: [],
+    lastAssistantStopReason: null,
+    lastAssistantErrorMessage: null,
   };
 }
 
@@ -19,6 +21,10 @@ export function handleRunnerSessionEvent(event, { ui, engine, state }) {
   if (event.type === "message_update" && event.assistantMessageEvent) {
     handleAssistantMessageEvent(event.assistantMessageEvent, { ui, state });
   }
+  if (event.type === "message_end" && event.message?.role === "assistant") {
+    state.lastAssistantStopReason = event.message.stopReason ?? null;
+    state.lastAssistantErrorMessage = event.message.errorMessage ?? null;
+  }
   if (event.type === "tool_execution_start") {
     closeAssistantReply({ ui, state });
     appendToolStartContext(state, event.toolName, event.args);

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

@@ -2,6 +2,8 @@ import { formatRecallHints } from "../../memory/markdown-store.mjs";
 import { resolveImageAttachmentReferences } from "../../session/attachment-references.mjs";
 import { closeAssistantReply, compactAssistantContext, createTurnEventState, handleRunnerSessionEvent } from "./turn-events.mjs";
 
+export const MODEL_STREAM_IDLE_TIMEOUT_CODE = "MODEL_STREAM_IDLE_TIMEOUT";
+
 export async function runRunnerTurn({
   prompt,
   userMessage,
@@ -21,30 +23,42 @@ export async function runRunnerTurn({
 }) {
   const {
     userRecallHints = [],
-    currentProject = "",
   } = options;
   const activeSession = sessionBinding.get();
   const turnState = createTurnEventState();
   const midTurnRecallHints = [];
+  const midTurnRecallTasks = [];
+  const idleWatchdog = createModelStreamIdleWatchdog({ session: activeSession, logger, setPhase });
   ui.turnStart();
   setPhase?.("subscribed");
   logger?.event("turn.ui.start");
 
   const unsubscribe = activeSession.subscribe((event) => {
     logSessionEvent(logger, event);
-    if (event.type === "tool_execution_start") setPhase?.(`tool_running:${event.toolName ?? "unknown"}`);
-    if (event.type === "tool_execution_end") setPhase?.("model_streaming");
-    if (event.type === "auto_retry_start") setPhase?.("retry_wait");
-    if (event.type === "auto_retry_end") setPhase?.("model_streaming");
-    if (event.type === "message_update") setPhase?.("model_streaming");
+    if (event.type === "tool_execution_start") {
+      idleWatchdog.pause();
+      setPhase?.(`tool_running:${event.toolName ?? "unknown"}`);
+    }
+    if (event.type === "tool_execution_end") {
+      setPhase?.("model_streaming");
+      idleWatchdog.arm("tool_execution_end");
+    }
+    if (event.type === "auto_retry_start") {
+      idleWatchdog.pause();
+      setPhase?.("retry_wait");
+    }
+    if (event.type === "auto_retry_end") {
+      setPhase?.("model_streaming");
+      idleWatchdog.arm("auto_retry_end");
+    }
+    if (event.type === "message_update") {
+      setPhase?.("model_streaming");
+      idleWatchdog.arm("message_update");
+    }
     handleRunnerSessionEvent(event, { ui, engine, state: turnState });
     if (event.type === "tool_execution_start") {
-      const hints = flushAssistantRecall({ memoryStore, engine, turnState, currentProject });
-      if (hints.length > 0) {
-        midTurnRecallHints.push(...hints);
-        queueMidTurnRecallHints(activeSession, hints, logger);
-        ui.recall?.({ source: "assistant", hints });
-      }
+      const task = flushMidTurnAssistantRecall({ memoryStore, engine, turnState, activeSession, ui, logger, midTurnRecallHints });
+      midTurnRecallTasks.push(task);
     }
   });
 
@@ -59,21 +73,24 @@ export async function runRunnerTurn({
     logger?.event("model.prompt.start", { contextMode });
     try {
       if (contextMode === "rebuild") resetPiMessageHistory(activeSession);
-      await activeSession.prompt(
+      idleWatchdog.arm("model_request");
+      await idleWatchdog.watch(activeSession.prompt(
         contextMode === "continueExistingPiTranscript" ? (userMessage ?? prompt) : prompt,
         attachmentReferences.images.length > 0 ? { images: attachmentReferences.images } : undefined,
-      );
+      ));
+      throwIfAssistantEndedWithError(turnState);
     } finally {
+      idleWatchdog.clear();
       setModelCallKind("model");
       logger?.event("model.prompt.end");
     }
 
     setPhase?.("finalizing");
-    finalizeTurn({
+    await Promise.allSettled(midTurnRecallTasks);
+    await finalizeTurn({
       prompt,
       userMessage,
       userRecallHints,
-      currentProject,
       memoryStore,
       engine,
       ui,
@@ -86,19 +103,78 @@ export async function runRunnerTurn({
     return { draft: turnState.draft };
   } finally {
     logger?.event("turn.ui.end");
+    idleWatchdog.clear();
     ui.turnEnd();
     unsubscribe();
   }
 }
 
+function createModelStreamIdleWatchdog({ session, logger, setPhase }) {
+  const timeoutMs = getModelStreamIdleTimeoutMs();
+  let timer = null;
+  let timedOut = false;
+  let rejectIdle = null;
+  const idlePromise = new Promise((_, reject) => {
+    rejectIdle = reject;
+  });
+
+  return {
+    arm(reason) {
+      if (timeoutMs <= 0 || timedOut) return;
+      clearTimer();
+      timer = setTimeout(() => {
+        timedOut = true;
+        setPhase?.("model_idle_timeout");
+        logger?.event("model.stream.idle_timeout", { timeoutMs, reason });
+        try { session.abortRetry?.(); } catch {}
+        try { session.abort?.(); } catch {}
+        rejectIdle(createModelStreamIdleTimeoutError(timeoutMs, reason));
+      }, timeoutMs);
+    },
+    pause: clearTimer,
+    clear: clearTimer,
+    async watch(promise) {
+      const guarded = Promise.resolve(promise);
+      guarded.catch(() => {});
+      return await Promise.race([guarded, idlePromise]);
+    },
+  };
+
+  function clearTimer() {
+    if (!timer) return;
+    clearTimeout(timer);
+    timer = null;
+  }
+}
+
+function createModelStreamIdleTimeoutError(timeoutMs, reason) {
+  const error = new Error(`Model stream idle timeout after ${timeoutMs}ms (${reason}); aborted the current turn`);
+  error.code = MODEL_STREAM_IDLE_TIMEOUT_CODE;
+  return error;
+}
+
+function getModelStreamIdleTimeoutMs() {
+  const raw = process.env.MARCH_MODEL_STREAM_IDLE_TIMEOUT_MS;
+  if (raw === "0" || raw === "false" || raw === "no") return 0;
+  const parsed = raw ? Number.parseInt(raw, 10) : 18000;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 18000;
+}
+
+function throwIfAssistantEndedWithError(turnState) {
+  if (turnState.lastAssistantStopReason !== "error") return;
+  const error = new Error(turnState.lastAssistantErrorMessage || "Model provider returned an error");
+  error.code = "MODEL_PROVIDER_ERROR";
+  throw error;
+}
+
 function queueMidTurnRecallHints(session, hints, logger) {
-  const content = formatRecallHints("assistant", hints);
+  const content = formatRecallHints(hints);
   if (!content) return;
   const injected = session.sendCustomMessage?.({
     customType: "march.recall",
     content,
     display: false,
-    details: { source: "assistant" },
+    details: { type: "recall" },
   }, { deliverAs: "steer" });
   void injected?.catch?.((err) => {
     logger?.debug("memory.mid_turn_recall.inject_failed", { errorMessage: err?.message ?? String(err) });
@@ -129,9 +205,9 @@ function logSessionEvent(logger, event) {
   });
 }
 
-function finalizeTurn({ prompt, userMessage, userRecallHints, currentProject, memoryStore, engine, ui, turnState, midTurnRecallHints, syncCurrentMarchSessionState, autoNameSession, recordHistory }) {
+async function finalizeTurn({ prompt, userMessage, userRecallHints, memoryStore, engine, ui, turnState, midTurnRecallHints, syncCurrentMarchSessionState, autoNameSession, recordHistory }) {
   closeAssistantReply({ ui, state: turnState });
-  const assistantRecallHints = flushAssistantRecall({ memoryStore, engine, turnState, currentProject });
+  const assistantRecallHints = await flushAssistantRecall({ memoryStore, engine, turnState });
   engine.setPendingAssistantRecallHints?.(assistantRecallHints);
   const recordedAssistantRecallHints = uniqueHints([...midTurnRecallHints, ...assistantRecallHints]);
 
@@ -148,17 +224,28 @@ function finalizeTurn({ prompt, userMessage, userRecallHints, currentProject, me
   syncCurrentMarchSessionState();
 }
 
-function flushAssistantRecall({ memoryStore, engine, turnState, currentProject }) {
+async function flushAssistantRecall({ memoryStore, engine, turnState }) {
   if (!memoryStore) return [];
   const text = assistantRecallDeltaText(turnState);
   advanceAssistantRecallCursor(turnState);
   if (!text.trim()) return [];
-  return memoryStore.recallForAssistant(text, {
-    currentProject,
+  return await memoryStore.recallForAssistant(text, {
     excludedIds: engine.getRecentRecallMemoryIds?.() ?? [],
   });
 }
 
+async function flushMidTurnAssistantRecall({ memoryStore, engine, turnState, activeSession, ui, logger, midTurnRecallHints }) {
+  try {
+    const hints = await flushAssistantRecall({ memoryStore, engine, turnState });
+    if (hints.length === 0) return;
+    midTurnRecallHints.push(...hints);
+    queueMidTurnRecallHints(activeSession, hints, logger);
+    ui.recall?.({ hints });
+  } catch (err) {
+    logger?.debug("memory.mid_turn_recall.failed", { errorMessage: err?.message ?? String(err) });
+  }
+}
+
 function assistantRecallDeltaText(turnState) {
   const cursor = turnState.recallCursor ?? { draftLength: 0, thinkingLength: 0 };
   const thinking = assistantThinkingText(turnState);

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 }) => {
+    recall: ({ hints, report }) => {
       ensureNewline();
-      for (const line of formatRecallLines(hints)) stdout.write(`${brightBlack(line)}\n`);
+      for (const line of formatRecallLines(hints, report)) stdout.write(`${brightBlack(line)}\n`);
     },
     clearOutput: () => {},
     restoreTranscript: () => {},

package/src/cli/repl-loop.mjs

@@ -16,10 +16,10 @@ export async function runSingleShotPrompt({
 }) {
   memoryStore.beginTurn();
   try {
-    const turnInput = prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState });
+    const turnInput = await 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 });
+    ui.recall?.({ hints: turnInput.userRecallHints, report: turnInput.userRecallReport });
+    if (turnInput.shouldRenderCarryoverRecall) ui.recall?.({ hints: turnInput.carryoverRecallHints });
     refreshStatusBar.startWorking?.();
     const result = await runner.runTurn(turnInput.fullPrompt, turnInput.userMessage, turnInput.runOptions);
     renderPendingAssistantRecallPreview({ runner, ui });
@@ -185,10 +185,10 @@ function startReplTurn({ runtime, prompt, ui, refreshStatusBar, setTurnRunning,
 async function runReplTurn({ prompt, runner, memoryStore, currentProject, ui, refreshStatusBar, setTurnRunning, modeState = null }) {
   memoryStore.beginTurn();
   try {
-    const turnInput = prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState });
+    const turnInput = await 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 });
+    ui.recall?.({ hints: turnInput.userRecallHints, report: turnInput.userRecallReport });
+    if (turnInput.shouldRenderCarryoverRecall) ui.recall?.({ hints: turnInput.carryoverRecallHints });
     setTurnRunning(true);
     refreshStatusBar.startWorking?.();
     const result = await runner.runTurn(turnInput.fullPrompt, turnInput.userMessage, turnInput.runOptions);
@@ -216,6 +216,6 @@ function renderPendingAssistantRecallPreview({ runner, ui }) {
   if (runner.engine.hasRenderedPendingAssistantRecallHints?.()) return;
   const hints = runner.engine.peekPendingAssistantRecallHints?.() ?? [];
   if (hints.length === 0) return;
-  ui.recall?.({ source: "assistant", hints });
+  ui.recall?.({ hints });
   runner.engine.markPendingAssistantRecallHintsRendered?.();
 }

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

@@ -11,6 +11,7 @@ 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 { preloadSemanticMemoryRecall } from "../../memory/markdown/semantic-preload.mjs";
 import { discoverProjectExtensionPaths } from "../../extensions/discovery.mjs";
 import { loadProjectLifecycleHookManifests } from "../../extensions/lifecycle-manifest.mjs";
 import { loadOrCreateProjectId, resumeStartupSession } from "./startup-session.mjs";
@@ -68,7 +69,7 @@ export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot }
   const memoryRoot = resolveMemoryRoot(config.memoryRoot, stateRoot);
   const profilePaths = defaultProfilePaths();
   ensureProfileFiles(profilePaths);
-  const memoryStore = new MarkdownMemoryStore({ root: memoryRoot });
+  const memoryStore = new MarkdownMemoryStore({ root: memoryRoot, stateRoot });
   const remoteMemorySources = normalizeRemoteMemorySources(config);
   const currentProject = basename(cwd);
   const shellRuntime = args.shellRuntime ? createCliShellRuntime({ cwd }) : null;
@@ -90,6 +91,8 @@ export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot }
     shellRuntime,
     historyStore: inputHistoryStore,
   });
+  await preloadSemanticMemoryRecall({ memoryStore, ui, logger });
+
   const outputRouter = createWorkspaceOutputRouter({
     ui,
     activeProjectId: currentProjectInfo.projectId,
@@ -166,7 +169,7 @@ export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot }
         stateRoot,
         memoryRoot,
         profilePaths,
-        createMemoryStore: () => new MarkdownMemoryStore({ root: memoryRoot }),
+        createMemoryStore: () => new MarkdownMemoryStore({ root: memoryRoot, stateRoot }),
         provider,
         serviceTier,
         model,

package/src/cli/tui/output/timeline-block-restore.mjs

@@ -30,7 +30,7 @@ function appendTimelineBlock(output, block) {
       output.addBlock({ type: "status", lines: [String(block.content ?? "")] });
       break;
     case "recall":
-      output.addBlock({ type: "plain", lines: formatRecallLines(block.hints ?? []) });
+      output.addBlock({ type: "plain", lines: formatRecallLines(block.hints ?? [], block.report ?? null) });
       break;
     case "editDiff":
       output.addBlock({ type: "diff", path: block.path, diffLines: block.diffLines ?? [] });

package/src/cli/tui/recall-rendering.mjs

@@ -1,18 +1,23 @@
+import { formatScore } from "../../memory/markdown/markdown-recall.mjs";
 import { brightBlack } from "./ui-theme.mjs";
 
 const RECALL_ICON = "✦";
 
-export function formatRecallLines(hints = []) {
-  if (!hints.length) return [];
+export function formatRecallLines(hints = [], report = null) {
+  const candidates = report?.candidates ?? [];
+  if (!hints.length && !candidates.length) return [];
   const noun = hints.length === 1 ? "note" : "notes";
+  const threshold = Number.isFinite(report?.threshold) ? ` · threshold ${formatScore(report.threshold)}` : "";
+  const fallback = report?.vectorizerStatus === "fallback" ? " · fallback" : "";
   return [
-    `${RECALL_ICON} Memory Recall · ${hints.length} ${noun}`,
-    ...hints.flatMap(formatHintLines),
+    `${RECALL_ICON} Memory Recall · ${hints.length} ${noun}${threshold}${fallback}`,
+    ...(report?.warning ? [`    ! ${report.warning}`] : []),
+    ...(candidates.length ? candidates : hints.map((hint) => ({ ...hint, recalled: true }))).flatMap(formatHintLines),
   ];
 }
 
-export function writeRecall({ output, hints = [] }) {
-  const lines = formatRecallLines(hints);
+export function writeRecall({ output, hints = [], report = null }) {
+  const lines = formatRecallLines(hints, report);
   lines.forEach((line) => {
     if (line.startsWith("    ")) output.writeln(brightBlack(line));
     else output.writeln(line);
@@ -21,7 +26,9 @@ export function writeRecall({ output, hints = [] }) {
 
 function formatHintLines(hint) {
   const title = hint.name || hint.id || "Untitled memory";
-  const lines = [`  • ${title}`];
+  const mark = hint.recalled === false ? "×" : "✓";
+  const score = `${formatScore(hint.score)} `;
+  const lines = [`  ${mark} ${score}${title}`];
   if (hint.description) lines.push(`    ${hint.description}`);
   return lines;
 }

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

@@ -4,19 +4,20 @@ import { formatRecallHints } from "../../memory/markdown-store.mjs";
 import { formatMessageAttachmentsForDisplay } from "../../session/attachment-display.mjs";
 import { formatShellHints } from "../../shell/hints.mjs";
 
-export function prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState = null }) {
+export async function prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState = null }) {
   const engine = runner.engine ?? {};
   const carryoverAlreadyRendered = engine.hasRenderedPendingAssistantRecallHints?.() ?? false;
   const carryoverRecallHints = engine.takePendingAssistantRecallHints?.() ?? [];
-  const userRecallHints = memoryStore.recallForUser(prompt, {
+  const userRecallHints = await memoryStore.recallForUser(prompt, {
     currentProject,
     excludedIds: engine.getRecentRecallMemoryIds?.() ?? [],
   });
+  const userRecallReport = memoryStore.lastUserRecallReport ?? null;
   const modePrompt = appendModeReminder(prompt, modeState?.get?.());
   const fullPrompt = appendPromptBlocks(
     modePrompt,
-    formatRecallHints("user", userRecallHints),
-    formatRecallHints("assistant", carryoverRecallHints),
+    formatRecallHints(userRecallHints),
+    formatRecallHints(carryoverRecallHints),
     formatShellHints(runner.shellRuntime),
   );
 
@@ -26,6 +27,7 @@ export function prepareTurnInput({ prompt, runner, memoryStore, currentProject,
     runOptions: { userRecallHints, currentProject },
     displayMessage: formatUserDisplayMessage(prompt),
     userRecallHints,
+    userRecallReport,
     carryoverRecallHints,
     shouldRenderCarryoverRecall: carryoverRecallHints.length > 0 && !carryoverAlreadyRendered,
   };

package/src/cli/ui.mjs

@@ -212,8 +212,8 @@ export function createTuiUI({
     status: (text) => {
       ensureStarted(); flushStreamDeltas(); retryStatus.stop(); spinnerStatus.stop(); output.setOverlayStatus([brightBlack(`● ${text}`)]); requestRender();
     },
-    recall: ({ hints }) => {
-      ensureStarted(); flushStreamDeltas(); retryStatus.stop(); spinnerStatus.stop(); output.ensureNewline(); writeRecall({ output, hints }); requestRender();
+    recall: ({ hints, report }) => {
+      ensureStarted(); flushStreamDeltas(); retryStatus.stop(); spinnerStatus.stop(); output.ensureNewline(); writeRecall({ output, hints, report }); requestRender();
     },
 
     clearOutput: () => {

package/src/cli/workspace/tui-timeline-projection.mjs

@@ -94,7 +94,7 @@ export function createTuiTimelineProjection() {
         blocks.push(createBlock("status", event.at, { content: String(first ?? "") }));
         break;
       case "recall":
-        blocks.push(createBlock("recall", event.at, { hints: first?.hints ?? [] }));
+        blocks.push(createBlock("recall", event.at, { hints: first?.hints ?? [], report: first?.report ?? null }));
         break;
       case "editDiff":
         closeAssistantBlock(event.at);

package/src/context/engine.mjs

@@ -168,14 +168,14 @@ export class ContextEngine {
     for (const turn of this.turns) {
       let block = `## Turn ${turn.index}\n` +
         `[user]\n${String(turn.userMessage ?? "")}\n`;
-      const userRecall = formatRecallHints("user", turn.userRecallHints ?? []);
+      const userRecall = formatRecallHints(turn.userRecallHints ?? []);
       if (userRecall) block += `\n${userRecall}\n`;
       block += `\n[assistant]\n`;
       const assistantText = turn.assistantContext || turn.assistantMessage;
       if (assistantText) {
         block += `\n${String(assistantText ?? "")}\n`;
       }
-      const assistantRecall = formatRecallHints("assistant", turn.assistantRecallHints ?? []);
+      const assistantRecall = formatRecallHints(turn.assistantRecallHints ?? []);
       if (assistantRecall) block += `\n${assistantRecall}\n`;
       entries.push(block);
     }