@smartergpt/lexrunner 2.0.2 → 2.2.0

package/dist/cli.js

@@ -24,7 +24,7 @@ import {
   finalizeAudit,
   initAuditEmitter,
   redactSecrets
-} from "./chunk-6PZDSWCG.js";
+} from "./chunk-37UC53OG.js";
 import "./chunk-6KK5JFFE.js";
 import {
   simulateBatchMerges
@@ -32,6 +32,7 @@ import {
 import {
   AutopilotConfigError,
   FileAnalyzer,
+  FrozenGitInputs,
   GATE_EXECUTION_RECEIPT_SCHEMA_VERSION,
   GitHubAuthError,
   GitHubClientImpl,
@@ -75,6 +76,7 @@ import {
   readRunLog,
   readRunState,
   removeIndexEntry,
+  repositoryIdentity,
   resolveProfile,
   resolveSpawnExecutable,
   runEnvironmentQualityCheck,
@@ -83,7 +85,7 @@ import {
   validateWriteOperation,
   verifyToolchainPins,
   writeRunState
-} from "./chunk-ARDKZW7F.js";
+} from "./chunk-M6AAYMHH.js";
 import {
   ExecutionState,
   generateMarkdownSummary,
@@ -135,9 +137,13 @@ import "./chunk-AXOAVRTU.js";
 import {
   __esm,
   __export,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
   __require,
   __toCommonJS
-} from "./chunk-V3BU2VDU.js";
+} from "./chunk-PDDULIDL.js";
 
 // src/metrics/export.ts
 var export_exports = {};
@@ -470,7 +476,7 @@ import "dotenv/config";
 // package.json
 var package_default = {
   name: "@smartergpt/lexrunner",
-  version: "2.0.2",
+  version: "2.2.0",
   type: "module",
   engines: {
     node: ">=24"
@@ -480,13 +486,13 @@ var package_default = {
   description: "Fan-out tasks as multiple PRs in parallel, then build a merge pyramid from the blocks. Compute dependency order, run gates locally, and merge cleanly.",
   repository: {
     type: "git",
-    url: "git+https://github.com/Guffawaffle/lexrunner.git"
+    url: "git+https://github.com/SmarterGPT/lexrunner.git"
   },
   publishConfig: {
-    access: "restricted",
+    access: "public",
     registry: "https://registry.npmjs.org/"
   },
-  license: "SEE LICENSE IN LICENSE.md",
+  license: "Apache-2.0",
   files: [
     "dist/",
     "schemas/",
@@ -495,7 +501,9 @@ var package_default = {
     "README.mcp.md",
     "CHANGELOG.md",
     "NOTICE.md",
-    "LICENSE.md"
+    "LICENSE.md",
+    "GOVERNANCE.md",
+    "BRAND.md"
   ],
   bin: {
     lexrunner: "dist/cli.js",
@@ -571,7 +579,7 @@ var package_default = {
     "docs:surface:check": "node scripts/render-doc-surfaces.mjs --check",
     "dogfood:ecosystem": "tsx scripts/dogfood-ecosystem.ts",
     test: "vitest run",
-    "test:git": "vitest run -c vitest.git.config.ts tests/release-prepare.spec.ts tests/promptsResolver.spec.ts tests/e2e-comprehensive.test.ts tests/autopilot-e2e-level3-4.spec.ts tests/deterministic-build.test.ts tests/e2e-merge-resume.spec.ts",
+    "test:git": "vitest run -c vitest.git.config.ts tests/release-prepare.spec.ts tests/promptsResolver.spec.ts tests/e2e-comprehensive.test.ts tests/autopilot-e2e-level3-4.spec.ts tests/deterministic-build.test.ts tests/e2e-merge-resume.spec.ts tests/e2e-frozen-git-inputs.spec.ts",
     "test:isolation": "node scripts/verify-parallel-isolation.mjs",
     "test:cli:slow": "vitest run -c vitest.slow-cli.config.ts",
     benchmark: "vitest bench -c vitest.benchmark.config.ts",
@@ -649,7 +657,7 @@ var package_default = {
 // src/cli.ts
 import { Command as Command6, CommanderError } from "commander";
 import { fileURLToPath as fileURLToPath6 } from "url";
-import { resolve as resolve14 } from "path";
+import { resolve as resolve15 } from "path";
 import chalk11 from "chalk";
 
 // src/core/inputs.ts
@@ -1106,8 +1114,8 @@ function generateSnapshot(plan, inputs) {
 }
 function getPackageVersion() {
   try {
-    const fs50 = __require("fs");
-    const packageJson = JSON.parse(fs50.readFileSync("package.json", "utf8"));
+    const fs51 = __require("fs");
+    const packageJson = JSON.parse(fs51.readFileSync("package.json", "utf8"));
     return packageJson.version || "unknown";
   } catch {
     return "unknown";
@@ -2432,10 +2440,10 @@ async function promptGitHubToken() {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     rl.question("GitHub token (optional, press Enter to skip): ", (answer) => {
       rl.close();
-      resolve15(answer.trim());
+      resolve16(answer.trim());
     });
   });
 }
@@ -2638,13 +2646,41 @@ function installUnhandledRejectionHandler() {
   unhandledRejectionHandlerInstalled = true;
 }
 
+// src/core/standardGateCommands.ts
+function getStandardGateCommand(gateName) {
+  const commands = {
+    lint: "npm run lint",
+    test: "npm test",
+    unit: "npm test",
+    typecheck: "npm run typecheck",
+    build: "npm run build",
+    format: "npm run format"
+  };
+  if (!Object.prototype.hasOwnProperty.call(commands, gateName)) {
+    throw new Error(
+      `No executable command is defined for gate ${JSON.stringify(gateName)}. Author an explicit gate run command in a manual plan, or select a supported standard gate.`
+    );
+  }
+  return commands[gateName];
+}
+
 // src/core/githubPlan.ts
 var STANDARD_TEST_GATE_TIMEOUT_MS = 5 * 60 * 1e3;
 async function generatePlanFromGitHub(client, options = {}) {
   const repoInfo = await client.validateRepository();
   const target = options.target || repoInfo.defaultBranch;
+  const targetCommit = await client.getBranchHead(target);
+  const gitInputs = {
+    schemaVersion: "1.0.0",
+    repository: `${repoInfo.url.replace(/\/$/, "").replace(/\.git$/, "")}.git`,
+    checkoutRemote: "origin",
+    acquisition: options.gitAcquisition ?? "fetch",
+    target: { ref: `refs/heads/${target}`, commit: targetCommit },
+    sources: []
+  };
   const prs = await client.listOpenPRs({
     state: "open",
+    base: target,
     labels: options.labels,
     // If no specific query, find PRs with stack labels or open PRs
     ...options.query ? { query: options.query } : {}
@@ -2655,8 +2691,9 @@ async function generatePlanFromGitHub(client, options = {}) {
   const finalPRs = excludePRs.length > 0 ? filteredPRs.filter((pr) => !excludePRs.includes(pr.number)) : filteredPRs;
   if (finalPRs.length === 0) {
     const emptyPlan = {
-      schemaVersion: "1.0.0",
+      schemaVersion: "1.0.1",
       target,
+      gitInputs,
       items: []
     };
     if (options.policy) {
@@ -2670,15 +2707,28 @@ async function generatePlanFromGitHub(client, options = {}) {
         mergeRule: { type: "strict-required" }
       };
     }
-    return emptyPlan;
+    return Plan.parse(emptyPlan);
   }
   const prDetails = await Promise.all(finalPRs.map((pr) => client.getPRDetails(pr.number)));
-  const planItems = prDetails.map((pr) => transformPRToPlanItem(pr, options));
+  if (prDetails.some((pr) => pr.base.ref !== target)) {
+    throw new Error(
+      "Selected PR targets a different branch; refresh discovery for the intended target"
+    );
+  }
+  const planItems = prDetails.map(
+    (pr) => transformPRToPlanItem(pr, options, `${repoInfo.owner}/${repoInfo.repo}`)
+  );
+  gitInputs.sources = prDetails.map((pr) => ({
+    item: `PR-${pr.number}`,
+    ref: `refs/pull/${pr.number}/head`,
+    commit: pr.head.sha
+  })).sort((a, b) => a.item.localeCompare(b.item));
   planItems.sort((a, b) => a.name.localeCompare(b.name));
   validateGitHubDependencies(planItems, prDetails);
   const plan = {
-    schemaVersion: "1.0.0",
+    schemaVersion: "1.0.1",
     target,
+    gitInputs,
     items: planItems
   };
   if (options.policy) {
@@ -2692,12 +2742,18 @@ async function generatePlanFromGitHub(client, options = {}) {
       mergeRule: { type: "strict-required" }
     };
   }
-  return plan;
+  return Plan.parse(plan);
 }
-function transformPRToPlanItem(pr, options) {
+function transformPRToPlanItem(pr, options, repository) {
   const name = `PR-${pr.number}`;
   const deps = pr.dependencies.filter((dep) => {
-    return dep.includes("#");
+    const match = /^(?:([^#]+))?#([1-9][0-9]*)$/.exec(dep);
+    if (!match || match[1] && match[1].toLowerCase() !== repository.toLowerCase()) {
+      throw new Error(
+        `Dependency ${JSON.stringify(dep)} is outside this single-repository plan; declare a valid repository-bound dependency`
+      );
+    }
+    return true;
   }).map((dep) => {
     const prNumber = dep.includes("#") ? dep.split("#")[1] : dep;
     return `PR-${prNumber}`;
@@ -2732,47 +2788,7 @@ function createStandardGate(gateName, pr) {
     runtime: "local",
     artifacts: []
   };
-  switch (gateName) {
-    case "lint":
-      return {
-        ...baseGate,
-        run: "npm run lint",
-        artifacts: ["lint-results.txt"]
-      };
-    case "test":
-    case "unit":
-      return {
-        ...baseGate,
-        run: "npm test",
-        artifacts: ["test-results.xml", "coverage/"],
-        timeoutMs: STANDARD_TEST_GATE_TIMEOUT_MS
-      };
-    case "typecheck":
-      return {
-        ...baseGate,
-        run: "npm run typecheck",
-        artifacts: ["typecheck-results.txt"]
-      };
-    case "build":
-      return {
-        ...baseGate,
-        run: "npm run build",
-        artifacts: ["dist/", "build-log.txt"]
-      };
-    default:
-      return baseGate;
-  }
-}
-function getStandardGateCommand(gateName) {
-  const standardCommands = {
-    lint: "npm run lint",
-    test: "npm test",
-    unit: "npm test",
-    typecheck: "npm run typecheck",
-    build: "npm run build",
-    format: "npm run format"
-  };
-  return standardCommands[gateName] || `echo "Running ${gateName} gate"`;
+  return gateName === "test" || gateName === "unit" ? { ...baseGate, timeoutMs: STANDARD_TEST_GATE_TIMEOUT_MS } : baseGate;
 }
 function validateGitHubDependencies(planItems, prDetails) {
   const itemNames = new Set(planItems.map((item) => item.name));
@@ -2922,7 +2938,7 @@ function generateGatesForMultiRepoPR(pr, options) {
   for (const gateName of requiredGates) {
     gates.push({
       name: gateName,
-      run: getGateCommand(gateName),
+      run: getStandardGateCommand(gateName),
       env: {
         PR_NUMBER: pr.number.toString(),
         PR_BRANCH: pr.head.ref,
@@ -2931,33 +2947,13 @@ function generateGatesForMultiRepoPR(pr, options) {
         REPO_NAME: pr.repoName
       },
       runtime: "local",
-      artifacts: getGateArtifacts(gateName),
+      artifacts: [],
       ...isStandardTestGate(gateName) ? { timeoutMs: STANDARD_TEST_GATE_TIMEOUT_MS2 } : {}
     });
   }
   gates.sort((a, b) => a.name.localeCompare(b.name));
   return gates;
 }
-function getGateCommand(gateName) {
-  const commands = {
-    lint: "npm run lint",
-    test: "npm test",
-    unit: "npm test",
-    typecheck: "npm run typecheck",
-    build: "npm run build"
-  };
-  return commands[gateName] || `echo "Running ${gateName}"`;
-}
-function getGateArtifacts(gateName) {
-  const artifacts = {
-    lint: ["lint-results.txt"],
-    test: ["test-results.xml", "coverage/"],
-    unit: ["test-results.xml", "coverage/"],
-    typecheck: ["typecheck-results.txt"],
-    build: ["dist/"]
-  };
-  return artifacts[gateName] || [];
-}
 function isStandardTestGate(gateName) {
   return gateName === "test" || gateName === "unit";
 }
@@ -3404,8 +3400,8 @@ function containedRegularFile(root, candidate) {
   }
 }
 function isContained(root, candidate) {
-  const relative3 = path8.relative(path8.resolve(root), path8.resolve(candidate));
-  return relative3 !== ".." && !relative3.startsWith(`..${path8.sep}`) && !path8.isAbsolute(relative3);
+  const relative5 = path8.relative(path8.resolve(root), path8.resolve(candidate));
+  return relative5 !== ".." && !relative5.startsWith(`..${path8.sep}`) && !path8.isAbsolute(relative5);
 }
 function evidenceError(code, message) {
   return new GateEvidenceServiceError(code, message);
@@ -3485,6 +3481,7 @@ var IntegrationStatusQueryService = class {
         schemaVersion: validated.schemaVersion,
         target: bounded(validated.target),
         itemCount: validated.items.length,
+        gitInputBinding: validated.gitInputs ? "frozen" : "legacy-unbound",
         ...validated.policy ? { policy: validated.policy } : {}
       },
       mergeSummary: evaluator.getMergeSummary(),
@@ -4528,7 +4525,7 @@ function registerGateImportChecksCommand(program2) {
           version: "1.0.0",
           mappings: []
         };
-        const { DEFAULT_GATE_MAPPINGS } = await import("./gateMapping-R3RJYKMS.js");
+        const { DEFAULT_GATE_MAPPINGS } = await import("./gateMapping-V4DTL5WD.js");
         mappingConfig.mappings = DEFAULT_GATE_MAPPINGS;
       }
       let githubClient;
@@ -4841,11 +4838,11 @@ function isTestFile(file) {
 }
 function directOwnerCandidates(file) {
   if (!file.startsWith("src/") || !/\.[cm]?tsx?$/.test(file)) return [];
-  const relative3 = file.replace(/^src\//, "").replace(/\.[cm]?tsx?$/, "");
-  const basename4 = path12.posix.basename(relative3);
+  const relative5 = file.replace(/^src\//, "").replace(/\.[cm]?tsx?$/, "");
+  const basename4 = path12.posix.basename(relative5);
   return [
-    `tests/${relative3}.spec.ts`,
-    `tests/${relative3}.test.ts`,
+    `tests/${relative5}.spec.ts`,
+    `tests/${relative5}.test.ts`,
     `tests/${basename4}.spec.ts`,
     `tests/${basename4}.test.ts`
   ];
@@ -6071,10 +6068,10 @@ async function readInput(inputPath) {
     }
     return fs17.readFileSync(inputPath, "utf-8");
   } else {
-    return new Promise((resolve15, reject) => {
+    return new Promise((resolve16, reject) => {
       const chunks = [];
       process.stdin.on("data", (chunk) => chunks.push(chunk));
-      process.stdin.on("end", () => resolve15(Buffer.concat(chunks).toString("utf-8")));
+      process.stdin.on("end", () => resolve16(Buffer.concat(chunks).toString("utf-8")));
       process.stdin.on("error", reject);
     });
   }
@@ -6711,20 +6708,20 @@ async function registerSecurityCommands(program2) {
   program2.command("security").description("Security operations: token rotation, secrets scanning, validation").addCommand(
     new Command3("check-rotation").description("Check if secrets need rotation based on age").argument("[secrets...]", "Secret IDs to check (without LEX_PR_ prefix)", ["GITHUB_TOKEN"]).option("--max-age <days>", "Maximum age in days before rotation needed", "90").option("--format <format>", "Output format: text or json", "text").option("--no-color", "Disable ANSI colors in text output").action(
       async (secretIds, opts) => {
-        const { checkRotation } = await import("./security-OE4VLUFK.js");
+        const { checkRotation } = await import("./security-W7TOUXSB.js");
         const result = await checkRotation(secretIds, parseInt(opts.maxAge));
         outputSecurityResult("check-rotation", result, opts.format, opts.color !== false);
       }
     )
   ).addCommand(
     new Command3("scan-plan").description("Scan plan file for accidentally exposed secrets").argument("[plan-file]", "Path to plan file", "plan.json").option("--format <format>", "Output format: text or json", "text").option("--no-color", "Disable ANSI colors in text output").action(async (planFile, opts) => {
-      const { scanPlan } = await import("./security-OE4VLUFK.js");
+      const { scanPlan } = await import("./security-W7TOUXSB.js");
       const result = await scanPlan(planFile);
       outputSecurityResult("scan-plan", result, opts.format, opts.color !== false);
     })
   ).addCommand(
     new Command3("validate-secrets").description("Validate that required secrets are present").argument("<secrets...>", "Required secret IDs (without LEX_PR_ prefix)").option("--format <format>", "Output format: text or json", "text").option("--no-color", "Disable ANSI colors in text output").action(async (secretIds, opts) => {
-      const { validateSecrets } = await import("./security-OE4VLUFK.js");
+      const { validateSecrets } = await import("./security-W7TOUXSB.js");
       const result = await validateSecrets(secretIds);
       outputSecurityResult("validate-secrets", result, opts.format, opts.color !== false);
     })
@@ -6765,7 +6762,7 @@ function outputAuditResult(command, result, format, color) {
 async function registerAuditCommands(program2) {
   program2.command("audit").description("Audit operations: signature verification, manifest validation").addCommand(
     new Command4("verify").description("Verify audit manifest signature").argument("[manifest-file]", "Path to audit manifest file", "audit-manifest.json").option("--format <format>", "Output format: text or json", "text").option("--no-color", "Disable ANSI colors in text output").action(async (manifestFile, opts) => {
-      const { verifyCommand } = await import("./verify-3UVMA62I.js");
+      const { verifyCommand } = await import("./verify-Y34CJAKB.js");
       const result = await verifyCommand(manifestFile);
       outputAuditResult("verify", result, opts.format, opts.color !== false);
     })
@@ -8387,8 +8384,8 @@ Details:`);
       if (opts.json || deps.jsonModeActive()) {
         const output = JSON.stringify(plan, null, 2);
         if (opts.output) {
-          const fs50 = await import("fs/promises");
-          await fs50.writeFile(opts.output, output, "utf-8");
+          const fs51 = await import("fs/promises");
+          await fs51.writeFile(opts.output, output, "utf-8");
           console.log(`Plan written to: ${opts.output}`);
         } else {
           console.log(output);
@@ -8411,8 +8408,8 @@ Details:`);
           console.log(`     ${phase}: ${count}`);
         }
         if (opts.output) {
-          const fs50 = await import("fs/promises");
-          await fs50.writeFile(opts.output, JSON.stringify(plan, null, 2), "utf-8");
+          const fs51 = await import("fs/promises");
+          await fs51.writeFile(opts.output, JSON.stringify(plan, null, 2), "utf-8");
           console.log(`
 Plan written to: ${opts.output}`);
         }
@@ -8664,8 +8661,8 @@ function registerHarvestCommand(fanoutCommand) {
       });
       const output = JSON.stringify(harvestBundle, null, 2);
       if (opts.output) {
-        const fs50 = await import("fs/promises");
-        await fs50.writeFile(opts.output, output, "utf-8");
+        const fs51 = await import("fs/promises");
+        await fs51.writeFile(opts.output, output, "utf-8");
         console.error(`\u2713 Harvest bundle written to ${opts.output}`);
         console.error(`  ${harvestBundle.bundle.pullRequests.length} PRs`);
         console.error(`  ${harvestBundle.bundle.issues.length} issues`);
@@ -9054,10 +9051,10 @@ function analyzeBundle(harvest) {
 function registerAnalyzeCommand(fanoutCommand) {
   fanoutCommand.command("analyze").description("D1: Analyze harvest bundle into facts pool (deterministic)").option("--input <file>", "Path to harvest bundle JSON file (default: stdin)").option("--json", "Output JSON format (default)").option("--output <file>", "Write output to file").action(async (opts) => {
     try {
-      const fs50 = await import("fs/promises");
+      const fs51 = await import("fs/promises");
       let content;
       if (opts.input) {
-        content = await fs50.readFile(opts.input, "utf-8");
+        content = await fs51.readFile(opts.input, "utf-8");
       } else {
         const chunks = [];
         for await (const chunk of process.stdin) {
@@ -9099,7 +9096,7 @@ function registerAnalyzeCommand(fanoutCommand) {
       const analysisPool = analyzeBundle(harvest);
       const output = JSON.stringify(analysisPool, null, 2);
       if (opts.output) {
-        await fs50.writeFile(opts.output, output, "utf-8");
+        await fs51.writeFile(opts.output, output, "utf-8");
         console.error(`\u2713 Analysis pool written to ${opts.output}`);
         console.error(`  ${analysisPool.pool.entities.length} entities`);
         console.error(`  ${analysisPool.pool.relations.length} relations`);
@@ -9196,9 +9193,9 @@ var DEFAULT_FANOUT_TEMPLATES_PATHS = [
   "fanout-templates.yml"
 ];
 var FanoutTemplatesLoadError = class extends Error {
-  constructor(message, path59, cause) {
+  constructor(message, path60, cause) {
     super(message);
-    this.path = path59;
+    this.path = path60;
     this.cause = cause;
     this.name = "FanoutTemplatesLoadError";
   }
@@ -9529,7 +9526,7 @@ function registerFanoutCommands(weaveCommand) {
     }
   });
   fanout.command("validate").description("Validate fanout templates file").option("-f, --file <path>", "Path to templates file").action(async (options) => {
-    const fs50 = await import("fs/promises");
+    const fs51 = await import("fs/promises");
     try {
       let filePath;
       if (options.file) {
@@ -9542,7 +9539,7 @@ function registerFanoutCommands(weaveCommand) {
         }
         filePath = result2.path;
       }
-      const content = await fs50.readFile(filePath, "utf-8");
+      const content = await fs51.readFile(filePath, "utf-8");
       const result = validateFanoutTemplatesContent(content);
       if (result.valid) {
         console.log(`\u2713 Valid: ${filePath}`);
@@ -10013,6 +10010,70 @@ import { join as join15 } from "path";
 import { simpleGit as simpleGit2 } from "simple-git";
 import { ulid } from "ulid";
 
+// src/git/frozen-inputs.ts
+var FrozenGitInputError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FrozenGitInputError";
+  }
+};
+async function verifyFrozenGitInputs(git2, value) {
+  const inputs = FrozenGitInputs.parse(value);
+  let remote;
+  try {
+    remote = (await git2.raw(["remote", "get-url", inputs.checkoutRemote])).trim();
+    if (repositoryIdentity(remote) !== repositoryIdentity(inputs.repository)) throw new Error();
+  } catch {
+    throw new FrozenGitInputError(
+      "Checkout repository does not match gitInputs; use the declared checkout"
+    );
+  }
+  const resolve16 = async (input) => {
+    let ref = input.ref;
+    if (inputs.acquisition === "fetch") {
+      ref = `refs/lexrunner/inputs/${sha256(Buffer.from(`${inputs.repository}
+${input.ref}
+${input.commit}`))}`;
+      try {
+        await git2.raw([
+          "fetch",
+          "--no-tags",
+          "--no-recurse-submodules",
+          "--no-write-fetch-head",
+          "--",
+          inputs.repository,
+          `+${input.ref}:${ref}`
+        ]);
+      } catch {
+        throw new FrozenGitInputError(
+          `Declared acquisition failed for ${input.ref}; restore access and retry without changing frozen expectations`
+        );
+      }
+    }
+    let observed;
+    try {
+      observed = (await git2.raw(["rev-parse", "--verify", ref])).trim();
+    } catch {
+      throw new FrozenGitInputError(
+        `Declared ref ${input.ref} is unavailable; explicitly acquire it or create a new plan permitting fetch`
+      );
+    }
+    if (observed !== input.commit) {
+      throw new FrozenGitInputError(
+        `Stale Git input ${input.ref}; reassess and generate a new plan instead of replacing its expected commit`
+      );
+    }
+    if ((await git2.raw(["cat-file", "-t", input.commit])).trim() !== "commit") {
+      throw new FrozenGitInputError(`Declared input ${input.ref} is not a commit object`);
+    }
+    return observed;
+  };
+  const targetHeadSha = await resolve16(inputs.target);
+  const sourceHeads = /* @__PURE__ */ Object.create(null);
+  for (const source of inputs.sources) sourceHeads[source.item] = await resolve16(source);
+  return { targetHeadSha, sourceHeads };
+}
+
 // src/weave/resume-service.ts
 import { z as z7 } from "zod";
 async function resumePersistedWeave(input) {
@@ -10161,6 +10222,15 @@ function validateResumeJournal(checkpoint) {
     };
   }
   const ids = /* @__PURE__ */ new Set();
+  const inputs = parsedPlan.data.gitInputs;
+  if (inputs && journal.repository.integrationBranch !== `weave/resume-${checkpoint.runId.toLowerCase()}`) {
+    return { valid: false, reason: "checkpoint integration branch does not match its bound run" };
+  }
+  if (inputs && (inputs.target.commit !== journal.repository.targetHeadSha || inputs.sources.some(
+    (source) => source.commit !== journal.repository.sourceHeads[source.item]
+  ))) {
+    return { valid: false, reason: "checkpoint commits do not match the plan's frozen Git inputs" };
+  }
   let seenIncomplete = false;
   for (const operation of journal.operations) {
     if (!operation.id || ids.has(operation.id)) {
@@ -10326,11 +10396,22 @@ async function createLocalResumeCheckpoint(input) {
   const runId = input.runId ?? ulid();
   const at = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
   const levels = computeMergeOrder(input.plan);
-  const sourceHeads = {};
-  for (const item of input.plan.items) {
-    sourceHeads[item.name] = await exactRefHead(git2, item.name);
+  Plan.parse(input.plan);
+  const sourceHeads = /* @__PURE__ */ Object.create(null);
+  let targetHeadSha;
+  if (input.plan.gitInputs) {
+    const status = await git2.status();
+    if (status.files.some(isUnexpectedBoundChange)) {
+      throw new Error("Working tree must be clean before acquiring frozen Git inputs");
+    }
+    const verified = await verifyFrozenGitInputs(git2, input.plan.gitInputs);
+    Object.assign(sourceHeads, verified.sourceHeads);
+    targetHeadSha = verified.targetHeadSha;
+  } else {
+    for (const item of input.plan.items)
+      sourceHeads[item.name] = await exactRefHead(git2, item.name);
+    targetHeadSha = await exactRefHead(git2, input.plan.target);
   }
-  const targetHeadSha = await exactRefHead(git2, input.plan.target);
   const integrationBranch = `weave/resume-${runId.toLowerCase()}`;
   const operations = planResumeOperations(input.plan);
   const planHash = sha256(Buffer.from(canonicalJSONStringify(input.plan)));
@@ -10352,7 +10433,7 @@ async function createLocalResumeCheckpoint(input) {
     lastUpdatedAt: at,
     metadata: {
       target: input.plan.target,
-      warnings: [],
+      warnings: input.plan.gitInputs ? [] : ["Legacy unbound plan: Git heads are selected at preparation, not frozen at synthesis"],
       resume: createResumeJournal({
         operations,
         target: input.plan.target,
@@ -10374,23 +10455,34 @@ var LocalWeaveResumeDriver = class {
     if (!journal) return { valid: false, reason: "resume journal is missing" };
     try {
       const status = await this.git.status();
-      const unexpectedChanges = status.files.filter((file) => !isRunnerStatePath(file.path));
+      const unexpectedChanges = status.files.filter(
+        checkpoint.plan.gitInputs ? isUnexpectedBoundChange : (file) => !isRunnerStatePath(file.path)
+      );
       if (unexpectedChanges.length > 0) {
         return {
           valid: false,
           reason: "working tree is not clean; resolve or abort the interrupted operation first"
         };
       }
-      const targetHead = await exactRefHead(this.git, journal.repository.target);
-      if (targetHead !== journal.repository.targetHeadSha) {
-        return { valid: false, reason: "target branch changed after the checkpoint was created" };
-      }
-      for (const [name, expected] of Object.entries(journal.repository.sourceHeads)) {
-        if (await exactRefHead(this.git, name) !== expected) {
-          return {
-            valid: false,
-            reason: `source branch ${name} changed after checkpoint creation`
-          };
+      if (checkpoint.plan.gitInputs) {
+        const verified = await verifyFrozenGitInputs(this.git, checkpoint.plan.gitInputs);
+        if (verified.targetHeadSha !== journal.repository.targetHeadSha || Object.entries(verified.sourceHeads).some(
+          ([name, commit]) => journal.repository.sourceHeads[name] !== commit
+        )) {
+          return { valid: false, reason: "Journal commit evidence differs from frozen Git inputs" };
+        }
+      } else {
+        const targetHead = await exactRefHead(this.git, journal.repository.target);
+        if (targetHead !== journal.repository.targetHeadSha) {
+          return { valid: false, reason: "target branch changed after the checkpoint was created" };
+        }
+        for (const [name, expected] of Object.entries(journal.repository.sourceHeads)) {
+          if (await exactRefHead(this.git, name) !== expected) {
+            return {
+              valid: false,
+              reason: `source branch ${name} changed after checkpoint creation`
+            };
+          }
         }
       }
       const integrationHead = await localBranchHead(this.git, journal.repository.integrationBranch);
@@ -10441,29 +10533,66 @@ var LocalWeaveResumeDriver = class {
   }
   async execute(operation, checkpoint) {
     const journal = checkpoint.metadata.resume;
+    const bound4 = !!checkpoint.plan.gitInputs;
+    const expectedIntegration = lastCompletedMergeSha(journal.operations) ?? journal.repository.targetHeadSha;
+    if (bound4) {
+      const stateError = await this.boundStateError();
+      if (stateError) return { completed: false, reason: stateError };
+      const integrationHead = await localBranchHead(this.git, journal.repository.integrationBranch);
+      if (integrationHead && integrationHead !== expectedIntegration || !integrationHead && lastCompletedMergeSha(journal.operations)) {
+        return {
+          completed: false,
+          reason: "Frozen integration branch changed before operation; preserve and inspect it"
+        };
+      }
+    }
     await this.ensureIntegrationBranch(
       journal.repository.integrationBranch,
       journal.repository.targetHeadSha
     );
     if (operation.phase === "merge") {
       await this.git.checkout(journal.repository.integrationBranch);
+      if (bound4) {
+        const stateError = await this.boundStateError(expectedIntegration);
+        if (stateError) return { completed: false, reason: stateError };
+      }
       const item = checkpoint.plan.items.find((candidate) => candidate.name === operation.item);
       if (!item) return { completed: false, reason: "plan item is missing" };
       const result2 = await this.operations.executeMergeOperation({
         item,
         targetBranch: journal.repository.integrationBranch,
-        strategy: "merge-weave"
+        strategy: "merge-weave",
+        ...checkpoint.plan.gitInputs ? { sourceCommit: journal.repository.sourceHeads[operation.item] } : {}
       });
+      if (bound4 && result2.success && result2.sha) {
+        const stateError = await this.boundStateError(result2.sha);
+        if (stateError) return { completed: false, reason: stateError };
+      }
       return result2.success && result2.sha ? { completed: true, externalId: result2.sha } : { completed: false, reason: result2.message ?? "merge failed" };
     }
     const gate = gateForOperation(checkpoint.plan, operation);
     if (!gate) return { completed: false, reason: "gate definition is missing" };
     if (operation.phase === "gate") {
-      await this.git.checkout(`origin/${operation.item}`).catch(() => this.git.checkout(operation.item));
+      if (checkpoint.plan.gitInputs) {
+        await this.git.checkout(["--detach", journal.repository.sourceHeads[operation.item]]);
+      } else {
+        await this.git.checkout(`origin/${operation.item}`).catch(() => this.git.checkout(operation.item));
+      }
     } else {
       await this.git.checkout(journal.repository.integrationBranch);
     }
-    const artifactDir = join15(this.workingDir, ".lexrunner", "runs", checkpoint.runId, "gates");
+    const expectedGateHead = operation.phase === "gate" ? journal.repository.sourceHeads[operation.item] : expectedIntegration;
+    if (bound4) {
+      const stateError = await this.boundStateError(expectedGateHead);
+      if (stateError) return { completed: false, reason: stateError };
+    }
+    const artifactDir = join15(
+      this.workingDir,
+      ".lexrunner",
+      "runs",
+      checkpoint.runId,
+      operation.phase
+    );
     await mkdir2(artifactDir, { recursive: true });
     const policy = Policy.parse(checkpoint.plan.policy ?? {});
     const result = await executeGate(
@@ -10475,12 +10604,38 @@ var LocalWeaveResumeDriver = class {
       false,
       this.workingDir
     );
-    return result.status === "pass" ? { completed: true, externalId: `${gate.name}:${result.lastAttempt ?? "pass"}` } : { completed: false, reason: result.stderr || `gate ${gate.name} failed` };
+    if (bound4) {
+      const stateError = await this.boundStateError(expectedGateHead);
+      if (stateError) return { completed: false, reason: stateError };
+      if (await localBranchHead(this.git, journal.repository.integrationBranch) !== expectedIntegration) {
+        return {
+          completed: false,
+          reason: "Gate changed the frozen integration branch; preserve and inspect it"
+        };
+      }
+    }
+    const receipt = result.artifacts?.find(
+      (path60) => /gate-execution-receipt\.attempt-\d+\.json$/.test(path60)
+    );
+    return result.status === "pass" ? {
+      completed: true,
+      externalId: receipt ?? `${gate.name}:${result.lastAttempt ?? "pass"}`
+    } : { completed: false, reason: result.stderr || `gate ${gate.name} failed` };
   }
   async ensureIntegrationBranch(branch, targetHeadSha) {
     if (await localBranchHead(this.git, branch)) return;
     await this.git.checkoutBranch(branch, targetHeadSha);
   }
+  async boundStateError(expectedHead) {
+    if (expectedHead && (await this.git.revparse(["HEAD"])).trim() !== expectedHead) {
+      return "Frozen checkout HEAD changed during the operation; preserve and inspect the new commit";
+    }
+    const status = await this.git.status();
+    if (status.files.some(isUnexpectedBoundChange)) {
+      return "Frozen checkout index or working tree changed; preserve and inspect the modifications before continuing";
+    }
+    return null;
+  }
 };
 function gateForOperation(plan, operation) {
   const parts = operation.id.split(":");
@@ -10523,8 +10678,11 @@ function lastCompletedMergeSha(operations) {
     (operation) => operation.phase === "merge" && operation.status === "completed" && operation.result?.externalId
   )?.result?.externalId;
 }
-function isRunnerStatePath(path59) {
-  return path59 === ".lexrunner" || path59.startsWith(".lexrunner/") || path59 === "weave-lock.json" || path59.endsWith("/weave-lock.json");
+function isRunnerStatePath(path60) {
+  return path60 === ".lexrunner" || path60.startsWith(".lexrunner/") || path60 === "weave-lock.json" || path60.endsWith("/weave-lock.json");
+}
+function isUnexpectedBoundChange(file) {
+  return !(file.index === "?" && file.working_dir === "?" && isRunnerStatePath(file.path));
 }
 
 // src/commands/weave.ts
@@ -10532,6 +10690,7 @@ import fs22 from "fs";
 import path15 from "path";
 
 // src/application/merge-application-service.ts
+import { join as join16 } from "path";
 var MAX_OPERATIONS = 256;
 var MAX_LABEL_BYTES2 = 512;
 var MAX_RESULT_BYTES2 = 256 * 1024;
@@ -10558,6 +10717,7 @@ var MergeApplicationService = class {
           ok: true,
           status: "preview",
           totalItems: input.plan.items.length,
+          gitInputBinding: input.plan.gitInputs ? "frozen" : "legacy-unbound",
           levels,
           maxParallelism: levels.length === 0 ? 0 : Math.max(...levels.map((level) => level.length)),
           artifactRefs: []
@@ -10579,10 +10739,10 @@ var MergeApplicationService = class {
     let runId;
     try {
       runId = await this.runtime.prepare(input.plan, input.workingDir);
-    } catch {
+    } catch (error) {
       throw new MergeApplicationServiceError(
         "MERGE_STALE_INPUT",
-        "Merge input could not be bound to current source and target heads"
+        error instanceof FrozenGitInputError ? error.message : "Merge input could not be bound to current source and target heads"
       );
     }
     return this.executePrepared({ plan: input.plan, workingDir: input.workingDir, runId });
@@ -10612,6 +10772,7 @@ var MergeApplicationService = class {
       ok: completed,
       status: execution.result.ok ? execution.result.outcome : "failed",
       totalItems: input.plan.items.length,
+      gitInputBinding: input.plan.gitInputs ? "frozen" : "legacy-unbound",
       runId: bound2(input.runId),
       operations: execution.operations.map((operation) => ({
         id: bound2(operation.id),
@@ -10632,15 +10793,22 @@ var LocalMergeApplicationRuntime = class {
   }
   async prepare(plan, workingDir) {
     const checkpoint = await createLocalResumeCheckpoint({ plan, workingDir });
-    await saveCheckpoint(checkpoint, { skipCleanup: true });
+    await saveCheckpoint(checkpoint, {
+      checkpointDir: join16(workingDir, ".lexrunner", "checkpoints"),
+      skipCleanup: true
+    });
     return checkpoint.runId;
   }
   async resume(runId, workingDir) {
     const result = await resumePersistedWeave({
       runId,
+      checkpointDir: join16(workingDir, ".lexrunner", "checkpoints"),
       driver: new LocalWeaveResumeDriver(workingDir)
     });
-    const checkpoint = await loadCheckpoint(runId, { validatePlanHash: false });
+    const checkpoint = await loadCheckpoint(runId, {
+      checkpointDir: join16(workingDir, ".lexrunner", "checkpoints"),
+      validatePlanHash: false
+    });
     return { result, operations: checkpoint.metadata?.resume?.operations ?? [] };
   }
 };
@@ -10936,7 +11104,7 @@ async function runWeaveApply(opts, deps) {
       if (json2) {
         const output = { ...preview.summary };
         if (showConstraints) {
-          const { previewConstraints: previewConstraints2 } = await import("./constraints-2ZK5FJFA.js");
+          const { previewConstraints: previewConstraints2 } = await import("./constraints-LE2MW5NS.js");
           output.constraints = await previewConstraints2(plan);
         }
         console.log(canonicalJSONStringify(output));
@@ -10946,13 +11114,17 @@ async function runWeaveApply(opts, deps) {
 \u{1F50D} Merge-Weave Dry Run
 `);
       if (showConstraints) {
-        const { previewConstraints: previewConstraints2, formatConstraintPreview: formatConstraintPreview2 } = await import("./constraints-2ZK5FJFA.js");
+        const { previewConstraints: previewConstraints2, formatConstraintPreview: formatConstraintPreview2 } = await import("./constraints-LE2MW5NS.js");
         console.log(formatConstraintPreview2(await previewConstraints2(plan)));
       }
       console.log(`Plan: ${opts.plan}`);
       console.log(`Items: ${plan.items.length}`);
       console.log(`Target: ${plan.target}
 `);
+      console.log(
+        `Git inputs: ${preview.summary.gitInputBinding}${plan.gitInputs ? `; acquisition: ${plan.gitInputs.acquisition}` : ""}
+`
+      );
       console.log("\u{1F4E6} Execution Plan\n");
       console.log("Execution Order (topological):\n");
       levels.forEach((level, index) => {
@@ -10976,7 +11148,7 @@ async function runWeaveApply(opts, deps) {
       console.log(`Items: ${plan.items.length}
 `);
     }
-    if (!opts.skipGates) {
+    if (!opts.skipGates && !(opts.execute && plan.gitInputs)) {
       if (!json2) console.log("Running gates...\n");
       const executionState = new ExecutionState(plan);
       const gatesDir = path15.join(process.cwd(), ".smartergpt", "runner", "gates");
@@ -11142,7 +11314,7 @@ function registerPlanDiffCommand(program2, deps) {
       const plan2Content = fs24.readFileSync(plan2Path, "utf-8");
       const plan1 = loadPlan(plan1Content);
       const plan2 = loadPlan(plan2Content);
-      const { comparePlans, formatPlanDiff } = await import("./planDiff-IHLFNZUT.js");
+      const { comparePlans, formatPlanDiff } = await import("./planDiff-4D3AERAW.js");
       const diff = comparePlans(plan1, plan2);
       if (opts.json || deps.jsonModeActive()) {
         writeJsonOutput(diff);
@@ -11626,12 +11798,12 @@ ${prefix} Plan validation failed: ${error.message}`);
   }
   fs25.mkdirSync(outDir, { recursive: true });
   const planPath = path16.join(outDir, "plan.json");
-  const snapshotPath = path16.join(outDir, "snapshot.md");
+  const snapshotPath2 = path16.join(outDir, "snapshot.md");
   fs25.writeFileSync(planPath, planJSON);
-  fs25.writeFileSync(snapshotPath, snapshot);
+  fs25.writeFileSync(snapshotPath2, snapshot);
   console.log(`\u2713 Generated plan artifacts:`);
   console.log(`  \u{1F4C1} ${planPath}`);
-  console.log(`  \u{1F4C1} ${snapshotPath}`);
+  console.log(`  \u{1F4C1} ${snapshotPath2}`);
   console.log("");
   console.log(generatePlanSummary(validatedPlan));
   return;
@@ -11772,7 +11944,7 @@ function registerAutopilotCommand(program2, deps) {
           argv: process.argv.slice(2)
         });
       }
-      const { AutopilotLevel0, AutopilotLevel1, AutopilotLevel2: AutopilotLevel22 } = await import("./autopilot-3OHEUTHD.js");
+      const { AutopilotLevel0, AutopilotLevel1, AutopilotLevel2: AutopilotLevel22 } = await import("./autopilot-7PX6YG55.js");
       const context = {
         plan,
         profilePath: profile.path,
@@ -11820,7 +11992,7 @@ function registerAutopilotCommand(program2, deps) {
 // src/application/gate-execution-service.ts
 import { randomUUID as randomUUID4 } from "crypto";
 import { mkdirSync as mkdirSync12 } from "fs";
-import { join as join18, resolve as resolve9 } from "path";
+import { join as join19, resolve as resolve9 } from "path";
 var MAX_ITEMS = 256;
 var MAX_GATES_PER_ITEM = 64;
 var MAX_LABEL_BYTES3 = 512;
@@ -11923,7 +12095,7 @@ var GateExecutionService = class {
 function prepareOwnedArtifactDirectory(requestedRoot) {
   const root = resolve9(bounded2(requestedRoot, MAX_ARTIFACT_REF_BYTES));
   mkdirSync12(root, { recursive: true });
-  const runDirectory = join18(root, `gate-run-${Date.now()}-${randomUUID4()}`);
+  const runDirectory = join19(root, `gate-run-${Date.now()}-${randomUUID4()}`);
   mkdirSync12(runDirectory);
   return runDirectory;
 }
@@ -12797,7 +12969,7 @@ import * as fs28 from "fs";
 import * as path18 from "path";
 async function finalizeAuditGuard(emitter, status) {
   try {
-    const { finalizeAudit: finalizeAudit2 } = await import("./audit-SKMMC2U4.js");
+    const { finalizeAudit: finalizeAudit2 } = await import("./audit-HVB2HJPU.js");
     await finalizeAudit2(emitter, status);
   } catch (e) {
     if (e instanceof Error && typeof e.message === "string" && e.message.startsWith("HIPAA:")) {
@@ -13363,8 +13535,8 @@ function registerPlanReviewCommand(program2, deps) {
       }
       const planContent = fs29.readFileSync(planFile, "utf-8");
       const plan = loadPlan(planContent);
-      const { reviewPlan } = await import("./planReview-UUMCGZJ6.js");
-      const { savePlanVersion, getPlanHistoryPath } = await import("./planHistory-GLRI356L.js");
+      const { reviewPlan } = await import("./planReview-FV6INFLQ.js");
+      const { savePlanVersion, getPlanHistoryPath } = await import("./planHistory-VPV4WDPW.js");
       const result = await reviewPlan({
         plan,
         interactive: !opts.nonInteractive,
@@ -14064,7 +14236,7 @@ async function predictConflicts(options) {
       const pr2Head = prHeads.get(edge.to);
       if (pr1Head && pr2Head) {
         const key = `${edge.from}-${edge.to}`;
-        const result = await import("./mergeTreeSimulator-QCFSOU25.js").then(
+        const result = await import("./mergeTreeSimulator-GWZ77NF2.js").then(
           (m) => m.simulateMerge(baseBranch, pr1Head, pr2Head, workingDir)
         );
         mergeTreeSimulation[key] = result;
@@ -14140,7 +14312,7 @@ function generateRecommendations(misBatches, mergeTreeSimulation) {
 
 // src/orchestration/agentAssigner.ts
 function sleep(ms) {
-  return new Promise((resolve15) => setTimeout(resolve15, ms));
+  return new Promise((resolve16) => setTimeout(resolve16, ms));
 }
 async function assignAgentWithRetry(issueNumber, repo, assignFn, maxRetries = 4) {
   let retries = 0;
@@ -14759,8 +14931,8 @@ function registerGenerateDeliverablesCommand(program2) {
       console.log(`\u2705 Created: ${path23.join(outputDir, "GATE5_cleanup.md")}`);
       console.log(`\u2705 Created: ${path23.join(outputDir, "SUMMARY.md")}`);
       console.log("");
-      const fs50 = await import("fs");
-      const planHashContent = fs50.readFileSync(path23.join(outputDir, "plan-hash.txt"), "utf-8");
+      const fs51 = await import("fs");
+      const planHashContent = fs51.readFileSync(path23.join(outputDir, "plan-hash.txt"), "utf-8");
       const planHashMatch = planHashContent.match(/SHA256: ([a-f0-9]+)/);
       if (planHashMatch) {
         console.log(`Plan hash: ${planHashMatch[1]}`);
@@ -15551,7 +15723,7 @@ function formatMonitor(monitor) {
 async function runCheck(opts) {
   let githubAPI = await createGitHubAPI();
   if (opts.owner && opts.repo) {
-    const { GitHubAPI: GitHubAPI2 } = await import("./api-QBPBKYOC.js");
+    const { GitHubAPI: GitHubAPI2 } = await import("./api-UIWVFU7M.js");
     githubAPI = new GitHubAPI2({
       owner: opts.owner,
       repo: opts.repo,
@@ -16762,9 +16934,9 @@ async function promptInteractive(defaults) {
     output: process.stdout
   });
   const question = (prompt) => {
-    return new Promise((resolve15) => {
+    return new Promise((resolve16) => {
       rl.question(prompt, (answer) => {
-        resolve15(answer.trim());
+        resolve16(answer.trim());
       });
     });
   };
@@ -18621,8 +18793,8 @@ Total: ${entries.length} counter-examples (${entries.filter((e) => e.shouldLearn
   counterExamples.command("export").description("Export counter-examples for analysis").option("--format <format>", "Export format (json|csv)", "json").option("--base-dir <dir>", "Base directory for lexrunner", process.cwd()).option("--output <file>", "Output file (prints to stdout if not specified)").action(async (options) => {
     const output = exportCounterExamples(options.format, options.baseDir);
     if (options.output) {
-      const fs50 = await import("fs");
-      fs50.writeFileSync(options.output, output, "utf-8");
+      const fs51 = await import("fs");
+      fs51.writeFileSync(options.output, output, "utf-8");
       console.log(chalk9.green(`\u2713 Exported counter-examples to ${options.output}`));
     } else {
       console.log(output);
@@ -19202,7 +19374,7 @@ function nativePathsOverlap(runtimePlatform, left, right, comparison) {
   if (api.parse(normalizedLeft).root !== api.parse(normalizedRight).root) return false;
   const relativeLeft = api.relative(normalizedLeft, normalizedRight);
   const relativeRight = api.relative(normalizedRight, normalizedLeft);
-  const isDescendant = (relative3) => relative3.length > 0 && relative3 !== ".." && !relative3.startsWith(`..${api.sep}`);
+  const isDescendant = (relative5) => relative5.length > 0 && relative5 !== ".." && !relative5.startsWith(`..${api.sep}`);
   return isDescendant(relativeLeft) || isDescendant(relativeRight);
 }
 function digestBinding(runtime) {
@@ -20547,8 +20719,8 @@ function parseGitStatusPorcelainV1Z(input) {
     }
     const indexStatus = field[0];
     const worktreeStatus = field[1];
-    const path59 = field.slice(3);
-    if (path59.length === 0) {
+    const path60 = field.slice(3);
+    if (path60.length === 0) {
       throw new Error("Malformed git status porcelain: path is empty");
     }
     const renameOrCopy = [indexStatus, worktreeStatus].find(
@@ -20566,7 +20738,7 @@ function parseGitStatusPorcelainV1Z(input) {
     records.push({
       indexStatus,
       worktreeStatus,
-      path: path59,
+      path: path60,
       ...originalPath === void 0 ? {} : { originalPath },
       kind
     });
@@ -21018,8 +21190,8 @@ function copyIssues(result, context) {
     context.addIssue({ code: "custom", path: issue.path, message: issue.message });
   }
 }
-function addIssue(context, path59, message) {
-  context.addIssue({ code: "custom", path: path59, message });
+function addIssue(context, path60, message) {
+  context.addIssue({ code: "custom", path: path60, message });
 }
 
 // src/workspaces/linux-workspace-boundary.ts
@@ -22060,8 +22232,8 @@ var NodeGitWorktreeBroker = class {
           "The worktree root was replaced after broker initialization"
         );
       }
-      const relative3 = path34.relative(this.worktreeRoot, path34.resolve(target.worktreePath));
-      const components = relative3.split(path34.sep);
+      const relative5 = path34.relative(this.worktreeRoot, path34.resolve(target.worktreePath));
+      const components = relative5.split(path34.sep);
       const targetName = components.pop();
       if (!targetName) {
         throw new DirectoryBoundaryError("invalid_path", "The worktree target has no basename");
@@ -22265,8 +22437,8 @@ var NodeGitWorktreeBroker = class {
       );
     }
     const normalized = path34.resolve(gitDirectoryPath);
-    const relative3 = path34.relative(this.repositoryGitIdentity.path, normalized);
-    if (!relative3 || relative3 === ".." || relative3.startsWith(`..${path34.sep}`)) {
+    const relative5 = path34.relative(this.repositoryGitIdentity.path, normalized);
+    if (!relative5 || relative5 === ".." || relative5.startsWith(`..${path34.sep}`)) {
       return this.failure(
         operation,
         "containment_violation",
@@ -22275,7 +22447,7 @@ var NodeGitWorktreeBroker = class {
     }
     let current = null;
     try {
-      for (const component of relative3.split(path34.sep)) {
+      for (const component of relative5.split(path34.sep)) {
         const child = await boundary.lease.openChild(
           current ?? boundary.repositoryGit,
           component,
@@ -22329,8 +22501,8 @@ var NodeGitWorktreeBroker = class {
     const normalizedRoot = path34.resolve(root);
     const comparedCandidate = this.pathComparison === "case-insensitive" ? normalizedCandidate.toLocaleLowerCase("en-US") : normalizedCandidate;
     const comparedRoot = this.pathComparison === "case-insensitive" ? normalizedRoot.toLocaleLowerCase("en-US") : normalizedRoot;
-    const relative3 = path34.relative(comparedRoot, comparedCandidate);
-    return relative3.length > 0 && relative3 !== ".." && !relative3.startsWith(`..${path34.sep}`);
+    const relative5 = path34.relative(comparedRoot, comparedCandidate);
+    return relative5.length > 0 && relative5 !== ".." && !relative5.startsWith(`..${path34.sep}`);
   }
   async git(boundary, operation, args, cwd, options, allowedNonzeroExitCodes = [], evidence) {
     const result = await boundary.lease.runProcess({
@@ -22435,7 +22607,7 @@ function nativePathsOverlap2(left, right, comparison) {
   if (normalizedLeft === normalizedRight) return true;
   const relativeLeft = path34.relative(normalizedLeft, normalizedRight);
   const relativeRight = path34.relative(normalizedRight, normalizedLeft);
-  const isDescendant = (relative3) => relative3.length > 0 && relative3 !== ".." && !relative3.startsWith(`..${path34.sep}`);
+  const isDescendant = (relative5) => relative5.length > 0 && relative5 !== ".." && !relative5.startsWith(`..${path34.sep}`);
   return isDescendant(relativeLeft) || isDescendant(relativeRight);
 }
 function branchName(ref) {
@@ -23478,7 +23650,7 @@ var NativeWslProjectionEngine = class {
         "native publication target became occupied"
       );
     }
-    const repositoryIdentity = identityOf(staging.repository);
+    const repositoryIdentity2 = identityOf(staging.repository);
     const allocationIdentity = identityOf(staging.allocation);
     staging.repository.close();
     staging.repository = void 0;
@@ -23491,7 +23663,7 @@ var NativeWslProjectionEngine = class {
     staging.repositoryPublished = true;
     assertPublishedIdentity(
       path35.join(boundary.projectionRoot.path, projectionId),
-      repositoryIdentity,
+      repositoryIdentity2,
       "native projection"
     );
     await rename(
@@ -24377,11 +24549,11 @@ function loadNativeWslProjectionSelection(repositoryRoot, expectedSelectionDiges
   if (!/^sha256:[a-f0-9]{64}$/u.test(expectedSelectionDigest)) {
     throw new Error("Projection selection authority is invalid");
   }
-  const repositoryIdentity = captureDirectoryIdentity(
+  const repositoryIdentity2 = captureDirectoryIdentity(
     repositoryRoot,
     "native projection repository"
   );
-  const repository = reopenDirectoryIdentity(repositoryIdentity, "native projection repository");
+  const repository = reopenDirectoryIdentity(repositoryIdentity2, "native projection repository");
   let gitDirectory;
   try {
     gitDirectory = openChildDirectory(repository, ".git", "native projection Git directory");
@@ -24975,24 +25147,24 @@ var AcceptanceCriterion = z19.object({
 function isMachineLocalAbsolutePath(value) {
   return /(?:^|\s)\/(?!\/)[^\s]*/.test(value) || /(?:^|\s)~\/[^\s]*/.test(value) || /(?:^|\s)\\\\[^\s]*/.test(value) || /(?:^|\s)[a-z]:[\\/][^\s]*/i.test(value) || /(?:^|\s)file:/i.test(value);
 }
-function rejectMachineLocalPaths(value, ctx, path59 = []) {
+function rejectMachineLocalPaths(value, ctx, path60 = []) {
   if (typeof value === "string") {
     if (isMachineLocalAbsolutePath(value)) {
       ctx.addIssue({
         code: "custom",
-        path: path59,
+        path: path60,
         message: "AgentTaskPacket_v1 must not contain machine-local absolute paths"
       });
     }
     return;
   }
   if (Array.isArray(value)) {
-    value.forEach((item, index) => rejectMachineLocalPaths(item, ctx, [...path59, index]));
+    value.forEach((item, index) => rejectMachineLocalPaths(item, ctx, [...path60, index]));
     return;
   }
   if (value !== null && typeof value === "object") {
     for (const [key, item] of Object.entries(value)) {
-      rejectMachineLocalPaths(item, ctx, [...path59, key]);
+      rejectMachineLocalPaths(item, ctx, [...path60, key]);
     }
   }
 }
@@ -27166,10 +27338,10 @@ function captureBoundIdentities(input) {
     worktree: captureDirectoryIdentity(input.worktreePath, "execution mapping worktree")
   };
 }
-function verifiedRoot(runtimeId, path59, identity) {
+function verifiedRoot(runtimeId, path60, identity) {
   return {
     runtime_id: runtimeId,
-    path: path59,
+    path: path60,
     verification: "directory_identity",
     directory_identity: identityClaim2(identity)
   };
@@ -27288,8 +27460,8 @@ async function requireDirectoryWithin(directory, root, field) {
     realpath(directory),
     realpath(root)
   ]);
-  const relative3 = path36.relative(resolvedRoot, resolvedDirectory);
-  if (relative3 === ".." || relative3.startsWith(`..${path36.sep}`) || path36.isAbsolute(relative3)) {
+  const relative5 = path36.relative(resolvedRoot, resolvedDirectory);
+  if (relative5 === ".." || relative5.startsWith(`..${path36.sep}`) || path36.isAbsolute(relative5)) {
     throw new Error(`${field} must resolve within its authorized root`);
   }
 }
@@ -32481,8 +32653,8 @@ async function requireDirectoryWithin2(directory, root, field) {
     realpath2(directory),
     realpath2(root)
   ]);
-  const relative3 = path37.relative(resolvedRoot, resolvedDirectory);
-  if (relative3 === ".." || relative3.startsWith(`..${path37.sep}`) || path37.isAbsolute(relative3)) {
+  const relative5 = path37.relative(resolvedRoot, resolvedDirectory);
+  if (relative5 === ".." || relative5.startsWith(`..${path37.sep}`) || path37.isAbsolute(relative5)) {
     throw new Error(`${field} must resolve within the authorized worktree`);
   }
 }
@@ -35259,10 +35431,10 @@ var WorkerSessionDelegationBinding_v1 = z29.object({
 function decisionReceiptMatchesOffer(receipt, offer, offerHash) {
   return receipt.delegation_id === offer.delegation_id && receipt.attempt_id === offer.attempt_id && receipt.offer_hash === offerHash && receipt.worker_thread_id === offer.worker.thread_id && receipt.transcript_start_hash === offer.transcript_start_hash && Date.parse(receipt.decided_at) >= Date.parse(offer.offered_at);
 }
-function requireTimeOrder(earlier, later, path59, context, equalAllowed = true) {
+function requireTimeOrder(earlier, later, path60, context, equalAllowed = true) {
   const ordered = equalAllowed ? Date.parse(earlier) <= Date.parse(later) : Date.parse(earlier) < Date.parse(later);
   if (!ordered) {
-    context.addIssue({ code: "custom", path: [path59], message: `${path59} is out of order` });
+    context.addIssue({ code: "custom", path: [path60], message: `${path60} is out of order` });
   }
 }
 
@@ -36372,12 +36544,12 @@ function grantWithinRequirements(grant, requirements) {
   );
   return grant.authorized_model_provider === requirements.authorized_model_provider && grant.source_disclosure_allowed === requirements.source_disclosure_allowed && grant.max_duration_ms <= requirements.max_duration_ms && grant.max_output_bytes <= requirements.max_output_bytes && grant.controls.every((control) => required2.get(control.control) === control.minimum_strength) && grant.tools.length <= 1;
 }
-function requireExactControls(controls, context, path59) {
+function requireExactControls(controls, context, path60) {
   const actual = new Set(controls.map((control) => control.control));
   if (actual.size !== GovernedControlId.options.length || GovernedControlId.options.some((control) => !actual.has(control))) {
     context.addIssue({
       code: "custom",
-      path: path59,
+      path: path60,
       message: "every governed denial control must appear exactly once"
     });
   }
@@ -37327,10 +37499,10 @@ function requireAbsent(value, fields, context) {
 function addStateIssue(message, context) {
   context.addIssue({ code: "custom", path: ["status"], message });
 }
-function requireOrdered(earlier, later, path59, context, equalAllowed = true) {
+function requireOrdered(earlier, later, path60, context, equalAllowed = true) {
   const ordered = equalAllowed ? Date.parse(earlier) <= Date.parse(later) : Date.parse(earlier) < Date.parse(later);
   if (!ordered) {
-    context.addIssue({ code: "custom", path: [path59], message: `${path59} is out of order` });
+    context.addIssue({ code: "custom", path: [path60], message: `${path60} is out of order` });
   }
 }
 
@@ -39050,8 +39222,8 @@ function normalizeInstant4(value) {
   return new Date(timestamp).toISOString();
 }
 function assertDescendant(parent, candidate) {
-  const relative3 = path46.relative(path46.resolve(parent), path46.resolve(candidate));
-  if (relative3.startsWith("..") || path46.isAbsolute(relative3)) {
+  const relative5 = path46.relative(path46.resolve(parent), path46.resolve(candidate));
+  if (relative5.startsWith("..") || path46.isAbsolute(relative5)) {
     throw new LocalProtectedEvidenceVerificationError("container_invalid");
   }
 }
@@ -39206,14 +39378,14 @@ var WindowsProtectedEvidenceAuthority = class {
     this.child = null;
     child?.stdin.end();
     if (child && child.exitCode === null) {
-      await new Promise((resolve15) => {
+      await new Promise((resolve16) => {
         const timeout = setTimeout(() => {
           child.kill();
-          resolve15();
+          resolve16();
         }, 5e3);
         child.once("close", () => {
           clearTimeout(timeout);
-          resolve15();
+          resolve16();
         });
       });
     }
@@ -39224,8 +39396,8 @@ var WindowsProtectedEvidenceAuthority = class {
     const child = this.ensureChild();
     const id = this.nextId;
     this.nextId += 1;
-    return new Promise((resolve15, reject) => {
-      this.pending.set(id, { resolve: resolve15, reject });
+    return new Promise((resolve16, reject) => {
+      this.pending.set(id, { resolve: resolve16, reject });
       child.stdin.write(`${JSON.stringify({ id, op: operation, path: target })}
 `, (error) => {
         if (!error) return;
@@ -39877,7 +40049,7 @@ var repositoryCorpusHeaderBody = z41.object({
 var GovernedRepositoryCorpusHeader_v1 = repositoryCorpusHeaderBody.superRefine(
   (value, context) => {
     const paths = value.entries.map((entry) => entry.path);
-    if (new Set(paths).size !== paths.length || paths.some((path59, index) => index > 0 && path59 <= paths[index - 1])) {
+    if (new Set(paths).size !== paths.length || paths.some((path60, index) => index > 0 && path60 <= paths[index - 1])) {
       context.addIssue({
         code: "custom",
         path: ["entries"],
@@ -40304,7 +40476,7 @@ function sanitizedWslEnvironment() {
   return environment;
 }
 function waitForExit(child, timeoutMs) {
-  return new Promise((resolve15, reject) => {
+  return new Promise((resolve16, reject) => {
     const timeout = setTimeout(() => {
       child.kill();
       reject(new Error("WSL2 provider control request timed out"));
@@ -40315,7 +40487,7 @@ function waitForExit(child, timeoutMs) {
     });
     child.once("close", (code) => {
       clearTimeout(timeout);
-      resolve15(code);
+      resolve16(code);
     });
   });
 }
@@ -41430,8 +41602,8 @@ var LocalProtectedEvidenceStore = class {
   exclusive(operation) {
     const previous = this.queue;
     let release;
-    this.queue = new Promise((resolve15) => {
-      release = resolve15;
+    this.queue = new Promise((resolve16) => {
+      release = resolve16;
     });
     return previous.then(operation).finally(release);
   }
@@ -41594,8 +41766,8 @@ function sameToken(expected, candidate) {
   return left.length === right.length && timingSafeEqual(left, right);
 }
 function assertDescendant2(root, candidate) {
-  const relative3 = path50.relative(root, candidate);
-  if (!relative3 || relative3.startsWith("..") || path50.isAbsolute(relative3)) {
+  const relative5 = path50.relative(root, candidate);
+  if (!relative5 || relative5.startsWith("..") || path50.isAbsolute(relative5)) {
     throw new Error("protected evidence deletion target escaped its root");
   }
 }
@@ -42443,11 +42615,11 @@ async function launchDetachedSupervisor(input) {
         env: sanitizedSupervisorEnvironment()
       }
     );
-    return await new Promise((resolve15) => {
-      child.once("error", () => resolve15(false));
+    return await new Promise((resolve16) => {
+      child.once("error", () => resolve16(false));
       child.once("spawn", () => {
         child.unref();
-        resolve15(true);
+        resolve16(true);
       });
     });
   } catch {
@@ -43193,10 +43365,10 @@ function commandPath(command) {
   }
   return components.join(" ");
 }
-function aliasWarning(path59) {
-  const policy = POLICY_BY_PATH.get(path59);
+function aliasWarning(path60) {
+  const policy = POLICY_BY_PATH.get(path60);
   if (!policy) return null;
-  return policy.disposition === "deprecated" ? `[lexrunner] deprecated alias "${path59}"; use "${policy.replacement}"; removal: ${policy.removeIn}.` : `[lexrunner] compatibility alias "${path59}"; use "${policy.replacement}"; supported through 2.x and reviewed at 3.0.0.`;
+  return policy.disposition === "deprecated" ? `[lexrunner] deprecated alias "${path60}"; use "${policy.replacement}"; removal: ${policy.removeIn}.` : `[lexrunner] compatibility alias "${path60}"; use "${policy.replacement}"; supported through 2.x and reviewed at 3.0.0.`;
 }
 function emitAliasWarning(command, write = (message) => process.stderr.write(message)) {
   const warning = aliasWarning(commandPath(command));
@@ -43302,8 +43474,8 @@ async function searchAttributions(query, runId) {
 }
 
 // src/cli.ts
-import * as fs49 from "fs";
-import * as path58 from "path";
+import * as fs50 from "fs";
+import * as path59 from "path";
 
 // src/runs/enforcement.ts
 import { z as z45 } from "zod";
@@ -44411,7 +44583,7 @@ function createRunManager(baseDirOrOptions) {
 
 // src/runs/coordinated-manager.ts
 import { existsSync as existsSync24, readFileSync as readFileSync32, renameSync as renameSync3, writeFileSync as writeFileSync19 } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 
 // src/runs/agent-work-supervisor.ts
 import { z as z48 } from "zod";
@@ -44725,8 +44897,8 @@ async function executeAgentWorkPreparation(input) {
 function passed(results, id) {
   return results.some((result) => result.id === id && result.outcome === "passed");
 }
-async function containedExistingDirectory(root, relative3) {
-  const candidate = relative3 ? path55.resolve(root, relative3) : root;
+async function containedExistingDirectory(root, relative5) {
+  const candidate = relative5 ? path55.resolve(root, relative5) : root;
   const resolved = await realpath6(candidate);
   const relation = path55.relative(root, resolved);
   if (relation === ".." || relation.startsWith(`..${path55.sep}`) || path55.isAbsolute(relation)) {
@@ -44809,7 +44981,7 @@ var workspaceFilesystemEntry = z49.discriminatedUnion("kind", [
   }).strict()
 ]);
 function requireStrictlyOrderedPaths(values, context, field) {
-  if (values.some(({ path: path59 }, index) => index > 0 && path59 <= values[index - 1].path)) {
+  if (values.some(({ path: path60 }, index) => index > 0 && path60 <= values[index - 1].path)) {
     context.addIssue({
       code: "custom",
       path: [field],
@@ -44829,7 +45001,7 @@ var completeGitIdentity = z49.object({
   kind: z49.enum(["absent", "present"]),
   paths: z49.array(boundedRelativePath).max(4096)
 }).strict().superRefine((identity, context) => {
-  if (identity.paths.some((path59, index) => index > 0 && path59 <= identity.paths[index - 1]) || identity.kind === "absent" && identity.paths.length !== 0 || identity.kind === "present" && identity.paths.length === 0) {
+  if (identity.paths.some((path60, index) => index > 0 && path60 <= identity.paths[index - 1]) || identity.kind === "absent" && identity.paths.length !== 0 || identity.kind === "present" && identity.paths.length === 0) {
     context.addIssue({
       code: "custom",
       path: ["paths"],
@@ -45139,7 +45311,7 @@ var GovernedWorkspaceMutationRecoveryReceipt_v1 = z49.object({
     });
   }
   if (receipt.changed_paths.some(
-    (path59, index) => index > 0 && path59 <= receipt.changed_paths[index - 1]
+    (path60, index) => index > 0 && path60 <= receipt.changed_paths[index - 1]
   )) {
     context.addIssue({
       code: "custom",
@@ -45974,15 +46146,15 @@ var AttemptAwaitableSupervisor = class {
       0,
       Date.parse(record.observer_lease.expires_at) - Date.parse(this.now()) + 1
     );
-    let resolve15;
+    let resolve16;
     const completion = new Promise((resolvePromise) => {
-      resolve15 = resolvePromise;
+      resolve16 = resolvePromise;
     });
     const timer = setTimeout(() => {
       this.leaseExpiryWakeups.delete(record.awaitable_id);
-      void this.attach(record.awaitable_id).finally(resolve15);
+      void this.attach(record.awaitable_id).finally(resolve16);
     }, delayMs);
-    this.leaseExpiryWakeups.set(record.awaitable_id, { timer, completion, resolve: resolve15 });
+    this.leaseExpiryWakeups.set(record.awaitable_id, { timer, completion, resolve: resolve16 });
   }
   clearLeaseExpiryWakeup(awaitableId) {
     const wakeup = this.leaseExpiryWakeups.get(awaitableId);
@@ -46087,14 +46259,14 @@ function normalizeRetryDelay(value, name) {
 }
 function waitForRetry(delayMs, signal) {
   if (signal.aborted) return Promise.resolve(false);
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     const timer = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve15(true);
+      resolve16(true);
     }, delayMs);
     const onAbort = () => {
       clearTimeout(timer);
-      resolve15(false);
+      resolve16(false);
     };
     signal.addEventListener("abort", onAbort, { once: true });
   });
@@ -49611,8 +49783,135 @@ function normalizeInstant8(value) {
 // src/application/plan-artifact-service.ts
 import * as fs48 from "fs";
 import * as path57 from "path";
-var MAX_PLAN_REFERENCE_BYTES = 4096;
-var MAX_PLAN_BYTES = 4 * 1024 * 1024;
+import { isDeepStrictEqual } from "util";
+
+// src/application/execution-plan-artifact.ts
+import { createHash as createHash13 } from "crypto";
+import { z as z54 } from "zod";
+var EXECUTION_PLAN_ARTIFACT_CONTRACT = "lexrunner.execution-plan-artifact.v1";
+var PLAN_ARTIFACT_REFERENCE_CONTRACT = "lexrunner.plan-artifact-reference.v1";
+var EXECUTION_PLAN_CANONICALIZATION_PROFILE = "lexrunner.execution-plan.canonical-json.v1";
+var EXECUTION_PLAN_HASH_PROFILE = "lexrunner.execution-plan-artifact.sha256.v1";
+var EXECUTION_PLAN_HASH_DOMAIN = "lexrunner:execution-plan-artifact:v1\0";
+var MAX_PLAN_ARTIFACT_BYTES = 4 * 1024 * 1024;
+var MAX_PLAN_RETRIEVAL_REFERENCE_BYTES = 4096;
+var MAX_SCOPE_LABEL_BYTES = 512;
+var Sha256Digest = z54.string().regex(/^sha256:[a-f0-9]{64}$/);
+var BoundedScopeLabel = z54.string().min(1).refine((value) => Buffer.byteLength(value, "utf8") <= MAX_SCOPE_LABEL_BYTES, {
+  message: "Scope label exceeds the transport limit"
+});
+var BoundedIdentityLabel = z54.string().min(1).refine((value) => Buffer.byteLength(value, "utf8") <= MAX_SCOPE_LABEL_BYTES, {
+  message: "Identity label exceeds the transport limit"
+});
+var PlanArtifactScope_v1Schema = z54.object({
+  tenant: BoundedScopeLabel,
+  workspace: BoundedScopeLabel,
+  repository: BoundedScopeLabel,
+  refNamespace: BoundedScopeLabel,
+  policy: BoundedScopeLabel
+}).strict();
+var ExecutionPlanArtifactIdentity_v1Schema = z54.object({
+  contract: z54.literal(EXECUTION_PLAN_ARTIFACT_CONTRACT),
+  kind: z54.literal("execution-plan"),
+  planSchema: z54.literal("lexrunner.execution-plan"),
+  planSchemaVersion: BoundedIdentityLabel,
+  canonicalizationProfile: z54.literal(EXECUTION_PLAN_CANONICALIZATION_PROFILE),
+  hashProfile: z54.literal(EXECUTION_PLAN_HASH_PROFILE),
+  digestAlgorithm: z54.literal("sha256"),
+  digest: Sha256Digest,
+  canonicalByteLength: z54.number().int().nonnegative().max(MAX_PLAN_ARTIFACT_BYTES),
+  target: BoundedIdentityLabel,
+  summary: z54.object({
+    itemCount: z54.number().int().nonnegative().max(256),
+    gateCount: z54.number().int().nonnegative().max(256 * 64)
+  }).strict()
+}).strict();
+var ExecutionPlanArtifact_v1Schema = z54.object({
+  identity: ExecutionPlanArtifactIdentity_v1Schema,
+  canonicalBytes: z54.string()
+}).strict().superRefine((artifact, context) => {
+  const byteLength = Buffer.byteLength(artifact.canonicalBytes, "utf8");
+  if (byteLength > MAX_PLAN_ARTIFACT_BYTES) {
+    context.addIssue({
+      code: "custom",
+      path: ["canonicalBytes"],
+      message: "Canonical plan bytes exceed the artifact limit"
+    });
+  }
+  if (byteLength !== artifact.identity.canonicalByteLength) {
+    context.addIssue({
+      code: "custom",
+      path: ["identity", "canonicalByteLength"],
+      message: "Canonical plan byte length does not match the artifact identity"
+    });
+  }
+  if (computeExecutionPlanArtifactDigest(artifact.canonicalBytes) !== artifact.identity.digest) {
+    context.addIssue({
+      code: "custom",
+      path: ["identity", "digest"],
+      message: "Canonical plan digest does not match the artifact identity"
+    });
+  }
+  try {
+    const plan = loadPlan(artifact.canonicalBytes);
+    if (canonicalJSONStringify(plan) !== artifact.canonicalBytes) {
+      context.addIssue({
+        code: "custom",
+        path: ["canonicalBytes"],
+        message: "Plan bytes are not in the declared canonical form"
+      });
+    }
+    const gateCount = plan.items.reduce((count, item) => count + item.gates.length, 0);
+    if (artifact.identity.planSchemaVersion !== plan.schemaVersion || artifact.identity.target !== plan.target || artifact.identity.summary.itemCount !== plan.items.length || artifact.identity.summary.gateCount !== gateCount) {
+      context.addIssue({
+        code: "custom",
+        path: ["identity"],
+        message: "Plan semantics do not match the artifact identity"
+      });
+    }
+  } catch {
+    context.addIssue({
+      code: "custom",
+      path: ["canonicalBytes"],
+      message: "Canonical bytes do not contain a valid execution plan"
+    });
+  }
+});
+var PlanArtifactReference_v1Schema = z54.object({
+  contract: z54.literal(PLAN_ARTIFACT_REFERENCE_CONTRACT),
+  artifact: ExecutionPlanArtifactIdentity_v1Schema,
+  expectedDigest: Sha256Digest,
+  expectedCanonicalByteLength: z54.number().int().nonnegative().max(MAX_PLAN_ARTIFACT_BYTES),
+  retrieval: z54.object({
+    kind: z54.enum(["file", "registered"]),
+    reference: z54.string().min(1).refine(
+      (value) => !value.includes("\0") && Buffer.byteLength(value, "utf8") <= MAX_PLAN_RETRIEVAL_REFERENCE_BYTES,
+      { message: "Retrieval reference is invalid or exceeds the transport limit" }
+    )
+  }).strict(),
+  scope: PlanArtifactScope_v1Schema.optional()
+}).strict().superRefine((reference, context) => {
+  if (reference.expectedDigest !== reference.artifact.digest) {
+    context.addIssue({
+      code: "custom",
+      path: ["expectedDigest"],
+      message: "Expected digest does not match the embedded artifact identity"
+    });
+  }
+  if (reference.expectedCanonicalByteLength !== reference.artifact.canonicalByteLength) {
+    context.addIssue({
+      code: "custom",
+      path: ["expectedCanonicalByteLength"],
+      message: "Expected byte length does not match the embedded artifact identity"
+    });
+  }
+});
+function computeExecutionPlanArtifactDigest(canonicalBytes2) {
+  const digest = createHash13("sha256").update(EXECUTION_PLAN_HASH_DOMAIN, "utf8").update(canonicalBytes2, "utf8").digest("hex");
+  return `sha256:${digest}`;
+}
+
+// src/application/plan-artifact-service.ts
 var MAX_PLAN_ITEMS = 256;
 var MAX_GATES_PER_ITEM2 = 64;
 var MAX_IDENTITY_LABEL_BYTES = 512;
@@ -49624,16 +49923,41 @@ var PlanArtifactServiceError = class extends Error {
     this.name = "PlanArtifactServiceError";
   }
 };
+var _hooks;
 var PlanArtifactService = class {
+  constructor(options = {}) {
+    __privateAdd(this, _hooks);
+    __privateSet(this, _hooks, options.importHooks ?? {});
+  }
   resolve(input = {}) {
     const workingDir = path57.resolve(input.workingDir ?? process.cwd());
+    const scope = parseScope(input.scope);
+    if (input.planReference !== void 0 && input.planFile !== void 0) {
+      throw new PlanArtifactServiceError(
+        "PLAN_REFERENCE_INVALID",
+        "Provide either an immutable plan reference or an explicit plan path, not both",
+        "explicit"
+      );
+    }
+    if (input.planReference !== void 0 && input.scope !== void 0) {
+      throw new PlanArtifactServiceError(
+        "PLAN_REFERENCE_INVALID",
+        "A separately supplied scope cannot override an immutable plan reference",
+        "explicit"
+      );
+    }
+    if (input.planReference !== void 0) {
+      const reference = parseReference(input.planReference);
+      const explicitPath = resolveExplicitReference(reference.retrieval.reference, workingDir);
+      return readArtifact(explicitPath, "explicit", __privateGet(this, _hooks), reference);
+    }
     if (input.planFile !== void 0) {
       const explicitPath = resolveExplicitReference(input.planFile, workingDir);
-      return readArtifact(explicitPath, "explicit");
+      return readArtifact(explicitPath, "explicit", __privateGet(this, _hooks), void 0, scope);
     }
     const repositoryPlan = path57.join(workingDir, "plan.json");
-    if (isRegularFile(repositoryPlan)) {
-      return readArtifact(repositoryPlan, "repository-root");
+    if (pathEntryExists(repositoryPlan)) {
+      return readArtifact(repositoryPlan, "repository-root", __privateGet(this, _hooks), void 0, scope);
     }
     let profilePlan;
     try {
@@ -49641,8 +49965,8 @@ var PlanArtifactService = class {
       profilePlan = path57.join(profile.path, "runner", "plan.json");
     } catch {
     }
-    if (profilePlan && isRegularFile(profilePlan)) {
-      return readArtifact(profilePlan, "profile-runner");
+    if (profilePlan && pathEntryExists(profilePlan)) {
+      return readArtifact(profilePlan, "profile-runner", __privateGet(this, _hooks), void 0, scope);
     }
     throw new PlanArtifactServiceError(
       "PLAN_NOT_FOUND",
@@ -49650,46 +49974,85 @@ var PlanArtifactService = class {
     );
   }
 };
-function resolveExplicitReference(reference, workingDir) {
-  if (reference.length === 0 || reference.includes("\0") || Buffer.byteLength(reference, "utf8") > MAX_PLAN_REFERENCE_BYTES) {
+_hooks = new WeakMap();
+function parseReference(reference) {
+  const parsed = PlanArtifactReference_v1Schema.safeParse(reference);
+  if (!parsed.success) {
     throw new PlanArtifactServiceError(
       "PLAN_REFERENCE_INVALID",
-      "The explicit plan reference is empty, overlong, or contains an invalid character",
+      "The immutable plan reference does not satisfy the bounded transport contract",
       "explicit"
     );
   }
-  return path57.isAbsolute(reference) ? path57.normalize(reference) : path57.resolve(workingDir, reference);
+  return parsed.data;
 }
-function readArtifact(filePath, source) {
-  let stat11;
-  try {
-    stat11 = fs48.statSync(filePath);
-  } catch {
+function parseScope(scope) {
+  if (scope === void 0) return void 0;
+  const parsed = PlanArtifactScope_v1Schema.safeParse(scope);
+  if (!parsed.success) {
     throw new PlanArtifactServiceError(
-      "PLAN_NOT_FOUND",
-      "The referenced integration plan does not exist",
-      source
+      "PLAN_REFERENCE_INVALID",
+      "The plan scope does not satisfy the bounded transport contract",
+      "explicit"
     );
   }
-  if (!stat11.isFile() || stat11.size > MAX_PLAN_BYTES) {
+  return parsed.data;
+}
+function resolveExplicitReference(reference, workingDir) {
+  if (reference.length === 0 || reference.includes("\0") || Buffer.byteLength(reference, "utf8") > MAX_PLAN_RETRIEVAL_REFERENCE_BYTES) {
     throw new PlanArtifactServiceError(
-      "PLAN_UNREADABLE",
-      "The referenced integration plan is not a readable bounded file",
+      "PLAN_REFERENCE_INVALID",
+      "The explicit plan reference is empty, overlong, or contains an invalid character",
+      "explicit"
+    );
+  }
+  return path57.isAbsolute(reference) ? path57.normalize(reference) : path57.resolve(workingDir, reference);
+}
+function readArtifact(filePath, source, hooks, expected, scope) {
+  const content = readPortableRaceDetectedFile(filePath, source, hooks);
+  const plan = loadPlan(content);
+  assertBoundedArtifact(plan, source);
+  const canonicalBytes2 = canonicalJSONStringify(plan);
+  const canonicalByteLength = Buffer.byteLength(canonicalBytes2, "utf8");
+  if (canonicalByteLength > MAX_PLAN_ARTIFACT_BYTES) {
+    throw new PlanArtifactServiceError(
+      "PLAN_ARTIFACT_LIMIT_EXCEEDED",
+      "The canonical integration plan exceeds the artifact byte limit",
       source
     );
   }
-  let content;
-  try {
-    content = fs48.readFileSync(filePath, "utf8");
-  } catch {
+  const artifactIdentity = {
+    contract: EXECUTION_PLAN_ARTIFACT_CONTRACT,
+    kind: "execution-plan",
+    planSchema: "lexrunner.execution-plan",
+    planSchemaVersion: plan.schemaVersion,
+    canonicalizationProfile: EXECUTION_PLAN_CANONICALIZATION_PROFILE,
+    hashProfile: EXECUTION_PLAN_HASH_PROFILE,
+    digestAlgorithm: "sha256",
+    digest: computeExecutionPlanArtifactDigest(canonicalBytes2),
+    canonicalByteLength,
+    target: plan.target,
+    summary: {
+      itemCount: plan.items.length,
+      gateCount: plan.items.reduce((count, item) => count + item.gates.length, 0)
+    }
+  };
+  const artifact = { identity: artifactIdentity, canonicalBytes: canonicalBytes2 };
+  if (expected && !isDeepStrictEqual(expected.artifact, artifactIdentity)) {
     throw new PlanArtifactServiceError(
-      "PLAN_UNREADABLE",
-      "The referenced integration plan could not be read",
+      "PLAN_REFERENCE_MISMATCH",
+      "The retrieved integration plan does not match the immutable reference",
       source
     );
   }
-  const plan = loadPlan(content);
-  assertBoundedArtifact(plan, source);
+  const reference = expected ?? parseReference({
+    contract: PLAN_ARTIFACT_REFERENCE_CONTRACT,
+    artifact: artifactIdentity,
+    expectedDigest: artifactIdentity.digest,
+    expectedCanonicalByteLength: artifactIdentity.canonicalByteLength,
+    retrieval: { kind: "file", reference: filePath },
+    ...scope ? { scope } : {}
+  });
   return {
     plan,
     identity: {
@@ -49701,10 +50064,167 @@ function readArtifact(filePath, source) {
       target: plan.target,
       itemCount: plan.items.length
     },
+    artifact,
+    reference,
+    acquisition: {
+      contract: "lexrunner.plan-artifact-acquisition.v1",
+      assurance: "portable-race-detection",
+      authority: "unverified"
+    },
     source,
     filePath
   };
 }
+function readPortableRaceDetectedFile(filePath, source, hooks) {
+  const initialPath = snapshotPath(filePath, source);
+  hooks.afterInitialPathSnapshot?.();
+  const noFollow = typeof fs48.constants.O_NOFOLLOW === "number" ? fs48.constants.O_NOFOLLOW : 0;
+  let descriptor;
+  try {
+    descriptor = fs48.openSync(filePath, fs48.constants.O_RDONLY | noFollow);
+  } catch (error) {
+    throw importError(error, source);
+  }
+  let bytes;
+  try {
+    const before = fs48.fstatSync(descriptor, { bigint: true });
+    assertOpenedIdentity(initialPath[initialPath.length - 1].stats, before, source);
+    hooks.afterOpen?.();
+    if (before.size > BigInt(MAX_PLAN_ARTIFACT_BYTES)) {
+      throw new PlanArtifactServiceError(
+        "PLAN_ARTIFACT_LIMIT_EXCEEDED",
+        "The referenced integration plan exceeds the artifact byte limit",
+        source
+      );
+    }
+    bytes = readAtMost(descriptor, MAX_PLAN_ARTIFACT_BYTES + 1);
+    hooks.afterRead?.();
+    const after = fs48.fstatSync(descriptor, { bigint: true });
+    assertStableOpenedFile(before, after, bytes.length, source);
+  } finally {
+    fs48.closeSync(descriptor);
+  }
+  hooks.beforeFinalPathSnapshot?.();
+  const finalPath = snapshotPath(filePath, source);
+  assertStablePath(initialPath, finalPath, source);
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new PlanArtifactServiceError(
+      "PLAN_UNREADABLE",
+      "The referenced integration plan is not valid UTF-8",
+      source
+    );
+  }
+}
+function snapshotPath(filePath, source) {
+  const absolute = path57.resolve(filePath);
+  const root = path57.parse(absolute).root;
+  const relative5 = path57.relative(root, absolute);
+  const segments = relative5.length === 0 ? [] : relative5.split(path57.sep);
+  const candidates = [root];
+  let current = root;
+  for (const segment of segments) {
+    current = path57.join(current, segment);
+    candidates.push(current);
+  }
+  return candidates.map((candidate, index) => {
+    let stats;
+    try {
+      stats = fs48.lstatSync(candidate, { bigint: true });
+    } catch (error) {
+      throw importError(error, source);
+    }
+    const leaf = index === candidates.length - 1;
+    if (stats.isSymbolicLink()) {
+      throw new PlanArtifactServiceError(
+        "PLAN_FILESYSTEM_UNSAFE",
+        "The integration plan path contains an unsafe filesystem object",
+        source
+      );
+    }
+    if (leaf ? !stats.isFile() : !stats.isDirectory()) {
+      throw new PlanArtifactServiceError(
+        "PLAN_UNREADABLE",
+        "The referenced integration plan is not a readable bounded file",
+        source
+      );
+    }
+    if (leaf && stats.nlink !== 1n) {
+      throw new PlanArtifactServiceError(
+        "PLAN_FILESYSTEM_UNSAFE",
+        "The integration plan file has an ambiguous filesystem identity",
+        source
+      );
+    }
+    return { stats, leaf };
+  });
+}
+function assertOpenedIdentity(pathStats, openedStats, source) {
+  if (!openedStats.isFile() || openedStats.nlink !== 1n || !sameObject(pathStats, openedStats) || pathStats.size !== openedStats.size || pathStats.mtimeNs !== openedStats.mtimeNs || pathStats.ctimeNs !== openedStats.ctimeNs) {
+    throw new PlanArtifactServiceError(
+      "PLAN_FILESYSTEM_UNSAFE",
+      "The integration plan filesystem identity changed during acquisition",
+      source
+    );
+  }
+}
+function assertStableOpenedFile(before, after, bytesRead, source) {
+  if (bytesRead > MAX_PLAN_ARTIFACT_BYTES) {
+    throw new PlanArtifactServiceError(
+      "PLAN_ARTIFACT_LIMIT_EXCEEDED",
+      "The referenced integration plan exceeds the artifact byte limit",
+      source
+    );
+  }
+  if (!after.isFile() || after.nlink !== 1n || !sameObject(before, after) || before.size !== after.size || before.mtimeNs !== after.mtimeNs || before.ctimeNs !== after.ctimeNs || BigInt(bytesRead) !== before.size) {
+    throw new PlanArtifactServiceError(
+      "PLAN_FILESYSTEM_UNSAFE",
+      "The integration plan changed while its bytes were being acquired",
+      source
+    );
+  }
+}
+function assertStablePath(before, after, source) {
+  if (before.length !== after.length || before.some((entry, index) => {
+    const current = after[index];
+    return !current || entry.leaf !== current.leaf || !sameObject(entry.stats, current.stats) || entry.leaf && (entry.stats.size !== current.stats.size || entry.stats.mtimeNs !== current.stats.mtimeNs || entry.stats.ctimeNs !== current.stats.ctimeNs || current.stats.nlink !== 1n);
+  })) {
+    throw new PlanArtifactServiceError(
+      "PLAN_FILESYSTEM_UNSAFE",
+      "The integration plan path changed while its bytes were being acquired",
+      source
+    );
+  }
+}
+function sameObject(left, right) {
+  return left.dev === right.dev && left.ino === right.ino && left.mode === right.mode;
+}
+function readAtMost(descriptor, maximumBytes) {
+  const buffer = Buffer.allocUnsafe(maximumBytes);
+  let offset = 0;
+  while (offset < maximumBytes) {
+    const count = fs48.readSync(descriptor, buffer, offset, maximumBytes - offset, null);
+    if (count === 0) break;
+    offset += count;
+  }
+  return buffer.subarray(0, offset);
+}
+function importError(error, source) {
+  const code = error?.code;
+  if (code === "ENOENT" || code === "ENOTDIR") {
+    return new PlanArtifactServiceError(
+      "PLAN_NOT_FOUND",
+      "The referenced integration plan does not exist",
+      source
+    );
+  }
+  return new PlanArtifactServiceError(
+    "PLAN_UNREADABLE",
+    "The referenced integration plan could not be safely read",
+    source
+  );
+}
 function assertBoundedArtifact(plan, source) {
   const labels = [
     plan.schemaVersion,
@@ -49719,11 +50239,277 @@ function assertBoundedArtifact(plan, source) {
     );
   }
 }
-function isRegularFile(filePath) {
+function pathEntryExists(filePath) {
   try {
-    return fs48.statSync(filePath).isFile();
-  } catch {
-    return false;
+    fs48.lstatSync(filePath);
+    return true;
+  } catch (error) {
+    const code = error?.code;
+    if (code === "ENOENT" || code === "ENOTDIR") return false;
+    return true;
+  }
+}
+
+// src/application/plan-artifact-registration-service.ts
+import * as fs49 from "fs";
+import * as path58 from "path";
+import { randomUUID as randomUUID9 } from "crypto";
+var PlanArtifactRegistrationError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "PlanArtifactRegistrationError";
+  }
+};
+var _PlanArtifactRegistrationService_instances, verifyExisting_fn;
+var PlanArtifactRegistrationService = class {
+  constructor() {
+    __privateAdd(this, _PlanArtifactRegistrationService_instances);
+  }
+  register(input) {
+    const parsed = ExecutionPlanArtifact_v1Schema.safeParse(input.artifact);
+    if (!parsed.success) {
+      throw new PlanArtifactRegistrationError(
+        "PLAN_REGISTRATION_INVALID",
+        "The plan artifact does not satisfy the immutable artifact contract"
+      );
+    }
+    const artifact = parsed.data;
+    const scope = parseScope2(input.scope);
+    const storeDirectory = validateStoreReference(input.storeDirectory);
+    prepareControlledStore(storeDirectory);
+    const digestName = `${artifact.identity.digest.slice("sha256:".length)}.json`;
+    const artifactPath = path58.join(storeDirectory, digestName);
+    const reference = createRegisteredReference(artifact, artifactPath, scope);
+    if (pathEntryExists2(artifactPath)) {
+      return __privateMethod(this, _PlanArtifactRegistrationService_instances, verifyExisting_fn).call(this, artifact, reference, false);
+    }
+    const temporaryPath = path58.join(storeDirectory, `.plan-${randomUUID9()}.tmp`);
+    let temporaryCreated = false;
+    try {
+      const descriptor = fs49.openSync(
+        temporaryPath,
+        fs49.constants.O_WRONLY | fs49.constants.O_CREAT | fs49.constants.O_EXCL,
+        384
+      );
+      temporaryCreated = true;
+      try {
+        writeAll(descriptor, Buffer.from(artifact.canonicalBytes, "utf8"));
+        fs49.fsyncSync(descriptor);
+      } finally {
+        fs49.closeSync(descriptor);
+      }
+      try {
+        fs49.linkSync(temporaryPath, artifactPath);
+      } catch (error) {
+        if (!pathEntryExists2(artifactPath)) throw error;
+        return __privateMethod(this, _PlanArtifactRegistrationService_instances, verifyExisting_fn).call(this, artifact, reference, false);
+      }
+      try {
+        fs49.unlinkSync(temporaryPath);
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+      temporaryCreated = false;
+      flushDirectoryWhenSupported(storeDirectory);
+      assertStoreDirectory(storeDirectory);
+      return __privateMethod(this, _PlanArtifactRegistrationService_instances, verifyExisting_fn).call(this, artifact, reference, true);
+    } catch (error) {
+      if (error instanceof PlanArtifactRegistrationError) throw error;
+      throw new PlanArtifactRegistrationError(
+        "PLAN_REGISTRATION_UNSAFE",
+        "The plan artifact could not be published without replacing existing bytes"
+      );
+    } finally {
+      if (temporaryCreated) {
+        try {
+          fs49.unlinkSync(temporaryPath);
+        } catch {
+        }
+      }
+    }
+  }
+};
+_PlanArtifactRegistrationService_instances = new WeakSet();
+verifyExisting_fn = function(artifact, reference, created) {
+  try {
+    waitForConcurrentPublisher(reference.retrieval.reference);
+    const resolved = new PlanArtifactService().resolve({ planReference: reference });
+    if (resolved.artifact.canonicalBytes !== artifact.canonicalBytes) {
+      throw new PlanArtifactRegistrationError(
+        "PLAN_REGISTRATION_CONFLICT",
+        "The content-addressed plan object conflicts with the requested artifact"
+      );
+    }
+    return {
+      artifact: resolved.artifact,
+      reference,
+      created,
+      storage: { assurance: "service-no-replace-verified", authority: "unverified" }
+    };
+  } catch (error) {
+    if (error instanceof PlanArtifactRegistrationError) throw error;
+    if (error instanceof PlanArtifactServiceError && error.code === "PLAN_REFERENCE_MISMATCH") {
+      throw new PlanArtifactRegistrationError(
+        "PLAN_REGISTRATION_CONFLICT",
+        "The content-addressed plan object conflicts with the requested artifact"
+      );
+    }
+    throw new PlanArtifactRegistrationError(
+      "PLAN_REGISTRATION_VERIFY_FAILED",
+      "The persisted plan artifact could not be reread and verified"
+    );
+  }
+};
+function createRegisteredReference(artifact, artifactPath, scope) {
+  if (Buffer.byteLength(artifactPath, "utf8") > 4096) {
+    throw new PlanArtifactRegistrationError(
+      "PLAN_REGISTRATION_INVALID",
+      "The artifact store cannot produce a bounded retrieval reference"
+    );
+  }
+  const reference = {
+    contract: PLAN_ARTIFACT_REFERENCE_CONTRACT,
+    artifact: artifact.identity,
+    expectedDigest: artifact.identity.digest,
+    expectedCanonicalByteLength: artifact.identity.canonicalByteLength,
+    retrieval: { kind: "registered", reference: artifactPath },
+    ...scope ? { scope } : {}
+  };
+  const parsed = PlanArtifactReference_v1Schema.safeParse(reference);
+  if (!parsed.success) {
+    throw new PlanArtifactRegistrationError(
+      "PLAN_REGISTRATION_INVALID",
+      "The registered artifact reference does not satisfy the bounded transport contract"
+    );
+  }
+  return parsed.data;
+}
+function parseScope2(scope) {
+  if (scope === void 0) return void 0;
+  const parsed = PlanArtifactScope_v1Schema.safeParse(scope);
+  if (!parsed.success) {
+    throw new PlanArtifactRegistrationError(
+      "PLAN_REGISTRATION_INVALID",
+      "The plan scope does not satisfy the bounded transport contract"
+    );
+  }
+  return parsed.data;
+}
+function validateStoreReference(reference) {
+  if (reference.length === 0 || reference.includes("\0") || Buffer.byteLength(reference, "utf8") > 4096) {
+    throw new PlanArtifactRegistrationError(
+      "PLAN_REGISTRATION_INVALID",
+      "The artifact store reference is invalid or exceeds its bound"
+    );
+  }
+  return path58.resolve(reference);
+}
+function prepareControlledStore(storeDirectory) {
+  const root = path58.parse(storeDirectory).root;
+  const segments = path58.relative(root, storeDirectory).split(path58.sep).filter(Boolean);
+  let current = root;
+  for (const segment of segments) {
+    current = path58.join(current, segment);
+    try {
+      const stats = fs49.lstatSync(current);
+      if (stats.isSymbolicLink() || !stats.isDirectory()) {
+        throw new PlanArtifactRegistrationError(
+          "PLAN_REGISTRATION_UNSAFE",
+          "The artifact store contains an unsafe filesystem object"
+        );
+      }
+    } catch (error) {
+      if (error instanceof PlanArtifactRegistrationError) throw error;
+      if (error.code !== "ENOENT") {
+        throw new PlanArtifactRegistrationError(
+          "PLAN_REGISTRATION_UNSAFE",
+          "The artifact store identity is unavailable"
+        );
+      }
+      try {
+        fs49.mkdirSync(current, { mode: 448 });
+      } catch (mkdirError) {
+        if (mkdirError.code !== "EEXIST") {
+          throw new PlanArtifactRegistrationError(
+            "PLAN_REGISTRATION_UNSAFE",
+            "The artifact store could not be prepared"
+          );
+        }
+      }
+      const created = fs49.lstatSync(current);
+      if (created.isSymbolicLink() || !created.isDirectory()) {
+        throw new PlanArtifactRegistrationError(
+          "PLAN_REGISTRATION_UNSAFE",
+          "The artifact store contains an unsafe filesystem object"
+        );
+      }
+    }
+  }
+  assertStoreDirectory(storeDirectory);
+}
+function assertStoreDirectory(storeDirectory) {
+  const root = path58.parse(storeDirectory).root;
+  const segments = path58.relative(root, storeDirectory).split(path58.sep).filter(Boolean);
+  let current = root;
+  for (const segment of segments) {
+    current = path58.join(current, segment);
+    let stats;
+    try {
+      stats = fs49.lstatSync(current);
+    } catch {
+      throw new PlanArtifactRegistrationError(
+        "PLAN_REGISTRATION_UNSAFE",
+        "The artifact store identity is unavailable"
+      );
+    }
+    if (stats.isSymbolicLink() || !stats.isDirectory()) {
+      throw new PlanArtifactRegistrationError(
+        "PLAN_REGISTRATION_UNSAFE",
+        "The artifact store contains an unsafe filesystem object"
+      );
+    }
+  }
+}
+function writeAll(descriptor, bytes) {
+  let offset = 0;
+  while (offset < bytes.length) {
+    offset += fs49.writeSync(descriptor, bytes, offset, bytes.length - offset, null);
+  }
+}
+function flushDirectoryWhenSupported(directory) {
+  let descriptor;
+  try {
+    descriptor = fs49.openSync(directory, fs49.constants.O_RDONLY);
+    fs49.fsyncSync(descriptor);
+  } catch (error) {
+    const code = error?.code;
+    if (process.platform !== "win32" || code !== "EISDIR" && code !== "EPERM") throw error;
+  } finally {
+    if (descriptor !== void 0) fs49.closeSync(descriptor);
+  }
+}
+function pathEntryExists2(filePath) {
+  try {
+    fs49.lstatSync(filePath);
+    return true;
+  } catch (error) {
+    const code = error?.code;
+    return code !== "ENOENT" && code !== "ENOTDIR";
+  }
+}
+function waitForConcurrentPublisher(artifactPath) {
+  const deadline = Date.now() + 500;
+  const signal = new Int32Array(new SharedArrayBuffer(4));
+  while (Date.now() < deadline) {
+    let stats;
+    try {
+      stats = fs49.lstatSync(artifactPath);
+    } catch {
+      return;
+    }
+    if (!stats.isFile() || stats.isSymbolicLink() || stats.nlink <= 1) return;
+    Atomics.wait(signal, 0, 0, 10);
   }
 }
 
@@ -50282,7 +51068,7 @@ workspaceCmd.command("init").description("Initialize lexrunner workspace with in
         force: opts.force
       });
       if (isJsonMode) {
-        const { writeSuccessEnvelope } = await import("./jsonEnvelope-K2U5CWKU.js");
+        const { writeSuccessEnvelope } = await import("./jsonEnvelope-MXJM5ZQH.js");
         writeSuccessEnvelope("lex-pr workspace init", initialized);
       } else {
         console.log(
@@ -50302,7 +51088,7 @@ workspaceCmd.command("init").description("Initialize lexrunner workspace with in
       policyTemplate: opts.policyTemplate
     });
     if (isJsonMode) {
-      const { writeSuccessEnvelope, writeErrorEnvelope } = await import("./jsonEnvelope-K2U5CWKU.js");
+      const { writeSuccessEnvelope, writeErrorEnvelope } = await import("./jsonEnvelope-MXJM5ZQH.js");
       if (result.success) {
         writeSuccessEnvelope("lex-pr workspace init", {
           profileDir: result.profileDir,
@@ -50330,7 +51116,7 @@ workspaceCmd.command("init").description("Initialize lexrunner workspace with in
       throw error;
     }
     if (isJsonMode) {
-      const { writeErrorEnvelope, errorToJsonError } = await import("./jsonEnvelope-K2U5CWKU.js");
+      const { writeErrorEnvelope, errorToJsonError } = await import("./jsonEnvelope-MXJM5ZQH.js");
       if (error instanceof WorkspaceConfigServiceError) {
         writeErrorEnvelope("lex-pr workspace init", {
           code: error.code,
@@ -50427,7 +51213,7 @@ program.command("init").description("Initialize lexrunner workspace with interac
       jsonMode: isJsonMode
     });
     if (isJsonMode) {
-      const { writeSuccessEnvelope, writeErrorEnvelope, errorToJsonError } = await import("./jsonEnvelope-K2U5CWKU.js");
+      const { writeSuccessEnvelope, writeErrorEnvelope, errorToJsonError } = await import("./jsonEnvelope-MXJM5ZQH.js");
       if (result.success) {
         writeSuccessEnvelope("lex-pr init", {
           profileDir: result.profileDir,
@@ -50455,7 +51241,7 @@ program.command("init").description("Initialize lexrunner workspace with interac
       throw error;
     }
     if (isJsonMode) {
-      const { writeErrorEnvelope, errorToJsonError } = await import("./jsonEnvelope-K2U5CWKU.js");
+      const { writeErrorEnvelope, errorToJsonError } = await import("./jsonEnvelope-MXJM5ZQH.js");
       if (error instanceof WriteProtectionError) {
         writeErrorEnvelope("lex-pr init", {
           code: "EWRITE_PROTECTED",
@@ -50651,8 +51437,8 @@ program.command("view").description("Interactive plan viewer with navigation and
     throwExit(1);
   }
   try {
-    const { InteractivePlanViewer } = await import("./planViewer-TRSQVMH4.js");
-    const planContent = fs49.readFileSync(planFile, "utf-8");
+    const { InteractivePlanViewer } = await import("./planViewer-WOV6A2HZ.js");
+    const planContent = fs50.readFileSync(planFile, "utf-8");
     const plan = loadPlan(planContent);
     const viewer = new InteractivePlanViewer(plan, {
       filter: opts.filter,
@@ -50668,7 +51454,7 @@ program.command("view").description("Interactive plan viewer with navigation and
 program.command("deliverables:list").description("List all autopilot deliverables with metadata").option("--profile-dir <dir>", "Profile directory (default: .smartergpt)").option("--json", "Output JSON format").action(async (opts) => {
   try {
     const profile = resolveProfile(opts.profileDir);
-    const { DeliverablesManager } = await import("./autopilot-3OHEUTHD.js");
+    const { DeliverablesManager } = await import("./autopilot-7PX6YG55.js");
     const manager = new DeliverablesManager(profile.path);
     const deliverables = await manager.listDeliverables();
     if (opts.json) {
@@ -50694,7 +51480,7 @@ program.command("deliverables:list").description("List all autopilot deliverable
       });
       const latest = manager.getLatestPath();
       if (latest) {
-        console.log(`\u{1F4CD} Latest: ${path58.basename(latest)}`);
+        console.log(`\u{1F4CD} Latest: ${path59.basename(latest)}`);
       }
     }
   } catch (error) {
@@ -50707,7 +51493,7 @@ program.command("deliverables:list").description("List all autopilot deliverable
 program.command("deliverables:cleanup").description("Clean up old deliverables based on retention policy").option("--profile-dir <dir>", "Profile directory (default: .smartergpt)").option("--max-age <days>", "Maximum age in days (deletes older deliverables)").option("--max-count <count>", "Maximum number of deliverables to keep").option("--keep-latest", "Always keep the latest deliverables (default: true)", true).option("--dry-run", "Preview cleanup without deleting").option("--json", "Output JSON format").action(async (opts) => {
   try {
     const profile = resolveProfile(opts.profileDir);
-    const { DeliverablesManager } = await import("./autopilot-3OHEUTHD.js");
+    const { DeliverablesManager } = await import("./autopilot-7PX6YG55.js");
     const manager = new DeliverablesManager(profile.path);
     const policy = {
       maxAge: opts.maxAge ? parseInt(opts.maxAge) : void 0,
@@ -50768,8 +51554,8 @@ program.command("deliverables:cleanup").description("Clean up old deliverables b
         console.log(`Freed space: ${(result.freedSpace / 1024).toFixed(2)} KB`);
         if (result.removed.length > 0) {
           console.log("\nRemoved:");
-          result.removed.forEach((path59) => {
-            console.log(`  - ${path59}`);
+          result.removed.forEach((path60) => {
+            console.log(`  - ${path60}`);
           });
         }
       }
@@ -50840,8 +51626,8 @@ var isDirectExec = (() => {
   try {
     if (typeof import.meta === "undefined") return false;
     if (!process.argv[1] || !import.meta.url) return false;
-    const invokedPath = fs49.realpathSync(resolve14(process.argv[1]));
-    const modulePath = fs49.realpathSync(fileURLToPath6(import.meta.url));
+    const invokedPath = fs50.realpathSync(resolve15(process.argv[1]));
+    const modulePath = fs50.realpathSync(fileURLToPath6(import.meta.url));
     return invokedPath === modulePath;
   } catch {
     return false;
@@ -50911,11 +51697,17 @@ export {
   ConfigurationQueryService,
   ControllerLease_v1,
   DiscoveryQueryService,
+  EXECUTION_PLAN_ARTIFACT_CONTRACT,
+  EXECUTION_PLAN_CANONICALIZATION_PROFILE,
+  EXECUTION_PLAN_HASH_DOMAIN,
+  EXECUTION_PLAN_HASH_PROFILE,
   EngineVerificationCheckSource_v2,
   EngineVerificationDeterminism_v2,
   EngineVerificationTrustGapReason_v2,
   ExecutionEnvelope_v1,
   ExecutionEnvironmentOS,
+  ExecutionPlanArtifactIdentity_v1Schema,
+  ExecutionPlanArtifact_v1Schema,
   ExecutionState,
   ExternalAwaitOutcome_v1,
   ExternalAwaitableDescriptor_v1,
@@ -50971,6 +51763,11 @@ export {
   NativeWslProjectionSelection_v1,
   NativeWslProjectionStatusRequestJsonSchema,
   NativeWslSourceObservation_v1,
+  PLAN_ARTIFACT_REFERENCE_CONTRACT,
+  PlanArtifactReference_v1Schema,
+  PlanArtifactRegistrationError,
+  PlanArtifactRegistrationService,
+  PlanArtifactScope_v1Schema,
   PlanArtifactService,
   PlanArtifactServiceError,
   PlanCreationService,
@@ -51000,6 +51797,7 @@ export {
   completionForAttemptAwaitable,
   computeAgentEngineVerificationV2Hash,
   computeAgentTaskPacketHash,
+  computeExecutionPlanArtifactDigest,
   computeFanInEvidenceSetHash,
   computeMergeOrder,
   containsAttemptAwaitableCredentialValue,