Skip to content

foryourhealth111-pixel/Vibe-Skills

Vibe Code Orchestrator (VCO) is a governed runtime entry that freezes requirements, bounds execution, and enforces verification and phase cleanup.

FileKindSize
SKILL.mdskill md17.2 KB
agents/templates/debugger.mdmarkdown323 B
agents/templates/planner.mdmarkdown313 B
agents/templates/reviewer.mdmarkdown331 B
agents/templates/security-reviewer.mdmarkdown341 B
references/change-proof-matrix.mdmarkdown2.6 KB
references/contributor-zone-decision-table.mdmarkdown2.2 KB
references/developer-entry-contract.mdmarkdown2.7 KB
references/fixtures/external-corpus/external-corpus-gate.jsonconfig8.6 KB
references/fixtures/external-corpus/prompt-signals.jsonconfig412.4 KB
references/fixtures/external-corpus/skill-keyword-index.backup.jsonconfig30.6 KB
references/fixtures/external-corpus/skill-keyword-index.candidate.jsonconfig26.5 KB
references/fixtures/external-corpus/vco-suggestions.jsonconfig16.6 KB
references/fixtures/migration-map.jsonconfig7.8 KB
references/fixtures/retro-compare/safety-gate/baseline-cer.jsonconfig294 B
references/fixtures/retro-compare/safety-gate/current-cer.jsonconfig1.1 KB
references/fixtures/retro-compare/safety-gate/delta.jsonconfig1.0 KB
references/fixtures/retro-compare/sample-run/baseline-cer.jsonconfig324 B
references/fixtures/retro-compare/sample-run/current-cer.jsonconfig1.2 KB
references/fixtures/retro-compare/sample-run/delta.jsonconfig1.0 KB
references/fixtures/retro-compare/smoke/baseline-smoke.jsonconfig266 B
references/fixtures/retro-compare/smoke/current-smoke.jsonconfig1.0 KB
references/fixtures/retro-compare/smoke/delta-smoke.jsonconfig1.0 KB
references/fixtures/runtime/vibe-sessions/20260413T131910Z-pr153-rabbit-review-fix/cleanup-receipt.jsonconfig1.3 KB
references/fixtures/runtime/vibe-sessions/20260413T131910Z-pr153-rabbit-review-fix/governance-capsule.jsonconfig408 B
references/fixtures/runtime/vibe-sessions/20260413T131910Z-pr153-rabbit-review-fix/intent-contract.jsonconfig2.2 KB
references/fixtures/runtime/vibe-sessions/20260413T131910Z-pr153-rabbit-review-fix/phase-plan-execute.jsonconfig2.4 KB
references/fixtures/runtime/vibe-sessions/20260413T131910Z-pr153-rabbit-review-fix/skeleton-receipt.jsonconfig722 B
references/fixtures/runtime/vibe-sessions/20260413T131910Z-pr153-rabbit-review-fix/stage-lineage.jsonconfig1.3 KB
references/fixtures/skills-audit/bio-science-problem/bio-science-problem-map.csvother9.2 KB
references/fixtures/skills-audit/bio-science-problem/bio-science-problem-map.jsonconfig18.1 KB
references/fixtures/verify/routing-stability/vibe-routing-stability-gate.jsonconfig24.4 KB
references/index.mdmarkdown1.3 KB
references/proof-bundles/claude-code-managed-closure-candidate/linux-managed-run-01-local-host/installed-runtime-outputs/runtime-freshness-receipt.jsonconfig262 B
references/proof-bundles/claude-code-managed-closure-candidate/manifest.jsonconfig2.6 KB
references/proof-bundles/linux-full-authoritative-candidate/linux-pwsh-run-01-wsl/installed-runtime-outputs/runtime-freshness-receipt.jsonconfig298 B
references/proof-bundles/linux-full-authoritative-candidate/linux-pwsh-run-02-docker/installed-runtime-outputs/runtime-freshness-receipt.jsonconfig298 B
references/proof-bundles/linux-full-authoritative-candidate/manifest.jsonconfig3.3 KB
references/proof-bundles/openclaw-runtime-core-preview-candidate/manifest.jsonconfig1.9 KB
references/release-ledger.jsonlother5.1 KB
scripts/README.mdmarkdown1.7 KB
scripts/bootstrap/one-shot-setup.ps1script797 B
scripts/bootstrap/one-shot-setup.shscript482 B
scripts/bootstrap/scaffold-claude-preview.ps1script875 B
scripts/bootstrap/scaffold-claude-preview.shexecutablescript866 B
scripts/bootstrap/sync-local-compat.ps1script2.6 KB
scripts/common/AntiProxyGoalDrift.ps1script15.1 KB
scripts/common/NodeLaunchWrapper.ps1script13.1 KB
scripts/common/ProcessLedger.ps1script27.1 KB
scripts/common/ProtectedDocumentCleanup.ps1script6.9 KB
scripts/common/README.mdmarkdown1.9 KB
scripts/common/Resolve-VgoAdapter.ps1script4.3 KB
scripts/common/adapter_registry_query.pyexecutablescript3.8 KB
scripts/common/python_helpers.shscript2.8 KB
scripts/common/resolve_vgo_adapter.pyexecutablescript2.4 KB
scripts/common/runtime_contracts.pyscript3.7 KB
scripts/common/vibe-governance-helpers.ps1script75.6 KB
scripts/common/vibe-wave-gate-runner.ps1script28.3 KB
scripts/governance/Invoke-NodeProcessAudit.ps1script3.6 KB
scripts/governance/Invoke-NodeZombieCleanup.ps1script3.7 KB
scripts/governance/README.mdmarkdown5.1 KB
scripts/governance/audit-upstream.ps1script22.7 KB
scripts/governance/export-repo-cleanliness-inventory.ps1script8.6 KB
scripts/governance/install-local-worktree-excludes.ps1script2.0 KB
scripts/governance/invoke-mem0-policy.ps1script1.0 KB
scripts/governance/invoke-openspec-governance.ps1script8.6 KB
scripts/governance/new-origin-record.ps1script3.3 KB
scripts/governance/phase-end-cleanup.ps1script10.7 KB
scripts/governance/publish-absorption-soft-rollout.ps1script3.2 KB
scripts/governance/publish-openspec-soft-rollout.ps1script9.3 KB
scripts/governance/release-cut.ps1script25.1 KB
scripts/governance/set-gsd-overlay-rollout.ps1script3.9 KB
scripts/governance/set-openspec-rollout.ps1script3.1 KB
scripts/governance/sync-bundled-vibe.ps1script20.3 KB
scripts/install/Install-VgoAdapter.ps1script2.0 KB
scripts/install/install_vgo_adapter.pyexecutablescript524 B
scripts/overlay/README.mdmarkdown885 B
scripts/overlay/suggest-browserops-provider.ps1script9.3 KB
scripts/overlay/suggest-overlays.ps1script17.3 KB
scripts/release/build_release_bundle.pyscript6.5 KB
scripts/research/README.mdmarkdown1.1 KB
scripts/research/build-eval-slicing-catalog.ps1script2.6 KB
scripts/research/build-watch-portfolio-review.ps1script3.5 KB
scripts/research/build-xl-operator-checklist.ps1script2.3 KB
scripts/research/extract-prompt-signals.ps1script6.7 KB
scripts/research/generate-vco-suggestions.ps1script9.7 KB
scripts/research/sync-mcp-catalog.ps1script3.5 KB
scripts/research/vibe-adaptive-train.ps1script10.1 KB
scripts/router/README.mdmarkdown1.8 KB
scripts/router/invoke-pack-route.pyscript428 B
scripts/router/modules/00-core-utils.ps1script14.6 KB
scripts/router/modules/01-openai-responses.ps1script17.9 KB
scripts/router/modules/10-observability.ps1script11.7 KB
scripts/router/modules/11-route-probe.ps1script20.7 KB
scripts/router/modules/12-heartbeat.ps1script19.9 KB
scripts/router/modules/19-custom-admission.ps1script16.3 KB
scripts/router/modules/20-routing-rules.ps1script1.7 KB
scripts/router/modules/21-capability-interview.ps1script11.8 KB
scripts/router/modules/22-intent-contract.ps1script18.2 KB
scripts/router/modules/30-openspec.ps1script8.3 KB
scripts/router/modules/31-gsd-overlay.ps1script5.5 KB
scripts/router/modules/32-prompt-overlay.ps1script8.0 KB
scripts/router/modules/33-memory-governance.ps1script5.5 KB
scripts/router/modules/34-data-scale-overlay.ps1script25.8 KB
scripts/router/modules/35-quality-debt-overlay.ps1script13.4 KB
scripts/router/modules/36-framework-interop-overlay.ps1script16.9 KB
scripts/router/modules/37-ml-lifecycle-overlay.ps1script22.4 KB
scripts/router/modules/38-python-clean-code-overlay.ps1script16.2 KB
scripts/router/modules/39-system-design-overlay.ps1script15.5 KB
scripts/router/modules/40-cuda-kernel-overlay.ps1script17.7 KB
scripts/router/modules/42-ai-rerank-overlay.ps1script14.0 KB
scripts/router/modules/43-retrieval-overlay.ps1script22.4 KB
scripts/router/modules/44-dialectic-team-gate.ps1script7.5 KB
scripts/router/modules/44-exploration-overlay.ps1script17.7 KB
scripts/router/modules/45-daily-dialectic-guard.ps1script6.6 KB
scripts/router/modules/47-closure-overlay.ps1script9.2 KB
scripts/router/modules/48-llm-acceleration-overlay.ps1script104.6 KB
scripts/router/modules/49-prompt-asset-boost.ps1script28.3 KB
scripts/router/resolve-pack-route.ps1script4.1 KB
scripts/router/runtime_neutral/custom_admission.pyscript349 B
scripts/router/runtime_neutral/router_contract.pyscript356 B
scripts/ruc-nlpir/preflight.ps1script5.3 KB
scripts/runtime/Freeze-RuntimeInputPacket.ps1script33.0 KB
scripts/runtime/Invoke-AntiProxyGoalDriftCompaction.ps1script551 B
scripts/runtime/Invoke-DeepInterview.ps1script1.1 KB
scripts/runtime/Invoke-PhaseCleanup.ps1script11.1 KB
scripts/runtime/Invoke-PlanExecute.ps1script13.7 KB
scripts/runtime/Invoke-SkeletonCheck.ps1script3.1 KB
scripts/runtime/Invoke-VibeCanonicalEntry.ps1script12.9 KB
scripts/runtime/VibeMemoryActivation.Common.ps1script41.3 KB
scripts/runtime/VibeMemoryBackends.Common.ps1script12.4 KB
scripts/runtime/VibeRuntime.Common.ps1script298.6 KB
scripts/runtime/VibeSkillRouting.Common.ps1script19.0 KB
scripts/runtime/VibeWorkspaceMemory.Common.ps1script6.9 KB
scripts/runtime/Write-RequirementDoc.ps1script23.7 KB
scripts/runtime/Write-XlPlan.ps1script32.3 KB
scripts/runtime/invoke-vibe-runtime.ps1script69.7 KB
scripts/runtime/memory_backend_driver.pyscript14.2 KB
scripts/runtime/skill_authority_driver.pyscript375 B
scripts/runtime/workspace_memory_driver.pyscript24.8 KB
scripts/setup/check-kvm-host-readiness.shscript3.4 KB
scripts/setup/check-windows-eval-iso-readiness.shexecutablescript2.2 KB
scripts/setup/check-windows-proof-vm-state.shexecutablescript2.0 KB
scripts/setup/export-codex-settings-sanitized.ps1script2.6 KB
scripts/setup/fetch-windows11-eval-iso.shexecutablescript4.1 KB
scripts/setup/install-local-vm-host.shexecutablescript1.6 KB
scripts/setup/persist-codex-openai-env.ps1script2.4 KB
scripts/setup/run-windows-proof-vm.shexecutablescript11.4 KB
scripts/setup/send-qmp-boot-keys.pyexecutablescript3.0 KB
scripts/setup/send-qmp-text.pyexecutablescript3.0 KB
scripts/setup/show-windows-proof-media-options.shexecutablescript1.6 KB
scripts/setup/stop-windows-proof-vm.shexecutablescript1.6 KB
scripts/setup/sync-codex-settings-to-user-env.ps1script2.6 KB
scripts/uninstall/Uninstall-VgoAdapter.ps1script1.4 KB
scripts/uninstall/uninstall_vgo_adapter.pyscript526 B
scripts/verify/README.mdmarkdown3.8 KB
scripts/verify/cer-compare.ps1script8.5 KB
scripts/verify/fixtures/README.mdmarkdown1.1 KB
scripts/verify/fixtures/document-cleanup-safety/README.mdmarkdown527 B
scripts/verify/fixtures/document-cleanup-safety/ambiguous-cn-set/metadata.jsonconfig101 B
scripts/verify/fixtures/document-cleanup-safety/ambiguous-cn-set/source/.tmp/docs/重庆市永川区技术预见与制度创新项目申报书1-修订版.docxbinary56 B
scripts/verify/fixtures/document-cleanup-safety/ambiguous-cn-set/source/.tmp/docs/重庆市永川区技术预见与制度创新项目申报书1-补充材料.pdfbinary56 B
scripts/verify/fixtures/document-cleanup-safety/ambiguous-cn-set/source/docs/重庆市永川区技术预见与制度创新项目申报书1-正式版.docxbinary36 B
scripts/verify/fixtures/document-cleanup-safety/mixed-office-assets/metadata.jsonconfig101 B
scripts/verify/fixtures/document-cleanup-safety/mixed-office-assets/source/.tmp/staging/budget-review.xlsxbinary59 B
scripts/verify/fixtures/document-cleanup-safety/mixed-office-assets/source/.tmp/staging/quarterly-review-deck.pptxbinary60 B
scripts/verify/fixtures/document-cleanup-safety/mixed-office-assets/source/docs/reference-manual.pdfbinary21 B
scripts/verify/fixtures/document-cleanup-safety/non-protected-control/metadata.jsonconfig101 B
scripts/verify/fixtures/document-cleanup-safety/non-protected-control/source/.tmp/control.txtmarkdown54 B
scripts/verify/fixtures/llm-acceleration.mock.jsonconfig1.0 KB
scripts/verify/fixtures/pilot-browserops.jsonconfig541 B
scripts/verify/fixtures/pilot-deep-extraction.jsonconfig731 B
scripts/verify/fixtures/pilot-desktopops.jsonconfig587 B
scripts/verify/fixtures/pilot-memory.jsonconfig575 B
scripts/verify/fixtures/pilot-prompt.jsonconfig525 B
scripts/verify/fixtures/process-health/external-node-protected-fixture.jsonconfig345 B
scripts/verify/fixtures/process-health/healthy-managed-fixture.jsonconfig1.1 KB
scripts/verify/fixtures/process-health/managed-completed-alive-fixture.jsonconfig1.2 KB
scripts/verify/fixtures/process-health/managed-stale-fixture.jsonconfig1.1 KB
scripts/verify/fixtures/process-health/no-node-processes-fixture.jsonconfig131 B
scripts/verify/fixtures/prompt-asset-boost.mock.jsonconfig1.2 KB
scripts/verify/gate-family-index.mdmarkdown2.5 KB
scripts/verify/lib/VibeOfflineSkillsAudit.Suites.ps1script11.8 KB
scripts/verify/lib/VibeOfflineSkillsAudit.ps1script12.2 KB
scripts/verify/lib/VibeRouteAudit.Suites.ps1script7.9 KB
scripts/verify/lib/VibeRouteAudit.ps1script5.2 KB
scripts/verify/live-document-gate.pyscript7.6 KB
scripts/verify/probe-scientific-packs.ps1script55.1 KB
scripts/verify/publish-proof.pyscript409 B
scripts/verify/runtime_neutral/README.mdmarkdown2.5 KB
scripts/verify/runtime_neutral/_bootstrap.pyscript321 B
scripts/verify/runtime_neutral/bio_science_pack_consolidation_audit.pyscript421 B
scripts/verify/runtime_neutral/bootstrap_doctor.pyscript494 B
scripts/verify/runtime_neutral/code_quality_pack_consolidation_audit.pyscript717 B
scripts/verify/runtime_neutral/coherence_gate.pyscript529 B
scripts/verify/runtime_neutral/freshness_gate.pyscript494 B
scripts/verify/runtime_neutral/global_pack_consolidation_audit.pyscript635 B
scripts/verify/runtime_neutral/ml_skills_pruning_audit.pyscript574 B
scripts/verify/runtime_neutral/opencode_preview_smoke.pyscript674 B
scripts/verify/runtime_neutral/release_notes_quality.pyscript701 B

scripts/router/modules/34-data-scale-overlay.ps1

View on GitHub
# Auto-extracted router module. Keep function bodies behavior-identical.

function Get-PathCandidatesFromPrompt {
    param(
        [string]$Prompt,
        [string[]]$SupportedExtensions
    )

    $paths = @()
    if (-not $Prompt -or -not $SupportedExtensions -or $SupportedExtensions.Count -eq 0) {
        return @()
    }

    $escapedExt = @($SupportedExtensions | ForEach-Object { [Regex]::Escape(([string]$_).ToLowerInvariant()) } | Sort-Object -Unique)
    if ($escapedExt.Count -eq 0) {
        return @()
    }

    $extPattern = ($escapedExt | Sort-Object { $_.Length } -Descending) -join "|"
    $regexes = @(
        [Regex]::new('"([^"]+\.(?:' + $extPattern + '))"', [System.Text.RegularExpressions.RegexOptions]::IgnoreCase),
        [Regex]::new("'([^']+\.(?:$extPattern))'", [System.Text.RegularExpressions.RegexOptions]::IgnoreCase),
        [Regex]::new('([^\s"'';,()]+?\.(?:' + $extPattern + '))', [System.Text.RegularExpressions.RegexOptions]::IgnoreCase)
    )

    foreach ($regex in $regexes) {
        $matches = $regex.Matches($Prompt)
        foreach ($m in $matches) {
            if ($m.Groups.Count -lt 2) { continue }
            $candidate = [string]$m.Groups[1].Value
            if (-not $candidate) { continue }
            $normalized = $candidate.Trim().Trim('"', "'").TrimEnd('.', ',', ';', ')', ']')
            if ($normalized) {
                $paths += $normalized
            }
        }
    }

    return @($paths | Select-Object -Unique)
}

function Resolve-ExistingPathCandidates {
    param(
        [string[]]$PathCandidates,
        [bool]$WorkspaceProbeEnabled,
        [int]$WorkspaceProbeLimit,
        [string[]]$WorkspaceProbeExtensions
    )

    $resolvedPaths = @()
    $cwd = (Get-Location).Path

    foreach ($candidate in @($PathCandidates)) {
        $raw = [Environment]::ExpandEnvironmentVariables([string]$candidate)
        if (-not $raw) { continue }

        $tries = @()
        if ([System.IO.Path]::IsPathRooted($raw)) {
            $tries += $raw
        } else {
            $tries += (Join-Path -Path $cwd -ChildPath $raw)
            $tries += $raw
        }

        foreach ($tryPath in $tries) {
            if (-not $tryPath) { continue }
            if (Test-Path -LiteralPath $tryPath -PathType Leaf) {
                $resolved = (Resolve-Path -LiteralPath $tryPath -ErrorAction SilentlyContinue).Path
                if ($resolved) {
                    $resolvedPaths += $resolved
                    break
                }
            }
        }
    }

    if ($resolvedPaths.Count -eq 0 -and $WorkspaceProbeEnabled) {
        $limit = if ($WorkspaceProbeLimit -gt 0) { $WorkspaceProbeLimit } else { 3 }
        $probeExt = @($WorkspaceProbeExtensions | ForEach-Object { [string]$_ } | Where-Object { $_ })
        if ($probeExt.Count -gt 0) {
            foreach ($ext in $probeExt) {
                $pattern = "*.$ext"
                $hits = Get-ChildItem -Path $cwd -File -Filter $pattern -ErrorAction SilentlyContinue | Select-Object -First $limit
                foreach ($h in $hits) {
                    if ($h -and $h.FullName) {
                        $resolvedPaths += [string]$h.FullName
                    }
                }
                if ($resolvedPaths.Count -ge $limit) { break }
            }
        }
    }

    return @($resolvedPaths | Select-Object -Unique)
}

function Get-DetectedExtension {
    param(
        [string]$Path,
        [string[]]$SupportedExtensions
    )

    $name = [System.IO.Path]::GetFileName([string]$Path).ToLowerInvariant()
    foreach ($ext in @($SupportedExtensions | Sort-Object { $_.Length } -Descending)) {
        $needle = "." + ([string]$ext).ToLowerInvariant()
        if ($name.EndsWith($needle)) {
            return ([string]$ext).ToLowerInvariant()
        }
    }

    return [System.IO.Path]::GetExtension($name).TrimStart('.').ToLowerInvariant()
}

function Test-WorkbookExtension {
    param([string]$Extension)
    return ($Extension -in @("xlsx", "xlsm", "xls"))
}

function Test-CsvLikeExtension {
    param([string]$Extension)
    return ($Extension -in @(
            "csv", "tsv", "tab", "psv", "ssv", "scsv",
            "csv.gz", "tsv.gz", "tab.gz", "psv.gz", "ssv.gz", "scsv.gz",
            "csv.zst", "tsv.zst", "tab.zst"
        ))
}

function Get-DelimiterHint {
    param(
        [string]$Extension,
        [string]$HeaderLine
    )

    if ($Extension -match "^(tsv|tab)(\.|$)") { return "`t" }
    if ($Extension -match "^psv(\.|$)") { return "|" }
    if ($Extension -match "^(ssv|scsv)(\.|$)") { return ";" }

    $candidates = @(",", ";", "`t", "|")
    $best = ","
    $bestCount = -1
    foreach ($d in $candidates) {
        $count = ([string]$HeaderLine).Split($d).Count
        if ($count -gt $bestCount) {
            $best = $d
            $bestCount = $count
        }
    }

    return $best
}

function Get-DelimitedFileSampleStats {
    param(
        [string]$Path,
        [string]$Extension,
        [int64]$FileSizeBytes,
        [int]$MaxLines,
        [int]$MaxChars
    )

    $result = [ordered]@{
        columns = $null
        delimiter = $null
        sample_rows = 0
        sample_bytes = 0
        estimated_rows = $null
    }

    if ($Extension -match "\.(gz|zst)$") {
        return [pscustomobject]$result
    }

    $lineCap = if ($MaxLines -gt 0) { $MaxLines } else { 200 }
    $charCap = if ($MaxChars -gt 0) { $MaxChars } else { 200000 }

    $rawLines = @()
    try {
        $rawLines = @(Get-Content -LiteralPath $Path -TotalCount $lineCap -Encoding UTF8 -ErrorAction Stop)
    } catch {
        return [pscustomobject]$result
    }

    if ($rawLines.Count -eq 0) {
        return [pscustomobject]$result
    }

    $lines = @()
    $chars = 0
    foreach ($line in $rawLines) {
        $text = [string]$line
        if (($chars + $text.Length + 1) -gt $charCap -and $lines.Count -gt 0) {
            break
        }
        $lines += $text
        $chars += ($text.Length + 1)
    }

    if ($lines.Count -eq 0) {
        return [pscustomobject]$result
    }

    $header = [string]$lines[0]
    $delimiter = Get-DelimiterHint -Extension $Extension -HeaderLine $header
    $splitPattern = [Regex]::Escape($delimiter)
    $columns = if ($header.Length -gt 0) { ([Regex]::Split($header, $splitPattern, [System.Text.RegularExpressions.RegexOptions]::None)).Count } else { 0 }
    $sampleRows = [Math]::Max(0, $lines.Count - 1)

    $sampleText = $lines -join "`n"
    $sampleBytes = [System.Text.Encoding]::UTF8.GetByteCount($sampleText)
    $estimatedRows = $null
    if ($sampleRows -gt 0 -and $sampleBytes -gt 0 -and $FileSizeBytes -gt 0) {
        $estimatedRows = [int64][Math]::Round(([double]$FileSizeBytes / [double]$sampleBytes) * [double]$sampleRows, 0)
    }

    $result.columns = $columns
    $result.delimiter = $delimiter
    $result.sample_rows = $sampleRows
    $result.sample_bytes = $sampleBytes
    $result.estimated_rows = $estimatedRows
    return [pscustomobject]$result
}

function Get-DataScaleOverlayAdvice {
    param(
        [string]$Prompt,
        [string]$PromptLower,
        [string]$Grade,
        [string]$TaskType,
        [string]$RouteMode,
        [string]$SelectedPackId,
        [string]$SelectedSkill,
        [string[]]$PackCandidates,
        [object]$DataScaleOverlayPolicy
    )

    if (-not $DataScaleOverlayPolicy) {
        return [pscustomobject]@{
            enabled = $false
            mode = "off"
            task_applicable = $false
            grade_applicable = $false
            pack_applicable = $false
            skill_applicable = $false
            scope_applicable = $false
            enforcement = "none"
            reason = "policy_missing"
            preserve_routing_assignment = $true
            paths_detected = @()
            paths_existing = @()
            probe_file_count = 0
            probe_primary_file = $null
            probe_file_analysis = @()
            data_scale = "unknown"
            size_bytes = 0
            estimated_rows = $null
            column_count = $null
            is_workbook = $false
            is_csv_like = $false
            is_compressed = $false
            operation_prefers_xan = $false
            recommended_skill = $null
            confidence = 0.0
            confirm_required = $false
            auto_override = $false
            override_candidate_allowed = $false
        }
    }

    $enabled = $true
    if ($DataScaleOverlayPolicy.enabled -ne $null) {
        $enabled = [bool]$DataScaleOverlayPolicy.enabled
    }
    $mode = if ($DataScaleOverlayPolicy.mode) { [string]$DataScaleOverlayPolicy.mode } else { "off" }
    if ((-not $enabled) -or ($mode -eq "off")) {
        return [pscustomobject]@{
            enabled = $false
            mode = "off"
            task_applicable = $false
            grade_applicable = $false
            pack_applicable = $false
            skill_applicable = $false
            scope_applicable = $false
            enforcement = "none"
            reason = "policy_off"
            preserve_routing_assignment = $true
            paths_detected = @()
            paths_existing = @()
            probe_file_count = 0
            probe_primary_file = $null
            probe_file_analysis = @()
            data_scale = "unknown"
            size_bytes = 0
            estimated_rows = $null
            column_count = $null
            is_workbook = $false
            is_csv_like = $false
            is_compressed = $false
            operation_prefers_xan = $false
            recommended_skill = $null
            confidence = 0.0
            confirm_required = $false
            auto_override = $false
            override_candidate_allowed = $false
        }
    }

    $taskAllow = @("coding", "research")
    if ($DataScaleOverlayPolicy.task_allow) {
        $taskAllow = @($DataScaleOverlayPolicy.task_allow)
    }
    $gradeAllow = @("M", "L", "XL")
    if ($DataScaleOverlayPolicy.grade_allow) {
        $gradeAllow = @($DataScaleOverlayPolicy.grade_allow)
    }

    $packAllow = @()
    if ($DataScaleOverlayPolicy.monitor -and $DataScaleOverlayPolicy.monitor.pack_allow) {
        $packAllow = @($DataScaleOverlayPolicy.monitor.pack_allow)
    }
    $skillAllow = @()
    if ($DataScaleOverlayPolicy.monitor -and $DataScaleOverlayPolicy.monitor.skill_allow) {
        $skillAllow = @($DataScaleOverlayPolicy.monitor.skill_allow)
    }
    $supportedExt = @("csv", "tsv", "tab", "psv", "ssv", "scsv", "csv.gz", "tsv.gz", "tab.gz", "psv.gz", "ssv.gz", "scsv.gz", "csv.zst", "tsv.zst", "tab.zst", "xlsx", "xlsm", "xls")
    if ($DataScaleOverlayPolicy.monitor -and $DataScaleOverlayPolicy.monitor.supported_extensions) {
        $supportedExt = @($DataScaleOverlayPolicy.monitor.supported_extensions)
    }

    $taskApplicable = ($taskAllow -contains $TaskType)
    $gradeApplicable = ($gradeAllow -contains $Grade)
    $packApplicable = if ($packAllow.Count -gt 0) { $packAllow -contains $SelectedPackId } else { $true }
    $skillApplicable = if ($skillAllow.Count -gt 0) { $skillAllow -contains $SelectedSkill } else { $true }
    $scopeApplicable = ($taskApplicable -and $gradeApplicable -and $packApplicable -and $skillApplicable)

    $preserveRoutingAssignment = $true
    if ($DataScaleOverlayPolicy.preserve_routing_assignment -ne $null) {
        $preserveRoutingAssignment = [bool]$DataScaleOverlayPolicy.preserve_routing_assignment
    }

    if (-not $scopeApplicable) {
        return [pscustomobject]@{
            enabled = $true
            mode = $mode
            task_applicable = $taskApplicable
            grade_applicable = $gradeApplicable
            pack_applicable = $packApplicable
            skill_applicable = $skillApplicable
            scope_applicable = $false
            enforcement = "none"
            reason = "outside_scope"
            preserve_routing_assignment = $preserveRoutingAssignment
            paths_detected = @()
            paths_existing = @()
            probe_file_count = 0
            probe_primary_file = $null
            probe_file_analysis = @()
            data_scale = "unknown"
            size_bytes = 0
            estimated_rows = $null
            column_count = $null
            is_workbook = $false
            is_csv_like = $false
            is_compressed = $false
            operation_prefers_xan = $false
            recommended_skill = $null
            confidence = 0.0
            confirm_required = $false
            auto_override = $false
            override_candidate_allowed = $false
        }
    }

    $probeEnabled = $true
    $extractFromPrompt = $true
    $workspaceProbeWhenNoPath = $false
    $workspaceProbeLimit = 3
    $workspaceProbeExtensions = @("csv", "tsv", "tab", "psv", "ssv", "scsv", "xlsx", "xlsm", "xls")
    $sampleMaxLines = 200
    $sampleMaxChars = 200000

    if ($DataScaleOverlayPolicy.path_probe) {
        if ($DataScaleOverlayPolicy.path_probe.enabled -ne $null) {
            $probeEnabled = [bool]$DataScaleOverlayPolicy.path_probe.enabled
        }
        if ($DataScaleOverlayPolicy.path_probe.extract_from_prompt -ne $null) {
            $extractFromPrompt = [bool]$DataScaleOverlayPolicy.path_probe.extract_from_prompt
        }
        if ($DataScaleOverlayPolicy.path_probe.workspace_probe_when_no_path -ne $null) {
            $workspaceProbeWhenNoPath = [bool]$DataScaleOverlayPolicy.path_probe.workspace_probe_when_no_path
        }
        if ($DataScaleOverlayPolicy.path_probe.workspace_probe_limit -ne $null) {
            $workspaceProbeLimit = [int]$DataScaleOverlayPolicy.path_probe.workspace_probe_limit
        }
        if ($DataScaleOverlayPolicy.path_probe.workspace_probe_extensions) {
            $workspaceProbeExtensions = @($DataScaleOverlayPolicy.path_probe.workspace_probe_extensions)
        }
        if ($DataScaleOverlayPolicy.path_probe.read_sample_max_lines -ne $null) {
            $sampleMaxLines = [int]$DataScaleOverlayPolicy.path_probe.read_sample_max_lines
        }
        if ($DataScaleOverlayPolicy.path_probe.read_sample_max_chars -ne $null) {
            $sampleMaxChars = [int]$DataScaleOverlayPolicy.path_probe.read_sample_max_chars
        }
    }

    if (-not $probeEnabled) {
        return [pscustomobject]@{
            enabled = $true
            mode = $mode
            task_applicable = $taskApplicable
            grade_applicable = $gradeApplicable
            pack_applicable = $packApplicable
            skill_applicable = $skillApplicable
            scope_applicable = $true
            enforcement = "advisory"
            reason = "probe_disabled"
            preserve_routing_assignment = $preserveRoutingAssignment
            paths_detected = @()
            paths_existing = @()
            probe_file_count = 0
            probe_primary_file = $null
            probe_file_analysis = @()
            data_scale = "unknown"
            size_bytes = 0
            estimated_rows = $null
            column_count = $null
            is_workbook = $false
            is_csv_like = $false
            is_compressed = $false
            operation_prefers_xan = $false
            recommended_skill = $null
            confidence = 0.0
            confirm_required = $false
            auto_override = $false
            override_candidate_allowed = $false
        }
    }

    $pathsDetected = @()
    if ($extractFromPrompt) {
        $pathsDetected = @(Get-PathCandidatesFromPrompt -Prompt $Prompt -SupportedExtensions $supportedExt)
    }
    $pathsExisting = @(Resolve-ExistingPathCandidates -PathCandidates $pathsDetected -WorkspaceProbeEnabled $workspaceProbeWhenNoPath -WorkspaceProbeLimit $workspaceProbeLimit -WorkspaceProbeExtensions $workspaceProbeExtensions)

    if ($pathsExisting.Count -eq 0) {
        return [pscustomobject]@{
            enabled = $true
            mode = $mode
            task_applicable = $taskApplicable
            grade_applicable = $gradeApplicable
            pack_applicable = $packApplicable
            skill_applicable = $skillApplicable
            scope_applicable = $true
            enforcement = "advisory"
            reason = "no_existing_data_path"
            preserve_routing_assignment = $preserveRoutingAssignment
            paths_detected = @($pathsDetected)
            paths_existing = @()
            probe_file_count = 0
            probe_primary_file = $null
            probe_file_analysis = @()
            data_scale = "unknown"
            size_bytes = 0
            estimated_rows = $null
            column_count = $null
            is_workbook = $false
            is_csv_like = $false
            is_compressed = $false
            operation_prefers_xan = $false
            recommended_skill = $null
            confidence = 0.0
            confirm_required = $false
            auto_override = $false
            override_candidate_allowed = $false
        }
    }

    $fileAnalysis = @()
    foreach ($path in $pathsExisting) {
        $item = $null
        try {
            $item = Get-Item -LiteralPath $path -ErrorAction Stop
        } catch {
            continue
        }
        if (-not $item) { continue }

        $ext = Get-DetectedExtension -Path $item.FullName -SupportedExtensions $supportedExt
        $isWorkbook = Test-WorkbookExtension -Extension $ext
        $isCsvLike = Test-CsvLikeExtension -Extension $ext
        $isCompressed = ($ext -match "\.(gz|zst)$")

        $columns = $null
        $estimatedRows = $null
        $sampleRows = 0
        if ($isCsvLike -and -not $isCompressed) {
            $sample = Get-DelimitedFileSampleStats -Path $item.FullName -Extension $ext -FileSizeBytes ([int64]$item.Length) -MaxLines $sampleMaxLines -MaxChars $sampleMaxChars
            $columns = $sample.columns
            $estimatedRows = $sample.estimated_rows
            $sampleRows = $sample.sample_rows
        }

        $fileAnalysis += [pscustomobject]@{
            path = [string]$item.FullName
            size_bytes = [int64]$item.Length
            extension = $ext
            is_workbook = $isWorkbook
            is_csv_like = $isCsvLike
            is_compressed = $isCompressed
            columns = $columns
            estimated_rows = $estimatedRows
            sample_rows = $sampleRows
        }
    }

    if ($fileAnalysis.Count -eq 0) {
        return [pscustomobject]@{
            enabled = $true
            mode = $mode
            task_applicable = $taskApplicable
            grade_applicable = $gradeApplicable
            pack_applicable = $packApplicable
            skill_applicable = $skillApplicable
            scope_applicable = $true
            enforcement = "advisory"
            reason = "probe_failed"
            preserve_routing_assignment = $preserveRoutingAssignment
            paths_detected = @($pathsDetected)
            paths_existing = @($pathsExisting)
            probe_file_count = 0
            probe_primary_file = $null
            probe_file_analysis = @()
            data_scale = "unknown"
            size_bytes = 0
            estimated_rows = $null
            column_count = $null
            is_workbook = $false
            is_csv_like = $false
            is_compressed = $false
            operation_prefers_xan = $false
            recommended_skill = $null
            confidence = 0.0
            confirm_required = $false
            auto_override = $false
            override_candidate_allowed = $false
        }
    }

    $primary = @($fileAnalysis | Sort-Object -Property @{ Expression = "size_bytes"; Descending = $true } | Select-Object -First 1)[0]
    $sizeBytes = [int64]$primary.size_bytes
    $estimatedRows = if ($primary.estimated_rows -ne $null) { [int64]$primary.estimated_rows } else { $null }
    $columnCount = if ($primary.columns -ne $null) { [int]$primary.columns } else { $null }
    $isWorkbook = [bool]$primary.is_workbook
    $isCsvLike = [bool]$primary.is_csv_like
    $isCompressed = [bool]$primary.is_compressed

    $mediumSize = 52428800
    $largeSize = 314572800
    $mediumRows = 500000
    $largeRows = 3000000
    $confirmMin = 0.6
    $overrideMin = 0.85

    if ($DataScaleOverlayPolicy.thresholds) {
        if ($DataScaleOverlayPolicy.thresholds.medium_size_bytes -ne $null) { $mediumSize = [int64]$DataScaleOverlayPolicy.thresholds.medium_size_bytes }
        if ($DataScaleOverlayPolicy.thresholds.large_size_bytes -ne $null) { $largeSize = [int64]$DataScaleOverlayPolicy.thresholds.large_size_bytes }
        if ($DataScaleOverlayPolicy.thresholds.medium_estimated_rows -ne $null) { $mediumRows = [int64]$DataScaleOverlayPolicy.thresholds.medium_estimated_rows }
        if ($DataScaleOverlayPolicy.thresholds.large_estimated_rows -ne $null) { $largeRows = [int64]$DataScaleOverlayPolicy.thresholds.large_estimated_rows }
        if ($DataScaleOverlayPolicy.thresholds.confirm_confidence_min -ne $null) { $confirmMin = [double]$DataScaleOverlayPolicy.thresholds.confirm_confidence_min }
        if ($DataScaleOverlayPolicy.thresholds.high_confidence_for_override -ne $null) { $overrideMin = [double]$DataScaleOverlayPolicy.thresholds.high_confidence_for_override }
    }

    $isLargeBySize = ($sizeBytes -ge $largeSize)
    $isLargeByRows = ($estimatedRows -ne $null -and $estimatedRows -ge $largeRows)
    $isMediumBySize = ($sizeBytes -ge $mediumSize)
    $isMediumByRows = ($estimatedRows -ne $null -and $estimatedRows -ge $mediumRows)

    $dataScale = "small"
    if ($isLargeBySize -or $isLargeByRows) {
        $dataScale = "large"
    } elseif ($isMediumBySize -or $isMediumByRows) {
        $dataScale = "medium"
    }

    $csvDefaultSkill = "spreadsheet"
    $csvLargeSkill = "xan"
    $workbookSkill = "xlsx"
    $workbookAnalysisSkill = "spreadsheet"
    $operationKeywords = @("join", "groupby", "dedup", "frequency", "sort", "filter", "pipeline", "aggregate", "window", "parallel", "merge", "split", "分组", "去重", "聚合", "连接", "排序", "过滤", "管道", "流式")
    if ($DataScaleOverlayPolicy.recommendations) {
        if ($DataScaleOverlayPolicy.recommendations.csv_default_skill) { $csvDefaultSkill = [string]$DataScaleOverlayPolicy.recommendations.csv_default_skill }
        if ($DataScaleOverlayPolicy.recommendations.csv_large_skill) { $csvLargeSkill = [string]$DataScaleOverlayPolicy.recommendations.csv_large_skill }
        if ($DataScaleOverlayPolicy.recommendations.workbook_skill) { $workbookSkill = [string]$DataScaleOverlayPolicy.recommendations.workbook_skill }
        if ($DataScaleOverlayPolicy.recommendations.workbook_analysis_skill) { $workbookAnalysisSkill = [string]$DataScaleOverlayPolicy.recommendations.workbook_analysis_skill }
        if ($DataScaleOverlayPolicy.recommendations.operations_preferring_xan) {
            $operationKeywords = @($DataScaleOverlayPolicy.recommendations.operations_preferring_xan)
        }
    }

    $operationPrefersXan = $false
    foreach ($kw in $operationKeywords) {
        if (Test-KeywordHit -PromptLower $PromptLower -Keyword ([string]$kw)) {
            $operationPrefersXan = $true
            break
        }
    }

    $recommendedSkill = $null
    $confidence = 0.0
    $reason = "no_recommendation"
    if ($isWorkbook) {
        $pivotLike = (Test-KeywordHit -PromptLower $PromptLower -Keyword "pivot") -or (Test-KeywordHit -PromptLower $PromptLower -Keyword "pivot table") -or (Test-KeywordHit -PromptLower $PromptLower -Keyword "数据透视") -or (Test-KeywordHit -PromptLower $PromptLower -Keyword "透视表")
        $recommendedSkill = if ($pivotLike) { $workbookAnalysisSkill } else { $workbookSkill }
        $confidence = 0.9
        $reason = "workbook_detected"
    } elseif ($isCsvLike) {
        if ($dataScale -eq "large") {
            $recommendedSkill = $csvLargeSkill
            $confidence = 0.9
            $reason = "csv_large_detected"
        } elseif ($dataScale -eq "medium" -and $operationPrefersXan) {
            $recommendedSkill = $csvLargeSkill
            $confidence = 0.72
            $reason = "csv_medium_operation_prefers_xan"
        } else {
            $recommendedSkill = $csvDefaultSkill
            $confidence = 0.68
            $reason = "csv_default_path"
        }
    } else {
        $reason = "unsupported_extension"
    }

    $overrideCandidateAllowed = ($recommendedSkill -and ($PackCandidates -contains $recommendedSkill))
    $enforcement = "advisory"
    $confirmRequired = $false
    $autoOverride = $false

    if ($recommendedSkill -and $overrideCandidateAllowed -and $SelectedSkill -and ($recommendedSkill -ne $SelectedSkill)) {
        switch ($mode) {
            "soft" {
                if ($confidence -ge $confirmMin) {
                    $enforcement = "confirm_required"
                    $confirmRequired = $true
                }
            }
            "strict" {
                if ($confidence -ge $overrideMin) {
                    $enforcement = "required"
                    $autoOverride = $true
                } elseif ($confidence -ge $confirmMin) {
                    $enforcement = "confirm_required"
                    $confirmRequired = $true
                }
            }
        }
    }

    return [pscustomobject]@{
        enabled = $true
        mode = $mode
        task_applicable = $taskApplicable
        grade_applicable = $gradeApplicable
        pack_applicable = $packApplicable
        skill_applicable = $skillApplicable
        scope_applicable = $scopeApplicable
        enforcement = $enforcement
        reason = $reason
        preserve_routing_assignment = $preserveRoutingAssignment
        paths_detected = @($pathsDetected)
        paths_existing = @($pathsExisting)
        probe_file_count = $fileAnalysis.Count
        probe_primary_file = [string]$primary.path
        probe_file_analysis = @($fileAnalysis)
        data_scale = $dataScale
        size_bytes = [int64]$sizeBytes
        estimated_rows = $estimatedRows
        column_count = $columnCount
        is_workbook = $isWorkbook
        is_csv_like = $isCsvLike
        is_compressed = $isCompressed
        operation_prefers_xan = $operationPrefersXan
        recommended_skill = $recommendedSkill
        confidence = [Math]::Round([double]$confidence, 4)
        confirm_required = $confirmRequired
        auto_override = $autoOverride
        override_candidate_allowed = $overrideCandidateAllowed
    }
}

receiving-code-reviewobra/superpowersUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementationStars: 322kUpdated Claude CodeCodexVerifiedInstall
requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirementsStars: 322kUpdated Claude CodeCodexVerifiedInstall
using-git-worktreesobra/superpowersUse when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallbackStars: 322kUpdated Claude CodeCodexVerifiedInstall
verification-before-completionobra/superpowersUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions alwaysStars: 322kUpdated Claude CodeCodexVerifiedInstall