@danmoisan/drm-copilot-mcp 1.1.17 → 1.1.18

package/out/mcp-server.js

@@ -4150,13 +4150,14 @@ var require_fast_uri = __commonJS({
         if (!malformedIPLiteral) {
           malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
         }
-        if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
-          if (uri.indexOf("%") !== -1) {
-            if (parsed.host !== void 0 && !malformedIPLiteral) {
-              const host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
-              parsed.host = reescapeHostDelimiters(host, isIP);
-            }
+        if (uri.indexOf("%") !== -1 && parsed.host !== void 0 && !malformedIPLiteral) {
+          let host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
+          if (!isIP) {
+            host = normalizePercentEncoding(host.toLowerCase());
           }
+          parsed.host = reescapeHostDelimiters(host, isIP);
+        }
+        if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
           if (parsed.path) {
             parsed.path = normalizePathEncoding(parsed.path);
           }
@@ -9273,13 +9274,13 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     }
     return propValues;
   });
-  const isObject15 = isObject;
+  const isObject16 = isObject;
   const catchall = def.catchall;
   let value;
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
     const input = payload.value;
-    if (!isObject15(input)) {
+    if (!isObject16(input)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
@@ -9406,7 +9407,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
     return (payload, ctx) => fn(shape, payload, ctx);
   };
   let fastpass;
-  const isObject15 = isObject;
+  const isObject16 = isObject;
   const jit = !globalConfig.jitless;
   const allowsEval2 = allowsEval;
   const fastEnabled = jit && allowsEval2.value;
@@ -9415,7 +9416,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
     const input = payload.value;
-    if (!isObject15(input)) {
+    if (!isObject16(input)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
@@ -25739,6 +25740,7 @@ var MERGED_STATUSES = /* @__PURE__ */ new Set([
   "merged",
   "worktree_removed"
 ]);
+var NOT_STARTED_MERGE_STATUS = "not_started";
 function isObject6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -25819,6 +25821,9 @@ function validateMergeStatusEnum(features) {
   }
   return errors;
 }
+function hasStarted(feature) {
+  return typeof feature["worktree_created_at"] === "string" || feature["merge_status"] !== NOT_STARTED_MERGE_STATUS;
+}
 function validateWaveBarrierOrdering(features) {
   const errors = [];
   const byFolder = /* @__PURE__ */ new Map();
@@ -25835,6 +25840,9 @@ function validateWaveBarrierOrdering(features) {
     if (typeof folder !== "string" || !Array.isArray(dependsOn)) {
       continue;
     }
+    if (!hasStarted(feature)) {
+      continue;
+    }
     const worktreeCreatedAt = feature["worktree_created_at"];
     for (const dependency of dependsOn) {
       const resolved = resolveFeatureReference(dependency, index);
@@ -25846,9 +25854,13 @@ function validateWaveBarrierOrdering(features) {
       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) {
+      if (statusViolation) {
+        errors.push(
+          `EPIC_WAVE_BARRIER_VIOLATION: ${folder} is treated as started while dependency ${String(dependency)} is not merged`
+        );
+      } else if (timingViolation) {
         errors.push(
-          `EPIC_WAVE_BARRIER_VIOLATION: ${folder} started before dependency ${String(dependency)} merged`
+          `EPIC_WAVE_BARRIER_VIOLATION: ${folder} worktree_created_at precedes dependency ${String(dependency)} merge_confirmed_at`
         );
       }
     }
@@ -27194,6 +27206,201 @@ function validateEpicPlannerStateText(text2, options = {}) {
   return errors;
 }
 
+// ../../extensions/drm-copilot/src/lib/validate/orchestrator-state-blocked-reason.ts
+var MECHANICAL_BLOCKED_REASONS = /* @__PURE__ */ new Set([
+  "spawn_agent_unavailable",
+  "delegation_launch_failed",
+  "delegate_no_receipt",
+  "delegate_contract_incomplete",
+  "validator_failed",
+  "user_requested_stop"
+]);
+var NON_MECHANICAL_BLOCKED_REASONS = /* @__PURE__ */ new Set([
+  "premise_falsified",
+  "external_dependency",
+  "policy_hold",
+  "awaiting_ci",
+  "human_decision_required"
+]);
+var VALID_BLOCKED_REASONS = /* @__PURE__ */ new Set([
+  "none",
+  ...MECHANICAL_BLOCKED_REASONS,
+  ...NON_MECHANICAL_BLOCKED_REASONS
+]);
+
+// ../../extensions/drm-copilot/src/lib/validate/orchestrator-state-promotion-tools.ts
+var FEATURE_PROMOTION_ENTRY_TOOL = "new_potential_entry";
+var BUG_PROMOTION_ENTRY_TOOL = "new_potential_bug_entry";
+var BUG_PROMOTION_TYPE = "bug";
+var PROMOTION_TYPE_KEY = "promotion-type";
+function resolvePromotionEntryTools(requiredMcpTools, state) {
+  if (state[PROMOTION_TYPE_KEY] !== BUG_PROMOTION_TYPE) {
+    return [...requiredMcpTools];
+  }
+  return requiredMcpTools.map(
+    (tool) => tool === FEATURE_PROMOTION_ENTRY_TOOL ? BUG_PROMOTION_ENTRY_TOOL : tool
+  );
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/orchestrator-state-issue-adoption.ts
+var ISSUE_ADOPTION_KEY = "issue_adoption";
+var POTENTIAL_TO_ISSUE_TOOL = "potential_to_issue";
+var ORIGIN_VALUES = /* @__PURE__ */ new Set([
+  "transferred",
+  "filed_before_orchestration",
+  "epic_decomposition"
+]);
+var VERIFIED_VIA_VALUES = /* @__PURE__ */ new Set([
+  "gh_issue_view",
+  "gh_api_get",
+  "github_mcp_issue_read"
+]);
+var WAIVABLE_TOOLS = /* @__PURE__ */ new Set([
+  POTENTIAL_TO_ISSUE_TOOL,
+  FEATURE_PROMOTION_ENTRY_TOOL,
+  BUG_PROMOTION_ENTRY_TOOL
+]);
+var PROMOTION_ENTRY_TOOLS = /* @__PURE__ */ new Set([
+  FEATURE_PROMOTION_ENTRY_TOOL,
+  BUG_PROMOTION_ENTRY_TOOL
+]);
+var POTENTIAL_RECORD_PREFIX = "docs/features/potential/";
+var POTENTIAL_RECORD_SUFFIX = ".md";
+var ISSUE_NUM_PATTERN = /^[1-9][0-9]*$/;
+var ERROR_NOT_OBJECT = "Checkpoint issue_adoption must be an object when present.";
+var ERROR_ISSUE_NUM_FORMAT = "Checkpoint issue_adoption.issue_num must be a string of decimal digits without a leading zero.";
+var ERROR_ISSUE_NUM_MISMATCH = "Checkpoint issue_adoption.issue_num must equal the checkpoint issue-num.";
+var ERROR_ISSUE_URL = "Checkpoint issue_adoption.issue_url must end with /issues/ followed by issue_num.";
+var ERROR_ORIGIN = "Checkpoint issue_adoption.origin must be one of transferred, filed_before_orchestration, epic_decomposition.";
+var ERROR_VERIFIED_VIA = "Checkpoint issue_adoption.verified_via must be one of gh_issue_view, gh_api_get, github_mcp_issue_read.";
+var ERROR_VERIFIED_AT = "Checkpoint issue_adoption.verified_at must be present.";
+var ERROR_EVIDENCE = "Checkpoint issue_adoption.evidence must be a non-empty string.";
+var ERROR_WAIVED_TOOLS_SHAPE = "Checkpoint issue_adoption.waived_tools must be a non-empty list of tool names.";
+var ERROR_WAIVED_TOOLS_INCLUDE = "Checkpoint issue_adoption.waived_tools must include potential_to_issue.";
+function isPlainObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonBlankString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function validIssueNum(value) {
+  return typeof value === "string" && ISSUE_NUM_PATTERN.test(value) ? value : null;
+}
+function issueIdentityErrors(adoption, state) {
+  const errors = [];
+  const issueNum = validIssueNum(adoption["issue_num"]);
+  if (issueNum === null) {
+    errors.push(ERROR_ISSUE_NUM_FORMAT);
+  } else {
+    const checkpointIssueNum = state["issue-num"];
+    if (typeof checkpointIssueNum === "string" && checkpointIssueNum !== issueNum) {
+      errors.push(ERROR_ISSUE_NUM_MISMATCH);
+    }
+  }
+  const issueUrl = adoption["issue_url"];
+  if (issueNum === null || typeof issueUrl !== "string" || !issueUrl.endsWith(`/issues/${issueNum}`)) {
+    errors.push(ERROR_ISSUE_URL);
+  }
+  return errors;
+}
+function provenanceErrors(adoption) {
+  const errors = [];
+  const origin = adoption["origin"];
+  if (typeof origin !== "string" || !ORIGIN_VALUES.has(origin)) {
+    errors.push(ERROR_ORIGIN);
+  }
+  const verifiedVia = adoption["verified_via"];
+  if (typeof verifiedVia !== "string" || !VERIFIED_VIA_VALUES.has(verifiedVia)) {
+    errors.push(ERROR_VERIFIED_VIA);
+  }
+  const verifiedAt = adoption["verified_at"];
+  if (verifiedAt === void 0 || verifiedAt === null || typeof verifiedAt === "string" && verifiedAt.trim().length === 0) {
+    errors.push(ERROR_VERIFIED_AT);
+  }
+  if (!isNonBlankString(adoption["evidence"])) {
+    errors.push(ERROR_EVIDENCE);
+  }
+  return errors;
+}
+function waivedToolList(value) {
+  if (!Array.isArray(value)) {
+    return null;
+  }
+  const items = value;
+  if (items.length === 0 || !items.every((item) => isNonBlankString(item))) {
+    return null;
+  }
+  return items;
+}
+function waivedToolErrors(waived, options) {
+  const errors = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const tool of waived) {
+    if (seen.has(tool)) {
+      errors.push(
+        `Checkpoint issue_adoption.waived_tools lists a tool more than once: ${tool}.`
+      );
+    } else if (!WAIVABLE_TOOLS.has(tool)) {
+      errors.push(
+        `Checkpoint issue_adoption.waived_tools names a tool that cannot be waived: ${tool}.`
+      );
+    } else if (!options.requiredMcpTools.includes(tool)) {
+      errors.push(
+        `Checkpoint issue_adoption.waived_tools names a tool that is not required by route ${options.routeId}: ${tool}.`
+      );
+    } else if (options.successfulTools.has(tool)) {
+      errors.push(
+        `Checkpoint issue_adoption.waived_tools names a tool that has a successful MCP receipt: ${tool}.`
+      );
+    }
+    seen.add(tool);
+  }
+  if (!seen.has(POTENTIAL_TO_ISSUE_TOOL)) {
+    errors.push(ERROR_WAIVED_TOOLS_INCLUDE);
+  }
+  return errors;
+}
+function potentialRecordErrors(waived, potentialRecord) {
+  if (typeof potentialRecord === "string" && potentialRecord.startsWith(POTENTIAL_RECORD_PREFIX) && potentialRecord.endsWith(POTENTIAL_RECORD_SUFFIX)) {
+    return [];
+  }
+  const errors = [];
+  const reported = /* @__PURE__ */ new Set();
+  for (const tool of waived) {
+    if (PROMOTION_ENTRY_TOOLS.has(tool) && !reported.has(tool)) {
+      errors.push(
+        `Checkpoint issue_adoption.potential_record must name a markdown file under docs/features/potential/ when waiving ${tool}.`
+      );
+      reported.add(tool);
+    }
+  }
+  return errors;
+}
+function resolveIssueAdoption(state, options) {
+  if (!Object.prototype.hasOwnProperty.call(state, ISSUE_ADOPTION_KEY)) {
+    return { errors: [], waivedTools: /* @__PURE__ */ new Set() };
+  }
+  const adoption = state[ISSUE_ADOPTION_KEY];
+  if (!isPlainObject3(adoption)) {
+    return { errors: [ERROR_NOT_OBJECT], waivedTools: /* @__PURE__ */ new Set() };
+  }
+  const errors = [
+    ...issueIdentityErrors(adoption, state),
+    ...provenanceErrors(adoption)
+  ];
+  const waived = waivedToolList(adoption["waived_tools"]);
+  if (waived === null) {
+    errors.push(ERROR_WAIVED_TOOLS_SHAPE);
+    return { errors, waivedTools: /* @__PURE__ */ new Set() };
+  }
+  errors.push(...waivedToolErrors(waived, options));
+  errors.push(...potentialRecordErrors(waived, adoption["potential_record"]));
+  if (errors.length > 0) {
+    return { errors, waivedTools: /* @__PURE__ */ new Set() };
+  }
+  return { errors: [], waivedTools: new Set(waived) };
+}
+
 // ../../extensions/drm-copilot/src/lib/validate/orchestrator-state-routing.ts
 var ROUTING_MATRIX_RELATIVE_PATH = "config/orchestration-routing.json";
 var MANDATORY_ROUTE_PHASES = {
@@ -27382,7 +27589,10 @@ function validateRoutingContract(state, options = {}) {
   const errors = [];
   const requiredAgents = routeList(rawRoute, "required_agents");
   const requiredSkills = routeList(rawRoute, "required_skills");
-  const requiredMcpTools = routeList(rawRoute, "required_mcp_tools");
+  const requiredMcpTools = resolvePromotionEntryTools(
+    routeList(rawRoute, "required_mcp_tools"),
+    state
+  );
   if (stateList(state, "required_agents", requiredAgents) === null) {
     errors.push(
       `Checkpoint required_agents must match routing matrix for route ${routeId}.`
@@ -27411,11 +27621,20 @@ function validateRoutingContract(state, options = {}) {
     }
   }
   const actualTools = mcpTools(state);
+  const adoption = resolveIssueAdoption(state, {
+    routeId,
+    requiredMcpTools,
+    successfulTools: actualTools
+  });
   for (const tool of requiredMcpTools) {
+    if (adoption.waivedTools.has(tool)) {
+      continue;
+    }
     if (!actualTools.has(tool)) {
       errors.push(`Checkpoint missing successful MCP receipt: ${tool}.`);
     }
   }
+  errors.push(...adoption.errors);
   errors.push(...validateEmptyListField(state, "local_execution_overrides"));
   errors.push(...validateEmptyListField(state, "delegation_bypasses"));
   errors.push(...validateLifecycleOperations(state));
@@ -27561,14 +27780,137 @@ function validateHumanInteraction(humanInteraction) {
   return errors;
 }
 
+// ../../extensions/drm-copilot/src/lib/validate/orchestrator-state-remediation-accounting.ts
+var REVIEW_OUTCOMES_KEY = "review_outcomes";
+var REVIEW_VERDICTS = [
+  "PASS",
+  "REMEDIATION_REQUIRED",
+  "HALT_NON_REMEDIABLE",
+  "AWAITING_CI"
+];
+var REMEDIABILITY_CLASSES = [
+  "autonomous",
+  "external_dependency",
+  "policy_hold",
+  "awaiting_ci",
+  "human_decision_required"
+];
+var HALT_CLASSES = /* @__PURE__ */ new Set([
+  "external_dependency",
+  "policy_hold",
+  "human_decision_required"
+]);
+var REMEDIABLE_CLASS = "autonomous";
+function isObject11(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pythonRepr8(value) {
+  if (value === null || value === void 0) {
+    return "None";
+  }
+  if (value === true) {
+    return "True";
+  }
+  if (value === false) {
+    return "False";
+  }
+  return String(value);
+}
+function deriveReviewVerdict(remediabilities) {
+  for (const value of remediabilities) {
+    if (!REMEDIABILITY_CLASSES.includes(value)) {
+      throw new RangeError(`invalid remediability: ${value}`);
+    }
+  }
+  if (remediabilities.length === 0) {
+    return "PASS";
+  }
+  if (remediabilities.includes(REMEDIABLE_CLASS)) {
+    return "REMEDIATION_REQUIRED";
+  }
+  if (remediabilities.some((value) => HALT_CLASSES.has(value))) {
+    return "HALT_NON_REMEDIABLE";
+  }
+  return "AWAITING_CI";
+}
+function validateReviewOutcome(index, outcome) {
+  const errors = [];
+  const prefix = `Checkpoint remediation review outcome #${index}`;
+  const verdict = outcome["verdict"];
+  if (typeof verdict !== "string" || !REVIEW_VERDICTS.includes(verdict)) {
+    errors.push(
+      `${prefix} verdict must be one of PASS, REMEDIATION_REQUIRED, HALT_NON_REMEDIABLE, AWAITING_CI; got: ${pythonRepr8(verdict)}`
+    );
+  }
+  const classes = [];
+  const findings = outcome["findings"];
+  if (!Array.isArray(findings)) {
+    errors.push(`${prefix} findings must be a list.`);
+  } else {
+    findings.forEach((finding, findingIndex) => {
+      if (!isObject11(finding)) {
+        errors.push(`${prefix} finding #${findingIndex} must be an object.`);
+        return;
+      }
+      const remediability = finding["remediability"];
+      if (typeof remediability !== "string" || !REMEDIABILITY_CLASSES.includes(remediability)) {
+        errors.push(
+          `${prefix} finding #${findingIndex} remediability must be one of autonomous, external_dependency, policy_hold, awaiting_ci, human_decision_required; got: ${pythonRepr8(remediability)}`
+        );
+        return;
+      }
+      classes.push(remediability);
+    });
+  }
+  if (errors.length === 0) {
+    const expected = deriveReviewVerdict(classes);
+    if (verdict !== expected) {
+      errors.push(
+        `${prefix} verdict ${pythonRepr8(verdict)} does not match its findings (expected ${expected}).`
+      );
+    }
+  }
+  return errors;
+}
+function validateReviewOutcomes(loop) {
+  if (!Object.prototype.hasOwnProperty.call(loop, REVIEW_OUTCOMES_KEY)) {
+    return [];
+  }
+  const outcomes = loop[REVIEW_OUTCOMES_KEY];
+  if (!Array.isArray(outcomes)) {
+    return ["Checkpoint remediation_loop review_outcomes must be a list."];
+  }
+  const errors = [];
+  outcomes.forEach((outcome, index) => {
+    if (!isObject11(outcome)) {
+      errors.push(
+        `Checkpoint remediation review outcome #${index} must be an object.`
+      );
+      return;
+    }
+    errors.push(...validateReviewOutcome(index, outcome));
+  });
+  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 isObject11(value) {
+var COMPLETED_ATTEMPTS_KEY = "completed_attempts";
+var CANDIDATE_APPLIED_KEY = "candidate_applied";
+var OPENED_BY_REVIEW_KEY = "opened_by_review";
+var COMPLETED_EXECUTION_STATUS = "complete";
+function isObject12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isStrictInteger(value) {
+  return typeof value === "number" && Number.isInteger(value);
+}
+function hasKey(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
 function validateRemediationCycle(index, cycle) {
   const errors = [];
   const planPath = cycle["plan_path"];
@@ -27580,7 +27922,7 @@ function validateRemediationCycle(index, cycle) {
   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;
+    const preflightStatus = isObject12(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'.`
@@ -27594,22 +27936,79 @@ function validateRemediationCycle(index, cycle) {
   }
   return errors;
 }
+function opensRemediationReview(openedByReview, outcomes) {
+  if (!isStrictInteger(openedByReview) || !Array.isArray(outcomes)) {
+    return false;
+  }
+  if (openedByReview < 0 || openedByReview >= outcomes.length) {
+    return false;
+  }
+  const target = outcomes[openedByReview];
+  return isObject12(target) && target["verdict"] === "REMEDIATION_REQUIRED";
+}
+function validateRemediationAccounting(loop, cycleList) {
+  const errors = [];
+  const outcomes = loop[REVIEW_OUTCOMES_KEY];
+  let appliedCount = 0;
+  (cycleList ?? []).forEach((cycle, index) => {
+    if (!isObject12(cycle)) {
+      return;
+    }
+    const prefix = `Checkpoint remediation cycle #${index}`;
+    if (hasKey(cycle, CANDIDATE_APPLIED_KEY)) {
+      const candidateApplied = cycle[CANDIDATE_APPLIED_KEY];
+      if (typeof candidateApplied !== "boolean") {
+        errors.push(`${prefix} candidate_applied must be a boolean.`);
+      } else if (candidateApplied) {
+        appliedCount += 1;
+        if (cycle["execution_status"] !== COMPLETED_EXECUTION_STATUS) {
+          errors.push(
+            `${prefix} candidate_applied is true but execution_status is not 'complete'.`
+          );
+        }
+      }
+    }
+    if (hasKey(cycle, OPENED_BY_REVIEW_KEY) && !opensRemediationReview(cycle[OPENED_BY_REVIEW_KEY], outcomes)) {
+      errors.push(
+        `${prefix} opened_by_review must reference a review outcome whose verdict is REMEDIATION_REQUIRED.`
+      );
+    }
+  });
+  if (hasKey(loop, COMPLETED_ATTEMPTS_KEY)) {
+    const completedAttempts = loop[COMPLETED_ATTEMPTS_KEY];
+    if (!isStrictInteger(completedAttempts) || completedAttempts < 0) {
+      errors.push(
+        "Checkpoint remediation_loop completed_attempts must be a non-negative integer."
+      );
+    } else if (completedAttempts !== appliedCount) {
+      errors.push(
+        `Checkpoint remediation_loop completed_attempts is ${completedAttempts} but ${appliedCount} cycles have candidate_applied true.`
+      );
+    }
+  }
+  return errors;
+}
 function validateRemediationLoop(remediationLoop) {
   const errors = [];
-  if (!isObject11(remediationLoop)) {
+  if (!isObject12(remediationLoop)) {
     return errors;
   }
   const cycles = remediationLoop[REMEDIATION_CYCLES_KEY];
-  if (!Array.isArray(cycles)) {
-    return errors;
+  let cycleList = null;
+  if (Array.isArray(cycles)) {
+    cycleList = cycles;
+    cycles.forEach((cycle, index) => {
+      if (!isObject12(cycle)) {
+        errors.push(
+          `Checkpoint remediation cycle #${index} must be an object.`
+        );
+        return;
+      }
+      errors.push(...validateRemediationCycle(index, cycle));
+    });
   }
-  cycles.forEach((cycle, index) => {
-    if (!isObject11(cycle)) {
-      errors.push(`Checkpoint remediation cycle #${index} must be an object.`);
-      return;
-    }
-    errors.push(...validateRemediationCycle(index, cycle));
-  });
+  errors.push(...validateReviewOutcomes(remediationLoop));
+  errors.push(...validateRemediationAccounting(remediationLoop, cycleList));
   return errors;
 }
 
@@ -27623,7 +28022,7 @@ var OUT_OF_SCOPE_STEP_KEYS = [
   "step9_status",
   "step10_status"
 ];
-function pythonRepr8(value) {
+function pythonRepr9(value) {
   if (value === void 0 || value === null) {
     return "None";
   }
@@ -27638,11 +28037,11 @@ function pythonRepr8(value) {
     return String(value);
   }
   if (Array.isArray(value)) {
-    return `[${value.map(pythonRepr8).join(", ")}]`;
+    return `[${value.map(pythonRepr9).join(", ")}]`;
   }
   if (typeof value === "object") {
     const entries = Object.entries(value).map(
-      ([key, item]) => `${pythonRepr8(key)}: ${pythonRepr8(item)}`
+      ([key, item]) => `${pythonRepr9(key)}: ${pythonRepr9(item)}`
     );
     return `{${entries.join(", ")}}`;
   }
@@ -27656,13 +28055,13 @@ function validatePreparationTerminalContract(state) {
   const errors = [];
   if (state["next_step"] !== EXPECTED_NEXT_STEP) {
     errors.push(
-      `Preparation checkpoint next_step must be ${pythonRepr8(EXPECTED_NEXT_STEP)}, found ${pythonRepr8(state["next_step"])}.`
+      `Preparation checkpoint next_step must be ${pythonRepr9(EXPECTED_NEXT_STEP)}, found ${pythonRepr9(state["next_step"])}.`
     );
   }
   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])}.`
+        `Preparation checkpoint ${key} must be 'not-applicable', found ${pythonRepr9(state[key])}.`
       );
     }
   }
@@ -27678,18 +28077,18 @@ var DELEGATING_AGENTS = /* @__PURE__ */ new Set([
   "prd-feature",
   "pr-author"
 ]);
-function isObject12(value) {
+function isObject13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function delegatedAgents(state) {
   const agents = /* @__PURE__ */ new Set();
   let receipts = state["delegation_receipts"];
-  if (isObject12(receipts)) {
+  if (isObject13(receipts)) {
     receipts = receipts["agents"];
   }
   if (Array.isArray(receipts)) {
     for (const receipt of receipts) {
-      if (!isObject12(receipt)) {
+      if (!isObject13(receipt)) {
         continue;
       }
       const agentName = receipt["agent_name"];
@@ -27713,7 +28112,7 @@ function validateModelRoutingExistence(state) {
   const receipts = state["model_routing_receipts"];
   if (Array.isArray(receipts)) {
     for (const receipt of receipts) {
-      if (!isObject12(receipt)) {
+      if (!isObject13(receipt)) {
         continue;
       }
       const agent = receipt["agent"];
@@ -27762,15 +28161,6 @@ var VALID_STEP_STATUS = /* @__PURE__ */ new Set([
   "in_progress",
   "completed"
 ]);
-var VALID_BLOCKED_REASONS = /* @__PURE__ */ new Set([
-  "none",
-  "spawn_agent_unavailable",
-  "delegation_launch_failed",
-  "delegate_no_receipt",
-  "delegate_contract_incomplete",
-  "validator_failed",
-  "user_requested_stop"
-]);
 var REQUIRED_RECEIPT_KEYS = [
   "step",
   "agent_name",
@@ -27810,13 +28200,13 @@ function isValidStepStatus(key, value) {
   }
   return STEP_SPECIFIC_EXTRA_STATUS.get(key)?.has(value) === true;
 }
-function isObject13(value) {
+function isObject14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function validateListDelegationReceipts(receipts) {
   const errors = [];
   receipts.forEach((receipt, index) => {
-    if (!isObject13(receipt)) {
+    if (!isObject14(receipt)) {
       errors.push(`Checkpoint delegation receipt #${index} must be an object.`);
       return;
     }
@@ -27858,7 +28248,7 @@ function validateNamespacedDelegationReceipts(receipts) {
   if (promotionReceipts === void 0 || promotionReceipts === null) {
     return errors;
   }
-  if (!isObject13(promotionReceipts)) {
+  if (!isObject14(promotionReceipts)) {
     errors.push(
       "Checkpoint delegation_receipts.promotion must be an object namespace."
     );
@@ -27893,7 +28283,7 @@ function validateOrchestratorStateText(text2, options = {}) {
       `Checkpoint is not valid JSON: ${exc instanceof Error ? exc.message : String(exc)}`
     ];
   }
-  if (!isObject13(state)) {
+  if (!isObject14(state)) {
     return ["Checkpoint root must be a JSON object."];
   }
   const stateMap = state;
@@ -27918,7 +28308,7 @@ function validateOrchestratorStateText(text2, options = {}) {
   if (receipts !== void 0 && receipts !== null) {
     if (Array.isArray(receipts)) {
       errors.push(...validateListDelegationReceipts(receipts));
-    } else if (isObject13(receipts)) {
+    } else if (isObject14(receipts)) {
       errors.push(...validateNamespacedDelegationReceipts(receipts));
     } else {
       errors.push(
@@ -28955,10 +29345,10 @@ var PROHIBITED_ANY_LEVEL_KEYS = words(
   "depends_on integration_branch epic_merge_pr"
 );
 var ROOT_PATH = "<root>";
-function isObject14(value) {
+function isObject15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function pythonRepr9(value) {
+function pythonRepr10(value) {
   if (value === null || value === void 0) {
     return "None";
   }
@@ -28969,18 +29359,18 @@ function pythonRepr9(value) {
     return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
   }
   if (Array.isArray(value)) {
-    return `[${value.map(pythonRepr9).join(", ")}]`;
+    return `[${value.map(pythonRepr10).join(", ")}]`;
   }
-  if (isObject14(value)) {
+  if (isObject15(value)) {
     const pairs = Object.entries(value).map(
-      ([key, item]) => `${pythonRepr9(key)}: ${pythonRepr9(item)}`
+      ([key, item]) => `${pythonRepr10(key)}: ${pythonRepr10(item)}`
     );
     return `{${pairs.join(", ")}}`;
   }
   return String(value);
 }
 function pythonStr2(value) {
-  return typeof value === "string" ? value : pythonRepr9(value);
+  return typeof value === "string" ? value : pythonRepr10(value);
 }
 function isEnumMember(members, value) {
   return typeof value === "string" && members.includes(value);
@@ -29004,13 +29394,13 @@ 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)}.`;
+  return `${context} ${field} must be one of ${members.join(", ")}; found: ${pythonRepr10(value)}.`;
 }
 function itemContext(context, index) {
   return `${context} items[${index}]`;
 }
 function validateBlastRadiusBlock(radius, context) {
-  if (!isObject14(radius)) {
+  if (!isObject15(radius)) {
     return [`${context} blast_radius must be an object.`];
   }
   const errors = [];
@@ -29046,25 +29436,25 @@ function validateMergeStatus(record3, context, state) {
   }
   if (isEnumMember(MERGED_MERGE_STATUSES, mergeStatus) && state !== "merged") {
     return [
-      `${context} merge_status ${pythonRepr9(mergeStatus)} requires state 'merged'; found: ${pythonRepr9(state)}.`
+      `${context} merge_status ${pythonRepr10(mergeStatus)} requires state 'merged'; found: ${pythonRepr10(state)}.`
     ];
   }
   if (isEnumMember(BLOCKED_MERGE_STATUSES, mergeStatus) && state !== "blocked") {
     return [
-      `${context} merge_status ${pythonRepr9(mergeStatus)} requires state 'blocked'; found: ${pythonRepr9(state)}.`
+      `${context} merge_status ${pythonRepr10(mergeStatus)} requires state 'blocked'; found: ${pythonRepr10(state)}.`
     ];
   }
   return [];
 }
 function validateItemRecord(item, context, requireKind = false) {
-  if (!isObject14(item)) {
+  if (!isObject15(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)}.`
+      `${context} issue_num must be a positive integer; found: ${pythonRepr10(issueNum)}.`
     );
   }
   if (!isNonEmptyString2(item["feature_folder"])) {
@@ -29095,7 +29485,7 @@ function validateItems(items, context, requireKind = false) {
     errors.push(
       ...validateItemRecord(entry, itemContext(context, index), requireKind)
     );
-    if (!isObject14(entry)) {
+    if (!isObject15(entry)) {
       return;
     }
     const issueNum = entry["issue_num"];
@@ -29114,7 +29504,7 @@ function validateItems(items, context, requireKind = false) {
 }
 function prohibitedKeyErrors(value, path16, context, keys) {
   const errors = [];
-  if (isObject14(value)) {
+  if (isObject15(value)) {
     for (const [key, child] of Object.entries(value)) {
       if (keys.includes(key)) {
         errors.push(`${context} carries prohibited key '${key}' at ${path16}.`);
@@ -29133,7 +29523,7 @@ function prohibitedKeyErrors(value, path16, context, keys) {
 }
 function scanProhibitedKeys(root, context, deepKeys = PROHIBITED_ANY_LEVEL_KEYS, topLevelKeys = []) {
   const errors = prohibitedKeyErrors(root, ROOT_PATH, context, deepKeys);
-  if (isObject14(root) && topLevelKeys.length > 0) {
+  if (isObject15(root) && topLevelKeys.length > 0) {
     for (const key of topLevelKeys) {
       if (key in root) {
         errors.push(
@@ -29149,7 +29539,7 @@ function scanProhibitedKeys(root, context, deepKeys = PROHIBITED_ANY_LEVEL_KEYS,
 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 NOT_STARTED_MERGE_STATUS2 = "not_started";
 var GATING_KEYS = ["conflict_edges", "cohorts"];
 var FOLDER_HINT_PREFIXES = [
   "docs/features/active/",
@@ -29172,7 +29562,7 @@ function buildReferenceIndex(items) {
     return { records, byFolderHint };
   }
   for (const entry of items) {
-    if (!isObject14(entry)) {
+    if (!isObject15(entry)) {
       continue;
     }
     const issueNum = entry["issue_num"];
@@ -29207,7 +29597,7 @@ function cohortIndexByItem(cohorts, recolorGeneration, references) {
     return assignments;
   }
   for (const entry of cohorts) {
-    if (!isObject14(entry) || entry["generation"] !== recolorGeneration) {
+    if (!isObject15(entry) || entry["generation"] !== recolorGeneration) {
       continue;
     }
     const cohortIndex = entry["index"];
@@ -29224,13 +29614,13 @@ function cohortIndexByItem(cohorts, recolorGeneration, references) {
   }
   return assignments;
 }
-function hasStarted(record3) {
+function hasStarted2(record3) {
   const start = record3[ITEM_START_TIMESTAMP_FIELD];
   if (typeof start === "string" && start.trim().length > 0) {
     return true;
   }
   const mergeStatus = record3["merge_status"];
-  return typeof mergeStatus === "string" && mergeStatus !== NOT_STARTED_MERGE_STATUS;
+  return typeof mergeStatus === "string" && mergeStatus !== NOT_STARTED_MERGE_STATUS2;
 }
 function satisfiesBarrier(record3) {
   return isEnumMember(MERGED_MERGE_STATUSES, record3["merge_status"]);
@@ -29258,7 +29648,7 @@ function violationEndpoints(first, second, assignments, records) {
   if (earlier === void 0 || later === void 0) {
     return null;
   }
-  const statusViolation = hasStarted(later) && !satisfiesBarrier(earlier);
+  const statusViolation = hasStarted2(later) && !satisfiesBarrier(earlier);
   if (statusViolation || mergeConfirmedAfterStart(earlier, later)) {
     return [earlierKey, laterKey];
   }
@@ -29280,7 +29670,7 @@ function validateCohortBarrierOrdering(state) {
   );
   const errors = [];
   for (const entry of edges) {
-    if (!isObject14(entry)) {
+    if (!isObject15(entry)) {
       continue;
     }
     const first = resolveReference(entry["a"], references);
@@ -29318,14 +29708,14 @@ function validateMutationItemKey(entry, entryContext, op, issueNums) {
   if (op === "close") {
     if (!isNone(itemKey)) {
       return [
-        `${entryContext} item_key must be null for op 'close'; found: ${pythonRepr9(itemKey)}.`
+        `${entryContext} item_key must be null for op 'close'; found: ${pythonRepr10(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.`
+      `${entryContext} item_key ${pythonRepr10(itemKey)} does not resolve to an items[].issue_num.`
     ];
   }
   return [];
@@ -29337,12 +29727,12 @@ function validateMutationStateField(entry, entryContext, field, op, nullOps) {
   }
   if (isEnumMember(nullOps, op)) {
     return [
-      `${entryContext} ${field} must be null for op ${pythonRepr9(op)}; found: ${pythonRepr9(value)}.`
+      `${entryContext} ${field} must be null for op ${pythonRepr10(op)}; found: ${pythonRepr10(value)}.`
     ];
   }
   if (!isEnumMember(VALID_ITEM_STATES, value)) {
     return [
-      `${entryContext} ${field} must be null or one of ${VALID_ITEM_STATES.join(", ")}; found: ${pythonRepr9(value)}.`
+      `${entryContext} ${field} must be null or one of ${VALID_ITEM_STATES.join(", ")}; found: ${pythonRepr10(value)}.`
     ];
   }
   return [];
@@ -29352,14 +29742,14 @@ function validateMutationDisposition(entry, entryContext, op) {
   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)}.`
+        `${entryContext} disposition must be one of ${VALID_DISPOSITIONS.join(", ")} for an in-flight removal; found: ${pythonRepr10(disposition)}.`
       ];
     }
     return [];
   }
   if (!isNone(disposition)) {
     return [
-      `${entryContext} disposition must be null unless op is 'remove' with prior_state 'in_flight'; found: ${pythonRepr9(disposition)}.`
+      `${entryContext} disposition must be null unless op is 'remove' with prior_state 'in_flight'; found: ${pythonRepr10(disposition)}.`
     ];
   }
   return [];
@@ -29368,7 +29758,7 @@ 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)}.`
+      `${entryContext} recolor_generation must be a non-negative integer; found: ${pythonRepr10(generation)}.`
     ];
   }
   if (isNonNegativeInteger(recolorGeneration) && typeof generation === "number" && typeof recolorGeneration === "number" && generation > recolorGeneration) {
@@ -29385,7 +29775,7 @@ function validateMutations(mutations, issueNums, recolorGeneration, context) {
   const errors = [];
   mutations.forEach((entry, position) => {
     const entryContext = `${context} mutations[${position}]`;
-    if (!isObject14(entry)) {
+    if (!isObject15(entry)) {
       errors.push(`${entryContext} must be an object.`);
       return;
     }
@@ -29429,14 +29819,14 @@ function validateDriftEvents(events, issueNums, context) {
   const errors = [];
   events.forEach((entry, position) => {
     const entryContext = `${context} drift_events[${position}]`;
-    if (!isObject14(entry)) {
+    if (!isObject15(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.`
+        `${entryContext} item_key ${pythonRepr10(itemKey)} does not resolve to an items[].issue_num.`
       );
     }
     for (const field of ["declared", "observed"]) {
@@ -29474,7 +29864,7 @@ function collectItemKeysAndStates(items) {
     return pairs;
   }
   for (const entry of items) {
-    if (!isObject14(entry)) {
+    if (!isObject15(entry)) {
       continue;
     }
     const issueNum = entry["issue_num"];
@@ -29492,13 +29882,13 @@ function validateCohortEntry(entry, entryContext, issueNums, recolorGeneration)
   const index = entry["index"];
   if (!isNonNegativeInteger(index)) {
     errors.push(
-      `${entryContext} index must be a non-negative integer; found: ${pythonRepr9(index)}.`
+      `${entryContext} index must be a non-negative integer; found: ${pythonRepr10(index)}.`
     );
   }
   const generation = entry["generation"];
   if (!isNonNegativeInteger(generation)) {
     errors.push(
-      `${entryContext} generation must be a non-negative integer; found: ${pythonRepr9(generation)}.`
+      `${entryContext} generation must be a non-negative integer; found: ${pythonRepr10(generation)}.`
     );
   } else if (recolorGeneration !== null && typeof generation === "number" && generation > recolorGeneration) {
     errors.push(
@@ -29513,7 +29903,7 @@ function validateCohortEntry(entry, entryContext, issueNums, recolorGeneration)
   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.`
+        `${entryContext} item_keys entry ${pythonRepr10(key)} does not resolve to an items[].issue_num.`
       );
     }
   }
@@ -29524,7 +29914,7 @@ function validateCohortShapes(cohorts, issueNums, recolorGeneration, context) {
   const generationOk = isNonNegativeInteger(recolorGeneration);
   if (!generationOk) {
     errors.push(
-      `${context} recolor_generation must be a non-negative integer; found: ${pythonRepr9(recolorGeneration)}.`
+      `${context} recolor_generation must be a non-negative integer; found: ${pythonRepr10(recolorGeneration)}.`
     );
   }
   if (!Array.isArray(cohorts)) {
@@ -29534,7 +29924,7 @@ function validateCohortShapes(cohorts, issueNums, recolorGeneration, context) {
   const bound = generationOk && typeof recolorGeneration === "number" ? recolorGeneration : null;
   cohorts.forEach((entry, position) => {
     const entryContext = `${context} cohorts[${position}]`;
-    if (!isObject14(entry)) {
+    if (!isObject15(entry)) {
       errors.push(`${entryContext} must be an object.`);
       return;
     }
@@ -29546,7 +29936,7 @@ function currentGenerationCohorts(cohorts, recolorGeneration) {
   if (!isNonNegativeInteger(recolorGeneration) || !Array.isArray(cohorts)) {
     return [];
   }
-  return cohorts.filter(isObject14).filter((entry) => entry["generation"] === recolorGeneration);
+  return cohorts.filter(isObject15).filter((entry) => entry["generation"] === recolorGeneration);
 }
 function validateCurrentGenerationCohorts(cohorts, items, recolorGeneration, context) {
   const current = currentGenerationCohorts(cohorts, recolorGeneration);
@@ -29591,7 +29981,7 @@ function validateCurrentGenerationCohorts(cohorts, items, recolorGeneration, con
       continue;
     }
     errors.push(
-      `${context} item ${issueNum} in state ${pythonRepr9(state)} must appear in exactly one current-generation cohort; found ${count}.`
+      `${context} item ${issueNum} in state ${pythonRepr10(state)} must appear in exactly one current-generation cohort; found ${count}.`
     );
   }
   return errors;
@@ -29599,7 +29989,7 @@ function validateCurrentGenerationCohorts(cohorts, items, recolorGeneration, con
 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)}.`
+      `${context} current_cohort must be a non-negative integer; found: ${pythonRepr10(currentCohort)}.`
     ];
   }
   const indices = [];
@@ -29629,7 +30019,7 @@ function validateEdgeEndpoints(entry, entryContext, issueNums) {
       endpoints.set(field, value);
     } else {
       errors.push(
-        `${entryContext} ${field} ${pythonRepr9(value)} does not resolve to an items[].issue_num.`
+        `${entryContext} ${field} ${pythonRepr10(value)} does not resolve to an items[].issue_num.`
       );
     }
   }
@@ -29659,7 +30049,7 @@ function validateConflictEdges(edges, issueNums, context) {
   const duplicates = /* @__PURE__ */ new Map();
   edges.forEach((entry, position) => {
     const entryContext = `${context} conflict_edges[${position}]`;
-    if (!isObject14(entry)) {
+    if (!isObject15(entry)) {
       errors.push(`${entryContext} must be an object.`);
       return;
     }
@@ -29738,7 +30128,7 @@ function validateIdentity(state) {
   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)}.`
+      `${CONTEXT} route_id must be '${EXPECTED_ROUTE_ID2}'; found: ${pythonRepr10(routeId)}.`
     );
   }
   const mode = state["mode"];
@@ -29748,7 +30138,7 @@ function validateIdentity(state) {
   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)}.`
+      `${CONTEXT} max_concurrency must be an integer from ${MIN_CONCURRENCY} through ${MAX_CONCURRENCY}; found: ${pythonRepr10(concurrency)}.`
     );
   }
   return errors;
@@ -29804,7 +30194,7 @@ function recordsCloseMutation(state) {
     return false;
   }
   return mutations.some(
-    (entry) => isObject14(entry) && entry["op"] === "close"
+    (entry) => isObject15(entry) && entry["op"] === "close"
   );
 }
 function validateCompletion2(state) {
@@ -29812,7 +30202,7 @@ function validateCompletion2(state) {
   const items = state["items"];
   const entries = Array.isArray(items) ? items : [];
   entries.forEach((entry, index) => {
-    if (!isObject14(entry)) {
+    if (!isObject15(entry)) {
       return;
     }
     if (entry["state"] === "withdrawn") {
@@ -29821,7 +30211,7 @@ function validateCompletion2(state) {
     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)}.`
+        `${itemContext(CONTEXT, index)} completion validation failed: merge_status is not merged or worktree_removed; found: ${pythonRepr10(mergeStatus)}.`
       );
     }
   });
@@ -29840,7 +30230,7 @@ function validateParallelOrchestratorStateText(text2, options = {}) {
     const detail = error2 instanceof Error ? error2.message : String(error2);
     return [`${CONTEXT} is not valid JSON: ${detail}.`];
   }
-  if (!isObject14(state)) {
+  if (!isObject15(state)) {
     return [`${CONTEXT} root must be a JSON object.`];
   }
   const errors = [];
@@ -29918,7 +30308,7 @@ function validateIdentity2(state) {
   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)}.`
+      `${CONTEXT2} max_concurrency must be an integer from ${MIN_CONCURRENCY2} through ${MAX_CONCURRENCY2}; found: ${pythonRepr10(concurrency)}.`
     );
   }
   return errors;
@@ -29929,7 +30319,7 @@ function itemRecords(items) {
   }
   const records = [];
   items.forEach((entry, index) => {
-    if (isObject14(entry)) {
+    if (isObject15(entry)) {
       records.push({ index, record: entry });
     }
   });
@@ -29998,13 +30388,13 @@ function validateReadyItem(record3, entryContext) {
   const preparationStatus = record3["preparation_status"];
   if (preparationStatus !== READY_PREPARATION_STATUS) {
     errors.push(
-      `${entryContext} preparation_status must be ${pythonRepr9(READY_PREPARATION_STATUS)}; found: ${pythonRepr9(preparationStatus)}.`
+      `${entryContext} preparation_status must be ${pythonRepr10(READY_PREPARATION_STATUS)}; found: ${pythonRepr10(preparationStatus)}.`
     );
   }
   const preflightStatus = record3["preflight_status"];
   if (preflightStatus !== READY_PREFLIGHT_STATUS) {
     errors.push(
-      `${entryContext} preflight_status must be ${pythonRepr9(READY_PREFLIGHT_STATUS)}; found: ${pythonRepr9(preflightStatus)}.`
+      `${entryContext} preflight_status must be ${pythonRepr10(READY_PREFLIGHT_STATUS)}; found: ${pythonRepr10(preflightStatus)}.`
     );
   }
   for (const key of READY_ITEM_PATH_KEYS) {
@@ -30013,10 +30403,10 @@ function validateReadyItem(record3, entryContext) {
     }
   }
   const radius = record3["blast_radius"];
-  const source = isObject14(radius) ? radius["source"] : null;
+  const source = isObject15(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)}.`
+      `${entryContext} blast_radius.source must be ${pythonRepr10(READY_RADIUS_SOURCE)} for execution readiness; found: ${pythonRepr10(source)}.`
     );
   }
   return errors;
@@ -30038,14 +30428,14 @@ function validateReadyGate(state) {
   const nextStep = state["next_step"];
   if (nextStep !== READY_NEXT_STEP2) {
     errors.push(
-      `${CONTEXT2} next_step must be ${pythonRepr9(READY_NEXT_STEP2)}; found: ${pythonRepr9(nextStep)}.`
+      `${CONTEXT2} next_step must be ${pythonRepr10(READY_NEXT_STEP2)}; found: ${pythonRepr10(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)}.`
+      `${CONTEXT2} kickoff_prompt_path must be ${pythonRepr10(expectedKickoff)}; found: ${pythonRepr10(kickoffPromptPath)}.`
     );
   }
   return errors;
@@ -30058,7 +30448,7 @@ function validateParallelPlannerStateText(text2, options = {}) {
     const detail = error2 instanceof Error ? error2.message : String(error2);
     return [`${CONTEXT2} is not valid JSON: ${detail}.`];
   }
-  if (!isObject14(state)) {
+  if (!isObject15(state)) {
     return [`${CONTEXT2} root must be a JSON object.`];
   }
   const errors = [];
@@ -35873,6 +36263,10 @@ function promotePotential(options) {
   filesystem.ensureDir(promotedDir);
   const destPath = posixJoin(promotedDir, posixBasename(resolved));
   filesystem.move(resolved, destPath);
+  if (!filesystem.exists(destPath)) {
+    emitLine(`Promoted file missing after move: ${destPath}`);
+    return { exitCode: 1, messages };
+  }
   emitLine(`Moved potential file to promoted folder: ${destPath}`);
   return { exitCode: 0, messages, destination: destPath };
 }