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/43-retrieval-overlay.ps1

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

function Get-RetrievalProfileKeywordHits {
    param(
        [string]$PromptLower,
        [string[]]$Keywords,
        [int]$Limit = 8
    )

    if (-not $PromptLower -or -not $Keywords -or $Keywords.Count -eq 0) {
        return @()
    }

    $hits = @()
    foreach ($keyword in @($Keywords)) {
        if (-not $keyword) { continue }
        if (Test-KeywordHit -PromptLower $PromptLower -Keyword ([string]$keyword)) {
            $hits += [string]$keyword
        }
    }

    return @($hits | Select-Object -Unique | Select-Object -First $Limit)
}

function Get-RetrievalProfileScore {
    param(
        [string]$PromptLower,
        [object]$Profile
    )

    if (-not $Profile) {
        return [pscustomobject]@{
            id = "unknown"
            score = 0.0
            positive_score = 0.0
            negative_score = 0.0
            positive_hits = @()
            negative_hits = @()
        }
    }

    $profileId = if ($Profile.id) { [string]$Profile.id } else { "unknown" }
    $positiveKeywords = @($Profile.positive_keywords)
    $negativeKeywords = @($Profile.negative_keywords)
    $negativePenaltyWeight = if ($Profile.negative_penalty_weight -ne $null) { [double]$Profile.negative_penalty_weight } else { 0.65 }

    $positiveScore = [double](Get-KeywordRatio -PromptLower $PromptLower -Keywords $positiveKeywords)
    $negativeScore = [double](Get-KeywordRatio -PromptLower $PromptLower -Keywords $negativeKeywords)
    $rawScore = $positiveScore - ($negativeScore * $negativePenaltyWeight)
    $score = [Math]::Round([Math]::Min(1.0, [Math]::Max(0.0, $rawScore)), 4)

    return [pscustomobject]@{
        id = $profileId
        score = $score
        positive_score = [Math]::Round($positiveScore, 4)
        negative_score = [Math]::Round($negativeScore, 4)
        positive_hits = @(Get-RetrievalProfileKeywordHits -PromptLower $PromptLower -Keywords $positiveKeywords)
        negative_hits = @(Get-RetrievalProfileKeywordHits -PromptLower $PromptLower -Keywords $negativeKeywords)
    }
}

function Resolve-RetrievalProfileChoice {
    param(
        [string]$PromptLower,
        [object[]]$Profiles,
        [double]$MinConfidence = 0.42,
        [double]$AmbiguousGap = 0.08,
        [string]$FallbackProfileId = "composite"
    )

    $rows = @()
    foreach ($profile in @($Profiles)) {
        $rows += Get-RetrievalProfileScore -PromptLower $PromptLower -Profile $profile
    }

    $ranked = @(
        $rows | Sort-Object -Property @(
            @{ Expression = "score"; Descending = $true },
            @{ Expression = "id"; Descending = $false }
        )
    )

    $top = if ($ranked.Count -gt 0) { $ranked[0] } else { $null }
    $second = if ($ranked.Count -gt 1) { $ranked[1] } else { $null }
    $topScore = if ($top) { [double]$top.score } else { 0.0 }
    $topGap = if ($second) { [double]$top.score - [double]$second.score } else { [double]$topScore }
    $topGap = [Math]::Round([Math]::Max(0.0, $topGap), 4)

    $ambiguous = ($topScore -lt $MinConfidence) -or ($topGap -lt $AmbiguousGap)
    $selectedId = if ($top) { [string]$top.id } else { [string]$FallbackProfileId }
    if ($ambiguous -and $FallbackProfileId) {
        $selectedId = [string]$FallbackProfileId
    }

    $selectedProfile = @($Profiles | Where-Object { [string]$_.id -eq $selectedId } | Select-Object -First 1)
    if (-not $selectedProfile -and $top) {
        $selectedProfile = @($Profiles | Where-Object { [string]$_.id -eq [string]$top.id } | Select-Object -First 1)
    }

    $selectedScore = 0.0
    if ($selectedProfile) {
        $selectedRow = @($ranked | Where-Object { [string]$_.id -eq [string]$selectedProfile.id } | Select-Object -First 1)
        if ($selectedRow) {
            $selectedScore = [double]$selectedRow.score
        }
    }

    $ranking = @(
        $ranked | Select-Object -First 6 | ForEach-Object {
            [pscustomobject]@{
                id = [string]$_.id
                score = [double]$_.score
                positive_score = [double]$_.positive_score
                negative_score = [double]$_.negative_score
            }
        }
    )

    return [pscustomobject]@{
        top_id = if ($top) { [string]$top.id } else { "none" }
        top_score = [Math]::Round([double]$topScore, 4)
        top_gap = [double]$topGap
        ambiguous = [bool]$ambiguous
        selected_id = if ($selectedProfile) { [string]$selectedProfile.id } else { "none" }
        selected_score = [Math]::Round([double]$selectedScore, 4)
        ranking = @($ranking)
        profile_rows = @($ranked)
    }
}

function Get-RetrievalSourcePlan {
    param(
        [object]$Profile,
        [object]$SourceRegistry
    )

    $preferredSourceIds = @()
    if ($Profile -and $Profile.default_sources) {
        $preferredSourceIds = @($Profile.default_sources)
    }

    $registryRows = @()
    if ($SourceRegistry -and $SourceRegistry.sources) {
        $registryRows = @($SourceRegistry.sources)
    }

    $sources = @()
    foreach ($sourceId in @($preferredSourceIds)) {
        $match = @($registryRows | Where-Object { [string]$_.id -eq [string]$sourceId } | Select-Object -First 1)
        if ($match) {
            $sources += [pscustomobject]@{
                id = [string]$match.id
                type = if ($match.type) { [string]$match.type } else { "general" }
                provider = if ($match.provider) { [string]$match.provider } else { "unknown" }
                quality_weight = if ($match.quality_weight -ne $null) { [double]$match.quality_weight } else { 0.5 }
                latency_tier = if ($match.latency_tier) { [string]$match.latency_tier } else { "unknown" }
            }
        }
    }

    if ($sources.Count -eq 0 -and $registryRows.Count -gt 0) {
        foreach ($fallback in @($registryRows | Select-Object -First 3)) {
            $sources += [pscustomobject]@{
                id = [string]$fallback.id
                type = if ($fallback.type) { [string]$fallback.type } else { "general" }
                provider = if ($fallback.provider) { [string]$fallback.provider } else { "unknown" }
                quality_weight = if ($fallback.quality_weight -ne $null) { [double]$fallback.quality_weight } else { 0.5 }
                latency_tier = if ($fallback.latency_tier) { [string]$fallback.latency_tier } else { "unknown" }
            }
        }
    }

    return [pscustomobject]@{
        preferred_source_ids = @($preferredSourceIds)
        sources = @($sources)
        source_count = [int]$sources.Count
    }
}

function Get-RetrievalRerankPlan {
    param(
        [object]$Profile,
        [object]$RerankWeights
    )

    $profileRerankMode = if ($Profile -and $Profile.rerank_mode) { [string]$Profile.rerank_mode } else { "balanced" }
    $fallbackMode = if ($RerankWeights -and $RerankWeights.fallback_mode) { [string]$RerankWeights.fallback_mode } else { "balanced" }
    $modes = if ($RerankWeights -and $RerankWeights.modes) { $RerankWeights.modes } else { $null }
    $availableModeKeys = if ($modes) { Get-ArraySafe -Value $modes.PSObject.Properties.Name } else { Get-ArraySafe -Value $null }

    $selectedMode = if ($availableModeKeys -contains $profileRerankMode) { $profileRerankMode } else { $fallbackMode }
    if (-not ($availableModeKeys -contains $selectedMode)) {
        $selectedMode = if ($availableModeKeys.Count -gt 0) { [string]$availableModeKeys[0] } else { "balanced" }
    }

    $weights = if ($modes -and ($availableModeKeys -contains $selectedMode)) { $modes.$selectedMode } else { $null }
    $semanticWeight = if ($weights -and $weights.semantic -ne $null) { [double]$weights.semantic } else { 0.45 }
    $keywordWeight = if ($weights -and $weights.keyword -ne $null) { [double]$weights.keyword } else { 0.35 }
    $authorityWeight = if ($weights -and $weights.authority -ne $null) { [double]$weights.authority } else { 0.20 }

    return [pscustomobject]@{
        mode = $selectedMode
        hybrid_enabled = $true
        weights = [pscustomobject]@{
            semantic = [Math]::Round($semanticWeight, 4)
            keyword = [Math]::Round($keywordWeight, 4)
            authority = [Math]::Round($authorityWeight, 4)
        }
    }
}

function Get-RetrievalOverlayAdvice {
    param(
        [string]$Prompt,
        [string]$PromptLower,
        [string]$Grade,
        [string]$TaskType,
        [string]$SelectedPackId,
        [string]$SelectedSkill,
        [string[]]$PackCandidates,
        [object]$RetrievalPolicy,
        [object]$RetrievalIntentProfiles,
        [object]$RetrievalSourceRegistry,
        [object]$RetrievalRerankWeights
    )

    if (-not $RetrievalPolicy) {
        return [pscustomobject]@{
            enabled = $false
            mode = "off"
            task_applicable = $false
            grade_applicable = $false
            route_mode_applicable = $false
            scope_applicable = $false
            enforcement = "none"
            reason = "policy_missing"
            profile_id = "none"
            profile_confidence = 0.0
            profile_top_gap = 0.0
            profile_ambiguous = $false
            confirm_recommended = $false
            confirm_required = $false
            auto_override = $false
            override_candidate_allowed = $false
            route_override_applied = $false
            recommended_skill = $null
            confidence = 0.0
        }
    }

    $enabled = if ($RetrievalPolicy.enabled -ne $null) { [bool]$RetrievalPolicy.enabled } else { $true }
    $mode = if ($RetrievalPolicy.mode) { [string]$RetrievalPolicy.mode } else { "off" }
    if ((-not $enabled) -or ($mode -eq "off")) {
        return [pscustomobject]@{
            enabled = $false
            mode = "off"
            task_applicable = $false
            grade_applicable = $false
            route_mode_applicable = $false
            scope_applicable = $false
            enforcement = "none"
            reason = "policy_off"
            profile_id = "none"
            profile_confidence = 0.0
            profile_top_gap = 0.0
            profile_ambiguous = $false
            confirm_recommended = $false
            confirm_required = $false
            auto_override = $false
            override_candidate_allowed = $false
            route_override_applied = $false
            recommended_skill = $null
            confidence = 0.0
        }
    }

    $taskAllow = @($RetrievalPolicy.task_allow)
    $gradeAllow = @($RetrievalPolicy.grade_allow)

    $taskApplicable = if ($taskAllow.Count -gt 0) { $taskAllow -contains $TaskType } else { $true }
    $gradeApplicable = if ($gradeAllow.Count -gt 0) { $gradeAllow -contains $Grade } else { $true }
    $routeModeApplicable = $true
    $scopeApplicable = $taskApplicable -and $gradeApplicable -and $routeModeApplicable

    if (-not $scopeApplicable) {
        $scopeReason = if (-not $taskApplicable) {
            "task_out_of_scope"
        } elseif (-not $gradeApplicable) {
            "grade_out_of_scope"
        } else {
            "route_mode_out_of_scope"
        }

        return [pscustomobject]@{
            enabled = $true
            mode = $mode
            task_applicable = [bool]$taskApplicable
            grade_applicable = [bool]$gradeApplicable
            route_mode_applicable = [bool]$routeModeApplicable
            scope_applicable = $false
            enforcement = "none"
            reason = $scopeReason
            profile_id = "none"
            profile_confidence = 0.0
            profile_top_gap = 0.0
            profile_ambiguous = $false
            confirm_recommended = $false
            confirm_required = $false
            auto_override = $false
            override_candidate_allowed = $false
            route_override_applied = $false
            recommended_skill = $null
            confidence = 0.0
        }
    }

    $profiles = if ($RetrievalIntentProfiles -and $RetrievalIntentProfiles.profiles) { Get-ArraySafe -Value $RetrievalIntentProfiles.profiles } else { Get-ArraySafe -Value $null }
    if ($profiles.Count -eq 0) {
        return [pscustomobject]@{
            enabled = $true
            mode = $mode
            task_applicable = [bool]$taskApplicable
            grade_applicable = [bool]$gradeApplicable
            route_mode_applicable = [bool]$routeModeApplicable
            scope_applicable = $false
            enforcement = "none"
            reason = "profiles_missing"
            profile_id = "none"
            profile_confidence = 0.0
            profile_top_gap = 0.0
            profile_ambiguous = $false
            confirm_recommended = $false
            confirm_required = $false
            auto_override = $false
            override_candidate_allowed = $false
            route_override_applied = $false
            recommended_skill = $null
            confidence = 0.0
        }
    }

    $profileSelection = if ($RetrievalPolicy.profile_selection) { $RetrievalPolicy.profile_selection } else { $null }
    $minProfileConfidence = if ($profileSelection -and $profileSelection.min_profile_confidence -ne $null) { [double]$profileSelection.min_profile_confidence } else { 0.42 }
    $ambiguousGap = if ($profileSelection -and $profileSelection.ambiguous_gap -ne $null) { [double]$profileSelection.ambiguous_gap } else { 0.08 }
    $fallbackProfileId = if ($profileSelection -and $profileSelection.fallback_profile) { [string]$profileSelection.fallback_profile } else { "composite" }

    $profileChoice = Resolve-RetrievalProfileChoice `
        -PromptLower $PromptLower `
        -Profiles $profiles `
        -MinConfidence $minProfileConfidence `
        -AmbiguousGap $ambiguousGap `
        -FallbackProfileId $fallbackProfileId

    $selectedProfile = @($profiles | Where-Object { [string]$_.id -eq [string]$profileChoice.selected_id } | Select-Object -First 1)
    if (-not $selectedProfile) {
        $selectedProfile = @($profiles | Select-Object -First 1)
    }

    $profileRows = @($profileChoice.profile_rows)
    $selectedProfileRow = @($profileRows | Where-Object { [string]$_.id -eq [string]$selectedProfile.id } | Select-Object -First 1)
    $selectedPositiveHits = if ($selectedProfileRow -and $selectedProfileRow.PSObject.Properties.Name -contains 'positive_hits') { Get-ArraySafe -Value $selectedProfileRow.positive_hits } else { Get-ArraySafe -Value $null }
    $selectedNegativeHits = if ($selectedProfileRow -and $selectedProfileRow.PSObject.Properties.Name -contains 'negative_hits') { Get-ArraySafe -Value $selectedProfileRow.negative_hits } else { Get-ArraySafe -Value $null }

    $modeBudget = 3
    if ($profileSelection -and $profileSelection.max_query_variants_by_mode) {
        $budgetTable = $profileSelection.max_query_variants_by_mode
        $budgetKeys = @($budgetTable.PSObject.Properties.Name)
        if ($budgetKeys -contains $mode) {
            $modeBudget = [int]$budgetTable.$mode
        }
    }
    if ($modeBudget -le 0) { $modeBudget = 3 }

    $profileBudget = if ($selectedProfile.max_query_variants -ne $null) { [int]$selectedProfile.max_query_variants } else { $modeBudget }
    if ($profileBudget -le 0) { $profileBudget = $modeBudget }
    $maxQueryVariants = [Math]::Max(1, [Math]::Min($modeBudget, $profileBudget))

    $queryTemplates = @($selectedProfile.query_templates)
    $selectedTemplates = if ($queryTemplates.Count -gt 0) {
        @($queryTemplates | Select-Object -First $maxQueryVariants)
    } else {
        @("Use profile-guided query decomposition with focused keywords")
    }
    $expansionTerms = @($selectedProfile.query_expansion_terms | Select-Object -First 8)

    $sourcePlan = Get-RetrievalSourcePlan -Profile $selectedProfile -SourceRegistry $RetrievalSourceRegistry
    $rerankPlan = Get-RetrievalRerankPlan -Profile $selectedProfile -RerankWeights $RetrievalRerankWeights

    $coverage = if ($RetrievalPolicy.coverage) { $RetrievalPolicy.coverage } else { $null }
    $minSourcesHit = if ($coverage -and $coverage.min_sources_hit -ne $null) { [int]$coverage.min_sources_hit } else { 1 }
    $minEvidenceItems = if ($coverage -and $coverage.min_evidence_items -ne $null) { [int]$coverage.min_evidence_items } else { 3 }
    $maxRetrieveRounds = if ($coverage -and $coverage.max_retrieve_rounds -ne $null) { [int]$coverage.max_retrieve_rounds } else { 2 }
    $requeryOnLowCoverage = if ($coverage -and $coverage.requery_on_low_coverage -ne $null) { [bool]$coverage.requery_on_low_coverage } else { $true }

    $predictedSourceHits = [int]$sourcePlan.source_count
    $predictedEvidenceItems = [int]($maxQueryVariants * [Math]::Max(1, $predictedSourceHits))
    $sourceCoverage = if ($minSourcesHit -gt 0) {
        [Math]::Min(1.0, ([double]$predictedSourceHits / [double]$minSourcesHit))
    } else {
        1.0
    }
    $evidenceCoverage = if ($minEvidenceItems -gt 0) {
        [Math]::Min(1.0, ([double]$predictedEvidenceItems / [double]$minEvidenceItems))
    } else {
        1.0
    }
    $coverageScore = [Math]::Round(([double]$sourceCoverage * 0.55) + ([double]$evidenceCoverage * 0.45), 4)
    $lowCoverage = ($coverageScore -lt 0.65)
    $needsRequery = [bool]($requeryOnLowCoverage -and ($lowCoverage -or [bool]$profileChoice.ambiguous))

    $candidatePool = @()
    if ($SelectedSkill) { $candidatePool += [string]$SelectedSkill }
    if ($PackCandidates) { $candidatePool += @($PackCandidates | ForEach-Object { [string]$_ }) }
    $candidatePool = @($candidatePool | Where-Object { $_ } | Select-Object -Unique)

    $recommendedSkill = $null
    $profileRecommendedSkills = @($selectedProfile.recommended_skills)
    if ($profileRecommendedSkills.Count -gt 0 -and $candidatePool.Count -gt 0) {
        foreach ($skill in @($profileRecommendedSkills)) {
            if ($candidatePool -contains [string]$skill) {
                $recommendedSkill = [string]$skill
                break
            }
        }
    }
    if (-not $recommendedSkill -and $profileRecommendedSkills.Count -gt 0) {
        $recommendedSkill = [string]$profileRecommendedSkills[0]
    }
    if (-not $recommendedSkill -and $SelectedSkill) {
        $recommendedSkill = [string]$SelectedSkill
    }

    $recommendedPacks = @($selectedProfile.recommended_packs)
    $selectedPackInProfile = if ($SelectedPackId -and $recommendedPacks.Count -gt 0) {
        ($recommendedPacks -contains [string]$SelectedPackId)
    } else {
        $true
    }

    $enforcementPolicy = if ($RetrievalPolicy.enforcement) { $RetrievalPolicy.enforcement } else { $null }
    $strictConfirmOnLowCoverage = if ($enforcementPolicy -and $enforcementPolicy.strict_confirm_on_low_coverage -ne $null) { [bool]$enforcementPolicy.strict_confirm_on_low_coverage } else { $true }
    $strictConfirmOnAmbiguousProfile = if ($enforcementPolicy -and $enforcementPolicy.strict_confirm_on_ambiguous_profile -ne $null) { [bool]$enforcementPolicy.strict_confirm_on_ambiguous_profile } else { $true }

    $confirmRecommended = [bool]($profileChoice.ambiguous -or $needsRequery -or (-not $selectedPackInProfile))
    $confirmRequired = $false
    $enforcement = "advisory"
    $reason = "retrieval_scope_match"

    switch ($mode) {
        "shadow" {
            $enforcement = "advisory"
            $reason = if ($confirmRecommended) { "shadow_retrieval_confirm_recommended" } else { "shadow_retrieval_advisory" }
        }
        "soft" {
            $enforcement = "advisory"
            $reason = if ($confirmRecommended) { "soft_retrieval_confirm_recommended" } else { "soft_retrieval_advisory" }
        }
        "strict" {
            $mustConfirm = ($strictConfirmOnLowCoverage -and $needsRequery) -or ($strictConfirmOnAmbiguousProfile -and [bool]$profileChoice.ambiguous)
            if ($mustConfirm) {
                $confirmRequired = $true
                $enforcement = "confirm_required"
                $reason = "strict_retrieval_confirm_required"
            } else {
                $enforcement = "advisory"
                $reason = "strict_retrieval_advisory"
            }
        }
        default {
            $enforcement = "advisory"
            $reason = "retrieval_scope_match"
        }
    }

    $profileConfidence = [double]$profileChoice.selected_score
    $confidence = [Math]::Round((($profileConfidence * 0.6) + ($coverageScore * 0.4)), 4)

    return [pscustomobject]@{
        enabled = $true
        mode = $mode
        task_applicable = [bool]$taskApplicable
        grade_applicable = [bool]$gradeApplicable
        route_mode_applicable = [bool]$routeModeApplicable
        scope_applicable = $true
        enforcement = $enforcement
        reason = $reason
        profile_id = if ($selectedProfile) { [string]$selectedProfile.id } else { "none" }
        profile_confidence = [Math]::Round($profileConfidence, 4)
        profile_top_gap = [double]$profileChoice.top_gap
        profile_ambiguous = [bool]$profileChoice.ambiguous
        profile_min_confidence = [Math]::Round([double]$minProfileConfidence, 4)
        profile_ranking = @($profileChoice.ranking)
        profile_matched_positive_keywords = @($selectedPositiveHits)
        profile_matched_negative_keywords = @($selectedNegativeHits)
        query_plan = [pscustomobject]@{
            max_query_variants = [int]$maxQueryVariants
            decomposition_strategy = if ($selectedProfile -and $selectedProfile.decomposition_strategy) { [string]$selectedProfile.decomposition_strategy } else { "single_query" }
            templates_selected = @($selectedTemplates)
            query_expansion_terms = @($expansionTerms)
        }
        source_plan = [pscustomobject]@{
            preferred_source_ids = @($sourcePlan.preferred_source_ids)
            sources = @($sourcePlan.sources)
            source_count = [int]$sourcePlan.source_count
        }
        rerank_plan = $rerankPlan
        coverage_gate = [pscustomobject]@{
            min_sources_hit = [int]$minSourcesHit
            min_evidence_items = [int]$minEvidenceItems
            max_retrieve_rounds = [int]$maxRetrieveRounds
            predicted_source_hits = [int]$predictedSourceHits
            predicted_evidence_items = [int]$predictedEvidenceItems
            coverage_score = [double]$coverageScore
            needs_requery = [bool]$needsRequery
        }
        coverage_score = [double]$coverageScore
        needs_requery = [bool]$needsRequery
        recommended_packs = @($recommendedPacks)
        selected_pack_in_profile = [bool]$selectedPackInProfile
        recommended_skill = $recommendedSkill
        confirm_recommended = [bool]$confirmRecommended
        confirm_required = [bool]$confirmRequired
        auto_override = $false
        override_candidate_allowed = $false
        route_override_applied = $false
        confidence = [double]$confidence
    }
}
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