@danmoisan/drm-copilot-mcp 1.0.13 → 1.0.15

package/out/mcp-server.js

@@ -8964,13 +8964,13 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     }
     return propValues;
   });
-  const isObject9 = isObject;
+  const isObject14 = isObject;
   const catchall = def.catchall;
   let value;
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
     const input = payload.value;
-    if (!isObject9(input)) {
+    if (!isObject14(input)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
@@ -9097,7 +9097,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
     return (payload, ctx) => fn(shape, payload, ctx);
   };
   let fastpass;
-  const isObject9 = isObject;
+  const isObject14 = isObject;
   const jit = !globalConfig.jitless;
   const allowsEval2 = allowsEval;
   const fastEnabled = jit && allowsEval2.value;
@@ -9106,7 +9106,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
     const input = payload.value;
-    if (!isObject9(input)) {
+    if (!isObject14(input)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
@@ -16096,7 +16096,7 @@ var REPO_AUTOMATION_TOOL_DEFINITIONS = [
   },
   {
     name: "run_poshqc_test",
-    description: "Run bundled PoshQC Pester checks against the target workspace using bundled extension resources.",
+    description: "Run bundled PoshQC Pester checks against the target workspace using bundled extension resources. When scan_folders is omitted, the scan set is resolved from config/poshqc-scan.json (test.scanFolders); an explicit scan_folders argument overrides the configuration.",
     inputSchema: {
       type: "object",
       properties: {
@@ -16203,7 +16203,7 @@ var REPO_AUTOMATION_TOOL_DEFINITIONS = [
   },
   {
     name: "validate_orchestration_artifacts",
-    description: "Validate an orchestration artifact (plan, policy-audit, code-review, feature-audit, or orchestrator-state) against its structural schema.",
+    description: "Validate an orchestration artifact, including epic planner, kickoff, and execution checkpoints, against its structural schema.",
     inputSchema: {
       type: "object",
       properties: {
@@ -16215,7 +16215,10 @@ var REPO_AUTOMATION_TOOL_DEFINITIONS = [
             "policy-audit",
             "code-review",
             "feature-audit",
-            "orchestrator-state"
+            "orchestrator-state",
+            "epic-orchestrator-state",
+            "epic-planner-state",
+            "epic-kickoff"
           ],
           description: "The type of orchestration artifact to validate."
         },
@@ -16225,11 +16228,23 @@ var REPO_AUTOMATION_TOOL_DEFINITIONS = [
         },
         require_complete: {
           type: "boolean",
-          description: "When true and artifact_type is 'orchestrator-state', require all phases to be complete."
+          description: "When true and artifact_type is 'orchestrator-state' or 'epic-orchestrator-state', require all phases to be complete."
         },
         require_model_routing: {
           type: "boolean",
           description: "When true and artifact_type is 'orchestrator-state', require a model_routing_receipts entry per delegated agent once a delegation is recorded. The TypeScript side performs the existence check only; the Python validator is authoritative for full per-receipt correctness."
+        },
+        require_codex_model_routing: {
+          type: "boolean",
+          description: "When true for an orchestrator checkpoint, require canonical Codex deployment receipts for delegated agents."
+        },
+        require_codex_topology: {
+          type: "boolean",
+          description: "When true for an orchestrator checkpoint, require canonical Codex topology receipts for delegated agents and epic roots."
+        },
+        require_ready_for_execution: {
+          type: "boolean",
+          description: "When true and artifact_type is 'epic-planner-state', require every child to be prepared and preflight-cleared."
         }
       },
       required: ["artifact_type", "artifact_path"],
@@ -16622,7 +16637,10 @@ var VALID_ARTIFACT_TYPES = /* @__PURE__ */ new Set([
   "policy-audit",
   "code-review",
   "feature-audit",
-  "orchestrator-state"
+  "orchestrator-state",
+  "epic-orchestrator-state",
+  "epic-planner-state",
+  "epic-kickoff"
 ]);
 function resolveValidateOrchestrationArtifactsToolInput(rawInput, fallbackWorkspaceRoot) {
   const args = asToolArgumentObject(rawInput);
@@ -16637,6 +16655,9 @@ function resolveValidateOrchestrationArtifactsToolInput(rawInput, fallbackWorksp
   }
   const requireComplete = args["require_complete"];
   const requireModelRouting = args["require_model_routing"];
+  const requireCodexModelRouting = args["require_codex_model_routing"];
+  const requireCodexTopology = args["require_codex_topology"];
+  const requireReadyForExecution = args["require_ready_for_execution"];
   return {
     workspaceRoot: normalizeWorkspaceRoot(
       args["workspace_root"],
@@ -16645,7 +16666,10 @@ function resolveValidateOrchestrationArtifactsToolInput(rawInput, fallbackWorksp
     artifactType,
     artifactPath: normalizeRequiredText(args["artifact_path"], "artifact_path"),
     ...requireComplete === true ? { requireComplete: true } : {},
-    ...requireModelRouting === true ? { requireModelRouting: true } : {}
+    ...requireModelRouting === true ? { requireModelRouting: true } : {},
+    ...requireCodexModelRouting === true ? { requireCodexModelRouting: true } : {},
+    ...requireCodexTopology === true ? { requireCodexTopology: true } : {},
+    ...requireReadyForExecution === true ? { requireReadyForExecution: true } : {}
   };
 }
 
@@ -17510,11 +17534,11 @@ function pushDownCustomizations(options) {
     effectiveSource,
     effectiveRoots
   )) {
-    const relativePath = relativeToPosix(sourcePath, effectiveSource);
-    if (relativePath === null) {
+    const relativePath2 = relativeToPosix(sourcePath, effectiveSource);
+    if (relativePath2 === null) {
       continue;
     }
-    const destinationPath = joinPosix2(destinationRoot, relativePath);
+    const destinationPath = joinPosix2(destinationRoot, relativePath2);
     const destinationStatus = fs9.isFile(
       destinationPath
     ) ? "overwritten" : "created";
@@ -17539,7 +17563,7 @@ function pushDownCustomizations(options) {
     fs9.ensureDir(destParent);
     fs9.writeTextFile(destinationPath, rewrittenText);
     fileResults.push({
-      relativePath,
+      relativePath: relativePath2,
       destinationStatus,
       rewrittenReferenceCount: rewrittenDelta,
       placeholderRewriteCount: placeholderDelta,
@@ -17774,6 +17798,11 @@ function assertSingleCsharpToolchain(publishedPaths, selectedPackNames) {
 var ARTIFACT_DIRECTORY3 = "artifacts/codex-and-agents-customizations";
 var ROOT_FOLDERS = [".codex", ".agents"];
 var PACK_MANIFEST_SUBDIR = "pack-manifests";
+var ROUTING_CONFIG_RELATIVE_PATH = "config/orchestration-routing.json";
+var PUBLISHED_ROOT_FOLDERS = [
+  ...ROOT_FOLDERS,
+  "config"
+];
 function passthroughRewrite(text) {
   return [text, 0, 0, []];
 }
@@ -17785,6 +17814,14 @@ function joinPosix4(root, relative2) {
   const normalizedRelative = relative2.replace(/\\/g, "/").replace(/^\/+/, "");
   return normalizedRoot === "" ? normalizedRelative : `${normalizedRoot}/${normalizedRelative}`;
 }
+function parentPosix(path11) {
+  const normalized = normalizePosix(path11);
+  const separatorIndex = normalized.lastIndexOf("/");
+  if (separatorIndex < 0) {
+    return "";
+  }
+  return separatorIndex === 0 ? "/" : normalized.slice(0, separatorIndex);
+}
 function relativeToPosix2(path11, root) {
   const normalizedPath = normalizePosix(path11);
   const normalizedRoot = normalizePosix(root);
@@ -17847,6 +17884,47 @@ var CodexFilteringFileSystem = class {
     this.inner.ensureDir(path11);
   }
 };
+var RoutingConfigFileSystem = class {
+  constructor(inner, options) {
+    this.inner = inner;
+    this.virtualPath = joinPosix4(
+      options.sourceRoot,
+      ROUTING_CONFIG_RELATIVE_PATH
+    );
+    this.virtualRoot = joinPosix4(options.sourceRoot, "config");
+    this.resourcePath = joinPosix4(
+      parentPosix(options.bundleRoot),
+      ROUTING_CONFIG_RELATIVE_PATH
+    );
+  }
+  inner;
+  virtualPath;
+  virtualRoot;
+  resourcePath;
+  listFiles(root) {
+    if (normalizePosix(root) === this.virtualRoot) {
+      return this.inner.isFile(this.resourcePath) ? [this.virtualPath] : [];
+    }
+    return this.inner.listFiles(root);
+  }
+  isDir(path11) {
+    return this.inner.isDir(path11);
+  }
+  isFile(path11) {
+    return normalizePosix(path11) === this.virtualPath ? this.inner.isFile(this.resourcePath) : this.inner.isFile(path11);
+  }
+  readTextFile(path11) {
+    return this.inner.readTextFile(
+      normalizePosix(path11) === this.virtualPath ? this.resourcePath : path11
+    );
+  }
+  writeTextFile(path11, content) {
+    this.inner.writeTextFile(path11, content);
+  }
+  ensureDir(path11) {
+    this.inner.ensureDir(path11);
+  }
+};
 function resolvePublishedPaths(packs, csharpVariant, bundleRoot, fs9) {
   const manifestPacks = resolveManifestPackNames(packs ?? null, csharpVariant);
   if (manifestPacks === null || manifestPacks.size === 0) {
@@ -17877,14 +17955,18 @@ function pushDownCustomizations3(options) {
     publishedPaths,
     csharpVariant
   });
+  const publishingFs = new RoutingConfigFileSystem(filteringFs, {
+    sourceRoot,
+    bundleRoot
+  });
   void options.memoryMode;
   return pushDownCustomizations({
     repoRoot: options.repoRoot,
     destinationRoot: options.destinationRoot,
-    fs: filteringFs,
+    fs: publishingFs,
     sourceRoot,
     ...options.artifactRoot === void 0 ? {} : { artifactRoot: options.artifactRoot },
-    rootFolders: ROOT_FOLDERS,
+    rootFolders: PUBLISHED_ROOT_FOLDERS,
     artifactDirectory: ARTIFACT_DIRECTORY3,
     rewriteReferences: passthroughRewrite,
     ...options.clock === void 0 ? {} : { clock: options.clock }
@@ -18155,15 +18237,15 @@ var ExcludingFileSystem = class {
    * @returns True when the file is outside the memory subtree or general-scoped.
    */
   isScopeIncluded(path11) {
-    const relativePath = relativeToPosix3(path11, this.repoRoot);
-    if (relativePath === null) {
+    const relativePath2 = relativeToPosix3(path11, this.repoRoot);
+    if (relativePath2 === null) {
       return true;
     }
-    if (!isUnderAgentMemory(relativePath)) {
+    if (!isUnderAgentMemory(relativePath2)) {
       return true;
     }
     const content = this.readText(path11);
-    return isGeneralMemoryFile(relativePath, content);
+    return isGeneralMemoryFile(relativePath2, content);
   }
   /**
    * Return whether a candidate file passes the memory-mode filter.
@@ -18575,12 +18657,12 @@ var RealFileSystem = class {
         return;
       }
       for (const entry of entries) {
-        const relativePath = relativePrefix === "" ? entry.name : `${relativePrefix}/${entry.name}`;
-        if (matcher.test(relativePath)) {
-          matches.push(joinPosix8(normalizedRoot, relativePath));
+        const relativePath2 = relativePrefix === "" ? entry.name : `${relativePrefix}/${entry.name}`;
+        if (matcher.test(relativePath2)) {
+          matches.push(joinPosix8(normalizedRoot, relativePath2));
         }
         if (entry.isDirectory()) {
-          walk(nodePath3.join(currentDir, entry.name), relativePath);
+          walk(nodePath3.join(currentDir, entry.name), relativePath2);
         }
       }
     };
@@ -21865,6 +21947,243 @@ var SubprocessRunner = class {
 // ../../extensions/drm-copilot/src/lib/validate/validate-orchestration-service-call.ts
 var path9 = __toESM(require("node:path"));
 
+// ../../extensions/drm-copilot/src/lib/validate/epic-kickoff-artifact.ts
+var KICKOFF_HEADING_RE = /^# Epic Kickoff: (?<slug>[a-z0-9][a-z0-9-]*)$/;
+var EPIC_RUN_RE = /Run `\/epic-run (?<slug>[a-z0-9][a-z0-9-]*)`/;
+var MANIFEST_RE = /docs\/features\/epics\/[a-z0-9][a-z0-9-]*\/epic\.md/;
+var INTEGRATION_BRANCH_RE = /epic\/[a-z0-9][a-z0-9-]*-integration/;
+var RESUME_RE = /(?:Every child|child features)\s+resumes?\s+at atomic execution\s+from\s+(?:its|their)\s+committed plan-path/i;
+var INTEGRITY_COMMIT_RE = /^(?:-\s*)?planning_commit:\s*`?(?<commit>[0-9a-fA-F]{7,64})`?\s*$/;
+var FEATURE_HEADERS = [
+  "issue_num",
+  "feature_folder",
+  "wave",
+  "complexity",
+  "plan-path"
+];
+var HASH_HEADERS = /* @__PURE__ */ new Set([
+  "plan-hash",
+  "plan_hash",
+  "git-blob-sha",
+  "git_blob_sha"
+]);
+function splitSections2(text) {
+  const sections = /* @__PURE__ */ new Map();
+  const errors = [];
+  let current;
+  for (const line of text.split("\n").slice(1)) {
+    if (line.startsWith("## ")) {
+      current = line.slice(3).trim();
+      if (sections.has(current)) {
+        errors.push(`Epic kickoff contains duplicate section: ## ${current}`);
+      } else {
+        sections.set(current, []);
+      }
+      continue;
+    }
+    if (current !== void 0) {
+      sections.get(current)?.push(line.replace(/\r$/, ""));
+    }
+  }
+  for (const required2 of ["Invocation Prompt", "Feature Summary"]) {
+    if (!sections.has(required2)) {
+      errors.push(`Epic kickoff is missing required section: ## ${required2}`);
+    }
+  }
+  return { sections, errors };
+}
+function parseCells(line) {
+  const stripped = line.trim();
+  if (!stripped.startsWith("|") || !stripped.endsWith("|")) {
+    return void 0;
+  }
+  return stripped.slice(1, -1).split("|").map((cell) => cell.trim().replace(/^`|`$/g, ""));
+}
+function isSeparator(cells) {
+  return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
+}
+function tableRows(lines, expectedHeaders) {
+  const nonempty = lines.filter((line) => line.trim().length > 0);
+  if (nonempty.length < 2) {
+    return {
+      rows: [],
+      errors: ["Epic kickoff table is missing its header or separator row."]
+    };
+  }
+  const headers = parseCells(nonempty[0] ?? "");
+  const separator = parseCells(nonempty[1] ?? "");
+  const errors = [];
+  if (headers === void 0 || headers.length !== expectedHeaders.length || headers.some((value, index) => value !== expectedHeaders[index])) {
+    errors.push(
+      `Epic kickoff feature table headers must be: ${expectedHeaders.join(" | ")}`
+    );
+  }
+  if (separator === void 0 || separator.length !== expectedHeaders.length || !isSeparator(separator)) {
+    errors.push("Epic kickoff table separator row is invalid.");
+  }
+  const rows = [];
+  for (const line of nonempty.slice(2)) {
+    const cells = parseCells(line);
+    if (cells === void 0 || cells.length !== expectedHeaders.length) {
+      errors.push(`Epic kickoff table row is invalid: ${line}`);
+    } else {
+      rows.push(cells);
+    }
+  }
+  if (rows.length === 0) {
+    errors.push(
+      "Epic kickoff feature table must contain at least one feature row."
+    );
+  }
+  return { rows, errors };
+}
+function parseFeatures(lines) {
+  const table = tableRows(lines, FEATURE_HEADERS);
+  const features = [];
+  table.rows.forEach((row, index) => {
+    const issueNum = Number(row[0]);
+    if (!Number.isInteger(issueNum)) {
+      table.errors.push(
+        `Epic kickoff feature row ${index} issue_num must be an integer.`
+      );
+      return;
+    }
+    const wave = Number(row[2]);
+    if (!Number.isInteger(wave)) {
+      table.errors.push(
+        `Epic kickoff feature row ${index} wave must be an integer.`
+      );
+      return;
+    }
+    const complexity = row[3] ?? "";
+    if (!(/* @__PURE__ */ new Set(["C1", "C2", "C3", "C4"])).has(complexity)) {
+      table.errors.push(
+        `Epic kickoff feature row ${index} complexity must be C1-C4.`
+      );
+    }
+    features.push({
+      issueNum,
+      featureFolder: row[1] ?? "",
+      wave,
+      complexity,
+      planPath: row[4] ?? ""
+    });
+  });
+  return { features, errors: table.errors };
+}
+function parseIntegrity(lines) {
+  let planningCommit;
+  const planHashes = {};
+  const errors = [];
+  const tableLines = [];
+  for (const line of lines) {
+    if (line.trim().length === 0) {
+      continue;
+    }
+    const match = INTEGRITY_COMMIT_RE.exec(line.trim());
+    if (match?.groups?.["commit"] !== void 0) {
+      if (planningCommit !== void 0) {
+        errors.push(
+          "Epic kickoff integrity has duplicate planning_commit fields."
+        );
+      }
+      planningCommit = match.groups["commit"].toLowerCase();
+    } else if (line.trim().startsWith("|")) {
+      tableLines.push(line);
+    } else {
+      errors.push(`Epic kickoff integrity line is invalid: ${line}`);
+    }
+  }
+  if (tableLines.length > 0) {
+    const header = parseCells(tableLines[0] ?? "");
+    if (header === void 0 || header.length !== 2 || header[0] !== "plan-path" || !HASH_HEADERS.has(header[1] ?? "")) {
+      errors.push(
+        "Epic kickoff integrity table headers must be plan-path and plan-hash."
+      );
+    } else if (tableLines.length < 2) {
+      errors.push("Epic kickoff integrity table is missing its separator row.");
+    } else {
+      const separator = parseCells(tableLines[1] ?? "");
+      if (separator === void 0 || separator.length !== 2 || !isSeparator(separator)) {
+        errors.push("Epic kickoff integrity table separator row is invalid.");
+      }
+      for (const line of tableLines.slice(2)) {
+        const cells = parseCells(line);
+        if (cells === void 0 || cells.length !== 2 || !/^[0-9a-fA-F]{40,64}$/.test(cells[1] ?? "")) {
+          errors.push(`Epic kickoff integrity table row is invalid: ${line}`);
+          continue;
+        }
+        const planPath = cells[0] ?? "";
+        if (planHashes[planPath] !== void 0) {
+          errors.push(
+            `Epic kickoff integrity repeats plan path: '${planPath}'.`
+          );
+        }
+        planHashes[planPath] = (cells[1] ?? "").toLowerCase();
+      }
+    }
+  }
+  return {
+    ...planningCommit === void 0 ? {} : { planningCommit },
+    planHashes,
+    errors
+  };
+}
+function parseEpicKickoff(text) {
+  const lines = text.split("\n");
+  if (text.length === 0) {
+    return { errors: ["Epic kickoff is empty."] };
+  }
+  const heading = KICKOFF_HEADING_RE.exec((lines[0] ?? "").replace(/\r$/, ""));
+  if (heading?.groups?.["slug"] === void 0) {
+    return {
+      errors: ["Epic kickoff first line must match '# Epic Kickoff: <slug>'."]
+    };
+  }
+  const sectionResult = splitSections2(text);
+  const invocation = (sectionResult.sections.get("Invocation Prompt") ?? []).join("\n");
+  const invocationSlug = EPIC_RUN_RE.exec(invocation)?.groups?.["slug"];
+  const manifestMatch = MANIFEST_RE.exec(invocation);
+  const branchMatch = INTEGRATION_BRANCH_RE.exec(invocation);
+  const resumeMatch = RESUME_RE.exec(invocation);
+  if (invocationSlug === void 0) {
+    sectionResult.errors.push(
+      "Epic kickoff invocation must contain `Run /epic-run <slug>`."
+    );
+  }
+  if (manifestMatch?.[0] === void 0 || branchMatch?.[0] === void 0 || resumeMatch === null) {
+    sectionResult.errors.push(
+      "Epic kickoff invocation must structurally name the manifest, integration branch, and atomic-execution resume boundary."
+    );
+  }
+  const featureResult = parseFeatures(
+    sectionResult.sections.get("Feature Summary") ?? []
+  );
+  sectionResult.errors.push(...featureResult.errors);
+  const integrity = parseIntegrity(
+    sectionResult.sections.get("Integrity") ?? []
+  );
+  sectionResult.errors.push(...integrity.errors);
+  if (sectionResult.errors.length > 0 || invocationSlug === void 0 || manifestMatch?.[0] === void 0 || branchMatch?.[0] === void 0 || resumeMatch === null) {
+    return { errors: sectionResult.errors };
+  }
+  return {
+    parsed: {
+      slug: heading.groups["slug"],
+      invocationSlug,
+      manifestPath: manifestMatch[0],
+      integrationBranch: branchMatch[0],
+      features: featureResult.features,
+      ...integrity.planningCommit === void 0 ? {} : { planningCommit: integrity.planningCommit },
+      planHashes: integrity.planHashes
+    },
+    errors: []
+  };
+}
+function validateEpicKickoffText(text) {
+  return parseEpicKickoff(text).errors;
+}
+
 // ../../extensions/drm-copilot/src/lib/validate/epic-orchestrator-state-resolution.ts
 var LIFECYCLE_PREFIXES = [
   "docs/features/active/",
@@ -22002,143 +22321,1162 @@ function validateIntentBlock(state) {
   return errors;
 }
 
-// ../../extensions/drm-copilot/src/lib/validate/epic-orchestrator-state-core.ts
-var REQUIRED_BASELINE_KEYS = [
-  "objective",
-  "completed_steps",
-  "next_step",
-  "last_updated"
-];
-var REQUIRED_EPIC_KEYS = [
-  "route_id",
-  "epic_feature_folder",
-  "integration_branch",
-  "waves",
-  "features"
+// ../../extensions/drm-copilot/src/lib/validate/epic-orchestrator-state-launch-binding.ts
+var LAUNCH_ARTIFACT_PARTS = [
+  "artifacts",
+  "orchestration",
+  "epic-child-launches"
 ];
-var EXPECTED_ROUTE_ID = "epic";
-var VALID_MERGE_STATUS = /* @__PURE__ */ new Set([
-  "not_started",
-  "worktree_created",
-  "pr_open",
-  "ci_green",
-  "merge_conflict",
-  "blocked_conflict_loop_limit",
-  "merged",
-  "worktree_removed"
-]);
-var MERGED_STATUSES = /* @__PURE__ */ new Set([
-  "merged",
-  "worktree_removed"
+var GENERATED_ORCHESTRATOR_AGENTS = /* @__PURE__ */ new Set([
+  "orchestrator-c1",
+  "orchestrator-c2",
+  "orchestrator-c3",
+  "orchestrator-c3-elevated",
+  "orchestrator-c4"
 ]);
 function isObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function extractFeatures(state) {
-  const features = state["features"];
-  if (!Array.isArray(features)) {
-    return [];
-  }
-  return features.filter(isObject3);
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim() !== "" && value === value.trim();
 }
-function missingBaselineAndEpicKeys(state) {
-  const errors = [];
-  for (const key of [...REQUIRED_BASELINE_KEYS, ...REQUIRED_EPIC_KEYS]) {
-    if (!(key in state)) {
-      errors.push(`Epic checkpoint missing required key: ${key}`);
+function validPathSegments(value, separator) {
+  return value.split(separator).every((part) => part !== "" && part !== "." && part !== "..");
+}
+function isCanonicalWorktreePath(value) {
+  if (!isNonEmptyString(value) || value.includes("\0")) {
+    return false;
+  }
+  if (value.startsWith("/")) {
+    if (value.includes("\\") || value === "/") {
+      return !value.includes("\\");
     }
+    const leadingLength = value.startsWith("//") ? 2 : 1;
+    return validPathSegments(value.slice(leadingLength), "/");
   }
-  return errors;
+  if (value.includes("/")) {
+    return false;
+  }
+  if (/^[A-Za-z]:\\/.test(value)) {
+    return value.length === 3 || validPathSegments(value.slice(3), "\\");
+  }
+  if (value.startsWith("\\\\")) {
+    const parts = value.slice(2).split("\\");
+    return parts.length >= 2 && validPathSegments(value.slice(2), "\\");
+  }
+  return false;
 }
-function validateRouteId(state) {
-  if ("route_id" in state && state["route_id"] !== EXPECTED_ROUTE_ID) {
-    return [
-      `Epic checkpoint route_id must be 'epic', found: ${JSON.stringify(state["route_id"])}`
-    ];
+function isLaunchArtifactPath(value) {
+  if (!isNonEmptyString(value) || value.includes("\0")) {
+    return false;
   }
-  return [];
+  const normalized = value.replaceAll("\\", "/");
+  const rawParts = normalized.split("/");
+  if (rawParts.some((part) => part === "." || part === "..")) {
+    return false;
+  }
+  const parts = rawParts.filter((part) => part !== "");
+  let markerIndex = -1;
+  for (let index = 0; index <= parts.length - LAUNCH_ARTIFACT_PARTS.length; index += 1) {
+    if (LAUNCH_ARTIFACT_PARTS.every(
+      (part, offset) => parts[index + offset] === part
+    )) {
+      markerIndex = index;
+      break;
+    }
+  }
+  if (markerIndex < 0 || markerIndex + LAUNCH_ARTIFACT_PARTS.length >= parts.length) {
+    return false;
+  }
+  const absolute = normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized);
+  return markerIndex === 0 || absolute;
 }
-function validateFeatureFolderUniquenessAndDependencies(features) {
+function featurePrefix(feature) {
+  const folder = feature["feature_folder"];
+  const label = typeof folder === "string" && folder !== "" ? folder : "<unknown>";
+  return `Epic checkpoint feature '${label}' launch binding`;
+}
+function validateBranchAndPaths(feature, prefix, seenBranches) {
   const errors = [];
-  const seen = /* @__PURE__ */ new Set();
-  const duplicates = /* @__PURE__ */ new Set();
-  const index = buildFeatureReferenceIndex(features);
-  for (const feature of features) {
-    const folder = feature["feature_folder"];
-    if (typeof folder !== "string" || !folder) {
-      continue;
-    }
-    if (seen.has(folder)) {
-      duplicates.add(folder);
-    }
-    seen.add(folder);
-    const dependsOn = feature["depends_on"];
-    if (!Array.isArray(dependsOn)) {
-      continue;
-    }
-    for (const dependency of dependsOn) {
-      if (resolveFeatureReference(dependency, index) === null) {
-        errors.push(
-          `Epic checkpoint feature '${folder}' depends_on unresolved feature_folder: ${JSON.stringify(dependency)}`
-        );
-      }
-    }
+  const branch = feature["branch_name"];
+  if (!isNonEmptyString(branch) || seenBranches.has(branch)) {
+    errors.push(`${prefix}.branch_name must be a non-empty unique string.`);
+  } else {
+    seenBranches.add(branch);
   }
-  for (const folder of [...duplicates].sort()) {
+  if (!isCanonicalWorktreePath(feature["worktree_path"])) {
     errors.push(
-      `Epic checkpoint has duplicate features[].feature_folder: ${folder}`
+      `${prefix}.worktree_path must be a non-empty canonical absolute path.`
     );
   }
-  return errors;
-}
-function validateMergeStatusEnum(features) {
-  const errors = [];
-  for (const feature of features) {
-    const folder = feature["feature_folder"] ?? "<unknown>";
-    const mergeStatus = feature["merge_status"];
-    if (mergeStatus !== void 0 && mergeStatus !== null && !(typeof mergeStatus === "string" && VALID_MERGE_STATUS.has(mergeStatus))) {
+  for (const key of ["launch_receipt_path", "launch_status_path"]) {
+    if (!isLaunchArtifactPath(feature[key])) {
       errors.push(
-        `Epic checkpoint feature '${String(folder)}' has invalid merge_status: ${JSON.stringify(mergeStatus)}`
+        `${prefix}.${key} must be under artifacts/orchestration/epic-child-launches/.`
       );
     }
   }
   return errors;
 }
-function validateWaveBarrierOrdering(features) {
+function validateDelegationReceipt(feature, prefix, seenDelegationIds, requireGeneratedOrchestrator = false) {
+  const value = feature["delegation_receipt"];
+  if (!isObject3(value)) {
+    return { errors: [`${prefix}.delegation_receipt must be an object.`] };
+  }
   const errors = [];
-  const byFolder = /* @__PURE__ */ new Map();
-  for (const feature of features) {
-    const folder = feature["feature_folder"];
-    if (typeof folder === "string") {
-      byFolder.set(folder, feature);
-    }
+  const delegationId = value["delegation_id"];
+  const validId = isNonEmptyString(delegationId) ? delegationId : void 0;
+  if (validId === void 0 || seenDelegationIds.has(validId)) {
+    errors.push(
+      `${prefix}.delegation_receipt.delegation_id must be a non-empty unique string.`
+    );
+  } else {
+    seenDelegationIds.add(validId);
   }
-  const index = buildFeatureReferenceIndex(features);
-  for (const feature of features) {
-    const folder = feature["feature_folder"];
-    const dependsOn = feature["depends_on"];
-    if (typeof folder !== "string" || !Array.isArray(dependsOn)) {
-      continue;
-    }
-    const worktreeCreatedAt = feature["worktree_created_at"];
-    for (const dependency of dependsOn) {
-      const resolved = resolveFeatureReference(dependency, index);
-      const dependencyFeature = resolved !== null ? byFolder.get(resolved) : void 0;
-      if (dependencyFeature === void 0) {
-        continue;
-      }
-      const depMergeStatus = dependencyFeature["merge_status"];
-      const depConfirmedAt = dependencyFeature["merge_confirmed_at"];
-      const statusViolation = typeof depMergeStatus !== "string" || !MERGED_STATUSES.has(depMergeStatus);
-      const timingViolation = typeof depConfirmedAt === "string" && typeof worktreeCreatedAt === "string" && depConfirmedAt > worktreeCreatedAt;
-      if (statusViolation || timingViolation) {
-        errors.push(
-          `EPIC_WAVE_BARRIER_VIOLATION: ${folder} started before dependency ${String(dependency)} merged`
-        );
-      }
-    }
+  if (value["feature_folder"] !== feature["feature_folder"]) {
+    errors.push(
+      `${prefix}.delegation_receipt.feature_folder must match the feature.`
+    );
   }
-  return errors;
+  if (!("issue_num" in feature) || !("issue_num" in value) || value["issue_num"] !== feature["issue_num"]) {
+    errors.push(
+      `${prefix}.delegation_receipt.issue_num must match the feature.`
+    );
+  }
+  const agentName = value["agent_name"];
+  const validAgent = isNonEmptyString(agentName) ? agentName : void 0;
+  if (validAgent === void 0) {
+    errors.push(
+      `${prefix}.delegation_receipt.agent_name must be a non-empty string.`
+    );
+  } else if (requireGeneratedOrchestrator && !GENERATED_ORCHESTRATOR_AGENTS.has(validAgent)) {
+    errors.push(
+      `${prefix}.delegation_receipt.agent_name must name a generated orchestrator agent.`
+    );
+  }
+  return {
+    errors,
+    ...validId === void 0 ? {} : { delegationId: validId },
+    ...validAgent === void 0 ? {} : { deploymentAgent: validAgent }
+  };
+}
+function validateModelReceipt(feature, prefix, delegation, expectedExecutionContext = "epic_execution_child") {
+  const value = feature["model_routing_receipt"];
+  if (!isObject3(value)) {
+    return [`${prefix}.model_routing_receipt must be an object.`];
+  }
+  const errors = [];
+  if (delegation.delegationId !== void 0 && value["delegation_id"] !== delegation.delegationId) {
+    errors.push(
+      `${prefix}.model_routing_receipt.delegation_id must match delegation_receipt.delegation_id.`
+    );
+  }
+  const modelAgent = value["deployment_agent"];
+  if (!isNonEmptyString(modelAgent)) {
+    errors.push(
+      `${prefix}.model_routing_receipt.deployment_agent must be a non-empty string.`
+    );
+  } else if (delegation.deploymentAgent !== void 0 && modelAgent !== delegation.deploymentAgent) {
+    errors.push(
+      `${prefix}.model_routing_receipt.deployment_agent must match delegation_receipt.agent_name.`
+    );
+  }
+  if (value["execution_context"] !== expectedExecutionContext) {
+    errors.push(
+      `${prefix}.model_routing_receipt.execution_context must be '${expectedExecutionContext}'.`
+    );
+  }
+  return errors;
+}
+function validateLaunchBindings(features, context) {
+  const errors = [];
+  const seenBranches = /* @__PURE__ */ new Set();
+  const seenDelegationIds = /* @__PURE__ */ new Set();
+  features.forEach((item, index) => {
+    if (!isObject3(item)) {
+      return;
+    }
+    if (context.skipNotStarted && item["merge_status"] === "not_started") {
+      return;
+    }
+    const prefix = context.planner ? `Epic planner checkpoint features[${index}] launch binding` : featurePrefix(item);
+    errors.push(...validateBranchAndPaths(item, prefix, seenBranches));
+    const delegation = validateDelegationReceipt(
+      item,
+      prefix,
+      seenDelegationIds,
+      context.requireGeneratedOrchestrator
+    );
+    errors.push(...delegation.errors);
+    errors.push(
+      ...validateModelReceipt(
+        item,
+        prefix,
+        delegation,
+        context.expectedExecutionContext
+      )
+    );
+  });
+  return errors;
+}
+function validateEpicPlannerChildLaunchBindings(features) {
+  return validateLaunchBindings(features, {
+    expectedExecutionContext: "epic_preparation_child",
+    planner: true,
+    requireGeneratedOrchestrator: true,
+    skipNotStarted: false
+  });
+}
+function validateEpicChildLaunchBindings(state, options = {}) {
+  if (options.requireCodexModelRouting !== true && options.requireCodexTopology !== true && options.requireComplete !== true) {
+    return [];
+  }
+  const value = state["features"];
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return validateLaunchBindings(value, {
+    expectedExecutionContext: "epic_execution_child",
+    planner: false,
+    requireGeneratedOrchestrator: false,
+    skipNotStarted: options.requireComplete !== true
+  });
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/orchestrator-state-codex-model-routing.ts
+var CODEX_MODEL_ROUTING_RECEIPTS_KEY = "codex_model_routing_receipts";
+var BAND_ORDER = ["C1", "C2", "C3", "C4"];
+var VALID_EXECUTION_CONTEXTS = /* @__PURE__ */ new Set([
+  "standalone",
+  "epic_preparation_child",
+  "epic_execution_child"
+]);
+var EPIC_EXECUTION_CONTEXTS = /* @__PURE__ */ new Set([
+  "epic_preparation_child",
+  "epic_execution_child"
+]);
+var GENERATED_AGENT_FAMILIES = /* @__PURE__ */ new Set([
+  "orchestrator",
+  "atomic-planner",
+  "atomic-executor",
+  "feature-reviewer",
+  "task-researcher",
+  "prd-feature",
+  "pr-author",
+  "python-typed-engineer",
+  "powershell-typed-engineer",
+  "csharp-typed-engineer",
+  "typescript-engineer"
+]);
+var LOGICAL_AGENT_ALIASES = {
+  "feature-review": "feature-reviewer"
+};
+var BASE_PROFILES = {
+  C1: {
+    suffix: "c1",
+    model: "gpt-5.6-luna",
+    model_reasoning_effort: "low"
+  },
+  C2: {
+    suffix: "c2",
+    model: "gpt-5.6-terra",
+    model_reasoning_effort: "medium"
+  },
+  C3: {
+    suffix: "c3",
+    model: "gpt-5.6-terra",
+    model_reasoning_effort: "high"
+  },
+  C4: {
+    suffix: "c4",
+    model: "gpt-5.6-sol",
+    model_reasoning_effort: "max"
+  }
+};
+var C3_ELEVATED_PROFILE = {
+  suffix: "c3-elevated",
+  model: "gpt-5.6-sol",
+  model_reasoning_effort: "high"
+};
+var FORCED_PERSONA_PROFILES = {
+  "epic-planner": {
+    suffix: "",
+    model: "gpt-5.6-sol",
+    model_reasoning_effort: "ultra"
+  },
+  "epic-orchestrator": {
+    suffix: "",
+    model: "gpt-5.6-sol",
+    model_reasoning_effort: "ultra"
+  }
+};
+var REQUIRED_KEYS = [
+  "logical_agent",
+  "deployment_agent",
+  "phase",
+  "complexity_band",
+  "execution_context",
+  "orchestration_complexity_ceiling",
+  "c3_overlay_applied",
+  "c3_overlay_reason",
+  "model",
+  "model_reasoning_effort"
+];
+var RESOLVED_KEYS = [
+  "logical_agent",
+  "deployment_agent",
+  "complexity_band",
+  "execution_context",
+  "orchestration_complexity_ceiling",
+  "c3_overlay_applied",
+  "c3_overlay_reason",
+  "model",
+  "model_reasoning_effort"
+];
+var ModelUnavailableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ModelUnavailableError";
+  }
+};
+function isObject4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pythonRepr2(value) {
+  if (value === void 0 || value === null) {
+    return "None";
+  }
+  if (typeof value === "string") {
+    const escaped = value.replaceAll("\\", "\\\\").replaceAll("'", "\\'").replaceAll("\n", "\\n").replaceAll("\r", "\\r").replaceAll("	", "\\t");
+    return `'${escaped}'`;
+  }
+  if (typeof value === "boolean") {
+    return value ? "True" : "False";
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(pythonRepr2).join(", ")}]`;
+  }
+  if (isObject4(value)) {
+    const entries = Object.entries(value).map(
+      ([key, item]) => `${pythonRepr2(key)}: ${pythonRepr2(item)}`
+    );
+    return `{${entries.join(", ")}}`;
+  }
+  return String(value);
+}
+function pythonStr(value) {
+  return typeof value === "string" ? value : pythonRepr2(value);
+}
+function validateBand(value, fieldName) {
+  if (!BAND_ORDER.includes(value)) {
+    throw new Error(
+      `${fieldName} must be one of ('C1', 'C2', 'C3', 'C4'), found ${pythonRepr2(value)}.`
+    );
+  }
+  return value;
+}
+function validateContext(value) {
+  if (!VALID_EXECUTION_CONTEXTS.has(value)) {
+    throw new Error(
+      `execution_context must be one of ('epic_execution_child', 'epic_preparation_child', 'standalone'), found ${pythonRepr2(value)}.`
+    );
+  }
+  return value;
+}
+function selectC3OverlayReason(executionContext, orchestrationComplexityCeiling) {
+  const epicContext = EPIC_EXECUTION_CONTEXTS.has(executionContext);
+  const c4Ceiling = orchestrationComplexityCeiling === "C4";
+  if (epicContext && c4Ceiling) {
+    return "epic_context_and_c4_ceiling";
+  }
+  if (epicContext) {
+    return "epic_context";
+  }
+  if (c4Ceiling) {
+    return "c4_orchestration_ceiling";
+  }
+  return null;
+}
+function resolveCodexDeployment(logicalAgent, complexityBand, executionContext, orchestrationComplexityCeiling, availableModels) {
+  const band = validateBand(complexityBand, "complexity_band");
+  const ceiling = validateBand(
+    orchestrationComplexityCeiling,
+    "orchestration_complexity_ceiling"
+  );
+  const context = validateContext(executionContext);
+  if (BAND_ORDER.indexOf(band) > BAND_ORDER.indexOf(ceiling)) {
+    throw new Error(
+      `orchestration_complexity_ceiling must be greater than or equal to complexity_band, found ${ceiling} below ${band}.`
+    );
+  }
+  const forcedProfile = FORCED_PERSONA_PROFILES[logicalAgent];
+  let profile;
+  let deploymentAgent;
+  let overlayReason;
+  if (forcedProfile !== void 0) {
+    profile = forcedProfile;
+    deploymentAgent = logicalAgent;
+    overlayReason = null;
+  } else {
+    const deploymentFamily = LOGICAL_AGENT_ALIASES[logicalAgent] ?? logicalAgent;
+    if (!GENERATED_AGENT_FAMILIES.has(deploymentFamily)) {
+      throw new Error(
+        `Unsupported Codex logical agent: ${pythonRepr2(logicalAgent)}.`
+      );
+    }
+    overlayReason = band === "C3" ? selectC3OverlayReason(context, ceiling) : null;
+    profile = overlayReason === null ? BASE_PROFILES[band] : C3_ELEVATED_PROFILE;
+    deploymentAgent = `${deploymentFamily}-${profile.suffix}`;
+  }
+  if (availableModels !== void 0 && !availableModels.has(profile.model)) {
+    throw new ModelUnavailableError(
+      `model_unavailable: required Codex model ${pythonRepr2(profile.model)} is unavailable; silent fallback is prohibited.`
+    );
+  }
+  return {
+    logical_agent: logicalAgent,
+    deployment_agent: deploymentAgent,
+    complexity_band: band,
+    execution_context: context,
+    orchestration_complexity_ceiling: ceiling,
+    c3_overlay_applied: overlayReason !== null,
+    c3_overlay_reason: overlayReason,
+    model: profile.model,
+    model_reasoning_effort: profile.model_reasoning_effort
+  };
+}
+function validateReceipt(value, prefix, previousCeiling) {
+  if (!isObject4(value)) {
+    return { errors: [`${prefix} must be an object.`] };
+  }
+  const missing = REQUIRED_KEYS.filter((key) => !(key in value));
+  if (missing.length > 0) {
+    return {
+      errors: [`${prefix} missing required keys: ${missing.join(", ")}.`]
+    };
+  }
+  const errors = [];
+  const phase = value["phase"];
+  if (typeof phase !== "string" || phase.trim() === "") {
+    errors.push(`${prefix}.phase must be a non-empty string.`);
+  }
+  let expected;
+  try {
+    expected = resolveCodexDeployment(
+      pythonStr(value["logical_agent"]),
+      pythonStr(value["complexity_band"]),
+      pythonStr(value["execution_context"]),
+      pythonStr(value["orchestration_complexity_ceiling"])
+    );
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    errors.push(`${prefix} has invalid routing inputs: ${message}`);
+    return { errors };
+  }
+  const currentCeiling = expected.orchestration_complexity_ceiling;
+  if (previousCeiling !== void 0 && BAND_ORDER.indexOf(currentCeiling) < BAND_ORDER.indexOf(previousCeiling)) {
+    errors.push(
+      `${prefix}.orchestration_complexity_ceiling must be monotonic; found ${currentCeiling} after ${previousCeiling}.`
+    );
+  } else if (previousCeiling !== void 0) {
+    const transition = value["ceiling_transition"];
+    if (currentCeiling === previousCeiling) {
+      if (transition !== void 0 && transition !== null) {
+        errors.push(
+          `${prefix}.ceiling_transition must be absent unless the ceiling rises.`
+        );
+      }
+    } else if (!isObject4(transition)) {
+      errors.push(
+        `${prefix}.ceiling_transition must record a ceiling increase.`
+      );
+    } else {
+      if (transition["from"] !== previousCeiling || transition["to"] !== currentCeiling) {
+        errors.push(
+          `${prefix}.ceiling_transition must record ${previousCeiling} to ${currentCeiling}.`
+        );
+      }
+      const affected = transition["affected_delegation_ids"];
+      if (!Array.isArray(affected) || affected.length === 0 || affected.some(
+        (item) => typeof item !== "string" || item.trim() === ""
+      ) || new Set(affected).size !== affected.length) {
+        errors.push(
+          `${prefix}.ceiling_transition.affected_delegation_ids must be a non-empty unique string list.`
+        );
+      }
+    }
+  } else if (value["ceiling_transition"] !== void 0 && value["ceiling_transition"] !== null) {
+    errors.push(
+      `${prefix}.ceiling_transition must be absent unless the ceiling rises.`
+    );
+  }
+  for (const key of RESOLVED_KEYS) {
+    if (value[key] !== expected[key]) {
+      errors.push(
+        `${prefix}.${key} must be ${pythonRepr2(expected[key])}, found ${pythonRepr2(value[key])}.`
+      );
+    }
+  }
+  return { errors, resolvedCeiling: currentCeiling };
+}
+function validateCodexModelRoutingReceipt(value, prefix = `Checkpoint ${CODEX_MODEL_ROUTING_RECEIPTS_KEY}[0]`) {
+  return validateReceipt(value, prefix).errors;
+}
+function validateCodexModelRoutingReceipts(value) {
+  if (!Array.isArray(value)) {
+    return [
+      `Checkpoint ${CODEX_MODEL_ROUTING_RECEIPTS_KEY} must be a list when present.`
+    ];
+  }
+  const errors = [];
+  let previousCeiling;
+  value.forEach((item, index) => {
+    const result = validateReceipt(
+      item,
+      `Checkpoint ${CODEX_MODEL_ROUTING_RECEIPTS_KEY}[${index}]`,
+      previousCeiling
+    );
+    errors.push(...result.errors);
+    previousCeiling = result.resolvedCeiling ?? previousCeiling;
+  });
+  return errors;
+}
+function delegatedAgentNames(state) {
+  const result = /* @__PURE__ */ new Set();
+  const receipts = state["delegation_receipts"];
+  if (!Array.isArray(receipts)) {
+    return result;
+  }
+  for (const item of receipts) {
+    if (!isObject4(item)) {
+      continue;
+    }
+    const agentName = item["agent_name"];
+    if (typeof agentName === "string" && agentName.trim() !== "") {
+      result.add(agentName);
+    }
+  }
+  return result;
+}
+function validateCodexModelRoutingGate(state) {
+  const delegated = delegatedAgentNames(state);
+  if (delegated.size === 0) {
+    return [];
+  }
+  const value = state[CODEX_MODEL_ROUTING_RECEIPTS_KEY];
+  const errors = validateCodexModelRoutingReceipts(value);
+  if (!Array.isArray(value)) {
+    return errors;
+  }
+  const logicalAgents = /* @__PURE__ */ new Set();
+  const deploymentAgents = /* @__PURE__ */ new Set();
+  for (const item of value) {
+    if (!isObject4(item)) {
+      continue;
+    }
+    const logical = item["logical_agent"];
+    const deployment = item["deployment_agent"];
+    if (typeof logical === "string") {
+      logicalAgents.add(logical);
+    }
+    if (typeof deployment === "string") {
+      deploymentAgents.add(deployment);
+    }
+  }
+  for (const agent of [...delegated].sort()) {
+    if (!logicalAgents.has(agent) && !deploymentAgents.has(agent)) {
+      errors.push(
+        `Checkpoint ${CODEX_MODEL_ROUTING_RECEIPTS_KEY} is missing a receipt for delegated agent: ${agent}.`
+      );
+    }
+  }
+  return errors;
+}
+function validateCodexModelRoutingState(state, requireGate = false) {
+  const errors = [];
+  if (CODEX_MODEL_ROUTING_RECEIPTS_KEY in state) {
+    errors.push(
+      ...validateCodexModelRoutingReceipts(
+        state[CODEX_MODEL_ROUTING_RECEIPTS_KEY]
+      )
+    );
+  }
+  if (requireGate) {
+    errors.push(...validateCodexModelRoutingGate(state));
+  }
+  return errors;
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/codex-topology-resolver.ts
+var VALID_EXECUTION_CONTEXTS2 = /* @__PURE__ */ new Set([
+  "standalone",
+  "epic_preparation_child",
+  "epic_execution_child"
+]);
+var EPIC_CHILD_CONTEXTS = /* @__PURE__ */ new Set([
+  "epic_preparation_child",
+  "epic_execution_child"
+]);
+var FORCED_ROOT_PERSONAS = /* @__PURE__ */ new Set([
+  "epic-planner",
+  "epic-orchestrator"
+]);
+var ORCHESTRATOR_LOGICAL_AGENT = "orchestrator";
+var LANGUAGE_BUDGETS = {
+  python: {
+    direct_mode_enabled: true,
+    max_production_files: 3,
+    max_test_files: 3,
+    logical_agent: "python-typed-engineer"
+  },
+  powershell: {
+    direct_mode_enabled: true,
+    max_production_files: 2,
+    max_test_files: 3,
+    logical_agent: "powershell-typed-engineer"
+  },
+  csharp: {
+    direct_mode_enabled: true,
+    max_production_files: 3,
+    max_test_files: 3,
+    logical_agent: "csharp-typed-engineer"
+  },
+  typescript: {
+    direct_mode_enabled: false,
+    max_production_files: 0,
+    max_test_files: 0,
+    logical_agent: "typescript-engineer"
+  }
+};
+function pythonRepr3(value) {
+  if (value === void 0 || value === null) {
+    return "None";
+  }
+  if (typeof value === "string") {
+    return `'${value.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
+  }
+  if (typeof value === "boolean") {
+    return value ? "True" : "False";
+  }
+  return String(value);
+}
+function validateContext2(value) {
+  if (typeof value !== "string" || !VALID_EXECUTION_CONTEXTS2.has(value)) {
+    throw new Error(
+      `execution_context must be one of ('epic_execution_child', 'epic_preparation_child', 'standalone'), found ${pythonRepr3(value)}.`
+    );
+  }
+  return value;
+}
+function normalizeLanguages(value) {
+  if (!Array.isArray(value) || value.some(
+    (language) => typeof language !== "string" || language.trim() === ""
+  )) {
+    throw new Error("languages must contain non-empty strings.");
+  }
+  const normalized = new Set(
+    value.map((language) => language.trim().toLowerCase())
+  );
+  return [...normalized].sort();
+}
+function requireInteger(value, fieldName) {
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    throw new Error(`${fieldName} must be an integer.`);
+  }
+  return value;
+}
+function requireBoolean(value) {
+  if (typeof value !== "boolean") {
+    throw new Error("cross_cutting must be a boolean.");
+  }
+  return value;
+}
+function orchestratorReceipt(context, languages, productionFileCount, testFileCount, crossCutting, reason, budget) {
+  return {
+    execution_context: context,
+    languages,
+    production_file_count: productionFileCount,
+    test_file_count: testFileCount,
+    cross_cutting: crossCutting,
+    root_persona: null,
+    route: "large",
+    topology: "orchestrator",
+    logical_agent: ORCHESTRATOR_LOGICAL_AGENT,
+    routing_reason: reason,
+    max_production_files: budget?.max_production_files ?? null,
+    max_test_files: budget?.max_test_files ?? null
+  };
+}
+function resolveCodexTopology(languagesValue, productionFileCountValue, testFileCountValue, executionContextValue, options = {}) {
+  const context = validateContext2(executionContextValue);
+  const languages = normalizeLanguages(languagesValue);
+  const productionFileCount = requireInteger(
+    productionFileCountValue,
+    "production_file_count"
+  );
+  const testFileCount = requireInteger(testFileCountValue, "test_file_count");
+  const crossCutting = requireBoolean(
+    options.crossCutting === void 0 ? false : options.crossCutting
+  );
+  const rootPersona = options.rootPersona ?? null;
+  if (rootPersona !== null) {
+    if (typeof rootPersona !== "string" || !FORCED_ROOT_PERSONAS.has(rootPersona)) {
+      throw new Error(
+        `Unsupported Codex root persona: ${pythonRepr3(rootPersona)}.`
+      );
+    }
+    if (context !== "standalone") {
+      throw new Error("A forced root persona requires standalone context.");
+    }
+    const persona = rootPersona;
+    return {
+      execution_context: context,
+      languages,
+      production_file_count: productionFileCount,
+      test_file_count: testFileCount,
+      cross_cutting: crossCutting,
+      root_persona: persona,
+      route: "epic",
+      topology: "epic_persona",
+      logical_agent: persona,
+      routing_reason: "forced_root_persona",
+      max_production_files: null,
+      max_test_files: null
+    };
+  }
+  const escalate = (reason, budget2) => orchestratorReceipt(
+    context,
+    languages,
+    productionFileCount,
+    testFileCount,
+    crossCutting,
+    reason,
+    budget2
+  );
+  if (EPIC_CHILD_CONTEXTS.has(context)) {
+    return escalate("epic_child_context");
+  }
+  if (productionFileCount <= 0 || testFileCount < 0) {
+    return escalate("invalid_estimate");
+  }
+  if (languages.length > 1) {
+    return escalate("cross_language");
+  }
+  if (languages.length !== 1) {
+    return escalate("unsupported_language");
+  }
+  const budget = LANGUAGE_BUDGETS[languages[0] ?? ""];
+  if (budget === void 0) {
+    return escalate("unsupported_language");
+  }
+  if (crossCutting) {
+    return escalate("cross_cutting", budget);
+  }
+  if (!budget.direct_mode_enabled) {
+    return escalate("direct_mode_disabled", budget);
+  }
+  if (productionFileCount > budget.max_production_files) {
+    return escalate("production_budget_exceeded", budget);
+  }
+  return {
+    execution_context: context,
+    languages,
+    production_file_count: productionFileCount,
+    test_file_count: testFileCount,
+    cross_cutting: crossCutting,
+    root_persona: null,
+    route: "small",
+    topology: "typed_engineer",
+    logical_agent: budget.logical_agent,
+    routing_reason: "within_language_budget",
+    max_production_files: budget.max_production_files,
+    max_test_files: budget.max_test_files
+  };
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/orchestrator-state-codex-topology.ts
+var CODEX_TOPOLOGY_RECEIPTS_KEY = "codex_topology_receipts";
+var REQUIRED_KEYS2 = [
+  "phase",
+  "execution_context",
+  "languages",
+  "production_file_count",
+  "test_file_count",
+  "cross_cutting",
+  "root_persona",
+  "route",
+  "topology",
+  "logical_agent",
+  "routing_reason",
+  "max_production_files",
+  "max_test_files"
+];
+var RESOLVED_KEYS2 = REQUIRED_KEYS2.filter((key) => key !== "phase");
+var FORCED_ROOT_PERSONAS2 = /* @__PURE__ */ new Set([
+  "epic-orchestrator",
+  "epic-planner"
+]);
+function isObject5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pythonRepr4(value) {
+  if (value === void 0 || value === null) {
+    return "None";
+  }
+  if (typeof value === "string") {
+    const escaped = value.replaceAll("\\", "\\\\").replaceAll("'", "\\'").replaceAll("\n", "\\n").replaceAll("\r", "\\r").replaceAll("	", "\\t");
+    return `'${escaped}'`;
+  }
+  if (typeof value === "boolean") {
+    return value ? "True" : "False";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(pythonRepr4).join(", ")}]`;
+  }
+  if (isObject5(value)) {
+    const entries = Object.entries(value).map(
+      ([key, item]) => `${pythonRepr4(key)}: ${pythonRepr4(item)}`
+    );
+    return `{${entries.join(", ")}}`;
+  }
+  return String(value);
+}
+function valuesEqual(actual, expected) {
+  if (Array.isArray(actual) && Array.isArray(expected)) {
+    return actual.length === expected.length && actual.every((item, index) => item === expected[index]);
+  }
+  return actual === expected;
+}
+function validateReceiptInputs(receipt, prefix) {
+  const errors = [];
+  const languages = receipt["languages"];
+  if (!Array.isArray(languages) || languages.some(
+    (language) => typeof language !== "string" || language.trim().length === 0
+  )) {
+    errors.push(`${prefix}.languages must be a list of non-empty strings.`);
+  }
+  for (const key of ["production_file_count", "test_file_count"]) {
+    const value = receipt[key];
+    if (typeof value !== "number" || !Number.isInteger(value)) {
+      errors.push(`${prefix}.${key} must be an integer.`);
+    }
+  }
+  if (typeof receipt["cross_cutting"] !== "boolean") {
+    errors.push(`${prefix}.cross_cutting must be a boolean.`);
+  }
+  if (typeof receipt["execution_context"] !== "string") {
+    errors.push(`${prefix}.execution_context must be a string.`);
+  }
+  const rootPersona = receipt["root_persona"];
+  if (rootPersona !== null && !FORCED_ROOT_PERSONAS2.has(rootPersona)) {
+    errors.push(
+      `${prefix}.root_persona must be null or one of ('epic-orchestrator', 'epic-planner').`
+    );
+  }
+  return errors;
+}
+function validateReceipt2(value, prefix) {
+  if (!isObject5(value)) {
+    return [`${prefix} must be an object.`];
+  }
+  const missing = REQUIRED_KEYS2.filter((key) => !(key in value));
+  if (missing.length > 0) {
+    return [`${prefix} missing required keys: ${missing.join(", ")}.`];
+  }
+  const errors = [];
+  const phase = value["phase"];
+  if (typeof phase !== "string" || phase.trim().length === 0) {
+    errors.push(`${prefix}.phase must be a non-empty string.`);
+  }
+  const inputErrors = validateReceiptInputs(value, prefix);
+  errors.push(...inputErrors);
+  if (inputErrors.length > 0) {
+    return errors;
+  }
+  let expected;
+  try {
+    expected = resolveCodexTopology(
+      value["languages"],
+      value["production_file_count"],
+      value["test_file_count"],
+      value["execution_context"],
+      {
+        crossCutting: value["cross_cutting"],
+        rootPersona: value["root_persona"]
+      }
+    );
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    errors.push(`${prefix} has invalid routing inputs: ${message}`);
+    return errors;
+  }
+  for (const key of RESOLVED_KEYS2) {
+    if (!valuesEqual(value[key], expected[key])) {
+      errors.push(
+        `${prefix}.${key} must be ${pythonRepr4(expected[key])}, found ${pythonRepr4(value[key])}.`
+      );
+    }
+  }
+  return errors;
+}
+function validateCodexTopologyReceipt(value, prefix = `Checkpoint ${CODEX_TOPOLOGY_RECEIPTS_KEY}[0]`) {
+  return validateReceipt2(value, prefix);
+}
+function validateCodexTopologyReceipts(value) {
+  if (!Array.isArray(value)) {
+    return [
+      `Checkpoint ${CODEX_TOPOLOGY_RECEIPTS_KEY} must be a list when present.`
+    ];
+  }
+  return value.flatMap(
+    (item, index) => validateReceipt2(
+      item,
+      `Checkpoint ${CODEX_TOPOLOGY_RECEIPTS_KEY}[${index}]`
+    )
+  );
+}
+function delegatedAgentNames2(state) {
+  const result = /* @__PURE__ */ new Set();
+  const receipts = state["delegation_receipts"];
+  if (!Array.isArray(receipts)) {
+    return result;
+  }
+  for (const item of receipts) {
+    if (!isObject5(item)) {
+      continue;
+    }
+    const agentName = item["agent_name"];
+    if (typeof agentName === "string" && agentName.trim().length > 0) {
+      result.add(agentName);
+    }
+  }
+  return result;
+}
+function validReceipts(value) {
+  return value.filter(
+    (item) => isObject5(item) && validateCodexTopologyReceipts([item]).length === 0
+  );
+}
+function modelDeployments(state, logicalAgent) {
+  const result = /* @__PURE__ */ new Set();
+  const receipts = state[CODEX_MODEL_ROUTING_RECEIPTS_KEY];
+  if (!Array.isArray(receipts)) {
+    return result;
+  }
+  for (const item of receipts) {
+    if (!isObject5(item) || validateCodexModelRoutingReceipt(item).length > 0 || item["logical_agent"] !== logicalAgent) {
+      continue;
+    }
+    const deployment = item["deployment_agent"];
+    if (typeof deployment === "string") {
+      result.add(deployment);
+    }
+  }
+  return result;
+}
+function validateCodexTopologyGate(state, options = {}) {
+  const delegated = delegatedAgentNames2(state);
+  const requiredRootPersona = options.requiredRootPersona;
+  if (delegated.size === 0 && requiredRootPersona === void 0) {
+    return [];
+  }
+  const value = state[CODEX_TOPOLOGY_RECEIPTS_KEY];
+  const errors = validateCodexTopologyReceipts(value);
+  if (!Array.isArray(value)) {
+    return errors;
+  }
+  const receipts = validReceipts(value);
+  if (requiredRootPersona !== void 0 && !receipts.some((receipt) => receipt.root_persona === requiredRootPersona)) {
+    errors.push(
+      `Checkpoint ${CODEX_TOPOLOGY_RECEIPTS_KEY} is missing the forced root persona receipt for ${requiredRootPersona}.`
+    );
+  }
+  const childReceipts = receipts.filter(
+    (receipt) => receipt.root_persona === null
+  );
+  if (delegated.size > 0 && childReceipts.length === 0) {
+    errors.push(
+      `Checkpoint ${CODEX_TOPOLOGY_RECEIPTS_KEY} is missing a child topology receipt for recorded delegations.`
+    );
+  }
+  for (const receipt of childReceipts) {
+    const selectedRoute = state["path_selected"];
+    if (receipt.execution_context === "standalone" && (selectedRoute === "small" || selectedRoute === "large") && receipt.route !== selectedRoute) {
+      errors.push(
+        `Checkpoint path_selected ${pythonRepr4(selectedRoute)} does not match the resolved Codex topology route ${pythonRepr4(receipt.route)}.`
+      );
+    }
+    const allowedNames = modelDeployments(state, receipt.logical_agent);
+    allowedNames.add(receipt.logical_agent);
+    if ([...delegated].every((agent) => !allowedNames.has(agent))) {
+      errors.push(
+        `Checkpoint delegation_receipts is missing the exact resolved topology agent for ${receipt.logical_agent}: ${[...allowedNames].sort().join(", ")}.`
+      );
+    }
+  }
+  return errors;
+}
+function validateCodexTopologyState(state, requireGate = false, options = {}) {
+  const errors = [];
+  if (CODEX_TOPOLOGY_RECEIPTS_KEY in state) {
+    errors.push(
+      ...validateCodexTopologyReceipts(state[CODEX_TOPOLOGY_RECEIPTS_KEY])
+    );
+  }
+  if (requireGate) {
+    errors.push(...validateCodexTopologyGate(state, options));
+  }
+  return errors;
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/epic-orchestrator-state-core.ts
+var REQUIRED_BASELINE_KEYS = [
+  "objective",
+  "completed_steps",
+  "next_step",
+  "last_updated"
+];
+var REQUIRED_EPIC_KEYS = [
+  "route_id",
+  "epic_feature_folder",
+  "integration_branch",
+  "max_parallel_features",
+  "waves",
+  "features"
+];
+var EXPECTED_ROUTE_ID = "epic";
+var VALID_MERGE_STATUS = /* @__PURE__ */ new Set([
+  "not_started",
+  "worktree_created",
+  "pr_open",
+  "ci_green",
+  "merge_conflict",
+  "blocked_conflict_loop_limit",
+  "merged",
+  "worktree_removed"
+]);
+var MERGED_STATUSES = /* @__PURE__ */ new Set([
+  "merged",
+  "worktree_removed"
+]);
+function isObject6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extractFeatures(state) {
+  const features = state["features"];
+  if (!Array.isArray(features)) {
+    return [];
+  }
+  return features.filter(isObject6);
+}
+function missingBaselineAndEpicKeys(state) {
+  const errors = [];
+  for (const key of [...REQUIRED_BASELINE_KEYS, ...REQUIRED_EPIC_KEYS]) {
+    if (!(key in state)) {
+      errors.push(`Epic checkpoint missing required key: ${key}`);
+    }
+  }
+  return errors;
+}
+function validateRouteId(state) {
+  const errors = [];
+  if ("route_id" in state && state["route_id"] !== EXPECTED_ROUTE_ID) {
+    errors.push(
+      `Epic checkpoint route_id must be 'epic', found: ${JSON.stringify(state["route_id"])}`
+    );
+  }
+  const parallelism = state["max_parallel_features"];
+  if (typeof parallelism !== "number" || !Number.isInteger(parallelism) || parallelism < 1 || parallelism > 8) {
+    errors.push(
+      "Epic checkpoint max_parallel_features must be an integer from 1 through 8."
+    );
+  }
+  return errors;
+}
+function validateFeatureFolderUniquenessAndDependencies(features) {
+  const errors = [];
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = /* @__PURE__ */ new Set();
+  const index = buildFeatureReferenceIndex(features);
+  for (const feature of features) {
+    const folder = feature["feature_folder"];
+    if (typeof folder !== "string" || !folder) {
+      continue;
+    }
+    if (seen.has(folder)) {
+      duplicates.add(folder);
+    }
+    seen.add(folder);
+    const dependsOn = feature["depends_on"];
+    if (!Array.isArray(dependsOn)) {
+      continue;
+    }
+    for (const dependency of dependsOn) {
+      if (resolveFeatureReference(dependency, index) === null) {
+        errors.push(
+          `Epic checkpoint feature '${folder}' depends_on unresolved feature_folder: ${JSON.stringify(dependency)}`
+        );
+      }
+    }
+  }
+  for (const folder of [...duplicates].sort()) {
+    errors.push(
+      `Epic checkpoint has duplicate features[].feature_folder: ${folder}`
+    );
+  }
+  return errors;
+}
+function validateMergeStatusEnum(features) {
+  const errors = [];
+  for (const feature of features) {
+    const folder = feature["feature_folder"] ?? "<unknown>";
+    const mergeStatus = feature["merge_status"];
+    if (mergeStatus !== void 0 && mergeStatus !== null && !(typeof mergeStatus === "string" && VALID_MERGE_STATUS.has(mergeStatus))) {
+      errors.push(
+        `Epic checkpoint feature '${String(folder)}' has invalid merge_status: ${JSON.stringify(mergeStatus)}`
+      );
+    }
+  }
+  return errors;
+}
+function validateWaveBarrierOrdering(features) {
+  const errors = [];
+  const byFolder = /* @__PURE__ */ new Map();
+  for (const feature of features) {
+    const folder = feature["feature_folder"];
+    if (typeof folder === "string") {
+      byFolder.set(folder, feature);
+    }
+  }
+  const index = buildFeatureReferenceIndex(features);
+  for (const feature of features) {
+    const folder = feature["feature_folder"];
+    const dependsOn = feature["depends_on"];
+    if (typeof folder !== "string" || !Array.isArray(dependsOn)) {
+      continue;
+    }
+    const worktreeCreatedAt = feature["worktree_created_at"];
+    for (const dependency of dependsOn) {
+      const resolved = resolveFeatureReference(dependency, index);
+      const dependencyFeature = resolved !== null ? byFolder.get(resolved) : void 0;
+      if (dependencyFeature === void 0) {
+        continue;
+      }
+      const depMergeStatus = dependencyFeature["merge_status"];
+      const depConfirmedAt = dependencyFeature["merge_confirmed_at"];
+      const statusViolation = typeof depMergeStatus !== "string" || !MERGED_STATUSES.has(depMergeStatus);
+      const timingViolation = typeof depConfirmedAt === "string" && typeof worktreeCreatedAt === "string" && depConfirmedAt > worktreeCreatedAt;
+      if (statusViolation || timingViolation) {
+        errors.push(
+          `EPIC_WAVE_BARRIER_VIOLATION: ${folder} started before dependency ${String(dependency)} merged`
+        );
+      }
+    }
+  }
+  return errors;
 }
 function validateWavesConsistency(state) {
   const errors = [];
@@ -22156,7 +23494,7 @@ function validateWavesConsistency(state) {
   }
   const index = buildFeatureReferenceIndex(features);
   for (const waveItem of waves) {
-    if (!isObject3(waveItem)) {
+    if (!isObject6(waveItem)) {
       continue;
     }
     const waveNumber = waveItem["wave_number"];
@@ -22191,7 +23529,7 @@ function validateCompletion(features, state) {
     }
   }
   const epicMergePr = state["epic_merge_pr"];
-  const mergeCommitSha = isObject3(epicMergePr) ? epicMergePr["merge_commit_sha"] : void 0;
+  const mergeCommitSha = isObject6(epicMergePr) ? epicMergePr["merge_commit_sha"] : void 0;
   if (typeof mergeCommitSha !== "string" || !mergeCommitSha.trim()) {
     errors.push(
       "Epic checkpoint completion validation failed: epic_merge_pr.merge_commit_sha is missing or empty."
@@ -22208,7 +23546,7 @@ function validateEpicOrchestratorStateText(text, options = {}) {
       `Epic checkpoint is not valid JSON: ${exc instanceof Error ? exc.message : String(exc)}`
     ];
   }
-  if (!isObject3(state)) {
+  if (!isObject6(state)) {
     return ["Epic checkpoint root must be a JSON object."];
   }
   const stateMap = state;
@@ -22225,236 +23563,1305 @@ function validateEpicOrchestratorStateText(text, options = {}) {
   errors.push(...validateWaveBarrierOrdering(features));
   errors.push(...validateWavesConsistency(stateMap));
   errors.push(...validateIntentBlock(stateMap));
+  errors.push(...validateEpicChildLaunchBindings(stateMap, options));
+  if (CODEX_MODEL_ROUTING_RECEIPTS_KEY in stateMap) {
+    errors.push(
+      ...validateCodexModelRoutingReceipts(
+        stateMap[CODEX_MODEL_ROUTING_RECEIPTS_KEY]
+      )
+    );
+  }
   if (options.requireComplete === true) {
     errors.push(...validateCompletion(features, stateMap));
   }
+  if (options.requireCodexModelRouting === true) {
+    errors.push(...validateCodexModelRoutingGate(stateMap));
+  }
+  errors.push(
+    ...validateCodexTopologyState(
+      stateMap,
+      options.requireCodexTopology === true,
+      { requiredRootPersona: "epic-orchestrator" }
+    )
+  );
   return errors;
 }
 
-// ../../extensions/drm-copilot/src/lib/validate/orchestrator-state-completion.ts
-var ISSUE_232 = "232";
-var ISSUE_232_BRANCH = "feature/harden-orchestrate-skill-232";
-var PR_GATE_KEYS = [
-  "pr_number",
-  "pr_url",
-  "head_branch",
-  "head_sha"
-];
-var CI_GATE_KEYS = ["conclusion", "head_sha", "verified_at"];
-var PROMOTION_RECEIPT_NAMESPACE_KEY = "promotion";
-var PROMOTION_RECEIPT_KEYS = [
-  "potential_entry",
-  "issue",
-  "feature_folder"
-];
-function isObject4(value) {
+// ../../extensions/drm-copilot/src/lib/validate/epic-wave-computation.ts
+function pythonRepr5(value) {
+  return `'${value.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
+}
+var EpicWaveCycleError = class extends Error {
+  featureFolder;
+  constructor(featureFolder) {
+    super(
+      `Epic dependency manifest contains a cycle at feature folder ${pythonRepr5(featureFolder)}; wave numbers cannot be computed for a cyclic dependency graph.`
+    );
+    this.name = "EpicWaveCycleError";
+    this.featureFolder = featureFolder;
+  }
+};
+function computeWaveNumbers(manifest) {
+  const waveNumbers = /* @__PURE__ */ new Map();
+  const inProgress = /* @__PURE__ */ new Set();
+  function resolve4(featureFolder) {
+    const existing = waveNumbers.get(featureFolder);
+    if (existing !== void 0) {
+      return existing;
+    }
+    if (inProgress.has(featureFolder)) {
+      throw new EpicWaveCycleError(featureFolder);
+    }
+    inProgress.add(featureFolder);
+    let waveNumber;
+    try {
+      const dependencies = manifest.get(featureFolder) ?? [];
+      waveNumber = dependencies.length === 0 ? 0 : 1 + Math.max(...dependencies.map(resolve4));
+    } finally {
+      inProgress.delete(featureFolder);
+    }
+    waveNumbers.set(featureFolder, waveNumber);
+    return waveNumber;
+  }
+  for (const featureFolder of manifest.keys()) {
+    resolve4(featureFolder);
+  }
+  return waveNumbers;
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/epic-planner-git-integrity.ts
+var HASH_RE = /^[0-9a-fA-F]{40,64}$/;
+var COMMIT_RE = /^[0-9a-fA-F]{7,64}$/;
+var CommandRunnerGitRepository = class {
+  constructor(workspaceRoot, runner) {
+    this.workspaceRoot = workspaceRoot;
+    this.runner = runner;
+  }
+  workspaceRoot;
+  runner;
+  run(arguments_) {
+    const result = this.runner.run(["git", ...arguments_], {
+      cwd: this.workspaceRoot,
+      allowError: true
+    });
+    return { code: result.code, stdout: result.stdout.trim() };
+  }
+  refExists(ref) {
+    return this.run(["rev-parse", "--verify", `${ref}^{commit}`]).code === 0;
+  }
+  commitExists(commit) {
+    return this.run(["cat-file", "-e", `${commit}^{commit}`]).code === 0;
+  }
+  isAncestor(commit, ref) {
+    return this.run(["merge-base", "--is-ancestor", commit, ref]).code === 0;
+  }
+  lastCommit(path11) {
+    const result = this.run(["log", "-n", "1", "--format=%H", "--", path11]);
+    return result.code === 0 && result.stdout.length > 0 ? result.stdout : void 0;
+  }
+  committedBlobHash(ref, path11) {
+    const result = this.run(["rev-parse", "--verify", `${ref}:${path11}`]);
+    return result.code === 0 && HASH_RE.test(result.stdout) ? result.stdout.toLowerCase() : void 0;
+  }
+  worktreeBlobHash(path11) {
+    const result = this.run(["hash-object", "--", path11]);
+    return result.code === 0 && HASH_RE.test(result.stdout) ? result.stdout.toLowerCase() : void 0;
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalIntegrity(state, parsed) {
+  const errors = [];
+  const integrityValue = state["integrity"];
+  let integrity = {};
+  if (integrityValue !== void 0) {
+    if (!isRecord(integrityValue)) {
+      errors.push(
+        "Epic planner checkpoint integrity must be an object when present."
+      );
+    } else {
+      integrity = integrityValue;
+    }
+  }
+  const commits = [
+    state["planning_commit"],
+    integrity["planning_commit"],
+    parsed.planningCommit
+  ].filter((value) => value !== void 0);
+  for (const commit of commits) {
+    if (typeof commit !== "string" || !COMMIT_RE.test(commit)) {
+      errors.push(
+        "Optional planning_commit values must be 7-64 hexadecimal characters."
+      );
+    }
+  }
+  const normalized = commits.filter(
+    (commit) => typeof commit === "string" && COMMIT_RE.test(commit)
+  ).map((commit) => commit.toLowerCase());
+  if (new Set(normalized).size > 1) {
+    errors.push(
+      "Optional planning_commit values in state and kickoff must match."
+    );
+  }
+  const planHashes = { ...parsed.planHashes };
+  const stateHashes = integrity["plan_hashes"] ?? state["plan_hashes"];
+  if (stateHashes !== void 0) {
+    if (!isRecord(stateHashes)) {
+      errors.push("Optional plan_hashes must be an object keyed by plan path.");
+    } else {
+      for (const [path11, value] of Object.entries(stateHashes)) {
+        if (typeof value !== "string" || !HASH_RE.test(value)) {
+          errors.push(
+            "Optional plan_hashes entries must map paths to 40-64 character hexadecimal hashes."
+          );
+          continue;
+        }
+        if (planHashes[path11] !== void 0 && planHashes[path11] !== value.toLowerCase()) {
+          errors.push(
+            `Optional plan hash declarations disagree for '${path11}'.`
+          );
+        }
+        planHashes[path11] = value.toLowerCase();
+      }
+    }
+  }
+  return {
+    ...normalized[0] === void 0 ? {} : { planningCommit: normalized[0] },
+    planHashes,
+    errors
+  };
+}
+function validateCommittedFile(git, ref, path11, label) {
+  const committed = git.committedBlobHash(ref, path11);
+  const worktree = git.worktreeBlobHash(path11);
+  if (committed === void 0) {
+    return [
+      `Execution readiness requires ${label} committed at ${ref}: ${path11}`
+    ];
+  }
+  if (worktree === void 0) {
+    return [`Execution readiness could not hash worktree ${label}: ${path11}`];
+  }
+  if (committed !== worktree) {
+    return [
+      `Execution readiness detected worktree drift for ${label}: ${path11}`
+    ];
+  }
+  return [];
+}
+function validatePlanningGitIntegrity(state, parsed, plans, git) {
+  const branch = state["integration_branch"];
+  if (typeof branch !== "string" || !git.refExists(branch)) {
+    return [
+      `Execution readiness integration branch does not exist: '${String(branch)}'`
+    ];
+  }
+  const errors = [];
+  const integrity = optionalIntegrity(state, parsed);
+  errors.push(...integrity.errors);
+  if (integrity.planningCommit !== void 0) {
+    if (!git.commitExists(integrity.planningCommit)) {
+      errors.push(
+        `Execution readiness planning commit does not exist: ${integrity.planningCommit}`
+      );
+    } else if (!git.isAncestor(integrity.planningCommit, branch)) {
+      errors.push(
+        `Execution readiness planning commit ${integrity.planningCommit} is not an ancestor of ${branch}.`
+      );
+    }
+  }
+  const features = Array.isArray(state["features"]) ? state["features"].filter(isRecord) : [];
+  plans.forEach((plan, index) => {
+    const derived = git.lastCommit(plan);
+    if (derived === void 0) {
+      errors.push(
+        `Execution readiness could not derive a planning commit for ${plan}.`
+      );
+      return;
+    }
+    if (!git.commitExists(derived) || !git.isAncestor(derived, branch)) {
+      errors.push(
+        `Execution readiness derived plan commit ${derived} is not on ${branch}.`
+      );
+      return;
+    }
+    const candidates = [derived];
+    const feature = features[index] ?? {};
+    const featureCommit = feature["planning_commit"];
+    if (featureCommit !== void 0) {
+      if (typeof featureCommit !== "string" || !COMMIT_RE.test(featureCommit)) {
+        errors.push(
+          `Epic planner checkpoint features[${index}].planning_commit must be hexadecimal.`
+        );
+      } else {
+        candidates.push(featureCommit.toLowerCase());
+      }
+    }
+    if (integrity.planningCommit !== void 0) {
+      candidates.push(integrity.planningCommit);
+    }
+    const worktreeHash = git.worktreeBlobHash(plan);
+    if (worktreeHash === void 0) {
+      errors.push(
+        `Execution readiness could not hash worktree atomic plan: ${plan}`
+      );
+      return;
+    }
+    for (const candidate of [...new Set(candidates)]) {
+      if (!git.commitExists(candidate)) {
+        errors.push(
+          `Execution readiness planning commit does not exist: ${candidate}`
+        );
+        continue;
+      }
+      if (!git.isAncestor(candidate, branch)) {
+        errors.push(
+          `Execution readiness planning commit ${candidate} is not an ancestor of ${branch}.`
+        );
+        continue;
+      }
+      const committedHash = git.committedBlobHash(candidate, plan);
+      if (committedHash === void 0) {
+        errors.push(
+          `Execution readiness planning commit ${candidate} does not contain ${plan}.`
+        );
+      } else if (committedHash !== worktreeHash) {
+        errors.push(
+          `Execution readiness detected committed plan drift: ${plan}`
+        );
+      }
+    }
+    const declared = feature["plan_hash"] ?? integrity.planHashes[plan];
+    if (declared !== void 0) {
+      if (typeof declared !== "string" || !HASH_RE.test(declared)) {
+        errors.push(
+          `Optional plan hash for ${plan} must be 40-64 hexadecimal characters.`
+        );
+      } else if (declared.toLowerCase() !== worktreeHash) {
+        errors.push(
+          `Optional plan hash does not match committed bytes for ${plan}.`
+        );
+      }
+    }
+  });
+  for (const extra of Object.keys(integrity.planHashes).filter((path11) => !plans.includes(path11)).sort()) {
+    errors.push(
+      `Optional plan_hashes contains unknown planner path: '${extra}'.`
+    );
+  }
+  return errors;
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/epic-planner-launch-evidence.ts
+var import_node_crypto = require("node:crypto");
+var LAUNCH_ROOT = "artifacts/orchestration/epic-child-launches";
+var SHA256_RE = /^[0-9a-f]{64}$/;
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function missingObjectKeys(value, keys) {
-  if (!isObject4(value)) {
-    return [...keys];
+function isNonEmpty(value) {
+  return typeof value === "string" && value.trim().length > 0 && value === value.trim();
+}
+function launchPath(value, context, field) {
+  if (!isNonEmpty(value) || value.includes("\0")) {
+    return {
+      errors: [`${field} must identify a launch artifact in this repository.`]
+    };
+  }
+  let normalized = toPosixPath2(value);
+  const root = toPosixPath2(context.workspaceRoot).replace(/\/+$/, "");
+  const rootPrefix = `${root}/`;
+  if (normalized.toLowerCase().startsWith(rootPrefix.toLowerCase())) {
+    normalized = normalized.slice(rootPrefix.length);
+  }
+  const parts = normalized.split("/");
+  if (normalized.startsWith("/") || /^[A-Za-z]:/.test(normalized) || parts.includes("..") || parts.includes(".") || !normalized.startsWith(`${LAUNCH_ROOT}/`)) {
+    return {
+      errors: [`${field} must identify a launch artifact in this repository.`]
+    };
+  }
+  return { relative: parts.join("/"), errors: [] };
+}
+function readJson(relative2, context, label) {
+  const path11 = `${toPosixPath2(context.workspaceRoot).replace(/\/+$/, "")}/${relative2}`;
+  if (!context.fileSystem.isFile(path11)) {
+    return { errors: [`Execution readiness requires ${label}: ${relative2}`] };
+  }
+  let text;
+  try {
+    text = context.fileSystem.readTextFile(path11);
+  } catch (error2) {
+    return {
+      errors: [
+        `Execution readiness could not read ${label} ${relative2}: ${String(error2)}`
+      ]
+    };
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch (error2) {
+    return {
+      text,
+      errors: [
+        `Execution readiness ${label} is not valid JSON: ${error2 instanceof Error ? error2.message : String(error2)}`
+      ]
+    };
+  }
+  if (!isRecord2(value)) {
+    return {
+      text,
+      errors: [`Execution readiness ${label} must be a JSON object.`]
+    };
+  }
+  return { value, text, errors: [] };
+}
+function expectedFeatureBindings(feature) {
+  const delegation = feature["delegation_receipt"];
+  const model = feature["model_routing_receipt"];
+  return {
+    issue_num: feature["issue_num"],
+    feature_folder: feature["feature_folder"],
+    delegation_id: isRecord2(delegation) ? delegation["delegation_id"] : void 0,
+    deployment_agent: isRecord2(model) ? model["deployment_agent"] : void 0,
+    model: isRecord2(model) ? model["model"] : void 0,
+    model_reasoning_effort: isRecord2(model) ? model["model_reasoning_effort"] : void 0,
+    execution_context: "epic_preparation_child",
+    branch_name: feature["branch_name"],
+    worktree_path: feature["worktree_path"]
+  };
+}
+function parseTimestamp(value, prefix, key, errors) {
+  if (!isNonEmpty(value) || !/(?:Z|[+-]\d\d:\d\d)$/.test(value) || Number.isNaN(Date.parse(value))) {
+    errors.push(`${prefix}.${key} must be an ISO-8601 timestamp with offset.`);
+    return void 0;
+  }
+  return new Date(value);
+}
+function validateCompletedReceipt(receipt, prefix) {
+  const errors = [];
+  if (receipt["schema_version"] !== 2 || receipt["state"] !== "completed") {
+    errors.push(`${prefix} must be a schema 2 completed launch receipt.`);
+  }
+  if (receipt["exit_code"] !== 0) {
+    errors.push(`${prefix}.exit_code must be 0.`);
+  }
+  if (!isNonEmpty(receipt["codex_session_id"])) {
+    errors.push(`${prefix}.codex_session_id must be a non-empty string.`);
+  }
+  const bound = parseTimestamp(
+    receipt["session_bound_at"],
+    prefix,
+    "session_bound_at",
+    errors
+  );
+  const completed = parseTimestamp(
+    receipt["completed_at"],
+    prefix,
+    "completed_at",
+    errors
+  );
+  if (bound !== void 0 && completed !== void 0 && completed < bound) {
+    errors.push(`${prefix}.completed_at must not precede session_bound_at.`);
+  }
+  return errors;
+}
+function validateSpec(receipt, expected, context, prefix) {
+  const specPath = launchPath(
+    receipt["spec_path"],
+    context,
+    `${prefix}.spec_path`
+  );
+  const errors = [...specPath.errors];
+  if (specPath.relative === void 0) {
+    return errors;
+  }
+  const receiptPath = launchPath(
+    receipt["receipt_path"],
+    context,
+    `${prefix}.receipt_path`
+  );
+  if (receiptPath.relative !== void 0 && specPath.relative.slice(0, specPath.relative.lastIndexOf("/")) !== receiptPath.relative.slice(0, receiptPath.relative.lastIndexOf("/"))) {
+    errors.push(`${prefix}.spec_path must share the receipt wave directory.`);
+  }
+  const spec = readJson(
+    specPath.relative,
+    context,
+    `${prefix} launch specification`
+  );
+  errors.push(...spec.errors);
+  const digest = receipt["spec_sha256"];
+  if (!isNonEmpty(digest) || !SHA256_RE.test(digest)) {
+    errors.push(`${prefix}.spec_sha256 must be a lowercase SHA-256 hash.`);
+  } else if (spec.text !== void 0 && (0, import_node_crypto.createHash)("sha256").update(spec.text, "utf8").digest("hex") !== digest) {
+    errors.push(`${prefix}.spec_sha256 does not match spec_path bytes.`);
+  }
+  if (spec.value === void 0) {
+    return errors;
+  }
+  if (spec.value["wave_id"] !== receipt["wave_id"]) {
+    errors.push(`${prefix}.wave_id must match its launch specification.`);
+  }
+  const launches = spec.value["launches"];
+  const matching = Array.isArray(launches) ? launches.filter(
+    (item) => isRecord2(item) && item["launch_id"] === receipt["launch_id"]
+  ) : [];
+  if (matching.length !== 1) {
+    errors.push(
+      `${prefix}.launch_id must identify exactly one specification launch.`
+    );
+  } else {
+    const launch = matching[0];
+    if (launch !== void 0) {
+      for (const [key, value] of Object.entries(expected)) {
+        if (launch[key] !== value) {
+          errors.push(
+            `${prefix} specification launch.${key} must match the feature.`
+          );
+        }
+      }
+    }
+  }
+  return errors;
+}
+function validateReceipt3(feature, index, context) {
+  const prefix = `Epic planner checkpoint features[${index}] launch receipt`;
+  const path11 = launchPath(
+    feature["launch_receipt_path"],
+    context,
+    `${prefix} path`
+  );
+  const errors = [...path11.errors];
+  if (path11.relative === void 0) {
+    return { errors };
+  }
+  const result = readJson(path11.relative, context, prefix);
+  errors.push(...result.errors);
+  if (result.value === void 0) {
+    return { path: path11.relative, errors };
+  }
+  const receipt = result.value;
+  const expected = expectedFeatureBindings(feature);
+  for (const [key, value] of Object.entries(expected)) {
+    if (receipt[key] !== value) {
+      errors.push(`${prefix}.${key} must match the feature.`);
+    }
+  }
+  const receiptPath = launchPath(
+    receipt["receipt_path"],
+    context,
+    `${prefix}.receipt_path`
+  );
+  errors.push(...receiptPath.errors);
+  if (receiptPath.relative !== void 0 && receiptPath.relative !== path11.relative) {
+    errors.push(`${prefix}.receipt_path must identify the receipt file.`);
+  }
+  const launchId = receipt["launch_id"];
+  const name = path11.relative.split("/").at(-1);
+  if (!isNonEmpty(launchId) || name !== `${launchId}.receipt.json`) {
+    errors.push(`${prefix}.launch_id must match the receipt filename.`);
+  }
+  const statusPath = launchPath(
+    receipt["status_path"],
+    context,
+    `${prefix}.status_path`
+  );
+  errors.push(...statusPath.errors);
+  const featureStatus = launchPath(
+    feature["launch_status_path"],
+    context,
+    `${prefix}.status_path`
+  );
+  if (statusPath.relative !== void 0 && statusPath.relative !== featureStatus.relative) {
+    errors.push(`${prefix}.status_path must match the feature status file.`);
+  }
+  errors.push(
+    ...validateCompletedReceipt(receipt, prefix),
+    ...validateSpec(receipt, expected, context, prefix)
+  );
+  return { receipt, path: path11.relative, errors };
+}
+function validateStatus(feature, index, receipt, receiptPath, status, statusPath, context) {
+  const prefix = `Epic planner checkpoint features[${index}] launch status`;
+  const errors = [];
+  if (status["schema_version"] !== 2 || status["state"] !== "completed") {
+    errors.push(`${prefix} shared wave must be a schema 2 completed status.`);
+  }
+  const failure = status["failure"];
+  if (failure !== void 0 && failure !== null && failure !== "") {
+    errors.push(`${prefix} shared wave must not contain a failure.`);
+  }
+  if (status["wave_id"] !== receipt["wave_id"]) {
+    errors.push(`${prefix}.wave_id must match the launch receipt.`);
+  }
+  const launches = status["launches"];
+  const launchId = receipt["launch_id"];
+  const entry = isRecord2(launches) && typeof launchId === "string" ? launches[launchId] : void 0;
+  if (!isRecord2(entry)) {
+    const launchLabel = typeof launchId === "string" ? `'${launchId}'` : "<invalid>";
+    return [...errors, `${prefix} must contain launch_id ${launchLabel}.`];
+  }
+  if (entry["state"] !== "completed" || entry["exit_code"] !== 0) {
+    errors.push(`${prefix} launch must be completed with exit_code 0.`);
+  }
+  const entryReceipt = launchPath(
+    entry["receipt_path"],
+    context,
+    `${prefix} launch.receipt_path`
+  );
+  errors.push(...entryReceipt.errors);
+  if (entryReceipt.relative !== void 0 && entryReceipt.relative !== receiptPath) {
+    errors.push(
+      `${prefix} launch.receipt_path must match the feature receipt.`
+    );
+  }
+  if (entry["codex_session_id"] !== receipt["codex_session_id"]) {
+    errors.push(`${prefix} launch.codex_session_id must match the receipt.`);
+  }
+  if (entry["completed_at"] !== receipt["completed_at"]) {
+    errors.push(`${prefix} launch.completed_at must match the receipt.`);
+  }
+  if (statusPath.slice(0, statusPath.lastIndexOf("/")) !== receiptPath.slice(0, receiptPath.lastIndexOf("/"))) {
+    errors.push(`${prefix} path must share the receipt wave directory.`);
+  }
+  const resolved = launchPath(feature["launch_status_path"], context, "status");
+  if (resolved.relative !== statusPath) {
+    errors.push(`${prefix} path must match the shared status file.`);
+  }
+  return errors;
+}
+function validateEpicPlannerLaunchEvidence(state, context) {
+  const features = state["features"];
+  if (!Array.isArray(features)) {
+    return [];
+  }
+  const errors = [];
+  let statusPath;
+  let status;
+  features.forEach((item, index) => {
+    if (!isRecord2(item)) {
+      return;
+    }
+    const receipt = validateReceipt3(item, index, context);
+    errors.push(...receipt.errors);
+    const featureStatus = launchPath(
+      item["launch_status_path"],
+      context,
+      `Epic planner checkpoint features[${index}] launch status path`
+    );
+    errors.push(...featureStatus.errors);
+    if (featureStatus.relative !== void 0 && statusPath !== void 0 && featureStatus.relative !== statusPath) {
+      errors.push(
+        "Epic planner preparation features must share one launch_status_path."
+      );
+    }
+    if (featureStatus.relative !== void 0 && statusPath === void 0) {
+      statusPath = featureStatus.relative;
+      const result = readJson(
+        statusPath,
+        context,
+        "the shared preparation launch status"
+      );
+      errors.push(...result.errors);
+      status = result.value;
+    }
+    if (receipt.receipt !== void 0 && receipt.path !== void 0 && status !== void 0 && statusPath !== void 0) {
+      errors.push(
+        ...validateStatus(
+          item,
+          index,
+          receipt.receipt,
+          receipt.path,
+          status,
+          statusPath,
+          context
+        )
+      );
+    }
+  });
+  return errors;
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/epic-planner-readiness-integrity.ts
+var ALL_CLEAR = "PREFLIGHT: ALL CLEAR";
+var SLUG_RE = /^[a-z0-9][a-z0-9-]*$/;
+function join9(root, relative2) {
+  return `${toPosixPath2(root).replace(/\/+$/, "")}/${relative2.replace(/^\/+/, "")}`;
+}
+function relativePath(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return {
+      errors: [`${field} must be a non-empty repository-relative path.`]
+    };
   }
-  const missing = [];
-  for (const key of keys) {
-    const item = value[key];
-    if (item === void 0 || typeof item === "string" && item.trim() === "") {
-      missing.push(key);
-    }
+  if (value.includes("\\")) {
+    return { errors: [`${field} must use forward slashes.`] };
   }
-  return missing;
+  const parts = value.split("/");
+  if (value.startsWith("/") || /^[A-Za-z]:/.test(value) || parts.includes("..") || parts.includes(".")) {
+    return { errors: [`${field} must stay within the workspace root.`] };
+  }
+  return { path: parts.join("/"), errors: [] };
 }
-function validateCompletionPrGate(state) {
-  const prGate = state["pr_gate"];
-  const missing = missingObjectKeys(prGate, PR_GATE_KEYS);
-  if (!isObject4(prGate)) {
-    return [
-      `Checkpoint completion validation failed: pr_gate must be an object with keys: ${PR_GATE_KEYS.join(", ")}.`
-    ];
+function readRequired(context, relative2, label) {
+  const path11 = join9(context.workspaceRoot, relative2);
+  if (!context.fileSystem.isFile(path11)) {
+    return { errors: [`Execution readiness requires ${label}: ${relative2}`] };
+  }
+  try {
+    return { text: context.fileSystem.readTextFile(path11), errors: [] };
+  } catch (error2) {
+    return {
+      errors: [
+        `Execution readiness could not read ${label} ${relative2}: ${String(error2)}`
+      ]
+    };
   }
+}
+function validateArtifactSource(stateText, context) {
+  const expected = "artifacts/orchestration/epic-planner-state.json";
+  const root = toPosixPath2(context.workspaceRoot).replace(/\/+$/, "");
+  const artifact = toPosixPath2(context.artifactPath);
+  if (!artifact.startsWith(`${root}/`)) {
+    return ["Epic planner artifact path must stay within the workspace root."];
+  }
+  const supplied = artifact.slice(root.length + 1);
   const errors = [];
-  if (missing.length > 0) {
+  if (supplied !== expected) {
     errors.push(
-      `Checkpoint completion validation failed: pr_gate missing required fields: ${missing.join(", ")}.`
+      `Execution-ready epic planner artifact path must be '${expected}'.`
     );
   }
-  if (state["issue-num"] === ISSUE_232) {
-    if (prGate["head_branch"] !== ISSUE_232_BRANCH) {
-      errors.push(
-        `Checkpoint completion validation failed: pr_gate.head_branch must be ${ISSUE_232_BRANCH} for Issue #232.`
-      );
-    }
+  const source = readRequired(context, supplied, "the epic planner checkpoint");
+  errors.push(...source.errors);
+  if (source.text !== void 0 && source.text !== stateText) {
+    errors.push(
+      "Supplied epic planner text does not match artifact_path bytes."
+    );
   }
   return errors;
 }
-function validateCompletionCiGate(state) {
-  const ciGate = state["ci_gate"];
-  const missing = missingObjectKeys(ciGate, CI_GATE_KEYS);
-  if (!isObject4(ciGate)) {
-    return [
-      `Checkpoint completion validation failed: ci_gate must be an object with keys: ${CI_GATE_KEYS.join(", ")}.`
-    ];
+function validateFeatureFiles(feature, index, context) {
+  const prefix = `Epic planner checkpoint features[${index}]`;
+  const folderResult = relativePath(
+    feature["feature_folder"],
+    `${prefix}.feature_folder`
+  );
+  const planResult = relativePath(feature["plan_path"], `${prefix}.plan_path`);
+  const researchResult = relativePath(
+    feature["research_path"],
+    `${prefix}.research_path`
+  );
+  const errors = [
+    ...folderResult.errors,
+    ...planResult.errors,
+    ...researchResult.errors
+  ];
+  const folder = folderResult.path;
+  const plan = planResult.path;
+  const researchPath = researchResult.path;
+  if (folder === void 0 || plan === void 0 || researchPath === void 0) {
+    return { ...plan === void 0 ? {} : { plan }, errors };
+  }
+  if (!folder.startsWith("docs/features/active/") && !folder.startsWith("docs/features/completed/")) {
+    errors.push(
+      `${prefix}.feature_folder must be under docs/features/active or completed.`
+    );
+  }
+  const folderPath = join9(context.workspaceRoot, folder);
+  if (!context.fileSystem.isDirectory(folderPath)) {
+    errors.push(`Execution readiness requires feature folder: ${folder}`);
+    return { plan, errors };
+  }
+  if (!plan.startsWith(`${folder}/`)) {
+    errors.push(`${prefix}.plan_path must be inside its feature_folder.`);
+  }
+  for (const name of ["issue.md", "spec.md", "user-story.md"]) {
+    errors.push(
+      ...readRequired(context, `${folder}/${name}`, `${prefix} ${name}`).errors
+    );
+  }
+  errors.push(...readRequired(context, plan, `${prefix} atomic plan`).errors);
+  if (!researchPath.startsWith("artifacts/research/") && !researchPath.startsWith(`${folder}/`)) {
+    errors.push(
+      `${prefix}.research_path must be under artifacts/research or its feature_folder.`
+    );
+  }
+  errors.push(
+    ...readRequired(context, researchPath, `${prefix} research evidence`).errors
+  );
+  const evidenceValue = feature["preflight_evidence_path"];
+  const evidencePaths = [];
+  if (evidenceValue !== void 0) {
+    const evidence = relativePath(
+      evidenceValue,
+      `${prefix}.preflight_evidence_path`
+    );
+    errors.push(...evidence.errors);
+    if (evidence.path !== void 0) {
+      if (!evidence.path.startsWith(`${folder}/`)) {
+        errors.push(
+          `${prefix}.preflight_evidence_path must be inside its feature_folder.`
+        );
+      }
+      evidencePaths.push(join9(context.workspaceRoot, evidence.path));
+    }
+  } else {
+    evidencePaths.push(
+      ...context.fileSystem.glob(folderPath, "**/*preflight*.md")
+    );
+  }
+  let allClear = false;
+  for (const path11 of evidencePaths) {
+    if (!context.fileSystem.isFile(path11)) {
+      continue;
+    }
+    try {
+      allClear = context.fileSystem.readTextFile(path11).includes(ALL_CLEAR);
+    } catch {
+      continue;
+    }
+    if (allClear) {
+      break;
+    }
+  }
+  if (!allClear) {
+    errors.push(
+      `Execution readiness requires preflight evidence containing '${ALL_CLEAR}' under ${folder}.`
+    );
   }
+  return { plan, errors };
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateKickoffAgainstState(parsed, state, label) {
   const errors = [];
-  if (missing.length > 0) {
+  const slug = state["epic_feature_folder"];
+  if (parsed.slug !== slug || parsed.invocationSlug !== slug) {
     errors.push(
-      `Checkpoint completion validation failed: ci_gate missing required fields: ${missing.join(", ")}.`
+      `${label} kickoff slug and /epic-run slug must match state '${String(slug)}'.`
     );
   }
-  if (ciGate["conclusion"] !== "success") {
+  if (parsed.manifestPath !== state["epic_manifest_path"]) {
     errors.push(
-      "Checkpoint completion validation failed: ci_gate.conclusion must be success."
+      `${label} kickoff manifest reference must match epic_manifest_path.`
     );
   }
-  const prGate = state["pr_gate"];
-  const prHeadSha = isObject4(prGate) ? prGate["head_sha"] : null;
-  if (prHeadSha !== null && prHeadSha !== void 0 && ciGate["head_sha"] !== prHeadSha) {
+  if (parsed.integrationBranch !== state["integration_branch"]) {
     errors.push(
-      "Checkpoint completion validation failed: ci_gate.head_sha must match pr_gate.head_sha."
+      `${label} kickoff integration branch must match planner state.`
+    );
+  }
+  const expected = Array.isArray(state["features"]) ? state["features"].filter(isRecord3).map((feature) => [
+    feature["issue_num"],
+    feature["feature_folder"],
+    feature["wave"],
+    feature["complexity_band"],
+    feature["plan_path"]
+  ]) : [];
+  const actual = parsed.features.map((feature) => [
+    feature.issueNum,
+    feature.featureFolder,
+    feature.wave,
+    feature.complexity,
+    feature.planPath
+  ]);
+  if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+    errors.push(
+      `${label} kickoff feature table must exactly match planner state order and values.`
     );
   }
   return errors;
 }
-function validateIssue232PromotionReceipts(state) {
-  if (state["issue-num"] !== ISSUE_232) {
-    return [];
+function validateEpicReadinessIntegrity(state, stateText, context) {
+  const errors = validateArtifactSource(stateText, context);
+  const slug = state["epic_feature_folder"];
+  if (typeof slug !== "string" || !SLUG_RE.test(slug)) {
+    return [
+      ...errors,
+      "Epic planner checkpoint epic_feature_folder must be a slug."
+    ];
   }
-  const receipts = state["delegation_receipts"];
-  let promotionSource = "promotion_receipts";
-  let promotion = state["promotion_receipts"];
-  if (isObject4(receipts)) {
-    const namespacedPromotion = receipts[PROMOTION_RECEIPT_NAMESPACE_KEY];
-    if (namespacedPromotion !== void 0 && namespacedPromotion !== null) {
-      promotionSource = "delegation_receipts.promotion";
-      promotion = namespacedPromotion;
+  const manifestPath = `docs/features/epics/${slug}/epic.md`;
+  if (state["epic_manifest_path"] !== manifestPath) {
+    errors.push(
+      `Execution-ready epic_manifest_path must be '${manifestPath}'.`
+    );
+  }
+  const branch = `epic/${slug}-integration`;
+  if (state["integration_branch"] !== branch) {
+    errors.push(`Execution-ready integration_branch must be '${branch}'.`);
+  }
+  const manifest = readRequired(context, manifestPath, "the epic manifest");
+  errors.push(...manifest.errors);
+  const ignoredResult = relativePath(
+    state["kickoff_prompt_path"],
+    "Epic planner checkpoint kickoff_prompt_path"
+  );
+  errors.push(...ignoredResult.errors);
+  const durablePath = `docs/features/epics/${slug}/epic-kickoff.md`;
+  const durable = readRequired(
+    context,
+    durablePath,
+    "the committed epic kickoff"
+  );
+  errors.push(...durable.errors);
+  const ignored = ignoredResult.path === void 0 ? { errors: [] } : readRequired(context, ignoredResult.path, "the ignored epic kickoff");
+  errors.push(...ignored.errors);
+  let parsed;
+  if (durable.text !== void 0) {
+    const result = parseEpicKickoff(durable.text);
+    errors.push(...result.errors);
+    parsed = result.parsed;
+    if (parsed !== void 0) {
+      errors.push(...validateKickoffAgainstState(parsed, state, "Committed"));
+    }
+  }
+  if (ignored.text !== void 0) {
+    const result = parseEpicKickoff(ignored.text);
+    errors.push(...result.errors);
+    if (result.parsed !== void 0) {
+      errors.push(
+        ...validateKickoffAgainstState(result.parsed, state, "Ignored")
+      );
+    }
+    if (durable.text !== void 0 && ignored.text !== durable.text) {
+      errors.push("Committed and ignored epic kickoff bytes must match.");
     }
   }
-  const missing = missingObjectKeys(promotion, PROMOTION_RECEIPT_KEYS);
-  if (missing.length > 0) {
-    return [
-      `Checkpoint completion validation failed: ${promotionSource} missing required Issue #232 receipt keys: ${missing.join(", ")}.`
-    ];
+  const plans = [];
+  if (Array.isArray(state["features"])) {
+    state["features"].forEach((feature, index) => {
+      if (!isRecord3(feature)) {
+        return;
+      }
+      const result = validateFeatureFiles(feature, index, context);
+      errors.push(...result.errors);
+      if (result.plan !== void 0) {
+        plans.push(result.plan);
+      }
+    });
   }
-  return [];
+  errors.push(...validateEpicPlannerLaunchEvidence(state, context));
+  if (parsed !== void 0) {
+    errors.push(
+      ...validatePlanningGitIntegrity(state, parsed, plans, context.git),
+      ...validateCommittedFile(
+        context.git,
+        String(state["integration_branch"]),
+        durablePath,
+        "durable kickoff"
+      )
+    );
+    if (manifest.text !== void 0) {
+      errors.push(
+        ...validateCommittedFile(
+          context.git,
+          String(state["integration_branch"]),
+          manifestPath,
+          "epic manifest"
+        )
+      );
+    }
+  }
+  return errors;
 }
 
-// ../../extensions/drm-copilot/src/lib/validate/orchestrator-state-human-interaction.ts
-var HUMAN_INTERACTION_KEY = "human_interaction";
-var HUMAN_INTERACTION_REQUIREMENTS_KEY = "requirements";
-var HUMAN_INTERACTION_RESPONSE_ENUM = /* @__PURE__ */ new Set([
-  "scope_change",
-  "exception",
-  "halt"
-]);
-var HUMAN_INTERACTION_EXCEPTION_RESPONSE = "exception";
-function isObject5(value) {
+// ../../extensions/drm-copilot/src/lib/validate/epic-planner-state-core.ts
+var REQUIRED_KEYS3 = [
+  "objective",
+  "epic_feature_folder",
+  "epic_manifest_path",
+  "integration_branch",
+  "max_parallel_features",
+  "epic_worthiness",
+  "features",
+  "kickoff_prompt_path",
+  "completed_steps",
+  "next_step",
+  "last_updated"
+];
+var REQUIRED_FEATURE_KEYS = [
+  "issue_num",
+  "feature_folder",
+  "depends_on",
+  "wave",
+  "complexity_band",
+  "preparation_status",
+  "research_path",
+  "plan_path",
+  "preflight_status"
+];
+var COMPLEXITY_BANDS = /* @__PURE__ */ new Set(["C1", "C2", "C3", "C4"]);
+var COMPLEXITY_BAND_REPR = "('C1', 'C2', 'C3', 'C4')";
+var READY_NEXT_STEP = "EPIC_EXECUTION_READY";
+var NON_EPIC_NEXT_STEP = "NON_EPIC_RECOMMENDED";
+function isObject7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function pythonRepr2(value) {
-  if (value === null || value === void 0) {
+function pythonRepr6(value) {
+  if (value === void 0 || value === null) {
     return "None";
   }
-  if (value === true) {
-    return "True";
+  if (typeof value === "string") {
+    return `'${value.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
   }
-  if (value === false) {
-    return "False";
+  if (typeof value === "boolean") {
+    return value ? "True" : "False";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(pythonRepr6).join(", ")}]`;
   }
   return String(value);
 }
-function validateHumanInteraction(humanInteraction) {
-  const errors = [];
-  if (!isObject5(humanInteraction)) {
-    errors.push("Checkpoint human_interaction must be an object when present.");
+function validateExpectedTopologyFields(value, prefix, expected) {
+  const errors = validateCodexTopologyReceipt(value, prefix);
+  if (!isObject7(value)) {
     return errors;
   }
-  const requirements = humanInteraction[HUMAN_INTERACTION_REQUIREMENTS_KEY];
-  if (!Array.isArray(requirements)) {
-    errors.push("Checkpoint human_interaction.requirements must be a list.");
-    return errors;
+  for (const [key, expectedValue] of Object.entries(expected)) {
+    if (value[key] !== expectedValue) {
+      const expectedRepresentation = expectedValue === null ? "None" : `'${String(expectedValue)}'`;
+      errors.push(`${prefix}.${key} must be ${expectedRepresentation}.`);
+    }
   }
-  requirements.forEach((requirement, index) => {
-    if (!isObject5(requirement)) {
+  return errors;
+}
+function validatePlannerTopologyReceipt(value) {
+  return validateExpectedTopologyFields(
+    value,
+    "Epic planner topology_receipt",
+    {
+      execution_context: "standalone",
+      root_persona: "epic-planner",
+      route: "epic",
+      topology: "epic_persona",
+      logical_agent: "epic-planner"
+    }
+  );
+}
+function validateChildTopologyReceipt(value, prefix) {
+  return validateExpectedTopologyFields(value, prefix, {
+    execution_context: "epic_preparation_child",
+    root_persona: null,
+    route: "large",
+    topology: "orchestrator",
+    logical_agent: "orchestrator"
+  });
+}
+function validateWorthiness(value) {
+  if (!isObject7(value)) {
+    return {
+      errors: ["Epic planner checkpoint epic_worthiness must be an object."],
+      verdict: null
+    };
+  }
+  const errors = [];
+  const verdict = value["verdict"];
+  if (verdict !== "epic" && verdict !== "non_epic") {
+    errors.push(
+      "Epic planner checkpoint epic_worthiness.verdict must be 'epic' or 'non_epic'."
+    );
+  }
+  const rationale = value["rationale"];
+  if (typeof rationale !== "string" || !rationale.trim()) {
+    errors.push(
+      "Epic planner checkpoint epic_worthiness.rationale must be non-empty."
+    );
+  }
+  return {
+    errors,
+    verdict: typeof verdict === "string" ? verdict : null
+  };
+}
+function extractFeatures2(value) {
+  if (!Array.isArray(value)) {
+    return {
+      errors: ["Epic planner checkpoint features must be a list."],
+      features: []
+    };
+  }
+  const errors = [];
+  const features = [];
+  value.forEach((item, index) => {
+    const prefix = `Epic planner checkpoint features[${index}]`;
+    if (!isObject7(item)) {
+      errors.push(`${prefix} must be an object.`);
+      return;
+    }
+    features.push(item);
+    const missing = REQUIRED_FEATURE_KEYS.filter((key) => !(key in item));
+    if (missing.length > 0) {
+      errors.push(`${prefix} missing required keys: ${missing.join(", ")}.`);
+      return;
+    }
+    if (!Array.isArray(item["depends_on"])) {
+      errors.push(`${prefix}.depends_on must be a list.`);
+    }
+    const wave = item["wave"];
+    if (typeof wave !== "number" || !Number.isInteger(wave) || wave < 0) {
+      errors.push(`${prefix}.wave must be a non-negative integer.`);
+    }
+    const complexityBand = item["complexity_band"];
+    if (typeof complexityBand !== "string" || !COMPLEXITY_BANDS.has(complexityBand)) {
       errors.push(
-        `Checkpoint human_interaction.requirements #${index} must be an object.`
+        `${prefix}.complexity_band must be one of ${COMPLEXITY_BAND_REPR}.`
       );
+    }
+  });
+  return { errors, features };
+}
+function validateDependencyWaves(features) {
+  const errors = [];
+  const seenFolders = /* @__PURE__ */ new Set();
+  const seenIssues = /* @__PURE__ */ new Set();
+  features.forEach((feature, index2) => {
+    const prefix = `Epic planner checkpoint features[${index2}]`;
+    const folder = feature["feature_folder"];
+    if (typeof folder === "string" && folder.length > 0) {
+      if (seenFolders.has(folder)) {
+        errors.push(
+          `${prefix}.feature_folder must be unique: ${pythonRepr6(folder)}.`
+        );
+      }
+      seenFolders.add(folder);
+    }
+    const issueNum = feature["issue_num"];
+    if (issueNum !== void 0 && issueNum !== null) {
+      if (seenIssues.has(issueNum)) {
+        errors.push(
+          `${prefix}.issue_num must be unique: ${pythonRepr6(issueNum)}.`
+        );
+      }
+      seenIssues.add(issueNum);
+    }
+  });
+  const index = buildFeatureReferenceIndex(features);
+  const manifest = /* @__PURE__ */ new Map();
+  features.forEach((feature, featureIndex) => {
+    const folder = feature["feature_folder"];
+    const dependencies = feature["depends_on"];
+    if (typeof folder !== "string" || folder.length === 0 || !Array.isArray(dependencies)) {
       return;
     }
-    const response = requirement["response"];
-    if (typeof response !== "string" || !HUMAN_INTERACTION_RESPONSE_ENUM.has(response)) {
+    const resolvedEdges = [];
+    for (const dependency of dependencies) {
+      const resolved = resolveFeatureReference(dependency, index);
+      if (resolved === null) {
+        errors.push(
+          `Epic planner checkpoint features[${featureIndex}].depends_on contains unresolved reference: ${pythonRepr6(dependency)}.`
+        );
+      } else {
+        resolvedEdges.push(resolved);
+      }
+    }
+    manifest.set(folder, resolvedEdges);
+  });
+  let expectedWaves;
+  try {
+    expectedWaves = computeWaveNumbers(manifest);
+  } catch (error2) {
+    if (error2 instanceof EpicWaveCycleError) {
+      errors.push(error2.message);
+      return errors;
+    }
+    throw error2;
+  }
+  features.forEach((feature, index2) => {
+    const folder = feature["feature_folder"];
+    if (typeof folder !== "string" || !expectedWaves.has(folder)) {
+      return;
+    }
+    const expected = expectedWaves.get(folder);
+    if (feature["wave"] !== expected) {
       errors.push(
-        `Checkpoint human_interaction.requirements #${index} response must be one of scope_change, exception, halt; got: ` + pythonRepr2(response)
+        `Epic planner checkpoint features[${index2}].wave must be ${expected} from the dependency graph, found ${pythonRepr6(feature["wave"])}.`
       );
-      return;
     }
-    if (response === HUMAN_INTERACTION_EXCEPTION_RESPONSE) {
-      const runbookPath = requirement["runbook_path"];
-      if (typeof runbookPath !== "string" || runbookPath.trim() === "") {
+  });
+  return errors;
+}
+function validateReadyFeatures(features) {
+  const errors = [];
+  if (features.length < 2) {
+    errors.push(
+      "Execution-ready epic planning requires at least two features."
+    );
+  }
+  features.forEach((feature, index) => {
+    const prefix = `Epic planner checkpoint features[${index}]`;
+    const issueNum = feature["issue_num"];
+    if (typeof issueNum !== "number" || !Number.isInteger(issueNum) || issueNum <= 0) {
+      errors.push(`${prefix}.issue_num must be a positive integer.`);
+    }
+    for (const key of [
+      "feature_folder",
+      "research_path",
+      "plan_path"
+    ]) {
+      const value = feature[key];
+      if (typeof value !== "string" || !value.trim()) {
+        errors.push(`${prefix}.${key} must be a non-empty string.`);
+      }
+    }
+    if (feature["preparation_status"] !== "prepared") {
+      errors.push(`${prefix}.preparation_status must be 'prepared'.`);
+    }
+    if (feature["preflight_status"] !== "PREFLIGHT: ALL CLEAR") {
+      errors.push(`${prefix}.preflight_status must be 'PREFLIGHT: ALL CLEAR'.`);
+    }
+    const receipt = feature["model_routing_receipt"];
+    errors.push(
+      ...validateCodexModelRoutingReceipt(
+        receipt,
+        `${prefix}.model_routing_receipt`
+      )
+    );
+    if (isObject7(receipt) && receipt["logical_agent"] !== "orchestrator") {
+      errors.push(
+        `${prefix}.model_routing_receipt.logical_agent must be 'orchestrator'.`
+      );
+    }
+    if (isObject7(receipt)) {
+      if (receipt["complexity_band"] !== feature["complexity_band"]) {
         errors.push(
-          `Checkpoint human_interaction.requirements #${index} response is exception but runbook_path is missing or empty.`
+          `${prefix}.model_routing_receipt.complexity_band must match feature complexity_band ${pythonRepr6(feature["complexity_band"])}.`
+        );
+      }
+      if (receipt["execution_context"] !== "epic_preparation_child") {
+        errors.push(
+          `${prefix}.model_routing_receipt.execution_context must be 'epic_preparation_child'.`
         );
       }
     }
+    errors.push(
+      ...validateChildTopologyReceipt(
+        feature["topology_receipt"],
+        `${prefix}.topology_receipt`
+      )
+    );
   });
   return errors;
 }
-
-// ../../extensions/drm-copilot/src/lib/validate/orchestrator-state-remediation.ts
-var REMEDIATION_LOOP_KEY = "remediation_loop";
-var REMEDIATION_CYCLES_KEY = "cycles";
-var EXECUTION_STATUSES_REQUIRING_CLEAR_PREFLIGHT = /* @__PURE__ */ new Set(["in_progress", "complete", "failed"]);
-var PREFLIGHT_CLEARED_STATUS = "clear";
-function isObject6(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function validateRemediationCycle(index, cycle) {
-  const errors = [];
-  const planPath = cycle["plan_path"];
-  if (typeof planPath !== "string" || planPath.trim() === "") {
+function validateEpicPlannerStateText(text, options = {}) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch (error2) {
+    return [
+      `Epic planner checkpoint is not valid JSON: ${error2 instanceof Error ? error2.message : String(error2)}`
+    ];
+  }
+  if (!isObject7(value)) {
+    return ["Epic planner checkpoint root must be a JSON object."];
+  }
+  const errors = REQUIRED_KEYS3.filter((key) => !(key in value)).map(
+    (key) => `Epic planner checkpoint missing required key: ${key}`
+  );
+  const worthiness = validateWorthiness(value["epic_worthiness"]);
+  errors.push(...worthiness.errors);
+  const featureResult = extractFeatures2(value["features"]);
+  errors.push(...featureResult.errors);
+  errors.push(...validateDependencyWaves(featureResult.features));
+  const maxParallel = value["max_parallel_features"];
+  if (typeof maxParallel !== "number" || !Number.isInteger(maxParallel) || maxParallel < 1 || maxParallel > 8) {
     errors.push(
-      `Checkpoint remediation cycle #${index} plan_path must be a non-empty string.`
+      "Epic planner checkpoint max_parallel_features must be an integer from 1 through 8."
     );
   }
-  const executionStatus = cycle["execution_status"];
-  if (typeof executionStatus === "string" && EXECUTION_STATUSES_REQUIRING_CLEAR_PREFLIGHT.has(executionStatus)) {
-    const preflight = cycle["preflight"];
-    const preflightStatus = isObject6(preflight) ? preflight["final_status"] : void 0;
-    if (preflightStatus !== PREFLIGHT_CLEARED_STATUS) {
+  if (worthiness.verdict === "non_epic" && value["next_step"] !== NON_EPIC_NEXT_STEP) {
+    errors.push(
+      `Non-epic planner checkpoint next_step must be '${NON_EPIC_NEXT_STEP}'.`
+    );
+  }
+  if (options.requireReadyForExecution === true) {
+    if (worthiness.verdict !== "epic") {
       errors.push(
-        `Checkpoint remediation cycle #${index} execution_status is ${executionStatus} but preflight.final_status is not 'clear'.`
+        "Execution readiness requires epic_worthiness.verdict 'epic'."
       );
     }
-  }
-  if (cycle["exit_condition_met"] === true && cycle["blocking_count"] !== 0) {
+    if (value["next_step"] !== READY_NEXT_STEP) {
+      errors.push(
+        `Execution-ready planner checkpoint next_step must be '${READY_NEXT_STEP}'.`
+      );
+    }
+    errors.push(...validateReadyFeatures(featureResult.features));
     errors.push(
-      `Checkpoint remediation cycle #${index} exit_condition_met is true but blocking_count is not 0.`
+      ...validateEpicPlannerChildLaunchBindings(featureResult.features)
     );
-  }
-  return errors;
-}
-function validateRemediationLoop(remediationLoop) {
-  const errors = [];
-  if (!isObject6(remediationLoop)) {
-    return errors;
-  }
-  const cycles = remediationLoop[REMEDIATION_CYCLES_KEY];
-  if (!Array.isArray(cycles)) {
-    return errors;
-  }
-  cycles.forEach((cycle, index) => {
-    if (!isObject6(cycle)) {
-      errors.push(`Checkpoint remediation cycle #${index} must be an object.`);
-      return;
+    errors.push(...validatePlannerTopologyReceipt(value["topology_receipt"]));
+    const expectedKickoff = `artifacts/orchestration/epic-kickoff-${String(
+      value["epic_feature_folder"]
+    )}.md`;
+    if (value["kickoff_prompt_path"] !== expectedKickoff) {
+      errors.push(
+        `Execution-ready planner checkpoint kickoff_prompt_path must be '${expectedKickoff}'.`
+      );
     }
-    errors.push(...validateRemediationCycle(index, cycle));
-  });
+    if (options.readinessContext === void 0) {
+      errors.push(
+        "Execution-ready planner validation requires repository context."
+      );
+    } else {
+      errors.push(
+        ...validateEpicReadinessIntegrity(
+          value,
+          text,
+          options.readinessContext
+        )
+      );
+    }
+  }
   return errors;
 }
 
 // ../../extensions/drm-copilot/src/lib/validate/orchestrator-state-routing.ts
 var ROUTING_MATRIX_RELATIVE_PATH = "config/orchestration-routing.json";
-function isObject7(value) {
+var MANDATORY_ROUTE_PHASES = {
+  small: ["S3_promotion", "S4_atomic_planning"],
+  preparation: ["S3_promotion", "S4_atomic_planning"]
+};
+function isObject8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function selectedRouteId(state) {
+  const value = state["route_id"] !== void 0 ? state["route_id"] : state["path_selected"];
+  return typeof value === "string" && value.trim() !== "" ? value : null;
+}
+function routeRequiresPrGate(state, options = {}) {
+  const routeId = selectedRouteId(state);
+  const matrix = options.routingMatrix;
+  if (routeId === null || !isObject8(matrix) || !isObject8(matrix["routes"])) {
+    return false;
+  }
+  const route = matrix["routes"][routeId];
+  return isObject8(route) && route["requires_pr_gate"] === true;
+}
+function routeRequiresCiGate(state, options = {}) {
+  const routeId = selectedRouteId(state);
+  const matrix = options.routingMatrix;
+  if (routeId === null || !isObject8(matrix) || !isObject8(matrix["routes"])) {
+    return true;
+  }
+  const route = matrix["routes"][routeId];
+  return !isObject8(route) || route["requires_ci_gate"] !== false;
+}
+function validatePhaseCompleteness(state) {
+  const routeId = selectedRouteId(state);
+  if (routeId === null) {
+    return [];
+  }
+  const mandatory = MANDATORY_ROUTE_PHASES[routeId];
+  if (mandatory === void 0) {
+    return [];
+  }
+  const completed = new Set(stringList(state["completed_steps"]) ?? []);
+  return mandatory.filter((phase) => !completed.has(phase)).map(
+    (phase) => `Checkpoint completion validation failed: route ${routeId} is missing mandatory phase ${phase}.`
+  );
+}
 function loadRoutingMatrix(fs9, root) {
   const path11 = `${toPosixPath2(root).replace(/\/+$/, "")}/${ROUTING_MATRIX_RELATIVE_PATH}`;
   return JSON.parse(fs9.readTextFile(path11));
@@ -22489,7 +24896,7 @@ function listReceipts(receipts) {
   if (!Array.isArray(receipts)) {
     return [];
   }
-  return receipts.filter(isObject7);
+  return receipts.filter(isObject8);
 }
 function receiptAgents(state) {
   const agents = /* @__PURE__ */ new Set();
@@ -22508,7 +24915,7 @@ function receiptSkills(state) {
     return skills;
   }
   for (const receipt of receipts) {
-    if (!isObject7(receipt)) {
+    if (!isObject8(receipt)) {
       continue;
     }
     const skill = receipt["skill"];
@@ -22527,7 +24934,7 @@ function mcpTools(state) {
     return tools;
   }
   for (const receipt of receipts) {
-    if (!isObject7(receipt)) {
+    if (!isObject8(receipt)) {
       continue;
     }
     const tool = receipt["tool"];
@@ -22539,101 +24946,402 @@ function mcpTools(state) {
   }
   return tools;
 }
-function validateEmptyListField(state, key) {
-  const value = state[key];
-  if (!Array.isArray(value)) {
-    return [`Checkpoint ${key} must be an empty list at completion.`];
+function validateEmptyListField(state, key) {
+  const value = state[key];
+  if (!Array.isArray(value)) {
+    return [`Checkpoint ${key} must be an empty list at completion.`];
+  }
+  if (value.length > 0) {
+    return [`Checkpoint ${key} must be empty at completion.`];
+  }
+  return [];
+}
+function validateLifecycleOperations(state) {
+  const operations = state["lifecycle_operations"];
+  if (operations === void 0 || operations === null) {
+    return [];
+  }
+  if (!Array.isArray(operations)) {
+    return ["Checkpoint lifecycle_operations must be a list when present."];
+  }
+  const errors = [];
+  operations.forEach((operation, index) => {
+    if (!isObject8(operation)) {
+      errors.push(
+        `Checkpoint lifecycle_operations #${index} must be an object.`
+      );
+      return;
+    }
+    if (operation["surface"] !== "mcp") {
+      errors.push(
+        `Checkpoint lifecycle_operations #${index} did not use MCP surface.`
+      );
+    }
+  });
+  return errors;
+}
+function validateRoutingContract(state, options = {}) {
+  const matrix = options.routingMatrix;
+  if (!isObject8(matrix)) {
+    return ["Routing matrix missing routes object."];
+  }
+  const rawRoutes = matrix["routes"];
+  if (!isObject8(rawRoutes)) {
+    return ["Routing matrix missing routes object."];
+  }
+  const routeId = selectedRouteId(state);
+  if (routeId === null) {
+    return ["Checkpoint route_id or path_selected must select a route."];
+  }
+  const rawRoute = rawRoutes[routeId];
+  if (!isObject8(rawRoute)) {
+    return [
+      `Checkpoint selected route has no routing-matrix entry: ${routeId}.`
+    ];
+  }
+  const errors = [];
+  const requiredAgents = routeList(rawRoute, "required_agents");
+  const requiredSkills = routeList(rawRoute, "required_skills");
+  const requiredMcpTools = routeList(rawRoute, "required_mcp_tools");
+  if (stateList(state, "required_agents", requiredAgents) === null) {
+    errors.push(
+      `Checkpoint required_agents must match routing matrix for route ${routeId}.`
+    );
+  }
+  if (stateList(state, "required_skills", requiredSkills) === null) {
+    errors.push(
+      `Checkpoint required_skills must match routing matrix for route ${routeId}.`
+    );
+  }
+  if (stateList(state, "required_mcp_tools", requiredMcpTools) === null) {
+    errors.push(
+      `Checkpoint required_mcp_tools must match routing matrix for route ${routeId}.`
+    );
+  }
+  const actualAgents = receiptAgents(state);
+  for (const agent of requiredAgents) {
+    if (!actualAgents.has(agent)) {
+      errors.push(`Checkpoint missing required agent receipt: ${agent}.`);
+    }
+  }
+  const actualSkills = receiptSkills(state);
+  for (const skill of requiredSkills) {
+    if (!actualSkills.has(skill)) {
+      errors.push(`Checkpoint missing required skill receipt: ${skill}.`);
+    }
+  }
+  const actualTools = mcpTools(state);
+  for (const tool of requiredMcpTools) {
+    if (!actualTools.has(tool)) {
+      errors.push(`Checkpoint missing successful MCP receipt: ${tool}.`);
+    }
+  }
+  errors.push(...validateEmptyListField(state, "local_execution_overrides"));
+  errors.push(...validateEmptyListField(state, "delegation_bypasses"));
+  errors.push(...validateLifecycleOperations(state));
+  return errors;
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/orchestrator-state-completion.ts
+var PR_GATE_KEYS = [
+  "pr_number",
+  "pr_url",
+  "head_branch",
+  "head_sha"
+];
+var CI_GATE_KEYS = ["conclusion", "head_sha", "verified_at"];
+var PROMOTION_RECEIPT_NAMESPACE_KEY = "promotion";
+var PROMOTION_RECEIPT_KEYS = [
+  "potential_entry",
+  "issue",
+  "feature_folder"
+];
+function isObject9(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function missingObjectKeys(value, keys) {
+  if (!isObject9(value)) {
+    return [...keys];
+  }
+  const missing = [];
+  for (const key of keys) {
+    const item = value[key];
+    if (item === void 0 || typeof item === "string" && item.trim() === "") {
+      missing.push(key);
+    }
+  }
+  return missing;
+}
+function validateCompletionPrGate(state, options = {}) {
+  if (!routeRequiresPrGate(state, options)) {
+    return [];
+  }
+  const prGate = state["pr_gate"];
+  const missing = missingObjectKeys(prGate, PR_GATE_KEYS);
+  if (!isObject9(prGate)) {
+    return [
+      `Checkpoint completion validation failed: pr_gate must be an object with keys: ${PR_GATE_KEYS.join(", ")}.`
+    ];
+  }
+  const errors = [];
+  if (missing.length > 0) {
+    errors.push(
+      `Checkpoint completion validation failed: pr_gate missing required fields: ${missing.join(", ")}.`
+    );
+  }
+  return errors;
+}
+function validateCompletionCiGate(state) {
+  const ciGate = state["ci_gate"];
+  const missing = missingObjectKeys(ciGate, CI_GATE_KEYS);
+  if (!isObject9(ciGate)) {
+    return [
+      `Checkpoint completion validation failed: ci_gate must be an object with keys: ${CI_GATE_KEYS.join(", ")}.`
+    ];
+  }
+  const errors = [];
+  if (missing.length > 0) {
+    errors.push(
+      `Checkpoint completion validation failed: ci_gate missing required fields: ${missing.join(", ")}.`
+    );
+  }
+  if (ciGate["conclusion"] !== "success") {
+    errors.push(
+      "Checkpoint completion validation failed: ci_gate.conclusion must be success."
+    );
+  }
+  const prGate = state["pr_gate"];
+  const prHeadSha = isObject9(prGate) ? prGate["head_sha"] : null;
+  if (prHeadSha !== null && prHeadSha !== void 0 && ciGate["head_sha"] !== prHeadSha) {
+    errors.push(
+      "Checkpoint completion validation failed: ci_gate.head_sha must match pr_gate.head_sha."
+    );
+  }
+  return errors;
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/orchestrator-state-human-interaction.ts
+var HUMAN_INTERACTION_KEY = "human_interaction";
+var HUMAN_INTERACTION_REQUIREMENTS_KEY = "requirements";
+var HUMAN_INTERACTION_RESPONSE_ENUM = /* @__PURE__ */ new Set([
+  "scope_change",
+  "exception",
+  "halt"
+]);
+var HUMAN_INTERACTION_EXCEPTION_RESPONSE = "exception";
+function isObject10(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pythonRepr7(value) {
+  if (value === null || value === void 0) {
+    return "None";
   }
-  if (value.length > 0) {
-    return [`Checkpoint ${key} must be empty at completion.`];
+  if (value === true) {
+    return "True";
   }
-  return [];
+  if (value === false) {
+    return "False";
+  }
+  return String(value);
 }
-function validateLifecycleOperations(state) {
-  const operations = state["lifecycle_operations"];
-  if (operations === void 0 || operations === null) {
-    return [];
+function validateHumanInteraction(humanInteraction) {
+  const errors = [];
+  if (!isObject10(humanInteraction)) {
+    errors.push("Checkpoint human_interaction must be an object when present.");
+    return errors;
   }
-  if (!Array.isArray(operations)) {
-    return ["Checkpoint lifecycle_operations must be a list when present."];
+  const requirements = humanInteraction[HUMAN_INTERACTION_REQUIREMENTS_KEY];
+  if (!Array.isArray(requirements)) {
+    errors.push("Checkpoint human_interaction.requirements must be a list.");
+    return errors;
   }
-  const errors = [];
-  operations.forEach((operation, index) => {
-    if (!isObject7(operation)) {
+  requirements.forEach((requirement, index) => {
+    if (!isObject10(requirement)) {
       errors.push(
-        `Checkpoint lifecycle_operations #${index} must be an object.`
+        `Checkpoint human_interaction.requirements #${index} must be an object.`
       );
       return;
     }
-    if (operation["surface"] !== "mcp") {
+    const response = requirement["response"];
+    if (typeof response !== "string" || !HUMAN_INTERACTION_RESPONSE_ENUM.has(response)) {
       errors.push(
-        `Checkpoint lifecycle_operations #${index} did not use MCP surface.`
+        `Checkpoint human_interaction.requirements #${index} response must be one of scope_change, exception, halt; got: ` + pythonRepr7(response)
       );
+      return;
+    }
+    if (response === HUMAN_INTERACTION_EXCEPTION_RESPONSE) {
+      const runbookPath = requirement["runbook_path"];
+      if (typeof runbookPath !== "string" || runbookPath.trim() === "") {
+        errors.push(
+          `Checkpoint human_interaction.requirements #${index} response is exception but runbook_path is missing or empty.`
+        );
+      }
     }
   });
   return errors;
 }
-function validateRoutingContract(state, options = {}) {
-  const matrix = options.routingMatrix;
-  if (!isObject7(matrix)) {
-    return ["Routing matrix missing routes object."];
-  }
-  const rawRoutes = matrix["routes"];
-  if (!isObject7(rawRoutes)) {
-    return ["Routing matrix missing routes object."];
-  }
-  const routeIdValue = state["route_id"] !== void 0 ? state["route_id"] : state["path_selected"];
-  if (typeof routeIdValue !== "string" || routeIdValue.trim() === "") {
-    return ["Checkpoint route_id or path_selected must select a route."];
-  }
-  const routeId = routeIdValue;
-  const rawRoute = rawRoutes[routeId];
-  if (!isObject7(rawRoute)) {
-    return [
-      `Checkpoint selected route has no routing-matrix entry: ${routeId}.`
-    ];
-  }
+
+// ../../extensions/drm-copilot/src/lib/validate/orchestrator-state-remediation.ts
+var REMEDIATION_LOOP_KEY = "remediation_loop";
+var REMEDIATION_CYCLES_KEY = "cycles";
+var EXECUTION_STATUSES_REQUIRING_CLEAR_PREFLIGHT = /* @__PURE__ */ new Set(["in_progress", "complete", "failed"]);
+var PREFLIGHT_CLEARED_STATUS = "clear";
+function isObject11(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateRemediationCycle(index, cycle) {
   const errors = [];
-  const requiredAgents = routeList(rawRoute, "required_agents");
-  const requiredSkills = routeList(rawRoute, "required_skills");
-  const requiredMcpTools = routeList(rawRoute, "required_mcp_tools");
-  if (stateList(state, "required_agents", requiredAgents) === null) {
+  const planPath = cycle["plan_path"];
+  if (typeof planPath !== "string" || planPath.trim() === "") {
     errors.push(
-      `Checkpoint required_agents must match routing matrix for route ${routeId}.`
+      `Checkpoint remediation cycle #${index} plan_path must be a non-empty string.`
     );
   }
-  if (stateList(state, "required_skills", requiredSkills) === null) {
+  const executionStatus = cycle["execution_status"];
+  if (typeof executionStatus === "string" && EXECUTION_STATUSES_REQUIRING_CLEAR_PREFLIGHT.has(executionStatus)) {
+    const preflight = cycle["preflight"];
+    const preflightStatus = isObject11(preflight) ? preflight["final_status"] : void 0;
+    if (preflightStatus !== PREFLIGHT_CLEARED_STATUS) {
+      errors.push(
+        `Checkpoint remediation cycle #${index} execution_status is ${executionStatus} but preflight.final_status is not 'clear'.`
+      );
+    }
+  }
+  if (cycle["exit_condition_met"] === true && cycle["blocking_count"] !== 0) {
     errors.push(
-      `Checkpoint required_skills must match routing matrix for route ${routeId}.`
+      `Checkpoint remediation cycle #${index} exit_condition_met is true but blocking_count is not 0.`
     );
   }
-  if (stateList(state, "required_mcp_tools", requiredMcpTools) === null) {
+  return errors;
+}
+function validateRemediationLoop(remediationLoop) {
+  const errors = [];
+  if (!isObject11(remediationLoop)) {
+    return errors;
+  }
+  const cycles = remediationLoop[REMEDIATION_CYCLES_KEY];
+  if (!Array.isArray(cycles)) {
+    return errors;
+  }
+  cycles.forEach((cycle, index) => {
+    if (!isObject11(cycle)) {
+      errors.push(`Checkpoint remediation cycle #${index} must be an object.`);
+      return;
+    }
+    errors.push(...validateRemediationCycle(index, cycle));
+  });
+  return errors;
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/orchestrator-state-preparation-terminal.ts
+var EXPECTED_NEXT_STEP = "S5_atomic_execution";
+var OUT_OF_SCOPE_STEP_KEYS = [
+  "step5_status",
+  "step6_status",
+  "step7_status",
+  "step8_status",
+  "step9_status",
+  "step10_status"
+];
+function pythonRepr8(value) {
+  if (value === void 0 || value === null) {
+    return "None";
+  }
+  if (typeof value === "string") {
+    const escaped = value.replaceAll("\\", "\\\\").replaceAll("'", "\\'").replaceAll("\n", "\\n").replaceAll("\r", "\\r").replaceAll("	", "\\t");
+    return `'${escaped}'`;
+  }
+  if (typeof value === "boolean") {
+    return value ? "True" : "False";
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(pythonRepr8).join(", ")}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).map(
+      ([key, item]) => `${pythonRepr8(key)}: ${pythonRepr8(item)}`
+    );
+    return `{${entries.join(", ")}}`;
+  }
+  return String(value);
+}
+function validatePreparationTerminalContract(state) {
+  const routeId = state["route_id"] !== void 0 ? state["route_id"] : state["path_selected"];
+  if (routeId !== "preparation") {
+    return [];
+  }
+  const errors = [];
+  if (state["next_step"] !== EXPECTED_NEXT_STEP) {
     errors.push(
-      `Checkpoint required_mcp_tools must match routing matrix for route ${routeId}.`
+      `Preparation checkpoint next_step must be ${pythonRepr8(EXPECTED_NEXT_STEP)}, found ${pythonRepr8(state["next_step"])}.`
     );
   }
-  const actualAgents = receiptAgents(state);
-  for (const agent of requiredAgents) {
-    if (!actualAgents.has(agent)) {
-      errors.push(`Checkpoint missing required agent receipt: ${agent}.`);
+  for (const key of OUT_OF_SCOPE_STEP_KEYS) {
+    if (state[key] !== "not-applicable") {
+      errors.push(
+        `Preparation checkpoint ${key} must be 'not-applicable', found ${pythonRepr8(state[key])}.`
+      );
     }
   }
-  const actualSkills = receiptSkills(state);
-  for (const skill of requiredSkills) {
-    if (!actualSkills.has(skill)) {
-      errors.push(`Checkpoint missing required skill receipt: ${skill}.`);
+  return errors;
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/orchestrator-state-model-routing-existence.ts
+var DELEGATING_AGENTS = /* @__PURE__ */ new Set([
+  "atomic-planner",
+  "atomic-executor",
+  "feature-review",
+  "task-researcher",
+  "prd-feature",
+  "pr-author"
+]);
+function isObject12(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function delegatedAgents(state) {
+  const agents = /* @__PURE__ */ new Set();
+  const receipts = state["delegation_receipts"];
+  if (Array.isArray(receipts)) {
+    for (const receipt of receipts) {
+      if (!isObject12(receipt)) {
+        continue;
+      }
+      const agentName = receipt["agent_name"];
+      if (typeof agentName === "string" && agentName.trim().length > 0) {
+        agents.add(agentName);
+      }
     }
   }
-  const actualTools = mcpTools(state);
-  for (const tool of requiredMcpTools) {
-    if (!actualTools.has(tool)) {
-      errors.push(`Checkpoint missing successful MCP receipt: ${tool}.`);
+  const nextStep = state["next_step"];
+  if (typeof nextStep === "string" && DELEGATING_AGENTS.has(nextStep)) {
+    agents.add(nextStep);
+  }
+  return agents;
+}
+function validateModelRoutingExistence(state) {
+  const delegated = delegatedAgents(state);
+  if (delegated.size === 0) {
+    return [];
+  }
+  const receiptAgents2 = /* @__PURE__ */ new Set();
+  const receipts = state["model_routing_receipts"];
+  if (Array.isArray(receipts)) {
+    for (const receipt of receipts) {
+      if (!isObject12(receipt)) {
+        continue;
+      }
+      const agent = receipt["agent"];
+      if (typeof agent === "string" && agent.trim().length > 0) {
+        receiptAgents2.add(agent);
+      }
     }
   }
-  errors.push(...validateEmptyListField(state, "local_execution_overrides"));
-  errors.push(...validateEmptyListField(state, "delegation_bypasses"));
-  errors.push(...validateLifecycleOperations(state));
-  return errors;
+  return [...delegated].filter((agent) => !receiptAgents2.has(agent)).sort().map(
+    (agent) => `Checkpoint model_routing_receipts is missing a receipt for delegated agent: ${agent}.`
+  );
 }
 
 // ../../extensions/drm-copilot/src/lib/validate/orchestrator-state-core.ts
@@ -22698,21 +25406,13 @@ var STEP_STATUS_KEYS = [
   "step9_status",
   "step10_status"
 ];
-var DELEGATING_AGENTS = /* @__PURE__ */ new Set([
-  "atomic-planner",
-  "atomic-executor",
-  "feature-review",
-  "task-researcher",
-  "prd-feature",
-  "pr-author"
-]);
-function isObject8(value) {
+function isObject13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function validateListDelegationReceipts(receipts) {
   const errors = [];
   receipts.forEach((receipt, index) => {
-    if (!isObject8(receipt)) {
+    if (!isObject13(receipt)) {
       errors.push(`Checkpoint delegation receipt #${index} must be an object.`);
       return;
     }
@@ -22744,7 +25444,7 @@ function validateNamespacedDelegationReceipts(receipts) {
   if (promotionReceipts === void 0 || promotionReceipts === null) {
     return errors;
   }
-  if (!isObject8(promotionReceipts)) {
+  if (!isObject13(promotionReceipts)) {
     errors.push(
       "Checkpoint delegation_receipts.promotion must be an object namespace."
     );
@@ -22769,53 +25469,6 @@ function resolveRoutingMatrix(options) {
   }
   return void 0;
 }
-function delegatedAgents(stateMap) {
-  const agents = /* @__PURE__ */ new Set();
-  const receipts = stateMap["delegation_receipts"];
-  if (Array.isArray(receipts)) {
-    receipts.forEach((receipt) => {
-      if (!isObject8(receipt)) {
-        return;
-      }
-      const agentName = receipt["agent_name"];
-      if (typeof agentName === "string" && agentName.trim() !== "") {
-        agents.add(agentName);
-      }
-    });
-  }
-  const nextStep = stateMap["next_step"];
-  if (typeof nextStep === "string" && DELEGATING_AGENTS.has(nextStep)) {
-    agents.add(nextStep);
-  }
-  return agents;
-}
-function validateModelRoutingExistence(stateMap) {
-  const errors = [];
-  const delegated = delegatedAgents(stateMap);
-  if (delegated.size === 0) {
-    return errors;
-  }
-  const receiptAgents2 = /* @__PURE__ */ new Set();
-  const receipts = stateMap["model_routing_receipts"];
-  if (Array.isArray(receipts)) {
-    receipts.forEach((receipt) => {
-      if (!isObject8(receipt)) {
-        return;
-      }
-      const agent = receipt["agent"];
-      if (typeof agent === "string" && agent.trim() !== "") {
-        receiptAgents2.add(agent);
-      }
-    });
-  }
-  const missing = [...delegated].filter((a) => !receiptAgents2.has(a)).sort();
-  for (const agent of missing) {
-    errors.push(
-      `Checkpoint model_routing_receipts is missing a receipt for delegated agent: ${agent}.`
-    );
-  }
-  return errors;
-}
 function validateOrchestratorStateText(text, options = {}) {
   const errors = [];
   let state;
@@ -22826,7 +25479,7 @@ function validateOrchestratorStateText(text, options = {}) {
       `Checkpoint is not valid JSON: ${exc instanceof Error ? exc.message : String(exc)}`
     ];
   }
-  if (!isObject8(state)) {
+  if (!isObject13(state)) {
     return ["Checkpoint root must be a JSON object."];
   }
   const stateMap = state;
@@ -22851,7 +25504,7 @@ function validateOrchestratorStateText(text, options = {}) {
   if (receipts !== void 0 && receipts !== null) {
     if (Array.isArray(receipts)) {
       errors.push(...validateListDelegationReceipts(receipts));
-    } else if (isObject8(receipts)) {
+    } else if (isObject13(receipts)) {
       errors.push(...validateNamespacedDelegationReceipts(receipts));
     } else {
       errors.push(
@@ -22880,18 +25533,34 @@ function validateOrchestratorStateText(text, options = {}) {
         "Checkpoint completion validation failed: blocked_reason is not `none`."
       );
     }
-    errors.push(...validateCompletionPrGate(stateMap));
-    errors.push(...validateCompletionCiGate(stateMap));
-    errors.push(...validateIssue232PromotionReceipts(stateMap));
+    const routingMatrix = resolveRoutingMatrix(options);
+    errors.push(...validateCompletionPrGate(stateMap, { routingMatrix }));
+    if (routeRequiresCiGate(stateMap, { routingMatrix })) {
+      errors.push(...validateCompletionCiGate(stateMap));
+    }
+    errors.push(...validatePhaseCompleteness(stateMap));
+    errors.push(...validatePreparationTerminalContract(stateMap));
     errors.push(
       ...validateRoutingContract(stateMap, {
-        routingMatrix: resolveRoutingMatrix(options)
+        routingMatrix
       })
     );
   }
   if (options.requireModelRouting === true) {
     errors.push(...validateModelRoutingExistence(stateMap));
   }
+  errors.push(
+    ...validateCodexModelRoutingState(
+      stateMap,
+      options.requireCodexModelRouting === true
+    )
+  );
+  errors.push(
+    ...validateCodexTopologyState(
+      stateMap,
+      options.requireCodexTopology === true
+    )
+  );
   return errors;
 }
 
@@ -23267,6 +25936,8 @@ function validateArtifact(input) {
       const options = {
         ...input.requireComplete === void 0 ? {} : { requireComplete: input.requireComplete },
         ...input.requireModelRouting === void 0 ? {} : { requireModelRouting: input.requireModelRouting },
+        ...input.requireCodexModelRouting === void 0 ? {} : { requireCodexModelRouting: input.requireCodexModelRouting },
+        ...input.requireCodexTopology === void 0 ? {} : { requireCodexTopology: input.requireCodexTopology },
         ...input.fs === void 0 ? {} : { fs: input.fs },
         ...input.root === void 0 ? {} : { root: input.root },
         ...input.routingMatrix === void 0 ? {} : { routingMatrix: input.routingMatrix }
@@ -23275,10 +25946,28 @@ function validateArtifact(input) {
     }
     case "epic-orchestrator-state": {
       const options = {
-        ...input.requireComplete === void 0 ? {} : { requireComplete: input.requireComplete }
+        ...input.requireComplete === void 0 ? {} : { requireComplete: input.requireComplete },
+        ...input.requireCodexModelRouting === void 0 ? {} : { requireCodexModelRouting: input.requireCodexModelRouting },
+        ...input.requireCodexTopology === void 0 ? {} : { requireCodexTopology: input.requireCodexTopology }
       };
       return validateEpicOrchestratorStateText(input.text, options);
     }
+    case "epic-planner-state": {
+      const options = {
+        ...input.requireReadyForExecution === void 0 ? {} : { requireReadyForExecution: input.requireReadyForExecution },
+        ...input.fs === void 0 || input.root === void 0 || input.artifactPath === void 0 || input.runner === void 0 ? {} : {
+          readinessContext: {
+            workspaceRoot: input.root,
+            artifactPath: input.artifactPath,
+            fileSystem: input.fs,
+            git: new CommandRunnerGitRepository(input.root, input.runner)
+          }
+        }
+      };
+      return validateEpicPlannerStateText(input.text, options);
+    }
+    case "epic-kickoff":
+      return validateEpicKickoffText(input.text);
     default:
       return [`Unsupported artifact type: ${input.artifactType}`];
   }
@@ -23295,6 +25984,11 @@ function validateOrchestrationServiceCall(input) {
     text,
     ...input.requireComplete === void 0 ? {} : { requireComplete: input.requireComplete },
     ...input.requireModelRouting === void 0 ? {} : { requireModelRouting: input.requireModelRouting },
+    ...input.requireCodexModelRouting === void 0 ? {} : { requireCodexModelRouting: input.requireCodexModelRouting },
+    ...input.requireCodexTopology === void 0 ? {} : { requireCodexTopology: input.requireCodexTopology },
+    ...input.requireReadyForExecution === void 0 ? {} : { requireReadyForExecution: input.requireReadyForExecution },
+    artifactPath: artifactFullPath,
+    ...input.runner === void 0 ? {} : { runner: input.runner },
     fs: input.fileSystem,
     root: input.workspaceRoot
   });
@@ -23312,14 +26006,18 @@ ${errors.join("\n")}`
 }
 
 // ../../extensions/drm-copilot/src/lib/validate/build-validate-orchestration-service-call-input.ts
-function buildValidateOrchestrationServiceCallInput(fileSystem, input) {
+function buildValidateOrchestrationServiceCallInput(fileSystem, input, runner) {
   return {
     fileSystem,
+    ...runner === void 0 ? {} : { runner },
     workspaceRoot: input.workspaceRoot,
     artifactType: input.artifactType,
     artifactPath: input.artifactPath,
     ...input.requireComplete === void 0 ? {} : { requireComplete: input.requireComplete },
-    ...input.requireModelRouting === void 0 ? {} : { requireModelRouting: input.requireModelRouting }
+    ...input.requireModelRouting === void 0 ? {} : { requireModelRouting: input.requireModelRouting },
+    ...input.requireCodexModelRouting === void 0 ? {} : { requireCodexModelRouting: input.requireCodexModelRouting },
+    ...input.requireCodexTopology === void 0 ? {} : { requireCodexTopology: input.requireCodexTopology },
+    ...input.requireReadyForExecution === void 0 ? {} : { requireReadyForExecution: input.requireReadyForExecution }
   };
 }
 
@@ -23744,7 +26442,7 @@ function extractStrings(raw, key) {
     return values;
   }
   for (const entry of raw) {
-    if (isRecord(entry)) {
+    if (isRecord4(entry)) {
       const value = entry[key];
       if (typeof value === "string") {
         values.push(value);
@@ -23759,7 +26457,7 @@ function extractClosingNumbers(raw) {
     return numbers;
   }
   for (const entry of raw) {
-    if (isRecord(entry)) {
+    if (isRecord4(entry)) {
       const num = entry["number"];
       if (typeof num === "number" && Number.isInteger(num)) {
         numbers.push(`#${num}`);
@@ -23782,7 +26480,7 @@ function compareCodePoint(left, right) {
 }
 function authorLogin(record2, key) {
   const raw = record2[key];
-  if (isRecord(raw)) {
+  if (isRecord4(raw)) {
     const login = raw["login"];
     if (typeof login === "string") {
       return login;
@@ -23800,7 +26498,7 @@ function issueDetailsImpl(client, numberRef) {
     [client.ghExecutable, "api", `repos/${repo}/issues/${numberRef}`],
     { context: "Fetch issue" }
   );
-  if (!isRecord(payload)) {
+  if (!isRecord4(payload)) {
     throw new Error("Unexpected issue payload format.");
   }
   const title = stringField(payload, "title");
@@ -23848,7 +26546,7 @@ function fetchIssueComments(client, commentsUrl) {
     return comments;
   }
   for (const entry of commentPayload) {
-    if (!isRecord(entry)) {
+    if (!isRecord4(entry)) {
       continue;
     }
     const login = authorLogin(entry, "user");
@@ -23872,7 +26570,7 @@ function prDetailsImpl(client, numberRef) {
     [client.ghExecutable, "pr", "view", numberRef, "--json", PR_DETAILS_FIELDS],
     { context: "Fetch pull request" }
   );
-  if (!isRecord(payload)) {
+  if (!isRecord4(payload)) {
     throw new Error("Unexpected pull request payload format.");
   }
   const title = stringField(payload, "title");
@@ -23917,7 +26615,7 @@ function closingIssuesImpl(client, prNumber) {
     args.splice(3, 0, prNumber);
   }
   const payload = client.requestJson(args, { context: "Fetch closing issues" });
-  if (!isRecord(payload)) {
+  if (!isRecord4(payload)) {
     return [];
   }
   return sortedSet(extractClosingNumbers(payload["closingIssuesReferences"]));
@@ -23932,7 +26630,7 @@ function currentPrImpl(client) {
     return null;
   }
   const payload = parseJsonOrNull(result.stdout);
-  if (!isRecord(payload)) {
+  if (!isRecord4(payload)) {
     return null;
   }
   const numberRaw = payload["number"];
@@ -24074,7 +26772,7 @@ var GhClient = class {
       return null;
     }
     const payload = parseJsonOrNull(result.stdout);
-    if (!isRecord(payload)) {
+    if (!isRecord4(payload)) {
       return null;
     }
     const nameRaw = payload["nameWithOwner"];
@@ -24147,7 +26845,7 @@ var GhClient = class {
     if (payload === null) {
       return null;
     }
-    if (isRecord(payload) && "pull_request" in payload) {
+    if (isRecord4(payload) && "pull_request" in payload) {
       return "pull";
     }
     return "issue";
@@ -24178,7 +26876,7 @@ var GhClient = class {
     } catch {
       return null;
     }
-    if (!isRecord(payload)) {
+    if (!isRecord4(payload)) {
       return null;
     }
     const contentRaw = payload["content"];
@@ -24215,7 +26913,7 @@ var GhClient = class {
       return [null, []];
     }
     const first = payload[0];
-    if (!isRecord(first)) {
+    if (!isRecord4(first)) {
       return [null, []];
     }
     const statusRaw = first["status"] || first["conclusion"];
@@ -24258,7 +26956,7 @@ function parseJsonOrNull(text) {
     return null;
   }
 }
-function isRecord(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -24936,9 +27634,9 @@ function parseVerificationEvidenceMarkdown(params) {
   };
 }
 function parseVerificationEvidenceFile(params) {
-  const { fs: fs9, root, feature, relativePath } = params;
+  const { fs: fs9, root, feature, relativePath: relativePath2 } = params;
   const normalizedRoot = toPosixPath2(root).replace(/\/+$/u, "");
-  const relPosix = toPosixPath2(relativePath).replace(/^\/+/u, "");
+  const relPosix = toPosixPath2(relativePath2).replace(/^\/+/u, "");
   const markdown = fs9.readTextFile(`${normalizedRoot}/${relPosix}`);
   return parseVerificationEvidenceMarkdown({
     feature,
@@ -24991,7 +27689,7 @@ var SPEC_HEADINGS = [
   "Behavior",
   "Overview"
 ];
-function extractFeatures2(changedFiles) {
+function extractFeatures3(changedFiles) {
   const features = /* @__PURE__ */ new Set();
   for (const raw of changedFiles) {
     const parts = toPosixPath2(raw).split("/");
@@ -25003,7 +27701,7 @@ function extractFeatures2(changedFiles) {
 }
 function gatherFeatureExcerpts2(fs9, root, changedFiles) {
   const normalizedRoot = toPosixPath2(root).replace(/\/+$/u, "");
-  const features = extractFeatures2(changedFiles);
+  const features = extractFeatures3(changedFiles);
   const excerpts = [];
   const baseDir = `${normalizedRoot}/docs/features/active`;
   const promotedDir = `${normalizedRoot}/docs/features/potential/promoted`;
@@ -26258,7 +28956,7 @@ function getSection(content, heading) {
   }
   return match[1].trim();
 }
-function buildBody(workMode, problem, behavior, criteria, constraints, tests, relativePath) {
+function buildBody(workMode, problem, behavior, criteria, constraints, tests, relativePath2) {
   return `- Work Mode: ${workMode}
 ## Problem / Why
 ${problem}
@@ -26276,20 +28974,20 @@ ${constraints}
 ${tests}
 
 ## Source
-From: ${relativePath}
+From: ${relativePath2}
 `;
 }
-function buildBugBody(workMode, sections, relativePath) {
+function buildBugBody(workMode, sections, relativePath2) {
   const parts = [`- Work Mode: ${workMode}`];
   for (const heading of BUG_SECTION_HEADINGS) {
     parts.push(`## ${heading}
 ${sections[heading] ?? ""}`);
   }
   parts.push(`## Source
-From: ${relativePath}`);
+From: ${relativePath2}`);
   return parts.join("\n\n") + "\n";
 }
-function buildMinorAuditBody(workMode, problem, implementationIntent, acceptanceCriteria, dependenciesRisks, verificationSteps, evidenceChecklist, relativePath) {
+function buildMinorAuditBody(workMode, problem, implementationIntent, acceptanceCriteria, dependenciesRisks, verificationSteps, evidenceChecklist, relativePath2) {
   return `- Work Mode: ${workMode}
 ## Problem / Why
 ${problem}
@@ -26310,7 +29008,7 @@ ${verificationSteps}
 ${evidenceChecklist}
 
 ## Source
-From: ${relativePath}
+From: ${relativePath2}
 `;
 }
 function parseIssueReference(output) {
@@ -26475,7 +29173,7 @@ function posixBasename(pathStr) {
   const lastSlash = normalized.lastIndexOf("/");
   return lastSlash === -1 ? normalized : normalized.slice(lastSlash + 1);
 }
-function buildIssueBody(content, selectedMode, promotionType, relativePath) {
+function buildIssueBody(content, selectedMode, promotionType, relativePath2) {
   if (selectedMode === "minor-audit") {
     const problem2 = getSection(content, "Problem / Why") || PLACEHOLDER;
     const implementationIntent = getSection(content, "Proposed Behavior") || PLACEHOLDER;
@@ -26494,7 +29192,7 @@ function buildIssueBody(content, selectedMode, promotionType, relativePath) {
       dependenciesRisks,
       verificationSteps,
       evidenceChecklist,
-      relativePath
+      relativePath2
     );
   }
   if (promotionType === "bug") {
@@ -26502,7 +29200,7 @@ function buildIssueBody(content, selectedMode, promotionType, relativePath) {
     for (const heading of BUG_SECTION_HEADINGS) {
       bugSections[heading] = getSection(content, heading) || PLACEHOLDER;
     }
-    return buildBugBody(selectedMode, bugSections, relativePath);
+    return buildBugBody(selectedMode, bugSections, relativePath2);
   }
   const problem = getSection(content, "Problem / Why") || PLACEHOLDER;
   const behavior = getSection(content, "Proposed Behavior") || PLACEHOLDER;
@@ -26516,7 +29214,7 @@ function buildIssueBody(content, selectedMode, promotionType, relativePath) {
     criteria,
     constraints,
     tests,
-    relativePath
+    relativePath2
   );
 }
 function promotePotential(options) {
@@ -26551,7 +29249,7 @@ function promotePotential(options) {
   const featurePath = getFeaturePath(featureName);
   const prefix = TITLE_PREFIXES[promotionType] ?? "Feature";
   const issueTitle = normalizeSmartPunctuation(`${prefix}: ${featureName}`);
-  const relativePath = computeRelativePath(resolved, workspacePath);
+  const relativePath2 = computeRelativePath(resolved, workspacePath);
   let selectedMode;
   try {
     selectedMode = normalizeRequestedWorkMode(workMode, promotionType);
@@ -26560,7 +29258,7 @@ function promotePotential(options) {
     throw new PromotionError(message);
   }
   const fallbackReason = "";
-  let body = buildIssueBody(content, selectedMode, promotionType, relativePath);
+  let body = buildIssueBody(content, selectedMode, promotionType, relativePath2);
   body = normalizeSmartPunctuation(body);
   const messages = [];
   const emitLine = (message) => {
@@ -27916,11 +30614,11 @@ function parseTranscriptLines(lines) {
       continue;
     }
     const parsed = tryParseJson(trimmed);
-    if (!isRecord2(parsed)) {
+    if (!isRecord5(parsed)) {
       continue;
     }
     const message = parsed["message"];
-    if (!isRecord2(message)) {
+    if (!isRecord5(message)) {
       continue;
     }
     recordModel(message["model"], models, seenModels);
@@ -27935,7 +30633,7 @@ function tryParseJson(text) {
     return void 0;
   }
 }
-function isRecord2(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function recordModel(model, models, seenModels) {
@@ -27949,7 +30647,7 @@ function collectAgentToolUseIds(content, agentToolUseIds) {
     return;
   }
   for (const block of content) {
-    if (!isRecord2(block)) {
+    if (!isRecord5(block)) {
       continue;
     }
     if (block["type"] === "tool_use" && block["name"] === "Agent" && typeof block["id"] === "string") {
@@ -28268,7 +30966,11 @@ var DefaultRepoAutomationService = class {
   }
   async validateOrchestrationArtifacts(input) {
     return validateOrchestrationServiceCall(
-      buildValidateOrchestrationServiceCallInput(this.fileSystem, input)
+      buildValidateOrchestrationServiceCallInput(
+        this.fileSystem,
+        input,
+        this.runner
+      )
     );
   }
   async renderSubagentTree(input) {