@smartergpt/lexrunner 1.5.2 → 2.0.0

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

@@ -13,6 +13,9 @@ import {
   canonicalJSONStringify
 } from "./chunk-UHFMFO54.js";
 import {
+  AXErrorException,
+  configInvalidError,
+  planValidationError,
   securitySarifParseError,
   securityScanFailedError
 } from "./chunk-26SCN2LJ.js";
@@ -243,7 +246,7 @@ function emitDeprecationNotice(oldVar, newVar) {
   }
   deprecationNotices.add(key);
   console.warn(
-    `\u26A0\uFE0F  Environment variable ${oldVar} is deprecated. Use ${newVar} instead. Support for ${oldVar} will be removed in v2.0.0.`
+    `\u26A0\uFE0F  Environment variable ${oldVar} is deprecated. Use ${newVar} instead. Support for ${oldVar} will be removed in v3.0.0.`
   );
 }
 
@@ -1869,11 +1872,12 @@ function createGitOperations(workingDir) {
 
 // src/gates.ts
 import { spawn as spawn2 } from "child_process";
+import { createHash as createHash2 } from "crypto";
 import path9 from "path";
 import fs9 from "fs";
 
 // src/security/scanning.ts
-import { AXErrorException } from "@smartergpt/lex/errors";
+import { AXErrorException as AXErrorException2 } from "@smartergpt/lex/errors";
 var DEFAULT_SECURITY_POLICY = {
   blockCritical: true,
   blockHigh: true,
@@ -1904,7 +1908,7 @@ var NpmAuditScanner = class {
           originalError: error instanceof Error ? error.message : String(error)
         }
       );
-      throw new AXErrorException(
+      throw new AXErrorException2(
         axError.code,
         axError.message,
         axError.nextActions,
@@ -1970,7 +1974,7 @@ var NpmAuditScanner = class {
 };
 
 // src/security/sarif.ts
-import { AXErrorException as AXErrorException2 } from "@smartergpt/lex/errors";
+import { AXErrorException as AXErrorException3 } from "@smartergpt/lex/errors";
 function mapSarifLevel(level, securitySeverity) {
   if (securitySeverity) {
     const normalized2 = securitySeverity.toLowerCase();
@@ -1994,7 +1998,7 @@ function parseSarif(sarifContent) {
       `Invalid SARIF JSON: ${error instanceof Error ? error.message : String(error)}`,
       { parseError: error instanceof Error ? error.message : String(error) }
     );
-    throw new AXErrorException2(axError.code, axError.message, axError.nextActions, axError.context);
+    throw new AXErrorException3(axError.code, axError.message, axError.nextActions, axError.context);
   }
   if (!sarif.runs || sarif.runs.length === 0) {
     return createEmptyResult("sarif");
@@ -3216,8 +3220,768 @@ import {
   writeFileSync as writeFileSync5
 } from "fs";
 import { basename as basename2, delimiter, dirname, extname, isAbsolute as isAbsolute2, join as join9, resolve as resolve5 } from "path";
-var GATE_EXECUTION_RECEIPT_SCHEMA_VERSION = "lexrunner-gate-execution-receipt/v1";
+import { z as z8 } from "zod";
+
+// src/schema.ts
+import { z as z6 } from "zod";
+
+// src/tiers/schema.ts
+import { z as z5 } from "zod";
+var CapabilityTier = z5.enum(["senior", "mid", "junior"]);
+var TierAssignment = z5.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),
+  /** Reason for escalation if applicable */
+  escalationReason: z5.string().optional(),
+  /** Whether actual tier differs from suggested tier */
+  mismatch: z5.boolean().optional()
+});
+var TierOverride = z5.object({
+  /** Item name to override */
+  itemName: z5.string(),
+  /** Tier to assign */
+  tier: CapabilityTier
+});
+function parseTierOverride(overrideStr) {
+  const parts = overrideStr.split("=");
+  if (parts.length !== 2) {
+    return null;
+  }
+  const [itemName, tierStr] = parts;
+  const tierResult = CapabilityTier.safeParse(tierStr.toLowerCase());
+  if (!tierResult.success || !itemName) {
+    return null;
+  }
+  return {
+    itemName: itemName.trim(),
+    tier: tierResult.data
+  };
+}
+function parseTierOverrides(overrides) {
+  const overrideList = typeof overrides === "string" ? overrides.split(",") : overrides;
+  const result = [];
+  for (const override of overrideList) {
+    const parsed = parseTierOverride(override.trim());
+    if (parsed) {
+      result.push(parsed);
+    }
+  }
+  return result;
+}
+
+// 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(),
+  status: GateStatus,
+  exitCode: z6.number().optional(),
+  duration: z6.number().optional(),
+  // milliseconds
+  timeoutMs: z6.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()
+  }).optional(),
+  artifacts: z6.array(z6.string()).optional(),
+  attempts: z6.number().default(1),
+  lastAttempt: z6.string().optional()
+  // ISO timestamp
+});
+var NodeResult = z6.object({
+  name: z6.string(),
+  status: NodeStatus,
+  gates: z6.array(GateResult).default([]),
+  blockedBy: z6.array(z6.string()).optional(),
+  // names of nodes that blocked this one
+  eligibleForMerge: z6.boolean().default(false)
+});
+var SchemaVersion = z6.string().regex(/^1\.\d+\.\d+$/, "Schema version must be 1.x.y format");
+function validateSchemaVersion(version) {
+  const parsed = SchemaVersion.safeParse(version);
+  if (!parsed.success) {
+    const axError = configInvalidError(
+      `Unsupported schema version: ${version}. This runner only supports schema version 1.x.y`,
+      { version, expected: "1.x.y" }
+    );
+    throw new AXErrorException(axError.code, axError.message, axError.nextActions, axError.context);
+  }
+  const [major] = version.split(".").map(Number);
+  if (major !== 1) {
+    const axError = configInvalidError(
+      `Incompatible schema major version: ${major}. This runner only supports major version 1.`,
+      { version, major, expectedMajor: 1 }
+    );
+    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 AdminOverride = z6.object({
+  allowedUsers: z6.array(z6.string()).optional(),
+  requireReason: z6.boolean().default(false)
+});
+var MergeRule = z6.object({
+  type: z6.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(),
+  // Memory limit in MB
+  batchSize: z6.number().int().min(1).default(50),
+  // Batch size for large plans
+  cacheTTLSeconds: z6.number().int().min(0).default(3600),
+  // Cache TTL in seconds
+  enableCaching: z6.boolean().default(true),
+  // Enable operation caching
+  throttleOnMemory: z6.boolean().default(true),
+  // Throttle workers when memory high
+  memoryThresholdPercent: z6.number().min(0).max(100).default(80)
+  // Memory threshold %
+}).default(() => ({
+  batchSize: 50,
+  cacheTTLSeconds: 3600,
+  enableCaching: true,
+  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)
+}).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({
+    adminGreen: AdminOverride.optional()
+  }).default(() => ({})),
+  blockOn: z6.array(z6.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 ContainerSpec = z6.object({
+  image: z6.string(),
+  entrypoint: z6.array(z6.string()).optional(),
+  mounts: z6.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(() => ({})),
+  // Runtime configuration
+  runtime: z6.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([]),
+  // Optional input data for gates that require structured inputs (validated against gate-specific schemas)
+  input: z6.record(z6.string(), z6.unknown()).optional(),
+  // Exact per-gate timeout. Overrides the operation default after hostility adjustment.
+  timeoutMs: z6.number().int().positive().max(24 * 60 * 60 * 1e3).optional()
+}).strict();
+var PlanItem = z6.object({
+  name: z6.string(),
+  deps: z6.string().array().default([]),
+  // Dependency references by item name
+  gates: z6.array(Gate).default([]),
+  // Tier routing for governance (optional - added during plan generation or execution)
+  tier: TierAssignment.optional()
+}).strict();
+var Plan = z6.object({
+  schemaVersion: SchemaVersion,
+  target: z6.string().default("main"),
+  policy: Policy.optional(),
+  items: z6.array(PlanItem).default([])
+}).strict().superRefine((plan, context) => {
+  const itemNames = /* @__PURE__ */ new Set();
+  let duplicateItemNameFound = false;
+  const duplicateGateNameItemIndexes = [];
+  for (const [itemIndex, item] of plan.items.entries()) {
+    if (itemNames.has(item.name)) {
+      duplicateItemNameFound = true;
+    }
+    itemNames.add(item.name);
+    const gateNames = /* @__PURE__ */ new Set();
+    let duplicateGateNameFound = false;
+    for (const gate of item.gates) {
+      if (gateNames.has(gate.name)) {
+        duplicateGateNameFound = true;
+      }
+      gateNames.add(gate.name);
+    }
+    if (duplicateGateNameFound) duplicateGateNameItemIndexes.push(itemIndex);
+  }
+  if (duplicateItemNameFound) {
+    context.addIssue({
+      code: "custom",
+      path: ["items"],
+      message: "Plan item names must be unique",
+      params: { validationCode: "DUPLICATE_NAMES" }
+    });
+  }
+  for (const itemIndex of duplicateGateNameItemIndexes) {
+    context.addIssue({
+      code: "custom",
+      path: ["items", itemIndex, "gates"],
+      message: "Gate names must be unique within an item",
+      params: { validationCode: "DUPLICATE_GATE_NAMES" }
+    });
+  }
+});
+var MAX_SCHEMA_VALIDATION_ERRORS = 50;
+var MAX_SCHEMA_VALIDATION_PATH_BYTES = 256;
+var MAX_SCHEMA_VALIDATION_MESSAGE_BYTES = 512;
+var MAX_SCHEMA_VALIDATION_ACTION_BYTES = 512;
+var SchemaValidationError = class extends AXErrorException {
+  constructor(issues) {
+    const errorCount = issues.length;
+    const errors = issues.slice(0, MAX_SCHEMA_VALIDATION_ERRORS).map(normalizeValidationIssue);
+    const errorsTruncated = errorCount > errors.length;
+    const errorStrings = errors.map((e) => `${e.path}: ${e.message}`);
+    const axError = planValidationError({
+      errors: errorStrings,
+      errorCount,
+      errorsTruncated
+      // planPath is omitted as it's not available in this context
+    });
+    super(axError.code, axError.message, axError.nextActions, axError.context);
+    this.name = "SchemaValidationError";
+    this.issues = issues;
+    this.errors = errors;
+    this.errorCount = errorCount;
+    this.errorsTruncated = errorsTruncated;
+  }
+  /**
+   * Get legacy machine-readable error format for backward compatibility
+   */
+  toLegacyJSON() {
+    return {
+      valid: false,
+      errors: this.errors
+    };
+  }
+};
+function formatPlanValidationFailure(error) {
+  const nextActions = error.axError.nextActions.filter((action) => !action.startsWith("Errors:")).slice(0, 10).map((action) => boundDiagnostic(action, MAX_SCHEMA_VALIDATION_ACTION_BYTES));
+  return {
+    contract: "bounded-ax-v1",
+    valid: false,
+    code: error.axError.code,
+    message: boundDiagnostic(error.message, MAX_SCHEMA_VALIDATION_MESSAGE_BYTES),
+    errorCount: error.errorCount,
+    errors: error.errors,
+    errorsTruncated: error.errorsTruncated,
+    nextActions: nextActions.length > 0 ? nextActions : ["Review each validation path and update the plan"],
+    context: {
+      errorCount: error.errorCount,
+      errorsTruncated: error.errorsTruncated
+    }
+  };
+}
+function asPlanValidationFailure(error) {
+  if (error instanceof SchemaValidationError) return formatPlanValidationFailure(error);
+  if (!(error instanceof AXErrorException) || error.axError.code !== "CONFIG_INVALID") {
+    return void 0;
+  }
+  const message = boundDiagnostic(error.message, MAX_SCHEMA_VALIDATION_MESSAGE_BYTES);
+  return {
+    contract: "bounded-ax-v1",
+    valid: false,
+    code: error.axError.code,
+    message,
+    errorCount: 1,
+    errors: [{ path: "root", message, code: error.axError.code }],
+    errorsTruncated: false,
+    nextActions: error.axError.nextActions.slice(0, 10).map((action) => boundDiagnostic(action, MAX_SCHEMA_VALIDATION_ACTION_BYTES)),
+    context: {
+      errorCount: 1,
+      errorsTruncated: false
+    }
+  };
+}
+function formatPlanValidationFailureText(failure) {
+  const lines = [failure.message];
+  for (const error of failure.errors) {
+    lines.push(`  - ${error.path} [${error.code}]: ${error.message}`);
+  }
+  if (failure.errorsTruncated) {
+    lines.push(
+      `  - \u2026 ${failure.errorCount - failure.errors.length} additional validation error(s) omitted`
+    );
+  }
+  return lines.join("\n");
+}
+function normalizeValidationIssue(issue) {
+  const path11 = normalizeValidationPath(issue.path);
+  const stableCustomIssue = safeCustomValidationIssue(issue);
+  return {
+    path: boundDiagnostic(path11, MAX_SCHEMA_VALIDATION_PATH_BYTES),
+    message: boundDiagnostic(
+      stableCustomIssue?.message ?? safeValidationMessage(issue.code),
+      MAX_SCHEMA_VALIDATION_MESSAGE_BYTES
+    ),
+    code: stableCustomIssue?.code ?? issue.code
+  };
+}
+function safeCustomValidationIssue(issue) {
+  if (issue.code !== "custom") return void 0;
+  switch (issue.params?.validationCode) {
+    case "DUPLICATE_NAMES":
+      return { code: "DUPLICATE_NAMES", message: "Plan item names must be unique" };
+    case "DUPLICATE_GATE_NAMES":
+      return {
+        code: "DUPLICATE_GATE_NAMES",
+        message: "Gate names must be unique within an item"
+      };
+    default:
+      return void 0;
+  }
+}
+function normalizeValidationPath(segments) {
+  if (segments.length === 0) return "root";
+  return segments.map((segment, index) => {
+    const previous = segments[index - 1];
+    if (previous === "retries" || previous === "env" || previous === "input") {
+      return "<key>";
+    }
+    return String(segment);
+  }).join(".");
+}
+function safeValidationMessage(code) {
+  switch (code) {
+    case "invalid_type":
+      return "Value has an invalid type";
+    case "invalid_value":
+      return "Value is not an allowed option";
+    case "too_big":
+      return "Value exceeds the allowed maximum";
+    case "too_small":
+      return "Value is below the allowed minimum";
+    case "invalid_format":
+      return "Value does not match the required format";
+    case "not_multiple_of":
+      return "Value is not an allowed multiple";
+    case "unrecognized_keys":
+      return "Object contains one or more unrecognized keys";
+    case "invalid_union":
+      return "Value does not match any allowed shape";
+    case "invalid_key":
+      return "Object contains an invalid key";
+    case "invalid_element":
+      return "Collection contains an invalid element";
+    case "custom":
+      return "Value failed schema validation";
+    default:
+      return "Value does not satisfy schema requirements";
+  }
+}
+function boundDiagnostic(value, maxBytes) {
+  const singleLine = value.replace(
+    /[\u0000-\u001f\u007f]/g,
+    (character) => JSON.stringify(character).slice(1, -1)
+  );
+  const encoded = Buffer.from(singleLine, "utf8");
+  if (encoded.length <= maxBytes) return singleLine;
+  const suffix = "\u2026 [truncated]";
+  const suffixBytes = Buffer.byteLength(suffix, "utf8");
+  let end = Math.max(0, maxBytes - suffixBytes);
+  while (end > 0 && (encoded[end] & 192) === 128) end -= 1;
+  return `${encoded.subarray(0, end).toString("utf8")}${suffix}`;
+}
+function validatePlan(planData) {
+  const result = Plan.safeParse(planData);
+  if (!result.success) {
+    throw new SchemaValidationError(result.error.issues);
+  }
+  validateSchemaVersion(result.data.schemaVersion);
+  return result.data;
+}
+function loadPlan(planContent) {
+  try {
+    const planData = JSON.parse(planContent);
+    return validatePlan(planData);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      const axError = configInvalidError("Invalid JSON: plan content could not be parsed", {
+        parseError: "MALFORMED_JSON"
+      });
+      throw new AXErrorException(
+        axError.code,
+        axError.message,
+        axError.nextActions,
+        axError.context
+      );
+    }
+    throw error;
+  }
+}
+
+// src/schemas/task-contract.ts
+import { createHash } from "crypto";
+import { z as z7 } from "zod";
+var TASK_CONTRACT_VERSION = "1.0.0";
+function computeCanonicalHash(obj) {
+  const canonical = JSON.stringify(obj, sortedReplacer);
+  return computeCanonicalHashFromCompactJSON(canonical);
+}
+function computeCanonicalHashFromCompactJSON(canonical) {
+  const hash = createHash("sha256").update(canonical, "utf8").digest("hex");
+  return `sha256:${hash}`;
+}
+function sortedReplacer(_key, value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    return Object.keys(value).sort().reduce(
+      (sorted, key) => {
+        sorted[key] = value[key];
+        return sorted;
+      },
+      {}
+    );
+  }
+  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("/"), {
+  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:"), {
+  message: "Must start with sha256:"
+});
+var RepoProvenance = z7.object({
+  /** Repository identifier (owner/name) */
+  id: z7.string().regex(/^[^/]+\/[^/]+$/, "Must be owner/repo format"),
+  /** Absolute path to repo root (engine-local, for resolution) */
+  root: z7.string(),
+  /** Pinned commit SHA */
+  commit_sha: z7.string().min(7)
+});
+var ScopeBoundary = z7.object({
+  /** Globs for files agent can read */
+  read_globs: z7.array(GlobPattern),
+  /** Globs for files agent can modify */
+  write_globs: z7.array(GlobPattern),
+  /** Globs for files explicitly denied (always applied) */
+  deny_globs: z7.array(GlobPattern),
+  /** Whether cross-repo operations are permitted */
+  cross_repo_allowed: z7.boolean()
+});
+var FailureEvidence = z7.object({
+  /** Short error description */
+  message: z7.string(),
+  /** Repo-relative path to failed file */
+  file_rel: RepoRelativePath,
+  /** Line number if available */
+  line: z7.number().int().positive().optional(),
+  /** Actual test runner output snippet */
+  runner_output_snip: z7.string(),
+  /** Code context around failure */
+  excerpt: z7.string().optional()
+});
+var HintEdit = z7.object({
+  find: z7.string(),
+  replace: z7.string()
+});
+var Target = z7.object({
+  /** Repo-relative file path */
+  path_rel: RepoRelativePath,
+  /** Anchored code context (±N lines) */
+  hunk: z7.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 SourceOfTruth = z7.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(),
+  /** Commit SHA (defaults to snapshot commit if omitted) */
+  commit_sha: z7.string().optional(),
+  /** Canonical excerpt */
+  excerpt: z7.string(),
+  /** Lexmap module ID if applicable */
+  lexmap_module_id: z7.string().optional(),
+  /** Change that introduced this */
+  introducing_change: IntroducingChange.optional()
+});
+var VerificationExpectations = z7.object({
+  /** Command to run */
+  cmd: z7.string(),
+  /** Expected results */
+  expect: z7.object({
+    /** Expected exit code (usually 0) */
+    exit_code: z7.number().int(),
+    /** Strings that must appear in output */
+    must_include: z7.array(z7.string()).optional(),
+    /** Strings that must not appear */
+    must_not_include: z7.array(z7.string()).optional()
+  })
+});
+var Budget = z7.object({
+  /** Token budget hint in bytes */
+  max_bytes: z7.number().int().positive().optional(),
+  /** Fields that were truncated (empty if none) */
+  truncated_fields: z7.array(z7.string())
+});
+var TaskSnapshot_v1 = z7.object({
+  // Schema version
+  schema_version: z7.literal(TASK_CONTRACT_VERSION),
+  // Identity
+  task_id: z7.string().min(1),
+  procedure: z7.string().min(1),
+  determinism: DeterminismLevel,
+  snapshot_hash: SHA256HashOrPlaceholder,
+  // Provenance (MUST)
+  repo: RepoProvenance,
+  // Scope boundary (MUST)
+  scope: ScopeBoundary,
+  // Failure evidence (MUST)
+  failure: FailureEvidence,
+  // Invariants (SHOULD) - anti-brittleness constraints
+  invariants: z7.array(z7.string()).optional(),
+  // Targets (MUST, array)
+  targets: z7.array(Target).min(1),
+  // Source of truth (SHOULD)
+  source_of_truth: SourceOfTruth.optional(),
+  // Verification expectations (MUST)
+  verification: VerificationExpectations,
+  // Budget/truncation (MUST)
+  budget: Budget,
+  // Output contract
+  receipt_schema_id: z7.string()
+});
+var StructuredAssumption = z7.object({
+  /** Type of assumption */
+  type: AssumptionType,
+  /** Assumption text */
+  text: z7.string(),
+  /** Whether it was validated */
+  validated: z7.boolean().optional(),
+  /** Evidence supporting validation */
+  evidence: z7.string().optional()
+});
+var AgentClaims = z7.object({
+  /** Whether the task succeeded */
+  success: z7.boolean(),
+  /** Unified diff patch */
+  patch: z7.string().optional(),
+  /** Files touched (repo-relative) */
+  files_touched: z7.array(RepoRelativePath),
+  /** Rationale for the fix */
+  rationale: z7.string(),
+  /** Confidence level */
+  confidence: ConfidenceLevel2,
+  /** Which invariants were respected */
+  invariants_respected: z7.array(z7.string()).optional(),
+  /** Structured assumptions made */
+  assumptions_made: z7.array(StructuredAssumption)
+});
+var SearchActivity = z7.object({
+  /** Search query */
+  query: z7.string(),
+  /** Search method used */
+  method: z7.string().optional(),
+  /** Roots searched (repo-relative) */
+  roots: z7.array(z7.string()),
+  /** Number of results found */
+  results_count: z7.number().int().nonnegative().optional(),
+  /** Time taken in milliseconds */
+  time_ms: z7.number().nonnegative().optional()
+});
+var TokenUsage = z7.object({
+  input: z7.number().int().nonnegative(),
+  output: z7.number().int().nonnegative(),
+  total: z7.number().int().nonnegative()
+});
+var CostTracking = z7.object({
+  /** Token usage breakdown */
+  token_usage: TokenUsage.optional(),
+  /** Number of tool calls made */
+  tool_calls_count: z7.number().int().nonnegative().optional(),
+  /** Elapsed time in milliseconds */
+  elapsed_ms: z7.number().nonnegative().optional()
+});
+var AgentVerification = z7.object({
+  /** Whether verification command was run */
+  cmd_ran: z7.boolean(),
+  /** Exit code if run */
+  exit_code: z7.number().int().optional(),
+  /** Output snippet */
+  output_snip: z7.string().optional()
+});
+var TaskReceipt_v1 = z7.object({
+  // Schema version
+  schema_version: z7.literal(TASK_CONTRACT_VERSION),
+  // Identity (echo from snapshot)
+  task_id: z7.string().min(1),
+  snapshot_hash: SHA256HashOrPlaceholder,
+  // Claims (what agent says it did)
+  claims: AgentClaims,
+  // Search activity (if agent searched)
+  search_activity: z7.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())
+});
+var DetectedFailure = z7.object({
+  type: z7.string(),
+  message: z7.string(),
+  file: z7.string().optional(),
+  line: z7.number().int().positive().optional()
+});
+var EngineVerification_v1 = z7.object({
+  // Identity
+  task_id: z7.string().min(1),
+  timestamp: z7.string().datetime(),
+  // Hash binding (audit trail)
+  snapshot_hash: SHA256HashOrPlaceholder,
+  receipt_hash: SHA256HashOrPlaceholder,
+  // Verification result
+  verified: z7.boolean(),
+  // What engine ran
+  cmd_ran: z7.string(),
+  exit_code: z7.number().int(),
+  stdout_snip: z7.string(),
+  stderr_snip: z7.string(),
+  // Patch verification
+  patch_hash: SHA256HashOrPlaceholder.optional(),
+  patch_applied: z7.boolean(),
+  // Comparison with agent claim
+  agent_claimed: z7.boolean(),
+  trust_gap: z7.boolean(),
+  // Failures detected
+  failures: z7.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)
+}).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)
+}).strict();
+var ArtifactIdentitySchema = z8.object({
+  declaredPath: z8.string(),
+  resolvedPath: z8.string(),
+  status: z8.enum(["collected", "missing", "stale", "unsupported", "collection_error"]),
+  before: FileIdentitySchema.nullable(),
+  source: FileIdentitySchema.nullable(),
+  retainedPath: z8.string().optional(),
+  retained: FileIdentitySchema.optional(),
+  error: z8.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()
+  }).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())
+  }).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"]),
+      executable: FileIdentitySchema.nullable(),
+      argv: z8.array(z8.string()),
+      identityAfter: FileIdentitySchema.nullable(),
+      unchanged: z8.boolean(),
+      spawned: z8.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()
+    }).strict().nullable(),
+    evidenceComplete: z8.boolean()
+  }).strict(),
+  output: z8.object({ stdout: OutputEvidenceSchema, stderr: OutputEvidenceSchema }).strict(),
+  artifacts: z8.array(ArtifactIdentitySchema)
+}).strict();
+function parseLocalGateExecutionReceipt(value) {
+  return LocalGateExecutionReceiptSchema.parse(value);
+}
+function gateExecutionBinding(gate, item, timeoutMs, candidateDigest) {
+  return {
+    item: item ?? null,
+    declaredGateDigest: computeCanonicalHash(Gate.parse(gate)),
+    candidateDigest: candidateDigest ?? null,
+    timeoutMs
+  };
+}
 function resolveSpawnExecutable(command, environment, workingDirectory, platform2 = process.platform) {
   if (isAbsolute2(command) || /[\\/]/u.test(command)) {
     return requireExecutable(resolve5(workingDirectory, command));
@@ -3365,7 +4129,17 @@ function resolveLocalGateShell(command, platform2 = process.platform) {
     arguments: ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", command]
   } : { command: "bash", arguments: ["-c", command] };
 }
-async function executeGate(gate, policy, artifactDir, timeoutMs = 3e4, itemName, skipValidation = false, repoRoot, turnCostTracker, suppressStdout = false) {
+function sanitizedGateEnvironment(declared) {
+  const environment = { ...process.env };
+  for (const key of Object.keys(environment)) {
+    if (key.toUpperCase().startsWith("GIT_")) delete environment[key];
+  }
+  return { ...environment, ...declared };
+}
+function artifactIdentitySegment(identity) {
+  return `identity-${createHash2("sha256").update(identity, "utf8").digest("hex").slice(0, 32)}`;
+}
+async function executeGate(gate, policy, artifactDir, timeoutMs = 3e4, itemName, skipValidation = false, repoRoot, turnCostTracker, suppressStdout = false, candidateDigest) {
   if (!skipValidation && gate.input) {
     try {
       validateGateInput(gate.name, gate.input);
@@ -3397,7 +4171,15 @@ async function executeGate(gate, policy, artifactDir, timeoutMs = 3e4, itemName,
       }
       await new Promise((resolve6) => setTimeout(resolve6, delayMs));
     }
-    const result = await executeGateAttempt(gate, artifactDir, attempt, timeoutMs, repoRoot);
+    const result = await executeGateAttempt(
+      gate,
+      artifactDir,
+      attempt,
+      timeoutMs,
+      repoRoot,
+      itemName,
+      candidateDigest
+    );
     lastResult = result;
     totalDuration += result.duration || 0;
     if (turnCostTracker && result.duration) {
@@ -3499,14 +4281,17 @@ async function writeFlakeReport(itemName, gateName, attempts, totalDuration, art
   if (!fs9.existsSync(flakeReportDir)) {
     fs9.mkdirSync(flakeReportDir, { recursive: true });
   }
-  const reportPath = path9.join(flakeReportDir, `${itemName}-${gateName}.json`);
+  const reportPath = path9.join(
+    flakeReportDir,
+    `${artifactIdentitySegment(itemName)}-${artifactIdentitySegment(gateName)}.json`
+  );
   const reportContent = canonicalJSONStringify(flakeReport);
   fs9.writeFileSync(reportPath, reportContent, "utf-8");
   if (!suppressStdout) {
     console.log(`\u{1F4CA} Flake report written: ${reportPath}`);
   }
 }
-async function executeGateAttempt(gate, artifactDir, attempt, timeoutMs, repoRoot) {
+async function executeGateAttempt(gate, artifactDir, attempt, timeoutMs, repoRoot, itemName, candidateDigest) {
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const startTime = Date.now();
   switch (gate.runtime) {
@@ -3518,7 +4303,8 @@ async function executeGateAttempt(gate, artifactDir, attempt, timeoutMs, repoRoo
         startedAt,
         startTime,
         timeoutMs,
-        repoRoot
+        repoRoot,
+        itemName
       );
     case "ci-service":
       return executeCiServiceGate(gate, artifactDir, attempt, startedAt, startTime);
@@ -3531,14 +4317,16 @@ async function executeGateAttempt(gate, artifactDir, attempt, timeoutMs, repoRoo
         startedAt,
         startTime,
         timeoutMs,
-        repoRoot
+        repoRoot,
+        itemName,
+        candidateDigest
       );
   }
 }
-async function executeLocalGate(gate, artifactDir, attempt, startedAt, startTime, timeoutMs, repoRoot) {
+async function executeLocalGate(gate, artifactDir, attempt, startedAt, startTime, timeoutMs, repoRoot, itemName, candidateDigest) {
   const workingDirectory = path9.resolve(gate.cwd || repoRoot || process.cwd());
-  const gateArtifactDirectory = path9.join(artifactDir, gate.name);
-  const environment = { ...process.env, ...gate.env };
+  const gateArtifactDirectory = path9.join(artifactDir, artifactIdentitySegment(gate.name));
+  const environment = sanitizedGateEnvironment(gate.env);
   const shell = resolveLocalGateShell(gate.run);
   const artifactBaselines = captureDeclaredArtifactBaselines(
     gate.artifacts ?? [],
@@ -3582,7 +4370,10 @@ async function executeLocalGate(gate, artifactDir, attempt, startedAt, startTime
         artifacts: [],
         attempts: attempt,
         lastAttempt: startedAt
-      }
+      },
+      itemName,
+      timeoutMs,
+      candidateDigest
     });
   }
   try {
@@ -3616,7 +4407,10 @@ async function executeLocalGate(gate, artifactDir, attempt, startedAt, startTime
         artifacts: [],
         attempts: attempt,
         lastAttempt: startedAt
-      }
+      },
+      itemName,
+      timeoutMs,
+      candidateDigest
     });
   }
   return new Promise((resolve6) => {
@@ -3680,7 +4474,10 @@ async function executeLocalGate(gate, artifactDir, attempt, startedAt, startTime
             artifacts: [],
             attempts: attempt,
             lastAttempt: startedAt
-          }
+          },
+          itemName,
+          timeoutMs,
+          candidateDigest
         })
       );
     });
@@ -3719,7 +4516,10 @@ async function executeLocalGate(gate, artifactDir, attempt, startedAt, startTime
             artifacts: [],
             attempts: attempt,
             lastAttempt: startedAt
-          }
+          },
+          itemName,
+          timeoutMs,
+          candidateDigest
         })
       );
     });
@@ -3746,6 +4546,12 @@ function finalizeLocalGateAttempt(input) {
   const receiptPath = writeLocalGateExecutionReceipt(input.gateArtifactDirectory, {
     schemaVersion: GATE_EXECUTION_RECEIPT_SCHEMA_VERSION,
     attempt: input.attempt,
+    binding: gateExecutionBinding(
+      input.gate,
+      input.itemName,
+      input.timeoutMs,
+      input.candidateDigest
+    ),
     declaredGate: {
       name: input.gate.name,
       run: input.gate.run,
@@ -3783,11 +4589,21 @@ function finalizeLocalGateAttempt(input) {
   result.artifacts = [...collected.paths, receiptPath];
   return result;
 }
-async function executeContainerGate(gate, artifactDir, attempt, startedAt, startTime, timeoutMs, repoRoot) {
-  console.warn(
-    `\u26A0\uFE0F  Container runtime for gate '${gate.name}' not yet implemented, falling back to local execution`
-  );
-  return executeLocalGate(gate, artifactDir, attempt, startedAt, startTime, timeoutMs, repoRoot);
+async function executeContainerGate(gate, artifactDir, attempt, startedAt, startTime, timeoutMs, repoRoot, itemName) {
+  console.warn(`\u26A0\uFE0F  Container runtime for gate '${gate.name}' is not implemented; failing closed`);
+  return {
+    gate: gate.name,
+    status: "fail",
+    exitCode: 1,
+    duration: Date.now() - startTime,
+    stdout: "",
+    stderr: "GATE_RUNTIME_UNAVAILABLE: container execution is not implemented",
+    failureKind: "evidence_error",
+    artifacts: [],
+    attempts: attempt,
+    lastAttempt: startedAt,
+    timeoutMs
+  };
 }
 async function executeCiServiceGate(gate, artifactDir, attempt, startedAt, startTime) {
   console.warn(
@@ -3952,7 +4768,7 @@ async function executeItemGates(item, policy, executionState, artifactDir, timeo
     return [];
   }
   const results = [];
-  const itemArtifactDir = path9.join(artifactDir, item.name);
+  const itemArtifactDir = path9.join(artifactDir, artifactIdentitySegment(item.name));
   if (!fs9.existsSync(itemArtifactDir)) {
     fs9.mkdirSync(itemArtifactDir, { recursive: true });
   }
@@ -4003,13 +4819,15 @@ async function executeItemGates(item, policy, executionState, artifactDir, timeo
       gate,
       policy,
       itemArtifactDir,
-      timeoutMs,
+      gate.timeoutMs ?? timeoutMs,
       item.name,
       skipValidation,
       repoRoot,
       options?.turnCostTracker,
-      options?.suppressStdout
+      options?.suppressStdout,
+      options?.candidateDigest
     );
+    result.timeoutMs = gate.timeoutMs ?? timeoutMs;
     results.push(result);
     executionState.updateGateResult(item.name, result);
     if (result.status === "fail" && options?.runId) {
@@ -5885,6 +6703,14 @@ var AutopilotLevel4 = class extends AutopilotLevel3 {
 };
 
 export {
+  parseTierOverrides,
+  Policy,
+  Plan,
+  SchemaValidationError,
+  formatPlanValidationFailure,
+  asPlanValidationFailure,
+  formatPlanValidationFailureText,
+  loadPlan,
   getRunsDir,
   getRunDir,
   writeRunState,
@@ -5901,6 +6727,14 @@ export {
   listCounterExamples,
   loadCounterExample,
   exportCounterExamples,
+  computeCanonicalHash,
+  computeCanonicalHashFromCompactJSON,
+  RepoRelativePath,
+  SHA256Hash,
+  GATE_EXECUTION_RECEIPT_SCHEMA_VERSION,
+  parseLocalGateExecutionReceipt,
+  resolveSpawnExecutable,
+  fileIdentity,
   executeGate,
   executeGatesWithPolicy,
   getEnvWithAlias,