@cortexkit/opencode-magic-context 0.47.0 → 0.49.0

package/dist/v2/{server-e0c1b7a7.js → server-q4ph9bwn.js}

@@ -1,19 +1,25 @@
 import {
-  log
-} from "./server-1qbnzc80.js";
+  Priority,
+  AdmissionClass,
+  SocketClosedError,
+  SocketTimeoutError,
+  StaleRouteHandleError,
+  SubcClient,
+  isConsumerReconnectTransient
+} from "./server-hb6xhh9q.js";
 import {
-  resolveWorkspaceShareCategories,
-  resolveWorkspaceIdentitySet,
-  expandWorkspaceIdentitySetWithAliases,
-  resolveStoredPathWorkspaceIdentity,
-  sourceNameForMemory
-} from "./server-njt3np1k.js";
+  getHarness2
+} from "./server-pavzsdc6.js";
+import {
+  getDataDir,
+  log2
+} from "./server-t4k4qexw.js";
+import {
+  buildCanonicalChunkTextFromFts,
+  loadCompartmentChunkEmbeddingsForSearch
+} from "./server-ss95ky04.js";
 import {
-  loadCompartmentChunkEmbeddingsForSearch,
-  getIndexedMessageCorpusSize,
   recordEmbeddingMeasurement,
-  getNotes,
-  getActivePrimers,
   saveCommitEmbedding,
   loadProjectCommitEmbeddings,
   loadUnembeddedCommits,
@@ -21,30 +27,813 @@ import {
   upsertCommits,
   getLatestIndexedCommitSha,
   enforceProjectCap,
-  getProjectEmbeddings,
-  contentSha256,
-  getShadowEmbeddingMeasurementCohort,
-  getPrimaryEmbeddingMeasurementCohort,
-  embedShadowTextForProject,
-  enqueueShadowEmbeddingItems,
-  getProjectEmbeddingSnapshot,
-  embedItemsForProject,
+  contentSha2562,
+  getShadowEmbeddingMeasurementCohort2,
+  getPrimaryEmbeddingMeasurementCohort2,
+  embedShadowTextForProject2,
+  enqueueShadowEmbeddingItems2,
+  getProjectEmbeddingSnapshot2,
+  embedItemsForProject2
+} from "./server-jvxzm1jy.js";
+import {
+  getProjectEmbeddings2
+} from "./server-4dhv7mqz.js";
+import {
   cosineSimilarity,
   isEmbeddingEnabled,
   embedText,
-  ensureMemoryEmbeddings,
-  ModuleMemoryAuthorityError,
-  getMemoriesByProject,
-  getMemoriesByProjects,
-  updateMemoryRetrievalCount,
+  ensureMemoryEmbeddings2
+} from "./server-w32kmdez.js";
+import {
+  ModuleMemoryAuthorityError2,
+  getMemoriesByProject2,
+  getMemoriesByProjects2,
+  updateMemoryRetrievalCount2
+} from "./server-7jzrrxap.js";
+import {
+  getNotes,
+  getActivePrimers,
+  USER_FACING_FAILURES,
   relaxedFtsQuery,
   sanitizeFtsQuery,
   searchMemoriesFTS,
   searchMemoriesFTSUnion
-} from "./server-3trjk1hx.js";
+} from "./server-zp53y8js.js";
+import {
+  isRecord
+} from "./server-c5rrgrcd.js";
+import {
+  getIndexedMessageCorpusSize
+} from "./server-1tk82krw.js";
+import {
+  resolveWorkspaceShareCategories,
+  resolveWorkspaceIdentitySet,
+  expandWorkspaceIdentitySetWithAliases,
+  resolveStoredPathWorkspaceIdentity,
+  sourceNameForMemory
+} from "./server-v4mewb78.js";
 import {
   isKnownAutocommit
-} from "./server-ajzeteqw.js";
+} from "./server-8ajstryz.js";
+
+// src/hooks/magic-context/module-transport.ts
+import { realpathSync } from "node:fs";
+import { join } from "node:path";
+
+// src/hooks/magic-context/reply-pages.ts
+import { createHash } from "node:crypto";
+var MAX_REPLY_BYTES = 128 * 1024 * 1024;
+var MAX_PAGE_BYTES = 512 * 1024;
+function fail() {
+  throw Object.assign(new Error("Incomplete or invalid module reply; abandon this pass"), {
+    code: "reply_page_invalid"
+  });
+}
+async function assembleReplyPages(response, fetchPage) {
+  if (!isRecord(response) || !("reply_page" in response))
+    return response;
+  const first = response.reply_page;
+  if (!isRecord(first))
+    fail();
+  const { id, total, bytes } = first;
+  if (typeof id !== "string" || !/^[a-f0-9]{64}$/.test(id) || typeof total !== "number" || !Number.isSafeInteger(total) || total < 2 || total > 4096 || typeof bytes !== "number" || !Number.isSafeInteger(bytes) || bytes <= 0 || bytes > MAX_REPLY_BYTES)
+    fail();
+  const chunks = [];
+  let received = 0;
+  for (let index = 0;index < total; index += 1) {
+    const envelope = index === 0 ? response : await fetchPage(id, index);
+    if (!isRecord(envelope) || !isRecord(envelope.reply_page))
+      fail();
+    const page = envelope.reply_page;
+    if (page.id !== id || page.index !== index || page.total !== total || page.bytes !== bytes || typeof page.data !== "string")
+      fail();
+    if (Buffer.byteLength(JSON.stringify(envelope)) > MAX_PAGE_BYTES)
+      fail();
+    const chunk = Buffer.from(page.data, "utf8");
+    received += chunk.length;
+    if (received > bytes)
+      fail();
+    chunks.push(chunk);
+  }
+  if (received !== bytes)
+    fail();
+  const rebuilt = Buffer.concat(chunks, received);
+  if (createHash("sha256").update(rebuilt).digest("hex") !== id)
+    fail();
+  return JSON.parse(rebuilt.toString("utf8"));
+}
+
+// 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 singleStoreMigrationRequiredFailure(error) {
+  let current = error;
+  const seen = new Set;
+  while (current !== null && typeof current === "object" && !seen.has(current)) {
+    seen.add(current);
+    if (current instanceof SingleStoreMigrationRequiredError)
+      return current;
+    const frame = current;
+    if (frame.code === SINGLE_STORE_MIGRATION_REQUIRED_CODE || frame.code === "single_store_state_split") {
+      return new SingleStoreMigrationRequiredError({ cause: error });
+    }
+    current = frame.cause;
+  }
+  return null;
+}
+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));
+}
+
+// src/hooks/magic-context/store-ahead-refusal.ts
+var STORE_AHEAD_OF_BINARY_CODE = "store_ahead_of_binary";
+function renderStoreAheadOfBinaryRefusal(versions) {
+  const failure = USER_FACING_FAILURES.store_ahead_of_binary;
+  const sentence = versions ? `Magic Context refused to start: its store (store.db) is at schema v${versions.dbVersion} but this ck-mc build only knows up to v${versions.binaryMax}.` : failure.sentence;
+  return `${sentence} ${failure.action} (${failure.code})`;
+}
+
+class StoreAheadOfBinaryError extends Error {
+  code = STORE_AHEAD_OF_BINARY_CODE;
+  versions;
+  constructor(versions, options) {
+    super(renderStoreAheadOfBinaryRefusal(versions), options);
+    this.name = "StoreAheadOfBinaryError";
+    this.versions = versions;
+  }
+}
+function isRecord2(value) {
+  return value !== null && typeof value === "object";
+}
+function nonNegativeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function versionsFromDetail(detail) {
+  if (!isRecord2(detail))
+    return null;
+  const dbVersion = nonNegativeInteger(detail.db_version);
+  const binaryMax = nonNegativeInteger(detail.binary_max);
+  return dbVersion !== null && binaryMax !== null ? { dbVersion, binaryMax } : null;
+}
+function versionsFromMessage(message) {
+  if (typeof message !== "string")
+    return null;
+  const match = /db_version=(\d+) binary_max=(\d+)/.exec(message) ?? /schema v(\d+) but this ck-mc build only knows up to v(\d+)/.exec(message);
+  if (!match)
+    return null;
+  return { dbVersion: Number(match[1]), binaryMax: Number(match[2]) };
+}
+function storeAheadOfBinaryFailure(error) {
+  let current = error;
+  const seen = new Set;
+  while (isRecord2(current) && !seen.has(current)) {
+    seen.add(current);
+    if (current instanceof StoreAheadOfBinaryError)
+      return current;
+    if (current.code === STORE_AHEAD_OF_BINARY_CODE) {
+      const versions = versionsFromDetail(current.detail) ?? versionsFromMessage(current.message);
+      return new StoreAheadOfBinaryError(versions, { cause: error });
+    }
+    current = current.cause;
+  }
+  return null;
+}
+
+// src/hooks/magic-context/module-transport.ts
+var DEFAULT_MODULE_ID = "magic-context";
+var CONNECT_BACKOFF_INITIAL_MS = 1000;
+var CONNECT_BACKOFF_MAX_MS = 30000;
+var CONNECT_BACKOFF_WAIT_BUDGET_MS = 12000;
+var CONNECT_BACKOFF_WAIT_JITTER_MS = 100;
+var HANDSHAKE_TIMEOUT_MS = 2000;
+var MODULE_SEND_TIMEOUT_MS = 15000;
+var TRANSFORM_PAGE_UPLOAD_TIMEOUT_MS = 5000;
+var TRANSFORM_COLD_START_EXECUTE_TIMEOUT_MS = 15000;
+var TRANSFORM_COLD_START_EXECUTE_TIMEOUT_PER_MESSAGE_MS = 2;
+var TRANSFORM_COLD_START_EXECUTE_TIMEOUT_MAX_MS = 90000;
+function transformColdStartExecuteTimeoutMs(seedMessageCount) {
+  const messages = Number.isSafeInteger(seedMessageCount) ? Math.max(0, seedMessageCount) : 0;
+  return Math.min(TRANSFORM_COLD_START_EXECUTE_TIMEOUT_MAX_MS, TRANSFORM_COLD_START_EXECUTE_TIMEOUT_MS + messages * TRANSFORM_COLD_START_EXECUTE_TIMEOUT_PER_MESSAGE_MS);
+}
+var MAX_WRAPUP_REQUEST_BUDGET_MS = 3800000;
+var SERIAL_LANE_MAX_WAITERS = 16;
+var SERIAL_LANE_MAX_WAITERS_PER_SESSION = 8;
+var SERIAL_LANE_MIN_REMAINING_MS = 25;
+var CANONICAL_ROOT_CACHE_MAX_ENTRIES = 256;
+function getDefaultSubcConnectionFile() {
+  return join(getDataDir(), "cortexkit", "run", "subc-connection.json");
+}
+function errorChainSome(error, predicate) {
+  let current = error;
+  const seen = new Set;
+  while (isRecord(current) && !seen.has(current)) {
+    seen.add(current);
+    if (predicate(current))
+      return true;
+    current = current.cause;
+  }
+  return false;
+}
+function isStaleOrDeadRouteFailure(error) {
+  return errorChainSome(error, (current) => {
+    const code = typeof current.code === "string" ? current.code : "";
+    const name = typeof current.name === "string" ? current.name : "";
+    const message = typeof current.message === "string" ? current.message : "";
+    return [
+      "stale_route_handle",
+      "route_closed",
+      "unknown_channel",
+      "unrecognized_channel",
+      "route_gone"
+    ].includes(code) || name === "StaleRouteHandleError" || /route handle \(\d+,\s*\d+\) is not live on the current connection/i.test(message) || /\b(?:unknown|unrecognized) channel\b/i.test(message);
+  });
+}
+function isDeadlineFailure(error) {
+  if (error instanceof SocketTimeoutError)
+    return true;
+  return errorChainSome(error, (current) => {
+    const code = typeof current.code === "string" ? current.code : "";
+    return ["ETIMEDOUT", "request_deadline", "deadline_exceeded_no_drop_observed"].includes(code);
+  });
+}
+function isConnectionFailure(error) {
+  if (error instanceof SocketClosedError || error instanceof SocketTimeoutError || error instanceof StaleRouteHandleError || isConsumerReconnectTransient(error) || isStaleOrDeadRouteFailure(error)) {
+    return true;
+  }
+  return errorChainSome(error, (current) => {
+    const code = typeof current.code === "string" ? current.code : "";
+    const message = typeof current.message === "string" ? current.message : "";
+    return [
+      "ENOENT",
+      "ECONNREFUSED",
+      "ECONNRESET",
+      "EPIPE",
+      "ETIMEDOUT",
+      "request_deadline",
+      "deadline_exceeded_no_drop_observed",
+      "connection_dropped",
+      "SUBC_CONNECTION_BACKOFF"
+    ].includes(code) || /\bclient closed\b|\bconnection closed\b|\bclosed the connection\b/i.test(message);
+  });
+}
+function routeOpenWithoutAmbientConsumerIdentity(client, target, identity, options = {}) {
+  return client.routeOpen(target, identity, {
+    ...options,
+    consumerIdentity: null
+  });
+}
+function isModuleTransportGenerationChangedResult(value) {
+  return isRecord(value) && value.transport_status === "connection_generation_changed" && typeof value.previous_generation === "number" && typeof value.current_generation === "number";
+}
+function moduleRequestBody(body, method) {
+  if (!isRecord(body))
+    return body;
+  const facade = typeof body.name === "string" && isRecord(body.arguments);
+  return { ...body, ...facade ? {} : { method }, accept_reply_pages: true };
+}
+
+class SubcModuleTransport {
+  connectionFile;
+  moduleId;
+  requestTimeoutMs;
+  routeSessionPrefix;
+  client = null;
+  routes = new Map;
+  routeOpenings = new Map;
+  canonicalRootCache = new Map;
+  sessionLanes = new Map;
+  queuedLaneWaiters = 0;
+  wrapupSessions = new Map;
+  nextProbeMs = 0;
+  connectionPromise = null;
+  backoffMs = CONNECT_BACKOFF_INITIAL_MS;
+  connectionGeneration = 0;
+  stateSyncCapabilityCache = null;
+  getCachedStateSyncCapabilities() {
+    const cached = this.stateSyncCapabilityCache;
+    if (!cached || cached.generation !== this.connectionGeneration)
+      return;
+    return cached.capabilities;
+  }
+  invalidateStateSyncCapabilities() {
+    this.stateSyncCapabilityCache = null;
+  }
+  async stateSyncCapabilities(args) {
+    const cached = this.getCachedStateSyncCapabilities();
+    if (cached)
+      return cached;
+    const response = await this.call({
+      sessionId: args.sessionId,
+      projectRoot: args.projectRoot,
+      method: "session.status",
+      body: { method: "session.status", v: 1, session_id: args.sessionId }
+    });
+    const raw = isRecord(response) ? response : {};
+    const value = isRecord(raw.result) ? raw.result : raw;
+    const epochs = isRecord(value.epochs) ? value.epochs : {};
+    const capabilities = {
+      state_sync_deltas: epochs.state_sync_deltas === true,
+      ...epochs.state_sync_resume === true ? { state_sync_resume: true } : {}
+    };
+    this.stateSyncCapabilityCache = { generation: this.connectionGeneration, capabilities };
+    return capabilities;
+  }
+  constructor(connectionFile, moduleId = DEFAULT_MODULE_ID, requestTimeoutMs = MODULE_SEND_TIMEOUT_MS, routeSessionPrefix = "") {
+    this.connectionFile = connectionFile;
+    this.moduleId = moduleId;
+    this.requestTimeoutMs = requestTimeoutMs;
+    this.routeSessionPrefix = routeSessionPrefix;
+  }
+  deadlineError(detail) {
+    const error = new Error(`module transport deadline expired ${detail}`);
+    error.code = "ETIMEDOUT";
+    return error;
+  }
+  laneTimeoutError() {
+    return this.deadlineError("while queued");
+  }
+  connectionChangedError(detail) {
+    const error = new Error(detail);
+    error.code = "ECONNRESET";
+    return error;
+  }
+  async beforeDeadline(operation, deadlineMs, detail) {
+    operation.catch(() => {});
+    const remainingMs = deadlineMs - Date.now();
+    if (remainingMs <= 0)
+      throw this.deadlineError(detail);
+    let timer;
+    try {
+      return await Promise.race([
+        operation,
+        new Promise((_resolve, reject) => {
+          timer = setTimeout(() => reject(this.deadlineError(detail)), remainingMs);
+        })
+      ]);
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
+  }
+  cleanupLane(sessionId, lane) {
+    if (!lane.active && lane.waiters.length === 0 && this.sessionLanes.get(sessionId) === lane) {
+      this.sessionLanes.delete(sessionId);
+    }
+  }
+  laneRelease(sessionId, lane) {
+    let released = false;
+    return () => {
+      if (released)
+        return;
+      released = true;
+      lane.active = false;
+      this.dispatchNextLaneWaiter(sessionId, lane);
+    };
+  }
+  dispatchNextLaneWaiter(sessionId, lane) {
+    if (lane.active)
+      return;
+    while (lane.waiters.length > 0) {
+      const waiter = lane.waiters.shift();
+      if (!waiter)
+        continue;
+      this.queuedLaneWaiters = Math.max(0, this.queuedLaneWaiters - 1);
+      if (waiter.settled)
+        continue;
+      waiter.settled = true;
+      clearTimeout(waiter.timer);
+      waiter.signal?.removeEventListener("abort", waiter.onAbort);
+      if (waiter.signal?.aborted) {
+        waiter.reject(waiter.signal.reason ?? new Error("module transport call aborted"));
+        continue;
+      }
+      if (waiter.deadlineMs - Date.now() < SERIAL_LANE_MIN_REMAINING_MS) {
+        waiter.reject(this.laneTimeoutError());
+        continue;
+      }
+      lane.active = true;
+      waiter.resolve(this.laneRelease(sessionId, lane));
+      return;
+    }
+    this.cleanupLane(sessionId, lane);
+  }
+  queueFullError() {
+    const error = new Error("module transport queue is full");
+    error.code = "EBUSY";
+    return error;
+  }
+  acquireCorrectnessLane(sessionId, signal, deadlineMs) {
+    if (signal?.aborted) {
+      return Promise.reject(signal.reason ?? new Error("module transport call aborted"));
+    }
+    if (deadlineMs - Date.now() < SERIAL_LANE_MIN_REMAINING_MS) {
+      return Promise.reject(this.laneTimeoutError());
+    }
+    const lane = this.sessionLanes.get(sessionId) ?? { active: false, waiters: [] };
+    this.sessionLanes.set(sessionId, lane);
+    if (!lane.active && lane.waiters.length === 0) {
+      lane.active = true;
+      return Promise.resolve(this.laneRelease(sessionId, lane));
+    }
+    if (this.queuedLaneWaiters >= SERIAL_LANE_MAX_WAITERS || lane.waiters.length >= SERIAL_LANE_MAX_WAITERS_PER_SESSION) {
+      return Promise.reject(this.queueFullError());
+    }
+    return new Promise((resolve, reject) => {
+      const waiter = {};
+      const removeAndReject = (error) => {
+        if (waiter.settled)
+          return;
+        waiter.settled = true;
+        clearTimeout(waiter.timer);
+        signal?.removeEventListener("abort", waiter.onAbort);
+        const index = lane.waiters.indexOf(waiter);
+        if (index >= 0) {
+          lane.waiters.splice(index, 1);
+          this.queuedLaneWaiters = Math.max(0, this.queuedLaneWaiters - 1);
+        }
+        reject(error);
+        this.cleanupLane(sessionId, lane);
+      };
+      waiter.signal = signal;
+      waiter.deadlineMs = deadlineMs;
+      waiter.resolve = resolve;
+      waiter.reject = reject;
+      waiter.settled = false;
+      waiter.onAbort = () => removeAndReject(signal?.reason ?? new Error("module transport call aborted"));
+      waiter.timer = setTimeout(() => removeAndReject(this.laneTimeoutError()), Math.max(0, deadlineMs - Date.now()));
+      signal?.addEventListener("abort", waiter.onAbort, { once: true });
+      lane.waiters.push(waiter);
+      this.queuedLaneWaiters += 1;
+    });
+  }
+  async call(args) {
+    const callStartedAt = performance.now();
+    const timings = {
+      lane: 0,
+      route: 0,
+      encode: 0,
+      issue: 0,
+      responseWait: 0,
+      settle: 0
+    };
+    const wrapupInFlight = (this.wrapupSessions.get(args.sessionId) ?? 0) > 0;
+    const attemptTimeoutMs = args.timeoutMs ?? (args.method === "session.wrapup" || args.method === "session.status" && wrapupInFlight ? MAX_WRAPUP_REQUEST_BUDGET_MS : args.attemptClass === "transform_series_execute" ? TRANSFORM_COLD_START_EXECUTE_TIMEOUT_MS : args.method === "transform" ? Math.min(this.requestTimeoutMs, TRANSFORM_PAGE_UPLOAD_TIMEOUT_MS) : this.requestTimeoutMs);
+    const tracksWrapup = args.method === "session.wrapup";
+    if (tracksWrapup) {
+      this.wrapupSessions.set(args.sessionId, (this.wrapupSessions.get(args.sessionId) ?? 0) + 1);
+    }
+    const finishWrapupTracking = () => {
+      if (!tracksWrapup)
+        return;
+      const remaining = (this.wrapupSessions.get(args.sessionId) ?? 1) - 1;
+      if (remaining > 0)
+        this.wrapupSessions.set(args.sessionId, remaining);
+      else
+        this.wrapupSessions.delete(args.sessionId);
+    };
+    const laneDeadlineMs = Date.now() + attemptTimeoutMs;
+    let releaseLane = () => {};
+    try {
+      const outsideSessionOrder = args.method.startsWith("historian.");
+      if (!args.bypassSessionLane && !outsideSessionOrder) {
+        releaseLane = await this.acquireCorrectnessLane(args.sessionId, args.signal, laneDeadlineMs);
+      }
+    } catch (error) {
+      finishWrapupTracking();
+      if (args.method === "state_sync" && isDeadlineFailure(error)) {
+        const body = isRecord(args.body) ? args.body : {};
+        throw Object.assign(new Error(`state_sync timeout stage=correctness_lane page=${body.seed_batch_index ?? 0}/${body.seed_batch_total ?? 1} series=${body.seed_id ?? "delta"} budget_ms=${attemptTimeoutMs}`), {
+          code: "state_sync_timeout",
+          stage: "correctness_lane",
+          page: body.seed_batch_index ?? 0,
+          pages: body.seed_batch_total ?? 1,
+          series: body.seed_id ?? null,
+          cause: error
+        });
+      }
+      throw error;
+    }
+    timings.lane = performance.now() - callStartedAt;
+    let rejectAbort;
+    const aborted = new Promise((_resolve, reject) => {
+      rejectAbort = reject;
+    });
+    aborted.catch(() => {});
+    const onAbort = () => rejectAbort(args.signal?.reason ?? new Error("module transport call aborted"));
+    args.signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+      for (let attempt = 0;attempt < 2; attempt += 1) {
+        let ensuredRoute = null;
+        let initialResponseReceived = false;
+        try {
+          if (args.signal?.aborted) {
+            throw args.signal.reason ?? new Error("module transport call aborted");
+          }
+          const attemptDeadlineMs = Date.now() + attemptTimeoutMs;
+          const routeStartedAt = performance.now();
+          ensuredRoute = await this.ensureRoute(args.sessionId, args.projectRoot, attemptDeadlineMs, args.signal);
+          if (args.signal?.aborted) {
+            throw args.signal.reason ?? new Error("module transport call aborted");
+          }
+          timings.route += performance.now() - routeStartedAt;
+          const encodeStartedAt = performance.now();
+          const body = args.body instanceof Uint8Array ? args.body : Buffer.from(JSON.stringify(moduleRequestBody(args.body, args.method)));
+          timings.encode += performance.now() - encodeStartedAt;
+          const issueStartedAt = performance.now();
+          const request = ensuredRoute.client.request(ensuredRoute.route, body, {
+            priority: Priority.Background,
+            admissionClass: AdmissionClass.Normal,
+            timeoutMs: Math.max(1, attemptDeadlineMs - Date.now())
+          });
+          timings.issue += performance.now() - issueStartedAt;
+          const waitStartedAt = performance.now();
+          const response = await this.beforeDeadline(Promise.race([request, aborted]), attemptDeadlineMs, "waiting for the module response");
+          timings.responseWait += performance.now() - waitStartedAt;
+          initialResponseReceived = true;
+          if (this.client !== ensuredRoute.client || this.connectionGeneration !== ensuredRoute.generation) {
+            throw this.connectionChangedError("subc connection changed while awaiting the module response");
+          }
+          const pageRoute = ensuredRoute;
+          const assembled = await assembleReplyPages(response, async (id, index) => {
+            if (args.signal?.aborted)
+              throw args.signal.reason;
+            const page = await this.beforeDeadline(Promise.race([
+              pageRoute.client.request(pageRoute.route, Buffer.from(JSON.stringify({
+                method: "reply.page",
+                reply_page_id: id,
+                reply_page_index: index
+              })), {
+                priority: Priority.Background,
+                admissionClass: AdmissionClass.Normal,
+                timeoutMs: Math.max(1, attemptDeadlineMs - Date.now())
+              }),
+              aborted
+            ]), attemptDeadlineMs, "waiting for a module reply page");
+            if (this.client !== pageRoute.client || this.connectionGeneration !== pageRoute.generation) {
+              throw this.connectionChangedError("subc connection changed during reply paging");
+            }
+            return page;
+          });
+          return assembled;
+        } catch (error) {
+          if (args.signal?.aborted)
+            throw args.signal.reason ?? error;
+          const migration = singleStoreMigrationRequiredFailure(error);
+          if (migration)
+            throw migration;
+          const storeAhead = storeAheadOfBinaryFailure(error);
+          if (storeAhead)
+            throw storeAhead;
+          if (args.method === "state_sync" && isDeadlineFailure(error)) {
+            const body = isRecord(args.body) ? args.body : {};
+            throw Object.assign(new Error(`state_sync timeout stage=module_ack page=${body.seed_batch_index ?? 0}/${body.seed_batch_total ?? 1} series=${body.seed_id ?? "delta"} budget_ms=${attemptTimeoutMs}`), {
+              code: "state_sync_timeout",
+              stage: "module_ack",
+              page: body.seed_batch_index ?? 0,
+              pages: body.seed_batch_total ?? 1,
+              series: body.seed_id ?? null,
+              cause: error
+            });
+          }
+          if (args.attemptClass === "transform_series_execute" && isDeadlineFailure(error)) {
+            throw error;
+          }
+          if (isConnectionFailure(error)) {
+            const previousGeneration = ensuredRoute?.generation ?? this.connectionGeneration;
+            if (ensuredRoute) {
+              this.dropRoute(ensuredRoute.routeKey, ensuredRoute.route);
+              this.invalidateConnection(ensuredRoute.client);
+            } else {
+              this.invalidateConnection();
+            }
+            const locallyUnsent = isRecord(error) && error.name === "StaleRouteHandleError" && error.code === "stale_route_handle";
+            if (attempt === 0 && ensuredRoute && !initialResponseReceived && locallyUnsent && !args.generationSensitive) {
+              continue;
+            }
+            if (args.method === "transform") {
+              if (!ensuredRoute)
+                throw error;
+              throw Object.assign(new Error("Transform transport interrupted; abandon this pass"), { code: "transform_transport_interrupted", cause: error });
+            }
+            if (args.generationSensitive && !args.signal?.aborted) {
+              return {
+                transport_status: "connection_generation_changed",
+                previous_generation: previousGeneration,
+                current_generation: this.connectionGeneration
+              };
+            }
+            if (attempt === 0 && !args.signal?.aborted)
+              continue;
+          }
+          throw error;
+        }
+      }
+      throw new Error("module transport route retry exhausted");
+    } finally {
+      args.signal?.removeEventListener("abort", onAbort);
+      finishWrapupTracking();
+      releaseLane();
+      timings.settle = Math.max(0, performance.now() - callStartedAt - timings.lane - timings.route - timings.encode - timings.issue - timings.responseWait);
+      args.onTimings?.(timings);
+    }
+  }
+  async deleteSession(sessionId, projectRoot) {
+    await this.call({
+      sessionId,
+      projectRoot,
+      method: "session.delete",
+      body: { method: "session.delete", v: 1, session_id: sessionId }
+    });
+  }
+  closeSession(sessionId) {
+    const client = this.client;
+    const prefix = `${sessionId}\x00`;
+    const routes = [...this.routes.entries()].filter(([key]) => key.startsWith(prefix));
+    for (const [key, cachedRoute] of routes) {
+      this.routes.delete(key);
+      if (client) {
+        client.closeRoute(cachedRoute.route).catch((error) => {
+          if (this.client === client && isConnectionFailure(error)) {
+            this.invalidateConnection(client);
+          }
+        });
+      }
+    }
+    if (routes.length === 0 && this.sessionLanes.get(sessionId)?.active) {
+      this.invalidateConnection(client);
+    }
+  }
+  async ensureRoute(sessionId, rawProjectRoot, deadlineMs = Date.now() + this.requestTimeoutMs, signal) {
+    const projectRoot = this.canonicalRoot(rawProjectRoot);
+    const routeKey = `${sessionId}\x00${projectRoot}`;
+    const client = await this.ensureConnected(signal);
+    const generation = this.connectionGeneration;
+    const existing = this.routes.get(routeKey);
+    if (existing?.generation === generation) {
+      return { client, route: existing.route, routeKey, generation };
+    }
+    if (existing)
+      this.routes.delete(routeKey);
+    const opening = this.routeOpenings.get(routeKey);
+    if (opening?.client === client && opening.generation === generation) {
+      return await opening.promise;
+    }
+    const promise = (async () => {
+      const target = { kind: "tool_provider", module_id: this.moduleId };
+      const identity = {
+        project_root: projectRoot,
+        harness: getHarness2(),
+        session: `${this.routeSessionPrefix}${sessionId}`
+      };
+      const route = await this.beforeDeadline(routeOpenWithoutAmbientConsumerIdentity(client, target, identity), deadlineMs, "opening the module route");
+      if (this.client !== client || generation !== this.connectionGeneration) {
+        await client.closeRoute(route).catch(() => {
+          return;
+        });
+        throw this.connectionChangedError("subc connection changed while opening module route");
+      }
+      this.routes.set(routeKey, { route, generation });
+      return { client, route, routeKey, generation };
+    })();
+    const routeOpening = { client, generation, promise };
+    this.routeOpenings.set(routeKey, routeOpening);
+    try {
+      return await promise;
+    } finally {
+      if (this.routeOpenings.get(routeKey) === routeOpening) {
+        this.routeOpenings.delete(routeKey);
+      }
+    }
+  }
+  dropRoute(routeKey, route) {
+    const existing = this.routes.get(routeKey);
+    if (!existing || route && existing.route !== route)
+      return;
+    this.routes.delete(routeKey);
+  }
+  canonicalRoot(root) {
+    const cached = this.canonicalRootCache.get(root);
+    if (cached !== undefined) {
+      this.canonicalRootCache.delete(root);
+      this.canonicalRootCache.set(root, cached);
+      return cached;
+    }
+    let resolved = root;
+    try {
+      resolved = realpathSync.native(root);
+    } catch {}
+    this.canonicalRootCache.set(root, resolved);
+    while (this.canonicalRootCache.size > CANONICAL_ROOT_CACHE_MAX_ENTRIES) {
+      const oldestRoot = this.canonicalRootCache.keys().next().value;
+      if (oldestRoot === undefined)
+        break;
+      this.canonicalRootCache.delete(oldestRoot);
+    }
+    return resolved;
+  }
+  connectClient() {
+    return SubcClient.connect({
+      connectionFile: this.connectionFile,
+      handshakeTimeoutMs: HANDSHAKE_TIMEOUT_MS
+    });
+  }
+  backoffActiveError() {
+    const error = new Error(`subc connection backoff active until ${this.nextProbeMs}`);
+    error.code = "SUBC_CONNECTION_BACKOFF";
+    return error;
+  }
+  sleepAbortable(durationMs, signal) {
+    return new Promise((resolve, reject) => {
+      if (signal?.aborted) {
+        reject(signal.reason ?? new Error("module transport call aborted"));
+        return;
+      }
+      const onAbort = () => {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+        reject(signal?.reason ?? new Error("module transport call aborted"));
+      };
+      const timer = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      }, Math.max(0, durationMs));
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  async ensureConnected(signal) {
+    if (this.client)
+      return this.client;
+    if (this.connectionPromise)
+      return await this.connectionPromise;
+    let now = Date.now();
+    if (now < this.nextProbeMs) {
+      const remainingMs = this.nextProbeMs - now;
+      if (remainingMs > CONNECT_BACKOFF_WAIT_BUDGET_MS)
+        throw this.backoffActiveError();
+      const jitterMs = Math.floor(Math.random() * CONNECT_BACKOFF_WAIT_JITTER_MS);
+      await this.sleepAbortable(remainingMs + jitterMs, signal);
+      if (this.client)
+        return this.client;
+      if (this.connectionPromise)
+        return await this.connectionPromise;
+      now = Date.now();
+      if (now < this.nextProbeMs)
+        throw this.backoffActiveError();
+    }
+    const generation = this.connectionGeneration;
+    const connecting = (async () => {
+      let candidate = null;
+      try {
+        candidate = await this.connectClient();
+        if (generation !== this.connectionGeneration) {
+          candidate.close();
+          throw this.connectionChangedError("subc connection attempt was superseded");
+        }
+        this.client = candidate;
+        this.routes.clear();
+        this.backoffMs = CONNECT_BACKOFF_INITIAL_MS;
+        this.nextProbeMs = 0;
+        return candidate;
+      } catch (error) {
+        candidate?.close();
+        if (generation === this.connectionGeneration)
+          this.invalidateConnection();
+        this.nextProbeMs = Date.now() + this.backoffMs;
+        this.backoffMs = Math.min(this.backoffMs * 2, CONNECT_BACKOFF_MAX_MS);
+        throw error;
+      }
+    })();
+    this.connectionPromise = connecting;
+    try {
+      return await connecting;
+    } finally {
+      if (this.connectionPromise === connecting)
+        this.connectionPromise = null;
+    }
+  }
+  invalidateConnection(client = this.client) {
+    if (client && this.client !== client)
+      return;
+    this.connectionGeneration += 1;
+    this.invalidateStateSyncCapabilities();
+    this.client = null;
+    this.routes.clear();
+    this.routeOpenings.clear();
+    client?.close();
+  }
+}
 
 // src/features/magic-context/git-commits/git-log-reader.ts
 import { execFile } from "node:child_process";
@@ -96,19 +885,19 @@ async function readGitCommitsResult(directory, options = {}) {
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     if (exclusion && message.includes("bad object")) {
-      log(`[git-commits] indexed tip ${exclusion.slice(0, 7)} is missing for ${projectLabel}; reading the full window`);
+      log2(`[git-commits] indexed tip ${exclusion.slice(0, 7)} is missing for ${projectLabel}; reading the full window`);
       return readGitCommitsResult(directory, { ...options, excludeReachableFrom: undefined });
     }
     const failure = classifyGitLogFailure(message);
     if (failure === "transient") {
-      log(`[git-commits] readGitCommits failed for ${projectLabel}: ${message.slice(0, 500)}`);
+      log2(`[git-commits] readGitCommits failed for ${projectLabel}: ${message.slice(0, 500)}`);
     } else {
-      log(`[git-commits] ${projectLabel} is not indexable (${failure})`);
+      log2(`[git-commits] ${projectLabel} is not indexable (${failure})`);
     }
     return { commits: [], failure };
   }
   if (stdout.trim().length === 0) {
-    log(`[git-commits] readGitCommits returned empty stdout for ${projectLabel} (sinceMs=${options.sinceMs ?? "none"} args=${args.slice(0, 4).join(" ")})`);
+    log2(`[git-commits] readGitCommits returned empty stdout for ${projectLabel} (sinceMs=${options.sinceMs ?? "none"} args=${args.slice(0, 4).join(" ")})`);
   }
   return { commits: parseGitLogOutput(stdout), failure: null };
 }
@@ -169,7 +958,7 @@ async function indexCommitsForProject(db, projectPath, directory, options) {
     nonIndexable: false
   };
   if (indexInProgress.has(projectPath)) {
-    log(`[git-commits] index already in progress for ${projectPath}, skipping`);
+    log2(`[git-commits] index already in progress for ${projectPath}, skipping`);
     return result;
   }
   indexInProgress.add(projectPath);
@@ -190,21 +979,21 @@ async function indexCommitsForProject(db, projectPath, directory, options) {
     }
     if (commits.length === 0) {
       result.evicted = enforceProjectCap(db, projectPath, options.maxCommits);
-      log(`[git-commits] no new commits for ${projectPath} (sinceMs=${sinceMs} latestIndexed=${latestIndexed?.slice(0, 7) ?? "none"} evicted=${result.evicted})`);
+      log2(`[git-commits] no new commits for ${projectPath} (sinceMs=${sinceMs} latestIndexed=${latestIndexed?.slice(0, 7) ?? "none"} evicted=${result.evicted})`);
       return result;
     }
-    log(`[git-commits] read ${commits.length} commits for ${projectPath} (sinceMs=${sinceMs} latestIndexed=${latestIndexed?.slice(0, 7) ?? "none"})`);
+    log2(`[git-commits] read ${commits.length} commits for ${projectPath} (sinceMs=${sinceMs} latestIndexed=${latestIndexed?.slice(0, 7) ?? "none"})`);
     const upsert = upsertCommits(db, projectPath, commits);
     result.inserted = upsert.inserted;
     result.updated = upsert.updated;
     result.evicted = enforceProjectCap(db, projectPath, options.maxCommits);
-    const snapshot = getProjectEmbeddingSnapshot(projectPath);
+    const snapshot = getProjectEmbeddingSnapshot2(projectPath);
     if (options.skipEmbed || !snapshot?.gitCommitEnabled) {
-      log(`[git-commits] indexed ${projectPath}: scanned=${result.scanned} inserted=${result.inserted} updated=${result.updated} evicted=${result.evicted} embedded=0 (embedding skipped: skipEmbed=${options.skipEmbed === true} gitCommitEnabled=${snapshot?.gitCommitEnabled === true})`);
+      log2(`[git-commits] indexed ${projectPath}: scanned=${result.scanned} inserted=${result.inserted} updated=${result.updated} evicted=${result.evicted} embedded=0 (embedding skipped: skipEmbed=${options.skipEmbed === true} gitCommitEnabled=${snapshot?.gitCommitEnabled === true})`);
       return result;
     }
     result.embedded = await embedUnembeddedCommits(db, projectPath);
-    log(`[git-commits] indexed ${projectPath}: scanned=${result.scanned} inserted=${result.inserted} updated=${result.updated} evicted=${result.evicted} embedded=${result.embedded}`);
+    log2(`[git-commits] indexed ${projectPath}: scanned=${result.scanned} inserted=${result.inserted} updated=${result.updated} evicted=${result.evicted} embedded=${result.embedded}`);
     return result;
   } finally {
     indexInProgress.delete(projectPath);
@@ -214,7 +1003,7 @@ async function embedUnembeddedCommits(db, projectPath) {
   if (embedInProgress.has(projectPath)) {
     return 0;
   }
-  const snapshot = getProjectEmbeddingSnapshot(projectPath);
+  const snapshot = getProjectEmbeddingSnapshot2(projectPath);
   if (!snapshot?.gitCommitEnabled) {
     return 0;
   }
@@ -229,10 +1018,10 @@ async function embedUnembeddedCommits(db, projectPath) {
         break;
       let embeddedThisBatch = 0;
       try {
-        const result = await embedItemsForProject(projectPath, rows.map((row) => ({
+        const result = await embedItemsForProject2(projectPath, rows.map((row) => ({
           id: `commit:${row.sha}`,
           text: row.message,
-          contentSha256: contentSha256(row.message)
+          contentSha256: contentSha2562(row.message)
         })), undefined, db, projectPath);
         if (!result)
           break;
@@ -245,9 +1034,9 @@ async function embedUnembeddedCommits(db, projectPath) {
             embeddedThisBatch += 1;
           }
         }).immediate();
-        enqueueShadowEmbeddingItems(projectPath, "commit", rows.filter((row) => result.vectors.has(`commit:${row.sha}`)).map((row) => row.sha));
+        enqueueShadowEmbeddingItems2(projectPath, "commit", rows.filter((row) => result.vectors.has(`commit:${row.sha}`)).map((row) => row.sha));
       } catch (error) {
-        log(`[git-commits] embed batch failed for ${projectPath}: ${error instanceof Error ? error.message : String(error)}`);
+        log2(`[git-commits] embed batch failed for ${projectPath}: ${error instanceof Error ? error.message : String(error)}`);
         break;
       }
       if (embeddedThisBatch === 0)
@@ -258,7 +1047,7 @@ async function embedUnembeddedCommits(db, projectPath) {
     }
     if (total > 0) {
       const totalEmbedded = countEmbeddedCommits(db, projectPath, snapshot.modelId);
-      log(`[git-commits] embedded ${total} commits for ${projectPath} (total embedded: ${totalEmbedded})`);
+      log2(`[git-commits] embedded ${total} commits for ${projectPath} (total embedded: ${totalEmbedded})`);
     }
     return total;
   } finally {
@@ -395,7 +1184,7 @@ function searchGitCommitsSync(db, projectPath, query, options) {
         ftsCandidates.push(rowToCommit(row));
       }
     } catch (error) {
-      log(`[git-commits] FTS query failed for "${trimmed}": ${error instanceof Error ? error.message : String(error)}`);
+      log2(`[git-commits] FTS query failed for "${trimmed}": ${error instanceof Error ? error.message : String(error)}`);
     }
   }
   if (ftsCandidates.length === 0) {
@@ -426,6 +1215,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);
@@ -565,7 +1367,7 @@ function withMessageFtsSessionFilter(db, sessionId, read) {
 }
 
 // src/features/magic-context/search-measurement.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 function resultId(result) {
   switch (result.source) {
     case "memory":
@@ -584,15 +1386,15 @@ function resultId(result) {
 }
 async function recordShadowMeasurement(args) {
   try {
-    const shadowCohort = getShadowEmbeddingMeasurementCohort(args.projectPath);
+    const shadowCohort = getShadowEmbeddingMeasurementCohort2(args.projectPath);
     if (!shadowCohort)
       return;
-    const primaryCohort = getPrimaryEmbeddingMeasurementCohort(args.projectPath);
+    const primaryCohort = getPrimaryEmbeddingMeasurementCohort2(args.projectPath);
     const shadowStartedAt = Date.now();
     let shadowFailed = false;
     let shadowResults = [];
     try {
-      const vector = await embedShadowTextForProject(args.projectPath, args.query);
+      const vector = await embedShadowTextForProject2(args.projectPath, args.query);
       if (!vector) {
         shadowFailed = true;
       } else {
@@ -648,11 +1450,273 @@ async function recordShadowMeasurement(args) {
       }
     });
   } catch (error) {
-    log("[magic-context] shadow embedding measurement failed:", error);
+    log2("[magic-context] shadow embedding measurement failed:", error);
   }
 }
 function sha256(value) {
-  return createHash("sha256").update(value).digest("hex");
+  return createHash2("sha256").update(value).digest("hex");
+}
+
+// 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);
+  });
 }
 
 // src/features/magic-context/search.ts
@@ -677,13 +1741,34 @@ var sessionFirstMessageSearchDiagnosticStatements = new WeakMap;
 var messageSearchDiagnosticStatementsWithDateRange = new WeakMap;
 var batchedMessageSearchStatements = new WeakMap;
 var batchedFtsCountStatements = new WeakMap;
-function createUnifiedSearchDiagnostics() {
+function createUnifiedSearchDiagnostics2() {
   return {
     suppressedVisibleMemoryIds: [],
     suppressedLiveMessageMatches: 0,
     gitCommitUnavailable: null
   };
 }
+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,
+    query: request.query,
+    limit: request.limit,
+    maxOrdinal: request.maxOrdinal,
+    probes: request.probes,
+    relaxedRecall: request.relaxedRecall,
+    diagnostics,
+    dateRange: request.dateRange,
+    capture
+  });
+  return {
+    results,
+    laneResults: capture?.results,
+    suppressedLiveMessageMatches: diagnostics?.suppressedLiveMessageMatches ?? 0
+  };
+}
 function normalizeLimit(limit) {
   if (typeof limit !== "number" || !Number.isFinite(limit)) {
     return DEFAULT_UNIFIED_SEARCH_LIMIT;
@@ -703,7 +1788,7 @@ function timestampIsInRange(timestamp, range) {
 }
 var ID_SHAPED_QUERY_MAX_TOKENS = 5;
 var ID_SHAPED_TOKEN = /^#?\d+$/;
-function parseIdShapedQuery(query) {
+function parseIdShapedQuery2(query) {
   const trimmed = query.trim();
   if (trimmed.length === 0) {
     return null;
@@ -978,8 +2063,8 @@ async function getSemanticScores(args) {
     return semanticScores;
   }
   if (!args.workspace?.isWorkspaced) {
-    const cachedEmbeddings = getProjectEmbeddings(args.db, args.projectPath, args.queryModelId);
-    const embeddings = args.backfillMemoryEmbeddings === false ? cachedEmbeddings : await ensureMemoryEmbeddings({
+    const cachedEmbeddings = getProjectEmbeddings2(args.db, args.projectPath, args.queryModelId);
+    const embeddings = args.backfillMemoryEmbeddings === false ? cachedEmbeddings : await ensureMemoryEmbeddings2({
       db: args.db,
       projectIdentity: args.projectPath,
       memories: args.memories,
@@ -1006,8 +2091,8 @@ async function getSemanticScores(args) {
   }
   const ownMemories = memoriesByIdentity.get(args.projectPath) ?? [];
   if (ownMemories.length > 0 && args.backfillMemoryEmbeddings !== false) {
-    const ownEmbeddings = getProjectEmbeddings(args.db, args.projectPath, args.queryModelId);
-    await ensureMemoryEmbeddings({
+    const ownEmbeddings = getProjectEmbeddings2(args.db, args.projectPath, args.queryModelId);
+    await ensureMemoryEmbeddings2({
       db: args.db,
       projectIdentity: args.projectPath,
       memories: ownMemories,
@@ -1018,7 +2103,7 @@ async function getSemanticScores(args) {
     const memberMemories = memoriesByIdentity.get(identity) ?? [];
     if (memberMemories.length === 0)
       continue;
-    const cachedEmbeddings = getProjectEmbeddings(args.db, identity, args.queryModelId);
+    const cachedEmbeddings = getProjectEmbeddings2(args.db, identity, args.queryModelId);
     for (const memory of memberMemories) {
       const memoryEmbedding = cachedEmbeddings.get(memory.id);
       if (!memoryEmbedding || memoryEmbedding.modelId !== args.queryModelId)
@@ -1032,7 +2117,7 @@ function getFtsMatches(args) {
   try {
     return args.workspace?.isWorkspaced ? searchMemoriesFTSUnion(args.db, args.workspace.expandedIdentities, args.query, args.limit, args.workspace.ownIdentities, args.workspace.shareCategories, args.dateRange) : searchMemoriesFTS(args.db, args.projectPath, args.query, args.limit, args.dateRange);
   } catch (error) {
-    log(`[search] FTS query failed for "${args.query}": ${error instanceof Error ? error.message : String(error)}`);
+    log2(`[search] FTS query failed for "${args.query}": ${error instanceof Error ? error.message : String(error)}`);
     return [];
   }
 }
@@ -1047,7 +2132,7 @@ function selectSemanticCandidates(args) {
   if (args.queryModelId && args.queryModelId !== "off") {
     const embeddingProjects = args.workspace?.isWorkspaced ? args.workspace.identities : [args.projectPath];
     for (const projectPath of embeddingProjects) {
-      const storedEmbeddings = getProjectEmbeddings(args.db, projectPath, args.queryModelId);
+      const storedEmbeddings = getProjectEmbeddings2(args.db, projectPath, args.queryModelId);
       for (const memoryId of storedEmbeddings.keys()) {
         candidateIds.add(memoryId);
       }
@@ -1073,7 +2158,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;
@@ -1110,7 +2195,7 @@ async function searchMemories(args) {
   if (!args.memoryEnabled) {
     return { results: [], suppressedVisibleIds: [] };
   }
-  const unfilteredMemories = args.workspace?.isWorkspaced ? getMemoriesByProjects(args.db, args.workspace.expandedIdentities, ["active", "permanent"], Date.now(), args.workspace.ownIdentities, args.workspace.shareCategories) : getMemoriesByProject(args.db, args.projectPath);
+  const unfilteredMemories = args.workspace?.isWorkspaced ? getMemoriesByProjects2(args.db, args.workspace.expandedIdentities, ["active", "permanent"], Date.now(), args.workspace.ownIdentities, args.workspace.shareCategories) : getMemoriesByProject2(args.db, args.projectPath);
   const memories = unfilteredMemories.filter((memory) => timestampIsInRange(memory.createdAt, args.dateRange));
   if (memories.length === 0) {
     return { results: [], suppressedVisibleIds: [] };
@@ -1141,25 +2226,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) {
@@ -1292,7 +2397,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) {
@@ -1312,15 +2419,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);
@@ -1360,39 +2472,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;
@@ -1662,12 +2779,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);
 }
@@ -1689,13 +2811,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;
@@ -1711,6 +2864,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) {
@@ -1737,7 +2892,7 @@ function memoriesToIdLookupResults(args) {
     sourceName: args.sourceNameByMemoryId?.get(memory.id)
   }));
 }
-function resolveMemoriesByIdsForSearch(args) {
+function resolveMemoriesByIdsForSearch2(args) {
   if (args.diagnostics) {
     args.diagnostics.suppressedVisibleMemoryIds = [];
   }
@@ -1745,7 +2900,7 @@ function resolveMemoriesByIdsForSearch(args) {
     return null;
   }
   const workspace = resolveSearchWorkspaceContext(args.db, args.projectPath);
-  const fetched = workspace.isWorkspaced ? getMemoriesByProjects(args.db, workspace.expandedIdentities, ["active", "permanent", "archived"], Date.now(), workspace.ownIdentities, workspace.shareCategories) : getMemoriesByProject(args.db, args.projectPath, ["active", "permanent", "archived"]);
+  const fetched = workspace.isWorkspaced ? getMemoriesByProjects2(args.db, workspace.expandedIdentities, ["active", "permanent", "archived"], Date.now(), workspace.ownIdentities, workspace.shareCategories) : getMemoriesByProject2(args.db, args.projectPath, ["active", "permanent", "archived"]);
   if (fetched.length === 0) {
     return null;
   }
@@ -1781,13 +2936,15 @@ function resolveMemoriesByIdsForSearch(args) {
     })
   });
 }
-async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
+async function unifiedSearch2(db, sessionId, projectPath, query, options = {}) {
   const trimmedQuery = query.trim();
   const measurementStartedAt = Date.now();
   if (trimmedQuery.length === 0 || options.signal?.aborted) {
     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) {
@@ -1812,28 +2969,44 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
   const runCompartmentChunks = runMessages && embeddingEnabled;
   const needsEmbedding = (runMemory || runGitCommits || runCompartmentChunks || runPrimers) && embeddingEnabled && isEmbeddingRuntimeEnabled();
   const queryEmbeddingPromise = needsEmbedding ? embedQuery(trimmedQuery, options.signal).catch((error) => {
-    log(`[search] query embedding failed: ${error instanceof Error ? error.message : String(error)}`);
+    log2(`[search] query embedding failed: ${error instanceof Error ? error.message : String(error)}`);
     return null;
   }) : Promise.resolve(null);
   await Promise.resolve();
   if (options.signal?.aborted)
     return [];
   const messageProbes = options.explicitSearch ? extractLiteralProbes(trimmedQuery) : [];
-  const messageResults = runMessages ? searchMessages({
-    db,
-    sessionId,
-    query: trimmedQuery,
-    limit: tierLimit,
-    maxOrdinal: options.maxMessageOrdinal,
-    probes: messageProbes,
-    relaxedRecall: options.explicitSearch,
-    diagnostics: options.diagnostics,
-    dateRange
-  }) : [];
+  let messageResults = [];
+  if (runMessages) {
+    const messageRequest = {
+      sessionId,
+      query: trimmedQuery,
+      limit: tierLimit,
+      captureLimit: lanes ? 75 : undefined,
+      maxOrdinal: options.maxMessageOrdinal,
+      probes: messageProbes,
+      relaxedRecall: options.explicitSearch,
+      collectDiagnostics: options.diagnostics !== undefined,
+      dateRange
+    };
+    const delegated = options.searchMessageHistory ? await options.searchMessageHistory(messageRequest).catch((error) => {
+      log2(`[search] off-thread message search failed: ${error instanceof Error ? error.message : String(error)}`);
+      return null;
+    }) : null;
+    if (delegated && options.signal?.aborted)
+      return [];
+    const outcome = delegated ?? searchMessageHistory2(db, messageRequest);
+    if (options.diagnostics) {
+      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)
     return [];
-  const embeddingSnapshot = getProjectEmbeddingSnapshot(projectPath);
+  const embeddingSnapshot = getProjectEmbeddingSnapshot2(projectPath);
   const queryContract = capturedQuery instanceof Float32Array || capturedQuery === null ? null : capturedQuery;
   const generationIsCurrent = queryContract === null || embeddingSnapshot !== null && embeddingSnapshot.generation === queryContract.generation;
   const queryEmbedding = generationIsCurrent ? queryContract?.vector ?? (capturedQuery instanceof Float32Array ? capturedQuery : null) : null;
@@ -1845,14 +3018,16 @@ async function unifiedSearch(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([
@@ -1867,6 +3042,7 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
       workspace,
       visibleMemoryIds: options.visibleMemoryIds,
       backfillMemoryEmbeddings: options.backfillMemoryEmbeddings,
+      lanes,
       dateRange
     }) : Promise.resolve({
       results: [],
@@ -1879,7 +3055,8 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
       limit: tierLimit,
       queryEmbedding,
       queryModelId: embeddingModelId && embeddingModelId !== "off" ? embeddingModelId : null,
-      dateRange
+      dateRange,
+      lanes
     })) : Promise.resolve([]),
     runPrimers ? Promise.resolve(searchPrimers({
       db,
@@ -1888,14 +3065,15 @@ async function unifiedSearch(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([])
@@ -1903,24 +3081,38 @@ async function unifiedSearch(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,
-      search: unifiedSearch
+      primaryLatencyMs: originalLatencyMs,
+      search: unifiedSearch2
     });
   }
   const countRetrievals = options.countRetrievals ?? true;
@@ -1930,9 +3122,9 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
       db.transaction(() => {
         for (const memoryId of memoryIds) {
           try {
-            updateMemoryRetrievalCount(db, memoryId);
+            updateMemoryRetrievalCount2(db, memoryId);
           } catch (error) {
-            if (error instanceof ModuleMemoryAuthorityError)
+            if (error instanceof ModuleMemoryAuthorityError2)
               continue;
             throw error;
           }
@@ -2032,7 +3224,7 @@ function formatSearchDiagnosticLines(results, diagnostics) {
   }
   return lines;
 }
-function formatSearchResults(query, results, currentSessionId, diagnostics) {
+function formatSearchResults2(query, results, currentSessionId, diagnostics) {
   const diagnosticLines = formatSearchDiagnosticLines(results, diagnostics);
   if (results.length === 0) {
     if (diagnosticLines.length > 0) {
@@ -2060,4 +3252,4 @@ ${bodyParts.join(`
 `)}`;
 }
 
-export { indexCommitsForProject, embedUnembeddedCommits, createUnifiedSearchDiagnostics, parseIdShapedQuery, resolveMemoriesByIdsForSearch, unifiedSearch, formatSearchResults };
+export { renderSingleStoreMigrationRequiredRefusal, SingleStoreMigrationRequiredError, singleStoreMigrationRequiredFailure, projectNeedsSingleStoreMigration, STORE_AHEAD_OF_BINARY_CODE, storeAheadOfBinaryFailure, TRANSFORM_PAGE_UPLOAD_TIMEOUT_MS, transformColdStartExecuteTimeoutMs, getDefaultSubcConnectionFile, isModuleTransportGenerationChangedResult, SubcModuleTransport, indexCommitsForProject, embedUnembeddedCommits, createUnifiedSearchDiagnostics2, searchMessageHistory2, parseIdShapedQuery2, resolveMemoriesByIdsForSearch2, unifiedSearch2, formatSearchResults2 };