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/common/AntiProxyGoalDrift.ps1

View on GitHub
Set-StrictMode -Version Latest

function Get-VgoAntiProxyGoalDriftPolicy {
    param(
        [Parameter(Mandatory)] [string]$RepoRoot
    )

    $path = Join-Path $RepoRoot 'config\anti-proxy-goal-drift-policy.json'
    if (-not (Test-Path -LiteralPath $path)) {
        throw "Anti-proxy-goal-drift policy missing: $path"
    }

    return (Get-Content -LiteralPath $path -Raw -Encoding UTF8 | ConvertFrom-Json)
}

function Get-VgoTierRank {
    param([AllowNull()] [string]$Tier)

    switch ($Tier) {
        'Tier A' { return 3 }
        'Tier B' { return 2 }
        'Tier C' { return 1 }
        default { return 0 }
    }
}

function Test-VgoValuePresent {
    param([AllowNull()] [object]$Value)

    if ($null -eq $Value) { return $false }
    if ($Value -is [string]) { return (-not [string]::IsNullOrWhiteSpace($Value)) }
    if ($Value -is [System.Collections.IEnumerable] -and -not ($Value -is [string])) {
        return (@($Value).Count -gt 0)
    }
    return $true
}

function Get-VgoMinimumTierForSurface {
    param(
        [Parameter(Mandatory)] [psobject]$Policy,
        [AllowNull()] [string]$SurfaceClass
    )

    if ([string]::IsNullOrWhiteSpace($SurfaceClass)) {
        return $null
    }

    $prop = $Policy.surface_minimum_tiers.PSObject.Properties[$SurfaceClass]
    if ($null -eq $prop) {
        return $null
    }

    return [string]$prop.Value
}

function Get-VgoProofCaseCount {
    param([AllowNull()] [object]$Bundle)

    if ($null -eq $Bundle) { return 0 }
    if ($Bundle.PSObject.Properties.Name -contains 'cases') {
        return @($Bundle.cases).Count
    }
    return 0
}

function Get-VgoRequiredProofCaseCount {
    param(
        [Parameter(Mandatory)] [psobject]$Policy,
        [AllowNull()] [string]$Tier,
        [AllowNull()] [string]$CompletionState
    )

    if ([string]::IsNullOrWhiteSpace($Tier) -or [string]::IsNullOrWhiteSpace($CompletionState)) {
        return 0
    }

    $tierPolicy = $Policy.proof_bundle_minimums.PSObject.Properties[$Tier]
    if ($null -eq $tierPolicy) { return 0 }
    $statePolicy = $tierPolicy.Value.PSObject.Properties[$CompletionState]
    if ($null -eq $statePolicy) { return 0 }
    return [int]$statePolicy.Value
}

function Test-VgoGeneralizedScope {
    param([AllowNull()] [string]$IntendedScope)

    if ([string]::IsNullOrWhiteSpace($IntendedScope)) { return $false }
    $normalized = $IntendedScope.Trim().ToLowerInvariant()
    return @('generalized', 'class_level', 'reusable', 'shared', 'systemic') -contains $normalized
}

function Test-VgoScenarioSpecificScope {
    param([AllowNull()] [string]$IntendedScope)

    if ([string]::IsNullOrWhiteSpace($IntendedScope)) { return $false }
    $normalized = $IntendedScope.Trim().ToLowerInvariant()
    return @('scenario_specific', 'scenario-local', 'scenario_local', 'bounded_local') -contains $normalized
}

function Get-VgoProxySignalTokens {
    param([AllowNull()] [object]$Signals)

    $tokens = @()
    foreach ($signal in @($Signals)) {
        if ([string]::IsNullOrWhiteSpace([string]$signal)) { continue }
        $tokens += ([string]$signal).Trim().ToLowerInvariant()
    }
    return $tokens
}

function Get-VgoAntiProxyGoalDriftAssessment {
    param(
        [Parameter(Mandatory)] [psobject]$Policy,
        [Parameter(Mandatory)] [psobject]$Packet
    )

    $requiredFields = @(
        'surface_class',
        'primary_objective',
        'non_objective_proxy_signals',
        'validation_material_role',
        'anti_proxy_goal_drift_tier',
        'intended_scope',
        'abstraction_layer_target',
        'completion_state',
        'generalization_evidence_bundle'
    )

    $missingFields = New-Object System.Collections.Generic.List[string]
    foreach ($field in $requiredFields) {
        $value = if ($Packet.PSObject.Properties.Name -contains $field) { $Packet.$field } else { $null }
        if (-not (Test-VgoValuePresent -Value $value)) {
            [void]$missingFields.Add($field)
        }
    }

    $declaredTier = if ($Packet.PSObject.Properties.Name -contains 'anti_proxy_goal_drift_tier') { [string]$Packet.anti_proxy_goal_drift_tier } else { $null }
    $surfaceClass = if ($Packet.PSObject.Properties.Name -contains 'surface_class') { [string]$Packet.surface_class } else { $null }
    $completionState = if ($Packet.PSObject.Properties.Name -contains 'completion_state') { [string]$Packet.completion_state } else { $null }
    $intendedScope = if ($Packet.PSObject.Properties.Name -contains 'intended_scope') { [string]$Packet.intended_scope } else { $null }
    $validationMaterialRole = if ($Packet.PSObject.Properties.Name -contains 'validation_material_role') { [string]$Packet.validation_material_role } else { $null }
    $signals = if ($Packet.PSObject.Properties.Name -contains 'non_objective_proxy_signals') { @($Packet.non_objective_proxy_signals) } else { @() }
    $bundle = if ($Packet.PSObject.Properties.Name -contains 'generalization_evidence_bundle') { $Packet.generalization_evidence_bundle } else { $null }

    $minimumTier = Get-VgoMinimumTierForSurface -Policy $Policy -SurfaceClass $surfaceClass
    $declaredTierRank = Get-VgoTierRank -Tier $declaredTier
    $minimumTierRank = Get-VgoTierRank -Tier $minimumTier
    $actualCaseCount = Get-VgoProofCaseCount -Bundle $bundle
    $requiredCaseCount = Get-VgoRequiredProofCaseCount -Policy $Policy -Tier $declaredTier -CompletionState $completionState
    $warningCodes = New-Object System.Collections.Generic.List[string]

    if ($missingFields.Count -gt 0) {
        [void]$warningCodes.Add('missing_required_field')
    }

    if ($minimumTierRank -gt 0 -and $declaredTierRank -gt 0) {
        if ($declaredTierRank -lt $minimumTierRank) {
            [void]$warningCodes.Add('tier_underclassified')
        } elseif ($declaredTierRank -gt $minimumTierRank) {
            [void]$warningCodes.Add('tier_overclassified')
        }
    }

    if ($requiredCaseCount -gt 0 -and $actualCaseCount -lt $requiredCaseCount) {
        [void]$warningCodes.Add('completion_proof_mismatch')
    }

    $isGeneralized = Test-VgoGeneralizedScope -IntendedScope $intendedScope
    if ($isGeneralized -and $completionState -eq 'complete' -and $actualCaseCount -le 1) {
        [void]$warningCodes.Add('generalization_overclaim')
    }

    $signalTokens = @(Get-VgoProxySignalTokens -Signals $signals)
    $containsProxyTemptation = $false
    foreach ($token in $signalTokens) {
        if ($token.Contains('sample') -or $token.Contains('demo') -or $token.Contains('test green') -or $token.Contains('current test') -or $token.Contains('single case')) {
            $containsProxyTemptation = $true
            break
        }
    }

    if ($containsProxyTemptation -and $completionState -eq 'complete' -and ($actualCaseCount -le 1 -or $validationMaterialRole -ne 'validation_only')) {
        [void]$warningCodes.Add('proxy_signal_overclaim')
    }

    $uniqueWarnings = @($warningCodes | Select-Object -Unique)

    return [pscustomobject]@{
        fixture_id = if ($Packet.PSObject.Properties.Name -contains 'fixture_id') { [string]$Packet.fixture_id } else { '' }
        surface_class = $surfaceClass
        declared_tier = $declaredTier
        minimum_tier = $minimumTier
        completion_state = $completionState
        intended_scope = $intendedScope
        validation_material_role = $validationMaterialRole
        missing_fields = @($missingFields)
        proof_case_count = $actualCaseCount
        required_proof_case_count = $requiredCaseCount
        warning_codes = @($uniqueWarnings)
        warning_count = @($uniqueWarnings).Count
        report_only = $true
        generalized_scope = [bool]$isGeneralized
        scenario_specific_scope = [bool](Test-VgoScenarioSpecificScope -IntendedScope $intendedScope)
    }
}

function ConvertFrom-VgoMarkdownValue {
    param([AllowNull()] [string]$Text)

    if ([string]::IsNullOrWhiteSpace($Text)) {
        return ''
    }

    $value = $Text.Trim()
    if ($value.StartsWith('-')) {
        $value = $value.Substring(1).Trim()
    }
    if ($value.StartsWith('`') -and $value.EndsWith('`') -and $value.Length -ge 2) {
        $value = $value.Substring(1, $value.Length - 2)
    }
    if ($value -eq '_author_to_declare_') {
        return ''
    }

    return $value.Trim()
}

function Get-VgoMarkdownSectionMap {
    param([Parameter(Mandatory)] [AllowEmptyCollection()] [AllowEmptyString()] [string[]]$Lines)

    $sections = @{}
    $currentHeading = $null
    $buffer = New-Object System.Collections.Generic.List[string]

    foreach ($line in $Lines) {
        if ($line -match '^##\s+(.+?)\s*$') {
            if ($null -ne $currentHeading) {
                $sections[$currentHeading] = @($buffer)
                $buffer.Clear()
            }
            $currentHeading = $Matches[1].Trim()
            continue
        }

        if ($null -ne $currentHeading) {
            [void]$buffer.Add($line)
        }
    }

    if ($null -ne $currentHeading) {
        $sections[$currentHeading] = @($buffer)
    }

    return $sections
}

function Get-VgoMarkdownSectionScalar {
    param(
        [Parameter(Mandatory)] [hashtable]$Sections,
        [Parameter(Mandatory)] [string]$Heading
    )

    if (-not $Sections.ContainsKey($Heading)) {
        return ''
    }

    foreach ($line in @($Sections[$Heading])) {
        $trimmed = $line.Trim()
        if ([string]::IsNullOrWhiteSpace($trimmed)) { continue }
        if ($trimmed.StartsWith('_')) { continue }
        return (ConvertFrom-VgoMarkdownValue -Text $trimmed)
    }

    return ''
}

function Get-VgoMarkdownSectionList {
    param(
        [Parameter(Mandatory)] [hashtable]$Sections,
        [Parameter(Mandatory)] [string]$Heading
    )

    if (-not $Sections.ContainsKey($Heading)) {
        return @()
    }

    $items = New-Object System.Collections.Generic.List[string]
    foreach ($line in @($Sections[$Heading])) {
        $trimmed = $line.Trim()
        if ([string]::IsNullOrWhiteSpace($trimmed)) { continue }
        if ($trimmed.StartsWith('_')) { continue }
        if ($trimmed.StartsWith('-')) {
            $value = ConvertFrom-VgoMarkdownValue -Text $trimmed
            if (-not [string]::IsNullOrWhiteSpace($value)) {
                [void]$items.Add($value)
            }
        }
    }

    if ($items.Count -gt 0) {
        return @($items)
    }

    $scalar = Get-VgoMarkdownSectionScalar -Sections $Sections -Heading $Heading
    if (-not [string]::IsNullOrWhiteSpace($scalar)) {
        return @($scalar)
    }

    return @()
}

function New-VgoAntiProxyGoalDriftDraft {
    param([AllowNull()] [string]$PrimaryObjective = '')

    $objective = if ([string]::IsNullOrWhiteSpace($PrimaryObjective)) {
        '_author_to_declare_'
    } else {
        $PrimaryObjective.Trim()
    }

    return [pscustomobject]@{
        primary_objective = $objective
        non_objective_proxy_signals = @(
            'single sample pass only',
            'current test green only',
            'demo success only'
        )
        validation_material_role = 'validation_only'
        anti_proxy_goal_drift_tier = 'Tier C'
        intended_scope = 'scenario_specific'
        abstraction_layer_target = '_author_to_declare_'
        completion_state = 'partial'
        generalization_evidence_bundle = @(
            'cases: []',
            'note: add independent evidence before generalized completion claims'
        )
    }
}

function Get-VgoAntiProxyGoalDriftPacketFromRequirementDoc {
    param([Parameter(Mandatory)] [string]$RequirementDocPath)

    if (-not (Test-Path -LiteralPath $RequirementDocPath)) {
        throw "Requirement doc not found: $RequirementDocPath"
    }

    $lines = Get-Content -LiteralPath $RequirementDocPath -Encoding UTF8
    $sections = Get-VgoMarkdownSectionMap -Lines $lines
    $goal = Get-VgoMarkdownSectionScalar -Sections $sections -Heading 'Goal'
    $draft = New-VgoAntiProxyGoalDriftDraft -PrimaryObjective $goal

    $primaryObjective = Get-VgoMarkdownSectionScalar -Sections $sections -Heading 'Primary Objective'
    if (-not [string]::IsNullOrWhiteSpace($primaryObjective)) {
        $draft.primary_objective = $primaryObjective
    }

    $signals = @(Get-VgoMarkdownSectionList -Sections $sections -Heading 'Non-Objective Proxy Signals')
    if ($signals.Count -gt 0) {
        $draft.non_objective_proxy_signals = $signals
    }

    foreach ($pair in @(
            @{ heading = 'Validation Material Role'; property = 'validation_material_role' },
            @{ heading = 'Anti-Proxy-Goal-Drift Tier'; property = 'anti_proxy_goal_drift_tier' },
            @{ heading = 'Intended Scope'; property = 'intended_scope' },
            @{ heading = 'Abstraction Layer Target'; property = 'abstraction_layer_target' },
            @{ heading = 'Completion State'; property = 'completion_state' }
        )) {
        $value = Get-VgoMarkdownSectionScalar -Sections $sections -Heading $pair.heading
        if (-not [string]::IsNullOrWhiteSpace($value)) {
            $draft.($pair.property) = $value
        }
    }

    $bundle = @(Get-VgoMarkdownSectionList -Sections $sections -Heading 'Generalization Evidence Bundle')
    if ($bundle.Count -gt 0) {
        $draft.generalization_evidence_bundle = $bundle
    }

    return $draft
}

function Get-VgoAntiProxyGoalDriftRequirementLines {
    param([Parameter(Mandatory)] [psobject]$Packet)

    $lines = @(
        '## Primary Objective',
        $Packet.primary_objective,
        '',
        '## Non-Objective Proxy Signals'
    )
    $lines += @($Packet.non_objective_proxy_signals | ForEach-Object { "- $_" })
    $lines += @(
        '',
        '## Validation Material Role',
        $Packet.validation_material_role,
        '',
        '## Anti-Proxy-Goal-Drift Tier',
        $Packet.anti_proxy_goal_drift_tier,
        '',
        '## Intended Scope',
        $Packet.intended_scope,
        '',
        '## Abstraction Layer Target',
        $Packet.abstraction_layer_target,
        '',
        '## Completion State',
        $Packet.completion_state,
        '',
        '## Generalization Evidence Bundle'
    )
    $lines += @($Packet.generalization_evidence_bundle | ForEach-Object { "- $_" })
    return $lines
}

function Get-VgoAntiProxyGoalDriftPlanLines {
    param([Parameter(Mandatory)] [psobject]$Packet)

    $lines = @(
        '## Anti-Proxy-Goal-Drift Controls',
        'Prefill from the frozen requirement doc where available. Only diverge with explicit justification.',
        '',
        '### Primary Objective',
        $Packet.primary_objective,
        '',
        '### Non-Objective Proxy Signals'
    )
    $lines += @($Packet.non_objective_proxy_signals | ForEach-Object { "- $_" })
    $lines += @(
        '',
        '### Validation Material Role',
        $Packet.validation_material_role,
        '',
        '### Declared Tier',
        $Packet.anti_proxy_goal_drift_tier,
        '',
        '### Intended Scope',
        $Packet.intended_scope,
        '',
        '### Abstraction Layer Target',
        $Packet.abstraction_layer_target,
        '',
        '### Completion State Target',
        $Packet.completion_state,
        '',
        '### Generalization Evidence Plan',
        '- Reuse the requirement-declared proof boundary as the starting point.'
    )
    $lines += @($Packet.generalization_evidence_bundle | ForEach-Object { "- $_" })
    return $lines
}
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: 323kUpdated Claude CodeCodexVerifiedInstall
requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirementsStars: 323kUpdated 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: 323kUpdated 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: 323kUpdated Claude CodeCodexVerifiedInstall