@danmoisan/drm-copilot-mcp 0.0.1

package/resources/claude-customizations/.claude/skills/research-issue/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: research-issue
+description: Investigate the best implementation approach for a feature or bug by analyzing the codebase and external references, then writing structured findings to artifacts/research/.
+allowed-tools:
+  - Read
+  - Grep
+  - Glob
+  - WebFetch
+---
+
+# Research Issue Skill
+
+Research the best implementation approach for a feature or bug described in the provided issue and spec documents. Output is a structured research file, not implementation code.
+
+## Inputs
+
+Accept one or more feature documents as context:
+
+- `docs/features/active/<feature>/issue.md` (primary)
+- `docs/features/active/<feature>/user-story.md` (when present)
+- `docs/features/active/<feature>/spec.md` (when present)
+
+## Output
+
+Create or update a single research file:
+
+- Path: `artifacts/research/<timestamp>-<short-name>-research.md`
+- Use the Task Researcher template from the repository exactly.
+- Place rejected-alternatives summaries inside `## Recommended Approach`, not as a separate top-level header.
+
+## Investigation Areas
+
+### 1. Current State Analysis
+
+- Identify implementation targets from the feature docs.
+- Read relevant modules end-to-end.
+- Document current behavior, key abstractions, extension points, and toolchain constraints.
+
+### 2. Candidate Implementation Approaches
+
+- Research and compare at least two viable approaches.
+- Select one final recommendation with justification.
+- For any new dependency, confirm whether it already exists in the repo and justify adding it.
+- Gather authoritative external documentation to support the recommendation.
+
+### 3. Behavior Semantics and Edge Cases
+
+- Extract intended behavior from feature docs.
+- Define success/failure conditions, ordering rules, cancellation behavior, and CI vs. local expectations.
+- Research comparable tools that implement similar semantics.
+
+### 4. Requirements Mapping to Design
+
+- Map acceptance criteria into a concrete design.
+- Propose state model, transitions, internal API boundaries, and required file changes.
+
+### 5. Testing Implications
+
+- Propose a test strategy consistent with repository policy (unit tests for pure logic, integration seams).
+- Do not write test code; describe the strategy only.
+
+## Constraints
+
+- Research only. Do not implement changes.
+- Ground all findings in verified evidence from the codebase and authoritative external sources.
+- Keep discussion of non-selected approaches brief.
+- Do not claim or perform nested worker delegation.

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

@@ -0,0 +1,21 @@
+---
+name: review-epic
+description: Invoke the epic-review worker to produce epic-audit artifacts for an epic folder.
+---
+
+# Review Epic Skill
+
+This direct-use wrapper delegates review work to the `epic-review` worker.
+
+## Inputs
+
+- Active epic folder path
+- Evidence and child-feature context under that epic
+
+## Output Paths
+
+- `docs/features/epics/<epic>/epic-audit.<timestamp>.md`
+
+## Worker Routing
+
+- Worker: `epic-review`

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

@@ -0,0 +1,25 @@
+---
+name: review-feature
+description: Invoke the feature-review worker to produce feature-audit artifacts for an active feature folder.
+---
+
+# Review Feature Skill
+
+This direct-use wrapper delegates review work to the `feature-review` worker.
+
+## Inputs
+
+- Active feature folder path
+- Existing implementation, evidence, and requirement files under that folder
+
+## Output Paths
+
+When the active review scope is a selected version folder such as `docs/features/active/<feature>/v2/`, write the review artifacts into that selected version folder rather than the parent feature root.
+
+- `docs/features/active/<feature-or-selected-version>/policy-audit.<timestamp>.md`
+- `docs/features/active/<feature-or-selected-version>/code-review.<timestamp>.md`
+- `docs/features/active/<feature-or-selected-version>/feature-audit.<timestamp>.md`
+
+## Worker Routing
+
+- Worker: `feature-review`

package/resources/claude-customizations/.claude/skills/review-staged/SKILL.md

@@ -0,0 +1,21 @@
+---
+name: review-staged
+description: Invoke the staged-review worker to produce staged-review artifacts from the staged diff.
+---
+
+# Review Staged Skill
+
+This direct-use wrapper delegates review work to the `staged-review` worker.
+
+## Inputs
+
+- Current staged diff
+- Repository context needed to review staged changes
+
+## Output Paths
+
+- `artifacts/reviews/staged-review.<timestamp>.md`
+
+## Worker Routing
+
+- Worker: `staged-review`

package/resources/claude-customizations/.claude/skills/skill-canonical-location-audit/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: skill-canonical-location-audit
+description: 'Audit skills for canonical-location duplication. Use when ensuring a canonical location for a given item is defined in exactly one skill and duplicates are flagged.'
+---
+
+# Skill Canonical-Location Audit
+
+Audit skills to ensure canonical locations for the same item are not defined in multiple places.
+
+## When to Use This Skill
+
+Use this skill when:
+- You add or update skills that define canonical locations.
+- You want to verify that canonical paths live in exactly one skill.
+- You need a duplication report listing which skills conflict.
+
+## Scope
+
+- Applies to all skills under `.claude/skills/**/SKILL.md`.
+- Focuses on canonical locations (paths, folders, or file names) for a given item (e.g., PR context artifacts, evidence locations, issue mirrors).
+
+## Audit Workflow
+
+1) Inventory canonical-location statements
+   - Read each `SKILL.md` and extract explicit canonical location statements (paths, folders, file names).
+   - Group statements by the item they describe (e.g., “PR context summary”, “baseline evidence”).
+
+2) Detect duplicates
+   - For each item group, verify that exactly one skill defines its canonical location.
+   - If two or more skills define the same item’s canonical location, flag it as a duplication.
+
+3) Report results
+   - Produce a short report listing:
+     - The item with duplicated canonical location
+     - The conflicting skills
+     - A recommendation for consolidation (name the single skill to keep as source-of-truth)
+
+## Output Template (Suggested)
+
+- Item: <canonical item name>
+  - Skills with definitions: <skill A>, <skill B>, ...
+  - Recommendation: Keep <skill X> as canonical; remove duplicates from others.
+
+## Notes
+
+- If a skill references a canonical location indirectly (e.g., “see evidence-and-timestamp-conventions”), do NOT treat that as a duplication.
+- Only treat explicit canonical paths or filenames as definitions.
+
+

package/resources/claude-customizations/.claude/skills/translate-copilot-to-claude/SKILL.md

@@ -0,0 +1,295 @@
+---
+name: translate-copilot-to-claude
+description: Translate one or more GitHub Copilot native files (.github/copilot-instructions.md, .github/instructions/*.instructions.md, .github/agents/*.agent.md, .github/prompts/*.prompt.md, .github/skills/<name>/SKILL.md) into the native Claude runtime. Classify each section into agent/rule/skill/hook surfaces, diff against existing .claude/ state, produce a translation plan for user approval, and then apply the plan.
+---
+
+# Translate Copilot to Claude
+
+Deterministic translation workflow that ports GitHub Copilot native files into the `.claude/` runtime without duplicating content, overwriting user edits, or breaking existing agents.
+
+## When to Use This Skill
+
+Use this skill when:
+
+- One or more `.github/` native files must be mirrored into `.claude/`.
+- An agent persona needs to be split across Claude's four runtime surfaces.
+- A batch of instructions files must be re-expressed as path-scoped Claude rules.
+- A Copilot prompt or skill must be reshaped into a Claude skill.
+- The user wants to know what is missing or out-of-date on the Claude side before making changes.
+
+## Inputs
+
+Required:
+
+- One or more source paths under `.github/`. Accepted types:
+  - `.github/copilot-instructions.md`
+  - `.github/instructions/<name>.instructions.md`
+  - `.github/agents/<name>.agent.md`
+  - `.github/prompts/<name>.prompt.md`
+  - `.github/skills/<name>/SKILL.md`
+
+Optional:
+
+- `mode=plan-only` — do not write anything; emit the translation plan and stop.
+- `mode=apply` — apply the plan after it is produced and approved in the same turn.
+- `target-scope=<agent|rule|skill|hook|all>` — restrict surfaces considered for this run.
+- `timestamp-override=<ISO-8601>` — override the auto-generated evidence folder timestamp.
+
+Default mode is `plan-only`. Apply requires explicit confirmation either via `mode=apply` or a plain-text approval in the same turn.
+
+## Phase 1 — Intake and Section Extraction
+
+For each input file:
+
+1. Read the full file with `Read`.
+2. Parse YAML frontmatter (name, description, tools, applyTo, agent, handoffs, model, other keys).
+3. Split the body into top-level sections delimited by `#`, `##`, `###` headings.
+4. Classify each section as declarative, procedural, enforceable, identity, or handoff per the taxonomy in Phase 2.
+5. Record each section as `{source_path, heading, classification, raw_content}` in an in-memory list.
+
+Never modify or delete source files. Translation is a copy-forward operation.
+
+## Phase 2 — Classification Taxonomy
+
+Apply these decision rules in order. Use the first rule that matches.
+
+### 2.1 Enforceable (hard gate / hard stop) -> `.claude/hooks/`
+
+A section is enforceable when it contains:
+
+- phrases such as "hard gate", "hard stop", "must not", "blocked", "forbidden", "zero-regression", "non-negotiable",
+- command or path blacklists that should be rejected regardless of model intent,
+- per-batch counting or budget limits,
+- toolchain-execution verification ("must run", "no unverified work"),
+- test-purity forbiddens (tempfile, network, subprocess in tests).
+
+Target:
+
+- A new or updated script under `.claude/hooks/<name>.ps1`.
+- Registration in `.claude/settings.json` under `hooks.PreToolUse` or `hooks.SubagentStop` with a `matcher` that targets the affected tools (`Bash`, `Write|Edit`, specific agent names).
+
+Hooks must be read-only validation gates unless the user explicitly authorizes state mutation. Prefer exit code 0 with a `{"decision":"block","reason":"..."}` JSON response over a non-zero exit when feedback to the agent is required.
+
+### 2.2 Declarative standards (always-on for matching files) -> `.claude/rules/`
+
+A section is declarative when it contains:
+
+- coding conventions (naming, typing, imports, error handling),
+- test structure requirements,
+- toolchain ordering statements,
+- file-size limits,
+- language-specific style rules.
+
+Target:
+
+- An existing rule file under `.claude/rules/` that already covers the same path scope, merged into place.
+- A new rule file under `.claude/rules/<language-or-topic>.md` with frontmatter:
+
+    ```yaml
+    ---
+    paths:
+      - "<glob>"
+    description: "<one line>"
+    ---
+    ```
+
+- If the source frontmatter used `applyTo: "<glob>"`, convert to `paths: [<glob>]`.
+
+### 2.3 Reusable procedures -> `.claude/skills/<name>/SKILL.md`
+
+A section is procedural when it contains:
+
+- multi-step workflows ("Phase A", "Phase B", "Workflow", numbered steps),
+- reporting templates,
+- routing decision tables,
+- delegation contracts.
+
+Target:
+
+- An existing skill under `.claude/skills/` when one already covers the same concept (check `.claude/skills/<name>/SKILL.md` by name and description).
+- A new skill at `.claude/skills/<name>/SKILL.md` when no coverage exists. Use the `make-skill-template` skill as the scaffold if needed. Frontmatter must include `name` and `description`.
+
+Copilot `.github/prompts/*.prompt.md` and `.github/skills/<name>/SKILL.md` default to this target. Preserve the original name when it does not collide with an existing Claude skill.
+
+### 2.4 Identity and preload manifest -> `.claude/agents/<name>.md`
+
+A section belongs on the persona when it contains:
+
+- agent name, description, role summary,
+- tool allowlist,
+- model selection,
+- skill preloads,
+- memory scope,
+- a short workflow index pointing to preloaded skills,
+- stop conditions.
+
+Target:
+
+- An existing agent file under `.claude/agents/<name>.md`. Update only the preload list, tools, description, and stop conditions. Keep the body thin.
+- A new agent file when the Copilot persona has no Claude counterpart. Do not duplicate rule, skill, or hook content into the persona body.
+
+### 2.5 Handoffs and delegation -> reference existing skills
+
+Sections describing handoffs to other agents ("delegate to atomic_planner", "handoffs:" frontmatter) should not be duplicated. Reference the canonical skill:
+
+- plan authoring -> `atomic-plan-contract`
+- remediation -> `remediation-handoff-atomic-planner`
+- promotion lifecycle -> `feature-promotion-lifecycle`
+- PR context -> `pr-context-artifacts`
+- evidence storage -> `evidence-and-timestamp-conventions`
+
+### 2.6 Repo-wide tone / policy precedence -> `CLAUDE.md`
+
+Sections that state cross-cutting repository defaults (tone, policy reading order, architectural overview) belong in `CLAUDE.md` and should be cross-referenced from `.claude/rules/` rather than restated.
+
+### 2.7 Out-of-scope content
+
+The following content is **not** translated:
+
+- GitHub Actions workflow YAML under `.github/workflows/`.
+- Codex or other non-Copilot customizations under `.github/codex/` unless explicitly requested.
+- Copilot `chatmodes` unless the user specifies a target Claude surface.
+
+## Phase 3 — Target Resolution
+
+For each classified section, compute a concrete target path:
+
+1. **Hook**: `.claude/hooks/<verb-noun>.ps1` where the verb is `check|enforce|validate` and the noun is the concern (for example, `check-python-test-purity.ps1`, `enforce-python-batch-budget.ps1`).
+2. **Rule**: `.claude/rules/<topic>.md` where topic is the language (`python.md`, `csharp.md`, `powershell.md`, `typescript.md`) or cross-cutting concern (`tonality.md`, `general-code-change.md`, `general-unit-test.md`).
+3. **Skill**: `.claude/skills/<kebab-case-name>/SKILL.md`. Prefer verb-first names for action skills (`review-feature`, `implement-python`, `invoke-python-engineer`) and topic names for contract skills (`python-qa-gate`, `atomic-plan-contract`).
+4. **Agent**: `.claude/agents/<kebab-case-name>.md`. Normalize underscores to hyphens (`python_typed_engineer` -> `python-typed-engineer`).
+5. **CLAUDE.md**: single repo-wide file at the workspace root.
+6. **settings.json**: `.claude/settings.json` sections `hooks` and `permissions`.
+
+Record target paths in the plan. Do not write anything yet.
+
+## Phase 4 — Existing State Diff
+
+For every target path:
+
+1. `Read` the existing file when it exists.
+2. Compute a per-section delta:
+   - **add** — the section does not exist in the target.
+   - **replace** — the section exists but the source content supersedes it (explicit user intent).
+   - **merge** — the section exists and source content must be appended or integrated without removing existing text.
+   - **skip** — the section is already present verbatim or has a newer canonical form in the target.
+   - **conflict** — the source and target disagree on substantive content; requires user decision.
+3. For `.claude/settings.json`, compute add-only updates to `hooks.*` arrays and `permissions.allow`. Never remove existing permissions without explicit instruction.
+4. For agent personas already present, prefer **merge** over **replace** to preserve hand-authored guidance.
+
+Flag every `conflict` row in the plan. Conflicts stop Phase 6 for that row until resolved.
+
+## Phase 5 — Translation Plan Artifact
+
+Write a translation plan to `artifacts/translation/<timestamp>/plan.md`. The timestamp is ISO-8601 UTC, for example `2026-04-18T14-30-00Z`, per `evidence-and-timestamp-conventions`.
+
+Plan structure:
+
+```markdown
+# Translation Plan: <source file basename(s)>
+
+Generated: <timestamp>
+Mode: <plan-only | apply>
+
+## Inputs
+- <source path 1>
+- <source path 2>
+
+## Mapping Table
+| Source Section | Classification | Target Path | Action |
+|---|---|---|---|
+| <source#section-anchor> | rule | .claude/rules/python.md#pytest-rules | merge |
+| <source#section-anchor> | hook | .claude/hooks/check-python-test-purity.ps1 | add |
+| <source#section-anchor> | skill | .claude/skills/python-qa-gate/SKILL.md | add |
+| <source#section-anchor> | agent | .claude/agents/python-typed-engineer.md | merge |
+| <source#section-anchor> | settings | .claude/settings.json | add |
+
+## Conflicts (require user decision)
+<one row per conflict, or "none">
+
+## New Files
+<list of new file paths>
+
+## Updated Files
+<list of modified file paths>
+
+## Settings Delta
+- Hooks added: <list>
+- Permissions added: <list>
+- Matchers extended: <list>
+
+## Evidence Paths
+- artifacts/translation/<timestamp>/plan.md
+- artifacts/translation/<timestamp>/diff.md (populated after apply)
+```
+
+Always produce the plan artifact, even in `mode=apply` runs, for auditability.
+
+## Phase 6 — Apply (only after explicit approval)
+
+Only execute when one of the following holds:
+
+- The user invoked the skill with `mode=apply`.
+- The user sent a plain-text approval ("proceed", "apply", "execute the plan") in the same turn after the plan was shown.
+
+Apply order (to minimize breakage):
+
+1. **Rules** — add or merge rule files under `.claude/rules/`.
+2. **Skills** — add or merge skill files under `.claude/skills/<name>/SKILL.md`.
+3. **Hooks** — add hook scripts under `.claude/hooks/` and parse-check them with `pwsh -NoProfile -Command "[System.Management.Automation.Language.Parser]::ParseFile(..., [ref]$null, [ref]$errors)"`.
+4. **Agent personas** — update `.claude/agents/<name>.md` frontmatter (tools, skills, memory) and trim the body to identity + workflow index.
+5. **settings.json** — append hook registrations and `Skill(...)` permissions. Never rewrite the file; use targeted edits.
+6. **CLAUDE.md** — append cross-references only; never overwrite existing sections.
+7. **Evidence** — write `artifacts/translation/<timestamp>/diff.md` summarizing what was actually changed, and store a copy of every new or modified file path under `artifacts/translation/<timestamp>/snapshots/`.
+
+After apply, run a verification sweep:
+
+- Parse-check every new or changed `.ps1` under `.claude/hooks/`.
+- JSON-parse `.claude/settings.json` to confirm validity.
+- Confirm every new skill appears in the skills catalog by reading back the first five lines of each target file.
+- Report the final mapping table with `done` / `skipped` / `conflict-unresolved` statuses.
+
+## Phase 7 — Reporting
+
+Every completion response must include:
+
+1. **Inputs** — list of source files.
+2. **Mapping summary** — counts by classification (rule, skill, hook, agent, settings).
+3. **Action summary** — counts by action (add, replace, merge, skip, conflict).
+4. **Files changed** — explicit list of created and modified paths.
+5. **Settings delta** — hooks and permissions added.
+6. **Evidence paths** — artifact locations.
+7. **Conflicts** — unresolved conflict rows, or "none".
+
+## Guarantees and Prohibitions
+
+- **Idempotency**: running the skill twice on the same input produces no new changes beyond the regenerated plan artifact.
+- **No source deletion**: `.github/` files are never modified or removed.
+- **No silent overwrites**: existing `.claude/` content is merged by default. Replace requires either user instruction or a `conflict` row resolved explicitly.
+- **No hook-based state mutation**: hooks generated by this skill are validation-only unless the user authorizes otherwise.
+- **No settings.json rewrites**: only targeted edits that append permissions or matchers.
+- **No translation of out-of-scope surfaces**: `.github/workflows/`, `.github/codex/`, and unrecognized file types are skipped and listed under "Skipped inputs" in the plan.
+
+## Classification Quick Reference
+
+| Copilot source pattern | Default Claude target | Notes |
+|---|---|---|
+| `.github/copilot-instructions.md` | `CLAUDE.md` + `.claude/rules/tonality.md` | Tone and precedence only. |
+| `.github/instructions/*.instructions.md` (applyTo) | `.claude/rules/<topic>.md` (paths) | Direct frontmatter rewrite. |
+| `.github/agents/*.agent.md` identity frontmatter | `.claude/agents/<name>.md` frontmatter | Convert `tools:` to Claude tool names. |
+| `.github/agents/*.agent.md` "Absolute guardrails / hard gate" | `.claude/hooks/*.ps1` + `settings.json` | Hooks enforce; rules merely document. |
+| `.github/agents/*.agent.md` "Workflow / Phase X" | `.claude/skills/<workflow>/SKILL.md` | Split per phase when phases are independent. |
+| `.github/agents/*.agent.md` "Design rules / Testing rules" | `.claude/rules/<language>.md` | Merge under Design Rules / Pytest Rules subheadings. |
+| `.github/agents/*.agent.md` "Handoffs" | Reference existing routing skills | Do not duplicate. |
+| `.github/agents/*.agent.md` "Reporting requirements" | `.claude/skills/<name>-qa-gate/SKILL.md` or the QA gate skill | Procedure, not identity. |
+| `.github/prompts/*.prompt.md` | `.claude/skills/<action-name>/SKILL.md` | One skill per prompt. |
+| `.github/skills/<name>/SKILL.md` | `.claude/skills/<name>/SKILL.md` | Near-1:1; reconcile frontmatter schema. |
+
+## Invocation Examples
+
+- Translate a single agent persona, plan only:
+  `translate-copilot-to-claude .github/agents/python-typed-engineer.agent.md`
+- Translate a set of instruction files and apply:
+  `translate-copilot-to-claude .github/instructions/python-code-change.instructions.md .github/instructions/python-unit-test.instructions.md mode=apply`
+- Translate an entire agent bundle (persona + its referenced instructions):
+  `translate-copilot-to-claude .github/agents/csharp-typed-engineer.agent.md .github/instructions/csharp-code-change.instructions.md .github/instructions/csharp-unit-test.instructions.md target-scope=all`

package/resources/claude-customizations/.claude/skills/update-status/SKILL.md

@@ -0,0 +1,21 @@
+---
+name: update-status
+description: Invoke the status-updater worker to reconcile status artifacts and synchronized status outputs.
+---
+
+# Update Status Skill
+
+This direct-use wrapper delegates status synchronization work to the `status-updater` worker.
+
+## Inputs
+
+- Epic or feature folder path
+- Existing plan, evidence, and issue status context
+
+## Output Paths
+
+- `artifacts/status/status-sync.<timestamp>.md`
+
+## Worker Routing
+
+- Worker: `status-updater`

package/resources/claude-dir-customizations/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "drmCopilotExtension": {
+      "command": "node",
+      "args": ["extensions/drm-copilot/out/mcp-server.js"]
+    }
+  }
+}

package/resources/codex-and-agents-customizations/.agents/README.md

@@ -0,0 +1,86 @@
+# Codex Skill Architecture
+
+## Purpose
+
+This directory is the canonical Codex runtime surface for repository-local skills.
+
+Codex-supported repository locations in this repo are:
+
+- `.agents/skills/<skill-name>/SKILL.md` for reusable workflow skills
+- `.codex/agents/*.toml` for subagent definitions
+- `.codex/prompts/*.md` for prompt entrypoints and lightweight workflow launchers
+
+The legacy GitHub Copilot ecosystem under `.github/skills` and `.github/agents` remains as historical source material during migration. New Codex-native runtime behavior should be authored in `.agents/skills` and consumed from `.codex/agents`.
+
+## Layering
+
+Design skills in layers so behavior is authored once and reused everywhere:
+
+1. Foundation skills
+   - Policy order
+   - Atomic plan contract
+   - Acceptance criteria tracking
+   - Evidence conventions
+   - Canonical-location audits
+
+2. Integration skills
+   - PR base resolution
+   - PR context artifact rules
+   - Feature-promotion lifecycle
+   - Remediation handoff
+   - Host-surface adapters
+
+3. Language routing and orchestration-state skills
+   - Change-budget routers
+   - Checkpoint and resume contracts
+
+4. Workflow skills
+   - `atomic-executor`
+   - `atomic-planner`
+   - `feature-review`
+   - `orchestrator-workflow`
+
+5. Specialist support skills
+   - `commit-message-conventions`
+   - `pr-authoring`
+
+6. Subagents
+   - Keep `.codex/agents/*.toml` concise.
+   - Reference workflow and shared skills by name instead of embedding long duplicated instructions.
+
+## Anti-Duplication Rules
+
+1. If multiple workflows need the same rule, extract it into one shared skill.
+2. Workflow skills should name the shared skills they depend on rather than restating those blocks.
+3. Environment-specific repo automation and its MCP dependency binding should live in `repo-automation-adapter`, not in each workflow skill.
+4. Canonical paths should be defined in exactly one skill; other skills should reference that skill instead of repeating the path.
+5. If Codex already ships a suitable system skill, prefer a thin repo-local compatibility wrapper instead of re-implementing the same scaffolding.
+6. If an agent persona grows reusable decision rules or formatting rules, move those rules into a shared skill and keep the agent as a thin wrapper.
+7. If a top-level workflow routes between multiple existing skills or subagents, capture that routing once in a shared workflow skill and keep the prompt or agent as a launcher.
+
+## Migration Rules
+
+When migrating a Copilot artifact:
+
+1. If it defines reusable repository guidance, migrate it to `.agents/skills/<name>/SKILL.md`.
+2. If it defines a reusable agent persona or bounded delegation role, migrate it to `.codex/agents/<name>.toml`.
+3. If it is mainly a launch prompt or an orchestration shortcut, migrate it to `.codex/prompts/<name>.md`.
+4. Preserve stable names where possible so downstream handoffs remain readable and consistent.
+5. If a Copilot workflow relied on `drmCopilotExtension.*` commands or another host-specific surface, move that translation logic into `repo-automation-adapter`, target semantic MCP tools on server `drmCopilotExtension` when available, and keep the business workflow skill host-agnostic.
+
+## External Tool Bindings
+
+When a repository skill owns an external MCP dependency:
+
+- declare that dependency once in `agents/openai.yaml` beside the owning skill
+- keep downstream workflow skills dependent on the adapter skill, not on duplicated MCP binding metadata
+
+## Future Migrations
+
+Use the system `$skill-creator` skill when scaffolding a new Codex skill, then apply the repository rules in this file:
+
+- place the runtime skill under `.agents/skills`
+- keep frontmatter minimal
+- make the description explicit about triggers
+- reference existing shared skills before creating a new one
+- add a new shared skill only when the behavior cannot be expressed as a composition of existing skills

package/resources/codex-and-agents-customizations/.agents/skills/README.md

@@ -0,0 +1,49 @@
+# Codex Repository Skills
+
+Repository-local Codex skills live under `.agents/skills/<skill-name>/SKILL.md`.
+
+## Skill Groups
+
+- Foundation
+  - `policy-compliance-order`
+  - `atomic-plan-contract`
+  - `acceptance-criteria-tracking`
+  - `evidence-and-timestamp-conventions`
+  - `skill-canonical-location-audit`
+
+- Integration
+  - `repo-automation-adapter`
+  - `pr-base-branch-merge-base`
+  - `pr-context-artifacts`
+  - `feature-promotion-lifecycle`
+  - `policy-audit-template-usage`
+  - `remediation-handoff-atomic-planner`
+
+- Language routing and state
+  - `csharp-change-budget-router`
+  - `csharp-orchestration-state-machine`
+  - `powershell-change-budget-router`
+  - `powershell-orchestration-state-machine`
+
+- Workflow
+  - `atomic-planner`
+  - `atomic-executor`
+  - `feature-review`
+  - `orchestrator-workflow`
+
+- Specialist support
+  - `commit-message-conventions`
+  - `pr-authoring`
+
+- Meta
+  - `make-skill-template`
+
+## Authoring Rules
+
+1. Put shared rules in one skill only.
+2. Have workflow skills reference shared skills instead of copying their text.
+3. Put host-specific repo automation rules and their MCP dependency binding in `repo-automation-adapter`.
+4. Keep names stable when migrating from the legacy Copilot ecosystem.
+5. When an agent needs reusable rules, extract them into a shared skill and keep the agent as a thin wrapper.
+6. Put top-level route selection and checkpoint rules in a shared workflow skill rather than duplicating them across prompts or agent personas.
+7. When a skill depends on an external MCP server, declare it in that skill's `agents/openai.yaml` instead of repeating the binding in each caller.