@danmoisan/drm-copilot-mcp 1.1.12 → 1.1.15

package/resources/claude-customizations/.claude/skills/orchestrate/SKILL.md

@@ -272,7 +272,7 @@ S9 procedure:
 
 1. Resolve the live PR head SHA for the feature branch (`gh pr view --json headRefOid` or equivalent).
 2. Invoke `gh pr checks --required --json bucket,name,state,link,workflow` (or an equivalent JSON-emitting command) against that head SHA. `gh` is the only sanctioned channel for querying GitHub Actions state.
-3. Parse the JSON via `scripts/orchestration/Invoke-CiGateParser.ps1`, which emits the `ci_gate` object defined below and derives `ci_gate.conclusion` as `success` when all required checks pass, `failure` when any required check failed, and `pending` when any required check is still in progress.
+3. Parse the JSON by running `pwsh -NoProfile -File .claude/lib/ci-gate/Invoke-CiGateParser.ps1 -ChecksJson <checks-json> -HeadSha <head-sha>`, which emits the `ci_gate` object defined below and derives `ci_gate.conclusion` as `success` when all required checks pass, `failure` when any required check failed, and `pending` when any required check is still in progress.
 4. Poll with a bounded interval and a documented total timeout while `conclusion == "pending"`. When the timeout is exhausted, set `step9_status: "failed_remediation_required"` and enter the remediation-loop CI-failure handling below with a timeout log.
 5. Write the `ci_gate` object and `last_verified_ci_sha` to the checkpoint, and set `step9_status` to `passed` only when `ci_gate.conclusion == "success"` AND `ci_gate.head_sha` equals the current PR head SHA.
 6. If the checkpoint's `epic_mode` is `true`, execute `gh pr merge --merge <PR>` merging the feature branch into `epic_context.integration_branch` (already the PR's base branch per the epic-mode `--base` override applied at S8). On success, record `epic_merge: { merge_commit_sha, target_branch, merged_at }` in the checkpoint. On failure due to merge conflict (non-mergeable PR), do not retry blindly: convert the conflict into a synthetic Blocking finding per "Merge-Conflict Remediation" below and re-enter the standard R1–R5 remediation loop; do not proceed to DONE.

package/resources/claude-customizations/.claude/skills/parallel-add/SKILL.md

@@ -58,25 +58,38 @@ re-derivation is mandatory and is not an optimization to skip when the checkpoin
    advances `proposed` -> `admitted` -> `prepared` during this step, recorded as item-state updates in
    `items[]` with the checkpoint's lifecycle timestamps.
 
-3. **Compute conflict edges over ALL items, including in-flight ones.** Invoke the contention
-   relation `Test-BlastRadiusConflict` from the destination-runtime PowerShell port
+3. **Compute conflict edges over ALL items, including in-flight ones.** Invoke the scheduling
+   entry point Get-BlastRadiusConflictEdge from the destination-runtime PowerShell port
    `.claude/lib/blast-radius/BlastRadius.psm1`, which is published by push-down and needs no Python
    interpreter (the default PowerShell 5.1 execution policy blocks `Import-Module` of a `.psm1`
    file, so `pwsh` is mandatory: run as `$repoRoot = git rev-parse --show-toplevel; Import-Module
    (Join-Path $repoRoot '.claude/lib/blast-radius/BlastRadius.psm1') -Force -ErrorAction Stop`).
-   Its two radius arguments are the two items' radius hashtables, not strings, and the third
-   argument is the required parsed `config/blast-radius.json` mapping, which push-down publishes
-   into the destination workspace. That mapping's optional `mergeable_paths` list is read by
-   `Test-BlastRadiusConflict`, which contributes no `path_overlap` edge for a path matching it
-   while the path stays in the declared radius. `conflicts(a, b, config)` in
+   Call it once, as `Get-BlastRadiusConflictEdge -Item <items> -Config <config> -Relation ${function:Test-BlastRadiusConflict}`, where each item
+   record carries `key` (the `items[].issue_num` value), `radius` (the item's radius hashtable, not
+   a string), and the optional complexity `band`, and `-Config` is the required parsed
+   `config/blast-radius.json` mapping, which push-down publishes into the destination workspace.
+   The -Relation argument is required and carries the facade's detection relation; an omitted
+   relation fails fast. The entry point applies the contention relation `Test-BlastRadiusConflict` to every unordered
+   pair and then the integration-cost edge rule of `.claude/rules/parallel-orchestration.md`
+   (hard classes, integer cost, pairwise benefit, and the configured `conflict_tolerance`); the
+   relation still reads the mapping's optional `mergeable_paths` list and contributes no
+   `path_overlap` edge for a path matching it while the path stays in the declared radius.
+   `schedule_conflict_edges(items, config)` and `conflicts(a, b, config)` in
    `scripts/dev_tools/compute_blast_radius.py` (defined in
-   `scripts/dev_tools/_blast_radius_conflicts.py`) remains the repository authority and the parity
-   reference. Read the verdict from `$result['conflict']`; do not test the returned hashtable
-   itself, since it is always truthy under PowerShell boolean coercion, so a bare `if ($result)`
-   check treats every pair as conflicting. Map each conflicting pair onto an `(int, int)` conflict
-   edge of `items[].issue_num` values, normalized so `a < b`. Do not reimplement the relation and do not
-   compute edges over the unstarted subset only: an in-flight conflict is precisely what the
-   admission decision turns on.
+   `scripts/dev_tools/_blast_radius_scheduling.py` and `scripts/dev_tools/_blast_radius_conflicts.py`)
+   remain the repository authority and the parity reference. The call returns a hashtable with
+   `edges` (records `a`, `b`, `reason`, `hard`, `cost`, `benefit`, already normalized so `a < b`)
+   and `tolerated_overlaps` (records `a`, `b`, `reasons`, `cost`, `benefit`). Take each returned
+   edge as an `(int, int)` conflict edge of `items[].issue_num` values, and record the returned
+   tolerated overlaps in the checkpoint's tolerated_overlaps list. When `Test-BlastRadiusConflict`
+   is called directly for a single pair, read the verdict from `$result['conflict']`; do not test
+   the returned hashtable itself, since it is always truthy under PowerShell boolean coercion, so a
+   bare `if ($result)` check treats every pair as conflicting. Do not reimplement the relation or
+   the edge rule, do not apply the relation to each pair by hand, and do not compute edges over the
+   unstarted subset only: an in-flight conflict is precisely what the admission decision turns on.
+   A tolerated overlap is not an edge: the two items run in the same or adjacent cohorts without a
+   barrier, and the later-merging item merges `origin/main` under the existing per-item
+   merge-conflict handling and re-passes CI before it merges.
 
 4. **Decide admission.** Call
    `decide_admission(candidate, conflict_edges, in_flight, current_cohort_members=current_cohort_members)`
@@ -150,9 +163,11 @@ re-derivation is mandatory and is not an optimization to skip when the checkpoin
 
 - One admission per invocation, one `mutations[]` entry per successful admission. A failed
   preparation appends no entry and leaves `items[]` without the candidate.
-- No field and no enum member is added to `mutations[]`, `conflict_edges[]`, `items[]`, or any
-  state or merge-status enum. The nine parallel enums are owned by
-  `.claude/rules/parallel-orchestration.md` and are consumed, never extended.
+- No field and no enum member is added to `mutations[]`, `items[]`, or any state or merge-status
+  enum. A `conflict_edges[]` entry may carry only the three tolerated extra fields `hard`, `cost`,
+  and `benefit` (tolerated-not-validated, returned by the scheduling entry point), and no reason
+  member is added: the four `conflict_edges[].reason` members are unchanged. The nine parallel
+  enums are owned by `.claude/rules/parallel-orchestration.md` and are consumed, never extended.
 - This operation never moves, restates, or re-derives an in-flight item's cohort or state.
 - This operation performs no destructive side effect: it closes no pull request and removes no
   worktree. Those belong to `/parallel-remove` with `--disposition abandon`.

package/resources/claude-customizations/.claude/skills/parallel-plan/SKILL.md

@@ -312,16 +312,25 @@ The library returns the partition; the planner supplies the record fields.
 ### Seeding procedure
 
 1. Invoke `compute-cohorts.sh` exactly once per plan run, over the full conflict graph, after every
-   item is `prepared` and radius-validated. Derive the conflict edge set by applying
-   `Test-BlastRadiusConflict` to every unordered pair of `declared` radii, then pass the pairs as
+   item is `prepared` and radius-validated. Derive the conflict edge set with one call to the
+   scheduling entry point over every item's `declared` radius and complexity band: Get-BlastRadiusConflictEdge
+   (`Get-BlastRadiusConflictEdge -Item <records carrying key, radius, band> -Config <parsed truth table> -Relation ${function:Test-BlastRadiusConflict}`)
+   in PowerShell, or `schedule_conflict_edges(items, config)` (re-exported from
+   `compute_blast_radius.py`, taking `SchedulingItem` records) in Python. Do not apply the
+   detection relation to each pair by hand: the entry point applies it to every unordered pair and
+   then applies the integration-cost edge rule of `.claude/rules/parallel-orchestration.md`
+   (hard classes, integer cost, pairwise benefit, and the configured `conflict_tolerance`). It
+   returns `edges` and `tolerated_overlaps`. The -Relation argument is required; pass the facade's
+   Test-BlastRadiusConflict function object as shown. Pass the returned `edges` pairs as
    `--edges "<a>:<b> ..."` and the item keys as `--keys "<k1> <k2> ..."`.
-   Read the verdict from the conflict key of the returned hashtable.
-   `Test-BlastRadiusConflict` contributes no `path_overlap` edge for a path matching the truth
-   table's optional `mergeable_paths` list, and the path stays in the declared radius.
-   The hashtable itself is always truthy, so a bare boolean test on the result treats every pair as
-   conflicting and serializes the whole run. This is the sibling hazard to the `@(...)` warning
-   above for `Test-BlastRadius`: that function writes an `IList`-shaped pipeline result whose
-   emptiness is falsy, while this one returns a hashtable whose emptiness is not expressible at all.
+   The detection relation inside the entry point contributes no `path_overlap` edge for a path
+   matching the truth table's optional `mergeable_paths` list, and the path stays in the declared
+   radius. When `Test-BlastRadiusConflict` is called directly (for example, while investigating a
+   single pair), read the verdict from the conflict key of the returned hashtable: the hashtable
+   itself is always truthy, so a bare boolean test on the result treats every pair as conflicting.
+   This is the sibling hazard to the `@(...)` warning above for `Test-BlastRadius`: that function
+   writes an `IList`-shaped pipeline result whose emptiness is falsy, while this one returns a
+   hashtable whose emptiness is not expressible at all.
 2. Immediately after the conflict-edge set is derived and before anything consumes it, run the
    lane-assertion diagnostic:
    `bash .claude/lib/bash/report-lane-assertion.sh --manifest docs/features/parallel/<slug>/parallel.md --edges "<a>:<b> ..."`
@@ -341,7 +350,16 @@ The library returns the partition; the planner supplies the record fields.
    Recording the diagnostic's result in the planner checkpoint is a tolerated extra field, not a
    validated one; no validator changes for it.
 3. Record `cohorts[]` at `generation: 0`, each cohort's `item_keys[]` sorted ascending.
-4. Record `conflict_edges[]` as `{a, b, reason}` entries for auditability.
+4. Record `conflict_edges[]` as `{a, b, reason}` entries for auditability; each entry may also carry
+   the tolerated extra fields `hard`, `cost`, and `benefit` returned by the entry point. Record the
+   returned tolerated overlaps in a `tolerated_overlaps` list on the planner checkpoint, one
+   `{a, b, reasons, cost, benefit}` entry per detected, non-hard pair within tolerance. No reason
+   member is added and no validator reads these fields.
+   **Soft-overlap merge rule.** A tolerated pair is not an edge: its two items run in the same or
+   adjacent cohorts without a barrier. The later-merging item of a tolerated pair merges
+   `origin/main` under the existing per-item merge-conflict handling and re-passes CI before it
+   merges. This is the operator-directed configured policy of issue #722; it never licenses
+   hand-narrowing a radius.
 5. Record `recolor_generation: 0` and `current_cohort: 0`.
 6. Record `max_concurrency` — default 4, bounded 1 through 32 by the F3 schema — without enforcing
    it. Enforcement is F5's, through
@@ -570,6 +588,17 @@ content-widening options, and any operand that resolves outside the five exempt
 exempt operand with one production operand denies the whole invocation. Name each exempt path
 explicitly; the exemption is allow-side only and every parse ambiguity denies.
 
+#### Attribution trailers (issue #713)
+
+With no ready feature checkpoint, the exemption admits two attribution-trailer forms on a pathspec-bearing `git commit`, each followed by the double-dash separator and the exempt path operands:
+
+- The trailer option: `git commit -m 'docs: plan' --trailer 'Co-Authored-By: Name <email>' --trailer 'Claude-Session: <url>' -- <exempt paths>`. The separate-value form and the `--trailer=<value>` form are both admitted, any number of times, on `git commit` only; `git add --trailer` and a trailer option with no value are denied. Git writes every trailer value into one trailer block.
+- The one-paragraph multi-message form: the subject in the first `-m` and every trailer in one single-quoted second `-m` value, separated by a literal newline. Each `-m` value becomes its own paragraph and git parses only the last paragraph as the trailer block, so trailers split across separate `-m` values do not form one trailer block.
+
+Quoting rules: `$` and backtick are literal and admitted inside single quotes, and denied outside quotes and inside double quotes, where the shell expands them. `<` and `>` are admitted inside single or double quotes and denied outside quotes. An unquoted `#` is denied anywhere, because it starts a shell comment that the exemption does not model; a `#` inside quotes is admitted. A typographic quote character (U+2018 to U+201E) anywhere in the command line is denied, because a PowerShell host reads it as a quote.
+
+Not admitted: heredoc-fed messages, including `git commit -m "$(cat <<'EOF' ... EOF)"` and `git commit -F - <<'EOF'`, and message files supplied through `-F <file>` or `--file=<file>`. Use one of the two forms above instead.
+
 ## Completion Report
 
 The final report to the operator must include:

package/resources/claude-customizations/config/blast-radius.json

@@ -20,7 +20,8 @@
     ".claude/skills/policy-compliance-order/SKILL.md",
     ".claude/agent-memory/**",
     ".agents/skills/**",
-    "scripts/vscode/**"
+    "scripts/vscode/**",
+    ".github/copilot-instructions.md"
   ],
   "mergeable_paths": [
     "**/*.csproj",
@@ -29,6 +30,18 @@
     "**/*.vbproj",
     "**/*.props"
   ],
+  "conflict_tolerance": {
+    "tolerance_percent": 100,
+    "weights": { "same_file": 8, "possible_overlap": 2, "append_only": 1, "module": 2 },
+    "band_durations": { "C1": 1, "C2": 2, "C3": 4, "C4": 8 },
+    "default_band": "C1",
+    "append_only_paths": [
+      "**/CHANGELOG.md",
+      "extensions/drm-copilot/resources/claude-customizations/pack-manifests/core.json"
+    ]
+  },
+  "write_intent_extraction": true,
+  "path_roots": [],
   "modules": {
     "config": ["config/**"]
   },

package/resources/claude-customizations/pack-manifests/core.json

@@ -74,6 +74,16 @@
     ".claude/skills/acceptance-criteria-tracking/SKILL.md",
     ".claude/skills/atomic-plan-contract/SKILL.md",
     ".claude/skills/cleanup-merged-worktrees/SKILL.md",
+    ".claude/skills/cleanup-merged-worktrees/scripts/cleanup-worktrees.sh",
+    ".claude/skills/cleanup-merged-worktrees/scripts/cleanup_worktrees_actions_lib.sh",
+    ".claude/skills/cleanup-merged-worktrees/scripts/cleanup_worktrees_detached_lib.sh",
+    ".claude/skills/cleanup-merged-worktrees/scripts/cleanup_worktrees_dirt_lib.sh",
+    ".claude/skills/cleanup-merged-worktrees/scripts/cleanup_worktrees_enumerate_lib.sh",
+    ".claude/skills/cleanup-merged-worktrees/scripts/cleanup_worktrees_lib.sh",
+    ".claude/skills/cleanup-merged-worktrees/scripts/cleanup_worktrees_preserve_eol_lib.sh",
+    ".claude/skills/cleanup-merged-worktrees/scripts/cleanup_worktrees_preserve_lib.sh",
+    ".claude/skills/cleanup-merged-worktrees/scripts/cleanup_worktrees_report_records_lib.sh",
+    ".claude/skills/cleanup-merged-worktrees/scripts/cleanup_worktrees_scan_helper.sh",
     ".claude/skills/commit-message/SKILL.md",
     ".claude/skills/discovery-behavior-reconciliation/SKILL.md",
     ".claude/skills/discovery-coverage-ledger/SKILL.md",
@@ -142,9 +152,12 @@
     ".claude/lib/blast-radius/BlastRadiusTokenShape.psm1",
     ".claude/lib/cleanup-manifest/CleanupWorktreeManifest.psm1",
     ".claude/lib/blast-radius/BlastRadiusConflict.psm1",
+    ".claude/lib/blast-radius/BlastRadiusScheduling.psm1",
+    ".claude/lib/blast-radius/BlastRadiusWriteIntent.psm1",
     ".claude/lib/project-file-merge/ProjectFileMergeGrammar.psm1",
     ".claude/lib/project-file-merge/ProjectFileMerge.psm1",
     ".claude/lib/project-file-merge/Resolve-MergeableConflict.ps1",
+    ".claude/lib/ci-gate/Invoke-CiGateParser.ps1",
     ".claude/rules/parallel-orchestration.md",
     ".claude/rules/shell.md",
     ".claude/lib/bash/compute-cohorts.sh",

package/resources/codex-and-agents-customizations/.codex/config.toml

@@ -2,7 +2,7 @@ default_permissions = ":danger-full-access"
 
 [mcp_servers.drm-copilot]
 command = "npx"
-args = ["-y", "@danmoisan/drm-copilot-mcp@1.1.12"]
+args = ["-y", "@danmoisan/drm-copilot-mcp@1.1.15"]
 required = true
 enabled_tools = [
     "collect_commit_context",