@danmoisan/drm-copilot-mcp 0.0.5 → 1.0.0

package/resources/config/orchestration-routing.json

@@ -7,14 +7,11 @@
       "required_agents": [
         "atomic-planner",
         "atomic-executor",
-        "feature-reviewer",
-        "commit-steward"
+        "feature-review"
       ],
       "required_skills": [
         "orchestrate",
-        "orchestrator-workflow",
         "feature-promotion-lifecycle",
-        "repo-automation-adapter",
         "atomic-plan-contract",
         "acceptance-criteria-tracking",
         "pr-context-artifacts",
@@ -24,20 +21,20 @@
         "new_potential_entry",
         "potential_to_issue",
         "new_active_feature_folder",
-        "collect_commit_context",
         "collect_pr_context",
         "validate_orchestration_artifacts"
       ]
     },
     "large": {
       "description": "Full feature or bug path for work outside small-path budget.",
+      "requires_pr_gate": true,
       "required_agents": [
         "task-researcher",
         "prd-feature",
         "atomic-planner",
         "atomic-executor",
-        "feature-reviewer",
-        "commit-steward"
+        "feature-review",
+        "pr-author"
       ],
       "required_skills": [
         "orchestrate",
@@ -53,7 +50,6 @@
         "new_potential_entry",
         "potential_to_issue",
         "new_active_feature_folder",
-        "collect_commit_context",
         "collect_pr_context",
         "validate_orchestration_artifacts"
       ]
@@ -63,19 +59,15 @@
       "required_agents": [
         "atomic-planner",
         "atomic-executor",
-        "feature-reviewer",
-        "commit-steward"
+        "feature-review"
       ],
       "required_skills": [
         "orchestrate",
-        "orchestrator-workflow",
-        "repo-automation-adapter",
         "atomic-plan-contract",
         "acceptance-criteria-tracking",
         "pr-context-artifacts"
       ],
       "required_mcp_tools": [
-        "collect_commit_context",
         "collect_pr_context",
         "validate_orchestration_artifacts"
       ]

package/resources/customizations/.github/agents/pr-author.agent.md

@@ -136,3 +136,28 @@ Use these sections, in this order:
 - No hallucinated issue/PR numbers.
 
 That’s it. Produce the PR body.
+
+## Authorization Sentinel Protocol (Documentation-Only in This Ecosystem)
+
+When this agent opens or updates a pull request via `gh pr create` or `gh pr edit --body*`, it follows
+the cross-ecosystem authorization sentinel protocol:
+
+1. Run `git rev-parse HEAD` to obtain `head_sha`.
+2. Write `artifacts/pr_author_authorization.json` with exactly: `issued_by` set to `"pr-author"`,
+   `issued_at` as a UTC ISO-8601 timestamp, `head_sha` from step 1, and `ttl_seconds` set to `120`.
+3. Issue the `gh pr create` / `gh pr edit --body-file ...` command immediately, within the 120-second
+   TTL. Pass the PR body via `--body-file`; inline `--body` is not used.
+4. Delete `artifacts/pr_author_authorization.json` after the command completes (success or failure).
+
+After opening or updating the PR, report the resulting PR URL or PR number.
+
+Enforcement in the GitHub Copilot ecosystem is **documentation-only**: the Copilot ecosystem has no
+PreToolUse hook surface, so the sentinel protocol cannot be mechanically enforced here. The protocol
+is documented for consistency with the Claude and Codex ecosystems, where a PreToolUse hook verifies
+the sentinel.
+
+The authorization sentinel is a **policy guardrail, not a cryptographic or security control.** Any
+actor with write access to `artifacts/` can forge `artifacts/pr_author_authorization.json`, because
+all agents share the same filesystem and the runtime exposes no native agent-identity signal at tool
+pre-use time. The mechanism prevents accidental bypass and requires a deliberate, documented act to
+circumvent. It is not tamper-proof and is not a security boundary.

package/resources/customizations/.github/agents/task-researcher.agent.md

@@ -8,13 +8,13 @@ tools: [vscode/getProjectSetupInfo, vscode/installExtension, vscode/newWorkspace
 
 ## Role Definition
 
-You are a research-only specialist who performs deep, comprehensive analysis for task planning. Your sole responsibility is to write transient research notes in the untracked scratch area `artifacts/research/`. You MUST NOT make changes to any other files, code, or configurations.
+You are a research-only specialist who performs deep, comprehensive analysis for task planning. Your sole responsibility is to write research notes to one of the two tracked research roots: `docs/features/<feature>/research/` for feature-associated research, or `docs/research/` for one-off research not tied to a feature. The orchestrator resolves which root to use and supplies the path; do not infer the feature folder independently. You MUST NOT make changes to any other files, code, or configurations.
 
 ## Core Research Principles
 
 You MUST operate under these constraints:
 
-- You WILL ONLY do deep research using ALL available tools and create/edit files in `artifacts/research/` (intentionally untracked scratch space) without modifying source code or configurations
+- You WILL ONLY do deep research using ALL available tools and create/edit files in the orchestrator-supplied research root (`docs/features/<feature>/research/` for feature-associated research, or `docs/research/` for one-off research) without modifying source code or configurations
 - You WILL document ONLY verified findings from actual tool usage, never assumptions, ensuring all research is backed by concrete evidence
 - You MUST cross-reference findings across multiple authoritative sources to validate accuracy
 - You WILL understand underlying principles and implementation rationale beyond surface-level patterns
@@ -71,7 +71,7 @@ In the final research document, "remove alternatives" means:
 
 ## Operational Constraints
 
-You WILL use read tools throughout the entire workspace and external sources. You MUST create and edit files ONLY in `artifacts/research/`. You MUST NOT modify any source code, configurations, or other project files.
+You WILL use read tools throughout the entire workspace and external sources. You MUST create and edit files ONLY in the orchestrator-supplied research root: `docs/features/<feature>/research/` (feature-associated) or `docs/research/` (one-off). You MUST NOT modify any source code, configurations, or other project files.
 
 You WILL provide brief, focused updates without overwhelming details. You WILL present discoveries and guide user toward single solution selection. You WILL keep all conversation focused on research activities and findings. You WILL NEVER repeat information already documented in research files.
 
@@ -205,7 +205,7 @@ For each research activity, you MUST:
 
 You MUST maintain research files as living documents:
 
-1. Search for existing research files in `artifacts/research/`
+1. Search for existing research files in the orchestrator-supplied research root (`docs/features/<feature>/research/` for feature-associated research, or `docs/research/` for one-off research)
 2. Create new research file if none exists for the topic
 3. Initialize with comprehensive research template structure
 

package/resources/customizations/.github/prompts/fillout-prd-feature.prompt.md

@@ -18,7 +18,7 @@ Use this prompt when invoking the prd_feature agent via `/fillout-prd-feature <p
 
 1. Load each supplied path in order; note missing or unreadable files explicitly.
 2. Extract available details (issue number, owner, status, story statements, constraints, inputs/outputs, CLI flags, personas, risks, acceptance criteria, non-goals).
-3. If research exists under `artifacts/research`, the caller must include the specific research file paths in the `/fillout-prd-feature` command; the agent must read each provided research file before writing.
+3. If research exists under `docs/features/<feature>/research/` (feature-associated) or `docs/research/` (one-off), the caller must include the specific research file paths in the `/fillout-prd-feature` command; the agent must read each provided research file before writing.
 4. Identify gaps; if the research document is insufficient to populate required sections, delegate additional research to the Task Researcher Agent and pause drafting until that research is complete.
 5. Before writing, run a technical completeness check: confirm Proposed Fix, Assumptions, Data/Config Impact, Test Strategy, and Acceptance Criteria can be filled with domain-specific, testable details (no placeholders).
 6. Apply the prd_feature agent’s section guidance when filling content:

package/resources/customizations/.github/prompts/research-issue.prompt.md

@@ -16,7 +16,7 @@ Your output must be actionable for an engineer/agent to implement, and must be g
 
 ## Scope and operating rules
 
-Follow the operating rules in your agent definition (research-only, write to `artifacts/research/`, evidence-based). Do not restate those rules in the research notes; apply them.
+Follow the operating rules in your agent definition (research-only; write to the orchestrator-supplied research root under `docs/features/<feature>/research/` for feature-associated research or `docs/research/` for one-off research; evidence-based). Do not restate those rules in the research notes; apply them.
 
 ## Inputs / Context (authoritative)
 
@@ -31,11 +31,12 @@ Also identify (from the feature docs) the **implementation target files** in the
 
 ## Research Outputs (required)
 
-Create (or update) a single research file under `artifacts/research/` using the Task Researcher template exactly.
+Create (or update) a single research file under the orchestrator-supplied research root using the Task Researcher template exactly. The two tracked research roots are `docs/features/<feature>/research/` (feature-associated; for example `docs/features/active/<feature>/research/`) and `docs/research/` (one-off, not tied to a feature). Routing rule: use the feature research root when an active feature folder is in scope (the orchestrator supplies the resolved path from `feature-folder` in `orchestrator-state.json`); otherwise use `docs/research/`.
 
 Filename convention:
 
-- `artifacts/research/YYYYMMDD-<short-feature-name>-implementation-research.md`
+- `docs/features/<feature>/research/YYYYMMDD-<short-feature-name>-implementation-research.md` (feature-associated), or
+- `docs/research/YYYYMMDD-<short-feature-name>-implementation-research.md` (one-off)
 
 In the research file, keep any discussion of non-selected approaches *brief and non-exhaustive*. After selecting a recommendation, remove detailed notes for other approaches and keep only a short “Rejected alternatives” summary (what was rejected and why).
 

package/resources/codex-and-agents-customizations/.codex/scripts/post-codex-worktree-session.ps1

@@ -1,5 +0,0 @@
-[CmdletBinding()]
-param()
-
-Set-StrictMode -Version Latest
-$ErrorActionPreference = 'Stop'

package/resources/scripts/dev_tools/_orchestrator_state_human_interaction.py

@@ -1,127 +0,0 @@
-"""Human-interaction invariants for orchestrator-state checkpoints.
-
-Purpose:
-    Hold the optional ``human_interaction`` block constants and the
-    ``_validate_human_interaction`` helper so the primary validator module
-    (`scripts.dev_tools.validate_orchestrator_state`) can stay within the
-    repository's 500-line file limit while preserving the existing validator
-    contract.
-
-Usage:
-    Import ``HUMAN_INTERACTION_KEY`` and ``_validate_human_interaction`` from
-    this module. The primary validator re-exports both symbols so existing
-    callers and tests continue to resolve them from
-    ``scripts.dev_tools.validate_orchestrator_state`` unchanged.
-
-Invariants / Constraints:
-    - The three permitted ``response`` values are ``scope_change``,
-      ``exception``, and ``halt``.
-    - An ``exception`` response requires a non-empty ``runbook_path`` string.
-    - The validator never imports ``schemas/orchestrator-state.schema.json``;
-      the invariants are expressed directly here per
-      `.claude/rules/orchestrator-state.md`.
-
-Side Effects:
-    None.
-"""
-
-from __future__ import annotations
-
-from typing import Any, cast
-
-# Declare the module's intended exported surface. Listing ``_validate_human_
-# interaction`` here marks it as a deliberate re-export consumed by
-# ``validate_orchestrator_state``, so static analysis does not flag the helper
-# as unused locally or as private-usage when imported across the module boundary.
-__all__ = [
-    "HUMAN_INTERACTION_KEY",
-    "HUMAN_INTERACTION_REQUIREMENTS_KEY",
-    "HUMAN_INTERACTION_RESPONSE_ENUM",
-    "HUMAN_INTERACTION_EXCEPTION_RESPONSE",
-    "_validate_human_interaction",
-]
-
-HUMAN_INTERACTION_KEY = "human_interaction"
-HUMAN_INTERACTION_REQUIREMENTS_KEY = "requirements"
-# The three permitted responses for an unautomatable requirement under the
-# autonomous-execution mandate (see `.claude/skills/orchestrate/SKILL.md`).
-HUMAN_INTERACTION_RESPONSE_ENUM = {"scope_change", "exception", "halt"}
-HUMAN_INTERACTION_EXCEPTION_RESPONSE = "exception"
-
-
-def _validate_human_interaction(human_interaction: object) -> list[str]:
-    """Validate the optional ``human_interaction`` block invariants.
-
-    Purpose:
-        Apply the autonomous-execution mandate invariants to the checkpoint's
-        optional top-level ``human_interaction`` object, mirroring the schema
-        invariants documented in `.claude/rules/orchestrator-state.md`. The
-        validator never imports `schemas/orchestrator-state.schema.json`; the
-        invariants are expressed directly here in the existing helper-plus-
-        error-list style.
-
-    Args:
-        human_interaction (object): The raw value of the checkpoint's top-level
-            ``human_interaction`` key. Callers invoke this helper only when the
-            key is present, so a non-object value is itself a malformed block.
-
-    Returns:
-        list[str]: One error string per violated invariant; an empty list when
-        the block is well-formed. The three invariants are: ``requirements`` is
-        present and is a list; each requirement is an object whose ``response``
-        is within the permitted enum; a requirement whose ``response`` is
-        ``exception`` carries a non-empty ``runbook_path`` string.
-
-    Raises:
-        None.
-
-    Side Effects:
-        None.
-    """
-
-    errors: list[str] = []
-
-    # A non-object human_interaction cannot carry a requirements list; the key
-    # was present, so this is a malformed block rather than an absent one.
-    if not isinstance(human_interaction, dict):
-        errors.append("Checkpoint human_interaction must be an object when present.")
-        return errors
-    human_interaction_map = cast("dict[str, Any]", human_interaction)
-
-    # Invariant 1: requirements must be present and a list.
-    requirements = human_interaction_map.get(HUMAN_INTERACTION_REQUIREMENTS_KEY)
-    if not isinstance(requirements, list):
-        errors.append("Checkpoint human_interaction.requirements must be a list.")
-        return errors
-    requirement_list = cast("list[object]", requirements)
-
-    # Validate each requirement independently so callers receive a complete
-    # error list instead of stopping at the first malformed requirement.
-    for index, requirement in enumerate(requirement_list):
-        if not isinstance(requirement, dict):
-            errors.append(
-                f"Checkpoint human_interaction.requirements #{index} must be an "
-                "object."
-            )
-            continue
-        requirement_map = cast("dict[str, Any]", requirement)
-
-        # Invariant 2: response must be within the permitted enum.
-        response = requirement_map.get("response")
-        if response not in HUMAN_INTERACTION_RESPONSE_ENUM:
-            errors.append(
-                f"Checkpoint human_interaction.requirements #{index} response "
-                f"must be one of scope_change, exception, halt; got: {response}"
-            )
-            continue
-
-        # Invariant 3: an exception response requires a non-empty runbook_path.
-        if response == HUMAN_INTERACTION_EXCEPTION_RESPONSE:
-            runbook_path = requirement_map.get("runbook_path")
-            if not isinstance(runbook_path, str) or not runbook_path.strip():
-                errors.append(
-                    f"Checkpoint human_interaction.requirements #{index} "
-                    "response is exception but runbook_path is missing or empty."
-                )
-
-    return errors

package/resources/scripts/dev_tools/_orchestrator_state_routing.py

@@ -1,216 +0,0 @@
-"""Routing and mandatory handoff invariants for orchestrator checkpoints."""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from typing import Any, cast
-
-ROUTING_MATRIX_PATH = (
-    Path(__file__).resolve().parents[2] / "config" / "orchestration-routing.json"
-)
-
-
-def load_routing_matrix(path: Path = ROUTING_MATRIX_PATH) -> dict[str, Any]:
-    """Load the repository routing matrix from disk."""
-
-    loaded: object = json.loads(path.read_text(encoding="utf-8"))
-    return cast("dict[str, Any]", loaded)
-
-
-def _string_list(value: object) -> list[str] | None:
-    """Return a list of strings only when the value has that exact shape."""
-
-    if not isinstance(value, list):
-        return None
-    values = cast("list[object]", value)
-    if not all(isinstance(item, str) and item.strip() for item in values):
-        return None
-    return cast("list[str]", values)
-
-
-def _route_list(route: dict[str, Any], key: str) -> list[str]:
-    """Read a required string-list field from one route entry."""
-
-    value = _string_list(route.get(key))
-    return [] if value is None else value
-
-
-def _state_list(
-    state: dict[str, Any], key: str, route_id: str, expected: list[str]
-) -> list[str] | None:
-    """Validate a state list against the routing matrix list."""
-
-    value = _string_list(state.get(key))
-    if value is None:
-        return None
-    if value != expected:
-        return None
-    return value
-
-
-def _list_receipts(receipts: object) -> list[dict[str, Any]]:
-    """Return legacy list delegation receipts as typed dictionaries."""
-
-    if not isinstance(receipts, list):
-        return []
-    receipt_list = cast("list[object]", receipts)
-    return [
-        cast("dict[str, Any]", item) for item in receipt_list if isinstance(item, dict)
-    ]
-
-
-def _receipt_agents(state: dict[str, Any]) -> set[str]:
-    """Collect agent names from delegation receipts."""
-
-    agents: set[str] = set()
-    for receipt in _list_receipts(state.get("delegation_receipts")):
-        agent_name = receipt.get("agent_name")
-        if isinstance(agent_name, str) and agent_name.strip():
-            agents.add(agent_name)
-    return agents
-
-
-def _receipt_skills(state: dict[str, Any]) -> set[str]:
-    """Collect acknowledged skill names from skill receipts."""
-
-    skills: set[str] = set()
-    receipts = state.get("skill_receipts")
-    if not isinstance(receipts, list):
-        return skills
-    for receipt in cast("list[object]", receipts):
-        if not isinstance(receipt, dict):
-            continue
-        receipt_map = cast("dict[str, object]", receipt)
-        skill = receipt_map.get("skill")
-        required = receipt_map.get("required")
-        evidence = receipt_map.get("evidence")
-        if (
-            isinstance(skill, str)
-            and skill.strip()
-            and required is True
-            and isinstance(evidence, str)
-            and evidence.strip()
-        ):
-            skills.add(skill)
-    return skills
-
-
-def _mcp_tools(state: dict[str, Any]) -> set[str]:
-    """Collect successful MCP tool receipts from checkpoint state."""
-
-    tools: set[str] = set()
-    receipts = state.get("mcp_call_receipts")
-    if not isinstance(receipts, list):
-        return tools
-    for receipt in cast("list[object]", receipts):
-        if not isinstance(receipt, dict):
-            continue
-        receipt_map = cast("dict[str, object]", receipt)
-        tool = receipt_map.get("tool")
-        ok = receipt_map.get("ok")
-        evidence = receipt_map.get("evidence")
-        if (
-            isinstance(tool, str)
-            and tool.strip()
-            and ok is True
-            and isinstance(evidence, str)
-            and evidence.strip()
-        ):
-            tools.add(tool)
-    return tools
-
-
-def _validate_empty_list_field(state: dict[str, Any], key: str) -> list[str]:
-    """Require a checkpoint field to exist as an empty list."""
-
-    value = state.get(key)
-    if not isinstance(value, list):
-        return [f"Checkpoint {key} must be an empty list at completion."]
-    if value:
-        return [f"Checkpoint {key} must be empty at completion."]
-    return []
-
-
-def _validate_lifecycle_operations(state: dict[str, Any]) -> list[str]:
-    """Reject lifecycle-operation records that did not use MCP."""
-
-    operations = state.get("lifecycle_operations")
-    if operations is None:
-        return []
-    if not isinstance(operations, list):
-        return ["Checkpoint lifecycle_operations must be a list when present."]
-    errors: list[str] = []
-    for index, operation in enumerate(cast("list[object]", operations)):
-        if not isinstance(operation, dict):
-            errors.append(
-                f"Checkpoint lifecycle_operations #{index} must be an object."
-            )
-            continue
-        operation_map = cast("dict[str, object]", operation)
-        if operation_map.get("surface") != "mcp":
-            errors.append(
-                f"Checkpoint lifecycle_operations #{index} did not use MCP surface."
-            )
-    return errors
-
-
-def validate_routing_contract(
-    state: dict[str, Any], *, routing_matrix: dict[str, Any] | None = None
-) -> list[str]:
-    """Validate mandatory route, handoff, skill, and MCP completion evidence."""
-
-    matrix = routing_matrix if routing_matrix is not None else load_routing_matrix()
-    raw_routes = matrix.get("routes")
-    if not isinstance(raw_routes, dict):
-        return ["Routing matrix missing routes object."]
-    routes = cast("dict[str, object]", raw_routes)
-
-    route_id = state.get("route_id", state.get("path_selected"))
-    if not isinstance(route_id, str) or not route_id.strip():
-        return ["Checkpoint route_id or path_selected must select a route."]
-    raw_route = routes.get(route_id)
-    if not isinstance(raw_route, dict):
-        return [f"Checkpoint selected route has no routing-matrix entry: {route_id}."]
-    route_map = cast("dict[str, Any]", raw_route)
-
-    errors: list[str] = []
-    required_agents = _route_list(route_map, "required_agents")
-    required_skills = _route_list(route_map, "required_skills")
-    required_mcp_tools = _route_list(route_map, "required_mcp_tools")
-
-    if _state_list(state, "required_agents", route_id, required_agents) is None:
-        errors.append(
-            "Checkpoint required_agents must match routing matrix for route "
-            f"{route_id}."
-        )
-    if _state_list(state, "required_skills", route_id, required_skills) is None:
-        errors.append(
-            "Checkpoint required_skills must match routing matrix for route "
-            f"{route_id}."
-        )
-    if _state_list(state, "required_mcp_tools", route_id, required_mcp_tools) is None:
-        errors.append(
-            "Checkpoint required_mcp_tools must match routing matrix for route "
-            f"{route_id}."
-        )
-
-    actual_agents = _receipt_agents(state)
-    for agent in required_agents:
-        if agent not in actual_agents:
-            errors.append(f"Checkpoint missing required agent receipt: {agent}.")
-
-    actual_skills = _receipt_skills(state)
-    for skill in required_skills:
-        if skill not in actual_skills:
-            errors.append(f"Checkpoint missing required skill receipt: {skill}.")
-
-    actual_tools = _mcp_tools(state)
-    for tool in required_mcp_tools:
-        if tool not in actual_tools:
-            errors.append(f"Checkpoint missing successful MCP receipt: {tool}.")
-
-    errors.extend(_validate_empty_list_field(state, "local_execution_overrides"))
-    errors.extend(_validate_empty_list_field(state, "delegation_bypasses"))
-    errors.extend(_validate_lifecycle_operations(state))
-    return errors