@danmoisan/drm-copilot-mcp 1.0.16 → 1.0.18

package/out/mcp-server.js

@@ -3771,6 +3771,7 @@ var require_fast_uri = __commonJS({
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
+    var AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
     function getParseError(parsed, matches) {
       if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
         return 'URI path must start with "/" when authority is present.';
@@ -3800,6 +3801,11 @@ var require_fast_uri = __commonJS({
           uri = "//" + uri;
         }
       }
+      const authorityMatch = uri.match(AUTHORITY_PREFIX);
+      if (authorityMatch !== null && authorityMatch[1].indexOf("\\") !== -1) {
+        parsed.error = "URI authority must not contain a literal backslash.";
+        malformedAuthorityOrPort = true;
+      }
       const matches = uri.match(URI_PARSE);
       if (matches) {
         parsed.scheme = matches[1];
@@ -3843,7 +3849,7 @@ var require_fast_uri = __commonJS({
         if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
           if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
             try {
-              parsed.host = URL.domainToASCII(parsed.host.toLowerCase());
+              parsed.host = new URL("http://" + parsed.host).hostname;
             } catch (e) {
               parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
             }
@@ -15500,8 +15506,43 @@ function findExecutableOnPath(executable) {
   }
   return void 0;
 }
-function detectRuntime(runtimeKind) {
-  void runtimeKind;
+function buildVenvInterpreterCandidate(workspaceRoot) {
+  const normalizedRoot = workspaceRoot.replace(/\\/g, "/").replace(/\/+$/, "");
+  const relativeInterpreter = process.platform === "win32" ? ".venv/Scripts/python.exe" : ".venv/bin/python";
+  return `${normalizedRoot}/${relativeInterpreter}`;
+}
+function detectPythonRuntime(workspaceRoot) {
+  if (workspaceRoot !== void 0 && workspaceRoot.trim().length > 0) {
+    const venvInterpreter = buildVenvInterpreterCandidate(workspaceRoot);
+    if (fs.existsSync(venvInterpreter)) {
+      return {
+        executable: venvInterpreter,
+        argsPrefix: []
+      };
+    }
+  }
+  const resolvedPy = findExecutableOnPath("py");
+  if (resolvedPy !== void 0) {
+    return {
+      executable: resolvedPy,
+      argsPrefix: []
+    };
+  }
+  const resolvedPython = findExecutableOnPath("python");
+  if (resolvedPython !== void 0) {
+    return {
+      executable: resolvedPython,
+      argsPrefix: []
+    };
+  }
+  throw new Error(
+    "Python runtime not found. Expected a workspace '.venv' interpreter or 'py' or 'python' on PATH."
+  );
+}
+function detectRuntime(runtimeKind, workspaceRoot) {
+  if (runtimeKind === "python") {
+    return detectPythonRuntime(workspaceRoot);
+  }
   if (executableExists("pwsh")) {
     return {
       executable: "pwsh",
@@ -15687,7 +15728,7 @@ function getStderrExcerpt(error2) {
 // ../../extensions/drm-copilot/src/mcp-push-down-schema-properties.ts
 var workspaceRootProperty = {
   type: "string",
-  description: "Target workspace root. Defaults to process.cwd() when omitted."
+  description: "Required absolute path to the root of the target checkout or worktree. The MCP server cannot infer the calling agent's checkout, so this value must be supplied explicitly."
 };
 var codexPacksProperty = {
   type: "array",
@@ -15827,8 +15868,13 @@ function validateRequiredIssueNumber(issueNumber, fieldName) {
   }
   return normalizedIssueNumber;
 }
-function normalizeWorkspaceRoot(value, fallbackWorkspaceRoot = process.cwd()) {
+function normalizeWorkspaceRoot(value, fallbackWorkspaceRoot) {
   if (value === void 0) {
+    if (fallbackWorkspaceRoot === void 0) {
+      throw new Error(
+        "workspace_root is required. The MCP server cannot infer the calling agent's checkout; pass the absolute worktree root explicitly."
+      );
+    }
     return fallbackWorkspaceRoot;
   }
   return normalizeRequiredText(value, "workspace_root");
@@ -15842,458 +15888,6 @@ function normalizeWorkspaceDestinationPath(value, workspaceRoot, fieldName) {
   return resolvedPath.replace(/\\/g, "/");
 }
 
-// ../../extensions/drm-copilot/src/mcp-repo-automation-tool-definitions.ts
-var REPO_AUTOMATION_TOOL_DEFINITIONS = [
-  {
-    name: "collect_commit_context",
-    description: "Collect commit context artifacts from the target workspace using bundled extension resources.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty
-      },
-      additionalProperties: false
-    }
-  },
-  {
-    name: "collect_pr_context",
-    description: "Collect PR context artifacts for an explicit base branch using bundled extension resources.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty,
-        base: {
-          type: "string",
-          description: "Explicit base branch or ref used for PR context collection."
-        }
-      },
-      required: ["base"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "run_codex_native_converter",
-    description: "Run the bundled Codex-native converter in review or apply mode using the extension resources.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty,
-        mode: {
-          type: "string",
-          description: "Converter mode to execute."
-        },
-        source_ecosystem: {
-          type: "string",
-          description: "Supported source ecosystem for the conversion run."
-        },
-        source_root: {
-          type: "string",
-          description: "Workspace-relative or absolute source runtime root."
-        },
-        selected_paths: {
-          type: "array",
-          description: "Optional workspace-relative or absolute source paths beneath source_root.",
-          items: {
-            type: "string"
-          }
-        },
-        destination_root: {
-          type: "string",
-          description: "Workspace-relative or absolute destination root required for apply mode."
-        },
-        artifact_root: {
-          type: "string",
-          description: "Optional workspace-relative or absolute artifact output root."
-        },
-        enable_repo_prompts: {
-          type: "boolean",
-          description: "When true, allow repository-convention .codex/prompts outputs."
-        }
-      },
-      required: ["mode", "source_ecosystem", "source_root"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "push_down_copilot_customizations",
-    description: "Copy the bundled Copilot customization payload into the target workspace.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty,
-        ...copilotPushDownSelectionProperties
-      },
-      additionalProperties: false
-    }
-  },
-  {
-    name: "push_down_codex_and_agents_customizations",
-    description: "Copy the bundled Codex and agents customization payload into the target workspace.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty,
-        ...codexPushDownSelectionProperties
-      },
-      additionalProperties: false
-    }
-  },
-  {
-    name: "push_down_claude_customizations",
-    description: "Copy the bundled Claude Code customization payload into the target workspace.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty,
-        ...claudePushDownSelectionProperties
-      },
-      additionalProperties: false
-    }
-  },
-  {
-    name: "new_potential_bug_entry",
-    description: "Create a new potential bug entry in the target workspace from bundled templates.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty,
-        short_name: {
-          type: "string",
-          description: "Kebab-case short name for the potential bug entry."
-        }
-      },
-      required: ["short_name"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "new_potential_entry",
-    description: "Create a new potential entry in the target workspace from bundled templates.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty,
-        short_name: {
-          type: "string",
-          description: "Kebab-case short name for the potential entry."
-        }
-      },
-      required: ["short_name"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "link_parent_child",
-    description: "Link a child GitHub issue to a parent GitHub issue in the target workspace using the bundled PowerShell workflow.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty,
-        parent_issue_number: {
-          type: "string",
-          description: "Numeric issue number of the parent issue."
-        },
-        child_issue_number: {
-          type: "string",
-          description: "Numeric issue number of the child issue."
-        }
-      },
-      required: ["parent_issue_number", "child_issue_number"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "potential_to_issue",
-    description: "Promote a potential entry into an issue-oriented feature workflow in the target workspace.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty,
-        potential_path: {
-          type: "string",
-          description: "Absolute or workspace-relative path to the potential Markdown file."
-        },
-        promotion_type: {
-          type: "string",
-          enum: ["epic", "feature", "refactor", "bug"],
-          description: "Promotion type to generate."
-        },
-        work_mode: {
-          type: "string",
-          enum: ["minor-audit", "full-feature", "full-bug", "full"],
-          description: "Work mode marker applied to the resulting issue workflow."
-        }
-      },
-      required: ["potential_path", "promotion_type", "work_mode"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "new_active_feature_folder",
-    description: "Create a new active feature folder in the target workspace from bundled templates.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty,
-        feature_name: {
-          type: "string",
-          description: "Feature folder name using kebab-case or underscore-case letters and numbers."
-        },
-        type: {
-          type: "string",
-          enum: ["epic", "feature", "refactor", "bug"],
-          description: "Feature folder type to create."
-        },
-        issue_number: {
-          type: "string",
-          description: "Optional numeric issue number associated with the feature folder."
-        },
-        work_mode: {
-          type: "string",
-          enum: ["minor-audit", "full-feature", "full-bug", "full"],
-          description: "Work mode marker applied to the feature folder."
-        }
-      },
-      required: ["feature_name", "type", "work_mode"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "run_poshqc_format",
-    description: "Run bundled PoshQC formatting against the target workspace using bundled extension resources.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty,
-        scan_folders: {
-          type: "array",
-          items: {
-            type: "string"
-          },
-          description: "Optional workspace-relative or workspace-contained folders to scan."
-        }
-      },
-      additionalProperties: false
-    }
-  },
-  {
-    name: "run_poshqc_analyze",
-    description: "Run bundled PoshQC analysis against the target workspace using bundled extension resources.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty,
-        scan_folders: {
-          type: "array",
-          items: {
-            type: "string"
-          },
-          description: "Optional workspace-relative or workspace-contained folders to scan."
-        }
-      },
-      additionalProperties: false
-    }
-  },
-  {
-    name: "run_poshqc_test",
-    description: "Run bundled PoshQC Pester checks against the target workspace using bundled extension resources. When scan_folders is omitted, the scan set is resolved from config/poshqc-scan.json (test.scanFolders); an explicit scan_folders argument overrides the configuration.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty,
-        scan_folders: {
-          type: "array",
-          items: {
-            type: "string"
-          },
-          description: "Optional workspace-relative or workspace-contained folders to scan."
-        }
-      },
-      additionalProperties: false
-    }
-  },
-  {
-    name: "run_poshqc_analyze_autofix",
-    description: "Apply bundled PoshQC analyzer autofixes, then rerun analysis against the target workspace using bundled extension resources.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty,
-        scan_folders: {
-          type: "array",
-          items: {
-            type: "string"
-          },
-          description: "Optional workspace-relative or workspace-contained folders to scan."
-        }
-      },
-      additionalProperties: false
-    }
-  },
-  {
-    name: "run_poshqc_suite",
-    description: "Run the bundled PoshQC suite against the target workspace using bundled extension resources.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty,
-        scan_folders: {
-          type: "array",
-          items: {
-            type: "string"
-          },
-          description: "Optional workspace-relative or workspace-contained folders to scan."
-        }
-      },
-      additionalProperties: false
-    }
-  },
-  {
-    name: "resolve_policy_audit_template_asset",
-    description: "Resolve a bundled policy-audit template asset from the published extension package, optionally copying it into the target workspace.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty,
-        asset: {
-          type: "string",
-          enum: [...POLICY_AUDIT_TEMPLATE_ASSET_SELECTORS],
-          description: "Bundled policy-audit asset selector: 'template' for policy-audit.yyyy-MM-ddTHH-mm.md, 'code-review-template' for code-review.yyyy-MM-ddTHH-mm.md, 'feature-audit-template' for feature-audit.yyyy-MM-ddTHH-mm.md, or 'agents' for AGENTS.md."
-        },
-        target_path: {
-          type: "string",
-          description: "Optional workspace-relative or absolute destination path for a copied asset."
-        }
-      },
-      required: ["asset"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "resolve_execute_hard_lock_prompt",
-    description: "Resolve the execute hard-lock prompt for a target plan path using bundled extension resources.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty,
-        target: {
-          type: "string",
-          description: "Target Markdown plan path to resolve."
-        }
-      },
-      required: ["target"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "resolve_atomic_plan_prompt",
-    description: "Resolve the atomic-plan prompt for a target plan path using bundled extension resources.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty,
-        target: {
-          type: "string",
-          description: "Target Markdown plan path to resolve."
-        }
-      },
-      required: ["target"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "validate_orchestration_artifacts",
-    description: "Validate an orchestration artifact, including epic planner, kickoff, and execution checkpoints, against its structural schema.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty,
-        artifact_type: {
-          type: "string",
-          enum: [
-            "plan",
-            "policy-audit",
-            "code-review",
-            "feature-audit",
-            "orchestrator-state",
-            "epic-orchestrator-state",
-            "epic-planner-state",
-            "epic-kickoff"
-          ],
-          description: "The type of orchestration artifact to validate."
-        },
-        artifact_path: {
-          type: "string",
-          description: "Workspace-relative or absolute path to the artifact file."
-        },
-        require_complete: {
-          type: "boolean",
-          description: "When true and artifact_type is 'orchestrator-state' or 'epic-orchestrator-state', require all phases to be complete."
-        },
-        require_model_routing: {
-          type: "boolean",
-          description: "When true and artifact_type is 'orchestrator-state', require a model_routing_receipts entry per delegated agent once a delegation is recorded. The TypeScript side performs the existence check only; the Python validator is authoritative for full per-receipt correctness."
-        },
-        require_codex_model_routing: {
-          type: "boolean",
-          description: "When true for an orchestrator checkpoint, require canonical Codex deployment receipts for delegated agents."
-        },
-        require_codex_topology: {
-          type: "boolean",
-          description: "When true for an orchestrator checkpoint, require canonical Codex topology receipts for delegated agents and epic roots."
-        },
-        require_ready_for_execution: {
-          type: "boolean",
-          description: "When true and artifact_type is 'epic-planner-state', require every child to be prepared and preflight-cleared."
-        }
-      },
-      required: ["artifact_type", "artifact_path"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "render_subagent_tree",
-    description: "Render the subagent call tree for a root session id. The session id is a transcript filename stem; the transcript is resolved under the user-global Claude projects directory, searching the encoded workspace directory plus its '-wt-' worktree siblings (case-insensitive) and returning the first match deterministically.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        workspace_root: workspaceRootProperty,
-        session_id: {
-          type: "string",
-          description: "Root session identifier (transcript filename stem under ~/.claude/projects/<encoded-workspace>/, e.g. a UUIDv4)."
-        }
-      },
-      required: ["session_id"],
-      additionalProperties: false
-    }
-  }
-];
-
-// ../../extensions/drm-copilot/src/repo-automation-tool-names.ts
-var REPO_AUTOMATION_TOOLS = [
-  "collect_commit_context",
-  "collect_pr_context",
-  "run_codex_native_converter",
-  "push_down_copilot_customizations",
-  "push_down_codex_and_agents_customizations",
-  "push_down_claude_customizations",
-  "new_potential_bug_entry",
-  "new_potential_entry",
-  "link_parent_child",
-  "potential_to_issue",
-  "new_active_feature_folder",
-  "run_poshqc_format",
-  "run_poshqc_analyze",
-  "run_poshqc_test",
-  "run_poshqc_analyze_autofix",
-  "run_poshqc_suite",
-  "resolve_policy_audit_template_asset",
-  "resolve_execute_hard_lock_prompt",
-  "resolve_atomic_plan_prompt",
-  "validate_orchestration_artifacts",
-  "render_subagent_tree"
-];
-
 // ../../extensions/drm-copilot/src/mcp-tool-inputs-push-down.ts
 function resolvePacksField(rawValue) {
   if (rawValue === void 0) {
@@ -16359,6 +15953,32 @@ function resolvePushDownCodexAndAgentsCustomizationsToolInput(rawInput, fallback
   };
 }
 
+// ../../extensions/drm-copilot/src/mcp-tool-inputs-potential-to-issue.ts
+function resolvePotentialToIssueToolInput(rawInput, fallbackWorkspaceRoot) {
+  const args = asToolArgumentObject(rawInput);
+  const workspaceRoot = normalizeWorkspaceRoot(
+    args["workspace_root"],
+    fallbackWorkspaceRoot
+  );
+  const potentialPath = normalizeWorkspaceDestinationPath(
+    normalizeRequiredText(args["potential_path"], "potential_path"),
+    workspaceRoot,
+    "potential_path"
+  );
+  return {
+    workspaceRoot,
+    potentialPath,
+    promotionType: validatePromotionType(
+      normalizeRequiredText(args["promotion_type"], "promotion_type"),
+      "promotion_type"
+    ),
+    workMode: validateWorkMode(
+      normalizeRequiredText(args["work_mode"], "work_mode"),
+      "work_mode"
+    )
+  };
+}
+
 // ../../extensions/drm-copilot/src/mcp-tool-inputs.ts
 function asToolArgumentObject(rawInput) {
   if (rawInput === void 0) {
@@ -16529,24 +16149,6 @@ function resolveLinkParentChildToolInput(rawInput, fallbackWorkspaceRoot) {
     )
   };
 }
-function resolvePotentialToIssueToolInput(rawInput, fallbackWorkspaceRoot) {
-  const args = asToolArgumentObject(rawInput);
-  return {
-    workspaceRoot: normalizeWorkspaceRoot(
-      args["workspace_root"],
-      fallbackWorkspaceRoot
-    ),
-    potentialPath: normalizeRequiredText(
-      args["potential_path"],
-      "potential_path"
-    ),
-    promotionType: resolvePromotionTypeField(
-      args["promotion_type"],
-      "promotion_type"
-    ),
-    workMode: resolveWorkModeField(args["work_mode"], "work_mode")
-  };
-}
 function resolveNewActiveFeatureFolderToolInput(rawInput, fallbackWorkspaceRoot) {
   const args = asToolArgumentObject(rawInput);
   const issueNumber = validateIssueNumber(
@@ -16606,72 +16208,868 @@ function resolvePolicyAuditTemplateAssetToolInput(rawInput, fallbackWorkspaceRoo
         "target_path"
       )
     }
-  };
-}
-function resolveRunPoshQCSuiteToolInput(rawInput, fallbackWorkspaceRoot) {
-  const args = asToolArgumentObject(rawInput);
-  const scanFolders = args["scan_folders"];
-  if (scanFolders === void 0) {
-    return {
-      workspaceRoot: normalizeWorkspaceRoot(
-        args["workspace_root"],
-        fallbackWorkspaceRoot
-      )
-    };
-  }
-  if (!Array.isArray(scanFolders)) {
-    throw new Error("Field 'scan_folders' must be an array when provided.");
-  }
-  return {
-    workspaceRoot: normalizeWorkspaceRoot(
-      args["workspace_root"],
-      fallbackWorkspaceRoot
-    ),
-    scanFolders: scanFolders.map(
-      (folder, index) => normalizeRequiredText(folder, `scan_folders[${index}]`)
-    )
-  };
-}
-var VALID_ARTIFACT_TYPES = /* @__PURE__ */ new Set([
-  "plan",
-  "policy-audit",
-  "code-review",
-  "feature-audit",
-  "orchestrator-state",
-  "epic-orchestrator-state",
-  "epic-planner-state",
-  "epic-kickoff"
-]);
-function resolveValidateOrchestrationArtifactsToolInput(rawInput, fallbackWorkspaceRoot) {
-  const args = asToolArgumentObject(rawInput);
-  const artifactType = normalizeRequiredText(
-    args["artifact_type"],
-    "artifact_type"
-  );
-  if (!VALID_ARTIFACT_TYPES.has(artifactType)) {
-    throw new Error(
-      `Field 'artifact_type' must be one of: ${[...VALID_ARTIFACT_TYPES].join(", ")}. Got '${artifactType}'.`
-    );
-  }
-  const requireComplete = args["require_complete"];
-  const requireModelRouting = args["require_model_routing"];
-  const requireCodexModelRouting = args["require_codex_model_routing"];
-  const requireCodexTopology = args["require_codex_topology"];
-  const requireReadyForExecution = args["require_ready_for_execution"];
-  return {
-    workspaceRoot: normalizeWorkspaceRoot(
-      args["workspace_root"],
-      fallbackWorkspaceRoot
-    ),
-    artifactType,
-    artifactPath: normalizeRequiredText(args["artifact_path"], "artifact_path"),
-    ...requireComplete === true ? { requireComplete: true } : {},
-    ...requireModelRouting === true ? { requireModelRouting: true } : {},
-    ...requireCodexModelRouting === true ? { requireCodexModelRouting: true } : {},
-    ...requireCodexTopology === true ? { requireCodexTopology: true } : {},
-    ...requireReadyForExecution === true ? { requireReadyForExecution: true } : {}
-  };
-}
+  };
+}
+function resolveRunPoshQCSuiteToolInput(rawInput, fallbackWorkspaceRoot) {
+  const args = asToolArgumentObject(rawInput);
+  const scanFolders = args["scan_folders"];
+  if (scanFolders === void 0) {
+    return {
+      workspaceRoot: normalizeWorkspaceRoot(
+        args["workspace_root"],
+        fallbackWorkspaceRoot
+      )
+    };
+  }
+  if (!Array.isArray(scanFolders)) {
+    throw new Error("Field 'scan_folders' must be an array when provided.");
+  }
+  return {
+    workspaceRoot: normalizeWorkspaceRoot(
+      args["workspace_root"],
+      fallbackWorkspaceRoot
+    ),
+    scanFolders: scanFolders.map(
+      (folder, index) => normalizeRequiredText(folder, `scan_folders[${index}]`)
+    )
+  };
+}
+var VALID_ARTIFACT_TYPES = /* @__PURE__ */ new Set([
+  "plan",
+  "policy-audit",
+  "code-review",
+  "feature-audit",
+  "orchestrator-state",
+  "epic-orchestrator-state",
+  "epic-planner-state",
+  "epic-kickoff"
+]);
+function resolveValidateOrchestrationArtifactsToolInput(rawInput, fallbackWorkspaceRoot) {
+  const args = asToolArgumentObject(rawInput);
+  const artifactType = normalizeRequiredText(
+    args["artifact_type"],
+    "artifact_type"
+  );
+  if (!VALID_ARTIFACT_TYPES.has(artifactType)) {
+    throw new Error(
+      `Field 'artifact_type' must be one of: ${[...VALID_ARTIFACT_TYPES].join(", ")}. Got '${artifactType}'.`
+    );
+  }
+  const requireComplete = args["require_complete"];
+  const requireModelRouting = args["require_model_routing"];
+  const requireCodexModelRouting = args["require_codex_model_routing"];
+  const requireCodexTopology = args["require_codex_topology"];
+  const requireReadyForExecution = args["require_ready_for_execution"];
+  return {
+    workspaceRoot: normalizeWorkspaceRoot(
+      args["workspace_root"],
+      fallbackWorkspaceRoot
+    ),
+    artifactType,
+    artifactPath: normalizeRequiredText(args["artifact_path"], "artifact_path"),
+    ...requireComplete === true ? { requireComplete: true } : {},
+    ...requireModelRouting === true ? { requireModelRouting: true } : {},
+    ...requireCodexModelRouting === true ? { requireCodexModelRouting: true } : {},
+    ...requireCodexTopology === true ? { requireCodexTopology: true } : {},
+    ...requireReadyForExecution === true ? { requireReadyForExecution: true } : {}
+  };
+}
+
+// ../../extensions/drm-copilot/src/mcp-tool-inputs-discovery.ts
+var DISCOVERY_ARTIFACT_TYPES = [
+  "profile",
+  "feature-contract",
+  "coverage-ledger",
+  "runtime-scenario",
+  "parity-matrix",
+  "unspecified-behavior",
+  "product-decision",
+  "evidence-reference",
+  "all"
+];
+var DISCOVERY_REPORT_TYPES = [
+  "coverage",
+  "parity",
+  "completion"
+];
+function normalizeOptionalBoolean(value, fieldName) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "boolean") {
+    throw new Error(`Field '${fieldName}' must be a boolean when provided.`);
+  }
+  return value;
+}
+function resolveValidateDiscoveryArtifactsToolInput(rawInput, fallbackWorkspaceRoot) {
+  const args = asToolArgumentObject(rawInput);
+  const artifactType = validateChoice(
+    normalizeRequiredText(args["artifact_type"], "artifact_type"),
+    "artifact_type",
+    DISCOVERY_ARTIFACT_TYPES
+  );
+  return {
+    workspaceRoot: normalizeWorkspaceRoot(
+      args["workspace_root"],
+      fallbackWorkspaceRoot
+    ),
+    artifactType,
+    artifactPath: normalizeRequiredText(args["artifact_path"], "artifact_path")
+  };
+}
+function resolveRunDiscoveryInitToolInput(rawInput, fallbackWorkspaceRoot) {
+  const args = asToolArgumentObject(rawInput);
+  const templateRoot = normalizeOptionalText(
+    args["template_root"],
+    "template_root"
+  );
+  const force = normalizeOptionalBoolean(args["force"], "force");
+  return {
+    workspaceRoot: normalizeWorkspaceRoot(
+      args["workspace_root"],
+      fallbackWorkspaceRoot
+    ),
+    targetDir: normalizeRequiredText(args["target_dir"], "target_dir"),
+    ...templateRoot === void 0 ? {} : { templateRoot },
+    ...force === void 0 ? {} : { force }
+  };
+}
+function resolveDiscoveryAnalyzerToolInput(rawInput, fallbackWorkspaceRoot) {
+  const args = asToolArgumentObject(rawInput);
+  const profilePath = normalizeOptionalText(
+    args["profile_path"],
+    "profile_path"
+  );
+  const outputDir = normalizeOptionalText(args["output_dir"], "output_dir");
+  return {
+    workspaceRoot: normalizeWorkspaceRoot(
+      args["workspace_root"],
+      fallbackWorkspaceRoot
+    ),
+    ...profilePath === void 0 ? {} : { profilePath },
+    ...outputDir === void 0 ? {} : { outputDir }
+  };
+}
+function resolveRunDiscoveryRepoInventoryToolInput(rawInput, fallbackWorkspaceRoot) {
+  return resolveDiscoveryAnalyzerToolInput(rawInput, fallbackWorkspaceRoot);
+}
+function resolveRunDiscoveryDotnetAnalyzerToolInput(rawInput, fallbackWorkspaceRoot) {
+  return resolveDiscoveryAnalyzerToolInput(rawInput, fallbackWorkspaceRoot);
+}
+function resolveRunDiscoveryVstoAnalyzerToolInput(rawInput, fallbackWorkspaceRoot) {
+  return resolveDiscoveryAnalyzerToolInput(rawInput, fallbackWorkspaceRoot);
+}
+function resolveRunDiscoveryScenarioGenerationToolInput(rawInput, fallbackWorkspaceRoot) {
+  const args = asToolArgumentObject(rawInput);
+  const outputPath = normalizeOptionalText(args["output_path"], "output_path");
+  const check = normalizeOptionalBoolean(args["check"], "check");
+  return {
+    workspaceRoot: normalizeWorkspaceRoot(
+      args["workspace_root"],
+      fallbackWorkspaceRoot
+    ),
+    featureContract: normalizeRequiredText(
+      args["feature_contract"],
+      "feature_contract"
+    ),
+    parityMatrix: normalizeRequiredText(args["parity_matrix"], "parity_matrix"),
+    runtimeCharacterization: normalizeRequiredText(
+      args["runtime_characterization"],
+      "runtime_characterization"
+    ),
+    ...outputPath === void 0 ? {} : { outputPath },
+    ...check === void 0 ? {} : { check }
+  };
+}
+function resolveRunDiscoveryReportToolInput(rawInput, fallbackWorkspaceRoot) {
+  const args = asToolArgumentObject(rawInput);
+  const reportType = validateChoice(
+    normalizeRequiredText(args["report_type"], "report_type"),
+    "report_type",
+    DISCOVERY_REPORT_TYPES
+  );
+  const outputPath = normalizeOptionalText(args["output_path"], "output_path");
+  const workspaceRoot = normalizeWorkspaceRoot(
+    args["workspace_root"],
+    fallbackWorkspaceRoot
+  );
+  if (reportType === "completion") {
+    return {
+      workspaceRoot,
+      reportType,
+      coverageInput: normalizeRequiredText(
+        args["coverage_input"],
+        "coverage_input"
+      ),
+      parityInput: normalizeRequiredText(args["parity_input"], "parity_input"),
+      ...outputPath === void 0 ? {} : { outputPath }
+    };
+  }
+  return {
+    workspaceRoot,
+    reportType,
+    inputPath: normalizeRequiredText(args["input_path"], "input_path"),
+    ...outputPath === void 0 ? {} : { outputPath }
+  };
+}
+
+// ../../extensions/drm-copilot/src/mcp-discovery-tool-definitions.ts
+var DISCOVERY_TOOL_DEFINITIONS = [
+  {
+    name: "validate_discovery_artifacts",
+    description: "Validate a discovery artifact against its declared schema by invoking the workspace discovery CLI. The artifact_type selects the per-kind validator entry.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        artifact_type: {
+          type: "string",
+          enum: [...DISCOVERY_ARTIFACT_TYPES],
+          description: "Discovery artifact kind to validate; 'all' validates every kind under the supplied path."
+        },
+        artifact_path: {
+          type: "string",
+          description: "Workspace-relative or absolute path to the artifact (or directory for 'all')."
+        }
+      },
+      required: ["workspace_root", "artifact_type", "artifact_path"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "run_discovery_init",
+    description: "Scaffold a discovery workspace by invoking the workspace discovery init CLI at the target directory.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        target_dir: {
+          type: "string",
+          description: "Workspace-relative or absolute directory to scaffold the discovery workspace into."
+        },
+        template_root: {
+          type: "string",
+          description: "Optional template root overriding the CLI default."
+        },
+        force: {
+          type: "boolean",
+          description: "When true, overwrite existing scaffold files."
+        }
+      },
+      required: ["workspace_root", "target_dir"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "run_discovery_repo_inventory",
+    description: "Run the repository inventory analyzer via the workspace discovery CLI, returning the written artifact paths.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        profile_path: {
+          type: "string",
+          description: "Optional domain-profile path; the CLI default filename applies when omitted."
+        },
+        output_dir: {
+          type: "string",
+          description: "Optional output directory for the analysis artifacts."
+        }
+      },
+      required: ["workspace_root"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "run_discovery_dotnet_analyzer",
+    description: "Run the .NET stack analyzer via the workspace discovery CLI, returning the written artifact paths.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        profile_path: {
+          type: "string",
+          description: "Optional domain-profile path; the CLI default filename applies when omitted."
+        },
+        output_dir: {
+          type: "string",
+          description: "Optional output directory for the analysis artifacts."
+        }
+      },
+      required: ["workspace_root"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "run_discovery_vsto_analyzer",
+    description: "Run the VSTO stack analyzer via the workspace discovery CLI, returning the written artifact paths.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        profile_path: {
+          type: "string",
+          description: "Optional domain-profile path; the CLI default filename applies when omitted."
+        },
+        output_dir: {
+          type: "string",
+          description: "Optional output directory for the analysis artifacts."
+        }
+      },
+      required: ["workspace_root"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "run_discovery_scenario_generation",
+    description: "Generate acceptance scenarios via the workspace discovery CLI from a feature contract, parity matrix, and runtime characterization.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        feature_contract: {
+          type: "string",
+          description: "Workspace-relative or absolute feature-contract path."
+        },
+        parity_matrix: {
+          type: "string",
+          description: "Workspace-relative or absolute parity-matrix path."
+        },
+        runtime_characterization: {
+          type: "string",
+          description: "Workspace-relative or absolute runtime-characterization path."
+        },
+        output_path: {
+          type: "string",
+          description: "Optional output path; when supplied the written artifact path is returned."
+        },
+        check: {
+          type: "boolean",
+          description: "When true, run in check mode without writing generated scenarios."
+        }
+      },
+      required: [
+        "workspace_root",
+        "feature_contract",
+        "parity_matrix",
+        "runtime_characterization"
+      ],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "run_discovery_report",
+    description: "Generate a discovery report via the workspace discovery CLI. report_type selects the report: 'coverage' and 'parity' require input_path; 'completion' requires both coverage_input and parity_input. The per-report_type required inputs are enforced by the tool before any invocation.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        report_type: {
+          type: "string",
+          enum: [...DISCOVERY_REPORT_TYPES],
+          description: "Report kind: 'coverage'/'parity' (single input) or 'completion' (coverage + parity inputs)."
+        },
+        input_path: {
+          type: "string",
+          description: "Required for 'coverage'/'parity': the ledger or matrix input path."
+        },
+        coverage_input: {
+          type: "string",
+          description: "Required for 'completion': the coverage-ledger input path."
+        },
+        parity_input: {
+          type: "string",
+          description: "Required for 'completion': the parity-matrix input path."
+        },
+        output_path: {
+          type: "string",
+          description: "Optional output path for the generated report."
+        }
+      },
+      required: ["workspace_root", "report_type"],
+      additionalProperties: false
+    }
+  }
+];
+
+// ../../extensions/drm-copilot/src/mcp-repo-automation-tool-definitions-poshqc.ts
+var POSHQC_TOOL_DEFINITIONS = [
+  {
+    name: "run_poshqc_format",
+    description: "Run bundled PoshQC formatting against the target workspace using bundled extension resources.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        scan_folders: {
+          type: "array",
+          items: {
+            type: "string"
+          },
+          description: "Optional workspace-relative or workspace-contained folders to scan."
+        }
+      },
+      required: ["workspace_root"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "run_poshqc_analyze",
+    description: "Run bundled PoshQC analysis against the target workspace using bundled extension resources.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        scan_folders: {
+          type: "array",
+          items: {
+            type: "string"
+          },
+          description: "Optional workspace-relative or workspace-contained folders to scan."
+        }
+      },
+      required: ["workspace_root"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "run_poshqc_test",
+    description: "Run bundled PoshQC Pester checks against the target workspace using bundled extension resources. When scan_folders is omitted, the scan set is resolved from config/poshqc-scan.json (test.scanFolders); an explicit scan_folders argument overrides the configuration.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        scan_folders: {
+          type: "array",
+          items: {
+            type: "string"
+          },
+          description: "Optional workspace-relative or workspace-contained folders to scan."
+        }
+      },
+      required: ["workspace_root"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "run_poshqc_analyze_autofix",
+    description: "Apply bundled PoshQC analyzer autofixes, then rerun analysis against the target workspace using bundled extension resources.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        scan_folders: {
+          type: "array",
+          items: {
+            type: "string"
+          },
+          description: "Optional workspace-relative or workspace-contained folders to scan."
+        }
+      },
+      required: ["workspace_root"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "run_poshqc_suite",
+    description: "Run the bundled PoshQC suite against the target workspace using bundled extension resources.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        scan_folders: {
+          type: "array",
+          items: {
+            type: "string"
+          },
+          description: "Optional workspace-relative or workspace-contained folders to scan."
+        }
+      },
+      required: ["workspace_root"],
+      additionalProperties: false
+    }
+  }
+];
+
+// ../../extensions/drm-copilot/src/mcp-repo-automation-tool-definitions.ts
+var REPO_AUTOMATION_TOOL_DEFINITIONS = [
+  {
+    name: "collect_commit_context",
+    description: "Collect commit context artifacts from the target workspace using bundled extension resources.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty
+      },
+      required: ["workspace_root"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "collect_pr_context",
+    description: "Collect PR context artifacts for an explicit base branch using bundled extension resources.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        base: {
+          type: "string",
+          description: "Explicit base branch or ref used for PR context collection."
+        }
+      },
+      required: ["workspace_root", "base"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "run_codex_native_converter",
+    description: "Run the bundled Codex-native converter in review or apply mode using the extension resources.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        mode: {
+          type: "string",
+          description: "Converter mode to execute."
+        },
+        source_ecosystem: {
+          type: "string",
+          description: "Supported source ecosystem for the conversion run."
+        },
+        source_root: {
+          type: "string",
+          description: "Workspace-relative or absolute source runtime root."
+        },
+        selected_paths: {
+          type: "array",
+          description: "Optional workspace-relative or absolute source paths beneath source_root.",
+          items: {
+            type: "string"
+          }
+        },
+        destination_root: {
+          type: "string",
+          description: "Workspace-relative or absolute destination root required for apply mode."
+        },
+        artifact_root: {
+          type: "string",
+          description: "Optional workspace-relative or absolute artifact output root."
+        },
+        enable_repo_prompts: {
+          type: "boolean",
+          description: "When true, allow repository-convention .codex/prompts outputs."
+        }
+      },
+      required: ["workspace_root", "mode", "source_ecosystem", "source_root"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "push_down_copilot_customizations",
+    description: "Copy the bundled Copilot customization payload into the target workspace.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        ...copilotPushDownSelectionProperties
+      },
+      required: ["workspace_root"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "push_down_codex_and_agents_customizations",
+    description: "Copy the bundled Codex and agents customization payload into the target workspace.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        ...codexPushDownSelectionProperties
+      },
+      required: ["workspace_root"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "push_down_claude_customizations",
+    description: "Copy the bundled Claude Code customization payload into the target workspace.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        ...claudePushDownSelectionProperties
+      },
+      required: ["workspace_root"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "new_potential_bug_entry",
+    description: "Create a new potential bug entry in the target workspace from bundled templates.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        short_name: {
+          type: "string",
+          description: "Kebab-case short name for the potential bug entry."
+        }
+      },
+      required: ["workspace_root", "short_name"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "new_potential_entry",
+    description: "Create a new potential entry in the target workspace from bundled templates.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        short_name: {
+          type: "string",
+          description: "Kebab-case short name for the potential entry."
+        }
+      },
+      required: ["workspace_root", "short_name"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "link_parent_child",
+    description: "Link a child GitHub issue to a parent GitHub issue in the target workspace using the bundled PowerShell workflow.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        parent_issue_number: {
+          type: "string",
+          description: "Numeric issue number of the parent issue."
+        },
+        child_issue_number: {
+          type: "string",
+          description: "Numeric issue number of the child issue."
+        }
+      },
+      required: ["workspace_root", "parent_issue_number", "child_issue_number"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "potential_to_issue",
+    description: "Promote a potential entry into an issue-oriented feature workflow in the target workspace.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        potential_path: {
+          type: "string",
+          description: "Absolute or workspace-relative path to the potential Markdown file."
+        },
+        promotion_type: {
+          type: "string",
+          enum: ["epic", "feature", "refactor", "bug"],
+          description: "Promotion type to generate."
+        },
+        work_mode: {
+          type: "string",
+          enum: ["minor-audit", "full-feature", "full-bug", "full"],
+          description: "Work mode marker applied to the resulting issue workflow."
+        }
+      },
+      required: [
+        "workspace_root",
+        "potential_path",
+        "promotion_type",
+        "work_mode"
+      ],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "new_active_feature_folder",
+    description: "Create a new active feature folder in the target workspace from bundled templates.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        feature_name: {
+          type: "string",
+          description: "Feature folder name using kebab-case or underscore-case letters and numbers."
+        },
+        type: {
+          type: "string",
+          enum: ["epic", "feature", "refactor", "bug"],
+          description: "Feature folder type to create."
+        },
+        issue_number: {
+          type: "string",
+          description: "Optional numeric issue number associated with the feature folder."
+        },
+        work_mode: {
+          type: "string",
+          enum: ["minor-audit", "full-feature", "full-bug", "full"],
+          description: "Work mode marker applied to the feature folder."
+        }
+      },
+      required: ["workspace_root", "feature_name", "type", "work_mode"],
+      additionalProperties: false
+    }
+  },
+  ...POSHQC_TOOL_DEFINITIONS,
+  {
+    name: "resolve_policy_audit_template_asset",
+    description: "Resolve a bundled policy-audit template asset from the published extension package, optionally copying it into the target workspace.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        asset: {
+          type: "string",
+          enum: [...POLICY_AUDIT_TEMPLATE_ASSET_SELECTORS],
+          description: "Bundled policy-audit asset selector: 'template' for policy-audit.yyyy-MM-ddTHH-mm.md, 'code-review-template' for code-review.yyyy-MM-ddTHH-mm.md, 'feature-audit-template' for feature-audit.yyyy-MM-ddTHH-mm.md, or 'agents' for AGENTS.md."
+        },
+        target_path: {
+          type: "string",
+          description: "Optional workspace-relative or absolute destination path for a copied asset."
+        }
+      },
+      required: ["workspace_root", "asset"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "resolve_execute_hard_lock_prompt",
+    description: "Resolve the execute hard-lock prompt for a target plan path using bundled extension resources.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        target: {
+          type: "string",
+          description: "Target Markdown plan path to resolve."
+        }
+      },
+      required: ["workspace_root", "target"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "resolve_atomic_plan_prompt",
+    description: "Resolve the atomic-plan prompt for a target plan path using bundled extension resources.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        target: {
+          type: "string",
+          description: "Target Markdown plan path to resolve."
+        }
+      },
+      required: ["workspace_root", "target"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "validate_orchestration_artifacts",
+    description: "Validate an orchestration artifact, including epic planner, kickoff, and execution checkpoints, against its structural schema.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        artifact_type: {
+          type: "string",
+          enum: [
+            "plan",
+            "policy-audit",
+            "code-review",
+            "feature-audit",
+            "orchestrator-state",
+            "epic-orchestrator-state",
+            "epic-planner-state",
+            "epic-kickoff"
+          ],
+          description: "The type of orchestration artifact to validate."
+        },
+        artifact_path: {
+          type: "string",
+          description: "Workspace-relative or absolute path to the artifact file."
+        },
+        require_complete: {
+          type: "boolean",
+          description: "When true and artifact_type is 'orchestrator-state' or 'epic-orchestrator-state', require all phases to be complete."
+        },
+        require_model_routing: {
+          type: "boolean",
+          description: "When true and artifact_type is 'orchestrator-state', require a model_routing_receipts entry per delegated agent once a delegation is recorded. The TypeScript side performs the existence check only; the Python validator is authoritative for full per-receipt correctness."
+        },
+        require_codex_model_routing: {
+          type: "boolean",
+          description: "When true for an orchestrator checkpoint, require canonical Codex deployment receipts for delegated agents."
+        },
+        require_codex_topology: {
+          type: "boolean",
+          description: "When true for an orchestrator checkpoint, require canonical Codex topology receipts for delegated agents and epic roots."
+        },
+        require_ready_for_execution: {
+          type: "boolean",
+          description: "When true and artifact_type is 'epic-planner-state', require every child to be prepared and preflight-cleared."
+        }
+      },
+      required: ["workspace_root", "artifact_type", "artifact_path"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "render_subagent_tree",
+    description: "Render the subagent call tree for a root session id. The session id is a transcript filename stem; the transcript is resolved under the user-global Claude projects directory, searching the encoded workspace directory plus its '-wt-' worktree siblings (case-insensitive) and returning the first match deterministically.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace_root: workspaceRootProperty,
+        session_id: {
+          type: "string",
+          description: "Root session identifier (transcript filename stem under ~/.claude/projects/<encoded-workspace>/, e.g. a UUIDv4)."
+        }
+      },
+      required: ["workspace_root", "session_id"],
+      additionalProperties: false
+    }
+  },
+  ...DISCOVERY_TOOL_DEFINITIONS
+];
+
+// ../../extensions/drm-copilot/src/repo-automation-tool-names.ts
+var REPO_AUTOMATION_TOOLS = [
+  "collect_commit_context",
+  "collect_pr_context",
+  "run_codex_native_converter",
+  "push_down_copilot_customizations",
+  "push_down_codex_and_agents_customizations",
+  "push_down_claude_customizations",
+  "new_potential_bug_entry",
+  "new_potential_entry",
+  "link_parent_child",
+  "potential_to_issue",
+  "new_active_feature_folder",
+  "run_poshqc_format",
+  "run_poshqc_analyze",
+  "run_poshqc_test",
+  "run_poshqc_analyze_autofix",
+  "run_poshqc_suite",
+  "resolve_policy_audit_template_asset",
+  "resolve_execute_hard_lock_prompt",
+  "resolve_atomic_plan_prompt",
+  "validate_orchestration_artifacts",
+  "render_subagent_tree",
+  "validate_discovery_artifacts",
+  "run_discovery_init",
+  "run_discovery_repo_inventory",
+  "run_discovery_dotnet_analyzer",
+  "run_discovery_vsto_analyzer",
+  "run_discovery_scenario_generation",
+  "run_discovery_report"
+];
 
 // ../../extensions/drm-copilot/src/mcp-handlers/collect-context-handlers.ts
 async function handleCollectCommitContext(rawInput, service) {
@@ -16754,6 +17152,36 @@ async function handleResolveExecuteHardLockPrompt(rawInput, service) {
   });
 }
 
+// ../../extensions/drm-copilot/src/mcp-handlers/discovery-handlers.ts
+async function handleValidateDiscoveryArtifacts(rawInput, service) {
+  const input = resolveValidateDiscoveryArtifactsToolInput(rawInput);
+  return service.validateDiscoveryArtifacts(input);
+}
+async function handleRunDiscoveryInit(rawInput, service) {
+  const input = resolveRunDiscoveryInitToolInput(rawInput);
+  return service.runDiscoveryInit(input);
+}
+async function handleRunDiscoveryRepoInventory(rawInput, service) {
+  const input = resolveRunDiscoveryRepoInventoryToolInput(rawInput);
+  return service.runDiscoveryRepoInventory(input);
+}
+async function handleRunDiscoveryDotnetAnalyzer(rawInput, service) {
+  const input = resolveRunDiscoveryDotnetAnalyzerToolInput(rawInput);
+  return service.runDiscoveryDotnetAnalyzer(input);
+}
+async function handleRunDiscoveryVstoAnalyzer(rawInput, service) {
+  const input = resolveRunDiscoveryVstoAnalyzerToolInput(rawInput);
+  return service.runDiscoveryVstoAnalyzer(input);
+}
+async function handleRunDiscoveryScenarioGeneration(rawInput, service) {
+  const input = resolveRunDiscoveryScenarioGenerationToolInput(rawInput);
+  return service.runDiscoveryScenarioGeneration(input);
+}
+async function handleRunDiscoveryReport(rawInput, service) {
+  const input = resolveRunDiscoveryReportToolInput(rawInput);
+  return service.runDiscoveryReport(input);
+}
+
 // ../../extensions/drm-copilot/src/mcp-tool-inputs-subagent-tree.ts
 function resolveRenderSubagentTreeToolInput(rawInput, fallbackWorkspaceRoot) {
   const args = asToolArgumentObject(rawInput);
@@ -16911,6 +17339,39 @@ async function dispatchRepoAutomationTool(toolName, rawInput, service) {
           await handleRenderSubagentTree(rawInput, service)
         );
       }
+      case "validate_discovery_artifacts": {
+        return toMcpToolResult(
+          await handleValidateDiscoveryArtifacts(rawInput, service)
+        );
+      }
+      case "run_discovery_init": {
+        return toMcpToolResult(await handleRunDiscoveryInit(rawInput, service));
+      }
+      case "run_discovery_repo_inventory": {
+        return toMcpToolResult(
+          await handleRunDiscoveryRepoInventory(rawInput, service)
+        );
+      }
+      case "run_discovery_dotnet_analyzer": {
+        return toMcpToolResult(
+          await handleRunDiscoveryDotnetAnalyzer(rawInput, service)
+        );
+      }
+      case "run_discovery_vsto_analyzer": {
+        return toMcpToolResult(
+          await handleRunDiscoveryVstoAnalyzer(rawInput, service)
+        );
+      }
+      case "run_discovery_scenario_generation": {
+        return toMcpToolResult(
+          await handleRunDiscoveryScenarioGeneration(rawInput, service)
+        );
+      }
+      case "run_discovery_report": {
+        return toMcpToolResult(
+          await handleRunDiscoveryReport(rawInput, service)
+        );
+      }
     }
   } catch (error2) {
     return toFailureToolResult(toolName, workspaceRoot, error2);
@@ -29174,6 +29635,13 @@ function posixBasename(pathStr) {
   return lastSlash === -1 ? normalized : normalized.slice(lastSlash + 1);
 }
 function buildIssueBody(content, selectedMode, promotionType, relativePath2) {
+  if (promotionType === "bug") {
+    const bugSections = {};
+    for (const heading of BUG_SECTION_HEADINGS) {
+      bugSections[heading] = getSection(content, heading) || PLACEHOLDER;
+    }
+    return buildBugBody(selectedMode, bugSections, relativePath2);
+  }
   if (selectedMode === "minor-audit") {
     const problem2 = getSection(content, "Problem / Why") || PLACEHOLDER;
     const implementationIntent = getSection(content, "Proposed Behavior") || PLACEHOLDER;
@@ -29195,13 +29663,6 @@ function buildIssueBody(content, selectedMode, promotionType, relativePath2) {
       relativePath2
     );
   }
-  if (promotionType === "bug") {
-    const bugSections = {};
-    for (const heading of BUG_SECTION_HEADINGS) {
-      bugSections[heading] = getSection(content, heading) || PLACEHOLDER;
-    }
-    return buildBugBody(selectedMode, bugSections, relativePath2);
-  }
   const problem = getSection(content, "Problem / Why") || PLACEHOLDER;
   const behavior = getSection(content, "Proposed Behavior") || PLACEHOLDER;
   const criteria = getSection(content, "Acceptance Criteria (early draft)") || PLACEHOLDER;
@@ -30800,6 +31261,263 @@ function renderSubagentTreeServiceCall(input, env = process.env) {
   };
 }
 
+// ../../extensions/drm-copilot/src/repo-automation-execute-discovery.ts
+var VALIDATE_DISCOVERY_ARTIFACTS_MODULE = "scripts.dev_tools.validate_discovery_artifacts";
+var VALIDATE_ENTRY_FUNCTION_BY_ARTIFACT_TYPE = {
+  profile: "main_profile",
+  "feature-contract": "main_feature_contract",
+  "coverage-ledger": "main_coverage_ledger",
+  "runtime-scenario": "main_runtime_scenario",
+  "parity-matrix": "main_parity_matrix",
+  "unspecified-behavior": "main_unspecified_behavior",
+  "product-decision": "main_product_decision",
+  "evidence-reference": "main_evidence_reference",
+  all: "main"
+};
+var DISCOVERY_INIT_ENTRY = {
+  module: "scripts.dev_tools.discovery.init_cli",
+  functionName: "main"
+};
+var DISCOVERY_REPO_INVENTORY_ENTRY = {
+  module: "scripts.dev_tools.discovery.analyzer.cli",
+  functionName: "main"
+};
+var DISCOVERY_STACK_ANALYZER_MODULE = "scripts.dev_tools.discovery.analyzer.stack_cli";
+var DISCOVERY_DOTNET_ANALYZER_FUNCTION = "main_dotnet";
+var DISCOVERY_VSTO_ANALYZER_FUNCTION = "main_vsto";
+var DISCOVERY_SCENARIO_GENERATION_ENTRY = {
+  module: "scripts.dev_tools.generate_acceptance_scenarios",
+  functionName: "main"
+};
+var DISCOVERY_REPORT_ENTRY_BY_REPORT_TYPE = {
+  coverage: {
+    module: "scripts.dev_tools.discovery.coverage_report",
+    functionName: "main"
+  },
+  parity: {
+    module: "scripts.dev_tools.discovery.parity_report",
+    functionName: "main"
+  },
+  completion: {
+    module: "scripts.dev_tools.discovery.completion_report",
+    functionName: "main"
+  }
+};
+function parseWrittenPathsJson(stdout) {
+  const trimmed = stdout.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return void 0;
+  }
+  const writtenPaths = parsed["written_paths"];
+  if (!Array.isArray(writtenPaths)) {
+    return void 0;
+  }
+  const paths = writtenPaths.filter(
+    (candidate) => typeof candidate === "string"
+  );
+  return paths.length > 0 ? paths : void 0;
+}
+function parseOkWrotePath(stdout) {
+  const match = /^ok:\s*wrote\s+(.+?)\s*$/im.exec(stdout);
+  if (match === null) {
+    return void 0;
+  }
+  const path11 = match[1]?.trim();
+  return path11 !== void 0 && path11.length > 0 ? [path11] : void 0;
+}
+function parseDiscoveryArtifacts(mode, stdout) {
+  if (mode === "written_paths_json") {
+    return parseWrittenPathsJson(stdout);
+  }
+  if (mode === "ok_wrote") {
+    return parseOkWrotePath(stdout);
+  }
+  return void 0;
+}
+async function executeDiscoveryServiceCall(output, request) {
+  output.appendLine(`[${request.invocationId}] runtime probe start`);
+  let runtime;
+  try {
+    runtime = detectRuntime("python", request.workspaceRoot);
+  } catch (error2) {
+    output.appendLine(`[${request.invocationId}] runtime probe failure`);
+    throw error2;
+  }
+  output.appendLine(
+    `[${request.invocationId}] runtime probe success: ${runtime.executable}`
+  );
+  const entryCode = `import sys; from ${request.module} import ${request.functionName}; sys.exit(${request.functionName}())`;
+  const args = [...runtime.argsPrefix, "-c", entryCode, ...request.cliArgs];
+  output.appendLine(
+    `[${request.invocationId}] command start: ${runtime.executable} -c <${request.module}:${request.functionName}>`
+  );
+  let processResult;
+  try {
+    processResult = await runCommandWithOutput(
+      output,
+      runtime.executable,
+      args,
+      request.workspaceRoot
+    );
+  } catch (error2) {
+    output.appendLine(`[${request.invocationId}] command failure`);
+    throw error2;
+  }
+  output.appendLine(`[${request.invocationId}] command success`);
+  const artifacts = parseDiscoveryArtifacts(
+    request.artifactParse,
+    processResult.stdout
+  );
+  return {
+    tool: request.tool,
+    workspaceRoot: request.workspaceRoot,
+    summary: request.summary,
+    ...artifacts === void 0 ? {} : { artifacts }
+  };
+}
+function resolveInvocationId(input, fallback) {
+  return input.invocationId ?? fallback;
+}
+function buildAnalyzerCliArgs(input) {
+  return [
+    ...input.profilePath === void 0 ? [] : [input.profilePath],
+    ...input.outputDir === void 0 ? [] : ["--output-dir", input.outputDir],
+    "--json"
+  ];
+}
+async function runValidateDiscoveryArtifacts(output, input) {
+  const functionName = VALIDATE_ENTRY_FUNCTION_BY_ARTIFACT_TYPE[input.artifactType];
+  if (functionName === void 0) {
+    throw new Error(
+      `Unsupported discovery artifact_type '${input.artifactType}'.`
+    );
+  }
+  return executeDiscoveryServiceCall(output, {
+    tool: "validate_discovery_artifacts",
+    module: VALIDATE_DISCOVERY_ARTIFACTS_MODULE,
+    functionName,
+    cliArgs: [input.artifactPath],
+    workspaceRoot: input.workspaceRoot,
+    invocationId: resolveInvocationId(input, "validate_discovery_artifacts"),
+    summary: `Validated discovery artifact '${input.artifactPath}' as artifact type '${input.artifactType}'.`,
+    artifactParse: "none"
+  });
+}
+async function runDiscoveryInit(output, input) {
+  const cliArgs = [
+    input.targetDir,
+    ...input.templateRoot === void 0 ? [] : ["--template-root", input.templateRoot],
+    ...input.force === true ? ["--force"] : []
+  ];
+  return executeDiscoveryServiceCall(output, {
+    tool: "run_discovery_init",
+    module: DISCOVERY_INIT_ENTRY.module,
+    functionName: DISCOVERY_INIT_ENTRY.functionName,
+    cliArgs,
+    workspaceRoot: input.workspaceRoot,
+    invocationId: resolveInvocationId(input, "run_discovery_init"),
+    summary: `Initialized the discovery workspace at '${input.targetDir}'.`,
+    artifactParse: "none"
+  });
+}
+async function runDiscoveryRepoInventory(output, input) {
+  return executeDiscoveryServiceCall(output, {
+    tool: "run_discovery_repo_inventory",
+    module: DISCOVERY_REPO_INVENTORY_ENTRY.module,
+    functionName: DISCOVERY_REPO_INVENTORY_ENTRY.functionName,
+    cliArgs: buildAnalyzerCliArgs(input),
+    workspaceRoot: input.workspaceRoot,
+    invocationId: resolveInvocationId(input, "run_discovery_repo_inventory"),
+    summary: "Generated the repository inventory discovery analysis.",
+    artifactParse: "written_paths_json"
+  });
+}
+async function runDiscoveryDotnetAnalyzer(output, input) {
+  return executeDiscoveryServiceCall(output, {
+    tool: "run_discovery_dotnet_analyzer",
+    module: DISCOVERY_STACK_ANALYZER_MODULE,
+    functionName: DISCOVERY_DOTNET_ANALYZER_FUNCTION,
+    cliArgs: buildAnalyzerCliArgs(input),
+    workspaceRoot: input.workspaceRoot,
+    invocationId: resolveInvocationId(input, "run_discovery_dotnet_analyzer"),
+    summary: "Generated the .NET stack discovery analysis.",
+    artifactParse: "written_paths_json"
+  });
+}
+async function runDiscoveryVstoAnalyzer(output, input) {
+  return executeDiscoveryServiceCall(output, {
+    tool: "run_discovery_vsto_analyzer",
+    module: DISCOVERY_STACK_ANALYZER_MODULE,
+    functionName: DISCOVERY_VSTO_ANALYZER_FUNCTION,
+    cliArgs: buildAnalyzerCliArgs(input),
+    workspaceRoot: input.workspaceRoot,
+    invocationId: resolveInvocationId(input, "run_discovery_vsto_analyzer"),
+    summary: "Generated the VSTO stack discovery analysis.",
+    artifactParse: "written_paths_json"
+  });
+}
+async function runDiscoveryScenarioGeneration(output, input) {
+  const cliArgs = [
+    "--feature-contract",
+    input.featureContract,
+    "--parity-matrix",
+    input.parityMatrix,
+    "--runtime-characterization",
+    input.runtimeCharacterization,
+    ...input.outputPath === void 0 ? [] : ["--output", input.outputPath],
+    ...input.check === true ? ["--check"] : []
+  ];
+  return executeDiscoveryServiceCall(output, {
+    tool: "run_discovery_scenario_generation",
+    module: DISCOVERY_SCENARIO_GENERATION_ENTRY.module,
+    functionName: DISCOVERY_SCENARIO_GENERATION_ENTRY.functionName,
+    cliArgs,
+    workspaceRoot: input.workspaceRoot,
+    invocationId: resolveInvocationId(
+      input,
+      "run_discovery_scenario_generation"
+    ),
+    summary: "Generated discovery acceptance scenarios.",
+    artifactParse: "ok_wrote"
+  });
+}
+async function runDiscoveryReport(output, input) {
+  const entry = DISCOVERY_REPORT_ENTRY_BY_REPORT_TYPE[input.reportType];
+  if (entry === void 0) {
+    throw new Error(`Unsupported discovery report_type '${input.reportType}'.`);
+  }
+  const cliArgs = input.reportType === "completion" ? [
+    "--coverage-input",
+    input.coverageInput ?? "",
+    "--parity-input",
+    input.parityInput ?? "",
+    ...input.outputPath === void 0 ? [] : ["--output", input.outputPath]
+  ] : [
+    "--input",
+    input.inputPath ?? "",
+    ...input.outputPath === void 0 ? [] : ["--output", input.outputPath]
+  ];
+  return executeDiscoveryServiceCall(output, {
+    tool: "run_discovery_report",
+    module: entry.module,
+    functionName: entry.functionName,
+    cliArgs,
+    workspaceRoot: input.workspaceRoot,
+    invocationId: resolveInvocationId(input, "run_discovery_report"),
+    summary: `Generated the '${input.reportType}' discovery report.`,
+    artifactParse: "none"
+  });
+}
+
 // ../../extensions/drm-copilot/src/repo-automation-service.ts
 var DefaultRepoAutomationService = class {
   extensionRoot;
@@ -30979,6 +31697,27 @@ var DefaultRepoAutomationService = class {
       fileSystem: this.fileSystem
     });
   }
+  async validateDiscoveryArtifacts(input) {
+    return runValidateDiscoveryArtifacts(this.output, input);
+  }
+  async runDiscoveryInit(input) {
+    return runDiscoveryInit(this.output, input);
+  }
+  async runDiscoveryRepoInventory(input) {
+    return runDiscoveryRepoInventory(this.output, input);
+  }
+  async runDiscoveryDotnetAnalyzer(input) {
+    return runDiscoveryDotnetAnalyzer(this.output, input);
+  }
+  async runDiscoveryVstoAnalyzer(input) {
+    return runDiscoveryVstoAnalyzer(this.output, input);
+  }
+  async runDiscoveryScenarioGeneration(input) {
+    return runDiscoveryScenarioGeneration(this.output, input);
+  }
+  async runDiscoveryReport(input) {
+    return runDiscoveryReport(this.output, input);
+  }
   async executeScript(options) {
     return executeScriptServiceCall(this.output, this.extensionRoot, options);
   }