@danmoisan/drm-copilot-mcp 0.0.1

package/resources/claude-customizations/.claude/rules/typescript-suppressions.md

@@ -0,0 +1,66 @@
+---
+paths:
+  - "**/*.ts"
+description: Pre-authorized ESLint and TypeScript suppression patterns. Applies to TypeScript files.
+---
+
+# TypeScript Suppression Policy
+
+This rule file summarizes the suppression authorization policy for TypeScript code.
+
+## Authorization Requirement
+
+All ESLint and TypeScript suppressions must either:
+1. **Match a pre-authorized pattern** defined in this file, OR
+2. **Have explicit user approval** for that specific suppression.
+
+**Escalation path before requesting approval:**
+1. First, attempt to resolve the error without a suppression (refactor, restructure, adjust types).
+2. If that fails, try at least five more distinct approaches.
+3. Continue iterating until you solve the problem or clearly demonstrate why each approach fails.
+4. Only after multiple documented failed attempts may you request user approval, providing: the specific rule/error code, each approach tried and why it failed, and why a suppression is the only remaining option.
+
+## Pre-Authorized Patterns
+
+### ESLint — Single-rule, single-line disable
+
+**Pattern:** `// eslint-disable-next-line <rule-name> -- <reason>`
+
+**When authorized:**
+- Suppresses exactly one ESLint rule for exactly one following line.
+- The reason is specific and local to the code (not "annoying rule", "temporary", or "works").
+- The suppression does not hide a real bug or broaden the type surface unnecessarily.
+
+**Required comment format:** The `-- <reason>` suffix is mandatory and must explain why the suppression is safe in this specific local context.
+
+### TypeScript — Single-line expect-error
+
+**Pattern:** `// @ts-expect-error -- <reason>`
+
+**When authorized:**
+- A single line is flagged by TypeScript and you can explain the mismatch precisely.
+- The reason explains what TypeScript is complaining about AND why this line is safe anyway.
+- Prefer fixing types, adding runtime guards, or refining control flow over suppressions.
+
+**Self-auditing:** `@ts-expect-error` fails the build if the error disappears, preventing stale suppressions.
+
+**Required comment format:** The `-- <reason>` suffix is mandatory.
+
+## Explicitly Prohibited Patterns
+
+These patterns require explicit user approval and should generally be avoided:
+
+| Pattern | Reason prohibited |
+|---------|-------------------|
+| `/* eslint-disable */` | File-level; extremely large blast radius; hides unrelated problems. |
+| `/* eslint-disable <rule> */` | File-level; use single-line suppression instead. |
+| `// @ts-ignore` | Can silently mask real problems; does not fail when the error disappears. |
+| `// @ts-nocheck` | Disables type checking for the entire file; defeats repo type-safety standards. |
+
+## Policy Enforcement Checklist
+
+Before using any suppression, verify:
+- [ ] Pattern exactly matches a pre-authorized pattern above.
+- [ ] Required comment format (`-- <reason>`) is used.
+- [ ] Scope is the smallest possible (single rule, single line).
+- [ ] The reason is specific and explains why the code is safe.

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

@@ -0,0 +1,45 @@
+---
+paths:
+  - "**/*.ts"
+description: TypeScript-specific toolchain and coding standards.
+---
+
+# TypeScript Code Standards
+
+This rule file summarizes the TypeScript-specific policies for this repository.
+
+## Toolchain
+
+1. **Formatting — Prettier**: All TypeScript must be formatted with the repository Prettier configuration. Command: `npm run format`
+2. **Linting — ESLint**: TypeScript must pass ESLint using the repository configuration. Command: `npm run lint`
+3. **Type Checking — TSC**: TypeScript must pass the compiler type-check. Avoid `any`; prefer `unknown` plus narrowing. Command: `npm run typecheck`
+4. **Testing — Jest**: All TypeScript unit tests must use Jest. Command: `npm run test:unit`
+
+Run the toolchain in order: format → lint → type-check → test. Restart from step 1 if any step fails or changes files.
+
+## Coding Standards
+
+- New user-invocable workflows belong under `.claude/skills/` rather than `.claude/commands/`.
+- **Strong typing**: Public functions, methods, and exported APIs must have clear, intentional types. Avoid type assertions (`as X`) unless justified.
+- **ES modules**: Use ES module syntax. Do not introduce CommonJS patterns (`require`, `module.exports`).
+- **Domain types**: Model domain concepts with interfaces/types that encode invariants. Prefer discriminated unions for state machines.
+- **Naming**: `PascalCase` for classes, interfaces, enums, and type aliases. `camelCase` for functions, methods, variables, and object properties. No `I` prefix on interfaces.
+- **File naming**: Prefer kebab-case filenames (e.g., `user-session.ts`, `task-runner.ts`).
+- **Separation of concerns**: Keep pure logic separate from VS Code extension APIs, filesystem/network I/O, and UI wiring.
+- **Error handling**: Fail fast with clear errors. Avoid catch-all `catch (e)` without rethrowing or adding context.
+- **Dependencies**: Do not add new runtime dependencies unless explicitly approved.
+
+## Testing Standards
+
+- Use **Jest** as the test framework.
+- Name test files `*.test.ts`.
+- Unit tests must not require the VS Code extension host.
+- Follow Arrange–Act–Assert structure.
+- Each test targets one behavior.
+- Use `jest.spyOn` or `jest.mock` for targeted mocking; reset mocks with `afterEach(() => { jest.resetAllMocks(); })`.
+- No external dependencies (network, filesystem temp files, external processes) in unit tests.
+- Avoid snapshot tests unless stable and intentional.
+- Repository-wide line coverage must remain >= 80%.
+- Any new module, class, or method must reach >= 90% coverage.
+- Coverage command: `npm run test:unit:coverage`
+- Coverage regression on changed lines is a blocking finding.

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

@@ -0,0 +1,144 @@
+{
+  "$schema": "https://json.schemastore.org/claude-code-settings.json",
+  "agent": "orchestrator",
+  "permissions": {
+    "allow": [
+      "Bash(git *)",
+      "Bash(poetry run *)",
+      "Bash(pwsh *)",
+      "Read",
+      "Edit(/docs/**)",
+      "Write(/docs/**)",
+      "Write(/artifacts/**)",
+      "mcp__drmCopilotExtension__run_poshqc_format",
+      "mcp__drmCopilotExtension__run_poshqc_analyze",
+      "mcp__drmCopilotExtension__run_poshqc_test",
+      "mcp__drmCopilotExtension__run_poshqc_analyze_autofix",
+      "mcp__drmCopilotExtension__resolve_execute_hard_lock_prompt",
+      "mcp__drmCopilotExtension__collect_pr_context",
+      "mcp__drmCopilotExtension__new_potential_entry",
+      "mcp__drmCopilotExtension__new_potential_bug_entry",
+      "mcp__drmCopilotExtension__potential_to_issue",
+      "mcp__drmCopilotExtension__new_active_feature_folder",
+      "mcp__drmCopilotExtension__validate_orchestration_artifacts",
+      "mcp__drmCopilotExtension__resolve_atomic_plan_prompt",
+      "Agent(atomic-planner)",
+      "Agent(atomic-executor)",
+      "Agent(feature-review)",
+      "Agent(task-researcher)",
+      "Agent(prd-feature)",
+      "Agent(staged-review)",
+      "Agent(epic-review)",
+      "Agent(status-updater)",
+      "Agent(python-typed-engineer)",
+      "Agent(powershell-typed-engineer)",
+      "Agent(csharp-typed-engineer)",
+      "Agent(typescript-engineer)",
+      "Skill(orchestrate *)",
+      "Skill(commit-message *)",
+      "Skill(pr-author *)",
+      "Skill(research-issue *)",
+      "Skill(review-feature *)",
+      "Skill(review-staged *)",
+      "Skill(review-epic *)",
+      "Skill(update-status *)",
+      "Skill(fill-feature-docs *)",
+      "Skill(python-change-budget-router *)",
+      "Skill(python-qa-gate *)",
+      "Skill(invoke-python-engineer *)",
+      "Skill(powershell-change-budget-router *)",
+      "Skill(powershell-qa-gate *)",
+      "Skill(invoke-powershell-engineer *)",
+      "Skill(translate-copilot-to-claude *)",
+      "Skill(execute-hard-lock *)",
+      "Edit(/.claude/skills/execute-hard-lock/**)",
+      "Edit(/.claude/skills/feature-review-workflow/**)",
+      "Edit(/.claude/skills/csharp-qa-gate/**)"
+    ],
+    "deny": [
+      "Read(./.env)",
+      "Read(./.env.*)",
+      "Read(./secrets/**)",
+      "Edit(./secrets/**)",
+      "Write(./secrets/**)"
+    ],
+    "additionalDirectories": [
+      "c:\\Users\\DanMoisan\\repos\\drm-copilot\\.claude\\skills\\execute-hard-lock"
+    ]
+  },
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "pwsh -NoProfile -File .claude/hooks/validate-bash.ps1"
+          },
+          {
+            "type": "command",
+            "command": "pwsh -NoProfile -File .claude/hooks/enforce-promotion-mcp-only.ps1"
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "pwsh -NoProfile -File .claude/hooks/check-python-test-purity.ps1"
+          },
+          {
+            "type": "command",
+            "command": "pwsh -NoProfile -File .claude/hooks/enforce-python-batch-budget.ps1"
+          },
+          {
+            "type": "command",
+            "command": "pwsh -NoProfile -File .claude/hooks/check-powershell-test-purity.ps1"
+          },
+          {
+            "type": "command",
+            "command": "pwsh -NoProfile -File .claude/hooks/enforce-powershell-batch-budget.ps1"
+          },
+          {
+            "type": "command",
+            "command": "pwsh -NoProfile -File .claude/hooks/enforce-evidence-locations.ps1"
+          }
+        ]
+      }
+    ],
+    "SubagentStop": [
+      {
+        "matcher": "atomic-planner|atomic-executor|feature-review|task-researcher|prd-feature|staged-review|epic-review|status-updater|python-typed-engineer|powershell-typed-engineer|csharp-typed-engineer|typescript-engineer",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "pwsh -NoProfile -Command \"$input = $env:CLAUDE_HOOK_INPUT | ConvertFrom-Json; $output = $input.output; if (-not ($output -match '(plan-path|research-path|review-artifact|PREFLIGHT|evidence/)')) { Write-Error 'Subagent stopped without required completion artifact path'; exit 1 }; exit 0\""
+          }
+        ]
+      },
+      {
+        "matcher": "feature-review",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "pwsh -NoProfile -File .claude/hooks/validate-feature-review-coverage.ps1"
+          }
+        ]
+      },
+      {
+        "matcher": "atomic-planner",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "pwsh -NoProfile -File .claude/hooks/validate-planner-output.ps1"
+          }
+        ]
+      }
+    ]
+  },
+  "enabledPlugins": {
+    "skill-creator@claude-plugins-official": true
+  },
+  "defaultPermissionMode": "bypassPermissions"
+}

package/resources/claude-customizations/.claude/skills/acceptance-criteria-tracking/SKILL.md

@@ -0,0 +1,102 @@
+---
+name: acceptance-criteria-tracking
+description: 'Track and check off acceptance criteria in requirement source files (issue.md, spec.md, user-story.md) as they are delivered. Use when executing plans, reviewing features, or validating delivery to keep AC checkboxes current.'
+---
+
+# Acceptance Criteria Tracking
+
+Shared protocol for identifying, tracking, and checking off acceptance criteria (AC) in their source requirement files as work is delivered and verified.
+
+## When to Use This Skill
+
+Use this skill when:
+- Executing an atomic plan that delivers work satisfying acceptance criteria.
+- Reviewing a feature branch and verifying acceptance criteria.
+- Validating small-path or large-path delivery against requirement files.
+- Any agent completes work that satisfies one or more acceptance criteria from `issue.md`, `spec.md`, or `user-story.md`.
+
+## AC Source Resolution (by Work Mode)
+
+Resolve the authoritative acceptance-criteria source file(s) using the work-mode marker from `issue.md`, per the mode rules in `feature-promotion-lifecycle` and `atomic-plan-contract`:
+
+| Work Mode | AC Source File(s) |
+|---|---|
+| `minor-audit` | `issue.md` only |
+| `full-feature` | `spec.md` and `user-story.md` |
+| `full-bug` | `spec.md` only |
+| legacy `full` | normalize to `full-feature` for compatibility |
+| missing / malformed | fail closed to `full-feature` (`spec.md` + `user-story.md`) |
+
+Deterministic mode rule: use the persisted `- Work Mode: ...` marker from `issue.md` as the single source of truth. `full-feature` always means `spec.md` **and** `user-story.md`; `full-bug` always means `spec.md` **only**; legacy `full` always normalizes to `full-feature`.
+
+For `minor-audit`, require an explicit `## Acceptance Criteria` section in `issue.md`. Do not treat other `issue.md` checkbox sections as acceptance criteria for `minor-audit`.
+
+When multiple AC source files exist, track checkboxes in **each** applicable file independently.
+
+## AC Identification
+
+Acceptance criteria are markdown checkbox items within AC source files.
+
+Deterministic heading rule:
+- For `minor-audit`, acceptance criteria MUST live under the exact heading `## Acceptance Criteria` in `issue.md`.
+- For other work modes, headings such as `## Acceptance Criteria`, `### Acceptance Criteria`, or `## Done When` may still be used when they are the authoritative AC source file.
+
+AC items use the standard markdown checkbox format:
+- `- [ ] <criterion text>` (not yet delivered)
+- `- [x] <criterion text>` (delivered and verified)
+
+If the explicit `minor-audit` section is missing, fail closed instead of guessing from other issue sections. If AC items are not in checkbox format (e.g., numbered lists or prose), do NOT reformat them. Instead, note their status in the agent's own tracking artifacts (plan checklist, feature-audit, etc.) and document that the source file uses a non-checkbox format.
+
+## Check-Off Protocol
+
+### Rules (non-negotiable)
+
+1. **Evidence before check-off**: Only mark an AC item `[x]` after the work satisfying it has been **implemented and verified** (e.g., tests pass, toolchain clean, code reviewed).
+2. **One-at-a-time**: Check off each AC item individually as the corresponding work is verified. Do not batch-check items without individual verification.
+3. **Preserve text**: When checking off, change only `- [ ]` to `- [x]`. Do not modify the criterion text.
+4. **Leave unmet items unchecked**: If an AC item cannot be fully delivered or verified, leave it as `- [ ]` and document the gap in the appropriate artifact (plan checklist, remediation inputs, or feature-audit).
+5. **No phantom criteria**: Do not add new AC items to source files. AC items are authored by planning/scoping agents, not by executors or reviewers.
+
+### When Executors Check Off AC
+
+During plan execution, after completing a task whose work satisfies an acceptance criterion:
+
+1. Identify which AC item(s) in the resolved source file(s) are satisfied by the completed task.
+2. Verify the work meets the criterion (task acceptance criteria passed, tests pass, etc.).
+3. Update the AC source file(s): change `- [ ]` to `- [x]` for the satisfied criterion.
+4. Report the check-off in the task's progress output (e.g., "Checked off AC: `<criterion text>` in `issue.md`").
+
+Timing: Check off AC items as soon as the corresponding plan task passes verification — do not defer all AC updates to the end of plan execution.
+
+### When Reviewers Check Off AC
+
+During feature review (feature-audit phase):
+
+1. For each AC item evaluated as **PASS** in the feature-audit evaluation table, check it off in the source file(s) if not already checked.
+2. For items evaluated as **PARTIAL**, **FAIL**, or **UNVERIFIED**, leave them unchecked and document the gap.
+3. Report any newly checked-off items in the feature-audit artifact.
+
+### When Orchestrators Enforce AC Tracking
+
+Orchestrators do not directly check off AC items. Instead:
+
+1. Ensure delegated executors and reviewers reference this skill.
+2. After executor or reviewer completion, verify that AC source files reflect delivered work (spot-check; do not re-execute verification).
+3. If AC items remain unchecked after all delegated work completes, flag them in the orchestration summary as outstanding acceptance criteria.
+
+## AC Status Summary (Required at Completion)
+
+At the end of plan execution or feature review, report an AC summary:
+
+```
+### Acceptance Criteria Status
+- Source: <file path(s)>
+- Total AC items: <N>
+- Checked off (delivered): <M>
+- Remaining (unchecked): <N - M>
+- Items remaining: <list of unchecked criterion texts, if any>
+```
+
+This summary must appear in:
+- The executor's final completion report (after last plan task).
+- The reviewer's feature-audit artifact (Phase F or equivalent).

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

@@ -0,0 +1,189 @@
+---
+name: atomic-plan-contract
+description: 'Atomic plan format and toolchain contract shared by planning and execution agents. Use when generating, validating, or executing atomic plans with Phase 0, baseline capture, and final QA loops.'
+---
+
+# Atomic Plan Contract
+
+Shared rules for atomic plan formatting, Phase 0 requirements, baseline capture, and final QA loops.
+
+## When to Use This Skill
+
+Use this skill when:
+- Creating or validating atomic plans.
+- Executing plans with strict format requirements.
+- Enforcing Phase 0 policy reading + baseline capture and final QA loops.
+
+## Canonical Plan Format
+
+- Phase headings must be: `### Phase N — <Title>`
+- Tasks must start with: `- [ ] [P#-T#]` (or `[x]` for completed)
+- Task IDs must match their phase and be sequential per phase.
+- Plans must pass the `mcp__drmCopilotExtension__validate_orchestration_artifacts` MCP tool with `artifact_type: "plan"` and `artifact_path: <plan-path>` before they can be reported as approved.
+
+## Short-Path Minimal Plan Contract
+
+When orchestration selects short path, a minimal plan is still mandatory and must include these blocks:
+
+1) Baseline capture block
+- policy reads in required order,
+- baseline toolchain/test state capture for each language that has explicit baseline command tasks in the plan.
+- required artifacts:
+	- a Phase 0 policy-read evidence artifact in the canonical evidence location defined by `evidence-and-timestamp-conventions`
+	- one baseline artifact per baseline command step (no aggregate-only baseline artifact)
+	- each baseline step artifact MUST include: `Timestamp:`, `Command:`, `EXIT_CODE:`, `Output Summary:`
+	- baseline test-step artifacts for languages with mandatory coverage policy MUST include numeric coverage headline values in `Output Summary:` (baseline percent and, when applicable, targeted module/new-code percent).
+
+2) Delegated implementation block
+- explicit handoff task to the small-path implementation engineer,
+- acceptance criteria for implementation completion.
+
+3) Final QC block
+- full language-appropriate QA loop (format → lint → type-check when applicable → test),
+- rerun behavior when any step changes files or fails.
+- one final-QC artifact per QC command step (no aggregate-only final-QC artifact)
+- each final-QC step artifact MUST include: `Timestamp:`, `Command:`, `EXIT_CODE:`, `Output Summary:`
+- final-QC test commands for languages with mandatory coverage policy MUST run in coverage mode and record numeric post-change coverage values in `Output Summary:`.
+- final-QC command tasks that are present in the approved plan MUST execute their stated commands; `SKIPPED` is invalid unless the task text itself explicitly authorizes a skip condition.
+
+4) Reduced audit block
+- explicit post-implementation small-audit handoff,
+- reduced artifact checks required by short-path policy.
+
+## Minimal-Audit Directive Contract (Small Path)
+
+For short-path planning handoffs, orchestrators MUST include:
+- `DIRECTIVE: MINIMAL-AUDIT PLAN REQUIRED`
+
+Required planner outputs for this directive:
+- plan MUST use `${feature-folder}/issue.md` as sole requirements source,
+- plan MUST require `${feature-folder}/issue.md` to contain an explicit `## Acceptance Criteria` section and MUST treat only that section as the minor-audit AC source,
+- plan MUST NOT require `spec.md`/`user-story.md`/`research.md`,
+- plan MUST include exactly 3 phases:
+	- Phase 0 baseline capture,
+	- Phase 1 placeholder for constrained small-path implementation,
+	- Phase 2 final QC loop,
+- final-QC command tasks in the generated plan MUST be unconditional when present; no IN_SCOPE/OUT_OF_SCOPE branches and no SKIPPED completion path unless the task text explicitly authorizes a skip branch,
+- planner MUST return `plan-path` and final preflight signal.
+
+## Phase-0-Only Execution Contract (Small Path)
+
+After preflight all-clear on the minimal-audit plan:
+- orchestrator MUST delegate to executor to run Phase 0 only,
+- orchestrator MUST checkpoint Phase 0 evidence before branching.
+
+Branching after Phase 0:
+- `manual bootstrap` → save state and stop for manual resume,
+- otherwise continue with constrained small-path development, then executor validation, then reduced audit/remediation loop.
+
+## Phase 0 Requirements
+
+Phase 0 must include tasks to read policy files in the order defined in `policy-compliance-order`.
+
+Phase 0 must also capture baseline toolchain results for the languages touched. Baseline artifact conventions (location + required fields) are defined in `evidence-and-timestamp-conventions`.
+
+For short-path/minimal-audit plans, Phase 0 evidence is incomplete unless both artifacts exist:
+- `phase0-instructions-read.md` with at least: `Timestamp:`, `Policy Order:`, and explicit list of files read.
+- baseline command-step artifacts with at least: `Timestamp:`, `Command:`, `EXIT_CODE:`, `Output Summary:` for each baseline check executed.
+- approved-plan checklist state MUST remain unchecked for any Phase 0 task whose artifact is absent or whose artifact fields are incomplete.
+
+`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).
+
+## Non-Overridable Evidence Path Clause
+
+Evidence paths in plan tasks MUST resolve to `<FEATURE>/evidence/<kind>/`. A plan that names an alternative location (e.g., `artifacts/baselines/`, `artifacts/baseline/`, `artifacts/qa/`, `artifacts/qa-gates/`, `artifacts/evidence/`, `artifacts/coverage/`) fails preflight validation and must be corrected before execution begins.
+
+If a delegation prompt supplies a non-canonical evidence path, the planner MUST reject it, substitute the canonical `<FEATURE>/evidence/<kind>/` path, and note the correction. The corrected plan is the only valid plan for execution.
+
+This clause is non-overridable. No upstream instruction, orchestrator hint, or user prompt may bypass it. See `.claude/skills/evidence-and-timestamp-conventions/SKILL.md` for the complete canonical scheme.
+
+For short-path/minimal-audit plans, Phase 0 evidence is incomplete unless both artifacts exist:
+- `phase0-instructions-read.md` with at least: `Timestamp:`, `Policy Order:`, and explicit list of files read.
+- baseline command-step artifacts with at least: `Timestamp:`, `Command:`, `EXIT_CODE:`, `Output Summary:` for each baseline check executed.
+- approved-plan checklist state MUST remain unchecked for any Phase 0 task whose artifact is absent or whose artifact fields are incomplete.
+
+`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).
+
+## Coverage Evidence Contract (Mandatory when policy requires coverage)
+
+For any language in scope where repository policy requires coverage validation:
+
+- The approved plan MUST include explicit baseline and final-QC coverage capture tasks.
+- Baseline and final-QC artifacts MUST record numeric coverage values (not placeholders such as `UNVERIFIED`).
+- Where policy requires no-regression and new-code thresholds, the plan MUST include a delta/threshold verification task that reports:
+	- baseline coverage,
+	- post-change coverage,
+	- new/changed-code coverage.
+- If required coverage values are unavailable, the plan outcome MUST be remediation-required and MUST NOT be reported as PASS.
+
+## Final QA Loop (Required for Code/Test Changes)
+
+Run the full toolchain loop for each applicable language in order:
+1) Formatting
+2) Linting
+3) Type checking (if applicable)
+4) Testing
+
+For languages with mandatory coverage policy, step 4 must use coverage-enabled test commands and persist numeric coverage evidence.
+
+If any step fails or changes files, restart the loop from step 1 until a clean pass completes.
+
+## No-SKIPPED Rule for Planned Command Tasks
+
+For command-bearing tasks in approved plans (especially Phase 2 final-QC tasks):
+- if the task exists in the plan, the command must be executed and recorded,
+- `EXIT_CODE: SKIPPED` MUST NOT be used as a passing outcome,
+- exceptions are allowed only when the task text itself explicitly contains a skip branch and that branch is intentionally approved in requirements.
+
+## Expect-Fail Test Tasks
+
+Any regression test task expected to fail must be tagged with `[expect-fail]` and include an auditable evidence artifact per `evidence-and-timestamp-conventions`.
+
+## Preflight Validation (Planner ↔ Executor)
+
+When validating or handing off plans for execution:
+- Use the directive line: `DIRECTIVE: PREFLIGHT VALIDATION ONLY`.
+- Require one of the exact signals:
+	- `PREFLIGHT: ALL CLEAR`
+	- `PREFLIGHT: REVISIONS REQUIRED`
+- If revisions are required, provide a precise plan delta and repeat validation until all clear.
+- If the required planner ↔ executor handoff cannot be started or completed, stop and report blocked state; do not self-approve the plan.
+
+## Validator Gate (Mandatory)
+
+Before a plan can be treated as approved:
+
+- run the `mcp__drmCopilotExtension__validate_orchestration_artifacts` MCP tool with `artifact_type: "plan"` and `artifact_path: <plan-path>`,
+- reject the plan if that validator exits non-zero,
+- do not treat human-readable summaries as a substitute for validator success.
+
+## Plan-Path Continuity Contract (Mandatory)
+
+When a caller provides an explicit target plan file path (for example `${plan-path}` or `${file}`):
+
+- Planner MUST update that exact file in place.
+- Planner MUST reuse the same file for all preflight revision iterations.
+- Planner MUST NOT create additional timestamped sibling files (for example `plan.<timestamp>.md`) during the same planning cycle.
+
+If the provided path does not exist, it may be created once, then reused for all subsequent revisions in that cycle.
+
+## Mode source precedence (Mandatory)
+
+When a plan is generated or validated from a feature folder, resolve selected mode in this order:
+
+1) Persisted marker in `issue.md` metadata block:
+	- `- Work Mode: minor-audit`
+	- `- Work Mode: full-feature`
+	- `- Work Mode: full-bug`
+2) Legacy compatibility marker `- Work Mode: full` resolves to `full-feature`
+3) Explicit workflow override only when repo policy allows and only when reconciled against `issue.md`
+4) Fail closed to `full-feature` when marker is missing or malformed
+
+## Mode-Specific Mandatory Plan Gates
+
+- `minor-audit` plans MUST include baseline evidence tasks, targeted verification evidence tasks, and end-state evidence tasks.
+- `minor-audit` plans MUST require `${feature-folder}/issue.md` to contain an explicit `## Acceptance Criteria` section; do not infer acceptance criteria from other `issue.md` sections.
+- `minor-audit` plans MUST NOT treat missing `spec.md` or `user-story.md` as automatic blockers.
+- `minor-audit` execution/validation/audit MUST fail closed when `spec.md` or `user-story.md` exists unexpectedly in the active folder, when the explicit `## Acceptance Criteria` section is missing from `issue.md`, when required Phase 0 artifacts are missing, or when checklist state contradicts evidence on disk.
+- `full-feature` plans MUST enforce full-document expectations (`spec.md` + `user-story.md`) and full QA loop obligations.
+- `full-bug` plans MUST enforce spec-driven expectations (`spec.md` required, `user-story.md` optional/absent by default) and full QA loop obligations.

package/resources/claude-customizations/.claude/skills/commit-message/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: commit-message
+description: Generate a conventional commit message from staged Git changes following the repository's commit message conventions.
+allowed-tools:
+  - Read
+  - "Bash(git log *)"
+  - "Bash(git diff *)"
+---
+
+# Commit Message Skill
+
+Generate a single conventional commit message from staged Git changes or a provided commit-context artifact.
+
+## Inputs
+
+- Staged Git changes are the primary source of truth.
+- Accept a commit-context artifact file when explicitly provided.
+- Ignore unstaged changes unless included in the provided context.
+- If no staged changes and no context artifact exist, stop and report that there is no in-scope commit content.
+
+## Context Gathering
+
+1. Use the supplied commit-context artifact first when present.
+2. Otherwise inspect the staged diff and commit history only:
+   - `git diff --cached --stat`
+   - `git diff --cached`
+   - `git diff --cached --name-only`
+   - `git log --oneline -n 20`
+3. Do not infer intent from unstaged files or unrelated commit history.
+
+## Classification
+
+Follow Conventional Commits semantics. Choose exactly one primary type from: `feat`, `fix`, `docs`, `test`, `refactor`, `ci`, `chore`.
+
+- Use the dominant intent of the staged changes.
+- Prefer `docs`, `test`, or `fix` over `chore` when classification is ambiguous.
+- Add a scope only when it materially improves clarity. Keep scopes concrete and subsystem-oriented.
+
+## Message Format
+
+Output exactly one fenced code block with language tag `text` containing the commit message:
+
+```text
+type(optional-scope): concise imperative summary
+
+- Bullet describing meaningful change #1
+- Bullet describing meaningful change #2
+
+Refs: #<issue>
+```
+
+Header rules: imperative mood, 72 characters or fewer, no trailing period, no filler words.
+
+Body rules: use bullets only when they add signal beyond the header. Avoid implementation trivia.
+
+Reference rules: include `Refs:` footer only when issue or PR references are present in the context. Do not invent references.
+
+## Prohibitions
+
+- No emojis
+- No commentary outside the fenced code block
+- No Markdown inside the commit body beyond plain-text hyphen bullets
+- No references to "this commit"
+- No speculation about unstaged work
+- No multiple alternative commit messages