@danmoisan/drm-copilot-mcp 1.1.21 → 1.1.23

package/resources/claude-customizations/.claude/lib/cleanup-manifest/CleanupWorktreeManifest.psm1

@@ -24,8 +24,8 @@
     throwing.
 
 .NOTES
-    Compatible with PowerShell 7+. No external module dependencies, no subprocess,
-    and no network. The single filesystem read and the single wall-clock read each
+    Compatible with PowerShell 7+. Imports only the in-repository sibling
+    WorktreeRunRecordPath.psm1 (issue #995); no subprocess and no network. The single filesystem read and the single wall-clock read each
     sit behind an injectable seam so tests drive them without writing a temporary
     file. Mirrored byte-identically under
     extensions/drm-copilot/resources/claude-customizations/.
@@ -35,6 +35,9 @@
 Set-StrictMode -Version Latest
 $ErrorActionPreference = 'Stop'
 
+# The shared recorded-path matcher (issue #995), used by the checkpoint-coverage test.
+Import-Module (Join-Path $PSScriptRoot '../worktree-resolution/WorktreeRunRecordPath.psm1') -ErrorAction Stop
+
 # Repo-relative location of the sanctioned-removal manifest. Kept as a script-scope
 # constant so the read seam is the only function that names the path.
 $script:CleanupWorktreeManifestPath = 'artifacts/orchestration/cleanup-worktrees-manifest.json'
@@ -355,6 +358,14 @@ function Test-CleanupManifestCheckpointCoversPath {
         the gate's existing deny. Reusing the gates' merge_status predicate here
         would reopen the one path by which the manifest could widen what the gates
         protect.
+
+        Case rule: a record covers the target when the shared matcher holds on the
+        inputs as given, or holds on the same inputs lower-cased with the invariant
+        culture. This keeps the exclusion at parity with
+        Find-CleanupWorktreeManifestRemovalRecord, which ignores case for every path,
+        so a record that differs from the target only by case still blocks the
+        manifest branch. The shared matcher itself stays ordinal for single-slash
+        POSIX paths because the gates' allow lookups must remain fail-closed.
     .PARAMETER Checkpoint
         Parsed checkpoint object, or $null when absent or unreadable.
     .PARAMETER RecordArrayName
@@ -362,6 +373,10 @@ function Test-CleanupManifestCheckpointCoversPath {
         for the parallel checkpoint.
     .PARAMETER WorktreePath
         The removal target extracted from the command text.
+    .PARAMETER BaseRoot
+        Optional. The roots a relative recorded worktree_path is joined to: the main
+        checkout root and the root that holds the checkpoint (issue #995). With none, a
+        relative record covers nothing and a rooted record compares as before.
     .OUTPUTS
         System.Boolean
     #>
@@ -377,7 +392,11 @@ function Test-CleanupManifestCheckpointCoversPath {
 
         [AllowNull()]
         [AllowEmptyString()]
-        [string] $WorktreePath
+        [string] $WorktreePath,
+
+        [AllowNull()]
+        [AllowEmptyCollection()]
+        [string[]] $BaseRoot = @()
     )
 
     if ($null -eq $Checkpoint -or [string]::IsNullOrWhiteSpace($WorktreePath)) {
@@ -388,8 +407,10 @@ function Test-CleanupManifestCheckpointCoversPath {
         return $false
     }
 
-    $normalizedTarget = ConvertTo-CleanupWorktreeManifestNormalizedPath -Path $WorktreePath
+    $lowerBaseRoot = [string[]] @(@($BaseRoot) | Where-Object { -not [string]::IsNullOrWhiteSpace($_) } | ForEach-Object { $_.ToLowerInvariant() })
 
+    # Every record is compared through the shared matcher, so a relative record covers
+    # the absolute target it names under a base root, and an unsafe one covers nothing.
     foreach ($record in @($Checkpoint.PSObject.Properties[$RecordArrayName].Value)) {
         if ($null -eq $record) {
             continue
@@ -398,8 +419,14 @@ function Test-CleanupManifestCheckpointCoversPath {
         if ($recordProperties -notcontains 'worktree_path') {
             continue
         }
-        $normalizedRecordPath = ConvertTo-CleanupWorktreeManifestNormalizedPath -Path ([string]$record.worktree_path)
-        if ($normalizedRecordPath -eq $normalizedTarget) {
+        $recordedPath = [string]$record.worktree_path
+        if (Test-WorktreeRunRecordedPathMatchesTarget -RecordedPath $recordedPath -TargetPath $WorktreePath -BaseRoot $BaseRoot) {
+            return $true
+        }
+        # Case-insensitive parity with Find-CleanupWorktreeManifestRemovalRecord: the same
+        # inputs lower-cased with the invariant culture, so the exclusion is never narrower
+        # than the manifest lookup it guards.
+        if (Test-WorktreeRunRecordedPathMatchesTarget -RecordedPath $recordedPath.ToLowerInvariant() -TargetPath $WorktreePath.ToLowerInvariant() -BaseRoot $lowerBaseRoot) {
             return $true
         }
     }

package/resources/claude-customizations/.claude/lib/file-size-policy/FileSizePolicy.psm1

@@ -0,0 +1,434 @@
+<#
+.SYNOPSIS
+    Pure functions of the tiered file-size policy (500 guidance, 700 advisory, 800 hard limit).
+
+.DESCRIPTION
+    Single source of truth for the repository file-size policy (issue #990). The
+    policy has three tiers: at 500 logical lines an author looks for a logical split,
+    at 700 lines an author splits more aggressively and reviewers report a
+    non-blocking Warning, and above 800 lines a split is enforced regardless of
+    logical separability. A file of exactly 800 lines passes.
+
+    Lines are counted as logical lines: the content is split on CRLF or LF, and a
+    trailing line terminator does not add a line. CRLF and LF content of the same
+    text therefore count identically, and the count equals the number of strings
+    Get-Content returns for the same file.
+
+    Covered files are identified by an extension allowlist; every other file
+    (Markdown, JSON, YAML, TOML, text fixtures) is outside the policy. Paths under
+    fixed build, cache, dependency, documentation, and virtual-environment
+    directory names, and paths under .claude/worktrees/, are not covered. The excluded
+    directory names are defined once, in Get-FileSizeExcludedSegment.
+
+    Every function is pure: no filesystem, process, network, environment, or clock
+    access. Callers supply the content, the paths, and the recorded sizes. The
+    policy constants live inside the functions rather than at module scope, so the
+    function definitions are self-contained and can be mirrored text-identically
+    into the dot-sourced Codex twin .codex/hooks/file-size-policy.ps1.
+    CONVENTION: this module fails fast at module scope and imports its siblings with -ErrorAction Stop.
+#>
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Stop'
+
+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 }
+}
+
+Export-ModuleMember -Function Get-FileSizePolicyLimit, Get-FileSizeLogicalLineCount, Get-FileSizeTier,
+Get-FileSizeExcludedSegment, ConvertTo-FileSizeRelativePath, Test-FileSizeCoveredPath, Compare-FileSizeBaselineEntry,
+Resolve-FileSizeEditContent, Get-FileSizeHookDecision

package/resources/claude-customizations/.claude/lib/orchestrator-state/OrchestratorStateFeatureFolderRecord.psm1

@@ -0,0 +1,166 @@
+<#
+.SYNOPSIS
+    Feature-folder adoption record validation (issue #992).
+
+.DESCRIPTION
+    Destination-runtime PowerShell port of `feature_folder_record_errors` in
+    `scripts/dev_tools/_orchestrator_state_feature_folder_record.py`. The optional
+    `issue_adoption.feature_folder_record` object declares that an adopted feature
+    folder already existed and was committed before the finishing run started. A
+    valid record lets the adoption waive the `new_active_feature_folder` receipt.
+
+    Invariants:
+      - Rule 10: waiving `new_active_feature_folder` requires an object record.
+      - Rules 11a to 11e run whenever the record is an object, waived or not;
+        rule 11b runs only when `path` passed rule 11a.
+      - Every string comparison is ordinal and case-sensitive; the path pattern is
+        applied with -cmatch and the \A...\z anchors.
+      - The record is a declaration. The Claude SubagentStop hook performs the git
+        probe separately.
+
+    Every function is pure: it reads no file, starts no process, and never mutates
+    its input.
+    CONVENTION: this module fails fast at module scope and imports its siblings with -ErrorAction Stop.
+#>
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Stop'
+
+# Import the shared checkpoint-value primitives, resolved relative to this
+# module's directory so the import travels with the pushed-down pack.
+Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'OrchestratorStateCheckpointValue.psm1') -Force -ErrorAction Stop
+
+$script:FEATURE_FOLDER_TOOL = 'new_active_feature_folder'
+$script:FEATURE_FOLDER_RECORD_KEY = 'feature_folder_record'
+$script:FEATURE_FOLDER_PATH_PATTERN = '\Adocs/features/active/[A-Za-z0-9][A-Za-z0-9._-]*(/[A-Za-z0-9][A-Za-z0-9._-]*)*\z'
+$script:FEATURE_FOLDER_VERIFIED_VIA = [string[]]@('git_cat_file_head', 'git_ls_tree_head')
+
+$script:ERROR_RECORD_NOT_OBJECT = 'Checkpoint issue_adoption.feature_folder_record must be an object when waiving new_active_feature_folder.'
+$script:ERROR_PATH_FORMAT = 'Checkpoint issue_adoption.feature_folder_record.path must be a folder path under docs/features/active/ without dot segments or a trailing slash.'
+$script:ERROR_PATH_EQUAL = 'Checkpoint issue_adoption.feature_folder_record.path must equal the checkpoint feature-folder.'
+$script:ERROR_VERIFIED_VIA = 'Checkpoint issue_adoption.feature_folder_record.verified_via must be one of git_cat_file_head, git_ls_tree_head.'
+$script:ERROR_VERIFIED_AT = 'Checkpoint issue_adoption.feature_folder_record.verified_at must be present.'
+$script:ERROR_EVIDENCE = 'Checkpoint issue_adoption.feature_folder_record.evidence must be a non-empty string.'
+
+
+function Test-OrchestratorStateFeatureFolderPath {
+    <#
+    .SYNOPSIS
+        Report whether a value is a valid adopted feature-folder path.
+    .DESCRIPTION
+        True only for a string that fully matches the shared path pattern: a folder
+        under docs/features/active/ whose every segment starts with a letter or
+        digit, so dot segments, empty segments, a trailing slash, backslashes,
+        drive letters, glob characters, and a leading hyphen are rejected.
+    .PARAMETER Value
+        The deserialized JSON value to inspect. May be $null.
+    .OUTPUTS
+        System.Boolean
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [AllowEmptyString()]
+        [object] $Value
+    )
+
+    return (($Value -is [string]) -and ([string]$Value -cmatch $script:FEATURE_FOLDER_PATH_PATTERN))
+}
+
+function Get-FeatureFolderRecordFieldError {
+    <#
+    .SYNOPSIS
+        Validate the fields of an object-shaped record (rules 11a to 11e).
+    .PARAMETER Record
+        The feature_folder_record object.
+    .PARAMETER State
+        The parsed checkpoint, read for its feature-folder member.
+    .OUTPUTS
+        System.String[] - zero or more error strings in rule order.
+    #>
+    [CmdletBinding()]
+    [OutputType([string[]])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [psobject] $Record,
+
+        [Parameter(Mandatory = $true)]
+        [psobject] $State
+    )
+
+    $errors = [System.Collections.Generic.List[string]]::new()
+    $path = (Get-CheckpointObjectMember -Owner $Record -Name 'path').Value
+    # Rule 11b compares a well-formed path only; a malformed path is reported once by rule 11a.
+    if (-not (Test-OrchestratorStateFeatureFolderPath -Value $path)) {
+        $errors.Add($script:ERROR_PATH_FORMAT)
+    }
+    else {
+        $checkpointFolder = (Get-CheckpointObjectMember -Owner $State -Name 'feature-folder').Value
+        if (-not (($checkpointFolder -is [string]) -and [string]::Equals([string]$checkpointFolder, [string]$path, [System.StringComparison]::Ordinal))) {
+            $errors.Add($script:ERROR_PATH_EQUAL)
+        }
+    }
+
+    $verifiedVia = (Get-CheckpointObjectMember -Owner $Record -Name 'verified_via').Value
+    if (-not (($verifiedVia -is [string]) -and ($script:FEATURE_FOLDER_VERIFIED_VIA -ccontains [string]$verifiedVia))) {
+        $errors.Add($script:ERROR_VERIFIED_VIA)
+    }
+
+    # Presence-only, matching the adoption-level verified_at rule; a System.DateTime
+    # produced by ConvertFrom-Json passes.
+    $verifiedAt = (Get-CheckpointObjectMember -Owner $Record -Name 'verified_at').Value
+    if (($null -ceq $verifiedAt) -or (($verifiedAt -is [string]) -and [string]::IsNullOrWhiteSpace([string]$verifiedAt))) {
+        $errors.Add($script:ERROR_VERIFIED_AT)
+    }
+
+    $evidence = (Get-CheckpointObjectMember -Owner $Record -Name 'evidence').Value
+    if (-not (($evidence -is [string]) -and -not [string]::IsNullOrWhiteSpace([string]$evidence))) {
+        $errors.Add($script:ERROR_EVIDENCE)
+    }
+    return $errors.ToArray()
+}
+
+function Get-OrchestratorStateFeatureFolderRecordError {
+    <#
+    .SYNOPSIS
+        Validate issue_adoption.feature_folder_record (rules 10 and 11a-11e).
+    .DESCRIPTION
+        An object record is always validated (rules 11a to 11e). A missing or
+        non-object record yields the rule-10 error only when waived_tools contains
+        new_active_feature_folder; otherwise nothing is reported.
+    .PARAMETER Adoption
+        The issue_adoption object.
+    .PARAMETER State
+        The parsed checkpoint, read for its feature-folder member.
+    .PARAMETER WaivedTool
+        The well-formed waived_tools list, in checkpoint order.
+    .OUTPUTS
+        System.String[] - zero or more error strings in rule order.
+    #>
+    [CmdletBinding()]
+    [OutputType([string[]])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [psobject] $Adoption,
+
+        [Parameter(Mandatory = $true)]
+        [psobject] $State,
+
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyCollection()]
+        [string[]] $WaivedTool
+    )
+
+    $record = (Get-CheckpointObjectMember -Owner $Adoption -Name $script:FEATURE_FOLDER_RECORD_KEY).Value
+    if (Test-CheckpointObjectValue -Value $record) {
+        return [string[]]@(Get-FeatureFolderRecordFieldError -Record $record -State $State)
+    }
+    if ($WaivedTool -ccontains $script:FEATURE_FOLDER_TOOL) {
+        return [string[]]@($script:ERROR_RECORD_NOT_OBJECT)
+    }
+    return [string[]]@()
+}
+
+Export-ModuleMember -Function Test-OrchestratorStateFeatureFolderPath, Get-OrchestratorStateFeatureFolderRecordError