@smartergpt/lexrunner 2.0.2 → 2.2.0

package/dist/{chunk-ARDKZW7F.js → chunk-M6AAYMHH.js}

@@ -31,7 +31,7 @@ import {
 } from "./chunk-AXOAVRTU.js";
 import {
   __require
-} from "./chunk-V3BU2VDU.js";
+} from "./chunk-PDDULIDL.js";
 
 // src/autopilot/types.ts
 import { z } from "zod";
@@ -1441,6 +1441,44 @@ function emitFailureReceipt(params, options = {}) {
   return emitActionReceipt({ ...params, outcome: "failure" }, options);
 }
 
+// src/git/input-schema.ts
+import { z as z3 } from "zod";
+function repositoryIdentity(value) {
+  const scp = /^git@([^/:]+):(.+)$/.exec(value);
+  const url = new URL(scp ? `ssh://git@${scp[1]}/${scp[2]}` : value);
+  if (!["https:", "ssh:", "file:"].includes(url.protocol) || url.password || url.search || url.hash || url.username && !(url.protocol === "ssh:" && url.username === "git"))
+    throw new Error("Repository must be an explicit HTTPS, SSH or file URL without credentials");
+  if (url.protocol === "file:") return url.href.replace(/\/$/, "");
+  if (!url.hostname || !/^\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/?$/.test(url.pathname)) {
+    throw new Error("Repository URL must identify an owner and repository");
+  }
+  const path11 = url.pathname.replace(/\/$/, "").replace(/\.git$/, "");
+  return `${url.hostname.toLowerCase()}${url.port ? `:${url.port}` : ""}${url.hostname.toLowerCase() === "github.com" ? path11.toLowerCase() : path11}`;
+}
+var GitCommitId = z3.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/);
+var GitRef = z3.string().max(512).regex(/^refs\/(?:heads\/.+|pull\/[1-9][0-9]*\/head)$/).refine(
+  (ref) => !/[\x00-\x20\x7f~^:?*\[\\]/.test(ref) && !ref.includes("..") && !ref.includes("@{") && ref.split("/").every(
+    (part) => !!part && !part.startsWith(".") && !part.endsWith(".") && !part.endsWith(".lock")
+  ),
+  "Invalid fully qualified Git ref"
+);
+var GitInput = z3.object({ ref: GitRef, commit: GitCommitId }).strict();
+var FrozenGitInputs = z3.object({
+  schemaVersion: z3.literal("1.0.0"),
+  repository: z3.string().max(2048).refine((value) => {
+    try {
+      repositoryIdentity(value);
+      return true;
+    } catch {
+      return false;
+    }
+  }, "An explicit repository URL without credentials is required"),
+  checkoutRemote: z3.string().max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/),
+  acquisition: z3.enum(["local-only", "fetch"]),
+  target: GitInput,
+  sources: z3.array(GitInput.extend({ item: z3.string().min(1).max(512) }).strict()).max(256)
+}).strict();
+
 // src/git/operations.ts
 var GitOperations = class {
   constructor(workingDir = process.cwd()) {
@@ -1539,38 +1577,46 @@ var GitOperations = class {
       const branchName = item.name;
       const premergeLog = await this.git.log(["-1"]);
       previousHead = premergeLog.latest?.hash || "HEAD";
-      const branches = await this.git.branch(["-a"]);
-      const branchExists = branches.all.some(
-        (branch) => branch === branchName || branch === `origin/${branchName}` || branch === `remotes/origin/${branchName}`
-      );
-      if (!branchExists) {
-        profiler.end(operationId);
-        metrics.incrementCounter(METRICS.MERGE_FAILURE_TOTAL, { reason: "branch_not_found" });
-        return {
-          success: false,
-          item,
-          message: `Branch ${branchName} not found`
-        };
+      let sourceRef = `origin/${branchName}`;
+      if (operation.sourceCommit !== void 0) {
+        sourceRef = GitCommitId.parse(operation.sourceCommit);
+        if ((await this.git.raw(["cat-file", "-t", sourceRef])).trim() !== "commit") {
+          throw new Error("Frozen merge source is not a commit object");
+        }
+      } else {
+        const branches = await this.git.branch(["-a"]);
+        const branchExists = branches.all.some(
+          (branch) => branch === branchName || branch === `origin/${branchName}` || branch === `remotes/origin/${branchName}`
+        );
+        if (!branchExists) {
+          profiler.end(operationId);
+          metrics.incrementCounter(METRICS.MERGE_FAILURE_TOTAL, { reason: "branch_not_found" });
+          return {
+            success: false,
+            item,
+            message: `Branch ${branchName} not found`
+          };
+        }
+        await this.git.fetch("origin", branchName);
       }
-      await this.git.fetch("origin", branchName);
       let gitMergeResult;
       let sha;
       let mergeError = null;
       try {
         switch (strategy) {
           case "merge-weave":
-            gitMergeResult = await this.git.merge([`origin/${branchName}`, "--no-ff"]);
+            gitMergeResult = await this.git.merge([sourceRef, "--no-ff"]);
             break;
           case "squash-weave":
-            gitMergeResult = await this.git.merge([`origin/${branchName}`, "--squash"]);
+            gitMergeResult = await this.git.merge([sourceRef, "--squash"]);
             if (gitMergeResult && !gitMergeResult.failed) {
               await this.git.commit(`Squash merge: ${item.name}`);
             }
             break;
           case "rebase-weave":
             try {
-              await this.git.rebase([`origin/${branchName}`]);
-              gitMergeResult = await this.git.merge([`origin/${branchName}`, "--ff-only"]);
+              await this.git.rebase([sourceRef]);
+              gitMergeResult = await this.git.merge([sourceRef, "--ff-only"]);
             } catch (rebaseError) {
               const conflictedFiles2 = await this.getConflictedFiles();
               profiler.end(operationId);
@@ -1690,6 +1736,9 @@ var GitOperations = class {
    * Execute merge pyramid with dependency ordering
    */
   async executeWeave(plan, levels, progressReporter) {
+    if (plan.gitInputs) {
+      throw new Error("Frozen Git inputs require the shared merge application/resume service");
+    }
     const results = [];
     let successful = 0;
     let failed = 0;
@@ -2115,7 +2164,7 @@ function validateGateInput(gateName, input) {
 }
 
 // src/runs/failures.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // src/runs/storage.ts
 import * as fs6 from "fs";
@@ -2280,57 +2329,57 @@ var RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set([
   FailureErrorCode.NETWORK_ERROR,
   FailureErrorCode.RATE_LIMITED
 ]);
-var FailureErrorSchema = z3.object({
+var FailureErrorSchema = z4.object({
   /** Error code for classification */
-  code: z3.string(),
+  code: z4.string(),
   /** Human-readable error message */
-  message: z3.string(),
+  message: z4.string(),
   /** Whether the error is retryable */
-  retryable: z3.boolean(),
+  retryable: z4.boolean(),
   /** Optional hint for recovery */
-  hint: z3.string().optional()
+  hint: z4.string().optional()
 });
-var RecommendedActionSchema = z3.object({
+var RecommendedActionSchema = z4.object({
   /** Action identifier */
-  action: z3.string(),
+  action: z4.string(),
   /** Action description */
-  description: z3.string(),
+  description: z4.string(),
   /** Whether this action requires LLM decision */
-  requiresLLMDecision: z3.boolean().optional(),
+  requiresLLMDecision: z4.boolean().optional(),
   /** Prompt for LLM decision */
-  prompt: z3.string().optional(),
+  prompt: z4.string().optional(),
   /** JSON schema for response */
-  responseSchema: z3.record(z3.string(), z3.unknown()).optional(),
+  responseSchema: z4.record(z4.string(), z4.unknown()).optional(),
   /** Risk level assessment */
-  riskLevel: z3.enum(["low", "medium", "high"]).optional()
+  riskLevel: z4.enum(["low", "medium", "high"]).optional()
 });
-var FailureRecordSchema = z3.object({
+var FailureRecordSchema = z4.object({
   /** ISO 8601 timestamp */
-  timestamp: z3.string(),
+  timestamp: z4.string(),
   /** Run identifier */
-  runId: z3.string(),
+  runId: z4.string(),
   /** Gate name that failed */
-  gate: z3.string(),
+  gate: z4.string(),
   /** Structured error information */
   error: FailureErrorSchema,
   /** Whether the error was retryable */
-  retryable: z3.boolean(),
+  retryable: z4.boolean(),
   /** Action taken to handle the failure */
-  actionTaken: z3.string().optional(),
+  actionTaken: z4.string().optional(),
   /** Rationale for the action taken */
-  rationale: z3.string().optional(),
+  rationale: z4.string().optional(),
   /** Exit code from gate execution */
-  exitCode: z3.number().optional(),
+  exitCode: z4.number().optional(),
   /** Duration in milliseconds */
-  duration_ms: z3.number().optional()
+  duration_ms: z4.number().optional()
 });
-var FailureHandlingPayloadSchema = z3.object({
+var FailureHandlingPayloadSchema = z4.object({
   /** Structured error information */
   error: FailureErrorSchema,
   /** Recommended actions for recovery */
-  recommendedActions: z3.array(RecommendedActionSchema),
+  recommendedActions: z4.array(RecommendedActionSchema),
   /** Schema for failure record logging */
-  failureRecordSchema: z3.record(z3.string(), z3.unknown()).optional()
+  failureRecordSchema: z4.record(z4.string(), z4.unknown()).optional()
 });
 function classifyGateError(gateName, stderr, exitCode, isFlaky) {
   const errorMessage = stderr.toLowerCase();
@@ -2565,17 +2614,17 @@ function emitGateReceipt(gateName, itemName, passed, duration, runId, options =
 }
 
 // src/hostility/score.ts
-import { z as z4 } from "zod";
-var HostilityComponentSchema = z4.object({
-  score: z4.number().min(0).max(1),
-  status: z4.enum(["good", "warning", "critical"]),
-  details: z4.string(),
-  recommendation: z4.string().optional()
+import { z as z5 } from "zod";
+var HostilityComponentSchema = z5.object({
+  score: z5.number().min(0).max(1),
+  status: z5.enum(["good", "warning", "critical"]),
+  details: z5.string(),
+  recommendation: z5.string().optional()
 });
-var HostilityScoreSchema = z4.object({
-  total: z4.number().min(0).max(1),
-  status: z4.enum(["low", "medium", "high"]),
-  components: z4.object({
+var HostilityScoreSchema = z5.object({
+  total: z5.number().min(0).max(1),
+  status: z5.enum(["low", "medium", "high"]),
+  components: z5.object({
     constraintClarity: HostilityComponentSchema,
     requirementExplicitness: HostilityComponentSchema,
     problemBoundedness: HostilityComponentSchema,
@@ -2584,7 +2633,7 @@ var HostilityScoreSchema = z4.object({
     stateCoherence: HostilityComponentSchema,
     modelContinuity: HostilityComponentSchema
   }),
-  recommendations: z4.array(z4.string())
+  recommendations: z5.array(z5.string())
 });
 var COMPONENT_LABELS = {
   constraintClarity: "Constraint Clarity",
@@ -3220,29 +3269,29 @@ import {
   writeFileSync as writeFileSync5
 } from "fs";
 import { basename as basename2, delimiter, dirname, extname, isAbsolute as isAbsolute2, join as join9, resolve as resolve5 } from "path";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/schema.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/tiers/schema.ts
-import { z as z5 } from "zod";
-var CapabilityTier = z5.enum(["senior", "mid", "junior"]);
-var TierAssignment = z5.object({
+import { z as z6 } from "zod";
+var CapabilityTier = z6.enum(["senior", "mid", "junior"]);
+var TierAssignment = z6.object({
   /** Suggested tier based on heuristics */
   suggested: CapabilityTier,
   /** Actual tier used during execution (may differ due to override) */
   actual: CapabilityTier.optional(),
   /** Whether the task was escalated to a higher tier */
-  escalated: z5.boolean().default(false),
+  escalated: z6.boolean().default(false),
   /** Reason for escalation if applicable */
-  escalationReason: z5.string().optional(),
+  escalationReason: z6.string().optional(),
   /** Whether actual tier differs from suggested tier */
-  mismatch: z5.boolean().optional()
+  mismatch: z6.boolean().optional()
 });
-var TierOverride = z5.object({
+var TierOverride = z6.object({
   /** Item name to override */
-  itemName: z5.string(),
+  itemName: z6.string(),
   /** Tier to assign */
   tier: CapabilityTier
 });
@@ -3274,38 +3323,38 @@ function parseTierOverrides(overrides) {
 }
 
 // src/schema.ts
-var GateStatus = z6.enum(["pass", "fail", "blocked", "skipped", "retrying"]);
-var NodeStatus = z6.enum(["pass", "fail", "blocked", "skipped", "retrying"]);
-var GateResult = z6.object({
-  gate: z6.string(),
+var GateStatus = z7.enum(["pass", "fail", "blocked", "skipped", "retrying"]);
+var NodeStatus = z7.enum(["pass", "fail", "blocked", "skipped", "retrying"]);
+var GateResult = z7.object({
+  gate: z7.string(),
   status: GateStatus,
-  exitCode: z6.number().optional(),
-  duration: z6.number().optional(),
+  exitCode: z7.number().optional(),
+  duration: z7.number().optional(),
   // milliseconds
-  timeoutMs: z6.number().int().positive().optional(),
+  timeoutMs: z7.number().int().positive().optional(),
   // effective timeout used for this gate
-  stdout: z6.string().optional(),
-  stderr: z6.string().optional(),
-  failureKind: z6.enum(["nonzero_exit", "spawn_error", "timeout", "evidence_error"]).optional(),
-  timeoutCleanup: z6.object({
-    method: z6.enum(["process-group", "taskkill", "direct-child"]),
-    forceKilled: z6.boolean(),
-    descendantsReaped: z6.boolean()
+  stdout: z7.string().optional(),
+  stderr: z7.string().optional(),
+  failureKind: z7.enum(["nonzero_exit", "spawn_error", "timeout", "evidence_error"]).optional(),
+  timeoutCleanup: z7.object({
+    method: z7.enum(["process-group", "taskkill", "direct-child"]),
+    forceKilled: z7.boolean(),
+    descendantsReaped: z7.boolean()
   }).optional(),
-  artifacts: z6.array(z6.string()).optional(),
-  attempts: z6.number().default(1),
-  lastAttempt: z6.string().optional()
+  artifacts: z7.array(z7.string()).optional(),
+  attempts: z7.number().default(1),
+  lastAttempt: z7.string().optional()
   // ISO timestamp
 });
-var NodeResult = z6.object({
-  name: z6.string(),
+var NodeResult = z7.object({
+  name: z7.string(),
   status: NodeStatus,
-  gates: z6.array(GateResult).default([]),
-  blockedBy: z6.array(z6.string()).optional(),
+  gates: z7.array(GateResult).default([]),
+  blockedBy: z7.array(z7.string()).optional(),
   // names of nodes that blocked this one
-  eligibleForMerge: z6.boolean().default(false)
+  eligibleForMerge: z7.boolean().default(false)
 });
-var SchemaVersion = z6.string().regex(/^1\.\d+\.\d+$/, "Schema version must be 1.x.y format");
+var SchemaVersion = z7.string().regex(/^1\.\d+\.\d+$/, "Schema version must be 1.x.y format");
 function validateSchemaVersion(version) {
   const parsed = SchemaVersion.safeParse(version);
   if (!parsed.success) {
@@ -3324,30 +3373,30 @@ function validateSchemaVersion(version) {
     throw new AXErrorException(axError.code, axError.message, axError.nextActions, axError.context);
   }
 }
-var RetryConfig = z6.object({
-  maxAttempts: z6.number().int().min(1).default(1),
-  backoffSeconds: z6.number().min(0).default(0)
+var RetryConfig = z7.object({
+  maxAttempts: z7.number().int().min(1).default(1),
+  backoffSeconds: z7.number().min(0).default(0)
 });
-var AdminOverride = z6.object({
-  allowedUsers: z6.array(z6.string()).optional(),
-  requireReason: z6.boolean().default(false)
+var AdminOverride = z7.object({
+  allowedUsers: z7.array(z7.string()).optional(),
+  requireReason: z7.boolean().default(false)
 });
-var MergeRule = z6.object({
-  type: z6.enum(["strict-required"]).default("strict-required")
+var MergeRule = z7.object({
+  type: z7.enum(["strict-required"]).default("strict-required")
   // Future: could add "best-effort", "admin-override-allowed", etc.
 });
-var PerformanceConfig = z6.object({
-  maxMemoryMB: z6.number().int().min(128).optional(),
+var PerformanceConfig = z7.object({
+  maxMemoryMB: z7.number().int().min(128).optional(),
   // Memory limit in MB
-  batchSize: z6.number().int().min(1).default(50),
+  batchSize: z7.number().int().min(1).default(50),
   // Batch size for large plans
-  cacheTTLSeconds: z6.number().int().min(0).default(3600),
+  cacheTTLSeconds: z7.number().int().min(0).default(3600),
   // Cache TTL in seconds
-  enableCaching: z6.boolean().default(true),
+  enableCaching: z7.boolean().default(true),
   // Enable operation caching
-  throttleOnMemory: z6.boolean().default(true),
+  throttleOnMemory: z7.boolean().default(true),
   // Throttle workers when memory high
-  memoryThresholdPercent: z6.number().min(0).max(100).default(80)
+  memoryThresholdPercent: z7.number().min(0).max(100).default(80)
   // Memory threshold %
 }).default(() => ({
   batchSize: 50,
@@ -3356,73 +3405,84 @@ var PerformanceConfig = z6.object({
   throttleOnMemory: true,
   memoryThresholdPercent: 80
 }));
-var VulnPolicy = z6.object({
-  blockCritical: z6.boolean().default(true),
-  blockHigh: z6.boolean().default(true),
-  maxMedium: z6.number().int().min(0).default(5),
-  maxLow: z6.number().int().min(0).default(10)
+var VulnPolicy = z7.object({
+  blockCritical: z7.boolean().default(true),
+  blockHigh: z7.boolean().default(true),
+  maxMedium: z7.number().int().min(0).default(5),
+  maxLow: z7.number().int().min(0).default(10)
 }).default(() => ({
   blockCritical: true,
   blockHigh: true,
   maxMedium: 5,
   maxLow: 10
 }));
-var Policy = z6.object({
-  requiredGates: z6.array(z6.string()).default([]),
-  optionalGates: z6.array(z6.string()).default([]),
-  maxWorkers: z6.number().int().min(1).default(1),
-  retries: z6.record(z6.string(), RetryConfig).default(() => ({})),
-  overrides: z6.object({
+var Policy = z7.object({
+  requiredGates: z7.array(z7.string()).default([]),
+  optionalGates: z7.array(z7.string()).default([]),
+  maxWorkers: z7.number().int().min(1).default(1),
+  retries: z7.record(z7.string(), RetryConfig).default(() => ({})),
+  overrides: z7.object({
     adminGreen: AdminOverride.optional()
   }).default(() => ({})),
-  blockOn: z6.array(z6.string()).default([]),
+  blockOn: z7.array(z7.string()).default([]),
   mergeRule: MergeRule.default({ type: "strict-required" }),
   performance: PerformanceConfig.optional(),
   // Performance tuning options
   security: VulnPolicy.optional()
   // Security/vulnerability thresholds for vuln gate
 });
-var ContainerMount = z6.object({
-  source: z6.string(),
-  target: z6.string(),
-  type: z6.enum(["bind", "volume"]).default("bind")
+var ContainerMount = z7.object({
+  source: z7.string(),
+  target: z7.string(),
+  type: z7.enum(["bind", "volume"]).default("bind")
 });
-var ContainerSpec = z6.object({
-  image: z6.string(),
-  entrypoint: z6.array(z6.string()).optional(),
-  mounts: z6.array(ContainerMount).optional()
+var ContainerSpec = z7.object({
+  image: z7.string(),
+  entrypoint: z7.array(z7.string()).optional(),
+  mounts: z7.array(ContainerMount).optional()
 });
-var Gate = z6.object({
-  name: z6.string(),
-  run: z6.string(),
-  cwd: z6.string().optional(),
-  env: z6.record(z6.string(), z6.string()).default(() => ({})),
+var Gate = z7.object({
+  name: z7.string(),
+  run: z7.string(),
+  cwd: z7.string().optional(),
+  env: z7.record(z7.string(), z7.string()).default(() => ({})),
   // Runtime configuration
-  runtime: z6.enum(["local", "container", "ci-service"]).default("local"),
+  runtime: z7.enum(["local", "container", "ci-service"]).default("local"),
   // Container spec (only used when runtime is "container")
   container: ContainerSpec.optional(),
   // Expected artifact paths (for output collection)
-  artifacts: z6.array(z6.string()).default([]),
+  artifacts: z7.array(z7.string()).default([]),
   // Optional input data for gates that require structured inputs (validated against gate-specific schemas)
-  input: z6.record(z6.string(), z6.unknown()).optional(),
+  input: z7.record(z7.string(), z7.unknown()).optional(),
   // Exact per-gate timeout. Overrides the operation default after hostility adjustment.
-  timeoutMs: z6.number().int().positive().max(24 * 60 * 60 * 1e3).optional()
+  timeoutMs: z7.number().int().positive().max(24 * 60 * 60 * 1e3).optional()
 }).strict();
-var PlanItem = z6.object({
-  name: z6.string(),
-  deps: z6.string().array().default([]),
+var PlanItem = z7.object({
+  name: z7.string(),
+  deps: z7.string().array().default([]),
   // Dependency references by item name
-  gates: z6.array(Gate).default([]),
+  gates: z7.array(Gate).default([]),
   // Tier routing for governance (optional - added during plan generation or execution)
   tier: TierAssignment.optional()
 }).strict();
-var Plan = z6.object({
+var Plan = z7.object({
   schemaVersion: SchemaVersion,
-  target: z6.string().default("main"),
+  target: z7.string().default("main"),
   policy: Policy.optional(),
-  items: z6.array(PlanItem).default([])
+  items: z7.array(PlanItem).default([]),
+  gitInputs: FrozenGitInputs.optional()
 }).strict().superRefine((plan, context) => {
   const itemNames = /* @__PURE__ */ new Set();
+  if (plan.gitInputs) {
+    const sources = plan.gitInputs.sources.map((source) => source.item);
+    if (plan.gitInputs.target.ref !== `refs/heads/${plan.target}` || new Set(sources).size !== sources.length || sources.length !== plan.items.length || plan.items.some((item) => !sources.includes(item.name))) {
+      context.addIssue({
+        code: "custom",
+        path: ["gitInputs"],
+        message: "Git inputs must bind the target and every plan item exactly once"
+      });
+    }
+  }
   let duplicateItemNameFound = false;
   const duplicateGateNameItemIndexes = [];
   for (const [itemIndex, item] of plan.items.entries()) {
@@ -3647,7 +3707,7 @@ function loadPlan(planContent) {
 
 // src/schemas/task-contract.ts
 import { createHash } from "crypto";
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var TASK_CONTRACT_VERSION = "1.0.0";
 function computeCanonicalHash(obj) {
   const canonical = JSON.stringify(obj, sortedReplacer);
@@ -3669,111 +3729,111 @@ function sortedReplacer(_key, value) {
   }
   return value;
 }
-var DeterminismLevel = z7.enum(["D1", "D2", "D3"]);
-var ConfidenceLevel2 = z7.enum(["high", "medium", "low"]);
-var SourceOfTruthKind = z7.enum(["symbol", "file", "registry"]);
-var AssumptionType = z7.enum(["scope", "codebase", "env", "intent", "dependency", "test"]);
-var RepoRelativePath = z7.string().refine((p) => !p.startsWith("/"), {
+var DeterminismLevel = z8.enum(["D1", "D2", "D3"]);
+var ConfidenceLevel2 = z8.enum(["high", "medium", "low"]);
+var SourceOfTruthKind = z8.enum(["symbol", "file", "registry"]);
+var AssumptionType = z8.enum(["scope", "codebase", "env", "intent", "dependency", "test"]);
+var RepoRelativePath = z8.string().refine((p) => !p.startsWith("/"), {
   message: "Path must be repo-relative (no leading slash)"
 }).refine((p) => !p.includes(":\\") && !p.includes(":/"), {
   message: "Path must not be absolute (no drive letters)"
 }).refine((p) => !p.startsWith(".."), {
   message: "Path must not escape repo root"
 });
-var GlobPattern = z7.string().min(1);
-var SHA256Hash = z7.string().regex(/^sha256:[a-f0-9]{64}$/, "Must be sha256:<64-hex-chars>");
-var SHA256HashOrPlaceholder = z7.string().refine((h) => h.startsWith("sha256:"), {
+var GlobPattern = z8.string().min(1);
+var SHA256Hash = z8.string().regex(/^sha256:[a-f0-9]{64}$/, "Must be sha256:<64-hex-chars>");
+var SHA256HashOrPlaceholder = z8.string().refine((h) => h.startsWith("sha256:"), {
   message: "Must start with sha256:"
 });
-var RepoProvenance = z7.object({
+var RepoProvenance = z8.object({
   /** Repository identifier (owner/name) */
-  id: z7.string().regex(/^[^/]+\/[^/]+$/, "Must be owner/repo format"),
+  id: z8.string().regex(/^[^/]+\/[^/]+$/, "Must be owner/repo format"),
   /** Absolute path to repo root (engine-local, for resolution) */
-  root: z7.string(),
+  root: z8.string(),
   /** Pinned commit SHA */
-  commit_sha: z7.string().min(7)
+  commit_sha: z8.string().min(7)
 });
-var ScopeBoundary = z7.object({
+var ScopeBoundary = z8.object({
   /** Globs for files agent can read */
-  read_globs: z7.array(GlobPattern),
+  read_globs: z8.array(GlobPattern),
   /** Globs for files agent can modify */
-  write_globs: z7.array(GlobPattern),
+  write_globs: z8.array(GlobPattern),
   /** Globs for files explicitly denied (always applied) */
-  deny_globs: z7.array(GlobPattern),
+  deny_globs: z8.array(GlobPattern),
   /** Whether cross-repo operations are permitted */
-  cross_repo_allowed: z7.boolean()
+  cross_repo_allowed: z8.boolean()
 });
-var FailureEvidence = z7.object({
+var FailureEvidence = z8.object({
   /** Short error description */
-  message: z7.string(),
+  message: z8.string(),
   /** Repo-relative path to failed file */
   file_rel: RepoRelativePath,
   /** Line number if available */
-  line: z7.number().int().positive().optional(),
+  line: z8.number().int().positive().optional(),
   /** Actual test runner output snippet */
-  runner_output_snip: z7.string(),
+  runner_output_snip: z8.string(),
   /** Code context around failure */
-  excerpt: z7.string().optional()
+  excerpt: z8.string().optional()
 });
-var HintEdit = z7.object({
-  find: z7.string(),
-  replace: z7.string()
+var HintEdit = z8.object({
+  find: z8.string(),
+  replace: z8.string()
 });
-var Target = z7.object({
+var Target = z8.object({
   /** Repo-relative file path */
   path_rel: RepoRelativePath,
   /** Anchored code context (±N lines) */
-  hunk: z7.string(),
+  hunk: z8.string(),
   /** SHA256 of hunk for drift detection */
   hunk_sha256: SHA256HashOrPlaceholder,
   /** Optional find/replace suggestion */
   hint_edit: HintEdit.optional()
 });
-var IntroducingChange = z7.object({
-  commit_sha: z7.string().min(7),
-  diff_hunk: z7.string()
+var IntroducingChange = z8.object({
+  commit_sha: z8.string().min(7),
+  diff_hunk: z8.string()
 });
-var SourceOfTruth = z7.object({
+var SourceOfTruth = z8.object({
   /** Kind of source */
   kind: SourceOfTruthKind,
   /** Repo-relative path */
   path_rel: RepoRelativePath,
   /** Repository ID (defaults to snapshot repo if omitted) */
-  repo_id: z7.string().optional(),
+  repo_id: z8.string().optional(),
   /** Commit SHA (defaults to snapshot commit if omitted) */
-  commit_sha: z7.string().optional(),
+  commit_sha: z8.string().optional(),
   /** Canonical excerpt */
-  excerpt: z7.string(),
+  excerpt: z8.string(),
   /** Lexmap module ID if applicable */
-  lexmap_module_id: z7.string().optional(),
+  lexmap_module_id: z8.string().optional(),
   /** Change that introduced this */
   introducing_change: IntroducingChange.optional()
 });
-var VerificationExpectations = z7.object({
+var VerificationExpectations = z8.object({
   /** Command to run */
-  cmd: z7.string(),
+  cmd: z8.string(),
   /** Expected results */
-  expect: z7.object({
+  expect: z8.object({
     /** Expected exit code (usually 0) */
-    exit_code: z7.number().int(),
+    exit_code: z8.number().int(),
     /** Strings that must appear in output */
-    must_include: z7.array(z7.string()).optional(),
+    must_include: z8.array(z8.string()).optional(),
     /** Strings that must not appear */
-    must_not_include: z7.array(z7.string()).optional()
+    must_not_include: z8.array(z8.string()).optional()
   })
 });
-var Budget = z7.object({
+var Budget = z8.object({
   /** Token budget hint in bytes */
-  max_bytes: z7.number().int().positive().optional(),
+  max_bytes: z8.number().int().positive().optional(),
   /** Fields that were truncated (empty if none) */
-  truncated_fields: z7.array(z7.string())
+  truncated_fields: z8.array(z8.string())
 });
-var TaskSnapshot_v1 = z7.object({
+var TaskSnapshot_v1 = z8.object({
   // Schema version
-  schema_version: z7.literal(TASK_CONTRACT_VERSION),
+  schema_version: z8.literal(TASK_CONTRACT_VERSION),
   // Identity
-  task_id: z7.string().min(1),
-  procedure: z7.string().min(1),
+  task_id: z8.string().min(1),
+  procedure: z8.string().min(1),
   determinism: DeterminismLevel,
   snapshot_hash: SHA256HashOrPlaceholder,
   // Provenance (MUST)
@@ -3783,9 +3843,9 @@ var TaskSnapshot_v1 = z7.object({
   // Failure evidence (MUST)
   failure: FailureEvidence,
   // Invariants (SHOULD) - anti-brittleness constraints
-  invariants: z7.array(z7.string()).optional(),
+  invariants: z8.array(z8.string()).optional(),
   // Targets (MUST, array)
-  targets: z7.array(Target).min(1),
+  targets: z8.array(Target).min(1),
   // Source of truth (SHOULD)
   source_of_truth: SourceOfTruth.optional(),
   // Verification expectations (MUST)
@@ -3793,183 +3853,183 @@ var TaskSnapshot_v1 = z7.object({
   // Budget/truncation (MUST)
   budget: Budget,
   // Output contract
-  receipt_schema_id: z7.string()
+  receipt_schema_id: z8.string()
 });
-var StructuredAssumption = z7.object({
+var StructuredAssumption = z8.object({
   /** Type of assumption */
   type: AssumptionType,
   /** Assumption text */
-  text: z7.string(),
+  text: z8.string(),
   /** Whether it was validated */
-  validated: z7.boolean().optional(),
+  validated: z8.boolean().optional(),
   /** Evidence supporting validation */
-  evidence: z7.string().optional()
+  evidence: z8.string().optional()
 });
-var AgentClaims = z7.object({
+var AgentClaims = z8.object({
   /** Whether the task succeeded */
-  success: z7.boolean(),
+  success: z8.boolean(),
   /** Unified diff patch */
-  patch: z7.string().optional(),
+  patch: z8.string().optional(),
   /** Files touched (repo-relative) */
-  files_touched: z7.array(RepoRelativePath),
+  files_touched: z8.array(RepoRelativePath),
   /** Rationale for the fix */
-  rationale: z7.string(),
+  rationale: z8.string(),
   /** Confidence level */
   confidence: ConfidenceLevel2,
   /** Which invariants were respected */
-  invariants_respected: z7.array(z7.string()).optional(),
+  invariants_respected: z8.array(z8.string()).optional(),
   /** Structured assumptions made */
-  assumptions_made: z7.array(StructuredAssumption)
+  assumptions_made: z8.array(StructuredAssumption)
 });
-var SearchActivity = z7.object({
+var SearchActivity = z8.object({
   /** Search query */
-  query: z7.string(),
+  query: z8.string(),
   /** Search method used */
-  method: z7.string().optional(),
+  method: z8.string().optional(),
   /** Roots searched (repo-relative) */
-  roots: z7.array(z7.string()),
+  roots: z8.array(z8.string()),
   /** Number of results found */
-  results_count: z7.number().int().nonnegative().optional(),
+  results_count: z8.number().int().nonnegative().optional(),
   /** Time taken in milliseconds */
-  time_ms: z7.number().nonnegative().optional()
+  time_ms: z8.number().nonnegative().optional()
 });
-var TokenUsage = z7.object({
-  input: z7.number().int().nonnegative(),
-  output: z7.number().int().nonnegative(),
-  total: z7.number().int().nonnegative()
+var TokenUsage = z8.object({
+  input: z8.number().int().nonnegative(),
+  output: z8.number().int().nonnegative(),
+  total: z8.number().int().nonnegative()
 });
-var CostTracking = z7.object({
+var CostTracking = z8.object({
   /** Token usage breakdown */
   token_usage: TokenUsage.optional(),
   /** Number of tool calls made */
-  tool_calls_count: z7.number().int().nonnegative().optional(),
+  tool_calls_count: z8.number().int().nonnegative().optional(),
   /** Elapsed time in milliseconds */
-  elapsed_ms: z7.number().nonnegative().optional()
+  elapsed_ms: z8.number().nonnegative().optional()
 });
-var AgentVerification = z7.object({
+var AgentVerification = z8.object({
   /** Whether verification command was run */
-  cmd_ran: z7.boolean(),
+  cmd_ran: z8.boolean(),
   /** Exit code if run */
-  exit_code: z7.number().int().optional(),
+  exit_code: z8.number().int().optional(),
   /** Output snippet */
-  output_snip: z7.string().optional()
+  output_snip: z8.string().optional()
 });
-var TaskReceipt_v1 = z7.object({
+var TaskReceipt_v1 = z8.object({
   // Schema version
-  schema_version: z7.literal(TASK_CONTRACT_VERSION),
+  schema_version: z8.literal(TASK_CONTRACT_VERSION),
   // Identity (echo from snapshot)
-  task_id: z7.string().min(1),
+  task_id: z8.string().min(1),
   snapshot_hash: SHA256HashOrPlaceholder,
   // Claims (what agent says it did)
   claims: AgentClaims,
   // Search activity (if agent searched)
-  search_activity: z7.array(SearchActivity),
+  search_activity: z8.array(SearchActivity),
   // Cost tracking
   cost: CostTracking,
   // Agent's verification attempt (still a claim)
   agent_verification: AgentVerification.optional(),
   // Blockers (if not successful)
-  blockers: z7.array(z7.string())
+  blockers: z8.array(z8.string())
 });
-var DetectedFailure = z7.object({
-  type: z7.string(),
-  message: z7.string(),
-  file: z7.string().optional(),
-  line: z7.number().int().positive().optional()
+var DetectedFailure = z8.object({
+  type: z8.string(),
+  message: z8.string(),
+  file: z8.string().optional(),
+  line: z8.number().int().positive().optional()
 });
-var EngineVerification_v1 = z7.object({
+var EngineVerification_v1 = z8.object({
   // Identity
-  task_id: z7.string().min(1),
-  timestamp: z7.string().datetime(),
+  task_id: z8.string().min(1),
+  timestamp: z8.string().datetime(),
   // Hash binding (audit trail)
   snapshot_hash: SHA256HashOrPlaceholder,
   receipt_hash: SHA256HashOrPlaceholder,
   // Verification result
-  verified: z7.boolean(),
+  verified: z8.boolean(),
   // What engine ran
-  cmd_ran: z7.string(),
-  exit_code: z7.number().int(),
-  stdout_snip: z7.string(),
-  stderr_snip: z7.string(),
+  cmd_ran: z8.string(),
+  exit_code: z8.number().int(),
+  stdout_snip: z8.string(),
+  stderr_snip: z8.string(),
   // Patch verification
   patch_hash: SHA256HashOrPlaceholder.optional(),
-  patch_applied: z7.boolean(),
+  patch_applied: z8.boolean(),
   // Comparison with agent claim
-  agent_claimed: z7.boolean(),
-  trust_gap: z7.boolean(),
+  agent_claimed: z8.boolean(),
+  trust_gap: z8.boolean(),
   // Failures detected
-  failures: z7.array(DetectedFailure)
+  failures: z8.array(DetectedFailure)
 });
 
 // src/gates/execution-receipt.ts
 var GATE_EXECUTION_RECEIPT_SCHEMA_VERSION = "lexrunner-gate-execution-receipt/v2";
 var MAX_GATE_RECEIPT_OUTPUT_BYTES = 64 * 1024;
-var FileIdentitySchema = z8.object({
-  path: z8.string(),
-  realPath: z8.string(),
-  bytes: z8.number().int().nonnegative(),
-  mtimeMs: z8.number().nonnegative(),
-  sha256: z8.string().regex(/^sha256:[a-f0-9]{64}$/u)
+var FileIdentitySchema = z9.object({
+  path: z9.string(),
+  realPath: z9.string(),
+  bytes: z9.number().int().nonnegative(),
+  mtimeMs: z9.number().nonnegative(),
+  sha256: z9.string().regex(/^sha256:[a-f0-9]{64}$/u)
 }).strict();
-var OutputEvidenceSchema = z8.object({
-  bytes: z8.number().int().nonnegative(),
-  sha256: z8.string().regex(/^sha256:[a-f0-9]{64}$/u),
-  truncated: z8.boolean(),
-  content: z8.string().max(MAX_GATE_RECEIPT_OUTPUT_BYTES)
+var OutputEvidenceSchema = z9.object({
+  bytes: z9.number().int().nonnegative(),
+  sha256: z9.string().regex(/^sha256:[a-f0-9]{64}$/u),
+  truncated: z9.boolean(),
+  content: z9.string().max(MAX_GATE_RECEIPT_OUTPUT_BYTES)
 }).strict();
-var ArtifactIdentitySchema = z8.object({
-  declaredPath: z8.string(),
-  resolvedPath: z8.string(),
-  status: z8.enum(["collected", "missing", "stale", "unsupported", "collection_error"]),
+var ArtifactIdentitySchema = z9.object({
+  declaredPath: z9.string(),
+  resolvedPath: z9.string(),
+  status: z9.enum(["collected", "missing", "stale", "unsupported", "collection_error"]),
   before: FileIdentitySchema.nullable(),
   source: FileIdentitySchema.nullable(),
-  retainedPath: z8.string().optional(),
+  retainedPath: z9.string().optional(),
   retained: FileIdentitySchema.optional(),
-  error: z8.string().optional()
+  error: z9.string().optional()
 }).strict();
-var LocalGateExecutionReceiptSchema = z8.object({
-  schemaVersion: z8.literal(GATE_EXECUTION_RECEIPT_SCHEMA_VERSION),
-  attempt: z8.number().int().positive(),
-  binding: z8.object({
-    item: z8.string().min(1).nullable(),
-    declaredGateDigest: z8.string().regex(/^sha256:[a-f0-9]{64}$/u),
-    candidateDigest: z8.string().regex(/^sha256:[a-f0-9]{64}$/u).nullable(),
-    timeoutMs: z8.number().int().positive()
+var LocalGateExecutionReceiptSchema = z9.object({
+  schemaVersion: z9.literal(GATE_EXECUTION_RECEIPT_SCHEMA_VERSION),
+  attempt: z9.number().int().positive(),
+  binding: z9.object({
+    item: z9.string().min(1).nullable(),
+    declaredGateDigest: z9.string().regex(/^sha256:[a-f0-9]{64}$/u),
+    candidateDigest: z9.string().regex(/^sha256:[a-f0-9]{64}$/u).nullable(),
+    timeoutMs: z9.number().int().positive()
   }).strict(),
-  declaredGate: z8.object({
-    name: z8.string(),
-    run: z8.string(),
-    cwd: z8.string().nullable(),
-    runtime: z8.enum(["local", "container", "ci-service"]),
-    artifacts: z8.array(z8.string())
+  declaredGate: z9.object({
+    name: z9.string(),
+    run: z9.string(),
+    cwd: z9.string().nullable(),
+    runtime: z9.enum(["local", "container", "ci-service"]),
+    artifacts: z9.array(z9.string())
   }).strict(),
-  execution: z8.object({
-    cwd: z8.string(),
-    startedAt: z8.string(),
-    finishedAt: z8.string(),
-    durationMs: z8.number().nonnegative(),
-    shell: z8.object({
-      command: z8.enum(["bash", "pwsh"]),
+  execution: z9.object({
+    cwd: z9.string(),
+    startedAt: z9.string(),
+    finishedAt: z9.string(),
+    durationMs: z9.number().nonnegative(),
+    shell: z9.object({
+      command: z9.enum(["bash", "pwsh"]),
       executable: FileIdentitySchema.nullable(),
-      argv: z8.array(z8.string()),
+      argv: z9.array(z9.string()),
       identityAfter: FileIdentitySchema.nullable(),
-      unchanged: z8.boolean(),
-      spawned: z8.boolean()
+      unchanged: z9.boolean(),
+      spawned: z9.boolean()
     }).strict()
   }).strict(),
-  outcome: z8.object({
-    status: z8.enum(["pass", "fail", "blocked", "skipped", "retrying"]),
-    exitCode: z8.number().int().nullable(),
-    failureKind: z8.enum(["nonzero_exit", "spawn_error", "timeout", "evidence_error"]).nullable(),
-    timeoutCleanup: z8.object({
-      method: z8.enum(["process-group", "taskkill", "direct-child"]),
-      forceKilled: z8.boolean(),
-      descendantsReaped: z8.boolean()
+  outcome: z9.object({
+    status: z9.enum(["pass", "fail", "blocked", "skipped", "retrying"]),
+    exitCode: z9.number().int().nullable(),
+    failureKind: z9.enum(["nonzero_exit", "spawn_error", "timeout", "evidence_error"]).nullable(),
+    timeoutCleanup: z9.object({
+      method: z9.enum(["process-group", "taskkill", "direct-child"]),
+      forceKilled: z9.boolean(),
+      descendantsReaped: z9.boolean()
     }).strict().nullable(),
-    evidenceComplete: z8.boolean()
+    evidenceComplete: z9.boolean()
   }).strict(),
-  output: z8.object({ stdout: OutputEvidenceSchema, stderr: OutputEvidenceSchema }).strict(),
-  artifacts: z8.array(ArtifactIdentitySchema)
+  output: z9.object({ stdout: OutputEvidenceSchema, stderr: OutputEvidenceSchema }).strict(),
+  artifacts: z9.array(ArtifactIdentitySchema)
 }).strict();
 function parseLocalGateExecutionReceipt(value) {
   return LocalGateExecutionReceiptSchema.parse(value);
@@ -4377,7 +4437,7 @@ async function executeLocalGate(gate, artifactDir, attempt, startedAt, startTime
     });
   }
   try {
-    const { getCommandValidator } = await import("./commandValidator-LVEMJTZP.js");
+    const { getCommandValidator } = await import("./commandValidator-XFVNCZXX.js");
     const validator = getCommandValidator();
     validator.validate(gate.run);
   } catch (validationError) {
@@ -6038,6 +6098,14 @@ var GitHubClientImpl = class {
     }
     return void 0;
   }
+  async getBranchHead(branch) {
+    const response = await this.octokit.rest.repos.getBranch({
+      owner: this.owner,
+      repo: this.repo,
+      branch
+    });
+    return response.data.commit.sha;
+  }
   async validateRepository() {
     try {
       const response = await this.octokit.rest.repos.get({
@@ -6704,6 +6772,8 @@ var AutopilotLevel4 = class extends AutopilotLevel3 {
 
 export {
   parseTierOverrides,
+  repositoryIdentity,
+  FrozenGitInputs,
   Policy,
   Plan,
   SchemaValidationError,