@jigging/jig 0.1.0-alpha.13 → 0.1.0-alpha.14

package/libexec/installed-cli.js

@@ -6996,19 +6996,18 @@ var require_x509_transport_state = __commonJS((exports, module) => {
 
 // src/installed-cli.ts
 import { realpath as realpath14 } from "fs/promises";
-import { dirname as dirname10 } from "path";
+import { dirname as dirname9 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/cli.ts
 import { randomBytes as randomBytes2 } from "crypto";
-import { closeSync as closeSync2 } from "fs";
-import { basename, dirname as dirname3, resolve as resolve3 } from "path";
+import { resolve as resolve3 } from "path";
 import { createInterface } from "readline/promises";
 import { setTimeout as delay } from "timers/promises";
 // package.json
 var package_default = {
   name: "@jigging/jig",
-  version: "0.1.0-alpha.13",
+  version: "0.1.0-alpha.14",
   description: "A local, secure host for admitted FLOW packages",
   license: "MPL-2.0",
   repository: {
@@ -7050,6 +7049,7 @@ var package_default = {
     "dist/index.js",
     "dist/index.d.ts",
     "dist/project/author.d.ts",
+    "dist/project/commands.d.ts",
     "dist/json.d.ts",
     "libexec/installed-cli.js",
     "libexec/linux-rootless-supervisor.js",
@@ -9325,6 +9325,43 @@ function normalizeProjectAdministrationDiagnostic(value) {
   });
 }
 
+// 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)
+    throw new TypeError("command file paths must be bounded relative paths without traversal");
+  return value;
+}
+function normalizeProjectCommands(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    throw new TypeError("commands must be an object");
+  const entries = Object.entries(value);
+  if (entries.length > 8)
+    throw new TypeError("commands exceed eight entries");
+  const output = Object.create(null);
+  for (const [name, item] of entries.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name) || name.length > 64)
+      throw new TypeError("command name must be a LocalName");
+    if (item === null || typeof item !== "object" || Array.isArray(item) || Object.keys(item).length !== 1)
+      throw new TypeError(`command ${name} must contain run or test`);
+    const command = item;
+    if (Object.hasOwn(command, "run")) {
+      const path = projectCommandPath(command.run);
+      if (!path.endsWith(".ts") && !path.endsWith(".js"))
+        throw new TypeError("command run must name a .ts or .js entrypoint");
+      output[name] = Object.freeze({ run: path });
+    } else if (Object.hasOwn(command, "test") && Array.isArray(command.test)) {
+      if (command.test.length === 0 || command.test.length > 16)
+        throw new TypeError("command test must select one to sixteen test files");
+      const paths = command.test.map(projectCommandPath);
+      if (new Set(paths).size !== paths.length || paths.some((path) => !/\.(test|spec)\.(ts|js)$/.test(path)))
+        throw new TypeError("command test must name distinct .test or .spec files");
+      output[name] = Object.freeze({ test: Object.freeze(paths) });
+    } else
+      throw new TypeError(`command ${name} must contain run or test`);
+  }
+  return Object.freeze(output);
+}
+
 // src/project/author.ts
 var LOCAL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 var GLOB_CHARACTERS = /[*?\[\]{}]/;
@@ -9363,7 +9400,7 @@ function normalizePackageBindingDefinition(input) {
 }
 function normalizeBinding(input, canonical) {
   const captured = snapshotJsonObject(input, "Binding definition");
-  assertClosedObject(captured, canonical ? ["kind", "package", "settings", "slots"] : ["package", "settings", "slots"], "Binding definition");
+  assertClosedObject(captured, canonical ? ["kind", "package", "settings", "slots", "commands"] : ["package", "settings", "slots", "commands"], "Binding definition");
   if (canonical && captured.kind !== "package") {
     throw new TypeError("Binding kind must be package");
   }
@@ -9372,11 +9409,13 @@ function normalizeBinding(input, canonical) {
   const packagePath = normalizeProjectPath(captured.package, "package");
   const settings = Object.hasOwn(captured, "settings") ? expectJsonObject(captured.settings, "settings") : emptyRecord();
   const slots = Object.hasOwn(captured, "slots") ? normalizeFlowSlots(captured.slots) : emptyRecord();
+  const commands = normalizeProjectCommands(Object.hasOwn(captured, "commands") ? captured.commands : {});
   return record({
     kind: "package",
     package: packagePath,
     settings,
-    slots
+    slots,
+    ...Object.keys(commands).length === 0 ? {} : { commands }
   });
 }
 function normalizeFlowSlots(value) {
@@ -9827,15 +9866,58 @@ import {
   constants,
   fstatSync,
   opendirSync,
+  openSync,
   readFileSync,
   readSync,
-  realpathSync,
   statfsSync,
   writeSync
 } from "fs";
 import { createRequire } from "module";
 import { dirname, posix, resolve as resolve2 } from "path";
 import { getSystemErrorName } from "util";
+
+// src/internal/linux-host-paths.ts
+import { realpathSync } from "fs";
+import { realpath } from "fs/promises";
+var LOADER_PATHS = [
+  "/run/current-system/sw/share/nix-ld/lib/ld.so",
+  "/lib64/ld-linux-x86-64.so.2"
+];
+function privateLinuxHostToolCandidates(name) {
+  return [
+    ...name === "codex" ? [`/usr/local/bin/${name}`] : [],
+    `/usr/bin/${name}`,
+    `/bin/${name}`,
+    `/run/current-system/sw/bin/${name}`
+  ];
+}
+async function resolvePrivateLinuxHostPath(candidates, resolve2 = realpath) {
+  for (const path of candidates) {
+    try {
+      return await resolve2(path);
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+  }
+  throw new Error("the required system-owned host file is unavailable");
+}
+function resolvePrivateLinuxHostLoader(resolve2 = realpath) {
+  return resolvePrivateLinuxHostPath(LOADER_PATHS, resolve2);
+}
+function resolvePrivateLinuxHostLoaderSync(resolve2 = realpathSync) {
+  for (const path of LOADER_PATHS) {
+    try {
+      return resolve2(path);
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+  }
+  throw new Error("the required system-owned glibc loader is unavailable");
+}
+
+// src/internal/linux-file-input.ts
 var PRIVATE_FILE_LIMITS = Object.freeze({
   bytes: 8 * 1024 * 1024,
   files: 64,
@@ -9863,10 +9945,20 @@ class PrivateFileInputError extends Error {
   constructor(reason, limit) {
     super({
       filesystem: "use a local ext4, XFS, Btrfs, or tmpfs filesystem",
+      native: "Jig could not load its Linux file controls; check the supported glibc loader and libc installation",
+      mount: "the selected attachment mount could not be identified; check that it is visible in the process mount namespace",
+      symlink: "the selected attachment contains a symbolic link; select a directory and files without links",
+      missing: "the selected attachment directory or file does not exist; check --attach and --select",
+      access: "the selected attachment cannot be read by the current operator; check its file and directory permissions",
+      "cross-mount": "the selected attachment crosses a mount boundary; select each mounted directory separately",
+      kernel: "the kernel does not provide the required Linux file controls; check the supported-host requirements",
       path: "select a relative path without traversal or links, within 16 components and 512 UTF-8 bytes",
       protected: "Jig state and host control files cannot be selected as input",
       linked: "select only singly linked regular files",
+      "input-link": "the selected --input file cannot be a symbolic link",
+      regular: "select a regular input file, not a directory or special file",
       changed: "selected input changed during capture; capture a stable source tree",
+      "input-changed": "the selected --input file changed during capture; retry with a stable file",
       bytes: `selected file exceeds the remaining ${limit ?? 0}-byte input budget; select less data`,
       files: "input exceeds 64 files; narrow the selection with --select",
       entries: "input exceeds 256 tree entries; narrow the selection with --select",
@@ -9883,22 +9975,35 @@ function calls() {
   if (process.platform !== "linux" || process.arch !== "x64")
     throw new Error("Linux x64 file controls are unavailable");
   const ffi = createRequire(import.meta.url)("bun:ffi");
-  const libc = posix.join(dirname(realpathSync("/lib64/ld-linux-x86-64.so.2")), "libc.so.6");
-  const { symbols } = ffi.dlopen(libc, {
-    syscall: { args: ["i64", "i32", "ptr", "ptr", "u64"], returns: "i32" },
-    memfd_create: { args: ["ptr", "u32"], returns: "i32" },
-    fcntl: { args: ["i32", "i32", "i32"], returns: "i32" },
-    renameat2: { args: ["i32", "ptr", "i32", "ptr", "u32"], returns: "i32" },
-    __errno_location: { args: [], returns: "ptr" }
-  });
-  native = { ffi, symbols };
-  return native;
+  try {
+    const libc = posix.join(dirname(resolvePrivateLinuxHostLoaderSync()), "libc.so.6");
+    const { symbols } = ffi.dlopen(libc, {
+      syscall: { args: ["i64", "i32", "ptr", "ptr", "u64"], returns: "i32" },
+      memfd_create: { args: ["ptr", "u32"], returns: "i32" },
+      fcntl: { args: ["i32", "i32", "i32"], returns: "i32" },
+      renameat2: { args: ["i32", "ptr", "i32", "ptr", "u32"], returns: "i32" },
+      __errno_location: { args: [], returns: "ptr" }
+    });
+    native = { ffi, symbols };
+    return native;
+  } catch {
+    throw new PrivateFileInputError("native");
+  }
 }
 function result(value) {
   if (value >= 0)
     return value;
   const { ffi, symbols } = calls();
   const code = getSystemErrorName(-ffi.read.i32(symbols.__errno_location()));
+  const reason = {
+    ELOOP: "symlink",
+    ENOENT: "missing",
+    EACCES: "access",
+    EXDEV: "cross-mount",
+    ENOSYS: "kernel"
+  };
+  if (Object.hasOwn(reason, code))
+    throw new PrivateFileInputError(reason[code]);
   throw Object.assign(new Error(`file boundary operation failed (${code})`), { code });
 }
 function cString(value) {
@@ -9944,12 +10049,12 @@ function privateOpenFileRoot(path) {
     const mount = readFileSync("/proc/self/mountinfo", "utf8").split(`
 `).find((line) => line.split(" ")[0] === mountId)?.split(" ");
     if (mount === undefined)
-      throw new TypeError("file mount identity is unavailable");
+      throw new PrivateFileInputError("mount");
     const decodeMountPath = (text) => text.replace(/\\([0-7]{3})/g, (_, octal) => String.fromCharCode(parseInt(octal, 8)));
     const root = decodeMountPath(mount[3]), point = decodeMountPath(mount[4]);
     const relative = posix.relative(point, absolute);
     if (relative.startsWith("../") || posix.isAbsolute(relative))
-      throw new TypeError("file mount identity changed");
+      throw new PrivateFileInputError("mount");
     requireUnprotected(posix.join(root, relative));
     return fd;
   } catch (error) {
@@ -9986,6 +10091,39 @@ function privateReadRegularFile(parent, path, maxBytes) {
     closeSync(fd);
   }
 }
+function privateReadOperatorFile(path, maxBytes) {
+  let fd;
+  try {
+    fd = openSync(path, constants.O_RDONLY | constants.O_NONBLOCK | O_CLOEXEC | constants.O_NOFOLLOW);
+  } catch (error) {
+    if (error.code === "ELOOP") {
+      throw new PrivateFileInputError("input-link");
+    }
+    throw error;
+  }
+  try {
+    const before = fstatSync(fd, { bigint: true });
+    if (!before.isFile())
+      throw new PrivateFileInputError("regular");
+    if (before.size > BigInt(maxBytes))
+      throw new PrivateFileInputError("bytes", maxBytes);
+    const bytes = Buffer.alloc(Number(before.size) + 1);
+    let offset = 0;
+    while (offset < bytes.length) {
+      const count = readSync(fd, bytes, offset, bytes.length - offset, null);
+      if (count === 0)
+        break;
+      offset += count;
+    }
+    const after = fstatSync(fd, { bigint: true });
+    if (offset !== Number(before.size) || after.size !== before.size || after.mtimeNs !== before.mtimeNs || after.ctimeNs !== before.ctimeNs) {
+      throw new PrivateFileInputError("input-changed");
+    }
+    return bytes.subarray(0, offset);
+  } finally {
+    closeSync(fd);
+  }
+}
 function privateCaptureAttachments(selections) {
   const attachments = [];
   const opened = [];
@@ -10141,28 +10279,6 @@ import { execFile } from "child_process";
 import { constants as constants2 } from "fs";
 import { access, readFile, readdir, realpath as realpath2, stat, statfs } from "fs/promises";
 import { posix as posix2 } from "path";
-
-// src/internal/linux-host-paths.ts
-import { realpath } from "fs/promises";
-function privateLinuxHostToolCandidates(name) {
-  return [`/usr/bin/${name}`, `/bin/${name}`, `/run/current-system/sw/bin/${name}`];
-}
-async function resolvePrivateLinuxHostPath(candidates, resolve3 = realpath) {
-  for (const path of candidates) {
-    try {
-      return await resolve3(path);
-    } catch (error) {
-      if (error.code !== "ENOENT")
-        throw error;
-    }
-  }
-  throw new Error("the required system-owned host file is unavailable");
-}
-function resolvePrivateLinuxHostLoader(resolve3 = realpath) {
-  return resolvePrivateLinuxHostPath(["/run/current-system/sw/share/nix-ld/lib/ld.so", "/lib64/ld-linux-x86-64.so.2"], resolve3);
-}
-
-// src/internal/linux-rootless-acquisition.ts
 var CGROUP_ROOT = "/sys/fs/cgroup";
 var CGROUP2_SUPER_MAGIC = 0x6367_7270n;
 var MAX_PROCESS_OUTPUT_BYTES = 16 * 1024;
@@ -10644,7 +10760,7 @@ class PrivateLinuxCgroupBackend {
       });
       const cancel = () => writeControlBestEffort(control, { type: "cancel" });
       signal?.addEventListener("abort", cancel, { once: true });
-      const preparedMessage = requireSupervisorMessage(await withTimeout(nextMessage(messages, closed), this.#options.startupTimeoutMs, "rootless preparation"), "prepared");
+      const preparedMessage = requireSupervisorMessage(await withTimeout(readPrivateSupervisorMessage(messages, closed), this.#options.startupTimeoutMs, "rootless preparation"), "prepared");
       preparedReached = true;
       requirePreparedMessage(preparedMessage, data);
       await requirePreparedCgroup(data);
@@ -10653,7 +10769,7 @@ class PrivateLinuxCgroupBackend {
       if (signal?.aborted)
         throw new Error("rootless Linux Run was cancelled before admission");
       writeControl(control, { type: "admit" });
-      const ready = requireSupervisorMessage(await withTimeout(nextMessage(messages, closed), this.#options.startupTimeoutMs, "rootless readiness"), "ready");
+      const ready = requireSupervisorMessage(await withTimeout(readPrivateSupervisorMessage(messages, closed), this.#options.startupTimeoutMs, "rootless readiness"), "ready");
       requireReadyMessage(ready, preparedMessage, data);
       if (ready.supervisorPid !== supervisor.pid)
         throw new Error("output owner identity changed");
@@ -11903,21 +12019,20 @@ function requireSupervisorMessage(value, type) {
   }
   return message;
 }
-async function nextMessage(iterator, closed) {
+async function readPrivateSupervisorMessage(iterator, closed) {
+  const pending = iterator.next().then((next) => {
+    if (next.done)
+      throw new Error("rootless supervisor control closed");
+    return next.value;
+  });
   return await Promise.race([
-    iterator.next().then((next) => {
-      if (next.done)
-        throw new Error("rootless supervisor control closed");
-      return next.value;
-    }),
-    closed.then((exit) => {
-      throw new Error(`rootless supervisor exited before completing (${exit.code ?? exit.signal})`);
-    })
+    pending,
+    closed.then(() => withTimeout(pending, 1000, "rootless supervisor final channel drain"))
   ]);
 }
 async function waitForTerminal(iterator, closed) {
   for (;; ) {
-    const value = await nextMessage(iterator, closed);
+    const value = await readPrivateSupervisorMessage(iterator, closed);
     if (dataType(value) === "terminal")
       return normalizeFinal(value);
   }
@@ -12194,6 +12309,7 @@ class PrivateRootRunFiles {
         settings: request.settings,
         capabilities: request.capabilities,
         flowSlots: request.flowSlots,
+        ...request.commands === undefined ? {} : { commands: request.commands },
         attachments: request.attachments
       })))
     });
@@ -12340,15 +12456,11 @@ async function executeRun(arguments_, runtime) {
   try {
     if (parsed.inputFile !== undefined) {
       const path = resolve3(runtime.currentDirectory, parsed.inputFile);
-      const parent = privateOpenFileRoot(dirname3(path));
-      try {
-        input = decodeJson1(privateReadRegularFile(parent, basename(path), JSON_1_LIMITS.bytes));
-      } finally {
-        closeSync2(parent);
-      }
+      input = decodeJson1(privateReadOperatorFile(path, JSON_1_LIMITS.bytes));
     }
   } catch (error) {
-    throw new CliDiagnostic("JIG_RUN_INPUT_INVALID", error instanceof PrivateFileInputError ? error.message : "--input requires bounded JSON/1 in a regular file; check the path, links, size, and contents", 1);
+    const message = error instanceof PrivateFileInputError ? error.message : error instanceof Json1Error ? `the selected --input file is not FLOW JSON/1: ${error.message}` : error.code === "ENOENT" ? "the selected --input file does not exist" : error.code === "EACCES" ? "the selected --input file is not readable by the current operator" : "--input file capture failed; check that it is a stable, readable regular file";
+    throw new CliDiagnostic("JIG_RUN_INPUT_INVALID", message, 1);
   }
   let capture;
   try {
@@ -12676,7 +12788,7 @@ function renderFailure(error, runtime) {
   }
   if (error instanceof ProjectAdministrationError) {
     const projected = projectError(error.code);
-    const hint = error.diagnostic?.code === "PROJECT_AGENT_UNAVAILABLE" ? runtime.host.agentUnavailableHint ?? "configure the host Agent before review; check exported credentials, model, and selected client" : error.diagnostic?.code === "PACKAGE_BUN_NODE_MODULES" ? "move generated node_modules outside the Flow package; jig review prepares its locked production dependencies" : error.diagnostic?.code === "PACKAGE_BUN_PREPARATION_FAILED" ? "locked dependencies could not be prepared; check registry access and package availability" : undefined;
+    const hint = error.diagnostic?.code === "PROJECT_AGENT_UNAVAILABLE" ? runtime.host.agentUnavailableHint ?? "configure the host Agent before review; check exported credentials, model, and selected client" : error.diagnostic?.code === "PROJECT_COMMAND_UNCONFIGURED" ? "select a Binding with reviewed commands for this Flow" : error.diagnostic?.code === "PACKAGE_BUN_NODE_MODULES" ? "move generated node_modules outside the Flow package; jig review prepares its locked production dependencies" : error.diagnostic?.code === "PACKAGE_BUN_PREPARATION_FAILED" ? "locked dependencies could not be prepared; check registry access and package availability" : undefined;
     runtime.writeError(error.diagnostic !== undefined ? renderProjectDiagnostic(error, hint ?? projected.message) : renderDiagnostic(error.code, projected.message));
     return projected.exitCode;
   }
@@ -12759,9 +12871,9 @@ import { randomBytes as randomBytes4 } from "crypto";
 import { connect, createServer as createServer2 } from "net";
 
 // src/internal/file-delivery.ts
-import { closeSync as closeSync3, fstatSync as fstatSync2, lstatSync, mkdirSync, opendirSync as opendirSync2 } from "fs";
+import { closeSync as closeSync2, fstatSync as fstatSync2, lstatSync, mkdirSync, opendirSync as opendirSync2 } from "fs";
 import { mkdir as mkdir3, open as open2, rm as rm2, statfs as statfs3 } from "fs/promises";
-import { basename as basename2, dirname as dirname4, resolve as resolve4 } from "path";
+import { basename, dirname as dirname3, resolve as resolve4 } from "path";
 import { randomBytes as randomBytes3 } from "crypto";
 class PrivateFileDeliveryOwner {
   signal;
@@ -12785,7 +12897,7 @@ class PrivateFileDeliveryOwner {
     let parent;
     try {
       this.signal.throwIfAborted();
-      const destination = resolve4(directory), parentPath = dirname4(destination), leaf = privateFilePath(basename2(destination));
+      const destination = resolve4(directory), parentPath = dirname3(destination), leaf = privateFilePath(basename(destination));
       if (destination === parentPath || leaf.includes("/"))
         throw new TypeError("output requires a new directory");
       parent = privateOpenFileRoot(parentPath);
@@ -12810,7 +12922,7 @@ class PrivateFileDeliveryOwner {
       this.#destination = destination;
     } finally {
       if (parent !== undefined)
-        closeSync3(parent);
+        closeSync2(parent);
       this.#preparing = false;
     }
   }
@@ -12868,7 +12980,7 @@ class PrivateFileDeliveryOwner {
           } finally {
             directory.closeSync();
             if (fd !== output.fd)
-              closeSync3(fd);
+              closeSync2(fd);
           }
         };
         walk("");
@@ -12892,7 +13004,7 @@ class PrivateFileDeliveryOwner {
       for (const file of files) {
         checkTime();
         const destination = `${stagePath}/files/${file.path}`;
-        await mkdir3(dirname4(destination), { recursive: true, mode: 448 });
+        await mkdir3(dirname3(destination), { recursive: true, mode: 448 });
         const handle = await open2(destination, "wx", 384);
         try {
           await handle.writeFile(file.contents);
@@ -12936,7 +13048,7 @@ class PrivateFileDeliveryOwner {
   async close() {
     await this.#cleanupStage();
     if (this.#parent !== undefined) {
-      closeSync3(this.#parent);
+      closeSync2(this.#parent);
       this.#parent = undefined;
     }
   }
@@ -12947,7 +13059,7 @@ class PrivateFileDeliveryOwner {
       if (before.dev !== after.dev || before.ino !== after.ino)
         throw new Error("destination parent changed");
     } finally {
-      closeSync3(current);
+      closeSync2(current);
     }
   }
   async#cleanupStage() {
@@ -12981,14 +13093,14 @@ function directoryContains(root, candidate) {
         return true;
       const next = privateOpenAt(current, "..", 2097152 | 65536, false);
       const parent = fstatSync2(next, { bigint: true });
-      closeSync3(current);
+      closeSync2(current);
       current = next;
       if (parent.dev === info.dev && parent.ino === info.ino)
         return false;
     }
     throw new Error("output ancestry exceeds limit");
   } finally {
-    closeSync3(current);
+    closeSync2(current);
   }
 }
 
@@ -13204,7 +13316,7 @@ async function* messages(socket) {
 
 // src/internal/claude-agent-provider.ts
 import { lstat as lstat3, realpath as realpath5 } from "fs/promises";
-import { dirname as dirname5, join as join3 } from "path";
+import { dirname as dirname4, join as join3 } from "path";
 
 // src/internal/acp-agent-provider.ts
 import { constants as constants3 } from "fs";
@@ -14627,7 +14739,7 @@ async function openPrivateClaudeAgentProvider(releaseRoot, environment = process
     adapterPath: join3(releaseRoot, "libexec", "agent", "claude-agent-acp.js"),
     executablePath,
     certificatesPath: await ordinaryFile(HOST_CERTIFICATES_PATH, "host certificate bundle"),
-    runtimeLibraryPath: await ordinaryFile(join3(dirname5(await resolvePrivateLinuxHostLoader()), "librt.so.1"), "Claude runtime library")
+    runtimeLibraryPath: await ordinaryFile(join3(dirname4(await resolvePrivateLinuxHostLoader()), "librt.so.1"), "Claude runtime library")
   });
   const apiKey = environment.ANTHROPIC_API_KEY;
   const authToken = environment.ANTHROPIC_AUTH_TOKEN;
@@ -14814,6 +14926,15 @@ var MAX_CREDENTIAL_BYTES = 64 * 1024 - 4;
 var MAX_SECRET_BYTES = 16 * 1024;
 var MAX_BASE_URL_CHARACTERS2 = 4096;
 var encoder5 = new TextEncoder;
+
+class PrivateCodexLoginUnavailableError extends Error {
+}
+
+class PrivateCodexExecutableUnavailableError extends Error {
+}
+
+class PrivateCodexSandboxUnavailableError extends Error {
+}
 var decoder2 = new TextDecoder("utf-8", { fatal: true });
 var OPENAI_API_KEY = "OPENAI_API_KEY";
 var OPENAI_MODEL = "OPENAI_MODEL";
@@ -14831,15 +14952,12 @@ var PRIVATE_CODEX_REQUIREMENTS = [
 ].join(`
 `);
 async function openPrivateCodexAgentProvider(releaseRoot, environment = process.env) {
-  const executablePath = environment.CODEX_PATH;
-  if (executablePath === undefined || executablePath.length === 0) {
-    throw new Error("the native Codex executable is unavailable");
-  }
+  const executablePath = await resolveCodexExecutable(environment.CODEX_PATH);
   const support = Object.freeze({
     launcherPath: join4(releaseRoot, "libexec", "agent", "codex-agent-launcher.js"),
     adapterPath: join4(releaseRoot, "libexec", "agent", "codex-acp.js"),
     executablePath,
-    nativeBubblewrapPath: await nativeBubblewrapFor(executablePath),
+    nativeBubblewrapPath: await nativeBubblewrapFor(executablePath, environment.JIG_BWRAP_PATH),
     certificatesPath: await ordinaryFile2(HOST_CERTIFICATES_PATH2, "host certificate bundle"),
     requirementsPath: join4(releaseRoot, "libexec", "agent", "codex-requirements.toml")
   });
@@ -14862,7 +14980,12 @@ async function openPrivateCodexAgentProvider(releaseRoot, environment = process.
     });
   }
   const sourceHome = environment.CODEX_HOME ?? join4(homedir(), ".codex");
-  const credential = await projectPrivateCodexSubscriptionCredential(join4(sourceHome, "auth.json"));
+  let credential;
+  try {
+    credential = await projectPrivateCodexSubscriptionCredential(join4(sourceHome, "auth.json"));
+  } catch {
+    throw new PrivateCodexLoginUnavailableError("Codex file-backed login is unavailable");
+  }
   return await createPrivateCodexSubscriptionAgentProvider({
     ...support,
     credential,
@@ -15031,12 +15154,51 @@ function codexEnvironment(subscription, model) {
     SSL_CERT_FILE: SANDBOX_CERTIFICATES_PATH2
   });
 }
-async function nativeBubblewrapFor(executablePath) {
-  const path = await exactFile2(join4(executablePath, "..", "..", "codex-resources", "bwrap"), "Codex native Bubblewrap");
-  if (((await lstat4(path)).mode & 73) === 0) {
-    throw new Error("Codex native Bubblewrap is invalid");
+async function resolveCodexExecutable(selected) {
+  if (selected !== undefined && (!selected.startsWith("/") || selected.includes("\x00"))) {
+    throw new PrivateCodexExecutableUnavailableError("CODEX_PATH must be an absolute executable path");
+  }
+  try {
+    const path = await resolvePrivateLinuxHostPath(selected === undefined ? privateLinuxHostToolCandidates("codex") : [selected]);
+    const information = await lstat4(path);
+    if (!information.isFile() || information.isSymbolicLink() || (information.mode & 73) === 0) {
+      throw new PrivateCodexExecutableUnavailableError("the native Codex executable is invalid");
+    }
+    return path;
+  } catch (error) {
+    if (error instanceof PrivateCodexExecutableUnavailableError)
+      throw error;
+    throw new PrivateCodexExecutableUnavailableError("the native Codex executable is unavailable");
+  }
+}
+async function nativeBubblewrapFor(executablePath, selected) {
+  if (selected !== undefined && (!selected.startsWith("/") || selected.includes("\x00"))) {
+    throw new PrivateCodexSandboxUnavailableError("JIG_BWRAP_PATH must be an absolute executable path");
+  }
+  try {
+    let path;
+    if (selected !== undefined) {
+      path = await resolvePrivateLinuxHostPath([selected]);
+    } else {
+      const adjacent = join4(executablePath, "..", "..", "codex-resources", "bwrap");
+      try {
+        path = await exactFile2(adjacent, "Codex native Bubblewrap");
+      } catch (error) {
+        if (error.code !== "ENOENT")
+          throw error;
+        path = await resolvePrivateLinuxHostPath(privateLinuxHostToolCandidates("bwrap"));
+      }
+    }
+    const information = await lstat4(path);
+    if (!information.isFile() || information.isSymbolicLink() || (information.mode & 3072) !== 0 || (information.mode & 73) === 0) {
+      throw new PrivateCodexSandboxUnavailableError("Codex native Bubblewrap is invalid");
+    }
+    return path;
+  } catch (error) {
+    if (error instanceof PrivateCodexSandboxUnavailableError)
+      throw error;
+    throw new PrivateCodexSandboxUnavailableError("Codex native Bubblewrap is unavailable");
   }
-  return path;
 }
 async function ordinaryFile2(path, label) {
   const exact = await realpath6(path);
@@ -15143,7 +15305,7 @@ function requireBaseURL2(value) {
 // src/internal/installed-bun-support.ts
 import { constants as constants4 } from "fs";
 import { access as access3, lstat as lstat5, realpath as realpath7 } from "fs/promises";
-import { dirname as dirname6, join as join5 } from "path";
+import { dirname as dirname5, join as join5 } from "path";
 var ELF_INTERPRETER = "/lib64/ld-linux-x86-64.so.2";
 var LIBRARIES = Object.freeze([
   "libc.so.6",
@@ -15193,7 +15355,7 @@ async function openPrivateInstalledBunSupport(location) {
   const preparationWorkerPath = await exactRegularFile(join5(releaseRoot, "libexec", "preparation", "bun-native-preparation-worker.js"), false, "installed Bun preparation worker");
   const agentWorkerPath = await exactRegularFile(join5(releaseRoot, "libexec", "agent", "openai-agent-worker.js"), false, "installed Agent provider worker");
   const loaderPath = await exactRegularFile(await resolvePrivateLinuxHostLoader(), true, "supported-host ELF interpreter");
-  const hostLibraryDirectory = dirname6(loaderPath);
+  const hostLibraryDirectory = dirname5(loaderPath);
   const libraries = await Promise.all(LIBRARIES.map(async (name) => Object.freeze({
     name,
     path: await exactRegularFile(join5(hostLibraryDirectory, name), false, `supported-host library ${name}`)
@@ -15588,7 +15750,7 @@ function requireApi(value) {
 import { constants as constants5 } from "fs";
 import { access as access4, lstat as lstat6, readFile as readFile4, realpath as realpath8 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname7, join as join6, resolve as resolve5 } from "path";
+import { dirname as dirname6, join as join6, resolve as resolve5 } from "path";
 var PI_CLIENT = "pi";
 var SANDBOX_LAUNCHER_PATH3 = "/agent/pi-agent-launcher.js";
 var SANDBOX_ADAPTER_PATH3 = "/agent/pi-acp.js";
@@ -15613,7 +15775,7 @@ async function openPrivatePiAgentProvider(releaseRoot, environment = process.env
     throw new Error("the native Pi executable is unavailable");
   }
   const executablePath = await executableFile(executable, "native Pi executable");
-  const nativeRoot = dirname7(executablePath);
+  const nativeRoot = dirname6(executablePath);
   const manifestPath = await piManifestFile(join6(nativeRoot, "package.json"));
   const support = Object.freeze({
     launcherPath: join6(releaseRoot, "libexec", "agent", "pi-agent-launcher.js"),
@@ -15926,6 +16088,7 @@ async function readCredentialFile(path) {
 
 // src/internal/installed-bun-host.ts
 var AGENT_CLIENT = "JIG_AGENT_CLIENT";
+var OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
 async function openPrivateInstalledBunHost(location, environment = process.env) {
   const installedBunSupport = await openPrivateInstalledBunSupport(location);
   const agent = await tryOpenAgentProvider(installedBunSupport, environment);
@@ -15946,21 +16109,39 @@ async function tryOpenAgentProvider(installedBunSupport, environment) {
     return {
       agentUnavailableHint: "JIG_AGENT_CLIENT must be codex, claude, or pi; unset it to use the configured API endpoint"
     };
+  let selectedEnvironment = environment;
+  let openRouter = false;
   if (client === undefined) {
-    const missing = ["OPENAI_API_KEY", "OPENAI_MODEL"].filter((key) => environment[key] === undefined);
+    const hasOpenRouter = ["OPENROUTER_API_KEY", "OPENROUTER_MODEL"].some((key) => environment[key] !== undefined);
+    const hasOpenAI = ["OPENAI_API_KEY", "OPENAI_MODEL", "OPENAI_BASE_URL", "OPENAI_API"].some((key) => environment[key] !== undefined);
+    if (hasOpenRouter && hasOpenAI)
+      return {
+        agentUnavailableHint: "choose either OPENROUTER_API_KEY and OPENROUTER_MODEL, or the OPENAI_* endpoint variables; unset the other family before jig review"
+      };
+    openRouter = hasOpenRouter;
+    const required = openRouter ? ["OPENROUTER_API_KEY", "OPENROUTER_MODEL"] : ["OPENAI_API_KEY", "OPENAI_MODEL"];
+    const missing = required.filter((key) => environment[key] === undefined);
     if (missing.length > 0)
       return {
-        agentUnavailableHint: `export ${missing.join(" and ")} before jig review; Jig reads operator configuration, not project .env files`
+        agentUnavailableHint: !hasOpenRouter && !hasOpenAI ? "export OPENROUTER_API_KEY and OPENROUTER_MODEL, or OPENAI_API_KEY and OPENAI_MODEL, before jig review; Jig reads operator configuration, not project .env files" : `export ${missing.join(" and ")} before jig review; Jig reads operator configuration, not project .env files`
       };
+    if (openRouter)
+      selectedEnvironment = Object.freeze({
+        ...environment,
+        OPENAI_API_KEY: environment.OPENROUTER_API_KEY,
+        OPENAI_MODEL: environment.OPENROUTER_MODEL,
+        OPENAI_BASE_URL: OPENROUTER_BASE_URL,
+        OPENAI_API: "chat-completions"
+      });
   }
   try {
-    const agentProvider = client === undefined ? openPrivateOpenAIAgentProvider(installedBunSupport, environment) : client === "codex" ? await openPrivateCodexAgentProvider(installedBunSupport.releaseRoot, environment) : client === "claude" ? await openPrivateClaudeAgentProvider(installedBunSupport.releaseRoot, environment) : client === "pi" ? await openPrivatePiAgentProvider(installedBunSupport.releaseRoot, environment) : (() => {
+    const agentProvider = client === undefined ? openPrivateOpenAIAgentProvider(installedBunSupport, selectedEnvironment) : client === "codex" ? await openPrivateCodexAgentProvider(installedBunSupport.releaseRoot, selectedEnvironment) : client === "claude" ? await openPrivateClaudeAgentProvider(installedBunSupport.releaseRoot, environment) : client === "pi" ? await openPrivatePiAgentProvider(installedBunSupport.releaseRoot, environment) : (() => {
       throw new Error("the native Agent client is unsupported");
     })();
     return { agentProvider };
   } catch (error) {
     return {
-      agentUnavailableHint: error instanceof PrivateAgentConfigurationError ? `correct the exported ${error.field} value before jig review` : client === undefined ? "the API Agent could not be opened; check the installed support assets and exported configuration" : `the selected ${client} client could not be opened; check its executable and exported host configuration`
+      agentUnavailableHint: error instanceof PrivateCodexExecutableUnavailableError ? "export CODEX_PATH with the absolute path of this operator's installed codex executable, then retry jig review" : error instanceof PrivateCodexSandboxUnavailableError ? "install Bubblewrap in a fixed system location or export its absolute JIG_BWRAP_PATH, then retry jig review" : error instanceof PrivateCodexLoginUnavailableError ? 'configure Codex with cli_auth_credentials_store="file", run codex login as this OS user, and retry jig review; Jig reads CODEX_HOME/auth.json or ~/.codex/auth.json' : error instanceof PrivateAgentConfigurationError ? `correct the exported ${openRouter ? error.field === "OPENAI_API_KEY" ? "OPENROUTER_API_KEY" : error.field === "OPENAI_MODEL" ? "OPENROUTER_MODEL" : error.field : error.field} value before jig review` : client === undefined ? "the API Agent could not be opened; check the installed support assets and exported configuration" : `the selected ${client} client could not be opened; check its executable and exported host configuration`
     };
   }
 }
@@ -17688,6 +17869,78 @@ async function validateUtf8File(captured, logicalPath) {
   }
 }
 
+// src/internal/private-project-command.ts
+import { createHash as createHash5 } from "crypto";
+var PROJECT_COMMAND_CONTRACT_ID = "https://jig.md/contracts/project-command";
+var PROJECT_COMMAND_CONTRACT_VERSION = "1.0.0";
+var PROJECT_COMMAND_CONTRACT_DIGEST = "sha256:aed62fe17f01897545f82d7ee91f163a023721431433c8f4f6981b4367c85bcf";
+var PROJECT_COMMAND_LIMITS = Object.freeze({
+  files: 64,
+  bytes: 262144,
+  streamBytes: 65536,
+  stdinBytes: 16384,
+  args: 32,
+  argumentBytes: 1024,
+  timeoutMs: 1e4
+});
+function isProjectCommandContract(value) {
+  return value.id === PROJECT_COMMAND_CONTRACT_ID && value.version === PROJECT_COMMAND_CONTRACT_VERSION && value.digest === PROJECT_COMMAND_CONTRACT_DIGEST;
+}
+function assertProjectCommandContract(contract) {
+  const parsed = parseCapabilityContract(canonicalJson(contract.descriptor));
+  if (!isProjectCommandContract({ ...parsed.descriptor, digest: parsed.digest }) || parsed.digest !== contract.digest)
+    throw new TypeError("expected the exact supported Project Command contract");
+}
+function parseProjectCommandInput(value, commands) {
+  const input = snapshotPrivateOrdinaryJson(value, "project command input", (message) => new TypeError(message));
+  if (!input || typeof input !== "object" || Array.isArray(input) || Object.keys(input).some((key) => !["command", "files", "args", "stdin"].includes(key)) || typeof input.command !== "string" || !Object.hasOwn(commands, input.command))
+    throw new TypeError("select a command from the admitted Binding commands");
+  if (!input.files || typeof input.files !== "object" || Array.isArray(input.files))
+    throw new TypeError("command files must be an object of UTF-8 source text");
+  const paths = Object.keys(input.files).sort();
+  if (paths.length === 0 || paths.length > PROJECT_COMMAND_LIMITS.files)
+    throw new TypeError("command requires one to 64 candidate files");
+  let bytes = 0;
+  for (const path of paths) {
+    projectCommandPath(path);
+    if (path.split("/").some((part) => ["node_modules", ".git", ".jig"].includes(part)))
+      throw new TypeError("candidate contains a reserved project directory");
+    if (paths.some((other) => path !== other && path.startsWith(`${other}/`)))
+      throw new TypeError("candidate has a file/directory collision");
+    const text = input.files[path];
+    if (typeof text !== "string")
+      throw new TypeError("candidate files must be UTF-8 text");
+    bytes += Buffer.byteLength(text);
+  }
+  if (bytes > PROJECT_COMMAND_LIMITS.bytes)
+    throw new TypeError("candidate exceeds 256 KiB");
+  const args = input.args === undefined ? [] : input.args;
+  if (!Array.isArray(args) || args.length > PROJECT_COMMAND_LIMITS.args || args.some((arg) => typeof arg !== "string" || arg.includes("\x00") || Buffer.byteLength(arg) > PROJECT_COMMAND_LIMITS.argumentBytes))
+    throw new TypeError("command arguments exceed their bounded string profile");
+  const stdin = input.stdin === undefined ? "" : input.stdin;
+  if (typeof stdin !== "string" || Buffer.byteLength(stdin) > PROJECT_COMMAND_LIMITS.stdinBytes)
+    throw new TypeError("command stdin exceeds 16 KiB");
+  const command = commands[input.command];
+  const selected = "run" in command ? [command.run] : command.test;
+  if (selected.some((path) => !Object.hasOwn(input.files, path)))
+    throw new TypeError("candidate omits a reviewed command file");
+  if ("test" in command && args.length !== 0)
+    throw new TypeError("test commands do not accept variable arguments");
+  const invocation = Object.freeze("run" in command ? ["bun", command.run, ...args] : ["bun", "test", ...command.test]);
+  return Object.freeze({
+    input,
+    invocation,
+    candidateDigest: projectCommandCandidateDigest(input.files),
+    stdinDigest: digest(Buffer.from(stdin))
+  });
+}
+function projectCommandCandidateDigest(files) {
+  return digest(canonicalJson(files));
+}
+function digest(bytes) {
+  return `sha256:${createHash5("sha256").update(bytes).digest("hex")}`;
+}
+
 // src/project/flow-source.ts
 import { constants as constants9 } from "fs";
 import { lstat as lstat9, open as open5, opendir as opendir2 } from "fs/promises";
@@ -18331,7 +18584,7 @@ function directoryEntryName2(entry) {
 }
 
 // src/internal/package-artifact-store.ts
-import { createHash as createHash5, randomUUID } from "crypto";
+import { createHash as createHash6, randomUUID } from "crypto";
 import { constants as constants10 } from "fs";
 import { link as link2, lstat as lstat10, mkdir as mkdir5, open as open6, opendir as opendir3, unlink as unlink3 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
@@ -18366,26 +18619,26 @@ async function publishCapturedPackage(storeRoot, captured) {
   }
 }
 async function publishCapturedPackageExclusive(storeRoot, captured) {
-  const digest = parsePackageDigest(captured.digest);
+  const digest2 = parsePackageDigest(captured.digest);
   const artifactBytes = privatePackageArtifactArchiveBytes(captured.files);
   if (artifactBytes > PRIVATE_PACKAGE_ARTIFACT_STORE_LIMITS.artifactBytes) {
     unavailable("PACKAGE_ARTIFACT_LIMIT", `Package/1 artifact exceeds the fixed ${PRIVATE_PACKAGE_ARTIFACT_STORE_LIMITS.artifactBytes}-byte alpha limit`);
   }
-  const location = await openArtifactShard(storeRoot, digest, true);
+  const location = await openArtifactShard(storeRoot, digest2, true);
   const stage = `${location.directoryPath}/.stage-${process.pid}-${randomUUID()}`;
   let stageHandle;
   let stageExists = false;
   let result2;
   let failure;
   try {
-    const existing = await tryCapturePackageArtifactFile(location.finalPath, digest, `stored Package/1 ${digest}`, location.ownerUid);
+    const existing = await tryCapturePackageArtifactFile(location.finalPath, digest2, `stored Package/1 ${digest2}`, location.ownerUid);
     if (existing !== undefined) {
       await existing.dispose();
       const observedDigest2 = await digestCapturedPackage(captured);
-      if (observedDigest2 !== digest) {
-        invalid("PACKAGE_ARTIFACT_SOURCE_MISMATCH", `captured Package/1 bytes produced ${observedDigest2}, not ${digest}`);
+      if (observedDigest2 !== digest2) {
+        invalid("PACKAGE_ARTIFACT_SOURCE_MISMATCH", `captured Package/1 bytes produced ${observedDigest2}, not ${digest2}`);
       }
-      return packageArtifactRef(digest);
+      return packageArtifactRef(digest2);
     }
     const retainedBytes = await retainedStoreBytes(storeRoot, location.ownerUid);
     if (retainedBytes + artifactBytes > PRIVATE_PACKAGE_ARTIFACT_STORE_LIMITS.storeBytes) {
@@ -18394,15 +18647,15 @@ async function publishCapturedPackageExclusive(storeRoot, captured) {
     stageHandle = await open6(stage, constants10.O_WRONLY | constants10.O_CREAT | constants10.O_EXCL | constants10.O_NOFOLLOW, 384);
     stageExists = true;
     const observedDigest = await writeCapturedArchive(stageHandle, captured);
-    if (observedDigest !== digest) {
-      invalid("PACKAGE_ARTIFACT_SOURCE_MISMATCH", `captured Package/1 bytes produced ${observedDigest}, not ${digest}`);
+    if (observedDigest !== digest2) {
+      invalid("PACKAGE_ARTIFACT_SOURCE_MISMATCH", `captured Package/1 bytes produced ${observedDigest}, not ${digest2}`);
     }
     await stageHandle.sync();
     await stageHandle.chmod(256);
     await stageHandle.sync();
     await stageHandle.close();
     stageHandle = undefined;
-    const staged = await capturePackageArtifactFile(stage, digest, "staged Package/1 artifact", location.ownerUid);
+    const staged = await capturePackageArtifactFile(stage, digest2, "staged Package/1 artifact", location.ownerUid);
     await staged.dispose();
     try {
       await link2(stage, location.finalPath);
@@ -18416,9 +18669,9 @@ async function publishCapturedPackageExclusive(storeRoot, captured) {
       await unlink3(stage);
       stageExists = false;
       await location.directory.sync();
-      const existing2 = await capturePackageArtifactFile(location.finalPath, digest, `stored Package/1 ${digest}`, location.ownerUid);
+      const existing2 = await capturePackageArtifactFile(location.finalPath, digest2, `stored Package/1 ${digest2}`, location.ownerUid);
       await existing2.dispose();
-      result2 = packageArtifactRef(digest);
+      result2 = packageArtifactRef(digest2);
       return result2;
     }
     await requireSameFile(stage, location.finalPath);
@@ -18426,7 +18679,7 @@ async function publishCapturedPackageExclusive(storeRoot, captured) {
     await unlink3(stage);
     stageExists = false;
     await location.directory.sync();
-    result2 = packageArtifactRef(digest);
+    result2 = packageArtifactRef(digest2);
     return result2;
   } catch (error) {
     failure = isResourceError2(error) ? new CheckError("unavailable", "PACKAGE_ARTIFACT_RESOURCE_EXHAUSTED", `cannot publish Package/1 artifact: ${errorText4(error)}`) : error;
@@ -18480,15 +18733,15 @@ function privatePackageArtifactArchiveBytes(files) {
   return bytes;
 }
 async function captureStoredPackage(storeRoot, reference) {
-  const digest = parsePackageArtifactRef(reference);
+  const digest2 = parsePackageArtifactRef(reference);
   let location;
   let captured;
   try {
-    location = await openArtifactShard(storeRoot, digest, false);
-    captured = await capturePackageArtifactFile(location.finalPath, digest, `stored Package/1 ${digest}`, location.ownerUid);
+    location = await openArtifactShard(storeRoot, digest2, false);
+    captured = await capturePackageArtifactFile(location.finalPath, digest2, `stored Package/1 ${digest2}`, location.ownerUid);
   } catch (error) {
     if (hasCode2(error, "ENOENT")) {
-      unavailable("PACKAGE_ARTIFACT_MISSING", `stored Package/1 ${digest} is missing`);
+      unavailable("PACKAGE_ARTIFACT_MISSING", `stored Package/1 ${digest2} is missing`);
     }
     if (isResourceError2(error)) {
       unavailable("PACKAGE_ARTIFACT_RESOURCE_EXHAUSTED", `cannot acquire Package/1 artifact: ${errorText4(error)}`);
@@ -18506,8 +18759,8 @@ async function captureStoredPackage(storeRoot, reference) {
   }
   return captured;
 }
-function packageArtifactRef(digest) {
-  return Object.freeze({ kind: ARTIFACT_KIND, digest });
+function packageArtifactRef(digest2) {
+  return Object.freeze({ kind: ARTIFACT_KIND, digest: digest2 });
 }
 function normalizePackageArtifactRef(reference) {
   return packageArtifactRef(parsePackageArtifactRef(reference));
@@ -18525,11 +18778,11 @@ function parsePackageArtifactRef(reference) {
     invalid("PACKAGE_ARTIFACT_REF", `Package/1 artifact reference must contain only kind=${ARTIFACT_KIND} and digest`);
   }
   const kind = Object.getOwnPropertyDescriptor(reference, "kind");
-  const digest = Object.getOwnPropertyDescriptor(reference, "digest");
-  if (kind === undefined || !("value" in kind) || !kind.enumerable || kind.value !== ARTIFACT_KIND || digest === undefined || !("value" in digest) || !digest.enumerable) {
+  const digest2 = Object.getOwnPropertyDescriptor(reference, "digest");
+  if (kind === undefined || !("value" in kind) || !kind.enumerable || kind.value !== ARTIFACT_KIND || digest2 === undefined || !("value" in digest2) || !digest2.enumerable) {
     invalid("PACKAGE_ARTIFACT_REF", `Package/1 artifact reference must contain enumerable data fields kind=${ARTIFACT_KIND} and digest`);
   }
-  return parsePackageDigest(digest.value);
+  return parsePackageDigest(digest2.value);
 }
 function parsePackageDigest(value) {
   if (typeof value !== "string" || !DIGEST_PATTERN.test(value)) {
@@ -18537,8 +18790,8 @@ function parsePackageDigest(value) {
   }
   return value;
 }
-async function openArtifactShard(storeRoot, digest, create) {
-  const hexadecimal = DIGEST_PATTERN.exec(digest)[1];
+async function openArtifactShard(storeRoot, digest2, create) {
+  const hexadecimal = DIGEST_PATTERN.exec(digest2)[1];
   let parent = await openStoreRoot(storeRoot);
   try {
     for (const segment of ["packages", "v1", "sha256", hexadecimal.slice(0, 2)]) {
@@ -18709,7 +18962,7 @@ async function capturePackageArtifactFile(path, expectedDigest, sourceLabel, exp
   }
 }
 async function parsePackageArchive(handle, information, expectedDigest, snapshot2) {
-  const hash = createHash5("sha256");
+  const hash = createHash6("sha256");
   let position = 0;
   async function readHashed(length, description) {
     const bytes = await readExact(handle, position, length, description);
@@ -18859,7 +19112,7 @@ async function readExact(handle, offset, length, description) {
   return result2;
 }
 async function writeCapturedArchive(destination, captured) {
-  const hash = createHash5("sha256");
+  const hash = createHash6("sha256");
   const iterator = encodePackage1(captured.files, (file) => captured.stream(file.path))[Symbol.asyncIterator]();
   let finished = false;
   let failure;
@@ -19073,28 +19326,36 @@ function projectSupportedCapabilityUses(inspected, packagePath) {
   const declarations = Object.entries(inspected.metadata.uses ?? {});
   if (declarations.length === 0)
     return Object.freeze(Object.create(null));
-  if (declarations.length !== 1) {
-    invalid("PROJECT_FLOW_CAPABILITY_UNSUPPORTED", "the direct alpha supports at most one Agent Run capability slot per package", packagePath);
+  if (declarations.length > 2) {
+    invalid("PROJECT_FLOW_CAPABILITY_UNSUPPORTED", "Jig supports one Agent Run and one Project Command capability slot per package", packagePath);
   }
-  const [slot, declaration] = declarations[0];
-  if (declaration.contract === undefined) {
-    invalid("PROJECT_FLOW_CAPABILITY_UNSUPPORTED", "the direct alpha supports only the exact Agent Run capability contract", packagePath, `/uses/${pointerToken(slot)}`);
-  }
-  const reference = inspected.usedContracts.find((candidate) => candidate.slot === slot);
-  if (reference === undefined)
-    throw new Error("inspected capability reference invariant violated");
-  try {
-    assertAgentRunContract(reference.contract);
-  } catch (error) {
-    invalid("PROJECT_FLOW_CAPABILITY_UNSUPPORTED", errorText5(error), packagePath, `/uses/${pointerToken(slot)}`);
+  const output = Object.create(null);
+  const used = new Set;
+  for (const [slot, declaration] of declarations) {
+    if (declaration.contract === undefined) {
+      invalid("PROJECT_FLOW_CAPABILITY_UNSUPPORTED", "Jig supports only the exact Agent Run and Project Command contracts", packagePath, `/uses/${pointerToken(slot)}`);
+    }
+    const reference = inspected.usedContracts.find((candidate) => candidate.slot === slot);
+    if (reference === undefined)
+      throw new Error("inspected capability reference invariant violated");
+    try {
+      if (reference.contract.digest === PROJECT_COMMAND_CONTRACT_DIGEST)
+        assertProjectCommandContract(reference.contract);
+      else
+        assertAgentRunContract(reference.contract);
+      if (used.has(reference.contract.digest))
+        throw new TypeError("a supported capability may be declared only once");
+      used.add(reference.contract.digest);
+    } catch (error) {
+      invalid("PROJECT_FLOW_CAPABILITY_UNSUPPORTED", errorText5(error), packagePath, `/uses/${pointerToken(slot)}`);
+    }
+    output[slot] = Object.freeze({
+      id: reference.contract.descriptor.id,
+      version: reference.contract.descriptor.version,
+      digest: reference.contract.digest
+    });
   }
-  return Object.freeze({
-    [slot]: Object.freeze({
-      id: AGENT_RUN_CONTRACT_ID,
-      version: AGENT_RUN_CONTRACT_VERSION,
-      digest: AGENT_RUN_CONTRACT_DIGEST
-    })
-  });
+  return Object.freeze(output);
 }
 function prepareBindings(values, flowByPath, budget) {
   const bindings = values.map((value, index) => {
@@ -19127,6 +19388,8 @@ function prepareBindings(values, flowByPath, budget) {
       invalid("PROJECT_BINDING_ENTRYPOINT_REQUIRED", `Binding ${id} selects an instruction-only package without a supported code entrypoint`, declarationPath, "/package");
     }
     validateSettings(definition.settings, flow.inspected, declarationPath);
+    if (definition.commands !== undefined && !Object.values(flow.value.uses).some(({ digest: digest2 }) => digest2 === PROJECT_COMMAND_CONTRACT_DIGEST))
+      invalid("PROJECT_BINDING_COMMANDS_UNDECLARED", "commands require a Project Command capability declaration", declarationPath, "/commands");
     return Object.freeze({ id, declarationPath, definition, flow });
   });
   bindings.sort((left, right) => compareProjectPaths(left.id, right.id));
@@ -19141,7 +19404,8 @@ function linkBinding(prepared, flowByPath, bindingById) {
     declarationPath,
     packagePath: definition.package,
     settings: definition.settings,
-    slots: linkFlowSlots(prepared, flowByPath, bindingById)
+    slots: linkFlowSlots(prepared, flowByPath, bindingById),
+    ...definition.commands === undefined ? {} : { commands: definition.commands }
   });
 }
 function linkFlowSlots(binding, flowByPath, bindingById) {
@@ -19521,15 +19785,15 @@ function requirePlainRecord(value, label) {
 }
 
 // src/project/author-evaluator.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import { readFile as readFile6 } from "fs/promises";
 import { join as join7 } from "path";
 
 // src/project/author-module.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import { constants as constants11 } from "fs";
 import { lstat as lstat11, open as open7 } from "fs/promises";
-import { dirname as dirname8, join as joinPath, normalize as normalizePath } from "path/posix";
+import { dirname as dirname7, join as joinPath, normalize as normalizePath } from "path/posix";
 var MAX_SOURCE_BYTES = 1024 * 1024;
 var MAX_CLOSURE_SOURCE_BYTES = 1024 * 1024;
 var MAX_CLOSURE_MODULES = 256;
@@ -19623,7 +19887,7 @@ function createClosure(entries, modulePaths, captured, imports, sourceBytes) {
     return Object.freeze({
       projectPath,
       sourceBytes: bytes.byteLength,
-      sourceDigest: digest(bytes),
+      sourceDigest: digest2(bytes),
       imports: Object.freeze([...imports.get(projectPath) ?? []])
     });
   });
@@ -19644,7 +19908,7 @@ function createClosure(entries, modulePaths, captured, imports, sourceBytes) {
     entries: Object.freeze([...entries]),
     modules: Object.freeze(modules),
     sourceBytes,
-    closureDigest: digest(canonicalJson(identity2)),
+    closureDigest: digest2(canonicalJson(identity2)),
     read(projectPath) {
       if (disposed)
         unavailable("PROJECT_CAPTURE_CLOSED", "author closure has been disposed", projectPath);
@@ -19695,7 +19959,7 @@ function resolveAuthorImport(importer, specifier) {
   if (!(specifier.startsWith("./") || specifier.startsWith("../")) || specifier.includes("\\") || specifier.includes("\x00") || !specifier.endsWith(".ts") || specifier.endsWith(".d.ts")) {
     invalid("PROJECT_EVALUATOR_IMPORT", `project-local imports must use an explicit relative .ts path: ${specifier}`, importer);
   }
-  const target = normalizePath(joinPath(dirname8(importer), specifier));
+  const target = normalizePath(joinPath(dirname7(importer), specifier));
   try {
     validateProjectPath(target, "author import target");
     if (isProtectedProjectPath(target)) {
@@ -19732,8 +19996,8 @@ function compareUtf82(left, right) {
   }
   return leftBytes.byteLength - rightBytes.byteLength;
 }
-function digest(bytes) {
-  return `sha256:${createHash6("sha256").update(bytes).digest("hex")}`;
+function digest2(bytes) {
+  return `sha256:${createHash7("sha256").update(bytes).digest("hex")}`;
 }
 async function captureFile(project, projectPath) {
   const opened = await openProjectFile(project, projectPath, false);
@@ -20208,7 +20472,7 @@ async function collectBounded(stream, maximum, terminate) {
   return output;
 }
 function digestBytes(bytes) {
-  return `sha256:${createHash7("sha256").update(bytes).digest("hex")}`;
+  return `sha256:${createHash8("sha256").update(bytes).digest("hex")}`;
 }
 function frozenNumbers(value) {
   return Object.freeze(Object.fromEntries(Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)));
@@ -20662,8 +20926,8 @@ async function retainAuthorClosure(storeRoot, closure) {
   };
   let captured;
   try {
-    const digest2 = await packageDigest(files, (file) => backing.stream(file.path));
-    captured = createCapturedPackage("captured author closure", files, digest2, backing);
+    const digest3 = await packageDigest(files, (file) => backing.stream(file.path));
+    captured = createCapturedPackage("captured author closure", files, digest3, backing);
     const reference = await publishCapturedPackage(storeRoot, captured);
     return Object.freeze({
       kind: "author-closure/1",
@@ -20854,6 +21118,7 @@ function buildPrivateActivationRequests(project) {
       settings: binding.settings,
       capabilities: flow.uses,
       flowSlots: binding.slots,
+      ...binding.commands === undefined ? {} : { commands: binding.commands },
       attachments: normalizeRequestAttachments(flow.metadata.attachments ?? {})
     }));
   }
@@ -20881,7 +21146,8 @@ function restorePrivateActivationRequest(value) {
     "settings",
     "capabilities",
     "flowSlots",
-    "attachments"
+    "attachments",
+    ...value !== null && typeof value === "object" && Object.hasOwn(value, "commands") ? ["commands"] : []
   ], "activation request");
   if (root.kind !== "activation-request/4") {
     throw new TypeError("activation request kind must be activation-request/4");
@@ -20924,7 +21190,10 @@ function restorePrivateActivationRequest(value) {
     settings: snapshotJsonObject2(root.settings, "activation settings"),
     capabilities: normalizeRequestCapabilities(root.capabilities),
     flowSlots: normalizeRequestFlowSlots(root.flowSlots),
-    attachments: normalizeRequestAttachments(root.attachments)
+    attachments: normalizeRequestAttachments(root.attachments),
+    ...root.commands === undefined ? {} : {
+      commands: normalizeProjectCommands(snapshotJsonObject2(root.commands, "activation commands"))
+    }
   });
   if (root.digest !== request.digest) {
     throw new TypeError("activation request digest does not match its canonical content");
@@ -21000,7 +21269,8 @@ function createRequest(input) {
     settings: input.settings,
     capabilities: input.capabilities,
     flowSlots: input.flowSlots,
-    attachments: input.attachments
+    attachments: input.attachments,
+    ...input.commands === undefined ? {} : { commands: input.commands }
   });
   const request = Object.freeze({
     ...valueWithoutDigest,
@@ -21034,7 +21304,8 @@ function semanticProject(project) {
       id: binding.id,
       packagePath: binding.packagePath,
       settings: binding.settings,
-      slots: binding.slots
+      slots: binding.slots,
+      ...binding.commands === undefined ? {} : { commands: binding.commands }
     }))
   };
 }
@@ -21117,22 +21388,24 @@ function normalizeRequestAttachments(value) {
 }
 function normalizeRequestCapabilities(value) {
   const input = snapshotJsonObject2(value, "activation capability uses");
-  if (Object.keys(input).length > 1) {
-    throw new TypeError("activation capability uses exceed 1 entry");
+  if (Object.keys(input).length > 2) {
+    throw new TypeError("activation capability uses exceed 2 entries");
   }
   const output = Object.create(null);
   for (const name of Object.keys(input).sort()) {
     requireLocalName3(name, "activation capability slot");
     const item = exactObject(input[name], ["id", "version", "digest"], `activation capability slot ${name}`);
-    if (item.id !== AGENT_RUN_CONTRACT_ID || item.version !== AGENT_RUN_CONTRACT_VERSION || item.digest !== AGENT_RUN_CONTRACT_DIGEST) {
-      throw new TypeError(`activation capability slot ${name} must select the exact Agent Run contract`);
+    if (!isProjectCommandContract(item) && (item.id !== AGENT_RUN_CONTRACT_ID || item.version !== AGENT_RUN_CONTRACT_VERSION || item.digest !== AGENT_RUN_CONTRACT_DIGEST)) {
+      throw new TypeError(`activation capability slot ${name} must select an exact supported contract`);
     }
     output[name] = Object.freeze({
-      id: AGENT_RUN_CONTRACT_ID,
-      version: AGENT_RUN_CONTRACT_VERSION,
-      digest: AGENT_RUN_CONTRACT_DIGEST
+      id: item.id,
+      version: item.version,
+      digest: item.digest
     });
   }
+  if (new Set(Object.values(output).map(({ digest: digest3 }) => digest3)).size !== Object.keys(output).length)
+    throw new TypeError("activation capability contracts must be distinct");
   return Object.freeze(output);
 }
 function normalizeRequestFlowSlots(value) {
@@ -21229,6 +21502,49 @@ function freezeJson(value) {
   return value;
 }
 
+// src/internal/root-operation-limits.ts
+var PRIVATE_FLOW_RESOURCE_CEILINGS = Object.freeze({
+  memoryBytes: 256 * 1024 * 1024,
+  pids: 64,
+  cpuQuotaMicros: 50000,
+  cpuPeriodMicros: 1e5,
+  cleanupTimeoutMs: 5000
+});
+var PRIVATE_AGENT_PROVIDER_PIDS = 128;
+var PRIVATE_ROOT_RESOURCE_POLICY = Object.freeze({
+  siblingFlows: 2,
+  leafEffects: 1,
+  memoryBytes: 1280 * 1024 * 1024,
+  pids: 448,
+  cpuQuotaMicros: 250000,
+  cpuPeriodMicros: 1e5,
+  reservation: "whole-branch-until-cleanup"
+});
+function isPrivateChildFlowAllocation(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && value.kind === "private-root-child-owner-allocation/1";
+}
+function privateRootBranchReservation(branches) {
+  if (!Number.isSafeInteger(branches) || branches < 0)
+    throw new TypeError("Invalid branch count.");
+  const flow = PRIVATE_FLOW_RESOURCE_CEILINGS;
+  return Object.freeze({
+    memoryBytes: flow.memoryBytes * (1 + branches * 2),
+    pids: flow.pids + branches * (flow.pids + PRIVATE_AGENT_PROVIDER_PIDS),
+    cpuQuotaMicros: flow.cpuQuotaMicros * (1 + branches * 2),
+    cpuPeriodMicros: flow.cpuPeriodMicros
+  });
+}
+function canReservePrivateRootOperation(current, proposed) {
+  const allocations = [...current, proposed];
+  const allFlows = allocations.every(isPrivateChildFlowAllocation);
+  if (!allFlows && allocations.length !== 1)
+    return false;
+  if (allocations.length > PRIVATE_ROOT_RESOURCE_POLICY.siblingFlows)
+    return false;
+  const reserved = privateRootBranchReservation(allocations.length);
+  return reserved.memoryBytes <= PRIVATE_ROOT_RESOURCE_POLICY.memoryBytes && reserved.pids <= PRIVATE_ROOT_RESOURCE_POLICY.pids && reserved.cpuQuotaMicros / reserved.cpuPeriodMicros <= PRIVATE_ROOT_RESOURCE_POLICY.cpuQuotaMicros / PRIVATE_ROOT_RESOURCE_POLICY.cpuPeriodMicros;
+}
+
 // src/internal/project-local-lock.ts
 var DIGEST6 = /^sha256:[0-9a-f]{64}$/;
 var LOCAL_NAME8 = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
@@ -21248,7 +21564,8 @@ function createPrivateProjectLocalLock(project) {
     bindings[binding.id] = Object.freeze({
       packagePath: binding.packagePath,
       settings: binding.settings,
-      slots: binding.slots
+      slots: binding.slots,
+      ...binding.commands === undefined ? {} : { commands: binding.commands }
     });
   }
   const lock = normalizeLock({ packages, bindings });
@@ -21297,7 +21614,7 @@ function normalizePackages(value) {
       throw new TypeError(`package ${path} directRun must be boolean`);
     }
     output[path] = Object.freeze({
-      digest: digest2(item.digest, `package ${path}`),
+      digest: digest3(item.digest, `package ${path}`),
       directRun: item.directRun,
       uses: normalizeUses(item.uses, `package ${path}`)
     });
@@ -21307,21 +21624,23 @@ function normalizePackages(value) {
 function normalizeUses(value, label) {
   const input = object2(value, `${label} uses`);
   const names = Object.keys(input);
-  if (names.length > 1)
-    throw new TypeError(`${label} uses exceed 1 entry`);
+  if (names.length > 2)
+    throw new TypeError(`${label} uses exceed 2 entries`);
   const output = Object.create(null);
   for (const name of names.sort()) {
     localName(name, `${label} capability slot`);
     const item = exactObject2(input[name], ["id", "version", "digest"], `${label} capability slot ${name}`);
-    if (item.id !== AGENT_RUN_CONTRACT_ID || item.version !== AGENT_RUN_CONTRACT_VERSION || item.digest !== AGENT_RUN_CONTRACT_DIGEST) {
-      throw new TypeError(`${label} capability slot ${name} must select the exact Agent Run contract`);
+    if (!isProjectCommandContract(item) && (item.id !== AGENT_RUN_CONTRACT_ID || item.version !== AGENT_RUN_CONTRACT_VERSION || item.digest !== AGENT_RUN_CONTRACT_DIGEST)) {
+      throw new TypeError(`${label} capability slot ${name} must select an exact supported contract`);
     }
     output[name] = Object.freeze({
-      id: AGENT_RUN_CONTRACT_ID,
-      version: AGENT_RUN_CONTRACT_VERSION,
-      digest: AGENT_RUN_CONTRACT_DIGEST
+      id: item.id,
+      version: item.version,
+      digest: item.digest
     });
   }
+  if (new Set(Object.values(output).map(({ digest: digest3 }) => digest3)).size !== names.length)
+    throw new TypeError("lock capability contracts must be distinct");
   return Object.freeze(output);
 }
 function normalizeBindings(value) {
@@ -21329,13 +21648,19 @@ function normalizeBindings(value) {
   const output = Object.create(null);
   for (const id of Object.keys(input).sort()) {
     localName(id, `Binding ${JSON.stringify(id)}`);
-    const item = exactObject2(input[id], ["packagePath", "settings", "slots"], `Binding ${id}`);
+    const item = exactObject2(input[id], [
+      "packagePath",
+      "settings",
+      "slots",
+      ...Object.hasOwn(object2(input[id], `Binding ${id}`), "commands") ? ["commands"] : []
+    ], `Binding ${id}`);
     const settings = object2(item.settings, `Binding ${id} settings`);
     const slots = normalizeSlots(item.slots, `Binding ${id}`);
     output[id] = Object.freeze({
       packagePath: projectPath(item.packagePath, `Binding ${id} packagePath`),
       settings,
-      slots
+      slots,
+      ...item.commands === undefined ? {} : { commands: normalizeProjectCommands(item.commands) }
     });
   }
   return Object.freeze(output);
@@ -21404,7 +21729,7 @@ function localName(value, label) {
   }
   return value;
 }
-function digest2(value, label) {
+function digest3(value, label) {
   if (typeof value !== "string" || !DIGEST6.test(value)) {
     throw new TypeError(`${label} digest must be sha256: followed by 64 lowercase hexadecimal digits`);
   }
@@ -21465,13 +21790,6 @@ var RUNTIME_PREDICATES = Object.freeze([
   "private-runtime-devices/1"
 ]);
 var authenticRecipes = new WeakSet;
-var RESOURCE_CEILINGS = Object.freeze({
-  memoryBytes: 256 * 1024 * 1024,
-  pids: 64,
-  cpuQuotaMicros: 50000,
-  cpuPeriodMicros: 1e5,
-  cleanupTimeoutMs: 5000
-});
 async function planPrivateBunDirectRun(input) {
   const request = requirePrivateActivationRequest(input.request);
   const installedSupport = requirePrivateInstalledBunSupport(input.installedSupport);
@@ -21487,13 +21805,19 @@ async function planPrivateBunDirectRun(input) {
     }
   }
   const capabilityUses = Object.values(request.capabilities);
-  if (capabilityUses.length > 0 && input.agentProvider === undefined) {
+  const usesAgent = capabilityUses.some(({ digest: digest4 }) => digest4 === AGENT_RUN_CONTRACT_DIGEST);
+  const usesCommand = capabilityUses.some(({ digest: digest4 }) => digest4 === PROJECT_COMMAND_CONTRACT_DIGEST);
+  if (usesAgent && input.agentProvider === undefined) {
     unavailable("PROJECT_AGENT_UNAVAILABLE", "the target requires a configured host Agent", `${request.packagePath}/FLOW.md`);
   }
-  const agentProvider = capabilityUses.length === 0 ? undefined : requirePrivateAgentProvider(input.agentProvider);
-  if (capabilityUses.some(({ digest: digest3 }) => digest3 !== AGENT_RUN_CONTRACT_DIGEST) || capabilityUses.length > 1 || agentProvider !== undefined && agentProvider.contractDigest !== AGENT_RUN_CONTRACT_DIGEST) {
-    throw new TypeError("private Bun recipe requires the exact supported Agent capability");
+  const agentProvider = !usesAgent ? undefined : requirePrivateAgentProvider(input.agentProvider);
+  if (capabilityUses.some(({ digest: digest4 }) => ![AGENT_RUN_CONTRACT_DIGEST, PROJECT_COMMAND_CONTRACT_DIGEST].includes(digest4)) || capabilityUses.length > 2 || agentProvider !== undefined && agentProvider.contractDigest !== AGENT_RUN_CONTRACT_DIGEST) {
+    throw new TypeError("private Bun recipe requires exact supported capabilities");
   }
+  if (usesCommand && Object.keys(request.commands ?? {}).length === 0)
+    unavailable("PROJECT_COMMAND_UNCONFIGURED", "configure commands in a Binding for this Project Command Flow", `${request.packagePath}/FLOW.md`);
+  if (!usesCommand && request.commands !== undefined)
+    throw new TypeError("command policy requires the Project Command capability");
   const adapterDigest = privateDomainDigest("JIG-Private-Bun-Direct-Adapter/1", {
     revision: ADAPTER_REVISION,
     installedSupportDigest: installedSupport.digest
@@ -21513,7 +21837,8 @@ async function planPrivateBunDirectRun(input) {
   });
   const authorityDigest = privateDomainDigest("JIG-Private-Bun-Authority/1", {
     attachments: request.attachments,
-    capabilities: request.capabilities
+    capabilities: request.capabilities,
+    ...request.commands === undefined ? {} : { commands: request.commands }
   });
   const launchEnvelopeDigest = logicalLaunchDigest(request, executionPackage, installedSupport, support, agentProvider);
   const observation = createPrivateActivationRecipeObservation({
@@ -21551,7 +21876,7 @@ async function planPrivateBunDirectRun(input) {
     packageDestination: PACKAGE_DESTINATION,
     scratch: SCRATCH,
     wallClockCeilingMs: PRIVATE_MAX_ROOT_RUN_TIMEOUT_MS,
-    resourceCeilings: RESOURCE_CEILINGS,
+    resourceCeilings: PRIVATE_FLOW_RESOURCE_CEILINGS,
     bunPolicy: BUN_POLICY3,
     privateProcessFilesystem: true,
     privateRuntimeDevices: true,
@@ -21577,8 +21902,9 @@ function logicalLaunchDigest(request, executionPackage, installedSupport, mechan
     backendMechanismDigest: mechanism.digest,
     packageDestination: PACKAGE_DESTINATION,
     scratch: SCRATCH,
-    resourceCeilings: RESOURCE_CEILINGS,
+    resourceCeilings: PRIVATE_FLOW_RESOURCE_CEILINGS,
     wallClockCeilingMs: PRIVATE_MAX_ROOT_RUN_TIMEOUT_MS,
+    rootResourcePolicy: PRIVATE_ROOT_RESOURCE_POLICY,
     environment: Object.freeze({
       LD_LIBRARY_PATH: "/jig-runtime/lib"
     }),
@@ -21591,6 +21917,7 @@ function logicalLaunchDigest(request, executionPackage, installedSupport, mechan
       rootOnly: true
     },
     capabilities: request.capabilities,
+    ...request.commands === undefined ? {} : { commands: request.commands, commandLimits: PROJECT_COMMAND_LIMITS },
     ...agentProvider === undefined ? {} : { agentProviderDigest: agentProvider.digest }
   });
 }
@@ -21970,11 +22297,11 @@ function normalizePlanV2(input, decodedLocks = false) {
   } else if (observedState === "present") {
     const present = exactObject3(observedInput, ["state", "digest", "lock"], "activation plan/2 observed lock");
     const lock = normalizeEmbeddedLock(present.lock, "activation plan/2 observed lock value", decodedLocks);
-    const digest3 = requireDigest3(present.digest, "observed lock");
-    if (digest3 !== privateProjectLocalLockDigest(lock)) {
+    const digest4 = requireDigest3(present.digest, "observed lock");
+    if (digest4 !== privateProjectLocalLockDigest(lock)) {
       throw new TypeError("activation plan/2 observed lock digest does not match its lock");
     }
-    observedLock = Object.freeze({ state: "present", digest: digest3, lock });
+    observedLock = Object.freeze({ state: "present", digest: digest4, lock });
   } else {
     throw new TypeError("activation plan/2 observed lock state must be absent or present");
   }
@@ -22048,7 +22375,7 @@ function normalizeTarget3(input) {
   if (!isUnavailableCode2(disposition.code)) {
     throw new TypeError("target disposition has an invalid unavailable code");
   }
-  const evidence = ordinaryArray(disposition.evidenceDigests, MAX_EVIDENCE, "target evidence").map((digest3) => requireDigest3(digest3, "target evidence")).sort();
+  const evidence = ordinaryArray(disposition.evidenceDigests, MAX_EVIDENCE, "target evidence").map((digest4) => requireDigest3(digest4, "target evidence")).sort();
   if (evidence.length === 0)
     throw new TypeError("unavailable target requires evidence");
   for (let index = 1;index < evidence.length; index += 1) {
@@ -22079,12 +22406,12 @@ function requireRequestLockProjection(request, lock) {
   }
   if (request.target.kind === "binding") {
     const binding = lock.bindings[request.target.id];
-    if (binding === undefined || !sameJson2(binding.settings, request.settings) || !sameJson2(binding.slots, request.flowSlots)) {
+    if (binding === undefined || !sameJson2(binding.settings, request.settings) || !sameJson2(binding.slots, request.flowSlots) || !sameJson2(binding.commands ?? {}, request.commands ?? {})) {
       throw new TypeError("activation request Binding configuration does not match its lock projection");
     }
     return;
   }
-  if (Object.keys(request.settings).length !== 0 || Object.keys(request.flowSlots).length !== 0) {
+  if (Object.keys(request.settings).length !== 0 || Object.keys(request.flowSlots).length !== 0 || request.commands !== undefined) {
     throw new TypeError("direct Flow activation request must have empty configuration");
   }
 }
@@ -22327,7 +22654,7 @@ function normalizePrivateRootRunIdentityInput(value) {
       inode: unsigned64(project.inode, "root Run project inode")
     }),
     origin: normalizePrivateRootRunOrigin(root.origin),
-    requestDigest: digest3(root.requestDigest, "root Run identity request"),
+    requestDigest: digest4(root.requestDigest, "root Run identity request"),
     coordinatorEpoch: positiveSafeInteger(root.coordinatorEpoch, "root Run identity coordinator epoch")
   });
 }
@@ -22398,13 +22725,13 @@ function normalizePrivateRootSpawnIntent(value) {
   const deadlineUnixMs = nonnegativeSafeInteger(root.deadlineUnixMs, "root Run spawn intent deadline");
   return Object.freeze({
     kind: "private-root-spawn-intent/1",
-    runId: digest3(root.runId, "root Run spawn intent run"),
-    admissionDigest: digest3(root.admissionDigest, "root Run spawn intent admission"),
+    runId: digest4(root.runId, "root Run spawn intent run"),
+    admissionDigest: digest4(root.admissionDigest, "root Run spawn intent admission"),
     candidateRevision,
     coordinatorEpoch,
-    requestDigest: digest3(root.requestDigest, "root Run spawn intent request"),
-    recipeDigest: digest3(root.recipeDigest, "root Run spawn intent recipe"),
-    observationDigest: digest3(root.observationDigest, "root Run spawn intent observation"),
+    requestDigest: digest4(root.requestDigest, "root Run spawn intent request"),
+    recipeDigest: digest4(root.recipeDigest, "root Run spawn intent recipe"),
+    observationDigest: digest4(root.observationDigest, "root Run spawn intent observation"),
     deadlineUnixMs
   });
 }
@@ -22502,7 +22829,7 @@ function exactRecord5(value, keys, label) {
   }
   return value;
 }
-function digest3(value, label) {
+function digest4(value, label) {
   if (typeof value !== "string" || !DIGEST8.test(value)) {
     throw new TypeError(`${label} digest is invalid`);
   }
@@ -22551,6 +22878,7 @@ var MAX_STORED_BYTES = 16777216;
 var MAX_SAFE_REVISION = BigInt(Number.MAX_SAFE_INTEGER);
 var DIGEST9 = /^sha256:[0-9a-f]{64}$/;
 var WIRE_ID = /^[A-Za-z0-9][A-Za-z0-9._:/-]*$/;
+var stateTurns = new Map;
 var CREATE_CANDIDATES = "CREATE TABLE candidates (revision INTEGER PRIMARY KEY CHECK (revision BETWEEN 1 AND 9007199254740991), candidate_digest TEXT NOT NULL, candidate_bytes BLOB NOT NULL CHECK (length(candidate_bytes) BETWEEN 1 AND 16777216), lock_bytes BLOB NOT NULL CHECK (length(lock_bytes) BETWEEN 1 AND 16777216)) STRICT";
 var CREATE_CANDIDATE_HEAD = "CREATE TABLE candidate_head (singleton INTEGER PRIMARY KEY CHECK (singleton = 1), revision INTEGER REFERENCES candidates(revision)) STRICT";
 var CREATE_REVIEW_PLANS = "CREATE TABLE review_plans (plan_digest TEXT PRIMARY KEY, candidate_revision INTEGER NOT NULL REFERENCES candidates(revision), plan_bytes BLOB NOT NULL CHECK (length(plan_bytes) BETWEEN 1 AND 16777216)) STRICT";
@@ -22789,6 +23117,7 @@ async function openPrivateProjectCoordinator(input) {
       device: owner.root.information.dev,
       inode: owner.root.information.ino
     }));
+    await owner.finish();
     await coordinator.verify();
     return coordinator;
   } catch (error) {
@@ -22835,7 +23164,7 @@ async function replacePrivateBunPreparationOwner(input) {
   const encoded = input.value === null ? null : canonicalJson(input.value);
   if (encoded !== null)
     requireStoredSize(encoded, "Bun preparation owner");
-  const digest4 = input.value === null ? null : privateDomainDigest("JIG-Private-Bun-Preparation-Owner/1", input.value);
+  const digest5 = input.value === null ? null : privateDomainDigest("JIG-Private-Bun-Preparation-Owner/1", input.value);
   const owner = await openStateOwner(input.projectRoot, false);
   let failure;
   try {
@@ -22845,7 +23174,7 @@ async function replacePrivateBunPreparationOwner(input) {
       if ((current?.digest ?? null) !== input.expectedDigest) {
         invalid("PREPARATION_OWNER_CONFLICT", "Bun preparation cleanup ownership changed");
       }
-      const changed = runFinalized(owner.database, "UPDATE coordinator_head SET preparation_owner_digest = ?1, preparation_owner_bytes = ?2 WHERE singleton = 1 AND preparation_owner_digest IS ?3", [digest4, encoded, input.expectedDigest]).changes;
+      const changed = runFinalized(owner.database, "UPDATE coordinator_head SET preparation_owner_digest = ?1, preparation_owner_bytes = ?2 WHERE singleton = 1 AND preparation_owner_digest IS ?3", [digest5, encoded, input.expectedDigest]).changes;
       if (changed !== 1)
         corrupt("Bun preparation cleanup owner compare-and-set failed");
       return readBunPreparationOwner(owner.database);
@@ -23009,10 +23338,10 @@ async function recordPrivateRootExecutionCheckpoint(input) {
       }, checkpoint);
       const bytes = canonicalJson(envelope);
       requireStoredSize(bytes, `root execution ${checkpoint}`);
-      const digest4 = rootExecutionCheckpointDigest(checkpoint, envelope);
+      const digest5 = rootExecutionCheckpointDigest(checkpoint, envelope);
       const current = executionFact(before, checkpoint);
       if (current !== undefined) {
-        if (current.digest !== digest4 || !sameBytes4(checkpointBytes(row, checkpoint), bytes)) {
+        if (current.digest !== digest5 || !sameBytes4(checkpointBytes(row, checkpoint), bytes)) {
           invalid("RUN_EXECUTION_CHECKPOINT_CONFLICT", `root execution ${checkpoint} checkpoint differs`);
         }
         return before;
@@ -23020,7 +23349,7 @@ async function recordPrivateRootExecutionCheckpoint(input) {
       requireCheckpointAuthority(run, coordinator, checkpoint, envelope.value);
       requireCheckpointOrder(before, checkpoint, envelope.value);
       const columns = checkpointColumns(checkpoint);
-      const changed = runFinalized(owner.database, `UPDATE root_execution_lifecycles SET ${columns.digest} = ?1, ${columns.bytes} = ?2 WHERE run_id = ?3 AND ${columns.digest} IS NULL`, [digest4, bytes, input.runId]).changes;
+      const changed = runFinalized(owner.database, `UPDATE root_execution_lifecycles SET ${columns.digest} = ?1, ${columns.bytes} = ?2 WHERE run_id = ?3 AND ${columns.digest} IS NULL`, [digest5, bytes, input.runId]).changes;
       if (changed !== 1)
         corrupt("root execution checkpoint compare-and-set failed");
       return loadRootExecutionLifecycle(owner.database, requireRootExecutionLifecycle(owner.database, input.runId), runRow);
@@ -23043,7 +23372,7 @@ async function allocatePrivateRootChildOwner(input) {
     requireWireId(input.parentOperationId, "parent child operation");
   const bytes = canonicalJson(input.allocation);
   requireStoredSize(bytes, "child owner allocation");
-  const digest4 = privateDomainDigest("JIG-Private-Root-Child-Owner-Allocation/1", input.allocation);
+  const digest5 = privateDomainDigest("JIG-Private-Root-Child-Owner-Allocation/1", input.allocation);
   const owner = await openStateOwner(input.projectRoot, false);
   let failure;
   try {
@@ -23060,19 +23389,28 @@ async function allocatePrivateRootChildOwner(input) {
       const existing = findRootChildOwner(owner.database, input.parentRunId, input.operationId, input.parentOperationId);
       if (existing !== null) {
         const loaded = loadRootChildOwner(existing);
-        if (loaded.allocation.digest !== digest4 || !sameBytes4(existing.allocation_bytes, bytes)) {
+        if (loaded.allocation.digest !== digest5 || !sameBytes4(existing.allocation_bytes, bytes)) {
           invalid("RUN_CHILD_OWNER_CONFLICT", "child operation owner was reused differently");
         }
         return loaded;
       }
       requireActiveChildScope(owner.database, input.parentRunId, input.parentOperationId);
-      if (input.parentOperationId !== undefined && (input.allocation === null || typeof input.allocation !== "object" || Array.isArray(input.allocation) || input.allocation.kind !== "private-root-agent-owner-allocation/1")) {
-        invalid("RUN_CHILD_OWNER_CONFLICT", "a child Flow may own only one Agent operation");
+      if (input.parentOperationId !== undefined && (input.allocation === null || typeof input.allocation !== "object" || Array.isArray(input.allocation) || !["private-root-agent-owner-allocation/1", "private-project-command-owner/1"].includes(String(input.allocation.kind)))) {
+        invalid("RUN_CHILD_OWNER_CONFLICT", "a child Flow may own only an Agent or project-command operation");
       }
-      if (countScopedRootChildOwners(owner.database, input.parentRunId, input.parentOperationId) !== 0n) {
-        invalid("RUN_CHILD_CAPACITY", "the parent Run already has an active child operation");
+      if (input.parentOperationId === undefined) {
+        const query = statement(owner.database, "SELECT allocation_bytes FROM root_child_owners WHERE parent_run_id = ?1 AND scope_operation_id = ?2");
+        try {
+          const allocations = query.all(input.parentRunId, "").map((row) => decodeJson1(row.allocation_bytes));
+          if (!canReservePrivateRootOperation(allocations, input.allocation))
+            invalid("RUN_CHILD_CAPACITY", "the root operation or aggregate resource budget is occupied");
+        } finally {
+          query.finalize();
+        }
+      } else if (countScopedRootChildOwners(owner.database, input.parentRunId, input.parentOperationId) !== 0n) {
+        invalid("RUN_CHILD_CAPACITY", "the child Flow already has an active effect");
       }
-      runFinalized(owner.database, "INSERT INTO root_child_owners(parent_run_id, scope_operation_id, operation_id, allocation_digest, allocation_bytes) VALUES (?1, ?2, ?3, ?4, ?5)", [input.parentRunId, input.parentOperationId ?? "", input.operationId, digest4, bytes]);
+      runFinalized(owner.database, "INSERT INTO root_child_owners(parent_run_id, scope_operation_id, operation_id, allocation_digest, allocation_bytes) VALUES (?1, ?2, ?3, ?4, ?5)", [input.parentRunId, input.parentOperationId ?? "", input.operationId, digest5, bytes]);
       return loadRootChildOwner(requireRootChildOwner(owner.database, input.parentRunId, input.operationId, input.parentOperationId));
     });
     await owner.finish();
@@ -23094,7 +23432,7 @@ async function recordPrivateRootChildSandbox(input) {
   requireDigest4(input.allocationDigest, "child allocation");
   const bytes = canonicalJson(input.sandbox);
   requireStoredSize(bytes, "child sandbox owner");
-  const digest4 = privateDomainDigest("JIG-Private-Root-Child-Sandbox/1", input.sandbox);
+  const digest5 = privateDomainDigest("JIG-Private-Root-Child-Sandbox/1", input.sandbox);
   const owner = await openStateOwner(input.projectRoot, false);
   let failure;
   try {
@@ -23106,7 +23444,7 @@ async function recordPrivateRootChildSandbox(input) {
         invalid("RUN_CHILD_OWNER_CONFLICT", "child sandbox names a different allocation");
       }
       if (row.sandbox_digest !== null) {
-        if (row.sandbox_digest !== digest4 || !sameBytes4(row.sandbox_bytes, bytes)) {
+        if (row.sandbox_digest !== digest5 || !sameBytes4(row.sandbox_bytes, bytes)) {
           invalid("RUN_CHILD_OWNER_CONFLICT", "child sandbox owner differs");
         }
         return loadRootChildOwner(row);
@@ -23119,7 +23457,7 @@ async function recordPrivateRootChildSandbox(input) {
         invalid("RUN_OWNER_CHANGED", "only the active parent coordinator may seal child work");
       }
       requireActiveChildScope(owner.database, input.parentRunId, input.parentOperationId);
-      const changed = runFinalized(owner.database, "UPDATE root_child_owners SET sandbox_digest = ?1, sandbox_bytes = ?2 WHERE parent_run_id = ?3 AND operation_id = ?4 AND scope_operation_id = ?5 AND sandbox_digest IS NULL", [digest4, bytes, input.parentRunId, input.operationId, input.parentOperationId ?? ""]).changes;
+      const changed = runFinalized(owner.database, "UPDATE root_child_owners SET sandbox_digest = ?1, sandbox_bytes = ?2 WHERE parent_run_id = ?3 AND operation_id = ?4 AND scope_operation_id = ?5 AND sandbox_digest IS NULL", [digest5, bytes, input.parentRunId, input.operationId, input.parentOperationId ?? ""]).changes;
       if (changed !== 1)
         corrupt("child sandbox owner compare-and-set failed");
       return loadRootChildOwner(requireRootChildOwner(owner.database, input.parentRunId, input.operationId, input.parentOperationId));
@@ -23144,7 +23482,7 @@ async function recordPrivateRootChildFence(input) {
   requireDigest4(input.sandboxDigest, "child sandbox");
   const bytes = canonicalJson(input.fence);
   requireStoredSize(bytes, "child fence");
-  const digest4 = privateDomainDigest("JIG-Private-Root-Child-Fence/1", input.fence);
+  const digest5 = privateDomainDigest("JIG-Private-Root-Child-Fence/1", input.fence);
   const owner = await openStateOwner(input.projectRoot, false);
   let failure;
   try {
@@ -23156,12 +23494,12 @@ async function recordPrivateRootChildFence(input) {
         invalid("RUN_CHILD_OWNER_CONFLICT", "child fence names a different owner");
       }
       if (row.fence_digest !== null) {
-        if (row.fence_digest !== digest4 || !sameBytes4(row.fence_bytes, bytes)) {
+        if (row.fence_digest !== digest5 || !sameBytes4(row.fence_bytes, bytes)) {
           invalid("RUN_CHILD_OWNER_CONFLICT", "child fence differs");
         }
         return loadRootChildOwner(row);
       }
-      const changed = runFinalized(owner.database, "UPDATE root_child_owners SET fence_digest = ?1, fence_bytes = ?2 WHERE parent_run_id = ?3 AND operation_id = ?4 AND scope_operation_id = ?5 AND fence_digest IS NULL", [digest4, bytes, input.parentRunId, input.operationId, input.parentOperationId ?? ""]).changes;
+      const changed = runFinalized(owner.database, "UPDATE root_child_owners SET fence_digest = ?1, fence_bytes = ?2 WHERE parent_run_id = ?3 AND operation_id = ?4 AND scope_operation_id = ?5 AND fence_digest IS NULL", [digest5, bytes, input.parentRunId, input.operationId, input.parentOperationId ?? ""]).changes;
       if (changed !== 1)
         corrupt("child fence compare-and-set failed");
       return loadRootChildOwner(requireRootChildOwner(owner.database, input.parentRunId, input.operationId, input.parentOperationId));
@@ -23187,7 +23525,7 @@ async function recordPrivateRootChildCleanup(input) {
   requireDigest4(input.fenceDigest, "child fence");
   const bytes = canonicalJson(input.cleanup);
   requireStoredSize(bytes, "child cleanup");
-  const digest4 = privateDomainDigest("JIG-Private-Root-Child-Cleanup/1", input.cleanup);
+  const digest5 = privateDomainDigest("JIG-Private-Root-Child-Cleanup/1", input.cleanup);
   const owner = await openStateOwner(input.projectRoot, false);
   let failure;
   try {
@@ -23199,12 +23537,12 @@ async function recordPrivateRootChildCleanup(input) {
         invalid("RUN_CHILD_OWNER_CONFLICT", "child cleanup names different durable evidence");
       }
       if (row.cleanup_digest !== null) {
-        if (row.cleanup_digest !== digest4 || !sameBytes4(row.cleanup_bytes, bytes)) {
+        if (row.cleanup_digest !== digest5 || !sameBytes4(row.cleanup_bytes, bytes)) {
           invalid("RUN_CHILD_OWNER_CONFLICT", "child cleanup differs");
         }
         return loadRootChildOwner(row);
       }
-      const changed = runFinalized(owner.database, "UPDATE root_child_owners SET cleanup_digest = ?1, cleanup_bytes = ?2 WHERE parent_run_id = ?3 AND operation_id = ?4 AND scope_operation_id = ?5 AND cleanup_digest IS NULL", [digest4, bytes, input.parentRunId, input.operationId, input.parentOperationId ?? ""]).changes;
+      const changed = runFinalized(owner.database, "UPDATE root_child_owners SET cleanup_digest = ?1, cleanup_bytes = ?2 WHERE parent_run_id = ?3 AND operation_id = ?4 AND scope_operation_id = ?5 AND cleanup_digest IS NULL", [digest5, bytes, input.parentRunId, input.operationId, input.parentOperationId ?? ""]).changes;
       if (changed !== 1)
         corrupt("child cleanup compare-and-set failed");
       return loadRootChildOwner(requireRootChildOwner(owner.database, input.parentRunId, input.operationId, input.parentOperationId));
@@ -23268,7 +23606,7 @@ async function closePrivateRootChildOwner(input) {
       await coordinator.verify();
       const row = findRootChildOwner(owner.database, input.parentRunId, input.operationId, input.parentOperationId);
       if (input.parentOperationId === undefined && countScopedRootChildOwners(owner.database, input.parentRunId, input.operationId) !== 0n) {
-        invalid("RUN_EXECUTION_INCOMPLETE", "child Flow still has an active Agent owner");
+        invalid("RUN_EXECUTION_INCOMPLETE", "child Flow still has an active operation owner");
       }
       if (row === null)
         return;
@@ -23459,7 +23797,7 @@ function requireActiveChildScope(database, parentRunId, parentOperationId) {
   }
   const allocation = loadRootChildOwner(parent).allocation.value;
   if (allocation === null || typeof allocation !== "object" || Array.isArray(allocation) || allocation.kind !== "private-root-child-owner-allocation/1") {
-    invalid("RUN_CHILD_PARENT_INACTIVE", "only a direct child Flow may own an Agent");
+    invalid("RUN_CHILD_PARENT_INACTIVE", "only a direct child Flow may own a nested operation");
   }
 }
 async function loadPrivateRootRunForCoordinator(input) {
@@ -23845,20 +24183,20 @@ function loadRootExecutionLifecycle(database, row, run) {
   return Object.freeze(result2);
 }
 function loadOptionalExecutionFact(row, checkpoint, allocationDigest) {
-  const digest4 = checkpointDigest(row, checkpoint);
+  const digest5 = checkpointDigest(row, checkpoint);
   const bytes = checkpointBytes(row, checkpoint);
-  if (digest4 === null !== (bytes === null))
+  if (digest5 === null !== (bytes === null))
     corrupt(`stored root execution ${checkpoint} pair is incomplete`);
-  if (digest4 === null || bytes === null)
+  if (digest5 === null || bytes === null)
     return {};
-  requireDigest4(digest4, `stored root execution ${checkpoint}`);
+  requireDigest4(digest5, `stored root execution ${checkpoint}`);
   let envelope;
   try {
     envelope = normalizeRootExecutionCheckpoint(decodeJson1(bytes), checkpoint);
   } catch {
     corrupt(`stored root execution ${checkpoint} checkpoint is invalid`);
   }
-  if (!sameBytes4(bytes, canonicalJson(envelope)) || rootExecutionCheckpointDigest(checkpoint, envelope) !== digest4 || envelope.runId !== row.run_id || envelope.allocationDigest !== allocationDigest) {
+  if (!sameBytes4(bytes, canonicalJson(envelope)) || rootExecutionCheckpointDigest(checkpoint, envelope) !== digest5 || envelope.runId !== row.run_id || envelope.allocationDigest !== allocationDigest) {
     corrupt(`stored root execution ${checkpoint} differs from its durable identity`);
   }
   if (checkpoint === "provisional" || checkpoint === "admitted") {
@@ -23870,7 +24208,7 @@ function loadOptionalExecutionFact(row, checkpoint, allocationDigest) {
     }
     envelope = Object.freeze({ ...envelope, value: terminal });
   }
-  return { [checkpoint]: Object.freeze({ digest: digest4, value: envelope.value }) };
+  return { [checkpoint]: Object.freeze({ digest: digest5, value: envelope.value }) };
 }
 function findRootTerminal(database, runId) {
   const query = statement(database, "SELECT run_id, terminal_digest, terminal_bytes FROM root_terminals WHERE run_id = ?1");
@@ -24035,8 +24373,8 @@ function persistRootTerminal(database, runId, terminalValue) {
   const terminal = normalizePrivateRootTerminal(terminalValue);
   const bytes = privateRootTerminalBytes(terminal);
   requireStoredSize(bytes, "root Run terminal");
-  const digest4 = privateDomainDigest("JIG-Private-Root-Terminal/1", terminal);
-  runFinalized(database, "INSERT INTO root_terminals(run_id, terminal_digest, terminal_bytes) VALUES (?1, ?2, ?3)", [runId, digest4, bytes]);
+  const digest5 = privateDomainDigest("JIG-Private-Root-Terminal/1", terminal);
+  runFinalized(database, "INSERT INTO root_terminals(run_id, terminal_digest, terminal_bytes) VALUES (?1, ?2, ?3)", [runId, digest5, bytes]);
 }
 function normalizeRootExecutionAllocation(value) {
   const root = exactJsonObject(value, ["kind", "runId", "spawnIntentDigest", "coordinatorEpoch", "value"], "root execution allocation");
@@ -24361,6 +24699,7 @@ async function openStateOwner(projectRoot, create) {
   const root = ownsRoot ? await openPrivateProjectRoot(projectRoot) : requirePrivateProjectRoot(projectRoot);
   if (!ownsRoot)
     await root.verify();
+  const releaseTurn = await acquireStateTurn(root);
   let directory;
   let database;
   try {
@@ -24415,6 +24754,7 @@ async function openStateOwner(projectRoot, create) {
         database.close(true);
         databaseClosed = true;
         await owner.verify();
+        releaseTurn();
       },
       async dispose() {
         if (disposed)
@@ -24441,6 +24781,7 @@ async function openStateOwner(projectRoot, create) {
             failures.push(error);
           }
         }
+        releaseTurn();
         if (failures.length > 0)
           throw new AggregateError(failures, "admission state cleanup did not complete");
       }
@@ -24457,11 +24798,31 @@ async function openStateOwner(projectRoot, create) {
       await root.dispose().catch(() => {
         return;
       });
+    releaseTurn();
     if (isSqliteBusy(error))
       busy();
     throw error;
   }
 }
+async function acquireStateTurn(root) {
+  const key = `${root.information.dev}:${root.information.ino}`;
+  const previous = stateTurns.get(key);
+  let resolve8;
+  const current = new Promise((done) => {
+    resolve8 = done;
+  });
+  stateTurns.set(key, current);
+  await previous;
+  let released = false;
+  return () => {
+    if (released)
+      return;
+    released = true;
+    if (stateTurns.get(key) === current)
+      stateTurns.delete(key);
+    resolve8();
+  };
+}
 async function openCheckedDirectory(path, projectDevice) {
   let observed;
   try {
@@ -24752,18 +25113,18 @@ function requireCandidateRow(database, revision) {
     corrupt(`candidate revision ${revision} is missing or duplicated`);
   return rows[0];
 }
-function requirePlanRow(database, digest4) {
+function requirePlanRow(database, digest5) {
   const query = statement(database, "SELECT plan_digest, candidate_revision, plan_bytes FROM review_plans WHERE plan_digest = ?1");
   let rows;
   try {
-    rows = query.all(digest4).map(copiedPlanRow);
+    rows = query.all(digest5).map(copiedPlanRow);
   } finally {
     query.finalize();
   }
   if (rows.length === 0)
-    unavailable("ADMISSION_PLAN_MISSING", `review plan ${digest4} does not exist`);
+    unavailable("ADMISSION_PLAN_MISSING", `review plan ${digest5} does not exist`);
   if (rows.length !== 1)
-    corrupt(`review plan ${digest4} is duplicated`);
+    corrupt(`review plan ${digest5} is duplicated`);
   return rows[0];
 }
 function requireAdmissionRow(database, revision) {
@@ -24790,16 +25151,16 @@ function findAdmissionByPlan(database, planDigest) {
     corrupt(`plan ${planDigest} names multiple admissions`);
   return rows[0] ?? null;
 }
-function requireAdmissionByDigest(database, digest4) {
+function requireAdmissionByDigest(database, digest5) {
   const query = statement(database, "SELECT revision, admission_digest, base_generation, plan_digest, admission_bytes FROM admissions WHERE admission_digest = ?1");
   let rows;
   try {
-    rows = query.all(digest4).map(copiedAdmissionRow);
+    rows = query.all(digest5).map(copiedAdmissionRow);
   } finally {
     query.finalize();
   }
   if (rows.length !== 1)
-    corrupt(`base admission ${digest4} is missing or duplicated`);
+    corrupt(`base admission ${digest5} is missing or duplicated`);
   return rows[0];
 }
 function copiedCandidateRow(row) {
@@ -25308,9 +25669,9 @@ async function reacquireCandidateArtifacts(packageStoreRoot, candidate) {
       ...Object.values(candidate.lock.packages).map((entry) => entry.digest),
       ...candidate.candidate.targets.flatMap((target) => target.disposition.state === "ready" ? [target.disposition.executionPackage.digest] : [])
     ]);
-    for (const digest4 of [...digests].sort()) {
-      const reference = normalizePackageArtifactRef({ kind: "flow-package/1", digest: digest4 });
-      captures.set(digest4, await captureStoredPackage(packageStoreRoot, reference));
+    for (const digest5 of [...digests].sort()) {
+      const reference = normalizePackageArtifactRef({ kind: "flow-package/1", digest: digest5 });
+      captures.set(digest5, await captureStoredPackage(packageStoreRoot, reference));
     }
     for (const [path, expected] of Object.entries(candidate.lock.packages)) {
       const captured = captures.get(expected.digest);
@@ -25334,10 +25695,10 @@ async function reacquireCandidateArtifacts(packageStoreRoot, candidate) {
   }
   let disposed = false;
   return Object.freeze({
-    inspection(digest4) {
-      const inspected = inspections.get(digest4);
+    inspection(digest5) {
+      const inspected = inspections.get(digest5);
       if (inspected === undefined)
-        corrupt(`stored package ${digest4} has no verified inspection`);
+        corrupt(`stored package ${digest5} has no verified inspection`);
       return inspected;
     },
     async dispose() {
@@ -26053,8 +26414,8 @@ async function capturedFromPrepared(value) {
       contents.clear();
     }
   };
-  const digest4 = await packageDigest(frozenFiles, (file) => backing.stream(file.path));
-  return createCapturedPackage("prepared Bun dependency tree", frozenFiles, digest4, backing);
+  const digest5 = await packageDigest(frozenFiles, (file) => backing.stream(file.path));
+  return createCapturedPackage("prepared Bun dependency tree", frozenFiles, digest5, backing);
 }
 async function* jsonLines(source, maximum) {
   let pending = [];
@@ -26157,6 +26518,7 @@ function projectCandidate(lock, targetValues) {
     packagePath: request.packagePath,
     entrypoint: request.entrypoint,
     settings: request.settings,
+    ...request.commands === undefined ? {} : { commands: request.commands },
     attachments: request.attachments,
     ...Object.keys(request.attachments).length === 0 ? {} : {
       filePolicy: "Root-only captured input; one initially empty bounded output; no live host writes."
@@ -26630,7 +26992,7 @@ import { lstat as lstat18, mkdir as mkdir11, realpath as realpath13 } from "fs/p
 import { join as join13 } from "path";
 
 // src/run/session.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 var ROOT_ID = "host:1";
 var MAX_PENDING_COMPONENT_REQUESTS = 64;
 var MAX_COMPONENT_REQUEST_IDS = 65536;
@@ -26899,7 +27261,7 @@ class RunHostSession {
       this.graceTimer ??= setTimeout(() => this.startTermination(), this.limits.cancellationGraceMs);
       return;
     }
-    if (request.method !== "flow/call" && request.method !== "effect/call") {
+    if (request.method !== "flow/run-child" && request.method !== "capability/call") {
       this.queueResponse(request.id, errorMessage(request.id, -32601, "Method not found"));
       return;
     }
@@ -26923,9 +27285,9 @@ class RunHostSession {
       this.attachOperationWaiter(request.id, prior);
       return;
     }
-    const dispatch = operation.method === "flow/call" ? this.dispatcher?.callFlow : this.dispatcher?.callEffect;
+    const dispatch = operation.method === "flow/run-child" ? this.dispatcher?.runChildFlow : this.dispatcher?.callCapability;
     if (dispatch === undefined) {
-      const terminal = failedOperation("UNAVAILABLE", operation.method === "effect/call" ? "no effect dispatcher is installed" : "no child Flow dispatcher is installed");
+      const terminal = failedOperation("UNAVAILABLE", operation.method === "capability/call" ? "no effect dispatcher is installed" : "no child Flow dispatcher is installed");
       const settled = {
         signature: operation.signature,
         controller: new AbortController,
@@ -26943,7 +27305,7 @@ class RunHostSession {
     };
     this.operations.set(operation.operationId, record2);
     this.attachOperationWaiter(request.id, record2);
-    const task = (operation.method === "flow/call" ? this.dispatcher.callFlow(operation.call, record2.controller.signal).then((terminal) => normalizeFlowOperationTerminal(terminal)) : this.dispatcher.callEffect(operation.call, record2.controller.signal).then((terminal) => normalizeEffectOperationTerminal(terminal))).catch((error) => failedOperation(error instanceof InvalidDispatcherResult ? "INVALID_RESULT" : "EXECUTION_FAILED", error instanceof InvalidDispatcherResult ? "the host dispatcher returned an invalid result" : "the host operation failed")).then((terminal) => this.settleOperation(record2, terminal));
+    const task = (operation.method === "flow/run-child" ? this.dispatcher.runChildFlow(operation.call, record2.controller.signal).then((terminal) => normalizeFlowOperationTerminal(terminal)) : this.dispatcher.callCapability(operation.call, record2.controller.signal).then((terminal) => normalizeEffectOperationTerminal(terminal))).catch((error) => failedOperation(error instanceof InvalidDispatcherResult ? "INVALID_RESULT" : "EXECUTION_FAILED", error instanceof InvalidDispatcherResult ? "the host dispatcher returned an invalid result" : "the host operation failed")).then((terminal) => this.settleOperation(record2, terminal));
     this.own(task);
   }
   receiveNotification(notification) {
@@ -27406,7 +27768,7 @@ function parseRunResult(value) {
 }
 function parseOperation(request) {
   const params = requireObject3(request.params, `${request.method} params`);
-  if (request.method === "flow/call") {
+  if (request.method === "flow/run-child") {
     const keys = Object.hasOwn(params, "intent") ? ["operationId", "slot", "intent", "input"] : ["operationId", "slot", "input"];
     requireExactKeys(params, keys);
     const operationId2 = requireWireId2(params.operationId);
@@ -27424,7 +27786,7 @@ function parseOperation(request) {
       input: params.input
     });
     return {
-      method: "flow/call",
+      method: "flow/run-child",
       operationId: operationId2,
       signature: operationSignature(request.method, params),
       call
@@ -27435,7 +27797,7 @@ function parseOperation(request) {
   const slot = requireLocalName4(params.slot);
   const method = requireLocalName4(params.method);
   return {
-    method: "effect/call",
+    method: "capability/call",
     operationId,
     signature: operationSignature(request.method, params),
     call: Object.freeze({ operationId, slot, method, input: params.input })
@@ -27448,7 +27810,7 @@ function operationSignature(method, params) {
       semantic[key] = value;
   }
   const bytes = canonicalJson({ method, params: semantic });
-  return createHash8("sha256").update(bytes).digest("hex");
+  return createHash9("sha256").update(bytes).digest("hex");
 }
 function errorMessage(id, code, message) {
   return { jsonrpc: "2.0", id, error: { code, message } };
@@ -27479,7 +27841,11 @@ function normalizeFlowOperationTerminal(value) {
   if (value.status === "succeeded") {
     try {
       const result2 = parseRunResult(value.result);
-      return Object.freeze({ status: "succeeded", method: "flow/call", result: result2 });
+      return Object.freeze({
+        status: "succeeded",
+        method: "flow/run-child",
+        result: result2
+      });
     } catch (error) {
       throw new InvalidDispatcherResult(`invalid Flow dispatcher result: ${errorText9(error)}`);
     }
@@ -27490,7 +27856,11 @@ function normalizeEffectOperationTerminal(value) {
   if (value.status === "succeeded") {
     try {
       const result2 = parseEffectResult(value.result);
-      return Object.freeze({ status: "succeeded", method: "effect/call", result: result2 });
+      return Object.freeze({
+        status: "succeeded",
+        method: "capability/call",
+        result: result2
+      });
     } catch (error) {
       throw new InvalidDispatcherResult(`invalid effect dispatcher result: ${errorText9(error)}`);
     }
@@ -27586,7 +27956,7 @@ import {
   rmdir as rmdir3,
   unlink as unlink5
 } from "fs/promises";
-import { dirname as dirname9, isAbsolute as isAbsolute2, join as join10, resolve as resolve8 } from "path";
+import { dirname as dirname8, isAbsolute as isAbsolute2, join as join10, resolve as resolve8 } from "path";
 import { types as utilTypes8 } from "util";
 var ALLOCATION_KIND = "private-package-materialization-allocation/1";
 var LEASE_KIND = "private-package-materialization-lease/1";
@@ -28419,6 +28789,9 @@ function invalidResult(terminal, message, details) {
 import { lstat as lstat17, mkdir as mkdir10, realpath as realpath12 } from "fs/promises";
 import { join as join12 } from "path";
 
+// src/internal/root-project-command-controller.ts
+import { closeSync as closeSync3 } from "fs";
+
 // src/internal/root-agent-run-controller.ts
 import { lstat as lstat16, mkdir as mkdir9, realpath as realpath11 } from "fs/promises";
 import { join as join11 } from "path";
@@ -49319,20 +49692,20 @@ function getName(value, options) {
   const name = "name" in value ? value.name : undefined;
   const explicitName = name && String(name) || "filename" in value && value.filename && String(value.filename);
   if (explicitName) {
-    return options?.stripFilename === false ? normalizeFilenamePath(explicitName) : basename3(explicitName);
+    return options?.stripFilename === false ? normalizeFilenamePath(explicitName) : basename2(explicitName);
   }
   const url2 = "url" in value && value.url && String(value.url);
   if (url2) {
     try {
-      return basename3(new URL(url2).pathname);
+      return basename2(new URL(url2).pathname);
     } catch {
-      return basename3(url2);
+      return basename2(url2);
     }
   }
   const path = "path" in value && value.path && String(value.path);
-  return path ? basename3(path) : undefined;
+  return path ? basename2(path) : undefined;
 }
-function basename3(value) {
+function basename2(value) {
   return value.split(/[\\/]/).pop() || undefined;
 }
 function normalizeFilenamePath(value) {
@@ -49513,7 +49886,7 @@ function getStreamingFileName(value, options) {
     if (typeof name !== "string" || !name) {
       throw new TypeError("Streaming upload file name must be a non-empty string");
     }
-    return options.stripFilenames === false ? normalizeFilenamePath(name) : basename3(name) ?? "unknown_file";
+    return options.stripFilenames === false ? normalizeFilenamePath(name) : basename2(name) ?? "unknown_file";
   }
   return getName(value, { stripFilename: options.stripFilenames }) ?? "unknown_file";
 }
@@ -59869,7 +60242,6 @@ var SANDBOX_KIND = "private-root-agent-sandbox/1";
 var CLEANUP_KIND = "private-root-agent-cleanup/1";
 var CANCELLATION_GRACE_MS = 1000;
 var PROVIDER_STDERR_BYTES = 64 * 1024;
-var AGENT_PROVIDER_MINIMUM_PIDS = 128;
 var PROVIDER_INSTRUCTION_BYTES = 1048576;
 var DIGEST11 = /^sha256:[0-9a-f]{64}$/;
 var decoder10 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
@@ -60234,7 +60606,7 @@ function backendPlan(recipe, provider, deadlineUnixMs, identity2) {
     runId: `agent-${identity2.slice(0, 42)}`,
     limits: Object.freeze({
       ...recipe.resourceCeilings,
-      pids: Math.max(recipe.resourceCeilings.pids, AGENT_PROVIDER_MINIMUM_PIDS),
+      pids: PRIVATE_AGENT_PROVIDER_PIDS,
       deadlineUnixMs,
       cancellationGraceMs: CANCELLATION_GRACE_MS
     }),
@@ -60494,7 +60866,7 @@ async function requireAllocationMatchesParent(input, lifecycle, allocation) {
     ...rootInput,
     ...parentFlow === null ? {} : { parentFlow }
   });
-  if (allocation.parentRunId !== input.parent.run.runId || allocation.coordinatorEpoch !== input.parent.run.coordinatorEpoch || allocation.operationId !== lifecycle.operationId || allocation.parentRequestDigest !== target.request.digest || allocation.effectiveDeadlineUnixMs > input.parent.intent.deadlineUnixMs || Object.values(target.request.capabilities).length !== 1 || Object.values(target.request.capabilities)[0]?.digest !== AGENT_RUN_CONTRACT_DIGEST) {
+  if (allocation.parentRunId !== input.parent.run.runId || allocation.coordinatorEpoch !== input.parent.run.coordinatorEpoch || allocation.operationId !== lifecycle.operationId || allocation.parentRequestDigest !== target.request.digest || allocation.effectiveDeadlineUnixMs > input.parent.intent.deadlineUnixMs || !Object.values(target.request.capabilities).some(({ digest: digest5 }) => digest5 === AGENT_RUN_CONTRACT_DIGEST)) {
     throw new Error("durable Agent allocation differs from its admitted parent or provider");
   }
   if (parentFlow !== null) {
@@ -60633,6 +61005,326 @@ function hasCode6(error49, code) {
 class AgentInstructionLimitError extends Error {
 }
 
+// src/internal/root-project-command-controller.ts
+var KIND = "private-project-command-owner/1";
+var ROOT = "/jig-input/project";
+async function executePrivateProjectCommand(input) {
+  const target = requireParentTarget(input);
+  const capability = target.request.capabilities[input.call.slot];
+  if (capability === undefined || !isProjectCommandContract(capability) || input.call.method !== "run")
+    return failed2("UNAVAILABLE", "the requested slot has no admitted Project Command run method");
+  if (input.signal.aborted)
+    return failed2("CANCELLED", "the project command was cancelled");
+  let prepared;
+  try {
+    prepared = parseProjectCommandInput(input.call.input, target.request.commands ?? {});
+  } catch {
+    return failed2("INVALID_INPUT", "select a reviewed command and supply bounded candidate files, arguments, and stdin");
+  }
+  let recipe;
+  try {
+    if (target.disposition.state !== "ready")
+      throw new Error("target unavailable");
+    recipe = await planPrivateDirectRun({
+      ...input,
+      request: target.request,
+      executionPackage: target.disposition.executionPackage
+    });
+    if (recipe.digest !== target.disposition.recipeDigest || recipe.observation.digest !== target.disposition.observationDigest)
+      throw new Error("command parent recipe changed");
+    await revalidatePrivateInstalledBunSupport(input.installedSupport);
+  } catch {
+    return failed2("UNAVAILABLE", "the admitted project-command runtime cannot be reproduced");
+  }
+  const deadlineUnixMs = Math.min(input.parentDeadlineUnixMs, input.parent.intent.deadlineUnixMs, Date.now() + PROJECT_COMMAND_LIMITS.timeoutMs);
+  if (deadlineUnixMs <= Date.now())
+    return failed2("DEADLINE_EXCEEDED", "the command deadline elapsed before dispatch");
+  if (input.parentFlow !== undefined)
+    await requireParentFlowOwner(input, input.parentFlow, deadlineUnixMs);
+  const rows = (await owners(input)).filter((row) => row.parentOperationId === input.parentFlow?.operationId);
+  const prior = rows.find((row) => row.operationId === input.call.operationId);
+  if (prior !== undefined) {
+    if (!isCommandOwner(prior))
+      throw new Error("command identity names a different operation");
+    await releaseCommand(input, prior);
+    return failed2("UNCERTAIN", "a prior command dispatch was fenced without a proved result");
+  }
+  if (rows.length !== 0)
+    return failed2("RESOURCE_EXHAUSTED", "the parent already has an active operation");
+  const identity2 = commandIdentity(input.parent.run.runId, input.call.operationId, input.parentFlow?.operationId);
+  const ownerAllocation = await planPrivateLinuxOwnerStateAllocation({
+    parent: await protectedOwnerRoot(input.projectRoot),
+    name: `x-${identity2.slice(0, 62)}`
+  });
+  const allocation = {
+    kind: KIND,
+    parentRunId: input.parent.run.runId,
+    coordinatorEpoch: input.parent.run.coordinatorEpoch,
+    operationId: input.call.operationId,
+    parentRequestDigest: target.request.digest,
+    parentFlow: input.parentFlow ?? null,
+    deadlineUnixMs,
+    ownerAllocation,
+    requestDigest: privateDomainDigest("JIG-Project-Command-Request/1", prepared)
+  };
+  const key = operationKey(input, input.call.operationId, input.parentFlow?.operationId);
+  let lifecycle;
+  try {
+    lifecycle = await allocatePrivateRootChildOwner({
+      ...key,
+      allocation
+    });
+  } catch (error49) {
+    const cancelled = await cancelPrivateLinuxOwnerStateAllocation(ownerAllocation);
+    await releasePrivateLinuxOwnerState(ownerAllocation, cancelled);
+    if (error49 instanceof CheckError && error49.code === "RUN_CHILD_CAPACITY")
+      return failed2("RESOURCE_EXHAUSTED", "the parent already has an active operation");
+    throw error49;
+  }
+  const files = [];
+  let attempted = false;
+  try {
+    for (const [path2, source] of Object.entries(prepared.input.files)) {
+      const bytes = Buffer.from(source);
+      files.push({
+        fd: privateSealedBytes(bytes),
+        destination: `${ROOT}/${path2}`,
+        bytes: bytes.length,
+        digest: sha256(bytes)
+      });
+    }
+    const sealed = await input.backend.seal(commandPlan(recipe, prepared, files, identity2, deadlineUnixMs), ownerAllocation);
+    lifecycle = await recordPrivateRootChildSandbox({
+      ...key,
+      allocationDigest: lifecycle.allocation.digest,
+      sandbox: sealed.identity
+    });
+    attempted = true;
+    const component = await sealed.admit(input.signal);
+    const observed = await collectCommand(component, prepared.input.stdin ?? "");
+    await releaseCommand(input, lifecycle, observed.fence);
+    const reason = observed.fence.stopReason;
+    if (!["payload_exit", "cancelled", "deadline"].includes(reason))
+      return failed2("UNCERTAIN", "the command was fenced without a proved command terminal");
+    const value = Object.freeze({
+      candidateDigest: prepared.candidateDigest,
+      command: prepared.input.command,
+      invocation: prepared.invocation,
+      stdinDigest: prepared.stdinDigest,
+      stdout: observed.stdout,
+      stderr: observed.stderr,
+      exitCode: observed.fence.exitCode,
+      signal: observed.fence.signal,
+      stopReason: reason === "payload_exit" ? "exited" : reason,
+      cleanup: "complete"
+    });
+    const details = { command: value };
+    if (input.signal.aborted || reason === "cancelled")
+      return failed2("CANCELLED", "the project command was cancelled", details);
+    if (reason === "deadline")
+      return failed2("DEADLINE_EXCEEDED", "the project command exceeded its deadline", details);
+    return { status: "succeeded", result: { value } };
+  } catch (error49) {
+    try {
+      const row = (await owners(input)).find((row2) => row2.operationId === input.call.operationId && row2.parentOperationId === input.parentFlow?.operationId);
+      if (row !== undefined)
+        await releaseCommand(input, row);
+    } catch (cleanupError) {
+      if (attempted && cleanupError instanceof PrivateLinuxFenceUnconfirmedError)
+        return failed2("UNCERTAIN", "command dispatch may have occurred but fencing is unconfirmed");
+      throw new AggregateError([error49, cleanupError], "project command execution and cleanup failed");
+    }
+    if (input.signal.aborted)
+      return failed2("CANCELLED", "the project command was cancelled");
+    if (Date.now() >= deadlineUnixMs)
+      return failed2("DEADLINE_EXCEEDED", "the project command deadline elapsed");
+    return failed2(attempted ? "UNCERTAIN" : "EXECUTION_FAILED", attempted ? "command dispatch may have occurred but no result was proved" : "project command setup failed before dispatch");
+  } finally {
+    for (const file2 of files)
+      closeSync3(file2.fd);
+  }
+}
+function commandPlan(recipe, prepared, files, identity2, deadlineUnixMs) {
+  const policy = recipe.request.commands[prepared.input.command];
+  const args = "run" in policy ? [
+    ...recipe.bunPolicy,
+    "--cwd",
+    ROOT,
+    `${ROOT}/${policy.run}`,
+    ...prepared.input.args ?? []
+  ] : [
+    "test",
+    ...recipe.bunPolicy,
+    "--cwd",
+    ROOT,
+    ...policy.test.map((path2) => `${ROOT}/${path2}`)
+  ];
+  return {
+    runId: `command-${identity2.slice(0, 40)}`,
+    limits: { ...recipe.resourceCeilings, deadlineUnixMs, cancellationGraceMs: 1000 },
+    readOnlyMounts: recipe.installedSupport.runtimeMounts,
+    capturedInputs: files,
+    inputDirectories: [ROOT],
+    command: [recipe.sandboxExecutablePath, ...args],
+    network: "isolated"
+  };
+}
+async function collectProjectCommandStream(source) {
+  const chunks = [];
+  let retained = 0;
+  let truncated = false;
+  for await (const chunk of source) {
+    const keep = Math.min(chunk.length, PROJECT_COMMAND_LIMITS.streamBytes - retained);
+    if (keep > 0) {
+      chunks.push(Uint8Array.from(chunk.subarray(0, keep)));
+      retained += keep;
+    }
+    if (keep < chunk.length)
+      truncated = true;
+  }
+  return Object.freeze({ text: new TextDecoder().decode(Buffer.concat(chunks)), truncated });
+}
+async function collectCommand(component, stdin) {
+  for (const promise2 of [component.completion, component.evidence, component.terminationReason])
+    promise2.catch(() => {
+      return;
+    });
+  const stdout = collectProjectCommandStream(component.stdout);
+  const stderr = collectProjectCommandStream(component.stderr);
+  const send2 = (async () => {
+    try {
+      if (stdin.length > 0)
+        await component.write(Buffer.from(stdin));
+    } catch (error49) {
+      if (!(error49 instanceof Error && ("code" in error49) && error49.code === "EPIPE"))
+        throw error49;
+    }
+    await component.closeInput();
+  })();
+  try {
+    const [out, err, fence] = await Promise.all([stdout, stderr, component.enforcement, send2]);
+    return { stdout: out, stderr: err, fence };
+  } catch (error49) {
+    await component.terminate().catch(() => {
+      return;
+    });
+    await Promise.allSettled([stdout, stderr, send2, component.enforcement]);
+    throw error49;
+  }
+}
+async function recoverPrivateProjectCommandOwners(input) {
+  for (const owner of await owners(input)) {
+    if (isCommandOwner(owner) && (input.parentFlow === undefined || owner.parentOperationId === input.parentFlow.operationId))
+      await releaseCommand(input, owner);
+  }
+}
+function isCommandOwner(row) {
+  const value = row.allocation.value;
+  return value !== null && typeof value === "object" && !Array.isArray(value) && value.kind === KIND;
+}
+async function releaseCommand(input, row, knownFence) {
+  let lifecycle = row;
+  const allocation = parseAllocation3(row);
+  const parentFlow = allocation.parentFlow;
+  const { parentFlow: _requestedParentFlow, ...rootInput } = input;
+  const context = { ...rootInput, ...parentFlow === null ? {} : { parentFlow } };
+  const target = requireParentTarget(context);
+  const identity2 = commandIdentity(lifecycle.parentRunId, lifecycle.operationId, lifecycle.parentOperationId);
+  if (allocation.parentRunId !== input.parent.run.runId || allocation.coordinatorEpoch !== input.parent.run.coordinatorEpoch || allocation.parentRequestDigest !== target.request.digest || allocation.deadlineUnixMs > input.parent.intent.deadlineUnixMs || !Object.values(target.request.capabilities).some(isProjectCommandContract) || allocation.ownerAllocation.parent !== await protectedOwnerRoot(input.projectRoot) || allocation.ownerAllocation.name !== `x-${identity2.slice(0, 62)}` || input.parentFlow !== undefined && input.parentFlow.operationId !== parentFlow?.operationId)
+    throw new Error("command owner differs from its admitted parent");
+  if (parentFlow !== null)
+    await requireParentFlowOwner(context, parentFlow, allocation.deadlineUnixMs);
+  const key = operationKey(input, lifecycle.operationId, lifecycle.parentOperationId);
+  if (lifecycle.sandbox === undefined) {
+    if (lifecycle.fence !== undefined || lifecycle.cleanup !== undefined)
+      throw new Error("command fence precedes sandbox");
+    const cancelled = await cancelPrivateLinuxOwnerStateAllocation(allocation.ownerAllocation);
+    await releasePrivateLinuxOwnerState(allocation.ownerAllocation, cancelled);
+  } else {
+    const owner = normalizePrivateLinuxSealedOwnerIdentity(lifecycle.sandbox.value);
+    if (owner.ownerStateAllocationDigest !== allocation.ownerAllocation.digest || owner.runId !== `command-${identity2.slice(0, 40)}` || owner.deadlineUnixMs !== allocation.deadlineUnixMs)
+      throw new Error("command sandbox differs from its allocation");
+    const fence = lifecycle.fence === undefined ? knownFence ?? await input.backend.recoverFence(owner) : normalizePrivateLinuxConfirmedEnforcementReceipt(lifecycle.fence.value);
+    normalizePrivateLinuxPreparedOwnerIdentity({
+      kind: "private-linux-prepared-owner/1",
+      digest: fence.ownerDigest,
+      owner
+    });
+    if (lifecycle.fence === undefined)
+      lifecycle = await recordPrivateRootChildFence({
+        ...key,
+        allocationDigest: lifecycle.allocation.digest,
+        sandboxDigest: lifecycle.sandbox.digest,
+        fence
+      });
+    const released = await releasePrivateLinuxOwnerState(owner, fence);
+    if (lifecycle.cleanup === undefined)
+      lifecycle = await recordPrivateRootChildCleanup({
+        ...key,
+        allocationDigest: lifecycle.allocation.digest,
+        sandboxDigest: lifecycle.sandbox.digest,
+        fenceDigest: lifecycle.fence.digest,
+        cleanup: released
+      });
+    else if (normalizePrivateLinuxOwnerStateReleaseReceipt(lifecycle.cleanup.value).digest !== released.digest)
+      throw new Error("command cleanup receipt changed");
+  }
+  await closePrivateRootChildOwner({
+    ...key,
+    allocationDigest: lifecycle.allocation.digest,
+    sandboxDigest: lifecycle.sandbox?.digest ?? null,
+    fenceDigest: lifecycle.fence?.digest ?? null,
+    cleanupDigest: lifecycle.cleanup?.digest ?? null
+  });
+}
+function parseAllocation3(row) {
+  const value = snapshotPrivateOrdinaryJson(row.allocation.value, "command allocation", (message) => new TypeError(message));
+  const fields = [
+    "kind",
+    "parentRunId",
+    "coordinatorEpoch",
+    "operationId",
+    "parentRequestDigest",
+    "parentFlow",
+    "requestDigest",
+    "deadlineUnixMs",
+    "ownerAllocation"
+  ];
+  if (!value || Array.isArray(value) || Object.keys(value).length !== fields.length || fields.some((field) => !Object.hasOwn(value, field)) || value.kind !== KIND || value.parentRunId !== row.parentRunId || value.operationId !== row.operationId || typeof value.coordinatorEpoch !== "number" || !Number.isSafeInteger(value.coordinatorEpoch) || value.coordinatorEpoch < 1 || typeof value.deadlineUnixMs !== "number" || !Number.isSafeInteger(value.deadlineUnixMs) || value.deadlineUnixMs < 0 || typeof value.parentRequestDigest !== "string" || !/^sha256:[0-9a-f]{64}$/.test(value.parentRequestDigest) || typeof value.requestDigest !== "string" || !/^sha256:[0-9a-f]{64}$/.test(value.requestDigest))
+    throw new TypeError("invalid command owner allocation");
+  return {
+    ...value,
+    parentFlow: normalizeParentFlow(value.parentFlow, row.parentOperationId),
+    ownerAllocation: normalizePrivateLinuxOwnerStateAllocationIdentity(value.ownerAllocation)
+  };
+}
+function operationKey(input, operationId, parentOperationId) {
+  return {
+    coordinator: input.coordinator,
+    projectRoot: input.projectRoot,
+    parentRunId: input.parent.run.runId,
+    operationId,
+    ...parentOperationId === undefined ? {} : { parentOperationId }
+  };
+}
+function owners(input) {
+  return listPrivateRootChildOwners({
+    coordinator: input.coordinator,
+    projectRoot: input.projectRoot,
+    parentRunId: input.parent.run.runId
+  });
+}
+function commandIdentity(parentRunId, operationId, parentOperationId) {
+  return privateDomainDigest("JIG-Project-Command-Owner/1", {
+    parentRunId,
+    operationId,
+    parentOperationId: parentOperationId ?? null
+  }).slice(7);
+}
+function failed2(code, message, details) {
+  return { status: "failed", code, message, ...details === undefined ? {} : { details } };
+}
+
 // src/internal/root-flow-call-controller.ts
 var ALLOCATION_KIND3 = "private-root-child-owner-allocation/1";
 var SANDBOX_KIND2 = "private-root-child-sandbox/1";
@@ -60641,13 +61333,13 @@ var CANCELLATION_GRACE_MS2 = 1000;
 async function executePrivateRootFlowCall(input) {
   const selected = selectChild(input.parent, input.call.slot);
   if (selected === undefined) {
-    return failed2("UNAVAILABLE", "the requested slot has no admitted child Flow");
+    return failed3("UNAVAILABLE", "the requested slot has no admitted child Flow");
   }
   if (selected.disposition.state !== "ready") {
-    return failed2("UNAVAILABLE", "the admitted child Flow is unavailable on this host");
+    return failed3("UNAVAILABLE", "the admitted child Flow is unavailable on this host");
   }
   if (input.signal.aborted)
-    return failed2("CANCELLED", "the child Flow call was cancelled");
+    return failed3("CANCELLED", "the child Flow call was cancelled");
   const invalidInput = await validateChildInput(input.packageStoreRoot, selected.request.package, input.call.input);
   if (invalidInput !== undefined)
     return invalidInput;
@@ -60661,14 +61353,14 @@ async function executePrivateRootFlowCall(input) {
       agentProvider: input.agentProvider
     });
   } catch {
-    return failed2("UNAVAILABLE", "the admitted child recipe cannot be reproduced");
+    return failed3("UNAVAILABLE", "the admitted child recipe cannot be reproduced");
   }
   if (recipe.digest !== selected.disposition.recipeDigest || recipe.observation.digest !== selected.disposition.observationDigest) {
-    return failed2("UNAVAILABLE", "the admitted child recipe cannot be reproduced");
+    return failed3("UNAVAILABLE", "the admitted child recipe cannot be reproduced");
   }
   const effectiveDeadlineUnixMs = Math.min(input.parentDeadlineUnixMs, input.parent.intent.deadlineUnixMs, Date.now() + recipe.wallClockCeilingMs);
   if (Date.now() >= effectiveDeadlineUnixMs) {
-    return failed2("DEADLINE_EXCEEDED", "the child Flow deadline elapsed before dispatch");
+    return failed3("DEADLINE_EXCEEDED", "the child Flow deadline elapsed before dispatch");
   }
   const existing = (await listPrivateRootChildOwners({
     coordinator: input.coordinator,
@@ -60677,7 +61369,7 @@ async function executePrivateRootFlowCall(input) {
   })).find(({ operationId, parentOperationId }) => parentOperationId === undefined && operationId === input.call.operationId);
   if (existing !== undefined) {
     await recoverOne(input, existing);
-    return failed2("UNCERTAIN", "a prior child dispatch was fenced without a proved result");
+    return failed3("UNCERTAIN", "a prior child dispatch was fenced without a proved result");
   }
   const roots = await protectedWorkRoots(input.projectRoot);
   const identity2 = childIdentity(input.parent.run.runId, input.call.operationId);
@@ -60714,7 +61406,7 @@ async function executePrivateRootFlowCall(input) {
     });
   } catch (error49) {
     if (error49 instanceof CheckError && error49.code === "RUN_CHILD_CAPACITY") {
-      return failed2("RESOURCE_EXHAUSTED", "the parent Run already has an active child operation");
+      return failed3("RESOURCE_EXHAUSTED", "the parent Run already has an active child operation");
     }
     throw error49;
   }
@@ -60758,25 +61450,25 @@ async function executePrivateRootFlowCall(input) {
         await recoverOne(input, active);
     } catch (cleanupError) {
       if (attemptedDispatch && cleanupError instanceof PrivateLinuxFenceUnconfirmedError) {
-        return failed2("UNCERTAIN", "child dispatch may have occurred but its fence is not yet confirmed");
+        return failed3("UNCERTAIN", "child dispatch may have occurred but its fence is not yet confirmed");
       }
       throw new AggregateError([error49, cleanupError], "child Flow execution and cleanup failed");
     }
     if (input.signal.aborted)
-      return failed2("CANCELLED", "the child Flow call was cancelled");
+      return failed3("CANCELLED", "the child Flow call was cancelled");
     if (Date.now() >= effectiveDeadlineUnixMs) {
-      return failed2("DEADLINE_EXCEEDED", "the child Flow deadline elapsed");
+      return failed3("DEADLINE_EXCEEDED", "the child Flow deadline elapsed");
     }
-    return attemptedDispatch ? failed2("UNCERTAIN", "child dispatch may have occurred but no result was proved") : failed2("EXECUTION_FAILED", "child Flow execution failed before dispatch");
+    return attemptedDispatch ? failed3("UNCERTAIN", "child dispatch may have occurred but no result was proved") : failed3("EXECUTION_FAILED", "child Flow execution failed before dispatch");
   }
 }
 async function recoverPrivateRootFlowCallOwners(input) {
-  const owners = await listPrivateRootChildOwners({
+  const owners2 = await listPrivateRootChildOwners({
     coordinator: input.coordinator,
     projectRoot: input.projectRoot,
     parentRunId: input.parent.run.runId
   });
-  for (const owner of owners) {
+  for (const owner of owners2) {
     if (isPrivateRootFlowCallOwner(owner))
       await recoverOne(input, owner);
   }
@@ -60804,14 +61496,25 @@ function specialistDispatcher(input, selected, parentDeadlineUnixMs) {
     return;
   let active = false;
   return {
-    async callEffect(call, signal) {
-      if (input.agentProvider === undefined) {
-        return failed2("UNAVAILABLE", "the admitted Agent provider is unavailable");
-      }
+    async callCapability(call, signal) {
       if (active)
-        return failed2("RESOURCE_EXHAUSTED", "the specialist already has an active Agent operation");
+        return failed3("RESOURCE_EXHAUSTED", "the specialist already has an active operation");
       active = true;
       try {
+        if (selected.request.capabilities[call.slot]?.digest === PROJECT_COMMAND_CONTRACT_DIGEST)
+          return await executePrivateProjectCommand({
+            ...input,
+            parentFlow: {
+              operationId: input.call.operationId,
+              target: selected.request.target,
+              requestDigest: selected.request.digest
+            },
+            call,
+            parentDeadlineUnixMs,
+            signal
+          });
+        if (input.agentProvider === undefined)
+          return failed3("UNAVAILABLE", "the admitted Agent provider is unavailable");
         return await executePrivateRootAgentRun({
           ...input,
           agentProvider: input.agentProvider,
@@ -60839,7 +61542,7 @@ async function validateChildInput(store, reference, value) {
     } catch (error49) {
       if (!(error49 instanceof SchemaDiagnostic))
         throw error49;
-      return failed2("INVALID_INPUT", "child Flow input does not satisfy its declared schema");
+      return failed3("INVALID_INPUT", "child Flow input does not satisfy its declared schema");
     }
     return;
   } finally {
@@ -60860,9 +61563,9 @@ async function admitOperationResult(store, reference, provisional) {
     return Object.freeze({ status: "succeeded", result: admitted.result });
   }
   if (admitted.code === "PROTOCOL_ERROR" || admitted.code === "CHANNEL_LOST") {
-    return failed2("EXECUTION_FAILED", "the child Flow execution channel failed");
+    return failed3("EXECUTION_FAILED", "the child Flow execution channel failed");
   }
-  return failed2(admitted.code, admitted.message, admitted.details);
+  return failed3(admitted.code, admitted.message, admitted.details);
 }
 async function materializeChild(store, recipe, allocation) {
   const captured = await captureStoredPackage(store, recipe.executionPackage);
@@ -60902,7 +61605,7 @@ function backendPlan2(recipe, packageRoot, identity2, deadlineUnixMs) {
 }
 async function releaseKnownChild(input, lifecycleValue, lease, fence) {
   let lifecycle = lifecycleValue;
-  const selected = await requireAllocationMatchesParent2(input, lifecycle, parseAllocation3(lifecycle));
+  const selected = await requireAllocationMatchesParent2(input, lifecycle, parseAllocation4(lifecycle));
   const sandbox = parseSandbox2(lifecycle);
   lifecycle = await recordPrivateRootChildFence({
     coordinator: input.coordinator,
@@ -60921,6 +61624,14 @@ async function releaseKnownChild(input, lifecycleValue, lease, fence) {
       requestDigest: selected.request.digest
     }
   });
+  await recoverPrivateProjectCommandOwners({
+    ...input,
+    parentFlow: {
+      operationId: lifecycle.operationId,
+      target: selected.request.target,
+      requestDigest: selected.request.digest
+    }
+  });
   await disposePrivatePackageMaterializationLease(lease.identity.allocation.parent.path, lease.identity);
   const ownerRelease = await releasePrivateLinuxOwnerState(sandbox.owner, fence);
   const cleanup = childCleanup(ownerRelease);
@@ -60946,7 +61657,7 @@ async function releaseKnownChild(input, lifecycleValue, lease, fence) {
   });
 }
 async function recoverOne(input, lifecycle) {
-  const allocation = parseAllocation3(lifecycle);
+  const allocation = parseAllocation4(lifecycle);
   const selected = await requireAllocationMatchesParent2(input, lifecycle, allocation);
   if (lifecycle.sandbox === undefined) {
     const cancelled = await cancelPrivateLinuxOwnerStateAllocation(allocation.ownerAllocation);
@@ -60976,6 +61687,14 @@ async function recoverOne(input, lifecycle) {
         requestDigest: selected.request.digest
       }
     });
+    await recoverPrivateProjectCommandOwners({
+      ...input,
+      parentFlow: {
+        operationId: lifecycle.operationId,
+        target: selected.request.target,
+        requestDigest: selected.request.digest
+      }
+    });
     const recovered = await recoverPrivatePackageMaterializationAllocation(allocation.packageAllocation.parent.path, allocation.packageAllocation);
     if (recovered.state === "complete")
       await recovered.lease.dispose();
@@ -61019,7 +61738,7 @@ async function findLifecycle2(input, operationId) {
     parentRunId: input.parent.run.runId
   })).find((item) => item.parentOperationId === undefined && item.operationId === operationId);
 }
-function parseAllocation3(lifecycle) {
+function parseAllocation4(lifecycle) {
   const value = exactObject5(lifecycle.allocation.value, [
     "kind",
     "parentRunId",
@@ -61119,9 +61838,9 @@ function childIdentity(parentRunId, operationId) {
 async function protectedWorkRoots(projectRoot) {
   const state2 = await realpath12(join12(projectRoot, ".jig"));
   const materializations = join12(state2, "private-root-materializations");
-  const owners = join12(state2, "private-root-linux-owners");
-  await Promise.all([ensureProtectedDirectory(materializations), ensureProtectedDirectory(owners)]);
-  return Object.freeze({ materializations, owners });
+  const owners2 = join12(state2, "private-root-linux-owners");
+  await Promise.all([ensureProtectedDirectory(materializations), ensureProtectedDirectory(owners2)]);
+  return Object.freeze({ materializations, owners: owners2 });
 }
 async function ensureProtectedDirectory(path2) {
   await mkdir10(path2, { mode: 448 }).catch((error49) => {
@@ -61148,7 +61867,7 @@ function startupSignal(signal) {
     }
   });
 }
-function failed2(code, message, details) {
+function failed3(code, message, details) {
   return Object.freeze({
     status: "failed",
     code,
@@ -61660,9 +62379,9 @@ async function reacquire(input) {
 async function protectedWorkRoots2(projectRoot) {
   const state2 = await realpath13(join13(projectRoot, ".jig"));
   const materializations = join13(state2, "private-root-materializations");
-  const owners = join13(state2, "private-root-linux-owners");
-  await Promise.all([ensureProtectedDirectory2(materializations), ensureProtectedDirectory2(owners)]);
-  return Object.freeze({ materializations, owners });
+  const owners2 = join13(state2, "private-root-linux-owners");
+  await Promise.all([ensureProtectedDirectory2(materializations), ensureProtectedDirectory2(owners2)]);
+  return Object.freeze({ materializations, owners: owners2 });
 }
 async function ensureProtectedDirectory2(path2) {
   await mkdir11(path2, { mode: 448 }).catch((error49) => {
@@ -61692,9 +62411,9 @@ function parsePlan(value) {
   }
   return Object.freeze({
     kind: PLAN_KIND,
-    requestDigest: digest4(record3.requestDigest, "direct root request"),
-    recipeDigest: digest4(record3.recipeDigest, "direct root recipe"),
-    observationDigest: digest4(record3.observationDigest, "direct root observation"),
+    requestDigest: digest5(record3.requestDigest, "direct root request"),
+    recipeDigest: digest5(record3.recipeDigest, "direct root recipe"),
+    observationDigest: digest5(record3.observationDigest, "direct root observation"),
     activationStartedUnixMs: record3.activationStartedUnixMs,
     effectiveDeadlineUnixMs: record3.effectiveDeadlineUnixMs,
     cancellationGraceMs: record3.cancellationGraceMs,
@@ -61747,7 +62466,7 @@ function exactRecord7(value, keys, label) {
   }
   return value;
 }
-function digest4(value, label) {
+function digest5(value, label) {
   if (typeof value !== "string" || !/^sha256:[0-9a-f]{64}$/.test(value)) {
     throw new TypeError(`${label} digest is invalid`);
   }
@@ -61826,37 +62545,52 @@ function operationInput(input, parent) {
 async function recoverPrivateRootOperationOwners(input) {
   await recoverPrivateRootFlowCallOwners(input);
   await recoverPrivateRootAgentRunOwners(input);
+  await recoverPrivateProjectCommandOwners(input);
 }
 function operationDispatcher(input, parent, parentDeadlineUnixMs) {
   const target = findPrivateActivationCandidateTargetV5(parent.candidate, parent.run.target);
   if (target === undefined)
     return;
   const hasFlows = Object.keys(target.request.flowSlots).length !== 0;
-  const hasAgent = Object.keys(target.request.capabilities).length !== 0;
-  if (!hasFlows && !hasAgent)
+  const hasEffects = Object.keys(target.request.capabilities).length !== 0;
+  if (!hasFlows && !hasEffects)
     return;
-  let active = false;
-  const enter = async (run, unavailable2) => {
-    if (active)
+  let activeFlows = 0;
+  let activeEffect = false;
+  const enter = async (kind, run, unavailable2) => {
+    if (activeEffect || (kind === "effect" ? activeFlows !== 0 : activeFlows >= PRIVATE_ROOT_RESOURCE_POLICY.siblingFlows))
       return unavailable2;
-    active = true;
+    if (kind === "flow")
+      activeFlows++;
+    else
+      activeEffect = true;
     try {
       return await run();
     } finally {
-      active = false;
+      if (kind === "flow")
+        activeFlows--;
+      else
+        activeEffect = false;
     }
   };
   return Object.freeze({
     ...hasFlows ? {
-      callFlow: async (call, signal) => enter(() => executePrivateRootFlowCall({
+      runChildFlow: async (call, signal) => enter("flow", () => executePrivateRootFlowCall({
         ...operationInput(input, parent),
         call,
         parentDeadlineUnixMs,
         signal
       }), operationBusy())
     } : {},
-    ...hasAgent ? {
-      callEffect: async (call, signal) => {
+    ...hasEffects ? {
+      callCapability: async (call, signal) => {
+        if (target.request.capabilities[call.slot]?.digest === PROJECT_COMMAND_CONTRACT_DIGEST)
+          return enter("effect", () => executePrivateProjectCommand({
+            ...operationInput(input, parent),
+            call,
+            parentDeadlineUnixMs,
+            signal
+          }), operationBusy());
         if (input.agentProvider === undefined) {
           return Object.freeze({
             status: "failed",
@@ -61864,7 +62598,7 @@ function operationDispatcher(input, parent, parentDeadlineUnixMs) {
             message: "the admitted Agent provider is unavailable"
           });
         }
-        return enter(() => executePrivateRootAgentRun({
+        return enter("effect", () => executePrivateRootAgentRun({
           ...operationInput(input, parent),
           agentProvider: input.agentProvider,
           call,
@@ -61879,7 +62613,7 @@ function operationBusy() {
   return Object.freeze({
     status: "failed",
     code: "RESOURCE_EXHAUSTED",
-    message: "the parent Run already has an active child operation"
+    message: "the root permits two sibling Flows or one exclusive effect; wait for owned work to settle"
   });
 }
 function terminal(run) {
@@ -62381,7 +63115,7 @@ function scopePrivatePackagePlanningError(error49, packagePath) {
   return new CheckError(error49.kind, error49.code, error49.message, `${packagePath}/${relativePath}`, error49.pointer);
 }
 function isUnavailableDiagnosticCode(code) {
-  return code === "PACKAGE_BUN_SOURCE_UNSUPPORTED" || code === "PACKAGE_BUN_PREPARATION_FAILED" || code === "PROJECT_AGENT_UNAVAILABLE";
+  return code === "PACKAGE_BUN_SOURCE_UNSUPPORTED" || code === "PACKAGE_BUN_PREPARATION_FAILED" || code === "PROJECT_AGENT_UNAVAILABLE" || code === "PROJECT_COMMAND_UNCONFIGURED";
 }
 function isCandidateDiagnosticCode(code) {
   return code.startsWith("CAPABILITY_") || code.startsWith("METADATA_") || code.startsWith("SCHEMA_") || code.startsWith("PACKAGE_BUN_") || code.startsWith("PROJECT_BINDING_") || code.startsWith("PROJECT_DECLARATION_") || code.startsWith("PROJECT_EVALUATION_") || code.startsWith("PROJECT_EVALUATOR_") || code.startsWith("PROJECT_MEMBER_") || code.startsWith("PROJECT_SOURCE_") || [
@@ -62421,7 +63155,7 @@ function hasCode9(error49, code) {
 // src/installed-cli.ts
 var BUN_POLICY5 = Object.freeze(["--no-env-file", "--no-install", "--config=/dev/null"]);
 var installedCliPath = await realpath14(fileURLToPath2(import.meta.url));
-var releaseRoot = dirname10(dirname10(installedCliPath));
+var releaseRoot = dirname9(dirname9(installedCliPath));
 var executablePath = await realpath14(process.execPath);
 if (process.argv[0] !== executablePath || process.argv[1] !== installedCliPath || await realpath14("/proc/self/exe") !== executablePath || process.execArgv.length !== BUN_POLICY5.length || process.execArgv.some((value, index) => value !== BUN_POLICY5[index])) {
   throw new Error("the installed Jig command has an invalid startup posture");