@cortexkit/opencode-magic-context 0.48.0 → 0.49.0

package/dist/{index-q2tqeqde.js → index-ha87j7a8.js}

@@ -1,9 +1,25 @@
+import {
+  Priority,
+  AdmissionClass,
+  SocketClosedError,
+  SocketTimeoutError,
+  StaleRouteHandleError,
+  SubcClient,
+  isConsumerReconnectTransient
+} from "./index-vkbqdnkj.js";
+import {
+  getHarness2
+} from "./index-pavzsdc6.js";
+import {
+  getDataDir
+} from "./index-0sahzkwr.js";
 import {
   log2
-} from "./index-8j7gqj40.js";
+} from "./index-nsjyysj0.js";
 import {
+  buildCanonicalChunkTextFromFts,
   loadCompartmentChunkEmbeddingsForSearch
-} from "./index-pg50n748.js";
+} from "./index-b7mv1jx3.js";
 import {
   recordEmbeddingMeasurement,
   saveCommitEmbedding,
@@ -20,7 +36,7 @@ import {
   enqueueShadowEmbeddingItems2,
   getProjectEmbeddingSnapshot2,
   embedItemsForProject2
-} from "./index-c43kr12f.js";
+} from "./index-kp5qe690.js";
 import {
   getProjectEmbeddings2
 } from "./index-4dhv7mqz.js";
@@ -29,7 +45,7 @@ import {
   isEmbeddingEnabled,
   embedText,
   ensureMemoryEmbeddings2
-} from "./index-5zygecde.js";
+} from "./index-peshmj6h.js";
 import {
   ModuleMemoryAuthorityError2,
   getMemoriesByProject2,
@@ -37,27 +53,790 @@ import {
   updateMemoryRetrievalCount2
 } from "./index-7jzrrxap.js";
 import {
+  USER_FACING_FAILURES,
   getNotes,
   getActivePrimers,
   relaxedFtsQuery,
   sanitizeFtsQuery,
   searchMemoriesFTS,
   searchMemoriesFTSUnion
-} from "./index-cb7emxgj.js";
+} from "./index-kmpvemph.js";
+import {
+  isRecord
+} from "./index-nydv6g8r.js";
 import {
   getIndexedMessageCorpusSize
-} from "./index-14cjxt20.js";
+} from "./index-hj2q50k0.js";
 import {
   resolveWorkspaceShareCategories,
   resolveWorkspaceIdentitySet,
   expandWorkspaceIdentitySetWithAliases,
   resolveStoredPathWorkspaceIdentity,
   sourceNameForMemory
-} from "./index-7mx8v0pw.js";
+} from "./index-nm6a8xpd.js";
 import {
   isKnownAutocommit
 } from "./index-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";
 import { promisify } from "node:util";
@@ -438,6 +1217,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);
@@ -577,7 +1369,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":
@@ -664,7 +1456,269 @@ async function recordShadowMeasurement(args) {
   }
 }
 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
@@ -698,6 +1752,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,
@@ -707,10 +1762,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
   };
 }
@@ -1103,7 +2160,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;
@@ -1171,25 +2228,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) {
@@ -1322,7 +2399,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) {
@@ -1342,15 +2421,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);
@@ -1390,39 +2474,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;
@@ -1692,12 +2781,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);
 }
@@ -1719,13 +2813,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;
@@ -1741,6 +2866,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) {
@@ -1818,6 +2945,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) {
@@ -1855,6 +2984,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,
@@ -1872,6 +3002,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)
@@ -1888,14 +3020,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([
@@ -1910,6 +3044,7 @@ async function unifiedSearch2(db, sessionId, projectPath, query, options = {}) {
       workspace,
       visibleMemoryIds: options.visibleMemoryIds,
       backfillMemoryEmbeddings: options.backfillMemoryEmbeddings,
+      lanes,
       dateRange
     }) : Promise.resolve({
       results: [],
@@ -1922,7 +3057,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,
@@ -1931,14 +3067,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([])
@@ -1946,23 +3083,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
     });
   }
@@ -2103,4 +3254,4 @@ ${bodyParts.join(`
 `)}`;
 }
 
-export { indexCommitsForProject, embedUnembeddedCommits, createUnifiedSearchDiagnostics2, searchMessageHistory2, parseIdShapedQuery2, resolveMemoriesByIdsForSearch2, unifiedSearch2, formatSearchResults2 };
+export { renderSingleStoreMigrationRequiredRefusal, SingleStoreMigrationRequiredError, singleStoreMigrationRequiredFailure, projectNeedsSingleStoreMigration, STORE_AHEAD_OF_BINARY_CODE, storeAheadOfBinaryFailure, TRANSFORM_PAGE_UPLOAD_TIMEOUT_MS, transformColdStartExecuteTimeoutMs, MAX_WRAPUP_REQUEST_BUDGET_MS, getDefaultSubcConnectionFile, isModuleTransportGenerationChangedResult, SubcModuleTransport, indexCommitsForProject, embedUnembeddedCommits, createUnifiedSearchDiagnostics2, searchMessageHistory2, parseIdShapedQuery2, resolveMemoriesByIdsForSearch2, unifiedSearch2, formatSearchResults2 };