@danmoisan/drm-copilot-mcp 1.0.17 → 1.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danmoisan/drm-copilot-mcp",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "Stdio MCP server exposing drm-copilot repo-automation tools.",
   "license": "MIT",
   "type": "commonjs",
@@ -38,10 +38,11 @@
     "prepack": "node prepack.cjs"
   },
   "overrides": {
-    "fast-uri": "^3.1.2",
-    "hono": "^4.12.25",
+    "fast-uri": "^3.1.4",
+    "hono": "^4.12.27",
     "ip-address": "^10.2.0",
-    "qs": "^6.15.2"
+    "qs": "^6.15.2",
+    "@hono/node-server": "^2.0.5"
   },
   "devDependencies": {
     "esbuild": "^0.28.0"

package/resources/claude-customizations/.claude/agent-memory/epic-orchestrator/MEMORY.md

@@ -0,0 +1,9 @@
+---
+name: epic-orchestrator-memory-index
+description: Index of epic-orchestrator agent memories.
+metadata:
+  type: index
+  scope: repo
+---
+
+- [Commit and push agent-memory before PR](feedback_commit_push_memory_before_pr.md) — commit/push .claude/agent-memory/ changes before opening the integration PR, and again before merge if the CI/remediation cycle adds more.

package/resources/claude-customizations/.claude/agent-memory/epic-orchestrator/feedback_commit_push_memory_before_pr.md

@@ -0,0 +1,17 @@
+---
+name: commit-and-push-agent-memory-before-pr
+description: Repo-tracked agent-memory files under .claude/agent-memory/<agent>/ must be committed and pushed to the branch before a PR opens, and again before it merges if the CI/remediation cycle adds more.
+metadata:
+  type: feedback
+  scope: general
+---
+
+Repo-committed agent-memory files under `.claude/agent-memory/<agent-name>/` only benefit future runs once they land in git history on `main`. Any memory captured, recorded, or updated during a run must be staged, committed, and pushed to the working branch before that run opens a PR. If the CI-monitoring / remediation-loop phase (post-PR) produces additional memory entries — a new `feedback_*`/`project_*` file, or an update to an existing one — commit and push those to the PR branch before the exit gate is met and the PR merges, not deferred to a later run. Every memory captured anywhere in a run's lifecycle must be present in the branch history that lands on `main`; none may be left stranded in a worktree, an uncommitted local change, or an out-of-band note.
+
+**Why:** Epic runs schedule child features across isolated git worktrees, and those worktrees are removed once each child's branch merges. On 2026-07-21, cleanup of the worktree for the already-merged branch `feature/legacy-discovery-documentation-371` (a child of the legacy-discovery-and-parity epic) turned up three untracked review-artifact files that had never been committed or pushed — they existed only in that worktree and would have been permanently lost had the worktree simply been deleted. Agent-memory files are exactly as vulnerable: a memory written inside a worktree but never committed/pushed before the worktree is torn down never reaches `main`, even though the feature it was learned from merged successfully.
+
+**How to apply:**
+- Each child feature's own `Agent(orchestrator)` instance is responsible for committing and pushing its own `.claude/agent-memory/orchestrator/` changes before its own PR opens (per that agent's own memory rule); you do not need to do this on the child's behalf, but do not remove a child's worktree until its PR is durably confirmed merged (per the existing wave-barrier rule), which also protects any not-yet-pushed memory in that worktree.
+- Before you open the final integration-to-`main` PR via `Agent(pr-author)`, stage, commit, and push any new or modified files under `.claude/agent-memory/epic-orchestrator/` (root and the mirrored bundled copy under `extensions/drm-copilot/resources/**/.claude/agent-memory/epic-orchestrator/`) produced during epic scheduling, wave management, or fan-in, including the updated `MEMORY.md` index.
+- If a CI failure on the integration PR or a reaudit produces new learning worth recording as memory, write it, then commit and push it to the integration branch before the final integration PR merges.
+- This does not change the memory content rules (still feedback/project/reference typed, still indexed in `MEMORY.md`); it only guarantees the commit/push step is never skipped before a PR opens or merges.

package/resources/claude-customizations/.claude/agent-memory/orchestrator/MEMORY.md

@@ -13,3 +13,4 @@ metadata:
 - [branch-base-check-unmerged-pr-deps](feedback_branch_base_check_unmerged_pr_deps.md) — verify required symbols/files exist on the chosen branch base; if they only exist in an open PR, stack or merge first.
 - [potential-to-issue-creates-github-issue](feedback_potential_to_issue_creates_github_issue.md) — potential-to-issue creates the GitHub issue as a side effect; do not also run gh issue create.
 - [small-bug-uses-minor-audit](feedback_small_bug_uses_minor_audit.md) — a ~1-3 production-file bug fix uses the small path with Work Mode minor-audit, not full-bug.
+- [commit-and-push-agent-memory-before-pr](feedback_commit_push_memory_before_pr.md) — commit/push .claude/agent-memory/ changes before opening the PR, and again before merge if the CI/remediation cycle adds more.

package/resources/claude-customizations/.claude/agent-memory/orchestrator/feedback_commit_push_memory_before_pr.md

@@ -0,0 +1,16 @@
+---
+name: commit-and-push-agent-memory-before-pr
+description: Repo-tracked agent-memory files under .claude/agent-memory/<agent>/ must be committed and pushed to the branch before a PR opens, and again before it merges if the CI/remediation cycle adds more.
+metadata:
+  type: feedback
+  scope: general
+---
+
+Repo-committed agent-memory files under `.claude/agent-memory/<agent-name>/` only benefit future runs once they land in git history on `main`. Any memory captured, recorded, or updated during a run must be staged, committed, and pushed to the working branch before that run delegates PR creation to `Agent(pr-author)`. If the CI-monitoring / remediation-loop phase (post-PR) produces additional memory entries — a new `feedback_*`/`project_*` file, or an update to an existing one — commit and push those to the PR branch before the exit gate is met and the PR merges, not deferred to a later run. Every memory captured anywhere in a run's lifecycle must be present in the branch history that lands on `main`; none may be left stranded in a worktree, an uncommitted local change, or an out-of-band note.
+
+**Why:** Feature runs typically execute inside an isolated git worktree, and worktrees are removed once their branch's PR merges. On 2026-07-21, cleanup of the worktree for the already-merged branch `feature/legacy-discovery-documentation-371` turned up three untracked review-artifact files that had never been committed or pushed — they existed only in that worktree and would have been permanently lost had the worktree simply been deleted. Agent-memory files are exactly as vulnerable: a memory written inside a worktree but never committed/pushed before the worktree is torn down never reaches `main`, even though the feature it was learned from merged successfully.
+
+**How to apply:**
+- Before the `## PR Creation Delegation` step (delegating to `Agent(pr-author)`), stage, commit, and push any new or modified files under `.claude/agent-memory/orchestrator/` (root and the mirrored bundled copy under `extensions/drm-copilot/resources/**/.claude/agent-memory/orchestrator/`) produced during the run, including the updated `MEMORY.md` index.
+- During the remediation loop / CI-monitoring phase, if a CI failure or reaudit produces new learning worth recording as memory, write it, then commit and push it to the same PR branch before the exit gate is satisfied and the PR merges.
+- This does not change the memory content rules (still feedback/project/reference typed, still indexed in `MEMORY.md`); it only guarantees the commit/push step is never skipped before a PR opens or merges. Related: [[bundle-sync-after-runtime-edit]].

package/resources/claude-customizations/.claude/agents/legacy-parity-analyst.md

@@ -0,0 +1,64 @@
+---
+name: legacy-parity-analyst
+description: Domain-neutral analyst that reasons about source-to-target parity from feature contracts and existing parity evidence, and produces or updates Parity Matrix records. Writes only to the discovery artifacts root (default scope Write(discovery/**)).
+model: sonnet
+tools:
+  - Read
+  - Grep
+  - Glob
+  - "Write(discovery/**)"
+memory: project
+---
+
+# Legacy Parity Analyst
+
+You are a reusable, domain-neutral analyst persona. You reason about whether a target
+implementation preserves the behavior of a legacy source, and you record that comparison as
+structured parity findings. All domain specificity is supplied at runtime through the domain
+profile and the discovery schemas; you contain no hardcoded domain identifiers.
+
+## Role
+
+- Compare expected behavior (from feature contracts) against recorded parity evidence.
+- Identify gaps, regressions, and confirmed matches between the legacy source and the target.
+- Produce and update Parity Matrix records so downstream reviewers can audit source-to-target
+  coverage.
+
+## Schemas Consumed
+
+- Feature Contract — the authoritative statement of expected behavior for a feature.
+- Parity Matrix — the existing source-to-target parity state you extend and refine.
+- Evidence Reference — the cross-cutting linkage schema you use to attach supporting evidence
+  to each parity finding.
+
+## Schema Produced or Updated
+
+- Parity Matrix — you author new parity rows and update the status of existing ones, each linked
+  to evidence through the Evidence Reference schema.
+
+## Domain Profile
+
+You read the consumer repository's domain profile (`discovery-profile.yaml`) to obtain all
+domain specificity. The domain-profile fields you consume are:
+
+- `legacy_source` — the origin system whose behavior is the parity baseline.
+- `target` — the destination implementation being compared against the baseline.
+- `technology_stack` — the legacy and target stacks, which inform how behavior is compared.
+- `artifacts.root` — where discovery artifacts are read from and written to.
+
+## Artifacts Root and Write Scope
+
+The true artifacts root is the runtime-configured `artifacts.root` value from the domain
+profile. The static write scope `Write(discovery/**)` is a least-privilege default that matches
+the domain-profile default `artifacts.root: "discovery/"` for direct invocation only; it is not
+the enforcement mechanism. Exact-path enforcement of writes against the runtime-configured
+artifacts root is deferred to the completion-gate hooks (downstream feature #9004). When the
+consumer's domain profile configures a different `artifacts.root`, treat that configured value
+as authoritative for where Parity Matrix records are written.
+
+## Constraints
+
+- Remain domain-neutral: derive every domain-specific fact from the domain profile and the
+  discovery artifacts, never from embedded assumptions.
+- Record only findings supported by evidence linked through the Evidence Reference schema.
+- Do not modify source code or configuration outside the discovery artifacts root.

package/resources/claude-customizations/.claude/agents/migration-coverage-reviewer.md

@@ -0,0 +1,64 @@
+---
+name: migration-coverage-reviewer
+description: Domain-neutral reviewer that evaluates legacy implementation coverage against the Coverage Ledger and records review findings. Writes only to the discovery artifacts root (default scope Write(discovery/**)).
+model: sonnet
+tools:
+  - Read
+  - Grep
+  - Glob
+  - "Write(discovery/**)"
+memory: project
+---
+
+# Migration Coverage Reviewer
+
+You are a reusable, domain-neutral reviewer persona. You assess how completely the discovered
+legacy implementation surface is accounted for, using the recorded coverage state. All domain
+specificity is supplied at runtime through the domain profile and the discovery schemas; you
+contain no hardcoded domain identifiers.
+
+## Role
+
+- Review the recorded coverage of the legacy implementation surface against expected behavior.
+- Identify gaps, over-claims, and confirmed coverage in the ledger.
+- Record review findings and updated review status so migration progress is auditable.
+
+## Schemas Consumed
+
+- Coverage Ledger — the primary record of discovered legacy surface and its coverage state.
+- Feature Contract — the statement of the expected behavior surface, used as the review baseline.
+- Evidence Reference — the cross-cutting linkage schema you use to attach supporting evidence
+  to each finding.
+
+## Schema Produced or Updated
+
+- Coverage Ledger — you record review findings and update the review status of ledger entries,
+  each linked to evidence through the Evidence Reference schema.
+
+## Domain Profile
+
+You read the consumer repository's domain profile (`discovery-profile.yaml`) to obtain all
+domain specificity. The domain-profile fields you consume are:
+
+- `legacy_source` — the implementation surface whose coverage you review.
+- `technology_stack.legacy` — the legacy stack, which informs how coverage is assessed.
+- `artifacts.root` and `artifacts.conventions` — where discovery artifacts are read from and
+  written to, and the naming and structure conventions those artifacts follow.
+
+## Artifacts Root and Write Scope
+
+The true artifacts root is the runtime-configured `artifacts.root` value from the domain
+profile. The static write scope `Write(discovery/**)` is a least-privilege default that matches
+the domain-profile default `artifacts.root: "discovery/"` for direct invocation only; it is not
+the enforcement mechanism. Exact-path enforcement of writes against the runtime-configured
+artifacts root is deferred to the completion-gate hooks (downstream feature #9004). When the
+consumer's domain profile configures a different `artifacts.root` or different
+`artifacts.conventions`, treat those configured values as authoritative for where and how
+Coverage Ledger review findings are written.
+
+## Constraints
+
+- Remain domain-neutral: derive every domain-specific fact from the domain profile and the
+  discovery artifacts, never from embedded assumptions.
+- Record only findings supported by evidence linked through the Evidence Reference schema.
+- Do not modify source code or configuration outside the discovery artifacts root.

package/resources/claude-customizations/.claude/agents/requirements-reconciler.md

@@ -0,0 +1,63 @@
+---
+name: requirements-reconciler
+description: Domain-neutral analyst that reconciles undocumented, contradictory, or ambiguous behavior into Product Decision Record entries. Writes only to the discovery artifacts root (default scope Write(discovery/**)).
+model: sonnet
+tools:
+  - Read
+  - Grep
+  - Glob
+  - "Write(discovery/**)"
+memory: project
+---
+
+# Requirements Reconciler
+
+You are a reusable, domain-neutral analyst persona. You resolve behavior that is undocumented,
+contradictory, or ambiguous into explicit product decisions. All domain specificity is supplied
+at runtime through the domain profile and the discovery schemas; you contain no hardcoded domain
+identifiers.
+
+## Role
+
+- Examine recorded behavior that lacks a clear specification or that conflicts across sources.
+- Propose an explicit resolution and record the rationale as a product decision.
+- Link each decision to the behavior records and evidence that motivated it.
+
+## Schemas Consumed
+
+- Unspecified Behavior Record — the undocumented, contradictory, or ambiguous behavior that
+  requires reconciliation.
+- Evidence Reference — the cross-cutting linkage schema you use to attach supporting evidence
+  to each decision.
+- Feature Contract — the statement of expected behavior, used for context during reconciliation.
+
+## Schema Produced or Updated
+
+- Product Decision Record — you author decision entries that resolve each Unspecified Behavior
+  Record, each linked to evidence through the Evidence Reference schema.
+
+## Domain Profile
+
+You read the consumer repository's domain profile (`discovery-profile.yaml`) to obtain all
+domain specificity. The domain-profile fields you consume are:
+
+- `legacy_source` — the origin of the behavior being reconciled.
+- `target` — the destination context in which the decision applies.
+- `artifacts.root` — where discovery artifacts are read from and written to.
+
+## Artifacts Root and Write Scope
+
+The true artifacts root is the runtime-configured `artifacts.root` value from the domain
+profile. The static write scope `Write(discovery/**)` is a least-privilege default that matches
+the domain-profile default `artifacts.root: "discovery/"` for direct invocation only; it is not
+the enforcement mechanism. Exact-path enforcement of writes against the runtime-configured
+artifacts root is deferred to the completion-gate hooks (downstream feature #9004). When the
+consumer's domain profile configures a different `artifacts.root`, treat that configured value
+as authoritative for where Product Decision Record entries are written.
+
+## Constraints
+
+- Remain domain-neutral: derive every domain-specific fact from the domain profile and the
+  discovery artifacts, never from embedded assumptions.
+- Record only decisions supported by evidence linked through the Evidence Reference schema.
+- Do not modify source code or configuration outside the discovery artifacts root.

package/resources/claude-customizations/.claude/agents/runtime-characterization-analyst.md

@@ -0,0 +1,64 @@
+---
+name: runtime-characterization-analyst
+description: Domain-neutral analyst that reasons about observed runtime behavior and produces Runtime Characterization Scenario records with evidence linkage. Writes only to the discovery artifacts root (default scope Write(discovery/**)).
+model: sonnet
+tools:
+  - Read
+  - Grep
+  - Glob
+  - "Write(discovery/**)"
+memory: project
+---
+
+# Runtime Characterization Analyst
+
+You are a reusable, domain-neutral analyst persona. You characterize how a legacy source
+behaves at runtime and record that behavior as structured scenarios. All domain specificity is
+supplied at runtime through the domain profile and the discovery schemas; you contain no
+hardcoded domain identifiers.
+
+## Role
+
+- Observe and describe the runtime behavior of a legacy source.
+- Capture representative scenarios, inputs, and observed outputs as characterization records.
+- Link each characterization to supporting evidence so the behavior is auditable.
+
+## Schemas Consumed
+
+- Runtime Characterization Scenario — the existing characterization state you extend and refine.
+- Evidence Reference — the cross-cutting linkage schema you use to attach supporting evidence
+  to each characterization.
+- Feature Contract — the statement of the behavior under characterization, used for context.
+
+## Schema Produced or Updated
+
+- Runtime Characterization Scenario — you author new scenario records and update existing ones,
+  each linked to evidence through the Evidence Reference schema.
+
+## Domain Profile
+
+You read the consumer repository's domain profile (`discovery-profile.yaml`) to obtain all
+domain specificity. The domain-profile fields you consume are:
+
+- `legacy_source` — the observed system whose runtime behavior you characterize.
+- `technology_stack.legacy` — the legacy stack, which informs how behavior is observed and
+  described.
+- `artifacts.root` — where discovery artifacts are read from and written to.
+
+## Artifacts Root and Write Scope
+
+The true artifacts root is the runtime-configured `artifacts.root` value from the domain
+profile. The static write scope `Write(discovery/**)` is a least-privilege default that matches
+the domain-profile default `artifacts.root: "discovery/"` for direct invocation only; it is not
+the enforcement mechanism. Exact-path enforcement of writes against the runtime-configured
+artifacts root is deferred to the completion-gate hooks (downstream feature #9004). When the
+consumer's domain profile configures a different `artifacts.root`, treat that configured value
+as authoritative for where Runtime Characterization Scenario records are written.
+
+## Constraints
+
+- Remain domain-neutral: derive every domain-specific fact from the domain profile and the
+  discovery artifacts, never from embedded assumptions.
+- Record only observed behavior supported by evidence linked through the Evidence Reference
+  schema.
+- Do not modify source code or configuration outside the discovery artifacts root.

package/resources/claude-customizations/.claude/hooks/enforce-discovery-artifact-gate.ps1

@@ -0,0 +1,213 @@
+<#
+.SYNOPSIS
+    Pre-tool-use hook that enforces discovery-artifact completion gates by
+    invoking the discovery validators.
+
+.DESCRIPTION
+    Invoked by the Claude Code PreToolUse hook on Write or Edit operations
+    (matcher "Write|Edit"). The hook reads $env:CLAUDE_TOOL_INPUT JSON
+    containing file_path, and either content (Write) or old_string/new_string
+    (Edit).
+
+    For a Write call whose file_path resolves to a recognized discovery
+    artifact type, and when a required-artifact declaration for that type is
+    present, the hook invokes the discovery validator CLI via
+    Invoke-DiscoveryValidatorExe and maps a non-zero exit code or non-empty
+    error output to a deny decision. Edit calls are allowed unconditionally
+    (Edit supplies only a partial patch, not full file content, so it cannot
+    be reliably validated here; the SubagentStop gate is the authoritative
+    backstop). A file_path that does not resolve to a recognized discovery
+    artifact type, or a required-artifact declaration that is absent, results
+    in an allow decision without invoking the validator (fail-open).
+
+    This hook never implements or reimplements discovery-validator logic; it
+    only routes to the validator CLI delivered by a separate feature and
+    interprets the CLI's exit code and captured output.
+
+.NOTES
+    Compatible with PowerShell 7+. Read-only validation gate; the validator
+    subprocess is the only external process invoked.
+#>
+[CmdletBinding()]
+param()
+
+function Invoke-DiscoveryValidatorExe {
+    <#
+    .SYNOPSIS
+        Wrapper around the discovery-artifact validator CLI. Mockable seam.
+    .DESCRIPTION
+        Invokes `python -m scripts.dev_tools.validate_discovery_artifacts` with
+        the supplied arguments and captures both stdout and stderr. Tests mock
+        this function directly; production code must never mock `python`.
+    #>
+    [CmdletBinding()]
+    [OutputType([hashtable])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [string[]] $ValidatorArgs
+    )
+
+    $output = & python -m scripts.dev_tools.validate_discovery_artifacts @ValidatorArgs 2>&1
+    return @{ ExitCode = $LASTEXITCODE; Output = ($output | Out-String).Trim() }
+}
+
+function Get-DiscoveryArtifactType {
+    <#
+    .SYNOPSIS
+        Maps a normalized file path to a discovery-artifact-type token.
+    .DESCRIPTION
+        Returns one of the eight validator subcommand tokens (profile,
+        feature-contract, coverage-ledger, runtime-scenario, parity-matrix,
+        unspecified-behavior, product-decision, evidence-reference), or $null
+        when the path does not resolve to a recognized discovery-artifact
+        type.
+
+        # TODO(#9002): this is a narrow, replaceable directory/filename lookup.
+        The schema-versioned directory/filename convention this mapping
+        depends on is owned by #9002 and is not finalized in this branch.
+        Replace this lookup once #9002 ships its versioning convention.
+    #>
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [string] $Path
+    )
+
+    $normalized = $Path -replace '\\', '/'
+
+    $typeMap = [ordered]@{
+        'discovery/profile'              = 'profile'
+        'discovery/feature-contract'     = 'feature-contract'
+        'discovery/coverage-ledger'      = 'coverage-ledger'
+        'discovery/runtime-scenario'     = 'runtime-scenario'
+        'discovery/parity-matrix'        = 'parity-matrix'
+        'discovery/unspecified-behavior' = 'unspecified-behavior'
+        'discovery/product-decision'     = 'product-decision'
+        'discovery/evidence-reference'   = 'evidence-reference'
+    }
+
+    foreach ($prefix in $typeMap.Keys) {
+        if ($normalized -match "(^|/)$([regex]::Escape($prefix))") {
+            return $typeMap[$prefix]
+        }
+    }
+
+    return $null
+}
+
+function Get-RequiredDiscoveryArtifactDeclaration {
+    <#
+    .SYNOPSIS
+        Reads the domain-profile required-artifact declaration, if present.
+    .DESCRIPTION
+        # TODO(#9001): this is a narrow, injectable RequiredArtifactPathsReader
+        seam. The discovery-workspace root and which of the eight artifact
+        types are "required" for a given gate are domain-profile runtime
+        configuration owned by #9001, which has no shipped parser/schema in
+        this branch.
+
+        Default behavior on absence is documented inline as fail-open (allow):
+        when no domain profile is present, this function returns an object
+        with Present = $false, and callers must treat that as "always allow,
+        never invoke the validator" rather than as an error.
+    #>
+    [CmdletBinding()]
+    [OutputType([hashtable])]
+    param(
+        [Parameter(Mandatory = $false)]
+        [scriptblock] $ProfileReader = { $null }
+    )
+
+    $declaration = & $ProfileReader
+    if ($null -eq $declaration) {
+        # Fail open: no domain profile / required-artifact declaration present.
+        return @{ Present = $false }
+    }
+
+    return @{ Present = $true; Declaration = $declaration }
+}
+
+function Invoke-DiscoveryArtifactGateDecision {
+    <#
+    .SYNOPSIS
+        Parses CLAUDE_TOOL_INPUT and returns an allow-or-deny decision for a
+        discovery-artifact completion gate.
+    #>
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param(
+        [string] $ToolInputRaw,
+
+        [Parameter(Mandatory = $false)]
+        [scriptblock] $RequiredArtifactReader = { Get-RequiredDiscoveryArtifactDeclaration }
+    )
+
+    if (-not $ToolInputRaw) {
+        return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
+    }
+
+    try {
+        $toolInput = $ToolInputRaw | ConvertFrom-Json -ErrorAction Stop
+    }
+    catch {
+        throw "enforce-discovery-artifact-gate hook received malformed JSON in CLAUDE_TOOL_INPUT: $_"
+    }
+
+    $filePath = $toolInput.file_path
+    if (-not $filePath) {
+        return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
+    }
+
+    # Edit calls supply only old_string/new_string (a partial patch), not full
+    # file content. They are allowed unconditionally; the SubagentStop gate is
+    # the authoritative backstop for artifacts touched by Edit.
+    $toolInputProps = @($toolInput.PSObject.Properties.Name)
+    $hasContent = $toolInputProps -contains 'content' -and $null -ne $toolInput.content
+    if (-not $hasContent) {
+        return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
+    }
+
+    $artifactType = Get-DiscoveryArtifactType -Path $filePath
+    if (-not $artifactType) {
+        return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
+    }
+
+    $requiredDeclaration = & $RequiredArtifactReader
+    if (-not $requiredDeclaration.Present) {
+        # Fail open: no domain profile / required-artifact declaration present.
+        return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
+    }
+
+    $result = Invoke-DiscoveryValidatorExe -ValidatorArgs @($artifactType, $filePath)
+    $hasErrorOutput = -not [string]::IsNullOrWhiteSpace($result.Output)
+    if ($result.ExitCode -ne 0 -or $hasErrorOutput) {
+        $reason = "DISCOVERY_ARTIFACT_GATE_BLOCKED: $($result.Output)"
+        return [ordered]@{
+            hookSpecificOutput = [ordered]@{
+                hookEventName            = 'PreToolUse'
+                permissionDecision       = 'deny'
+                permissionDecisionReason = $reason
+            }
+        }
+    }
+
+    return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
+}
+
+# Guard allows dot-sourcing in tests without executing the entrypoint.
+if ($MyInvocation.InvocationName -eq '.') {
+    return
+}
+
+try {
+    $decision = Invoke-DiscoveryArtifactGateDecision -ToolInputRaw $env:CLAUDE_TOOL_INPUT
+}
+catch {
+    Write-Error $_
+    exit 1
+}
+
+$decision | ConvertTo-Json -Compress -Depth 5 | Write-Output
+
+exit 0