@danmoisan/drm-copilot-mcp 0.0.1

package/resources/templates/new-potential-entry.ps1

@@ -0,0 +1,187 @@
+# Creates a dated potential feature file from the template and opens it plus backlog.md.
+param(
+    [string] $ShortName,
+    [string] $TemplateRoot
+)
+
+. (Join-Path -Path $PSScriptRoot -ChildPath 'vscode-cli.helpers.ps1')
+
+function Test-ValidShortName {
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [Alias('Name')]
+        [AllowEmptyString()]
+        [string] $CandidateName
+    )
+
+    $shortPattern = '^[a-z0-9]+(-[a-z0-9]+)*$'
+    if ($CandidateName -cmatch $shortPattern) {
+        return $true
+    }
+
+    return $false
+}
+
+function Get-AuthorName {
+    [CmdletBinding()]
+    param(
+        [scriptblock] $GetGitConfig = { param([string] $Key) git config $Key 2>$null },
+        [scriptblock] $GetEnvironmentVariable = { param([string] $Name) [Environment]::GetEnvironmentVariable($Name) }
+    )
+
+    $author = & $GetGitConfig 'user.name'
+    if (-not $author -or [string]::IsNullOrWhiteSpace($author)) {
+        $author = & $GetEnvironmentVariable 'USERNAME'
+    }
+    if (-not $author) { $author = 'Unknown' }
+    return $author
+}
+
+function Convert-TemplateContent {
+    <#
+    .SYNOPSIS
+    Replaces placeholders in template content with actual values.
+
+    .DESCRIPTION
+    This is a pure string transformation function that does not modify system state.
+    It replaces frontmatter and body placeholders in the provided content.
+    #>
+    param(
+        [Parameter(Mandatory = $true)]
+        [string] $Content,
+        [Parameter(Mandatory = $true)]
+        [string] $ShortName,
+        [Parameter(Mandatory = $true)]
+        [string] $Date,
+        [Parameter(Mandatory = $true)]
+        [string] $Author,
+        [string] $LastUpdated,
+        [string] $Status,
+        [string] $StatusColor,
+        [string] $Issue,
+        [string] $Parent,
+        [string] $Version
+    )
+    $updatedContent = $Content -replace '<feature-name>', $ShortName
+    $updatedContent = $updatedContent -replace '- Author: name', "- Author: $Author"
+    if ($Author) {
+        $updatedContent = $updatedContent -replace '<name>', $Author
+    }
+    if ($LastUpdated) {
+        $updatedContent = $updatedContent -replace '<yyyy-MM-ddTHH-mm>', $LastUpdated
+    }
+    $updatedContent = $updatedContent -replace '- Date captured: YYYY-MM-DD', "- Date captured: $Date"
+    if ($Status) {
+        $updatedContent = $updatedContent -replace '<status>', $Status
+    }
+    if ($StatusColor) {
+        $updatedContent = $updatedContent -replace '<color>', $StatusColor
+    }
+    if ($Issue) {
+        $updatedContent = $updatedContent -replace '<issue>', $Issue
+    }
+    if ($Parent) {
+        $updatedContent = $updatedContent -replace '<parent-id>', $Parent
+    }
+    if ($Version) {
+        $updatedContent = $updatedContent -replace '<version_number>', $Version
+    }
+    return $updatedContent
+}
+
+function Invoke-VSCodeOpen {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)]
+        [string[]] $Files,
+        [scriptblock] $GetCommand = { param([string]$Name) Get-Command $Name -ErrorAction SilentlyContinue },
+        # DI seam: receives ($Exe, $CmdArgs); default invokes directly to support --reuse-window.
+        [scriptblock] $InvokeCommand = { param([string]$Exe, [string[]]$CmdArgs) & $Exe @CmdArgs }
+    )
+
+    # Detect Insiders using multiple signals; TERM_PROGRAM_VERSION alone is
+    # unreliable when VS Code spawns external processes (e.g., extension host or task runners).
+    $isInsidersSession = $env:TERM_PROGRAM_VERSION -match 'insider' -or
+    (-not [string]::IsNullOrEmpty($env:VSCODE_IPC_HOOK_CLI) -and $env:VSCODE_IPC_HOOK_CLI -match 'insider') -or
+    ($null -ne (Get-Process -Name '*insiders*' -ErrorAction SilentlyContinue | Select-Object -First 1))
+
+    $hasMatchingCommand = {
+        param(
+            $CommandInfo,
+            [string] $ExpectedName
+        )
+
+        return $CommandInfo -and $CommandInfo.Name -eq $ExpectedName
+    }
+
+    if ($isInsidersSession) {
+        $codeInsidersCmd = & $GetCommand 'code-insiders'
+        if (& $hasMatchingCommand $codeInsidersCmd 'code-insiders') {
+            & $InvokeCommand 'code-insiders' (@('--reuse-window') + $Files)
+            return $true
+        }
+    }
+
+    $codeCmd = & $GetCommand 'code'
+    if (& $hasMatchingCommand $codeCmd 'code') {
+        & $InvokeCommand 'code' (@('--reuse-window') + $Files)
+        return $true
+    }
+
+    return $false
+}
+
+# Main script logic
+if ([string]::IsNullOrWhiteSpace($ShortName)) {
+    Write-Error 'Aborted: no name provided. (Pass -ShortName or use the VS Code task prompt.)'
+    exit 1
+}
+
+if (-not (Test-ValidShortName -CandidateName $ShortName)) {
+    Write-Error "Aborted: '$ShortName' is invalid. Use kebab-case letters/numbers only (e.g., notes-feature)."
+    exit 1
+}
+
+$workspace = (Get-Location).Path
+$today = Get-Date -Format 'yyyy-MM-dd'
+$lastUpdated = Get-Date -Format 'yyyy-MM-ddTHH-mm'
+$target = Join-Path $workspace "docs/features/potential/$today-$ShortName.md"
+if ($TemplateRoot -and (Test-Path (Join-Path $TemplateRoot 'potential/template.md'))) {
+    $template = Join-Path $TemplateRoot 'potential/template.md'
+}
+else {
+    $template = Join-Path $workspace 'docs/features/potential/template.md'
+}
+if (-not (Test-Path $template)) {
+    Write-Error "Template not found: $template"
+    exit 1
+}
+$backlog = Join-Path $workspace 'docs/features/backlog.md'
+
+$targetDir = Split-Path -Parent $target
+if (-not (Test-Path $targetDir)) {
+    New-Item -ItemType Directory -Path $targetDir -Force | Out-Null
+}
+Copy-Item $template $target -Force
+Write-Output "Created: $target"
+
+# Populate placeholders in the new file
+$author = Get-AuthorName
+$status = 'Draft'
+$statusColor = 'lightgrey'
+$issue = 'TBD'
+$parent = 'none'
+$version = '0.1'
+$content = Get-Content -Raw -Path $target
+$content = Convert-TemplateContent -Content $content -ShortName $ShortName -Date $today -Author $author -LastUpdated $lastUpdated -Status $status -StatusColor $statusColor -Issue $issue -Parent $parent -Version $version
+Set-Content -Path $target -Value $content -Encoding UTF8
+
+$opened = Invoke-VSCodeOpen -Files @($target, $backlog)
+if (-not $opened) {
+    Write-Warning "VS Code CLI command not found (expected 'code' or 'code-insiders'). Open files manually:"
+    Write-Output "  $target"
+    Write-Output "  $backlog"
+}
+

package/resources/templates/new_active_feature_folder.py

@@ -0,0 +1,67 @@
+"""Compatibility wrapper for extension-side active feature folder creation.
+
+Purpose:
+    Preserve the bundled-script entry point while delegating folder-creation
+    behavior to the bundled package implementation.
+
+Usage:
+    python new_active_feature_folder.py --feature-name <name> --type <type> \
+    [--issue-number <number>] --work-mode <mode>
+
+Flow:
+    1. Ensure `resources/scripts/` is importable at runtime.
+    2. Import `dev_tools.new_active_feature_folder` from bundled sources.
+    3. Invoke the bundled CLI entrypoint in-process with unmodified CLI args.
+
+Invariants / Constraints:
+    - No feature-folder business logic is implemented in this wrapper.
+    - Argument contract is owned by the bundled folder-creation module and
+      forwarded unchanged.
+
+Side Effects:
+    Imports bundled folder-creation code and executes it in the current Python
+    process.
+"""
+
+from __future__ import annotations
+
+import importlib
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING, cast
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+def _ensure_bundled_scripts_import_path() -> None:
+    """Prepend bundled `resources/scripts` directory to ``sys.path``."""
+    scripts_dir = Path(__file__).resolve().parent.parent / "scripts"
+    scripts_dir_str = str(scripts_dir)
+
+    if scripts_dir_str not in sys.path:
+        sys.path.insert(0, scripts_dir_str)
+
+
+def main() -> int:
+    """Execute bundled active-feature-folder entrypoint in-process.
+
+    Injects ``--template-root`` pointing to the extension's bundled
+    ``feature-templates`` directory so the downstream module resolves
+    templates from the extension rather than the workspace.
+    """
+    _ensure_bundled_scripts_import_path()
+
+    # Compute the bundled template root relative to this wrapper script.
+    template_root = str(Path(__file__).resolve().parent.parent / "feature-templates")
+    if "--template-root" not in sys.argv:
+        sys.argv.extend(["--template-root", template_root])
+
+    module = importlib.import_module("dev_tools.new_active_feature_folder")
+    module_main = cast("Callable[[], None]", module.main)
+    module_main()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/resources/templates/new_potential_bug_entry.py

@@ -0,0 +1,54 @@
+"""Compatibility wrapper for extension-side potential bug entry creation.
+
+Purpose:
+    Preserve the bundled-script entry point while delegating bug-entry creation
+    behavior to the bundled package implementation.
+
+Usage:
+    python new_potential_bug_entry.py --short-name <name> [--template-root <path>]
+
+Flow:
+    1. Ensure `resources/scripts/` is importable at runtime.
+    2. Import `dev_tools.new_potential_bug_entry` from bundled sources.
+    3. Invoke the bundled CLI entrypoint in-process with unmodified CLI args.
+
+Invariants / Constraints:
+    - No bug-entry business logic is implemented in this wrapper.
+    - Argument contract is owned by the bundled bug-entry module and forwarded
+      unchanged.
+
+Side Effects:
+    Imports bundled bug-entry code and executes it in the current Python process.
+"""
+
+from __future__ import annotations
+
+import importlib
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING, cast
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+def _ensure_bundled_scripts_import_path() -> None:
+    """Prepend bundled `resources/scripts` directory to ``sys.path``."""
+    scripts_dir = Path(__file__).resolve().parent.parent / "scripts"
+    scripts_dir_str = str(scripts_dir)
+
+    if scripts_dir_str not in sys.path:
+        sys.path.insert(0, scripts_dir_str)
+
+
+def main() -> int:
+    """Execute bundled potential-bug-entry entrypoint in-process."""
+    _ensure_bundled_scripts_import_path()
+    module = importlib.import_module("dev_tools.new_potential_bug_entry")
+    module_main = cast("Callable[[], None]", module.main)
+    module_main()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/resources/templates/policy_audit/AGENTS.md

@@ -0,0 +1,117 @@
+# Policy Audit Agent Instructions (Local Scope)
+
+> NOTE: This file is scoped **only** to the policy audit templates directory.
+> It does **not** change the global repo policy or day-to-day coding behavior.
+> Apply these instructions only when the user explicitly requests a **Policy Audit**.
+
+## When these instructions apply
+
+Only follow this file when:
+
+- The user explicitly asks for a "Policy Audit", "policy compliance audit", or similar, **or**
+- The user is editing or creating a `PolicyAudit*.md` file in connection with a specific change, PR, or feature.
+
+If the user is doing normal coding, test authoring, or refactoring without asking for an audit, **ignore this AGENTS.md** and follow the canonical instructions in:
+
+- `.github/copilot-instructions.md`
+- `.github/instructions/*.instructions.md`
+
+## Inputs
+
+When performing a policy audit:
+
+1. Use the local process guide  
+   - Read [README.md](./README.md) in this directory for the detailed audit process and usage instructions.
+
+2. Use the policy audit template  
+   - Use [policy-audit.yyyy-MM-ddTHH-mm.md](./policy-audit.yyyy-MM-ddTHH-mm.md) as the structural starting point for the audit document.
+   - Create a working copy (for example: `docs/features/active/<feature>/policy-audit.2026-01-08T14-30.md`) rather than editing the template in place.
+
+3. Use the canonical policy documents for evaluation (read-only)  
+   - General code change policy: `.github/instructions/general-code-change.instructions.md`
+   - Language-specific code change policy:
+     - Python: `.github/instructions/python-code-change.instructions.md`
+     - PowerShell: `.github/instructions/powershell-code-change.instructions.md`
+   - General unit test policy: `.github/instructions/general-unit-test.instructions.md`
+   - Language-specific unit test policy:
+     - Python: `.github/instructions/python-unit-test.instructions.md`
+     - PowerShell: `.github/instructions/powershell-unit-test.instructions.md`
+
+## Behavior: How to run a Policy Audit
+
+When asked to perform a Policy Audit for a component, branch, or PR:
+
+1. **Identify scope**
+   - Determine what is being audited (e.g., "fix-all.ps1 unit tests", "Lexile scoring pipeline refactor", "new Python module X").
+   - Identify the relevant code files and test files.
+   - **Document baseline coverage BEFORE making changes** (if development has not yet started, or shelve changes temporarily to establish baseline).
+
+2. **Create an audit document**
+   - Generate a timestamp in ISO-8601 format `yyyy-MM-ddTHH-mm` (e.g., "2026-01-08T14-30" for Jan 8, 2026 at 2:30 PM).
+   - Copy [policy-audit.yyyy-MM-ddTHH-mm.md](./policy-audit.yyyy-MM-ddTHH-mm.md) to the requested location with timestamped filename: `policy-audit.<timestamp>.md` (e.g., feature folder or PR docs).
+   - Replace placeholders (`[Component Name]`, dates, paths, counts) as described in [README.md](./README.md).
+   - Preserve the explicit coverage evidence checklist in the template.
+     - Keep the TypeScript and PowerShell artifact lines even when those languages are out of scope; mark them `N/A - out of scope` rather than deleting them.
+     - Fill the per-language comparison summary reference with either an in-document section reference or an exact artifact path.
+   - **For multi-language changes:**
+     - Fill in the Coverage Metrics by Language table with one row per language.
+     - Complete all applicable language sections (3A, 3B, 3C, 3D for code; 4A, 4B for tests).
+     - Delete sections for languages NOT involved in this change.
+   - **Fill in baseline coverage metrics** from pre-development measurement (per language that has coverage).
+   - Add one per-language comparison bullet for every in-scope language that has coverage requirements.
+
+3. **Evaluate policy compliance**
+   - For each section of the template:
+     - Run the actual toolchain commands required by the general and language-specific policies.
+     - Inspect the code and tests for compliance with both:
+       - General policies, and
+       - Language-specific addenda.
+     - Record **status** (`✅ PASS`, `⚠️ PARTIAL`, `❌ FAIL`, `N/A`) and **evidence** in the appropriate table rows.
+   - **For multi-language changes:**
+     - Run each language's toolchain separately and document results in its section.
+     - **Python:** Black → Ruff → Pyright → Pytest (with coverage)
+     - **PowerShell:** Invoke-PoshQCFormat → Invoke-PoshQCAnalyze → Invoke-PoshQCTest (with coverage)
+     - **Bash:** shfmt → shellcheck → bats (coverage N/A)
+     - **JSON:** format_json → validate_json (coverage N/A)
+   - **For coverage metrics (Python and PowerShell only):**
+     - Compare post-change coverage to baseline to verify no regression (per language).
+     - Isolate and measure coverage of new/modified code only (must be ≥90% per language).
+     - Use concrete examples showing calculations: "Baseline: 85.2% → Post-change: 87.1% (+1.9%) ✅"
+   - **Fail-closed evidence handling:**
+     - No policy audit may report PASS unless it includes numeric baseline and post-change coverage metrics for every language in scope, plus changed/new-code coverage when required.
+     - If any required baseline artifact, QA artifact, or coverage-comparison artifact is missing, the verdict must be BLOCKED or INCOMPLETE, never PASS.
+     - Do not synthesize or backfill missing audit evidence from memory or inference.
+     - If evidence is missing, stop and report the exact missing artifact paths.
+   - **For scenario testing:**
+     - Use deterministic, input→output→assertion format for all examples.
+     - **Positive flows:** Show concrete valid inputs and expected outputs.
+     - **Negative flows:** Show concrete invalid inputs, expected exceptions, and error messages.
+     - **Edge cases:** Show concrete boundary conditions (empty, max length, Unicode, whitespace).
+     - **Error handling:** Show concrete error conditions and expected exception types.
+
+4. **Verify temporary artifacts cleanup**
+   - **Identify all scripts created during development** (check commit history, staged files, dev-tools folders).
+   - **Categorize each script:**
+     - Temporary/one-time: Delete before finalizing audit.
+     - Ongoing tooling: Must have full test coverage and pass all repo policies.
+   - **Document disposition** in "Temporary artifacts cleanup" section of audit.
+
+5. **Document gaps and exceptions**
+   - If any requirement is not fully met:
+     - Document the gap, rationale, and proposed follow-up in the "Gaps and Exceptions" section.
+     - List any removed/skipped tests and their justifications.
+   - If exceptions to policy are explicitly approved, record them in the "Approved Exceptions" section.
+
+6. **Summarize and recommend**
+   - Complete the summary sections at the end of the template:
+     - Policy-by-policy summary
+     - Metrics summary (with deterministic baseline/post-change/new code coverage)
+     - Recommendation (`Ready for merge`, `Needs revision`, or `Blocked`)
+   - Ensure the final audit document is consistent with the underlying evidence and toolchain output.
+
+## Constraints
+
+- Do **not** modify the canonical `.instructions.md` policy documents as part of an audit.
+- Do **not** treat this AGENTS file as a reason to change how normal code or tests are written; it is for **evaluation and documentation** only.
+- Do **not** report readiness as PASS when required audit evidence is absent; report incomplete with the missing artifact names or paths.
+- If you detect any conflict between this file and the canonical policy documents, halt and ask the user for clarification instead of guessing.

package/resources/templates/policy_audit/code-review.yyyy-MM-ddTHH-mm.md

@@ -0,0 +1,165 @@
+# Code Review: [Feature or Scope Name] ([#Issue or Scope Reference])
+
+> **Template Usage Instructions:**
+>
+> This template is for writing feature-level or staged-diff code reviews that accompany policy audits and feature audits.
+>
+> **How to use:**
+> 1. Copy this template to the target feature folder with an ISO-8601 timestamped filename: `code-review.yyyy-MM-ddTHH-mm.md`.
+> 2. Replace all placeholders with concrete branch, file, test, and evidence details.
+> 3. Keep the sections that apply to the reviewed scope and delete inapplicable language subsections.
+> 4. Base all findings on verified evidence: diff inspection, toolchain output, coverage data, and feature-folder artifacts.
+> 5. Use severity labels consistently: `Blocker`, `Major`, `Minor`, `Nit`, `Info`.
+> 6. End with a clear readiness recommendation that matches the actual findings.
+>
+> **When to use:**
+> - Feature branch review relative to a base branch
+> - Post-remediation re-review
+> - Staged-diff review before commit
+> - Any repository workflow that requires `code-review.<timestamp>.md`
+>
+> **Delete this instruction block before finalizing the review.**
+
+---
+
+**Review Date:** [YYYY-MM-DD]
+**Reviewer:** [Agent or reviewer name]
+**Feature Folder:** `[docs/features/active/or/archive/path]`
+**Feature Folder Selection Rule:** [How this feature folder was selected, or delete if obvious]
+**Base Branch:** `[branch-name]`
+**Head Branch:** `[branch-name or staged working tree]`
+**Review Type:** [Initial review / Post-remediation re-review / Staged-diff review]
+
+---
+
+## Executive Summary
+
+[Summarize the reviewed change in 1-2 paragraphs. State what changed, how large the scope is, what evidence was reviewed, and the overall implementation quality.]
+
+**What changed:**
+[Describe the implementation delta relative to the base branch or staged diff. Keep this concrete and file-aware.]
+
+**Top 3 risks:**
+1. [Most important remaining risk or uncertainty]
+2. [Second most important remaining risk or uncertainty]
+3. [Third most important remaining risk or uncertainty]
+
+**PR readiness recommendation:** **[Go / Conditional Go / Needs Revision / Blocked]** — [One-sentence rationale grounded in the evidence below.]
+
+---
+
+## Findings Table
+
+| Severity | File | Location | Finding | Recommendation | Rationale | Evidence |
+|---|---|---|---|---|---|---|
+| [Blocker/Major/Minor/Nit/Info] | `[path]` | `[line range / section / n/a]` | [Concrete issue] | [Concrete corrective action or note] | [Why it matters] | [Command output, artifact path, or inspected file reference] |
+| [Blocker/Major/Minor/Nit/Info] | `[path]` | `[line range / section / n/a]` | [Concrete issue] | [Concrete corrective action or note] | [Why it matters] | [Command output, artifact path, or inspected file reference] |
+
+[If applicable, add a short line such as `No Blockers or Major findings.`]
+
+---
+
+## Implementation Audit
+
+**Instructions:** Keep only the language subsections that apply to the reviewed diff. Delete unused subsections.
+
+### Python implementation audit (if applicable)
+
+#### What changed well
+
+- [Summarize the strongest implementation decisions in the Python scope.]
+
+#### Typing and API notes
+
+- [Describe type annotation quality, protocol/dataclass usage, public API clarity, or note `No new public Python API surface was added.`]
+
+#### Error handling and logging
+
+- [Describe exception handling, logging choices, and any relevant safeguards.]
+
+### TypeScript implementation audit (if applicable)
+
+#### What changed well
+
+- [Summarize the strongest implementation decisions in the TypeScript scope.]
+
+#### Type safety and maintainability
+
+- [Describe exported type precision, generic use, suppression status, maintainability, and any notable gaps.]
+
+#### Error handling and logging
+
+- [Describe boundary validation, failure behavior, and logging patterns.]
+
+### PowerShell implementation audit (if applicable)
+
+#### What changed well
+
+- [Summarize the strongest implementation decisions in the PowerShell scope.]
+
+#### API and safety notes
+
+- [Describe advanced-function usage, parameter validation, ShouldProcess behavior, naming, and analyzer hygiene.]
+
+#### Error handling and logging
+
+- [Describe failure behavior, error surfacing, and logging choices.]
+
+### C# implementation audit (if applicable)
+
+#### What changed well
+
+- [Summarize the strongest implementation decisions in the C# scope.]
+
+#### Type safety and API notes
+
+- [Describe nullable safety, public contracts, analyzer cleanliness, and API clarity.]
+
+#### Error handling and logging
+
+- [Describe exception handling, logging patterns, and resource/lifecycle safety.]
+
+---
+
+## Test Quality Audit
+
+[Summarize the automated and manual verification evidence reviewed. Note whether coverage, regression, or end-to-end evidence is present and what gaps remain.]
+
+### Reviewed test and QA artifacts
+
+- `[test-or-artifact-path]` — [What it verifies, execution quality, and any notable gap]
+- `[test-or-artifact-path]` — [What it verifies, execution quality, and any notable gap]
+- `[evidence/artifact-path]` — [What it proves about the change]
+
+### Quality assessment prompts
+
+- **Determinism:** [How the tests avoid flaky dependencies]
+- **Isolation:** [Whether each test targets a clear behavior]
+- **Speed:** [Observed runtime quality or evidence source]
+- **Diagnostics:** [How clearly failures would identify the problem]
+
+---
+
+## Security / Correctness Checks
+
+| Check | Status | Evidence |
+|---|---|---|
+| No secrets in code | [✅ PASS / ⚠️ PARTIAL / ❌ FAIL / N/A] | [Concrete inspection result] |
+| No unsafe subprocess or command construction | [✅ PASS / ⚠️ PARTIAL / ❌ FAIL / N/A] | [Concrete inspection result] |
+| Input validation at boundaries | [✅ PASS / ⚠️ PARTIAL / ❌ FAIL / N/A] | [Concrete inspection result] |
+| Error handling remains explicit | [✅ PASS / ⚠️ PARTIAL / ❌ FAIL / N/A] | [Concrete inspection result] |
+| Configuration / path handling is safe | [✅ PASS / ⚠️ PARTIAL / ❌ FAIL / N/A] | [Concrete inspection result] |
+
+[Add or delete rows to match the reviewed technology and risk profile.]
+
+---
+
+## Research Log
+
+[State whether external research was required. If none, say so directly. If research was required, list the sources and why they mattered.]
+
+---
+
+## Verdict
+
+[Provide the final review conclusion in 1-2 paragraphs. State whether the change is ready for normal PR flow, ready after a specific follow-up, or blocked. Ensure this conclusion is consistent with the Findings Table and PR readiness recommendation above.]