@danmoisan/drm-copilot-mcp 1.1.21 → 1.1.23

package/resources/codex-and-agents-customizations/.codex/hooks/file-size-policy.ps1

@@ -0,0 +1,421 @@
+<#
+.SYNOPSIS
+    Codex twin of the tiered file-size policy functions (500 guidance, 700 advisory, 800 hard limit).
+
+.DESCRIPTION
+    Dot-sourced by .codex/hooks/enforce-file-size-limit.ps1 as:
+    . (Join-Path $PSScriptRoot 'file-size-policy.ps1')
+
+    Codex hooks cannot import .claude/lib in a consumer repository, so the policy
+    functions of .claude/lib/file-size-policy/FileSizePolicy.psm1 are mirrored here.
+    Every function definition in this file is text-identical to the definition of the
+    same name in that module; tests/scripts/codex-hooks/file-size-policy.Tests.ps1
+    parses both files and fails on any difference, and runs the shared case rows
+    against this file. Edit the module first, then copy each changed definition here.
+
+.NOTES
+    Compatible with PowerShell 7+.
+
+    Entrypoint-free by design: this file contains only function definitions, so
+    dot-sourcing it has no side effects and no exit-code semantics. It never reads
+    standard input and never reads any legacy Claude environment variable. Every
+    function is pure: no filesystem, process, network, environment, or clock access.
+#>
+
+function Get-FileSizePolicyLimit {
+    <#
+    .SYNOPSIS
+        Return the three tier limits of the file-size policy.
+    .OUTPUTS
+        A PSCustomObject with Guidance (500), Advisory (700), and HardLimit (800).
+    #>
+    [CmdletBinding()]
+    [OutputType([pscustomobject])]
+    param()
+
+    return [pscustomobject]@{
+        Guidance  = 500
+        Advisory  = 700
+        HardLimit = 800
+    }
+}
+
+function Get-FileSizeExcludedSegment {
+    <#
+    .SYNOPSIS
+        Return the directory names excluded from the file-size policy.
+    .DESCRIPTION
+        A path with any of these names as a directory segment is not covered. This
+        function is the single source of the excluded names: Test-FileSizeCoveredPath
+        and the repository gate traversal both read it. Each call returns a new array.
+    .OUTPUTS
+        System.String[].
+    #>
+    [CmdletBinding()]
+    [OutputType([string[]])]
+    param()
+
+    return [string[]]@('.git', 'node_modules', 'artifacts', 'coverage', 'dist', 'out', 'virtual', 'docs',
+        'build', '.venv', 'venv', 'env', '__pycache__', '.pytest_cache', '.mypy_cache', '.ruff_cache', '.tox',
+        '.nox', 'htmlcov', '.vscode-test')
+}
+
+function Get-FileSizeLogicalLineCount {
+    <#
+    .SYNOPSIS
+        Count the logical lines of a text.
+    .DESCRIPTION
+        Splits the content on CRLF or LF. A trailing line terminator does not add a
+        line, and empty or null content has zero lines.
+    .PARAMETER Content
+        The file content.
+    .OUTPUTS
+        System.Int32.
+    #>
+    [CmdletBinding()]
+    [OutputType([int])]
+    param(
+        [Parameter(Mandatory)]
+        [AllowNull()]
+        [AllowEmptyString()]
+        [string] $Content
+    )
+
+    if ([string]::IsNullOrEmpty($Content)) {
+        return 0
+    }
+
+    $count = [regex]::Split($Content, '\r?\n').Count
+    if ($Content.EndsWith("`n")) {
+        # The split yields one empty trailing element after a final terminator.
+        $count--
+    }
+    return $count
+}
+
+function Get-FileSizeTier {
+    <#
+    .SYNOPSIS
+        Classify a logical line count into a policy tier.
+    .DESCRIPTION
+        Returns 'Below' (under 500), 'Guidance' (500 through 699), 'Advisory' (700
+        through 799), or 'HardLimit' (800 and above). The hard block applies only
+        above 800; a count of exactly 800 is in the HardLimit tier and still passes.
+    .PARAMETER LineCount
+        A non-negative logical line count.
+    .OUTPUTS
+        System.String.
+    #>
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter(Mandatory)]
+        [int] $LineCount
+    )
+
+    if ($LineCount -lt 0) {
+        throw "Get-FileSizeTier: LineCount must be non-negative; received $LineCount."
+    }
+
+    $limit = Get-FileSizePolicyLimit
+    if ($LineCount -ge $limit.HardLimit) { return 'HardLimit' }
+    if ($LineCount -ge $limit.Advisory) { return 'Advisory' }
+    if ($LineCount -ge $limit.Guidance) { return 'Guidance' }
+    return 'Below'
+}
+
+function ConvertTo-FileSizeRelativePath {
+    <#
+    .SYNOPSIS
+        Convert a file path to a repository-relative forward-slash path.
+    .DESCRIPTION
+        Backslashes are normalized to forward slashes. A relative path is returned
+        without a leading './'. An absolute path under the repository root is
+        returned relative to the root (compared case-insensitively, because the
+        root may come from a case-insensitive file system). A path outside the root,
+        a relative path that climbs above the root, and the root itself return
+        $null, which callers treat as not covered.
+    .PARAMETER Path
+        The file path from a tool payload or a discovery.
+    .PARAMETER RepositoryRoot
+        The repository root directory.
+    .OUTPUTS
+        System.String, or $null for a path outside the repository root.
+    #>
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter(Mandatory)]
+        [AllowNull()]
+        [AllowEmptyString()]
+        [string] $Path,
+
+        [Parameter(Mandatory)]
+        [string] $RepositoryRoot
+    )
+
+    if ([string]::IsNullOrWhiteSpace($Path)) {
+        return $null
+    }
+
+    $normalized = $Path.Replace('\', '/')
+    $isRooted = $normalized.StartsWith('/') -or ($normalized -match '^[A-Za-z]:/')
+    if (-not $isRooted) {
+        while ($normalized.StartsWith('./')) {
+            $normalized = $normalized.Substring(2)
+        }
+        if ($normalized -eq '..' -or $normalized.StartsWith('../') -or $normalized.Length -eq 0) {
+            return $null
+        }
+        return $normalized
+    }
+
+    $root = $RepositoryRoot.Replace('\', '/').TrimEnd('/')
+    $prefix = $root + '/'
+    if (-not $normalized.StartsWith($prefix, [System.StringComparison]::OrdinalIgnoreCase)) {
+        return $null
+    }
+
+    $relative = $normalized.Substring($prefix.Length)
+    if ($relative.Length -eq 0) {
+        return $null
+    }
+    return $relative
+}
+
+function Test-FileSizeCoveredPath {
+    <#
+    .SYNOPSIS
+        Report whether a repository-relative path is covered by the file-size policy.
+    .DESCRIPTION
+        A path is covered when its extension (case-insensitive) is in the allowlist
+        (py, ps1, psm1, ts, tsx, js, cjs, mjs, cs, sh, and bats), no directory segment
+        is an excluded name, and it is not under the worktrees folder of .claude.
+        Excluded directory names are matched exactly. Null or empty input is not covered.
+    .PARAMETER RelativePath
+        A repository-relative path, for example from ConvertTo-FileSizeRelativePath.
+    .OUTPUTS
+        System.Boolean.
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [Parameter(Mandatory)]
+        [AllowNull()]
+        [AllowEmptyString()]
+        [string] $RelativePath
+    )
+
+    if ([string]::IsNullOrWhiteSpace($RelativePath)) {
+        return $false
+    }
+
+    $allowedExtension = @('.py', '.ps1', '.psm1', '.ts', '.tsx', '.js', '.cjs', '.mjs', '.cs', '.sh', '.bats')
+    $excludedSegment = @(Get-FileSizeExcludedSegment)
+
+    $normalized = $RelativePath.Replace('\', '/')
+    if ($normalized.StartsWith('.claude/worktrees/')) {
+        return $false
+    }
+
+    $segment = @($normalized.Split('/'))
+    for ($index = 0; $index -lt ($segment.Count - 1); $index++) {
+        if ($excludedSegment -ccontains $segment[$index]) {
+            return $false
+        }
+    }
+
+    $extension = [System.IO.Path]::GetExtension($segment[-1]).ToLowerInvariant()
+    return ($allowedExtension -contains $extension)
+}
+
+function Compare-FileSizeBaselineEntry {
+    <#
+    .SYNOPSIS
+        Compare one file's current size with its baseline entry under the strict ratchet.
+    .DESCRIPTION
+        Rows (S is the current size, B the recorded size):
+          S <= 800, no entry       -> pass
+          S <= 800, entry          -> 'stale-entry' (remove the entry)
+          S > 800, no entry        -> 'new-over-limit'
+          S > 800, entry, S > B    -> 'grew'
+          S > 800, entry, S == B   -> pass
+          S > 800, entry, S < B    -> 'tighten' (tighten the entry to S)
+          no file, entry           -> 'missing-file' (stale entry for a deleted or renamed file)
+          no file, no entry        -> pass
+    .PARAMETER Path
+        The repository-relative path, used in the violation message.
+    .PARAMETER CurrentSize
+        The current logical line count, or $null when no file exists on disk.
+    .PARAMETER BaselineSize
+        The recorded size, or $null when the baseline has no entry.
+    .OUTPUTS
+        $null on pass; otherwise a PSCustomObject with Path, Rule, and Message.
+    #>
+    [CmdletBinding()]
+    [OutputType([pscustomobject])]
+    param(
+        [Parameter(Mandatory)]
+        [string] $Path,
+
+        [AllowNull()]
+        [Nullable[int]] $CurrentSize,
+
+        [AllowNull()]
+        [Nullable[int]] $BaselineSize
+    )
+
+    $hardLimit = (Get-FileSizePolicyLimit).HardLimit
+    $rule = $null
+    $message = $null
+
+    if ($null -eq $CurrentSize) {
+        if ($null -ne $BaselineSize) {
+            $rule = 'missing-file'
+            $message = "stale baseline entry: '$Path' has no file on disk (deleted or renamed); remove the entry or move it with its recorded size unchanged."
+        }
+    } elseif ($CurrentSize -le $hardLimit) {
+        if ($null -ne $BaselineSize) {
+            $rule = 'stale-entry'
+            $message = "stale baseline entry: '$Path' has $CurrentSize lines, at or below the $hardLimit-line hard limit; remove the entry."
+        }
+    } elseif ($null -eq $BaselineSize) {
+        $rule = 'new-over-limit'
+        $message = "new file over the hard limit: '$Path' has $CurrentSize lines, above the $hardLimit-line hard limit; split the file."
+    } elseif ($CurrentSize -gt $BaselineSize) {
+        $rule = 'grew'
+        $message = "baselined file grew: '$Path' has $CurrentSize lines, above its recorded $BaselineSize; a baselined file may not grow."
+    } elseif ($CurrentSize -lt $BaselineSize) {
+        $rule = 'tighten'
+        $message = "baselined file shrank: '$Path' has $CurrentSize lines, below its recorded $BaselineSize; tighten the entry to $CurrentSize."
+    }
+
+    if ($null -eq $rule) {
+        return $null
+    }
+    return [pscustomobject]@{ Path = $Path; Rule = $rule; Message = $message }
+}
+
+function Resolve-FileSizeEditContent {
+    <#
+    .SYNOPSIS
+        Apply an Edit-tool old_string to new_string replacement to pre-edit content in memory.
+    .DESCRIPTION
+        Follows the replacement approach of Resolve-EditedCheckpointContent in
+        .claude/hooks/enforce-completion-consistency.ps1: CRLF is normalized to LF in
+        all three strings, matching is ordinal (no regular expression, so '$' in the
+        new text stays literal), one occurrence is replaced unless ReplaceAll is true,
+        and a second match after the first is ambiguous. Failure is 'no-old-string'
+        (absent or empty old string), 'not-found', or 'ambiguous'.
+    .PARAMETER Content
+        The pre-edit file content.
+    .PARAMETER OldString
+        The text to replace.
+    .PARAMETER NewString
+        The replacement text; null is treated as empty.
+    .PARAMETER ReplaceAll
+        Replace every occurrence instead of exactly one.
+    .OUTPUTS
+        A PSCustomObject with Content (the edited text, or $null on failure) and
+        Failure (a failure code, or $null on success).
+    #>
+    [CmdletBinding()]
+    [OutputType([pscustomobject])]
+    param(
+        [Parameter(Mandatory)]
+        [AllowNull()]
+        [AllowEmptyString()]
+        [string] $Content,
+
+        [Parameter(Mandatory)]
+        [AllowNull()]
+        [AllowEmptyString()]
+        [string] $OldString,
+
+        [AllowNull()]
+        [AllowEmptyString()]
+        [string] $NewString = '',
+
+        [bool] $ReplaceAll = $false
+    )
+
+    if ([string]::IsNullOrEmpty($OldString)) {
+        return [pscustomobject]@{ Content = $null; Failure = 'no-old-string' }
+    }
+
+    $text = ([string]$Content).Replace("`r`n", "`n")
+    $old = $OldString.Replace("`r`n", "`n")
+    $new = ([string]$NewString).Replace("`r`n", "`n")
+
+    $first = $text.IndexOf($old, [System.StringComparison]::Ordinal)
+    if ($first -lt 0) {
+        return [pscustomobject]@{ Content = $null; Failure = 'not-found' }
+    }
+    if ($ReplaceAll) {
+        return [pscustomobject]@{ Content = $text.Replace($old, $new); Failure = $null }
+    }
+
+    $second = $text.IndexOf($old, $first + $old.Length, [System.StringComparison]::Ordinal)
+    if ($second -ge 0) {
+        return [pscustomobject]@{ Content = $null; Failure = 'ambiguous' }
+    }
+
+    $edited = $text.Substring(0, $first) + $new + $text.Substring($first + $old.Length)
+    return [pscustomobject]@{ Content = $edited; Failure = $null }
+}
+
+function Get-FileSizeHookDecision {
+    <#
+    .SYNOPSIS
+        Decide whether a Write or Edit may leave a file at its resulting size.
+    .DESCRIPTION
+        Baseline-free pre-edit-size ratchet. A path that is not covered is allowed.
+        A covered result of at most 800 lines is allowed. A covered result above 800
+        lines is allowed only when the file already existed and the result is not
+        larger than its pre-edit size, so an already-large file may shrink or stay
+        the same size but may not grow; every other case is denied. The deny reason
+        starts with 'FILE_SIZE_LIMIT_BLOCKED:' and names the path, the resulting
+        count, the three tiers, and the split requirement.
+    .PARAMETER RelativePath
+        The repository-relative path; $null or empty (outside the repository) is not covered.
+    .PARAMETER ResultLineCount
+        The logical line count the file would have after the operation.
+    .PARAMETER PreEditLineCount
+        The logical line count before the operation, or $null for a new file.
+    .OUTPUTS
+        A PSCustomObject with Allowed (bool) and Reason ($null when allowed).
+    #>
+    [CmdletBinding()]
+    [OutputType([pscustomobject])]
+    param(
+        [Parameter(Mandatory)]
+        [AllowNull()]
+        [AllowEmptyString()]
+        [string] $RelativePath,
+
+        [Parameter(Mandatory)]
+        [int] $ResultLineCount,
+
+        [AllowNull()]
+        [Nullable[int]] $PreEditLineCount
+    )
+
+    $limit = Get-FileSizePolicyLimit
+    $isAllowed = (-not (Test-FileSizeCoveredPath -RelativePath $RelativePath)) -or
+    ($ResultLineCount -le $limit.HardLimit) -or
+    (($null -ne $PreEditLineCount) -and ($ResultLineCount -le $PreEditLineCount))
+    if ($isAllowed) {
+        return [pscustomobject]@{ Allowed = $true; Reason = $null }
+    }
+
+    $growth = ''
+    if ($null -ne $PreEditLineCount) {
+        $growth = " It has $PreEditLineCount lines now; a file already above the hard limit may shrink or stay the same size but may not grow."
+    }
+    $reason = "FILE_SIZE_LIMIT_BLOCKED: '$RelativePath' would have $ResultLineCount logical lines, above the " +
+    "$($limit.HardLimit)-line hard limit.$growth File-size policy tiers: $($limit.Guidance) lines is guidance " +
+    "(look for a logical split), $($limit.Advisory) lines is advisory (split more aggressively; reviewers report " +
+    "a non-blocking Warning), and above $($limit.HardLimit) lines a split is enforced regardless of logical " +
+    "separability. Split the file into smaller files so each stays at or below $($limit.HardLimit) lines."
+    return [pscustomobject]@{ Allowed = $false; Reason = $reason }
+}

package/resources/codex-and-agents-customizations/.codex-variants/csharp-legacy/agents/csharp-typed-engineer.toml

@@ -83,7 +83,7 @@ If the marker is missing or malformed, fail closed to `full-feature`.
 Stop implementation and return to the user when:
 
 - the scope estimate or an in-flight batch would exceed the 3-production-file cap in direct mode,
-- a file is near or would exceed the 500-line limit,
+- a file is above or would exceed the 800-line hard limit of the tiered file-size policy (split it before proceeding; at 500 lines look for a logical split, and at 700 lines split more aggressively),
 - any QA gate delta is non-zero after self-correction,
 - the toolchain cannot be executed in the current environment (mark the change **unverified**),
 - orchestrator handoff mode is requested but the required context package is incomplete,

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

@@ -52,7 +52,10 @@ Run the full toolchain in this exact order and repeat until all steps pass in a
 
 ## File Size Limit
 
-- No production code, test code, or reusable script file may exceed **500 lines**.
+- File size follows three tiers for production code, test code, and reusable script files, counted in logical lines (a trailing line terminator does not add a line):
+  - **500 lines (guidance):** look for a logical way to divide the file into multiple files, provided the parts can be separated logically. No gate fails at this tier.
+  - **700 lines (advisory):** look for a split more aggressively. Reviewers and `feature-review` report a non-blocking Warning for a file at or above 700 lines. No gate fails at this tier.
+  - **Above 800 lines (hard block):** split the file regardless of logical separability. The repository CI check and the PreToolUse hook block a file of 801 lines or more; a file of exactly 800 lines passes. Legacy files above 800 lines are listed in `config/file-size-baseline.json` and may shrink (with the entry tightened) or stay the same size, but may not grow.
 - Exceptions: temporary throwaway scripts created and deleted within an agent session; raw text fixtures for language-processing test data; Markdown documentation files.
 
 ## Error Handling and Logging

package/resources/codex-and-agents-customizations/pack-manifests/core.json

@@ -64,6 +64,8 @@
     ".codex/hooks/enforce-completion-consistency.ps1",
     ".codex/hooks/enforce-completion-helpers.ps1",
     ".codex/hooks/enforce-evidence-locations.ps1",
+    ".codex/hooks/enforce-file-size-limit.ps1",
+    ".codex/hooks/file-size-policy.ps1",
     ".codex/hooks/enforce-orchestration-preimplementation-gate.ps1",
     ".codex/hooks/enforce-powershell-batch-budget.ps1",
     ".codex/hooks/enforce-promotion-mcp-only.ps1",
@@ -79,6 +81,7 @@
     ".codex/scripts/codex-routing-cli-common.ps1",
     ".codex/scripts/Resolve-CodexDeployment.ps1",
     ".codex/scripts/Resolve-CodexTopology.ps1",
+    ".codex/scripts/post-codex-worktree-session.ps1",
     ".codex/prompts/generate-pr.md",
     ".codex/prompts/orchestrate-work.md",
     ".codex/agents/feature-reviewer.toml",

package/resources/customizations/.github/agents/commentary-remediation.agent.md

@@ -14,7 +14,7 @@ Relentlessly bring the targeted scope into full compliance with `.github/instruc
 - **Scope fidelity:** Accept a scope (single file, set of files, or entire repo) and remediate everything in that scope. Do not stop or return early; continue through all phases, using additional turns automatically if needed.
 - **Policy order:** Read and apply, in order: `.github/copilot-instructions.md`, general code-change, general unit-test, python code-change, python unit-test, and self-explanatory-commenting policies. Treat them as hard requirements.
 - **Docstrings & intent comments:** Ensure every class/function/method has robust docstrings; add intent-level comments for loops, branches, and multi-step blocks per the intent-first policy. Avoid low-value narration.
-- **Safety & structure:** Keep modules cohesive, under 500 lines, with strong typing and separation of concerns. Prefer helper extraction over dense inline logic when comments would become bulky.
+- **Safety & structure:** Keep modules cohesive, within the tiered file-size policy of `general-code-change.instructions.md`, with strong typing and separation of concerns. Prefer helper extraction over dense inline logic when comments would become bulky.
 - **Autonomy:** Never ask for clarification once scope is given. Do not defer or ask for approval. If work requires multiple turns, continue automatically.
 
 ## Workflow

package/resources/customizations/.github/agents/python-execution-only-typed.agent.md

@@ -81,7 +81,7 @@ If the environment prevents running tools, STOP implementation and provide a pla
    - Coverage baseline for touched files (and overall if enforced)
 3) Summarize root cause / design constraint in one paragraph.
 
-Before exiting Phase A, perform a quick line-count check on all in-scope files. If any file is near the 500-line limit or planned additions would push it over 500, decide upfront to split now (counting new files against the budget) or seek an override before Phase B. If uncertain, treat it as at-risk and plan for a split rather than discovering it mid-execution. If an approved plan would create a 500-line violation, halt and seek clarification before proceeding.
+Before exiting Phase A, perform a quick line-count check on all in-scope files and apply the tiered file-size policy: at 500 lines, look for a logical split; at 700 lines, split more aggressively; if any file is above 800 lines or planned additions would push it above 800, decide upfront to split it now (a hard stop, regardless of logical separability, counting new files against the budget) before Phase B. If uncertain, treat it as at-risk and plan for a split rather than discovering it mid-execution. If an approved plan would leave a file above 800 lines, halt and seek clarification before proceeding.
 
 Do not proceed to edits until the user explicitly approves (e.g., “Proceed.”).
 However, if a plan is provided in the initial prompt, it is already implicitly approved.

package/resources/customizations/.github/agents/python-typed-engineer.agent.md

@@ -134,7 +134,7 @@ If no plan is provided, delegate the creation of a plan to the `atomic_planner`.
 - Mocking plan (what is mocked, where patched, and why)
 - Exact files to change (must match scope guardrails)
 
-Before exiting Phase B, perform a quick line-count check on all in-scope files. If any file is near the 500-line limit or planned additions would push it over 500, decide upfront to split now (counting new files against the budget) before Phase C. If uncertain, treat it as at-risk and plan for a split rather than discovering it mid-execution. If an approved plan would create a 500-line violation, halt and seek clarification before proceeding.
+Before exiting Phase B, perform a quick line-count check on all in-scope files and apply the tiered file-size policy: at 500 lines, look for a logical split; at 700 lines, split more aggressively; if any file is above 800 lines or planned additions would push it above 800, decide upfront to split it now (a hard stop, regardless of logical separability, counting new files against the budget) before Phase C. If uncertain, treat it as at-risk and plan for a split rather than discovering it mid-execution. If an approved plan would leave a file above 800 lines, halt and seek clarification before proceeding.
 
 Do not proceed to edits until the user explicitly approves (e.g., “Proceed.”).
 However, if a plan is provided in the initial prompt, it is already implicitly approved.

package/resources/customizations/.github/instructions/general-code-change.instructions.md

@@ -143,8 +143,11 @@ Rules for functions:
 
    - A module/file should have a clear purpose (e.g. “QIF parsing,” “Lexile model,” “corpus download”).
    - Avoid dumping unrelated classes/functions into the same file.
-   - Do not exceed 500 lines for any one file.
-   - This 500-line limit applies to production code, test code, and reusable scripts.
+   - File size follows a tiered policy that applies to production code, test code, and reusable scripts:
+     - **500 lines (guidance):** look for logical ways to divide the file into multiple files, provided the parts can be separated logically. No gate fails at this tier.
+     - **700 lines (advisory):** look for a split more aggressively. Reviewers and `feature-review` report a non-blocking Warning for a file at or above 700 lines. No gate fails at this tier.
+     - **Above 800 lines (hard block):** a split is enforced regardless of logical separability. A file of 801 lines or more is blocked by the repository CI check and by the PreToolUse hook; a file of exactly 800 lines passes. Legacy files already above 800 lines are recorded in `config/file-size-baseline.json` and may shrink (with the entry tightened) or stay the same size, but may not grow.
+     - Lines are logical lines: the content split on line terminators, where a trailing terminator does not add a line.
    - Exceptions: temporary throwaway scripts created and deleted during an agent session; raw text fixtures used for language-processing test data; Markdown documentation files.
 
 2. Public vs internal

package/resources/customizations/.github/instructions/powershell-code-change.instructions.md

@@ -58,7 +58,7 @@ If you encounter any conflicting instructions, **halt and notify the user.**
 
 ## 3. Structure, Naming, and Comments
 
-- Keep scripts **cohesive and under 500 lines** (matches general policy).
+- Keep scripts **cohesive** and within the tiered file-size policy of `general-code-change.instructions.md` (section 4, Module & File Structure).
 - Use approved verbs and descriptive nouns for functions (PSScriptAnalyzer will enforce).
 - Prefer modules/helpers over copy-paste between scripts; share common logic in dedicated helper functions.
 - Comment **why** for non-obvious patterns (e.g., rule suppressions, compatibility shims), not what.

package/resources/customizations/.github/prompts/remediate-comments.prompt.md

@@ -25,7 +25,7 @@ Apply in this sequence:
 ## Execution Rules
 
 - Remediate the entire scope to add/adjust robust docstrings and intent comments for loops, branches, and multi-step blocks; avoid low-value narration.
-- Keep modules cohesive, under 500 lines, strongly typed; avoid `Any` unless justified.
+- Keep modules cohesive, within the tiered file-size policy of `general-code-change.instructions.md`, strongly typed; avoid `Any` unless justified.
 - Maintain encoding/EOL and ASCII unless the file already uses Unicode.
 - Do not pause for approval or clarification once scope is set; continue across turns if needed until fully compliant.
 

package/resources/customizations/.github/skills/execution-environment/SKILL.md

@@ -83,6 +83,7 @@ Run these after editing any mirrored or bundled file; each is under `tests/scrip
 
 - `test_push_down_claude_resource_contracts.py` and `test_push_down_codex_and_agents_resource_contracts.py`: every distributable `.claude`, `.agents`, and `.codex` file exists in the bundle with equal text.
 - `test_push_down_claude_pack_manifest_completeness.py` and `test_push_down_codex_and_agents_pack_manifest_completeness.py`: every bundled file is listed in a pack manifest.
+- `test_push_down_pack_manifest_dependency_closure.py`: every `$PSScriptRoot` dependency of a manifested PowerShell file, and every hook script named by `.claude/settings.json`, manifested agent frontmatter, or `.codex/config.toml`, is in core plus the owning pack.
 - The Codex generator check: `scripts/dev_tools/generate_codex_agent_variants.py` run in module form with `--check` (base agents are hand-edited; variants, bundle copies, and the Codex `core.json` are generated).
 - `test_codex_agent_wrapper_contracts.py` and `test_codex_handoff_contract_parity.py`: pinned Codex agent fragments and handoff parity.
 - `test_claude_rules_frontmatter.py`: rule `paths:` scopes and that every preloaded skill exists.
@@ -121,7 +122,7 @@ These pass every validator rule and are found only by reading the plan against t
 - Python: measure a module with `--cov=<dotted.module>`, `--cov-branch`, `--cov-report=term-missing`, and `--cov-report=json:<path>`; read branch figures from the JSON report.
 - TypeScript: a new production file needs its own entry in the `coverageThreshold` map of `extensions/drm-copilot/jest.config.cjs`; Jest runs through `node run-jest.cjs` in `extensions/drm-copilot/`.
 - PowerShell: per-file line coverage is read from `artifacts/pester/powershell-coverage.xml` written by the self-hosted PoshQC module.
-- No production, test, or reusable script file exceeds 500 physical lines; Markdown is exempt. Files at or near the limit are not extended; new logic goes into a new module and a new test file.
+- File size follows three tiers for production, test, and reusable script files, counted in logical lines (a trailing terminator adds no line): at 500 lines look for a logical split (guidance); at 700 lines split more aggressively, and reviewers report a non-blocking Warning (advisory); above 800 lines a split is enforced regardless of logical separability (hard limit; exactly 800 passes). The hard limit is enforced by `tests/scripts/ci/FileSizePolicy.RepoGate.Tests.ps1` in the existing PowerShell shards against `config/file-size-baseline.json`, where legacy files above 800 may shrink (with the entry tightened) or stay equal but may not grow, and by the PreToolUse hook `.claude/hooks/enforce-file-size-limit.ps1` (`.codex/hooks/enforce-file-size-limit.ps1`). New logic in a file near a tier goes into a new module and a new test file. Markdown is exempt.
 
 ## Test Isolation Checks
 

package/resources/customizations/.github/skills/feature-review-workflow/SKILL.md

@@ -154,6 +154,14 @@ Always apply:
 - `feature-audit.<timestamp>.md`
   - contains the five required major sections listed above
 
+## File Size Advisory
+
+The tiered file-size policy (section 4, Module & File Structure, in `.github/instructions/general-code-change.instructions.md`) sets a 500-line guidance tier, a 700-line advisory tier, and an 800-line hard limit. Measure the logical line count of every added or modified covered file in the branch diff. Covered files have one of the extensions `.py`, `.ps1`, `.psm1`, `.ts`, `.tsx`, `.js`, `.cjs`, `.mjs`, `.cs`, `.sh`, or `.bats` and are not under a build, cache, dependency, virtual-environment, or `docs` directory. A logical line count splits the content on line terminators, and a trailing terminator does not add a line; it equals `@(Get-Content -LiteralPath <path>).Count`. Do not use `wc -l` or `Measure-Object -Line`.
+
+- Report each covered file at or above 700 lines as a non-blocking `Warning` row in the Findings Table of `code-review.<timestamp>.md`, naming the file and its line count. Do not write the Warning to `remediation-inputs.<timestamp>.md`, and do not give it a remediation severity label.
+- Report a covered file above 800 lines that has no entry in `config/file-size-baseline.json`, and any added or increased entry in `config/file-size-baseline.json`, as a blocking policy finding.
+- Produce no finding for the 500-line guidance tier.
+
 ## Constraints
 
 - Prefer check-only commands.

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

@@ -9,7 +9,7 @@
 > 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`.
+> 5. Use severity labels consistently: `Blocker`, `Major`, `Minor`, `Nit`, `Info`, `Warning`. `Warning` is the non-blocking file-size advisory for a covered file at or above 700 logical lines; it names the file and its line count and is never carried into remediation inputs.
 > 6. End with a clear readiness recommendation that matches the actual findings.
 >
 > **When to use:**
@@ -52,8 +52,8 @@
 
 | 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] |
+| [Blocker/Major/Minor/Nit/Info/Warning] | `[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/Warning] | `[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.`]
 
@@ -162,4 +162,4 @@
 
 ## 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.]
+[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.]

package/resources/templates/policy_audit/policy-audit.yyyy-MM-ddTHH-mm.md

@@ -159,7 +159,7 @@ Repeat one bullet per in-scope language that has coverage requirements. Keep the
 | Requirement | Status | Evidence |
 |------------|--------|----------|
 | **Cohesive modules** | [✅/❌/N/A] [PASS/FAIL/N/A] | [Describe the purpose and cohesion of each module/file. Note organization strategy.] |
-| **Under 500 lines** | [✅/❌/N/A] [PASS/FAIL/N/A] | [Report line counts for all files. Note any exceptions and justifications.] |
+| **At or below the 800-line hard limit** | [✅/❌/N/A] [PASS/FAIL/N/A] | [Report logical line counts for all covered files. FAIL for a file above 800 lines without a `config/file-size-baseline.json` entry, a baselined file that grew, or an added or increased baseline entry. Note each file at or above 700 lines as a non-blocking Warning. Note any exceptions.] |
 | **Public vs internal** | [✅/❌/N/A] [PASS/FAIL/N/A] | [Describe the public API surface. Note how internals are hidden.] |
 | **No circular dependencies** | [✅/❌/N/A] [PASS/FAIL/N/A] | [Describe the dependency graph. Confirm no circular dependencies exist.] |
 
@@ -253,7 +253,7 @@ Repeat one bullet per in-scope language that has coverage requirements. Keep the
 
 | Requirement | Status | Evidence |
 |------------|--------|----------|
-| **Cohesive and under 500 lines** | [✅/❌/N/A] [PASS/FAIL/N/A] | [Report file line counts. Confirm all under limit.] |
+| **Cohesive and at or below the 800-line hard limit** | [✅/❌/N/A] [PASS/FAIL/N/A] | [Report logical line counts. FAIL for a file above 800 lines without a baseline entry or a baselined file that grew. Note each file at or above 700 lines as a non-blocking Warning.] |
 | **Approved verbs** | [✅/❌/N/A] [PASS/FAIL/N/A] | [List all function names and confirm verbs are approved.] |
 | **Comment why** | [✅/❌/N/A] [PASS/FAIL/N/A] | [Describe commenting approach. Confirm focus on rationale.] |
 
@@ -285,7 +285,7 @@ Repeat one bullet per in-scope language that has coverage requirements. Keep the
 |------------|--------|----------|
 | **Portable shebang** | [✅/❌/N/A] [PASS/FAIL/N/A] | [Confirm `#!/usr/bin/env bash` or `#!/bin/bash` used.] |
 | **Error handling** | [✅/❌/N/A] [PASS/FAIL/N/A] | [Describe use of `set -e`, `set -u`, `set -o pipefail`, error traps.] |
-| **Under 500 lines** | [✅/❌/N/A] [PASS/FAIL/N/A] | [Report file line counts.] |
+| **At or below the 800-line hard limit** | [✅/❌/N/A] [PASS/FAIL/N/A] | [Report logical line counts. FAIL for a file above 800 lines without a baseline entry or a baselined file that grew. Note each file at or above 700 lines as a non-blocking Warning.] |
 
 ---
 
@@ -424,7 +424,7 @@ Repeat one bullet per in-scope language that has coverage requirements. Keep the
 | Average Time per Test | [X]ms | [✅/❌] Fast/Slow |
 | Discovery Time | [X]ms | [✅/❌] |
 | Functions/Classes Tested | [N]/[M] ([X]%) | [✅/❌] |
-| Test File Size | [N] lines | [✅/❌] Maintainable |
+| Test File Size | [N] logical lines | [✅/❌] PASS at or below 800 lines, FAIL above 800 without a baseline entry; note a non-blocking Warning at or above 700 lines |
 | Code Coverage (if applicable) | [X]% lines, [Y]% branches | [✅/❌] |
 
 ---