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/19-custom-admission.ps1

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

$customAdmissionHelperPath = Join-Path (Split-Path $PSScriptRoot -Parent) '..\common\vibe-governance-helpers.ps1'
if (-not (Get-Command Resolve-VgoTargetRoot -ErrorAction SilentlyContinue) -and (Test-Path -LiteralPath $customAdmissionHelperPath)) {
    . $customAdmissionHelperPath
}

function Resolve-CustomAdmissionTargetRoot {
    param(
        [AllowEmptyString()] [string]$TargetRoot = '',
        [AllowEmptyString()] [string]$HostId = ''
    )

    try {
        return Resolve-VgoTargetRoot -TargetRoot $TargetRoot -HostId $HostId
    } catch {
        return $null
    }
}

function Test-CustomAdmissionPathWithin {
    param(
        [Parameter(Mandatory)] [string]$BasePath,
        [Parameter(Mandatory)] [string]$CandidatePath
    )

    try {
        $baseFull = [System.IO.Path]::GetFullPath($BasePath)
        $candidateFull = [System.IO.Path]::GetFullPath($CandidatePath)
    } catch {
        return $false
    }

    if (-not $baseFull.EndsWith([System.IO.Path]::DirectorySeparatorChar)) {
        $baseFull += [System.IO.Path]::DirectorySeparatorChar
    }

    return $candidateFull.StartsWith($baseFull, [System.StringComparison]::OrdinalIgnoreCase)
}

function Resolve-CustomAdmissionSkillMdPath {
    param(
        [Parameter(Mandatory)] [string]$TargetRoot,
        [Parameter(Mandatory)] [string]$RelativePath
    )

    $rawPath = [System.IO.Path]::GetFullPath((Join-Path $TargetRoot $RelativePath))
    if (-not (Test-CustomAdmissionPathWithin -BasePath $TargetRoot -CandidatePath $rawPath)) {
        return $null
    }
    if ([System.IO.Path]::GetExtension($rawPath).ToLowerInvariant() -eq '.md') {
        return $rawPath
    }
    return [System.IO.Path]::GetFullPath((Join-Path $rawPath 'SKILL.md'))
}

function Get-CustomAdmissionDescription {
    param(
        [AllowEmptyString()] [string]$SkillMdPath = ''
    )

    if ([string]::IsNullOrWhiteSpace($SkillMdPath) -or -not (Test-Path -LiteralPath $SkillMdPath)) {
        return $null
    }

    $lines = @()
    try {
        $lines = Get-Content -LiteralPath $SkillMdPath -Encoding UTF8 -TotalCount 20
    } catch {
        return $null
    }

    if (-not $lines -or $lines.Count -lt 3 -or [string]$lines[0] -ne '---') {
        return $null
    }

    foreach ($line in @($lines | Select-Object -Skip 1)) {
        $trimmed = [string]$line
        if ($trimmed -eq '---') {
            break
        }
        if ($trimmed -match '^\s*description:\s*(.+?)\s*$') {
            return $Matches[1].Trim()
        }
    }

    return $null
}

function Resolve-CustomAdmissionDependencyPath {
    param(
        [Parameter(Mandatory)] [string]$RepoRoot,
        [Parameter(Mandatory)] [string]$TargetRoot,
        [Parameter(Mandatory)] [string]$SkillId
    )

    $normalizedSkillId = Normalize-Key -InputText $SkillId
    $candidates = @(
        (Join-Path $TargetRoot (Join-Path 'skills' (Join-Path $SkillId 'SKILL.md'))),
        (Join-Path $TargetRoot (Join-Path 'skills' (Join-Path 'custom' (Join-Path $SkillId 'SKILL.md'))))
    )
    if ($normalizedSkillId -eq 'vibe') {
        $candidates += (Join-Path $RepoRoot 'SKILL.md')
    }
    foreach ($candidate in $candidates) {
        if (Test-Path -LiteralPath $candidate) {
            return [System.IO.Path]::GetFullPath($candidate)
        }
    }
    return $null
}

function Get-CustomAdmissionTaskAllow {
    param(
        [AllowNull()] [object]$Entry
    )

    $standard = @('planning', 'coding', 'review', 'debug', 'research')
    if ($Entry -and $Entry.PSObject.Properties.Name -contains 'task_allow' -and $null -ne $Entry.task_allow) {
        $explicit = @($Entry.task_allow | ForEach-Object { Normalize-Key -InputText ([string]$_) } | Where-Object { $_ -in $standard } | Select-Object -Unique)
        if (@($explicit).Count -gt 0) {
            return @($explicit)
        }
    }

    $intentTags = if ($Entry -and $Entry.PSObject.Properties.Name -contains 'intent_tags' -and $null -ne $Entry.intent_tags) {
        @($Entry.intent_tags | ForEach-Object { Normalize-Key -InputText ([string]$_) } | Select-Object -Unique)
    } else {
        @()
    }

    $derived = @($standard | Where-Object { $intentTags -contains $_ })
    if (@($derived).Count -gt 0) {
        return @($derived)
    }

    return @($standard)
}

function Get-CustomAdmissionDispatchPhase {
    param(
        [AllowNull()] [object[]]$PreferredStages = @()
    )

    $mapping = @{
        skeleton_check = 'pre_execution'
        deep_interview = 'pre_execution'
        requirement_doc = 'pre_execution'
        xl_plan = 'pre_execution'
        plan_execute = 'in_execution'
        phase_cleanup = 'post_execution'
        pre_execution = 'pre_execution'
        in_execution = 'in_execution'
        post_execution = 'post_execution'
        verification = 'verification'
    }

    foreach ($stage in @($PreferredStages)) {
        $normalized = Normalize-Key -InputText ([string]$stage)
        if ($mapping.ContainsKey($normalized)) {
            return [string]$mapping[$normalized]
        }
    }

    return 'in_execution'
}

function Test-CustomAdmissionRouteUsable {
    param(
        [Parameter(Mandatory)] [string]$TriggerMode,
        [AllowEmptyString()] [string]$RequestedCanonical = '',
        [Parameter(Mandatory)] [string]$SkillId
    )

    if ($TriggerMode -eq 'auto') {
        return $true
    }

    if (-not [string]::IsNullOrWhiteSpace($RequestedCanonical) -and
        [string]::Equals((Normalize-Key -InputText $RequestedCanonical), (Normalize-Key -InputText $SkillId), [System.StringComparison]::OrdinalIgnoreCase)) {
        return $true
    }

    return $false
}

function ConvertTo-CustomAdmissionCandidate {
    param(
        [Parameter(Mandatory)] [string]$RepoRoot,
        [Parameter(Mandatory)] [string]$TargetRoot,
        [Parameter(Mandatory)] [string]$ManifestKind,
        [Parameter(Mandatory)] [object]$Entry,
        [AllowEmptyString()] [string]$RequestedCanonical = ''
    )

    $skillId = Normalize-Key -InputText ([string]$Entry.id)
    $relativePath = [string]$Entry.path
    $keywords = @($Entry.keywords | ForEach-Object { [string]$_ } | Where-Object { -not [string]::IsNullOrWhiteSpace($_) } | Select-Object -Unique)
    $intentTags = @($Entry.intent_tags | ForEach-Object { Normalize-Key -InputText ([string]$_) } | Where-Object { -not [string]::IsNullOrWhiteSpace($_) } | Select-Object -Unique)
    $nonGoals = @($Entry.non_goals | ForEach-Object { Normalize-Key -InputText ([string]$_) } | Where-Object { -not [string]::IsNullOrWhiteSpace($_) } | Select-Object -Unique)
    $requires = @($Entry.requires | ForEach-Object { Normalize-Key -InputText ([string]$_) } | Where-Object { -not [string]::IsNullOrWhiteSpace($_) } | Select-Object -Unique)

    $missingFields = @()
    if ([string]::IsNullOrWhiteSpace($skillId)) { $missingFields += 'id' }
    if ([string]::IsNullOrWhiteSpace($relativePath)) { $missingFields += 'path' }
    if (@($keywords).Count -eq 0) { $missingFields += 'keywords' }
    if (@($intentTags).Count -eq 0) { $missingFields += 'intent_tags' }
    if (@($nonGoals).Count -eq 0) { $missingFields += 'non_goals' }
    if (@($requires).Count -eq 0) { $missingFields += 'requires' }
    if (@($missingFields).Count -gt 0) {
        return [pscustomobject]@{
            admitted = $false
            failure = [pscustomobject]@{
                manifest_kind = $ManifestKind
                entry_id = if ($skillId) { $skillId } else { $null }
                reason = 'missing_required_fields'
                missing_fields = @($missingFields)
            }
        }
    }

    $skillMdPath = Resolve-CustomAdmissionSkillMdPath -TargetRoot $TargetRoot -RelativePath $relativePath
    if ([string]::IsNullOrWhiteSpace($skillMdPath)) {
        return [pscustomobject]@{
            admitted = $false
            failure = [pscustomobject]@{
                manifest_kind = $ManifestKind
                entry_id = $skillId
                reason = 'path_outside_target_root'
                path = $relativePath
            }
        }
    }
    if (-not (Test-Path -LiteralPath $skillMdPath)) {
        return [pscustomobject]@{
            admitted = $false
            failure = [pscustomobject]@{
                manifest_kind = $ManifestKind
                entry_id = $skillId
                reason = 'skill_md_missing'
                path = $relativePath
                skill_md_path = $skillMdPath
            }
        }
    }

    $missingDependencies = @()
    foreach ($dependency in @($requires)) {
        if (-not (Resolve-CustomAdmissionDependencyPath -RepoRoot $RepoRoot -TargetRoot $TargetRoot -SkillId $dependency)) {
            $missingDependencies += $dependency
        }
    }
    if (@($missingDependencies).Count -gt 0) {
        return [pscustomobject]@{
            admitted = $false
            failure = [pscustomobject]@{
                manifest_kind = $ManifestKind
                entry_id = $skillId
                reason = 'custom_dependencies_missing'
                missing_dependencies = @($missingDependencies)
            }
        }
    }

    $triggerMode = Normalize-Key -InputText ([string]$Entry.trigger_mode)
    if ($triggerMode -notin @('explicit_only', 'advisory', 'auto')) {
        $triggerMode = 'advisory'
    }
    $priority = 60
    if ($Entry.PSObject.Properties.Name -contains 'priority' -and $null -ne $Entry.priority) {
        try {
            $priority = [Math]::Max(0, [Math]::Min(89, [int]$Entry.priority))
        } catch {
            $priority = 60
        }
    }
    $preferredStages = @($Entry.preferred_stages | ForEach-Object { Normalize-Key -InputText ([string]$_) } | Where-Object { -not [string]::IsNullOrWhiteSpace($_) } | Select-Object -Unique)
    $taskAllow = Get-CustomAdmissionTaskAllow -Entry $Entry
    $dispatchPhase = Get-CustomAdmissionDispatchPhase -PreferredStages @($preferredStages)
    $description = Get-CustomAdmissionDescription -SkillMdPath $skillMdPath
    $routeUsable = Test-CustomAdmissionRouteUsable -TriggerMode $triggerMode -RequestedCanonical $RequestedCanonical -SkillId $skillId

    $customSummary = [pscustomobject]@{
        skill_id = $skillId
        manifest_kind = $ManifestKind
        pack_id = "custom-$ManifestKind-$skillId"
        trigger_mode = $triggerMode
        dispatch_phase = $dispatchPhase
        binding_profile = $ManifestKind
        lane_policy = 'agent_module_handoff'
        parallelizable_in_root_xl = [bool]($Entry.PSObject.Properties.Name -contains 'parallelizable_in_root_xl' -and $Entry.parallelizable_in_root_xl)
        must_preserve_workflow = $true
        _route_usable = [bool]$routeUsable
        skill_md_path = $skillMdPath
        description = $description
    }

    $candidate = [pscustomobject]@{
        skill_id = $skillId
        manifest_kind = $ManifestKind
        pack_id = "custom-$ManifestKind-$skillId"
        path = $relativePath
        skill_md_path = $skillMdPath
        description = $description
        enabled = $true
        trigger_mode = $triggerMode
        priority = $priority
        keywords = @($keywords)
        intent_tags = @($intentTags)
        non_goals = @($nonGoals)
        requires = @($requires)
        task_allow = @($taskAllow)
        preferred_stages = @($preferredStages)
        dispatch_phase = $dispatchPhase
        binding_profile = $ManifestKind
        lane_policy = 'agent_module_handoff'
        parallelizable_in_root_xl = [bool]($Entry.PSObject.Properties.Name -contains 'parallelizable_in_root_xl' -and $Entry.parallelizable_in_root_xl)
        must_preserve_workflow = $true
        _route_usable = [bool]$routeUsable
        pack = [pscustomobject]@{
            id = "custom-$ManifestKind-$skillId"
            priority = $priority
            grade_allow = @('M', 'L', 'XL')
            task_allow = @($taskAllow)
            trigger_keywords = @($keywords)
            skill_candidates = @($skillId)
            defaults_by_task = [pscustomobject]@{}
            custom_admission = $null
        }
    }

    foreach ($task in @($taskAllow)) {
        $candidate.pack.defaults_by_task | Add-Member -NotePropertyName $task -NotePropertyValue $skillId
    }
    $candidate.pack.custom_admission = $customSummary

    return [pscustomobject]@{
        admitted = $true
        candidate = $candidate
        failure = $null
    }
}

function Get-CustomAdmissionResult {
    param(
        [Parameter(Mandatory)] [string]$RepoRoot,
        [AllowEmptyString()] [string]$TargetRoot = '',
        [AllowEmptyString()] [string]$HostId = '',
        [AllowEmptyString()] [string]$RequestedCanonical = ''
    )

    $resolvedTargetRoot = Resolve-CustomAdmissionTargetRoot -TargetRoot $TargetRoot -HostId $HostId
    $result = [ordered]@{
        enabled = -not [string]::IsNullOrWhiteSpace($resolvedTargetRoot)
        target_root = $resolvedTargetRoot
        manifest_paths = [pscustomobject]@{}
        manifests_present = [pscustomobject]@{}
        invalid_entries = @()
        dependency_failures = @()
        admitted_candidates = @()
        admitted_packs = @()
        skill_index = [pscustomobject]@{}
        status = 'target_root_unavailable'
    }

    if ([string]::IsNullOrWhiteSpace($resolvedTargetRoot)) {
        return [pscustomobject]$result
    }

    $manifests = @(
        [pscustomobject]@{ kind = 'workflow'; path = (Join-Path $resolvedTargetRoot 'config\custom-workflows.json'); collection = 'workflows' },
        [pscustomobject]@{ kind = 'skill'; path = (Join-Path $resolvedTargetRoot 'config\custom-skills.json'); collection = 'skills' }
    )

    foreach ($manifest in $manifests) {
        $result.manifest_paths | Add-Member -NotePropertyName $manifest.kind -NotePropertyValue ([System.IO.Path]::GetFullPath($manifest.path))
        $exists = Test-Path -LiteralPath $manifest.path
        $result.manifests_present | Add-Member -NotePropertyName $manifest.kind -NotePropertyValue ([bool]$exists)
        if (-not $exists) {
            continue
        }

        $json = $null
        try {
            $json = Get-Content -LiteralPath $manifest.path -Raw -Encoding UTF8 | ConvertFrom-Json
        } catch {
            $result.invalid_entries += [pscustomobject]@{
                manifest_kind = $manifest.kind
                entry_id = $null
                reason = 'manifest_parse_error'
                message = $_.Exception.Message
            }
            continue
        }

        $rows = if ($json.PSObject.Properties.Name -contains $manifest.collection) { @($json.$($manifest.collection)) } else { $null }
        if ($null -eq $rows) {
            $result.invalid_entries += [pscustomobject]@{
                manifest_kind = $manifest.kind
                entry_id = $null
                reason = 'manifest_missing_collection'
                expected_key = [string]$manifest.collection
            }
            continue
        }

        foreach ($entry in @($rows)) {
            if ($null -eq $entry) { continue }
            $enabled = $true
            if ($entry.PSObject.Properties.Name -contains 'enabled' -and $null -ne $entry.enabled) {
                $enabled = [bool]$entry.enabled
            }
            if (-not $enabled) { continue }

            $conversion = ConvertTo-CustomAdmissionCandidate `
                -RepoRoot $RepoRoot `
                -TargetRoot $resolvedTargetRoot `
                -ManifestKind ([string]$manifest.kind) `
                -Entry $entry `
                -RequestedCanonical $RequestedCanonical
            if (-not [bool]$conversion.admitted) {
                if ($conversion.failure.reason -eq 'custom_dependencies_missing') {
                    $result.dependency_failures += $conversion.failure
                } else {
                    $result.invalid_entries += $conversion.failure
                }
                continue
            }

            $candidate = $conversion.candidate
            $result.admitted_candidates += $candidate
            $result.admitted_packs += $candidate.pack
            $result.skill_index | Add-Member -NotePropertyName $candidate.skill_id -NotePropertyValue $candidate
        }
    }

    if (@($result.invalid_entries).Count -gt 0) {
        $result.status = 'custom_manifest_invalid'
    } elseif (@($result.dependency_failures).Count -gt 0) {
        $result.status = 'custom_dependencies_missing'
    } elseif (@($result.admitted_candidates).Count -gt 0) {
        $result.status = 'admitted'
    } else {
        $result.status = 'no_custom_manifests'
    }

    return [pscustomobject]$result
}
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