@danmoisan/drm-copilot-mcp 1.1.17 → 1.1.19

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",
@@ -14077,6 +14078,9 @@ var Protocol = class {
       this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => {
         const handleTaskResult = async () => {
           const taskId = request.params.taskId;
+          if (!await this._taskStore.getTask(taskId, extra.sessionId)) {
+            throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
+          }
           if (this._taskMessageQueue) {
             let queuedMessage;
             while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) {
@@ -14107,12 +14111,12 @@ var Protocol = class {
             throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
           }
           if (!isTerminal(task.status)) {
-            await this._waitForTaskUpdate(taskId, extra.signal);
+            await this._waitForTaskUpdate(taskId, extra.signal, extra.sessionId);
             return await handleTaskResult();
           }
           if (isTerminal(task.status)) {
             const result = await this._taskStore.getTaskResult(taskId, extra.sessionId);
-            this._clearTaskQueue(taskId);
+            this._clearTaskQueue(taskId, extra.sessionId);
             return {
               ...result,
               _meta: {
@@ -14149,7 +14153,7 @@ var Protocol = class {
             throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
           }
           await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
-          this._clearTaskQueue(request.params.taskId);
+          this._clearTaskQueue(request.params.taskId, extra.sessionId);
           const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
           if (!cancelledTask) {
             throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
@@ -14277,6 +14281,19 @@ var Protocol = class {
     const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler;
     const capturedTransport = this._transport;
     const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
+    const sessionId = capturedTransport?.sessionId;
+    const store = this._taskStore;
+    let relatedTaskFound = true;
+    let relatedTaskLookup;
+    if (relatedTaskId && store && this._taskMessageQueue && sessionId !== void 0) {
+      relatedTaskFound = false;
+      relatedTaskLookup = (async () => {
+        if (!await store.getTask(relatedTaskId, sessionId)) {
+          throw new McpError(ErrorCode.InvalidParams, `Task not found: ${relatedTaskId}`);
+        }
+        relatedTaskFound = true;
+      })();
+    }
     if (handler === void 0) {
       const errorResponse = {
         jsonrpc: "2.0",
@@ -14286,7 +14303,10 @@ var Protocol = class {
           message: "Method not found"
         }
       };
-      if (relatedTaskId && this._taskMessageQueue) {
+      if (relatedTaskId && relatedTaskLookup) {
+        const queuedError = { type: "error", message: errorResponse, timestamp: Date.now() };
+        relatedTaskLookup.then(() => this._enqueueTaskMessage(relatedTaskId, queuedError, sessionId), () => capturedTransport?.send(errorResponse)).catch((error2) => this._onerror(new Error(`Failed to send an error response: ${error2}`)));
+      } else if (relatedTaskId && this._taskMessageQueue) {
         this._enqueueTaskMessage(relatedTaskId, {
           type: "error",
           message: errorResponse,
@@ -14337,7 +14357,10 @@ var Protocol = class {
       closeSSEStream: extra?.closeSSEStream,
       closeStandaloneSSEStream: extra?.closeStandaloneSSEStream
     };
-    Promise.resolve().then(() => {
+    (relatedTaskLookup ?? Promise.resolve()).then(() => {
+      if (relatedTaskLookup && abortController.signal.aborted) {
+        throw new McpError(ErrorCode.ConnectionClosed, "Request was cancelled");
+      }
       if (taskCreationParams) {
         this.assertTaskHandlerCapability(request.method);
       }
@@ -14372,7 +14395,7 @@ var Protocol = class {
           ...error2["data"] !== void 0 && { data: error2["data"] }
         }
       };
-      if (relatedTaskId && this._taskMessageQueue) {
+      if (relatedTaskId && this._taskMessageQueue && relatedTaskFound) {
         await this._enqueueTaskMessage(relatedTaskId, {
           type: "error",
           message: errorResponse,
@@ -14852,7 +14875,7 @@ var Protocol = class {
       throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
     }
     const maxQueueSize = this._options?.maxTaskQueueSize;
-    await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
+    await this._taskMessageQueue.enqueue(taskId, message, sessionId ?? this._transport?.sessionId, maxQueueSize);
   }
   /**
    * Clears the message queue for a task and rejects any pending request resolvers.
@@ -14881,12 +14904,13 @@ var Protocol = class {
    * Uses polling to check for updates at the task's configured poll interval.
    * @param taskId The task ID to wait for
    * @param signal Abort signal to cancel the wait
+   * @param sessionId Session of the request that waits, passed to the task store
    * @returns Promise that resolves when an update occurs or rejects if aborted
    */
-  async _waitForTaskUpdate(taskId, signal) {
+  async _waitForTaskUpdate(taskId, signal, sessionId) {
     let interval = this._options?.defaultTaskPollInterval ?? 1e3;
     try {
-      const task = await this._taskStore?.getTask(taskId);
+      const task = await this._taskStore?.getTask(taskId, sessionId);
       if (task?.pollInterval) {
         interval = task.pollInterval;
       }
@@ -17830,7 +17854,8 @@ function toAuthorityMcpResult(tool, workspaceRoot, result) {
     primary_failure_code: result.primaryFailureCode,
     affected_paths: result.affectedPaths,
     unsupported_capabilities: result.unsupportedCapabilities,
-    resolution: result.resolution
+    resolution: result.resolution,
+    ...result.failureCause === void 0 ? {} : { failure_cause: result.failureCause }
   };
 }
 function toTransitionMcpResult(workspaceRoot, result) {
@@ -17849,7 +17874,8 @@ function toTransitionMcpResult(workspaceRoot, result) {
     destination_checkpoint_sha256: result.destinationCheckpointSha256,
     primary_failure_code: result.primaryFailureCode,
     affected_paths: result.affectedPaths,
-    unsupported_capabilities: result.unsupportedCapabilities
+    unsupported_capabilities: result.unsupportedCapabilities,
+    ...result.failureCause === void 0 ? {} : { failure_cause: result.failureCause }
   };
 }
 async function handlePortableHandoffTool(tool, rawInput, service) {
@@ -18294,6 +18320,33 @@ function buildPoshQcWorkflowArguments(tool, input) {
 // ../../extensions/drm-copilot/src/lib/push-down/filesystem-adapter.ts
 var fs2 = __toESM(require("node:fs"));
 var nodePath2 = __toESM(require("node:path"));
+
+// ../../extensions/drm-copilot/src/lib/string-ordering.ts
+function rankCodeUnit(unit) {
+  if (unit >= 55296 && unit <= 57343) {
+    return unit + 8192;
+  }
+  if (unit >= 57344) {
+    return unit - 2048;
+  }
+  return unit;
+}
+function compareCodePoint(left, right) {
+  const sharedLength = Math.min(left.length, right.length);
+  for (let index = 0; index < sharedLength; index += 1) {
+    const leftUnit = left.charCodeAt(index);
+    const rightUnit = right.charCodeAt(index);
+    if (leftUnit !== rightUnit) {
+      return rankCodeUnit(leftUnit) < rankCodeUnit(rightUnit) ? -1 : 1;
+    }
+  }
+  if (left.length === right.length) {
+    return 0;
+  }
+  return left.length < right.length ? -1 : 1;
+}
+
+// ../../extensions/drm-copilot/src/lib/push-down/filesystem-adapter.ts
 function toPosixPath(value) {
   return value.replace(/\\/g, "/");
 }
@@ -18342,9 +18395,7 @@ var RealPushDownFileSystem = class {
       }
     };
     walk(normalizedRoot);
-    return files.sort(
-      (left, right) => left < right ? -1 : left > right ? 1 : 0
-    );
+    return files.sort(compareCodePoint);
   }
   /**
    * @param path Path to inspect.
@@ -18554,7 +18605,7 @@ function enumerateSourceFiles(fs12, sourceRoot, rootFolders) {
     const sorted = [...rootFiles].sort((left, right) => {
       const leftRel = relativeToPosix(left, rootPath) ?? left;
       const rightRel = relativeToPosix(right, rootPath) ?? right;
-      return leftRel < rightRel ? -1 : leftRel > rightRel ? 1 : 0;
+      return compareCodePoint(leftRel, rightRel);
     });
     orderedFiles.push(...sorted);
   }
@@ -18612,7 +18663,7 @@ function stringifySorted(value, indent) {
     }
     if (input !== null && typeof input === "object") {
       const entries = Object.entries(input).sort(
-        ([leftKey], [rightKey]) => leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0
+        ([leftKey], [rightKey]) => compareCodePoint(leftKey, rightKey)
       );
       const result = {};
       for (const [key, val] of entries) {
@@ -18666,11 +18717,11 @@ function pushDownCustomizations(options) {
     effectiveSource,
     effectiveRoots
   )) {
-    const relativePath2 = relativeToPosix(sourcePath, effectiveSource);
-    if (relativePath2 === null) {
+    const relativePath = relativeToPosix(sourcePath, effectiveSource);
+    if (relativePath === null) {
       continue;
     }
-    const destinationPath = joinPosix2(destinationRoot, relativePath2);
+    const destinationPath = joinPosix2(destinationRoot, relativePath);
     const destinationStatus = fs12.isFile(
       destinationPath
     ) ? "overwritten" : "created";
@@ -18695,7 +18746,7 @@ function pushDownCustomizations(options) {
     fs12.ensureDir(destParent);
     fs12.writeTextFile(destinationPath, rewrittenText);
     fileResults.push({
-      relativePath: relativePath2,
+      relativePath,
       destinationStatus,
       rewrittenReferenceCount: rewrittenDelta,
       placeholderRewriteCount: placeholderDelta,
@@ -18786,12 +18837,14 @@ function loadPackManifests(manifestDir, selectedPackNames, fs12) {
     (name) => !MANIFEST_PACK_NAMES.has(name)
   );
   if (unknown2.length > 0) {
-    throw new ManifestError(`Unknown Codex pack name(s): ${unknown2.sort()}`);
+    throw new ManifestError(
+      `Unknown Codex pack name(s): ${unknown2.sort(compareCodePoint)}`
+    );
   }
   const namesToLoad = new Set(selectedPackNames);
   namesToLoad.add(CORE_PACK_NAME);
   const manifests = /* @__PURE__ */ new Map();
-  for (const name of [...namesToLoad].sort()) {
+  for (const name of [...namesToLoad].sort(compareCodePoint)) {
     const manifestPath = joinPosix3(manifestDir, `${name}.json`);
     if (!fs12.isFile(manifestPath)) {
       throw new ManifestError(
@@ -18814,14 +18867,16 @@ function resolveManifestPackNames(selectedPackNames, csharpVariant) {
   );
   if (variantSpecific.length > 0) {
     throw new ManifestError(
-      `Use public Codex pack 'csharp' with csharpVariant instead of variant-specific pack name(s): ${variantSpecific.sort().join(", ")}.`
+      `Use public Codex pack 'csharp' with csharpVariant instead of variant-specific pack name(s): ${variantSpecific.sort(compareCodePoint).join(", ")}.`
     );
   }
   const unknown2 = [...selectedPackNames].filter(
     (name) => !SUPPORTED_PACK_NAMES.has(name)
   );
   if (unknown2.length > 0) {
-    throw new ManifestError(`Unknown Codex pack name(s): ${unknown2.sort()}`);
+    throw new ManifestError(
+      `Unknown Codex pack name(s): ${unknown2.sort(compareCodePoint)}`
+    );
   }
   const manifestNames = new Set(selectedPackNames);
   if (manifestNames.has(PUBLIC_CSHARP_PACK_NAME)) {
@@ -18917,7 +18972,7 @@ function resolveVariantSourcePath(destinationRelativePath, csharpVariant) {
   return destinationRelativePath;
 }
 function assertSingleCsharpToolchain(publishedPaths, selectedPackNames) {
-  const selectedCsharp = [...selectedPackNames].filter((name) => CSHARP_PACK_NAMES.has(name)).sort();
+  const selectedCsharp = [...selectedPackNames].filter((name) => CSHARP_PACK_NAMES.has(name)).sort(compareCodePoint);
   if (selectedCsharp.length > 1) {
     throw new ManifestError(
       `C# mutual exclusion violated: both modern and legacy Codex C# packs were selected (${selectedCsharp.join(", ")}); select exactly one C# variant.`
@@ -19207,7 +19262,7 @@ function loadPackManifests2(manifestDir, selectedPackNames, fs12) {
   const namesToLoad = new Set(selectedPackNames);
   namesToLoad.add(CORE_PACK_NAME2);
   const manifests = /* @__PURE__ */ new Map();
-  for (const name of [...namesToLoad].sort()) {
+  for (const name of [...namesToLoad].sort(compareCodePoint)) {
     const manifestPath = joinPosix5(manifestDir, `${name}.json`);
     if (!fs12.isFile(manifestPath)) {
       throw new ManifestError2(
@@ -19302,7 +19357,7 @@ function resolveVariantSourcePath2(destinationRelativePath, csharpVariant) {
   return destinationRelativePath;
 }
 function assertSingleCsharpToolchain2(publishedPaths, selectedPackNames) {
-  const selectedCsharp = [...selectedPackNames].filter((name) => CSHARP_PACK_NAMES2.has(name)).sort();
+  const selectedCsharp = [...selectedPackNames].filter((name) => CSHARP_PACK_NAMES2.has(name)).sort(compareCodePoint);
   if (selectedCsharp.length > 1) {
     throw new ManifestError2(
       `C# mutual exclusion violated: both modern and legacy C# packs were selected ([${selectedCsharp.map((n) => `'${n}'`).join(", ")}]); select exactly one C# variant.`
@@ -19312,6 +19367,10 @@ function assertSingleCsharpToolchain2(publishedPaths, selectedPackNames) {
 }
 
 // ../../extensions/drm-copilot/src/lib/push-down/claude-filesystem-adapter.ts
+var LOCAL_RUNTIME_RELATIVE_DIRECTORIES = [
+  ".claude/state",
+  ".claude/worktrees"
+];
 function normalizePosix3(value) {
   return value.replace(/\\/g, "/").replace(/\/+$/, "");
 }
@@ -19377,6 +19436,21 @@ var ExcludingFileSystem = class {
   sourceRelativePosix(path16) {
     return relativeToPosix3(path16, this.sourceRoot);
   }
+  /**
+   * Return whether a path is a local runtime directory or lies below one.
+   *
+   * @param path An absolute candidate POSIX path from the inner adapter.
+   * @returns True when the source-relative path is in a runtime directory.
+   */
+  isLocalRuntimePath(path16) {
+    const relative2 = this.sourceRelativePosix(path16);
+    if (relative2 === null) {
+      return false;
+    }
+    return LOCAL_RUNTIME_RELATIVE_DIRECTORIES.some(
+      (directory) => relative2 === directory || relative2.startsWith(`${directory}/`)
+    );
+  }
   /**
    * Return whether a candidate path is in the active published set.
    *
@@ -19402,15 +19476,15 @@ var ExcludingFileSystem = class {
    * @returns True when the file is outside the memory subtree or general-scoped.
    */
   isScopeIncluded(path16) {
-    const relativePath2 = relativeToPosix3(path16, this.repoRoot);
-    if (relativePath2 === null) {
+    const relativePath = relativeToPosix3(path16, this.repoRoot);
+    if (relativePath === null) {
       return true;
     }
-    if (!isUnderAgentMemory(relativePath2)) {
+    if (!isUnderAgentMemory(relativePath)) {
       return true;
     }
     const content = this.readText(path16);
-    return isGeneralMemoryFile(relativePath2, content);
+    return isGeneralMemoryFile(relativePath, content);
   }
   /**
    * Return whether a candidate file passes the memory-mode filter.
@@ -19460,7 +19534,7 @@ var ExcludingFileSystem = class {
   }
   listFiles(root) {
     return this.inner.listFiles(root).filter(
-      (p) => !this.excluded.has(normalizePosix3(p)) && this.isPackIncluded(p) && this.isScopeIncluded(p) && this.isMemoryModeIncluded(p)
+      (p) => !this.isLocalRuntimePath(p) && !this.excluded.has(normalizePosix3(p)) && this.isPackIncluded(p) && this.isScopeIncluded(p) && this.isMemoryModeIncluded(p)
     );
   }
   isDir(path16) {
@@ -19677,9 +19751,6 @@ var EXCLUDED_DIR_NAMES = /* @__PURE__ */ new Set([
   "tests",
   "venv"
 ]);
-function compareOrdinal(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
 function isExcludedDirectoryName(name) {
   return name.startsWith(".") || EXCLUDED_DIR_NAMES.has(name);
 }
@@ -19708,7 +19779,7 @@ function classifyProjectDirectories(observations) {
       structureObserved = true;
     }
   }
-  return { modulePaths: modulePaths.sort(compareOrdinal), structureObserved };
+  return { modulePaths: modulePaths.sort(compareCodePoint), structureObserved };
 }
 
 // ../../extensions/drm-copilot/src/lib/push-down/claude-blast-radius-derive-core.ts
@@ -19776,12 +19847,12 @@ function pruneAncestors(paths) {
 function topLevelDirectories(observations) {
   const names = [];
   for (const observation of observations) {
-    const relativePath2 = observation.relativePath;
-    if (relativePath2 !== "" && !relativePath2.includes("/")) {
-      names.push(relativePath2);
+    const relativePath = observation.relativePath;
+    if (relativePath !== "" && !relativePath.includes("/")) {
+      names.push(relativePath);
     }
   }
-  return names.sort(compareOrdinal);
+  return names.sort(compareCodePoint);
 }
 function assembleModules(derivedPaths) {
   const combined = /* @__PURE__ */ new Map();
@@ -19792,7 +19863,7 @@ function assembleModules(derivedPaths) {
     combined.set(name, [...globs]);
   }
   const modules = {};
-  for (const name of [...combined.keys()].sort(compareOrdinal)) {
+  for (const name of [...combined.keys()].sort(compareCodePoint)) {
     const globs = combined.get(name);
     if (globs !== void 0) {
       modules[name] = globs;
@@ -19868,9 +19939,7 @@ var realDirectoryLister = (root) => {
   } catch {
     return [];
   }
-  return entries.map((entry) => ({ name: entry.name, isDir: entry.isDirectory() })).sort(
-    (left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0
-  );
+  return entries.map((entry) => ({ name: entry.name, isDir: entry.isDirectory() })).sort((left, right) => compareCodePoint(left.name, right.name));
 };
 function listTolerantly(lister, path16) {
   try {
@@ -20064,7 +20133,7 @@ function composeModules(base, overlay, overlayPath) {
     merged[name] = globs;
   }
   const composed = {};
-  for (const name of Object.keys(merged).sort(compareOrdinal)) {
+  for (const name of Object.keys(merged).sort(compareCodePoint)) {
     const globs = merged[name] ?? [];
     composed[name] = globs;
     for (const glob of Array.isArray(globs) ? globs : []) {
@@ -20392,19 +20461,19 @@ function matchesExclusionEntry(entry, candidate) {
 function planExclusions(payloadRelativePaths, manifest, destinationExists) {
   const kept = [];
   const skipped = [];
-  for (const relativePath2 of payloadRelativePaths) {
+  for (const relativePath of payloadRelativePaths) {
     const entry = manifest.entries.find(
-      (candidate) => matchesExclusionEntry(candidate, relativePath2)
+      (candidate) => matchesExclusionEntry(candidate, relativePath)
     );
     if (entry === void 0) {
-      kept.push(relativePath2);
+      kept.push(relativePath);
       continue;
     }
     skipped.push({
-      relativePath: relativePath2,
+      relativePath,
       entry: entry.normalized,
       line: entry.line,
-      destinationStatus: destinationExists(relativePath2) ? "present" : "absent"
+      destinationStatus: destinationExists(relativePath) ? "present" : "absent"
     });
   }
   const claimed = new Set(
@@ -20415,16 +20484,16 @@ function planExclusions(payloadRelativePaths, manifest, destinationExists) {
   );
   return { kept, skipped, unmatchedEntries };
 }
-function assertManifestPathIsRootLevel(relativePath2, rootFolders) {
-  if (relativePath2.includes("/")) {
+function assertManifestPathIsRootLevel(relativePath, rootFolders) {
+  if (relativePath.includes("/")) {
     throw new Error(
-      `Exclusion manifest path must be root-level: ${relativePath2}`
+      `Exclusion manifest path must be root-level: ${relativePath}`
     );
   }
-  const root = rootFolders.find((name) => relativePath2.startsWith(name));
+  const root = rootFolders.find((name) => relativePath.startsWith(name));
   if (root !== void 0) {
     throw new Error(
-      `Exclusion manifest path must not begin with published root ${root}: ${relativePath2}`
+      `Exclusion manifest path must not begin with published root ${root}: ${relativePath}`
     );
   }
 }
@@ -21019,12 +21088,12 @@ var RealFileSystem = class {
         return;
       }
       for (const entry of entries) {
-        const relativePath2 = relativePrefix === "" ? entry.name : `${relativePrefix}/${entry.name}`;
-        if (matcher.test(relativePath2)) {
-          matches.push(joinPosix8(normalizedRoot, relativePath2));
+        const relativePath = relativePrefix === "" ? entry.name : `${relativePrefix}/${entry.name}`;
+        if (matcher.test(relativePath)) {
+          matches.push(joinPosix8(normalizedRoot, relativePath));
         }
         if (entry.isDirectory()) {
-          walk(nodePath3.join(currentDir, entry.name), relativePath2);
+          walk(nodePath3.join(currentDir, entry.name), relativePath);
         }
       }
     };
@@ -21422,12 +21491,12 @@ function extractTemplateVariables(template) {
 }
 function replaceAllVariables(template, variables) {
   const referenced = extractTemplateVariables(template);
-  const missing = [...referenced].filter((name) => !(name in variables)).sort();
+  const missing = [...referenced].filter((name) => !(name in variables)).sort(compareCodePoint);
   if (missing.length > 0) {
     throw new Error(`Unresolved template variables: ${missing.join(", ")}`);
   }
   let resolved = template;
-  for (const key of [...referenced].sort()) {
+  for (const key of [...referenced].sort(compareCodePoint)) {
     resolved = resolved.split(`\${${key}}`).join(variables[key] ?? "");
   }
   if (extractTemplateVariables(resolved).size > 0) {
@@ -21876,9 +21945,7 @@ function validationFindingToJson(finding) {
 }
 function sourceArtifactToJson(artifact) {
   const sortedFrontmatter = {};
-  for (const key of Object.keys(artifact.frontmatter).sort(
-    (left, right) => left < right ? -1 : left > right ? 1 : 0
-  )) {
+  for (const key of Object.keys(artifact.frontmatter).sort(compareCodePoint)) {
     sortedFrontmatter[key] = artifact.frontmatter[key];
   }
   return {
@@ -22376,9 +22443,7 @@ function normalizeSelectedPaths(sourceRoot, selectedPaths) {
   for (const candidatePath of selectedPaths) {
     normalized.add(normalizeRelativePath(sourceRoot, candidatePath));
   }
-  return [...normalized].sort(
-    (left, right) => left < right ? -1 : left > right ? 1 : 0
-  );
+  return [...normalized].sort(compareCodePoint);
 }
 function collectFilesRecursive(fileSystem, absoluteDir, out) {
   for (const childName of fileSystem.listDirectory(absoluteDir)) {
@@ -22411,9 +22476,7 @@ function iterSupportedArtifacts(fileSystem, sourceRoot, sourceEcosystem) {
       discovered.add(filePath.slice(rootPrefix.length));
     }
   }
-  return [...discovered].sort(
-    (left, right) => left < right ? -1 : left > right ? 1 : 0
-  );
+  return [...discovered].sort(compareCodePoint);
 }
 function discoverSourceArtifacts(fileSystem, sourceRoot, sourceEcosystem, selectedPaths) {
   const allArtifacts = iterSupportedArtifacts(
@@ -22439,9 +22502,7 @@ function discoverSourceArtifacts(fileSystem, sourceRoot, sourceEcosystem, select
       matched.push(artifactPath);
     }
   }
-  return matched.sort(
-    (left, right) => left < right ? -1 : left > right ? 1 : 0
-  );
+  return matched.sort(compareCodePoint);
 }
 function isUnderSelectedDirectory(artifactPath, selectedSet) {
   const segments = artifactPath.split("/");
@@ -23282,23 +23343,19 @@ function buildPromptTranslationTraces(fileSystem, runOptions, mappingRecord) {
     });
   }
   return [...translationTraces].sort((left, right) => {
-    if (left.sourcePath !== right.sourcePath) {
-      return left.sourcePath < right.sourcePath ? -1 : 1;
-    }
-    if (left.sectionId !== right.sectionId) {
-      return left.sectionId < right.sectionId ? -1 : 1;
+    const bySource = compareCodePoint(left.sourcePath, right.sourcePath);
+    if (bySource !== 0) {
+      return bySource;
     }
-    if (left.targetRole !== right.targetRole) {
-      return left.targetRole < right.targetRole ? -1 : 1;
+    const bySection = compareCodePoint(left.sectionId, right.sectionId);
+    if (bySection !== 0) {
+      return bySection;
     }
-    return 0;
+    return compareCodePoint(left.targetRole, right.targetRole);
   });
 }
 
 // ../../extensions/drm-copilot/src/lib/codex-native-converter/engine-pipeline.ts
-function compareStrings(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
 function planMappings(fileSystem, runOptions) {
   const discoveredPaths = discoverSourceArtifacts(
     fileSystem,
@@ -23320,7 +23377,7 @@ function planMappings(fileSystem, runOptions) {
     mappingRecords.push(mappedRecord);
   }
   return [...mappingRecords].sort(
-    (left, right) => compareStrings(left.sourcePath, right.sourcePath)
+    (left, right) => compareCodePoint(left.sourcePath, right.sourcePath)
   );
 }
 function renderGeneratedOutput(fileSystem, runOptions, mappingRecords, plannedEmissions) {
@@ -23347,7 +23404,7 @@ function renderGeneratedOutput(fileSystem, runOptions, mappingRecords, plannedEm
     sectionEmissionsByTarget.set(plannedEmission.targetPath, bucket);
   }
   for (const targetPath of [...mappingRecordsByTarget.keys()].sort(
-    compareStrings
+    compareCodePoint
   )) {
     const recordsForTarget = mappingRecordsByTarget.get(targetPath) ?? [];
     if (recordsForTarget.length === 0) {
@@ -23375,7 +23432,7 @@ function renderGeneratedOutput(fileSystem, runOptions, mappingRecords, plannedEm
     ...new Set(
       plannedEmissions.filter((emission) => emission.targetPath !== null).map((emission) => emission.sourcePath)
     )
-  ].sort(compareStrings);
+  ].sort(compareCodePoint);
   for (const sourcePath of parsedSourcePaths) {
     const sourceArtifact = parseSourceArtifact(
       fileSystem,
@@ -23389,7 +23446,7 @@ function renderGeneratedOutput(fileSystem, runOptions, mappingRecords, plannedEm
     }
   }
   for (const targetPath of [...sectionEmissionsByTarget.keys()].sort(
-    compareStrings
+    compareCodePoint
   )) {
     if (targetPath in generatedOutput) {
       continue;
@@ -23412,15 +23469,15 @@ function buildTranslationTraces(fileSystem, runOptions, mappingRecords) {
     );
   }
   return [...translationTraces].sort((left, right) => {
-    const bySource = compareStrings(left.sourcePath, right.sourcePath);
+    const bySource = compareCodePoint(left.sourcePath, right.sourcePath);
     if (bySource !== 0) {
       return bySource;
     }
-    const bySection = compareStrings(left.sectionId, right.sectionId);
+    const bySection = compareCodePoint(left.sectionId, right.sectionId);
     if (bySection !== 0) {
       return bySection;
     }
-    return compareStrings(left.targetRole, right.targetRole);
+    return compareCodePoint(left.targetRole, right.targetRole);
   });
 }
 function buildPlannedEmissions(translationTraces) {
@@ -23438,7 +23495,9 @@ function buildPlannedEmissions(translationTraces) {
 }
 function writeDestinationOutputs(fileSystem, destinationRoot, generatedOutput) {
   const normalizedRoot = destinationRoot.replace(/\/+$/, "");
-  for (const targetPath of Object.keys(generatedOutput).sort(compareStrings)) {
+  for (const targetPath of Object.keys(generatedOutput).sort(
+    compareCodePoint
+  )) {
     const fullPath = normalizedRoot === "" ? targetPath : `${normalizedRoot}/${targetPath}`;
     fileSystem.writeTextFile(fullPath, generatedOutput[targetPath] ?? "");
   }
@@ -23452,7 +23511,7 @@ function sortKeysDeep(value) {
   if (value !== null && typeof value === "object") {
     const sorted = {};
     for (const key of Object.keys(value).sort(
-      (left, right) => left < right ? -1 : left > right ? 1 : 0
+      compareCodePoint
     )) {
       sorted[key] = sortKeysDeep(value[key]);
     }
@@ -23528,7 +23587,7 @@ function extractTopologyDestinations(renderedText, knownDestinationPaths) {
     if (left[0] !== right[0]) {
       return left[0] - right[0];
     }
-    return left[1] < right[1] ? -1 : left[1] > right[1] ? 1 : 0;
+    return compareCodePoint(left[1], right[1]);
   });
   return destinationsByPosition.map(([, destinationPath]) => destinationPath);
 }
@@ -23540,7 +23599,7 @@ function buildTopologyEdges(fileSystem, runOptions, mappingRecords, translationT
     ...new Set(
       mappingRecords.filter((record3) => record3.targetPath !== null).map((record3) => record3.targetPath)
     )
-  ].sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
+  ].sort(compareCodePoint);
   const topologyEdges = [];
   const translationTraceSourcePaths = new Set(
     translationTraces.map((trace) => trace.sourcePath)
@@ -23586,13 +23645,11 @@ function buildTopologyEdges(fileSystem, runOptions, mappingRecords, translationT
     }
   }
   return [...topologyEdges].sort((left, right) => {
-    if (left.sourcePath !== right.sourcePath) {
-      return left.sourcePath < right.sourcePath ? -1 : 1;
-    }
-    if (left.destinationPath !== right.destinationPath) {
-      return left.destinationPath < right.destinationPath ? -1 : 1;
+    const bySource = compareCodePoint(left.sourcePath, right.sourcePath);
+    if (bySource !== 0) {
+      return bySource;
     }
-    return 0;
+    return compareCodePoint(left.destinationPath, right.destinationPath);
   });
 }
 
@@ -23665,38 +23722,35 @@ function renderDestinationToRepeatedSourceChart(topologyEdges) {
 }
 
 // ../../extensions/drm-copilot/src/lib/codex-native-converter/reporting-render.ts
-function compareStrings2(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
 function renderConversionReport(runOptions, mappingRecords, topologyEdges, translationTraces, validationFindings) {
   const blockingCount = validationFindings.filter(
     (finding) => finding.blocking
   ).length;
   const destinationRootText = runOptions.destinationRoot !== null ? toPosixPath2(runOptions.destinationRoot) : "review-only";
   const sortedMappingRecords = [...mappingRecords].sort(
-    (left, right) => compareStrings2(left.sourcePath, right.sourcePath)
+    (left, right) => compareCodePoint(left.sourcePath, right.sourcePath)
   );
   const sortedTopologyEdges = [...topologyEdges].sort((left, right) => {
-    const bySource = compareStrings2(left.sourcePath, right.sourcePath);
+    const bySource = compareCodePoint(left.sourcePath, right.sourcePath);
     if (bySource !== 0) {
       return bySource;
     }
-    return compareStrings2(left.destinationPath, right.destinationPath);
+    return compareCodePoint(left.destinationPath, right.destinationPath);
   });
   const sortedTranslationTraces = [...translationTraces].sort((left, right) => {
-    const bySource = compareStrings2(left.sourcePath, right.sourcePath);
+    const bySource = compareCodePoint(left.sourcePath, right.sourcePath);
     if (bySource !== 0) {
       return bySource;
     }
-    const bySection = compareStrings2(left.sectionId, right.sectionId);
+    const bySection = compareCodePoint(left.sectionId, right.sectionId);
     if (bySection !== 0) {
       return bySection;
     }
-    const byRole = compareStrings2(left.targetRole, right.targetRole);
+    const byRole = compareCodePoint(left.targetRole, right.targetRole);
     if (byRole !== 0) {
       return byRole;
     }
-    return compareStrings2(left.targetPath ?? "", right.targetPath ?? "");
+    return compareCodePoint(left.targetPath ?? "", right.targetPath ?? "");
   });
   const lines = [
     "# Conversion Report",
@@ -23764,18 +23818,18 @@ function renderConversionReport(runOptions, mappingRecords, topologyEdges, trans
     lines.push("- None");
   } else {
     const sortedFindings = [...validationFindings].sort((left, right) => {
-      const byCode = compareStrings2(left.code, right.code);
+      const byCode = compareCodePoint(left.code, right.code);
       if (byCode !== 0) {
         return byCode;
       }
-      const bySource = compareStrings2(
+      const bySource = compareCodePoint(
         left.sourcePath ?? "",
         right.sourcePath ?? ""
       );
       if (bySource !== 0) {
         return bySource;
       }
-      return compareStrings2(left.targetPath ?? "", right.targetPath ?? "");
+      return compareCodePoint(left.targetPath ?? "", right.targetPath ?? "");
     });
     for (const validationFinding of sortedFindings) {
       lines.push(
@@ -23794,7 +23848,7 @@ function sortKeysDeep2(value) {
   if (value !== null && typeof value === "object") {
     const sorted = {};
     for (const key of Object.keys(value).sort(
-      (left, right) => left < right ? -1 : left > right ? 1 : 0
+      compareCodePoint
     )) {
       sorted[key] = sortKeysDeep2(value[key]);
     }
@@ -23836,21 +23890,23 @@ function joinPosix12(root, child) {
 }
 function sortBySourcePath(mappingRecords) {
   return [...mappingRecords].sort(
-    (left, right) => left.sourcePath < right.sourcePath ? -1 : left.sourcePath > right.sourcePath ? 1 : 0
+    (left, right) => compareCodePoint(left.sourcePath, right.sourcePath)
   );
 }
 function sortFindings(validationFindings) {
-  const compare = (left, right) => left < right ? -1 : left > right ? 1 : 0;
   return [...validationFindings].sort((left, right) => {
-    const byCode = compare(left.code, right.code);
+    const byCode = compareCodePoint(left.code, right.code);
     if (byCode !== 0) {
       return byCode;
     }
-    const bySource = compare(left.sourcePath ?? "", right.sourcePath ?? "");
+    const bySource = compareCodePoint(
+      left.sourcePath ?? "",
+      right.sourcePath ?? ""
+    );
     if (bySource !== 0) {
       return bySource;
     }
-    return compare(left.targetPath ?? "", right.targetPath ?? "");
+    return compareCodePoint(left.targetPath ?? "", right.targetPath ?? "");
   });
 }
 function writeConversionReportSet(fileSystem, runOptions, mappingRecords, topologyEdges, translationTraces, validationFindings, generatedOutput) {
@@ -23889,7 +23945,7 @@ function writeConversionReportSet(fileSystem, runOptions, mappingRecords, topolo
     dumpsSortedWithNewline(validationResultsPayload)
   );
   for (const targetPath of Object.keys(generatedOutput).sort(
-    (left, right) => left < right ? -1 : left > right ? 1 : 0
+    compareCodePoint
   )) {
     fileSystem.writeTextFile(
       joinPosix12(proposedTreeRoot, targetPath),
@@ -24055,9 +24111,7 @@ function validateDuplicateTargets(mappingRecords, plannedEmissions) {
       conflictingTargets.add(targetPath);
     }
   }
-  for (const targetPath of [...conflictingTargets].sort(
-    (left, right) => left < right ? -1 : left > right ? 1 : 0
-  )) {
+  for (const targetPath of [...conflictingTargets].sort(compareCodePoint)) {
     for (const plannedEmission of sectionEmissionsByTarget.get(targetPath) ?? []) {
       findings.push(
         buildFinding({
@@ -24100,17 +24154,19 @@ function validateConversionPlan(runOptions, mappingRecords, plannedEmissions, ge
     ...validateDuplicateTargets(mappingRecords, plannedEmissions),
     ...validateGeneratedOutput(generatedOutput)
   ];
-  const compare = (left, right) => left < right ? -1 : left > right ? 1 : 0;
   return [...findings].sort((left, right) => {
-    const byCode = compare(left.code, right.code);
+    const byCode = compareCodePoint(left.code, right.code);
     if (byCode !== 0) {
       return byCode;
     }
-    const bySource = compare(left.sourcePath ?? "", right.sourcePath ?? "");
+    const bySource = compareCodePoint(
+      left.sourcePath ?? "",
+      right.sourcePath ?? ""
+    );
     if (bySource !== 0) {
       return bySource;
     }
-    return compare(left.targetPath ?? "", right.targetPath ?? "");
+    return compareCodePoint(left.targetPath ?? "", right.targetPath ?? "");
   });
 }
 
@@ -24887,13 +24943,13 @@ function validateLaunchBindings(features, context) {
   });
   return errors;
 }
-function validateEpicPlannerChildLaunchBindings(features) {
+function validateEpicPlannerChildLaunchBindings(features, options = {}) {
   return validateLaunchBindings(features, {
     expectedExecutionContext: "epic_preparation_child",
     planner: true,
     requireGeneratedOrchestrator: true,
     skipNotStarted: false,
-    requireLaunchPaths: false
+    requireLaunchPaths: options.requireLaunchPaths === true
   });
 }
 function validateEpicChildLaunchBindings(state, options = {}) {
@@ -25260,7 +25316,7 @@ function validateCodexModelRoutingGate(state) {
       deploymentAgents.add(deployment);
     }
   }
-  for (const agent of [...delegated].sort()) {
+  for (const agent of [...delegated].sort(compareCodePoint)) {
     if (!logicalAgents.has(agent) && !deploymentAgents.has(agent)) {
       errors.push(
         `Checkpoint ${CODEX_MODEL_ROUTING_RECEIPTS_KEY} is missing a receipt for delegated agent: ${agent}.`
@@ -25354,7 +25410,7 @@ function normalizeLanguages(value) {
   const normalized = new Set(
     value.map((language) => language.trim().toLowerCase())
   );
-  return [...normalized].sort();
+  return [...normalized].sort(compareCodePoint);
 }
 function requireInteger(value, fieldName) {
   if (typeof value !== "number" || !Number.isInteger(value)) {
@@ -25690,7 +25746,7 @@ function validateCodexTopologyGate(state, options = {}) {
     allowedNames.add(receipt.logical_agent);
     if ([...delegated].every((agent) => !allowedNames.has(agent))) {
       errors.push(
-        `Checkpoint delegation_receipts is missing the exact resolved topology agent for ${receipt.logical_agent}: ${[...allowedNames].sort().join(", ")}.`
+        `Checkpoint delegation_receipts is missing the exact resolved topology agent for ${receipt.logical_agent}: ${[...allowedNames].sort(compareCodePoint).join(", ")}.`
       );
     }
   }
@@ -25739,6 +25795,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);
 }
@@ -25799,7 +25856,7 @@ function validateFeatureFolderUniquenessAndDependencies(features) {
       }
     }
   }
-  for (const folder of [...duplicates].sort()) {
+  for (const folder of [...duplicates].sort(compareCodePoint)) {
     errors.push(
       `Epic checkpoint has duplicate features[].feature_folder: ${folder}`
     );
@@ -25819,6 +25876,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 +25895,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 +25909,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`
         );
       }
     }
@@ -26127,6 +26194,53 @@ function validateCommittedFile(git, ref, path16, label) {
   }
   return [];
 }
+function repositoryRelativePath(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return {
+      errors: [`${field} must be a non-empty repository-relative path.`]
+    };
+  }
+  if (value.includes("\\")) {
+    return { errors: [`${field} must use forward slashes.`] };
+  }
+  const parts = value.split("/").filter((part) => part.length > 0 && part !== ".");
+  if (value.startsWith("/") || /^[A-Za-z]:/.test(value) || parts.includes("..")) {
+    return { errors: [`${field} must stay within the workspace root.`] };
+  }
+  return { path: parts.length === 0 ? "." : parts.join("/"), errors: [] };
+}
+function derivedPlanPath(feature) {
+  return repositoryRelativePath(feature["plan_path"], "plan_path").path;
+}
+function pairPlansWithFeatures(features, plans) {
+  const entries = [];
+  if (Array.isArray(features)) {
+    features.forEach((item, index) => {
+      if (isRecord(item)) {
+        entries.push([index, item]);
+      }
+    });
+  }
+  const paired = [];
+  let position = 0;
+  for (const plan of plans) {
+    let entry = entries[position];
+    while (entry !== void 0 && derivedPlanPath(entry[1]) !== plan) {
+      position += 1;
+      entry = entries[position];
+    }
+    if (entry === void 0) {
+      return plans.map((fallbackPlan, slot) => [
+        slot,
+        entries[slot]?.[1] ?? {},
+        fallbackPlan
+      ]);
+    }
+    paired.push([entry[0], entry[1], plan]);
+    position += 1;
+  }
+  return paired;
+}
 function validatePlanningGitIntegrity(state, parsed, plans, git) {
   const branch = state["integration_branch"];
   if (typeof branch !== "string" || !git.refExists(branch)) {
@@ -26148,8 +26262,8 @@ function validatePlanningGitIntegrity(state, parsed, plans, git) {
       );
     }
   }
-  const features = Array.isArray(state["features"]) ? state["features"].filter(isRecord) : [];
-  plans.forEach((plan, index) => {
+  const pairs = pairPlansWithFeatures(state["features"], plans);
+  pairs.forEach(([index, feature, plan]) => {
     const derived = git.lastCommit(plan);
     if (derived === void 0) {
       errors.push(
@@ -26164,7 +26278,6 @@ function validatePlanningGitIntegrity(state, parsed, plans, git) {
       return;
     }
     const candidates = [derived];
-    const feature = features[index] ?? {};
     const featureCommit = feature["planning_commit"];
     if (featureCommit !== void 0) {
       if (typeof featureCommit !== "string" || !COMMIT_RE.test(featureCommit)) {
@@ -26222,7 +26335,7 @@ function validatePlanningGitIntegrity(state, parsed, plans, git) {
       }
     }
   });
-  for (const extra of Object.keys(integrity.planHashes).filter((path16) => !plans.includes(path16)).sort()) {
+  for (const extra of Object.keys(integrity.planHashes).filter((path16) => !plans.includes(path16)).sort(compareCodePoint)) {
     errors.push(
       `Optional plan_hashes contains unknown planner path: '${extra}'.`
     );
@@ -26508,7 +26621,7 @@ function validateStatus(feature, index, receipt, receiptPath, status, statusPath
   }
   return errors;
 }
-function validateEpicPlannerLaunchEvidence(state, context) {
+function validateEpicPlannerLaunchEvidence(state, context, options = {}) {
   const features = state["features"];
   if (!Array.isArray(features)) {
     return [];
@@ -26520,6 +26633,9 @@ function validateEpicPlannerLaunchEvidence(state, context) {
     if (!isRecord2(item)) {
       return;
     }
+    if (options.requireLaunchPaths === true && !featureCarriesLaunchPath(item)) {
+      return;
+    }
     const receipt = validateReceipt3(item, index, context);
     errors.push(...receipt.errors);
     const featureStatus = launchPath(
@@ -26566,21 +26682,6 @@ var SLUG_RE = /^[a-z0-9][a-z0-9-]*$/;
 function join9(root, relative2) {
   return `${toPosixPath2(root).replace(/\/+$/, "")}/${relative2.replace(/^\/+/, "")}`;
 }
-function relativePath(value, field) {
-  if (typeof value !== "string" || value.trim().length === 0) {
-    return {
-      errors: [`${field} must be a non-empty repository-relative path.`]
-    };
-  }
-  if (value.includes("\\")) {
-    return { errors: [`${field} must use forward slashes.`] };
-  }
-  const parts = value.split("/");
-  if (value.startsWith("/") || /^[A-Za-z]:/.test(value) || parts.includes("..") || parts.includes(".")) {
-    return { errors: [`${field} must stay within the workspace root.`] };
-  }
-  return { path: parts.join("/"), errors: [] };
-}
 function readRequired(context, relative2, label) {
   const path16 = join9(context.workspaceRoot, relative2);
   if (!context.fileSystem.isFile(path16)) {
@@ -26621,12 +26722,15 @@ function validateArtifactSource(stateText, context) {
 }
 function validateFeatureFiles(feature, index, context) {
   const prefix = `Epic planner checkpoint features[${index}]`;
-  const folderResult = relativePath(
+  const folderResult = repositoryRelativePath(
     feature["feature_folder"],
     `${prefix}.feature_folder`
   );
-  const planResult = relativePath(feature["plan_path"], `${prefix}.plan_path`);
-  const researchResult = relativePath(
+  const planResult = repositoryRelativePath(
+    feature["plan_path"],
+    `${prefix}.plan_path`
+  );
+  const researchResult = repositoryRelativePath(
     feature["research_path"],
     `${prefix}.research_path`
   );
@@ -26671,7 +26775,7 @@ function validateFeatureFiles(feature, index, context) {
   const evidenceValue = feature["preflight_evidence_path"];
   const evidencePaths = [];
   if (evidenceValue !== void 0) {
-    const evidence = relativePath(
+    const evidence = repositoryRelativePath(
       evidenceValue,
       `${prefix}.preflight_evidence_path`
     );
@@ -26752,7 +26856,7 @@ function validateKickoffAgainstState(parsed, state, label) {
   }
   return errors;
 }
-function validateEpicReadinessIntegrity(state, stateText, context) {
+function validateEpicReadinessIntegrity(state, stateText, context, options = {}) {
   const errors = validateArtifactSource(stateText, context);
   const slug = state["epic_feature_folder"];
   if (typeof slug !== "string" || !SLUG_RE.test(slug)) {
@@ -26773,7 +26877,7 @@ function validateEpicReadinessIntegrity(state, stateText, context) {
   }
   const manifest = readRequired(context, manifestPath, "the epic manifest");
   errors.push(...manifest.errors);
-  const ignoredResult = relativePath(
+  const ignoredResult = repositoryRelativePath(
     state["kickoff_prompt_path"],
     "Epic planner checkpoint kickoff_prompt_path"
   );
@@ -26821,7 +26925,7 @@ function validateEpicReadinessIntegrity(state, stateText, context) {
       }
     });
   }
-  errors.push(...validateEpicPlannerLaunchEvidence(state, context));
+  errors.push(...validateEpicPlannerLaunchEvidence(state, context, options));
   if (parsed !== void 0) {
     errors.push(
       ...validatePlanningGitIntegrity(state, parsed, plans, context.git),
@@ -26957,18 +27061,19 @@ function extractFeatures2(value) {
   if (!Array.isArray(value)) {
     return {
       errors: ["Epic planner checkpoint features must be a list."],
-      features: []
+      indexedFeatures: [],
+      entries: []
     };
   }
   const errors = [];
-  const features = [];
+  const indexedFeatures = [];
   value.forEach((item, index) => {
     const prefix = `Epic planner checkpoint features[${index}]`;
     if (!isObject7(item)) {
       errors.push(`${prefix} must be an object.`);
       return;
     }
-    features.push(item);
+    indexedFeatures.push([index, item]);
     const missing = REQUIRED_FEATURE_KEYS.filter((key) => !(key in item));
     if (missing.length > 0) {
       errors.push(`${prefix} missing required keys: ${missing.join(", ")}.`);
@@ -26988,13 +27093,14 @@ function extractFeatures2(value) {
       );
     }
   });
-  return { errors, features };
+  return { errors, indexedFeatures, entries: value };
 }
-function validateDependencyWaves(features) {
+function validateDependencyWaves(indexedFeatures) {
+  const features = indexedFeatures.map(([, feature]) => feature);
   const errors = [];
   const seenFolders = /* @__PURE__ */ new Set();
   const seenIssues = /* @__PURE__ */ new Set();
-  features.forEach((feature, index2) => {
+  indexedFeatures.forEach(([index2, feature]) => {
     const prefix = `Epic planner checkpoint features[${index2}]`;
     const folder = feature["feature_folder"];
     if (typeof folder === "string" && folder.length > 0) {
@@ -27017,7 +27123,7 @@ function validateDependencyWaves(features) {
   });
   const index = buildFeatureReferenceIndex(features);
   const manifest = /* @__PURE__ */ new Map();
-  features.forEach((feature, featureIndex) => {
+  indexedFeatures.forEach(([featureIndex, feature]) => {
     const folder = feature["feature_folder"];
     const dependencies = feature["depends_on"];
     if (typeof folder !== "string" || folder.length === 0 || !Array.isArray(dependencies)) {
@@ -27046,7 +27152,7 @@ function validateDependencyWaves(features) {
     }
     throw error2;
   }
-  features.forEach((feature, index2) => {
+  indexedFeatures.forEach(([index2, feature]) => {
     const folder = feature["feature_folder"];
     if (typeof folder !== "string" || !expectedWaves.has(folder)) {
       return;
@@ -27060,14 +27166,14 @@ function validateDependencyWaves(features) {
   });
   return errors;
 }
-function validateReadyFeatures(features) {
+function validateReadyFeatures(indexedFeatures, keyGated) {
   const errors = [];
-  if (features.length < 2) {
+  if (indexedFeatures.length < 2) {
     errors.push(
       "Execution-ready epic planning requires at least two features."
     );
   }
-  features.forEach((feature, index) => {
+  indexedFeatures.forEach(([index, feature]) => {
     const prefix = `Epic planner checkpoint features[${index}]`;
     const issueNum = feature["issue_num"];
     if (typeof issueNum !== "number" || !Number.isInteger(issueNum) || issueNum <= 0) {
@@ -27089,36 +27195,40 @@ function validateReadyFeatures(features) {
     if (feature["preflight_status"] !== "PREFLIGHT: ALL CLEAR") {
       errors.push(`${prefix}.preflight_status must be 'PREFLIGHT: ALL CLEAR'.`);
     }
-    const receipt = feature["model_routing_receipt"];
-    errors.push(
-      ...validateCodexModelRoutingReceipt(
-        receipt,
-        `${prefix}.model_routing_receipt`
-      )
-    );
-    if (isObject7(receipt) && receipt["logical_agent"] !== "orchestrator") {
+    if (!keyGated || "model_routing_receipt" in feature) {
+      const receipt = feature["model_routing_receipt"];
       errors.push(
-        `${prefix}.model_routing_receipt.logical_agent must be 'orchestrator'.`
+        ...validateCodexModelRoutingReceipt(
+          receipt,
+          `${prefix}.model_routing_receipt`
+        )
       );
-    }
-    if (isObject7(receipt)) {
-      if (receipt["complexity_band"] !== feature["complexity_band"]) {
+      if (isObject7(receipt) && receipt["logical_agent"] !== "orchestrator") {
         errors.push(
-          `${prefix}.model_routing_receipt.complexity_band must match feature complexity_band ${pythonRepr6(feature["complexity_band"])}.`
+          `${prefix}.model_routing_receipt.logical_agent must be 'orchestrator'.`
         );
       }
-      if (receipt["execution_context"] !== "epic_preparation_child") {
-        errors.push(
-          `${prefix}.model_routing_receipt.execution_context must be 'epic_preparation_child'.`
-        );
+      if (isObject7(receipt)) {
+        if (receipt["complexity_band"] !== feature["complexity_band"]) {
+          errors.push(
+            `${prefix}.model_routing_receipt.complexity_band must match feature complexity_band ${pythonRepr6(feature["complexity_band"])}.`
+          );
+        }
+        if (receipt["execution_context"] !== "epic_preparation_child") {
+          errors.push(
+            `${prefix}.model_routing_receipt.execution_context must be 'epic_preparation_child'.`
+          );
+        }
       }
     }
-    errors.push(
-      ...validateChildTopologyReceipt(
-        feature["topology_receipt"],
-        `${prefix}.topology_receipt`
-      )
-    );
+    if (!keyGated || "topology_receipt" in feature) {
+      errors.push(
+        ...validateChildTopologyReceipt(
+          feature["topology_receipt"],
+          `${prefix}.topology_receipt`
+        )
+      );
+    }
   });
   return errors;
 }
@@ -27141,7 +27251,7 @@ function validateEpicPlannerStateText(text2, options = {}) {
   errors.push(...worthiness.errors);
   const featureResult = extractFeatures2(value["features"]);
   errors.push(...featureResult.errors);
-  errors.push(...validateDependencyWaves(featureResult.features));
+  errors.push(...validateDependencyWaves(featureResult.indexedFeatures));
   const maxParallel = value["max_parallel_features"];
   if (typeof maxParallel !== "number" || !Number.isInteger(maxParallel) || maxParallel < 1 || maxParallel > 8) {
     errors.push(
@@ -27154,6 +27264,7 @@ function validateEpicPlannerStateText(text2, options = {}) {
     );
   }
   if (options.requireReadyForExecution === true) {
+    const requireLaunchPaths = options.requireCodexModelRouting !== true && options.requireCodexTopology !== true;
     if (worthiness.verdict !== "epic") {
       errors.push(
         "Execution readiness requires epic_worthiness.verdict 'epic'."
@@ -27164,11 +27275,20 @@ function validateEpicPlannerStateText(text2, options = {}) {
         `Execution-ready planner checkpoint next_step must be '${READY_NEXT_STEP}'.`
       );
     }
-    errors.push(...validateReadyFeatures(featureResult.features));
     errors.push(
-      ...validateEpicPlannerChildLaunchBindings(featureResult.features)
+      ...validateReadyFeatures(
+        featureResult.indexedFeatures,
+        requireLaunchPaths
+      )
+    );
+    errors.push(
+      ...validateEpicPlannerChildLaunchBindings(featureResult.entries, {
+        requireLaunchPaths
+      })
     );
-    errors.push(...validatePlannerTopologyReceipt(value["topology_receipt"]));
+    if (!requireLaunchPaths || "topology_receipt" in value) {
+      errors.push(...validatePlannerTopologyReceipt(value["topology_receipt"]));
+    }
     const expectedKickoff = `artifacts/orchestration/epic-kickoff-${String(
       value["epic_feature_folder"]
     )}.md`;
@@ -27186,7 +27306,8 @@ function validateEpicPlannerStateText(text2, options = {}) {
         ...validateEpicReadinessIntegrity(
           value,
           text2,
-          options.readinessContext
+          options.readinessContext,
+          { requireLaunchPaths }
         )
       );
     }
@@ -27194,6 +27315,215 @@ 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 RECORD_OPTIONAL_ORIGINS = /* @__PURE__ */ new Set([
+  "transferred",
+  "filed_before_orchestration"
+]);
+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, origin, recordPresent) {
+  if (!recordPresent && typeof origin === "string" && RECORD_OPTIONAL_ORIGINS.has(origin)) {
+    return [];
+  }
+  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"],
+      adoption["origin"],
+      Object.prototype.hasOwnProperty.call(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 +27712,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 +27744,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 +27903,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 +28045,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 +28059,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 +28145,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 +28160,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 +28178,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 +28200,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 +28235,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"];
@@ -27722,7 +28244,7 @@ function validateModelRoutingExistence(state) {
       }
     }
   }
-  return [...delegated].filter((agent) => !receiptAgents2.has(agent)).sort().map(
+  return [...delegated].filter((agent) => !receiptAgents2.has(agent)).sort(compareCodePoint).map(
     (agent) => `Checkpoint model_routing_receipts is missing a receipt for delegated agent: ${agent}.`
   );
 }
@@ -27762,15 +28284,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 +28323,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;
     }
@@ -27840,7 +28353,7 @@ function validateNamespacedDelegationReceipts(receipts) {
   const errors = [];
   const unsupportedKeys = Object.keys(receipts).filter(
     (key) => key !== AGENT_RECEIPT_NAMESPACE_KEY && key !== PROMOTION_RECEIPT_NAMESPACE_KEY
-  ).sort();
+  ).sort(compareCodePoint);
   for (const key of unsupportedKeys) {
     errors.push(
       `Checkpoint delegation_receipts object contains unsupported key: ${key}`
@@ -27858,7 +28371,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."
     );
@@ -27866,7 +28379,7 @@ function validateNamespacedDelegationReceipts(receipts) {
   }
   const unsupportedPromotionKeys = Object.keys(promotionReceipts).filter(
     (key) => !PROMOTION_RECEIPT_KEYS.includes(key)
-  ).sort();
+  ).sort(compareCodePoint);
   for (const key of unsupportedPromotionKeys) {
     errors.push(
       "Checkpoint delegation_receipts.promotion contains unsupported key: " + key
@@ -27893,7 +28406,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 +28431,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(
@@ -28336,7 +28849,7 @@ function classifyKind(argv) {
   }
   return "other";
 }
-function splitLines2(text2) {
+function splitPlanLines(text2) {
   if (text2 === "") {
     return [];
   }
@@ -28346,6 +28859,11 @@ function splitLines2(text2) {
   }
   return lines;
 }
+var PLAN_WHITESPACE_CLASS = String.raw`[\t\n\v\f\r \u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]`;
+var PLAN_WHITESPACE_RUN_RE = new RegExp(`${PLAN_WHITESPACE_CLASS}+`);
+function normalizePlanWhitespace(value) {
+  return value.split(PLAN_WHITESPACE_RUN_RE).filter((word) => word !== "").join(" ");
+}
 function inlineSpans(line) {
   const spans = [];
   for (const match of line.matchAll(INLINE_SPAN_RE)) {
@@ -28389,7 +28907,7 @@ function extractPlanCommands(text2) {
   let inFence = false;
   let windowLines = [];
   let windowStart = 0;
-  const lines = splitLines2(text2);
+  const lines = splitPlanLines(text2);
   for (let index = 0; index < lines.length; index += 1) {
     const line = lines[index] ?? "";
     const lineNumber = index + 1;
@@ -28559,7 +29077,7 @@ function planQuotesLiteral(text2, literal2, excludeSpan) {
   return normalizeWhitespace(remainder).includes(needle);
 }
 function windowJoin(lines, size = WINDOW_SIZE) {
-  const dense = lines.filter((line) => line.trim() !== "").map((line) => normalizeWhitespace(line));
+  const dense = lines.map((line) => normalizePlanWhitespace(line)).filter((line) => line !== "");
   const windows = [];
   for (let index = 0; index < dense.length; index += 1) {
     windows.push(dense.slice(index, index + size).join(" "));
@@ -28567,15 +29085,15 @@ function windowJoin(lines, size = WINDOW_SIZE) {
   return windows;
 }
 function hasCrossLinePresence(context, literal2) {
-  const words2 = literal2.split(/\s+/).filter((word) => word !== "");
+  const needle = normalizePlanWhitespace(literal2);
+  const words2 = needle.split(" ");
   if (words2.length < 2) {
     return false;
   }
-  const needle = words2.join(" ");
   const firstWord = words2[0] ?? "";
   for (const path16 of context.git.filesContaining(firstWord)) {
     const lines = context.git.readTrackedText(path16).split(/\r\n|\n|\r/);
-    if (lines.some((line) => normalizeWhitespace(line).includes(needle))) {
+    if (lines.some((line) => normalizePlanWhitespace(line).includes(needle))) {
       continue;
     }
     if (windowJoin(lines).some((window2) => window2.includes(needle))) {
@@ -28821,6 +29339,71 @@ function evaluateObservabilityGates(report, commands, context) {
   }
 }
 
+// ../../extensions/drm-copilot/src/lib/validate/plan-gate-scratch.ts
+var G10_SEVERITY = "blocking";
+var BACKTICK = "`";
+var SCRATCH_DEFINITION_PATTERN = String.raw`(?:^|[^A-Za-z0-9_<>$/.-])${BACKTICK}?SCRATCH${BACKTICK}?(?:\*\*)?[ \t]*(?:means\b|:=|=|:|is (?:the|a|an)\b|resolves to\b|abbreviates\b|denotes\b|refers to\b|stands for\b)`;
+var SCRATCH_NAMESPACE_PATTERN = String.raw`issue-(?:<issue-num>|[0-9]+)`;
+var FENCE_RE2 = /^\s*```/;
+var DEFINITION_RE = new RegExp(SCRATCH_DEFINITION_PATTERN);
+var NAMESPACE_RE = new RegExp(SCRATCH_NAMESPACE_PATTERN);
+var LEADING_WHITESPACE_RE = new RegExp(`^${PLAN_WHITESPACE_CLASS}`);
+function continuesLogicalLine(line) {
+  if (normalizePlanWhitespace(line) === "" || !LEADING_WHITESPACE_RE.test(line)) {
+    return false;
+  }
+  return !FENCE_RE2.test(line);
+}
+function isBareDefinition(logical) {
+  const match = DEFINITION_RE.exec(logical);
+  if (match === null) {
+    return false;
+  }
+  return !NAMESPACE_RE.test(logical.slice(match.index + match[0].length));
+}
+function recordIfBare(findings, pending) {
+  const logical = normalizePlanWhitespace(pending.parts.join(" "));
+  if (isBareDefinition(logical)) {
+    findings.push([pending.start + 1, logical]);
+  }
+}
+function bareScratchDefinitions(text2) {
+  const findings = [];
+  let inFence = false;
+  let pending = null;
+  for (const [index, line] of splitPlanLines(text2).entries()) {
+    if (pending !== null && continuesLogicalLine(line)) {
+      pending.parts.push(line);
+      continue;
+    }
+    if (pending !== null) {
+      recordIfBare(findings, pending);
+      pending = null;
+    }
+    if (FENCE_RE2.test(line)) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence || normalizePlanWhitespace(line) === "") {
+      continue;
+    }
+    pending = { start: index, parts: [line] };
+  }
+  if (pending !== null) {
+    recordIfBare(findings, pending);
+  }
+  return findings;
+}
+function scratchFindingMessage(lineNumber, logicalLine) {
+  return `Line ${String(lineNumber)}: SCRATCH definition \`${logicalLine}\` is not namespaced by issue number; define SCRATCH as \`<session scratchpad>/issue-<issue-num>/\`.`;
+}
+function evaluateScratchGate(report, text2, severity = G10_SEVERITY) {
+  const channel = severity === "blocking" ? report.blocking : report.warnings;
+  for (const [lineNumber, logicalLine] of bareScratchDefinitions(text2)) {
+    channel.push(scratchFindingMessage(lineNumber, logicalLine));
+  }
+}
+
 // ../../extensions/drm-copilot/src/lib/validate/plan-gate-discrimination.ts
 var G5_SEVERITY = "warning";
 var CommandRunnerPlanGateRepository = class {
@@ -28920,6 +29503,7 @@ function evaluatePlanGates(text2, context) {
   if (context !== void 0) {
     evaluateLiteralRules(report, text2, commands, context);
   }
+  evaluateScratchGate(report, text2);
   return report;
 }
 
@@ -28955,10 +29539,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 +29553,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 +29588,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 +29630,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 +29679,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 +29698,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 +29717,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 +29733,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 +29756,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 +29791,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 +29808,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 +29842,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 +29864,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 +29902,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 +29921,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 +29936,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 +29952,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 +29969,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 +30013,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 +30058,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 +30076,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 +30097,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 +30108,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 +30118,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 +30130,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 +30175,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 +30183,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 +30213,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 +30243,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 +30322,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 +30332,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 +30388,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 +30396,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 +30405,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 +30424,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 = [];
@@ -29855,6 +30439,110 @@ function validateParallelOrchestratorStateText(text2, options = {}) {
   return errors;
 }
 
+// ../../extensions/drm-copilot/src/lib/validate/parallel-planner-state-routing.ts
+var BAND_ORDER2 = ["C1", "C2", "C3", "C4"];
+var VALID_FABLE_POLICIES = [
+  "disabled",
+  "available",
+  "preferred"
+];
+var ROUTING_AGENT = "orchestrator";
+function sameValue(left, right) {
+  return JSON.stringify(left ?? null) === JSON.stringify(right ?? null);
+}
+function isListOfStrings(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function validateAssessmentEntry(assessment, context) {
+  const errors = [];
+  const band = assessment["band"];
+  const floor = assessment["floor"];
+  if (!isEnumMember(BAND_ORDER2, band)) {
+    errors.push(
+      `${context} band must be one of C1, C2, C3, C4; got: ${pythonStr2(band)}.`
+    );
+  }
+  if (!isListOfStrings(assessment["signals_present"])) {
+    errors.push(`${context} signals_present must be a list of strings.`);
+  }
+  if (isEnumMember(BAND_ORDER2, band) && isEnumMember(BAND_ORDER2, floor) && BAND_ORDER2.indexOf(String(band)) < BAND_ORDER2.indexOf(String(floor))) {
+    errors.push(
+      `${context} band ${pythonStr2(band)} is below its floor ${pythonStr2(floor)}.`
+    );
+  }
+  if (!isNonEmptyString2(assessment["rationale"])) {
+    errors.push(`${context} rationale must be a non-empty string.`);
+  }
+  return errors;
+}
+function validateAssessment(assessment, band, entryContext) {
+  const context = `${entryContext} complexity_assessment`;
+  const errors = validateAssessmentEntry(assessment, context);
+  if (!isNonEmptyString2(assessment["assessed_at"])) {
+    errors.push(`${context}.assessed_at must be a non-empty string.`);
+  }
+  const assessedBand = assessment["band"];
+  if (!sameValue(assessedBand, band)) {
+    errors.push(
+      `${context}.band ${pythonRepr10(assessedBand)} does not equal complexity_band ${pythonRepr10(band)}.`
+    );
+  }
+  return errors;
+}
+function validateReceipt4(receipt, band, entryContext) {
+  const context = `${entryContext} model_routing_receipt`;
+  const errors = [];
+  const receiptBand = receipt["complexity_band"];
+  if (!isEnumMember(BAND_ORDER2, receiptBand)) {
+    errors.push(
+      `${context} complexity_band must be one of C1, C2, C3, C4; got: ${pythonStr2(receiptBand)}.`
+    );
+  }
+  const agent = receipt["agent"];
+  if (agent !== ROUTING_AGENT) {
+    errors.push(
+      `${context}.agent must be ${pythonRepr10(ROUTING_AGENT)}; found: ${pythonRepr10(agent)}.`
+    );
+  }
+  if (!sameValue(receiptBand, band)) {
+    errors.push(
+      `${context}.complexity_band ${pythonRepr10(receiptBand)} does not equal complexity_band ${pythonRepr10(band)}.`
+    );
+  }
+  const fablePolicy = receipt["fable_policy"];
+  if (!isEnumMember(VALID_FABLE_POLICIES, fablePolicy)) {
+    errors.push(
+      enumError(
+        entryContext,
+        "model_routing_receipt.fable_policy",
+        VALID_FABLE_POLICIES,
+        fablePolicy
+      )
+    );
+  }
+  return errors;
+}
+function validateReadyItemRouting(record3, entryContext) {
+  const errors = [];
+  const band = record3["complexity_band"];
+  if (!isEnumMember(BAND_ORDER2, band)) {
+    errors.push(enumError(entryContext, "complexity_band", BAND_ORDER2, band));
+  }
+  const assessment = record3["complexity_assessment"];
+  if (isObject15(assessment)) {
+    errors.push(...validateAssessment(assessment, band, entryContext));
+  } else {
+    errors.push(`${entryContext} complexity_assessment must be an object.`);
+  }
+  const receipt = record3["model_routing_receipt"];
+  if (isObject15(receipt)) {
+    errors.push(...validateReceipt4(receipt, band, entryContext));
+  } else {
+    errors.push(`${entryContext} model_routing_receipt must be an object.`);
+  }
+  return errors;
+}
+
 // ../../extensions/drm-copilot/src/lib/validate/parallel-planner-state-core.ts
 var CONTEXT2 = "Parallel planner checkpoint";
 var MIN_CONCURRENCY2 = 1;
@@ -29918,7 +30606,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 +30617,7 @@ function itemRecords(items) {
   }
   const records = [];
   items.forEach((entry, index) => {
-    if (isObject14(entry)) {
+    if (isObject15(entry)) {
       records.push({ index, record: entry });
     }
   });
@@ -29998,13 +30686,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 +30701,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;
@@ -30032,20 +30720,22 @@ function validateReadyGate(state) {
       );
     }
     for (const { index, record: record3 } of itemRecords(items)) {
-      errors.push(...validateReadyItem(record3, itemContext(CONTEXT2, index)));
+      const entryContext = itemContext(CONTEXT2, index);
+      errors.push(...validateReadyItem(record3, entryContext));
+      errors.push(...validateReadyItemRouting(record3, entryContext));
     }
   }
   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 +30748,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 = [];
@@ -31198,6 +31888,8 @@ function dispatchValidatorErrors(input) {
     case "epic-planner-state": {
       const options = {
         ...input.requireReadyForExecution === void 0 ? {} : { requireReadyForExecution: input.requireReadyForExecution },
+        ...input.requireCodexModelRouting === void 0 ? {} : { requireCodexModelRouting: input.requireCodexModelRouting },
+        ...input.requireCodexTopology === void 0 ? {} : { requireCodexTopology: input.requireCodexTopology },
         ...input.fs === void 0 || input.root === void 0 || input.artifactPath === void 0 || input.runner === void 0 ? {} : {
           readinessContext: {
             workspaceRoot: input.root,
@@ -31395,6 +32087,76 @@ function createGitCheckoutContext(runner) {
   return { observe, isHeadRelationshipSatisfied };
 }
 
+// ../../extensions/drm-copilot/src/lib/validate/orchestration-handoff-materializer-request.ts
+var HANDOFF_ERROR_CODE_PATTERN = /^[A-Z][A-Z0-9_]*$/;
+var HANDOFF_ERROR_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function describeHandoffFailureCause(stage, error2) {
+  if (typeof error2 === "object" && error2 !== null && "code" in error2) {
+    const code = error2.code;
+    if (typeof code === "string" && HANDOFF_ERROR_CODE_PATTERN.test(code)) {
+      return `${stage}: ${code}`;
+    }
+  }
+  if (error2 instanceof Error) {
+    return HANDOFF_ERROR_NAME_PATTERN.test(error2.name) ? `${stage}: ${error2.name}` : `${stage}: Error`;
+  }
+  return `${stage}: non-error value`;
+}
+function describeEnvelopeParseFailure(error2) {
+  return {
+    code: error2 instanceof HandoffContractError ? error2.code : "HANDOFF_UNSUPPORTED_VERSION",
+    failureCause: describeHandoffFailureCause("envelope-parse", error2)
+  };
+}
+function toReferenceRequest(request) {
+  return {
+    workspaceRoot: request.workspaceRoot,
+    handoffEnvelopePath: request.handoffEnvelopePath,
+    expectedHandoffEnvelopeSha256: request.expectedHandoffEnvelopeSha256,
+    destinationProvider: request.destinationProvider,
+    expectedRepositoryId: request.expectedRepositoryId,
+    expectedWorkspaceRoot: request.expectedWorkspaceRoot,
+    expectedBranch: request.expectedBranch,
+    expectedSourceHeadSha: request.expectedSourceHeadSha,
+    allowedHeadRelationship: request.allowedHeadRelationship,
+    expectedIssueNumber: request.expectedIssueNumber,
+    expectedFeatureFolder: request.expectedFeatureFolder,
+    expectedWorkMode: request.expectedWorkMode,
+    expectedPlanPath: request.expectedPlanPath,
+    expectedPlanSha256: request.expectedPlanSha256
+  };
+}
+function blockedResult(request, primaryFailureCode, options = {}) {
+  return {
+    status: "blocked",
+    handoffId: options.handoffId ?? null,
+    sourceCheckpointSha256: request.expectedSourceCheckpointSha256,
+    handoffEnvelopeSha256: request.expectedHandoffEnvelopeSha256,
+    handoffHistorySha256: options.handoffHistorySha256 ?? null,
+    requestedTransition: "prepared_to_atomic_execution",
+    destinationCheckpointPath: null,
+    destinationCheckpointSha256: null,
+    primaryFailureCode,
+    affectedPaths: options.affectedPaths ?? [],
+    unsupportedCapabilities: options.unsupportedCapabilities ?? [],
+    ...options.failureCause === void 0 ? {} : { failureCause: options.failureCause }
+  };
+}
+function authorityFailure(request, authority, handoffHistorySha256) {
+  if (authority.status === "validated") return null;
+  return blockedResult(
+    request,
+    authority.primaryFailureCode ?? "HANDOFF_VALIDATOR_UNAVAILABLE",
+    {
+      handoffId: authority.handoffId,
+      handoffHistorySha256,
+      affectedPaths: authority.affectedPaths,
+      unsupportedCapabilities: authority.unsupportedCapabilities,
+      ...authority.failureCause === void 0 ? {} : { failureCause: authority.failureCause }
+    }
+  );
+}
+
 // ../../extensions/drm-copilot/src/lib/validate/orchestration-handoff-path-boundary.ts
 var fs6 = __toESM(require("node:fs"));
 var path11 = __toESM(require("node:path"));
@@ -31423,6 +32185,13 @@ function normalizedRepositorySegments(repositoryPath2) {
 function missingPath(error2) {
   return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
 }
+function guardedResolution(stage, operation) {
+  try {
+    return { ok: true, value: operation() };
+  } catch (error2) {
+    return { ok: false, cause: describeHandoffFailureCause(stage, error2) };
+  }
+}
 function lexicalCandidate(canonicalWorkspaceRoot, repositoryPath2, caseSensitive) {
   if (!path11.isAbsolute(canonicalWorkspaceRoot)) return null;
   const segments = normalizedRepositorySegments(repositoryPath2);
@@ -31433,14 +32202,13 @@ function lexicalCandidate(canonicalWorkspaceRoot, repositoryPath2, caseSensitive
 function createHandoffPathBoundary(fileSystem, caseSensitive = process.platform !== "win32") {
   const resolveWorkspaceRoot = (workspaceRoot) => {
     if (!path11.isAbsolute(workspaceRoot)) return null;
-    try {
+    const resolution = guardedResolution("workspace-root", () => {
       const canonicalRoot = normalizedAbsolutePath(
         fileSystem.realpath(path11.resolve(workspaceRoot))
       );
       return fileSystem.stat(canonicalRoot).isDirectory() ? canonicalRoot : null;
-    } catch {
-      return null;
-    }
+    });
+    return resolution.ok ? resolution.value : null;
   };
   const resolveExistingTarget = (canonicalWorkspaceRoot, repositoryPath2) => {
     const candidate = lexicalCandidate(
@@ -31449,14 +32217,12 @@ function createHandoffPathBoundary(fileSystem, caseSensitive = process.platform
       caseSensitive
     );
     if (candidate === null) return null;
-    try {
-      const canonicalTarget = normalizedAbsolutePath(
-        fileSystem.realpath(candidate)
-      );
-      return isContained(canonicalWorkspaceRoot, canonicalTarget, caseSensitive) ? canonicalTarget : null;
-    } catch {
-      return null;
-    }
+    const resolution = guardedResolution(
+      "target-path",
+      () => normalizedAbsolutePath(fileSystem.realpath(candidate))
+    );
+    if (!resolution.ok) return null;
+    return isContained(canonicalWorkspaceRoot, resolution.value, caseSensitive) ? resolution.value : null;
   };
   const resolveCreatableTarget = (canonicalWorkspaceRoot, repositoryPath2) => {
     const candidate = lexicalCandidate(
@@ -31559,7 +32325,8 @@ function blocked(request, code, options = {}) {
     primaryFailureCode: code,
     affectedPaths: options.affectedPaths ?? [],
     unsupportedCapabilities: options.unsupportedCapabilities ?? [],
-    resolution: null
+    resolution: null,
+    ...options.failureCause === void 0 ? {} : { failureCause: options.failureCause }
   };
 }
 function readEnvelope(fileSystem, request, pathBoundary, canonicalWorkspaceRoot) {
@@ -31568,13 +32335,17 @@ function readEnvelope(fileSystem, request, pathBoundary, canonicalWorkspaceRoot)
     request.handoffEnvelopePath
   );
   if (envelopePath === null) {
-    return blocked(request, "HANDOFF_PLAN_PATH_INVALID");
+    return blocked(request, "HANDOFF_PLAN_PATH_INVALID", {
+      failureCause: "target-path: unresolved"
+    });
   }
   let envelopeText;
   try {
     envelopeText = fileSystem.readTextFile(envelopePath);
-  } catch {
-    return blocked(request, "HANDOFF_VALIDATOR_UNAVAILABLE");
+  } catch (error2) {
+    return blocked(request, "HANDOFF_VALIDATOR_UNAVAILABLE", {
+      failureCause: describeHandoffFailureCause("envelope-read", error2)
+    });
   }
   if (sha256(envelopeText) !== request.expectedHandoffEnvelopeSha256) {
     return blocked(request, "HANDOFF_SOURCE_HASH_MISMATCH");
@@ -31582,10 +32353,10 @@ function readEnvelope(fileSystem, request, pathBoundary, canonicalWorkspaceRoot)
   try {
     return parseHandoffEnvelopeText(envelopeText);
   } catch (error2) {
-    return blocked(
-      request,
-      error2 instanceof HandoffContractError ? error2.code : "HANDOFF_UNSUPPORTED_VERSION"
-    );
+    const failure = describeEnvelopeParseFailure(error2);
+    return blocked(request, failure.code, {
+      failureCause: failure.failureCause
+    });
   }
 }
 function observedPlanSha256(fileSystem, expectedPlanPath, pathBoundary, canonicalWorkspaceRoot) {
@@ -31593,11 +32364,11 @@ function observedPlanSha256(fileSystem, expectedPlanPath, pathBoundary, canonica
     canonicalWorkspaceRoot,
     expectedPlanPath
   );
-  if (planPath === null) return null;
+  if (planPath === null) return { failureCause: "target-path: unresolved" };
   try {
-    return sha256(fileSystem.readTextFile(planPath));
-  } catch {
-    return null;
+    return { sha256: sha256(fileSystem.readTextFile(planPath)) };
+  } catch (error2) {
+    return { failureCause: describeHandoffFailureCause("plan-read", error2) };
   }
 }
 function canonicalizeObservedPath(value) {
@@ -31657,7 +32428,9 @@ function resolvePortableHandoffAuthority(fileSystem, request, kind, pathBoundary
     request.workspaceRoot
   );
   if (canonicalWorkspaceRoot === null) {
-    return blocked(request, "HANDOFF_PLAN_PATH_INVALID");
+    return blocked(request, "HANDOFF_PLAN_PATH_INVALID", {
+      failureCause: "workspace-root: unresolved"
+    });
   }
   const effectiveCheckoutContext = checkoutContext ?? createGitCheckoutContext(new SubprocessRunner());
   const observation = effectiveCheckoutContext.observe(
@@ -31695,17 +32468,19 @@ function resolvePortableHandoffAuthority(fileSystem, request, kind, pathBoundary
       handoffId: envelope.handoffId
     });
   }
-  const planSha256 = observedPlanSha256(
+  const planObservation = observedPlanSha256(
     fileSystem,
     request.expectedPlanPath,
     effectivePathBoundary,
     canonicalWorkspaceRoot
   );
-  if (planSha256 === null) {
+  if ("failureCause" in planObservation) {
     return blocked(request, "HANDOFF_PLAN_PATH_INVALID", {
-      handoffId: envelope.handoffId
+      handoffId: envelope.handoffId,
+      failureCause: planObservation.failureCause
     });
   }
+  const planSha256 = planObservation.sha256;
   const validation = collectHandoffValidationFailures(envelope, {
     repositoryId: request.expectedRepositoryId,
     workspaceRoot: request.expectedWorkspaceRoot,
@@ -31809,54 +32584,6 @@ function porcelainAffectedPaths(output) {
   return [...paths].sort((left, right) => left.localeCompare(right));
 }
 
-// ../../extensions/drm-copilot/src/lib/validate/orchestration-handoff-materializer-request.ts
-function toReferenceRequest(request) {
-  return {
-    workspaceRoot: request.workspaceRoot,
-    handoffEnvelopePath: request.handoffEnvelopePath,
-    expectedHandoffEnvelopeSha256: request.expectedHandoffEnvelopeSha256,
-    destinationProvider: request.destinationProvider,
-    expectedRepositoryId: request.expectedRepositoryId,
-    expectedWorkspaceRoot: request.expectedWorkspaceRoot,
-    expectedBranch: request.expectedBranch,
-    expectedSourceHeadSha: request.expectedSourceHeadSha,
-    allowedHeadRelationship: request.allowedHeadRelationship,
-    expectedIssueNumber: request.expectedIssueNumber,
-    expectedFeatureFolder: request.expectedFeatureFolder,
-    expectedWorkMode: request.expectedWorkMode,
-    expectedPlanPath: request.expectedPlanPath,
-    expectedPlanSha256: request.expectedPlanSha256
-  };
-}
-function blockedResult(request, primaryFailureCode, options = {}) {
-  return {
-    status: "blocked",
-    handoffId: options.handoffId ?? null,
-    sourceCheckpointSha256: request.expectedSourceCheckpointSha256,
-    handoffEnvelopeSha256: request.expectedHandoffEnvelopeSha256,
-    handoffHistorySha256: options.handoffHistorySha256 ?? null,
-    requestedTransition: "prepared_to_atomic_execution",
-    destinationCheckpointPath: null,
-    destinationCheckpointSha256: null,
-    primaryFailureCode,
-    affectedPaths: options.affectedPaths ?? [],
-    unsupportedCapabilities: options.unsupportedCapabilities ?? []
-  };
-}
-function authorityFailure(request, authority, handoffHistorySha256) {
-  if (authority.status === "validated") return null;
-  return blockedResult(
-    request,
-    authority.primaryFailureCode ?? "HANDOFF_VALIDATOR_UNAVAILABLE",
-    {
-      handoffId: authority.handoffId,
-      handoffHistorySha256,
-      affectedPaths: authority.affectedPaths,
-      unsupportedCapabilities: authority.unsupportedCapabilities
-    }
-  );
-}
-
 // ../../extensions/drm-copilot/src/lib/validate/orchestration-handoff-provider-adapters.ts
 var PROVIDER_ADAPTERS = {
   claude: {
@@ -32022,7 +32749,9 @@ var OrchestrationHandoffMaterializer = class {
       request.workspaceRoot
     );
     if (canonicalWorkspaceRoot === null) {
-      return blockedResult(request, "HANDOFF_PLAN_PATH_INVALID");
+      return blockedResult(request, "HANDOFF_PLAN_PATH_INVALID", {
+        failureCause: "workspace-root: unresolved"
+      });
     }
     const sourcePath = pathBoundary.resolveExistingTarget(
       canonicalWorkspaceRoot,
@@ -32033,15 +32762,19 @@ var OrchestrationHandoffMaterializer = class {
       request.handoffEnvelopePath
     );
     if (sourcePath === null || envelopePath === null) {
-      return blockedResult(request, "HANDOFF_PLAN_PATH_INVALID");
+      return blockedResult(request, "HANDOFF_PLAN_PATH_INVALID", {
+        failureCause: "target-path: unresolved"
+      });
     }
     let sourceBytes;
     let envelopeBytes;
     try {
       sourceBytes = this.dependencies.fileSystem.readFile(sourcePath);
       envelopeBytes = this.dependencies.fileSystem.readFile(envelopePath);
-    } catch {
-      return blockedResult(request, "HANDOFF_VALIDATOR_UNAVAILABLE");
+    } catch (error2) {
+      return blockedResult(request, "HANDOFF_VALIDATOR_UNAVAILABLE", {
+        failureCause: describeHandoffFailureCause("checkpoint-read", error2)
+      });
     }
     if (sha2562(sourceBytes) !== request.expectedSourceCheckpointSha256 || sha2562(envelopeBytes) !== request.expectedHandoffEnvelopeSha256) {
       return blockedResult(request, "HANDOFF_SOURCE_HASH_MISMATCH");
@@ -32049,8 +32782,10 @@ var OrchestrationHandoffMaterializer = class {
     let envelopeText;
     try {
       envelopeText = textDecoder.decode(envelopeBytes);
-    } catch {
-      return blockedResult(request, "HANDOFF_UNSUPPORTED_VERSION");
+    } catch (error2) {
+      return blockedResult(request, "HANDOFF_UNSUPPORTED_VERSION", {
+        failureCause: describeHandoffFailureCause("envelope-decode", error2)
+      });
     }
     const validation = this.dependencies.validator.validateEnvelope(envelopeText);
     if (validation.primaryFailureCode !== null || validation.envelope === null) {
@@ -32059,7 +32794,8 @@ var OrchestrationHandoffMaterializer = class {
         validation.primaryFailureCode ?? "HANDOFF_VALIDATOR_UNAVAILABLE",
         {
           affectedPaths: validation.affectedPaths,
-          unsupportedCapabilities: validation.unsupportedCapabilities
+          unsupportedCapabilities: validation.unsupportedCapabilities,
+          failureCause: validation.failureCause
         }
       );
     }
@@ -32106,7 +32842,8 @@ var OrchestrationHandoffMaterializer = class {
     if (archivePath === null || destinationPath === null || candidatePath === null) {
       return blockedResult(request, "HANDOFF_PLAN_PATH_INVALID", {
         handoffId: envelope.handoffId,
-        handoffHistorySha256: lastHistoryEntry.entrySha256
+        handoffHistorySha256: lastHistoryEntry.entrySha256,
+        failureCause: "target-path: unresolved"
       });
     }
     const referenceRequest = toReferenceRequest(request);
@@ -32139,7 +32876,11 @@ var OrchestrationHandoffMaterializer = class {
         error2 instanceof Error && "code" in error2 ? error2.code : "HANDOFF_VALIDATOR_UNAVAILABLE",
         {
           handoffId: envelope.handoffId,
-          handoffHistorySha256: lastHistoryEntry.entrySha256
+          handoffHistorySha256: lastHistoryEntry.entrySha256,
+          failureCause: describeHandoffFailureCause(
+            "destination-projection",
+            error2
+          )
         }
       );
     }
@@ -32148,7 +32889,8 @@ var OrchestrationHandoffMaterializer = class {
       return blockedResult(request, "HANDOFF_VALIDATOR_UNAVAILABLE", {
         handoffId: envelope.handoffId,
         handoffHistorySha256: lastHistoryEntry.entrySha256,
-        affectedPaths: [envelope.destinationCheckpointPath]
+        affectedPaths: [envelope.destinationCheckpointPath],
+        failureCause: "destination-projection: invalid"
       });
     }
     let porcelainStatus;
@@ -32156,10 +32898,11 @@ var OrchestrationHandoffMaterializer = class {
       porcelainStatus = await this.dependencies.git.readPorcelainStatus(
         canonicalWorkspaceRoot
       );
-    } catch {
+    } catch (error2) {
       return blockedResult(request, "HANDOFF_VALIDATOR_UNAVAILABLE", {
         handoffId: envelope.handoffId,
-        handoffHistorySha256: lastHistoryEntry.entrySha256
+        handoffHistorySha256: lastHistoryEntry.entrySha256,
+        failureCause: describeHandoffFailureCause("git-status", error2)
       });
     }
     const affectedPaths = porcelainAffectedPaths(porcelainStatus);
@@ -32205,24 +32948,30 @@ var OrchestrationHandoffMaterializer = class {
         preparation.sourceBytes,
         { exclusive: true }
       );
-    } catch {
+    } catch (writeError) {
+      const writeCause = describeHandoffFailureCause(
+        "archive-write",
+        writeError
+      );
       let archivedBytes;
       try {
         archivedBytes = this.dependencies.fileSystem.readFile(
           preparation.archivePath
         );
-      } catch {
+      } catch (readError) {
         return blockedResult(request, "HANDOFF_VALIDATOR_UNAVAILABLE", {
           handoffId: preparation.result.handoffId,
           handoffHistorySha256: preparation.result.handoffHistorySha256,
-          affectedPaths: [preparation.archivePath]
+          affectedPaths: [preparation.archivePath],
+          failureCause: `${writeCause}; ${describeHandoffFailureCause("archive-readback", readError)}`
         });
       }
       if (sha2562(archivedBytes) !== expectedSourceSha256) {
         return blockedResult(request, "HANDOFF_SOURCE_HASH_MISMATCH", {
           handoffId: preparation.result.handoffId,
           handoffHistorySha256: preparation.result.handoffHistorySha256,
-          affectedPaths: [preparation.archivePath]
+          affectedPaths: [preparation.archivePath],
+          failureCause: writeCause
         });
       }
     }
@@ -32232,24 +32981,30 @@ var OrchestrationHandoffMaterializer = class {
         preparation.projectionBytes,
         { exclusive: true }
       );
-    } catch {
+    } catch (writeError) {
+      const writeCause = describeHandoffFailureCause(
+        "candidate-write",
+        writeError
+      );
       let existingCandidate;
       try {
         existingCandidate = this.dependencies.fileSystem.readFile(
           preparation.candidatePath
         );
-      } catch {
+      } catch (readError) {
         return blockedResult(request, "HANDOFF_VALIDATOR_UNAVAILABLE", {
           handoffId: preparation.result.handoffId,
           handoffHistorySha256: preparation.result.handoffHistorySha256,
-          affectedPaths: [preparation.candidatePath]
+          affectedPaths: [preparation.candidatePath],
+          failureCause: `${writeCause}; ${describeHandoffFailureCause("candidate-readback", readError)}`
         });
       }
       if (sha2562(existingCandidate) !== sha2562(preparation.projectionBytes)) {
         return blockedResult(request, "HANDOFF_VALIDATOR_UNAVAILABLE", {
           handoffId: preparation.result.handoffId,
           handoffHistorySha256: preparation.result.handoffHistorySha256,
-          affectedPaths: [preparation.candidatePath]
+          affectedPaths: [preparation.candidatePath],
+          failureCause: writeCause
         });
       }
     }
@@ -32259,35 +33014,51 @@ var OrchestrationHandoffMaterializer = class {
       );
       const writtenText = textDecoder.decode(writtenCandidate);
       if (sha2562(writtenCandidate) !== sha2562(preparation.projectionBytes) || this.dependencies.validator.validateDestinationProjection(writtenText).length > 0) {
-        throw new Error("Candidate validation failed.");
+        throw Object.assign(new Error("Candidate validation failed."), {
+          code: "HANDOFF_CANDIDATE_MISMATCH"
+        });
       }
-    } catch {
-      this.discardCandidate(preparation.candidatePath);
-      return blockedResult(request, "HANDOFF_VALIDATOR_UNAVAILABLE", {
-        handoffId: preparation.result.handoffId,
-        handoffHistorySha256: preparation.result.handoffHistorySha256,
-        affectedPaths: [preparation.candidatePath]
-      });
+    } catch (error2) {
+      return this.discardedCandidateResult(
+        request,
+        preparation,
+        describeHandoffFailureCause("candidate-validate", error2)
+      );
     }
     try {
       this.dependencies.fileSystem.replaceFile(
         preparation.candidatePath,
         preparation.destinationPath
       );
-    } catch {
-      this.discardCandidate(preparation.candidatePath);
-      return blockedResult(request, "HANDOFF_VALIDATOR_UNAVAILABLE", {
-        handoffId: preparation.result.handoffId,
-        handoffHistorySha256: preparation.result.handoffHistorySha256,
-        affectedPaths: [preparation.candidatePath]
-      });
+    } catch (error2) {
+      return this.discardedCandidateResult(
+        request,
+        preparation,
+        describeHandoffFailureCause("candidate-replace", error2)
+      );
     }
     return { ...preparation.result, status: "materialized" };
   }
+  /** Discard the candidate and block, appending any cleanup failure cause. */
+  discardedCandidateResult(request, preparation, cause) {
+    const cleanupCause = this.discardCandidate(preparation.candidatePath);
+    return blockedResult(request, "HANDOFF_VALIDATOR_UNAVAILABLE", {
+      handoffId: preparation.result.handoffId,
+      handoffHistorySha256: preparation.result.handoffHistorySha256,
+      affectedPaths: [preparation.candidatePath],
+      failureCause: cleanupCause === null ? cause : `${cause}; ${cleanupCause}`
+    });
+  }
+  /**
+   * Remove the candidate. Returns `null` on success, otherwise the cleanup
+   * cause; the blocked result names the retained candidate for explicit cleanup.
+   */
   discardCandidate(candidatePath) {
     try {
       this.dependencies.fileSystem.removeFile(candidatePath);
-    } catch {
+      return null;
+    } catch (error2) {
+      return describeHandoffFailureCause("candidate-cleanup", error2);
     }
   }
 };
@@ -32305,11 +33076,13 @@ function validateEnvelope(text2) {
       unsupportedCapabilities: []
     };
   } catch (error2) {
+    const failure = describeEnvelopeParseFailure(error2);
     return {
       envelope: null,
-      primaryFailureCode: error2 instanceof HandoffContractError ? error2.code : "HANDOFF_UNSUPPORTED_VERSION",
+      primaryFailureCode: failure.code,
       affectedPaths: [],
-      unsupportedCapabilities: []
+      unsupportedCapabilities: [],
+      failureCause: failure.failureCause
     };
   }
 }
@@ -32317,8 +33090,10 @@ function validateDestinationProjection(text2) {
   let value;
   try {
     value = JSON.parse(text2);
-  } catch {
-    return ["destination checkpoint must be valid JSON"];
+  } catch (error2) {
+    return [
+      `destination checkpoint must be valid JSON (${describeHandoffFailureCause("destination-projection", error2)})`
+    ];
   }
   if (!isRecord4(value)) return ["destination checkpoint must be an object"];
   const provider = value["provider"];
@@ -32634,7 +33409,7 @@ function truncate(text2, limit = 800) {
   }
   return rstrip3(text2.slice(0, limit - 3)) + "...";
 }
-function splitLines3(value) {
+function splitLines2(value) {
   if (value === "") {
     return [];
   }
@@ -32645,7 +33420,7 @@ function splitLines3(value) {
   return lines;
 }
 function truncateLines(text2, limit) {
-  const lines = splitLines3(text2);
+  const lines = splitLines2(text2);
   if (lines.length <= limit) {
     return text2;
   }
@@ -32685,14 +33460,11 @@ function formatList(values, emptyText) {
   }
   return valuesList.map((item) => `- ${item}`).join("\n");
 }
-function compareCodePoint(left, right) {
-  if (left < right) {
-    return -1;
-  }
-  if (left > right) {
-    return 1;
-  }
-  return 0;
+function sortedSet(values) {
+  return [...new Set(values)].sort(compareCodePoint);
+}
+function escapeRegExp4(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
 
 // ../../extensions/drm-copilot/src/lib/pr-context/git-client.ts
@@ -32885,9 +33657,6 @@ function extractClosingNumbers(raw) {
   }
   return numbers;
 }
-function sortedSet(values) {
-  return [...new Set(values)].sort(compareCodePoint);
-}
 function authorLogin(record3, key) {
   const raw = record3[key];
   if (isRecord5(raw)) {
@@ -33543,7 +34312,7 @@ function convertNumstat(numstatText) {
   let adds = 0;
   let dels = 0;
   const files = [];
-  for (const rawLine of splitLines4(numstatText)) {
+  for (const rawLine of splitLines2(numstatText)) {
     if (!rawLine.trim()) {
       continue;
     }
@@ -33606,7 +34375,7 @@ function summarizeConventionalCommits(subjects) {
   }
   counts.set("other", 0);
   const typePattern = /^(feat|fix|refactor|perf|docs|test|chore|build|ci|style)(\(|!|:)/u;
-  for (const rawLine of splitLines4(subjects)) {
+  for (const rawLine of splitLines2(subjects)) {
     const line = rawLine.trim();
     if (!line) {
       continue;
@@ -33624,7 +34393,7 @@ function summarizeConventionalCommits(subjects) {
 function extractChangedPaths(contextText) {
   const paths = [];
   let capture = false;
-  for (const line of splitLines4(contextText)) {
+  for (const line of splitLines2(contextText)) {
     if (line.startsWith("===== Changed files")) {
       capture = true;
       continue;
@@ -33661,15 +34430,144 @@ function padName(name) {
 function isDigits(value) {
   return value.length > 0 && /^\d+$/u.test(value);
 }
-function splitLines4(value) {
-  if (value === "") {
+
+// ../../extensions/drm-copilot/src/lib/pr-context/feature-docs-parsers.ts
+function parseSection(markdown, heading) {
+  const escaped = escapeRegExp4(heading);
+  const pattern = new RegExp(
+    `^##\\s+${escaped}\\s*\\r?\\n([\\s\\S]*?)(?=^##\\s+|$(?![\\s\\S]))`,
+    "m"
+  );
+  const match = pattern.exec(markdown);
+  if (!match) {
+    return "";
+  }
+  return match[1].trim();
+}
+function completedPlanTasks(markdown, limit = 10) {
+  const tasks = [];
+  for (const line of splitLines2(markdown)) {
+    if (/\[x\]/iu.test(line)) {
+      const cleaned = line.replace(/^[-*]\s*\[[xX]\]\s*/u, "").trim();
+      tasks.push(cleaned);
+    }
+    if (tasks.length >= limit) {
+      break;
+    }
+  }
+  return tasks;
+}
+function extractIssueReferences2(text2) {
+  if (!text2) {
     return [];
   }
-  const lines = value.split(/\r\n|\r|\n/u);
-  if (lines.length > 0 && lines[lines.length - 1] === "" && /(\r\n|\r|\n)$/u.test(value)) {
-    lines.pop();
+  const matches = text2.match(new RegExp(ISSUE_REFERENCE_PATTERN, "gu")) ?? [];
+  const seen = /* @__PURE__ */ new Set();
+  const ordered = [];
+  for (const item of matches) {
+    if (!seen.has(item)) {
+      seen.add(item);
+      ordered.push(item);
+    }
   }
-  return lines;
+  return ordered;
+}
+function resolveFeatureDir(fs12, baseDir, feature) {
+  const direct = `${baseDir}/${feature}`;
+  if (fs12.exists(direct)) {
+    return direct;
+  }
+  const pattern = new RegExp(
+    `(?:^|[-_])${escapeRegExp4(feature)}(?:[-_]|$)`,
+    "u"
+  );
+  const strongMatches = [];
+  const weakMatches = [];
+  for (const name of fs12.listDirectory(baseDir)) {
+    const candidate = `${baseDir}/${name}`;
+    if (!fs12.isDirectory(candidate)) {
+      continue;
+    }
+    if (pattern.test(name)) {
+      strongMatches.push(candidate);
+    } else if (name.includes(feature)) {
+      weakMatches.push(candidate);
+    }
+  }
+  if (strongMatches.length > 0) {
+    return strongMatches[0];
+  }
+  if (weakMatches.length > 0) {
+    return weakMatches[0];
+  }
+  return null;
+}
+function readText(fs12, path16) {
+  return fs12.exists(path16) ? fs12.readTextFile(path16) : "";
+}
+function latestGlobPath(fs12, directory, pattern) {
+  const matches = [...fs12.glob(directory, pattern)].sort(compareCodePoint);
+  return matches.length > 0 ? matches[matches.length - 1] : null;
+}
+function verificationText(planText) {
+  for (const heading of ["Verification", "Test Plan"]) {
+    const sectionText = parseSection(planText, heading);
+    if (sectionText) {
+      return sectionText;
+    }
+  }
+  return "";
+}
+function parsePrimaryIssueFromMetadata(params) {
+  const pattern = /^\s*[-*]?\s*Issue:\s*(#\d+)\s*$/iu;
+  for (const sourceText of [
+    params.specText,
+    params.storyText,
+    params.issueText
+  ]) {
+    for (const line of splitLines2(sourceText)) {
+      const match = pattern.exec(line);
+      if (match) {
+        return match[1];
+      }
+    }
+  }
+  return null;
+}
+function parseReadinessValue(text2) {
+  const normalized = text2.replaceAll("**", "");
+  const match = /^\s*(?:Readiness|Overall feature readiness):\s*(.+?)\s*$/im.exec(
+    normalized
+  );
+  if (!match) {
+    return null;
+  }
+  const value = match[1].trim().toUpperCase();
+  if (value === "PASS" || value === "NEEDS REVISION" || value === "BLOCKED") {
+    return value;
+  }
+  return null;
+}
+function resolveReadinessSignal(fs12, featureDir) {
+  const auditFiles = [...fs12.glob(featureDir, "feature-audit.*.md")].sort(
+    compareCodePoint
+  );
+  for (let index = auditFiles.length - 1; index >= 0; index -= 1) {
+    const auditPath = auditFiles[index];
+    const readiness = parseReadinessValue(readText(fs12, auditPath));
+    if (readiness) {
+      return [readiness, auditPath];
+    }
+  }
+  return [null, null];
+}
+function relativeToPosix8(root, path16) {
+  const normalizedRoot = toPosixPath2(root).replace(/\/+$/u, "");
+  const normalized = toPosixPath2(path16);
+  if (normalized.startsWith(`${normalizedRoot}/`)) {
+    return normalized.slice(normalizedRoot.length + 1);
+  }
+  return normalized.replace(/^\/+/u, "");
 }
 
 // ../../extensions/drm-copilot/src/lib/pr-context/render.ts
@@ -33730,8 +34628,8 @@ function buildPrContext(options) {
     const oneline = git.log("--pretty=format:%h %ad %an %s", revRange);
     const subjects = git.log("--pretty=%s", revRange);
     const authors = git.log("--format=%an <%ae>", revRange);
-    const authorsList = sortedSet2(
-      splitLines5(authors).map((line) => line.trim()).filter((line) => line)
+    const authorsList = sortedSet(
+      splitLines2(authors).map((line) => line.trim()).filter((line) => line)
     );
     const nameStatus = git.diffRange(["--name-status", mergeBase, headSha]);
     const numstat = git.diffRange(["--numstat", mergeBase, headSha]);
@@ -33739,7 +34637,7 @@ function buildPrContext(options) {
     const stat = git.diffRange(["--stat", mergeBase, headSha]);
     const [additions, deletions, files] = convertNumstat(numstat);
     const extSummary = extensionSummary(files);
-    const mergePrs = extractMergePrNumbers(splitLines5(oneline));
+    const mergePrs = extractMergePrNumbers(splitLines2(oneline));
     const issueCandidates = extractIssueReferences(
       oneline + "\n" + subjects
     ).filter((ref) => !mergePrs.includes(ref));
@@ -33759,9 +34657,9 @@ function buildPrContext(options) {
         issues.push(formattedRef);
       }
     }
-    referencedIssues = sortedSet2(issues);
-    referencedPrs = sortedSet2([...prs, ...mergePrs]);
-    let issuesDisplay = sortedSet2([
+    referencedIssues = sortedSet(issues);
+    referencedPrs = sortedSet([...prs, ...mergePrs]);
+    let issuesDisplay = sortedSet([
       ...referencedIssues,
       ...featureIssueList
     ]).join(", ");
@@ -33871,8 +34769,8 @@ Deletions: ${deletions}
     text: combinedText,
     referencedIssues,
     referencedPrs,
-    verifiedClosing: sortedSet2(verifiedClosing),
-    invalidReferences: sortedSet2(invalidReferences),
+    verifiedClosing: sortedSet(verifiedClosing),
+    invalidReferences: sortedSet(invalidReferences),
     baseRef,
     resolvedBase,
     baseSha,
@@ -33886,161 +34784,6 @@ Deletions: ${deletions}
 function errorMessage(exc) {
   return exc instanceof Error ? exc.message : String(exc);
 }
-function sortedSet2(values) {
-  return [...new Set(values)].sort(compareCodePoint);
-}
-function splitLines5(value) {
-  if (value === "") {
-    return [];
-  }
-  const lines = value.split(/\r\n|\r|\n/u);
-  if (lines.length > 0 && lines[lines.length - 1] === "" && /(\r\n|\r|\n)$/u.test(value)) {
-    lines.pop();
-  }
-  return lines;
-}
-
-// ../../extensions/drm-copilot/src/lib/pr-context/feature-docs-parsers.ts
-function parseSection2(markdown, heading) {
-  const escaped = escapeRegExp4(heading);
-  const pattern = new RegExp(
-    `^##\\s+${escaped}\\s*\\r?\\n([\\s\\S]*?)(?=^##\\s+|$(?![\\s\\S]))`,
-    "m"
-  );
-  const match = pattern.exec(markdown);
-  if (!match) {
-    return "";
-  }
-  return match[1].trim();
-}
-function completedPlanTasks2(markdown, limit = 10) {
-  const tasks = [];
-  for (const line of splitLines3(markdown)) {
-    if (/\[x\]/iu.test(line)) {
-      const cleaned = line.replace(/^[-*]\s*\[[xX]\]\s*/u, "").trim();
-      tasks.push(cleaned);
-    }
-    if (tasks.length >= limit) {
-      break;
-    }
-  }
-  return tasks;
-}
-function extractIssueReferences2(text2) {
-  if (!text2) {
-    return [];
-  }
-  const matches = text2.match(new RegExp(ISSUE_REFERENCE_PATTERN, "gu")) ?? [];
-  const seen = /* @__PURE__ */ new Set();
-  const ordered = [];
-  for (const item of matches) {
-    if (!seen.has(item)) {
-      seen.add(item);
-      ordered.push(item);
-    }
-  }
-  return ordered;
-}
-function resolveFeatureDir2(fs12, baseDir, feature) {
-  const direct = `${baseDir}/${feature}`;
-  if (fs12.exists(direct)) {
-    return direct;
-  }
-  const pattern = new RegExp(
-    `(?:^|[-_])${escapeRegExp4(feature)}(?:[-_]|$)`,
-    "u"
-  );
-  const strongMatches = [];
-  const weakMatches = [];
-  for (const name of fs12.listDirectory(baseDir)) {
-    const candidate = `${baseDir}/${name}`;
-    if (!fs12.isDirectory(candidate)) {
-      continue;
-    }
-    if (pattern.test(name)) {
-      strongMatches.push(candidate);
-    } else if (name.includes(feature)) {
-      weakMatches.push(candidate);
-    }
-  }
-  if (strongMatches.length > 0) {
-    return strongMatches[0];
-  }
-  if (weakMatches.length > 0) {
-    return weakMatches[0];
-  }
-  return null;
-}
-function readText(fs12, path16) {
-  return fs12.exists(path16) ? fs12.readTextFile(path16) : "";
-}
-function latestGlobPath(fs12, directory, pattern) {
-  const matches = [...fs12.glob(directory, pattern)].sort(compareCodePoint);
-  return matches.length > 0 ? matches[matches.length - 1] : null;
-}
-function verificationText(planText) {
-  for (const heading of ["Verification", "Test Plan"]) {
-    const sectionText = parseSection2(planText, heading);
-    if (sectionText) {
-      return sectionText;
-    }
-  }
-  return "";
-}
-function parsePrimaryIssueFromMetadata(params) {
-  const pattern = /^\s*[-*]?\s*Issue:\s*(#\d+)\s*$/iu;
-  for (const sourceText of [
-    params.specText,
-    params.storyText,
-    params.issueText
-  ]) {
-    for (const line of splitLines3(sourceText)) {
-      const match = pattern.exec(line);
-      if (match) {
-        return match[1];
-      }
-    }
-  }
-  return null;
-}
-function parseReadinessValue(text2) {
-  const normalized = text2.replaceAll("**", "");
-  const match = /^\s*(?:Readiness|Overall feature readiness):\s*(.+?)\s*$/im.exec(
-    normalized
-  );
-  if (!match) {
-    return null;
-  }
-  const value = match[1].trim().toUpperCase();
-  if (value === "PASS" || value === "NEEDS REVISION" || value === "BLOCKED") {
-    return value;
-  }
-  return null;
-}
-function resolveReadinessSignal(fs12, featureDir) {
-  const auditFiles = [...fs12.glob(featureDir, "feature-audit.*.md")].sort(
-    compareCodePoint
-  );
-  for (let index = auditFiles.length - 1; index >= 0; index -= 1) {
-    const auditPath = auditFiles[index];
-    const readiness = parseReadinessValue(readText(fs12, auditPath));
-    if (readiness) {
-      return [readiness, auditPath];
-    }
-  }
-  return [null, null];
-}
-function relativeToPosix8(root, path16) {
-  const normalizedRoot = toPosixPath2(root).replace(/\/+$/u, "");
-  const normalized = toPosixPath2(path16);
-  if (normalized.startsWith(`${normalizedRoot}/`)) {
-    return normalized.slice(normalizedRoot.length + 1);
-  }
-  return normalized.replace(/^\/+/u, "");
-}
-function escapeRegExp4(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-}
 
 // ../../extensions/drm-copilot/src/lib/pr-context/verification-evidence.ts
 var REQUIRED_FIELDS = ["Timestamp", "Command", "EXIT_CODE"];
@@ -34063,7 +34806,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(relativeToPosix9(normalizedRoot, candidate));
+        discovered.add(relativeToPosix8(normalizedRoot, candidate));
       }
     }
   }
@@ -34072,7 +34815,7 @@ function discoverCanonicalEvidenceFiles(fs12, root, feature) {
 function parseVerificationEvidenceMarkdown(params) {
   const { feature, sourceFile, markdown } = params;
   const parsed = /* @__PURE__ */ new Map();
-  for (const rawLine of splitLines6(markdown)) {
+  for (const rawLine of splitLines2(markdown)) {
     const colonIndex = rawLine.indexOf(":");
     if (colonIndex === -1) {
       continue;
@@ -34140,9 +34883,9 @@ function parseVerificationEvidenceMarkdown(params) {
   };
 }
 function parseVerificationEvidenceFile(params) {
-  const { fs: fs12, root, feature, relativePath: relativePath2 } = params;
+  const { fs: fs12, root, feature, relativePath } = params;
   const normalizedRoot = toPosixPath2(root).replace(/\/+$/u, "");
-  const relPosix = toPosixPath2(relativePath2).replace(/^\/+/u, "");
+  const relPosix = toPosixPath2(relativePath).replace(/^\/+/u, "");
   const markdown = fs12.readTextFile(`${normalizedRoot}/${relPosix}`);
   return parseVerificationEvidenceMarkdown({
     feature,
@@ -34156,23 +34899,6 @@ function parseIntegerStrict(value) {
   }
   return Number.parseInt(value, 10);
 }
-function relativeToPosix9(root, absolute) {
-  const normalized = toPosixPath2(absolute);
-  if (normalized.startsWith(`${root}/`)) {
-    return normalized.slice(root.length + 1);
-  }
-  return normalized.replace(/^\/+/u, "");
-}
-function splitLines6(value) {
-  if (value === "") {
-    return [];
-  }
-  const lines = value.split(/\r\n|\r|\n/u);
-  if (lines.length > 0 && lines[lines.length - 1] === "" && /(\r\n|\r|\n)$/u.test(value)) {
-    lines.pop();
-  }
-  return lines;
-}
 
 // ../../extensions/drm-copilot/src/lib/pr-context/feature-docs.ts
 var SPEC_HEADINGS = [
@@ -34203,8 +34929,8 @@ function gatherFeatureExcerpts2(fs12, root, changedFiles) {
   const baseDir = `${normalizedRoot}/docs/features/active`;
   const promotedDir = `${normalizedRoot}/docs/features/potential/promoted`;
   for (const feature of [...features].sort(compareCodePoint)) {
-    const featureDir = resolveFeatureDir2(fs12, baseDir, feature);
-    const promotedFeatureDir = resolveFeatureDir2(fs12, promotedDir, feature);
+    const featureDir = resolveFeatureDir(fs12, baseDir, feature);
+    const promotedFeatureDir = resolveFeatureDir(fs12, promotedDir, feature);
     if (featureDir === null && promotedFeatureDir === null) {
       continue;
     }
@@ -34279,7 +35005,7 @@ function gatherFeatureExcerpts2(fs12, root, changedFiles) {
 function buildSpecParts(specText) {
   const specParts = [];
   for (const heading of SPEC_HEADINGS) {
-    const sectionText = parseSection2(specText, heading);
+    const sectionText = parseSection(specText, heading);
     if (sectionText) {
       specParts.push(`${heading}: ${truncate(sectionText)}`);
     }
@@ -34287,7 +35013,7 @@ function buildSpecParts(specText) {
   return specParts;
 }
 function buildPlanSection(planText) {
-  const planTasks = completedPlanTasks2(planText);
+  const planTasks = completedPlanTasks(planText);
   return planTasks.length > 0 ? planTasks.map((task) => `- ${task}`).join("\n") : "";
 }
 function buildVerificationBlock(planText) {
@@ -34296,7 +35022,7 @@ function buildVerificationBlock(planText) {
 }
 function buildStoryParts(userStoryText, promotedStoryText) {
   const storyParts = [];
-  const storyStatements = parseSection2(userStoryText, "Story Statement");
+  const storyStatements = parseSection(userStoryText, "Story Statement");
   if (storyStatements) {
     const storyLines = storyStatements.split(/\r\n|\r|\n/u).filter((line) => line.trim()).map((line) => line.replace(/^[- ]+|[- ]+$/gu, ""));
     if (storyLines.length > 0) {
@@ -34305,14 +35031,14 @@ function buildStoryParts(userStoryText, promotedStoryText) {
       );
     }
   }
-  const problemSection = parseSection2(userStoryText, "Problem / Why");
+  const problemSection = parseSection(userStoryText, "Problem / Why");
   if (problemSection) {
     storyParts.push("Problem / Why:\n" + truncate(problemSection));
   }
   if (storyParts.length === 0 && promotedStoryText) {
-    let promotedProblem = parseSection2(promotedStoryText, "Problem / Why");
+    let promotedProblem = parseSection(promotedStoryText, "Problem / Why");
     if (!promotedProblem) {
-      promotedProblem = parseSection2(promotedStoryText, "Summary");
+      promotedProblem = parseSection(promotedStoryText, "Summary");
     }
     if (promotedProblem) {
       storyParts.push("Problem / Why:\n" + truncate(promotedProblem));
@@ -34385,7 +35111,7 @@ function extractDigestBullets(body, headings, limit) {
     if (!sectionText) {
       continue;
     }
-    for (const line of splitLines3(sectionText)) {
+    for (const line of splitLines2(sectionText)) {
       if (!line.trim()) {
         continue;
       }
@@ -34526,7 +35252,7 @@ function parseNumstatDetailed(numstatText) {
   let addsTotal = 0;
   let delsTotal = 0;
   const perFile = /* @__PURE__ */ new Map();
-  for (const rawLine of splitLines3(numstatText)) {
+  for (const rawLine of splitLines2(numstatText)) {
     if (!rawLine.trim()) {
       continue;
     }
@@ -34545,7 +35271,7 @@ function parseNumstatDetailed(numstatText) {
 }
 function parseNameStatusMap(nameStatusText) {
   const mapping = /* @__PURE__ */ new Map();
-  for (const rawLine of splitLines3(nameStatusText)) {
+  for (const rawLine of splitLines2(nameStatusText)) {
     if (!rawLine.trim()) {
       continue;
     }
@@ -34593,7 +35319,7 @@ function scopingDocChanges(options) {
       path16
     ]);
     let headingTouched = false;
-    for (const line of splitLines3(diffText)) {
+    for (const line of splitLines2(diffText)) {
       if (!line.startsWith("+") || line.startsWith("+++")) {
         continue;
       }
@@ -34609,7 +35335,7 @@ function scopingDocChanges(options) {
       material = true;
       reasons.push("key section touched");
     }
-    const addedLines = splitLines3(diffText).filter((line) => line.startsWith("+") && !line.startsWith("+++")).map((line) => line.replace(/^\++/u, "").trim());
+    const addedLines = splitLines2(diffText).filter((line) => line.startsWith("+") && !line.startsWith("+++")).map((line) => line.replace(/^\++/u, "").trim());
     if (addedLines.length > 0 && addedLines.every(
       (line) => !line || line.startsWith("[") || line.startsWith("http")
     )) {
@@ -34759,10 +35485,10 @@ function collectPrContext(options) {
   });
   const changedPaths = extractChangedPaths(contextResult.text);
   const featureDocs = gatherFeatureExcerpts2(fs12, resolvedRoot, changedPaths);
-  const additionalContextFiles = sortedSet3(
+  const additionalContextFiles = sortedSet(
     featureDocs.flatMap((doc) => doc.contextFiles).filter((path16) => path16)
   );
-  const featureIssueRefs = sortedSet3(
+  const featureIssueRefs = sortedSet(
     featureDocs.flatMap((doc) => doc.issueRefs).filter((ref) => ref.trim())
   );
   if (featureIssueRefs.length > 0) {
@@ -34820,7 +35546,7 @@ function collectPrContext(options) {
       pendingPrimary.push(featureDoc.primaryIssueRef);
     }
   }
-  const readinessSignals = sortedSet3(
+  const readinessSignals = sortedSet(
     featureDocs.map((doc) => doc.readinessSignal).filter((signal) => Boolean(signal))
   );
   const selection = selectPendingPrimary({ gh, ghAvailable, pendingPrimary });
@@ -34831,7 +35557,7 @@ function collectPrContext(options) {
     ghAvailable,
     pendingPrimaryExcluded: selection.excluded
   });
-  const issuesToFetch = sortedSet3([
+  const issuesToFetch = sortedSet([
     ...verified,
     ...referencedIssues,
     ...selection.kept
@@ -34919,7 +35645,7 @@ function collectPrContext(options) {
     verified,
     verifiedReason,
     authorReason,
-    authorAsserted: sortedSet3(authorAsserted),
+    authorAsserted: sortedSet(authorAsserted),
     issuesToAutocloseSection,
     issueDetails,
     prDetailsList,
@@ -34940,9 +35666,6 @@ function collectPrContext(options) {
 function errorMessage2(exc) {
   return exc instanceof Error ? exc.message : String(exc);
 }
-function sortedSet3(values) {
-  return [...new Set(values)].sort(compareCodePoint);
-}
 
 // ../../extensions/drm-copilot/src/lib/pr-context/collector-output.ts
 function renderVerificationEvidenceSection(fs12, resolvedRoot, featureDocs) {
@@ -34975,7 +35698,7 @@ function renderVerificationEvidenceSection(fs12, resolvedRoot, featureDocs) {
   }
   const lines = [];
   const sorted = [...parseableRecords].sort(
-    (left, right) => left.sourceFile < right.sourceFile ? -1 : left.sourceFile > right.sourceFile ? 1 : 0
+    (left, right) => compareCodePoint(left.sourceFile, right.sourceFile)
   );
   for (const record3 of sorted) {
     const expected = record3.expectedExitCode;
@@ -35508,7 +36231,7 @@ function getSection(content, heading) {
   }
   return match[1].trim();
 }
-function buildBody(workMode, problem, behavior, criteria, constraints, tests, relativePath2) {
+function buildBody(workMode, problem, behavior, criteria, constraints, tests, relativePath) {
   return `- Work Mode: ${workMode}
 ## Problem / Why
 ${problem}
@@ -35526,20 +36249,20 @@ ${constraints}
 ${tests}
 
 ## Source
-From: ${relativePath2}
+From: ${relativePath}
 `;
 }
-function buildBugBody(workMode, sections, relativePath2) {
+function buildBugBody(workMode, sections, relativePath) {
   const parts = [`- Work Mode: ${workMode}`];
   for (const heading of BUG_SECTION_HEADINGS) {
     parts.push(`## ${heading}
 ${sections[heading] ?? ""}`);
   }
   parts.push(`## Source
-From: ${relativePath2}`);
+From: ${relativePath}`);
   return parts.join("\n\n") + "\n";
 }
-function buildMinorAuditBody(workMode, problem, implementationIntent, acceptanceCriteria, dependenciesRisks, verificationSteps, evidenceChecklist, relativePath2) {
+function buildMinorAuditBody(workMode, problem, implementationIntent, acceptanceCriteria, dependenciesRisks, verificationSteps, evidenceChecklist, relativePath) {
   return `- Work Mode: ${workMode}
 ## Problem / Why
 ${problem}
@@ -35560,7 +36283,7 @@ ${verificationSteps}
 ${evidenceChecklist}
 
 ## Source
-From: ${relativePath2}
+From: ${relativePath}
 `;
 }
 function parseIssueReference(output) {
@@ -35725,13 +36448,13 @@ function posixBasename(pathStr) {
   const lastSlash = normalized.lastIndexOf("/");
   return lastSlash === -1 ? normalized : normalized.slice(lastSlash + 1);
 }
-function buildIssueBody(content, selectedMode, promotionType, relativePath2) {
+function buildIssueBody(content, selectedMode, promotionType, relativePath) {
   if (promotionType === "bug") {
     const bugSections = {};
     for (const heading of BUG_SECTION_HEADINGS) {
       bugSections[heading] = getSection(content, heading) || PLACEHOLDER;
     }
-    return buildBugBody(selectedMode, bugSections, relativePath2);
+    return buildBugBody(selectedMode, bugSections, relativePath);
   }
   if (selectedMode === "minor-audit") {
     const problem2 = getSection(content, "Problem / Why") || PLACEHOLDER;
@@ -35751,7 +36474,7 @@ function buildIssueBody(content, selectedMode, promotionType, relativePath2) {
       dependenciesRisks,
       verificationSteps,
       evidenceChecklist,
-      relativePath2
+      relativePath
     );
   }
   const problem = getSection(content, "Problem / Why") || PLACEHOLDER;
@@ -35766,7 +36489,7 @@ function buildIssueBody(content, selectedMode, promotionType, relativePath2) {
     criteria,
     constraints,
     tests,
-    relativePath2
+    relativePath
   );
 }
 function promotePotential(options) {
@@ -35801,7 +36524,7 @@ function promotePotential(options) {
   const featurePath = getFeaturePath(featureName);
   const prefix = TITLE_PREFIXES[promotionType] ?? "Feature";
   const issueTitle = normalizeSmartPunctuation(`${prefix}: ${featureName}`);
-  const relativePath2 = computeRelativePath(resolved, workspacePath);
+  const relativePath = computeRelativePath(resolved, workspacePath);
   let selectedMode;
   try {
     selectedMode = normalizeRequestedWorkMode(workMode, promotionType);
@@ -35810,7 +36533,7 @@ function promotePotential(options) {
     throw new PromotionError(message);
   }
   const fallbackReason = "";
-  let body = buildIssueBody(content, selectedMode, promotionType, relativePath2);
+  let body = buildIssueBody(content, selectedMode, promotionType, relativePath);
   body = normalizeSmartPunctuation(body);
   const messages = [];
   const emitLine = (message) => {
@@ -35873,6 +36596,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 };
 }
@@ -36188,12 +36915,12 @@ function validateFeatureName2(featureName) {
 function escapeRegExp6(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function splitLines7(text2) {
+function splitLines3(text2) {
   return text2.split(/\r\n|\r|\n/);
 }
 function formatChecklist(text2) {
   const lines = [];
-  for (const rawLine of splitLines7(text2)) {
+  for (const rawLine of splitLines3(text2)) {
     const trimmed = rawLine.trim();
     if (!trimmed) {
       continue;
@@ -36222,7 +36949,7 @@ function getSection2(content, name) {
 function upsertWorkModeMarker(content, mode) {
   const markerLine = `- Work Mode: ${mode}`;
   const markerPattern = /^- Work Mode:\s*(minor-audit|full-feature|full-bug|full)\s*$/;
-  const lines = splitLines7(content).filter((line) => !markerPattern.test(line));
+  const lines = splitLines3(content).filter((line) => !markerPattern.test(line));
   for (let idx = 0; idx < lines.length; idx += 1) {
     const line = lines[idx] ?? "";
     if (line.replace(/^\s+/, "").startsWith("## ")) {
@@ -37215,13 +37942,7 @@ function findParentKey(toolUseId, transcriptsByKey) {
   return void 0;
 }
 function compareByAgentId(a, b) {
-  if (a.meta.agentId < b.meta.agentId) {
-    return -1;
-  }
-  if (a.meta.agentId > b.meta.agentId) {
-    return 1;
-  }
-  return 0;
+  return compareCodePoint(a.meta.agentId, b.meta.agentId);
 }
 function sortBySpawnIndex(children, parentTranscript) {
   return [...children].sort((a, b) => {
@@ -37265,7 +37986,7 @@ function buildNode(input) {
     agentType,
     description,
     depth,
-    models: [...models].sort(),
+    models: [...models].sort(compareCodePoint),
     children
   };
 }
@@ -37395,7 +38116,7 @@ function formatTree(node) {
 }
 function renderLines(node) {
   const indent = "  ".repeat(node.depth);
-  const sortedModels = [...node.models].sort();
+  const sortedModels = [...node.models].sort(compareCodePoint);
   const line = `${indent}${node.agentType} \xB7 [${sortedModels.join(",")}] \xB7 ${node.depth} \xB7 ${node.description}`;
   const childLines = node.children.flatMap((child) => renderLines(child));
   return [line, ...childLines];