@cortexkit/opencode-magic-context 0.49.34 → 0.49.36

package/dist/v2/recomp-orchestrator-9cjk6aej.js

@@ -0,0 +1,68 @@
+import {
+  isRecompFailure2,
+  isRecompSkip2,
+  extractRecompReason2,
+  setRecompStarting2,
+  setRecompNote2,
+  setRecompTerminal2,
+  buildRecompDeps2,
+  runManagedRecomp2
+} from "./server-5by3vdzs.js";
+import"./server-r4430x9m.js";
+import"./server-nq3cb7be.js";
+import"./server-gkse1wyz.js";
+import"./server-jjvbk92s.js";
+import"./server-7acq7815.js";
+import"./server-4dhv7mqz.js";
+import"./server-t8y64xj7.js";
+import"./server-ypf1ap0v.js";
+import"./server-dfq5vb8j.js";
+import"./server-2amn2s73.js";
+import"./server-ef1mskas.js";
+import"./server-sd8hvzte.js";
+import"./server-bez34e60.js";
+import"./server-qt1qqasc.js";
+import"./server-jd7vzwn4.js";
+import"./server-xfjjbrkt.js";
+import"./server-1zx87sdm.js";
+import"./server-mfn1yf9d.js";
+import"./server-f0j864ma.js";
+import"./server-avdveykk.js";
+import"./server-qxzbmtqt.js";
+import"./server-x8a7jmkh.js";
+import"./server-6vzh6wej.js";
+import"./server-7zacmty5.js";
+import"./server-dcws5831.js";
+import"./server-cp1a03vc.js";
+import"./server-zzgtgqmd.js";
+import"./server-g3gqq4ac.js";
+import"./server-fb3zxn06.js";
+import"./server-3schkz95.js";
+import"./server-fr0wbhdn.js";
+import"./server-69m30b21.js";
+import"./server-nmyganc8.js";
+import"./server-468mya5v.js";
+import"./server-sefxj8k1.js";
+import"./server-xy7w7hrd.js";
+import"./server-tpt7bwq8.js";
+import"./server-tnzbk64q.js";
+import"./server-96ztjvkn.js";
+import"./server-v0p37hm2.js";
+import"./server-2ra6pwf3.js";
+import"./server-qmmkhz2z.js";
+import"./server-969cdpmg.js";
+import"./server-gzy5w8ya.js";
+import"./server-jb6tjyeb.js";
+import"./server-pavzsdc6.js";
+import"./server-z4p0ry94.js";
+import"./server-1d042x6w.js";
+export {
+  buildRecompDeps2 as buildRecompDeps,
+  extractRecompReason2 as extractRecompReason,
+  isRecompFailure2 as isRecompFailure,
+  isRecompSkip2 as isRecompSkip,
+  runManagedRecomp2 as runManagedRecomp,
+  setRecompNote2 as setRecompNote,
+  setRecompStarting2 as setRecompStarting,
+  setRecompTerminal2 as setRecompTerminal
+};

package/dist/v2/render-5dz1knf2.js

@@ -0,0 +1,43 @@
+import {
+  renderMessageByOrdinal2,
+  renderVerboseRangeForTool2,
+  renderItemByTag2
+} from "./server-qjyp27vf.js";
+import"./server-t8y64xj7.js";
+import"./server-ypf1ap0v.js";
+import"./server-dfq5vb8j.js";
+import"./server-2amn2s73.js";
+import"./server-ef1mskas.js";
+import"./server-jd7vzwn4.js";
+import"./server-xfjjbrkt.js";
+import"./server-1zx87sdm.js";
+import"./server-mfn1yf9d.js";
+import"./server-7zacmty5.js";
+import"./server-cp1a03vc.js";
+import"./server-zzgtgqmd.js";
+import"./server-g3gqq4ac.js";
+import"./server-fb3zxn06.js";
+import"./server-3schkz95.js";
+import"./server-fr0wbhdn.js";
+import"./server-69m30b21.js";
+import"./server-nmyganc8.js";
+import"./server-468mya5v.js";
+import"./server-sefxj8k1.js";
+import"./server-xy7w7hrd.js";
+import"./server-tpt7bwq8.js";
+import"./server-tnzbk64q.js";
+import"./server-96ztjvkn.js";
+import"./server-v0p37hm2.js";
+import"./server-2ra6pwf3.js";
+import"./server-qmmkhz2z.js";
+import"./server-969cdpmg.js";
+import"./server-gzy5w8ya.js";
+import"./server-jb6tjyeb.js";
+import"./server-pavzsdc6.js";
+import"./server-z4p0ry94.js";
+import"./server-1d042x6w.js";
+export {
+  renderItemByTag2 as renderItemByTag,
+  renderMessageByOrdinal2 as renderMessageByOrdinal,
+  renderVerboseRangeForTool2 as renderVerboseRangeForTool
+};

package/dist/v2/{safe-notification-target-khnzg57c.js → safe-notification-target-gphhast7.js}

@@ -1,9 +1,10 @@
 import {
   isDefaultSessionTitle2,
   waitForSafeNotificationTarget2
-} from "./server-1bw1wcbp.js";
-import"./server-6495nmn9.js";
+} from "./server-f0j864ma.js";
+import"./server-jb6tjyeb.js";
 import"./server-pavzsdc6.js";
+import"./server-z4p0ry94.js";
 export {
   isDefaultSessionTitle2 as isDefaultSessionTitle,
   waitForSafeNotificationTarget2 as waitForSafeNotificationTarget

package/dist/v2/search-8yfet25y.js

@@ -0,0 +1,52 @@
+import {
+  createUnifiedSearchDiagnostics2,
+  searchMessageHistory2,
+  parseIdShapedQuery2,
+  resolveMemoriesByIdsForSearch2,
+  unifiedSearch2,
+  formatSearchResults2
+} from "./server-7094pk3w.js";
+import"./server-kaqs6h31.js";
+import"./server-nq3cb7be.js";
+import"./server-gkse1wyz.js";
+import"./server-jjvbk92s.js";
+import"./server-7acq7815.js";
+import"./server-4dhv7mqz.js";
+import"./server-ypf1ap0v.js";
+import"./server-dfq5vb8j.js";
+import"./server-2amn2s73.js";
+import"./server-qt1qqasc.js";
+import"./server-jd7vzwn4.js";
+import"./server-xfjjbrkt.js";
+import"./server-1zx87sdm.js";
+import"./server-mfn1yf9d.js";
+import"./server-6vzh6wej.js";
+import"./server-7zacmty5.js";
+import"./server-dcws5831.js";
+import"./server-cp1a03vc.js";
+import"./server-zzgtgqmd.js";
+import"./server-3schkz95.js";
+import"./server-fr0wbhdn.js";
+import"./server-69m30b21.js";
+import"./server-nmyganc8.js";
+import"./server-xy7w7hrd.js";
+import"./server-tpt7bwq8.js";
+import"./server-tnzbk64q.js";
+import"./server-96ztjvkn.js";
+import"./server-v0p37hm2.js";
+import"./server-2ra6pwf3.js";
+import"./server-qmmkhz2z.js";
+import"./server-969cdpmg.js";
+import"./server-gzy5w8ya.js";
+import"./server-jb6tjyeb.js";
+import"./server-pavzsdc6.js";
+import"./server-z4p0ry94.js";
+import"./server-1d042x6w.js";
+export {
+  createUnifiedSearchDiagnostics2 as createUnifiedSearchDiagnostics,
+  formatSearchResults2 as formatSearchResults,
+  parseIdShapedQuery2 as parseIdShapedQuery,
+  resolveMemoriesByIdsForSearch2 as resolveMemoriesByIdsForSearch,
+  searchMessageHistory2 as searchMessageHistory,
+  unifiedSearch2 as unifiedSearch
+};

package/dist/v2/search-archive-z6z9jqwf.js

@@ -0,0 +1,28 @@
+import {
+  renderSearchArchive2,
+  renderSearchArchiveOffThread2
+} from "./server-a9w5f0yw.js";
+import"./server-e51xmr4d.js";
+import"./server-kaqs6h31.js";
+import"./server-jd7vzwn4.js";
+import"./server-xfjjbrkt.js";
+import"./server-1zx87sdm.js";
+import"./server-mfn1yf9d.js";
+import"./server-7zacmty5.js";
+import"./server-xy7w7hrd.js";
+import"./server-tpt7bwq8.js";
+import"./server-tnzbk64q.js";
+import"./server-96ztjvkn.js";
+import"./server-v0p37hm2.js";
+import"./server-2ra6pwf3.js";
+import"./server-qmmkhz2z.js";
+import"./server-969cdpmg.js";
+import"./server-gzy5w8ya.js";
+import"./server-jb6tjyeb.js";
+import"./server-pavzsdc6.js";
+import"./server-z4p0ry94.js";
+import"./server-1d042x6w.js";
+export {
+  renderSearchArchive2 as renderSearchArchive,
+  renderSearchArchiveOffThread2 as renderSearchArchiveOffThread
+};

package/dist/v2/{send-session-notification-x5nzy34v.js → send-session-notification-kxp47tsw.js}

@@ -8,17 +8,19 @@ import {
   clearIgnoredMessages2,
   observeIgnoredNotificationEvent2,
   sendStatusNotification2
-} from "./server-qc915kw2.js";
+} from "./server-bez34e60.js";
 import"./server-qt1qqasc.js";
-import"./server-a7x00tw8.js";
-import"./server-1bw1wcbp.js";
+import"./server-mfn1yf9d.js";
+import"./server-f0j864ma.js";
+import"./server-tnzbk64q.js";
+import"./server-96ztjvkn.js";
+import"./server-v0p37hm2.js";
 import"./server-2ra6pwf3.js";
-import"./server-6vd2n183.js";
-import"./server-51779zs2.js";
 import"./server-gzy5w8ya.js";
-import"./server-6495nmn9.js";
+import"./server-jb6tjyeb.js";
 import"./server-pavzsdc6.js";
-import"./server-cpjk5jd2.js";
+import"./server-z4p0ry94.js";
+import"./server-1d042x6w.js";
 export {
   MAX_QUEUED_IGNORED_NOTIFICATIONS2 as MAX_QUEUED_IGNORED_NOTIFICATIONS,
   __ignoredNotificationTest2 as __ignoredNotificationTest,

package/dist/v2/{server-cpjk5jd2.js → server-1d042x6w.js}

@@ -3,31 +3,33 @@ var WORKER_CLOSE_MESSAGE = { kind: "close" };
 function isWorkerCloseMessage(message) {
   return typeof message === "object" && message !== null && message.kind === WORKER_CLOSE_MESSAGE.kind;
 }
-function exitOnWorkerClose(port, closeConnections) {
+function exitOnWorkerClose(port, closeConnections, exitThread = true) {
   const listener = (message) => {
     if (!isWorkerCloseMessage(message))
       return;
     try {
       closeConnections();
     } finally {
-      process.exit(0);
+      if (exitThread)
+        process.exit(0);
+      closePort();
     }
   };
   if (!port)
     return { closePort() {} };
-  port.on("message", listener);
+  const owner = port;
+  owner.on("message", listener);
   let closed = false;
-  return {
-    closePort() {
-      if (closed)
-        return;
-      closed = true;
-      setTimeout(() => {
-        port.off("message", listener);
-        port.close();
-      });
-    }
-  };
+  function closePort() {
+    if (closed)
+      return;
+    closed = true;
+    setTimeout(() => {
+      owner.off("message", listener);
+      owner.close();
+    });
+  }
+  return { closePort };
 }
 var outcomes = new Map;
 function createWorkerShutdown(worker, site, deadlineMs) {

package/dist/v2/server-2amn2s73.js

@@ -0,0 +1,123 @@
+import {
+  withSqliteBackgroundWriter2,
+  withoutSqliteTransformPass2,
+  isTransientSqliteError2
+} from "./server-gzy5w8ya.js";
+
+// src/hooks/magic-context/embed-session-state.ts
+var embedPauseBySession = new Set;
+var embedRunStateBySession = new Map;
+var activeEmbeddingSessions = new Map;
+var autoEmbedAttemptedBySession = new Set;
+var autoEmbedIdentityBySession = new Map;
+var autoEmbedRetryAfterBySession = new Map;
+function invalidateAutoEmbedSession(sessionId) {
+  autoEmbedAttemptedBySession.delete(sessionId);
+  autoEmbedIdentityBySession.delete(sessionId);
+  autoEmbedRetryAfterBySession.delete(sessionId);
+}
+function getEmbedDrainUiStatus(sessionId, progress) {
+  if (embedPauseBySession.has(sessionId)) {
+    return { status: "paused" };
+  }
+  const activeRun = embedRunStateBySession.get(sessionId);
+  if (activeRun && !activeRun.signal.aborted || progress?.kind === "embed" && progress.phase === "recomp") {
+    return { status: "running" };
+  }
+  if (progress?.kind === "embed" && (progress.phase === "failed" || progress.phase === "skipped") && progress.message) {
+    if (/provider/i.test(progress.message)) {
+      return { status: "stopped", detail: progress.message };
+    }
+  }
+  return { status: "idle" };
+}
+function clearEmbedSessionState(sessionId) {
+  activeEmbeddingSessions.delete(sessionId);
+  embedPauseBySession.delete(sessionId);
+  const ctrl = embedRunStateBySession.get(sessionId);
+  if (ctrl) {
+    ctrl.abort();
+    embedRunStateBySession.delete(sessionId);
+  }
+  invalidateAutoEmbedSession(sessionId);
+}
+
+// src/shared/background-batch-drain.ts
+async function drainBackgroundBatches(step, options = {}) {
+  const now = options.now ?? (() => performance.now());
+  const deadline = now() + (options.budgetMs ?? 2000);
+  const yieldFn = options.yieldFn ?? (() => new Promise((resolve) => setTimeout(resolve, 0)));
+  let batches = 0;
+  while (now() < deadline) {
+    try {
+      if (!withoutSqliteTransformPass2(() => withSqliteBackgroundWriter2(step)))
+        break;
+    } catch (error) {
+      if (isTransientSqliteError2(error))
+        break;
+      throw error;
+    }
+    batches++;
+    await yieldFn();
+  }
+  return batches;
+}
+
+// src/features/magic-context/storage-embedding-measurements.ts
+import { createHash } from "node:crypto";
+function normalizedQueryHash(query) {
+  const normalized = query.trim().replace(/\s+/g, " ").toLowerCase();
+  return createHash("sha256").update(normalized).digest("hex");
+}
+var MEASUREMENT_CORPUS_SESSION_ROW_CAP = 2000;
+function recordEmbeddingMeasurement(db, input, cap = MEASUREMENT_CORPUS_SESSION_ROW_CAP) {
+  const queryTextHash = normalizedQueryHash(input.queryText);
+  const dedupKey = queryTextHash;
+  const result = db.prepare(`INSERT OR IGNORE INTO embedding_measurement_corpus
+            (session_id, project_path, dedup_key, cohort_key, query_text_hash,
+             primary_result_ids_json, shadow_result_ids_json, primary_latency_ms, shadow_latency_ms,
+             primary_failed, shadow_failed, primary_model_id, shadow_model_id,
+             primary_fingerprint, shadow_fingerprint, primary_epoch, shadow_epoch,
+             corpus_hash, coverage_json, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(input.sessionId, input.projectPath, dedupKey, input.cohortKey, queryTextHash, JSON.stringify(input.primaryResultIds.slice(0, 10)), JSON.stringify(input.shadowResultIds.slice(0, 10)), input.primaryLatencyMs, input.shadowLatencyMs, input.primaryFailed ? 1 : 0, input.shadowFailed ? 1 : 0, input.primaryModelId, input.shadowModelId, input.primaryFingerprint, input.shadowFingerprint, input.primaryEpoch, input.shadowEpoch, input.corpusHash, JSON.stringify(input.coverage), Date.now());
+  if (result.changes > 0) {
+    const rowCount = db.prepare("SELECT COUNT(*) AS count FROM embedding_measurement_corpus WHERE session_id = ?").get(input.sessionId).count;
+    const overflow = rowCount - cap;
+    if (overflow > 0) {
+      db.prepare(`DELETE FROM embedding_measurement_corpus
+                  WHERE session_id = ?
+                    AND id IN (
+                        SELECT id FROM embedding_measurement_corpus
+                        WHERE session_id = ?
+                        ORDER BY id ASC
+                        LIMIT ?
+                    )`).run(input.sessionId, input.sessionId, overflow);
+    }
+  }
+  return result.changes > 0;
+}
+function beginSynapseBatchLedger(db, input, now = Date.now()) {
+  db.prepare(`INSERT INTO synapse_batch_ledger
+            (session_id, project_path, scope, manifest_json, request_key, status, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, 'pending', ?, ?)
+         ON CONFLICT(session_id, request_key) DO UPDATE SET
+            manifest_json = excluded.manifest_json,
+            updated_at = excluded.updated_at`).run(input.sessionId, input.projectPath, input.scope, JSON.stringify(input.manifest), input.requestKey, now, now);
+}
+function finishSynapseBatchLedger(db, sessionId, requestKey, status, now = Date.now()) {
+  db.prepare("UPDATE synapse_batch_ledger SET status = ?, updated_at = ? WHERE session_id = ? AND request_key = ?").run(status, now, sessionId, requestKey);
+}
+var SYNAPSE_BATCH_LEDGER_TTL_MS = 14 * 24 * 60 * 60 * 1000;
+function pruneSynapseBatchLedgerForProject(db, projectIdentity, ttlMs = SYNAPSE_BATCH_LEDGER_TTL_MS) {
+  const ledgerTable = db.prepare("SELECT 1 AS present FROM sqlite_master WHERE type = 'table' AND name = 'synapse_batch_ledger'").get();
+  if (!ledgerTable)
+    return 0;
+  const shadow = `shadow:${projectIdentity}`;
+  const cutoff = Date.now() - ttlMs;
+  const predicate = "session_id IN (?, ?) AND updated_at < ?";
+  if (!db.prepare(`SELECT 1 FROM synapse_batch_ledger WHERE ${predicate} LIMIT 1`).get(projectIdentity, shadow, cutoff))
+    return 0;
+  return db.prepare(`DELETE FROM synapse_batch_ledger WHERE ${predicate}`).run(projectIdentity, shadow, cutoff).changes;
+}
+
+export { embedPauseBySession, embedRunStateBySession, activeEmbeddingSessions, autoEmbedAttemptedBySession, autoEmbedIdentityBySession, autoEmbedRetryAfterBySession, invalidateAutoEmbedSession, getEmbedDrainUiStatus, clearEmbedSessionState, drainBackgroundBatches, recordEmbeddingMeasurement, beginSynapseBatchLedger, finishSynapseBatchLedger, pruneSynapseBatchLedgerForProject };

package/dist/v2/{server-6g98c227.js → server-3schkz95.js}

@@ -3,12 +3,12 @@ import {
 } from "./server-fr0wbhdn.js";
 import {
   log2
-} from "./server-6495nmn9.js";
+} from "./server-jb6tjyeb.js";
 import {
   ensureColumn,
   healAllNullColumns,
   installV95PerfSchema
-} from "./server-v77xa5wj.js";
+} from "./server-tpt7bwq8.js";
 import {
   resolveOpenCodeDbPath,
   openCodeDbPathExists,
@@ -20,10 +20,10 @@ import {
 import {
   normalizeStoredProjectPath,
   storedPathBelongsToIdentity
-} from "./server-qjvk4a9t.js";
+} from "./server-69m30b21.js";
 import {
   logSlowWriteTransaction
-} from "./server-gyy4k6mf.js";
+} from "./server-qmmkhz2z.js";
 
 // src/features/magic-context/migrations.ts
 import { isMainThread } from "node:worker_threads";

package/dist/v2/server-468mya5v.js

@@ -0,0 +1,209 @@
+import {
+  sanitizeDiagnosticText
+} from "./server-z4p0ry94.js";
+
+// src/features/magic-context/fail-closed-block.ts
+var FAIL_CLOSED_DOCTOR_COMMAND = "npx @cortexkit/magic-context@latest doctor";
+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 formatFailClosedBlockingSummary(reason) {
+  if (reason.kind === "migration_guard") {
+    if (reason.unreadableFile) {
+      return `Magic Context cannot migrate the shared database from v${reason.persistedVersion} to v${reason.supportedVersion}: RPC discovery file ${reason.unreadableFile} could not be read, so an older host may still be attached.`;
+    }
+    const blockers = reason.blockingProcesses.filter((process) => Number.isInteger(process.pid) && process.pid > 0).map((process) => `${normalizeFailClosedProcessKind(process)} (PID ${process.pid})`);
+    const named = blockers.length > 0 ? blockers.join(", ") : "a live process";
+    return `Magic Context cannot migrate the shared database from v${reason.persistedVersion} to v${reason.supportedVersion} while ${named} may still run an older Magic Context build. Stop or update that host, then start this one once.`;
+  }
+  if (reason.kind === "schema_fence") {
+    return `Magic Context cannot operate: the shared database is at v${reason.persistedVersion}, newer than this build supports (v${reason.supportedVersion}). Update and restart this host.`;
+  }
+  const cause = reason.cause.trim().length > 0 ? reason.cause.trim() : "unknown storage error";
+  return `Magic Context cannot operate: persistent storage failed (${cause}).`;
+}
+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 resolveAgentNameFromMessages(messages) {
+  for (let i = messages.length - 1;i >= 0; i -= 1) {
+    const info = messages[i]?.info;
+    if (!info || typeof info !== "object")
+      continue;
+    const agent = info.agent;
+    if (typeof agent === "string" && agent.length > 0)
+      return agent;
+  }
+  return;
+}
+
+export { FAIL_CLOSED_DOCTOR_COMMAND, attachFailClosedBlockingProcessEvidence, formatFailClosedBlockingMessage, formatFailClosedBlockingSummary, createFailClosedBlockingError, isFailClosedBlockingError, shouldBypassFailClosedBlock, resolveAgentNameFromMessages };