@danmoisan/drm-copilot-mcp 1.1.3 → 1.1.5

package/out/mcp-server.js

@@ -2671,18 +2671,18 @@ var require_validate = __commonJS({
         const { schemaCode } = this;
         this.fail((0, codegen_1._)`${schemaCode} !== undefined && (${(0, codegen_1.or)(this.invalid$data(), condition)})`);
       }
-      error(append, errorParams, errorPaths) {
+      error(append2, errorParams, errorPaths) {
         if (errorParams) {
           this.setParams(errorParams);
-          this._error(append, errorPaths);
+          this._error(append2, errorPaths);
           this.setParams({});
           return;
         }
-        this._error(append, errorPaths);
+        this._error(append2, errorPaths);
       }
-      _error(append, errorPaths) {
+      _error(append2, errorPaths) {
         ;
-        (append ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths);
+        (append2 ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths);
       }
       $dataError() {
         (0, errors_1.reportError)(this, this.def.$dataError || errors_1.keyword$DataError);
@@ -23551,6 +23551,7 @@ var GENERATED_AGENT_FAMILIES = /* @__PURE__ */ new Set([
   "atomic-planner",
   "atomic-executor",
   "feature-reviewer",
+  "commit-steward",
   "task-researcher",
   "prd-feature",
   "pr-author",
@@ -26957,7 +26958,14 @@ function classifyKind(argv) {
   return "other";
 }
 function splitLines2(text) {
-  return text.split(/\r\n|\n|\r/);
+  if (text === "") {
+    return [];
+  }
+  const lines = text.split(/\r\n|\n|\r/);
+  if (lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  return lines;
 }
 function inlineSpans(line) {
   const spans = [];
@@ -26979,34 +26987,63 @@ function appendCommand(commands, taskId, sourceLine, rawSpan) {
     sourceLine,
     rawSpan,
     argv,
-    kind: classifyKind(argv)
+    kind: classifyKind(argv),
+    taskText: ""
   });
 }
+function closeWindow(commands, windowStart, windowLines) {
+  if (windowStart >= commands.length) {
+    return;
+  }
+  const taskText = windowLines.join("\n");
+  for (let index = windowStart; index < commands.length; index += 1) {
+    const record2 = commands[index];
+    if (record2 === void 0) {
+      continue;
+    }
+    commands[index] = { ...record2, taskText };
+  }
+}
 function extractPlanCommands(text) {
   const commands = [];
   let currentTask = null;
   let inFence = false;
+  let windowLines = [];
+  let windowStart = 0;
   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;
+      if (currentTask !== null) {
+        windowLines.push(line);
+      }
       continue;
     }
     if (inFence) {
+      if (currentTask === null) {
+        continue;
+      }
+      windowLines.push(line);
       const fenced = line.trim();
-      if (currentTask !== null && fenced !== "") {
+      if (fenced !== "") {
         appendCommand(commands, currentTask, lineNumber, fenced);
       }
       continue;
     }
     if (PLAN_GATE_HEADING_PATTERN.test(line)) {
+      closeWindow(commands, windowStart, windowLines);
+      windowStart = commands.length;
+      windowLines = [];
       currentTask = null;
       continue;
     }
     const taskMatch = PLAN_GATE_TASK_PATTERN.exec(line);
     if (taskMatch !== null) {
+      closeWindow(commands, windowStart, windowLines);
+      windowStart = commands.length;
+      windowLines = [];
       const phase = taskMatch.groups?.["phase"] ?? "";
       const task = taskMatch.groups?.["task"] ?? "";
       currentTask = `P${phase}-T${task}`;
@@ -27014,10 +27051,12 @@ function extractPlanCommands(text) {
     if (currentTask === null) {
       continue;
     }
+    windowLines.push(line);
     for (const span of inlineSpans(line)) {
       appendCommand(commands, currentTask, lineNumber, span);
     }
   }
+  closeWindow(commands, windowStart, windowLines);
   return commands;
 }
 
@@ -27167,6 +27206,242 @@ function hasCrossLinePresence(context, literal2) {
   return false;
 }
 
+// ../../extensions/drm-copilot/src/lib/validate/plan-gate-observability.ts
+var G7_SEVERITY = "warning";
+var G8_SEVERITY = "warning";
+var G8B_SEVERITY = "warning";
+var G9_SEVERITY = "warning";
+var WRITE_MODE_REGISTER = [
+  {
+    name: "black-write",
+    shapes: [{ words: ["black"] }],
+    excludes: ["--check", "--diff"],
+    markers: ["reformatted", "left unchanged", "unchanged"]
+  },
+  {
+    name: "ruff-fix",
+    shapes: [{ words: ["ruff", "check"] }],
+    excludes: ["--no-fix"],
+    markers: ["Fixed", "All checks passed", "fixes applied"]
+  },
+  {
+    name: "prettier-write",
+    shapes: [
+      { words: ["prettier"], requires: ["--write"] },
+      { words: ["npm", "run", "format"] }
+    ],
+    excludes: [],
+    markers: ["(unchanged)", "unchanged", "rewrote"]
+  },
+  {
+    name: "poshqc-format",
+    shapes: [{ suffix: "run_poshqc_format" }],
+    excludes: [],
+    markers: ["formatted", "unchanged"]
+  },
+  {
+    name: "poshqc-analyze-autofix",
+    shapes: [{ suffix: "run_poshqc_analyze_autofix" }],
+    excludes: [],
+    markers: ["autofix", "Fixed", "unchanged"]
+  },
+  {
+    name: "poshqc-suite",
+    shapes: [{ suffix: "run_poshqc_suite" }],
+    excludes: [],
+    markers: ["formatted", "unchanged"]
+  }
+];
+var EXECUTABLE_SCAN_LIMIT2 = 4;
+var PATHSPEC_SEPARATOR = "--";
+var INDEX_FLAGS = ["--cached", "--staged"];
+var NAME_LISTING_FLAGS = ["--name-only", "--name-status"];
+var GIT_DIFF_SPAN = "git diff";
+var GIT_STATUS_SPAN = "git status";
+var GIT_ADD_SPAN = "git add";
+var GIT_PORCELAIN_SPAN = "git status --porcelain";
+var PROJECT_CONFIG_PATH = "pyproject.toml";
+var TERMINAL_REPORTER_PREFIX = "--cov-report=term";
+var FAIL_UNDER_PREFIX = "--cov-fail-under";
+var ADDOPTS_PATTERNS = [
+  /addopts[ \t]*=[ \t]*"([^"]*)"/,
+  /addopts[ \t]*=[ \t]*'([^']*)'/
+];
+function append(report, severity, finding) {
+  const channel = severity === BLOCKING_CHANNEL ? report.blocking : report.warnings;
+  channel.push(finding);
+}
+function executablePositions(argv) {
+  const limit = Math.min(argv.length, EXECUTABLE_SCAN_LIMIT2);
+  const positions = [];
+  for (let index = 0; index < limit; index += 1) {
+    if (index === 0 || !(argv[index - 1] ?? "").startsWith("-")) {
+      positions.push(index);
+    }
+  }
+  return positions;
+}
+function shapeMatches(argv, shape) {
+  const requires = shape.requires ?? [];
+  if (requires.some((required2) => !argv.includes(required2))) {
+    return false;
+  }
+  const words2 = shape.words ?? [];
+  for (const index of executablePositions(argv)) {
+    if (shape.suffix !== void 0 && shape.suffix !== "") {
+      if ((argv[index] ?? "").endsWith(shape.suffix)) {
+        return true;
+      }
+      continue;
+    }
+    const end = index + words2.length;
+    if (end <= argv.length && words2.every((word, offset) => argv[index + offset] === word)) {
+      return true;
+    }
+  }
+  return false;
+}
+function matchingEntry(argv) {
+  for (const entry of WRITE_MODE_REGISTER) {
+    if (entry.excludes.some((excluded) => argv.includes(excluded))) {
+      continue;
+    }
+    if (entry.shapes.some((shape) => shapeMatches(argv, shape))) {
+      return entry;
+    }
+  }
+  return null;
+}
+function taskTextWithoutSpan(command) {
+  return command.taskText.replace(command.rawSpan, " ");
+}
+function evaluateWriteMode(report, command) {
+  const entry = matchingEntry(command.argv);
+  if (entry === null) {
+    return;
+  }
+  const remainder = taskTextWithoutSpan(command);
+  if (entry.markers.some((marker) => remainder.includes(marker))) {
+    return;
+  }
+  append(
+    report,
+    G7_SEVERITY,
+    `[${command.taskId}] write-mode command \`${command.rawSpan}\` rewrites tracked source and exits 0 after rewriting; the attributed task text carries none of its observation markers. Record an observation beyond the exit code.`
+  );
+}
+function gitDiffIndex(argv) {
+  const limit = Math.min(argv.length, EXECUTABLE_SCAN_LIMIT2);
+  for (let index = 0; index < limit; index += 1) {
+    if (argv[index] === "git" && argv[index + 1] === "diff") {
+      return index + 1;
+    }
+  }
+  return null;
+}
+function diffOperands(argv, diffIndex) {
+  const operands = [];
+  for (const word of argv.slice(diffIndex + 1)) {
+    if (word === PATHSPEC_SEPARATOR) {
+      break;
+    }
+    operands.push(word);
+  }
+  return operands;
+}
+function carriesPairingCompanion(command) {
+  const remainder = taskTextWithoutSpan(command);
+  return remainder.includes(GIT_DIFF_SPAN) || remainder.includes(GIT_STATUS_SPAN);
+}
+function carriesListingCompanion(command) {
+  const remainder = taskTextWithoutSpan(command);
+  return remainder.includes(GIT_ADD_SPAN) || remainder.includes(GIT_PORCELAIN_SPAN);
+}
+function evaluateGitDiff(report, command) {
+  const argv = command.argv;
+  const diffIndex = gitDiffIndex(argv);
+  if (diffIndex === null) {
+    return;
+  }
+  const operands = diffOperands(argv, diffIndex);
+  const hasRefOperand = operands.some((word) => !word.startsWith("-"));
+  const hasIndexFlag = INDEX_FLAGS.some((flag) => argv.includes(flag));
+  if (!hasRefOperand && !hasIndexFlag) {
+    if (!carriesPairingCompanion(command)) {
+      append(
+        report,
+        G8_SEVERITY,
+        `[${command.taskId}] git diff span \`${command.rawSpan}\` carries no ref operand and no --cached flag; it compares the worktree against the index and passes vacuously once the change is committed. Anchor the diff to a ref.`
+      );
+    }
+    return;
+  }
+  if (hasRefOperand && NAME_LISTING_FLAGS.some((flag) => argv.includes(flag))) {
+    if (!carriesListingCompanion(command)) {
+      append(
+        report,
+        G8B_SEVERITY,
+        `[${command.taskId}] name-listing diff \`${command.rawSpan}\` never reports an untracked file, and the attributed task text carries neither a staging span nor a porcelain-status span; a path the plan creates is invisible to it. Add a staging or porcelain-status companion.`
+      );
+    }
+  }
+}
+function projectAddopts(context) {
+  const text = context.git.readTrackedText(PROJECT_CONFIG_PATH);
+  if (text === "") {
+    return null;
+  }
+  for (const pattern of ADDOPTS_PATTERNS) {
+    const match = pattern.exec(text);
+    if (match !== null) {
+      return match[1] ?? "";
+    }
+  }
+  return "";
+}
+function collectCoverageReporter(pending, command, addopts) {
+  const argv = command.argv;
+  if (!argv.some((word) => isCovFlagToken(word))) {
+    return;
+  }
+  if (argv.some((word) => word.startsWith(TERMINAL_REPORTER_PREFIX))) {
+    return;
+  }
+  if (argv.some((word) => word.startsWith(FAIL_UNDER_PREFIX))) {
+    return;
+  }
+  if (addopts.includes(TERMINAL_REPORTER_PREFIX)) {
+    return;
+  }
+  pending.push(
+    `[${command.taskId}] coverage command \`${command.rawSpan}\` supplies no terminal reporter and the project addopts supplies none either, so no coverage table is printed. Add --cov-report=term-missing.`
+  );
+}
+function evaluateObservabilityGates(report, commands, context) {
+  for (const command of commands) {
+    evaluateWriteMode(report, command);
+    evaluateGitDiff(report, command);
+  }
+  if (context === void 0) {
+    return;
+  }
+  const pending = [];
+  try {
+    const addopts = projectAddopts(context);
+    if (addopts === null) {
+      return;
+    }
+    for (const command of commands) {
+      collectCoverageReporter(pending, command, addopts);
+    }
+  } catch {
+    return;
+  }
+  for (const finding of pending) {
+    append(report, G9_SEVERITY, finding);
+  }
+}
+
 // ../../extensions/drm-copilot/src/lib/validate/plan-gate-discrimination.ts
 var G5_SEVERITY = "warning";
 var CommandRunnerPlanGateRepository = class {
@@ -27262,6 +27537,7 @@ function evaluatePlanGates(text, context) {
       evaluateCovValue(report, command, cov, context);
     }
   }
+  evaluateObservabilityGates(report, commands, context);
   if (context !== void 0) {
     evaluateLiteralRules(report, text, commands, context);
   }
@@ -31555,12 +31831,12 @@ function buildAppendixText(collected, clock) {
   }
   return appendixText;
 }
-function writeOutput(fs10, text, outPath, append) {
+function writeOutput(fs10, text, outPath, append2) {
   const parent = parentDir(outPath);
   if (parent) {
     fs10.ensureDir(parent);
   }
-  if (append && fs10.isFile(outPath)) {
+  if (append2 && fs10.isFile(outPath)) {
     const existing = fs10.readTextFile(outPath);
     fs10.writeTextFile(outPath, existing + text);
   } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danmoisan/drm-copilot-mcp",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Stdio MCP server exposing drm-copilot repo-automation tools.",
   "license": "MIT",
   "type": "commonjs",

package/resources/claude-customizations/.claude/agents/epic-orchestrator.md

@@ -19,10 +19,7 @@ tools:
 skills:
   - policy-compliance-order
   - epic-orchestrate
-  - feature-promotion-lifecycle
-  - atomic-plan-contract
   - acceptance-criteria-tracking
-  - evidence-and-timestamp-conventions
 memory: project
 hooks:
   SubagentStop:
@@ -54,15 +51,13 @@ maintenance. This agent frames the *who* and *when*; the skill documents the *ho
 
 On every invocation:
 
-1. Read `CLAUDE.md` for repository tone policy and architecture context.
-2. Read applicable `.claude/rules/` files for languages in scope.
-3. Read `artifacts/orchestration/epic-orchestrator-state.json` to check for existing epic
+1. Read `artifacts/orchestration/epic-orchestrator-state.json` to check for existing epic
    checkpoint state.
-4. If a valid epic checkpoint exists with a matching `epic_feature_folder`, resume from the
+2. If a valid epic checkpoint exists with a matching `epic_feature_folder`, resume from the
    recorded `next_step` (re-deriving durable ground truth via `git worktree list --porcelain`,
    `git branch`, and `gh pr view --json state,mergedAt,headRefOid` per the `epic-orchestrate`
    skill's resume procedure, not from in-memory notifications alone).
-5. If no checkpoint exists or the objective is new, begin from manifest parsing
+3. If no checkpoint exists or the objective is new, begin from manifest parsing
    (`docs/features/epics/<epic-slug>/epic.md`).
 
 ## Invocation Origin
@@ -104,7 +99,8 @@ You delegate exclusively through two channels:
 
 - `Agent(orchestrator)` — one delegation per child feature in the manifest, carrying the epic-mode
   kickoff line and, for dependent features, the upstream-context citation lines (both defined in
-  `spec.md` §4 and §10 of this feature and restated procedurally in the `epic-orchestrate` skill).
+  `.claude/skills/epic-orchestrate/SKILL.md` under `## Merge-on-Green Kickoff Parameter` and
+  `## Context Handoff to Dependent Features`).
   Each child `orchestrator` runs its own full small/large route (including its own delegation to
   `atomic-planner`, `atomic-executor`, `feature-review`, and, on CI-green in epic mode, the
   merge-on-green S9 step 6 extension) inside its own isolated worktree
@@ -133,7 +129,9 @@ at your own `SubagentStop` time.
 ## Checkpoint Persistence
 
 Update `artifacts/orchestration/epic-orchestrator-state.json` after every completed step, per the
-full schema defined in `spec.md` §6: `objective`, `route_id: "epic"`, `epic_feature_folder`,
+full schema enforced by `validate_epic_orchestrator_state_text`, implemented in
+`scripts/dev_tools/validate_epic_orchestrator_state.py`: `objective`, `route_id: "epic"`,
+`epic_feature_folder`,
 `epic_manifest_path`, `epic_status_doc_path`, `integration_branch`, `completed_steps`, `next_step`,
 `last_updated`, `current_wave`, `waves[]`, `features[]` (including `merge_status` and the four
 lifecycle timestamps), `epic_merge_pr`, and the three receipt arrays