@cortexkit/pi-magic-context 0.49.34 → 0.49.36

package/dist/expand-attachments-8sxeyj26.js

@@ -0,0 +1,21 @@
+// ../plugin/src/v2/hooks/expand-attachments.ts
+function createV2RecoveryAttachments(reader) {
+  return (sessionId, messageId) => {
+    const row = reader.messageById(sessionId, messageId);
+    if (row?.type !== "user" || !Array.isArray(row.data.files))
+      return [];
+    return row.data.files.map((file, index) => {
+      const source = file.source;
+      return {
+        type: "file",
+        filename: file.name,
+        mime: file.mime,
+        url: source?.uri,
+        partIndex: index + 1
+      };
+    });
+  };
+}
+export {
+  createV2RecoveryAttachments
+};

package/dist/historian-calibration-extension.js

@@ -10,8 +10,9 @@ import {
 } from "./index-0b5kqg7n.js";
 import"./index-4knyh1kt.js";
 import"./index-6x556c2q.js";
-import"./index-fgs78jyd.js";
+import"./index-gymgz20n.js";
 import"./index-0h2mkab2.js";
+import"./index-dnp1jjar.js";
 export {
   HISTORIAN_CACHE_TAIL_ENV2 as HISTORIAN_CACHE_TAIL_ENV,
   HISTORIAN_MAX_OUTPUT_TOKENS_ENV2 as HISTORIAN_MAX_OUTPUT_TOKENS_ENV,

package/dist/{index-hqw0rt9k.js → index-0wtm7g7f.js}

@@ -1,6 +1,6 @@
 import {
   log2
-} from "./index-fgs78jyd.js";
+} from "./index-gymgz20n.js";
 
 // ../plugin/src/shared/write-transaction-timing.ts
 var SLOW_WRITE_TRANSACTION_THRESHOLD_MS = 1000;

package/dist/{index-wqpjhx1p.js → index-2qqsnh1b.js}

@@ -3,7 +3,7 @@ import {
 } from "./index-ccanzg8p.js";
 import {
   getSynapseLaneIdentity
-} from "./index-gwxaz0z5.js";
+} from "./index-rzfr7wdv.js";
 import {
   getHarness2
 } from "./index-0h2mkab2.js";
@@ -11,7 +11,7 @@ import {
   getMagicContextStorageDir,
   importPluginModule,
   log2
-} from "./index-fgs78jyd.js";
+} from "./index-gymgz20n.js";
 import {
   inRootAsyncContext2
 } from "./index-2qtx0q6h.js";

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-399p688g.js → index-8sqebjzk.js}

@@ -15,5 +15,8 @@ function registerExitAbort(controller) {
   listenerRegistered = true;
   process.once("exit", abortAll);
 }
+function unregisterExitAbort(controller) {
+  controllers.delete(controller);
+}
 
-export { registerExitAbort };
+export { registerExitAbort, unregisterExitAbort };