@danmoisan/drm-copilot-mcp 1.0.22 → 1.0.23

package/resources/claude-customizations/.claude/lib/bash/validate-parallel-manifest.sh

@@ -0,0 +1,134 @@
+#!/usr/bin/env bash
+# validate-parallel-manifest.sh: destination-portable command-line entry point
+# for parallel-run manifest validation and the two default-resolving accessors.
+# It exists so a workspace that received the Claude customization payload can
+# validate a manifest with nothing but bash -- no Python, no Poetry, no yq, and
+# no repository checkout.
+#
+# Usage:
+#   bash .claude/lib/bash/validate-parallel-manifest.sh <manifest-path>
+#   bash .claude/lib/bash/validate-parallel-manifest.sh --print-mode <manifest-path>
+#   bash .claude/lib/bash/validate-parallel-manifest.sh --print-max-concurrency <manifest-path>
+#
+# Output contract:
+#   stdout  validation errors one per line (empty for a valid manifest), or the
+#           resolved accessor value under --print-mode / --print-max-concurrency
+#   exit 0  the manifest is valid, or the accessor resolved
+#   exit 1  the manifest is invalid
+#   exit 2  usage error, unreadable manifest, or a YAML construct outside the
+#           supported subset
+#
+# The accessors resolve the documented defaults -- `closed` and `4` -- when the
+# manifest omits the key or carries a malformed value, matching
+# manifest_mode and manifest_max_concurrency in the Python authority.
+set -euo pipefail
+
+# Resolve this script's own directory so the library sources regardless of cwd.
+VM_SCRIPT_DIR=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=.claude/lib/bash/parallel-manifest-validate.sh
+# shellcheck disable=SC1091
+source "$VM_SCRIPT_DIR/parallel-manifest-validate.sh"
+
+pc_enforce_c_locale
+
+vm_usage() {
+	# Print the entry point's usage text.
+	cat <<'EOF'
+Usage: validate-parallel-manifest.sh [--print-mode | --print-max-concurrency] <manifest-path>
+
+Validates a parallel-run manifest against invariants M1 through M7 and prints
+one error per line on stdout; a valid manifest prints nothing and exits 0.
+
+Options:
+  --print-mode              Print the resolved run mode (default: closed).
+  --print-max-concurrency   Print the resolved fan-out cap (default: 4).
+EOF
+}
+
+vm_require_readable() {
+	# Return 0 when the manifest path names a readable file.
+	#
+	# Args: $1 = manifest path. A missing manifest is an operator error rather
+	# than a validation verdict, so the caller exits 2 instead of reporting it
+	# as a manifest defect.
+	local path="$1"
+	if [[ ! -f $path || ! -r $path ]]; then
+		printf 'validate-parallel-manifest.sh: manifest not found or not readable: %s\n' "$path" >&2
+		return 1
+	fi
+	return 0
+}
+
+vm_report_subset_refusal() {
+	# Print the out-of-subset refusal and exit 2.
+	#
+	# Refusing to answer is deliberate: a guessed parse could disagree with the
+	# Python authority silently, whereas an explicit refusal is visible.
+	printf 'validate-parallel-manifest.sh: manifest uses a YAML construct outside the supported subset: %s\n' \
+		"$PM_SUBSET_DETAIL" >&2
+	exit 2
+}
+
+vm_main() {
+	# Dispatch on the optional accessor flag and run the requested operation.
+	local mode="validate" path="" status=0 text
+	# Routing table: the two accessor flags each consume the following path
+	# argument; anything else is treated as the manifest path itself.
+	case "${1-}" in
+	--print-mode)
+		mode="print-mode"
+		path="${2-}"
+		;;
+	--print-max-concurrency)
+		mode="print-max-concurrency"
+		path="${2-}"
+		;;
+	--help | -h)
+		vm_usage
+		return 0
+		;;
+	-*)
+		vm_usage >&2
+		return 2
+		;;
+	*)
+		path="${1-}"
+		;;
+	esac
+	[[ -n $path ]] || {
+		vm_usage >&2
+		return 2
+	}
+
+	vm_require_readable "$path" || return 2
+	text=$(cat -- "$path")
+	pm_validate_text "$text" || status=$?
+	if ((status == 2)); then
+		vm_report_subset_refusal
+	fi
+
+	# The accessors read the parsed node table, which pm_validate_text has
+	# already populated, so a malformed-but-parseable manifest still resolves.
+	if [[ $mode == "print-mode" ]]; then
+		pm_manifest_mode
+		printf '\n'
+		return 0
+	fi
+	if [[ $mode == "print-max-concurrency" ]]; then
+		pm_manifest_max_concurrency
+		printf '\n'
+		return 0
+	fi
+
+	pc_errors_print
+	(($(pc_errors_count) == 0)) || return 1
+	return 0
+}
+
+# Guard so the file can be sourced without executing main. main's return code
+# is captured and re-exited explicitly as the final statement.
+if [[ ${BASH_SOURCE[0]} == "${0}" ]]; then
+	vm_rc=0
+	vm_main "$@" || vm_rc=$?
+	exit "$vm_rc"
+fi

package/resources/claude-customizations/.claude/rules/shell.md

@@ -45,8 +45,10 @@ single pass. Do not substitute the VS Code task wrappers for the native command
 
 ## Discovery Contract
 
-- Search roots: `tools/` and `scripts/`, relative to the current working directory; a missing
-  root is silently skipped.
+- Search roots: `tools/`, `scripts/`, and `.claude/lib/bash/`, relative to the current working
+  directory; a missing root is silently skipped. The `.claude/lib/bash/` root carries the
+  destination-portable bash library published by push-down, so those scripts are held to the
+  same format, lint, test, and coverage standards as `tools/` and `scripts/`.
 - A file is a shell script when its suffix (lowercased) is `.sh` or its first line is a
   shebang whose resolved interpreter is `bash` or `sh` (including `env` and `env -S`/`-flag`
   forms; the shebang is lowercased before parsing, so `#!/usr/bin/env BASH` qualifies).
@@ -60,6 +62,9 @@ single pass. Do not substitute the VS Code task wrappers for the native command
 - Coverage is measured with kcov, which emits a single merged Cobertura report `cov.xml` under
   `artifacts/pester/kcov` (or `SHELL_QC_KCOV_OUT_DIR`). The run prints
   `Bash coverage (lines): NN.N%`.
+- The kcov include pattern covers all three discovery roots — `tools/`, `scripts/`, and
+  `.claude/lib/bash/` — so the Claude bash library is measured, not merely discovered. The
+  `tests/` tree remains excluded.
 - kcov reports **line coverage only**. The uniform line-coverage threshold (>= 85% per
   `.claude/rules/quality-tiers.md`) applies. Branch coverage is not measurable by kcov for
   bash; there is no bash branch-coverage gate.

package/resources/claude-customizations/.claude/settings.json

@@ -5,6 +5,9 @@
       "Bash(git *)",
       "Bash(poetry run *)",
       "Bash(pwsh *)",
+      "Bash(bash .claude/lib/bash/compute-cohorts.sh*)",
+      "Bash(bash .claude/lib/bash/compute-concurrency-batches.sh*)",
+      "Bash(bash .claude/lib/bash/validate-parallel-manifest.sh*)",
       "Read",
       "Edit(/docs/**)",
       "Write(/docs/**)",

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

@@ -56,11 +56,15 @@ 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 landed
-   contention relation `conflicts(a, b, config)` from `scripts/dev_tools/compute_blast_radius.py`
-   (defined in `scripts/dev_tools/_blast_radius_conflicts.py`). `a` and `b` are the two items'
-   `BlastRadius` value objects, not strings, and `config` is the required parsed
-   `config/blast-radius.json` mapping. Map each conflicting pair onto an `(int, int)` conflict edge
+3. **Compute conflict edges over ALL items, including in-flight ones.** Invoke the contention
+   relation `Test-BlastRadiusConflict` from the destination-runtime PowerShell port
+   `.claude/lib/blast-radius/BlastRadius.psm1`, which is published by push-down and needs no Python
+   interpreter (`Import-Module .claude/lib/blast-radius/BlastRadius.psm1 -Force`). 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. `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. 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.

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

@@ -54,7 +54,8 @@ only run-level artifacts under `docs/features/parallel/<slug>/`.
 nine parallel enums are defined once as prose invariants in
 `.claude/rules/parallel-orchestration.md` (manifest invariants M1 through M7) and are enforced by
 the F3-owned validators `scripts/dev_tools/parallel_manifest_contract.py` and
-`scripts/dev_tools/validate_parallel_orchestrator_state.py`. This is a deliberate delta from
+`scripts/dev_tools/validate_parallel_orchestrator_state.py`, with the manifest half reachable on the
+destination-runtime path as `bash .claude/lib/bash/validate-parallel-manifest.sh`. This is a deliberate delta from
 `.claude/skills/epic-orchestrate/SKILL.md`, whose manifest section carries its schema inline. Read
 the schema from the rule file and the validators; consume it here and never redefine or extend it.
 
@@ -72,13 +73,17 @@ Consumption rules:
   Presence of either is an explicit rejection, not a tolerated extra field.
 - A malformed manifest is rejected before any kickoff, recorded as a synthetic Blocking finding in
   the checkpoint. Do not guess a repair, do not silently skip the offending item, and do not launch
-  a partial cohort. Validate by calling `validate_parallel_manifest_text` from
-  `scripts/dev_tools/parallel_manifest_contract.py`, which is a library call and deliberately not
-  an MCP artifact type. That module exposes no CLI entry point, so the permitted mechanism for the
-  call is the granted interpreter invocation
-  `poetry run python -c "import pathlib, sys; from scripts.dev_tools.parallel_manifest_contract import validate_parallel_manifest_text; errors = validate_parallel_manifest_text(pathlib.Path(sys.argv[1]).read_text(encoding='utf-8')); print(errors); sys.exit(1 if errors else 0)" docs/features/parallel/<slug>/parallel.md`,
-  whose non-zero exit is the rejection signal and whose printed error list is the content of the
-  Blocking finding.
+  a partial cohort. Validate with the destination-runtime bash entry point, which needs no Python
+  interpreter and is published by push-down alongside `.claude`:
+  `bash .claude/lib/bash/validate-parallel-manifest.sh docs/features/parallel/<slug>/parallel.md`.
+  Its non-zero exit is the rejection signal and its printed error list, one error per line on
+  stdout, is the content of the Blocking finding; exit 1 means the manifest is invalid and exit 2
+  means the file is unreadable or uses a YAML construct outside the supported subset. Consume
+  `mode` and `max_concurrency` through the same entry point's `--print-mode` and
+  `--print-max-concurrency` subcommands rather than reading the frontmatter directly.
+  `validate_parallel_manifest_text` in `scripts/dev_tools/parallel_manifest_contract.py` remains the
+  repository authority and the parity reference. Manifest validation is deliberately not an MCP
+  artifact type.
 
 ## Cohort Consumption and Ordering
 
@@ -122,10 +127,13 @@ items independently of cohort size: a cohort of twelve items executes at most `m
 items at a time. Fill slots in ascending item-key order, keyed on `issue_num`, and refill each
 freed slot with the next unstarted item of the current cohort in that same ascending item-key
 order. A cohort larger than `max_concurrency` therefore launches in several batches from the same
-recorded `main` tip. The batching is a pure function:
+recorded `main` tip. The batching is a pure function, reached on the destination-runtime path as
+`bash .claude/lib/bash/compute-concurrency-batches.sh --keys "<k1> <k2> ..." --max-concurrency <n>`.
+It prints a compact JSON array of arrays, returns the batches in order, and sorts the keys itself,
+so determinism does not depend on caller ordering.
 `compute_concurrency_batches(cohort_item_keys, max_concurrency)` in
-`scripts/dev_tools/parallel_cohort_computation.py` returns the batches in order and sorts the keys
-itself, so determinism does not depend on caller ordering.
+`scripts/dev_tools/parallel_cohort_computation.py` remains the repository authority and the parity
+reference.
 
 **Mechanical enforcement of the barrier is F7 scope, not this feature's.** F7 delivers a two-layer
 design, because no single `PreToolUse` hook can validate a batch of concurrent `Agent` calls: hooks
@@ -484,8 +492,11 @@ carries exactly ONE current-generation entry per index, so returned keys landing
 `current_cohort` JOIN the pinned members of that one entry instead of forming a second entry with
 the same index, which F3 invariant 13 rejects.
 
-Coloring is delegated in full to the Welsh-Powell entry point `compute_cohorts` in
-`scripts/dev_tools/parallel_cohort_computation.py`. No part of the coloring, the vertex ordering, or
+Coloring is delegated in full to the Welsh-Powell entry point
+`bash .claude/lib/bash/compute-cohorts.sh --keys "<k1> ..." --edges "<a>:<b> ..."`, the
+destination-runtime port of `compute_cohorts` in
+`scripts/dev_tools/parallel_cohort_computation.py`, which remains the repository authority and the
+parity reference. No part of the coloring, the vertex ordering, or
 the tie-break is reimplemented by the mutation engine, and the offset is applied entirely inside the
 mutation engine's own recolor function.
 

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

@@ -142,15 +142,27 @@ Three residual risks are recorded rather than eliminated:
 
 ## Radius Computation and Validation
 
-The blast-radius feature landed as an **import-only Python library with no CLI entry point**,
-matching the `scripts/dev_tools/epic_wave_computation.py` precedent. Reach it through the
-`"Bash(poetry run *)"` allowlist entry as an importable-library call:
+Reach blast-radius derivation, validation, and contention through the **destination-runtime
+PowerShell port** under `.claude/lib/blast-radius/`, which is published by push-down and needs no
+Python interpreter:
 
-```bash
-poetry run python -c "from scripts.dev_tools.compute_blast_radius import derive_blast_radius"
+```powershell
+Import-Module .claude/lib/blast-radius/BlastRadius.psm1 -Force
 ```
 
-Landed contract, consumed as-is and never reimplemented here:
+The facade re-exports the five functions this skill needs: `Get-PlanPaths` (port of
+`extract_plan_paths`), `Get-BlastRadius` (port of `derive_blast_radius`),
+`Get-BlastRadiusFromObservedPaths` (port of `radius_from_observed_paths`), `Test-BlastRadius`
+(port of `validate_blast_radius`), and `Test-BlastRadiusConflict` (port of `conflicts`). Wrap a
+call to `Test-BlastRadius` in `@(...)`: it writes its findings to the pipeline, so a zero-element
+result writes nothing and a one-element result writes a single object.
+
+The truth table the port reads is `config/blast-radius.json`, which push-down publishes into the
+destination workspace alongside `.claude`.
+
+The Python modules named below remain the repository authority and the parity reference; they are
+cited for their contract, not invoked on the destination-runtime path. Landed contract, consumed
+as-is and never reimplemented here:
 
 - **Derivation.**
   `derive_blast_radius(plan_text, spec_text, feature_folder, config, *, source, computed_at) -> BlastRadius`
@@ -201,19 +213,26 @@ them; it defines none of them.
 
 ## Cohort Seeding
 
-The cohort-scheduler feature likewise landed as an **import-only Python library with no CLI entry
-point**, invoked through the same `"Bash(poetry run *)"` allowlist entry:
+Reach cohort computation through the **destination-runtime bash entry point** under
+`.claude/lib/bash/`, which is published by push-down and needs no Python interpreter:
 
 ```bash
-poetry run python -c "from scripts.dev_tools.parallel_cohort_computation import compute_cohorts"
+bash .claude/lib/bash/compute-cohorts.sh --keys "<k1> <k2> ..." --edges "<a>:<b> <a>:<b> ..."
 ```
 
-Landed contract:
+`--edges` is optional; omitting it, or passing an empty string, means the conflict graph has no
+edges. The entry point prints a compact JSON array of arrays on stdout, identical to Python
+`json.dumps(..., separators=(",", ":"))`. On malformed input it prints the reference
+implementation's exact message on stderr and exits 1; a token outside the accepted integer lexis
+`-?(0|[1-9][0-9]*)` is rejected fail-closed with exit 2.
+
+Landed contract, mirrored byte for byte by the bash entry point:
 
 - `compute_cohorts(item_keys, conflict_edges) -> list[list[int]]` in
-  `scripts/dev_tools/parallel_cohort_computation.py`. The signature accepts exactly two parameters,
-  `item_keys: Iterable[int]` and `conflict_edges: Iterable[tuple[int, int]]`. There is no third
-  parameter and nothing further to supply at seeding time.
+  `scripts/dev_tools/parallel_cohort_computation.py` is the repository authority and the parity
+  reference. The signature accepts exactly two parameters, `item_keys: Iterable[int]` and
+  `conflict_edges: Iterable[tuple[int, int]]`. There is no third parameter and nothing further to
+  supply at seeding time.
 - The return value is a plain list of lists in deterministic Welsh-Powell order: vertices are
   visited by the composite key `(-degree, item_key)` ascending — descending distinct-neighbour
   degree with ties broken by ascending item key — and each vertex takes the lowest cohort index not
@@ -227,17 +246,19 @@ The library returns the partition; the planner supplies the record fields.
 
 ### Seeding procedure
 
-1. Invoke `compute_cohorts` exactly once per plan run, over the full conflict graph, after every
+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
-   `conflicts(a, b, config)` to every unordered pair of `declared` radii.
+   `Test-BlastRadiusConflict` to every unordered pair of `declared` radii, then pass the pairs as
+   `--edges "<a>:<b> ..."` and the item keys as `--keys "<k1> <k2> ..."`.
 2. Record `cohorts[]` at `generation: 0`, each cohort's `item_keys[]` sorted ascending.
 3. Record `conflict_edges[]` as `{a, b, reason}` entries for auditability.
 4. Record `recolor_generation: 0` and `current_cohort: 0`.
 5. Record `max_concurrency` — default 4, bounded 1 through 8 by the F3 schema — without enforcing
    it. Enforcement is F5's, through
-   `compute_concurrency_batches(cohort_item_keys, max_concurrency)`, which fills slots in ascending
-   item-key order. Recoloring under add, remove, or drift mutation is F6 and F8 scope. This skill
-   performs seeding only.
+   `bash .claude/lib/bash/compute-concurrency-batches.sh --keys "<k1> ..." --max-concurrency <n>`
+   (the bash port of `compute_concurrency_batches(cohort_item_keys, max_concurrency)`), which fills
+   slots in ascending item-key order. Recoloring under add, remove, or drift mutation is F6 and F8
+   scope. This skill performs seeding only.
 
 ### Recomputation parity (planner-owned check)
 
@@ -276,9 +297,29 @@ field; both are prohibited-key rejections in the schema. Commit it to `parallel/
 fully resolved form — every negative placeholder `issue_num` replaced by its promoted number —
 before the kickoff artifact is written.
 
-Manifest validation is a library call to `scripts/dev_tools/parallel_manifest_contract.py`
-(`validate_parallel_manifest_text`, with the default-resolving accessors `manifest_mode` and
-`manifest_max_concurrency`). It is deliberately not an MCP `artifact_type`; do not attempt to
+Validate the manifest with the **destination-runtime bash entry point**, which is published by
+push-down and needs no Python interpreter:
+
+```bash
+bash .claude/lib/bash/validate-parallel-manifest.sh <manifest-path>
+```
+
+It prints validation errors one per line on stdout and exits 0 for a valid manifest, 1 for an
+invalid one, and 2 for an unreadable file or a YAML construct outside the supported subset. The two
+default-resolving accessors are subcommands of the same entry point:
+
+```bash
+bash .claude/lib/bash/validate-parallel-manifest.sh --print-mode <manifest-path>
+bash .claude/lib/bash/validate-parallel-manifest.sh --print-max-concurrency <manifest-path>
+```
+
+They resolve the documented defaults `closed` and `4` when the manifest omits the key or carries a
+malformed value. Consume `mode` and `max_concurrency` through these accessors rather than reading
+the frontmatter directly.
+
+`scripts/dev_tools/parallel_manifest_contract.py` (`validate_parallel_manifest_text`,
+`manifest_mode`, `manifest_max_concurrency`) remains the repository authority and the parity
+reference. Manifest validation is deliberately not an MCP `artifact_type`; do not attempt to
 validate the manifest through `mcp__drm-copilot__validate_orchestration_artifacts`.
 
 ## Checkpoint Persistence

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

@@ -0,0 +1,16 @@
+{
+  "version": 1,
+  "shared_surfaces": [
+    ".claude/settings.json",
+    "config/orchestration-routing.json",
+    "config/blast-radius.json"
+  ],
+  "shared_surface_globs": [],
+  "modules": {
+    "claude-runtime": [".claude/**"],
+    "config": ["config/**"],
+    "docs": ["docs/**"],
+    "tests": ["tests/**"]
+  },
+  "over_breadth_fraction": 0.25
+}