@cortexkit/pi-magic-context 0.48.0 → 0.49.0

package/dist/{index-pvm4pd5d.js → index-hwqb3s7f.js}

@@ -9,9 +9,11 @@ import {
   CATEGORY_DEFAULT_TTL
 } from "./index-135e8hvg.js";
 import {
+  getDataDir,
+  sanitizeDiagnosticText,
   log2,
   sessionLog2
-} from "./index-f956htf3.js";
+} from "./index-x3dcnxh0.js";
 import {
   resolveWorkspaceShareCategories,
   resolveWorkspaceIdentitySet,
@@ -19,13 +21,17 @@ import {
   resolveStoredPathWorkspaceIdentity,
   sourceNameForMemory,
   managedAuthorityNoteRow
-} from "./index-72bdc1bd.js";
+} from "./index-3mgf68pn.js";
 import {
   isKnownAutocommit
-} from "./index-8y5knskr.js";
+} from "./index-mcgehvgw.js";
 import {
+  SubcClient
+} from "./index-21v1kfs7.js";
+import {
+  buildCanonicalChunkTextFromFts,
   loadCompartmentChunkEmbeddingsForSearch
-} from "./index-fm3ksh5e.js";
+} from "./index-bejpsj10.js";
 import {
   recordEmbeddingMeasurement,
   saveCommitEmbedding,
@@ -43,7 +49,7 @@ import {
   getProjectEmbeddingSnapshot2,
   embedTextForProject2,
   embedItemsForProject2
-} from "./index-544c0e0x.js";
+} from "./index-yarjn32j.js";
 import {
   saveEmbeddingIfHashMatches,
   getProjectEmbeddings2
@@ -53,7 +59,7 @@ import {
   isEmbeddingEnabled,
   embedText,
   ensureMemoryEmbeddings2
-} from "./index-0am8a7k1.js";
+} from "./index-904reqtg.js";
 import {
   getMemorySelectColumns2,
   isMemoryRow2,
@@ -70,7 +76,7 @@ import {
 } from "./index-xjqheg7a.js";
 import {
   getIndexedMessageCorpusSize
-} from "./index-5jp1h0bz.js";
+} from "./index-yzcjxnt2.js";
 import {
   computeNormalizedHash
 } from "./index-9x1f96r8.js";
@@ -591,6 +597,351 @@ function updatePrimerSupport(db, input) {
 function updatePrimerAnswer(db, primerId, answer, refreshedAt = Date.now()) {
   db.prepare("UPDATE primers SET answer = ?, answer_refreshed_at = ?, updated_at = ? WHERE id = ?").run(answer, refreshedAt, refreshedAt, primerId);
 }
+
+// ../plugin/src/shared/user-facing-codes.ts
+var USER_FACING_FAILURES = {
+  historian_unavailable: {
+    code: "MC-H01",
+    sentence: "History compression could not finish this turn.",
+    action: "It will retry automatically."
+  },
+  historian_saved_history_misaligned: {
+    code: "MC-H03",
+    sentence: "History compression is paused because this session's saved summaries no longer line up with its messages.",
+    action: "Run /ctx-recomp to rebuild them."
+  },
+  history_boundary_unresolved: {
+    code: "MC-H04",
+    sentence: "This request was not sent: the message that marks where this session's history summary ends is missing from the OpenCode store, and without it the request is larger than the model's context window.",
+    action: "Run /ctx-recomp to rebuild the history summary."
+  },
+  history_over_window_unmanaged: {
+    code: "MC-H06",
+    sentence: "This request was not sent: this session's history is larger than the model's context window, and Magic Context does not have a summary of it yet to send in its place.",
+    action: "Send your message again once history compression has caught up, or switch to a model with a larger context window."
+  },
+  frozen_history_over_window: {
+    code: "MC-H07",
+    sentence: "This request was not sent: the conversation is larger than the context window the provider reported, and the compressed history Magic Context has ready does not fit either.",
+    action: "Run /ctx-flush to compress it now, then send your message again."
+  },
+  historian_window_too_small: {
+    code: "MC-H05",
+    sentence: "History compression is paused because the history model's context window is too small for its instructions.",
+    action: "Set historian.model in magic-context.jsonc to a model with a larger context window."
+  },
+  recomp_unavailable: {
+    code: "MC-R01",
+    sentence: "History compression could not be rebuilt.",
+    action: "Run /ctx-recomp again."
+  },
+  dream_provider_timeout: {
+    code: "MC-D01",
+    sentence: "Memory maintenance took too long to respond.",
+    action: "Run /ctx-dream again."
+  },
+  dream_provider_error: {
+    code: "MC-D02",
+    sentence: "Memory maintenance could not reach its model.",
+    action: "Check the model connection, then run /ctx-dream again."
+  },
+  dream_local_refusal: {
+    code: "MC-D12",
+    sentence: "Memory maintenance was refused before reaching the model.",
+    action: "Check the hidden-request diagnostic in the Magic Context log before retrying."
+  },
+  dream_step_limit: {
+    code: "MC-D10",
+    sentence: "Memory maintenance stopped at its hidden agent step limit.",
+    action: "This task needs less work per run; changing the model connection will not help."
+  },
+  dream_token_budget: {
+    code: "MC-D11",
+    sentence: "Memory maintenance reached its prompt-token budget.",
+    action: "The unfinished items will be retried on the next run."
+  },
+  dream_empty_completion: {
+    code: "MC-D03",
+    sentence: "Memory maintenance received no usable response.",
+    action: "Run /ctx-dream again."
+  },
+  dream_no_models: {
+    code: "MC-D04",
+    sentence: "Memory maintenance has no model available.",
+    action: "Check the model settings, then run /ctx-dream again."
+  },
+  dream_child_aborted: {
+    code: "MC-D05",
+    sentence: "Memory maintenance was interrupted.",
+    action: "Run /ctx-dream again."
+  },
+  dream_parse_failed: {
+    code: "MC-D06",
+    sentence: "Memory maintenance could not use the model response.",
+    action: "Run /ctx-dream again."
+  },
+  dream_unknown: {
+    code: "MC-D07",
+    sentence: "Memory maintenance could not finish.",
+    action: "Run /ctx-dream again."
+  },
+  dreamer_tick_blocked: {
+    code: "MC-D09",
+    sentence: "Background maintenance is not running: its last pass stopped before it reached the scheduled tasks.",
+    action: "It is retried automatically; if it keeps happening, check the Magic Context log for the stage that stopped and run `npx @cortexkit/magic-context doctor`."
+  },
+  dream_task_needs_tool_loop: {
+    code: "MC-D08",
+    sentence: "Some memory maintenance tasks need a tool loop this host does not provide.",
+    action: "The remaining tasks still run; the listed ones are skipped on this host."
+  },
+  embedding_substitution_rejected: {
+    code: "MC-E01",
+    sentence: "Search indexing could not use the selected model.",
+    action: "Check the embedding model setting, then run /ctx-embed start again."
+  },
+  embedding_http_error: {
+    code: "MC-E02",
+    sentence: "The search indexing provider refused the request.",
+    action: "Check the provider connection and credentials, then run /ctx-embed start again."
+  },
+  embedding_transport_error: {
+    code: "MC-E03",
+    sentence: "Search indexing could not reach its provider.",
+    action: "Check the connection, then run /ctx-embed start again."
+  },
+  embedding_invalid_envelope: {
+    code: "MC-E04",
+    sentence: "Search indexing received an unsupported response.",
+    action: "Check the embedding endpoint, then run /ctx-embed start again."
+  },
+  embedding_empty_result: {
+    code: "MC-E05",
+    sentence: "Search indexing received no usable result.",
+    action: "Run /ctx-embed start again."
+  },
+  embedding_certification_refusal: {
+    code: "MC-E06",
+    sentence: "Search indexing is not ready for this provider.",
+    action: "Finish the provider setup, or set a fallback provider in the embedding settings, then run /ctx-embed start again."
+  },
+  embedding_credential_required: {
+    code: "MC-E07",
+    sentence: "Search indexing needs provider credentials.",
+    action: "Sign in to the provider, then run /ctx-embed start again."
+  },
+  embedding_local_binding_missing: {
+    code: "MC-E08",
+    sentence: "Local search indexing is unavailable on this system.",
+    action: "Run `npx @cortexkit/magic-context doctor`, then retry."
+  },
+  embedding_local_fs_unavailable: {
+    code: "MC-E09",
+    sentence: "Local search indexing cannot save its model files.",
+    action: "Update or reinstall Magic Context, then retry."
+  },
+  embedding_local_download_failure: {
+    code: "MC-E10",
+    sentence: "Local search indexing could not download its model.",
+    action: "Check the network connection, then retry."
+  },
+  embedding_local_runtime_error: {
+    code: "MC-E11",
+    sentence: "Local search indexing could not start.",
+    action: "Run `npx @cortexkit/magic-context doctor`, then retry."
+  },
+  embedding_unavailable: {
+    code: "MC-E12",
+    sentence: "Search indexing could not finish.",
+    action: "Run /ctx-embed start again."
+  },
+  status_unavailable: {
+    code: "MC-S01",
+    sentence: "Magic Context status is temporarily unavailable.",
+    action: "Retry /ctx-status in a moment."
+  },
+  transform_update_failed: {
+    code: "MC-S02",
+    sentence: "The last context update did not finish.",
+    action: "Send another message to retry."
+  },
+  transform_pass_degraded: {
+    code: "MC-S06",
+    sentence: "This request was not sent: Magic Context could not finish preparing it, and without that preparation it could be far larger than the previous request.",
+    action: "Send your message again."
+  },
+  configuration_warning: {
+    code: "MC-S03",
+    sentence: "Some configuration settings could not be applied.",
+    action: "Fix the configuration warning shown in /ctx-status, then restart."
+  },
+  status_log_unavailable: {
+    code: "MC-S04",
+    sentence: "Some diagnostic details could not be saved.",
+    action: "Retry /ctx-status in a moment."
+  },
+  memory_writes_paused: {
+    code: "MC-C01",
+    sentence: "Memory writes are paused while the engine syncs.",
+    action: "Retry in a moment."
+  },
+  memory_access_unavailable: {
+    code: "MC-C02",
+    sentence: "Memory access is temporarily unavailable.",
+    action: "Retry in a moment."
+  },
+  note_changes_paused: {
+    code: "MC-C03",
+    sentence: "Note changes are paused while the engine syncs.",
+    action: "Retry in a moment."
+  },
+  note_access_unavailable: {
+    code: "MC-C04",
+    sentence: "Notes are temporarily unavailable.",
+    action: "Retry in a moment."
+  },
+  context_cleanup_paused: {
+    code: "MC-C05",
+    sentence: "Context cleanup is paused while the engine syncs.",
+    action: "Retry in a moment."
+  },
+  partial_history_unavailable: {
+    code: "MC-C06",
+    sentence: "Partial history compression is not available in the current mode.",
+    action: "Run /ctx-recomp without a range."
+  },
+  smart_note_conditions_unavailable: {
+    code: "MC-C08",
+    sentence: "Conditional notes are not available in the current mode.",
+    action: "Save a regular note without a condition."
+  },
+  history_compression_paused: {
+    code: "MC-C09",
+    sentence: "History compression is paused while the engine syncs.",
+    action: "Retry in a moment."
+  },
+  history_compression_needs_message: {
+    code: "MC-C12",
+    sentence: "History compression has not seen this session since Magic Context reconnected.",
+    action: "Send a message in this session first, then run /ctx-wrapup again."
+  },
+  context_service_unavailable: {
+    code: "MC-C10",
+    sentence: "Magic Context is temporarily unavailable.",
+    action: "Retry in a moment."
+  },
+  context_db_missing: {
+    code: "MC-C15",
+    sentence: "Magic Context has no context.db.",
+    action: "Run `npx @cortexkit/magic-context doctor store init`, then restart ck-mc."
+  },
+  single_store_migration_required: {
+    code: "MC-C14",
+    sentence: "Magic Context's Rust mode needs a one-time migration of its store.",
+    action: "Quit OpenCode and every ck-mc process, then run `magic-context doctor single-store migrate`."
+  },
+  store_ahead_of_binary: {
+    code: "MC-C13",
+    sentence: "Magic Context refused to start: its store (store.db) was migrated by a newer ck-mc build than the one running.",
+    action: "Update ck-mc, or roll back by restoring ck-mc together with context.db and store.db from the same backup."
+  },
+  compaction_marker_missing: {
+    code: "MC-C11",
+    sentence: "The history boundary marker is missing from the OpenCode store, so requests carry the full session.",
+    action: "It is retried on every message; if this persists, run `/ctx-flush`."
+  },
+  memory_mirror_stalled: {
+    code: "MC-M01",
+    sentence: "Memory synchronization stopped before the host mirror caught up.",
+    action: "Send another message to resume it, or run `ck doctor drain-authority`."
+  },
+  memory_authority_mismatch: {
+    code: "MC-M02",
+    sentence: "Memory authority is inconsistent between the host and module.",
+    action: "Run `ck doctor drain-authority` before changing Rust mode."
+  },
+  dreamer_task_failing: {
+    code: "MC-S05",
+    sentence: "A background maintenance task keeps failing on its schedule.",
+    action: "Check the Magic Context log for the failing task and its error."
+  }
+};
+function renderUserFacingFailure(key, style = "markdown") {
+  const failure = USER_FACING_FAILURES[key];
+  const action = style === "plain" ? failure.action.replaceAll("`", "") : failure.action;
+  return `${failure.sentence} ${action} (${failure.code})`;
+}
+function userFacingFailureCode(key) {
+  return USER_FACING_FAILURES[key].code;
+}
+var CAPABILITY_FAILURES = {
+  memory_write: "memory_writes_paused",
+  memory_access: "memory_access_unavailable",
+  note_change: "note_changes_paused",
+  note_access: "note_access_unavailable",
+  context_cleanup: "context_cleanup_paused",
+  partial_history: "partial_history_unavailable",
+  smart_note_condition: "smart_note_conditions_unavailable",
+  history_compression: "history_compression_paused",
+  context_service: "context_service_unavailable"
+};
+function renderCapabilityRefusal(capability) {
+  return renderUserFacingFailure(CAPABILITY_FAILURES[capability]);
+}
+var DREAM_FAILURE_KEYS = {
+  provider_timeout: "dream_provider_timeout",
+  provider_error: "dream_provider_error",
+  local_refusal: "dream_local_refusal",
+  step_limit: "dream_step_limit",
+  token_budget: "dream_token_budget",
+  empty_completion: "dream_empty_completion",
+  no_models: "dream_no_models",
+  child_aborted: "dream_child_aborted",
+  parse_failed: "dream_parse_failed",
+  unknown: "dream_unknown"
+};
+var EMBEDDING_FAILURE_KEYS = {
+  substitution_rejected: "embedding_substitution_rejected",
+  http_error: "embedding_http_error",
+  transport_error: "embedding_transport_error",
+  invalid_envelope: "embedding_invalid_envelope",
+  empty_result: "embedding_empty_result",
+  certification_refusal: "embedding_certification_refusal",
+  credential_required: "embedding_credential_required",
+  local_binding_missing: "embedding_local_binding_missing",
+  local_fs_unavailable: "embedding_local_fs_unavailable",
+  local_download_failure: "embedding_local_download_failure",
+  local_runtime_error: "embedding_local_runtime_error"
+};
+function renderDreamFailure(failureClass, style = "markdown", refusalReason) {
+  const rendered = renderUserFacingFailure(DREAM_FAILURE_KEYS[failureClass], style);
+  return failureClass === "local_refusal" && refusalReason ? `${rendered} Reason: ${sanitizeDiagnosticText(refusalReason).slice(0, 500)}` : rendered;
+}
+function dreamFailureCode(failureClass) {
+  return userFacingFailureCode(DREAM_FAILURE_KEYS[failureClass]);
+}
+function renderEmbeddingFailure(failureClass, style = "markdown") {
+  return renderUserFacingFailure(EMBEDDING_FAILURE_KEYS[failureClass], style);
+}
+
+// ../plugin/src/hooks/magic-context/single-store-refusal.ts
+var SINGLE_STORE_MIGRATION_REQUIRED_CODE = "single_store_migration_required";
+function renderSingleStoreMigrationRequiredRefusal() {
+  const failure = USER_FACING_FAILURES.single_store_migration_required;
+  return `${failure.sentence} ${failure.action} (${failure.code})`;
+}
+
+class SingleStoreMigrationRequiredError extends Error {
+  code = SINGLE_STORE_MIGRATION_REQUIRED_CODE;
+  constructor(options) {
+    super(renderSingleStoreMigrationRequiredRefusal(), options);
+    this.name = "SingleStoreMigrationRequiredError";
+  }
+}
+function projectNeedsSingleStoreMigration(db, projectPath) {
+  const table = db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'authority_managed'").get();
+  return Boolean(table && db.prepare("SELECT 1 FROM authority_managed WHERE project_path = ?").get(projectPath));
+}
 // ../plugin/src/features/magic-context/memory/promotion.ts
 function isPromotableCategory(category) {
   return PROMOTABLE_CATEGORIES.some((promotableCategory) => promotableCategory === category);
@@ -1401,6 +1752,19 @@ function searchGitCommitsSync(db, projectPath, query, options) {
     for (const row of rows)
       bySha.set(row.sha, rowToCommit(row));
   }
+  if (options.captureLanes) {
+    const fts = [...bySha.values()].filter((commit) => ftsScores.has(commit.sha)).map((commit) => ({
+      commit,
+      matchType: "fts",
+      score: (ftsScores.get(commit.sha) ?? 0) * singleSourcePenalty
+    })).sort((a, b) => b.score - a.score || b.commit.committedAtMs - a.commit.committedAtMs).slice(0, 25);
+    const vector = [...bySha.values()].filter((commit) => (semanticScores.get(commit.sha) ?? 0) > 0).map((commit) => ({
+      commit,
+      matchType: "semantic",
+      score: semanticScores.get(commit.sha) ?? 0
+    })).sort((a, b) => b.score - a.score || b.commit.committedAtMs - a.commit.committedAtMs).slice(0, 25);
+    options.captureLanes(fts, vector);
+  }
   const results = [];
   for (const [sha, commit] of bySha.entries()) {
     const sem = semanticScores.get(sha);
@@ -1630,6 +1994,280 @@ function sha256(value) {
   return createHash("sha256").update(value).digest("hex");
 }
 
+// ../plugin/src/hooks/magic-context/module-transport.ts
+import { join } from "node:path";
+
+// ../plugin/src/hooks/magic-context/reply-pages.ts
+var MAX_REPLY_BYTES = 128 * 1024 * 1024;
+var MAX_PAGE_BYTES = 512 * 1024;
+
+// ../plugin/src/hooks/magic-context/module-transport.ts
+function getDefaultSubcConnectionFile() {
+  return join(getDataDir(), "cortexkit", "run", "subc-connection.json");
+}
+
+// ../plugin/src/features/magic-context/search-rerank.ts
+var RERANK_MODEL = "gte-reranker-modernbert-base-f32";
+var RERANK_LANE_LIMIT = 25;
+var DEADLINE_MS = 1500;
+function isProseQuery(query) {
+  const text = query.trim();
+  if (!text || /[\n;]|^["'`]|["'`]$/.test(text))
+    return false;
+  if (/^(?:error\b|cannot\b|failed\b|panic\b|traceback\b|assertion\b|SQLITE_|TypeError\b|ReferenceError\b|SyntaxError\b)/i.test(text))
+    return false;
+  if (/\b(?:[A-Z][A-Z_]+:|\w*(?:Error|Exception):)|\bat\s+\S+\s*\(/.test(text))
+    return false;
+  const words = text.replace(/[?!.]$/, "").split(/\s+/);
+  if (words.length < 3)
+    return false;
+  const plain = words.filter((word) => /^[a-zA-Z]+(?:['’-][a-zA-Z]+)*$/.test(word));
+  if (/^(?:how|why|what|where|when|which|who)\b/i.test(text))
+    return plain.length >= 3;
+  return words.length >= 4 && plain.length >= 3 && !/[\\/]|::|=/.test(text);
+}
+function emptySearchLanes() {
+  return {
+    memory_fts: [],
+    memory_vector: [],
+    primer_fts: [],
+    primer_vector: [],
+    message_fts: [],
+    chunk_vector: [],
+    git_fts: [],
+    git_vector: [],
+    notes: []
+  };
+}
+function searchResultKey(hit) {
+  switch (hit.source) {
+    case "memory":
+      return `memory:${hit.memoryId}`;
+    case "primer":
+      return `primer:${hit.primerId}`;
+    case "message":
+      return `message:${hit.messageId}`;
+    case "compartment":
+      return `compartment:${hit.compartmentId}`;
+    case "git_commit":
+      return `git_commit:${hit.sha}`;
+    case "note":
+      return `note:${hit.noteId}`;
+  }
+}
+function fuseSearchLanes(lanes) {
+  const compartments = lanes.chunk_vector.filter((hit) => hit.source === "compartment");
+  const fused = new Map;
+  for (const [name, lane] of Object.entries(lanes)) {
+    const seen = new Set;
+    lane.slice(0, RERANK_LANE_LIMIT).forEach((original, index) => {
+      const hit = name === "message_fts" && original.source === "message" ? compartments.find((chunk) => original.messageOrdinal >= chunk.startOrdinal && original.messageOrdinal <= chunk.endOrdinal) ?? original : original;
+      const key = searchResultKey(hit);
+      if (seen.has(key))
+        return;
+      seen.add(key);
+      const prior = fused.get(key);
+      const score = 1 / (60 + index + 1);
+      if (prior)
+        prior.score += score;
+      else
+        fused.set(key, { hit, score, order: fused.size });
+    });
+  }
+  return [...fused.values()].sort((a, b) => b.score - a.score || a.order - b.order).slice(0, 20).map((row) => row.hit);
+}
+function truncateUtf8(text, bytes) {
+  const buffer = Buffer.from(text);
+  let end = Math.min(buffer.length, bytes);
+  while (end > 0 && end < buffer.length && (buffer[end] & 192) === 128)
+    end--;
+  return buffer.subarray(0, end).toString("utf8");
+}
+function candidateText(location, title, body) {
+  const header = `${truncateUtf8(location.replaceAll(`
+`, " "), 200)}
+${truncateUtf8(title.replaceAll(`
+`, " "), 120)}
+`;
+  return header + truncateUtf8(body, 1024 - Buffer.byteLength(header));
+}
+
+class RerankFailure extends Error {
+  reason;
+  constructor(reason) {
+    super(reason);
+    this.reason = reason;
+  }
+}
+function unwrap(value) {
+  if (!value || typeof value !== "object")
+    throw new RerankFailure("validation");
+  const outer = value;
+  const body = outer.result ?? outer;
+  if (!body || typeof body !== "object")
+    throw new RerankFailure("validation");
+  if (body.error) {
+    const error = body.error;
+    throw new RerankFailure(error.code ?? "synapse_error");
+  }
+  return body;
+}
+function pinReranker(value) {
+  const body = unwrap(value);
+  const models = body.models;
+  const model = Array.isArray(models) ? models.find((row) => row?.model_id === RERANK_MODEL) : null;
+  if (model?.certified !== true || model.fingerprints?.length !== 1 || typeof model.fingerprints[0] !== "string" || !/^[a-f0-9]{64}$/.test(model.fingerprints[0]) || !Number.isSafeInteger(body.table_epoch))
+    throw new RerankFailure("catalog_validation");
+  return { fingerprint: model.fingerprints[0], tableEpoch: body.table_epoch };
+}
+var loggedReasons = new Set;
+function logRerankFallback(reason) {
+  if (loggedReasons.has(reason))
+    return;
+  loggedReasons.add(reason);
+  log2(`[ctx_search] rerank fallback (${reason}); retaining original ranking`);
+}
+function reasonOf(error) {
+  if (error instanceof RerankFailure)
+    return error.reason;
+  if (error && typeof error === "object" && "code" in error) {
+    const code = String(error.code);
+    return ["ENOENT", "ECONNREFUSED"].includes(code) ? "missing_synapse" : code;
+  }
+  return "synapse_error";
+}
+async function bounded(promise) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new RerankFailure("deadline_exceeded")), DEADLINE_MS);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var connections = new Map;
+async function connect(connectionFile) {
+  let connection = connections.get(connectionFile);
+  if (!connection) {
+    connection = SubcClient.connect({ connectionFile });
+    connections.set(connectionFile, connection);
+    connection.catch(() => connections.delete(connectionFile));
+  }
+  return bounded(connection);
+}
+async function prepareReranker(projectRoot, sessionId, connectionFile, injectedClient) {
+  try {
+    if (injectedClient === null)
+      throw new RerankFailure("missing_synapse");
+    const client = injectedClient ?? await connect(connectionFile ?? getDefaultSubcConnectionFile());
+    const identity = {
+      project_root: projectRoot,
+      harness: "magic-context",
+      session: sessionId
+    };
+    const lane = pinReranker(await bounded(client.call("synapse", "models.list", {}, { timeoutMs: DEADLINE_MS, targetKind: "management_surface", identity })));
+    return { client, lane, identity };
+  } catch (error) {
+    logRerankFallback(reasonOf(error));
+    return null;
+  }
+}
+async function rerankSearchResults(session, query, baseline, pool, texts, limit) {
+  if (!pool.length)
+    return baseline;
+  try {
+    if (pool.length > 20 || texts.length !== pool.length || texts.some((text) => Buffer.byteLength(text) > 1024))
+      throw new RerankFailure("validation");
+    const body = unwrap(await bounded(session.client.call("synapse", "rerank.score", {
+      model: RERANK_MODEL,
+      query,
+      candidates: texts,
+      required_fingerprint: session.lane.fingerprint,
+      allow_equivalent: false,
+      accept_declared: false,
+      max_queue_ms: 100,
+      deadline_ms: DEADLINE_MS
+    }, {
+      timeoutMs: DEADLINE_MS,
+      targetKind: "management_surface",
+      identity: session.identity
+    })));
+    if (body.fingerprint !== session.lane.fingerprint)
+      throw new RerankFailure("fingerprint_mismatch");
+    if (body.table_epoch !== session.lane.tableEpoch)
+      throw new RerankFailure("epoch_mismatch");
+    if (!Array.isArray(body.scores) || body.scores.length !== pool.length || body.scores.some((score) => typeof score !== "number" || !Number.isFinite(score)))
+      throw new RerankFailure("validation");
+    const scores = body.scores;
+    return pool.map((hit, index) => ({ hit, index, score: scores[index] })).sort((a, b) => b.score - a.score || a.index - b.index).slice(0, limit).map((row) => row.hit);
+  } catch (error) {
+    logRerankFallback(reasonOf(error));
+    return baseline;
+  }
+}
+function candidateTexts(db, sessionId, projectPath, pool) {
+  return pool.map((hit) => {
+    const id = searchResultKey(hit).split(":").slice(1).join(":");
+    let location = `${hit.source} ${id} ${projectPath}`;
+    let title = hit.content.split(`
+`)[0];
+    let body = hit.content;
+    switch (hit.source) {
+      case "memory": {
+        const row = db.prepare("SELECT content FROM memories WHERE id=?").get(hit.memoryId);
+        body = row.content;
+        title = body.split(`
+`)[0];
+        break;
+      }
+      case "primer": {
+        const row = db.prepare("SELECT question, answer FROM primers WHERE id=?").get(hit.primerId);
+        title = row.question;
+        body = `Q: ${row.question}
+A: ${row.answer}`;
+        break;
+      }
+      case "git_commit": {
+        const row = db.prepare("SELECT message FROM git_commits WHERE sha=?").get(hit.sha);
+        body = row.message;
+        title = `${hit.shortSha} ${body.split(`
+`)[0]}`;
+        break;
+      }
+      case "note": {
+        const row = db.prepare("SELECT content, ready_reason AS reason FROM notes WHERE id=?").get(hit.noteId);
+        body = `${row.content}${row.reason ? `
+Reason: ${row.reason}` : ""}`;
+        title = body.split(`
+`)[0];
+        break;
+      }
+      case "message": {
+        const mapped = db.prepare(`SELECT f.content FROM message_fts_rowid_map m
+                    JOIN message_history_fts f ON f.rowid=m.fts_rowid
+                    WHERE m.session_id=? AND m.message_ordinal=? AND f.message_id=?`).get(sessionId, hit.messageOrdinal, hit.messageId);
+        const row = mapped ?? db.prepare("SELECT content FROM message_history_fts WHERE session_id=? AND message_id=? ORDER BY CAST(message_ordinal AS INTEGER) LIMIT 1").get(sessionId, hit.messageId);
+        body = row.content;
+        title = `${hit.role}: ${body.split(`
+`)[0]}`;
+        location = `message ${hit.messageId} ${sessionId} @${hit.messageOrdinal}`;
+        break;
+      }
+      case "compartment": {
+        title = hit.title;
+        location = `compartment ${hit.compartmentId} ${hit.sessionId} @${hit.startOrdinal}-${hit.endOrdinal}`;
+        body = buildCanonicalChunkTextFromFts(db, hit.sessionId, hit.startOrdinal, hit.endOrdinal) ?? "";
+        break;
+      }
+    }
+    return candidateText(location, title, body);
+  });
+}
+
 // ../plugin/src/features/magic-context/search.ts
 var DEFAULT_UNIFIED_SEARCH_LIMIT = 10;
 var MAX_UNIFIED_SEARCH_LIMIT = 25;
@@ -1661,6 +2299,7 @@ function createUnifiedSearchDiagnostics2() {
 }
 function searchMessageHistory2(db, request) {
   const diagnostics = request.collectDiagnostics ? createUnifiedSearchDiagnostics2() : undefined;
+  const capture = request.captureLimit ? { limit: request.captureLimit, results: [] } : undefined;
   const results = searchMessages({
     db,
     sessionId: request.sessionId,
@@ -1670,10 +2309,12 @@ function searchMessageHistory2(db, request) {
     probes: request.probes,
     relaxedRecall: request.relaxedRecall,
     diagnostics,
-    dateRange: request.dateRange
+    dateRange: request.dateRange,
+    capture
   });
   return {
     results,
+    laneResults: capture?.results,
     suppressedLiveMessageMatches: diagnostics?.suppressedLiveMessageMatches ?? 0
   };
 }
@@ -2066,7 +2707,7 @@ function mergeMemoryResults(args) {
       score = SEMANTIC_WEIGHT * semanticScore + FTS_WEIGHT * ftsScore;
       matchType = "hybrid";
     } else if (semanticScore !== undefined) {
-      score = semanticScore * SINGLE_SOURCE_PENALTY;
+      score = semanticScore * (args.singleSourcePenalty ?? SINGLE_SOURCE_PENALTY);
       matchType = "semantic";
     } else if (ftsScore !== undefined) {
       score = ftsScore * SINGLE_SOURCE_PENALTY;
@@ -2134,25 +2775,45 @@ async function searchMemories(args) {
     queryModelId: args.queryModelId,
     workspace: args.workspace
   });
+  const sourceNameByMemoryId = sourceNamesForSearchMemories({
+    memories,
+    projectPath: args.projectPath,
+    workspace: args.workspace ?? {
+      identities: [args.projectPath],
+      expandedIdentities: [args.projectPath],
+      namesByIdentity: new Map,
+      canonicalIdentityByStoredPath: new Map([[args.projectPath, args.projectPath]]),
+      ownIdentities: [args.projectPath],
+      shareCategories: null,
+      isWorkspaced: false
+    }
+  });
+  if (args.lanes) {
+    args.lanes.memory_fts = mergeMemoryResults({
+      memories,
+      semanticScores: new Map,
+      ftsScores,
+      sourceNameByMemoryId,
+      limit: 25,
+      visibleMemoryIds: args.visibleMemoryIds
+    }).results;
+    args.lanes.memory_vector = mergeMemoryResults({
+      memories,
+      semanticScores,
+      ftsScores: new Map,
+      sourceNameByMemoryId,
+      singleSourcePenalty: 1,
+      limit: 25,
+      visibleMemoryIds: args.visibleMemoryIds
+    }).results;
+  }
   return mergeMemoryResults({
     memories,
     semanticScores,
     ftsScores,
     limit: args.limit,
     visibleMemoryIds: args.visibleMemoryIds,
-    sourceNameByMemoryId: sourceNamesForSearchMemories({
-      memories,
-      projectPath: args.projectPath,
-      workspace: args.workspace ?? {
-        identities: [args.projectPath],
-        expandedIdentities: [args.projectPath],
-        namesByIdentity: new Map,
-        canonicalIdentityByStoredPath: new Map([[args.projectPath, args.projectPath]]),
-        ownIdentities: [args.projectPath],
-        shareCategories: null,
-        isWorkspaced: false
-      }
-    })
+    sourceNameByMemoryId
   });
 }
 function linearDecayScore(rank, total) {
@@ -2285,7 +2946,9 @@ function searchMessages(args) {
 }
 function searchMessagesInSnapshot(args, sessionFirst) {
   const cutoff = args.maxOrdinal != null && args.maxOrdinal >= 0 ? args.maxOrdinal : null;
-  const fetchLimit = args.maxOrdinal != null && args.maxOrdinal >= 0 ? args.limit * 3 : args.limit;
+  const baselineFetchLimit = cutoff !== null ? args.limit * 3 : args.limit;
+  const captureFetchLimit = args.capture ? cutoff !== null ? args.capture.limit * 3 : args.capture.limit : 0;
+  const fetchLimit = Math.max(baselineFetchLimit, captureFetchLimit);
   const baseQuery = sanitizeFtsQuery(args.query.trim());
   const probes = args.probes ?? [];
   if (probes.length === 0) {
@@ -2305,15 +2968,20 @@ function searchMessagesInSnapshot(args, sessionFirst) {
       args.diagnostics.suppressedLiveMessageMatches = outcome.suppressedCount;
     }
     const rows = outcome.rows.length > 0 || !args.relaxedRecall ? outcome.rows : runMessageFtsQuery(args.db, args.sessionId, relaxedFtsQuery(args.query), fetchLimit, cutoff, args.dateRange, sessionFirst);
-    const filtered = rows.slice(0, args.limit);
-    return filtered.map((row, rank) => ({
-      source: "message",
-      content: previewText(row.content),
-      score: linearDecayScore(rank, filtered.length),
-      messageOrdinal: row.messageOrdinal,
-      messageId: row.messageId,
-      role: row.role
-    }));
+    const renderRows = (limit) => {
+      const filtered = rows.slice(0, limit);
+      return filtered.map((row, rank) => ({
+        source: "message",
+        content: previewText(row.content),
+        score: linearDecayScore(rank, filtered.length),
+        messageOrdinal: row.messageOrdinal,
+        messageId: row.messageId,
+        role: row.role
+      }));
+    };
+    if (args.capture)
+      args.capture.results = renderRows(args.capture.limit);
+    return renderRows(args.limit);
   }
   const sanitizedProbes = probes.map((probe) => ({ probe, query: sanitizeFtsQuery(probe) })).filter((entry) => entry.query.length > 0);
   const corpusSize = getIndexedMessageCorpusSize(args.db, args.sessionId, cutoff);
@@ -2353,39 +3021,44 @@ function searchMessagesInSnapshot(args, sessionFirst) {
     queryLists.push({ rows: rowsByQuery[queryIndex] ?? [], weight });
     queryIndex += 1;
   });
-  const fused = new Map;
-  for (const list of queryLists) {
-    list.rows.forEach((row, rank) => {
-      const rrf = list.weight / (RRF_K + rank);
-      const existing = fused.get(row.messageId);
-      if (existing) {
-        existing.score += rrf;
-      } else {
-        fused.set(row.messageId, { row, score: rrf });
+  const rankProbeLists = (rowLimit, resultLimit) => {
+    const fused = new Map;
+    for (const list of queryLists) {
+      list.rows.slice(0, rowLimit).forEach((row, rank) => {
+        const rrf = list.weight / (RRF_K + rank);
+        const existing = fused.get(row.messageId);
+        if (existing) {
+          existing.score += rrf;
+        } else {
+          fused.set(row.messageId, { row, score: rrf });
+        }
+      });
+    }
+    for (const entry of fused.values()) {
+      let best = 0;
+      for (const probe of probes) {
+        const weight = probeWeights.get(probe) ?? 0;
+        if (weight > best && containsProbeVerbatim(entry.row.content, [probe])) {
+          best = weight;
+        }
       }
-    });
-  }
-  for (const entry of fused.values()) {
-    let best = 0;
-    for (const probe of probes) {
-      const weight = probeWeights.get(probe) ?? 0;
-      if (weight > best && containsProbeVerbatim(entry.row.content, [probe])) {
-        best = weight;
+      if (best > 0) {
+        entry.score += best * VERBATIM_RANK_BONUS;
       }
     }
-    if (best > 0) {
-      entry.score += best * VERBATIM_RANK_BONUS;
-    }
-  }
-  const ranked = [...fused.values()].sort((a, b) => b.score !== a.score ? b.score - a.score : a.row.messageOrdinal - b.row.messageOrdinal).slice(0, args.limit);
-  return ranked.map((entry, rank) => ({
-    source: "message",
-    content: previewText(entry.row.content),
-    score: linearDecayScore(rank, ranked.length),
-    messageOrdinal: entry.row.messageOrdinal,
-    messageId: entry.row.messageId,
-    role: entry.row.role
-  }));
+    const ranked = [...fused.values()].sort((a, b) => b.score !== a.score ? b.score - a.score : a.row.messageOrdinal - b.row.messageOrdinal).slice(0, resultLimit);
+    return ranked.map((entry, rank) => ({
+      source: "message",
+      content: previewText(entry.row.content),
+      score: linearDecayScore(rank, ranked.length),
+      messageOrdinal: entry.row.messageOrdinal,
+      messageId: entry.row.messageId,
+      role: entry.row.role
+    }));
+  };
+  if (args.capture)
+    args.capture.results = rankProbeLists(captureFetchLimit, args.capture.limit);
+  return rankProbeLists(baselineFetchLimit, args.limit);
 }
 var NOTE_SEARCHABLE_STATUSES = ["active", "pending", "ready"];
 var MAX_NOTE_KEYWORD_SCORE = 3.5;
@@ -2655,12 +3328,17 @@ function toGitCommitResult(hit) {
 function searchGitCommits(args) {
   if (args.limit <= 0)
     return [];
+  const lanes = args.lanes;
   const hits = searchGitCommitsSync(args.db, args.projectPath, args.query, {
     limit: args.limit,
     queryEmbedding: args.queryEmbedding,
     queryModelId: args.queryModelId,
     from: args.dateRange?.from,
-    to: args.dateRange?.to
+    to: args.dateRange?.to,
+    captureLanes: lanes ? (fts, vector) => {
+      lanes.git_fts = fts.map(toGitCommitResult);
+      lanes.git_vector = vector.map(toGitCommitResult);
+    } : undefined
   });
   return hits.map(toGitCommitResult);
 }
@@ -2682,13 +3360,44 @@ function searchPrimers(args) {
                   WHERE primers_fts MATCH ? AND p.project_path = ? AND p.status = 'active'
                     ${args.dateRange === null ? "" : "AND p.created_at BETWEEN ? AND ?"}
                   ORDER BY rank ASC
-                  LIMIT ?`).all(ftsQuery, args.projectPath, ...args.dateRange === null ? [] : [args.dateRange.from, args.dateRange.to], args.limit * 3);
-    rows.forEach((row, index) => {
-      ftsRanks.set(row.id, linearDecayScore(index, rows.length));
+                  LIMIT ?`).all(ftsQuery, args.projectPath, ...args.dateRange === null ? [] : [args.dateRange.from, args.dateRange.to], args.lanes ? Math.max(args.limit * 3, 225) : args.limit * 3);
+    const baselineRows = rows.slice(0, args.limit * 3);
+    baselineRows.forEach((row, index) => {
+      ftsRanks.set(row.id, linearDecayScore(index, baselineRows.length));
     });
+    if (args.lanes) {
+      const byId = new Map(primers.map((primer) => [primer.id, primer]));
+      args.lanes.primer_fts = rows.flatMap((row, index) => {
+        const primer = byId.get(row.id);
+        return primer ? [
+          {
+            source: "primer",
+            primerId: primer.id,
+            content: previewText(primerText(primer)),
+            question: primer.question,
+            support: primer.totalSupport,
+            lastObservedAt: primer.lastObservedAt,
+            matchType: "fts",
+            score: linearDecayScore(index, rows.length)
+          }
+        ] : [];
+      }).slice(0, 25);
+    }
   }
+  const vectorResults = [];
   const scored = primers.map((primer) => {
     const semantic = args.queryEmbedding && primer.questionEmbedding && primer.questionEmbeddingModelId === args.queryModelId ? normalizeCosineScore(cosineSimilarity(args.queryEmbedding, primer.questionEmbedding)) : 0;
+    if (args.lanes && semantic > 0)
+      vectorResults.push({
+        source: "primer",
+        primerId: primer.id,
+        content: previewText(primerText(primer)),
+        question: primer.question,
+        support: primer.totalSupport,
+        lastObservedAt: primer.lastObservedAt,
+        matchType: "semantic",
+        score: semantic
+      });
     const fts = ftsRanks.get(primer.id) ?? 0;
     if (semantic <= 0 && fts <= 0)
       return null;
@@ -2704,6 +3413,8 @@ function searchPrimers(args) {
       matchType: semantic > 0 && fts > 0 ? "hybrid" : semantic > 0 ? "semantic" : "fts"
     };
   }).filter((result) => result !== null).sort((a, b) => b.score - a.score || b.support - a.support || a.primerId - b.primerId).slice(0, args.limit);
+  if (args.lanes)
+    args.lanes.primer_vector = vectorResults.sort((a, b) => b.score - a.score || b.support - a.support || a.primerId - b.primerId).slice(0, 25);
   return scored;
 }
 function resolveSources(sources) {
@@ -2781,6 +3492,8 @@ async function unifiedSearch2(db, sessionId, projectPath, query, options = {}) {
     return [];
   }
   const limit = normalizeLimit(options.limit);
+  const reranker = options.explicitSearch && options.rerank !== false && isProseQuery(trimmedQuery) ? await prepareReranker(projectPath, sessionId, options.rerankConnectionFile, options.rerankClient) : null;
+  const lanes = reranker || options.captureRerankLanes ? emptySearchLanes() : undefined;
   const dateRange = normalizeDateRange(options.from, options.to);
   const tierLimit = Math.max(limit * 3, DEFAULT_UNIFIED_SEARCH_LIMIT);
   if (options.diagnostics) {
@@ -2818,6 +3531,7 @@ async function unifiedSearch2(db, sessionId, projectPath, query, options = {}) {
       sessionId,
       query: trimmedQuery,
       limit: tierLimit,
+      captureLimit: lanes ? 75 : undefined,
       maxOrdinal: options.maxMessageOrdinal,
       probes: messageProbes,
       relaxedRecall: options.explicitSearch,
@@ -2835,6 +3549,8 @@ async function unifiedSearch2(db, sessionId, projectPath, query, options = {}) {
       options.diagnostics.suppressedLiveMessageMatches = outcome.suppressedLiveMessageMatches;
     }
     messageResults = outcome.results;
+    if (lanes)
+      lanes.message_fts = (outcome.laneResults ?? outcome.results).slice(0, 25);
   }
   const capturedQuery = await queryEmbeddingPromise;
   if (options.signal?.aborted)
@@ -2851,14 +3567,16 @@ async function unifiedSearch2(db, sessionId, projectPath, query, options = {}) {
     sessionId,
     projectPath,
     queryEmbedding,
-    limit: tierLimit,
+    limit: lanes ? Math.max(tierLimit, 25) : tierLimit,
     maxOrdinal: options.maxMessageOrdinal,
     modelId: chunkModelId && chunkModelId !== "off" ? chunkModelId : null,
     dateRange
   }) : [];
+  if (lanes)
+    lanes.chunk_vector = compartmentResults.slice(0, 25);
   const messageLikeResults = mergeMessageAndCompartmentResults({
     messages: messageResults,
-    compartments: compartmentResults,
+    compartments: compartmentResults.slice(0, tierLimit),
     limit: tierLimit
   });
   const [memoryOutcome, gitCommitResults, primerResults, noteResults] = await Promise.all([
@@ -2873,6 +3591,7 @@ async function unifiedSearch2(db, sessionId, projectPath, query, options = {}) {
       workspace,
       visibleMemoryIds: options.visibleMemoryIds,
       backfillMemoryEmbeddings: options.backfillMemoryEmbeddings,
+      lanes,
       dateRange
     }) : Promise.resolve({
       results: [],
@@ -2885,7 +3604,8 @@ async function unifiedSearch2(db, sessionId, projectPath, query, options = {}) {
       limit: tierLimit,
       queryEmbedding,
       queryModelId: embeddingModelId && embeddingModelId !== "off" ? embeddingModelId : null,
-      dateRange
+      dateRange,
+      lanes
     })) : Promise.resolve([]),
     runPrimers ? Promise.resolve(searchPrimers({
       db,
@@ -2894,14 +3614,15 @@ async function unifiedSearch2(db, sessionId, projectPath, query, options = {}) {
       limit: tierLimit,
       queryEmbedding,
       queryModelId: embeddingModelId && embeddingModelId !== "off" ? embeddingModelId : null,
-      dateRange
+      dateRange,
+      lanes
     })) : Promise.resolve([]),
     runNotes ? Promise.resolve(searchNotes({
       db,
       sessionId,
       projectPath,
       query: trimmedQuery,
-      limit: tierLimit,
+      limit: lanes ? Math.max(tierLimit, 25) : tierLimit,
       probes: messageProbes,
       dateRange
     })) : Promise.resolve([])
@@ -2909,23 +3630,37 @@ async function unifiedSearch2(db, sessionId, projectPath, query, options = {}) {
   if (options.diagnostics) {
     options.diagnostics.suppressedVisibleMemoryIds = memoryOutcome.suppressedVisibleIds;
   }
-  const results = [
+  let results = [
     ...memoryOutcome.results,
     ...primerResults,
     ...messageLikeResults,
     ...gitCommitResults,
     ...noteResults
   ].sort(compareUnifiedResults).slice(0, limit);
+  const originalResults = results;
+  const originalLatencyMs = Date.now() - measurementStartedAt;
+  if (lanes) {
+    lanes.notes = noteResults.slice(0, 25);
+    options.captureRerankLanes?.(lanes);
+  }
+  if (reranker && lanes) {
+    const pool = fuseSearchLanes(lanes);
+    try {
+      results = await rerankSearchResults(reranker, trimmedQuery, results, pool, candidateTexts(db, sessionId, projectPath, pool), limit);
+    } catch {
+      logRerankFallback("candidate_validation");
+    }
+  }
   if (!options.measurementDisabled) {
     recordShadowMeasurement({
       db,
       sessionId,
       projectPath,
       query: trimmedQuery,
-      options,
-      primaryResults: results,
+      options: { ...options, rerank: false, captureRerankLanes: undefined },
+      primaryResults: originalResults,
       primaryQuery: queryContract,
-      primaryLatencyMs: Date.now() - measurementStartedAt,
+      primaryLatencyMs: originalLatencyMs,
       search: unifiedSearch2
     });
   }
@@ -3066,4 +3801,4 @@ ${bodyParts.join(`
 `)}`;
 }
 
-export { getNoteByIdInScope, getNotes, addNote, getSessionNotes, getPendingSmartNotes, getReadySmartNotes, updateNote, dismissNotes, dismissNote, markNoteReady, markNoteChecked, PRIMER_CANDIDATE_TTL_MS, PRIMER_CANDIDATE_MAX_AGE_MS, primerOccurrenceKey, primerOccurrenceUtcDay, insertPrimerCandidates, updatePrimerCandidateEmbedding, getPrimerCandidatesByIds, getPrimerCandidatesForPromotion, countPrimerCandidatesForProject, getActivePrimers, createPrimer, updatePrimerSupport, updatePrimerAnswer, promoteSessionFactsDurable, embedPromotedFacts, recordMemoryMapping, recordMemoryVerifications, getUnmappedMemoryIds, clearMemoryVerifications, getMemoryVerifications, resolveGitTopLevel, readGitHead, readGitChangedFilesSince, readGitFileChangeTimesSince, verificationFileExists, normalizeVerificationFiles, indexCommitsForProject, embedUnembeddedCommits, createUnifiedSearchDiagnostics2, searchMessageHistory2, parseIdShapedQuery2, resolveMemoriesByIdsForSearch2, unifiedSearch2, formatSearchResults2 };
+export { getNoteByIdInScope, getNotes, addNote, getSessionNotes, getPendingSmartNotes, getReadySmartNotes, updateNote, dismissNotes, dismissNote, markNoteReady, markNoteChecked, PRIMER_CANDIDATE_TTL_MS, PRIMER_CANDIDATE_MAX_AGE_MS, primerOccurrenceKey, primerOccurrenceUtcDay, insertPrimerCandidates, updatePrimerCandidateEmbedding, getPrimerCandidatesByIds, getPrimerCandidatesForPromotion, countPrimerCandidatesForProject, getActivePrimers, createPrimer, updatePrimerSupport, updatePrimerAnswer, USER_FACING_FAILURES, renderUserFacingFailure, userFacingFailureCode, renderCapabilityRefusal, renderDreamFailure, dreamFailureCode, renderEmbeddingFailure, renderSingleStoreMigrationRequiredRefusal, SingleStoreMigrationRequiredError, projectNeedsSingleStoreMigration, promoteSessionFactsDurable, embedPromotedFacts, recordMemoryMapping, recordMemoryVerifications, getUnmappedMemoryIds, clearMemoryVerifications, getMemoryVerifications, resolveGitTopLevel, readGitHead, readGitChangedFilesSince, readGitFileChangeTimesSince, verificationFileExists, normalizeVerificationFiles, indexCommitsForProject, embedUnembeddedCommits, createUnifiedSearchDiagnostics2, searchMessageHistory2, parseIdShapedQuery2, resolveMemoriesByIdsForSearch2, unifiedSearch2, formatSearchResults2 };