@danmoisan/drm-copilot-mcp 1.1.16 → 1.1.18

package/out/mcp-server.js

@@ -1146,9 +1146,9 @@ var require_util = __commonJS({
       }
     }
     exports2.eachItem = eachItem;
-    function makeMergeEvaluated({ mergeNames, mergeToName, mergeValues: mergeValues2, resultToName }) {
+    function makeMergeEvaluated({ mergeNames, mergeToName, mergeValues: mergeValues3, resultToName }) {
       return (gen, from, to, toName) => {
-        const res = to === void 0 ? from : to instanceof codegen_1.Name ? (from instanceof codegen_1.Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to) : from instanceof codegen_1.Name ? (mergeToName(gen, to, from), from) : mergeValues2(from, to);
+        const res = to === void 0 ? from : to instanceof codegen_1.Name ? (from instanceof codegen_1.Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to) : from instanceof codegen_1.Name ? (mergeToName(gen, to, from), from) : mergeValues3(from, to);
         return toName === codegen_1.Name && !(res instanceof codegen_1.Name) ? resultToName(gen, res) : res;
       };
     }
@@ -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",
@@ -19984,6 +19985,237 @@ var BlastRadiusDeriveFileSystem = class {
   }
 };
 
+// ../../extensions/drm-copilot/src/lib/push-down/claude-blast-radius-overlay.ts
+var BLAST_RADIUS_OVERLAY_RELATIVE_PATH = "config/blast-radius.local.json";
+var STRING_LIST_KEYS = /* @__PURE__ */ new Set([
+  "shared_surfaces",
+  "shared_surface_globs",
+  "mandate_reads",
+  "mergeable_paths",
+  "path_roots"
+]);
+var MODULES_KEY = "modules";
+var VERSION_KEY = "version";
+var BlastRadiusOverlayError = class extends Error {
+  /** Relative path of the document that could not be composed. */
+  path;
+  /**
+   * @param path Relative path of the offending document.
+   * @param detail Reason appended to the message.
+   */
+  constructor(path16, detail) {
+    super(
+      `Blast-radius overlay ${path16} was not applied; ${BLAST_RADIUS_RELATIVE_PATH} was not written: ${detail}`
+    );
+    this.name = "BlastRadiusOverlayError";
+    this.path = path16;
+  }
+};
+function isJsonObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isStringList(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function parseObject(text2, path16) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text2);
+  } catch (error2) {
+    const detail = error2 instanceof Error ? error2.message : String(error2);
+    throw new BlastRadiusOverlayError(path16, `not valid JSON (${detail})`);
+  }
+  if (!isJsonObject(parsed)) {
+    throw new BlastRadiusOverlayError(
+      path16,
+      "document root is not a JSON object"
+    );
+  }
+  return parsed;
+}
+function unionStrings(base, overlay) {
+  const composed = [...base];
+  const seen = new Set(base.filter((item) => typeof item === "string"));
+  for (const item of overlay) {
+    if (!seen.has(item)) {
+      seen.add(item);
+      composed.push(item);
+    }
+  }
+  return composed;
+}
+function composeStringList(key, base, overlay, overlayPath) {
+  if (!isStringList(overlay)) {
+    throw new BlastRadiusOverlayError(
+      overlayPath,
+      `key "${key}" must be a list of strings`
+    );
+  }
+  return unionStrings(Array.isArray(base) ? base : [], overlay);
+}
+function composeModules(base, overlay, overlayPath) {
+  if (!isJsonObject(overlay) || !Object.values(overlay).every((globs) => isStringList(globs))) {
+    throw new BlastRadiusOverlayError(
+      overlayPath,
+      `key "${MODULES_KEY}" must map module names to lists of strings`
+    );
+  }
+  const merged = { ...isJsonObject(base) ? base : {} };
+  for (const [name, globs] of Object.entries(overlay)) {
+    merged[name] = globs;
+  }
+  const composed = {};
+  for (const name of Object.keys(merged).sort(compareOrdinal)) {
+    const globs = merged[name] ?? [];
+    composed[name] = globs;
+    for (const glob of Array.isArray(globs) ? globs : []) {
+      if (typeof glob === "string" && FORBIDDEN_GLOBS.includes(glob)) {
+        throw new BlastRadiusGuardError(name, glob);
+      }
+    }
+  }
+  return composed;
+}
+function mergeValues2(base, overlay, dottedKey, overlayPath) {
+  if (isJsonObject(base) && isJsonObject(overlay)) {
+    const merged = {};
+    for (const [key, value] of Object.entries(base)) {
+      const overlayValue = overlay[key];
+      merged[key] = overlayValue === void 0 ? value : mergeValues2(
+        value,
+        overlayValue,
+        `${dottedKey}.${key}`,
+        overlayPath
+      );
+    }
+    for (const [key, value] of Object.entries(overlay)) {
+      if (!(key in merged)) {
+        merged[key] = value;
+      }
+    }
+    return merged;
+  }
+  if (Array.isArray(base) && Array.isArray(overlay)) {
+    if (!isStringList(overlay)) {
+      throw new BlastRadiusOverlayError(
+        overlayPath,
+        `key "${dottedKey}" must be a list of strings`
+      );
+    }
+    return unionStrings(base, overlay);
+  }
+  return overlay;
+}
+function composeKey(key, base, overlay, overlayPath) {
+  if (STRING_LIST_KEYS.has(key)) {
+    return composeStringList(key, base, overlay, overlayPath);
+  }
+  if (key === MODULES_KEY) {
+    return composeModules(base, overlay, overlayPath);
+  }
+  return base === void 0 ? overlay : mergeValues2(base, overlay, key, overlayPath);
+}
+function composeBlastRadiusOverlay(baseText, overlayText, overlayPath) {
+  if (overlayText === null) {
+    return baseText;
+  }
+  const overlay = parseObject(overlayText, overlayPath);
+  const base = parseObject(baseText, BLAST_RADIUS_RELATIVE_PATH);
+  if (VERSION_KEY in overlay && overlay[VERSION_KEY] !== base[VERSION_KEY]) {
+    throw new BlastRadiusOverlayError(
+      overlayPath,
+      `key "${VERSION_KEY}" does not match the base version`
+    );
+  }
+  const composed = {};
+  for (const [key, value] of Object.entries(base)) {
+    const overlayValue = overlay[key];
+    composed[key] = key === VERSION_KEY || overlayValue === void 0 ? value : composeKey(key, value, overlayValue, overlayPath);
+  }
+  for (const [key, value] of Object.entries(overlay)) {
+    if (!(key in composed)) {
+      composed[key] = composeKey(key, void 0, value, overlayPath);
+    }
+  }
+  return `${JSON.stringify(composed, null, 2)}
+`;
+}
+function normalizePosix6(value) {
+  return value.replace(/\\/g, "/").replace(/\/+$/, "");
+}
+function relativeToPosix6(path16, root) {
+  const normalizedPath = normalizePosix6(path16);
+  const normalizedRoot = normalizePosix6(root);
+  if (normalizedPath === normalizedRoot) {
+    return "";
+  }
+  const prefix = `${normalizedRoot}/`;
+  return normalizedPath.startsWith(prefix) ? normalizedPath.slice(prefix.length) : null;
+}
+var BlastRadiusOverlayFileSystem = class {
+  inner;
+  destinationRoot;
+  overlayRelativePath;
+  targetRelativePath;
+  /**
+   * @param inner The wrapped adapter performing real I/O.
+   * @param destinationRoot Destination workspace root (POSIX path).
+   * @param overlayRelativePath Destination-relative overlay path.
+   * @param targetRelativePath Destination-relative path the overlay composes
+   *   onto.
+   */
+  constructor(inner, destinationRoot, overlayRelativePath = BLAST_RADIUS_OVERLAY_RELATIVE_PATH, targetRelativePath = BLAST_RADIUS_RELATIVE_PATH) {
+    this.inner = inner;
+    this.destinationRoot = normalizePosix6(destinationRoot);
+    this.overlayRelativePath = overlayRelativePath;
+    this.targetRelativePath = targetRelativePath;
+  }
+  /** @inheritdoc */
+  listFiles(root) {
+    return this.inner.listFiles(root);
+  }
+  /** @inheritdoc */
+  isDir(path16) {
+    return this.inner.isDir(path16);
+  }
+  /** @inheritdoc */
+  isFile(path16) {
+    return this.inner.isFile(path16);
+  }
+  /** @inheritdoc */
+  readTextFile(path16) {
+    return this.inner.readTextFile(path16);
+  }
+  /** @inheritdoc */
+  ensureDir(path16) {
+    this.inner.ensureDir(path16);
+  }
+  /**
+   * Write a file, composing the destination overlay onto the target path.
+   *
+   * @param path Absolute destination POSIX path.
+   * @param content Content the layers above want to publish.
+   * @throws BlastRadiusOverlayError When the overlay cannot be composed; the
+   *   destination target keeps its prior bytes.
+   * @throws BlastRadiusGuardError When a composed module carries a forbidden
+   *   glob; the destination target keeps its prior bytes.
+   */
+  writeTextFile(path16, content) {
+    if (relativeToPosix6(path16, this.destinationRoot) !== this.targetRelativePath) {
+      this.inner.writeTextFile(path16, content);
+      return;
+    }
+    const overlayPath = `${this.destinationRoot}/${this.overlayRelativePath}`;
+    const overlayText = this.inner.isFile(overlayPath) ? this.inner.readTextFile(overlayPath) : null;
+    const composed = composeBlastRadiusOverlay(
+      content,
+      overlayText,
+      this.overlayRelativePath
+    );
+    this.inner.writeTextFile(path16, composed);
+  }
+};
+
 // ../../extensions/drm-copilot/src/lib/push-down/claude-gitignore-merge.ts
 var CLAUDE_GITIGNORE_RELATIVE_PATH = ".gitignore";
 var CLAUDE_GITIGNORE_BEGIN_SENTINEL = "# BEGIN drm-copilot managed ignores";
@@ -20043,12 +20275,363 @@ function toDocument(lines) {
   return `${lines.join(LINE_SEPARATOR)}${LINE_SEPARATOR}`;
 }
 
+// ../../extensions/drm-copilot/src/lib/push-down/claude-exclusion-manifest.ts
+var EXCLUSION_MANIFEST_RELATIVE_PATH = ".push-down-exclusions";
+var ExclusionManifestError = class extends Error {
+  /** Destination-relative manifest path. */
+  path;
+  /** 1-based offending line, or `undefined` when the whole file is at fault. */
+  line;
+  /**
+   * @param path Destination-relative manifest path.
+   * @param line Offending line, or `undefined` for a whole-file condition.
+   * @param reason Human-readable reason.
+   */
+  constructor(path16, line, reason) {
+    const location = line === void 0 ? path16 : `${path16} line ${String(line)}`;
+    super(`Malformed push-down exclusion manifest ${location}: ${reason}`);
+    this.name = "ExclusionManifestError";
+    this.path = path16;
+    this.line = line;
+  }
+};
+var BYTE_ORDER_MARK = "\uFEFF";
+var REPLACEMENT_CHARACTER = "\uFFFD";
+var LINE_SPLIT = /\r?\n/;
+var REPEATED_SLASH = /\/{2,}/g;
+var DRIVE_PREFIX = /^[A-Za-z]:/;
+function hasWildcard(normalized) {
+  return normalized.includes("*") || normalized.includes("?");
+}
+function escapeRegexCharacter(character) {
+  return /[\\^$.*+?()[\]{}|/-]/.test(character) ? `\\${character}` : character;
+}
+function globToRegexText(pattern) {
+  const parts = [];
+  let index = 0;
+  while (index < pattern.length) {
+    if (pattern.startsWith("**", index)) {
+      parts.push(".*");
+      index += 2;
+      continue;
+    }
+    const character = pattern.charAt(index);
+    if (character === "*") {
+      parts.push("[^/]*");
+    } else if (character === "?") {
+      parts.push("[^/]");
+    } else {
+      parts.push(escapeRegexCharacter(character));
+    }
+    index += 1;
+  }
+  return parts.join("");
+}
+function matchesGlob(pattern, candidate) {
+  return new RegExp(`^(?:${globToRegexText(pattern)})$`).test(candidate);
+}
+function normalizeExclusionEntry(raw) {
+  let text2 = raw.trim().replace(/\\/g, "/");
+  if (text2.startsWith("./")) {
+    text2 = text2.slice(2);
+  }
+  return text2.replace(REPEATED_SLASH, "/");
+}
+function malformedReason(normalized) {
+  const checks = [
+    [normalized === "", "entry is empty after normalization"],
+    [
+      normalized.startsWith("/") || DRIVE_PREFIX.test(normalized),
+      "entry is an absolute path"
+    ],
+    [normalized.split("/").includes(".."), "entry contains a '..' segment"],
+    [normalized.startsWith("!"), "negation entries are not supported"],
+    [
+      normalized.includes("[") || normalized.includes("]"),
+      "character classes are not supported"
+    ],
+    [
+      hasWildcard(normalized) && normalized.endsWith("/"),
+      "a wildcard entry must not end with '/'"
+    ],
+    [normalized.includes(REPLACEMENT_CHARACTER), "text is not valid UTF-8"]
+  ];
+  const failed = checks.find(([isFailed]) => isFailed);
+  return failed === void 0 ? void 0 : failed[1];
+}
+function classify(normalized) {
+  if (hasWildcard(normalized)) {
+    return "glob";
+  }
+  return normalized.endsWith("/") ? "directory" : "exact";
+}
+function parseExclusionManifest(text2, path16) {
+  const body = text2.startsWith(BYTE_ORDER_MARK) ? text2.slice(BYTE_ORDER_MARK.length) : text2;
+  const entries = [];
+  body.split(LINE_SPLIT).forEach((raw, offset) => {
+    const line = offset + 1;
+    const stripped = raw.trim();
+    if (stripped === "" || stripped.startsWith("#")) {
+      return;
+    }
+    const normalized = normalizeExclusionEntry(raw);
+    const reason = malformedReason(normalized);
+    if (reason !== void 0) {
+      throw new ExclusionManifestError(path16, line, reason);
+    }
+    entries.push({ raw, normalized, kind: classify(normalized), line });
+  });
+  return { path: path16, entries };
+}
+function matchesExclusionEntry(entry, candidate) {
+  if (entry.kind === "glob") {
+    return matchesGlob(entry.normalized, candidate);
+  }
+  const base = entry.normalized.replace(/\/+$/, "");
+  return candidate === base || candidate.startsWith(`${base}/`);
+}
+function planExclusions(payloadRelativePaths, manifest, destinationExists) {
+  const kept = [];
+  const skipped = [];
+  for (const relativePath2 of payloadRelativePaths) {
+    const entry = manifest.entries.find(
+      (candidate) => matchesExclusionEntry(candidate, relativePath2)
+    );
+    if (entry === void 0) {
+      kept.push(relativePath2);
+      continue;
+    }
+    skipped.push({
+      relativePath: relativePath2,
+      entry: entry.normalized,
+      line: entry.line,
+      destinationStatus: destinationExists(relativePath2) ? "present" : "absent"
+    });
+  }
+  const claimed = new Set(
+    skipped.map((skip) => `${String(skip.line)}\0${skip.entry}`)
+  );
+  const unmatchedEntries = manifest.entries.filter(
+    (entry) => !claimed.has(`${String(entry.line)}\0${entry.normalized}`)
+  );
+  return { kept, skipped, unmatchedEntries };
+}
+function assertManifestPathIsRootLevel(relativePath2, rootFolders) {
+  if (relativePath2.includes("/")) {
+    throw new Error(
+      `Exclusion manifest path must be root-level: ${relativePath2}`
+    );
+  }
+  const root = rootFolders.find((name) => relativePath2.startsWith(name));
+  if (root !== void 0) {
+    throw new Error(
+      `Exclusion manifest path must not begin with published root ${root}: ${relativePath2}`
+    );
+  }
+}
+
+// ../../extensions/drm-copilot/src/lib/push-down/claude-exclusion-filter.ts
+var EXCLUSION_CONFLICT_LINE_PREFIX = "push-down exclusion conflict:";
+var DEFAULT_ARTIFACT_DIRECTORY = "artifacts/claude-customizations";
+var ExclusionViolationError = class extends Error {
+  /**
+   * @param message Description of the refused write.
+   */
+  constructor(message) {
+    super(message);
+    this.name = "ExclusionViolationError";
+  }
+};
+function normalizePosix7(value) {
+  return value.replace(/\\/g, "/").replace(/\/+$/, "");
+}
+function relativeToPosix7(path16, root) {
+  const normalizedPath = normalizePosix7(path16);
+  const prefix = `${normalizePosix7(root)}/`;
+  return normalizedPath.startsWith(prefix) ? normalizedPath.slice(prefix.length) : void 0;
+}
+function findFirstMatch(manifest, candidate) {
+  return manifest.entries.find(
+    (entry) => matchesExclusionEntry(entry, candidate)
+  );
+}
+var ExclusionFilterFileSystem = class {
+  /** Skip records in enumeration order. */
+  skipped = [];
+  inner;
+  sourceRoot;
+  destinationRoot;
+  manifest;
+  artifactPrefix;
+  /**
+   * @param inner Adapter the engine would otherwise use.
+   * @param sourceRoot Root the engine enumerates payload files under.
+   * @param destinationRoot Destination workspace root.
+   * @param manifest Parsed manifest.
+   * @param artifactDirectory Destination-relative summary-artifact directory
+   *   exempt from the write guard.
+   */
+  constructor(inner, sourceRoot, destinationRoot, manifest, artifactDirectory = DEFAULT_ARTIFACT_DIRECTORY) {
+    this.inner = inner;
+    this.sourceRoot = normalizePosix7(sourceRoot);
+    this.destinationRoot = normalizePosix7(destinationRoot);
+    this.manifest = manifest;
+    this.artifactPrefix = `${normalizePosix7(artifactDirectory)}/`;
+  }
+  listFiles(root) {
+    const listed = this.inner.listFiles(root);
+    const relativeByPath = listed.map(
+      (path16) => [path16, relativeToPosix7(path16, this.sourceRoot)]
+    );
+    const candidates = relativeByPath.flatMap(
+      ([, relative2]) => relative2 === void 0 ? [] : [relative2]
+    );
+    const plan = planExclusions(
+      candidates,
+      this.manifest,
+      (relative2) => this.inner.isFile(`${this.destinationRoot}/${relative2}`)
+    );
+    this.skipped.push(...plan.skipped);
+    const kept = new Set(plan.kept);
+    return relativeByPath.filter(([, relative2]) => relative2 === void 0 || kept.has(relative2)).map(([path16]) => path16);
+  }
+  isDir(path16) {
+    return this.inner.isDir(path16);
+  }
+  isFile(path16) {
+    return this.inner.isFile(path16);
+  }
+  readTextFile(path16) {
+    return this.inner.readTextFile(path16);
+  }
+  ensureDir(path16) {
+    this.inner.ensureDir(path16);
+  }
+  /**
+   * Write through the inner adapter unless the target is excluded.
+   *
+   * @param path Target path.
+   * @param content Text to write.
+   * @throws ExclusionViolationError When the destination-relative target is
+   *   the manifest path or matches a manifest entry.
+   */
+  writeTextFile(path16, content) {
+    const relative2 = relativeToPosix7(path16, this.destinationRoot);
+    if (relative2 !== void 0 && !relative2.startsWith(this.artifactPrefix)) {
+      if (relative2 === EXCLUSION_MANIFEST_RELATIVE_PATH) {
+        throw new ExclusionViolationError(
+          `Refusing to write the push-down exclusion manifest: ${relative2}`
+        );
+      }
+      const entry = findFirstMatch(this.manifest, relative2);
+      if (entry !== void 0) {
+        throw new ExclusionViolationError(
+          `Refusing to write excluded path ${relative2} (entry ${entry.normalized}, line ${String(entry.line)})`
+        );
+      }
+    }
+    this.inner.writeTextFile(path16, content);
+  }
+};
+function readExclusionManifest(fs12, destinationRoot) {
+  const manifestPath = `${normalizePosix7(destinationRoot)}/${EXCLUSION_MANIFEST_RELATIVE_PATH}`;
+  if (!fs12.isFile(manifestPath)) {
+    if (fs12.isDir(manifestPath)) {
+      throw new ExclusionManifestError(
+        EXCLUSION_MANIFEST_RELATIVE_PATH,
+        void 0,
+        "path is not a regular file"
+      );
+    }
+    return void 0;
+  }
+  return parseExclusionManifest(
+    fs12.readTextFile(manifestPath),
+    EXCLUSION_MANIFEST_RELATIVE_PATH
+  );
+}
+function buildExclusionReport(manifest, skipped) {
+  const claimed = new Set(
+    skipped.map((skip) => `${String(skip.line)}\0${skip.entry}`)
+  );
+  return {
+    manifestPath: manifest.path,
+    entries: manifest.entries,
+    skipped: [...skipped],
+    unmatchedEntries: manifest.entries.filter(
+      (entry) => !claimed.has(`${String(entry.line)}\0${entry.normalized}`)
+    )
+  };
+}
+function renderExclusionLines(report) {
+  const skippedLines = report.skipped.map((skip) => {
+    const suffix2 = `${skip.relativePath} (entry ${skip.entry}, line ${String(skip.line)})`;
+    return skip.destinationStatus === "present" ? `${EXCLUSION_CONFLICT_LINE_PREFIX} destination file present, not overwritten: ${suffix2}` : `push-down exclusion: skipped ${suffix2}`;
+  });
+  const unmatchedLines = report.unmatchedEntries.map(
+    (entry) => `push-down exclusion: entry matched no payload path: ${entry.normalized} (line ${String(entry.line)})`
+  );
+  return [...skippedLines, ...unmatchedLines];
+}
+function exclusionReportPayload(report) {
+  return {
+    conflict_count: report.skipped.filter(
+      (skip) => skip.destinationStatus === "present"
+    ).length,
+    entries: report.entries.map((entry) => entry.normalized),
+    manifest_path: report.manifestPath,
+    skipped: report.skipped.map((skip) => ({
+      destination_status: skip.destinationStatus,
+      entry: skip.entry,
+      line: skip.line,
+      relative_path: skip.relativePath
+    })),
+    skipped_count: report.skipped.length,
+    unmatched_entries: report.unmatchedEntries.map((entry) => entry.normalized)
+  };
+}
+function appendExclusionsToArtifact(fs12, artifactPath, report) {
+  const payload = JSON.parse(fs12.readTextFile(artifactPath));
+  if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new Error(`Summary artifact is not a JSON object: ${artifactPath}`);
+  }
+  const document = {
+    ...payload,
+    exclusions: exclusionReportPayload(report)
+  };
+  fs12.writeTextFile(artifactPath, stringifySorted(document, 2));
+}
+
 // ../../extensions/drm-copilot/src/lib/push-down/claude-customizations.ts
 var ARTIFACT_DIRECTORY4 = "artifacts/claude-customizations";
 var ROOT_FOLDERS2 = [".claude", "config"];
+assertManifestPathIsRootLevel(EXCLUSION_MANIFEST_RELATIVE_PATH, ROOT_FOLDERS2);
 var ROUTING_MERGE_RELATIVE_PATH = "config/orchestration-routing.json";
 var EXCLUDED_RELATIVE_PATHS = [
-  ".claude/settings.local.json"
+  ".claude/settings.local.json",
+  "config/blast-radius.local.json"
+];
+var DESTINATION_WRITE_DECORATORS = [
+  {
+    relativePath: ROUTING_MERGE_RELATIVE_PATH,
+    wrap: (inner, destinationRoot) => new RoutingMergeFileSystem(
+      inner,
+      destinationRoot,
+      ROUTING_MERGE_RELATIVE_PATH
+    )
+  },
+  {
+    relativePath: BLAST_RADIUS_RELATIVE_PATH,
+    wrap: (inner, destinationRoot) => new BlastRadiusOverlayFileSystem(inner, destinationRoot)
+  },
+  {
+    relativePath: BLAST_RADIUS_RELATIVE_PATH,
+    wrap: (inner, destinationRoot, { listEntries }) => listEntries === void 0 ? new BlastRadiusDeriveFileSystem(inner, destinationRoot) : new BlastRadiusDeriveFileSystem(
+      inner,
+      destinationRoot,
+      listEntries
+    )
+  }
 ];
 var BUNDLE_ROOT_RELATIVE_DIR = "extensions/drm-copilot/resources/claude-customizations";
 var PACK_MANIFEST_SUBDIR2 = "pack-manifests";
@@ -20091,23 +20674,19 @@ function pushDownCustomizations4(options) {
   } = options;
   const effectiveSource = sourceRoot ?? repoRoot;
   const effectiveBundle = bundleRoot ?? joinPosix7(effectiveSource, BUNDLE_ROOT_RELATIVE_DIR);
+  const manifest = readExclusionManifest(fs12, destinationRoot);
   const publishedPaths = resolvePublishedPaths2(
     packs ?? null,
     effectiveBundle,
     fs12
   );
-  const mergingFs = new RoutingMergeFileSystem(
-    fs12,
-    destinationRoot,
-    ROUTING_MERGE_RELATIVE_PATH
-  );
-  const derivingFs = listEntries === void 0 ? new BlastRadiusDeriveFileSystem(mergingFs, destinationRoot) : new BlastRadiusDeriveFileSystem(
-    mergingFs,
-    destinationRoot,
-    listEntries
+  const decoratorOptions = listEntries === void 0 ? {} : { listEntries };
+  const decoratedFs = DESTINATION_WRITE_DECORATORS.reduce(
+    (inner, decorator) => decorator.wrap(inner, destinationRoot, decoratorOptions),
+    fs12
   );
   const excludingFs = new ExcludingFileSystem(
-    derivingFs,
+    decoratedFs,
     repoRoot,
     EXCLUDED_RELATIVE_PATHS,
     {
@@ -20119,10 +20698,17 @@ function pushDownCustomizations4(options) {
       variantRoot: effectiveBundle
     }
   );
+  const exclusionFs = manifest === void 0 ? void 0 : new ExclusionFilterFileSystem(
+    excludingFs,
+    effectiveSource,
+    destinationRoot,
+    manifest,
+    ARTIFACT_DIRECTORY4
+  );
   const summary = pushDownCustomizations({
     repoRoot,
     destinationRoot,
-    fs: excludingFs,
+    fs: exclusionFs ?? excludingFs,
     ...sourceRoot === void 0 ? {} : { sourceRoot },
     ...artifactRoot === void 0 ? {} : { artifactRoot },
     rootFolders: ROOT_FOLDERS2,
@@ -20130,19 +20716,41 @@ function pushDownCustomizations4(options) {
     rewriteReferences: passthroughRewrite2,
     ...clock === void 0 ? {} : { clock }
   });
-  deliverDestinationGitignore(fs12, destinationRoot);
-  return summary;
+  const gitignoreSkip = deliverDestinationGitignore(
+    fs12,
+    destinationRoot,
+    manifest
+  );
+  if (manifest === void 0 || exclusionFs === void 0) {
+    return summary;
+  }
+  const skipped = gitignoreSkip === void 0 ? exclusionFs.skipped : [...exclusionFs.skipped, gitignoreSkip];
+  const report = buildExclusionReport(manifest, skipped);
+  appendExclusionsToArtifact(fs12, summary.artifactPath, report);
+  return { ...summary, exclusions: report };
 }
-function deliverDestinationGitignore(fs12, destinationRoot) {
+function deliverDestinationGitignore(fs12, destinationRoot, manifest) {
   const destinationPath = joinPosix7(
     destinationRoot,
     CLAUDE_GITIGNORE_RELATIVE_PATH
   );
+  const entry = manifest?.entries.find(
+    (candidate) => matchesExclusionEntry(candidate, CLAUDE_GITIGNORE_RELATIVE_PATH)
+  );
+  if (entry !== void 0) {
+    return {
+      relativePath: CLAUDE_GITIGNORE_RELATIVE_PATH,
+      entry: entry.normalized,
+      line: entry.line,
+      destinationStatus: fs12.isFile(destinationPath) ? "present" : "absent"
+    };
+  }
   const currentText = fs12.isFile(destinationPath) ? fs12.readTextFile(destinationPath) : "";
   const mergedText = mergeClaudeGitignore(currentText);
   if (mergedText !== currentText) {
     fs12.writeTextFile(destinationPath, mergedText);
   }
+  return void 0;
 }
 
 // ../../extensions/drm-copilot/src/lib/push-down/push-down-service-call.ts
@@ -20216,11 +20824,16 @@ function pushDownClaudeCustomizationsServiceCall(input) {
     ...input.memoryMode === void 0 ? {} : { memoryMode: input.memoryMode },
     ...input.clock === void 0 ? {} : { clock: input.clock }
   });
+  const lines = summary.exclusions === void 0 ? [] : renderExclusionLines(summary.exclusions);
+  for (const line of lines) {
+    input.log?.(line);
+  }
   return {
     tool: "push_down_claude_customizations",
     workspaceRoot: input.workspaceRoot,
     summary: "Pushed bundled Claude Code customizations into the destination workspace.",
-    artifacts: [normalizeGeneratedPath(summary.artifactPath)]
+    artifacts: [normalizeGeneratedPath(summary.artifactPath)],
+    ...lines.length > 0 ? { warnings: lines } : {}
   };
 }
 
@@ -25127,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);
 }
@@ -25207,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();
@@ -25223,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);
@@ -25234,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} started before dependency ${String(dependency)} merged`
+          `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} worktree_created_at precedes dependency ${String(dependency)} merge_confirmed_at`
         );
       }
     }
@@ -26582,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 = {
@@ -26770,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}.`
@@ -26799,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));
@@ -26949,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"];
@@ -26968,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'.`
@@ -26982,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;
 }
 
@@ -27011,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";
   }
@@ -27026,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(", ")}}`;
   }
@@ -27044,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])}.`
       );
     }
   }
@@ -27066,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"];
@@ -27101,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"];
@@ -27150,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",
@@ -27198,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;
     }
@@ -27246,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."
     );
@@ -27281,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;
@@ -27306,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(
@@ -28343,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";
   }
@@ -28357,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);
@@ -28385,25 +29387,25 @@ function isPositiveInteger(value) {
 function isNonNegativeInteger(value) {
   return isIntegral(value) && value >= 0;
 }
-function isStringList(value) {
+function isStringList2(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)}.`;
+  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 = [];
   for (const field of BLAST_RADIUS_LIST_FIELDS) {
-    if (!isStringList(radius[field])) {
+    if (!isStringList2(radius[field])) {
       errors.push(
         `${context} blast_radius.${field} must be a list of non-empty strings.`
       );
@@ -28434,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"])) {
@@ -28483,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"];
@@ -28502,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}.`);
@@ -28521,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(
@@ -28537,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/",
@@ -28560,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"];
@@ -28595,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"];
@@ -28612,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"]);
@@ -28646,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];
   }
@@ -28668,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);
@@ -28706,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 [];
@@ -28725,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 [];
@@ -28740,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 [];
@@ -28756,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) {
@@ -28773,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;
     }
@@ -28817,25 +29819,25 @@ 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"]) {
-      if (!isStringList(entry[field])) {
+      if (!isStringList2(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) {
+    if (!isStringList2(escapedPaths) || !Array.isArray(escapedPaths) || escapedPaths.length === 0) {
       errors.push(
         `${entryContext} escaped_paths must be a non-empty list of non-empty strings.`
       );
@@ -28862,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"];
@@ -28880,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(
@@ -28901,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.`
       );
     }
   }
@@ -28912,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)) {
@@ -28922,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;
     }
@@ -28934,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);
@@ -28979,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;
@@ -28987,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 = [];
@@ -29017,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.`
       );
     }
   }
@@ -29047,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;
     }
@@ -29126,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"];
@@ -29136,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;
@@ -29192,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) {
@@ -29200,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") {
@@ -29209,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)}.`
       );
     }
   });
@@ -29228,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 = [];
@@ -29306,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;
@@ -29317,7 +30319,7 @@ function itemRecords(items) {
   }
   const records = [];
   items.forEach((entry, index) => {
-    if (isObject14(entry)) {
+    if (isObject15(entry)) {
       records.push({ index, record: entry });
     }
   });
@@ -29386,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) {
@@ -29401,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;
@@ -29426,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;
@@ -29446,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 = [];
@@ -33418,7 +34420,7 @@ function resolveReadinessSignal(fs12, featureDir) {
   }
   return [null, null];
 }
-function relativeToPosix6(root, path16) {
+function relativeToPosix8(root, path16) {
   const normalizedRoot = toPosixPath2(root).replace(/\/+$/u, "");
   const normalized = toPosixPath2(path16);
   if (normalized.startsWith(`${normalizedRoot}/`)) {
@@ -33451,7 +34453,7 @@ function discoverCanonicalEvidenceFiles(fs12, root, feature) {
   for (const pattern of CANONICAL_GLOBS) {
     for (const candidate of fs12.glob(featureRoot, pattern)) {
       if (fs12.isFile(candidate)) {
-        discovered.add(relativeToPosix7(normalizedRoot, candidate));
+        discovered.add(relativeToPosix9(normalizedRoot, candidate));
       }
     }
   }
@@ -33544,7 +34546,7 @@ function parseIntegerStrict(value) {
   }
   return Number.parseInt(value, 10);
 }
-function relativeToPosix7(root, absolute) {
+function relativeToPosix9(root, absolute) {
   const normalized = toPosixPath2(absolute);
   if (normalized.startsWith(`${root}/`)) {
     return normalized.slice(root.length + 1);
@@ -33732,11 +34734,11 @@ function buildContextFiles(params) {
   const contextFiles = [];
   for (const path16 of candidatePaths) {
     if (fs12.exists(path16)) {
-      contextFiles.push(relativeToPosix6(root, path16));
+      contextFiles.push(relativeToPosix8(root, path16));
     }
   }
   if (readinessSource !== null) {
-    contextFiles.push(relativeToPosix6(root, readinessSource));
+    contextFiles.push(relativeToPosix8(root, readinessSource));
   }
   const evidenceContextFiles = discoverCanonicalEvidenceFiles(
     fs12,
@@ -35261,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 };
 }