@danmoisan/drm-copilot-mcp 1.1.17 → 1.1.19

package/resources/claude-customizations/.claude/skills/atomic-plan-contract/SKILL.md

@@ -104,6 +104,10 @@ For short-path/minimal-audit plans, Phase 0 evidence is incomplete unless both a
 
 `Output Summary:` is mandatory for each command-step artifact and must concisely summarize the essential result signal (for example: pass/fail status, key counts, coverage headline, or primary diagnostic).
 
+## Evidence Filename Timestamps in Plans
+
+Plans name evidence artifacts `<name>.<timestamp>.md` and never fix a plan-time stamp in an evidence filename. An acceptance condition identifies a consumed evidence artifact by the derivation in `evidence-and-timestamp-conventions` (`### Evidence Filename Timestamp`): the lexicographically greatest file matching `<name>.*.md`, not a pre-stamped literal path. This section governs artifact paths only: asserted search tokens remain concrete.
+
 ## Coverage Evidence Contract (Mandatory when policy requires coverage)
 
 For any language in scope where repository policy requires coverage validation:
@@ -191,7 +195,7 @@ Before a plan can be treated as approved:
 
 The same validator call also applies the acceptance-gate rules G1 through G6 defined in `.claude/rules/plan-acceptance-gates.md`. Those rules report acceptance conditions that cannot fail — a coverage argument that collects no data, or a search for a literal that returns zero matches whatever the executor does. They run automatically on the existing `plan` route with no additional flag. Blocking findings appear in the validator's error output and fail the gate; Warnings are surfaced without failing it, prefixed with `PLAN GATE WARNING: ` on the CLI and carried on the optional `warnings` field of the MCP result. Read that rule file before authoring acceptance conditions.
 
-The same call additionally applies the rules G7, G8, G8b, and G9, which report a write-mode command observed only by its exit code, an unanchored `git diff`, a name-listing diff with no companion span, and a coverage command that prints no table. All four ship in the Warning channel, so they surface without failing the gate. The complete shipped set is therefore G1 through G9.
+The same call additionally applies the rules G7, G8, G8b, and G9, which report a write-mode command observed only by its exit code, an unanchored `git diff`, a name-listing diff with no companion span, and a coverage command that prints no table. All four ship in the Warning channel, so they surface without failing the gate. The same call also applies G10, a document-level rule that reports a SCRATCH definition not namespaced by issue number. G10 ships in the Blocking channel and reports each finding with a `Line N: ` prefix rather than a task identifier, because the definition sits outside any task window. The complete shipped set is therefore G1 through G10.
 
 ## Wrap-Tolerant Assertion Authoring (Mandatory)
 
@@ -212,6 +216,8 @@ Rules:
 - **Observe a command's success-case output before asserting over that output (mandatory).** Run the command, or read a recorded run of it, and confirm the value you intend to assert is actually printed on a *successful* run. Do not infer it from the tool's documentation, from the plan, or from what the tool prints on failure. This requirement exists because the class of defect it prevents is not detectable by reading: an assertion on a line the tool prints only when it changed something is unsatisfiable on a clean run; a demand for a zero-diagnostic count from a tool that returns only an ok flag names a value with no source; a demand for separate line and branch percentages from a coverage run that prints one combined column reads two numbers that are never printed. G7 and G9 cover two decidable slices of this class. The remainder is covered by this requirement and by nothing else, so a reviewer cannot rely on the gate to catch it.
 - **Fix the evidence in the plan; never leave the executor to select it.** An executor free to choose the evidence it is judged against cannot fail. Do not write an acceptance condition that asks the executor to identify "the known-genuine pair", to choose a survivor list, or to pick any suitable instance. Name the instances, or state the mechanical derivation that produces them, so a third party re-running it obtains the same set. This is authoring guidance and not a rule: a validator rule that scanned acceptance text for selection vocabulary was proposed and rejected, because that vocabulary is ordinary plan prose used in roles carrying no selection semantics and a keyword scan over prose is not statically decidable for the property it would claim to detect. The judgment is the author's, and it is not automated. `.claude/rules/plan-acceptance-gates.md` records the rejection and the reason for it.
 - **Check that the task-ordering does not make the condition unsatisfiable.** No rule covers this. A gate that runs a test path containing deliberately-failing cases added by an earlier task, before the later task that makes them pass, cannot exit 0. A baseline captured after a write-mode formatter has already repaired pre-existing drift becomes either a blanket waiver or makes a later gate unsatisfiable. Read each acceptance condition against the state the plan will actually be in when its task runs.
+- **Name the runner and job for a Pester acceptance criterion.** CI runs Pester in two jobs of `.github/workflows/_poshqc.yml`: `poshqc / PowerShell QC` runs every suite with coverage on `windows-latest`, and `poshqc / PowerShell hook suites (Linux)` runs only `tests/scripts/claude-hooks` and `tests/scripts/codex-hooks` on `ubuntu-latest`, with coverage disabled. A Pester acceptance criterion may cite `ubuntu-latest` only for suites under `tests/scripts/claude-hooks` or `tests/scripts/codex-hooks`, never for coverage, and must name the job it relies on (`poshqc / PowerShell QC` or `poshqc / PowerShell hook suites (Linux)`).
+- **Do not assert a fixed-string search literal that contains a backslash.** Git for Windows grep 3.0 reads a doubled backslash in a `grep -F` pattern as one backslash, so the same check returns a different count locally than on a CI runner and cannot pass in both places. Assert a backslash-free substring of the literal, a named test, or a hash or byte-identity check instead.
 
 ## Plan-Path Continuity Contract (Mandatory)
 

package/resources/claude-customizations/.claude/skills/cleanup-merged-worktrees/SKILL.md

@@ -128,9 +128,17 @@ The script emits pipe-delimited, `LC_ALL=C`-ordered records, one per line:
   per-file outcome is reported by the companion `ACTION|preserve-stage|...` record.
 - `ORPHAN_DIR|<path>|<size>` — a directory under a worktree-tracking root that carries
   no `.git` pointer file and no `git worktree list` entry. `<size>` is best-effort and
-  may be the literal `unknown`. The record is advisory: it reports the directory, and
-  nothing in apply mode acts on it. For the disposition, see the Dirty Worktree Triage
-  Procedure's step 7, which governs how an orphaned directory is handled.
+  may be the literal `unknown`. The scanned roots are the default pair
+  `<main>/.claude/worktrees` and `<main>-wt`, or the `CLEANUP_WT_ORPHAN_ROOTS` entries
+  when that variable is set (the override replaces the default pair), plus the parent
+  directory of every non-main registered worktree, which is always added. A derived
+  parent is skipped when it is the main worktree or one of its ancestors, or is equal to
+  or inside a registered worktree. `CLEANUP_WT_ORPHAN_ROOTS` entries are separated by a
+  semicolon, a newline, or a colon; a colon that follows a single drive letter and
+  precedes `/` or `\` is part of the path, and empty or relative entries are dropped.
+  The record is advisory: it reports the directory, and nothing in apply mode acts on
+  it. For the disposition, see the Dirty Worktree Triage Procedure's step 7, which
+  governs how an orphaned directory is handled.
 - `STALE_REF|<refname>` — a `refs/remotes/<name>/*` ref whose `<name>` is not a
   configured remote, named in full ref form. Advisory only; no ref is ever pruned by
   this tool.

package/resources/claude-customizations/.claude/skills/cleanup-merged-worktrees/scripts/cleanup-worktrees.sh

@@ -139,8 +139,17 @@ Environment overrides:
                                nonexistent value is treated as missing (falls back to
                                the bundled cleanup_worktrees_scan_helper.sh). This is
                                the filesystem-scan test-stub seam.
-  CLEANUP_WT_ORPHAN_ROOTS      Colon-separated override for the worktree-tracking roots
-                               scanned for ORPHAN_DIR and WARN|registration-lost.
+  CLEANUP_WT_ORPHAN_ROOTS      Worktree-tracking roots scanned for ORPHAN_DIR and
+                               WARN|registration-lost. Entries are separated by a
+                               semicolon, a newline, or a colon; a colon that follows
+                               a single drive letter and precedes / or \ is part of
+                               the path (C:/x). Empty and relative entries are
+                               dropped. When set, it replaces the default pair
+                               <main>/.claude/worktrees and <main>-wt. The parent of
+                               every non-main registered worktree is always added,
+                               except a parent that is the main worktree or its
+                               ancestor, or is equal to or inside a registered
+                               worktree.
   CLEANUP_WT_STUB_SCENARIO     Scenario directory consumed by the checked-in git and
                                scan stubs (tests only).
   CLEANUP_WT_CONSOLIDATION_PATH Override the derived consolidation worktree path

package/resources/claude-customizations/.claude/skills/cleanup-merged-worktrees/scripts/cleanup_worktrees_detached_lib.sh

@@ -43,7 +43,7 @@ is_detached_candidate() {
 	#
 	# The predicate is the porcelain FLAG, not the branch field: emit_record writes the
 	# literal DETACHED into the branch field whenever the branch accumulator is empty
-	# (.claude/skills/cleanup-merged-worktrees/scripts/cleanup_worktrees_enumerate_lib.sh:115-116), which is also true of a
+	# (emit_record, nested in parse_worktree_list in cleanup_worktrees_enumerate_lib.sh), which is also true of a
 	# bare-repository stanza, and a local branch literally named DETACHED would produce
 	# the same branch field with no `detached` flag.
 	#

package/resources/claude-customizations/.claude/skills/cleanup-merged-worktrees/scripts/cleanup_worktrees_enumerate_lib.sh

@@ -4,16 +4,19 @@
 # every file within the 500-line cap. Provides the git-binary test seam
 # (cleanup_wt_git), branch/worktree enumeration (enumerate_branches,
 # parse_worktree_list), path normalization (normalize_wt_path), the
-# current-worktree/branch and base-branch protection set (compute_protected), and
-# the main-freshness warning (check_main_freshness). The classification ladder,
-# consolidation, deletion, and the CLI live in sibling files (cleanup_worktrees_lib.sh,
-# cleanup_worktrees_actions_lib.sh, cleanup-worktrees.sh).
+# current-worktree/branch and base-branch protection set (compute_protected), the
+# main-freshness warning (check_main_freshness), the shared absolute-path predicate
+# (cleanup_wt_is_absolute_path), and the worktree-tracking scan roots
+# (cleanup_wt_split_roots, cleanup_wt_derive_scan_roots, cleanup_wt_scan_roots). The
+# classification ladder, consolidation, deletion, and the CLI live in sibling files
+# (cleanup_worktrees_lib.sh, cleanup_worktrees_actions_lib.sh, cleanup-worktrees.sh).
 #
 # Sourcing contract: defines functions and the single constant CLEANUP_WT_BASE_BRANCH
 # and runs no other work at source time, so wrapper and bats suites source it safely.
 # It MUST be sourced before cleanup_worktrees_lib.sh, whose classification functions
 # call cleanup_wt_git, parse_worktree_list, compute_protected, and normalize_wt_path
-# defined here.
+# defined here. The filesystem-scan helper cleanup_worktrees_scan_helper.sh runs as a
+# separate process and sources this library directly for cleanup_wt_is_absolute_path.
 #
 # All git commands go through cleanup_wt_git so tests can stub the git binary via
 # CLEANUP_WT_GIT_BIN. Git exit-code capture rule: the `git worktree list --porcelain`
@@ -250,3 +253,166 @@ check_main_freshness() {
 	fi
 	return 0
 }
+
+cleanup_wt_is_absolute_path() {
+	# Return 0 when <path> is absolute, else 1. Pure: no filesystem access.
+	#
+	# Absolute forms are a leading `/` (POSIX paths, MSYS `/c/...` paths, and `//server`
+	# UNC paths) and a drive letter followed by `/` or `\` (`C:/...`, `c:/...`,
+	# `C:\...`), which is the form Git for Windows writes into a worktree's `.git`
+	# pointer file (issue #706). A drive letter with no separator (`C:rel`) is
+	# drive-relative and is not absolute; an empty path is not absolute. This is the one
+	# absolute-path predicate of the skill: the preserve library and the filesystem-scan
+	# helper both call it.
+	#
+	# Args: $1 = path. Returns 0 (absolute) or 1 (not absolute).
+	local path=${1:-}
+	[[ $path == /* || $path == [A-Za-z]:[/\\]* ]]
+}
+
+cleanup_wt_split_roots() {
+	# Split a CLEANUP_WT_ORPHAN_ROOTS value into absolute roots, one per line.
+	#
+	# Entries are separated by `;`, by a newline, or by `:`. A `:` is part of the path
+	# instead when the text before it in the current entry is exactly one ASCII letter
+	# and the character after it is `/` or `\` (a drive letter, as in `C:/x`). Empty
+	# entries are dropped. An entry that is not absolute (cleanup_wt_is_absolute_path) is
+	# dropped with a one-line stderr diagnostic naming it, because a relative root would
+	# be resolved against the process's current working directory.
+	#
+	# The value is walked one character at a time with parameter expansion and never
+	# word-split, so no pathname expansion occurs and a `*` is emitted literally.
+	#
+	# Args: $1 = the override value. Always returns 0.
+	local value=${1:-}
+	local -a entries=()
+	local entry="" ch next i
+	for ((i = 0; i < ${#value}; i++)); do
+		ch=${value:i:1}
+		if [[ $ch == ';' || $ch == $'\n' ]]; then
+			entries+=("$entry")
+			entry=""
+		elif [[ $ch == ':' ]]; then
+			next=${value:i+1:1}
+			if [[ ${#entry} -eq 1 && $entry == [A-Za-z] && $next == [/\\] ]]; then
+				entry+=$ch
+			else
+				entries+=("$entry")
+				entry=""
+			fi
+		else
+			entry+=$ch
+		fi
+	done
+	entries+=("$entry")
+	for entry in "${entries[@]}"; do
+		[[ -z $entry ]] && continue
+		if ! cleanup_wt_is_absolute_path "$entry"; then
+			printf 'cleanup-worktrees: CLEANUP_WT_ORPHAN_ROOTS entry is not absolute, dropped: %s\n' "$entry" >&2
+			continue
+		fi
+		printf '%s\n' "$entry"
+	done
+	return 0
+}
+
+cleanup_wt_derive_scan_roots() {
+	# Echo the registration-derived scan roots, one per line.
+	#
+	# Input is parse_worktree_list output; its first record is the main worktree. The
+	# candidate for every later record is the parent directory of its path (backslashes
+	# converted to `/`). A candidate is kept only when its normalize_wt_path value N:
+	#   - is not the main worktree's normalized path and is not one of its ancestors
+	#     (scanning an ancestor would list the main worktree's siblings), and
+	#   - is not equal to, and not inside, any registered worktree, main included
+	#     (its subdirectories are that worktree's own content, not worktrees).
+	# Kept candidates are emitted in LC_ALL=C order of N, once per N, using the first
+	# spelling seen in record order.
+	#
+	# Args: $1 = parse_worktree_list output. Always returns 0.
+	local records=${1:-}
+	local -a paths=() norms=()
+	local record path
+	while IFS= read -r record; do
+		[[ -z $record ]] && continue
+		path=${record%%|*}
+		paths+=("$path")
+		norms+=("$(normalize_wt_path "$path")")
+	done <<<"$records"
+	((${#paths[@]} < 2)) && return 0
+	local main_norm=${norms[0]}
+	local -A seen=()
+	local -a kept=()
+	local i p parent n w inside
+	for ((i = 1; i < ${#paths[@]}; i++)); do
+		p=${paths[i]//\\//}
+		parent=${p%/*}
+		[[ -z $parent || $parent == "$p" ]] && continue
+		# A drive-relative parent (a registration directly under a drive root, such as D:/wt) is not an absolute root and is dropped.
+		cleanup_wt_is_absolute_path "$parent" || continue
+		n=$(normalize_wt_path "$parent")
+		[[ -z $n || -n ${seen[$n]:-} ]] && continue
+		[[ $n == "$main_norm" || $main_norm == "$n"/* ]] && continue
+		inside=0
+		for w in "${norms[@]}"; do
+			[[ -z $w ]] && continue
+			if [[ $n == "$w" || $n == "$w"/* ]]; then
+				inside=1
+				break
+			fi
+		done
+		((inside == 1)) && continue
+		seen[$n]=1
+		kept+=("$n|$parent")
+	done
+	((${#kept[@]} == 0)) && return 0
+	local line
+	while IFS= read -r line; do
+		printf '%s\n' "${line#*|}"
+	done < <(printf '%s\n' "${kept[@]}" | LC_ALL=C sort -t '|' -k1,1)
+	return 0
+}
+
+cleanup_wt_scan_roots() {
+	# Echo the worktree-tracking roots to scan, one per line.
+	#
+	# Configured roots come first: the CLEANUP_WT_ORPHAN_ROOTS entries
+	# (cleanup_wt_split_roots) when that variable is set, otherwise the default pair
+	# derived from the main worktree path (the first `git worktree list --porcelain`
+	# stanza, the same derivation consolidation_worktree_path uses in
+	# cleanup_worktrees_actions_lib.sh): `<main>/.claude/worktrees` then `<main>-wt`.
+	# Registration-derived roots (cleanup_wt_derive_scan_roots) are always appended.
+	# The combined list is deduplicated by normalize_wt_path, keeping the first spelling.
+	#
+	# The listing is read once (`out=$(...) || rc=$?`). On a parse_worktree_list hard
+	# failure nothing is derived from it: with no override no root is emitted at all,
+	# rather than a bare relative path resolved against the current working directory,
+	# and with an override exactly the override roots are emitted.
+	# cleanup_wt_scan_records returns 0 with no record for an empty root list, so the
+	# advisory records degrade to silence rather than to a misleading scan.
+	# Always returns 0.
+	local out rc=0 first_record main_wt="" configured="" derived=""
+	out=$(parse_worktree_list) || rc=$?
+	if ((rc == 0)); then
+		first_record=${out%%$'\n'*}
+		main_wt=${first_record%%|*}
+		derived=$(cleanup_wt_derive_scan_roots "$out")
+	fi
+	if [[ -n ${CLEANUP_WT_ORPHAN_ROOTS:-} ]]; then
+		configured=$(cleanup_wt_split_roots "$CLEANUP_WT_ORPHAN_ROOTS")
+	elif [[ -n $main_wt ]]; then
+		configured="${main_wt}/.claude/worktrees"$'\n'"${main_wt}-wt"
+	fi
+	local -A seen=()
+	local root n
+	while IFS= read -r root; do
+		[[ -z $root ]] && continue
+		n=$(normalize_wt_path "$root")
+		# A root of `/` normalizes to empty, which is not a valid array key.
+		[[ -z $n ]] && n=/
+		[[ -n ${seen[$n]:-} ]] && continue
+		seen[$n]=1
+		printf '%s\n' "$root"
+	done <<<"${configured}"$'\n'"${derived}"
+	return 0
+}

package/resources/claude-customizations/.claude/skills/cleanup-merged-worktrees/scripts/cleanup_worktrees_preserve_lib.sh

@@ -158,7 +158,7 @@ preserve_relative_path_reason() {
 	local name=${1-} val=${2-}
 	if [[ -z $val ]]; then
 		printf '%s is empty' "$name"
-	elif [[ $val == /* || $val == [A-Za-z]:[\\/]* ]]; then
+	elif cleanup_wt_is_absolute_path "$val"; then
 		printf '%s is absolute: %s' "$name" "$val"
 	elif [[ $val == ".." || $val == "../"* || $val == *"/../"* || $val == *"/.." ]]; then
 		printf '%s contains a .. segment: %s' "$name" "$val"

package/resources/claude-customizations/.claude/skills/cleanup-merged-worktrees/scripts/cleanup_worktrees_report_records_lib.sh

@@ -6,10 +6,10 @@
 # whose gitdir pointer no longer resolves, and the ancestor relationship between two
 # branches that both resolve NOT_MERGED. The enumeration/protection seam
 # (cleanup_wt_git, enumerate_branches, parse_worktree_list, normalize_wt_path,
-# compute_protected, check_main_freshness) lives in cleanup_worktrees_enumerate_lib.sh
-# and the classification ladder (classify_branch) lives in cleanup_worktrees_lib.sh;
-# both MUST be sourced before this file. Keeping these records in a sibling file keeps
-# every file within the 500-line cap.
+# compute_protected, check_main_freshness, cleanup_wt_scan_roots) lives in
+# cleanup_worktrees_enumerate_lib.sh and the classification ladder (classify_branch)
+# lives in cleanup_worktrees_lib.sh; both MUST be sourced before this file. Keeping
+# these records in a sibling file keeps every file within the 500-line cap.
 #
 # Sourcing contract: this library defines functions only; it never runs work at source
 # time, so the wrapper and the bats suites can source it without side effects.
@@ -111,47 +111,10 @@ scan_stale_refs() {
 	return 0
 }
 
-cleanup_wt_scan_roots() {
-	# Echo the worktree-tracking roots to scan, one per line.
-	#
-	# CLEANUP_WT_ORPHAN_ROOTS overrides the derivation with a colon-separated list.
-	# Otherwise BOTH roots derive from the main worktree path — the first
-	# `git worktree list --porcelain` stanza, the same derivation
-	# consolidation_worktree_path uses in cleanup_worktrees_actions_lib.sh. They are
-	# `<main-worktree-path>` joined with `.claude/worktrees` (the agent worktree folder)
-	# and `<main-worktree-path>-wt` (the sibling worktree folder), in that order.
-	#
-	# Deriving both from one read means a parse_worktree_list hard failure emits no root
-	# at all, rather than a bare relative path that would be resolved against whatever
-	# the process's current working directory happened to be. cleanup_wt_scan_records
-	# returns 0 with no record for an empty root list, so the advisory records degrade to
-	# silence rather than to a misleading scan. Always returns 0.
-	local override=${CLEANUP_WT_ORPHAN_ROOTS:-}
-	if [[ -n $override ]]; then
-		local IFS=:
-		local part
-		for part in $override; do
-			[[ -n $part ]] && printf '%s\n' "$part"
-		done
-		return 0
-	fi
-	local out rc=0 first_record main_wt=""
-	out=$(parse_worktree_list) || rc=$?
-	if ((rc != 0)); then
-		return 0
-	fi
-	first_record=${out%%$'\n'*}
-	main_wt=${first_record%%|*}
-	if [[ -n $main_wt ]]; then
-		printf '%s\n' "${main_wt}/.claude/worktrees"
-		printf '%s\n' "${main_wt}-wt"
-	fi
-	return 0
-}
-
 cleanup_wt_scan_records() {
 	# Echo the raw `<path>|<has_gitfile>|<gitdir_target_exists>|<size>` records for every
-	# candidate directory under the resolved scan roots, one per line.
+	# candidate directory under the resolved scan roots, one per line. The roots come
+	# from cleanup_wt_scan_roots in cleanup_worktrees_enumerate_lib.sh.
 	#
 	# Every filesystem read goes through the CLEANUP_WT_SCAN_BIN seam, so the bats suites
 	# replay canned records instead of touching the real filesystem. The scan output is

package/resources/claude-customizations/.claude/skills/cleanup-merged-worktrees/scripts/cleanup_worktrees_scan_helper.sh

@@ -40,6 +40,11 @@
 # the SHELL_QC_<TOOL>_BIN seams substitute a checked-in stand-in for a real dependency.
 # An empty value is treated as missing and falls back to `.git`.
 set -euo pipefail
+# The library path is computed at runtime from BASH_SOURCE, so shellcheck (run without
+# -x) cannot follow it; SC1091 is the expected, benign result.
+# shellcheck source=.claude/skills/cleanup-merged-worktrees/scripts/cleanup_worktrees_enumerate_lib.sh
+# shellcheck disable=SC1091
+source "$(dirname -- "${BASH_SOURCE[0]}")/cleanup_worktrees_enumerate_lib.sh"
 
 scan_helper_dir_size() {
 	# Echo the best-effort human-readable size of a directory, or `unknown`.
@@ -70,20 +75,6 @@ scan_helper_gitfile_name() {
 	printf '%s\n' ".git"
 }
 
-scan_helper_is_absolute_path() {
-	# Return 0 when <path> is absolute, else 1. Pure: no filesystem access.
-	#
-	# Absolute forms are a leading `/` (POSIX paths, MSYS `/c/...` paths, and `//server`
-	# UNC paths) and a drive letter followed by `/` or `\` (`C:/...`, `c:/...`,
-	# `C:\...`), which is the form Git for Windows writes into a worktree's `.git`
-	# pointer file (issue #706). A drive letter with no separator (`C:rel`) is
-	# drive-relative and is not absolute; an empty path is not absolute.
-	#
-	# Args: $1 = path. Returns 0 (absolute) or 1 (not absolute).
-	local path=${1:-}
-	[[ $path == /* || $path == [A-Za-z]:[/\\]* ]]
-}
-
 scan_helper_target_present() {
 	# Return 0 when <path> exists, else non-zero. This is the helper's single
 	# filesystem existence check, kept in its own function as a test seam: bats tests
@@ -113,7 +104,7 @@ scan_helper_gitdir_target_exists() {
 		printf '0\n'
 		return 0
 	fi
-	if ! scan_helper_is_absolute_path "$target"; then
+	if ! cleanup_wt_is_absolute_path "$target"; then
 		target="$dir/$target"
 	fi
 	if scan_helper_target_present "$target"; then

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

@@ -95,14 +95,32 @@ function of the DAG.
 2. Before starting each wave, `epic-orchestrator` runs
    `git fetch origin epic/<epic-slug>-integration` so the wave's child worktrees branch off the
    current remote tip, not a stale local ref.
-3. Each child feature's worktree/branch (created via
+3. Before each wave launches (wave 0 included), `epic-orchestrator` runs
+   `git fetch origin main` and then
+   `git rev-list --count origin/epic/<epic-slug>-integration..origin/main`. A zero count
+   proceeds directly to the wave. A non-zero count means `origin/main` has commits the
+   integration branch lacks, and the main-sync runs as a dedicated chore child item before the
+   wave launches, following the `epic-852-main-sync` / PR #882 pattern. Before delegating it,
+   `epic-orchestrator` writes the sync child's `features[]` row (with `depends_on: []`) and its
+   own `waves[]` entry to the epic checkpoint, because `enforce-epic-wave-barrier.ps1` denies a
+   delegation whose feature record is absent. The sync child must not reuse a manifest child's
+   issue number; it uses the epic issue number or a dedicated chore issue. Its branch is created
+   from the integration branch, merges `origin/main` with a merge commit
+   (`git merge --no-ff origin/main`; no rebase, no force-push), resolves any conflict inside its
+   own remediation loop, and opens a PR into the integration branch. The wave does not launch
+   until that PR has merged into the integration branch and the sync entry's `merge_status` is
+   `merged`. At most one main-sync child runs per wave: after it merges, `epic-orchestrator`
+   re-runs step 2 and launches the wave without repeating the count, and commits that reach
+   `origin/main` afterwards are picked up by the next wave's check or by the final integration
+   PR in step 6.
+4. Each child feature's worktree/branch (created via
    `Agent(orchestrator, isolation: "worktree", run_in_background: true)`) is branched from
    `origin/<integration_branch>`, not `origin/main`. The child's own `orchestrator` instance
    honors this via the epic-mode kickoff line below.
-4. Each child feature's PR base branch is the integration branch, not `main` — an explicit
+5. Each child feature's PR base branch is the integration branch, not `main` — an explicit
    epic-mode override recorded in the checkpoint, not a reliance on `pr-base-branch-merge-base`'s
    ancestry heuristic. Non-epic (standalone) orchestration is unchanged.
-5. At epic completion (every feature in the final wave has `merge_status: "merged"`),
+6. At epic completion (every feature in the final wave has `merge_status: "merged"`),
    `epic-orchestrator` drives a final PR merging `epic/<epic-slug>-integration` into `main`,
    delegating PR authoring to `Agent(pr-author)` and refreshing context via
    `mcp__drm-copilot__collect_pr_context`. `epic-orchestrator` runs the same S9 CI-green
@@ -221,9 +239,10 @@ Procedure, triggered by S9 step 6's merge failure:
 3. The existing R1–R5 loop processes this finding exactly as a local blocking finding:
    `atomic-planner` (R1) plans the resolution, `atomic-executor` performs preflight (R2) then
    resolves the conflict markers, stages, and commits (R3), `feature-review` re-audits (R4).
-4. The child's own `remediation_pass` counter is shared with local-finding and CI-failure passes
-   (cap 3), unmodified.
-5. On the third conflict pass without resolution, the child's `orchestrator` records
+4. Conflict cycles share the child's own `remediation_loop.completed_attempts` count with
+   local-finding and CI-failure cycles. The active cycle number is `completed_attempts + 1`, and a
+   cycle without an applied candidate consumes no number.
+5. After three completed attempts without resolution, the child's `orchestrator` records
    `step9_status: "blocked_conflict_loop_limit"` (parallel to `blocked_ci_loop_limit`), does not
    write DONE, and halts. It reports this status to `epic-orchestrator`, which mirrors it into
    the epic checkpoint's per-feature `merge_status: "blocked_conflict_loop_limit"` field.
@@ -240,11 +259,26 @@ cross-call/conversation-state visibility.
   prompt text, reads `artifacts/orchestration/epic-orchestrator-state.json`, looks up that
   feature's `depends_on`, and denies with reason `EPIC_WAVE_BARRIER_BLOCKED` unless every
   dependency's `merge_status` is `merged` or `worktree_removed`.
-- **Layer 2 — retrospective backstop:** the wave-barrier ordering invariant inside
-  `validate_epic_orchestrator_state_text`, enforced at `epic-orchestrator` `SubagentStop` time via
-  the parameterized `validate-orchestrator-output.ps1` hook. It appends
-  `EPIC_WAVE_BARRIER_VIOLATION: <f> started before dependency <d> merged` when a dependency edge's
-  timing invariant is violated.
+- **Layer 2 — retrospective backstop:** the wave-barrier ordering invariant of
+  `validate_epic_orchestrator_state_text`, enforced at `epic-orchestrator` `SubagentStop` time by a
+  PowerShell port, `Get-OrchestratorStateEpicWaveBarrierError` in
+  `.claude/lib/orchestrator-state/OrchestratorStateEpicWaveBarrier.psm1`, which the parameterized
+  `validate-orchestrator-output.ps1` hook invokes for `epic-orchestrator-state` after resolving the
+  epic checkpoint through `WorktreeRunResolution.psm1`. The hook starts no Python process. Parity
+  with `validate_epic_orchestrator_state_text` is pinned by the shared fixtures under
+  `tests/fixtures/epic_wave_barrier/`, and the Python validator remains the authority used through
+  the `mcp__drm-copilot__validate_orchestration_artifacts` call. It checks only a dependent feature
+  that is treated as started: one with a string `worktree_created_at`, or with a `merge_status`
+  other than `not_started` (a missing or non-string `merge_status` counts as started). It appends
+  exactly one error per violated dependency edge. When the dependency's `merge_status` is not
+  `merged` or `worktree_removed`, the error is
+  `EPIC_WAVE_BARRIER_VIOLATION: <f> is treated as started while dependency <d> is not merged`.
+  Otherwise, when the dependency's `merge_confirmed_at` is later than the dependent's
+  `worktree_created_at`, the error is
+  `EPIC_WAVE_BARRIER_VIOLATION: <f> worktree_created_at precedes dependency <d> merge_confirmed_at`.
+  A violation blocks with an instruction to report it to the operator and halt. The `SubagentStop`
+  transport and exit-code defect that this check previously depended on was resolved by epic #904
+  and issue #928: a violation blocks the stop with exit 2 and a stderr reason.
 
 Both layers are required; neither alone closes the gap. `epic-orchestrator` does not launch wave
 N+1 until every wave-N feature's dependency edges are durably confirmed merged, verified against

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

@@ -211,7 +211,7 @@ With no ready feature checkpoint, the exemption admits two attribution-trailer f
 - 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.
+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. Because the executing shell is undetermined (issue #735), a shape whose meaning differs between a POSIX shell and PowerShell is denied: a backslash anywhere in the command line is denied, and `{`, `}`, `,`, `(`, `)`, and `@` are denied outside quotes. Every staging operand must be a plain forward-slash repository-relative path that uses only the characters `A-Z a-z 0-9 . _ / -`.
 
 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.
 

package/resources/claude-customizations/.claude/skills/evidence-and-timestamp-conventions/SKILL.md

@@ -46,6 +46,17 @@ Use this skill when:
 Use `yyyy-MM-ddTHH-mm` for all audit, remediation, and evidence artifacts.
 Example: `2026-02-06T14-30`.
 
+The `Timestamp` value is UTC read from the host system clock when the recorded command runs (for example `Get-Date -AsUTC -Format yyyy-MM-ddTHH-mm` in PowerShell 7, `(Get-Date).ToUniversalTime().ToString('yyyy-MM-ddTHH-mm')` in Windows PowerShell 5.1, or `date -u +%Y-%m-%dT%H-%M` in a POSIX shell); the agent never composes or estimates it. The value is written without a zone suffix.
+
+### Evidence Filename Timestamp
+
+The stamp in the filename of every artifact under `<FEATURE>/evidence/<kind>/` is the UTC time at which that file is written, read from the host system clock immediately before the write, in the same `yyyy-MM-ddTHH-mm` shape with no zone suffix. It is never a plan-time stamp, a plan-cycle identifier, or any other value fixed before the write.
+
+- Plans name such an artifact `<name>.<timestamp>.md`, and the executor substitutes the write time. A later loop pass writes a new file with a new stamp.
+- A task that consumes an evidence artifact selects the lexicographically greatest file matching `<name>.*.md`. The fixed-width UTC shape sorts in chronological order, so that file is the most recently written one.
+- Plan files (`plan.<timestamp>.md`, stamped by the feature-folder tooling in America/New_York) and the review artifact set (`policy-audit`, `code-review`, `feature-audit`, `remediation-inputs`, which share one stamp) are outside this rule.
+- Existing evidence files whose names carry a plan-time stamp are not renamed.
+
 ## Canonical Evidence Locations
 
 - Baseline evidence: `evidence/baseline/`
@@ -110,6 +121,8 @@ When evidence artifacts are used for automated checking or plan reconciliation,
 - `Command: <exact command>`
 - `EXIT_CODE: <int>`
 
+The first occurrence of `Timestamp`, `Command`, `EXIT_CODE`, and `ExpectedExitCode` forms the record in both the Python and the TypeScript parser; later occurrences, including empty later values, are ignored. An artifact that records several gates therefore reports its first gate.
+
 One optional field may also be declared:
 - `ExpectedExitCode: <int>` — the exit code the gate is expected to produce.
 

package/resources/claude-customizations/.claude/skills/feature-promotion-lifecycle/SKILL.md

@@ -40,6 +40,16 @@ Each `delegation_receipts.promotion.*` field stores the raw MCP receipt payload
 
 Note: VS Code command-palette commands may exist for interactive extension use, but this note is non-authoritative for agent sessions.
 
+## Pre-Existing Issue Path
+
+When the GitHub issue already exists (it was transferred, filed before orchestration, or created by epic decomposition), do not call `potential_to_issue`: that tool creates a new issue and would duplicate the existing one. Instead:
+
+1. Verify the issue read-only with `gh issue view`, a `gh api` GET request, or a GitHub MCP issue read, and use its number as `${issue-num}`.
+2. Record a top-level `issue_adoption` object in the orchestrator checkpoint (`issue_num`, `issue_url`, `origin`, `verified_via`, `verified_at`, `evidence`, `waived_tools`, and, when a promotion-entry tool is waived, `potential_record`). For that waiver `potential_record` is required when `origin` is `epic_decomposition`, optional when `origin` is `transferred` or `filed_before_orchestration`, and validated whenever it is present. A valid record waives the `potential_to_issue` receipt requirement at completion.
+3. `delegation_receipts.promotion.issue` may be omitted, because no promotion receipt exists for an adopted issue.
+
+The field rules, the closed set of waivable tools, and the fail-closed behavior are defined in `.claude/rules/orchestrator-state.md` under `## Invariants (issue_adoption object)`.
+
 ## Canonical Variables
 
 - `${promotion-type}`: `feature` or `bug`

package/resources/claude-customizations/.claude/skills/feature-review-workflow/SKILL.md

@@ -70,9 +70,9 @@ Always apply:
 If the branch diff modifies any path matching `.github/workflows/**`, `scripts/benchmarks/**`, or `.github/actions/**`, the policy audit emits a Blocking finding unless evidence of a green workflow run against the branch head is present in the remediation inputs.
 
 - The rule provides a second, independent line of defense for CI-gate-modifying features, separate from and prior to the orchestrator's S9 CI green gate.
-- "Green workflow run against the branch head" means a workflow run whose head SHA matches the current branch head and whose conclusion is success for the affected workflow.
+- "Green workflow run against the branch head" means a run of the affected workflow whose conclusion is success and which satisfies either (a) or (b): (a) its head SHA equals the current branch head; or (b) all three predecessor-head conditions hold: (1) the run's head SHA is an ancestor of, or equal to, the current branch head and contains the latest commit that changes any path outside the active feature folder (`git merge-base --is-ancestor <commit> <run-sha>`); (2) every commit after the run's head SHA changes only paths inside the active feature folder (`git log <run-sha>..HEAD -- . ":!<feature-folder>"` returns no commits); (3) the policy audit states that the orchestrator's S9 CI green gate remains responsible for `ci_gate.conclusion == "success"` with `ci_gate.head_sha` equal to the final PR head before DONE. Condition (b) exists because an in-repo evidence artifact cannot name the SHA of the commit that contains it.
 - A green `workflow_dispatch` run against the branch head also satisfies the rule, not only a PR-context run. This mitigates the chicken-and-egg case where a feature must land its CI gate before the gate can run in PR context (see spec.md Risks & Mitigations).
-- When the rule fires and no qualifying green-run evidence is present, record a Blocking finding and route it through the standard remediation handoff. The supporting validator `scripts/feature-review/Test-ModifiedWorkflowNeedsGreenRun.ps1` implements the trigger-path and evidence-presence logic.
+- When the rule fires and no qualifying green-run evidence is present, record a Blocking finding classified `awaiting_ci` (the remediation inputs carry `Remediability: awaiting_ci` and a `Remediability-Evidence:` line naming the awaited workflow) and route it to the wait path (`AWAITING_CI` when no other class is present) instead of the remediation handoff.
 
 ## Ordered Procedure
 
@@ -108,12 +108,13 @@ If the branch diff modifies any path matching `.github/workflows/**`, `scripts/b
         - Python: `poetry run pytest --cov` → artifact: `artifacts/python/lcov.info`
         - PowerShell: `mcp__drm-copilot__run_poshqc_test` → artifact: `artifacts/pester/powershell-coverage.xml`
         - C#: `dotnet test --collect:"XPlat Code Coverage"` → artifact: `artifacts/csharp/coverage.xml`
-        - Coverage thresholds (uniform tier rule per quality-tiers.md). The branch threshold applies only to branch-capable languages — TypeScript, Python, and C#. PowerShell is a coverage language and is fully subject to the line threshold and the no-regression requirement, but Pester measures command (instruction) coverage and line coverage only, so no branch percentage exists to evaluate and no branch threshold applies to it (see `.claude/rules/powershell.md`). Do not flag a missing PowerShell branch figure as FAIL:
+        - Coverage thresholds (threshold precedence per `.claude/rules/quality-tiers.md` and `.claude/rules/general-unit-test.md`: when the repository's root `CLAUDE.md` states line or branch coverage thresholds, those thresholds govern; otherwise the default thresholds below govern; each metric falls back independently, so a root `CLAUDE.md` that states only one of the two thresholds governs only that metric). The branch threshold applies only to branch-capable languages — TypeScript, Python, and C#. PowerShell is a coverage language and is fully subject to the line threshold and the no-regression requirement, but Pester measures command (instruction) coverage and line coverage only, so no branch percentage exists to evaluate and no branch threshold applies to it (see `.claude/rules/powershell.md`). Do not flag a missing PowerShell branch figure as FAIL:
           - New code files (added in this feature): line coverage >= 85%, and branch coverage >= 75% for branch-capable languages. Flag as FAIL otherwise.
           - Modified files (changed but previously existing): line coverage >= 85%, branch coverage >= 75% for branch-capable languages, and no regression on changed lines relative to baseline. Flag as FAIL otherwise.
           - Repo-wide per language: line coverage >= 85%, and branch coverage >= 75% for branch-capable languages. Flag as FAIL otherwise.
         - If coverage artifacts already exist from the executor run, inspect them instead of re-running.
         - If no coverage artifact exists for a language that has changed files, flag as FAIL — coverage verification is mandatory for all languages with changed files.
+        - Tier classification findings: report a missing or incomplete `quality-tiers.yml` only when the repository has adopted tiers, that is, when `quality-tiers.yml` exists at the repository root on the resolved base branch or the repository's CI runs a tier-classification check. Otherwise record tier classification as not applicable; it is not a finding.
    - Run the smallest relevant subset first when the repo policy permits it.
    - If a tool cannot run in the environment, mark the affected section unverified or partial with a concrete reason.
 
@@ -145,8 +146,10 @@ If the branch diff modifies any path matching `.github/workflows/**`, `scripts/b
      - toolchain checks fail
      - the code review contains blockers
      - required acceptance criteria are FAIL or PARTIAL
-     - coverage regression below policy threshold (< 80% repo-wide per language, < 80% or regression for modified files, or < 90% for new files)
+     - coverage below the governing thresholds defined in step 5 (repo-wide per language, modified files including any regression on changed lines, or new files)
      - coverage artifact absent for any language that has changed files
+   - Classify each blocking finding before triggering remediation: each receives one remediability class (`autonomous`, `external_dependency`, `policy_hold`, `awaiting_ci`, or `human_decision_required`; `autonomous` when no class is stated). A published MCP runtime that lags the repository contract is classified `external_dependency`.
+   - Trigger the remediation handoff only when at least one blocking finding is `autonomous`. When every blocking finding is non-remediable, write the remediation inputs with the `HALT_NON_REMEDIABLE` or `AWAITING_CI` verdict and create no remediation plan target.
    - Create `remediation-inputs.<timestamp>.md` first.
    - Create the target remediation plan file from the canonical plan template.
    - Hand off plan creation through `remediation-handoff-atomic-planner`.