@danmoisan/drm-copilot-mcp 0.0.1

package/resources/codex-and-agents-customizations/.agents/skills/python/SKILL.md

@@ -0,0 +1,104 @@
+# Converted skill
+
+Applied rewrites:
+- None
+
+---
+paths:
+  - "**/*.py"
+description: Python-specific toolchain and coding standards.
+---
+
+# Python Code Standards
+
+This rule file summarizes the Python-specific policies for this repository.
+
+## Toolchain
+
+1. **Formatting — Black**: All Python code must be formatted with Black (default settings). Command: `poetry run black .`
+2. **Linting — Ruff**: Python code must pass Ruff using the project configuration. Command: `poetry run ruff check .` Suppressions require pre-authorization per `python-suppressions.instructions.md` or explicit user approval.
+3. **Type Checking — Pyright**: All Python code must be fully type-annotated and pass Pyright. Avoid `Any` unless unavoidable and commented. Command: `poetry run pyright`
+4. **Testing — Pytest**: All tests use Pytest. New logic must have test coverage >= 90%. Command: `poetry run pytest --cov --cov-report=term-missing`
+
+Run the toolchain in order: format → lint → type-check → test. Restart from step 1 if any step fails or changes files. Do not stop the loop until all four steps complete without errors in a single pass.
+
+If the environment prevents running tools, stop implementation and provide a plan and proposed diffs only, clearly marked **unverified**.
+
+## Coding Standards
+
+- **PEP 8 naming**: `snake_case` for functions/methods/variables, `PascalCase` for classes/exceptions, `CONSTANT_CASE` for module constants.
+- **Strong typing**: All public functions and methods must have full type hints for parameters and return values.
+- **Dataclasses**: Prefer `@dataclass` for value objects. Use `frozen=True` where appropriate. Enforce invariants in `__post_init__` (dataclasses) or `__init__`.
+- **Protocols**: Use `typing.Protocol` or `abc.ABC` when multiple implementations are expected.
+- **Imports**: Prefer absolute imports. Avoid circular dependencies.
+- **Error handling**: Fail fast with specific exceptions. Avoid broad `except:` or `except Exception:` without context. Reserve broad handlers for well-defined boundaries (CLI/entrypoints) with context logging.
+- **Assertions**: Use `assert` only for internal sanity checks, not for user-facing validation.
+- **Logging**: Use the standard `logging` module. No ad-hoc `print` statements for permanent behavior.
+
+## Python Design Rules
+
+### Small, cohesive modules
+
+- Each class or module has one clear purpose. Avoid grab-bag utilities.
+- Prefer explicit names and straightforward control flow.
+- Keep the public surface area small. Internal helpers are `_prefixed` or live in `_internal` modules.
+
+### Classes vs functions
+
+Create a class when at least one of the following is true:
+
+- A clear domain concept with data and behavior.
+- State and invariants must travel together.
+- Multiple implementations behind a common interface are expected.
+- A multi-step workflow shares context across steps.
+
+Create a standalone function when:
+
+- The operation is pure, stateless, and simple.
+- It is a small helper that does not naturally belong on a specific domain class.
+- It is a simple transformation from inputs to outputs.
+
+Keep methods small and focused. Avoid god objects that know about too many unrelated concerns. Avoid long, deeply branching functions; factor logic into smaller helpers.
+
+### Strong typing by default (Pyright-clean)
+
+- All public functions, methods, and constructors must have complete type hints.
+- Avoid `Any`. If unavoidable, isolate it by wrapping untyped libraries behind small typed adapters.
+- Use line-specific `# type: ignore[...]` only when justified with a brief comment.
+- Prefer `typing.Protocol` (or `abc.ABC`) only when multiple implementations are expected.
+
+### Dependency seams (testability without frameworks)
+
+Introduce the smallest seam that enables reliable testing:
+
+- Inject collaborators via constructor parameters (preferred).
+- Accept optional callables with sensible defaults for time/randomness (for example, `clock: Callable[[], datetime] = datetime.now`).
+- Extract boundary interactions into a tiny helper function and patch that helper in tests.
+
+Do not introduce generic service-locator patterns or heavy dependency-injection frameworks.
+
+## Pytest Rules
+
+- Use **Pytest** as the test runner.
+- One behavior per test. Follow Arrange–Act–Assert structure.
+- Use descriptive `test_...` function names.
+- Prefer behavioral assertions over implementation detail.
+- Use `pytest.mark.parametrize` for boundary matrices.
+- Fixtures should be narrow by default (function scope unless justified).
+- Mock sparingly; prefer real pure code paths. Use `monkeypatch` for environment variables and module attributes.
+- Patch at the **import location used by the unit under test**, not where a symbol originated.
+- No sleeps, retries, or timing hacks.
+- Organize tests to mirror code structure (for example, `tests/test_module_name.py` for `module_name.py`).
+- No external dependencies (network, databases, external processes, runtime filesystem temp files) in unit tests.
+- Repository-wide line coverage must remain >= 80%.
+- Any new module, class, or method must reach >= 90% coverage.
+- Coverage regression on changed lines is a blocking finding.
+
+## Prohibited Behaviors
+
+- Broad refactors across multiple modules outside the approved scope.
+- Adding new dependencies without explicit user instruction.
+- Reducing typing strictness to make Pyright pass.
+- Weakening tests to make them pass (removing assertions, overbroad exception checks).
+- Using runtime temp files or external services in unit tests.
+- Claiming success without running the toolchain.

package/resources/codex-and-agents-customizations/.agents/skills/python-change-budget-router/SKILL.md

@@ -0,0 +1,84 @@
+# Converted skill
+
+Applied rewrites:
+- None
+
+---
+name: python-change-budget-router
+description: Budget-first routing and batch-scope contract for Python work. Estimate production-file scope, choose small vs large path, enforce the 3 production + 3 test per-batch cap, and halt the agent for scope expansion approval when the estimate exceeds the budget.
+---
+
+# Python Change Budget Router
+
+Canonical guidance for deciding whether Python work stays on the small path (`python-typed-engineer` direct mode) or escalates to the full orchestration workflow, and for enforcing per-batch change budgets during execution.
+
+## When to Use This Skill
+
+Use this skill when:
+
+- Intake starts from a natural-language Python request.
+- An agent must decide the execution path before planning or implementation.
+- A direct-mode route must reject over-budget requests and switch to orchestrated flow.
+- An executor must confirm a batch fits within the 3 production + 3 test file cap before editing.
+
+## Canonical Routing Rules
+
+1. Estimate rough change budget first based on likely **production Python files** touched.
+2. Route:
+   - `1-3` production files (plus corresponding tests) → **small path** (`python-typed-engineer` direct mode).
+   - `>3` production files → **large path** (orchestration workflow with promotion, research, spec, planning, execution, and review).
+
+## Per-Batch Change Budget (Hard Gate)
+
+During Phase C execution:
+
+- A single batch may change at most **3 production files** and **3 test files**.
+- The default cap applies unless the user supplies an override of the form `budget: prod=<N>, test=<M>` in the initiating prompt.
+- A user override may be honored only if it complies with repo policy and approved scope. If the requested scope exceeds 3 production files overall, stop before execution and seek explicit approval.
+- If an override is requested, confirm compliance with repo policy before entering Phase C.
+
+## Scope Expansion Protocol
+
+When in-scope work is required beyond 3 production files, stop and return:
+
+- a one-paragraph justification for the additional files,
+- the exact additional file paths,
+- the smallest alternative that avoids expanding scope,
+
+and wait for explicit user approval before proceeding.
+
+Allowed minimal-seam exceptions (still within the 3-file cap) are:
+
+- introducing a minimal seam for testability (I/O boundary isolation, dependency injection),
+- typing changes required for Pyright cleanliness in the slice,
+- updating the smallest set of call sites needed to preserve a stable public API.
+
+## Direct-Mode Rejection Rule
+
+If `python-typed-engineer` is invoked directly and estimated scope is `>3` production files:
+
+- Stop before implementation.
+- Return an explicit routing instruction to invoke the orchestrated workflow.
+
+## Orchestrated Small-Path Requirements
+
+When routed through the orchestrator, the small path still requires lifecycle scaffolding before implementation:
+
+- invoke promotion and folder lifecycle steps through `vscode/runCommand` and extension access per `feature-promotion-lifecycle` when available. Use script or CLI fallback only when direct extension command execution is unavailable.
+- promote the potential item to a GitHub issue with `--work-mode minor-audit`,
+- create the active feature folder with `--work-mode minor-audit`,
+- delegate minimal-audit plan creation to `atomic_planner` with `DIRECTIVE: MINIMAL-AUDIT PLAN REQUIRED`,
+- require `atomic_executor` preflight until `PREFLIGHT: ALL CLEAR`,
+- execute Phase 0 only via `atomic_executor` before branching,
+- run the reduced small-audit after implementation and QC.
+
+Direct invocation of `python-typed-engineer` remains implementation-focused and does not replace orchestrator lifecycle steps.
+
+## Documentation Expectations
+
+Record in the agent response or logs:
+
+- estimated production file count,
+- chosen path (`small` or `large`),
+- rationale summary (1-3 bullets),
+- any requested budget override and its approval state.

package/resources/codex-and-agents-customizations/.agents/skills/python-qa-gate/SKILL.md

@@ -0,0 +1,82 @@
+# Converted skill
+
+Applied rewrites:
+- Rewrite Claude skill paths to shared skill paths.
+
+---
+name: python-qa-gate
+description: Final QA gate for Python changes. Executes the full Black -> Ruff -> Pyright -> Pytest toolchain, compares against a captured baseline, enforces zero-regression deltas, and produces the required reporting block before the agent declares the change complete.
+---
+
+# Python QA Gate
+
+Canonical procedure for the Phase D final quality gate that every Python change must pass before completion is reported.
+
+## When to Use This Skill
+
+Use this skill when:
+
+- `python-typed-engineer` is about to declare a change complete.
+- An executor has finished applying a planned batch and must verify zero regressions against the baseline captured in Phase A.
+- A reviewer needs to confirm the toolchain was actually run and produced a clean pass.
+
+## Required Inputs
+
+Before invoking this gate, the agent must have:
+
+- a baseline record produced in Phase A, containing Ruff, Pyright, Pytest, and per-file coverage status for the in-scope files,
+- the exact list of touched production and test files,
+- a clean working tree (all planned edits committed to the working copy).
+
+## Toolchain Execution Sequence
+
+Run the full toolchain in this exact order. If any step fails or modifies files, fix the issue and restart from step 1. Do not stop the loop until all four steps complete without errors in a single pass.
+
+1. `poetry run black .`
+2. `poetry run ruff check .`
+3. `poetry run pyright`
+4. `poetry run pytest --cov --cov-report=term-missing`
+
+If the environment prevents running any tool, stop and report the change as **unverified**. Do not declare completion.
+
+## Delta Requirements (Zero-Regression Hard Gate)
+
+Compare the final results to the Phase A baseline. All of the following must hold:
+
+- **Ruff delta**: 0 new findings across the repository.
+- **Pyright delta**: 0 new diagnostics across the repository.
+- **Pytest delta**: 0 new failing tests.
+- **Per-file coverage delta**: coverage for every touched file is greater than or equal to the baseline for that file.
+- **Overall coverage delta** (when the repo enforces it): overall coverage is greater than or equal to the baseline.
+- **New modules, classes, or methods**: coverage >= 90% for each new unit introduced in the batch.
+
+If any delta check fails, the agent must revert or fix immediately and rerun the full toolchain. Do not proceed to reporting until all deltas are clean.
+
+## Required Reporting Block
+
+Every completion response must include the following sections:
+
+1. **Scope** — exact file list touched in this change.
+2. **Baseline** — Ruff, Pyright, Pytest, and coverage status recorded in Phase A.
+3. **Plan** — design and test-strategy summary, referencing the approved plan.
+4. **Diffs** — patch-style or full-file replacements for scoped files only.
+5. **QA Gate Results** — Ruff, Pyright, Pytest, and coverage deltas. If any step could not be run, mark the corresponding line **unverified** and state why.
+
+## Evidence Storage
+
+Persist toolchain output according to `evidence-and-timestamp-conventions`:
+
+- store baseline outputs under `<FEATURE>/evidence/baseline/<timestamp>/`,
+- store post-change outputs under `<FEATURE>/evidence/qa-gates/<timestamp>/`,
+- use ISO-8601 UTC timestamps in folder names.
+
+This location is canonical per evidence-and-timestamp-conventions and is not overridable.
+See `.agents/skills/evidence-and-timestamp-conventions/SKILL.md` for the canonical evidence path authority.
+
+The evidence paths must be referenced in the agent's completion message to satisfy the `SubagentStop` completion-artifact gate.
+
+## Prohibited Shortcuts
+
+- Do not disable, skip, or narrow any step of the toolchain to reach a clean result.
+- Do not add Ruff `noqa`, Pyright `# type: ignore`, or test skips to suppress new findings introduced by the change.
+- Do not report success based on partial or targeted runs alone. Targeted runs are allowed mid-batch, but the final gate requires a full-repo pass.

package/resources/codex-and-agents-customizations/.agents/skills/python-suppressions/SKILL.md

@@ -0,0 +1,148 @@
+# Converted skill
+
+Applied rewrites:
+- None
+
+---
+paths:
+  - "**/*.py"
+description: Pre-authorized Python Ruff and Pyright suppression patterns. Applies to Python files.
+---
+
+# Python Suppression Policy
+
+This rule file summarizes the suppression authorization policy for Python code.
+
+## Authorization Requirement
+
+All `# noqa` and `# type: ignore` 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, use approved patterns).
+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 `# noqa` Patterns
+
+### S603 — Subprocess with validated executable
+
+**When authorized:** Subprocess calls where the executable is validated via `shutil.which()` before use.
+
+**Required comment format:** `# noqa: S603 - static analysis can't verify runtime validation`
+
+**Rationale:** Cross-platform compatibility requires runtime PATH resolution. Static analysis cannot trace the runtime validation, but the code is safe because the executable path is resolved from PATH (not user input), existence is verified before use, and hardcoding platform-specific paths would break portability.
+
+---
+
+### ARG002 — Unused method argument in test mocks
+
+**When authorized:** Test mock/stub implementations that must match interface signatures but do not use all parameters. Must be in test code (`tests/` directory) implementing a known interface.
+
+**Required comment format:** `# noqa: ARG002 - mock API signature` or `# noqa: ARG002 - match [InterfaceName] API`
+
+---
+
+### B008 — Function call in default argument (Typer)
+
+**When authorized:** Typer CLI option declarations where `Option()` must be evaluated at import time for CLI metadata. Must be a Typer option declaration in a CLI function signature.
+
+**Required comment format:** `# noqa: B008 - Typer framework pattern`
+
+---
+
+### TCH002 / TCH003 — Type checking block violations
+
+**When authorized:** Modules used for both runtime and type hints (pytest fixtures, Typer type hints, runtime `isinstance` checks). The module must be used at runtime and cannot be moved to a `TYPE_CHECKING` block without breaking functionality.
+
+**Required comment format:** `# noqa: TCH002 - [module] required at runtime for [reason]` or `# noqa: TCH003 - [module] required at runtime for [reason]`
+
+---
+
+### S310 — URL open with urllib (trusted endpoints)
+
+**When authorized:** Accessing documented, trusted HTTPS API endpoints with timeout. URL must be a validated HTTPS endpoint, domain must be a documented trusted source, timeout must be set, and the URL must not come from user input.
+
+**Required comment format:** `# noqa: S310 - trusted HTTPS endpoint: [domain]`
+
+---
+
+### S314 — XML parsing with ElementTree (trusted sources)
+
+**When authorized:** Parsing user's own local files (EPUB, configuration) or known-safe data sources (Wikipedia dumps, curated datasets). Must NOT be parsing untrusted network data.
+
+**Required comment format:** `# noqa: S314 - parsing trusted [source type]`
+
+---
+
+### BLE001 — Blind except (CLI entry points only)
+
+**When authorized:** Top-level CLI exception handlers for user-friendly error messages and clean exits. Must be at a CLI entry point, must log or display the error with context, and must exit cleanly. NOT allowed in library or internal code.
+
+**Required comment format:** `# noqa: BLE001 - CLI top-level error handling`
+
+---
+
+### S301 — Pickle deserialization (trusted model artifacts)
+
+**When authorized:** Loading known model artifacts from hardcoded trusted local paths. Path must be hardcoded or validated (not from user input or CLI args). Only for ML model/artifact loading.
+
+**Required comment format:** `# noqa: S301 - trusted model artifact from hardcoded path`
+
+---
+
+### S108 / S105 — Hardcoded paths/passwords in tests only
+
+**When authorized:** Test fixtures with example paths and test data literals. Must be in test code only. Not actual secrets or production paths.
+
+**Required comment format:** `# noqa: S108 - test fixture path` or `# noqa: S105 - test fixture data`
+
+---
+
+## Pre-Authorized `# type: ignore` Patterns
+
+### import-untyped — Optional third-party dependency without stubs
+
+**When authorized:** Optional third-party dependencies that lack type stubs or `py.typed` marker. Import must be in a `try/except ImportError` block; library must be optional; no type stubs available; library lacks `py.typed` marker.
+
+**Required comment format:** `# type: ignore[import-untyped]` with a comment on the same or adjacent line explaining the library and why stubs are absent.
+
+---
+
+## Explicitly Not Authorized (with Required Workarounds)
+
+### S110 — `try`-`except`-`pass` fallback chains
+
+**Not authorized.** Use explicit platform detection via `shutil.which()` or environment variable checks instead. `try`-`except`-`pass` chains hide lazy design and make behavior unpredictable.
+
+**Workaround:** Resolve the correct method at design time using `shutil.which()` for executables or explicit platform detection. Cache the result to avoid repeated detection overhead.
+
+---
+
+### TID252 — Relative imports beyond top-level package
+
+**Not authorized.** Use absolute imports (`from project.module import Thing`) instead of parent-relative imports (`from ..module import`).
+
+---
+
+### S607 — Starting process with partial executable path
+
+**Not authorized.** Resolve executables via `shutil.which()` first; use the full path returned by `which()`. This satisfies both S607 and the pre-authorized S603 pattern.
+
+---
+
+### D401, F401, UP017
+
+**Not authorized.** Fix the root cause: rewrite docstrings in imperative mood (D401), remove unused imports (F401), and use timezone-aware datetime (UP017).
+
+---
+
+## Policy Enforcement Checklist
+
+Before using any suppression, verify:
+- [ ] Pattern exactly matches a pre-authorized pattern above.
+- [ ] Required comment format is used verbatim.
+- [ ] All contextual requirements are met (e.g., in tests/, validated path, try/except block).
+- [ ] Suppression scope is as narrow as possible (single line, not file-level).

package/resources/codex-and-agents-customizations/.agents/skills/remediation-handoff-atomic-planner/SKILL.md

@@ -0,0 +1,49 @@
+# Converted skill
+
+Applied rewrites:
+- None
+
+---
+name: remediation-handoff-atomic-planner
+description: 'Reusable remediation trigger and atomic_planner handoff steps. Use when audits require remediation inputs and a delegated remediation plan.'
+---
+
+# Remediation Handoff to atomic_planner
+
+Shared remediation workflow and handoff expectations for agents that delegate to `atomic_planner`.
+
+## When to Use This Skill
+
+Use this skill when:
+- Audit findings require remediation.
+- You must create remediation inputs and delegate plan creation to `atomic_planner`.
+
+## Trigger Conditions (Generic)
+
+Trigger remediation when any of these are true:
+- Audit artifacts contain FAIL or meaningful PARTIAL findings.
+- Toolchain checks fail.
+- Acceptance criteria are not met.
+
+## Required Remediation Inputs
+
+Create `remediation-inputs.<timestamp>.md` with:
+- Enumerated fix list with file paths, expected behavior, and verification commands.
+- A “do not do” list (no scope creep, no policy weakening, no silent skips).
+
+## Plan Creation and Handoff
+
+1) Create a remediation plan target file using the repo’s plan template.
+2) Delegate to `atomic_planner` with:
+   - `${spec}` pointing to remediation inputs (authoritative)
+   - `${file}` pointing to the remediation plan target file
+3) Require `atomic_planner` to output a deterministic, atomic plan with phases and `[P#-T#]` IDs.
+4) Require the same `${file}` path to be updated in place across all remediation-plan revisions in the same remediation loop.
+5) The caller owns the downstream clearance loop:
+   - hand the resulting remediation plan to `atomic_executor` in preflight-validation mode,
+   - if preflight returns `PREFLIGHT: REVISIONS REQUIRED`, re-delegate to `atomic_planner` against the same `${file}` path,
+   - execute the remediation plan only after `PREFLIGHT: ALL CLEAR`.
+
+## Context Package (When Required)
+
+If the calling agent requires a context package, inline the specified audit artifacts, PR context artifacts, and any relevant plan files in the delegated prompt.

package/resources/codex-and-agents-customizations/.agents/skills/repo-automation-adapter/SKILL.md

@@ -0,0 +1,142 @@
+---
+name: repo-automation-adapter
+description: 'Centralize host-surface and repo-automation differences for Codex. Use when a migrated workflow previously depended on GitHub Copilot or VS Code extension commands and needs a single Codex-compatible execution or fallback rule.'
+---
+
+# Repo Automation Adapter
+
+Use this skill to keep host-specific workflow translation in one place.
+
+## When to Use This Skill
+
+Use this skill when:
+- a migrated skill previously depended on `drmCopilotExtension.*` commands,
+- a workflow needs PR-context collection, issue promotion, or feature-folder creation,
+- the same fallback behavior would otherwise be repeated across multiple skills.
+
+## Canonical Rule
+
+Do not encode host-specific execution details in multiple workflow skills. Put them here and have the calling skills reference this skill.
+
+## Published Codex Automation Surface
+
+The canonical Codex automation dependency for this repo is the published MCP server:
+- `drmCopilotExtension`
+
+Downstream Codex skills should depend on the MCP server name `drmCopilotExtension`, not on raw VS Code command IDs.
+
+Declare that dependency once on this skill via `agents/openai.yaml`.
+
+## Codex Capability Model
+
+Codex in this repo can reliably use:
+- repository files,
+- shell commands,
+- git,
+- local scripts that already exist in the repository,
+- configured MCP tools when available.
+
+Codex in this repo should not assume direct access to:
+- `vscode/runCommand`,
+- `drmCopilotExtension.*` command execution,
+- GitHub issue or PR mutation unless an explicit connector or script is available.
+
+## Published MCP Tool Surface
+
+Prefer these semantic MCP tools when the server is configured:
+
+- `collect_commit_context`
+- `collect_pr_context`
+- `push_down_copilot_customizations`
+- `push_down_codex_and_agents_customizations`
+- `new_potential_bug_entry`
+- `new_potential_entry`
+- `potential_to_issue`
+- `new_active_feature_folder`
+- `resolve_execute_hard_lock_prompt`
+
+Legacy VS Code command IDs remain historical source material only:
+
+- `drmCopilotExtension.collectCommitContext`
+- `drmCopilotExtension.collectPrContext`
+- `drmCopilotExtension.pushDownCopilotCustomizations`
+- `drmCopilotExtension.pushDownCodexAndAgentsCustomizations`
+- `drmCopilotExtension.newPotentialBugEntry`
+- `drmCopilotExtension.newPotentialEntry`
+- `drmCopilotExtension.potentialToIssue`
+- `drmCopilotExtension.newActiveFeatureFolder`
+- `drmCopilotExtension.resolveExecuteHardLockPrompt`
+
+## Adapter Preconditions
+
+Before treating the MCP path as available, assume these prerequisites:
+
+- the Codex client is configured with MCP server name `drmCopilotExtension`
+- the published extension or bridge is installed and built
+- an open workspace folder exists for workspace-targeted operations
+- `python` is on `PATH`
+- `pwsh` is preferred, with Windows PowerShell fallback when applicable
+
+## Execution Order
+
+For any host-specific workflow step:
+
+1. Prefer the published `drmCopilotExtension` MCP tool when it covers the requested operation.
+2. If the MCP server is unavailable, determine whether a deterministic git or filesystem fallback is sufficient.
+3. If a deterministic fallback is sufficient, use it and record that the result is a fallback artifact rather than a canonical tool-produced artifact.
+4. If no MCP path or safe fallback exists, stop and report the missing automation dependency instead of inventing behavior.
+
+## Current Adapter Guidance
+
+### PR context collection
+
+- Preferred: call tool `collect_pr_context` on MCP server `drmCopilotExtension`.
+- When the caller already resolved a base branch, pass that base explicitly.
+- Current fallback: use deterministic git commands to reconstruct equivalent context when review workflows only need base/head, merge-base, commits, and changed files.
+- When using fallback, record the provenance in the generated review artifact.
+- For orchestrator remediation loops, PR-context refresh is mandatory after each remediation commit and before each re-review.
+- When the caller explicitly requires MCP tooling for PR-context refresh, do not silently downgrade to fallback; stop and report the dependency gap instead.
+
+### Commit context collection
+
+- Preferred: call tool `collect_commit_context` on MCP server `drmCopilotExtension`.
+- If the MCP server is unavailable and the workflow only needs staged-diff summary, use non-destructive git inspection as fallback and record that provenance.
+- For orchestrator remediation loops, collect commit context only after `git add -A` and only when staged changes exist.
+- For orchestrator remediation loops, do not continue to commit-message generation without an on-disk commit-context artifact path produced by the selected adapter path.
+- When the caller explicitly requires MCP tooling for commit-context collection, do not silently downgrade to fallback; stop and report the dependency gap instead.
+
+### Feature promotion and active feature folder creation
+
+- Preferred MCP tools:
+  - `new_potential_entry`
+  - `new_potential_bug_entry`
+  - `potential_to_issue`
+  - `new_active_feature_folder`
+- Current rule: use the MCP tools as the canonical path.
+- Execute these lifecycle operations as one ordered chain:
+  - create potential entry
+  - promote with `potential_to_issue`
+  - capture numeric issue number from promotion output
+  - create or check out `${promotion-type}/${short-name}-${issue-num}`
+  - create active feature folder with `new_active_feature_folder`
+- `new_active_feature_folder` is not an allowed bootstrap substitute for missing promotion state.
+- If `${issue-num}` is missing, non-numeric, or placeholder text, stop instead of continuing.
+- If the MCP server is unavailable, surface a precise dependency gap unless the caller explicitly requests a best-effort local-only fallback.
+- Do not synthesize GitHub issue state, active-folder scaffolding, or placeholder lifecycle variables unless the user explicitly requests a best-effort local-only fallback.
+- When a local-only fallback is explicitly approved, preserve the same ordered lifecycle and verification gates; do not skip directly to folder creation.
+
+### Customization publishing and hard-lock resolution
+
+- Preferred MCP tools:
+  - `push_down_copilot_customizations`
+  - `push_down_codex_and_agents_customizations`
+  - `resolve_execute_hard_lock_prompt`
+- If the MCP server is unavailable, stop unless the caller explicitly provides an approved alternate path.
+
+## Output Requirements
+
+When this skill is used, the calling workflow should report:
+- which operation required host adaptation,
+- which direct adapter or fallback path was selected,
+- whether the result is canonical or fallback-only,
+- what dependency is missing when the step is blocked.

package/resources/codex-and-agents-customizations/.agents/skills/repo-automation-adapter/agents/openai.yaml

@@ -0,0 +1,5 @@
+dependencies:
+  tools:
+    - type: "mcp"
+      value: "drmCopilotExtension"
+      description: "Published drm-copilot stdio MCP bridge for repository automation"