@danmoisan/drm-copilot-mcp 1.0.21 → 1.0.22

package/out/mcp-server.js

@@ -1796,13 +1796,13 @@ var require_code2 = __commonJS({
       const valid = gen.name("valid");
       if (it.allErrors) {
         const validArr = gen.let("valid", true);
-        validateItems(() => gen.assign(validArr, false));
+        validateItems2(() => gen.assign(validArr, false));
         return validArr;
       }
       gen.var(valid, true);
-      validateItems(() => gen.break());
+      validateItems2(() => gen.break());
       return valid;
-      function validateItems(notValid) {
+      function validateItems2(notValid) {
         const len = gen.const("len", (0, codegen_1._)`${data}.length`);
         gen.forRange("i", 0, len, (i) => {
           cxt.subschema({
@@ -5246,10 +5246,10 @@ var require_additionalItems = __commonJS({
         cxt.pass((0, codegen_1._)`${len} <= ${items.length}`);
       } else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
         const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items.length}`);
-        gen.if((0, codegen_1.not)(valid), () => validateItems(valid));
+        gen.if((0, codegen_1.not)(valid), () => validateItems2(valid));
         cxt.ok(valid);
       }
-      function validateItems(valid) {
+      function validateItems2(valid) {
         gen.forRange("i", items.length, len, (i) => {
           cxt.subschema({ keyword, dataProp: i, dataPropType: util_1.Type.Num }, valid);
           if (!it.allErrors)
@@ -5421,7 +5421,7 @@ var require_contains = __commonJS({
         it.items = true;
         const valid = gen.name("valid");
         if (max === void 0 && min === 1) {
-          validateItems(valid, () => gen.if(valid, () => gen.break()));
+          validateItems2(valid, () => gen.if(valid, () => gen.break()));
         } else if (min === 0) {
           gen.let(valid, true);
           if (max !== void 0)
@@ -5434,9 +5434,9 @@ var require_contains = __commonJS({
         function validateItemsWithCount() {
           const schValid = gen.name("_valid");
           const count = gen.let("count", 0);
-          validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)));
+          validateItems2(schValid, () => gen.if(schValid, () => checkLimits(count)));
         }
-        function validateItems(_valid, block) {
+        function validateItems2(_valid, block) {
           gen.forRange("i", 0, len, (i) => {
             cxt.subschema({
               keyword: "contains",
@@ -8990,13 +8990,13 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     }
     return propValues;
   });
-  const isObject14 = isObject;
+  const isObject15 = isObject;
   const catchall = def.catchall;
   let value;
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
     const input = payload.value;
-    if (!isObject14(input)) {
+    if (!isObject15(input)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
@@ -9123,7 +9123,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
     return (payload, ctx) => fn(shape, payload, ctx);
   };
   let fastpass;
-  const isObject14 = isObject;
+  const isObject15 = isObject;
   const jit = !globalConfig.jitless;
   const allowsEval2 = allowsEval;
   const fastEnabled = jit && allowsEval2.value;
@@ -9132,7 +9132,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
     const input = payload.value;
-    if (!isObject14(input)) {
+    if (!isObject15(input)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
@@ -15089,16 +15089,7 @@ var Server = class extends Protocol {
     if (!methodSchema) {
       throw new Error("Schema is missing a method literal");
     }
-    let methodValue;
-    if (isZ4Schema(methodSchema)) {
-      const v4Schema = methodSchema;
-      const v4Def = v4Schema._zod?.def;
-      methodValue = v4Def?.value ?? v4Schema.value;
-    } else {
-      const v3Schema = methodSchema;
-      const legacyDef = v3Schema._def;
-      methodValue = legacyDef?.value ?? v3Schema.value;
-    }
+    const methodValue = getLiteralValue(methodSchema);
     if (typeof methodValue !== "string") {
       throw new Error("Schema method literal must be a string");
     }
@@ -15407,8 +15398,17 @@ var Server = class extends Protocol {
 var import_node_process = __toESM(require("node:process"), 1);
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
+var STDIO_DEFAULT_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
 var ReadBuffer = class {
+  constructor(options) {
+    this._maxBufferSize = options?.maxBufferSize ?? STDIO_DEFAULT_MAX_BUFFER_SIZE;
+  }
   append(chunk) {
+    const newSize = (this._buffer?.length ?? 0) + chunk.length;
+    if (newSize > this._maxBufferSize) {
+      this.clear();
+      throw new Error(`ReadBuffer exceeded maximum size of ${this._maxBufferSize} bytes`);
+    }
     this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
   }
   readMessage() {
@@ -15436,18 +15436,24 @@ function serializeMessage(message) {
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 var StdioServerTransport = class {
-  constructor(_stdin = import_node_process.default.stdin, _stdout = import_node_process.default.stdout) {
+  constructor(_stdin = import_node_process.default.stdin, _stdout = import_node_process.default.stdout, options) {
     this._stdin = _stdin;
     this._stdout = _stdout;
-    this._readBuffer = new ReadBuffer();
     this._started = false;
     this._ondata = (chunk) => {
-      this._readBuffer.append(chunk);
-      this.processReadBuffer();
+      try {
+        this._readBuffer.append(chunk);
+        this.processReadBuffer();
+      } catch (error2) {
+        this.onerror?.(error2);
+        this.close().catch(() => {
+        });
+      }
     };
     this._onerror = (error2) => {
       this.onerror?.(error2);
     };
+    this._readBuffer = new ReadBuffer({ maxBufferSize: options?.maxBufferSize });
   }
   /**
    * Starts listening for messages on stdin.
@@ -16262,7 +16268,10 @@ var VALID_ARTIFACT_TYPES = /* @__PURE__ */ new Set([
   "orchestrator-state",
   "epic-orchestrator-state",
   "epic-planner-state",
-  "epic-kickoff"
+  "epic-kickoff",
+  "parallel-orchestrator-state",
+  "parallel-planner-state",
+  "parallel-kickoff"
 ]);
 function resolveValidateOrchestrationArtifactsToolInput(rawInput, fallbackWorkspaceRoot) {
   const args = asToolArgumentObject(rawInput);
@@ -17007,7 +17016,10 @@ var REPO_AUTOMATION_TOOL_DEFINITIONS = [
             "orchestrator-state",
             "epic-orchestrator-state",
             "epic-planner-state",
-            "epic-kickoff"
+            "epic-kickoff",
+            "parallel-orchestrator-state",
+            "parallel-planner-state",
+            "parallel-kickoff"
           ],
           description: "The type of orchestration artifact to validate."
         },
@@ -17017,7 +17029,7 @@ var REPO_AUTOMATION_TOOL_DEFINITIONS = [
         },
         require_complete: {
           type: "boolean",
-          description: "When true and artifact_type is 'orchestrator-state' or 'epic-orchestrator-state', require all phases to be complete."
+          description: "When true and artifact_type is 'orchestrator-state', 'epic-orchestrator-state', or 'parallel-orchestrator-state', require all phases to be complete."
         },
         require_model_routing: {
           type: "boolean",
@@ -17033,7 +17045,7 @@ var REPO_AUTOMATION_TOOL_DEFINITIONS = [
         },
         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."
+          description: "When true and artifact_type is 'epic-planner-state' or 'parallel-planner-state', require every child to be prepared and preflight-cleared."
         }
       },
       required: ["workspace_root", "artifact_type", "artifact_path"],
@@ -26088,191 +26100,1599 @@ function validateOrchestratorStateText(text, options = {}) {
   return errors;
 }
 
-// ../../extensions/drm-copilot/src/lib/validate/policy-audit-artifact.ts
-var COVERAGE_PERCENT_RE = /\b\d+(?:\.\d+)?%/;
-var POLICY_AUDIT_REQUIRED_HEADINGS = [
-  "## Executive Summary",
-  "## 1. General Unit Test Policy Compliance",
-  "## 2. General Code Change Policy Compliance",
-  "## 3. Language-Specific Code Change Policy Compliance",
-  "## 4. Language-Specific Unit Test Policy Compliance",
-  "## 5. Test Coverage Detail",
-  "## 6. Test Execution Metrics",
-  "## 7. Code Quality Checks",
-  "## 8. Gaps and Exceptions",
-  "## 9. Summary of Changes",
-  "## 10. Compliance Verdict",
-  "## Appendix A: Test Inventory",
-  "## Appendix B: Toolchain Commands Reference"
-];
-var POLICY_AUDIT_REQUIRED_CHECKLIST_LABELS = [
-  "TypeScript baseline coverage artifact:",
-  "TypeScript post-change coverage artifact:",
-  "PowerShell baseline coverage artifact:",
-  "PowerShell post-change coverage artifact:",
-  "Per-language comparison summary:"
-];
-var POLICY_AUDIT_COMPARISON_HEADING = "### 1.2.1 Per-Language Coverage Comparison";
-var PLACEHOLDER_MARKERS = [
-  "[n]",
-  "[path",
-  "[artifact",
-  "[section reference",
-  "[language]",
-  "tbd",
-  "unverified",
-  "missing"
-];
-var TEMPLATE_RESOLVER_TOOL = "resolve_policy_audit_template_asset";
-var TEMPLATE_RESOLVER_MISSING_MARKERS = [
-  "not exposed",
-  "was not exposed",
-  "missing resolver exposure",
-  "fallback template",
-  "fallback-template"
+// ../../extensions/drm-copilot/src/lib/validate/parallel-kickoff-artifact.ts
+var KICKOFF_HEADING_RE2 = /^# Parallel Kickoff: (?<slug>[a-z0-9][a-z0-9-]*)$/;
+var PARALLEL_RUN_RE = /Run `\/parallel-run (?<slug>[a-z0-9][a-z0-9-]*)`/;
+var MANIFEST_RE2 = /docs\/features\/parallel\/[a-z0-9][a-z0-9-]*\/parallel\.md/;
+var PLAN_BRANCH_RE = /parallel\/[a-z0-9][a-z0-9-]*-plan/;
+var RESUME_RE2 = /(?:Every item|Each item|items)\s+resumes?\s+at atomic execution\s+from\s+(?:its|their)\s+committed plan-path\s+on\s+(?:its|their)\s+own\s+(?:pushed\s+)?feature branch/i;
+var INTEGRITY_COMMIT_RE2 = /^(?:-\s*)?planning_commit:\s*`?(?<commit>[0-9a-fA-F]{7,64})`?\s*$/;
+var LINE_SPLIT_RE = /\r\n|\r|\n/u;
+var ITEM_HEADERS = [
+  "issue_num",
+  "feature_folder",
+  "cohort",
+  "complexity",
+  "branch",
+  "plan-path"
 ];
-function hasNumericCoverage(value) {
-  return COVERAGE_PERCENT_RE.test(value);
-}
-function isNaValue(value) {
-  return value.trim().toLowerCase().startsWith("n/a");
-}
-function hasPlaceholderMarker(value) {
-  const lowered = value.toLowerCase();
-  return PLACEHOLDER_MARKERS.some((marker) => lowered.includes(marker));
-}
-function reportsMissingTemplateResolverSuccess(text) {
-  const lowered = text.toLowerCase();
-  if (!lowered.includes(TEMPLATE_RESOLVER_TOOL)) {
-    return false;
-  }
-  if (!TEMPLATE_RESOLVER_MISSING_MARKERS.some((m) => lowered.includes(m))) {
-    return false;
-  }
-  return /\b(pass|ready|readiness)\b/.test(lowered);
-}
-function extractPolicyAuditCoverageRows(text) {
-  const rows = [];
-  for (const line of text.split("\n")) {
-    if (!line.startsWith("|")) {
-      continue;
-    }
-    const segments = line.split("|");
-    const cells = segments.slice(1, -1).map((cell) => cell.trim());
-    if (cells.length !== 7) {
-      continue;
-    }
-    const language = cells[0] ?? "";
-    if (language === "Language" || language === "----------" || !language) {
+var HASH_HEADERS2 = /* @__PURE__ */ new Set([
+  "plan-hash",
+  "plan_hash",
+  "git-blob-sha",
+  "git_blob_sha"
+]);
+var COMPLEXITY_BANDS2 = /* @__PURE__ */ new Set(["C1", "C2", "C3", "C4"]);
+function splitSections3(text) {
+  const sections = /* @__PURE__ */ new Map();
+  const errors = [];
+  let current;
+  for (const line of text.split(LINE_SPLIT_RE).slice(1)) {
+    if (line.startsWith("## ")) {
+      current = line.slice(3).trim();
+      if (sections.has(current)) {
+        errors.push(
+          `Parallel kickoff contains duplicate section: ## ${current}`
+        );
+      } else {
+        sections.set(current, []);
+      }
       continue;
     }
-    if (language.length > 0 && /^-+$/.test(language)) {
-      continue;
+    if (current !== void 0) {
+      sections.get(current)?.push(line);
     }
-    rows.push({
-      Language: language,
-      "Files Changed": cells[1] ?? "",
-      Tests: cells[2] ?? "",
-      "Test Result": cells[3] ?? "",
-      "Baseline Coverage": cells[4] ?? "",
-      "Post-Change Coverage": cells[5] ?? "",
-      "New Code Coverage": cells[6] ?? ""
-    });
   }
-  return rows;
-}
-function findPolicyAuditChecklistLine(text, label) {
-  for (const line of text.split("\n")) {
-    const stripped = line.trim();
-    if (stripped.startsWith("- ") && stripped.includes(label)) {
-      return stripped;
+  for (const required2 of ["Invocation Prompt", "Item Summary"]) {
+    if (!sections.has(required2)) {
+      errors.push(
+        `Parallel kickoff is missing required section: ## ${required2}`
+      );
     }
   }
-  return null;
+  return { sections, errors };
 }
-function extractPolicyAuditComparisonLines(text) {
-  let inSection = false;
-  const comparisonLines = /* @__PURE__ */ new Map();
-  for (const line of text.split("\n")) {
-    const stripped = line.trim();
-    if (stripped === POLICY_AUDIT_COMPARISON_HEADING) {
-      inSection = true;
-      continue;
-    }
-    if (inSection && stripped.startsWith("### ")) {
-      break;
-    }
-    if (!inSection || !stripped.startsWith("- ")) {
-      continue;
-    }
-    const body = stripped.slice(2);
-    const colonIndex = body.indexOf(":");
-    if (colonIndex === -1) {
-      continue;
-    }
-    const language = body.slice(0, colonIndex);
-    comparisonLines.set(language.trim().toLowerCase(), stripped);
+function parseCells2(line) {
+  const stripped = line.trim();
+  if (!stripped.startsWith("|") || !stripped.endsWith("|")) {
+    return void 0;
   }
-  return comparisonLines;
-}
-function escapeRegExp3(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return stripped.slice(1, -1).split("|").map((cell) => cell.trim().replace(/^`|`$/g, ""));
 }
-function comparisonLineHasLabelledPercentage(line, label) {
-  const pattern = new RegExp(`${escapeRegExp3(label)}.*?\\d+(?:\\.\\d+)?%`);
-  return pattern.test(line);
+function isSeparator2(cells) {
+  return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
 }
-function validatePolicyAuditSubstantiveRequirements(text) {
+function tableRows2(lines, expectedHeaders) {
+  const nonempty = lines.filter((line) => line.trim().length > 0);
+  if (nonempty.length < 2) {
+    return {
+      rows: [],
+      errors: [
+        "Parallel kickoff table is missing its header or separator row."
+      ]
+    };
+  }
+  const headers = parseCells2(nonempty[0] ?? "");
+  const separator = parseCells2(nonempty[1] ?? "");
   const errors = [];
-  for (const label of POLICY_AUDIT_REQUIRED_CHECKLIST_LABELS) {
-    const line = findPolicyAuditChecklistLine(text, label);
-    if (line === null) {
-      errors.push(`Policy audit missing required checklist line: ${label}`);
-      continue;
-    }
-    if (hasPlaceholderMarker(line)) {
-      errors.push(
-        `Policy audit checklist line still contains placeholder text: ${label}`
-      );
-    }
+  if (headers === void 0 || headers.length !== expectedHeaders.length || headers.some((value, index) => value !== expectedHeaders[index])) {
+    errors.push(
+      `Parallel kickoff item table headers must be: ${expectedHeaders.join(" | ")}`
+    );
   }
-  const coverageRows = extractPolicyAuditCoverageRows(text);
-  if (coverageRows.length === 0) {
-    errors.push("Policy audit missing coverage metrics table rows.");
+  if (separator === void 0 || separator.length !== expectedHeaders.length || !isSeparator2(separator)) {
+    errors.push("Parallel kickoff table separator row is invalid.");
   }
-  if (!text.includes(POLICY_AUDIT_COMPARISON_HEADING)) {
+  const rows = [];
+  for (const line of nonempty.slice(2)) {
+    const cells = parseCells2(line);
+    if (cells === void 0 || cells.length !== expectedHeaders.length) {
+      errors.push(`Parallel kickoff table row is invalid: ${line}`);
+    } else {
+      rows.push(cells);
+    }
+  }
+  if (rows.length === 0) {
     errors.push(
-      `Policy audit missing required heading: ${POLICY_AUDIT_COMPARISON_HEADING}`
+      "Parallel kickoff item table must contain at least one item row."
     );
   }
-  const comparisonLines = extractPolicyAuditComparisonLines(text);
-  for (const row of coverageRows) {
-    const language = row.Language;
-    const baseline = row["Baseline Coverage"];
-    const postChange = row["Post-Change Coverage"];
-    const newCode = row["New Code Coverage"];
-    const requiresCoverageComparison = [baseline, postChange, newCode].some(
-      (value) => !isNaValue(value)
-    );
-    if (!isNaValue(baseline) && !hasNumericCoverage(baseline)) {
-      errors.push(
-        `Policy audit missing numeric baseline coverage for ${language}.`
+  return { rows, errors };
+}
+function parseItems(lines) {
+  const table = tableRows2(lines, ITEM_HEADERS);
+  const items = [];
+  table.rows.forEach((row, index) => {
+    const issueNum = Number(row[0]);
+    if (!Number.isInteger(issueNum)) {
+      table.errors.push(
+        `Parallel kickoff item row ${String(index)} issue_num must be an integer.`
       );
+      return;
     }
-    if (!isNaValue(postChange) && !hasNumericCoverage(postChange)) {
-      errors.push(
-        `Policy audit missing numeric post-change coverage for ${language}.`
+    const cohort = Number(row[2]);
+    if (!Number.isInteger(cohort)) {
+      table.errors.push(
+        `Parallel kickoff item row ${String(index)} cohort must be an integer.`
       );
+      return;
     }
-    if (!isNaValue(newCode) && !hasNumericCoverage(newCode)) {
-      errors.push(
-        `Policy audit missing numeric new/changed-code coverage for ${language}.`
+    const complexity = row[3] ?? "";
+    if (!COMPLEXITY_BANDS2.has(complexity)) {
+      table.errors.push(
+        `Parallel kickoff item row ${String(index)} complexity must be C1-C4.`
       );
     }
-    if (!requiresCoverageComparison) {
+    items.push({
+      issueNum,
+      featureFolder: row[1] ?? "",
+      cohort,
+      complexity,
+      branch: row[4] ?? "",
+      planPath: row[5] ?? ""
+    });
+  });
+  return { items, errors: table.errors };
+}
+function parseIntegrityTable(tableLines) {
+  const planHashes = {};
+  const errors = [];
+  const header = parseCells2(tableLines[0] ?? "");
+  if (header === void 0 || header.length !== 2 || header[0] !== "plan-path" || !HASH_HEADERS2.has(header[1] ?? "")) {
+    errors.push(
+      "Parallel kickoff integrity table headers must be plan-path and plan-hash."
+    );
+  } else if (tableLines.length < 2) {
+    errors.push(
+      "Parallel kickoff integrity table is missing its separator row."
+    );
+  } else {
+    const separator = parseCells2(tableLines[1] ?? "");
+    if (separator === void 0 || separator.length !== 2 || !isSeparator2(separator)) {
+      errors.push("Parallel kickoff integrity table separator row is invalid.");
+    }
+    for (const line of tableLines.slice(2)) {
+      const cells = parseCells2(line);
+      if (cells === void 0 || cells.length !== 2 || !/^[0-9a-fA-F]{40,64}$/.test(cells[1] ?? "")) {
+        errors.push(`Parallel kickoff integrity table row is invalid: ${line}`);
+        continue;
+      }
+      const planPath = cells[0] ?? "";
+      if (planHashes[planPath] !== void 0) {
+        errors.push(
+          `Parallel kickoff integrity repeats plan path: '${planPath}'.`
+        );
+      }
+      planHashes[planPath] = (cells[1] ?? "").toLowerCase();
+    }
+  }
+  return { planHashes, errors };
+}
+function parseIntegrity2(lines) {
+  let planningCommit;
+  const errors = [];
+  const tableLines = [];
+  for (const line of lines) {
+    if (line.trim().length === 0) {
       continue;
     }
-    const comparisonLine = comparisonLines.get(language.toLowerCase());
+    const match = INTEGRITY_COMMIT_RE2.exec(line.trim());
+    if (match?.groups?.["commit"] !== void 0) {
+      if (planningCommit !== void 0) {
+        errors.push(
+          "Parallel kickoff integrity has duplicate planning_commit fields."
+        );
+      }
+      planningCommit = match.groups["commit"].toLowerCase();
+    } else if (line.trim().startsWith("|")) {
+      tableLines.push(line);
+    } else {
+      errors.push(`Parallel kickoff integrity line is invalid: ${line}`);
+    }
+  }
+  let planHashes = {};
+  if (tableLines.length > 0) {
+    const table = parseIntegrityTable(tableLines);
+    planHashes = table.planHashes;
+    errors.push(...table.errors);
+  }
+  return {
+    ...planningCommit === void 0 ? {} : { planningCommit },
+    planHashes,
+    errors
+  };
+}
+function parseParallelKickoff(text) {
+  const lines = text.split(LINE_SPLIT_RE);
+  if (text.length === 0) {
+    return { errors: ["Parallel kickoff is empty."] };
+  }
+  const heading = KICKOFF_HEADING_RE2.exec(lines[0] ?? "");
+  if (heading?.groups?.["slug"] === void 0) {
+    return {
+      errors: [
+        "Parallel kickoff first line must match '# Parallel Kickoff: <slug>'."
+      ]
+    };
+  }
+  const sectionResult = splitSections3(text);
+  const invocation = (sectionResult.sections.get("Invocation Prompt") ?? []).join("\n");
+  const invocationSlug = PARALLEL_RUN_RE.exec(invocation)?.groups?.["slug"];
+  const manifestMatch = MANIFEST_RE2.exec(invocation);
+  const branchMatch = PLAN_BRANCH_RE.exec(invocation);
+  const resumeMatch = RESUME_RE2.exec(invocation);
+  if (invocationSlug === void 0) {
+    sectionResult.errors.push(
+      "Parallel kickoff invocation must contain `Run /parallel-run <slug>`."
+    );
+  }
+  if (manifestMatch?.[0] === void 0 || branchMatch?.[0] === void 0 || resumeMatch === null) {
+    sectionResult.errors.push(
+      "Parallel kickoff invocation must structurally name the manifest, plan-home branch, and atomic-execution resume boundary."
+    );
+  }
+  const itemResult = parseItems(
+    sectionResult.sections.get("Item Summary") ?? []
+  );
+  sectionResult.errors.push(...itemResult.errors);
+  const integrity = parseIntegrity2(
+    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],
+      planHomeBranch: branchMatch[0],
+      items: itemResult.items,
+      ...integrity.planningCommit === void 0 ? {} : { planningCommit: integrity.planningCommit },
+      planHashes: integrity.planHashes
+    },
+    errors: []
+  };
+}
+function validateParallelKickoffText(text) {
+  return parseParallelKickoff(text).errors;
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/parallel-state-shared.ts
+function words(text) {
+  return text.split(" ");
+}
+var VALID_ITEM_STATES = words(
+  "proposed admitted prepared scheduled in_flight merged withdrawn blocked"
+);
+var VALID_MERGE_STATUS2 = words(
+  "not_started worktree_created pr_open ci_green merged worktree_removed blocked_drift blocked_ci_loop_limit"
+);
+var VALID_SOURCES = words("derived declared observed");
+var VALID_KINDS = words("feature bug");
+var VALID_MODES = words("closed open");
+var VALID_MUTATION_OPS = words("add remove close requeue");
+var VALID_DISPOSITIONS = words("detach abandon");
+var VALID_EDGE_REASONS = words(
+  "path_overlap module_overlap shared_surface_overlap contract_dependency"
+);
+var VALID_DRIFT_ACTIONS = words(
+  "raised_blocking_finding halted_later_started_item"
+);
+var MERGED_MERGE_STATUSES = words("merged worktree_removed");
+var BLOCKED_MERGE_STATUSES = words(
+  "blocked_drift blocked_ci_loop_limit"
+);
+var BLAST_RADIUS_LIST_FIELDS = words(
+  "paths modules shared_surfaces contracts"
+);
+var PROHIBITED_ANY_LEVEL_KEYS = words(
+  "depends_on integration_branch epic_merge_pr"
+);
+var ROOT_PATH = "<root>";
+function isObject14(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pythonRepr9(value) {
+  if (value === null || value === void 0) {
+    return "None";
+  }
+  if (typeof value === "boolean") {
+    return value ? "True" : "False";
+  }
+  if (typeof value === "string") {
+    return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(pythonRepr9).join(", ")}]`;
+  }
+  if (isObject14(value)) {
+    const pairs = Object.entries(value).map(
+      ([key, item]) => `${pythonRepr9(key)}: ${pythonRepr9(item)}`
+    );
+    return `{${pairs.join(", ")}}`;
+  }
+  return String(value);
+}
+function pythonStr2(value) {
+  return typeof value === "string" ? value : pythonRepr9(value);
+}
+function isEnumMember(members, value) {
+  return typeof value === "string" && members.includes(value);
+}
+function isNonEmptyString2(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isIntegral(value) {
+  return typeof value === "number" && Number.isInteger(value);
+}
+function isPositiveInteger(value) {
+  return isIntegral(value) && value > 0;
+}
+function isNonNegativeInteger(value) {
+  return isIntegral(value) && value >= 0;
+}
+function isStringList(value) {
+  return Array.isArray(value) && value.every(isNonEmptyString2);
+}
+function inBoundedRange(value, minimum, maximum) {
+  return isIntegral(value) && value >= minimum && value <= maximum;
+}
+function enumError(context, field, members, value) {
+  return `${context} ${field} must be one of ${members.join(", ")}; found: ${pythonRepr9(value)}.`;
+}
+function itemContext(context, index) {
+  return `${context} items[${index}]`;
+}
+function validateBlastRadiusBlock(radius, context) {
+  if (!isObject14(radius)) {
+    return [`${context} blast_radius must be an object.`];
+  }
+  const errors = [];
+  for (const field of BLAST_RADIUS_LIST_FIELDS) {
+    if (!isStringList(radius[field])) {
+      errors.push(
+        `${context} blast_radius.${field} must be a list of non-empty strings.`
+      );
+    }
+  }
+  const source = radius["source"];
+  if (!isEnumMember(VALID_SOURCES, source)) {
+    errors.push(
+      enumError(context, "blast_radius.source", VALID_SOURCES, source)
+    );
+  }
+  if (!isNonEmptyString2(radius["computed_at"])) {
+    errors.push(
+      `${context} blast_radius.computed_at must be a non-empty string.`
+    );
+  }
+  return errors;
+}
+function validateMergeStatus(record2, context, state) {
+  if (!("merge_status" in record2)) {
+    return [];
+  }
+  const mergeStatus = record2["merge_status"];
+  if (!isEnumMember(VALID_MERGE_STATUS2, mergeStatus)) {
+    return [
+      enumError(context, "merge_status", VALID_MERGE_STATUS2, mergeStatus)
+    ];
+  }
+  if (isEnumMember(MERGED_MERGE_STATUSES, mergeStatus) && state !== "merged") {
+    return [
+      `${context} merge_status ${pythonRepr9(mergeStatus)} requires state 'merged'; found: ${pythonRepr9(state)}.`
+    ];
+  }
+  if (isEnumMember(BLOCKED_MERGE_STATUSES, mergeStatus) && state !== "blocked") {
+    return [
+      `${context} merge_status ${pythonRepr9(mergeStatus)} requires state 'blocked'; found: ${pythonRepr9(state)}.`
+    ];
+  }
+  return [];
+}
+function validateItemRecord(item, context, requireKind = false) {
+  if (!isObject14(item)) {
+    return [`${context} must be an object.`];
+  }
+  const errors = [];
+  const issueNum = item["issue_num"];
+  if (!isPositiveInteger(issueNum)) {
+    errors.push(
+      `${context} issue_num must be a positive integer; found: ${pythonRepr9(issueNum)}.`
+    );
+  }
+  if (!isNonEmptyString2(item["feature_folder"])) {
+    errors.push(`${context} feature_folder must be a non-empty string.`);
+  }
+  const state = item["state"];
+  if (!isEnumMember(VALID_ITEM_STATES, state)) {
+    errors.push(enumError(context, "state", VALID_ITEM_STATES, state));
+  }
+  if (requireKind) {
+    const kind = item["kind"];
+    if (!isEnumMember(VALID_KINDS, kind)) {
+      errors.push(enumError(context, "kind", VALID_KINDS, kind));
+    }
+  }
+  errors.push(...validateMergeStatus(item, context, state));
+  errors.push(...validateBlastRadiusBlock(item["blast_radius"], context));
+  return errors;
+}
+function validateItems(items, context, requireKind = false) {
+  if (!Array.isArray(items)) {
+    return [`${context} items must be a list.`];
+  }
+  const errors = [];
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = /* @__PURE__ */ new Set();
+  items.forEach((entry, index) => {
+    errors.push(
+      ...validateItemRecord(entry, itemContext(context, index), requireKind)
+    );
+    if (!isObject14(entry)) {
+      return;
+    }
+    const issueNum = entry["issue_num"];
+    if (typeof issueNum !== "number" || !Number.isInteger(issueNum)) {
+      return;
+    }
+    if (seen.has(issueNum)) {
+      duplicates.add(issueNum);
+    }
+    seen.add(issueNum);
+  });
+  for (const issueNum of [...duplicates].sort((left, right) => left - right)) {
+    errors.push(`${context} has duplicate items[].issue_num: ${issueNum}.`);
+  }
+  return errors;
+}
+function prohibitedKeyErrors(value, path11, context, keys) {
+  const errors = [];
+  if (isObject14(value)) {
+    for (const [key, child] of Object.entries(value)) {
+      if (keys.includes(key)) {
+        errors.push(`${context} carries prohibited key '${key}' at ${path11}.`);
+      }
+      const childPath = path11 === ROOT_PATH ? key : `${path11}.${key}`;
+      errors.push(...prohibitedKeyErrors(child, childPath, context, keys));
+    }
+  } else if (Array.isArray(value)) {
+    value.forEach((entry, index) => {
+      errors.push(
+        ...prohibitedKeyErrors(entry, `${path11}[${index}]`, context, keys)
+      );
+    });
+  }
+  return errors;
+}
+function scanProhibitedKeys(root, context, deepKeys = PROHIBITED_ANY_LEVEL_KEYS, topLevelKeys = []) {
+  const errors = prohibitedKeyErrors(root, ROOT_PATH, context, deepKeys);
+  if (isObject14(root) && topLevelKeys.length > 0) {
+    for (const key of topLevelKeys) {
+      if (key in root) {
+        errors.push(
+          `${context} carries prohibited key '${key}' at ${ROOT_PATH}.`
+        );
+      }
+    }
+  }
+  return errors;
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/parallel-orchestrator-state-cohort-barrier.ts
+var VIOLATION_PREFIX = "PARALLEL_COHORT_BARRIER_VIOLATION";
+var ITEM_START_TIMESTAMP_FIELD = "worktree_created_at";
+var MERGE_CONFIRMATION_TIMESTAMP_FIELD = "merged_at";
+var NOT_STARTED_MERGE_STATUS = "not_started";
+var GATING_KEYS = ["conflict_edges", "cohorts"];
+var FOLDER_HINT_PREFIXES = [
+  "docs/features/active/",
+  "docs/features/completed/",
+  "active/",
+  "completed/"
+];
+function normalizeFolderHint2(value) {
+  for (const prefix of FOLDER_HINT_PREFIXES) {
+    if (value.startsWith(prefix)) {
+      return value.slice(prefix.length);
+    }
+  }
+  return value;
+}
+function buildReferenceIndex(items) {
+  const records = /* @__PURE__ */ new Map();
+  const byFolderHint = /* @__PURE__ */ new Map();
+  if (!Array.isArray(items)) {
+    return { records, byFolderHint };
+  }
+  for (const entry of items) {
+    if (!isObject14(entry)) {
+      continue;
+    }
+    const issueNum = entry["issue_num"];
+    if (typeof issueNum !== "number" || !isPositiveInteger(issueNum)) {
+      continue;
+    }
+    if (!records.has(issueNum)) {
+      records.set(issueNum, entry);
+    }
+    const folder = entry["feature_folder"];
+    if (typeof folder === "string" && folder.trim().length > 0) {
+      const hint = normalizeFolderHint2(folder);
+      if (!byFolderHint.has(hint)) {
+        byFolderHint.set(hint, issueNum);
+      }
+    }
+  }
+  return { records, byFolderHint };
+}
+function resolveReference(reference, references) {
+  if (typeof reference === "string") {
+    return references.byFolderHint.get(normalizeFolderHint2(reference)) ?? null;
+  }
+  if (typeof reference === "number" && isPositiveInteger(reference) && references.records.has(reference)) {
+    return reference;
+  }
+  return null;
+}
+function cohortIndexByItem(cohorts, recolorGeneration, references) {
+  const assignments = /* @__PURE__ */ new Map();
+  if (!Array.isArray(cohorts) || !isNonNegativeInteger(recolorGeneration)) {
+    return assignments;
+  }
+  for (const entry of cohorts) {
+    if (!isObject14(entry) || entry["generation"] !== recolorGeneration) {
+      continue;
+    }
+    const cohortIndex = entry["index"];
+    const itemKeys = entry["item_keys"];
+    if (typeof cohortIndex !== "number" || !isNonNegativeInteger(cohortIndex) || !Array.isArray(itemKeys)) {
+      continue;
+    }
+    for (const reference of itemKeys) {
+      const key = resolveReference(reference, references);
+      if (key !== null && !assignments.has(key)) {
+        assignments.set(key, cohortIndex);
+      }
+    }
+  }
+  return assignments;
+}
+function hasStarted(record2) {
+  const start = record2[ITEM_START_TIMESTAMP_FIELD];
+  if (typeof start === "string" && start.trim().length > 0) {
+    return true;
+  }
+  const mergeStatus = record2["merge_status"];
+  return typeof mergeStatus === "string" && mergeStatus !== NOT_STARTED_MERGE_STATUS;
+}
+function satisfiesBarrier(record2) {
+  return isEnumMember(MERGED_MERGE_STATUSES, record2["merge_status"]);
+}
+function mergeConfirmedAfterStart(earlier, later) {
+  const confirmed = earlier[MERGE_CONFIRMATION_TIMESTAMP_FIELD];
+  const started = later[ITEM_START_TIMESTAMP_FIELD];
+  if (typeof confirmed !== "string" || typeof started !== "string") {
+    return false;
+  }
+  return confirmed > started;
+}
+function violationEndpoints(first, second, assignments, records) {
+  const firstIndex = assignments.get(first);
+  const secondIndex = assignments.get(second);
+  if (firstIndex !== void 0 && firstIndex === secondIndex) {
+    return [first, second];
+  }
+  if (firstIndex === void 0 || secondIndex === void 0) {
+    return null;
+  }
+  const [earlierKey, laterKey] = firstIndex < secondIndex ? [first, second] : [second, first];
+  const earlier = records.get(earlierKey);
+  const later = records.get(laterKey);
+  if (earlier === void 0 || later === void 0) {
+    return null;
+  }
+  const statusViolation = hasStarted(later) && !satisfiesBarrier(earlier);
+  if (statusViolation || mergeConfirmedAfterStart(earlier, later)) {
+    return [earlierKey, laterKey];
+  }
+  return null;
+}
+function validateCohortBarrierOrdering(state) {
+  if (GATING_KEYS.some((key) => !(key in state))) {
+    return [];
+  }
+  const edges = state["conflict_edges"];
+  if (!Array.isArray(edges)) {
+    return [];
+  }
+  const references = buildReferenceIndex(state["items"]);
+  const assignments = cohortIndexByItem(
+    state["cohorts"],
+    state["recolor_generation"],
+    references
+  );
+  const errors = [];
+  for (const entry of edges) {
+    if (!isObject14(entry)) {
+      continue;
+    }
+    const first = resolveReference(entry["a"], references);
+    const second = resolveReference(entry["b"], references);
+    if (first === null || second === null || first === second) {
+      continue;
+    }
+    const endpoints = violationEndpoints(
+      first,
+      second,
+      assignments,
+      references.records
+    );
+    if (endpoints !== null) {
+      errors.push(
+        `${VIOLATION_PREFIX}: ${endpoints[0]} ran concurrently with conflicting ${endpoints[1]}`
+      );
+    }
+  }
+  return errors;
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/parallel-state-records.ts
+var OPS_REQUIRING_ITEM_KEY = ["add", "remove", "requeue"];
+var OPS_REQUIRING_NULL_PRIOR_STATE = ["add", "close"];
+var OPS_REQUIRING_NULL_NEW_STATE = ["close"];
+function isNone(value) {
+  return value === null || value === void 0;
+}
+function resolves(value, issueNums) {
+  return typeof value === "number" && Number.isInteger(value) && issueNums.has(value);
+}
+function validateMutationItemKey(entry, entryContext, op, issueNums) {
+  const itemKey = entry["item_key"];
+  if (op === "close") {
+    if (!isNone(itemKey)) {
+      return [
+        `${entryContext} item_key must be null for op 'close'; found: ${pythonRepr9(itemKey)}.`
+      ];
+    }
+    return [];
+  }
+  if (isEnumMember(OPS_REQUIRING_ITEM_KEY, op) && !resolves(itemKey, issueNums)) {
+    return [
+      `${entryContext} item_key ${pythonRepr9(itemKey)} does not resolve to an items[].issue_num.`
+    ];
+  }
+  return [];
+}
+function validateMutationStateField(entry, entryContext, field, op, nullOps) {
+  const value = entry[field];
+  if (isNone(value)) {
+    return [];
+  }
+  if (isEnumMember(nullOps, op)) {
+    return [
+      `${entryContext} ${field} must be null for op ${pythonRepr9(op)}; found: ${pythonRepr9(value)}.`
+    ];
+  }
+  if (!isEnumMember(VALID_ITEM_STATES, value)) {
+    return [
+      `${entryContext} ${field} must be null or one of ${VALID_ITEM_STATES.join(", ")}; found: ${pythonRepr9(value)}.`
+    ];
+  }
+  return [];
+}
+function validateMutationDisposition(entry, entryContext, op) {
+  const disposition = entry["disposition"];
+  if (op === "remove" && entry["prior_state"] === "in_flight") {
+    if (!isEnumMember(VALID_DISPOSITIONS, disposition)) {
+      return [
+        `${entryContext} disposition must be one of ${VALID_DISPOSITIONS.join(", ")} for an in-flight removal; found: ${pythonRepr9(disposition)}.`
+      ];
+    }
+    return [];
+  }
+  if (!isNone(disposition)) {
+    return [
+      `${entryContext} disposition must be null unless op is 'remove' with prior_state 'in_flight'; found: ${pythonRepr9(disposition)}.`
+    ];
+  }
+  return [];
+}
+function validateMutationGeneration(entry, entryContext, recolorGeneration) {
+  const generation = entry["recolor_generation"];
+  if (!isNonNegativeInteger(generation)) {
+    return [
+      `${entryContext} recolor_generation must be a non-negative integer; found: ${pythonRepr9(generation)}.`
+    ];
+  }
+  if (isNonNegativeInteger(recolorGeneration) && typeof generation === "number" && typeof recolorGeneration === "number" && generation > recolorGeneration) {
+    return [
+      `${entryContext} recolor_generation ${generation} must not exceed recolor_generation ${recolorGeneration}.`
+    ];
+  }
+  return [];
+}
+function validateMutations(mutations, issueNums, recolorGeneration, context) {
+  if (!Array.isArray(mutations)) {
+    return [`${context} mutations must be a list.`];
+  }
+  const errors = [];
+  mutations.forEach((entry, position) => {
+    const entryContext = `${context} mutations[${position}]`;
+    if (!isObject14(entry)) {
+      errors.push(`${entryContext} must be an object.`);
+      return;
+    }
+    const op = entry["op"];
+    if (!isEnumMember(VALID_MUTATION_OPS, op)) {
+      errors.push(enumError(entryContext, "op", VALID_MUTATION_OPS, op));
+    }
+    errors.push(...validateMutationItemKey(entry, entryContext, op, issueNums));
+    if (!isNonEmptyString2(entry["at"])) {
+      errors.push(`${entryContext} at must be a non-empty string.`);
+    }
+    errors.push(
+      ...validateMutationStateField(
+        entry,
+        entryContext,
+        "prior_state",
+        op,
+        OPS_REQUIRING_NULL_PRIOR_STATE
+      )
+    );
+    errors.push(
+      ...validateMutationStateField(
+        entry,
+        entryContext,
+        "new_state",
+        op,
+        OPS_REQUIRING_NULL_NEW_STATE
+      )
+    );
+    errors.push(...validateMutationDisposition(entry, entryContext, op));
+    errors.push(
+      ...validateMutationGeneration(entry, entryContext, recolorGeneration)
+    );
+  });
+  return errors;
+}
+function validateDriftEvents(events, issueNums, context) {
+  if (!Array.isArray(events)) {
+    return [`${context} drift_events must be a list.`];
+  }
+  const errors = [];
+  events.forEach((entry, position) => {
+    const entryContext = `${context} drift_events[${position}]`;
+    if (!isObject14(entry)) {
+      errors.push(`${entryContext} must be an object.`);
+      return;
+    }
+    const itemKey = entry["item_key"];
+    if (!resolves(itemKey, issueNums)) {
+      errors.push(
+        `${entryContext} item_key ${pythonRepr9(itemKey)} does not resolve to an items[].issue_num.`
+      );
+    }
+    for (const field of ["declared", "observed"]) {
+      if (!isStringList(entry[field])) {
+        errors.push(
+          `${entryContext} ${field} must be a list of non-empty strings.`
+        );
+      }
+    }
+    const escapedPaths = entry["escaped_paths"];
+    if (!isStringList(escapedPaths) || !Array.isArray(escapedPaths) || escapedPaths.length === 0) {
+      errors.push(
+        `${entryContext} escaped_paths must be a non-empty list of non-empty strings.`
+      );
+    }
+    if (!isNonEmptyString2(entry["at"])) {
+      errors.push(`${entryContext} at must be a non-empty string.`);
+    }
+    const action = entry["action"];
+    if (!isEnumMember(VALID_DRIFT_ACTIONS, action)) {
+      errors.push(
+        enumError(entryContext, "action", VALID_DRIFT_ACTIONS, action)
+      );
+    }
+  });
+  return errors;
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/parallel-state-structures.ts
+var COHORT_COVERAGE_EXEMPT_STATES = "withdrawn merged blocked".split(" ");
+var RECEIPT_ARRAY_KEYS = "delegation_receipts skill_receipts mcp_call_receipts".split(" ");
+function collectItemKeysAndStates(items) {
+  const pairs = [];
+  if (!Array.isArray(items)) {
+    return pairs;
+  }
+  for (const entry of items) {
+    if (!isObject14(entry)) {
+      continue;
+    }
+    const issueNum = entry["issue_num"];
+    if (typeof issueNum === "number" && Number.isInteger(issueNum) && issueNum > 0) {
+      pairs.push({ issueNum, state: entry["state"] });
+    }
+  }
+  return pairs;
+}
+function collectIssueNumbers(items) {
+  return new Set(collectItemKeysAndStates(items).map((pair) => pair.issueNum));
+}
+function validateCohortEntry(entry, entryContext, issueNums, recolorGeneration) {
+  const errors = [];
+  const index = entry["index"];
+  if (!isNonNegativeInteger(index)) {
+    errors.push(
+      `${entryContext} index must be a non-negative integer; found: ${pythonRepr9(index)}.`
+    );
+  }
+  const generation = entry["generation"];
+  if (!isNonNegativeInteger(generation)) {
+    errors.push(
+      `${entryContext} generation must be a non-negative integer; found: ${pythonRepr9(generation)}.`
+    );
+  } else if (recolorGeneration !== null && typeof generation === "number" && generation > recolorGeneration) {
+    errors.push(
+      `${entryContext} generation ${generation} must not exceed recolor_generation ${recolorGeneration}.`
+    );
+  }
+  const itemKeys = entry["item_keys"];
+  if (!Array.isArray(itemKeys)) {
+    errors.push(`${entryContext} item_keys must be a list.`);
+    return errors;
+  }
+  for (const key of itemKeys) {
+    if (typeof key !== "number" || !Number.isInteger(key) || !issueNums.has(key)) {
+      errors.push(
+        `${entryContext} item_keys entry ${pythonRepr9(key)} does not resolve to an items[].issue_num.`
+      );
+    }
+  }
+  return errors;
+}
+function validateCohortShapes(cohorts, issueNums, recolorGeneration, context) {
+  const errors = [];
+  const generationOk = isNonNegativeInteger(recolorGeneration);
+  if (!generationOk) {
+    errors.push(
+      `${context} recolor_generation must be a non-negative integer; found: ${pythonRepr9(recolorGeneration)}.`
+    );
+  }
+  if (!Array.isArray(cohorts)) {
+    errors.push(`${context} cohorts must be a list.`);
+    return errors;
+  }
+  const bound = generationOk && typeof recolorGeneration === "number" ? recolorGeneration : null;
+  cohorts.forEach((entry, position) => {
+    const entryContext = `${context} cohorts[${position}]`;
+    if (!isObject14(entry)) {
+      errors.push(`${entryContext} must be an object.`);
+      return;
+    }
+    errors.push(...validateCohortEntry(entry, entryContext, issueNums, bound));
+  });
+  return errors;
+}
+function currentGenerationCohorts(cohorts, recolorGeneration) {
+  if (!isNonNegativeInteger(recolorGeneration) || !Array.isArray(cohorts)) {
+    return [];
+  }
+  return cohorts.filter(isObject14).filter((entry) => entry["generation"] === recolorGeneration);
+}
+function validateCurrentGenerationCohorts(cohorts, items, recolorGeneration, context) {
+  const current = currentGenerationCohorts(cohorts, recolorGeneration);
+  const errors = [];
+  const seenIndices = /* @__PURE__ */ new Set();
+  const duplicateIndices = /* @__PURE__ */ new Set();
+  const membershipCounts = /* @__PURE__ */ new Map();
+  for (const entry of current) {
+    const index = entry["index"];
+    if (isNonNegativeInteger(index) && typeof index === "number") {
+      if (seenIndices.has(index)) {
+        duplicateIndices.add(index);
+      }
+      seenIndices.add(index);
+    }
+    const itemKeys = entry["item_keys"];
+    if (!Array.isArray(itemKeys)) {
+      continue;
+    }
+    for (const key of itemKeys) {
+      if (typeof key === "number" && Number.isInteger(key)) {
+        membershipCounts.set(key, (membershipCounts.get(key) ?? 0) + 1);
+      }
+    }
+  }
+  for (const index of [...duplicateIndices].sort(
+    (left, right) => left - right
+  )) {
+    errors.push(
+      `${context} has duplicate current-generation cohorts[].index: ${index}.`
+    );
+  }
+  const pairs = [...collectItemKeysAndStates(items)].sort(
+    (left, right) => left.issueNum - right.issueNum
+  );
+  for (const { issueNum, state } of pairs) {
+    const count = membershipCounts.get(issueNum) ?? 0;
+    if (count === 1) {
+      continue;
+    }
+    if (count === 0 && isEnumMember(COHORT_COVERAGE_EXEMPT_STATES, state)) {
+      continue;
+    }
+    errors.push(
+      `${context} item ${issueNum} in state ${pythonRepr9(state)} must appear in exactly one current-generation cohort; found ${count}.`
+    );
+  }
+  return errors;
+}
+function validateCurrentCohortBound(currentCohort, cohorts, recolorGeneration, context) {
+  if (!isNonNegativeInteger(currentCohort) || typeof currentCohort !== "number") {
+    return [
+      `${context} current_cohort must be a non-negative integer; found: ${pythonRepr9(currentCohort)}.`
+    ];
+  }
+  const indices = [];
+  for (const entry of currentGenerationCohorts(cohorts, recolorGeneration)) {
+    const index = entry["index"];
+    if (isNonNegativeInteger(index) && typeof index === "number") {
+      indices.push(index);
+    }
+  }
+  if (indices.length === 0) {
+    return [];
+  }
+  const highest = Math.max(...indices);
+  if (currentCohort > highest) {
+    return [
+      `${context} current_cohort ${currentCohort} must not exceed the maximum current-generation cohorts[].index ${highest}.`
+    ];
+  }
+  return [];
+}
+function validateEdgeEndpoints(entry, entryContext, issueNums) {
+  const errors = [];
+  const endpoints = /* @__PURE__ */ new Map();
+  for (const field of ["a", "b"]) {
+    const value = entry[field];
+    if (typeof value === "number" && Number.isInteger(value) && issueNums.has(value)) {
+      endpoints.set(field, value);
+    } else {
+      errors.push(
+        `${entryContext} ${field} ${pythonRepr9(value)} does not resolve to an items[].issue_num.`
+      );
+    }
+  }
+  if (endpoints.size !== 2) {
+    return { errors, pair: null };
+  }
+  const first = endpoints.get("a") ?? 0;
+  const second = endpoints.get("b") ?? 0;
+  if (first === second) {
+    errors.push(`${entryContext} endpoints must be distinct; found: ${first}.`);
+    return { errors, pair: null };
+  }
+  if (first > second) {
+    errors.push(
+      `${entryContext} must be normalized with a < b; found: (${first}, ${second}).`
+    );
+    return { errors, pair: null };
+  }
+  return { errors, pair: [first, second] };
+}
+function validateConflictEdges(edges, issueNums, context) {
+  if (!Array.isArray(edges)) {
+    return [`${context} conflict_edges must be a list.`];
+  }
+  const errors = [];
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = /* @__PURE__ */ new Map();
+  edges.forEach((entry, position) => {
+    const entryContext = `${context} conflict_edges[${position}]`;
+    if (!isObject14(entry)) {
+      errors.push(`${entryContext} must be an object.`);
+      return;
+    }
+    const { errors: endpointErrors, pair } = validateEdgeEndpoints(
+      entry,
+      entryContext,
+      issueNums
+    );
+    errors.push(...endpointErrors);
+    const reason = entry["reason"];
+    if (!isEnumMember(VALID_EDGE_REASONS, reason)) {
+      errors.push(
+        enumError(entryContext, "reason", VALID_EDGE_REASONS, reason)
+      );
+    }
+    if (pair === null) {
+      return;
+    }
+    const key = `${pair[0]},${pair[1]}`;
+    if (seen.has(key)) {
+      duplicates.set(key, pair);
+    }
+    seen.add(key);
+  });
+  const ordered = [...duplicates.values()].sort(
+    (left, right) => left[0] - right[0] || left[1] - right[1]
+  );
+  for (const pair of ordered) {
+    errors.push(
+      `${context} has duplicate conflict_edges[] pair: (${pair[0]}, ${pair[1]}).`
+    );
+  }
+  return errors;
+}
+function validateReceiptArrays(state, context) {
+  const errors = [];
+  for (const key of RECEIPT_ARRAY_KEYS) {
+    if (key in state && !Array.isArray(state[key])) {
+      errors.push(`${context} ${key} must be a list when present.`);
+    }
+  }
+  return errors;
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/parallel-orchestrator-state-core.ts
+var CONTEXT = "Parallel checkpoint";
+var EXPECTED_ROUTE_ID2 = "parallel";
+var MIN_CONCURRENCY = 1;
+var MAX_CONCURRENCY = 8;
+var REQUIRED_KEYS4 = [
+  "objective",
+  "completed_steps",
+  "next_step",
+  "last_updated",
+  "route_id",
+  "parallel_slug",
+  "parallel_manifest_path",
+  "parallel_status_doc_path",
+  "mode",
+  "max_concurrency",
+  "current_cohort",
+  "recolor_generation",
+  "cohorts",
+  "items",
+  "conflict_edges",
+  "mutations",
+  "drift_events"
+];
+function missingRequiredKeys(state) {
+  return REQUIRED_KEYS4.filter((key) => !(key in state)).map(
+    (key) => `${CONTEXT} missing required key: ${key}.`
+  );
+}
+function validateIdentity(state) {
+  const errors = [];
+  const routeId = state["route_id"];
+  if ("route_id" in state && routeId !== EXPECTED_ROUTE_ID2) {
+    errors.push(
+      `${CONTEXT} route_id must be '${EXPECTED_ROUTE_ID2}'; found: ${pythonRepr9(routeId)}.`
+    );
+  }
+  const mode = state["mode"];
+  if ("mode" in state && !isEnumMember(VALID_MODES, mode)) {
+    errors.push(enumError(CONTEXT, "mode", VALID_MODES, mode));
+  }
+  const concurrency = state["max_concurrency"];
+  if ("max_concurrency" in state && !inBoundedRange(concurrency, MIN_CONCURRENCY, MAX_CONCURRENCY)) {
+    errors.push(
+      `${CONTEXT} max_concurrency must be an integer from ${MIN_CONCURRENCY} through ${MAX_CONCURRENCY}; found: ${pythonRepr9(concurrency)}.`
+    );
+  }
+  return errors;
+}
+function validateCollections(state) {
+  const items = state["items"];
+  const issueNums = collectIssueNumbers(items);
+  const generation = state["recolor_generation"];
+  const cohorts = state["cohorts"];
+  const errors = [];
+  if ("items" in state) {
+    errors.push(...validateItems(items, CONTEXT));
+  }
+  if ("cohorts" in state) {
+    errors.push(
+      ...validateCohortShapes(cohorts, issueNums, generation, CONTEXT)
+    );
+    errors.push(
+      ...validateCurrentGenerationCohorts(cohorts, items, generation, CONTEXT)
+    );
+  }
+  if ("current_cohort" in state) {
+    errors.push(
+      ...validateCurrentCohortBound(
+        state["current_cohort"],
+        cohorts,
+        generation,
+        CONTEXT
+      )
+    );
+  }
+  if ("conflict_edges" in state) {
+    errors.push(
+      ...validateConflictEdges(state["conflict_edges"], issueNums, CONTEXT)
+    );
+  }
+  if ("mutations" in state) {
+    errors.push(
+      ...validateMutations(state["mutations"], issueNums, generation, CONTEXT)
+    );
+  }
+  if ("drift_events" in state) {
+    errors.push(
+      ...validateDriftEvents(state["drift_events"], issueNums, CONTEXT)
+    );
+  }
+  errors.push(...validateReceiptArrays(state, CONTEXT));
+  return errors;
+}
+function recordsCloseMutation(state) {
+  const mutations = state["mutations"];
+  if (!Array.isArray(mutations)) {
+    return false;
+  }
+  return mutations.some(
+    (entry) => isObject14(entry) && entry["op"] === "close"
+  );
+}
+function validateCompletion2(state) {
+  const errors = [];
+  const items = state["items"];
+  const entries = Array.isArray(items) ? items : [];
+  entries.forEach((entry, index) => {
+    if (!isObject14(entry)) {
+      return;
+    }
+    if (entry["state"] === "withdrawn") {
+      return;
+    }
+    const mergeStatus = entry["merge_status"];
+    if (!isEnumMember(MERGED_MERGE_STATUSES, mergeStatus)) {
+      errors.push(
+        `${itemContext(CONTEXT, index)} completion validation failed: merge_status is not merged or worktree_removed; found: ${pythonRepr9(mergeStatus)}.`
+      );
+    }
+  });
+  if (state["mode"] === "open" && !recordsCloseMutation(state)) {
+    errors.push(
+      `${CONTEXT} completion validation failed: open mode requires a mutations[] entry with op 'close'.`
+    );
+  }
+  return errors;
+}
+function validateParallelOrchestratorStateText(text, options = {}) {
+  let state;
+  try {
+    state = JSON.parse(text);
+  } catch (error2) {
+    const detail = error2 instanceof Error ? error2.message : String(error2);
+    return [`${CONTEXT} is not valid JSON: ${detail}.`];
+  }
+  if (!isObject14(state)) {
+    return [`${CONTEXT} root must be a JSON object.`];
+  }
+  const errors = [];
+  errors.push(...missingRequiredKeys(state));
+  errors.push(...validateIdentity(state));
+  errors.push(...scanProhibitedKeys(state, CONTEXT));
+  errors.push(...validateCollections(state));
+  errors.push(...validateCohortBarrierOrdering(state));
+  if (options.requireComplete === true) {
+    errors.push(...validateCompletion2(state));
+  }
+  return errors;
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/parallel-planner-state-core.ts
+var CONTEXT2 = "Parallel planner checkpoint";
+var MIN_CONCURRENCY2 = 1;
+var MAX_CONCURRENCY2 = 8;
+var REQUIRED_KEYS5 = [
+  "objective",
+  "parallel_slug",
+  "parallel_manifest_path",
+  "mode",
+  "max_concurrency",
+  "items",
+  "cohorts",
+  "conflict_edges",
+  "recolor_generation",
+  "completed_steps",
+  "next_step",
+  "last_updated"
+];
+var REQUIRED_ITEM_KEYS = [
+  "issue_num",
+  "feature_folder",
+  "kind",
+  "state",
+  "blast_radius",
+  "preparation_status",
+  "research_path",
+  "plan_path",
+  "preflight_status"
+];
+var VALID_COMPLEXITY_BANDS = [
+  "C1",
+  "C2",
+  "C3",
+  "C4"
+];
+var READY_NEXT_STEP2 = "PARALLEL_EXECUTION_READY";
+var READY_PREPARATION_STATUS = "prepared";
+var READY_PREFLIGHT_STATUS = "PREFLIGHT: ALL CLEAR";
+var READY_RADIUS_SOURCE = "declared";
+var MINIMUM_READY_ITEMS = 2;
+var READY_ITEM_PATH_KEYS = ["research_path", "plan_path"];
+function kickoffPathFor(slug) {
+  return `artifacts/orchestration/parallel-kickoff-${pythonStr2(slug)}.md`;
+}
+function missingRequiredKeys2(state) {
+  return REQUIRED_KEYS5.filter((key) => !(key in state)).map(
+    (key) => `${CONTEXT2} missing required key: ${key}.`
+  );
+}
+function validateIdentity2(state) {
+  const errors = [];
+  for (const key of ["parallel_slug", "parallel_manifest_path"]) {
+    if (key in state && !isNonEmptyString2(state[key])) {
+      errors.push(`${CONTEXT2} ${key} must be a non-empty string.`);
+    }
+  }
+  const mode = state["mode"];
+  if ("mode" in state && !isEnumMember(VALID_MODES, mode)) {
+    errors.push(enumError(CONTEXT2, "mode", VALID_MODES, mode));
+  }
+  const concurrency = state["max_concurrency"];
+  if ("max_concurrency" in state && !inBoundedRange(concurrency, MIN_CONCURRENCY2, MAX_CONCURRENCY2)) {
+    errors.push(
+      `${CONTEXT2} max_concurrency must be an integer from ${MIN_CONCURRENCY2} through ${MAX_CONCURRENCY2}; found: ${pythonRepr9(concurrency)}.`
+    );
+  }
+  return errors;
+}
+function itemRecords(items) {
+  if (!Array.isArray(items)) {
+    return [];
+  }
+  const records = [];
+  items.forEach((entry, index) => {
+    if (isObject14(entry)) {
+      records.push({ index, record: entry });
+    }
+  });
+  return records;
+}
+function validateItemContract(items) {
+  const errors = [];
+  for (const { index, record: record2 } of itemRecords(items)) {
+    const entryContext = itemContext(CONTEXT2, index);
+    for (const key of REQUIRED_ITEM_KEYS) {
+      if (!(key in record2)) {
+        errors.push(`${entryContext} missing required key: ${key}.`);
+      }
+    }
+    const band = record2["complexity_band"];
+    if ("complexity_band" in record2 && !isEnumMember(VALID_COMPLEXITY_BANDS, band)) {
+      errors.push(
+        enumError(
+          entryContext,
+          "complexity_band",
+          VALID_COMPLEXITY_BANDS,
+          band
+        )
+      );
+    }
+  }
+  return errors;
+}
+function validateCollections2(state) {
+  const items = state["items"];
+  const issueNums = collectIssueNumbers(items);
+  const generation = state["recolor_generation"];
+  const cohorts = state["cohorts"];
+  const errors = [];
+  if ("items" in state) {
+    errors.push(...validateItems(items, CONTEXT2, true));
+    errors.push(...validateItemContract(items));
+  }
+  if ("cohorts" in state) {
+    errors.push(
+      ...validateCohortShapes(cohorts, issueNums, generation, CONTEXT2)
+    );
+    errors.push(
+      ...validateCurrentGenerationCohorts(cohorts, items, generation, CONTEXT2)
+    );
+  }
+  if ("current_cohort" in state) {
+    errors.push(
+      ...validateCurrentCohortBound(
+        state["current_cohort"],
+        cohorts,
+        generation,
+        CONTEXT2
+      )
+    );
+  }
+  if ("conflict_edges" in state) {
+    errors.push(
+      ...validateConflictEdges(state["conflict_edges"], issueNums, CONTEXT2)
+    );
+  }
+  return errors;
+}
+function validateReadyItem(record2, entryContext) {
+  const errors = [];
+  const preparationStatus = record2["preparation_status"];
+  if (preparationStatus !== READY_PREPARATION_STATUS) {
+    errors.push(
+      `${entryContext} preparation_status must be ${pythonRepr9(READY_PREPARATION_STATUS)}; found: ${pythonRepr9(preparationStatus)}.`
+    );
+  }
+  const preflightStatus = record2["preflight_status"];
+  if (preflightStatus !== READY_PREFLIGHT_STATUS) {
+    errors.push(
+      `${entryContext} preflight_status must be ${pythonRepr9(READY_PREFLIGHT_STATUS)}; found: ${pythonRepr9(preflightStatus)}.`
+    );
+  }
+  for (const key of READY_ITEM_PATH_KEYS) {
+    if (!isNonEmptyString2(record2[key])) {
+      errors.push(`${entryContext} ${key} must be a non-empty string.`);
+    }
+  }
+  const radius = record2["blast_radius"];
+  const source = isObject14(radius) ? radius["source"] : null;
+  if (source !== READY_RADIUS_SOURCE) {
+    errors.push(
+      `${entryContext} blast_radius.source must be ${pythonRepr9(READY_RADIUS_SOURCE)} for execution readiness; found: ${pythonRepr9(source)}.`
+    );
+  }
+  return errors;
+}
+function validateReadyGate(state) {
+  const errors = [];
+  const items = state["items"];
+  if (Array.isArray(items)) {
+    const count = items.length;
+    if (count < MINIMUM_READY_ITEMS) {
+      errors.push(
+        `${CONTEXT2} requires at least ${MINIMUM_READY_ITEMS} items for execution readiness; found: ${count}.`
+      );
+    }
+    for (const { index, record: record2 } of itemRecords(items)) {
+      errors.push(...validateReadyItem(record2, itemContext(CONTEXT2, index)));
+    }
+  }
+  const nextStep = state["next_step"];
+  if (nextStep !== READY_NEXT_STEP2) {
+    errors.push(
+      `${CONTEXT2} next_step must be ${pythonRepr9(READY_NEXT_STEP2)}; found: ${pythonRepr9(nextStep)}.`
+    );
+  }
+  const expectedKickoff = kickoffPathFor(state["parallel_slug"]);
+  const kickoffPromptPath = state["kickoff_prompt_path"];
+  if (kickoffPromptPath !== expectedKickoff) {
+    errors.push(
+      `${CONTEXT2} kickoff_prompt_path must be ${pythonRepr9(expectedKickoff)}; found: ${pythonRepr9(kickoffPromptPath)}.`
+    );
+  }
+  return errors;
+}
+function validateParallelPlannerStateText(text, options = {}) {
+  let state;
+  try {
+    state = JSON.parse(text);
+  } catch (error2) {
+    const detail = error2 instanceof Error ? error2.message : String(error2);
+    return [`${CONTEXT2} is not valid JSON: ${detail}.`];
+  }
+  if (!isObject14(state)) {
+    return [`${CONTEXT2} root must be a JSON object.`];
+  }
+  const errors = [];
+  errors.push(...missingRequiredKeys2(state));
+  errors.push(...validateIdentity2(state));
+  errors.push(...scanProhibitedKeys(state, CONTEXT2));
+  errors.push(...validateCollections2(state));
+  if (options.requireReadyForExecution === true) {
+    errors.push(...validateReadyGate(state));
+  }
+  return errors;
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/policy-audit-artifact.ts
+var COVERAGE_PERCENT_RE = /\b\d+(?:\.\d+)?%/;
+var POLICY_AUDIT_REQUIRED_HEADINGS = [
+  "## Executive Summary",
+  "## 1. General Unit Test Policy Compliance",
+  "## 2. General Code Change Policy Compliance",
+  "## 3. Language-Specific Code Change Policy Compliance",
+  "## 4. Language-Specific Unit Test Policy Compliance",
+  "## 5. Test Coverage Detail",
+  "## 6. Test Execution Metrics",
+  "## 7. Code Quality Checks",
+  "## 8. Gaps and Exceptions",
+  "## 9. Summary of Changes",
+  "## 10. Compliance Verdict",
+  "## Appendix A: Test Inventory",
+  "## Appendix B: Toolchain Commands Reference"
+];
+var POLICY_AUDIT_REQUIRED_CHECKLIST_LABELS = [
+  "TypeScript baseline coverage artifact:",
+  "TypeScript post-change coverage artifact:",
+  "PowerShell baseline coverage artifact:",
+  "PowerShell post-change coverage artifact:",
+  "Per-language comparison summary:"
+];
+var POLICY_AUDIT_COMPARISON_HEADING = "### 1.2.1 Per-Language Coverage Comparison";
+var PLACEHOLDER_MARKERS = [
+  "[n]",
+  "[path",
+  "[artifact",
+  "[section reference",
+  "[language]",
+  "tbd",
+  "unverified",
+  "missing"
+];
+var TEMPLATE_RESOLVER_TOOL = "resolve_policy_audit_template_asset";
+var TEMPLATE_RESOLVER_MISSING_MARKERS = [
+  "not exposed",
+  "was not exposed",
+  "missing resolver exposure",
+  "fallback template",
+  "fallback-template"
+];
+function hasNumericCoverage(value) {
+  return COVERAGE_PERCENT_RE.test(value);
+}
+function isNaValue(value) {
+  return value.trim().toLowerCase().startsWith("n/a");
+}
+function hasPlaceholderMarker(value) {
+  const lowered = value.toLowerCase();
+  return PLACEHOLDER_MARKERS.some((marker) => lowered.includes(marker));
+}
+function reportsMissingTemplateResolverSuccess(text) {
+  const lowered = text.toLowerCase();
+  if (!lowered.includes(TEMPLATE_RESOLVER_TOOL)) {
+    return false;
+  }
+  if (!TEMPLATE_RESOLVER_MISSING_MARKERS.some((m) => lowered.includes(m))) {
+    return false;
+  }
+  return /\b(pass|ready|readiness)\b/.test(lowered);
+}
+function extractPolicyAuditCoverageRows(text) {
+  const rows = [];
+  for (const line of text.split("\n")) {
+    if (!line.startsWith("|")) {
+      continue;
+    }
+    const segments = line.split("|");
+    const cells = segments.slice(1, -1).map((cell) => cell.trim());
+    if (cells.length !== 7) {
+      continue;
+    }
+    const language = cells[0] ?? "";
+    if (language === "Language" || language === "----------" || !language) {
+      continue;
+    }
+    if (language.length > 0 && /^-+$/.test(language)) {
+      continue;
+    }
+    rows.push({
+      Language: language,
+      "Files Changed": cells[1] ?? "",
+      Tests: cells[2] ?? "",
+      "Test Result": cells[3] ?? "",
+      "Baseline Coverage": cells[4] ?? "",
+      "Post-Change Coverage": cells[5] ?? "",
+      "New Code Coverage": cells[6] ?? ""
+    });
+  }
+  return rows;
+}
+function findPolicyAuditChecklistLine(text, label) {
+  for (const line of text.split("\n")) {
+    const stripped = line.trim();
+    if (stripped.startsWith("- ") && stripped.includes(label)) {
+      return stripped;
+    }
+  }
+  return null;
+}
+function extractPolicyAuditComparisonLines(text) {
+  let inSection = false;
+  const comparisonLines = /* @__PURE__ */ new Map();
+  for (const line of text.split("\n")) {
+    const stripped = line.trim();
+    if (stripped === POLICY_AUDIT_COMPARISON_HEADING) {
+      inSection = true;
+      continue;
+    }
+    if (inSection && stripped.startsWith("### ")) {
+      break;
+    }
+    if (!inSection || !stripped.startsWith("- ")) {
+      continue;
+    }
+    const body = stripped.slice(2);
+    const colonIndex = body.indexOf(":");
+    if (colonIndex === -1) {
+      continue;
+    }
+    const language = body.slice(0, colonIndex);
+    comparisonLines.set(language.trim().toLowerCase(), stripped);
+  }
+  return comparisonLines;
+}
+function escapeRegExp3(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function comparisonLineHasLabelledPercentage(line, label) {
+  const pattern = new RegExp(`${escapeRegExp3(label)}.*?\\d+(?:\\.\\d+)?%`);
+  return pattern.test(line);
+}
+function validatePolicyAuditSubstantiveRequirements(text) {
+  const errors = [];
+  for (const label of POLICY_AUDIT_REQUIRED_CHECKLIST_LABELS) {
+    const line = findPolicyAuditChecklistLine(text, label);
+    if (line === null) {
+      errors.push(`Policy audit missing required checklist line: ${label}`);
+      continue;
+    }
+    if (hasPlaceholderMarker(line)) {
+      errors.push(
+        `Policy audit checklist line still contains placeholder text: ${label}`
+      );
+    }
+  }
+  const coverageRows = extractPolicyAuditCoverageRows(text);
+  if (coverageRows.length === 0) {
+    errors.push("Policy audit missing coverage metrics table rows.");
+  }
+  if (!text.includes(POLICY_AUDIT_COMPARISON_HEADING)) {
+    errors.push(
+      `Policy audit missing required heading: ${POLICY_AUDIT_COMPARISON_HEADING}`
+    );
+  }
+  const comparisonLines = extractPolicyAuditComparisonLines(text);
+  for (const row of coverageRows) {
+    const language = row.Language;
+    const baseline = row["Baseline Coverage"];
+    const postChange = row["Post-Change Coverage"];
+    const newCode = row["New Code Coverage"];
+    const requiresCoverageComparison = [baseline, postChange, newCode].some(
+      (value) => !isNaValue(value)
+    );
+    if (!isNaValue(baseline) && !hasNumericCoverage(baseline)) {
+      errors.push(
+        `Policy audit missing numeric baseline coverage for ${language}.`
+      );
+    }
+    if (!isNaValue(postChange) && !hasNumericCoverage(postChange)) {
+      errors.push(
+        `Policy audit missing numeric post-change coverage for ${language}.`
+      );
+    }
+    if (!isNaValue(newCode) && !hasNumericCoverage(newCode)) {
+      errors.push(
+        `Policy audit missing numeric new/changed-code coverage for ${language}.`
+      );
+    }
+    if (!requiresCoverageComparison) {
+      continue;
+    }
+    const comparisonLine = comparisonLines.get(language.toLowerCase());
     if (comparisonLine === void 0) {
       errors.push(
         `Policy audit missing per-language comparison line for ${language}.`
@@ -26492,6 +27912,20 @@ function validateArtifact(input) {
     }
     case "epic-kickoff":
       return validateEpicKickoffText(input.text);
+    case "parallel-orchestrator-state": {
+      const options = {
+        ...input.requireComplete === void 0 ? {} : { requireComplete: input.requireComplete }
+      };
+      return validateParallelOrchestratorStateText(input.text, options);
+    }
+    case "parallel-planner-state": {
+      const options = {
+        ...input.requireReadyForExecution === void 0 ? {} : { requireReadyForExecution: input.requireReadyForExecution }
+      };
+      return validateParallelPlannerStateText(input.text, options);
+    }
+    case "parallel-kickoff":
+      return validateParallelKickoffText(input.text);
     default:
       return [`Unsupported artifact type: ${input.artifactType}`];
   }