@cortexkit/pi-magic-context 0.49.33 → 0.49.35

package/dist/index-3bb24eb6.js

@@ -0,0 +1,229 @@
+import {
+  sanitizeDiagnosticText
+} from "./index-dnp1jjar.js";
+
+// ../plugin/src/features/magic-context/fail-closed-block.ts
+var FAIL_CLOSED_DOCTOR_COMMAND = "npx @cortexkit/magic-context@latest doctor";
+var FAIL_CLOSED_REPROBE_EVERY_N = 5;
+function attachFailClosedBlockingProcessEvidence(process, evidence) {
+  Object.defineProperties(process, {
+    startTime: { configurable: true, value: evidence.startTime },
+    commandLine: { configurable: true, value: evidence.commandLine }
+  });
+  return process;
+}
+
+class FailClosedBlockingError extends Error {
+  code = "FAIL_CLOSED_BLOCKING";
+  reason;
+  constructor(message, reason, options) {
+    super(message, options);
+    this.name = "FailClosedBlockingError";
+    this.reason = reason;
+  }
+}
+var OPENCODE_INTERNAL_AGENT_NAMES = new Set(["title", "summary", "compaction"]);
+function isMagicContextHiddenAgentName(agent) {
+  if (agent === "smart-note-compiler" || agent.startsWith("smart-note-")) {
+    return true;
+  }
+  if (agent === "historian" || agent.startsWith("historian-"))
+    return true;
+  if (agent === "dreamer" || agent.startsWith("dreamer-"))
+    return true;
+  return false;
+}
+var MAX_FORMATTED_BLOCKING_PROCESSES = 8;
+var MAX_FORMATTED_COMMAND_LINE_LENGTH = 80;
+function normalizeFailClosedProcessKind(process) {
+  switch (process.kind) {
+    case "OpenCode server":
+    case "OpenCode instance (TUI/CLI)":
+    case "Pi":
+    case "process":
+      return process.kind;
+  }
+  switch (process.harness?.trim().toLowerCase()) {
+    case "opencode server":
+      return "OpenCode server";
+    case "opencode instance (tui/cli)":
+    case "opencode instance":
+      return "OpenCode instance (TUI/CLI)";
+    case "pi":
+    case "pi harness":
+    case "omp":
+      return "Pi";
+    default:
+      return "process";
+  }
+}
+function formatFailClosedProcessStartTime(startTime) {
+  if (!Number.isFinite(startTime) || startTime <= 0)
+    return "unverified";
+  try {
+    const parts = new Intl.DateTimeFormat("en-US", {
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit",
+      month: "short",
+      hour12: false
+    }).formatToParts(new Date(startTime));
+    const values = Object.fromEntries(parts.map(({ type, value }) => [type, value]));
+    if (!values.month || !values.day || !values.hour || !values.minute)
+      return "unverified";
+    return `${values.month} ${values.day} ${values.hour}:${values.minute}`;
+  } catch {
+    return "unverified";
+  }
+}
+function formatFailClosedCommandLine(commandLine) {
+  if (typeof commandLine !== "string" || commandLine.trim().length === 0)
+    return "unverified";
+  try {
+    const normalized = commandLine.replaceAll("\x00", " ").replace(/\s+/g, " ").trim();
+    if (normalized.length === 0)
+      return "unverified";
+    const sanitized = sanitizeDiagnosticText(normalized).trim();
+    if (sanitized.length === 0)
+      return "unverified";
+    return sanitized.length > MAX_FORMATTED_COMMAND_LINE_LENGTH ? `${sanitized.slice(0, MAX_FORMATTED_COMMAND_LINE_LENGTH - 3)}...` : sanitized;
+  } catch {
+    return "unverified";
+  }
+}
+function formatFailClosedBlockingProcesses(processes) {
+  const uniqueProcesses = new Map;
+  for (const process of processes) {
+    if (!Number.isInteger(process.pid) || process.pid <= 0)
+      continue;
+    const candidate = {
+      kind: normalizeFailClosedProcessKind(process),
+      pid: process.pid,
+      startTime: process.startTime,
+      commandLine: process.commandLine
+    };
+    const previous = uniqueProcesses.get(process.pid);
+    if (!previous || previous.kind === "process" && candidate.kind !== "process") {
+      uniqueProcesses.set(process.pid, candidate);
+    } else {
+      uniqueProcesses.set(process.pid, {
+        ...previous,
+        startTime: previous.startTime ?? candidate.startTime,
+        commandLine: previous.commandLine ?? candidate.commandLine
+      });
+    }
+  }
+  const entries = [...uniqueProcesses.values()];
+  const visible = entries.slice(0, MAX_FORMATTED_BLOCKING_PROCESSES);
+  const rendered = visible.map(({ kind, pid }) => `${kind} (PID ${pid})`);
+  const omitted = entries.length - visible.length;
+  if (omitted > 0)
+    rendered.push(`${omitted} more blocking process(es)`);
+  if (rendered.length === 0)
+    return "a live process";
+  const summary = rendered.length === 1 ? rendered[0] : `${rendered.slice(0, -1).join(", ")}, and ${rendered.at(-1)}`;
+  const evidence = entries.map(({ kind, pid, startTime, commandLine }) => `- PID ${pid}: ${kind}, started ${formatFailClosedProcessStartTime(startTime)}, cmd: ${formatFailClosedCommandLine(commandLine)}`).join(`
+`);
+  return `${summary}
+Blocking process evidence:
+${evidence}`;
+}
+function formatFailClosedBlockingMessage(reason) {
+  if (reason.kind === "migration_guard") {
+    if (reason.unreadableFile) {
+      const arm = reason.unreadableArm ?? "io";
+      const recovery = arm === "io" ? `If none of these processes are running, it is safe to delete ${reason.unreadableFile} and retry.` : `The file may be a recent incomplete write; retry after the file is older than the ten-minute grace window, or stop the relevant process before deleting it.`;
+      return [
+        `Magic Context cannot migrate the shared database because RPC discovery file ${reason.unreadableFile} is uncertain (${arm} arm), so the absence of a live process cannot be proven.`,
+        recovery,
+        `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
+      ].join(" ");
+    }
+    return [
+      `Magic Context cannot migrate the shared database (one database serves every project on this machine) because ${formatFailClosedBlockingProcesses(reason.blockingProcesses)} may be running an older Magic Context build that would fail against the migrated database.`,
+      `The database is at upstream migration v${reason.persistedVersion}; this build needs v${reason.supportedVersion}.`,
+      "Restart the blocking process — even one from a different project — and it will pick up the new build and migrate on start; or shut it down and retry.",
+      "If that host loads a pinned or cached older Magic Context build, a restart alone is not enough: stop it or update its Magic Context build, then start this host once so it migrates the database with nothing older attached.",
+      `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
+    ].join(" ");
+  }
+  if (reason.kind === "schema_fence") {
+    return [
+      `Magic Context cannot operate: this Magic Context build is older than the database; upgrade/restart this harness (upstream migration lane v${reason.persistedVersion}, build supports through v${reason.supportedVersion}).`,
+      `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
+    ].join(" ");
+  }
+  const cause = reason.cause.trim().length > 0 ? reason.cause.trim() : "unknown storage error";
+  return [
+    `Magic Context cannot operate: persistent storage failed (${cause}).`,
+    "The plugin will not silently degrade to native compaction while enabled.",
+    `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
+  ].join(" ");
+}
+function createFailClosedBlockingError(reason, options) {
+  return new FailClosedBlockingError(formatFailClosedBlockingMessage(reason), reason, options);
+}
+function isFailClosedBlockingError(error) {
+  return error instanceof FailClosedBlockingError || typeof error === "object" && error !== null && error.name === "FailClosedBlockingError" && error.code === "FAIL_CLOSED_BLOCKING";
+}
+function shouldBypassFailClosedBlock(input) {
+  if (input.isPiSubagentEnv === true)
+    return true;
+  if (input.isInternalChildSession === true)
+    return true;
+  const agent = typeof input.agent === "string" ? input.agent.trim() : "";
+  if (agent.length === 0)
+    return false;
+  if (OPENCODE_INTERNAL_AGENT_NAMES.has(agent))
+    return true;
+  if (isMagicContextHiddenAgentName(agent))
+    return true;
+  return false;
+}
+function createFailClosedController(options) {
+  const reprobeEveryN = Math.max(1, options?.reprobeEveryN ?? FAIL_CLOSED_REPROBE_EVERY_N);
+  let reason = null;
+  let blockedPassCount = 0;
+  return {
+    arm(next) {
+      reason = next;
+      blockedPassCount = 0;
+    },
+    clear() {
+      reason = null;
+      blockedPassCount = 0;
+    },
+    isArmed() {
+      return reason !== null;
+    },
+    getReason() {
+      return reason;
+    },
+    async enforce(input) {
+      if (!reason)
+        return;
+      if (!input.blockingEnabled)
+        return;
+      if (input.exempt)
+        return;
+      blockedPassCount += 1;
+      const shouldReprobe = typeof input.tryReopen === "function" && (blockedPassCount === 1 || blockedPassCount % reprobeEveryN === 0);
+      if (shouldReprobe) {
+        try {
+          const healed = await input.tryReopen?.();
+          if (healed) {
+            reason = null;
+            blockedPassCount = 0;
+            return;
+          }
+        } catch {}
+      }
+      const blockedReason = reason;
+      if (!blockedReason)
+        return;
+      throw createFailClosedBlockingError(blockedReason);
+    }
+  };
+}
+
+export { FAIL_CLOSED_DOCTOR_COMMAND, attachFailClosedBlockingProcessEvidence, formatFailClosedBlockingMessage, createFailClosedBlockingError, isFailClosedBlockingError, shouldBypassFailClosedBlock, createFailClosedController };

package/dist/{index-48twbev2.js → index-6pk49fc3.js}

@@ -1,10 +1,13 @@
 import {
   getMagicContextStorageDir,
   log2
-} from "./index-fgs78jyd.js";
+} from "./index-gymgz20n.js";
 import {
   inRootAsyncContext2
 } from "./index-2qtx0q6h.js";
+import {
+  projectDirectoryKey
+} from "./index-wrr9rp9a.js";
 import {
   writeStorageFileAtomicSync
 } from "./index-81nthk8j.js";
@@ -14,32 +17,15 @@ import { execFileSync } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
 import { existsSync, realpathSync as realpathSync2, statSync as statSync2 } from "node:fs";
 import { homedir } from "node:os";
-import path4 from "node:path";
+import path3 from "node:path";
 
 // ../plugin/src/features/magic-context/memory/project-identity-cache.ts
 import { createHash } from "node:crypto";
 import { promises as fs, readFileSync } from "node:fs";
-import path2 from "node:path";
-
-// ../plugin/src/shared/project-directory-key.ts
 import path from "node:path";
-function projectDirectoryKey(directory) {
-  const slashed = directory.replaceAll("\\", "/").replace(/^\/\/\?\/UNC\//i, "//").replace(/^\/\/\?\//, "");
-  if (/^[a-z]:\//i.test(slashed) || slashed.startsWith("//")) {
-    return path.win32.normalize(slashed).replaceAll("\\", "/").replace(/\/$/, "").toLowerCase();
-  }
-  return path.resolve(directory);
-}
-function sameProjectDirectory(a, b) {
-  if (a.length === 0 || b.length === 0)
-    return false;
-  return projectDirectoryKey(a) === projectDirectoryKey(b);
-}
-
-// ../plugin/src/features/magic-context/memory/project-identity-cache.ts
 function cachePath(directory, storageDir = getMagicContextStorageDir()) {
   const hash = createHash("sha256").update(projectDirectoryKey(directory)).digest("hex");
-  return path2.join(storageDir, "project-identities", `${hash}.json`);
+  return path.join(storageDir, "project-identities", `${hash}.json`);
 }
 function rememberGitIdentity(directory, identity) {
   try {
@@ -56,7 +42,7 @@ function readRememberedGitIdentity(directory, storageDir) {
   return;
 }
 async function pruneMissingProjectIdentities(storageDir = getMagicContextStorageDir()) {
-  const directory = path2.join(storageDir, "project-identities");
+  const directory = path.join(storageDir, "project-identities");
   let removed = 0;
   let entries;
   try {
@@ -67,10 +53,10 @@ async function pruneMissingProjectIdentities(storageDir = getMagicContextStorage
   for (const entry of entries) {
     if (!/^[0-9a-f]{64}\.json$/.test(entry))
       continue;
-    const file = path2.join(directory, entry);
+    const file = path.join(directory, entry);
     try {
       const record = JSON.parse(await fs.readFile(file, "utf8"));
-      if (typeof record.directory !== "string" || !path2.isAbsolute(record.directory) || cachePath(record.directory, storageDir) !== file || !/^git:[0-9a-f]{7,64}$/.test(record.identity))
+      if (typeof record.directory !== "string" || !path.isAbsolute(record.directory) || cachePath(record.directory, storageDir) !== file || !/^git:[0-9a-f]{7,64}$/.test(record.identity))
         continue;
       try {
         await fs.stat(record.directory);
@@ -87,7 +73,7 @@ async function pruneMissingProjectIdentities(storageDir = getMagicContextStorage
 
 // ../plugin/src/features/magic-context/memory/unborn-head.ts
 import { readFileSync as readFileSync2, realpathSync, statSync } from "node:fs";
-import path3 from "node:path";
+import path2 from "node:path";
 var GIT_LOCATION_ENV_VARS = [
   "GIT_DIR",
   "GIT_COMMON_DIR",
@@ -123,7 +109,7 @@ function stripLineEnding(text) {
   return text.replace(/\r?\n$/u, "");
 }
 function resolveMetadataPath(baseDirectory, value) {
-  return path3.resolve(baseDirectory, value);
+  return path2.resolve(baseDirectory, value);
 }
 function isPlainBranchName(name) {
   if (name.length === 0 || name.endsWith("/") || name.endsWith("."))
@@ -140,7 +126,7 @@ function isPlainBranchName(name) {
 function findGitDirectory(start) {
   let current = start;
   while (true) {
-    const dotGit = path3.join(current, ".git");
+    const dotGit = path2.join(current, ".git");
     const kind = entryKind(dotGit);
     if (kind === "directory")
       return dotGit;
@@ -156,7 +142,7 @@ function findGitDirectory(start) {
     }
     if (kind !== "missing")
       return;
-    const parent = path3.dirname(current);
+    const parent = path2.dirname(current);
     if (parent === current)
       return;
     current = parent;
@@ -181,7 +167,7 @@ function isUnbornHeadInLayout(directory) {
   if (gitDirectory === undefined)
     return false;
   let commonDirectory = gitDirectory;
-  const commondir = readText(path3.join(gitDirectory, "commondir"));
+  const commondir = readText(path2.join(gitDirectory, "commondir"));
   if (commondir.ok) {
     const value = stripLineEnding(commondir.text);
     if (value === "" || value.includes(`
@@ -191,22 +177,22 @@ function isUnbornHeadInLayout(directory) {
   } else if (!commondir.missing) {
     return false;
   }
-  if (entryKind(path3.join(gitDirectory, "HEAD")) !== "file")
+  if (entryKind(path2.join(gitDirectory, "HEAD")) !== "file")
     return false;
-  if (entryKind(path3.join(commonDirectory, "objects")) !== "directory")
+  if (entryKind(path2.join(commonDirectory, "objects")) !== "directory")
     return false;
-  if (entryKind(path3.join(commonDirectory, "refs")) !== "directory")
+  if (entryKind(path2.join(commonDirectory, "refs")) !== "directory")
     return false;
-  if (entryKind(path3.join(commonDirectory, "reftable")) !== "missing")
+  if (entryKind(path2.join(commonDirectory, "reftable")) !== "missing")
     return false;
-  const config = readText(path3.join(commonDirectory, "config"));
+  const config = readText(path2.join(commonDirectory, "config"));
   if (config.ok) {
     if (/refstorage/iu.test(config.text))
       return false;
   } else if (!config.missing) {
     return false;
   }
-  const head = readText(path3.join(gitDirectory, "HEAD"));
+  const head = readText(path2.join(gitDirectory, "HEAD"));
   if (!head.ok)
     return false;
   const headMatch = /^ref: (refs\/heads\/(.+))$/u.exec(head.text.replace(/\s+$/u, ""));
@@ -216,10 +202,10 @@ function isUnbornHeadInLayout(directory) {
     return false;
   const refSegments = ref.split("/");
   for (const base of new Set([commonDirectory, gitDirectory])) {
-    if (entryKind(path3.join(base, ...refSegments)) !== "missing")
+    if (entryKind(path2.join(base, ...refSegments)) !== "missing")
       return false;
   }
-  const packed = readText(path3.join(commonDirectory, "packed-refs"));
+  const packed = readText(path2.join(commonDirectory, "packed-refs"));
   if (packed.ok) {
     if (packedRefsList(packed.text, ref) !== false)
       return false;
@@ -234,7 +220,7 @@ function isUnbornHeadOnDisk(directory, env = process.env) {
   }
   let realDirectory;
   try {
-    realDirectory = realpathSync.native(path3.resolve(directory));
+    realDirectory = realpathSync.native(path2.resolve(directory));
   } catch {
     return false;
   }
@@ -316,7 +302,7 @@ function getErrorStderr(error) {
   return "";
 }
 function directoryFallback(directory) {
-  const canonical = path4.resolve(directory);
+  const canonical = path3.resolve(directory);
   const hash = createHash2("md5").update(canonical, "utf8").digest("hex").slice(0, 12);
   return `dir:${hash}`;
 }
@@ -388,7 +374,7 @@ function classifyGitError(error, rawDirectory) {
 }
 function resolveProjectIdentityStrict(directory, allowHomeProject = homeProjectPermission, options = {}) {
   assertProjectAllowed(directory, allowHomeProject);
-  const canonical = path4.resolve(directory);
+  const canonical = path3.resolve(directory);
   const cached = options.cache === false ? undefined : identityCache.get(canonical);
   if (cached !== undefined) {
     return cached;
@@ -460,9 +446,9 @@ function nearestLastKnownGitIdentity(canonical) {
       const cached = lastKnownGitIdentity(current);
       if (cached !== undefined)
         return { identity: cached, source: current };
-      if (existsSync(path4.join(current, ".git")))
+      if (existsSync(path3.join(current, ".git")))
         break;
-      const parent = path4.dirname(current);
+      const parent = path3.dirname(current);
       if (parent === current)
         break;
       current = parent;
@@ -512,20 +498,20 @@ function isUserHomeDirectory(directory) {
   if (projectDirectoryKey(directory) === projectDirectoryKey(userHomeDirectoryForIdentity()))
     return true;
   try {
-    return projectDirectoryKey(realpathSync2.native(path4.resolve(directory))) === projectDirectoryKey(canonicalUserHomeDirectory());
+    return projectDirectoryKey(realpathSync2.native(path3.resolve(directory))) === projectDirectoryKey(canonicalUserHomeDirectory());
   } catch {
     return false;
   }
 }
 function assertProjectAllowed(directory, allowHomeProject) {
-  const canonical = path4.resolve(directory);
+  const canonical = path3.resolve(directory);
   if (!allowHomeProject && (isUserHomeDirectory(directory) || isUserHomeDirectory(gitRootDirectory(canonical) ?? canonical))) {
     throw new ProjectIdentityError("home_project_disabled", directory, "Home project memory is disabled; set allow_home_project to opt in");
   }
 }
 function resolveProjectIdentity(directory, allowHomeProject = homeProjectPermission) {
   assertProjectAllowed(directory, allowHomeProject);
-  const canonical = path4.resolve(directory);
+  const canonical = path3.resolve(directory);
   const cachedFallback = directoryFallbackCache.get(canonical);
   if (cachedFallback !== undefined) {
     if (!hasGitDir(canonical)) {
@@ -573,7 +559,7 @@ function resolveProjectIdentityOrFallback(directory, allowHomeProject = homeProj
   try {
     return resolveProjectIdentity(directory, allowHomeProject);
   } catch (error) {
-    const canonical = path4.resolve(directory);
+    const canonical = path3.resolve(directory);
     if (hasGitDir(canonical) || error instanceof ProjectIdentityError && error.errorClass === "home_project_disabled")
       throw error;
     const fallback = rememberedIdentityOrDirectoryFallback(canonical);
@@ -596,14 +582,14 @@ function hasGitDir(canonical) {
 function gitRootInAncestorChain(startDirectory) {
   let current = startDirectory;
   while (true) {
-    if (existsSync(path4.join(current, ".git"))) {
+    if (existsSync(path3.join(current, ".git"))) {
       try {
         return realpathSync2.native(current);
       } catch {
-        return path4.resolve(current);
+        return path3.resolve(current);
       }
     }
-    const parent = path4.dirname(current);
+    const parent = path3.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -625,13 +611,13 @@ function gitRootDirectory(canonical) {
   }
 }
 function directoryHasGitMetadata(directory) {
-  return gitRootDirectory(path4.resolve(directory)) !== null;
+  return gitRootDirectory(path3.resolve(directory)) !== null;
 }
 function isUsableProjectIdentity(identity) {
   return typeof identity === "string" && identity.trim().length > 0;
 }
 function resolveProjectIdentityForSession(directory, allowHomeProject = homeProjectPermission) {
-  const resolvedDirectory = path4.resolve(directory);
+  const resolvedDirectory = path3.resolve(directory);
   const cacheKey = `${allowHomeProject ? "1" : "0"}\x00${resolvedDirectory}`;
   const cached = sessionIdentityCache.get(cacheKey);
   if (cached && (cached.revalidateAt === null || nowMs() < cached.revalidateAt) && !(cached.identity?.startsWith("dir:") && hasGitDir(resolvedDirectory))) {
@@ -710,4 +696,4 @@ function setBootQuietPeriodForTests(startAtMs) {
   bootQuietUntilMs = startAtMs === null ? 0 : startAtMs + BOOT_QUIET_MS;
 }
 
-export { sameProjectDirectory, pruneMissingProjectIdentities, setHomeProjectPermission, ProjectIdentityError, resolveProjectIdentityStrict, isUserHomeDirectory, resolveProjectIdentity, directoryHasGitMetadata, isUsableProjectIdentity, resolveProjectIdentityForSession, normalizeStoredProjectPath, storedPathBelongsToIdentity, beginBootQuietPeriod, scheduleAfterBootQuiet, setBootQuietPeriodForTests };
+export { pruneMissingProjectIdentities, setHomeProjectPermission, ProjectIdentityError, resolveProjectIdentityStrict, isUserHomeDirectory, resolveProjectIdentity, directoryHasGitMetadata, isUsableProjectIdentity, resolveProjectIdentityForSession, normalizeStoredProjectPath, storedPathBelongsToIdentity, beginBootQuietPeriod, scheduleAfterBootQuiet, setBootQuietPeriodForTests };

package/dist/index-6y6v2wvn.js

@@ -0,0 +1,194 @@
+import {
+  registerExitAbort
+} from "./index-399p688g.js";
+import {
+  inRootAsyncContext2
+} from "./index-2qtx0q6h.js";
+import {
+  createWorkerShutdown
+} from "./index-54wmg4rj.js";
+
+// ../plugin/src/tools/ctx-expand/v2-archive-reader.ts
+import { Worker } from "node:worker_threads";
+var worker;
+var shutdown;
+var ready;
+var idle;
+var startingTimer;
+var rejectStart;
+var nextId = 0;
+var exitRegistered = false;
+var pending = new Map;
+async function stopV2ArchiveReader() {
+  const closing = shutdown;
+  worker = undefined;
+  shutdown = undefined;
+  ready = undefined;
+  clearTimeout(idle);
+  clearTimeout(startingTimer);
+  rejectStart?.(new Error("Search archive worker unavailable: reader stopped"));
+  rejectStart = undefined;
+  for (const item of pending.values()) {
+    clearTimeout(item.timer);
+    item.reject(new Error("Search archive worker unavailable: reader stopped"));
+  }
+  pending.clear();
+  await closing?.close();
+}
+function start() {
+  if (ready)
+    return ready;
+  if (!exitRegistered) {
+    exitRegistered = true;
+    const controller = new AbortController;
+    controller.signal.addEventListener("abort", () => {
+      stopV2ArchiveReader();
+    }, { once: true });
+    registerExitAbort(controller);
+  }
+  ready = new Promise((resolve, reject) => {
+    rejectStart = reject;
+    const entry = new URL(import.meta.url.endsWith(".ts") ? "../../hooks/magic-context/raw-ordinal-warmup-worker.ts" : "./raw-ordinal-warmup-worker.js", import.meta.url);
+    const current = inRootAsyncContext2(() => new Worker(entry, { workerData: { v2ArchiveReader: true } }));
+    worker = current;
+    shutdown = createWorkerShutdown(current, "v2-archive-reader", 2000);
+    current.unref();
+    const fail = (detail) => {
+      if (worker !== current)
+        return;
+      clearTimeout(startingTimer);
+      reject(new Error(`Search archive worker unavailable: ${detail}`));
+      stopV2ArchiveReader();
+    };
+    startingTimer = setTimeout(() => fail("reader did not start"), 1e4);
+    startingTimer.unref?.();
+    current.on("error", (error) => fail(String(error)));
+    current.on("exit", (code) => fail(`exit code ${code}`));
+    current.on("message", (reply) => {
+      if (worker !== current)
+        return;
+      if (reply.kind === "v2-archive-ready") {
+        clearTimeout(startingTimer);
+        rejectStart = undefined;
+        resolve();
+      } else if (reply.kind === "v2-archive-result") {
+        const item = pending.get(reply.id);
+        if (!item)
+          return;
+        pending.delete(reply.id);
+        clearTimeout(item.timer);
+        if (reply.error)
+          item.reject(new Error(`Search archive worker unavailable: ${reply.error}`));
+        else
+          item.resolve(reply.text);
+        if (pending.size === 0) {
+          idle = setTimeout(() => {
+            stopV2ArchiveReader();
+          }, 60000);
+          idle.unref?.();
+        }
+      }
+    });
+  });
+  return ready;
+}
+async function readV2ArchiveOffThread2(path, rawPath, sessionId, read) {
+  try {
+    clearTimeout(idle);
+    await start();
+    const current = worker;
+    if (!current)
+      throw new Error("Search archive worker unavailable: reader stopped");
+    return await new Promise((resolve, reject) => {
+      const id = ++nextId;
+      const timer = setTimeout(() => {
+        stopV2ArchiveReader();
+      }, 10 * 60000);
+      timer.unref?.();
+      pending.set(id, { resolve, reject, timer });
+      try {
+        current.postMessage({
+          kind: "v2-archive-read",
+          id,
+          path,
+          rawPath,
+          sessionId,
+          read
+        });
+      } catch {
+        stopV2ArchiveReader();
+      }
+    });
+  } catch (error) {
+    await stopV2ArchiveReader();
+    if (error instanceof Error && error.message.startsWith("Search archive worker unavailable:"))
+      throw error;
+    throw new Error(`Search archive worker unavailable: ${String(error)}`);
+  }
+}
+async function serveV2ArchiveReads2(port, openConnections) {
+  const [
+    { Database },
+    { V2StoreReaderPool },
+    { createV2RawMessageReader, createV2RawMessageProvider },
+    { setBoundedRawMessageProvider },
+    { renderItemByTag, renderMessageByOrdinal, renderVerboseRangeForTool },
+    { renderSearchArchive },
+    { createV2RecoveryAttachments }
+  ] = await Promise.all([
+    import("./sqlite-v89bj0yy.js"),
+    import("./store-reader-2m80zs5z.js"),
+    import("./store-kabezr25.js"),
+    import("./read-session-chunk-nbcznexm.js"),
+    import("./render-d931g2vv.js"),
+    import("./search-archive-a76pp30g.js"),
+    import("./expand-attachments-8sxeyj26.js")
+  ]);
+  const pool = new V2StoreReaderPool;
+  openConnections.add(pool);
+  port.on("message", (request) => {
+    if (request.kind !== "v2-archive-read")
+      return;
+    let db;
+    let unregister;
+    let rawReader;
+    let reply;
+    try {
+      db = new Database(request.path, { readonly: true, fileMustExist: true });
+      openConnections.add(db);
+      db.exec("PRAGMA busy_timeout = 250");
+      const raw = pool.open(request.rawPath);
+      rawReader = raw;
+      const reader = createV2RawMessageReader(() => raw, undefined, () => {});
+      const attachments = createV2RecoveryAttachments(raw);
+      unregister = setBoundedRawMessageProvider(request.sessionId, createV2RawMessageProvider(reader, request.sessionId));
+      const read = request.read;
+      let text;
+      if (read.kind === "tag") {
+        text = renderItemByTag(db, request.sessionId, read.tag, "part", attachments);
+      } else {
+        const start = read.kind === "message" ? read.message : read.start;
+        const end = read.kind === "message" ? read.message : read.end;
+        text = renderSearchArchive(db, request.sessionId, start, end, read.tokenBudget, read.kind === "archive" && read.archiveOnly, () => reader.ordinalMapForRange(request.sessionId, start, end));
+        if (text === null && read.kind === "message") {
+          text = renderMessageByOrdinal(request.sessionId, read.message, attachments);
+        } else if (text === null && read.kind === "verbose") {
+          text = renderVerboseRangeForTool(request.sessionId, start, end, read.tokenBudget, read.expandTools, attachments);
+        }
+      }
+      reply = { kind: "v2-archive-result", id: request.id, text };
+    } catch (error) {
+      reply = { kind: "v2-archive-result", id: request.id, text: null, error: String(error) };
+    } finally {
+      unregister?.();
+      rawReader?.close();
+      if (db)
+        openConnections.delete(db);
+      db?.close();
+    }
+    port.postMessage(reply);
+  });
+  port.postMessage({ kind: "v2-archive-ready" });
+}
+
+export { readV2ArchiveOffThread2, serveV2ArchiveReads2 };