@danmoisan/drm-copilot-mcp 1.0.0 → 1.0.7

package/out/mcp-server.js

@@ -8964,13 +8964,13 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     }
     return propValues;
   });
-  const isObject7 = isObject;
+  const isObject8 = isObject;
   const catchall = def.catchall;
   let value;
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
     const input = payload.value;
-    if (!isObject7(input)) {
+    if (!isObject8(input)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
@@ -9097,7 +9097,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
     return (payload, ctx) => fn(shape, payload, ctx);
   };
   let fastpass;
-  const isObject7 = isObject;
+  const isObject8 = isObject;
   const jit = !globalConfig.jitless;
   const allowsEval2 = allowsEval;
   const fastEnabled = jit && allowsEval2.value;
@@ -9106,7 +9106,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
     const input = payload.value;
-    if (!isObject7(input)) {
+    if (!isObject8(input)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
@@ -15504,9 +15504,15 @@ function createBufferedOutput() {
   };
 }
 function executableExists(executable) {
+  return findExecutableOnPath(executable) !== void 0;
+}
+function getPathExtensions() {
+  return process.platform === "win32" ? (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD").split(";").filter((part) => part.length > 0) : [""];
+}
+function findExecutableOnPath(executable) {
   const pathValue = process.env["PATH"] ?? "";
   const pathParts = pathValue.split(path.delimiter).filter((part) => part.length > 0);
-  const pathExtensions = process.platform === "win32" ? (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD").split(";").filter((part) => part.length > 0) : [""];
+  const pathExtensions = getPathExtensions();
   for (const directory of pathParts) {
     for (const extension of pathExtensions) {
       const candidate = path.join(
@@ -15514,11 +15520,11 @@ function executableExists(executable) {
         process.platform === "win32" ? `${executable}${extension}` : executable
       );
       if (fs.existsSync(candidate)) {
-        return true;
+        return candidate.replace(/\\/g, "/");
       }
     }
   }
-  return false;
+  return void 0;
 }
 function detectRuntime(runtimeKind) {
   void runtimeKind;
@@ -15660,6 +15666,54 @@ function getStderrExcerpt(error2) {
   return trimmed.length > 0 ? trimmed : void 0;
 }
 
+// ../../extensions/drm-copilot/src/mcp-push-down-schema-properties.ts
+var workspaceRootProperty = {
+  type: "string",
+  description: "Target workspace root. Defaults to process.cwd() when omitted."
+};
+var codexPacksProperty = {
+  type: "array",
+  items: {
+    type: "string"
+  },
+  description: "Optional Codex language pack names to publish. When omitted, the full tree is published. 'core' is always included."
+};
+var codexCsharpVariantProperty = {
+  type: "string",
+  enum: ["modern", "legacy"],
+  description: "Optional Codex C# toolchain variant to source ('modern' default or 'legacy')."
+};
+var codexMemoryModeProperty = {
+  type: "string",
+  enum: ["overwrite", "merge", "skip"],
+  description: "Optional inert Codex memory parity field: 'overwrite' (default), 'merge', or 'skip'."
+};
+var codexPushDownSelectionProperties = {
+  packs: codexPacksProperty,
+  csharp_variant: codexCsharpVariantProperty,
+  memory_mode: codexMemoryModeProperty
+};
+var copilotPushDownSelectionProperties = {};
+var claudePushDownSelectionProperties = {
+  packs: {
+    type: "array",
+    items: {
+      type: "string"
+    },
+    description: "Optional language pack names to publish (for example 'core', 'typescript'). When omitted, the full tree is published. 'core' is always included."
+  },
+  csharp_variant: {
+    type: "string",
+    enum: ["modern", "legacy"],
+    description: "Optional C# toolchain variant to source ('modern' default or 'legacy')."
+  },
+  memory_mode: {
+    type: "string",
+    enum: ["overwrite", "merge", "skip"],
+    description: "Optional agent-memory handling mode: 'overwrite' (default), 'merge', or 'skip'."
+  }
+};
+
 // ../../extensions/drm-copilot/src/workflow-command-arguments.ts
 var path2 = __toESM(require("node:path"));
 var SHORT_NAME_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*$/;
@@ -15771,10 +15825,6 @@ function normalizeWorkspaceDestinationPath(value, workspaceRoot, fieldName) {
 }
 
 // ../../extensions/drm-copilot/src/mcp-repo-automation-tool-definitions.ts
-var workspaceRootProperty = {
-  type: "string",
-  description: "Target workspace root. Defaults to process.cwd() when omitted."
-};
 var REPO_AUTOMATION_TOOL_DEFINITIONS = [
   {
     name: "collect_commit_context",
@@ -15852,7 +15902,8 @@ var REPO_AUTOMATION_TOOL_DEFINITIONS = [
     inputSchema: {
       type: "object",
       properties: {
-        workspace_root: workspaceRootProperty
+        workspace_root: workspaceRootProperty,
+        ...copilotPushDownSelectionProperties
       },
       additionalProperties: false
     }
@@ -15863,7 +15914,8 @@ var REPO_AUTOMATION_TOOL_DEFINITIONS = [
     inputSchema: {
       type: "object",
       properties: {
-        workspace_root: workspaceRootProperty
+        workspace_root: workspaceRootProperty,
+        ...codexPushDownSelectionProperties
       },
       additionalProperties: false
     }
@@ -15875,23 +15927,7 @@ var REPO_AUTOMATION_TOOL_DEFINITIONS = [
       type: "object",
       properties: {
         workspace_root: workspaceRootProperty,
-        packs: {
-          type: "array",
-          items: {
-            type: "string"
-          },
-          description: "Optional language pack names to publish (for example 'core', 'typescript'). When omitted, the full tree is published. 'core' is always included."
-        },
-        csharp_variant: {
-          type: "string",
-          enum: ["modern", "legacy"],
-          description: "Optional C# toolchain variant to source ('modern' default or 'legacy')."
-        },
-        memory_mode: {
-          type: "string",
-          enum: ["overwrite", "merge", "skip"],
-          description: "Optional agent-memory handling mode: 'overwrite' (default), 'merge', or 'skip'."
-        }
+        ...claudePushDownSelectionProperties
       },
       additionalProperties: false
     }
@@ -16205,7 +16241,7 @@ var REPO_AUTOMATION_TOOLS = [
 ];
 
 // ../../extensions/drm-copilot/src/mcp-tool-inputs-push-down.ts
-function resolveClaudePacksField(rawValue) {
+function resolvePacksField(rawValue) {
   if (rawValue === void 0) {
     return void 0;
   }
@@ -16240,7 +16276,22 @@ function resolveMemoryModeField(rawValue) {
 }
 function resolvePushDownClaudeCustomizationsToolInput(rawInput, fallbackWorkspaceRoot) {
   const args = asToolArgumentObject(rawInput);
-  const packs = resolveClaudePacksField(args["packs"]);
+  const packs = resolvePacksField(args["packs"]);
+  const csharpVariant = resolveCsharpVariantField(args["csharp_variant"]);
+  const memoryMode = resolveMemoryModeField(args["memory_mode"]);
+  return {
+    workspaceRoot: normalizeWorkspaceRoot(
+      args["workspace_root"],
+      fallbackWorkspaceRoot
+    ),
+    ...packs === void 0 ? {} : { packs },
+    ...csharpVariant === void 0 ? {} : { csharpVariant },
+    ...memoryMode === void 0 ? {} : { memoryMode }
+  };
+}
+function resolvePushDownCodexAndAgentsCustomizationsToolInput(rawInput, fallbackWorkspaceRoot) {
+  const args = asToolArgumentObject(rawInput);
+  const packs = resolvePacksField(args["packs"]);
   const csharpVariant = resolveCsharpVariantField(args["csharp_variant"]);
   const memoryMode = resolveMemoryModeField(args["memory_mode"]);
   return {
@@ -16381,15 +16432,6 @@ function resolvePushDownCopilotCustomizationsToolInput(rawInput, fallbackWorkspa
     )
   };
 }
-function resolvePushDownCodexAndAgentsCustomizationsToolInput(rawInput, fallbackWorkspaceRoot) {
-  const args = asToolArgumentObject(rawInput);
-  return {
-    workspaceRoot: normalizeWorkspaceRoot(
-      args["workspace_root"],
-      fallbackWorkspaceRoot
-    )
-  };
-}
 function resolveNewPotentialBugEntryToolInput(rawInput, fallbackWorkspaceRoot) {
   const args = asToolArgumentObject(rawInput);
   return {
@@ -17458,18 +17500,304 @@ function pushDownCustomizations2(options) {
   });
 }
 
+// ../../extensions/drm-copilot/src/lib/push-down/codex-pack-selection.ts
+var CORE_PACK_NAME = "core";
+var PUBLIC_CSHARP_PACK_NAME = "csharp";
+var SUPPORTED_PACK_NAMES = /* @__PURE__ */ new Set([
+  "core",
+  "python",
+  "powershell",
+  "typescript",
+  PUBLIC_CSHARP_PACK_NAME
+]);
+var MANIFEST_PACK_NAMES = /* @__PURE__ */ new Set([
+  "core",
+  "python",
+  "powershell",
+  "typescript",
+  "csharp-modern",
+  "csharp-legacy"
+]);
+var CSHARP_CANONICAL_PATHS = [
+  ".agents/skills/csharp/SKILL.md",
+  ".agents/skills/csharp-qa-gate/SKILL.md",
+  ".agents/skills/invoke-csharp-engineer/SKILL.md",
+  ".codex/agents/csharp-typed-engineer.toml"
+];
+var CSHARP_PACK_NAMES = /* @__PURE__ */ new Set([
+  "csharp-modern",
+  "csharp-legacy"
+]);
+var AGENTS_LEGACY_VARIANT_SOURCE_PREFIX = ".agents-variants/csharp-legacy";
+var CODEX_LEGACY_VARIANT_SOURCE_PREFIX = ".codex-variants/csharp-legacy";
+var ManifestError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ManifestError";
+  }
+};
+function joinPosix3(dir, name) {
+  const normalizedDir = dir.replace(/\\/g, "/").replace(/\/+$/, "");
+  return normalizedDir === "" ? name : `${normalizedDir}/${name}`;
+}
+function loadPackManifests(manifestDir, selectedPackNames, fs9) {
+  const unknown2 = [...selectedPackNames].filter(
+    (name) => !MANIFEST_PACK_NAMES.has(name)
+  );
+  if (unknown2.length > 0) {
+    throw new ManifestError(`Unknown Codex pack name(s): ${unknown2.sort()}`);
+  }
+  const namesToLoad = new Set(selectedPackNames);
+  namesToLoad.add(CORE_PACK_NAME);
+  const manifests = /* @__PURE__ */ new Map();
+  for (const name of [...namesToLoad].sort()) {
+    const manifestPath = joinPosix3(manifestDir, `${name}.json`);
+    if (!fs9.isFile(manifestPath)) {
+      throw new ManifestError(
+        `Codex pack manifest is missing for pack '${name}': ${manifestPath}`
+      );
+    }
+    manifests.set(
+      name,
+      parseManifest(name, manifestPath, fs9.readTextFile(manifestPath))
+    );
+  }
+  return manifests;
+}
+function resolveManifestPackNames(selectedPackNames, csharpVariant) {
+  if (selectedPackNames === null || selectedPackNames.size === 0) {
+    return null;
+  }
+  const variantSpecific = [...selectedPackNames].filter(
+    (name) => CSHARP_PACK_NAMES.has(name)
+  );
+  if (variantSpecific.length > 0) {
+    throw new ManifestError(
+      `Use public Codex pack 'csharp' with csharpVariant instead of variant-specific pack name(s): ${variantSpecific.sort().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()}`);
+  }
+  const manifestNames = new Set(selectedPackNames);
+  if (manifestNames.has(PUBLIC_CSHARP_PACK_NAME)) {
+    manifestNames.delete(PUBLIC_CSHARP_PACK_NAME);
+    manifestNames.add(`csharp-${csharpVariant}`);
+  }
+  return manifestNames;
+}
+function parseManifest(name, manifestPath, rawText) {
+  let loaded;
+  try {
+    loaded = JSON.parse(rawText);
+  } catch {
+    throw new ManifestError(
+      `Codex pack manifest is not valid JSON for pack '${name}': ${manifestPath}`
+    );
+  }
+  if (loaded === null || typeof loaded !== "object" || Array.isArray(loaded)) {
+    throw new ManifestError(
+      `Codex pack manifest must be a JSON object for pack '${name}': ${manifestPath}`
+    );
+  }
+  const parsed = loaded;
+  const manifestName = parsed["name"];
+  const manifestLabel = parsed["label"] ?? manifestName;
+  const manifestPaths = parsed["paths"];
+  const sourcePrefix = parsed["source_prefix"];
+  if (typeof manifestName !== "string" || manifestName === "") {
+    throw new ManifestError(
+      `Codex pack manifest 'name' must be a non-empty string: ${manifestPath}`
+    );
+  }
+  if (typeof manifestLabel !== "string" || manifestLabel === "") {
+    throw new ManifestError(
+      `Codex pack manifest 'label' must be a non-empty string: ${manifestPath}`
+    );
+  }
+  if (!Array.isArray(manifestPaths) || manifestPaths.length === 0) {
+    throw new ManifestError(
+      `Codex pack manifest 'paths' must be a non-empty list of strings: ${manifestPath}`
+    );
+  }
+  const paths = [];
+  for (const entry of manifestPaths) {
+    if (typeof entry !== "string" || entry === "") {
+      throw new ManifestError(
+        `Codex pack manifest 'paths' must be a non-empty list of strings: ${manifestPath}`
+      );
+    }
+    paths.push(entry);
+  }
+  if (sourcePrefix !== void 0 && sourcePrefix !== null && typeof sourcePrefix !== "string") {
+    throw new ManifestError(
+      `Codex pack manifest 'source_prefix' must be a string when present: ${manifestPath}`
+    );
+  }
+  return {
+    name: manifestName,
+    label: manifestLabel,
+    paths,
+    sourcePrefix: sourcePrefix === void 0 || sourcePrefix === null ? null : sourcePrefix
+  };
+}
+function computePublishedPaths(selectedPackNames, manifests) {
+  if (selectedPackNames === null || selectedPackNames.size === 0) {
+    return null;
+  }
+  const effectiveNames = new Set(selectedPackNames);
+  effectiveNames.add(CORE_PACK_NAME);
+  const published = /* @__PURE__ */ new Set();
+  for (const name of effectiveNames) {
+    const manifest = manifests.get(name);
+    if (manifest === void 0) {
+      throw new ManifestError(
+        `No loaded Codex manifest for selected pack '${name}'.`
+      );
+    }
+    for (const path10 of manifest.paths) {
+      published.add(path10);
+    }
+  }
+  return published;
+}
+function resolveVariantSourcePath(destinationRelativePath, csharpVariant) {
+  if (csharpVariant === "legacy" && CSHARP_CANONICAL_PATHS.includes(destinationRelativePath)) {
+    if (destinationRelativePath.startsWith(".agents/")) {
+      return `${AGENTS_LEGACY_VARIANT_SOURCE_PREFIX}/${destinationRelativePath.slice(".agents/".length)}`;
+    }
+    if (destinationRelativePath.startsWith(".codex/")) {
+      return `${CODEX_LEGACY_VARIANT_SOURCE_PREFIX}/${destinationRelativePath.slice(".codex/".length)}`;
+    }
+  }
+  return destinationRelativePath;
+}
+function assertSingleCsharpToolchain(publishedPaths, selectedPackNames) {
+  const selectedCsharp = [...selectedPackNames].filter((name) => CSHARP_PACK_NAMES.has(name)).sort();
+  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.`
+    );
+  }
+  void publishedPaths;
+}
+
 // ../../extensions/drm-copilot/src/lib/push-down/codex-agents-customizations.ts
 var ARTIFACT_DIRECTORY3 = "artifacts/codex-and-agents-customizations";
 var ROOT_FOLDERS = [".codex", ".agents"];
+var PACK_MANIFEST_SUBDIR = "pack-manifests";
 function passthroughRewrite(text) {
   return [text, 0, 0, []];
 }
+function normalizePosix(value) {
+  return value.replace(/\\/g, "/").replace(/\/+$/, "");
+}
+function joinPosix4(root, relative2) {
+  const normalizedRoot = normalizePosix(root);
+  const normalizedRelative = relative2.replace(/\\/g, "/").replace(/^\/+/, "");
+  return normalizedRoot === "" ? normalizedRelative : `${normalizedRoot}/${normalizedRelative}`;
+}
+function relativeToPosix2(path10, root) {
+  const normalizedPath = normalizePosix(path10);
+  const normalizedRoot = normalizePosix(root);
+  if (normalizedPath === normalizedRoot) {
+    return "";
+  }
+  const prefix = `${normalizedRoot}/`;
+  return normalizedPath.startsWith(prefix) ? normalizedPath.slice(prefix.length) : null;
+}
+var CodexFilteringFileSystem = class {
+  constructor(inner, options) {
+    this.inner = inner;
+    this.sourceRoot = normalizePosix(options.sourceRoot);
+    this.bundleRoot = normalizePosix(options.bundleRoot);
+    this.publishedPaths = options.publishedPaths;
+    this.csharpVariant = options.csharpVariant;
+  }
+  inner;
+  sourceRoot;
+  bundleRoot;
+  publishedPaths;
+  csharpVariant;
+  sourceRelative(path10) {
+    return relativeToPosix2(path10, this.sourceRoot);
+  }
+  isPackIncluded(path10) {
+    if (this.publishedPaths === null) {
+      return true;
+    }
+    const relative2 = this.sourceRelative(path10);
+    return relative2 === null || this.publishedPaths.has(relative2);
+  }
+  resolveReadSource(path10) {
+    if (this.csharpVariant !== "legacy") {
+      return path10;
+    }
+    const relative2 = this.sourceRelative(path10);
+    if (relative2 === null) {
+      return path10;
+    }
+    const routed = resolveVariantSourcePath(relative2, "legacy");
+    return routed === relative2 ? path10 : joinPosix4(this.bundleRoot, routed);
+  }
+  listFiles(root) {
+    return this.inner.listFiles(root).filter((path10) => this.isPackIncluded(path10));
+  }
+  isDir(path10) {
+    return this.inner.isDir(path10);
+  }
+  isFile(path10) {
+    return this.inner.isFile(path10);
+  }
+  readTextFile(path10) {
+    return this.inner.readTextFile(this.resolveReadSource(path10));
+  }
+  writeTextFile(path10, content) {
+    this.inner.writeTextFile(path10, content);
+  }
+  ensureDir(path10) {
+    this.inner.ensureDir(path10);
+  }
+};
+function resolvePublishedPaths(packs, csharpVariant, bundleRoot, fs9) {
+  const manifestPacks = resolveManifestPackNames(packs ?? null, csharpVariant);
+  if (manifestPacks === null || manifestPacks.size === 0) {
+    return null;
+  }
+  const manifests = loadPackManifests(
+    joinPosix4(bundleRoot, PACK_MANIFEST_SUBDIR),
+    manifestPacks,
+    fs9
+  );
+  const published = computePublishedPaths(manifestPacks, manifests) ?? /* @__PURE__ */ new Set();
+  assertSingleCsharpToolchain(published, manifestPacks);
+  return published;
+}
 function pushDownCustomizations3(options) {
+  const sourceRoot = options.sourceRoot ?? options.repoRoot;
+  const bundleRoot = options.bundleRoot ?? sourceRoot;
+  const csharpVariant = options.csharpVariant ?? "modern";
+  const publishedPaths = resolvePublishedPaths(
+    options.packs,
+    csharpVariant,
+    bundleRoot,
+    options.fs
+  );
+  const filteringFs = new CodexFilteringFileSystem(options.fs, {
+    sourceRoot,
+    bundleRoot,
+    publishedPaths,
+    csharpVariant
+  });
+  void options.memoryMode;
   return pushDownCustomizations({
     repoRoot: options.repoRoot,
     destinationRoot: options.destinationRoot,
-    fs: options.fs,
-    ...options.sourceRoot === void 0 ? {} : { sourceRoot: options.sourceRoot },
+    fs: filteringFs,
+    sourceRoot,
     ...options.artifactRoot === void 0 ? {} : { artifactRoot: options.artifactRoot },
     rootFolders: ROOT_FOLDERS,
     artifactDirectory: ARTIFACT_DIRECTORY3,
@@ -17506,11 +17834,11 @@ function readMemoryScope(content) {
   }
   return scopeValue === GENERAL_MEMORY_SCOPE ? GENERAL_MEMORY_SCOPE : REPO_MEMORY_SCOPE;
 }
-function normalizePosix(value) {
+function normalizePosix2(value) {
   return value.replace(/\\/g, "/").replace(/\/+$/, "");
 }
 function isUnderAgentMemory(relativePosixPath) {
-  const normalized = normalizePosix(relativePosixPath);
+  const normalized = normalizePosix2(relativePosixPath);
   return normalized === AGENT_MEMORY_RELATIVE_ROOT || normalized.startsWith(`${AGENT_MEMORY_RELATIVE_ROOT}/`);
 }
 function isGeneralMemoryFile(relativePosixPath, content) {
@@ -17521,55 +17849,55 @@ function isGeneralMemoryFile(relativePosixPath, content) {
 }
 
 // ../../extensions/drm-copilot/src/lib/push-down/claude-pack-selection.ts
-var CORE_PACK_NAME = "core";
-var CSHARP_CANONICAL_PATHS = [
+var CORE_PACK_NAME2 = "core";
+var CSHARP_CANONICAL_PATHS2 = [
   ".claude/rules/csharp.md",
   ".claude/agents/csharp-typed-engineer.md",
   ".claude/skills/csharp-qa-gate/SKILL.md",
   ".claude/skills/invoke-csharp-engineer/SKILL.md"
 ];
-var CSHARP_PACK_NAMES = /* @__PURE__ */ new Set([
+var CSHARP_PACK_NAMES2 = /* @__PURE__ */ new Set([
   "csharp-modern",
   "csharp-legacy"
 ]);
 var LEGACY_VARIANT_SOURCE_PREFIX = ".claude-variants/csharp-legacy";
-var ManifestError = class extends Error {
+var ManifestError2 = class extends Error {
   constructor(message) {
     super(message);
     this.name = "ManifestError";
   }
 };
-function joinPosix3(dir, name) {
+function joinPosix5(dir, name) {
   const normalizedDir = dir.replace(/\\/g, "/").replace(/\/+$/, "");
   return normalizedDir === "" ? name : `${normalizedDir}/${name}`;
 }
-function loadPackManifests(manifestDir, selectedPackNames, fs9) {
+function loadPackManifests2(manifestDir, selectedPackNames, fs9) {
   const namesToLoad = new Set(selectedPackNames);
-  namesToLoad.add(CORE_PACK_NAME);
+  namesToLoad.add(CORE_PACK_NAME2);
   const manifests = /* @__PURE__ */ new Map();
   for (const name of [...namesToLoad].sort()) {
-    const manifestPath = joinPosix3(manifestDir, `${name}.json`);
+    const manifestPath = joinPosix5(manifestDir, `${name}.json`);
     if (!fs9.isFile(manifestPath)) {
-      throw new ManifestError(
+      throw new ManifestError2(
         `Pack manifest is missing for pack '${name}': ${manifestPath}`
       );
     }
     const rawText = fs9.readTextFile(manifestPath);
-    manifests.set(name, parseManifest(name, manifestPath, rawText));
+    manifests.set(name, parseManifest2(name, manifestPath, rawText));
   }
   return manifests;
 }
-function parseManifest(name, manifestPath, rawText) {
+function parseManifest2(name, manifestPath, rawText) {
   let loaded;
   try {
     loaded = JSON.parse(rawText);
   } catch {
-    throw new ManifestError(
+    throw new ManifestError2(
       `Pack manifest is not valid JSON for pack '${name}': ${manifestPath}`
     );
   }
   if (loaded === null || typeof loaded !== "object" || Array.isArray(loaded)) {
-    throw new ManifestError(
+    throw new ManifestError2(
       `Pack manifest must be a JSON object for pack '${name}': ${manifestPath}`
     );
   }
@@ -17579,31 +17907,31 @@ function parseManifest(name, manifestPath, rawText) {
   const manifestPaths = parsed["paths"];
   const sourcePrefix = parsed["source_prefix"];
   if (typeof manifestName !== "string" || manifestName === "") {
-    throw new ManifestError(
+    throw new ManifestError2(
       `Pack manifest 'name' must be a non-empty string: ${manifestPath}`
     );
   }
   if (typeof manifestLabel !== "string" || manifestLabel === "") {
-    throw new ManifestError(
+    throw new ManifestError2(
       `Pack manifest 'label' must be a non-empty string: ${manifestPath}`
     );
   }
   if (!Array.isArray(manifestPaths)) {
-    throw new ManifestError(
+    throw new ManifestError2(
       `Pack manifest 'paths' must be a list of strings: ${manifestPath}`
     );
   }
   const typedPaths = [];
   for (const entry of manifestPaths) {
     if (typeof entry !== "string") {
-      throw new ManifestError(
+      throw new ManifestError2(
         `Pack manifest 'paths' must be a list of strings: ${manifestPath}`
       );
     }
     typedPaths.push(entry);
   }
   if (sourcePrefix !== void 0 && sourcePrefix !== null && typeof sourcePrefix !== "string") {
-    throw new ManifestError(
+    throw new ManifestError2(
       `Pack manifest 'source_prefix' must be a string when present: ${manifestPath}`
     );
   }
@@ -17614,17 +17942,17 @@ function parseManifest(name, manifestPath, rawText) {
     sourcePrefix: sourcePrefix === void 0 || sourcePrefix === null ? null : sourcePrefix
   };
 }
-function computePublishedPaths(selectedPackNames, manifests) {
+function computePublishedPaths2(selectedPackNames, manifests) {
   if (selectedPackNames === null || selectedPackNames.size === 0) {
     return null;
   }
   const effectiveNames = new Set(selectedPackNames);
-  effectiveNames.add(CORE_PACK_NAME);
+  effectiveNames.add(CORE_PACK_NAME2);
   const published = /* @__PURE__ */ new Set();
   for (const name of effectiveNames) {
     const manifest = manifests.get(name);
     if (manifest === void 0) {
-      throw new ManifestError(
+      throw new ManifestError2(
         `No loaded manifest for selected pack '${name}'.`
       );
     }
@@ -17634,17 +17962,17 @@ function computePublishedPaths(selectedPackNames, manifests) {
   }
   return published;
 }
-function resolveVariantSourcePath(destinationRelativePath, csharpVariant) {
-  if (csharpVariant === "legacy" && CSHARP_CANONICAL_PATHS.includes(destinationRelativePath)) {
+function resolveVariantSourcePath2(destinationRelativePath, csharpVariant) {
+  if (csharpVariant === "legacy" && CSHARP_CANONICAL_PATHS2.includes(destinationRelativePath)) {
     const tail = destinationRelativePath.slice(".claude/".length);
     return `${LEGACY_VARIANT_SOURCE_PREFIX}/${tail}`;
   }
   return destinationRelativePath;
 }
-function assertSingleCsharpToolchain(publishedPaths, selectedPackNames) {
-  const selectedCsharp = [...selectedPackNames].filter((name) => CSHARP_PACK_NAMES.has(name)).sort();
+function assertSingleCsharpToolchain2(publishedPaths, selectedPackNames) {
+  const selectedCsharp = [...selectedPackNames].filter((name) => CSHARP_PACK_NAMES2.has(name)).sort();
   if (selectedCsharp.length > 1) {
-    throw new ManifestError(
+    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.`
     );
   }
@@ -17652,11 +17980,11 @@ function assertSingleCsharpToolchain(publishedPaths, selectedPackNames) {
 }
 
 // ../../extensions/drm-copilot/src/lib/push-down/claude-filesystem-adapter.ts
-function normalizePosix2(value) {
+function normalizePosix3(value) {
   return value.replace(/\\/g, "/").replace(/\/+$/, "");
 }
-function joinPosix4(root, relative2) {
-  const normalizedRoot = normalizePosix2(root);
+function joinPosix6(root, relative2) {
+  const normalizedRoot = normalizePosix3(root);
   const normalizedRelative = relative2.replace(/\\/g, "/").replace(/^\/+/, "");
   if (normalizedRoot === "") {
     return normalizedRelative;
@@ -17666,9 +17994,9 @@ function joinPosix4(root, relative2) {
   }
   return `${normalizedRoot}/${normalizedRelative}`;
 }
-function relativeToPosix2(path10, root) {
-  const normalizedPath = normalizePosix2(path10);
-  const normalizedRoot = normalizePosix2(root);
+function relativeToPosix3(path10, root) {
+  const normalizedPath = normalizePosix3(path10);
+  const normalizedRoot = normalizePosix3(root);
   if (normalizedPath === normalizedRoot) {
     return "";
   }
@@ -17697,16 +18025,16 @@ var ExcludingFileSystem = class {
    */
   constructor(inner, repoRoot, excluded, options = {}) {
     this.inner = inner;
-    this.repoRoot = normalizePosix2(repoRoot);
-    this.sourceRoot = normalizePosix2(options.sourceRoot ?? repoRoot);
-    this.variantRoot = normalizePosix2(
+    this.repoRoot = normalizePosix3(repoRoot);
+    this.sourceRoot = normalizePosix3(options.sourceRoot ?? repoRoot);
+    this.variantRoot = normalizePosix3(
       options.variantRoot ?? options.sourceRoot ?? repoRoot
     );
-    this.destinationRoot = options.destinationRoot === void 0 ? void 0 : normalizePosix2(options.destinationRoot);
+    this.destinationRoot = options.destinationRoot === void 0 ? void 0 : normalizePosix3(options.destinationRoot);
     this.publishedPaths = options.publishedPaths ?? null;
     this.csharpVariant = options.csharpVariant ?? "modern";
     this.memoryMode = options.memoryMode ?? "overwrite";
-    this.excluded = new Set(excluded.map((p) => joinPosix4(this.repoRoot, p)));
+    this.excluded = new Set(excluded.map((p) => joinPosix6(this.repoRoot, p)));
   }
   /**
    * Return the source-relative POSIX path, or null when outside the root.
@@ -17715,7 +18043,7 @@ var ExcludingFileSystem = class {
    * @returns The source-relative POSIX path, or `null`.
    */
   sourceRelativePosix(path10) {
-    return relativeToPosix2(path10, this.sourceRoot);
+    return relativeToPosix3(path10, this.sourceRoot);
   }
   /**
    * Return whether a candidate path is in the active published set.
@@ -17742,7 +18070,7 @@ var ExcludingFileSystem = class {
    * @returns True when the file is outside the memory subtree or general-scoped.
    */
   isScopeIncluded(path10) {
-    const relativePath = relativeToPosix2(path10, this.repoRoot);
+    const relativePath = relativeToPosix3(path10, this.repoRoot);
     if (relativePath === null) {
       return true;
     }
@@ -17773,7 +18101,7 @@ var ExcludingFileSystem = class {
       if (this.destinationRoot === void 0) {
         return true;
       }
-      const destinationPath = joinPosix4(this.destinationRoot, relative2);
+      const destinationPath = joinPosix6(this.destinationRoot, relative2);
       return !this.inner.isFile(destinationPath);
     }
     return true;
@@ -17792,15 +18120,15 @@ var ExcludingFileSystem = class {
       return path10;
     }
     const relative2 = this.sourceRelativePosix(path10);
-    if (relative2 === null || !CSHARP_CANONICAL_PATHS.includes(relative2)) {
+    if (relative2 === null || !CSHARP_CANONICAL_PATHS2.includes(relative2)) {
       return path10;
     }
-    const redirectedRelative = resolveVariantSourcePath(relative2, "legacy");
-    return joinPosix4(this.variantRoot, redirectedRelative);
+    const redirectedRelative = resolveVariantSourcePath2(relative2, "legacy");
+    return joinPosix6(this.variantRoot, redirectedRelative);
   }
   listFiles(root) {
     return this.inner.listFiles(root).filter(
-      (p) => !this.excluded.has(normalizePosix2(p)) && this.isPackIncluded(p) && this.isScopeIncluded(p) && this.isMemoryModeIncluded(p)
+      (p) => !this.excluded.has(normalizePosix3(p)) && this.isPackIncluded(p) && this.isScopeIncluded(p) && this.isMemoryModeIncluded(p)
     );
   }
   isDir(path10) {
@@ -17830,28 +18158,28 @@ var EXCLUDED_RELATIVE_PATHS = [
   ".claude/settings.local.json"
 ];
 var BUNDLE_ROOT_RELATIVE_DIR = "extensions/drm-copilot/resources/claude-customizations";
-var PACK_MANIFEST_SUBDIR = "pack-manifests";
+var PACK_MANIFEST_SUBDIR2 = "pack-manifests";
 function passthroughRewrite2(text) {
   return [text, 0, 0, []];
 }
-function joinPosix5(root, relative2) {
+function joinPosix7(root, relative2) {
   const normalizedRoot = root.replace(/\\/g, "/").replace(/\/+$/, "");
   const normalizedRelative = relative2.replace(/\\/g, "/").replace(/^\/+/, "");
   return normalizedRoot === "" ? normalizedRelative : `${normalizedRoot}/${normalizedRelative}`;
 }
-function resolvePublishedPaths(packs, bundleRoot, fs9) {
+function resolvePublishedPaths2(packs, bundleRoot, fs9) {
   if (packs === null || packs.size === 0) {
     return null;
   }
-  const manifestDir = joinPosix5(bundleRoot, PACK_MANIFEST_SUBDIR);
-  const manifests = loadPackManifests(
+  const manifestDir = joinPosix7(bundleRoot, PACK_MANIFEST_SUBDIR2);
+  const manifests = loadPackManifests2(
     manifestDir,
     packs,
     fs9
   );
-  const published = computePublishedPaths(packs, manifests);
+  const published = computePublishedPaths2(packs, manifests);
   const effectivePublished = published ?? /* @__PURE__ */ new Set();
-  assertSingleCsharpToolchain(effectivePublished, packs);
+  assertSingleCsharpToolchain2(effectivePublished, packs);
   return effectivePublished;
 }
 function pushDownCustomizations4(options) {
@@ -17868,8 +18196,8 @@ function pushDownCustomizations4(options) {
     clock
   } = options;
   const effectiveSource = sourceRoot ?? repoRoot;
-  const effectiveBundle = bundleRoot ?? joinPosix5(effectiveSource, BUNDLE_ROOT_RELATIVE_DIR);
-  const publishedPaths = resolvePublishedPaths(
+  const effectiveBundle = bundleRoot ?? joinPosix7(effectiveSource, BUNDLE_ROOT_RELATIVE_DIR);
+  const publishedPaths = resolvePublishedPaths2(
     packs ?? null,
     effectiveBundle,
     fs9
@@ -17932,12 +18260,17 @@ function pushDownCodexAndAgentsCustomizationsServiceCall(input) {
     "resources/codex-and-agents-customizations"
   );
   const destinationRoot = toPosixPath(input.workspaceRoot);
+  const packs = input.packs === void 0 || input.packs.length === 0 ? null : new Set(input.packs);
   const summary = pushDownCustomizations3({
     repoRoot: sourceRoot,
     destinationRoot,
     fs: input.fs,
     sourceRoot,
     artifactRoot: destinationRoot,
+    bundleRoot: sourceRoot,
+    packs,
+    ...input.csharpVariant === void 0 ? {} : { csharpVariant: input.csharpVariant },
+    ...input.memoryMode === void 0 ? {} : { memoryMode: input.memoryMode },
     ...input.clock === void 0 ? {} : { clock: input.clock }
   });
   return {
@@ -17983,6 +18316,14 @@ function buildPushDownClaudeCustomizationsOptions(input) {
     ...input.memoryMode === void 0 ? {} : { memoryMode: input.memoryMode }
   };
 }
+function buildPushDownCodexAndAgentsCustomizationsOptions(input) {
+  return {
+    workspaceRoot: input.workspaceRoot,
+    ...input.packs === void 0 ? {} : { packs: input.packs },
+    ...input.csharpVariant === void 0 ? {} : { csharpVariant: input.csharpVariant },
+    ...input.memoryMode === void 0 ? {} : { memoryMode: input.memoryMode }
+  };
+}
 function runPushDownCopilotCustomizations(workspaceRoot, deps) {
   return pushDownCopilotCustomizationsServiceCall({
     fs: deps.fs,
@@ -17991,12 +18332,16 @@ function runPushDownCopilotCustomizations(workspaceRoot, deps) {
     log: deps.log
   });
 }
-function runPushDownCodexAndAgentsCustomizations(workspaceRoot, deps) {
+function runPushDownCodexAndAgentsCustomizations(input, deps) {
+  const forwarded = buildPushDownCodexAndAgentsCustomizationsOptions(input);
   return pushDownCodexAndAgentsCustomizationsServiceCall({
     fs: deps.fs,
     extensionRoot: deps.extensionRoot,
-    workspaceRoot,
-    log: deps.log
+    workspaceRoot: forwarded.workspaceRoot,
+    log: deps.log,
+    ...forwarded.packs === void 0 ? {} : { packs: forwarded.packs },
+    ...forwarded.csharpVariant === void 0 ? {} : { csharpVariant: forwarded.csharpVariant },
+    ...forwarded.memoryMode === void 0 ? {} : { memoryMode: forwarded.memoryMode }
   });
 }
 function runPushDownClaudeCustomizations(input, deps) {
@@ -18074,7 +18419,7 @@ var nodePath3 = __toESM(require("node:path"));
 function toPosixPath2(value) {
   return value.replace(/\\/g, "/");
 }
-function joinPosix6(root, relative2) {
+function joinPosix8(root, relative2) {
   const normalizedRoot = toPosixPath2(root).replace(/\/+$/, "");
   const normalizedRelative = toPosixPath2(relative2).replace(/^\/+/, "");
   if (normalizedRoot === "") {
@@ -18147,7 +18492,7 @@ var RealFileSystem = class {
       for (const entry of entries) {
         const relativePath = relativePrefix === "" ? entry.name : `${relativePrefix}/${entry.name}`;
         if (matcher.test(relativePath)) {
-          matches.push(joinPosix6(normalizedRoot, relativePath));
+          matches.push(joinPosix8(normalizedRoot, relativePath));
         }
         if (entry.isDirectory()) {
           walk(nodePath3.join(currentDir, entry.name), relativePath);
@@ -18305,11 +18650,11 @@ function resolveTemplateName(templateKind) {
 function resolveTemplatePath(templateName, workspaceRoot, templateRoot, fs9) {
   const candidates = [];
   if (templateRoot !== null) {
-    candidates.push(joinPosix7(templateRoot, templateName));
+    candidates.push(joinPosix9(templateRoot, templateName));
   }
   candidates.push(
-    joinPosix7(
-      joinPosix7(toPosixPath2(workspaceRoot), ".github/codex"),
+    joinPosix9(
+      joinPosix9(toPosixPath2(workspaceRoot), ".github/codex"),
       templateName
     )
   );
@@ -18324,15 +18669,15 @@ function resolveIssueFileForTarget(targetPath, workspaceRoot, fs9) {
   const normalizedRoot = toPosixPath2(workspaceRoot).replace(/\/+$/, "");
   const relativeTarget = tryRelativeToWorkspace(targetPath, workspaceRoot);
   const planDir = parentOf(relativeTarget);
-  const directIssue = joinPosix7(joinPosix7(normalizedRoot, planDir), "issue.md");
+  const directIssue = joinPosix9(joinPosix9(normalizedRoot, planDir), "issue.md");
   if (fs9.isFile(directIssue)) {
     return directIssue;
   }
   const planDirParts = splitParts(planDir);
   const planDirName = planDirParts[planDirParts.length - 1] ?? "";
   if (planDirName.startsWith("v") && planDirParts.length >= 2) {
-    const parentIssue = joinPosix7(
-      joinPosix7(normalizedRoot, parentOf(planDir)),
+    const parentIssue = joinPosix9(
+      joinPosix9(normalizedRoot, parentOf(planDir)),
       "issue.md"
     );
     if (fs9.isFile(parentIssue)) {
@@ -18453,7 +18798,7 @@ function resolveOutputPath(output, workspaceRoot) {
   if (isAbsolute(output)) {
     return toPosixPath2(output);
   }
-  return joinPosix7(toPosixPath2(workspaceRoot), output);
+  return joinPosix9(toPosixPath2(workspaceRoot), output);
 }
 function tryRelativeToWorkspace(path10, workspaceRoot) {
   const normalizedPath = toPosixPath2(path10).replace(/\/+$/, "");
@@ -18481,7 +18826,7 @@ function parentOf(pathValue) {
 function splitParts(pathValue) {
   return toPosixPath2(pathValue).split("/").filter((part) => part.length > 0 && part !== ".");
 }
-function joinPosix7(root, relative2) {
+function joinPosix9(root, relative2) {
   const normalizedRoot = toPosixPath2(root).replace(/\/+$/, "");
   const normalizedRelative = toPosixPath2(relative2).replace(/^\/+/, "");
   if (normalizedRelative === "" || normalizedRelative === ".") {
@@ -19443,7 +19788,7 @@ var SUPPORTED_ROOTS = {
     ".claude/rules"
   ]
 };
-function joinPosix8(root, relative2) {
+function joinPosix10(root, relative2) {
   const normalizedRoot = root.replace(/\/+$/, "");
   const normalizedRelative = relative2.replace(/^\/+/, "");
   if (normalizedRoot === "") {
@@ -19485,7 +19830,7 @@ function isAbsolutePath(value) {
 function normalizeRelativePath(sourceRoot, candidatePath) {
   const resolvedRoot = collapseSegments(toPosixPath2(sourceRoot));
   const candidate = toPosixPath2(candidatePath);
-  const resolvedCandidate = isAbsolutePath(candidate) ? collapseSegments(candidate) : collapseSegments(joinPosix8(resolvedRoot, candidate));
+  const resolvedCandidate = isAbsolutePath(candidate) ? collapseSegments(candidate) : collapseSegments(joinPosix10(resolvedRoot, candidate));
   const rootPrefix = `${resolvedRoot.replace(/\/+$/, "")}/`;
   if (resolvedCandidate === resolvedRoot) {
     return "";
@@ -19508,7 +19853,7 @@ function normalizeSelectedPaths(sourceRoot, selectedPaths) {
 }
 function collectFilesRecursive(fileSystem, absoluteDir, out) {
   for (const childName of fileSystem.listDirectory(absoluteDir)) {
-    const childPath = joinPosix8(absoluteDir, childName);
+    const childPath = joinPosix10(absoluteDir, childName);
     if (fileSystem.isDirectory(childPath)) {
       collectFilesRecursive(fileSystem, childPath, out);
     } else if (fileSystem.isFile(childPath)) {
@@ -19522,7 +19867,7 @@ function iterSupportedArtifacts(fileSystem, sourceRoot, sourceEcosystem) {
   const discovered = /* @__PURE__ */ new Set();
   for (const supportedRoot of SUPPORTED_ROOTS[sourceEcosystem]) {
     const absoluteSupportedRoot = collapseSegments(
-      joinPosix8(resolvedRoot, supportedRoot)
+      joinPosix10(resolvedRoot, supportedRoot)
     );
     if (!fileSystem.exists(absoluteSupportedRoot)) {
       continue;
@@ -20589,14 +20934,14 @@ function sortKeysDeep(value) {
 function dumpsSorted(payload) {
   return JSON.stringify(sortKeysDeep(payload), null, 2);
 }
-function joinPosix9(root, child) {
+function joinPosix11(root, child) {
   const normalizedRoot = root.replace(/\/+$/, "");
   return normalizedRoot === "" ? child : `${normalizedRoot}/${child}`;
 }
 function writeIntermediateStateArtifacts(fileSystem, state, artifactRoot) {
-  const intermediateDir = joinPosix9(artifactRoot, "intermediate");
+  const intermediateDir = joinPosix11(artifactRoot, "intermediate");
   fileSystem.ensureDir(intermediateDir);
-  const sourceArtifactsPath = joinPosix9(
+  const sourceArtifactsPath = joinPosix11(
     intermediateDir,
     "source-artifacts.json"
   );
@@ -20606,14 +20951,14 @@ function writeIntermediateStateArtifacts(fileSystem, state, artifactRoot) {
       state.sourceArtifacts.map((artifact) => sourceArtifactToJson(artifact))
     )
   );
-  const sectionIntentsPath = joinPosix9(intermediateDir, "section-intents.json");
+  const sectionIntentsPath = joinPosix11(intermediateDir, "section-intents.json");
   fileSystem.writeTextFile(
     sectionIntentsPath,
     dumpsSorted(
       state.sectionIntents.map((intent) => sectionIntentToJson(intent))
     )
   );
-  const plannedEmissionsPath = joinPosix9(
+  const plannedEmissionsPath = joinPosix11(
     intermediateDir,
     "planned-emissions.json"
   );
@@ -20623,7 +20968,7 @@ function writeIntermediateStateArtifacts(fileSystem, state, artifactRoot) {
       state.plannedEmissions.map((emission) => plannedEmissionToJson(emission))
     )
   );
-  const translationTracesPath = joinPosix9(
+  const translationTracesPath = joinPosix11(
     intermediateDir,
     "translation-traces.json"
   );
@@ -20955,7 +21300,7 @@ function collapseSegments2(value) {
   }
   return isAbsolute2 ? `/${joined}` : joined;
 }
-function joinPosix10(root, child) {
+function joinPosix12(root, child) {
   const normalizedRoot = root.replace(/\/+$/, "");
   const normalizedChild = child.replace(/^\/+/, "");
   return normalizedRoot === "" ? normalizedChild : `${normalizedRoot}/${normalizedChild}`;
@@ -20981,11 +21326,11 @@ function sortFindings(validationFindings) {
 }
 function writeConversionReportSet(fileSystem, runOptions, mappingRecords, topologyEdges, translationTraces, validationFindings, generatedOutput) {
   const artifactRoot = collapseSegments2(runOptions.artifactRoot);
-  const proposedTreeRoot = joinPosix10(artifactRoot, "proposed-tree");
+  const proposedTreeRoot = joinPosix12(artifactRoot, "proposed-tree");
   const reportPaths = {
-    conversionReport: joinPosix10(artifactRoot, "conversion-report.md"),
-    mappingCatalog: joinPosix10(artifactRoot, "mapping-catalog.json"),
-    validationResults: joinPosix10(artifactRoot, "validation-results.json"),
+    conversionReport: joinPosix12(artifactRoot, "conversion-report.md"),
+    mappingCatalog: joinPosix12(artifactRoot, "mapping-catalog.json"),
+    validationResults: joinPosix12(artifactRoot, "validation-results.json"),
     proposedTreeRoot
   };
   fileSystem.ensureDir(artifactRoot);
@@ -21018,7 +21363,7 @@ function writeConversionReportSet(fileSystem, runOptions, mappingRecords, topolo
     (left, right) => left < right ? -1 : left > right ? 1 : 0
   )) {
     fileSystem.writeTextFile(
-      joinPosix10(proposedTreeRoot, targetPath),
+      joinPosix12(proposedTreeRoot, targetPath),
       generatedOutput[targetPath] ?? ""
     );
   }
@@ -21435,6 +21780,278 @@ var SubprocessRunner = class {
 // ../../extensions/drm-copilot/src/lib/validate/validate-orchestration-service-call.ts
 var path8 = __toESM(require("node:path"));
 
+// ../../extensions/drm-copilot/src/lib/validate/epic-orchestrator-state-core.ts
+var REQUIRED_BASELINE_KEYS = [
+  "objective",
+  "completed_steps",
+  "next_step",
+  "last_updated"
+];
+var REQUIRED_EPIC_KEYS = [
+  "route_id",
+  "epic_feature_folder",
+  "integration_branch",
+  "waves",
+  "features"
+];
+var EXPECTED_ROUTE_ID = "epic";
+var VALID_MERGE_STATUS = /* @__PURE__ */ new Set([
+  "not_started",
+  "worktree_created",
+  "pr_open",
+  "ci_green",
+  "merge_conflict",
+  "blocked_conflict_loop_limit",
+  "merged",
+  "worktree_removed"
+]);
+var MERGED_STATUSES = /* @__PURE__ */ new Set([
+  "merged",
+  "worktree_removed"
+]);
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extractFeatures(state) {
+  const features = state["features"];
+  if (!Array.isArray(features)) {
+    return [];
+  }
+  return features.filter(isObject2);
+}
+function missingBaselineAndEpicKeys(state) {
+  const errors = [];
+  for (const key of [...REQUIRED_BASELINE_KEYS, ...REQUIRED_EPIC_KEYS]) {
+    if (!(key in state)) {
+      errors.push(`Epic checkpoint missing required key: ${key}`);
+    }
+  }
+  return errors;
+}
+function validateRouteId(state) {
+  if ("route_id" in state && state["route_id"] !== EXPECTED_ROUTE_ID) {
+    return [
+      `Epic checkpoint route_id must be 'epic', found: ${JSON.stringify(state["route_id"])}`
+    ];
+  }
+  return [];
+}
+function validateFeatureFolderUniquenessAndDependencies(features) {
+  const errors = [];
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = /* @__PURE__ */ new Set();
+  const allFolders = /* @__PURE__ */ new Set();
+  for (const feature of features) {
+    const folder = feature["feature_folder"];
+    if (typeof folder === "string" && folder) {
+      allFolders.add(folder);
+    }
+  }
+  for (const feature of features) {
+    const folder = feature["feature_folder"];
+    if (typeof folder !== "string" || !folder) {
+      continue;
+    }
+    if (seen.has(folder)) {
+      duplicates.add(folder);
+    }
+    seen.add(folder);
+    const dependsOn = feature["depends_on"];
+    if (!Array.isArray(dependsOn)) {
+      continue;
+    }
+    for (const dependency of dependsOn) {
+      if (!allFolders.has(dependency)) {
+        errors.push(
+          `Epic checkpoint feature '${folder}' depends_on unresolved feature_folder: ${JSON.stringify(dependency)}`
+        );
+      }
+    }
+  }
+  for (const folder of [...duplicates].sort()) {
+    errors.push(
+      `Epic checkpoint has duplicate features[].feature_folder: ${folder}`
+    );
+  }
+  return errors;
+}
+function detectDependencyCycle(features) {
+  const graph = /* @__PURE__ */ new Map();
+  for (const feature of features) {
+    const folder = feature["feature_folder"];
+    if (typeof folder !== "string" || !folder) {
+      continue;
+    }
+    const dependsOn = feature["depends_on"];
+    graph.set(
+      folder,
+      Array.isArray(dependsOn) ? dependsOn.filter(
+        (d) => typeof d === "string"
+      ) : []
+    );
+  }
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  function visit(node) {
+    if (visiting.has(node)) {
+      return node;
+    }
+    if (visited.has(node) || !graph.has(node)) {
+      return null;
+    }
+    visiting.add(node);
+    for (const dependency of graph.get(node) ?? []) {
+      const cycleNode = visit(dependency);
+      if (cycleNode !== null) {
+        return cycleNode;
+      }
+    }
+    visiting.delete(node);
+    visited.add(node);
+    return null;
+  }
+  for (const start of graph.keys()) {
+    const cycleNode = visit(start);
+    if (cycleNode !== null) {
+      return `Epic checkpoint depends_on graph contains a cycle involving feature_folder: ${cycleNode}`;
+    }
+  }
+  return null;
+}
+function validateMergeStatusEnum(features) {
+  const errors = [];
+  for (const feature of features) {
+    const folder = feature["feature_folder"] ?? "<unknown>";
+    const mergeStatus = feature["merge_status"];
+    if (mergeStatus !== void 0 && mergeStatus !== null && !(typeof mergeStatus === "string" && VALID_MERGE_STATUS.has(mergeStatus))) {
+      errors.push(
+        `Epic checkpoint feature '${String(folder)}' has invalid merge_status: ${JSON.stringify(mergeStatus)}`
+      );
+    }
+  }
+  return errors;
+}
+function validateWaveBarrierOrdering(features) {
+  const errors = [];
+  const byFolder = /* @__PURE__ */ new Map();
+  for (const feature of features) {
+    const folder = feature["feature_folder"];
+    if (typeof folder === "string") {
+      byFolder.set(folder, feature);
+    }
+  }
+  for (const feature of features) {
+    const folder = feature["feature_folder"];
+    const dependsOn = feature["depends_on"];
+    if (typeof folder !== "string" || !Array.isArray(dependsOn)) {
+      continue;
+    }
+    const worktreeCreatedAt = feature["worktree_created_at"];
+    for (const dependency of dependsOn) {
+      const dependencyFeature = byFolder.get(dependency);
+      if (dependencyFeature === void 0) {
+        continue;
+      }
+      const depMergeStatus = dependencyFeature["merge_status"];
+      const depConfirmedAt = dependencyFeature["merge_confirmed_at"];
+      const statusViolation = typeof depMergeStatus !== "string" || !MERGED_STATUSES.has(depMergeStatus);
+      const timingViolation = typeof depConfirmedAt === "string" && typeof worktreeCreatedAt === "string" && depConfirmedAt > worktreeCreatedAt;
+      if (statusViolation || timingViolation) {
+        errors.push(
+          `EPIC_WAVE_BARRIER_VIOLATION: ${folder} started before dependency ${String(dependency)} merged`
+        );
+      }
+    }
+  }
+  return errors;
+}
+function validateWavesConsistency(state) {
+  const errors = [];
+  const waves = state["waves"];
+  if (!Array.isArray(waves)) {
+    return errors;
+  }
+  const featuresByFolder = /* @__PURE__ */ new Map();
+  for (const feature of extractFeatures(state)) {
+    const folder = feature["feature_folder"];
+    if (typeof folder === "string") {
+      featuresByFolder.set(folder, feature);
+    }
+  }
+  for (const waveItem of waves) {
+    if (!isObject2(waveItem)) {
+      continue;
+    }
+    const waveNumber = waveItem["wave_number"];
+    const folders = waveItem["feature_folders"];
+    if (!Array.isArray(folders)) {
+      continue;
+    }
+    for (const folder of folders) {
+      const feature = featuresByFolder.get(folder);
+      if (feature === void 0) {
+        continue;
+      }
+      if (feature["wave_number"] !== waveNumber) {
+        errors.push(
+          `Epic checkpoint waves[] lists '${String(folder)}' under wave ${String(waveNumber)} but its own wave_number is ${JSON.stringify(feature["wave_number"])}`
+        );
+      }
+    }
+  }
+  return errors;
+}
+function validateCompletion(features, state) {
+  const errors = [];
+  for (const feature of features) {
+    const folder = feature["feature_folder"] ?? "<unknown>";
+    const mergeStatus = feature["merge_status"];
+    if (typeof mergeStatus !== "string" || !MERGED_STATUSES.has(mergeStatus)) {
+      errors.push(
+        `Epic checkpoint completion validation failed: feature '${String(folder)}' merge_status is not merged/worktree_removed.`
+      );
+    }
+  }
+  const epicMergePr = state["epic_merge_pr"];
+  const mergeCommitSha = isObject2(epicMergePr) ? epicMergePr["merge_commit_sha"] : void 0;
+  if (typeof mergeCommitSha !== "string" || !mergeCommitSha.trim()) {
+    errors.push(
+      "Epic checkpoint completion validation failed: epic_merge_pr.merge_commit_sha is missing or empty."
+    );
+  }
+  return errors;
+}
+function validateEpicOrchestratorStateText(text, options = {}) {
+  let state;
+  try {
+    state = JSON.parse(text);
+  } catch (exc) {
+    return [
+      `Epic checkpoint is not valid JSON: ${exc instanceof Error ? exc.message : String(exc)}`
+    ];
+  }
+  if (!isObject2(state)) {
+    return ["Epic checkpoint root must be a JSON object."];
+  }
+  const stateMap = state;
+  const errors = [];
+  errors.push(...missingBaselineAndEpicKeys(stateMap));
+  errors.push(...validateRouteId(stateMap));
+  const features = extractFeatures(stateMap);
+  errors.push(...validateFeatureFolderUniquenessAndDependencies(features));
+  const cycleError = detectDependencyCycle(features);
+  if (cycleError !== null) {
+    errors.push(cycleError);
+  }
+  errors.push(...validateMergeStatusEnum(features));
+  errors.push(...validateWaveBarrierOrdering(features));
+  errors.push(...validateWavesConsistency(stateMap));
+  if (options.requireComplete === true) {
+    errors.push(...validateCompletion(features, stateMap));
+  }
+  return errors;
+}
+
 // ../../extensions/drm-copilot/src/lib/validate/orchestrator-state-completion.ts
 var ISSUE_232 = "232";
 var ISSUE_232_BRANCH = "feature/harden-orchestrate-skill-232";
@@ -21451,11 +22068,11 @@ var PROMOTION_RECEIPT_KEYS = [
   "issue",
   "feature_folder"
 ];
-function isObject2(value) {
+function isObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function missingObjectKeys(value, keys) {
-  if (!isObject2(value)) {
+  if (!isObject3(value)) {
     return [...keys];
   }
   const missing = [];
@@ -21470,7 +22087,7 @@ function missingObjectKeys(value, keys) {
 function validateCompletionPrGate(state) {
   const prGate = state["pr_gate"];
   const missing = missingObjectKeys(prGate, PR_GATE_KEYS);
-  if (!isObject2(prGate)) {
+  if (!isObject3(prGate)) {
     return [
       `Checkpoint completion validation failed: pr_gate must be an object with keys: ${PR_GATE_KEYS.join(", ")}.`
     ];
@@ -21493,7 +22110,7 @@ function validateCompletionPrGate(state) {
 function validateCompletionCiGate(state) {
   const ciGate = state["ci_gate"];
   const missing = missingObjectKeys(ciGate, CI_GATE_KEYS);
-  if (!isObject2(ciGate)) {
+  if (!isObject3(ciGate)) {
     return [
       `Checkpoint completion validation failed: ci_gate must be an object with keys: ${CI_GATE_KEYS.join(", ")}.`
     ];
@@ -21510,7 +22127,7 @@ function validateCompletionCiGate(state) {
     );
   }
   const prGate = state["pr_gate"];
-  const prHeadSha = isObject2(prGate) ? prGate["head_sha"] : null;
+  const prHeadSha = isObject3(prGate) ? prGate["head_sha"] : null;
   if (prHeadSha !== null && prHeadSha !== void 0 && ciGate["head_sha"] !== prHeadSha) {
     errors.push(
       "Checkpoint completion validation failed: ci_gate.head_sha must match pr_gate.head_sha."
@@ -21525,7 +22142,7 @@ function validateIssue232PromotionReceipts(state) {
   const receipts = state["delegation_receipts"];
   let promotionSource = "promotion_receipts";
   let promotion = state["promotion_receipts"];
-  if (isObject2(receipts)) {
+  if (isObject3(receipts)) {
     const namespacedPromotion = receipts[PROMOTION_RECEIPT_NAMESPACE_KEY];
     if (namespacedPromotion !== void 0 && namespacedPromotion !== null) {
       promotionSource = "delegation_receipts.promotion";
@@ -21550,7 +22167,7 @@ var HUMAN_INTERACTION_RESPONSE_ENUM = /* @__PURE__ */ new Set([
   "halt"
 ]);
 var HUMAN_INTERACTION_EXCEPTION_RESPONSE = "exception";
-function isObject3(value) {
+function isObject4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function pythonRepr(value) {
@@ -21567,7 +22184,7 @@ function pythonRepr(value) {
 }
 function validateHumanInteraction(humanInteraction) {
   const errors = [];
-  if (!isObject3(humanInteraction)) {
+  if (!isObject4(humanInteraction)) {
     errors.push("Checkpoint human_interaction must be an object when present.");
     return errors;
   }
@@ -21577,7 +22194,7 @@ function validateHumanInteraction(humanInteraction) {
     return errors;
   }
   requirements.forEach((requirement, index) => {
-    if (!isObject3(requirement)) {
+    if (!isObject4(requirement)) {
       errors.push(
         `Checkpoint human_interaction.requirements #${index} must be an object.`
       );
@@ -21607,7 +22224,7 @@ 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 isObject4(value) {
+function isObject5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function validateRemediationCycle(index, cycle) {
@@ -21621,7 +22238,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 = isObject4(preflight) ? preflight["final_status"] : void 0;
+    const preflightStatus = isObject5(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'.`
@@ -21637,7 +22254,7 @@ function validateRemediationCycle(index, cycle) {
 }
 function validateRemediationLoop(remediationLoop) {
   const errors = [];
-  if (!isObject4(remediationLoop)) {
+  if (!isObject5(remediationLoop)) {
     return errors;
   }
   const cycles = remediationLoop[REMEDIATION_CYCLES_KEY];
@@ -21645,7 +22262,7 @@ function validateRemediationLoop(remediationLoop) {
     return errors;
   }
   cycles.forEach((cycle, index) => {
-    if (!isObject4(cycle)) {
+    if (!isObject5(cycle)) {
       errors.push(`Checkpoint remediation cycle #${index} must be an object.`);
       return;
     }
@@ -21656,7 +22273,7 @@ function validateRemediationLoop(remediationLoop) {
 
 // ../../extensions/drm-copilot/src/lib/validate/orchestrator-state-routing.ts
 var ROUTING_MATRIX_RELATIVE_PATH = "config/orchestration-routing.json";
-function isObject5(value) {
+function isObject6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function loadRoutingMatrix(fs9, root) {
@@ -21693,7 +22310,7 @@ function listReceipts(receipts) {
   if (!Array.isArray(receipts)) {
     return [];
   }
-  return receipts.filter(isObject5);
+  return receipts.filter(isObject6);
 }
 function receiptAgents(state) {
   const agents = /* @__PURE__ */ new Set();
@@ -21712,7 +22329,7 @@ function receiptSkills(state) {
     return skills;
   }
   for (const receipt of receipts) {
-    if (!isObject5(receipt)) {
+    if (!isObject6(receipt)) {
       continue;
     }
     const skill = receipt["skill"];
@@ -21731,7 +22348,7 @@ function mcpTools(state) {
     return tools;
   }
   for (const receipt of receipts) {
-    if (!isObject5(receipt)) {
+    if (!isObject6(receipt)) {
       continue;
     }
     const tool = receipt["tool"];
@@ -21763,7 +22380,7 @@ function validateLifecycleOperations(state) {
   }
   const errors = [];
   operations.forEach((operation, index) => {
-    if (!isObject5(operation)) {
+    if (!isObject6(operation)) {
       errors.push(
         `Checkpoint lifecycle_operations #${index} must be an object.`
       );
@@ -21779,11 +22396,11 @@ function validateLifecycleOperations(state) {
 }
 function validateRoutingContract(state, options = {}) {
   const matrix = options.routingMatrix;
-  if (!isObject5(matrix)) {
+  if (!isObject6(matrix)) {
     return ["Routing matrix missing routes object."];
   }
   const rawRoutes = matrix["routes"];
-  if (!isObject5(rawRoutes)) {
+  if (!isObject6(rawRoutes)) {
     return ["Routing matrix missing routes object."];
   }
   const routeIdValue = state["route_id"] !== void 0 ? state["route_id"] : state["path_selected"];
@@ -21792,7 +22409,7 @@ function validateRoutingContract(state, options = {}) {
   }
   const routeId = routeIdValue;
   const rawRoute = rawRoutes[routeId];
-  if (!isObject5(rawRoute)) {
+  if (!isObject6(rawRoute)) {
     return [
       `Checkpoint selected route has no routing-matrix entry: ${routeId}.`
     ];
@@ -21902,13 +22519,13 @@ var STEP_STATUS_KEYS = [
   "step9_status",
   "step10_status"
 ];
-function isObject6(value) {
+function isObject7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function validateListDelegationReceipts(receipts) {
   const errors = [];
   receipts.forEach((receipt, index) => {
-    if (!isObject6(receipt)) {
+    if (!isObject7(receipt)) {
       errors.push(`Checkpoint delegation receipt #${index} must be an object.`);
       return;
     }
@@ -21940,7 +22557,7 @@ function validateNamespacedDelegationReceipts(receipts) {
   if (promotionReceipts === void 0 || promotionReceipts === null) {
     return errors;
   }
-  if (!isObject6(promotionReceipts)) {
+  if (!isObject7(promotionReceipts)) {
     errors.push(
       "Checkpoint delegation_receipts.promotion must be an object namespace."
     );
@@ -21975,7 +22592,7 @@ function validateOrchestratorStateText(text, options = {}) {
       `Checkpoint is not valid JSON: ${exc instanceof Error ? exc.message : String(exc)}`
     ];
   }
-  if (!isObject6(state)) {
+  if (!isObject7(state)) {
     return ["Checkpoint root must be a JSON object."];
   }
   const stateMap = state;
@@ -22000,7 +22617,7 @@ function validateOrchestratorStateText(text, options = {}) {
   if (receipts !== void 0 && receipts !== null) {
     if (Array.isArray(receipts)) {
       errors.push(...validateListDelegationReceipts(receipts));
-    } else if (isObject6(receipts)) {
+    } else if (isObject7(receipts)) {
       errors.push(...validateNamespacedDelegationReceipts(receipts));
     } else {
       errors.push(
@@ -22418,6 +23035,12 @@ function validateArtifact(input) {
       };
       return validateOrchestratorStateText(input.text, options);
     }
+    case "epic-orchestrator-state": {
+      const options = {
+        ...input.requireComplete === void 0 ? {} : { requireComplete: input.requireComplete }
+      };
+      return validateEpicOrchestratorStateText(input.text, options);
+    }
     default:
       return [`Unsupported artifact type: ${input.artifactType}`];
   }
@@ -23969,7 +24592,7 @@ function resolveReadinessSignal(fs9, featureDir) {
   }
   return [null, null];
 }
-function relativeToPosix3(root, path10) {
+function relativeToPosix4(root, path10) {
   const normalizedRoot = toPosixPath2(root).replace(/\/+$/u, "");
   const normalized = toPosixPath2(path10);
   if (normalized.startsWith(`${normalizedRoot}/`)) {
@@ -24007,7 +24630,7 @@ function discoverCanonicalEvidenceFiles(fs9, root, feature) {
   for (const pattern of CANONICAL_GLOBS) {
     for (const candidate of fs9.glob(featureRoot, pattern)) {
       if (fs9.isFile(candidate)) {
-        discovered.add(relativeToPosix4(normalizedRoot, candidate));
+        discovered.add(relativeToPosix5(normalizedRoot, candidate));
       }
     }
   }
@@ -24078,7 +24701,7 @@ function parseIntegerStrict(value) {
   }
   return Number.parseInt(value, 10);
 }
-function relativeToPosix4(root, absolute) {
+function relativeToPosix5(root, absolute) {
   const normalized = toPosixPath2(absolute);
   if (normalized.startsWith(`${root}/`)) {
     return normalized.slice(root.length + 1);
@@ -24117,7 +24740,7 @@ var SPEC_HEADINGS = [
   "Behavior",
   "Overview"
 ];
-function extractFeatures(changedFiles) {
+function extractFeatures2(changedFiles) {
   const features = /* @__PURE__ */ new Set();
   for (const raw of changedFiles) {
     const parts = toPosixPath2(raw).split("/");
@@ -24129,7 +24752,7 @@ function extractFeatures(changedFiles) {
 }
 function gatherFeatureExcerpts2(fs9, root, changedFiles) {
   const normalizedRoot = toPosixPath2(root).replace(/\/+$/u, "");
-  const features = extractFeatures(changedFiles);
+  const features = extractFeatures2(changedFiles);
   const excerpts = [];
   const baseDir = `${normalizedRoot}/docs/features/active`;
   const promotedDir = `${normalizedRoot}/docs/features/potential/promoted`;
@@ -24275,11 +24898,11 @@ function buildContextFiles(params) {
   const contextFiles = [];
   for (const path10 of candidatePaths) {
     if (fs9.exists(path10)) {
-      contextFiles.push(relativeToPosix3(root, path10));
+      contextFiles.push(relativeToPosix4(root, path10));
     }
   }
   if (readinessSource !== null) {
-    contextFiles.push(relativeToPosix3(root, readinessSource));
+    contextFiles.push(relativeToPosix4(root, readinessSource));
   }
   const evidenceContextFiles = discoverCanonicalEvidenceFiles(
     fs9,
@@ -25816,7 +26439,7 @@ var PLACEHOLDERS = [
   "<bug-name>"
 ];
 var PLAN_TIMESTAMP_TEMPLATE_NAME = "plan.yyyy-MM-ddTHH-mm.md";
-function joinPosix11(root, relative2) {
+function joinPosix13(root, relative2) {
   const normalizedRoot = toPosixPath2(root).replace(/\/+$/, "");
   const normalizedRelative = toPosixPath2(relative2).replace(/^\/+/, "");
   if (normalizedRoot === "") {
@@ -25876,14 +26499,14 @@ var RealFolderFileSystem = class {
         return;
       }
       for (const entry of entries) {
-        const childAbs = joinPosix11(toPosixPath2(currentDir), entry.name);
+        const childAbs = joinPosix13(toPosixPath2(currentDir), entry.name);
         if (entry.isDirectory()) {
           walk(childAbs);
           continue;
         }
         if (entry.isFile()) {
           const relative2 = childAbs.slice(normalizedSrc.length + 1);
-          this.copyFile(childAbs, joinPosix11(toPosixPath2(dest), relative2));
+          this.copyFile(childAbs, joinPosix13(toPosixPath2(dest), relative2));
         }
       }
     };
@@ -25904,7 +26527,7 @@ var RealFolderFileSystem = class {
     const files = [];
     for (const entry of entries) {
       if (entry.isFile()) {
-        files.push(joinPosix11(toPosixPath2(path10), entry.name));
+        files.push(joinPosix13(toPosixPath2(path10), entry.name));
       }
     }
     return files;
@@ -26289,8 +26912,8 @@ function stem(path10) {
 function findPotentialFile(featureName, workspace2, fs9) {
   const normalized = featureName.replace(/_/g, "-");
   const potentialDirs = [
-    joinPosix11(workspace2, "docs/features/potential"),
-    joinPosix11(workspace2, "docs/features/potential/promoted")
+    joinPosix13(workspace2, "docs/features/potential"),
+    joinPosix13(workspace2, "docs/features/potential/promoted")
   ];
   for (const directory of potentialDirs) {
     const candidates = fs9.listFiles(directory).filter(
@@ -26327,9 +26950,9 @@ function buildFolderSlug(featureName, potentialFile, issueNumber) {
 function copyTemplate(featureType, templateDir, targetDir, fs9) {
   if (featureType === "bug") {
     for (const name of ["spec.md", PLAN_TIMESTAMP_TEMPLATE_NAME, "plan.md"]) {
-      const src = joinPosix11(templateDir, name);
+      const src = joinPosix13(templateDir, name);
       if (fs9.exists(src)) {
-        fs9.copyFile(src, joinPosix11(targetDir, name));
+        fs9.copyFile(src, joinPosix13(targetDir, name));
         if (name === PLAN_TIMESTAMP_TEMPLATE_NAME) {
           break;
         }
@@ -26340,24 +26963,24 @@ function copyTemplate(featureType, templateDir, targetDir, fs9) {
   }
 }
 function copyFeatureTemplateForMinorAudit(templateDir, targetDir, fs9) {
-  const timestampedPlan = joinPosix11(templateDir, PLAN_TIMESTAMP_TEMPLATE_NAME);
+  const timestampedPlan = joinPosix13(templateDir, PLAN_TIMESTAMP_TEMPLATE_NAME);
   if (fs9.exists(timestampedPlan)) {
     fs9.copyFile(
       timestampedPlan,
-      joinPosix11(targetDir, PLAN_TIMESTAMP_TEMPLATE_NAME)
+      joinPosix13(targetDir, PLAN_TIMESTAMP_TEMPLATE_NAME)
     );
     return;
   }
-  const legacyPlan = joinPosix11(templateDir, "plan.md");
+  const legacyPlan = joinPosix13(templateDir, "plan.md");
   if (fs9.exists(legacyPlan)) {
-    fs9.copyFile(legacyPlan, joinPosix11(targetDir, "plan.md"));
+    fs9.copyFile(legacyPlan, joinPosix13(targetDir, "plan.md"));
   }
 }
 function materializePlanFile(featureType, targetDir, featureName, issueField, ownerField, parentField, statusField, versionField, planTimestamp, fs9) {
   void featureType;
-  const templatePlan = joinPosix11(targetDir, PLAN_TIMESTAMP_TEMPLATE_NAME);
+  const templatePlan = joinPosix13(targetDir, PLAN_TIMESTAMP_TEMPLATE_NAME);
   if (fs9.exists(templatePlan)) {
-    const targetPlan = joinPosix11(targetDir, `plan.${planTimestamp}.md`);
+    const targetPlan = joinPosix13(targetDir, `plan.${planTimestamp}.md`);
     fs9.move(templatePlan, targetPlan);
     let content = fs9.readText(targetPlan);
     const updatedField = planTimestamp;
@@ -26374,7 +26997,7 @@ function materializePlanFile(featureType, targetDir, featureName, issueField, ow
     fs9.writeText(targetPlan, content);
     return targetPlan;
   }
-  const legacy = joinPosix11(targetDir, "plan.md");
+  const legacy = joinPosix13(targetDir, "plan.md");
   if (fs9.exists(legacy)) {
     return legacy;
   }
@@ -26444,9 +27067,9 @@ function updateFeatureDocs(featureType, featureName, targetDir, issueField, owne
   const filesToOpen = [];
   const get = (key) => sections[key] ?? "";
   if (featureType === "feature") {
-    const userStory = joinPosix11(targetDir, "user-story.md");
-    const spec = joinPosix11(targetDir, "spec.md");
-    const plan = planPath ?? joinPosix11(targetDir, "plan.md");
+    const userStory = joinPosix13(targetDir, "user-story.md");
+    const spec = joinPosix13(targetDir, "spec.md");
+    const plan = planPath ?? joinPosix13(targetDir, "plan.md");
     applyHeaderAndSections(
       userStory,
       featureName,
@@ -26496,8 +27119,8 @@ function updateFeatureDocs(featureType, featureName, targetDir, issueField, owne
     );
     filesToOpen.push(userStory, spec, plan);
   } else if (featureType === "refactor") {
-    const spec = joinPosix11(targetDir, "spec.md");
-    const plan = planPath ?? joinPosix11(targetDir, "plan.md");
+    const spec = joinPosix13(targetDir, "spec.md");
+    const plan = planPath ?? joinPosix13(targetDir, "plan.md");
     applyHeaderAndSections(
       spec,
       featureName,
@@ -26532,7 +27155,7 @@ function updateFeatureDocs(featureType, featureName, targetDir, issueField, owne
     );
     filesToOpen.push(spec, plan);
   } else if (featureType === "epic") {
-    const initiative = joinPosix11(targetDir, "initiative.md");
+    const initiative = joinPosix13(targetDir, "initiative.md");
     applyHeaderAndSections(
       initiative,
       featureName,
@@ -26547,8 +27170,8 @@ function updateFeatureDocs(featureType, featureName, targetDir, issueField, owne
     );
     filesToOpen.push(initiative);
   } else if (featureType === "bug") {
-    const spec = joinPosix11(targetDir, "spec.md");
-    const plan = planPath ?? joinPosix11(targetDir, "plan.md");
+    const spec = joinPosix13(targetDir, "spec.md");
+    const plan = planPath ?? joinPosix13(targetDir, "plan.md");
     const contextParts = [];
     if (get("bug_summary")) {
       contextParts.push(get("bug_summary"));
@@ -26669,9 +27292,9 @@ function createActiveFolder(options) {
     const autoResolveError = "Select a promoted issue markdown file under docs/features/potential/promoted or supply --feature-name directly.";
     let activeFilePath = toPosixPath2(options.activeFileForFeatureName);
     if (!isAbsolutePosix(activeFilePath)) {
-      activeFilePath = joinPosix11(workspacePath, activeFilePath);
+      activeFilePath = joinPosix13(workspacePath, activeFilePath);
     }
-    const promotedRoot = joinPosix11(
+    const promotedRoot = joinPosix13(
       workspacePath,
       "docs/features/potential/promoted"
     );
@@ -26689,7 +27312,7 @@ function createActiveFolder(options) {
   }
   validateFeatureName2(resolvedFeatureName);
   emit(`Feature name source: ${featureNameSource}`);
-  const templateDir = options.templateRoot !== void 0 && options.templateRoot !== null ? joinPosix11(options.templateRoot, featureType) : joinPosix11(workspacePath, `docs/features/templates/${featureType}`);
+  const templateDir = options.templateRoot !== void 0 && options.templateRoot !== null ? joinPosix13(options.templateRoot, featureType) : joinPosix13(workspacePath, `docs/features/templates/${featureType}`);
   if (!filesystem.exists(templateDir)) {
     throw new Error(`Template folder not found: ${templateDir}`);
   }
@@ -26717,7 +27340,7 @@ function createActiveFolder(options) {
     potentialFile,
     normalizedIssueNumber
   );
-  const targetDir = joinPosix11(
+  const targetDir = joinPosix13(
     workspacePath,
     `docs/features/active/${folderSlug}`
   );
@@ -26782,7 +27405,7 @@ function createActiveFolder(options) {
   let potentialIssuePath = null;
   if (useMinorAudit) {
     if (potentialFile) {
-      potentialIssuePath = joinPosix11(targetDir, "issue.md");
+      potentialIssuePath = joinPosix13(targetDir, "issue.md");
       filesystem.move(potentialFile, potentialIssuePath);
       const movedContent = filesystem.readText(potentialIssuePath);
       filesystem.writeText(
@@ -26791,7 +27414,7 @@ function createActiveFolder(options) {
       );
       filesToOpen = [potentialIssuePath];
     } else {
-      const issueDoc = joinPosix11(targetDir, "issue.md");
+      const issueDoc = joinPosix13(targetDir, "issue.md");
       const issueBody = [
         `# ${resolvedFeatureName}`,
         "",
@@ -26842,7 +27465,7 @@ function createActiveFolder(options) {
         emit(`Moved potential file to ${potentialIssuePath}`);
       }
     } else {
-      potentialIssuePath = joinPosix11(targetDir, "issue.md");
+      potentialIssuePath = joinPosix13(targetDir, "issue.md");
       filesystem.move(potentialFile, potentialIssuePath);
       const movedContent = filesystem.readText(potentialIssuePath);
       filesystem.writeText(
@@ -26989,10 +27612,7 @@ var DefaultRepoAutomationService = class {
     );
   }
   async pushDownCodexAndAgentsCustomizations(input) {
-    return runPushDownCodexAndAgentsCustomizations(
-      input.workspaceRoot,
-      this.pushDownDeps
-    );
+    return runPushDownCodexAndAgentsCustomizations(input, this.pushDownDeps);
   }
   async pushDownClaudeCustomizations(input) {
     return runPushDownClaudeCustomizations(input, this.pushDownDeps);