@jigging/jig 0.1.0-alpha.27 → 0.1.0-alpha.33

package/libexec/installed-cli.js

@@ -7580,7 +7580,7 @@ function readRecord(directory, name) {
   const parent = privateDirectory(directory);
   let fd;
   try {
-    fd = openSync(join(directory, name), constants.O_RDONLY | O_NOFOLLOW_ANY | O_CLOEXEC);
+    fd = openSync(join(directory, name), constants.O_RDONLY | constants.O_NONBLOCK | O_NOFOLLOW_ANY | O_CLOEXEC);
     const before = fstatSync(fd, { bigint: true });
     if (!before.isFile() || before.uid !== BigInt(process.getuid?.() ?? -1) || (before.mode & 0o177n) !== 0n || before.nlink !== 1n || before.size < 1n || before.size > 1024n)
       throw new Error("macOS ownership journal is unsafe");
@@ -9075,19 +9075,19 @@ var init_file_input = __esm(() => {
 
 // src/installed-cli.ts
 import { realpath as realpath25 } from "fs/promises";
-import { dirname as dirname19 } from "path";
+import { dirname as dirname20 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/cli.ts
 import { randomBytes as randomBytes7 } from "crypto";
-import { lstat as lstat19 } from "fs/promises";
-import { basename as basename4, resolve as resolve11 } from "path";
+import { lstat as lstat20 } from "fs/promises";
+import { basename as basename6, resolve as resolve11 } from "path";
 import { createInterface } from "readline";
 import { setTimeout as delay } from "timers/promises";
 // package.json
 var package_default = {
   name: "@jigging/jig",
-  version: "0.1.0-alpha.27",
+  version: "0.1.0-alpha.33",
   description: "A local, secure host for admitted FLOW packages",
   license: "SEE LICENSE IN LICENSE.md",
   repository: {
@@ -15554,6 +15554,16 @@ function snapshotJson(value, label, active = new WeakSet) {
   }
 }
 
+// src/internal/native-agent-turn-policy.ts
+var PRIVATE_NATIVE_TURN_POLICY = Object.freeze({
+  default: 1,
+  minimum: 1,
+  maximum: 8
+});
+function isPrivateNativeTurnAllowance(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= PRIVATE_NATIVE_TURN_POLICY.minimum && value <= PRIVATE_NATIVE_TURN_POLICY.maximum;
+}
+
 // src/project/commands.ts
 function projectCommandPath(value) {
   if (typeof value !== "string" || value.length > 256 || !/^[A-Za-z0-9_][A-Za-z0-9_./-]*$/.test(value) || value.split("/").some((part) => part === "" || part === "." || part === "..") || value.split("/").length > 16)
@@ -15645,8 +15655,8 @@ function normalizeGrant(value) {
   if (kind === "command")
     return Object.freeze({ kind, ...normalizeProjectCommand(policy) });
   if (kind === "acp") {
-    if (Object.keys(policy).some((key) => !["client", "model", "maxTurns", "retainSessions"].includes(key)) || "retainSessions" in policy && (policy.retainSessions !== true || policy.client !== "codex") || "maxTurns" in policy && (typeof policy.maxTurns !== "number" || !Number.isSafeInteger(policy.maxTurns) || policy.maxTurns < 1 || policy.maxTurns > 8) || !["codex", "claude", "pi"].includes(policy.client) || "model" in policy && (typeof policy.model !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:/+-]{0,255}(?![\s\S])/.test(policy.model)))
-      throw new TypeError("ACP grant requires a supported native client, optional model, maxTurns from 1 to 8, and optional retainSessions: true for Codex");
+    if (Object.keys(policy).some((key) => !["client", "model", "maxTurns", "retainSessions"].includes(key)) || "retainSessions" in policy && (policy.retainSessions !== true || policy.client !== "codex") || "maxTurns" in policy && !isPrivateNativeTurnAllowance(policy.maxTurns) || !["codex", "claude", "pi"].includes(policy.client) || "model" in policy && (typeof policy.model !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:/+-]{0,255}(?![\s\S])/.test(policy.model)))
+      throw new TypeError(`ACP grant requires a supported native client, optional model, maxTurns from ${PRIVATE_NATIVE_TURN_POLICY.minimum} to ${PRIVATE_NATIVE_TURN_POLICY.maximum}, and optional retainSessions: true for Codex`);
     return Object.freeze({
       kind,
       client: policy.client,
@@ -16847,7 +16857,10 @@ var clients = {
   codex: {
     name: "Codex",
     path: "CODEX_PATH",
-    installation: "Use a supported Linux x86-64 Codex installation with its required libraries and sandbox helper.",
+    installation: {
+      linux: "Use a supported Linux x86-64 Codex installation with its required libraries and sandbox helper.",
+      darwin: "Use a supported native macOS Codex installation for this Mac's architecture, with its required libraries."
+    },
     login: "Run codex login and use its operator-owned file-backed authentication; an expired credential needs a fresh login.",
     api: "Configure OPENAI_API_KEY and a model in the ACP grant or OPENAI_MODEL for Responses; OPENAI_API, if set, must be responses. Check OPENAI_BASE_URL if overridden.",
     model: "Set a valid model in the ACP grant, or OPENAI_MODEL for API access / CODEX_MODEL for subscription access."
@@ -16855,7 +16868,10 @@ var clients = {
   claude: {
     name: "Claude Code",
     path: "CLAUDE_PATH",
-    installation: "Use a supported Linux x86-64 native Claude Code installation with its required libraries.",
+    installation: {
+      linux: "Use a supported Linux x86-64 native Claude Code installation with its required libraries.",
+      darwin: "Use a supported native macOS Claude Code installation for this Mac's architecture, with its required libraries."
+    },
     login: "Configure CLAUDE_CODE_OAUTH_TOKEN with a valid Claude setup token.",
     api: "Set exactly one of ANTHROPIC_API_KEY or ANTHROPIC_AUTH_TOKEN and a model in the ACP grant or ANTHROPIC_MODEL. Check ANTHROPIC_BASE_URL if overridden.",
     model: "Set a valid model in the ACP grant, or ANTHROPIC_MODEL for API access / CLAUDE_MODEL for subscription access."
@@ -16863,7 +16879,10 @@ var clients = {
   pi: {
     name: "Pi",
     path: "PI_PATH",
-    installation: "Use the supported standalone Linux x86-64 Pi 0.84.4 distribution with its package.json and theme directory; a Node/npm launcher is not supported.",
+    installation: {
+      linux: "Use the supported standalone Linux x86-64 Pi 0.84.4 distribution with its package.json and theme directory; a Node/npm launcher is not supported.",
+      darwin: "Use the supported standalone macOS Pi 0.84.4 distribution for this Mac's architecture, with its package.json and theme directory; a Node/npm launcher is not supported."
+    },
     login: "Use valid Pi subscription authentication for PI_PROVIDER in the operator auth.json; check PI_CODING_AGENT_DIR if overridden.",
     api: "Configure PI_PROVIDER, a model in the ACP grant or PI_MODEL, and a valid PI_API_KEY for the selected Pi API provider.",
     model: "Configure PI_PROVIDER and a valid model in the ACP grant or PI_MODEL."
@@ -16888,29 +16907,32 @@ var ACP_SETUP_CAUSES = Object.freeze(Object.fromEntries(Object.entries(clients).
     `${profile.name} is selected, but ${cause}.`
   ]);
 })));
-var ACP_SETUP_HINTS = Object.freeze(Object.fromEntries(Object.entries(clients).flatMap(([client, profile]) => {
-  const hints = {
-    executable: `Select an executable ${profile.name} installation using ${profile.path} or operator PATH. Shell aliases and functions are not executable installations. An explicit ${profile.path} must be an absolute executable file and never falls back to PATH.`,
-    installation: profile.installation,
-    location: `Select a ${profile.name} installation whose executable and runtime files are outside reserved sandbox paths (/dev, /jig, /proc, /run, /sys, /tmp and /work). Use an operator-owned installation directory and update ${profile.path}.`,
-    wrapper: `The selected ${profile.name} launcher is an unsupported wrapper. Select the underlying supported native executable with ${profile.path}; Jig does not execute shell or npm wrappers to discover their dependencies.`,
-    sandbox: "Install an unprivileged Bubblewrap helper supported by the selected Codex installation; do not bypass containment.",
-    login: profile.login,
-    api: profile.api,
-    model: profile.model
-  };
-  return Object.entries(hints).map(([stage, hint]) => [
-    acpSetupCode(client, stage),
-    `${hint} Then retry jig review. No Flow was started by this review.`
-  ]);
-})));
+function acpSetupHints(platform) {
+  return Object.freeze(Object.fromEntries(Object.entries(clients).flatMap(([client, profile]) => {
+    const hints = {
+      executable: `Select an executable ${profile.name} installation using ${profile.path} or operator PATH. Shell aliases and functions are not executable installations. An explicit ${profile.path} must be an absolute executable file and never falls back to PATH.`,
+      installation: profile.installation[platform],
+      location: `Select a ${profile.name} installation whose executable and runtime files are outside reserved sandbox paths (/dev, /jig, /proc, /run, /sys, /tmp and /work). Use an operator-owned installation directory and update ${profile.path}.`,
+      wrapper: `The selected ${profile.name} launcher is an unsupported wrapper. Select the underlying supported native executable with ${profile.path}; Jig does not execute shell or npm wrappers to discover their dependencies.`,
+      sandbox: platform === "darwin" ? "Use a qualified Jig macOS host with its system /usr/bin/sandbox-exec helper intact; do not replace system helpers or bypass containment. See https://jig.md/guide/agents for supported native installations." : "Install an unprivileged Bubblewrap helper supported by the selected Codex installation; do not bypass containment.",
+      login: profile.login,
+      api: profile.api,
+      model: profile.model
+    };
+    return Object.entries(hints).map(([stage, hint]) => [
+      acpSetupCode(client, stage),
+      `${hint} Then retry jig review. No Flow was started by this review.`
+    ]);
+  })));
+}
+var ACP_SETUP_HINTS = acpSetupHints(process.platform === "darwin" ? "darwin" : "linux");
 
 // src/internal/activation-admission-store.ts
 import { createHash as createHash13, randomUUID as randomUUID3 } from "crypto";
-import { constants as constants23 } from "fs";
+import { constants as constants26 } from "fs";
 import { realpath as realpath17 } from "fs/promises";
 import { createRequire as createRequire7 } from "module";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 
 // src/channel-contract.ts
 import { createHash } from "crypto";
@@ -26119,10 +26141,20 @@ function privateMacosExecutionPlan(intent, allocation) {
     return value;
   };
   const embedded = (value) => {
-    let result2 = value;
-    for (const [destination, source] of mappings)
-      result2 = result2.split(destination).join(source);
-    return result2.split("/jig-output").join(join4(data, "output")).split("/tmp/").join(`${join4(data, "tmp")}/`);
+    try {
+      let changed = false;
+      const parsed = JSON.parse(value, (_name, entry) => {
+        if (typeof entry !== "string")
+          return entry;
+        const relocated = path(entry);
+        if (relocated !== entry)
+          changed = true;
+        return relocated;
+      });
+      return changed ? JSON.stringify(parsed) : value;
+    } catch {
+      return path(value);
+    }
   };
   const environment = Object.fromEntries(Object.entries(intent.environment ?? {}).map(([name, value]) => [
     name,
@@ -26179,7 +26211,6 @@ function inputPath(destination) {
 }
 
 // src/internal/linux-rootless-backend.ts
-init_file_input_policy();
 import { spawn } from "child_process";
 import { randomBytes as randomBytes3 } from "crypto";
 import { closeSync as closeSync10 } from "fs";
@@ -26202,6 +26233,7 @@ import { tmpdir as tmpdir3 } from "os";
 import { dirname as dirname5, extname, join as join6, posix as posix5 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { types as utilTypes4 } from "util";
+init_file_input_policy();
 init_input_capture();
 
 // src/internal/installation-verification.ts
@@ -28711,34 +28743,7 @@ async function openPrivateMacosBackendState(value) {
       if (named.dev !== rootInfo.dev || named.ino !== rootInfo.ino || held.dev !== rootInfo.dev || held.ino !== rootInfo.ino || namedControl.dev !== controlInfo.dev || namedControl.ino !== controlInfo.ino)
         throw new Error("native execution allocation changed");
     };
-    const readFile3 = async (name) => {
-      let file;
-      try {
-        file = await openPrivateChild(control, name, constants13.O_RDONLY);
-      } catch (error) {
-        if (error.code === "ENOENT")
-          return;
-        throw error;
-      }
-      try {
-        const before = await file.stat({ bigint: true });
-        if (!before.isFile() || before.uid !== BigInt(process.getuid()) || before.nlink !== 1n || (before.mode & 0o7777n) !== 0o600n || before.size > BigInt(MAX_RECORD_BYTES2))
-          throw new Error("native execution record is unsafe");
-        const bytes = Buffer.alloc(Number(before.size));
-        for (let offset = 0;offset < bytes.length; ) {
-          const { bytesRead } = await file.read(bytes, offset, bytes.length - offset, offset);
-          if (!bytesRead)
-            throw new Error("native execution record ended early");
-          offset += bytesRead;
-        }
-        const after = await file.stat({ bigint: true });
-        if (before.size !== after.size || before.mtimeNs !== after.mtimeNs || before.ctimeNs !== after.ctimeNs || after.nlink !== 1n)
-          throw new Error("native execution record changed");
-        return bytes;
-      } finally {
-        await file.close();
-      }
-    };
+    const readFile3 = (name) => readFileFrom(control, name);
     const read = async () => {
       await verify();
       const bytes = await readFile3("state.json");
@@ -28779,20 +28784,24 @@ async function openPrivateMacosBackendState(value) {
         receipt,
         mac: releaseSignature(allocation.ownerToken, receipt).toString("hex")
       });
-      let existing = await readFileFrom(root, "release.json");
+      const existing = await readFileFrom(root, "release.json");
+      if (existing !== undefined && !existing.equals(marker))
+        throw new Error("native execution release marker conflicts");
+      if (await readFileFrom(root, "release.pending") !== undefined)
+        await unlinkPrivateFile(privateChildLocation(root, "release.pending"));
       if (existing === undefined) {
-        const file = await openPrivateChild(root, "release.json", constants13.O_WRONLY | constants13.O_CREAT | constants13.O_EXCL);
+        const file = await openPrivateChild(root, "release.pending", constants13.O_WRONLY | constants13.O_CREAT | constants13.O_EXCL);
         try {
           await file.writeFile(marker);
           await file.sync();
         } finally {
           await file.close();
         }
+        await verify();
+        await root.sync();
+        privateMacosRenameAt(root.fd, "release.pending", root.fd, "release.json", true);
         await root.sync();
-        existing = marker;
       }
-      if (!existing.equals(marker))
-        throw new Error("native execution release marker conflicts");
       privateMacosRenameAt(parent.fd, allocation.name, parent.fd, releaseName(allocation), true);
       await parent.sync();
     };
@@ -28864,7 +28873,7 @@ async function openPrivateMacosBackendState(value) {
 async function readFileFrom(parent, name) {
   let file;
   try {
-    file = await openPrivateChild(parent, name, constants13.O_RDONLY);
+    file = await openPrivateChild(parent, name, constants13.O_RDONLY | constants13.O_NONBLOCK);
   } catch (error) {
     if (error.code === "ENOENT")
       return;
@@ -29082,7 +29091,6 @@ import { posix as posix10 } from "path";
 init_input_capture();
 
 // src/internal/macos-guardian-client.ts
-init_input_capture();
 import { spawnSync } from "child_process";
 import { createHash as createHash10 } from "crypto";
 import { lstat as lstat7, mkdir as mkdir4, mkdtemp as mkdtemp3, rmdir as rmdir4, writeFile } from "fs/promises";
@@ -29090,6 +29098,18 @@ import { createServer as createServer2 } from "net";
 import { join as join11 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
+// src/internal/execution-process.ts
+class PrivateExecutionPreparationDeadlineError extends Error {
+  code = "EXECUTION_PREPARATION_DEADLINE";
+  constructor(cause) {
+    super("execution preparation reached its enforced deadline", { cause });
+    this.name = "PrivateExecutionPreparationDeadlineError";
+  }
+}
+
+// src/internal/macos-guardian-client.ts
+init_input_capture();
+
 // src/internal/macos-control-channel.ts
 function privateMacosControlChannel(socket) {
   const messages = [];
@@ -29511,6 +29531,17 @@ async function sendPrivateMacosDescriptors(path, peer, descriptors, timeoutMs, s
 
 // src/internal/macos-guardian-diagnostics.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+var failureSteps = [
+  "configuration",
+  "admission",
+  "input-transfer",
+  "storage",
+  "input-projection",
+  "scope-preparation",
+  "execution",
+  "collection",
+  "storage-recovery"
+];
 var causes = new Map([
   ["macOS control channel ended", "CONTROL_EOF"],
   ["macOS control channel socket failed", "CONTROL_SOCKET"],
@@ -29522,15 +29553,38 @@ var causes = new Map([
   ["invalid macOS guardian response", "INVALID_RESPONSE"],
   ["macOS collector has no successful fenced owner", "INVALID_COLLECTOR"],
   ["macOS collector descriptor count changed", "DESCRIPTOR_COUNT"],
-  ["macOS guardian job removal is unconfirmed", "JOB_REMOVAL_UNCONFIRMED"]
+  ["macOS guardian job removal is unconfirmed", "JOB_REMOVAL_UNCONFIRMED"],
+  ["macOS guardian operation deadline expired", "OPERATION_DEADLINE"],
+  ["macOS volume create failed", "VOLUME_CREATE"],
+  ["macOS volume attach failed", "VOLUME_ATTACH"],
+  ["macOS volume info failed", "VOLUME_INFO"],
+  ["macOS volume detach failed", "VOLUME_DETACH"],
+  ["macOS volume plist conversion failed", "VOLUME_PLIST"],
+  ["macOS image attachment does not match its allocation", "VOLUME_IMAGE"],
+  ["macOS volume device does not match its allocation", "VOLUME_DEVICE"]
 ]);
+function closedCause(error) {
+  try {
+    return error instanceof Error ? causes.get(error.message) ?? "OTHER" : "OTHER";
+  } catch {
+    return "OTHER";
+  }
+}
+function normalizePrivateMacosGuardianFailure(value) {
+  if (value === null)
+    return null;
+  const record3 = value;
+  if (typeof value !== "object" || Array.isArray(value) || Object.keys(value).sort().join() !== "cause,step" || !failureSteps.includes(record3.step) || record3.cause !== "OTHER" && ![...causes.values()].includes(record3.cause))
+    throw new Error("invalid macOS guardian response");
+  return Object.freeze({ step: record3.step, cause: record3.cause });
+}
 var observers = new AsyncLocalStorage2;
 function reportPrivateMacosGuardianRecovery(phase, step, error) {
   try {
     const observer = observers.getStore();
     if (observer === undefined)
       return;
-    const cause = error instanceof Error ? causes.get(error.message) ?? "OTHER" : "OTHER";
+    const cause = closedCause(error);
     observer(Object.freeze({ phase, step, cause }));
   } catch {}
 }
@@ -29555,13 +29609,14 @@ var MIB2 = 1024 * 1024;
 var IMAGE = "volume.dmg";
 var INTENT = "volume.json";
 var IMAGE_RECORD = "volume-image.json";
+var IMAGE_PENDING = "volume-image.pending";
 var RETIRE_RECORD = "storage.release.json";
 var RETIRE_PENDING = "storage.release.pending";
-function identity2(stat3) {
-  return { device: String(stat3.dev), inode: String(stat3.ino) };
+function identity2(stat2) {
+  return { device: String(stat2.dev), inode: String(stat2.ino) };
 }
-function matches(stat3, value) {
-  return String(stat3.dev) === value.device && String(stat3.ino) === value.inode;
+function matches(stat2, value) {
+  return String(stat2.dev) === value.device && String(stat2.ino) === value.inode;
 }
 function isIdentity(value) {
   if (value === null || typeof value !== "object")
@@ -29584,8 +29639,8 @@ async function privateDirectory3(path) {
     throw new Error("macOS volume directory is aliased");
   const directory = await open10(path, OPEN_DIRECTORY);
   try {
-    const stat3 = await directory.stat({ bigint: true });
-    if (!stat3.isDirectory() || stat3.uid !== BigInt(process.getuid()) || (stat3.mode & 0o777n) !== 0o700n)
+    const stat2 = await directory.stat({ bigint: true });
+    if (!stat2.isDirectory() || stat2.uid !== BigInt(process.getuid()) || (stat2.mode & 0o777n) !== 0o700n)
       throw new Error("macOS volume directory is not private");
     return directory;
   } catch (error) {
@@ -29768,8 +29823,13 @@ async function releasePrivateMacosVolume(controlPath, token, signal) {
       } finally {
         entries.closeSync();
       }
-      if (!names.every((name2) => [INTENT, IMAGE_RECORD].includes(name2)))
+      if (!names.every((name2) => [INTENT, IMAGE_RECORD, IMAGE_PENDING].includes(name2)))
         throw new Error("macOS volume control contains unexpected state");
+      if (names.includes(IMAGE_PENDING)) {
+        const pending = privateMacosStatAt(control.fd, IMAGE_PENDING);
+        if (!pending.isFile() || pending.uid !== BigInt(process.getuid()) || pending.nlink !== 1n || (pending.mode & 0o777n) !== 0o600n || pending.size > 4096n)
+          throw new Error("macOS volume backing staging is unsafe");
+      }
       if (retired === undefined)
         await writeRetirement(parent, token, allocation);
       if (names.includes(IMAGE_RECORD)) {
@@ -29779,6 +29839,8 @@ async function releasePrivateMacosVolume(controlPath, token, signal) {
           throw new Error("macOS volume backing journal is invalid");
         privateMacosUnlinkAt(control.fd, IMAGE_RECORD);
       }
+      if (names.includes(IMAGE_PENDING))
+        privateMacosUnlinkAt(control.fd, IMAGE_PENDING);
       if (intent !== undefined)
         privateMacosUnlinkAt(control.fd, INTENT);
       await control.sync();
@@ -30080,12 +30142,10 @@ async function recoverStorageWithGuardian(targetDirectory, targetToken, runtime)
   });
   recovery.stdout.resume();
   recovery.stderr.resume();
-  recovery.admit().catch(() => {
-    return;
-  });
+  const admission = recovery.admit().catch((error) => error);
   const result2 = await recovery.completion;
   if (result2.recovered || result2.outputLost || result2.result !== null)
-    throw new Error("macOS storage recovery is unconfirmed");
+    throw new Error("macOS storage recovery is unconfirmed", { cause: await admission });
 }
 async function preparePrivateMacosGuardian(input) {
   return prepareGuardian(input);
@@ -30278,6 +30338,7 @@ async function prepareGuardian(input) {
     };
     const completion = (async () => {
       let step = "receive";
+      let terminalResult;
       try {
         for (;; ) {
           step = "receive";
@@ -30316,10 +30377,19 @@ async function prepareGuardian(input) {
               fenced: true,
               ...received === undefined ? {} : { outputFd: received.descriptors[0] }
             }));
-          } else if (message2?.type === "terminal" && Object.keys(message2).sort().join() === "outputLost,result,type" && typeof message2.outputLost === "boolean" && (message2.result === null || typeof message2.result === "object" && message2.result.fenced === true)) {
+          } else if (message2?.type === "terminal" && Object.keys(message2).sort().join() === "failure,outputLost,result,type" && typeof message2.outputLost === "boolean" && (message2.result === null || typeof message2.result === "object" && message2.result.fenced === true)) {
+            const failure = normalizePrivateMacosGuardianFailure(message2.failure);
+            if (failure !== null && !message2.outputLost)
+              throw new Error("invalid macOS guardian response");
             phase = "terminal";
             const normalizedResult = message2.result === null ? null : normalizePrivateMacosScopeResult(message2.result);
-            rejectReady(new Error(`macOS guardian ended before readiness (${normalizedResult?.reason ?? "recovery"})`));
+            terminalResult = normalizedResult ?? undefined;
+            const readinessError = new Error(`macOS guardian ended before readiness (${normalizedResult?.reason ?? "recovery"})`);
+            if (failure !== null)
+              Object.assign(readinessError, {
+                code: `MACOS_GUARDIAN_${failure.step.replaceAll("-", "_").toUpperCase()}_${failure.cause}`
+              });
+            rejectReady(failure?.cause === "OPERATION_DEADLINE" ? new PrivateExecutionPreparationDeadlineError(readinessError) : readinessError);
             step = "terminal-cleanup";
             closeCollector();
             await cleanup();
@@ -30341,7 +30411,8 @@ async function prepareGuardian(input) {
         phase = "terminal";
         rejectReady(new Error("macOS guardian connection lost"));
         try {
-          const result2 = await recover();
+          const recovered = await recover();
+          const result2 = terminalResult === undefined ? recovered : Object.freeze({ ...recovered, result: terminalResult });
           resolveFenced(result2);
           return result2;
         } catch (error2) {
@@ -30982,7 +31053,7 @@ function normalizePrivateMacosConfirmedEnforcementReceipt(value) {
     "cpu_limit",
     "accounting_failed",
     "recovered"
-  ].includes(record3.stopReason) || record3.fenced !== true || typeof record3.outputLost !== "boolean" || typeof record3.recovered !== "boolean" || record3.recovered !== (record3.stopReason === "recovered"))
+  ].includes(record3.stopReason) || record3.fenced !== true || typeof record3.outputLost !== "boolean" || typeof record3.recovered !== "boolean" || record3.stopReason === "recovered" && !record3.recovered)
     throw new TypeError("invalid native macOS enforcement receipt");
   const scope = normalizePrivateMacosScopeResult({
     reason: record3.stopReason === "recovered" ? "coordinator_lost" : record3.stopReason,
@@ -31159,7 +31230,7 @@ function receiptFor2(prepared, terminal) {
     signal: result2.signal,
     fenced: true,
     outputLost: terminal.outputLost,
-    recovered: false,
+    recovered: terminal.recovered,
     evidence: result2.evidence
   });
 }
@@ -32183,7 +32254,10 @@ async function evaluateAuthorClosureBatch(options, captured, requestedEntries, s
       unavailable("PROJECT_EVALUATOR_SUPPORT", "cannot seal evaluator support", entryProjectPath);
     }
     const component = await privateProfileSpan("author-envelope-startup", () => launchPrivateExecution(options.backend, evaluatorLaunchPlan(installedSupport, runId, limits, inputs), signal)).catch((error) => {
-      return unavailable("PROJECT_EVALUATOR_LAUNCH", `cannot launch evaluator envelope: ${errorText8(error)}`, entryProjectPath);
+      const deadline = error instanceof PrivateExecutionPreparationDeadlineError;
+      const failure = new CheckError(deadline ? "invalid" : "unavailable", deadline ? "PROJECT_EVALUATOR_DEADLINE" : "PROJECT_EVALUATOR_LAUNCH", deadline ? "evaluator preparation reached its hard wall deadline" : "cannot launch evaluator envelope", entryProjectPath);
+      failure.cause = error;
+      throw failure;
     });
     const validEnvelope = component.envelope.kind === "linux-rootless-cgroup-v2-bubblewrap/1" ? component.envelope.privateProcessFilesystem && component.envelope.privateRuntimeDevices && sameEvaluatorLimits(component.envelope.limits, limits) && component.envelope.trustedCoordinatorBunDigest === installedSupport.executableDigest : component.envelope.resourceAccounting === "supervised-sampled-with-termination" && component.envelope.resourceOvershoot === true && sameEvaluatorLimits(component.envelope.limits, limits);
     if (!validEnvelope) {
@@ -34467,8 +34541,11 @@ function exactKeys2(value, required, optional) {
     throw new TypeError("invalid channel params");
 }
 
+// src/internal/bun-direct-run.ts
+init_file_input_policy();
+
 // src/internal/private-acp-resources.ts
-import { isAbsolute as isAbsolute6 } from "path";
+import { isAbsolute as isAbsolute7 } from "path";
 
 // src/internal/acp-agent-provider.ts
 import { constants as constants21 } from "fs";
@@ -34712,14 +34789,133 @@ async function exactFile(path2, executable, label) {
 }
 
 // src/internal/claude-agent-provider.ts
-import { lstat as lstat14, realpath as realpath14 } from "fs/promises";
-import { join as join18 } from "path";
+import { lstat as lstat15, realpath as realpath14 } from "fs/promises";
+import { join as join19 } from "path";
 
 // src/internal/native-agent-executable.ts
+import { constants as constants23 } from "fs";
+import { access as access5, lstat as lstat12, open as open13, readlink as readlink2, realpath as realpath11 } from "fs/promises";
+import { basename as basename2, delimiter, dirname as dirname10, isAbsolute as isAbsolute4, join as join17, relative as relative2, resolve as resolve7, sep } from "path";
+
+// src/internal/codex-installation.ts
 import { constants as constants22 } from "fs";
-import { access as access4, lstat as lstat11, readlink as readlink2, realpath as realpath11 } from "fs/promises";
-import { delimiter, dirname as dirname9, isAbsolute as isAbsolute3, join as join16, relative as relative2, resolve as resolve7, sep } from "path";
+import { access as access4, lstat as lstat11, open as open12 } from "fs/promises";
+import { basename, dirname as dirname9, isAbsolute as isAbsolute3, join as join16 } from "path";
+var MAX_METADATA_BYTES = 64 * 1024;
+var MAX_PACKAGE_ANCESTORS = 32;
+async function resolvePrivateCodexInstallation(selected, voltaHome, outsideProject) {
+  try {
+    let launcher = selected;
+    let recordedVersion;
+    if (basename(selected) === "volta-shim") {
+      if (basename(dirname9(selected)) !== "bin")
+        throw new Error("unsupported dispatcher layout");
+      const home = voltaHome ?? dirname9(dirname9(selected));
+      if (!isAbsolute3(home) || home.includes("\x00"))
+        throw new Error("invalid Volta home");
+      const record3 = await metadata(join16(home, "tools/user/bins/codex.json"), outsideProject);
+      if (record3.name !== "codex" || record3.package !== "@openai/codex" || record3.manager !== "Npm")
+        throw new Error("unsupported dispatcher selection");
+      recordedVersion = version(record3.version);
+      launcher = await requiredPath(join16(home, "tools/image/packages/@openai/codex/bin/codex"), outsideProject);
+    }
+    if (basename(launcher) !== "codex.js" || basename(dirname9(launcher)) !== "bin")
+      throw new Error("unsupported npm launcher layout");
+    if (await requiredPath(launcher, outsideProject) !== launcher)
+      throw new Error("launcher selection changed");
+    const information = await lstat11(launcher);
+    if (!information.isFile() || (information.mode & 73) === 0)
+      throw new Error("invalid Codex npm launcher");
+    await access4(launcher, constants22.X_OK);
+    const root = dirname9(dirname9(launcher));
+    const manifest = await metadata(join16(root, "package.json"), outsideProject);
+    const selectedVersion = version(manifest.version);
+    if (manifest.name !== "@openai/codex" || object7(manifest.bin).codex !== "bin/codex.js" || recordedVersion !== undefined && recordedVersion !== selectedVersion)
+      throw new Error("unsupported Codex installation");
+    const platform = `${process.platform}-${process.arch}`;
+    const triple = process.platform === "darwin" ? `${process.arch === "arm64" ? "aarch64" : "x86_64"}-apple-darwin` : "x86_64-unknown-linux-musl";
+    if (!(process.platform === "darwin" && ["x64", "arm64"].includes(process.arch)) && !(process.platform === "linux" && process.arch === "x64"))
+      throw new Error("unsupported Codex platform");
+    const dependency = `@openai/codex-${platform}`;
+    const nativeVersion = `${selectedVersion}-${platform}`;
+    if (object7(manifest.optionalDependencies)[dependency] !== `npm:@openai/codex@${nativeVersion}`)
+      throw new Error("unsupported Codex native dependency");
+    let directory = dirname9(launcher);
+    for (let depth = 0;depth < MAX_PACKAGE_ANCESTORS; depth++) {
+      if (basename(directory) !== "node_modules") {
+        const nativeRoot = join16(directory, "node_modules", dependency);
+        let present2 = false;
+        try {
+          await requiredPath(nativeRoot, outsideProject);
+          present2 = true;
+        } catch (error) {
+          if (!absent2(error))
+            throw error;
+        }
+        if (present2) {
+          const nativeManifest = await metadata(join16(nativeRoot, "package.json"), outsideProject);
+          if (nativeManifest.name !== "@openai/codex" || nativeManifest.version !== nativeVersion || !exactArray(nativeManifest.os, process.platform) || !exactArray(nativeManifest.cpu, process.arch))
+            throw new Error("mismatched Codex native dependency");
+          return await requiredPath(join16(nativeRoot, "vendor", triple, "bin/codex"), outsideProject);
+        }
+      }
+      const parent = dirname9(directory);
+      if (parent === directory)
+        break;
+      directory = parent;
+    }
+    throw new Error("Codex native dependency is unavailable");
+  } catch {
+    throw new PrivateAcpSetupError("wrapper");
+  }
+}
+async function requiredPath(path2, outsideProject) {
+  const selected = await outsideProject(path2);
+  if (selected === undefined)
+    throw new Error("Codex installation enters the project");
+  return selected;
+}
+async function metadata(path2, outsideProject) {
+  const selected = await requiredPath(path2, outsideProject);
+  const file = await open12(selected, constants22.O_RDONLY | constants22.O_NONBLOCK | constants22.O_NOFOLLOW);
+  try {
+    const before = await file.stat();
+    if (!before.isFile() || before.size > MAX_METADATA_BYTES)
+      throw new Error("invalid Codex installation metadata");
+    const bytes = Buffer.alloc(before.size + 1);
+    let used = 0;
+    while (used < bytes.length) {
+      const result2 = await file.read(bytes, used, bytes.length - used, used);
+      if (result2.bytesRead === 0)
+        break;
+      used += result2.bytesRead;
+    }
+    const after = await file.stat();
+    if (used !== before.size || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs)
+      throw new Error("Codex installation metadata changed");
+    return object7(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, used))));
+  } finally {
+    await file.close();
+  }
+}
+function object7(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    throw new Error("invalid Codex installation record");
+  return value;
+}
+function version(value) {
+  if (typeof value !== "string" || value.length > 128 || !/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?$/.test(value))
+    throw new Error("invalid Codex installation version");
+  return value;
+}
+function exactArray(value, selected) {
+  return Array.isArray(value) && value.length === 1 && value[0] === selected;
+}
+function absent2(error) {
+  return ["ENOENT", "ENOTDIR"].includes(error.code ?? "");
+}
 
+// src/internal/native-agent-executable.ts
 class PrivateNativeAgentExecutableUnavailableError extends Error {
   client;
   constructor(client) {
@@ -34730,16 +34926,17 @@ class PrivateNativeAgentExecutableUnavailableError extends Error {
 async function resolvePrivateNativeAgentExecutable(client, environment, projectDirectory = process.cwd()) {
   const selected = environment[`${client.toUpperCase()}_PATH`];
   const searchPath = environment.PATH;
+  const voltaHome = environment.VOLTA_HOME;
   const project = resolve7(projectDirectory);
   try {
     if (selected !== undefined) {
-      if (!isAbsolute3(selected) || selected.includes("\x00"))
+      if (!isAbsolute4(selected) || selected.includes("\x00"))
         throw new Error("invalid override");
-      return await executable(selected);
+      return await selectExecutable(client, await executable(selected), voltaHome, project);
     }
     const outside = await privateNativeAgentSupportResolver(project);
     for (const directory of (searchPath ?? "").split(delimiter)) {
-      if (!isAbsolute3(directory) || directory.includes("\x00"))
+      if (!isAbsolute4(directory) || directory.includes("\x00"))
         continue;
       const candidate = `${directory}${sep}${client}`;
       try {
@@ -34748,13 +34945,15 @@ async function resolvePrivateNativeAgentExecutable(client, environment, projectD
           continue;
         if (await executable(path2) !== path2)
           throw new Error("executable selection changed");
-        return path2;
+        return await selectExecutable(client, path2, voltaHome, project, outside);
       } catch (error) {
-        if (!absent2(error) && error.code !== "EACCES")
+        if (!absent3(error) && error.code !== "EACCES")
           throw error;
       }
     }
-  } catch {
+  } catch (error) {
+    if (error instanceof PrivateAcpSetupError)
+      throw error;
     throw new PrivateNativeAgentExecutableUnavailableError(client);
   }
   throw new PrivateNativeAgentExecutableUnavailableError(client);
@@ -34764,22 +34963,22 @@ async function privateNativeAgentSupportResolver(projectDirectory) {
   const projectRoot = await realpath11(project);
   const excluded = [project, projectRoot];
   for (const root of [project, projectRoot]) {
-    for (let directory = dirname9(root);; directory = dirname9(directory)) {
-      const dependencies = join16(directory, "node_modules");
+    for (let directory = dirname10(root);; directory = dirname10(directory)) {
+      const dependencies = join17(directory, "node_modules");
       excluded.push(dependencies);
       try {
         excluded.push(await realpath11(dependencies));
       } catch (error) {
-        if (!absent2(error))
+        if (!absent3(error))
           throw error;
       }
-      if (dirname9(directory) === directory)
+      if (dirname10(directory) === directory)
         break;
     }
   }
   const forbidden = (path2) => excluded.some((root) => inside2(root, path2));
   return async (path2) => {
-    if (!isAbsolute3(path2) || path2.includes("\x00") || forbidden(path2))
+    if (!isAbsolute4(path2) || path2.includes("\x00") || forbidden(path2))
       return;
     return await outsideProject(path2, forbidden);
   };
@@ -34795,11 +34994,11 @@ async function outsideProject(candidate, forbidden) {
     path2 = resolve7(path2, component);
     if (forbidden(path2))
       return;
-    if ((await lstat11(path2)).isSymbolicLink()) {
+    if ((await lstat12(path2)).isSymbolicLink()) {
       if (++links > 40)
         throw new Error("too many executable symlinks");
       const link4 = await readlink2(path2);
-      const target = isAbsolute3(link4) ? link4 : `${dirname9(path2)}${sep}${link4}`;
+      const target = isAbsolute4(link4) ? link4 : `${dirname10(path2)}${sep}${link4}`;
       if (forbidden(target))
         return;
       pending = [...target.split(sep).filter(Boolean), ...pending];
@@ -34810,29 +35009,59 @@ async function outsideProject(candidate, forbidden) {
 }
 async function executable(candidate) {
   const path2 = await realpath11(candidate);
-  const information = await lstat11(path2);
+  const information = await lstat12(path2);
   if (!information.isFile() || (information.mode & 73) === 0) {
     throw Object.assign(new Error("not an executable file"), { code: "EACCES" });
   }
-  await access4(path2, constants22.X_OK);
+  await access5(path2, constants23.X_OK);
   return path2;
 }
+async function selectExecutable(client, selected, voltaHome, project, outside) {
+  const dispatcher = basename2(selected) === "volta-shim";
+  if (dispatcher && client !== "codex")
+    throw new PrivateAcpSetupError("wrapper");
+  if (client === "codex" && (dispatcher || basename2(selected) === "codex.js" && await script(selected))) {
+    try {
+      const native5 = await resolvePrivateCodexInstallation(selected, voltaHome, outside ?? await privateNativeAgentSupportResolver(project));
+      if (await executable(native5) !== native5)
+        throw new Error("executable selection changed");
+      return native5;
+    } catch {
+      throw new PrivateAcpSetupError("wrapper");
+    }
+  }
+  return selected;
+}
+async function script(path2) {
+  const file = await open13(path2, constants23.O_RDONLY | constants23.O_NONBLOCK | constants23.O_NOFOLLOW);
+  try {
+    if (!(await file.stat()).isFile())
+      throw new Error("invalid executable selection");
+    const magic = Buffer.alloc(2);
+    await file.read(magic, 0, magic.length, 0);
+    return magic.toString() === "#!";
+  } finally {
+    await file.close();
+  }
+}
 function inside2(root, path2) {
   const child2 = relative2(root, path2);
-  return child2 === "" || child2 !== ".." && !child2.startsWith(`..${sep}`) && !isAbsolute3(child2);
+  return child2 === "" || child2 !== ".." && !child2.startsWith(`..${sep}`) && !isAbsolute4(child2);
 }
-function absent2(error) {
+function absent3(error) {
   return ["ENOENT", "ENOTDIR"].includes(error.code ?? "");
 }
 
 // src/internal/native-agent-runtime.ts
-import { lstat as lstat13, open as open13, realpath as realpath13 } from "fs/promises";
-import { dirname as dirname11, isAbsolute as isAbsolute5, join as join17, normalize as normalize2 } from "path";
+import { constants as constants25 } from "fs";
+import { lstat as lstat14, open as open15, realpath as realpath13 } from "fs/promises";
+import { dirname as dirname12, isAbsolute as isAbsolute6, join as join18, normalize as normalize2 } from "path";
 
 // src/internal/macos-agent-runtime.ts
-import { lstat as lstat12, open as open12, realpath as realpath12 } from "fs/promises";
+import { constants as constants24 } from "fs";
+import { lstat as lstat13, open as open14, realpath as realpath12 } from "fs/promises";
 import { createRequire as createRequire6 } from "module";
-import { dirname as dirname10, isAbsolute as isAbsolute4, normalize } from "path";
+import { dirname as dirname11, isAbsolute as isAbsolute5, normalize } from "path";
 init_macos_process_controls();
 async function inspectPrivateMacosAgentRuntime(executable2, projectDirectory = process.cwd()) {
   privateMacosCurrentProcessIdentity();
@@ -34865,28 +35094,28 @@ async function inspectPrivateMacosAgentRuntime(executable2, projectDirectory = p
       return;
     if (inspected.size >= 128)
       throw new Error("native Agent runtime is too large");
-    const information = await lstat12(path2);
+    const information = await lstat13(path2);
     if (!information.isFile() || (information.mode & 3072) !== 0 || isMain && (information.mode & 73) === 0)
       throw new Error("native Agent runtime file is invalid");
     inspected.add(path2);
     if (!isMain)
       mounts.set(path2, Object.freeze({ source: path2, destination: path2, role: "support" }));
     digests.set(path2, await privateInstallationFileDigest(path2));
-    const metadata = await readPrivateMacosAgentMetadata(path2);
-    if (metadata.executable !== isMain)
+    const metadata2 = await readPrivateMacosAgentMetadata(path2);
+    if (metadata2.executable !== isMain)
       throw new Error("native Agent Mach-O file type is invalid");
-    if (metadata.installName !== undefined) {
-      const previous = loaded.get(metadata.installName);
+    if (metadata2.installName !== undefined) {
+      const previous = loaded.get(metadata2.installName);
       if (previous !== undefined && previous !== path2)
         throw new Error("native Agent library identity is ambiguous");
-      loaded.set(metadata.installName, path2);
+      loaded.set(metadata2.installName, path2);
     }
     const expand = (value) => {
       let expanded;
       if (value === "@loader_path" || value.startsWith("@loader_path/"))
-        expanded = `${dirname10(path2)}${value.slice(12)}`;
+        expanded = `${dirname11(path2)}${value.slice(12)}`;
       else if (value === "@executable_path" || value.startsWith("@executable_path/"))
-        expanded = `${dirname10(main)}${value.slice(16)}`;
+        expanded = `${dirname11(main)}${value.slice(16)}`;
       else {
         requirePath(value);
         expanded = value;
@@ -34894,11 +35123,11 @@ async function inspectPrivateMacosAgentRuntime(executable2, projectDirectory = p
       requirePath(expanded, false);
       return expanded;
     };
-    const search = [...metadata.search.map(expand), ...inherited];
+    const search = [...metadata2.search.map(expand), ...inherited];
     if (search.length > 128)
       throw new Error("native Agent library search is too large");
     const dependencies = [];
-    for (const dependency of metadata.needed) {
+    for (const dependency of metadata2.needed) {
       const name = dependency.path;
       if (name.startsWith("@rpath/") && loaded.has(name))
         continue;
@@ -34949,9 +35178,12 @@ function privateMacosCachedLibrary(path2) {
 async function readPrivateMacosAgentMetadata(path2) {
   const systemSandbox = process.platform === "darwin" && process.arch === "arm64" && path2 === "/usr/bin/sandbox-exec";
   const acceptedSubtype = (value) => nativeSubtype(value) || systemSandbox && value === 2147483650;
-  const file = await open12(path2, "r");
+  const file = await open14(path2, constants24.O_RDONLY | constants24.O_NONBLOCK);
   try {
-    const size = (await file.stat()).size;
+    const information = await file.stat();
+    if (!information.isFile())
+      throw new Error("native Agent runtime is not a regular file");
+    const size = information.size;
     async function read(offset2, length) {
       if (!Number.isSafeInteger(offset2) || !Number.isSafeInteger(length) || offset2 < 0 || length < 0 || length > 1024 * 1024 || length > size - offset2)
         throw new Error("invalid native Agent Mach-O bounds");
@@ -35097,7 +35329,7 @@ function nativeSubtype(value) {
   return value === 3 || value === 2147483651;
 }
 function requirePath(path2, canonical3 = true) {
-  if (!isAbsolute4(path2) || canonical3 && normalize(path2) !== path2 || path2 === "/" || Buffer.byteLength(path2) > 4096 || [...path2].some((char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127))
+  if (!isAbsolute5(path2) || canonical3 && normalize(path2) !== path2 || path2 === "/" || Buffer.byteLength(path2) > 4096 || [...path2].some((char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127))
     throw new Error("native Agent runtime path is invalid");
 }
 
@@ -35117,7 +35349,7 @@ async function inspectPrivateNativeAgentRuntime(executable2, projectDirectory =
     const source = destination === executable2 ? await realpath13(destination) : await outsideProject2(destination);
     if (source === undefined)
       throw new Error("native Agent runtime enters the project");
-    const information = await lstat13(source);
+    const information = await lstat14(source);
     if (!information.isFile() || (information.mode & 3072) !== 0 || executableFile && (information.mode & 73) === 0) {
       throw new Error("native Agent runtime file is invalid");
     }
@@ -35126,12 +35358,12 @@ async function inspectPrivateNativeAgentRuntime(executable2, projectDirectory =
       return;
     inspected.add(source);
     digests.set(source, await privateInstallationFileDigest(source));
-    const elf = await readElf(source);
+    const elf = await readPrivateNativeAgentElfMetadata(source);
     if (elf === undefined) {
       throw new Error("native Agent runtime is not a qualified executable");
     }
     const search = elf.search.map((path2) => {
-      const expanded = path2.replace(/\$\{ORIGIN\}|\$ORIGIN/g, dirname11(destination));
+      const expanded = path2.replace(/\$\{ORIGIN\}|\$ORIGIN/g, dirname12(destination));
       requirePath2(expanded);
       if (expanded.includes("$"))
         throw new Error("unsupported native Agent library search");
@@ -35141,7 +35373,7 @@ async function inspectPrivateNativeAgentRuntime(executable2, projectDirectory =
     const directories = [...search, ...inherited];
     if (elf.interpreter !== undefined) {
       await visit2(elf.interpreter, [], new Map, true);
-      directories.push(dirname11(elf.interpreter), dirname11(mounts.get(elf.interpreter).source));
+      directories.push(dirname12(elf.interpreter), dirname12(mounts.get(elf.interpreter).source));
     }
     directories.push("/lib/x86_64-linux-gnu", "/usr/lib/x86_64-linux-gnu", "/lib64", "/usr/lib64", "/lib", "/usr/lib");
     const dependencies = [];
@@ -35156,9 +35388,9 @@ async function inspectPrivateNativeAgentRuntime(executable2, projectDirectory =
       }
       let found;
       for (const directory of directories) {
-        const candidate = join17(directory, name);
+        const candidate = join18(directory, name);
         try {
-          await lstat13(candidate);
+          await lstat14(candidate);
           found = candidate;
           break;
         } catch (error) {
@@ -35188,10 +35420,13 @@ async function inspectPrivateNativeAgentRuntime(executable2, projectDirectory =
     verifyProvider: (provider) => verifyPrivateAcpAgentFileDigests(provider, digests)
   });
 }
-async function readElf(path2) {
-  const file = await open13(path2, "r");
+async function readPrivateNativeAgentElfMetadata(path2) {
+  const file = await open15(path2, constants25.O_RDONLY | constants25.O_NONBLOCK);
   try {
-    const size = (await file.stat()).size;
+    const information = await file.stat();
+    if (!information.isFile())
+      throw new Error("native Agent runtime is not a regular file");
+    const size = information.size;
     async function read(offset, length) {
       if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || length > 1024 * 1024 || offset + length > size) {
         throw new Error("invalid native Agent ELF bounds");
@@ -35303,7 +35538,7 @@ function stringAt(bytes, offset, allowEmpty = false) {
   return value;
 }
 function requirePath2(path2) {
-  if (!isAbsolute5(path2) || path2.includes("\x00") || normalize2(path2) !== path2 || path2 === "/") {
+  if (!isAbsolute6(path2) || path2.includes("\x00") || normalize2(path2) !== path2 || path2 === "/") {
     throw new Error("native Agent runtime path is invalid");
   }
 }
@@ -35324,8 +35559,8 @@ async function openPrivateClaudeAgentProvider(releaseRoot, environment = process
   const executablePath = await resolvePrivateNativeAgentExecutable("claude", environment, projectDirectory);
   const runtime = await checkAcpSetup("installation", () => inspectPrivateNativeAgentRuntime(executablePath, projectDirectory));
   const support = Object.freeze({
-    launcherPath: join18(releaseRoot, "libexec", "agent", "claude-agent-launcher.js"),
-    adapterPath: join18(releaseRoot, "libexec", "agent", "claude-agent-acp.js"),
+    launcherPath: join19(releaseRoot, "libexec", "agent", "claude-agent-launcher.js"),
+    adapterPath: join19(releaseRoot, "libexec", "agent", "claude-agent-acp.js"),
     executablePath,
     certificatesPath: await ordinaryFile(HOST_CERTIFICATES_PATH, "host certificate bundle"),
     runtimeMounts: runtime.mounts
@@ -35492,7 +35727,7 @@ function frameStartupInput(value) {
 }
 async function ordinaryFile(path2, label) {
   const exact6 = await realpath14(path2);
-  const information = await lstat14(exact6);
+  const information = await lstat15(exact6);
   if (!information.isFile() || information.isSymbolicLink()) {
     throw new Error(`${label} is invalid`);
   }
@@ -35500,9 +35735,9 @@ async function ordinaryFile(path2, label) {
 }
 
 // src/internal/codex-agent-provider.ts
-import { lstat as lstat15, readFile as readFile4, realpath as realpath15 } from "fs/promises";
+import { lstat as lstat16, readFile as readFile4, realpath as realpath15 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { basename, dirname as dirname12, join as join19 } from "path";
+import { basename as basename3, dirname as dirname13, join as join20 } from "path";
 var CODEX_CLIENT = "openai-codex";
 var SANDBOX_LAUNCHER_PATH2 = "/agent/codex-agent-launcher.js";
 var SANDBOX_ADAPTER_PATH2 = "/agent/codex-acp.js";
@@ -35549,7 +35784,9 @@ async function openPrivateCodexAgentProvider(releaseRoot, environment = process.
   let executablePath;
   try {
     executablePath = await resolvePrivateNativeAgentExecutable("codex", environment, projectDirectory);
-  } catch {
+  } catch (error) {
+    if (error instanceof PrivateAcpSetupError)
+      throw error;
     throw new PrivateCodexExecutableUnavailableError("the native Codex executable is unavailable");
   }
   let runtime;
@@ -35572,7 +35809,7 @@ async function openPrivateCodexAgentProvider(releaseRoot, environment = process.
     if (bubblewrapRuntime.pathPrefix)
       throw new Error("wrapped Bubblewrap is unsupported");
   } catch (error) {
-    throw new PrivateCodexRuntimeUnavailableError("the Codex sandbox runtime is unavailable", {
+    throw new PrivateCodexSandboxUnavailableError("the Codex sandbox runtime is unavailable", {
       cause: error
     });
   }
@@ -35585,14 +35822,14 @@ async function openPrivateCodexAgentProvider(releaseRoot, environment = process.
     mounts.set(mount.destination, mount);
   }
   const support = Object.freeze({
-    launcherPath: join19(releaseRoot, "libexec", "agent", "codex-agent-launcher.js"),
-    adapterPath: join19(releaseRoot, "libexec", "agent", "codex-acp.js"),
+    launcherPath: join20(releaseRoot, "libexec", "agent", "codex-agent-launcher.js"),
+    adapterPath: join20(releaseRoot, "libexec", "agent", "codex-acp.js"),
     executablePath,
     nativeBubblewrapPath,
     nativeBubblewrapSource: nativeBubblewrap.source,
     runtimeMounts: Object.freeze([...mounts.values()]),
     certificatesPath: await ordinaryFile2(HOST_CERTIFICATES_PATH2, "host certificate bundle"),
-    requirementsPath: join19(releaseRoot, "libexec", "agent", "codex-requirements.toml")
+    requirementsPath: join20(releaseRoot, "libexec", "agent", "codex-requirements.toml")
   });
   const apiKey = environment[OPENAI_API_KEY];
   const apiModel = environment[OPENAI_MODEL];
@@ -35617,10 +35854,10 @@ async function openPrivateCodexAgentProvider(releaseRoot, environment = process.
     bubblewrapRuntime.verifyProvider(provider2);
     return provider2;
   }
-  const sourceHome = environment.CODEX_HOME ?? join19(homedir2(), ".codex");
+  const sourceHome = environment.CODEX_HOME ?? join20(homedir2(), ".codex");
   let credential;
   try {
-    credential = await projectPrivateCodexSubscriptionCredential(join19(sourceHome, "auth.json"));
+    credential = await projectPrivateCodexSubscriptionCredential(join20(sourceHome, "auth.json"));
   } catch {
     throw new PrivateCodexLoginUnavailableError("Codex file-backed login is unavailable");
   }
@@ -35636,7 +35873,7 @@ async function openPrivateCodexAgentProvider(releaseRoot, environment = process.
 }
 async function projectPrivateCodexSubscriptionCredential(path2) {
   const exact6 = await exactFile2(path2, "Codex subscription credential");
-  const information = await lstat15(exact6);
+  const information = await lstat16(exact6);
   const uid = typeof process.getuid === "function" ? process.getuid() : -1;
   if (information.uid !== uid || information.nlink !== 1 || (information.mode & 63) !== 0 || information.size > MAX_CREDENTIAL_BYTES) {
     throw new Error("Codex subscription credential is invalid");
@@ -35793,7 +36030,7 @@ function codexEnvironment(subscription, model, support) {
     }),
     CODEX_HOME: SANDBOX_CODEX_HOME,
     CODEX_PATH: support.executablePath,
-    PATH: support.nativeBubblewrapSource === "bundled" ? "/agent" : dirname12(support.nativeBubblewrapPath),
+    PATH: support.nativeBubblewrapSource === "bundled" ? "/agent" : dirname13(support.nativeBubblewrapPath),
     CODEX_SQLITE_HOME: "/tmp/codex-state",
     INITIAL_AGENT_MODE: "read-only",
     ...subscription ? { JIG_CODEX_STARTUP_INPUT: "subscription" } : {},
@@ -35807,15 +36044,15 @@ async function nativeBubblewrapFor(executablePath, environment, projectDirectory
     system = await resolvePrivateNativeAgentExecutable("bwrap", environment, projectDirectory);
   } catch {}
   if (system !== undefined) {
-    if (((await lstat15(system)).mode & 3072) !== 0) {
+    if (((await lstat16(system)).mode & 3072) !== 0) {
       throw new PrivateCodexSandboxUnavailableError("Codex Bubblewrap must be unprivileged");
     }
     return { path: system, source: "path" };
   }
-  const executableDirectory = dirname12(executablePath);
-  const adjacent = join19(executableDirectory, "codex-resources", "bwrap");
-  const packageResource = join19(executableDirectory, "..", "codex-resources", "bwrap");
-  const candidates = basename(executableDirectory) === "bin" ? [packageResource, adjacent] : [adjacent, packageResource];
+  const executableDirectory = dirname13(executablePath);
+  const adjacent = join20(executableDirectory, "codex-resources", "bwrap");
+  const packageResource = join20(executableDirectory, "..", "codex-resources", "bwrap");
+  const candidates = basename3(executableDirectory) === "bin" ? [packageResource, adjacent] : [adjacent, packageResource];
   try {
     for (const candidate of candidates) {
       let path2;
@@ -35826,7 +36063,7 @@ async function nativeBubblewrapFor(executablePath, environment, projectDirectory
           throw error;
         continue;
       }
-      const information = await lstat15(path2);
+      const information = await lstat16(path2);
       if ((information.mode & 3072) !== 0 || (information.mode & 73) === 0) {
         throw new PrivateCodexSandboxUnavailableError("Codex bundled Bubblewrap is invalid");
       }
@@ -35841,7 +36078,7 @@ async function nativeBubblewrapFor(executablePath, environment, projectDirectory
 }
 async function ordinaryFile2(path2, label) {
   const exact6 = await realpath15(path2);
-  const information = await lstat15(exact6);
+  const information = await lstat16(exact6);
   if (!information.isFile() || information.isSymbolicLink()) {
     throw new Error(`${label} is invalid`);
   }
@@ -35886,7 +36123,7 @@ function requireSubscriptionCredential(value) {
 }
 async function exactFile2(path2, label) {
   const exact6 = await realpath15(path2);
-  const information = await lstat15(exact6);
+  const information = await lstat16(exact6);
   if (exact6 !== path2 || !information.isFile() || information.isSymbolicLink()) {
     throw new Error(`${label} is invalid`);
   }
@@ -35942,9 +36179,9 @@ function requireBaseURL2(value) {
 }
 
 // src/internal/pi-agent-provider.ts
-import { lstat as lstat16, readFile as readFile5, realpath as realpath16 } from "fs/promises";
+import { lstat as lstat17, readFile as readFile5, realpath as realpath16 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname13, join as join20, resolve as resolve8 } from "path";
+import { dirname as dirname14, join as join21, resolve as resolve8 } from "path";
 var PI_CLIENT = "pi";
 var SANDBOX_LAUNCHER_PATH3 = "/agent/pi-agent-launcher.js";
 var SANDBOX_ADAPTER_PATH3 = "/agent/pi-acp.js";
@@ -35972,15 +36209,15 @@ async function openPrivatePiAgentProvider(releaseRoot, environment = process.env
       throw new Error("native Pi support enters the project");
     return exact6;
   }
-  const nativeRoot = dirname13(executablePath);
+  const nativeRoot = dirname14(executablePath);
   const support = await checkAcpSetup("installation", async () => Object.freeze({
-    launcherPath: join20(releaseRoot, "libexec", "agent", "pi-agent-launcher.js"),
-    adapterPath: join20(releaseRoot, "libexec", "agent", "pi-acp.js"),
+    launcherPath: join21(releaseRoot, "libexec", "agent", "pi-agent-launcher.js"),
+    adapterPath: join21(releaseRoot, "libexec", "agent", "pi-acp.js"),
     executablePath,
     runtimeMounts: runtime.mounts,
-    manifestPath: await piManifestFile(await asset(join20(nativeRoot, "package.json"))),
-    darkThemePath: await ordinaryFile3(await asset(join20(nativeRoot, "theme", "dark.json")), "native Pi dark theme"),
-    lightThemePath: await ordinaryFile3(await asset(join20(nativeRoot, "theme", "light.json")), "native Pi light theme"),
+    manifestPath: await piManifestFile(await asset(join21(nativeRoot, "package.json"))),
+    darkThemePath: await ordinaryFile3(await asset(join21(nativeRoot, "theme", "dark.json")), "native Pi dark theme"),
+    lightThemePath: await ordinaryFile3(await asset(join21(nativeRoot, "theme", "light.json")), "native Pi light theme"),
     certificatesPath: await ordinaryFile3(process.platform === "darwin" ? "/etc/ssl/cert.pem" : "/etc/ssl/certs/ca-certificates.crt", "host certificate bundle")
   }));
   const provider = environment.PI_PROVIDER;
@@ -36005,7 +36242,7 @@ async function openPrivatePiAgentProvider(releaseRoot, environment = process.env
     if (configuredAgentDirectory !== undefined && (configuredAgentDirectory.length === 0 || configuredAgentDirectory.includes("\x00"))) {
       throw new PrivateAcpSetupError("login");
     }
-    const credentialPath = join20(configuredAgentDirectory === undefined ? join20(homedir3(), ".pi", "agent") : resolve8(configuredAgentDirectory), "auth.json");
+    const credentialPath = join21(configuredAgentDirectory === undefined ? join21(homedir3(), ".pi", "agent") : resolve8(configuredAgentDirectory), "auth.json");
     const sourceCredential = await checkAcpSetup("login", () => readCredentialFile(credentialPath));
     let credential;
     try {
@@ -36109,17 +36346,17 @@ async function createPiProvider(value) {
         },
         {
           source: value.support.manifestPath,
-          destination: join20(dirname13(value.support.executablePath), "package.json"),
+          destination: join21(dirname14(value.support.executablePath), "package.json"),
           role: "support"
         },
         {
           source: value.support.darkThemePath,
-          destination: join20(dirname13(value.support.executablePath), "theme", "dark.json"),
+          destination: join21(dirname14(value.support.executablePath), "theme", "dark.json"),
           role: "support"
         },
         {
           source: value.support.lightThemePath,
-          destination: join20(dirname13(value.support.executablePath), "theme", "light.json"),
+          destination: join21(dirname14(value.support.executablePath), "theme", "light.json"),
           role: "support"
         }
       ]
@@ -36248,7 +36485,7 @@ function isRecord3(value) {
 }
 async function ordinaryFile3(path2, label) {
   const exact6 = await realpath16(path2);
-  const information = await lstat16(exact6);
+  const information = await lstat17(exact6);
   if (!information.isFile() || information.isSymbolicLink()) {
     throw new Error(`${label} is invalid`);
   }
@@ -36269,7 +36506,7 @@ async function piManifestFile(path2) {
 }
 async function readCredentialFile(path2) {
   const exact6 = await realpath16(path2);
-  const information = await lstat16(exact6);
+  const information = await lstat17(exact6);
   const uid = process.getuid?.();
   if (!information.isFile() || information.isSymbolicLink() || information.nlink !== 1 || information.size <= 0 || information.size > MAX_CREDENTIAL_BYTES2 || uid === undefined || information.uid !== uid || (information.mode & 63) !== 0) {
     throw new Error("Pi subscription credential projection is invalid");
@@ -36302,7 +36539,7 @@ var CLIENT_IDENTITIES = {
 };
 function openPrivateAcpResources(installedSupport, environment, projectDirectory, openClient = openQualifiedClient) {
   const support = requirePrivateInstalledBunSupport(installedSupport);
-  if (!isAbsolute6(projectDirectory) || projectDirectory.includes("\x00"))
+  if (!isAbsolute7(projectDirectory) || projectDirectory.includes("\x00"))
     throw new TypeError("ACP resources require the fixed absolute project directory");
   const owner = Object.freeze({ kind: "private-acp-resources/1" });
   owners.set(owner, {
@@ -36349,8 +36586,8 @@ async function selectPrivateAcpResources(owner, slots, installedSupport) {
   return Object.freeze(selected);
 }
 async function openQualifiedClient(client, support, environment, projectDirectory, model) {
-  const open14 = client === "codex" ? openPrivateCodexAgentProvider : client === "claude" ? openPrivateClaudeAgentProvider : openPrivatePiAgentProvider;
-  return await open14(support.releaseRoot, environment, projectDirectory, model);
+  const open16 = client === "codex" ? openPrivateCodexAgentProvider : client === "claude" ? openPrivateClaudeAgentProvider : openPrivatePiAgentProvider;
+  return await open16(support.releaseRoot, environment, projectDirectory, model);
 }
 
 // src/internal/bun-direct-run.ts
@@ -36519,9 +36756,9 @@ function logicalLaunchDigest(request, execution, installedSupport, mechanism, ht
     bunPolicy: BUN_POLICY2,
     runtimePredicates: RUNTIME_PREDICATES,
     fileProfile: {
-      inputBytes: 8 * 1024 * 1024,
-      inputFiles: 64,
-      outputBytes: 16 * 1024 * 1024,
+      inputBytes: PRIVATE_CAPTURE_LIMITS.input,
+      inputFiles: PRIVATE_FILE_LIMITS.files,
+      outputBytes: PRIVATE_CAPTURE_LIMITS.output,
       rootOnly: true
     },
     slots: request.slots,
@@ -36650,7 +36887,7 @@ function normalizeLock(value) {
   const root = exactObject2(value, [
     "packages",
     "bindings",
-    ...Object.hasOwn(object7(value, "lock"), "entrypoint") ? ["entrypoint"] : []
+    ...Object.hasOwn(object8(value, "lock"), "entrypoint") ? ["entrypoint"] : []
   ], "lock");
   const packages = normalizePackages(root.packages);
   const bindings = normalizeBindings(root.bindings);
@@ -36671,7 +36908,7 @@ function normalizeLock(value) {
   });
 }
 function normalizePackages(value) {
-  const input = object7(value, "packages");
+  const input = object8(value, "packages");
   const paths2 = Object.keys(input);
   assertNoProjectPathCollisions(paths2, "lock package");
   const output = Object.create(null);
@@ -36681,8 +36918,8 @@ function normalizePackages(value) {
       "digest",
       "directRun",
       "uses",
-      ...Object.hasOwn(object7(input[path2], `package ${path2}`), "supports") ? ["supports"] : [],
-      ...Object.hasOwn(object7(input[path2], `package ${path2}`), "slots") ? ["slots"] : []
+      ...Object.hasOwn(object8(input[path2], `package ${path2}`), "supports") ? ["supports"] : [],
+      ...Object.hasOwn(object8(input[path2], `package ${path2}`), "slots") ? ["slots"] : []
     ], `package ${path2}`);
     if (typeof item2.directRun !== "boolean") {
       throw new TypeError(`package ${path2} directRun must be boolean`);
@@ -36707,20 +36944,20 @@ function normalizeFeatureNames(value) {
   return Object.freeze([...value]);
 }
 function normalizeUses(value, label) {
-  const input = object7(value, `${label} uses`);
+  const input = object8(value, `${label} uses`);
   const names = Object.keys(input);
   if (names.length > 256)
     throw new TypeError(`${label} uses exceed 256 entries`);
   const output = Object.create(null);
   for (const name of names.sort()) {
     localName3(name, `${label} invocation slot`);
-    const requirement = object7(input[name], `${label} slot ${name}`);
+    const requirement = object8(input[name], `${label} slot ${name}`);
     output[name] = Object.keys(requirement).length === 0 ? Object.freeze({}) : normalizeInvocationRequirement(requirement);
   }
   return Object.freeze(output);
 }
 function normalizeBindings(value) {
-  const input = object7(value, "bindings");
+  const input = object8(value, "bindings");
   const output = Object.create(null);
   for (const id of Object.keys(input).sort()) {
     localName3(id, `Binding ${JSON.stringify(id)}`);
@@ -36728,9 +36965,9 @@ function normalizeBindings(value) {
       "packagePath",
       "settings",
       "slots",
-      ...Object.hasOwn(object7(input[id], `Binding ${id}`), "attachments") ? ["attachments"] : []
+      ...Object.hasOwn(object8(input[id], `Binding ${id}`), "attachments") ? ["attachments"] : []
     ], `Binding ${id}`);
-    const settings = object7(item2.settings, `Binding ${id} settings`);
+    const settings = object8(item2.settings, `Binding ${id} settings`);
     const slots = normalizeSlots(item2.slots, `Binding ${id}`);
     output[id] = Object.freeze({
       packagePath: projectPath(item2.packagePath, `Binding ${id} packagePath`),
@@ -36774,14 +37011,14 @@ function validateReferences(packages, bindings) {
   validateChildGraph(new Map(Object.entries(bindings)), directFlows);
 }
 function normalizeSlots(value, label) {
-  const input = object7(value, `${label} slots`);
+  const input = object8(value, `${label} slots`);
   const names = Object.keys(input);
   if (names.length > 256)
     throw new TypeError(`${label} slots exceed 256 entries`);
   const output = Object.create(null);
   for (const name of names.sort()) {
     localName3(name, `${label} slot`);
-    const target = object7(input[name], `${label} slot ${name}`);
+    const target = object8(input[name], `${label} slot ${name}`);
     if (target.kind === "grant") {
       exactObject2(target, ["kind", "policy", ...Object.hasOwn(target, "name") ? ["name"] : []], label);
       output[name] = Object.freeze({
@@ -36823,14 +37060,14 @@ function digest4(value, label) {
   }
   return value;
 }
-function object7(value, label) {
+function object8(value, label) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     throw new TypeError(`${label} must be an object`);
   }
   return value;
 }
 function exactObject2(value, fields, label) {
-  const result2 = object7(value, label);
+  const result2 = object8(value, label);
   const actual = Object.keys(result2).sort();
   const expected = [...fields].sort();
   if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) {
@@ -37422,8 +37659,8 @@ function normalizeEmbeddedLock(value, label, decoded) {
   if (!decoded) {
     return decodePrivateProjectLocalLock(encodePrivateProjectLocalLock(value));
   }
-  const object8 = plainObject(value, label);
-  return decodePrivateProjectLocalLock(encodeRecord(object8, label));
+  const object9 = plainObject(value, label);
+  return decodePrivateProjectLocalLock(encodeRecord(object9, label));
 }
 function samePrivateLocks(left, right) {
   return sameBytes2(encodePrivateProjectLocalLock(left), encodePrivateProjectLocalLock(right));
@@ -39769,8 +40006,8 @@ async function openCoordinatorLock(owner) {
   const directoryInformation = await owner.directory.stat({ bigint: true });
   const databaseInformation = await ensureDatabaseFile(databasePath, owner.directory, directoryInformation.dev, true, COORDINATOR_DATABASE_NAME);
   await validateSidecars(owner.directory, databaseInformation.dev, COORDINATOR_DATABASE_NAME);
-  const visibleStatePath = join21(await sqliteVisibleRoot(owner.root), STATE_DIRECTORY);
-  const visibleDatabasePath = join21(visibleStatePath, COORDINATOR_DATABASE_NAME);
+  const visibleStatePath = join22(await sqliteVisibleRoot(owner.root), STATE_DIRECTORY);
+  const visibleDatabasePath = join22(visibleStatePath, COORDINATOR_DATABASE_NAME);
   await verifyVisibleHierarchy(owner.root, visibleStatePath, directoryInformation, visibleDatabasePath, databaseInformation);
   const sqlite = loadSqlite();
   const flags = sqliteFlag(sqlite, "SQLITE_OPEN_READWRITE") | sqliteFlag(sqlite, "SQLITE_OPEN_NOFOLLOW");
@@ -39830,15 +40067,15 @@ function initializeOrVerifyCoordinatorSchema(database) {
     throw error;
   }
   try {
-    const version = pragmaInteger(database, "user_version");
+    const version2 = pragmaInteger(database, "user_version");
     const application = pragmaInteger(database, "application_id");
     const existing = schemaRows(database);
-    if (version === 0n && application === 0n && existing.length === 0) {
+    if (version2 === 0n && application === 0n && existing.length === 0) {
       database.exec(CREATE_COORDINATOR_LOCK);
       database.exec("INSERT INTO coordinator_lock(singleton) VALUES (1)");
       database.exec(`PRAGMA application_id=${COORDINATOR_APPLICATION_ID}`);
       database.exec(`PRAGMA user_version=${COORDINATOR_SCHEMA_VERSION}`);
-    } else if (version !== COORDINATOR_SCHEMA_VERSION || application !== COORDINATOR_APPLICATION_ID) {
+    } else if (version2 !== COORDINATOR_SCHEMA_VERSION || application !== COORDINATOR_APPLICATION_ID) {
       invalid("COORDINATOR_SCHEMA_VERSION", "private coordinator database has an unsupported format identity");
     }
     const rows = schemaRows(database);
@@ -39983,8 +40220,8 @@ async function inspectPrivateApprovedProject(projectRoot, selector, checkEnviron
     await owner.dispose();
   }
 }
-async function openStateOwner(projectRoot, create, access5 = "read-write") {
-  if (create && access5 === "read-only")
+async function openStateOwner(projectRoot, create, access6 = "read-write") {
+  if (create && access6 === "read-only")
     throw new TypeError("read-only state cannot be created");
   const ownsRoot = typeof projectRoot === "string";
   const root = ownsRoot ? await openPrivateProjectRoot(projectRoot) : requirePrivateProjectRoot(projectRoot);
@@ -40012,15 +40249,15 @@ async function openStateOwner(projectRoot, create, access5 = "read-write") {
     const databaseExists = await pathExists2(databasePath);
     const databaseInformation = await ensureDatabaseFile(databasePath, directory, directoryInformation.dev, create && !databaseExists);
     await validateSidecars(directory, databaseInformation.dev);
-    const visibleStatePath = join21(await sqliteVisibleRoot(root), STATE_DIRECTORY);
-    const visibleDatabasePath = join21(visibleStatePath, DATABASE_NAME);
+    const visibleStatePath = join22(await sqliteVisibleRoot(root), STATE_DIRECTORY);
+    const visibleDatabasePath = join22(visibleStatePath, DATABASE_NAME);
     await verifyVisibleHierarchy(root, visibleStatePath, directoryInformation, visibleDatabasePath, databaseInformation);
     const sqlite = loadSqlite();
-    const flags = sqliteFlag(sqlite, access5 === "read-only" ? "SQLITE_OPEN_READONLY" : "SQLITE_OPEN_READWRITE") | sqliteFlag(sqlite, "SQLITE_OPEN_NOFOLLOW");
+    const flags = sqliteFlag(sqlite, access6 === "read-only" ? "SQLITE_OPEN_READONLY" : "SQLITE_OPEN_READWRITE") | sqliteFlag(sqlite, "SQLITE_OPEN_NOFOLLOW");
     database = sqlite.Database.open(visibleDatabasePath, flags);
     await verifyVisibleHierarchy(root, visibleStatePath, directoryInformation, visibleDatabasePath, databaseInformation);
     configureConnection(database);
-    if (access5 === "read-only") {
+    if (access6 === "read-only") {
       database.exec("PRAGMA query_only=ON; BEGIN");
       if (pragmaInteger(database, "user_version") !== SCHEMA_VERSION || pragmaInteger(database, "application_id") !== APPLICATION_ID) {
         invalid("ADMISSION_SCHEMA_VERSION", "private admission database has an unsupported format identity");
@@ -40132,7 +40369,7 @@ async function openCheckedDirectory(path2, projectDevice) {
     throw error;
   }
   requireStateDirectory(observed, projectDevice);
-  const handle = await openPrivateFile(path2, constants23.O_RDONLY | constants23.O_DIRECTORY | constants23.O_NOFOLLOW | constants23.O_NONBLOCK);
+  const handle = await openPrivateFile(path2, constants26.O_RDONLY | constants26.O_DIRECTORY | constants26.O_NOFOLLOW | constants26.O_NONBLOCK);
   try {
     const information = await handle.stat({ bigint: true });
     requireStateDirectory(information, projectDevice);
@@ -40162,7 +40399,7 @@ async function ensureDatabaseFile(path2, directory, expectedDevice, create, data
   if (create) {
     let handle2;
     try {
-      handle2 = await openPrivateFile(path2, constants23.O_RDWR | constants23.O_CREAT | constants23.O_EXCL | constants23.O_NOFOLLOW, 384);
+      handle2 = await openPrivateFile(path2, constants26.O_RDWR | constants26.O_CREAT | constants26.O_EXCL | constants26.O_NOFOLLOW, 384);
       await handle2.sync();
       await handle2.close();
       handle2 = undefined;
@@ -40184,7 +40421,7 @@ async function ensureDatabaseFile(path2, directory, expectedDevice, create, data
     throw error;
   }
   requireDatabaseFile(observed, expectedDevice);
-  const handle = await openPrivateFile(path2, constants23.O_RDONLY | constants23.O_NOFOLLOW | constants23.O_NONBLOCK);
+  const handle = await openPrivateFile(path2, constants26.O_RDONLY | constants26.O_NOFOLLOW | constants26.O_NONBLOCK);
   try {
     const information = await handle.stat({ bigint: true });
     requireDatabaseFile(information, expectedDevice);
@@ -40242,10 +40479,10 @@ function initializeOrVerifySchema(database, root) {
     throw error;
   }
   try {
-    const version = pragmaInteger(database, "user_version");
+    const version2 = pragmaInteger(database, "user_version");
     const application = pragmaInteger(database, "application_id");
     const existing = schemaRows(database);
-    if (version === 0n && application === 0n && existing.length === 0) {
+    if (version2 === 0n && application === 0n && existing.length === 0) {
       database.exec(CREATE_CANDIDATES);
       database.exec(CREATE_CANDIDATE_HEAD);
       database.exec(CREATE_REVIEW_PLANS);
@@ -40263,7 +40500,7 @@ function initializeOrVerifySchema(database, root) {
       database.exec("INSERT INTO coordinator_head(singleton, epoch) VALUES (1, 0)");
       database.exec(`PRAGMA application_id=${APPLICATION_ID}`);
       database.exec(`PRAGMA user_version=${SCHEMA_VERSION}`);
-    } else if (version !== SCHEMA_VERSION || application !== APPLICATION_ID) {
+    } else if (version2 !== SCHEMA_VERSION || application !== APPLICATION_ID) {
       invalid("ADMISSION_SCHEMA_VERSION", "private admission database has an unsupported format identity");
     }
     verifySchema(database, root);
@@ -40728,7 +40965,7 @@ async function observeVisibleLock(root) {
   const path2 = privateChildLocation(root.handle, LOCK_NAME);
   let handle;
   try {
-    handle = await openPrivateFile(path2, constants23.O_RDONLY | constants23.O_NOFOLLOW | constants23.O_NONBLOCK);
+    handle = await openPrivateFile(path2, constants26.O_RDONLY | constants26.O_NOFOLLOW | constants26.O_NONBLOCK);
   } catch (error) {
     if (hasCode3(error, "ENOENT"))
       return Object.freeze({ state: "absent" });
@@ -40820,7 +41057,7 @@ async function synchronizeExactVisibleLock(owner, proposed) {
   const path2 = privateChildLocation(owner.root.handle, LOCK_NAME);
   let handle;
   try {
-    handle = await openPrivateFile(path2, constants23.O_RDONLY | constants23.O_NOFOLLOW | constants23.O_NONBLOCK);
+    handle = await openPrivateFile(path2, constants26.O_RDONLY | constants26.O_NOFOLLOW | constants26.O_NONBLOCK);
   } catch (error) {
     if (hasCode3(error, "ENOENT"))
       stale("jig.lock disappeared before admission");
@@ -40851,7 +41088,7 @@ async function publishVisibleLock(owner, plan, proposed) {
   await clearSafeLockStage(owner);
   const stagePath = privateChildLocation(owner.directory, LOCK_STAGE_NAME);
   const lockPath = privateChildLocation(owner.root.handle, LOCK_NAME);
-  const handle = await openPrivateFile(stagePath, constants23.O_RDWR | constants23.O_CREAT | constants23.O_EXCL | constants23.O_NOFOLLOW | constants23.O_NONBLOCK, 384);
+  const handle = await openPrivateFile(stagePath, constants26.O_RDWR | constants26.O_CREAT | constants26.O_EXCL | constants26.O_NOFOLLOW | constants26.O_NONBLOCK, 384);
   let failure;
   try {
     const opened = await handle.stat({ bigint: true });
@@ -41271,9 +41508,9 @@ function hasCode3(error, code2) {
 
 // src/internal/contract-import.ts
 import { randomBytes as randomBytes6 } from "crypto";
-import { constants as constants24 } from "fs";
-import { lstat as lstat17, open as open14, realpath as realpath18 } from "fs/promises";
-import { basename as basename2, dirname as dirname14, resolve as resolve9 } from "path";
+import { constants as constants27 } from "fs";
+import { lstat as lstat18, open as open16, realpath as realpath18 } from "fs/promises";
+import { basename as basename4, dirname as dirname15, resolve as resolve9 } from "path";
 init_file_input();
 async function installedDescriptor(selector, destination) {
   let name;
@@ -41282,17 +41519,17 @@ async function installedDescriptor(selector, destination) {
   } catch {
     invalid("CONTRACT_IMPORT_SOURCE", "Select an exact npm package name without a version or subpath.", selector);
   }
-  let directory = dirname14(resolve9(destination));
+  let directory = dirname15(resolve9(destination));
   for (;; ) {
     const packagePath = resolve9(directory, "node_modules", name);
     try {
-      await lstat17(packagePath);
+      await lstat18(packagePath);
       return resolve9(packagePath, "FLOW.contract.json");
     } catch (error) {
       if (error.code !== "ENOENT")
         throw error;
     }
-    const parent = dirname14(directory);
+    const parent = dirname15(directory);
     if (parent === directory)
       break;
     directory = parent;
@@ -41308,8 +41545,8 @@ async function importContract(source, destination, signal) {
   try {
     signal?.throwIfAborted();
     const selected = source.startsWith("npm:") ? await installedDescriptor(source, destination) : source;
-    const name = basename2(selected);
-    root = await open14(await realpath18(dirname14(resolve9(selected))), constants24.O_RDONLY | constants24.O_DIRECTORY | constants24.O_NOFOLLOW);
+    const name = basename4(selected);
+    root = await open16(await realpath18(dirname15(resolve9(selected))), constants27.O_RDONLY | constants27.O_DIRECTORY | constants27.O_NOFOLLOW);
     const capture = (paths3) => captureOpenedPackageDirectory(selected, root, {
       includes: (path2) => paths3.some((p) => p === path2 || p.startsWith(`${path2}/`)),
       maximumFiles: 65,
@@ -41332,12 +41569,12 @@ async function importContract(source, destination, signal) {
     signal?.throwIfAborted();
     phase = "destination";
     const target = resolve9(destination);
-    const leaf = privateFilePath(basename2(target));
-    parent = await open14(await realpath18(dirname14(target)), constants24.O_RDONLY | constants24.O_DIRECTORY | constants24.O_NOFOLLOW);
+    const leaf = privateFilePath(basename4(target));
+    parent = await open16(await realpath18(dirname15(target)), constants27.O_RDONLY | constants27.O_DIRECTORY | constants27.O_NOFOLLOW);
     const allocation = privateChildLocation(parent, `.jig-contract-${randomBytes6(16).toString("hex")}`);
     await mkdirPrivateFile(allocation);
     staged = allocation;
-    const stage = await openPrivateFile(staged, constants24.O_RDONLY | constants24.O_DIRECTORY | constants24.O_NOFOLLOW);
+    const stage = await openPrivateFile(staged, constants27.O_RDONLY | constants27.O_DIRECTORY | constants27.O_NOFOLLOW);
     try {
       for (const path2 of paths2) {
         signal?.throwIfAborted();
@@ -41380,10 +41617,10 @@ async function writeCaptured(root, path2, bytes) {
         if (error.code !== "EEXIST")
           throw error;
       });
-      parent = await openPrivateFile(directory, constants24.O_RDONLY | constants24.O_DIRECTORY | constants24.O_NOFOLLOW);
+      parent = await openPrivateFile(directory, constants27.O_RDONLY | constants27.O_DIRECTORY | constants27.O_NOFOLLOW);
       handles2.push(parent);
     }
-    const file = await openPrivateFile(privateChildLocation(parent, parts.at(-1)), constants24.O_WRONLY | constants24.O_CREAT | constants24.O_EXCL | constants24.O_NOFOLLOW, 384);
+    const file = await openPrivateFile(privateChildLocation(parent, parts.at(-1)), constants27.O_WRONLY | constants27.O_CREAT | constants27.O_EXCL | constants27.O_NOFOLLOW, 384);
     try {
       await file.writeFile(bytes);
     } finally {
@@ -41399,7 +41636,7 @@ async function removeStage(location) {
   const visit2 = async (current2, depth) => {
     if (depth > 512)
       throw new Error("contract staging cleanup exceeds its depth bound");
-    const directory = await openPrivateFile(current2, constants24.O_RDONLY | constants24.O_DIRECTORY | constants24.O_NOFOLLOW);
+    const directory = await openPrivateFile(current2, constants27.O_RDONLY | constants27.O_DIRECTORY | constants27.O_NOFOLLOW);
     try {
       for await (const entry of privateDirectoryEntries(directory)) {
         if (++entries > 65536)
@@ -41480,19 +41717,19 @@ var EVALUATOR_HINTS = Object.freeze({
 });
 
 // src/project-init.ts
-import { constants as constants25 } from "fs";
+import { constants as constants28 } from "fs";
 import {
-  lstat as lstat18,
+  lstat as lstat19,
   mkdir as mkdir6,
   mkdtemp as mkdtemp5,
-  open as open15,
+  open as open17,
   readFile as readFile6,
   rm as rm2,
   rmdir as rmdir6,
   unlink as unlink3,
   writeFile as writeFile2
 } from "fs/promises";
-import { basename as basename3, join as join22, resolve as resolve10 } from "path";
+import { basename as basename5, join as join23, resolve as resolve10 } from "path";
 init_file_input();
 var DEFAULT_FILE_SYSTEM = {
   mkdir: mkdir6,
@@ -41501,7 +41738,7 @@ var DEFAULT_FILE_SYSTEM = {
   writeFile: writeFile2
 };
 var GREETING_SDK_VERSION = "0.1.0-alpha.13";
-var AGENT_ACP_VERSION = "0.1.0-alpha.6";
+var AGENT_ACP_VERSION = "0.1.0-alpha.8";
 
 class ProjectInitError extends Error {
   code;
@@ -41521,12 +41758,12 @@ async function createFlow(project, name, uses = [], signal) {
   signal?.throwIfAborted();
   let sdk = GREETING_SDK_VERSION;
   try {
-    const definition = await lstat18(join22(project, "jig.ts"));
+    const definition = await lstat19(join23(project, "jig.ts"));
     if (!definition.isFile() || definition.isSymbolicLink())
       throw new Error("not a regular project definition");
     try {
-      const path2 = join22(project, "package.json");
-      const info = await lstat18(path2);
+      const path2 = join23(project, "package.json");
+      const info = await lstat19(path2);
       if (!info.isFile() || info.size > 262144)
         throw new Error("unsafe manifest");
       const manifest = JSON.parse(await readFile6(path2, "utf8"));
@@ -41543,8 +41780,8 @@ async function createFlow(project, name, uses = [], signal) {
   } catch {
     throw new ProjectInitError("invalid", "JIG_NEW_INVALID", "Run jig new from a project with a regular jig.ts and a readable, valid package.json if present. No source was evaluated.");
   }
-  const flows = join22(project, "flows");
-  const destination = join22(flows, name);
+  const flows = join23(project, "flows");
+  const destination = join23(flows, name);
   const created = [];
   let staged;
   let createdFlows = false, createdDestination = false;
@@ -41555,7 +41792,7 @@ async function createFlow(project, name, uses = [], signal) {
     } catch (error) {
       if (errorCode(error) !== "EEXIST")
         throw error;
-      if (!(await lstat18(flows)).isDirectory())
+      if (!(await lstat19(flows)).isDirectory())
         throw new Error("flows must be a directory, not a link");
     }
     try {
@@ -41564,27 +41801,27 @@ async function createFlow(project, name, uses = [], signal) {
         createdDestination = true;
       } else {
         try {
-          await lstat18(destination);
+          await lstat19(destination);
           throw Object.assign(new Error("exists"), { code: "EEXIST" });
         } catch (error) {
           if (errorCode(error) !== "ENOENT")
             throw error;
         }
-        staged = await mkdtemp5(join22(project, ".jig-new-"));
+        staged = await mkdtemp5(join23(project, ".jig-new-"));
       }
     } catch (error) {
       if (errorCode(error) === "EEXIST")
         throw new ProjectInitError("invalid", "JIG_NEW_EXISTS", "That Flow directory already exists. Choose a different name; existing files were not changed.");
       throw error;
     }
-    const projectName = basename3(resolve10(project)).toLowerCase().replace(/[^a-z0-9-]/g, "-").slice(0, 64);
+    const projectName = basename5(resolve10(project)).toLowerCase().replace(/[^a-z0-9-]/g, "-").slice(0, 64);
     const authoredAt = staged ?? destination;
     const declarations = Object.create(null);
     if (uses.length > 0)
-      await mkdir6(join22(authoredAt, "contracts"));
+      await mkdir6(join23(authoredAt, "contracts"));
     for (const { slot, source } of uses) {
-      const imported = await importContract(source.startsWith("npm:") ? source : resolve10(project, source), join22(authoredAt, "contracts", slot), signal);
-      declarations[slot] = { contract: `./contracts/${slot}/${basename3(imported.descriptor)}` };
+      const imported = await importContract(source.startsWith("npm:") ? source : resolve10(project, source), join23(authoredAt, "contracts", slot), signal);
+      declarations[slot] = { contract: `./contracts/${slot}/${basename5(imported.descriptor)}` };
     }
     const files = {
       "FLOW.meta.json": `${JSON.stringify({ name, description: "Describe what this method does.", ...uses.length === 0 ? {} : { uses: declarations } }, null, 2)}
@@ -41600,18 +41837,18 @@ await handle(async (run) => {
     };
     for (const [file, content] of Object.entries(files)) {
       signal?.throwIfAborted();
-      const path2 = join22(authoredAt, file);
+      const path2 = join23(authoredAt, file);
       await writeFile2(path2, content, { flag: "wx" });
       if (staged === undefined)
         created.push(path2);
     }
     if (staged !== undefined) {
-      const projectDirectory = await open15(project, constants25.O_RDONLY | constants25.O_DIRECTORY | constants25.O_NOFOLLOW);
+      const projectDirectory = await open17(project, constants28.O_RDONLY | constants28.O_DIRECTORY | constants28.O_NOFOLLOW);
       try {
-        const flowsDirectory = await openPrivateChild(projectDirectory, "flows", constants25.O_RDONLY | constants25.O_DIRECTORY | constants25.O_NOFOLLOW);
+        const flowsDirectory = await openPrivateChild(projectDirectory, "flows", constants28.O_RDONLY | constants28.O_DIRECTORY | constants28.O_NOFOLLOW);
         try {
           signal?.throwIfAborted();
-          privatePublishDirectory(flowsDirectory.fd, basename3(staged), name, projectDirectory.fd);
+          privatePublishDirectory(flowsDirectory.fd, basename5(staged), name, projectDirectory.fd);
           staged = undefined;
         } finally {
           await flowsDirectory.close();
@@ -41655,12 +41892,12 @@ async function createProject(destination, fileSystem = DEFAULT_FILE_SYSTEM, bare
     }
     created.push({ kind: "directory", path: target });
     for (const name of ["flows", "bindings"]) {
-      const path2 = join22(target, name);
+      const path2 = join23(target, name);
       await fileSystem.mkdir(path2);
       created.push({ kind: "directory", path: path2 });
     }
     if (!bare) {
-      const path2 = join22(target, "flows", "hello");
+      const path2 = join23(target, "flows", "hello");
       await fileSystem.mkdir(path2);
       created.push({ kind: "directory", path: path2 });
     }
@@ -41672,7 +41909,7 @@ async function createProject(destination, fileSystem = DEFAULT_FILE_SYSTEM, bare
       ...agent === undefined ? [] : agentFiles(agent)
     ];
     for (const [name, contents] of files) {
-      const path2 = join22(target, name);
+      const path2 = join23(target, name);
       await fileSystem.writeFile(path2, contents, {
         encoding: "utf8",
         flag: "wx"
@@ -42107,10 +42344,10 @@ async function executeCompletion(arguments_, runtime) {
       return 1;
     }
   }
-  const script = arguments_.length === 2 ? completionScript(arguments_[1]) : undefined;
-  if (script === undefined)
+  const script2 = arguments_.length === 2 ? completionScript(arguments_[1]) : undefined;
+  if (script2 === undefined)
     usage("completion", "Choose bash, zsh, or fish.");
-  await runtime.writeRecord(script);
+  await runtime.writeRecord(script2);
   return 0;
 }
 async function executeNew(arguments_, runtime) {
@@ -42194,7 +42431,7 @@ async function executeImportContract(arguments_, runtime) {
   try {
     const result2 = await importContract(arguments_[1].startsWith("npm:") ? arguments_[1] : resolve11(runtime.currentDirectory, arguments_[1]), resolve11(runtime.currentDirectory, arguments_[2]), runtime.signal);
     runtime.writeOutput(`Imported ${result2.files} contract files into ${asciiJsonString(arguments_[2])}.
-Use ${asciiJsonString(basename4(result2.descriptor))} in the caller's slot declaration, then review the project.
+Use ${asciiJsonString(basename6(result2.descriptor))} in the caller's slot declaration, then review the project.
 `);
     return 0;
   } catch (error) {
@@ -42350,7 +42587,7 @@ function shellWord(value) {
 async function executeReview(arguments_, runtime) {
   let resolutionNoticeShown = false;
   const parsed = parseReview(arguments_, runtime.currentDirectory);
-  runtime.progress.note(`Reviewing ${asciiJsonString(basename4(resolve11(runtime.currentDirectory, parsed.project)))}`);
+  runtime.progress.note(`Reviewing ${asciiJsonString(basename6(resolve11(runtime.currentDirectory, parsed.project)))}`);
   const result2 = await withProjectSession(parsed.project, runtime, async (session) => {
     const plan = await privateProfileSpan("project-planning", () => session.plan({ lockMode: "update" }));
     runtime.progress.complete(true);
@@ -42518,7 +42755,7 @@ Check --input and the file contents. No Flow was started.`, 1);
   const files = new PrivateRootRunFiles(capture.attachments, parsed.output === undefined ? null : resolve11(runtime.currentDirectory, parsed.output), runtime.host.delivery);
   try {
     if (parsed.output !== undefined) {
-      const occupied = await lstat19(files.identity.output).then(() => true, (error) => {
+      const occupied = await lstat20(files.identity.output).then(() => true, (error) => {
         if (error.code === "ENOENT")
           return false;
         throw new CliDiagnostic("JIG_OUTPUT_INVALID", "cannot inspect --out; check its path and directory permissions. No Flow was started.", 1);
@@ -42892,6 +43129,11 @@ function renderFailure(error, runtime) {
       PACKAGE_ENTRYPOINT_MISSING: "the selected package needs one exact-case FLOW.<suffix> entrypoint",
       PACKAGE_METADATA_OWNER: "keep Markdown frontmatter in FLOW.md; use FLOW.meta.json only with a code entrypoint",
       PACKAGE_SCHEMA_OWNER: "place invocation input and result schemas in FLOW.contract.json",
+      SCHEMA_INVALID: error.diagnostic?.pointer === "/$schema" ? `Set the root "$schema" to "${SCHEMA_1_URI}" in the indicated file, then run jig review again.` : "Correct the indicated schema declaration using FLOW Schema/0; see https://flow.jig.md/spec/schema-files.",
+      SCHEMA_INVALID_JSON: "Use valid UTF-8 JSON/0 without duplicate keys and within its value limits; see https://flow.jig.md/spec/json-values.",
+      SCHEMA_KEYWORD_UNSUPPORTED: "Use only the supported FLOW Schema/0 keywords; see https://flow.jig.md/spec/schema-files.",
+      SCHEMA_REFERENCE_INVALID: "Use an acyclic same-document reference spelled #/$defs/<name> to an existing root definition; see https://flow.jig.md/spec/schema-files.",
+      SCHEMA_LIMIT_EXCEEDED: "Reduce schema size or validation work to the FLOW Schema/0 limits; see https://flow.jig.md/spec/schema-files.",
       PACKAGE_PROFILE_UNSUPPORTED: "use a runtime and single-invocation contract supported by this host",
       PACKAGE_METADATA_UNSUPPORTED: "this host cannot honor the indicated metadata requirement; use a qualified host or revise that requirement explicitly",
       PACKAGE_TOOLS_UNSUPPORTED: "the selected runtime cannot enforce this allowed-tools restriction",
@@ -42907,6 +43149,7 @@ function renderFailure(error, runtime) {
       PROJECT_BINDING_ATTACHMENTS_INVALID: "check the Binding attachment directories: use stable project-relative regular-file trees without links, protected state or nested mounts, within the file limits",
       PROJECT_BINDING_ATTACHMENT_UNDECLARED: "select only attachment names declared read-only in the Flow contract",
       PROJECT_BINDING_ATTACHMENTS_NOT_CAPTURED: "the selected Binding files could not be retained consistently; review stable source directories again",
+      PROJECT_CHECKPOINT_ATTACHMENT: "declare a read-write attachment in FLOW.contract.json for the root Flow that uses Run Checkpoint",
       PROJECT_BINDING_PACKAGE_MISSING: "the Binding references a Flow not selected by jig.ts; correct the path or project membership",
       PROJECT_ENTRYPOINT_INVALID: "Fix entrypoint in jig.ts: use an invokable Flow or Binding followed by valid jig run invocation arguments, project-relative paths, and declared unbound attachments or outgoing channels. Operator flags such as --verification are not project defaults.",
       PROJECT_DEFAULT_MISSING: "defaultProviders in jig.ts names a missing Flow or Binding; create the selected local Binding and include its Flow in discovery, or correct the selector. Provider selection does not create Bindings",
@@ -42936,6 +43179,7 @@ function renderFailure(error, runtime) {
       PACKAGE_BUN_RESOLUTION_VERSION_UNAVAILABLE: "a requested dependency version or tag is unavailable in the registry; check package.json against published versions or use a declared local workspace dependency",
       PACKAGE_BUN_RESOLVED_SOURCE_UNSUPPORTED: "resolved dependencies are unsupported; requests may already have occurred; use integrity-pinned default npm registry dependencies",
       PACKAGE_BUN_SOURCE_UNSUPPORTED: "use default npm registry dependencies or declared workspace members; patches require workspace-root declarations and captured .patch files; overrides and other dependency sources are unsupported",
+      PACKAGE_BUN_LOCK_VERSION_UNSUPPORTED: "the supplied Bun lock format is unsupported by this host; generate it explicitly with Bun 1.3.3 for Linux and Mac, or Bun 1.4.2 for Mac, then review again. Jig does not convert or replace supplied locks",
       PACKAGE_BUN_MANIFEST_SHAPE: "package.json must contain an object",
       PACKAGE_BUN_MANIFEST_FIELD: "the indicated manifest field is unsupported here; use default npm registry dependencies or declared workspace members, with patches declared only at the workspace root",
       PACKAGE_BUN_MANIFEST_DEPENDENCIES: "the indicated dependency section must be an object mapping package names to version requests",
@@ -43166,19 +43410,19 @@ class PrivateCliOutput {
 import { spawn as spawn2 } from "child_process";
 import { randomBytes as randomBytes9 } from "crypto";
 import { closeSync as closeSync14, fstatSync as fstatSync13 } from "fs";
-import { open as open17 } from "fs/promises";
+import { open as open19 } from "fs/promises";
 import { connect, createServer as createServer3 } from "net";
-import { dirname as dirname16, join as join24 } from "path";
+import { dirname as dirname17, join as join25 } from "path";
 
 // src/internal/file-delivery.ts
 import { randomBytes as randomBytes8 } from "crypto";
-import { closeSync as closeSync13, constants as constants27, fstatSync as fstatSync11 } from "fs";
+import { closeSync as closeSync13, constants as constants30, fstatSync as fstatSync11 } from "fs";
 import { statfs as statfs3 } from "fs/promises";
-import { basename as basename5, dirname as dirname15, resolve as resolve12 } from "path";
+import { basename as basename7, dirname as dirname16, resolve as resolve12 } from "path";
 
 // src/internal/file-delivery-storage.ts
-import { constants as constants26 } from "fs";
-var DIRECTORY4 = constants26.O_RDONLY | constants26.O_DIRECTORY | constants26.O_NOFOLLOW;
+import { constants as constants29 } from "fs";
+var DIRECTORY4 = constants29.O_RDONLY | constants29.O_DIRECTORY | constants29.O_NOFOLLOW;
 async function writePrivateDeliveryFile(root, path2, bytes, check) {
   const parts = path2.split("/");
   const handles2 = [];
@@ -43196,7 +43440,7 @@ async function writePrivateDeliveryFile(root, path2, bytes, check) {
       handles2.push(parent);
     }
     check();
-    const file = await openPrivateFile(privateChildLocation(parent, parts.at(-1)), constants26.O_WRONLY | constants26.O_CREAT | constants26.O_EXCL | constants26.O_NOFOLLOW);
+    const file = await openPrivateFile(privateChildLocation(parent, parts.at(-1)), constants29.O_WRONLY | constants29.O_CREAT | constants29.O_EXCL | constants29.O_NOFOLLOW);
     try {
       await file.writeFile(bytes);
     } finally {
@@ -43273,7 +43517,7 @@ class PrivateFileDeliveryOwner {
     let parent;
     try {
       this.signal.throwIfAborted();
-      const destination = resolve12(directory), parentPath = dirname15(destination), leaf = privateFilePath(basename5(destination));
+      const destination = resolve12(directory), parentPath = dirname16(destination), leaf = privateFilePath(basename7(destination));
       if (destination === parentPath || leaf.includes("/"))
         throw new TypeError("output requires a new directory");
       const selected = privateOpenFileRoot(parentPath);
@@ -43361,7 +43605,7 @@ class PrivateFileDeliveryOwner {
       await this.onStaged?.();
       checkTime();
       let delivery;
-      const stage = await openPrivateFile(location, constants27.O_RDONLY | constants27.O_DIRECTORY | constants27.O_NOFOLLOW);
+      const stage = await openPrivateFile(location, constants30.O_RDONLY | constants30.O_DIRECTORY | constants30.O_NOFOLLOW);
       try {
         const opened = await stage.stat({ bigint: true });
         if (opened.ino !== info.ino || opened.dev !== info.dev)
@@ -43469,8 +43713,8 @@ init_file_input();
 
 // src/internal/macos-file-command.ts
 import { fstatSync as fstatSync12, lstatSync as lstatSync6 } from "fs";
-import { mkdtemp as mkdtemp6, open as open16, rmdir as rmdir7 } from "fs/promises";
-import { join as join23 } from "path";
+import { mkdtemp as mkdtemp6, open as open18, rmdir as rmdir7 } from "fs/promises";
+import { join as join24 } from "path";
 init_macos_descriptor_files();
 init_macos_process_controls();
 function requirePrivateMacosFilePeer(socket2, expected) {
@@ -43482,7 +43726,7 @@ function requirePrivateMacosFilePeer(socket2, expected) {
 async function createPrivateMacosFileCommand() {
   const peer = privateMacosCurrentProcessIdentity();
   const directory = await mkdtemp6("/private/tmp/jig-file-owner-");
-  const parent = await open16(directory, "r");
+  const parent = await open18(directory, "r");
   const identity3 = await parent.stat({ bigint: true });
   let roots;
   let output;
@@ -43542,7 +43786,7 @@ async function createPrivateMacosFileCommand() {
     return Object.freeze({
       directory,
       peer,
-      socket: join23(directory, "control"),
+      socket: join24(directory, "control"),
       close,
       controlReady() {
         const info = controlIdentity();
@@ -43908,7 +44152,7 @@ async function privateConnectFileOwner() {
         if (!Array.isArray(roots) || roots.length > 8)
           throw new TypeError("invalid input roots");
         const pending = request({ type: "prepare", destination: path2, rootCount: roots.length });
-        const transfer = roots.length ? sendPrivateMacosDescriptors(join24(dirname16(selected.socket), "fd-roots"), selected.peer, roots, 5000, cancellation.signal) : Promise.resolve();
+        const transfer = roots.length ? sendPrivateMacosDescriptors(join25(dirname17(selected.socket), "fd-roots"), selected.peer, roots, 5000, cancellation.signal) : Promise.resolve();
         await Promise.all([pending, transfer]).catch((error) => {
           socket2.destroy();
           throw error;
@@ -43956,7 +44200,7 @@ async function privateConnectFileOwner() {
           },
           cancelled: signal?.aborted ?? false
         });
-        const transfer = selected.platform === "darwin" && transferred !== undefined ? sendPrivateMacosDescriptors(join24(dirname16(selected.socket), "fd-output"), selected.peer, [transferred.fd], 5000, cancellation.signal) : Promise.resolve();
+        const transfer = selected.platform === "darwin" && transferred !== undefined ? sendPrivateMacosDescriptors(join25(dirname17(selected.socket), "fd-output"), selected.peer, [transferred.fd], 5000, cancellation.signal) : Promise.resolve();
         const [reply] = await Promise.all([pending, transfer]).catch((error) => {
           socket2.destroy();
           throw error;
@@ -44054,7 +44298,7 @@ async function withLinuxDirectories(pid, descriptors, maximum, work) {
   let result2;
   try {
     for (const fd of descriptors) {
-      const directory = await open17(`/proc/${pid}/fd/${fd}`, 65536);
+      const directory = await open19(`/proc/${pid}/fd/${fd}`, 65536);
       directories.push(directory);
       if (!(await directory.stat()).isDirectory())
         throw new TypeError("file transfer requires directories");
@@ -44135,19 +44379,19 @@ async function openPrivateInstalledBunHost(location, environment = process.env,
 init_linux_host_paths();
 import { execFile as execFile2, spawn as spawn3 } from "child_process";
 import { randomBytes as randomBytes10 } from "crypto";
-import { constants as constants28, realpathSync as realpathSync6 } from "fs";
+import { constants as constants31, realpathSync as realpathSync6 } from "fs";
 import {
-  access as access5,
+  access as access6,
   mkdir as mkdir7,
   readFile as readFile7,
   readdir as readdir3,
   realpath as realpath19,
-  stat as stat3,
+  stat as stat2,
   statfs as statfs4,
   writeFile as writeFile3
 } from "fs/promises";
 import { createServer as createServer4, connect as connect2 } from "net";
-import { isAbsolute as isAbsolute7, posix as posix12 } from "path";
+import { isAbsolute as isAbsolute8, posix as posix12 } from "path";
 var CGROUP_ROOT2 = "/sys/fs/cgroup";
 var CGROUP2_SUPER_MAGIC3 = 0x6367_7270n;
 var CHILD_NAME = "jig";
@@ -44198,7 +44442,7 @@ async function acquireOrReexecutePrivateRootlessLinux(input = {}) {
       throw new Error("invalid transient scope identity");
     const command = requireCommand(dependencies.currentCommand(input.commandArguments ?? process.argv.slice(2)));
     const directory = dependencies.currentDirectory();
-    if (!isAbsolute7(directory) || directory.includes("\x00")) {
+    if (!isAbsolute8(directory) || directory.includes("\x00")) {
       throw new Error("invalid current directory");
     }
     return await dependencies.reexecute(managerPath, unit, command, directory, environment, commandLifetimeMs, input.signal);
@@ -44226,10 +44470,10 @@ async function preparePrivateRootlessLinuxScope(unit, dependencies = scopeDepend
   if (!information.isDirectory() || information.uid !== uid) {
     throw new Error("the transient scope is not owned by the current user");
   }
-  await dependencies.requireAccess(scope, constants28.W_OK | constants28.X_OK);
-  await dependencies.requireAccess(`${scope}/cgroup.procs`, constants28.R_OK | constants28.W_OK);
-  await dependencies.requireAccess(`${scope}/cgroup.subtree_control`, constants28.R_OK | constants28.W_OK);
-  await dependencies.requireAccess(`${scope}/cgroup.kill`, constants28.W_OK);
+  await dependencies.requireAccess(scope, constants31.W_OK | constants31.X_OK);
+  await dependencies.requireAccess(`${scope}/cgroup.procs`, constants31.R_OK | constants31.W_OK);
+  await dependencies.requireAccess(`${scope}/cgroup.subtree_control`, constants31.R_OK | constants31.W_OK);
+  await dependencies.requireAccess(`${scope}/cgroup.kill`, constants31.W_OK);
   requireWords2(await dependencies.readText(`${scope}/cgroup.controllers`), REQUIRED_CONTROLLERS2);
   if ((await dependencies.listDirectories(scope)).length !== 0) {
     throw new Error("the transient scope already contains a child cgroup");
@@ -44285,7 +44529,7 @@ function requirePreparedObservation(observation, unit) {
   }
 }
 function requireCommand(command) {
-  if (command.length === 0 || !isAbsolute7(command[0]) || command.some((value) => value.includes("\x00"))) {
+  if (command.length === 0 || !isAbsolute8(command[0]) || command.some((value) => value.includes("\x00"))) {
     throw new Error("the current command is invalid");
   }
   return Object.freeze([...command]);
@@ -44330,8 +44574,8 @@ async function resolveManager() {
   for (const candidate of MANAGER_CANDIDATES) {
     try {
       const resolved = await realpath19(candidate);
-      const information = await stat3(resolved);
-      if (isAbsolute7(resolved) && information.isFile() && (information.mode & 73) !== 0 && (information.mode & 3072) === 0) {
+      const information = await stat2(resolved);
+      if (isAbsolute8(resolved) && information.isFile() && (information.mode & 73) !== 0 && (information.mode & 3072) === 0) {
         return resolved;
       }
     } catch {}
@@ -44460,8 +44704,8 @@ async function resolveControl() {
   for (const candidate of CONTROL_CANDIDATES) {
     try {
       const resolved = await realpath19(candidate);
-      const information = await stat3(resolved);
-      if (isAbsolute7(resolved) && information.isFile() && (information.mode & 73) !== 0 && (information.mode & 3072) === 0) {
+      const information = await stat2(resolved);
+      if (isAbsolute8(resolved) && information.isFile() && (information.mode & 73) !== 0 && (information.mode & 3072) === 0) {
         return resolved;
       }
     } catch {}
@@ -44561,7 +44805,7 @@ async function requirePathAbsent(path2, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   for (;; ) {
     try {
-      await stat3(path2);
+      await stat2(path2);
     } catch (error) {
       if (error.code === "ENOENT")
         return;
@@ -44773,10 +45017,10 @@ var scopeDependencies = Object.freeze({
   pid: () => process.pid,
   readText: (path2) => readFile7(path2, "utf8"),
   listDirectories: async (path2) => (await readdir3(path2, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name),
-  information: (path2) => stat3(path2),
+  information: (path2) => stat2(path2),
   filesystemType: async (path2) => (await statfs4(path2)).type,
   resolve: (path2) => realpath19(path2),
-  requireAccess: (path2, mode) => access5(path2, mode),
+  requireAccess: (path2, mode) => access6(path2, mode),
   makeDirectory: (path2) => mkdir7(path2, { mode: 493 }),
   writeText: (path2, value) => writeFile3(path2, value)
 });
@@ -44792,14 +45036,14 @@ var systemDependencies2 = Object.freeze({
   reexecute: (managerPath, unit, command, directory, environment, commandLifetimeMs, signal) => reexecutePrivateRootlessLinuxCommand(managerPath, unit, command, directory, environment, STARTUP_TIMEOUT_MS, commandLifetimeMs, signal)
 });
 function currentCommand(arguments_) {
-  if (process.argv[0] === process.execPath && process.argv[1]?.endsWith("/libexec/installed-cli.js") && isAbsolute7(process.argv[1]) && realpathSync6(process.argv[1]) === process.argv[1] && realpathSync6(process.execPath) === process.execPath && process.execArgv.length === BUN_POLICY3.length && process.execArgv.every((value, index) => value === BUN_POLICY3[index])) {
+  if (process.argv[0] === process.execPath && process.argv[1]?.endsWith("/libexec/installed-cli.js") && isAbsolute8(process.argv[1]) && realpathSync6(process.argv[1]) === process.argv[1] && realpathSync6(process.execPath) === process.execPath && process.execArgv.length === BUN_POLICY3.length && process.execArgv.every((value, index) => value === BUN_POLICY3[index])) {
     return [process.execPath, ...BUN_POLICY3, process.argv[1], ...arguments_];
   }
   throw new Error("the installed Jig command cannot be reexecuted exactly");
 }
 
 // src/internal/project-session-controller.ts
-import { constants as constants32 } from "fs";
+import { constants as constants35 } from "fs";
 
 // src/internal/bun-native-lock-policy.ts
 var MANIFEST_REASONS = {
@@ -44907,8 +45151,8 @@ function isExactRegistryResolution(value) {
   if (separator < 1)
     return false;
   const name = value.slice(0, separator);
-  const version = value.slice(separator + 1);
-  return isPackageName(name) && /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.test(version);
+  const version2 = value.slice(separator + 1);
+  return isPackageName(name) && /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.test(version2);
 }
 function isPackageName(value) {
   const valid = value.startsWith("@") ? /^@[a-z0-9][a-z0-9._~-]*\/[a-z0-9][a-z0-9._~-]*$/.test(value) : /^[a-z0-9][a-z0-9._~-]*$/.test(value);
@@ -44921,8 +45165,8 @@ function ordinaryRecord2(value) {
 }
 
 // src/internal/bun-native-preparation.ts
-import { lstat as lstat20, mkdir as mkdir8, realpath as realpath20 } from "fs/promises";
-import { join as join25 } from "path";
+import { lstat as lstat21, mkdir as mkdir8, realpath as realpath20 } from "fs/promises";
+import { join as join26 } from "path";
 
 // src/internal/bun-native-preparation-protocol.ts
 var MIB3 = 1024 * 1024;
@@ -45048,6 +45292,7 @@ var BUN_POLICY4 = Object.freeze(["--no-env-file", "--no-install", "--config=/dev
 var WORKER_FAILURE_CODES = new Set([
   "PACKAGE_BUN_INPUT_LIMIT",
   "PACKAGE_BUN_LOCK_INVALID",
+  "PACKAGE_BUN_LOCK_VERSION_UNSUPPORTED",
   "PACKAGE_BUN_LOCK_STALE",
   "PACKAGE_BUN_OUTPUT_LIMIT",
   "PACKAGE_BUN_OUTPUT_UNSUPPORTED",
@@ -45183,7 +45428,7 @@ async function interact(component, sourceBytes, input) {
             throw protocolFailure();
           location = { path: value2.path, pointer: value2.pointer };
         }
-        terminal = new CheckError(message2.code === "PACKAGE_BUN_SOURCE_UNSUPPORTED" || message2.code === "PACKAGE_BUN_RESOLVED_SOURCE_UNSUPPORTED" || message2.code === "PACKAGE_BUN_RESOLUTION_FAILED" || message2.code === "PACKAGE_BUN_RESOLUTION_VERSION_UNAVAILABLE" || message2.code === "PACKAGE_BUN_PREPARATION_FAILED" || message2.code === "PACKAGE_BUN_OUTPUT_UNSUPPORTED" ? "unavailable" : "invalid", message2.code, boundedMessage(message2.message), location?.path ?? (message2.code.startsWith("PACKAGE_BUN_RESOL") || message2.code === "PACKAGE_BUN_INPUT_LIMIT" || message2.code === "PACKAGE_BUN_OUTPUT_LIMIT" ? "package.json" : message2.code.includes("LOCK") || message2.code.includes("SOURCE_UNSUPPORTED") ? "bun.lock" : undefined), location?.pointer);
+        terminal = new CheckError(message2.code === "PACKAGE_BUN_SOURCE_UNSUPPORTED" || message2.code === "PACKAGE_BUN_LOCK_VERSION_UNSUPPORTED" || message2.code === "PACKAGE_BUN_RESOLVED_SOURCE_UNSUPPORTED" || message2.code === "PACKAGE_BUN_RESOLUTION_FAILED" || message2.code === "PACKAGE_BUN_RESOLUTION_VERSION_UNAVAILABLE" || message2.code === "PACKAGE_BUN_PREPARATION_FAILED" || message2.code === "PACKAGE_BUN_OUTPUT_UNSUPPORTED" ? "unavailable" : "invalid", message2.code, boundedMessage(message2.message), location?.path ?? (message2.code.startsWith("PACKAGE_BUN_RESOL") || message2.code === "PACKAGE_BUN_INPUT_LIMIT" || message2.code === "PACKAGE_BUN_OUTPUT_LIMIT" ? "package.json" : message2.code.includes("LOCK") || message2.code.includes("SOURCE_UNSUPPORTED") ? "bun.lock" : undefined), location?.pointer);
       } else {
         throw protocolFailure();
       }
@@ -45301,13 +45546,13 @@ function normalizeCheckpoint(value) {
   return Object.freeze({ allocation, owner, fence });
 }
 async function preparationOwnerParent(projectRoot) {
-  const state = await realpath20(join25(projectRoot, ".jig"));
-  const parent = join25(state, "private-preparation-owners");
+  const state = await realpath20(join26(projectRoot, ".jig"));
+  const parent = join26(state, "private-preparation-owners");
   await mkdir8(parent, { mode: 448 }).catch((error) => {
     if (!hasCode4(error, "EEXIST"))
       throw error;
   });
-  const information = await lstat20(parent);
+  const information = await lstat21(parent);
   const uid = typeof process.getuid === "function" ? process.getuid() : -1;
   if (!information.isDirectory() || information.isSymbolicLink() || information.uid !== uid || (information.mode & 63) !== 0 || await realpath20(parent) !== parent) {
     throw new Error("private Bun preparation owner directory is not protected");
@@ -45668,8 +45913,9 @@ function failure(code2, message2) {
 }
 
 // src/internal/bun-workspace-capture.ts
-import { constants as constants29 } from "fs";
-import { dirname as dirname17, relative as relative3, resolve as resolve13 } from "path";
+import { constants as constants32 } from "fs";
+import { lstat as lstat22 } from "fs/promises";
+import { dirname as dirname18, relative as relative3, resolve as resolve13 } from "path";
 var MANIFEST_BYTES = 1024 * 1024;
 var MAX_MEMBERS4 = 256;
 var MAX_ENTRIES2 = 32768;
@@ -45685,7 +45931,18 @@ async function capturePrivateBunWorkspace(input) {
   if (!requiresWorkspace && Object.keys(dependencies).length === 0)
     return;
   const physical = resolve13(input.projectRoot.requestedPath, input.packagePath);
-  for (let path2 = physical, depth = 0;depth < MAX_DEPTH; depth++, path2 = dirname17(path2)) {
+  const roots = [];
+  for (let path2 = physical;roots.length < MAX_DEPTH; path2 = dirname18(path2)) {
+    input.signal.throwIfAborted();
+    if (path2 !== physical && (await lstat22(path2)).isSymbolicLink())
+      break;
+    roots.push(path2);
+    if (dirname18(path2) === path2)
+      break;
+  }
+  const projectDepth = roots.indexOf(resolve13(input.projectRoot.requestedPath));
+  const paths2 = projectDepth === -1 ? roots : [...roots.slice(projectDepth + 1), ...roots.slice(1, projectDepth + 1), physical];
+  for (const path2 of paths2) {
     input.signal.throwIfAborted();
     const root = await openPrivateProjectRoot(path2);
     try {
@@ -45714,8 +45971,6 @@ async function capturePrivateBunWorkspace(input) {
     } finally {
       await root.dispose();
     }
-    if (dirname17(path2) === path2)
-      break;
   }
   if (requiresWorkspace)
     fail("PACKAGE_BUN_WORKSPACE_MISSING", "workspace dependencies require membership in a declared ancestor workspace");
@@ -45903,9 +46158,9 @@ function runtimeDependencies(manifest) {
     return value;
   }));
 }
-function workspaceVersionMatches(version, request) {
+function workspaceVersionMatches(version2, request) {
   const range = request.slice("workspace:".length);
-  return ["*", "^", "~"].includes(range) || typeof version === "string" && Bun.semver.satisfies(version, range);
+  return ["*", "^", "~"].includes(range) || typeof version2 === "string" && Bun.semver.satisfies(version2, range);
 }
 function parseManifest(bytes) {
   try {
@@ -45978,7 +46233,7 @@ async function openBeneath(root, path2) {
   let current2 = root;
   try {
     for (const part of path2.split("/")) {
-      const next2 = await openPrivateChild(current2, part, constants29.O_RDONLY | constants29.O_DIRECTORY | constants29.O_NOFOLLOW | constants29.O_NONBLOCK);
+      const next2 = await openPrivateChild(current2, part, constants32.O_RDONLY | constants32.O_DIRECTORY | constants32.O_NOFOLLOW | constants32.O_NONBLOCK);
       if (current2 !== root)
         await current2.close();
       current2 = next2;
@@ -45993,7 +46248,7 @@ async function openBeneath(root, path2) {
 async function readOptional(directory, name, maximum = MANIFEST_BYTES) {
   let handle;
   try {
-    handle = await openPrivateChild(directory, name, constants29.O_RDONLY | constants29.O_NOFOLLOW | constants29.O_NONBLOCK);
+    handle = await openPrivateChild(directory, name, constants32.O_RDONLY | constants32.O_NOFOLLOW | constants32.O_NONBLOCK);
   } catch (error) {
     if (error.code === "ENOENT")
       return;
@@ -46070,7 +46325,7 @@ function fail(code2, message2) {
 
 // src/internal/contract-generation.ts
 import { createHash as createHash15, randomUUID as randomUUID4 } from "crypto";
-import { constants as constants30 } from "fs";
+import { constants as constants33 } from "fs";
 
 // ../agent-method/dist/errors.js
 class AgentMethodError extends Error {
@@ -46157,13 +46412,13 @@ function visitJson2(value, depth, state, memberName) {
       }
       return;
     }
-    const object8 = value;
-    const prototype = Object.getPrototypeOf(object8);
+    const object9 = value;
+    const prototype = Object.getPrototypeOf(object9);
     if (prototype !== Object.prototype && prototype !== null) {
       throw new Json1Error2("object must be an ordinary record");
     }
-    const keys = Object.keys(object8);
-    if (Reflect.ownKeys(object8).length !== keys.length) {
+    const keys = Object.keys(object9);
+    if (Reflect.ownKeys(object9).length !== keys.length) {
       throw new Json1Error2("object members must be enumerable string data");
     }
     if (keys.length > JSON_1_LIMITS2.containerEntries) {
@@ -46173,7 +46428,7 @@ function visitJson2(value, depth, state, memberName) {
     for (const key of keys) {
       validateString2(key, JSON_1_LIMITS2.memberNameBytes);
       chargeEncodedBytes2(state, encodedJsonStringBytes2(key));
-      const field = Object.getOwnPropertyDescriptor(object8, key);
+      const field = Object.getOwnPropertyDescriptor(object9, key);
       if (!("value" in field))
         throw new Json1Error2("object members must be ordinary data");
       visitJson2(field.value, depth + 1, state, false);
@@ -46219,8 +46474,8 @@ function canonicalText2(value) {
     return Object.is(value, -0) ? "0" : JSON.stringify(value);
   if (Array.isArray(value))
     return `[${value.map(canonicalText2).join(",")}]`;
-  const object8 = value;
-  const members = Object.keys(object8).sort(compareUtf162).map((key) => `${JSON.stringify(key)}:${canonicalText2(object8[key])}`);
+  const object9 = value;
+  const members = Object.keys(object9).sort(compareUtf162).map((key) => `${JSON.stringify(key)}:${canonicalText2(object9[key])}`);
   return `{${members.join(",")}}`;
 }
 function compareUtf162(left, right) {
@@ -46367,19 +46622,19 @@ var decoder11 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
 
 // src/internal/contract-authoring-client.ts
 import { spawn as spawn4 } from "child_process";
-import { lstat as lstat21, realpath as realpath21 } from "fs/promises";
-import { isAbsolute as isAbsolute8 } from "path";
+import { lstat as lstat23, realpath as realpath21 } from "fs/promises";
+import { isAbsolute as isAbsolute9 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 async function generateContract(source, signal, workerPath) {
   signal.throwIfAborted();
   const override = process.env.JIG_AUTHORING_NODE_PATH;
-  if (override !== undefined && !isAbsolute8(override))
+  if (override !== undefined && !isAbsolute9(override))
     unavailable("AUTHORING_NODE", "Select an absolute Node executable.");
   let node;
   for (const path2 of override ? [override] : ["/usr/bin/node", "/usr/local/bin/node", "/run/current-system/sw/bin/node"]) {
     try {
       const resolved = await realpath21(path2);
-      if ((await lstat21(resolved)).isFile()) {
+      if ((await lstat23(resolved)).isFile()) {
         node = resolved;
         break;
       }
@@ -46479,15 +46734,15 @@ async function readInput(root, path2) {
 async function read(directory, name, limit2 = MAX_RECORD) {
   let file;
   try {
-    file = await openPrivateFile(privateChildLocation(directory, name), constants30.O_RDONLY | constants30.O_NOFOLLOW | constants30.O_NONBLOCK);
+    file = await openPrivateFile(privateChildLocation(directory, name), constants33.O_RDONLY | constants33.O_NOFOLLOW | constants33.O_NONBLOCK);
   } catch (error) {
     if (error.code === "ENOENT")
       return null;
     return conflict(name);
   }
   try {
-    const stat4 = await file.stat();
-    if (!stat4.isFile() || stat4.nlink !== 1 || stat4.size > limit2)
+    const stat3 = await file.stat();
+    if (!stat3.isFile() || stat3.nlink !== 1 || stat3.size > limit2)
       conflict(name);
     const bytes = await file.readFile();
     if (bytes.length > limit2)
@@ -46504,7 +46759,7 @@ async function directory(parent, name, create) {
         throw error;
     });
   try {
-    return await openPrivateFile(privateChildLocation(parent, name), constants30.O_RDONLY | constants30.O_DIRECTORY | constants30.O_NOFOLLOW);
+    return await openPrivateFile(privateChildLocation(parent, name), constants33.O_RDONLY | constants33.O_DIRECTORY | constants33.O_NOFOLLOW);
   } catch (error) {
     if (error.code === "ENOENT")
       return;
@@ -46513,7 +46768,7 @@ async function directory(parent, name, create) {
 }
 async function write(directory2, name, value) {
   const temporary = `.write-${randomUUID4()}`;
-  const file = await openPrivateFile(privateChildLocation(directory2, temporary), constants30.O_CREAT | constants30.O_EXCL | constants30.O_WRONLY | constants30.O_NOFOLLOW, 384);
+  const file = await openPrivateFile(privateChildLocation(directory2, temporary), constants33.O_CREAT | constants33.O_EXCL | constants33.O_WRONLY | constants33.O_NOFOLLOW, 384);
   try {
     await file.writeFile(value);
     await file.sync();
@@ -46757,7 +47012,7 @@ function prepareContractGeneration(options) {
 // src/internal/dependency-flows.ts
 import { posix as posix13 } from "path";
 async function captureDependencyFlows(input) {
-  const metadata = await captureOpenedPackageDirectory("project dependency metadata", input.root.handle, {
+  const metadata2 = await captureOpenedPackageDirectory("project dependency metadata", input.root.handle, {
     includes: (path2) => ["package.json", "bun.lock", ".npmrc"].includes(path2),
     maximumFiles: 3,
     maximumBytes: 3 * 1024 * 1024
@@ -46766,7 +47021,7 @@ async function captureDependencyFlows(input) {
   let prepared;
   const members = [];
   try {
-    const manifest = await readManifest(metadata, "package.json");
+    const manifest = await readManifest(metadata2, "package.json");
     const declarations = manifest.dependencies;
     if (!declarations || typeof declarations !== "object" || Array.isArray(declarations))
       invalid("PROJECT_DEPENDENCY_MISSING", "npm Flow targets require project package.json dependencies", "package.json");
@@ -46778,10 +47033,10 @@ async function captureDependencyFlows(input) {
     workspace = await capturePrivateBunWorkspace({
       projectRoot: input.root,
       packagePath: "",
-      captured: metadata,
+      captured: metadata2,
       signal: input.signal
     });
-    prepared = await input.prepare(workspace?.captured ?? metadata, workspace);
+    prepared = await input.prepare(workspace?.captured ?? metadata2, workspace);
     for (const selector of input.selectors) {
       input.signal.throwIfAborted();
       const name = npmPackageName(selector);
@@ -46836,7 +47091,7 @@ async function captureDependencyFlows(input) {
       try {
         await workspace?.captured.dispose();
       } finally {
-        await metadata.dispose();
+        await metadata2.dispose();
       }
     }
   }
@@ -47684,8 +47939,8 @@ function isProjectIdentityLoss(error) {
 }
 
 // src/internal/root-run-controller.ts
-import { lstat as lstat24, mkdir as mkdir11, realpath as realpath24 } from "fs/promises";
-import { join as join30 } from "path";
+import { lstat as lstat26, mkdir as mkdir11, realpath as realpath24 } from "fs/promises";
+import { join as join31 } from "path";
 
 // src/run/session.ts
 import { createHash as createHash16 } from "crypto";
@@ -48498,56 +48753,56 @@ function validateLimits(limits) {
   }
 }
 function parseEnvelope(value) {
-  const object8 = requireObject3(value, "JSON-RPC envelope");
-  if (object8.jsonrpc !== "2.0")
+  const object9 = requireObject3(value, "JSON-RPC envelope");
+  if (object9.jsonrpc !== "2.0")
     throw new Error("invalid JSON-RPC version");
-  const hasMethod = Object.hasOwn(object8, "method");
-  const hasId = Object.hasOwn(object8, "id");
-  const hasResult = Object.hasOwn(object8, "result");
-  const hasError = Object.hasOwn(object8, "error");
+  const hasMethod = Object.hasOwn(object9, "method");
+  const hasId = Object.hasOwn(object9, "id");
+  const hasResult = Object.hasOwn(object9, "result");
+  const hasError = Object.hasOwn(object9, "error");
   if (hasMethod) {
-    if (typeof object8.method !== "string")
+    if (typeof object9.method !== "string")
       throw new Error("method must be a string");
-    const hasParams = Object.hasOwn(object8, "params");
-    if (hasParams && (object8.params === null || typeof object8.params !== "object")) {
+    const hasParams = Object.hasOwn(object9, "params");
+    if (hasParams && (object9.params === null || typeof object9.params !== "object")) {
       throw new Error("JSON-RPC params must be a structured value");
     }
-    requireExactKeys(object8, hasId ? hasParams ? ["jsonrpc", "id", "method", "params"] : ["jsonrpc", "id", "method"] : hasParams ? ["jsonrpc", "method", "params"] : ["jsonrpc", "method"]);
+    requireExactKeys(object9, hasId ? hasParams ? ["jsonrpc", "id", "method", "params"] : ["jsonrpc", "id", "method"] : hasParams ? ["jsonrpc", "method", "params"] : ["jsonrpc", "method"]);
     if (hasId) {
       return {
         kind: "request",
-        id: requireWireId2(object8.id),
-        method: object8.method,
-        ...hasParams ? { params: object8.params } : {}
+        id: requireWireId2(object9.id),
+        method: object9.method,
+        ...hasParams ? { params: object9.params } : {}
       };
     }
     return {
       kind: "notification",
-      method: object8.method,
-      ...hasParams ? { params: object8.params } : {}
+      method: object9.method,
+      ...hasParams ? { params: object9.params } : {}
     };
   }
   if (!hasId || hasResult === hasError)
     throw new Error("invalid response envelope");
-  requireExactKeys(object8, hasResult ? ["jsonrpc", "id", "result"] : ["jsonrpc", "id", "error"]);
+  requireExactKeys(object9, hasResult ? ["jsonrpc", "id", "result"] : ["jsonrpc", "id", "error"]);
   if (hasResult) {
-    return { kind: "success", id: requireWireId2(object8.id), result: object8.result };
+    return { kind: "success", id: requireWireId2(object9.id), result: object9.result };
   }
-  const id = object8.id === null ? null : requireWireId2(object8.id);
-  return { kind: "error", id, error: parseErrorPayload(object8.error) };
+  const id = object9.id === null ? null : requireWireId2(object9.id);
+  return { kind: "error", id, error: parseErrorPayload(object9.error) };
 }
 function parseErrorPayload(value) {
-  const object8 = requireObject3(value, "JSON-RPC error");
-  requireExactKeys(object8, Object.hasOwn(object8, "data") ? ["code", "message", "data"] : ["code", "message"]);
-  if (!Number.isSafeInteger(object8.code))
+  const object9 = requireObject3(value, "JSON-RPC error");
+  requireExactKeys(object9, Object.hasOwn(object9, "data") ? ["code", "message", "data"] : ["code", "message"]);
+  if (!Number.isSafeInteger(object9.code))
     throw new Error("invalid error code");
-  if (typeof object8.message !== "string" || scalarLength3(object8.message) < 1 || scalarLength3(object8.message) > 1024) {
+  if (typeof object9.message !== "string" || scalarLength3(object9.message) < 1 || scalarLength3(object9.message) > 1024) {
     throw new Error("invalid error message");
   }
   return {
-    code: object8.code,
-    message: object8.message,
-    ...Object.hasOwn(object8, "data") ? { data: object8.data } : {}
+    code: object9.code,
+    message: object9.message,
+    ...Object.hasOwn(object9, "data") ? { data: object9.data } : {}
   };
 }
 function parseRootFailure(error) {
@@ -48567,9 +48822,9 @@ function parseRootFailure(error) {
   };
 }
 function parseRunResult(value) {
-  const object8 = requireObject3(value, "Run result");
-  requireExactKeys(object8, ["outcome", "output"]);
-  return { outcome: requireLocalName4(object8.outcome), output: object8.output };
+  const object9 = requireObject3(value, "Run result");
+  requireExactKeys(object9, ["outcome", "output"]);
+  return { outcome: requireLocalName4(object9.outcome), output: object9.output };
 }
 function parseOperation2(request) {
   const params = requireObject3(request.params, "flow/call params");
@@ -48596,11 +48851,11 @@ function parseOperation2(request) {
   };
 }
 function parseChannelReferences(value) {
-  const object8 = requireObject3(value, "channel references");
-  if (Object.keys(object8).length > 256)
+  const object9 = requireObject3(value, "channel references");
+  if (Object.keys(object9).length > 256)
     throw new TypeError("too many channel references");
   const references2 = Object.create(null);
-  for (const [name, reference] of Object.entries(object8)) {
+  for (const [name, reference] of Object.entries(object9)) {
     requireLocalName4(name);
     if (typeof reference !== "string" || reference.length < 1 || reference.length > 256)
       throw new TypeError("invalid channel reference");
@@ -48689,8 +48944,8 @@ function requireObject3(value, description) {
   }
   return value;
 }
-function requireExactKeys(object8, expected) {
-  const actual = Object.keys(object8).sort();
+function requireExactKeys(object9, expected) {
+  const actual = Object.keys(object9).sort();
   const wanted = [...expected].sort();
   if (actual.length !== wanted.length || actual.some((key, index) => key !== wanted[index])) {
     throw new Error(`unexpected object members: ${actual.join(", ")}`);
@@ -48750,8 +49005,8 @@ function privateFlowExecutionIntent(recipe, packageRoot, runId, deadlineUnixMs,
 }
 
 // src/internal/package-materialization.ts
-import { constants as constants31 } from "fs";
-import { dirname as dirname18, isAbsolute as isAbsolute9, join as join26, resolve as resolve14 } from "path";
+import { constants as constants34 } from "fs";
+import { dirname as dirname19, isAbsolute as isAbsolute10, join as join27, resolve as resolve14 } from "path";
 import { types as utilTypes9 } from "util";
 var ALLOCATION_KIND = "private-package-materialization-allocation/1";
 var LEASE_KIND = "private-package-materialization-lease/1";
@@ -48761,7 +49016,7 @@ var DIGEST12 = /^sha256:[0-9a-f]{64}$/;
 var LEAF = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 var UNSIGNED_642 = /^(?:0|[1-9][0-9]{0,19})$/;
 var MAX_UNSIGNED_643 = (1n << 64n) - 1n;
-var DIRECTORY_FLAGS = constants31.O_RDONLY | constants31.O_DIRECTORY | constants31.O_NOFOLLOW | constants31.O_NONBLOCK;
+var DIRECTORY_FLAGS = constants34.O_RDONLY | constants34.O_DIRECTORY | constants34.O_NOFOLLOW | constants34.O_NONBLOCK;
 async function allocatePrivatePackageMaterialization(raw) {
   const options = parseAllocationOptions(raw);
   const parent = await openProtectedParent(options.protectedParent);
@@ -48772,7 +49027,7 @@ async function allocatePrivatePackageMaterialization(raw) {
       kind: ALLOCATION_KIND,
       parent: pathIdentity(parent.path, parent.information),
       name: options.name,
-      path: join26(parent.path, options.name),
+      path: join27(parent.path, options.name),
       packageDigest: options.packageDigest,
       ownerToken: options.ownerToken,
       ...options.aliases === undefined ? {} : { aliases: options.aliases }
@@ -49035,7 +49290,7 @@ function leaseFromObserved(allocation, transaction, packageDirectory) {
     kind: LEASE_KIND,
     allocation,
     transaction: pathIdentity(allocation.path, transaction),
-    package: pathIdentity(join26(allocation.path, PACKAGE_NAME), packageDirectory)
+    package: pathIdentity(join27(allocation.path, PACKAGE_NAME), packageDirectory)
   });
   return durableLease(identity3);
 }
@@ -49270,7 +49525,7 @@ async function packageModesMatch(packageDirectory, files, filesystem, aliases) {
       const observed = await statPrivateFile(path2);
       if (observed.isSymbolicLink() || !observed.isFile())
         return false;
-      const handle = await openPrivateFile(path2, constants31.O_RDONLY | constants31.O_NOFOLLOW | constants31.O_NONBLOCK);
+      const handle = await openPrivateFile(path2, constants34.O_RDONLY | constants34.O_NOFOLLOW | constants34.O_NONBLOCK);
       try {
         const information = await handle.stat({ bigint: true });
         if (!sameIdentity9(observed, information) || !information.isFile() || information.nlink !== 1n || information.uid !== filesystem.uid || information.dev !== filesystem.dev || fileMode(information) !== 0o444n)
@@ -49359,7 +49614,7 @@ async function removeTree(root, filesystem, aliases = new Map, prefix = "") {
     if (!observed.isFile()) {
       throw new Error("refusing to remove a special file from a materialization allocation");
     }
-    const file = await openPrivateFile(path2, constants31.O_RDONLY | constants31.O_NOFOLLOW | constants31.O_NONBLOCK);
+    const file = await openPrivateFile(path2, constants34.O_RDONLY | constants34.O_NOFOLLOW | constants34.O_NONBLOCK);
     let information;
     try {
       information = await file.stat({ bigint: true });
@@ -49436,7 +49691,7 @@ function parseAllocation(value) {
   const path2 = normalizeAbsolutePath(root.path, "allocation path");
   const packageDigest2 = parseDigest(root.packageDigest);
   const ownerToken = normalizeOwnerToken(root.ownerToken);
-  if (parent.path !== normalizeParent(parent.path) || path2 !== join26(parent.path, name)) {
+  if (parent.path !== normalizeParent(parent.path) || path2 !== join27(parent.path, name)) {
     throw new TypeError("materialization allocation paths are not canonical and correlated");
   }
   return freezeAllocation({
@@ -49460,7 +49715,7 @@ function parseLease(value) {
   const allocation = parseAllocation(root.allocation);
   const transaction = parsePathIdentity(root.transaction, "lease transaction");
   const packageDirectory = parsePathIdentity(root.package, "lease package");
-  if (transaction.path !== allocation.path || packageDirectory.path !== join26(allocation.path, PACKAGE_NAME))
+  if (transaction.path !== allocation.path || packageDirectory.path !== join27(allocation.path, PACKAGE_NAME))
     throw new TypeError("materialization lease paths do not match their allocation");
   return freezeLease({
     kind: LEASE_KIND,
@@ -49523,7 +49778,7 @@ function normalizeParent(value) {
   return normalizeAbsolutePath(value, "protected materialization parent");
 }
 function normalizeAbsolutePath(value, label) {
-  if (typeof value !== "string" || value.length === 0 || value.includes("\x00") || !isAbsolute9(value) || resolve14(value) !== value || Buffer.byteLength(value, "utf8") > 4096)
+  if (typeof value !== "string" || value.length === 0 || value.includes("\x00") || !isAbsolute10(value) || resolve14(value) !== value || Buffer.byteLength(value, "utf8") > 4096)
     throw new TypeError(`${label} must be a bounded canonical absolute path`);
   return value;
 }
@@ -49558,7 +49813,7 @@ function requireExpectedParent(value, expected) {
   }
 }
 async function copyCapturedFile(captured, logicalPath, expectedBytes, destination, filesystem) {
-  const handle = await openPrivateFile(destination, constants31.O_WRONLY | constants31.O_CREAT | constants31.O_EXCL | constants31.O_NOFOLLOW, 256);
+  const handle = await openPrivateFile(destination, constants34.O_WRONLY | constants34.O_CREAT | constants34.O_EXCL | constants34.O_NOFOLLOW, 256);
   let observedBytes = 0;
   try {
     if (filesystem !== undefined) {
@@ -49670,8 +49925,8 @@ function invalidResult(terminal, message2, details) {
 init_input_capture();
 
 // src/internal/invocation-context.ts
-import { lstat as lstat22, mkdir as mkdir9, realpath as realpath22 } from "fs/promises";
-import { join as join27 } from "path";
+import { lstat as lstat24, mkdir as mkdir9, realpath as realpath22 } from "fs/promises";
+import { join as join28 } from "path";
 var DIGEST13 = /^sha256:[0-9a-f]{64}$/;
 function requireParentTarget(input) {
   const { parent } = input;
@@ -49733,13 +49988,13 @@ function normalizeParentFlow(value, parentOperationId, depth = 0) {
   });
 }
 async function protectedOwnerRoot(projectRoot) {
-  const state2 = await realpath22(join27(projectRoot, ".jig"));
-  const owners2 = join27(state2, "private-root-owners");
+  const state2 = await realpath22(join28(projectRoot, ".jig"));
+  const owners2 = join28(state2, "private-root-owners");
   await mkdir9(owners2, { mode: 448 }).catch((error) => {
     if (!hasCode6(error, "EEXIST"))
       throw error;
   });
-  const information = await lstat22(owners2);
+  const information = await lstat24(owners2);
   const uid = typeof process.getuid === "function" ? process.getuid() : -1;
   if (!information.isDirectory() || information.isSymbolicLink() || information.uid !== uid || (information.mode & 63) !== 0 || await realpath22(owners2) !== owners2) {
     throw new Error("execution owner directory is not protected");
@@ -50239,10 +50494,10 @@ class PrivateNativeHistoryUnavailable extends TypeError {
 function parsePrivateNativeSessionRequest(input) {
   if (input === null)
     return;
-  const outer = object8(input);
+  const outer = object9(input);
   if (Object.keys(outer).join() !== "session")
     invalid4();
-  const session = object8(outer.session);
+  const session = object9(outer.session);
   if (session.retain === true && session.lifetime === "run" && Object.keys(session).length === 2)
     return { retain: true, lifetime: "run" };
   if (Object.keys(session).length !== 1)
@@ -50287,10 +50542,10 @@ function validatePrivateCodexSession(state2, secrets2 = []) {
         invalid4();
       throw error;
     }
-    const record3 = object8(decoded);
+    const record3 = object9(decoded);
     if (Object.keys(record3).some((key) => !["timestamp", "ordinal", "type", "payload"].includes(key)) || typeof record3.timestamp !== "string" || record3.ordinal !== ordinal)
       invalid4();
-    const payload = object8(record3.payload);
+    const payload = object9(record3.payload);
     if (ordinal === 0) {
       if (record3.type !== "session_meta" || payload.cli_version !== "0.154.0" || payload.id !== state2.nativeId || payload.session_id !== state2.nativeId || payload.cwd !== "/work" || Object.keys(payload).some((key) => ![
         "session_id",
@@ -50322,7 +50577,7 @@ function validatePrivateCodexSession(state2, secrets2 = []) {
           completions++;
           complete = true;
         } else if (payload.type === "item_completed") {
-          const item2 = object8(payload.item);
+          const item2 = object9(payload.item);
           if (active === undefined || payload.turn_id !== active || payload.thread_id !== state2.nativeId || !["UserMessage", "AgentMessage", "Reasoning"].includes(String(item2.type)))
             invalid4();
         } else if (![
@@ -50338,11 +50593,11 @@ function validatePrivateCodexSession(state2, secrets2 = []) {
       case "response_item":
         if (!["message", "reasoning"].includes(String(payload.type)))
           invalid4();
-        if (payload.type === "message" && (!["system", "developer", "user", "assistant"].includes(String(payload.role)) || !Array.isArray(payload.content) || payload.content.some((part) => !["input_text", "output_text"].includes(String(object8(part).type)))))
+        if (payload.type === "message" && (!["system", "developer", "user", "assistant"].includes(String(payload.role)) || !Array.isArray(payload.content) || payload.content.some((part) => !["input_text", "output_text"].includes(String(object9(part).type)))))
           invalid4();
         break;
       case "turn_context":
-        if (active === undefined || payload.turn_id !== active || payload.cwd !== "/work" || !["never", "on-request"].includes(String(payload.approval_policy)) || !supportedSandboxPolicy(object8(payload.sandbox_policy)))
+        if (active === undefined || payload.turn_id !== active || payload.cwd !== "/work" || !["never", "on-request"].includes(String(payload.approval_policy)) || !supportedSandboxPolicy(object9(payload.sandbox_policy)))
           invalid4();
         break;
       case "world_state":
@@ -50443,8 +50698,8 @@ function privateCodexSessionSecrets(runtime, startup) {
         leaves(child2);
   };
   if (runtime.authentication) {
-    const metadata = runtime.authentication.request._meta;
-    leaves(metadata?.gateway?.headers);
+    const metadata2 = runtime.authentication.request._meta;
+    leaves(metadata2?.gateway?.headers);
   }
   if (startup?.byteLength)
     leaves(JSON.parse(decoder12.decode(startup.subarray(4))).tokens);
@@ -50460,7 +50715,7 @@ function privateCodexSessionBootstrap(state2) {
   header.writeUInt32BE(bytes.byteLength, 4);
   return Buffer.concat([header, path2, bytes]);
 }
-function object8(value) {
+function object9(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value))
     return invalid4();
   return value;
@@ -50532,12 +50787,12 @@ class PrivateFiniteAcpPolicy {
   updates = 0;
   textBytes = 0;
   constructor(configuration = {}) {
-    const policy = object9(snapshotPrivateOrdinaryJson(configuration, "finite ACP policy", invalid5));
+    const policy = object10(snapshotPrivateOrdinaryJson(configuration, "finite ACP policy", invalid5));
     keys(policy, [], ["configuration", "modeId", "maxTurns", "restoreSessionId"]);
     if (Object.hasOwn(policy, "restoreSessionId"))
       this.restoreSessionId = identifier(policy.restoreSessionId);
-    const maxTurns = policy.maxTurns ?? 1;
-    if (typeof maxTurns !== "number" || !Number.isSafeInteger(maxTurns) || maxTurns < 1 || maxTurns > 8)
+    const maxTurns = Object.hasOwn(policy, "maxTurns") ? policy.maxTurns : PRIVATE_NATIVE_TURN_POLICY.default;
+    if (!isPrivateNativeTurnAllowance(maxTurns))
       fail2("Invalid ACP turn allowance");
     this.maxTurns = maxTurns;
     const options = Object.hasOwn(policy, "configuration") ? policy.configuration : [];
@@ -50545,7 +50800,7 @@ class PrivateFiniteAcpPolicy {
       fail2("Invalid finite ACP configuration");
     const ids = new Set;
     for (const item2 of options) {
-      const option = object9(item2);
+      const option = object10(item2);
       keys(option, ["configId", "value"], ["type"]);
       const id = identifier(option.configId);
       if (ids.has(id))
@@ -50569,7 +50824,7 @@ class PrivateFiniteAcpPolicy {
       const frame = this.frame(bytes, "adapter");
       keys(frame, ["jsonrpc", "method", "params"], ["id"]);
       const method = frame.method;
-      const params = object9(frame.params);
+      const params = object10(frame.params);
       if (method === CANCEL) {
         keys(frame, ["jsonrpc", "method", "params"]);
         this.ownedSession(params, []);
@@ -50593,9 +50848,9 @@ class PrivateFiniteAcpPolicy {
           if (params.protocolVersion !== 1)
             fail2("Unsupported ACP version");
           if (params.clientCapabilities !== undefined)
-            keys(object9(params.clientCapabilities), []);
+            keys(object10(params.clientCapabilities), []);
           if (params.clientInfo !== undefined) {
-            const info = object9(params.clientInfo);
+            const info = object10(params.clientInfo);
             keys(info, ["name"], ["version", "title"]);
             for (const value of Object.values(info))
               identifier(value);
@@ -50636,7 +50891,7 @@ class PrivateFiniteAcpPolicy {
             fail2("ACP prompt is not available");
           if (!Array.isArray(params.prompt) || params.prompt.length !== 1)
             fail2("ACP requires one text prompt");
-          const content = object9(params.prompt[0]);
+          const content = object10(params.prompt[0]);
           keys(content, ["type", "text"]);
           if (content.type !== "text" || typeof content.text !== "string" || !content.text || content.text.includes("\x00") || content.text.trimStart().startsWith("/") || encoder11.encode(content.text).byteLength > PRIVATE_FINITE_ACP_LIMITS.promptBytes)
             fail2("ACP prompt exceeds its authority or bounds");
@@ -50671,7 +50926,7 @@ class PrivateFiniteAcpPolicy {
       if (pending === undefined || id !== pending.id || Object.hasOwn(frame, "result") === Object.hasOwn(frame, "error"))
         fail2("ACP response has no matching request");
       if (Object.hasOwn(frame, "error")) {
-        const error = object9(frame.error);
+        const error = object10(frame.error);
         if (!Number.isSafeInteger(error.code) || typeof error.message !== "string")
           fail2("Invalid ACP error response");
         this.pending = undefined;
@@ -50680,7 +50935,7 @@ class PrivateFiniteAcpPolicy {
           toAdapter: response(id, { code: error.code, message: "Native ACP request failed" }, true)
         });
       }
-      const result2 = object9(frame.result);
+      const result2 = object10(frame.result);
       if (this.notice(result2._meta))
         this.pendingNotice = true;
       let projected;
@@ -50692,10 +50947,10 @@ class PrivateFiniteAcpPolicy {
           const sessions = optionalObject(capabilities.sessionCapabilities);
           this.canClose = sessions.close !== undefined && sessions.close !== null;
           if (this.canClose)
-            object9(sessions.close);
+            object10(sessions.close);
           this.canResume = sessions.resume !== undefined && sessions.resume !== null;
           if (this.canResume)
-            object9(sessions.resume);
+            object10(sessions.resume);
           if (this.restoreSessionId !== undefined && !this.canResume)
             fail2("ACP client does not support restoration");
           this.initialized = true;
@@ -50722,8 +50977,8 @@ class PrivateFiniteAcpPolicy {
           const required = this.configuration[this.configured];
           if (!Array.isArray(result2.configOptions))
             fail2("ACP configuration was not confirmed");
-          const matches3 = result2.configOptions.filter((option2) => object9(option2).id === required.configId);
-          if (matches3.length !== 1 || object9(matches3[0]).currentValue !== required.value)
+          const matches3 = result2.configOptions.filter((option2) => object10(option2).id === required.configId);
+          if (matches3.length !== 1 || object10(matches3[0]).currentValue !== required.value)
             fail2("ACP configuration was not confirmed");
           const option = typeof required.value === "boolean" ? {
             id: required.configId,
@@ -50781,7 +51036,7 @@ class PrivateFiniteAcpPolicy {
     });
   }
   clientMessage(frame) {
-    const params = object9(frame.params);
+    const params = object10(frame.params);
     if (frame.method === PERMISSION) {
       keys(frame, ["jsonrpc", "method", "params", "id"]);
       const id = requestId(frame.id);
@@ -50795,12 +51050,12 @@ class PrivateFiniteAcpPolicy {
       fail2("ACP client operation is not permitted");
     if (++this.updates > PRIVATE_FINITE_ACP_LIMITS.updates)
       fail2("ACP update capacity exceeded");
-    const update = object9(params.update);
+    const update = object10(params.update);
     const notice = this.notice(update._meta);
     if (this.sessionId === undefined && (this.pending?.method === NEW || this.pending?.method === RESUME)) {
       keys(params, ["sessionId", "update"], ["_meta"]);
       identifier(params.sessionId);
-      object9(params.update);
+      object10(params.update);
       if (notice)
         this.pendingNotice = true;
       return Object.freeze({});
@@ -50817,7 +51072,7 @@ class PrivateFiniteAcpPolicy {
     } else if (update.sessionUpdate === "agent_message_chunk") {
       if (this.pending?.method !== PROMPT)
         fail2("ACP text arrived outside an active turn");
-      const content = object9(update.content);
+      const content = object10(update.content);
       if (content.type !== "text")
         return Object.freeze({});
       if (typeof content.text !== "string")
@@ -50836,7 +51091,7 @@ class PrivateFiniteAcpPolicy {
       if (!Array.isArray(update.entries))
         fail2("Invalid ACP plan update");
       const entries = update.entries.map((value) => {
-        const entry = object9(value);
+        const entry = object10(value);
         if (typeof entry.content !== "string" || !["high", "medium", "low"].includes(entry.priority) || !["pending", "in_progress", "completed"].includes(entry.status))
           fail2("Invalid ACP plan entry");
         return { content: entry.content, priority: entry.priority, status: entry.status };
@@ -50866,13 +51121,13 @@ class PrivateFiniteAcpPolicy {
       }
     };
   }
-  notice(metadata) {
-    const air = optionalObject(optionalObject(optionalObject(metadata).jetbrains).air);
+  notice(metadata2) {
+    const air = optionalObject(optionalObject(optionalObject(metadata2).jetbrains).air);
     if (air.sessionFailure === undefined || air.sessionFailure === null)
       return false;
     if (air.version !== 1)
       fail2("Unsupported native ACP diagnostic version");
-    const notice = object9(air.sessionFailure);
+    const notice = object10(air.sessionFailure);
     if (notice.severity === "error")
       throw new PrivateFiniteAcpPolicyError("Native ACP reported a session failure", "native-session");
     if (notice.severity !== "warning")
@@ -50902,7 +51157,7 @@ class PrivateFiniteAcpPolicy {
     } catch {
       fail2("Invalid ACP JSON frame");
     }
-    const frame = object9(value);
+    const frame = object10(value);
     if (frame.jsonrpc !== "2.0")
       fail2("Invalid ACP protocol frame");
     return freeze4(frame);
@@ -50944,13 +51199,13 @@ function requestId(value) {
     return value;
   return identifier(value);
 }
-function object9(value) {
+function object10(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value))
     fail2("Invalid ACP object");
   return value;
 }
 function optionalObject(value) {
-  return value === undefined || value === null ? {} : object9(value);
+  return value === undefined || value === null ? {} : object10(value);
 }
 function keys(value, required, optional = []) {
   if (required.some((key) => !Object.hasOwn(value, key)) || Object.keys(value).some((key) => !required.includes(key) && !optional.includes(key)))
@@ -50965,7 +51220,7 @@ function fail2(message2) {
 
 // src/internal/finite-acp-resource.ts
 import { randomUUID as randomUUID5 } from "crypto";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 import { clearTimeout as clearTimeout2, setTimeout as setTimeout2 } from "timers";
 
 // ../agent-acp/dist/transport.js
@@ -50987,7 +51242,7 @@ class FiniteAcpTransportError extends Error {
   }
 }
 var encoder12 = new TextEncoder;
-function object10(value) {
+function object11(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value))
     invalid6("Expected an object");
   const prototype = Object.getPrototypeOf(value);
@@ -51035,7 +51290,7 @@ function identifier2(value) {
   return value;
 }
 function readFiniteAcpReady(value) {
-  const record3 = object10(value);
+  const record3 = object11(value);
   exact6(record3, ["kind", "protocolVersion", "cwd", "maxTurns", "configuration"], ["modeId", "restoreSessionId"]);
   if (record3.kind !== "ready" || record3.protocolVersion !== 1 || record3.cwd !== "/work" || typeof record3.maxTurns !== "number" || !Number.isSafeInteger(record3.maxTurns) || record3.maxTurns < 1 || record3.maxTurns > 8 || !Array.isArray(record3.configuration) || record3.configuration.length > 16)
     invalid6("Invalid finite ACP ready record");
@@ -51048,7 +51303,7 @@ function readFiniteAcpReady(value) {
     if (!descriptor || !Object.hasOwn(descriptor, "value") || !descriptor.enumerable)
       invalid6("Configuration must be a dense data array");
     const item2 = descriptor.value;
-    const entry = object10(item2);
+    const entry = object11(item2);
     exact6(entry, ["configId", "value"], ["type"]);
     const configId = identifier2(entry.configId);
     if (names2.has(configId))
@@ -51113,7 +51368,7 @@ class FiniteAcpFrames {
   }
   accept(value) {
     return this.guard(() => {
-      const record3 = object10(value);
+      const record3 = object11(value);
       exact6(record3, ["kind", "text", "end"]);
       if (record3.kind !== "data" || typeof record3.end !== "boolean")
         invalid6("Invalid finite ACP fragment");
@@ -51318,7 +51573,7 @@ var PRIVATE_FINITE_ACP_CHANNELS = Object.freeze({
     contract: channel(responses_default)
   })
 });
-async function runPrivateFiniteAcpResource(component, runtime, endpoints, signal, maxTurns = 1, session) {
+async function runPrivateFiniteAcpResource(component, runtime, endpoints, signal, maxTurns = PRIVATE_NATIVE_TURN_POLICY.default, session) {
   const local = new AbortController;
   const enforcement = component.enforcement.then((receipt) => receipt);
   const stopped = () => local.abort(signal.reason);
@@ -51371,10 +51626,10 @@ async function runPrivateFiniteAcpResource(component, runtime, endpoints, signal
   };
   const requests = async () => {
     for (;; ) {
-      const item2 = object11(await endpoints.owner.next(endpoints.requests, local.signal));
+      const item2 = object12(await endpoints.owner.next(endpoints.requests, local.signal));
       if (Object.hasOwn(item2, "end"))
         break;
-      const text3 = frames.accept(object11(item2.item).value);
+      const text3 = frames.accept(object12(item2.item).value);
       if (text3 === undefined)
         continue;
       if (authenticationId !== undefined)
@@ -51418,7 +51673,7 @@ async function runPrivateFiniteAcpResource(component, runtime, endpoints, signal
           ...native5,
           params: {
             ...native5.params,
-            cwd: join28(component.owner.owner.allocation.directory, "data", "work")
+            cwd: join29(component.owner.owner.allocation.directory, "data", "work")
           }
         };
       }
@@ -51437,11 +51692,11 @@ async function runPrivateFiniteAcpResource(component, runtime, endpoints, signal
   };
   const responses = async () => {
     for await (const bytes of nativeFrames(component.stdout)) {
-      const raw = object11(decodeJson1(bytes));
+      const raw = object12(decodeJson1(bytes));
       if (authenticationId !== undefined && raw.id === authenticationId) {
         if (raw.jsonrpc !== "2.0" || !Object.hasOwn(raw, "result") || Object.hasOwn(raw, "error") || Object.hasOwn(raw, "method"))
           invalid7("Native ACP authentication failed");
-        object11(raw.result);
+        object12(raw.result);
         authenticationId = undefined;
         const delivery2 = initialize;
         initialize = undefined;
@@ -51449,8 +51704,8 @@ async function runPrivateFiniteAcpResource(component, runtime, endpoints, signal
         continue;
       }
       if (runtime.authentication !== undefined && isInitializeReply(raw)) {
-        const result2 = object11(raw.result);
-        if (!Array.isArray(result2.authMethods) || !result2.authMethods.some((value) => object11(value).id === runtime.authentication.request.methodId))
+        const result2 = object12(raw.result);
+        if (!Array.isArray(result2.authMethods) || !result2.authMethods.some((value) => object12(value).id === runtime.authentication.request.methodId))
           invalid7("Native ACP authentication is unavailable");
         initialize = policy.fromClient(bytes).toAdapter;
         authenticationId = `jig-auth-${randomUUID5()}`;
@@ -51483,7 +51738,7 @@ async function runPrivateFiniteAcpResource(component, runtime, endpoints, signal
   function isInitializeReply(value) {
     if (initializedReply || !Object.hasOwn(value, "result") || value.method !== undefined)
       return false;
-    const result2 = object11(value.result);
+    const result2 = object12(value.result);
     if (result2.protocolVersion !== 1)
       return false;
     initializedReply = true;
@@ -51608,7 +51863,7 @@ async function within(pending, milliseconds, signal) {
     removeAbort();
   }
 }
-function object11(value) {
+function object12(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value))
     invalid7("Invalid native ACP frame");
   return value;
@@ -51659,7 +51914,7 @@ async function executePrivateRootFiniteAcp(input) {
   let participant;
   try {
     const terminal = await executeOwnedProvider(input, provider, recipe, {
-      maxTurns: route.grant.maxTurns ?? 1,
+      maxTurns: route.grant.maxTurns ?? PRIVATE_NATIVE_TURN_POLICY.default,
       ...session === undefined ? {} : { session },
       digest: privateDomainDigest("JIG-Private-Finite-ACP-Request/1", {
         providerDigest: provider.digest,
@@ -52226,8 +52481,8 @@ function failed2(code2, message2, details) {
 }
 
 // src/internal/root-flow-call-controller.ts
-import { lstat as lstat23, mkdir as mkdir10, realpath as realpath23 } from "fs/promises";
-import { join as join29 } from "path";
+import { lstat as lstat25, mkdir as mkdir10, realpath as realpath23 } from "fs/promises";
+import { join as join30 } from "path";
 
 // src/internal/run-channels.ts
 class PrivateRunChannels {
@@ -52961,9 +53216,9 @@ function childIdentity(parentRunId, operationId) {
   }).slice("sha256:".length);
 }
 async function protectedWorkRoots(projectRoot) {
-  const state2 = await realpath23(join29(projectRoot, ".jig"));
-  const materializations = join29(state2, "private-root-materializations");
-  const owners3 = join29(state2, "private-root-owners");
+  const state2 = await realpath23(join30(projectRoot, ".jig"));
+  const materializations = join30(state2, "private-root-materializations");
+  const owners3 = join30(state2, "private-root-owners");
   await Promise.all([ensureProtectedDirectory(materializations), ensureProtectedDirectory(owners3)]);
   return Object.freeze({ materializations, owners: owners3 });
 }
@@ -52972,7 +53227,7 @@ async function ensureProtectedDirectory(path2) {
     if (!hasCode7(error, "EEXIST"))
       throw error;
   });
-  const information = await lstat23(path2);
+  const information = await lstat25(path2);
   const uid = typeof process.getuid === "function" ? process.getuid() : -1;
   if (!information.isDirectory() || information.isSymbolicLink() || information.uid !== uid || (information.mode & 63) !== 0 || await realpath23(path2) !== path2) {
     throw new Error("child execution owner directory is not protected");
@@ -53549,9 +53804,9 @@ async function reacquire(input) {
   });
 }
 async function protectedWorkRoots2(projectRoot) {
-  const state2 = await realpath24(join30(projectRoot, ".jig"));
-  const materializations = join30(state2, "private-root-materializations");
-  const owners3 = join30(state2, "private-root-owners");
+  const state2 = await realpath24(join31(projectRoot, ".jig"));
+  const materializations = join31(state2, "private-root-materializations");
+  const owners3 = join31(state2, "private-root-owners");
   await Promise.all([ensureProtectedDirectory2(materializations), ensureProtectedDirectory2(owners3)]);
   return Object.freeze({ materializations, owners: owners3 });
 }
@@ -53560,7 +53815,7 @@ async function ensureProtectedDirectory2(path2) {
     if (!hasCode8(error, "EEXIST"))
       throw error;
   });
-  const information = await lstat24(path2);
+  const information = await lstat26(path2);
   const uid = typeof process.getuid === "function" ? process.getuid() : -1;
   if (!information.isDirectory() || information.isSymbolicLink() || information.uid !== uid || (information.mode & 63) !== 0 || await realpath24(path2) !== path2) {
     throw new Error("private root execution work directory is not protected");
@@ -54052,7 +54307,13 @@ function closedTestErrorCauses(error) {
   return result2;
 }
 function closedNativeTestCause(error) {
-  switch (error.message) {
+  let message2;
+  try {
+    message2 = error.message;
+  } catch {
+    return;
+  }
+  switch (message2) {
     case "macOS control deadline expired":
       return "MACOS_CONTROL_DEADLINE";
     case "macOS guardian bootstrap failed":
@@ -54061,12 +54322,28 @@ function closedNativeTestCause(error) {
       return "MACOS_GUARDIAN_CONNECTION_LOST";
     case "macOS guardian job removal is unconfirmed":
       return "MACOS_GUARDIAN_REMOVAL_UNCONFIRMED";
+    case "macOS guardian job is still present":
+      return "MACOS_GUARDIAN_JOB_PRESENT";
+    case "macOS storage recovery guardian job is still present":
+      return "MACOS_RECOVERY_JOB_PRESENT";
+    case "macOS storage recovery is unconfirmed":
+      return "MACOS_STORAGE_RECOVERY_UNCONFIRMED";
+    case "macOS volume backing identity changed":
+      return "MACOS_VOLUME_BACKING_CHANGED";
+    case "macOS volume info failed":
+      return "MACOS_VOLUME_INFO";
+    case "macOS volume detach failed":
+      return "MACOS_VOLUME_DETACH";
+    case "macOS guardian contains unexpected state":
+      return "MACOS_GUARDIAN_UNEXPECTED_STATE";
+    case "macOS recovery slot contains unexpected state":
+      return "MACOS_RECOVERY_UNEXPECTED_STATE";
     case "macOS prepared ownership does not match":
       return "MACOS_PREPARED_OWNER_MISMATCH";
     case "native macOS Run was cancelled before admission":
       return "MACOS_STARTUP_CANCELLED";
     default:
-      return error.message.startsWith("macOS guardian ended before readiness (") && error.message.endsWith(")") ? "MACOS_GUARDIAN_BEFORE_READINESS" : undefined;
+      return message2.startsWith("macOS guardian ended before readiness (") && message2.endsWith(")") ? "MACOS_GUARDIAN_BEFORE_READINESS" : undefined;
   }
 }
 function createSession(owner, roots, packageStore, host, onOperationFailure) {
@@ -54447,7 +54724,7 @@ function createSession(owner, roots, packageStore, host, onOperationFailure) {
 async function preparePackageStore(owner) {
   await owner.verify();
   const statePath = privateChildLocation(owner.root.handle, ".jig");
-  const state2 = await openPrivateFile(statePath, constants32.O_RDONLY | constants32.O_DIRECTORY | constants32.O_NOFOLLOW | constants32.O_NONBLOCK);
+  const state2 = await openPrivateFile(statePath, constants35.O_RDONLY | constants35.O_DIRECTORY | constants35.O_NOFOLLOW | constants35.O_NONBLOCK);
   try {
     const storePath = privateChildLocation(state2, PRIVATE_PACKAGE_STORE_DIRECTORY);
     try {
@@ -54459,7 +54736,7 @@ async function preparePackageStore(owner) {
     await state2.sync();
     const observed = await statPrivateFile(storePath);
     requireProtectedStore(observed, owner.root.information.dev);
-    const store = await openPrivateFile(storePath, constants32.O_RDONLY | constants32.O_DIRECTORY | constants32.O_NOFOLLOW | constants32.O_NONBLOCK);
+    const store = await openPrivateFile(storePath, constants35.O_RDONLY | constants35.O_DIRECTORY | constants35.O_NOFOLLOW | constants35.O_NONBLOCK);
     try {
       const actual = await store.stat({ bigint: true });
       requireProtectedStore(actual, owner.root.information.dev);
@@ -54570,7 +54847,7 @@ function isUnavailableDiagnosticCode(code2) {
     "AUTHORING_INTERRUPTED",
     "AUTHORING_LIMIT",
     "AUTHORING_STATE"
-  ].includes(code2) || code2 === "PACKAGE_BUN_SOURCE_UNSUPPORTED" || code2 === "PACKAGE_BUN_RESOLUTION_PERMISSION_REQUIRED" || code2 === "PACKAGE_BUN_RESOLUTION_FAILED" || code2 === "PACKAGE_BUN_RESOLUTION_VERSION_UNAVAILABLE" || code2 === "PACKAGE_BUN_RESOLVED_SOURCE_UNSUPPORTED" || code2 === "PACKAGE_BUN_PREPARATION_FAILED" || code2 === "PROJECT_ACP_UNAVAILABLE" || code2 === "PROJECT_HTTP_UNAVAILABLE" || code2 === "PACKAGE_PROFILE_UNSUPPORTED" || code2 === "PACKAGE_METADATA_UNSUPPORTED" || code2 === "PACKAGE_TOOLS_UNSUPPORTED" || code2 === "PROJECT_INTERFACE_ANONYMOUS" || code2 === "PROJECT_ATTACHMENTS_UNSUPPORTED";
+  ].includes(code2) || code2 === "PACKAGE_BUN_SOURCE_UNSUPPORTED" || code2 === "PACKAGE_BUN_LOCK_VERSION_UNSUPPORTED" || code2 === "PACKAGE_BUN_RESOLUTION_PERMISSION_REQUIRED" || code2 === "PACKAGE_BUN_RESOLUTION_FAILED" || code2 === "PACKAGE_BUN_RESOLUTION_VERSION_UNAVAILABLE" || code2 === "PACKAGE_BUN_RESOLVED_SOURCE_UNSUPPORTED" || code2 === "PACKAGE_BUN_PREPARATION_FAILED" || code2 === "PROJECT_ACP_UNAVAILABLE" || code2 === "PROJECT_HTTP_UNAVAILABLE" || code2 === "PACKAGE_PROFILE_UNSUPPORTED" || code2 === "PACKAGE_METADATA_UNSUPPORTED" || code2 === "PACKAGE_TOOLS_UNSUPPORTED" || code2 === "PROJECT_INTERFACE_ANONYMOUS" || code2 === "PROJECT_ATTACHMENTS_UNSUPPORTED";
 }
 function isCandidateDiagnosticCode(code2) {
   return ["AUTHORING_COMPILE", "AUTHORING_CONFLICT"].includes(code2) || code2.startsWith("CONTRACT_") || code2.startsWith("MARKDOWN_") || code2.startsWith("METADATA_") || code2.startsWith("SCHEMA_") || code2.startsWith("PACKAGE_BUN_") || code2.startsWith("PROJECT_BINDING_") || code2.startsWith("PROJECT_DEFAULT_") || code2.startsWith("PROJECT_PROVIDER_") || code2.startsWith("PROJECT_DEPENDENCY_") || code2.startsWith("PROJECT_GRANT") || code2.startsWith("PROJECT_DECLARATION_") || code2.startsWith("PROJECT_EVALUATION_") || code2.startsWith("PROJECT_EVALUATOR_") || code2.startsWith("PROJECT_MEMBER_") || code2.startsWith("PROJECT_SOURCE_") || [
@@ -54596,7 +54873,8 @@ function isCandidateDiagnosticCode(code2) {
     "PACKAGE_SPECIAL_FILE",
     "PACKAGE_SYMLINK",
     "PROJECT_FLOW_COLLISION",
-    "PROJECT_FLOW_MODE_UNSUPPORTED"
+    "PROJECT_FLOW_MODE_UNSUPPORTED",
+    "PROJECT_CHECKPOINT_ATTACHMENT"
   ].includes(code2);
 }
 function isRootIdentityLoss(error, owner) {
@@ -54619,7 +54897,7 @@ var releaseRoot;
 var executablePath;
 try {
   installedCliPath = await realpath25(fileURLToPath5(import.meta.url));
-  releaseRoot = dirname19(dirname19(installedCliPath));
+  releaseRoot = dirname20(dirname20(installedCliPath));
   executablePath = await realpath25(process.execPath);
   const runningExecutablePath = process.platform === "linux" ? await realpath25("/proc/self/exe") : executablePath;
   if (process.argv[0] !== executablePath || process.argv[1] !== installedCliPath || runningExecutablePath !== executablePath || process.execArgv.length !== BUN_POLICY5.length || process.execArgv.some((value, index) => value !== BUN_POLICY5[index])) {