@danmoisan/drm-copilot-mcp 1.0.26 → 1.0.27

package/out/mcp-server.js

@@ -17260,7 +17260,8 @@ function toMcpToolResult(result) {
     ...result.assetId === void 0 ? {} : { asset_id: result.assetId },
     ...result.bundledSourcePath === void 0 ? {} : { bundled_source_path: result.bundledSourcePath },
     ...result.destinationPath === void 0 ? {} : { destination_path: result.destinationPath },
-    ...result.renderedTree === void 0 ? {} : { rendered_tree: result.renderedTree }
+    ...result.renderedTree === void 0 ? {} : { rendered_tree: result.renderedTree },
+    ...result.warnings === void 0 ? {} : { warnings: result.warnings }
   };
 }
 function toFailureToolResult(tool, workspaceRoot, error2) {
@@ -19015,7 +19016,8 @@ var CARRIED_KEYS = [
   "version",
   "shared_surfaces",
   "shared_surface_globs",
-  "over_breadth_fraction"
+  "over_breadth_fraction",
+  "mandate_reads"
 ];
 var BlastRadiusDeriveError = class extends Error {
   /** Destination-relative path of the document that failed to parse. */
@@ -19143,6 +19145,7 @@ function deriveDestinationModuleMap(observations, sourceDocumentText) {
     version: source[CARRIED_KEYS[0]],
     shared_surfaces: source[CARRIED_KEYS[1]],
     shared_surface_globs: source[CARRIED_KEYS[2]],
+    mandate_reads: source[CARRIED_KEYS[4]],
     modules,
     over_breadth_fraction: source[CARRIED_KEYS[3]]
   };
@@ -26846,6 +26849,417 @@ function validateParallelKickoffText(text) {
   return parseParallelKickoff(text).errors;
 }
 
+// ../../extensions/drm-copilot/src/lib/validate/plan-gate-commands.ts
+var SHELL_WHITESPACE = /* @__PURE__ */ new Set([" ", "	", "\r", "\n"]);
+var ESCAPE = "\\";
+var COV_FLAG = "--cov";
+var COV_FLAG_PREFIX = "--cov=";
+var GREP_EXECUTABLES = /* @__PURE__ */ new Set(["grep", "egrep", "fgrep", "rg"]);
+var EXECUTABLE_SCAN_LIMIT = 4;
+var PLAN_GATE_TASK_PATTERN = /^- \[(?<state>[ xX])\] \[P(?<phase>\d+)-T(?<task>\d+)\] (?<title>.+)$/;
+var PLAN_GATE_HEADING_PATTERN = /^#{1,6} /;
+var INLINE_SPAN_RE = /`([^`]+)`/g;
+var FENCE_RE = /^\s*```/;
+var MINIMUM_ARGV_LENGTH = 2;
+function splitShellWords(span) {
+  const words2 = [];
+  let token = null;
+  let quote = null;
+  let index = 0;
+  while (index < span.length) {
+    const char = span[index] ?? "";
+    index += 1;
+    if (quote === null) {
+      if (SHELL_WHITESPACE.has(char)) {
+        if (token !== null) {
+          words2.push(token);
+          token = null;
+        }
+        continue;
+      }
+      if (char === ESCAPE) {
+        const next = span[index];
+        if (next === void 0) {
+          return null;
+        }
+        index += 1;
+        token = (token ?? "") + next;
+        continue;
+      }
+      if (char === '"' || char === "'") {
+        quote = char;
+        token = token ?? "";
+        continue;
+      }
+      token = (token ?? "") + char;
+      continue;
+    }
+    if (char === quote) {
+      quote = null;
+      continue;
+    }
+    if (quote === '"' && char === ESCAPE) {
+      const next = span[index];
+      if (next === void 0) {
+        return null;
+      }
+      index += 1;
+      if (next !== quote && next !== ESCAPE) {
+        token = (token ?? "") + ESCAPE;
+      }
+      token = (token ?? "") + next;
+      continue;
+    }
+    token = (token ?? "") + char;
+  }
+  if (quote !== null) {
+    return null;
+  }
+  if (token !== null) {
+    words2.push(token);
+  }
+  return words2;
+}
+function isCovFlagToken(token) {
+  return token === COV_FLAG || token.startsWith(COV_FLAG_PREFIX);
+}
+function grepExecutableIndex(argv) {
+  const limit = Math.min(argv.length, EXECUTABLE_SCAN_LIMIT);
+  for (let index = 0; index < limit; index += 1) {
+    const word = argv[index];
+    if (word === void 0) {
+      continue;
+    }
+    if (GREP_EXECUTABLES.has(word)) {
+      return index;
+    }
+    if (word === "git" && argv[index + 1] === "grep") {
+      return index + 1;
+    }
+  }
+  return null;
+}
+function classifyKind(argv) {
+  if (grepExecutableIndex(argv) !== null) {
+    return "grep";
+  }
+  if (argv.some((word) => isCovFlagToken(word))) {
+    return "pytest_cov";
+  }
+  return "other";
+}
+function splitLines2(text) {
+  return text.split(/\r\n|\n|\r/);
+}
+function inlineSpans(line) {
+  const spans = [];
+  for (const match of line.matchAll(INLINE_SPAN_RE)) {
+    const body = match[1];
+    if (body !== void 0) {
+      spans.push(body);
+    }
+  }
+  return spans;
+}
+function appendCommand(commands, taskId, sourceLine, rawSpan) {
+  const argv = splitShellWords(rawSpan);
+  if (argv === null || argv.length < MINIMUM_ARGV_LENGTH) {
+    return;
+  }
+  commands.push({
+    taskId,
+    sourceLine,
+    rawSpan,
+    argv,
+    kind: classifyKind(argv)
+  });
+}
+function extractPlanCommands(text) {
+  const commands = [];
+  let currentTask = null;
+  let inFence = false;
+  const lines = splitLines2(text);
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    const lineNumber = index + 1;
+    if (FENCE_RE.test(line)) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) {
+      const fenced = line.trim();
+      if (currentTask !== null && fenced !== "") {
+        appendCommand(commands, currentTask, lineNumber, fenced);
+      }
+      continue;
+    }
+    if (PLAN_GATE_HEADING_PATTERN.test(line)) {
+      currentTask = null;
+      continue;
+    }
+    const taskMatch = PLAN_GATE_TASK_PATTERN.exec(line);
+    if (taskMatch !== null) {
+      const phase = taskMatch.groups?.["phase"] ?? "";
+      const task = taskMatch.groups?.["task"] ?? "";
+      currentTask = `P${phase}-T${task}`;
+    }
+    if (currentTask === null) {
+      continue;
+    }
+    for (const span of inlineSpans(line)) {
+      appendCommand(commands, currentTask, lineNumber, span);
+    }
+  }
+  return commands;
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/plan-gate-rules.ts
+function emptyPlanGateReport() {
+  return { blocking: [], warnings: [] };
+}
+var BLOCKING_CHANNEL = "blocking";
+var PLACEHOLDER_MARKERS = ["<", ">", "${", "$(", "%"];
+var PATH_SEPARATORS = ["/", "\\"];
+var PYTHON_SUFFIX = ".py";
+var PYTEST_NODE_SEPARATOR = "::";
+var REGEX_METACHARACTERS = /* @__PURE__ */ new Set([...".*[]^$\\(){}|+?"]);
+var FIXED_STRING_FLAG = "-F";
+var WINDOW_SIZE = 4;
+function isPlaceholder(value) {
+  return PLACEHOLDER_MARKERS.some((marker) => value.includes(marker));
+}
+function dottedRemedy(value) {
+  const stem2 = value.endsWith(PYTHON_SUFFIX) ? value.slice(0, value.length - PYTHON_SUFFIX.length) : value;
+  return stem2.split("/").join(".").split("\\").join(".");
+}
+function covValues(command) {
+  const values = [];
+  const argv = command.argv;
+  for (let index = 0; index < argv.length; index += 1) {
+    const word = argv[index];
+    if (word === void 0) {
+      continue;
+    }
+    if (word === COV_FLAG) {
+      const next = argv[index + 1];
+      if (next !== void 0) {
+        values.push({ value: next, spaceSeparated: true });
+      }
+      continue;
+    }
+    if (word.startsWith(COV_FLAG_PREFIX)) {
+      values.push({
+        value: word.slice(COV_FLAG_PREFIX.length),
+        spaceSeparated: false
+      });
+    }
+  }
+  return values;
+}
+function evaluateCovValue(report, command, cov, context) {
+  const task = command.taskId;
+  if (cov.spaceSeparated) {
+    report.warnings.push(
+      `[${task}] --cov argument value \`${cov.value}\` is supplied space-separated; the ambiguous form can bind the following positional argument. Use the --cov=<module> form.`
+    );
+  }
+  if (isPlaceholder(cov.value)) {
+    return;
+  }
+  const truncated = cov.value.split(PYTEST_NODE_SEPARATOR)[0] ?? "";
+  if (truncated.endsWith(PYTHON_SUFFIX)) {
+    report.blocking.push(
+      `[${task}] --cov argument \`${cov.value}\` names a filesystem path; coverage.py accepts only directories or importable names. Use --cov=${dottedRemedy(truncated)}.`
+    );
+    return;
+  }
+  if (!PATH_SEPARATORS.some((separator) => cov.value.includes(separator))) {
+    return;
+  }
+  if (context === void 0) {
+    return;
+  }
+  try {
+    evaluateTrackedCovValue(report, task, cov, truncated, context);
+  } catch {
+  }
+}
+function evaluateTrackedCovValue(report, task, cov, truncated, context) {
+  if (context.git.isTrackedFile(truncated + PYTHON_SUFFIX)) {
+    report.blocking.push(
+      `[${task}] --cov argument \`${cov.value}\` names a tracked module file path; coverage.py accepts only directories or importable names. Use --cov=${dottedRemedy(truncated)}.`
+    );
+    return;
+  }
+  if (context.git.isTrackedDirectory(truncated)) {
+    return;
+  }
+  report.warnings.push(
+    `[${task}] --cov argument \`${cov.value}\` contains a path separator but resolves to neither a tracked file nor a tracked directory; coverage may collect no data. Use the importable dotted form or a tracked directory.`
+  );
+}
+function patternOperand(argv) {
+  const executable = grepExecutableIndex(argv);
+  if (executable === null) {
+    return null;
+  }
+  for (let index = executable + 1; index < argv.length; index += 1) {
+    const word = argv[index];
+    if (word === void 0 || word.startsWith("-")) {
+      continue;
+    }
+    return word;
+  }
+  return null;
+}
+function isCheckableLiteral(argv, pattern) {
+  if (isPlaceholder(pattern)) {
+    return false;
+  }
+  if (argv.includes(FIXED_STRING_FLAG)) {
+    return true;
+  }
+  return ![...pattern].some((character) => REGEX_METACHARACTERS.has(character));
+}
+function normalizeWhitespace(value) {
+  return value.split(/\s+/).filter((word) => word !== "").join(" ");
+}
+function planQuotesLiteral(text, literal2, excludeSpan) {
+  const remainder = text.split(excludeSpan).join(" ");
+  const needle = normalizeWhitespace(literal2);
+  if (needle === "") {
+    return false;
+  }
+  return normalizeWhitespace(remainder).includes(needle);
+}
+function windowJoin(lines, size = WINDOW_SIZE) {
+  const dense = lines.filter((line) => line.trim() !== "").map((line) => normalizeWhitespace(line));
+  const windows = [];
+  for (let index = 0; index < dense.length; index += 1) {
+    windows.push(dense.slice(index, index + size).join(" "));
+  }
+  return windows;
+}
+function hasCrossLinePresence(context, literal2) {
+  const words2 = literal2.split(/\s+/).filter((word) => word !== "");
+  if (words2.length < 2) {
+    return false;
+  }
+  const needle = words2.join(" ");
+  const firstWord = words2[0] ?? "";
+  for (const path11 of context.git.filesContaining(firstWord)) {
+    const lines = context.git.readTrackedText(path11).split(/\r\n|\n|\r/);
+    if (lines.some((line) => normalizeWhitespace(line).includes(needle))) {
+      continue;
+    }
+    if (windowJoin(lines).some((window2) => window2.includes(needle))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// ../../extensions/drm-copilot/src/lib/validate/plan-gate-discrimination.ts
+var G5_SEVERITY = "warning";
+var CommandRunnerPlanGateRepository = class {
+  constructor(workspaceRoot, runner) {
+    this.workspaceRoot = workspaceRoot;
+    this.runner = runner;
+  }
+  workspaceRoot;
+  runner;
+  /** Run one `git` invocation and return its exit code and trimmed stdout. */
+  run(arguments_) {
+    const result = this.runner.run(["git", ...arguments_], {
+      cwd: this.workspaceRoot,
+      allowError: true
+    });
+    return { code: result.code, stdout: result.stdout.trim() };
+  }
+  /** Return tracked paths carrying the literal on a single line. */
+  filesContaining(literal2) {
+    const result = this.run(["grep", "-F", "-l", "--", literal2]);
+    if (result.code !== 0 || result.stdout === "") {
+      return [];
+    }
+    return result.stdout.split(/\r\n|\n|\r/).map((line) => line.trim()).filter((line) => line !== "");
+  }
+  /** Return whether `git ls-files` lists the path itself. */
+  isTrackedFile(path11) {
+    const normalized = path11.split("\\").join("/");
+    const result = this.run(["ls-files", "--", normalized]);
+    if (result.code !== 0 || result.stdout === "") {
+      return false;
+    }
+    return result.stdout.split(/\r\n|\n|\r/).some((line) => line.trim() === normalized);
+  }
+  /** Return whether entries exist beneath the path but none equals it. */
+  isTrackedDirectory(path11) {
+    const normalized = path11.split("\\").join("/").replace(/\/+$/, "");
+    const result = this.run(["ls-files", "--", normalized]);
+    if (result.code !== 0 || result.stdout === "") {
+      return false;
+    }
+    const listed = result.stdout.split(/\r\n|\n|\r/).map((line) => line.trim()).filter((line) => line !== "");
+    return listed.length > 0 && listed.every((entry) => entry !== normalized);
+  }
+  /** Return the committed text of the path at `HEAD`, or an empty string. */
+  readTrackedText(path11) {
+    const normalized = path11.split("\\").join("/");
+    const result = this.run(["show", `HEAD:${normalized}`]);
+    return result.code === 0 ? result.stdout : "";
+  }
+};
+function evaluateLiteral(report, text, command, context) {
+  const pattern = patternOperand(command.argv);
+  if (pattern === null || !isCheckableLiteral(command.argv, pattern)) {
+    return;
+  }
+  if (context.git.filesContaining(pattern).length > 0) {
+    return;
+  }
+  if (planQuotesLiteral(text, pattern, command.rawSpan)) {
+    return;
+  }
+  if (hasCrossLinePresence(context, pattern)) {
+    report.warnings.push(
+      `[${command.taskId}] search literal \`${pattern}\` is present only across adjacent lines of a tracked file and matches no single line; a line-oriented search returns zero matches. Search a shorter single-line token.`
+    );
+    return;
+  }
+  const finding = `[${command.taskId}] search literal \`${pattern}\` is absent from the tracked tree and is not quoted in the plan; the search returns zero matches whatever the executor does. Quote the exact literal the task will create, or assert a literal that exists.`;
+  const channel = G5_SEVERITY === BLOCKING_CHANNEL ? report.blocking : report.warnings;
+  channel.push(finding);
+}
+function evaluateLiteralRules(report, text, commands, context) {
+  const literalFindings = emptyPlanGateReport();
+  try {
+    for (const command of commands) {
+      if (command.kind !== "grep") {
+        continue;
+      }
+      evaluateLiteral(literalFindings, text, command, context);
+    }
+  } catch {
+    return;
+  }
+  report.blocking.push(...literalFindings.blocking);
+  report.warnings.push(...literalFindings.warnings);
+}
+function evaluatePlanGates(text, context) {
+  const report = emptyPlanGateReport();
+  const commands = extractPlanCommands(text);
+  for (const command of commands) {
+    for (const cov of covValues(command)) {
+      evaluateCovValue(report, command, cov, context);
+    }
+  }
+  if (context !== void 0) {
+    evaluateLiteralRules(report, text, commands, context);
+  }
+  return report;
+}
+
 // ../../extensions/drm-copilot/src/lib/validate/parallel-state-shared.ts
 function words(text) {
   return text.split(" ");
@@ -28020,7 +28434,7 @@ var POLICY_AUDIT_REQUIRED_CHECKLIST_LABELS = [
   "Per-language comparison summary:"
 ];
 var POLICY_AUDIT_COMPARISON_HEADING = "### 1.2.1 Per-Language Coverage Comparison";
-var PLACEHOLDER_MARKERS = [
+var PLACEHOLDER_MARKERS2 = [
   "[n]",
   "[path",
   "[artifact",
@@ -28046,7 +28460,7 @@ function isNaValue(value) {
 }
 function hasPlaceholderMarker(value) {
   const lowered = value.toLowerCase();
-  return PLACEHOLDER_MARKERS.some((marker) => lowered.includes(marker));
+  return PLACEHOLDER_MARKERS2.some((marker) => lowered.includes(marker));
 }
 function reportsMissingTemplateResolverSuccess(text) {
   const lowered = text.toLowerCase();
@@ -28353,10 +28767,28 @@ function validatePlanText(text) {
   }
   return errors;
 }
-function validateArtifact(input) {
+function buildPlanGateContext(input) {
+  if (input.fs === void 0 || input.root === void 0 || input.artifactPath === void 0 || input.runner === void 0) {
+    return void 0;
+  }
+  return {
+    workspaceRoot: input.root,
+    fileSystem: input.fs,
+    git: new CommandRunnerPlanGateRepository(input.root, input.runner)
+  };
+}
+function validateArtifactWithWarnings(input) {
+  if (input.artifactType === "plan") {
+    const report = evaluatePlanGates(input.text, buildPlanGateContext(input));
+    return {
+      errors: [...validatePlanText(input.text), ...report.blocking],
+      warnings: report.warnings
+    };
+  }
+  return { errors: dispatchValidatorErrors(input), warnings: [] };
+}
+function dispatchValidatorErrors(input) {
   switch (input.artifactType) {
-    case "plan":
-      return validatePlanText(input.text);
     case "policy-audit":
       return validatePolicyAuditText(input.text);
     case "code-review":
@@ -28419,12 +28851,13 @@ function validateArtifact(input) {
 }
 
 // ../../extensions/drm-copilot/src/lib/validate/validate-orchestration-service-call.ts
+var PLAN_GATE_WARNING_PREFIX = "PLAN GATE WARNING: ";
 function validateOrchestrationServiceCall(input) {
   const artifactFullPath = toPosixPath2(
     path9.join(input.workspaceRoot, input.artifactPath)
   );
   const text = input.fileSystem.readTextFile(artifactFullPath);
-  const errors = validateArtifact({
+  const { errors, warnings } = validateArtifactWithWarnings({
     artifactType: input.artifactType,
     text,
     ...input.requireComplete === void 0 ? {} : { requireComplete: input.requireComplete },
@@ -28438,15 +28871,17 @@ function validateOrchestrationServiceCall(input) {
     root: input.workspaceRoot
   });
   if (errors.length > 0) {
+    const warningBlock = warnings.length === 0 ? "" : "\n" + warnings.map((warning) => `${PLAN_GATE_WARNING_PREFIX}${warning}`).join("\n");
     throw new Error(
       `Validation failed for ${input.artifactType} artifact at '${input.artifactPath}':
-${errors.join("\n")}`
+${errors.join("\n")}${warningBlock}`
     );
   }
   return {
     tool: "validate_orchestration_artifacts",
     workspaceRoot: input.workspaceRoot,
-    summary: `Validated ${input.artifactType} artifact at '${input.artifactPath}'.`
+    summary: `Validated ${input.artifactType} artifact at '${input.artifactPath}'.`,
+    ...warnings.length === 0 ? {} : { warnings }
   };
 }
 
@@ -28669,7 +29104,7 @@ function truncate(text, limit = 800) {
   }
   return rstrip3(text.slice(0, limit - 3)) + "...";
 }
-function splitLines2(value) {
+function splitLines3(value) {
   if (value === "") {
     return [];
   }
@@ -28680,7 +29115,7 @@ function splitLines2(value) {
   return lines;
 }
 function truncateLines(text, limit) {
-  const lines = splitLines2(text);
+  const lines = splitLines3(text);
   if (lines.length <= limit) {
     return text;
   }
@@ -29444,7 +29879,7 @@ function convertNumstat(numstatText) {
   let adds = 0;
   let dels = 0;
   const files = [];
-  for (const rawLine of splitLines3(numstatText)) {
+  for (const rawLine of splitLines4(numstatText)) {
     if (!rawLine.trim()) {
       continue;
     }
@@ -29507,7 +29942,7 @@ function summarizeConventionalCommits(subjects) {
   }
   counts.set("other", 0);
   const typePattern = /^(feat|fix|refactor|perf|docs|test|chore|build|ci|style)(\(|!|:)/u;
-  for (const rawLine of splitLines3(subjects)) {
+  for (const rawLine of splitLines4(subjects)) {
     const line = rawLine.trim();
     if (!line) {
       continue;
@@ -29562,7 +29997,7 @@ function buildIssuesToAutocloseSection(params) {
 function extractChangedPaths(contextText) {
   const paths = [];
   let capture = false;
-  for (const line of splitLines3(contextText)) {
+  for (const line of splitLines4(contextText)) {
     if (line.startsWith("===== Changed files")) {
       capture = true;
       continue;
@@ -29608,7 +30043,7 @@ function compareCodePoint2(left, right) {
   }
   return 0;
 }
-function splitLines3(value) {
+function splitLines4(value) {
   if (value === "") {
     return [];
   }
@@ -29678,7 +30113,7 @@ function buildPrContext(options) {
     const subjects = git.log("--pretty=%s", revRange);
     const authors = git.log("--format=%an <%ae>", revRange);
     const authorsList = sortedSet2(
-      splitLines4(authors).map((line) => line.trim()).filter((line) => line)
+      splitLines5(authors).map((line) => line.trim()).filter((line) => line)
     );
     const nameStatus = git.diffRange(["--name-status", mergeBase, headSha]);
     const numstat = git.diffRange(["--numstat", mergeBase, headSha]);
@@ -29686,7 +30121,7 @@ function buildPrContext(options) {
     const stat = git.diffRange(["--stat", mergeBase, headSha]);
     const [additions, deletions, files] = convertNumstat(numstat);
     const extSummary = extensionSummary(files);
-    const mergePrs = extractMergePrNumbers(splitLines4(oneline));
+    const mergePrs = extractMergePrNumbers(splitLines5(oneline));
     const issueCandidates = extractIssueReferences(
       oneline + "\n" + subjects
     ).filter((ref) => !mergePrs.includes(ref));
@@ -29845,7 +30280,7 @@ function compareCodePoint3(left, right) {
   }
   return 0;
 }
-function splitLines4(value) {
+function splitLines5(value) {
   if (value === "") {
     return [];
   }
@@ -29871,7 +30306,7 @@ function parseSection2(markdown, heading) {
 }
 function completedPlanTasks2(markdown, limit = 10) {
   const tasks = [];
-  for (const line of splitLines2(markdown)) {
+  for (const line of splitLines3(markdown)) {
     if (/\[x\]/iu.test(line)) {
       const cleaned = line.replace(/^[-*]\s*\[[xX]\]\s*/u, "").trim();
       tasks.push(cleaned);
@@ -29950,7 +30385,7 @@ function parsePrimaryIssueFromMetadata(params) {
     params.storyText,
     params.issueText
   ]) {
-    for (const line of splitLines2(sourceText)) {
+    for (const line of splitLines3(sourceText)) {
       const match = pattern.exec(line);
       if (match) {
         return match[1];
@@ -30009,11 +30444,15 @@ function escapeRegExp4(value) {
 
 // ../../extensions/drm-copilot/src/lib/pr-context/verification-evidence.ts
 var REQUIRED_FIELDS = ["Timestamp", "Command", "EXIT_CODE"];
+var EXPECTED_EXIT_CODE_FIELD = "ExpectedExitCode";
 var CANONICAL_GLOBS = [
   "evidence/qa-gates/**/*.md",
   "evidence/regression-testing/**/*.md",
   "evidence/other/**/*.md"
 ];
+function normalizeResult(exitCode, expectedExitCode) {
+  return exitCode === expectedExitCode ? "pass" : "fail";
+}
 function discoverCanonicalEvidenceFiles(fs10, root, feature) {
   const normalizedRoot = toPosixPath2(root).replace(/\/+$/u, "");
   const featureRoot = `${normalizedRoot}/docs/features/active/${feature}`;
@@ -30033,7 +30472,7 @@ function discoverCanonicalEvidenceFiles(fs10, root, feature) {
 function parseVerificationEvidenceMarkdown(params) {
   const { feature, sourceFile, markdown } = params;
   const parsed = /* @__PURE__ */ new Map();
-  for (const rawLine of splitLines5(markdown)) {
+  for (const rawLine of splitLines6(markdown)) {
     const colonIndex = rawLine.indexOf(":");
     if (colonIndex === -1) {
       continue;
@@ -30043,10 +30482,14 @@ function parseVerificationEvidenceMarkdown(params) {
     if (REQUIRED_FIELDS.includes(key) && !parsed.has(key)) {
       parsed.set(key, value);
     }
+    if (key === EXPECTED_EXIT_CODE_FIELD && !parsed.has(key)) {
+      parsed.set(key, value);
+    }
   }
   const timestamp = parsed.get("Timestamp") ?? null;
   const command = parsed.get("Command") ?? null;
   const exitCodeRaw = parsed.get("EXIT_CODE");
+  const expectedExitCodeRaw = parsed.get(EXPECTED_EXIT_CODE_FIELD);
   if (!timestamp || !command || exitCodeRaw === void 0) {
     return {
       feature,
@@ -30054,7 +30497,8 @@ function parseVerificationEvidenceMarkdown(params) {
       timestamp,
       command,
       exitCode: null,
-      normalizedResult: "unparseable"
+      normalizedResult: "unparseable",
+      expectedExitCode: 0
     };
   }
   const exitCode = parseIntegerStrict(exitCodeRaw);
@@ -30065,17 +30509,34 @@ function parseVerificationEvidenceMarkdown(params) {
       timestamp,
       command,
       exitCode: null,
-      normalizedResult: "unparseable"
+      normalizedResult: "unparseable",
+      expectedExitCode: 0
     };
   }
-  const normalizedResult = exitCode === 0 ? "pass" : "fail";
+  const expectedExitCode = expectedExitCodeRaw === void 0 ? 0 : parseIntegerStrict(expectedExitCodeRaw);
+  if (expectedExitCode === null) {
+    return {
+      feature,
+      sourceFile,
+      timestamp,
+      command,
+      exitCode: null,
+      normalizedResult: "unparseable",
+      expectedExitCode: 0
+    };
+  }
+  const normalizedResult = normalizeResult(
+    exitCode,
+    expectedExitCode
+  );
   return {
     feature,
     sourceFile,
     timestamp,
     command,
     exitCode,
-    normalizedResult
+    normalizedResult,
+    expectedExitCode
   };
 }
 function parseVerificationEvidenceFile(params) {
@@ -30111,7 +30572,7 @@ function compareCodePoint5(left, right) {
   }
   return 0;
 }
-function splitLines5(value) {
+function splitLines6(value) {
   if (value === "") {
     return [];
   }
@@ -30333,7 +30794,7 @@ function extractDigestBullets(body, headings, limit) {
     if (!sectionText) {
       continue;
     }
-    for (const line of splitLines2(sectionText)) {
+    for (const line of splitLines3(sectionText)) {
       if (!line.trim()) {
         continue;
       }
@@ -30474,7 +30935,7 @@ function parseNumstatDetailed(numstatText) {
   let addsTotal = 0;
   let delsTotal = 0;
   const perFile = /* @__PURE__ */ new Map();
-  for (const rawLine of splitLines2(numstatText)) {
+  for (const rawLine of splitLines3(numstatText)) {
     if (!rawLine.trim()) {
       continue;
     }
@@ -30493,7 +30954,7 @@ function parseNumstatDetailed(numstatText) {
 }
 function parseNameStatusMap(nameStatusText) {
   const mapping = /* @__PURE__ */ new Map();
-  for (const rawLine of splitLines2(nameStatusText)) {
+  for (const rawLine of splitLines3(nameStatusText)) {
     if (!rawLine.trim()) {
       continue;
     }
@@ -30541,7 +31002,7 @@ function scopingDocChanges(options) {
       path11
     ]);
     let headingTouched = false;
-    for (const line of splitLines2(diffText)) {
+    for (const line of splitLines3(diffText)) {
       if (!line.startsWith("+") || line.startsWith("+++")) {
         continue;
       }
@@ -30557,7 +31018,7 @@ function scopingDocChanges(options) {
       material = true;
       reasons.push("key section touched");
     }
-    const addedLines = splitLines2(diffText).filter((line) => line.startsWith("+") && !line.startsWith("+++")).map((line) => line.replace(/^\++/u, "").trim());
+    const addedLines = splitLines3(diffText).filter((line) => line.startsWith("+") && !line.startsWith("+++")).map((line) => line.replace(/^\++/u, "").trim());
     if (addedLines.length > 0 && addedLines.every(
       (line) => !line || line.startsWith("[") || line.startsWith("http")
     )) {
@@ -30957,12 +31418,15 @@ function renderVerificationEvidenceSection(fs10, resolvedRoot, featureDocs) {
     (left, right) => left.sourceFile < right.sourceFile ? -1 : left.sourceFile > right.sourceFile ? 1 : 0
   );
   for (const record2 of sorted) {
+    const expected = record2.expectedExitCode;
+    const expectedRows = expected === 0 ? [] : [`  - Expected EXIT_CODE: ${String(expected)}`];
     lines.push(
       `- Feature: ${record2.feature}`,
       `  - Source: ${record2.sourceFile}`,
       `  - Timestamp: ${record2.timestamp}`,
       `  - Command: ${record2.command}`,
       `  - EXIT_CODE: ${record2.exitCode}`,
+      ...expectedRows,
       `  - Normalized result: ${record2.normalizedResult}`
     );
   }
@@ -31795,12 +32259,13 @@ var CommandRunnerGhAdapter = class {
 };
 function potentialToIssueServiceCall(input) {
   const ghClient = input.gh ?? new RealGhClient({ runner: new CommandRunnerGhAdapter(input.runner) });
+  const fileSystem = input.fileSystem ?? new RealPotentialFileSystem();
   const outcome = promotePotential({
     potentialPath: input.potentialPath,
     promotionType: input.promotionType,
     workMode: input.workMode,
     workspace: input.workspaceRoot,
-    fs: input.fileSystem ?? new RealPotentialFileSystem(),
+    fs: fileSystem,
     gh: ghClient,
     ...input.log === void 0 ? {} : { emit: input.log }
   });
@@ -31811,6 +32276,11 @@ ${outcome.messages.join("\n")}` : "";
   }
   const summary = `Promoted '${input.potentialPath}' as a ${input.promotionType} workflow in ${input.workMode} mode.`;
   const [issueUrl] = parseIssueReference(outcome.messages);
+  if (outcome.destination !== void 0 && !fileSystem.exists(outcome.destination)) {
+    throw new Error(
+      `potential_to_issue reported a path that does not exist: ${outcome.destination}`
+    );
+  }
   return {
     tool: "potential_to_issue",
     workspaceRoot: input.workspaceRoot,
@@ -31997,12 +32467,12 @@ function validateFeatureName2(featureName) {
 function escapeRegExp6(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function splitLines6(text) {
+function splitLines7(text) {
   return text.split(/\r\n|\r|\n/);
 }
 function formatChecklist(text) {
   const lines = [];
-  for (const rawLine of splitLines6(text)) {
+  for (const rawLine of splitLines7(text)) {
     const trimmed = rawLine.trim();
     if (!trimmed) {
       continue;
@@ -32031,7 +32501,7 @@ function getSection2(content, name) {
 function upsertWorkModeMarker(content, mode) {
   const markerLine = `- Work Mode: ${mode}`;
   const markerPattern = /^- Work Mode:\s*(minor-audit|full-feature|full-bug|full)\s*$/;
-  const lines = splitLines6(content).filter((line) => !markerPattern.test(line));
+  const lines = splitLines7(content).filter((line) => !markerPattern.test(line));
   for (let idx = 0; idx < lines.length; idx += 1) {
     const line = lines[idx] ?? "";
     if (line.replace(/^\s+/, "").startsWith("## ")) {
@@ -32723,6 +33193,7 @@ function createActiveFolder(options) {
     filesystem
   );
   const potentialContent = potentialFile ? filesystem.readText(potentialFile) : "";
+  const retainsPotentialSource = potentialFile !== null && isPromotedPotentialSource(potentialFile, workspacePath);
   const selectedWorkMode = normalizeRequestedWorkMode(workMode, featureType);
   const [useMinorAudit, fallbackReason] = shouldUseMinorAuditMode(
     selectedWorkMode,
@@ -32810,7 +33281,11 @@ function createActiveFolder(options) {
   if (useMinorAudit) {
     if (potentialFile) {
       potentialIssuePath = joinPosix13(targetDir, "issue.md");
-      filesystem.move(potentialFile, potentialIssuePath);
+      if (retainsPotentialSource) {
+        filesystem.copyFile(potentialFile, potentialIssuePath);
+      } else {
+        filesystem.move(potentialFile, potentialIssuePath);
+      }
       const movedContent = filesystem.readText(potentialIssuePath);
       filesystem.writeText(
         potentialIssuePath,
@@ -32866,17 +33341,25 @@ function createActiveFolder(options) {
   if (potentialFile) {
     if (useMinorAudit) {
       if (potentialIssuePath !== null) {
-        emit(`Moved potential file to ${potentialIssuePath}`);
+        emit(
+          retainsPotentialSource ? `Copied potential file to ${potentialIssuePath}` : `Moved potential file to ${potentialIssuePath}`
+        );
       }
     } else {
       potentialIssuePath = joinPosix13(targetDir, "issue.md");
-      filesystem.move(potentialFile, potentialIssuePath);
+      if (retainsPotentialSource) {
+        filesystem.copyFile(potentialFile, potentialIssuePath);
+      } else {
+        filesystem.move(potentialFile, potentialIssuePath);
+      }
       const movedContent = filesystem.readText(potentialIssuePath);
       filesystem.writeText(
         potentialIssuePath,
         upsertWorkModeMarker(movedContent, selectedWorkMode)
       );
-      emit(`Moved potential file to ${potentialIssuePath}`);
+      emit(
+        retainsPotentialSource ? `Copied potential file to ${potentialIssuePath}` : `Moved potential file to ${potentialIssuePath}`
+      );
     }
   }
   if (potentialFile) {
@@ -32915,6 +33398,12 @@ function isRelativeTo(child, root) {
   const normalizedRoot = toPosixPath2(root);
   return normalizedChild === normalizedRoot || normalizedChild.startsWith(`${normalizedRoot}/`);
 }
+function isPromotedPotentialSource(potentialPath, workspacePath) {
+  return isRelativeTo(
+    potentialPath,
+    joinPosix13(workspacePath, "docs/features/potential/promoted")
+  );
+}
 function posixBaseName(path11) {
   const normalized = toPosixPath2(path11).replace(/\/+$/, "");
   const slash = normalized.lastIndexOf("/");
@@ -32927,7 +33416,15 @@ function posixStem2(path11) {
 }
 
 // ../../extensions/drm-copilot/src/lib/new-active-feature-folder/new-active-feature-folder-service-call.ts
+function requireReportedPathExists(fileSystem, path11) {
+  if (!fileSystem.exists(path11)) {
+    throw new Error(
+      `new_active_feature_folder reported a path that does not exist: ${path11}`
+    );
+  }
+}
 function newActiveFeatureFolderServiceCall(input) {
+  const fileSystem = input.fileSystem ?? new RealFolderFileSystem();
   const result = createActiveFolder({
     featureName: input.featureName,
     featureType: input.type,
@@ -32935,13 +33432,17 @@ function newActiveFeatureFolderServiceCall(input) {
     workMode: input.workMode,
     workspace: input.workspaceRoot,
     templateRoot: input.templateRoot,
-    fs: input.fileSystem ?? new RealFolderFileSystem(),
+    fs: fileSystem,
     // Route the guarded gh issue fetch through the injected F1 runner.
     issueFetcher: (issueNumber) => defaultIssueFetcher(issueNumber, input.runner),
     // No-op launcher: the MCP/non-interactive path must never open an editor.
     codeLauncher: () => false,
     ...input.log === void 0 ? {} : { emit: input.log }
   });
+  requireReportedPathExists(fileSystem, result.target);
+  if (result.potentialIssuePath !== null) {
+    requireReportedPathExists(fileSystem, result.potentialIssuePath);
+  }
   return {
     tool: "new_active_feature_folder",
     workspaceRoot: input.workspaceRoot,