march-cli 0.1.42 → 0.1.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "march-cli",
-  "version": "0.1.42",
+  "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/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-runner.mjs

@@ -23,11 +23,11 @@ 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");
@@ -57,12 +57,8 @@ export async function runRunnerTurn({
     }
     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);
     }
   });
 
@@ -90,11 +86,11 @@ export async function runRunnerTurn({
     }
 
     setPhase?.("finalizing");
-    finalizeTurn({
+    await Promise.allSettled(midTurnRecallTasks);
+    await finalizeTurn({
       prompt,
       userMessage,
       userRecallHints,
-      currentProject,
       memoryStore,
       engine,
       ui,
@@ -172,13 +168,13 @@ function throwIfAssistantEndedWithError(turnState) {
 }
 
 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) });
@@ -209,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]);
 
@@ -228,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);
     }

package/src/context/system-core/base.md

@@ -96,7 +96,7 @@ The user primarily asks for software engineering work: fixing bugs, adding behav
 </git_contract>
 
 <memory_system>
-- [recall source="..."] blocks in recent_chat are lightweight recall hints matched from prior thinking output. Treat them as possibly relevant pointers, not as complete facts.
+- [recall] blocks in recent_chat are lightweight memory hints matched by semantic recall. Treat them as possibly relevant pointers, not as complete facts.
 - A recall hint's description may record key operational constraints, including when the full memory must be opened; factor those constraints into relevance before acting.
 - If a recall hint may help the current task, use memory_open(id) to read the full memory before relying on it. Ignore hints that are clearly unrelated or too low-value for the task.
 - Use memory_search(query) for full-text search across all memories.

package/src/memory/markdown/markdown-format.mjs

@@ -32,24 +32,7 @@ export function normalizeTags(tags) {
   return out;
 }
 
-export function expandTags(tags) {
-  const terms = [];
-  for (const tag of tags) {
-    terms.push(tag);
-    for (const part of tag.split(/[\/_-]+/)) {
-      if (part) terms.push(part);
-    }
-  }
-  return [...new Set(terms.map(normalizeText).filter(Boolean))];
-}
 
-export function quoteFtsTerm(term) {
-  return `"${String(term).replace(/"/g, '""')}"`;
-}
-
-export function normalizeText(text) {
-  return String(text ?? "").trim().toLowerCase();
-}
 
 export function generateMemoryId() {
   return `mem_${randomUUID().replace(/-/g, "").slice(0, 16)}`;

package/src/memory/markdown/markdown-recall.mjs

@@ -1,28 +1,20 @@
-import { expandTags, normalizeText } from "./markdown-format.mjs";
-
-export function formatRecallHints(source, hints = []) {
+export function formatRecallHints(hints = []) {
   if (!hints.length) return "";
-  const lines = [`[recall source="${source}"]`];
+  const lines = ["[recall]"];
   for (const hint of hints) {
-    lines.push(`- ${hint.id} | ${hint.name} | ${hint.description}`);
+    lines.push(`- ${hint.id}${formatScoreForPrompt(hint.score)} | ${hint.name} | ${hint.description}`);
   }
   return lines.join("\n");
 }
 
-export function scoreEntry(entry, terms, currentProject) {
-  const expanded = expandTags(entry.tags);
-  let score = 0;
-  for (const term of terms) {
-    if (entry.tags.map(normalizeText).includes(term)) score += 10;
-    else if (expanded.includes(term)) score += 5;
-  }
-  if (currentProject) {
-    const projectTag = normalizeText(`project/${currentProject}`);
-    if (entry.tags.map(normalizeText).includes(projectTag)) score += 2;
-  }
-  return score;
+export function toHint(entry, metadata = {}) {
+  return { id: entry.id, name: entry.name, description: entry.description, ...metadata };
+}
+
+function formatScoreForPrompt(score) {
+  return Number.isFinite(score) ? ` | score=${formatScore(score)}` : "";
 }
 
-export function toHint(entry) {
-  return { id: entry.id, name: entry.name, description: entry.description };
+export function formatScore(score) {
+  return Number.isFinite(score) ? score.toFixed(2) : "--";
 }

package/src/memory/markdown/semantic-preload.mjs

@@ -0,0 +1,17 @@
+export async function preloadSemanticMemoryRecall({ memoryStore, ui = null, logger = null } = {}) {
+  if (!memoryStore?.semanticRecall?.enabled) return { ok: true, skipped: true };
+  try {
+    ui?.status?.("Preparing memory recall model...");
+    await memoryStore.semanticRecall.preload();
+    memoryStore.semanticRecallWarning = memoryStore.semanticRecall.warning;
+    if (memoryStore.semanticRecallWarning) ui?.writeln?.(`Memory recall fallback: ${memoryStore.semanticRecallWarning}`);
+    logger?.event?.("memory.semantic_model_ready", { modelId: memoryStore.semanticRecall.modelId, status: memoryStore.semanticRecall.status });
+    return { ok: true, skipped: false, fallback: memoryStore.semanticRecall.status === "fallback" };
+  } catch (err) {
+    const message = err?.message ?? String(err);
+    memoryStore.semanticRecallWarning = message;
+    logger?.error?.("memory.semantic_model_preload_failed", { error: message });
+    ui?.writeln?.(`Memory recall model preload failed: ${message}`);
+    return { ok: false, error: message };
+  }
+}