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/verify/lib/VibeOfflineSkillsAudit.ps1

View on GitHub
Set-StrictMode -Version Latest

function Assert-VibeOfflineTrue {
    param(
        [bool]$Condition,
        [string]$Message
    )

    if ($Condition) {
        Write-Host "[PASS] $Message"
        return $true
    }

    Write-Host "[FAIL] $Message" -ForegroundColor Red
    return $false
}

function New-VibeOfflineCaseInsensitiveSet {
    return New-Object 'System.Collections.Generic.HashSet[string]' ([System.StringComparer]::OrdinalIgnoreCase)
}

function Read-VibeOfflineJsonUtf8 {
    param(
        [Parameter(Mandatory = $true)]
        [string]$Path
    )

    return ([System.IO.File]::ReadAllText($Path, [System.Text.Encoding]::UTF8) | ConvertFrom-Json)
}

function Resolve-VibeOfflineAuditPaths {
    param(
        [Parameter(Mandatory = $true)]
        [string]$ScriptRoot,
        [string]$SkillsRoot = "",
        [string]$RuntimeCorePackagingPath = "",
        [string]$SkillsLockPath = ""
    )

    $repoRoot = (Resolve-Path (Join-Path $ScriptRoot "..\..")).Path
    if ([string]::IsNullOrWhiteSpace($SkillsRoot)) {
        $SkillsRoot = Join-Path $repoRoot "skills"
    }
    if ([string]::IsNullOrWhiteSpace($RuntimeCorePackagingPath)) {
        $RuntimeCorePackagingPath = Join-Path $repoRoot "config\runtime-core-packaging.json"
    }
    if ([string]::IsNullOrWhiteSpace($SkillsLockPath)) {
        $SkillsLockPath = Join-Path $repoRoot "config\skills-lock.json"
    }

    return [pscustomobject]@{
        repo_root                  = $repoRoot
        skills_root                = $SkillsRoot
        runtime_core_packaging_path = $RuntimeCorePackagingPath
        skills_lock_path           = $SkillsLockPath
    }
}

function Resolve-VibeOfflineSkillsLockState {
    param(
        [Parameter(Mandatory = $true)]
        [string]$SkillsLockPath,
        [switch]$RequireSkillsLock
    )

    if (Test-Path -LiteralPath $SkillsLockPath) {
        return [pscustomobject]@{
            available = $true
            path      = $SkillsLockPath
            reason    = ""
        }
    }

    $reason = "skills-lock audit requires a generated lock file; run scripts/verify/vibe-generate-skills-lock.ps1 or pass -SkillsLockPath."
    if ($RequireSkillsLock) {
        throw "Skills lock not found: $SkillsLockPath. $reason"
    }

    return [pscustomobject]@{
        available = $false
        path      = $SkillsLockPath
        reason    = $reason
    }
}

function Get-VibeOfflineBytesHash {
    param(
        [Parameter(Mandatory = $true)]
        [AllowEmptyCollection()]
        [byte[]]$Bytes
    )

    $stream = [System.IO.MemoryStream]::new($Bytes)
    try {
        return (Get-FileHash -InputStream $stream -Algorithm SHA256).Hash.ToLowerInvariant()
    } finally {
        $stream.Dispose()
    }
}

function Test-VibeOfflineTextLikeFile {
    param(
        [Parameter(Mandatory = $true)]
        [string]$Path,
        [Parameter(Mandatory = $true)]
        [AllowEmptyCollection()]
        [byte[]]$Bytes
    )

    $textExtensions = @(
        ".md", ".txt", ".json", ".ps1", ".psm1", ".sh",
        ".yml", ".yaml", ".toml", ".ini", ".cfg", ".xml",
        ".csv", ".tsv", ".js", ".ts", ".jsx", ".tsx",
        ".py", ".rb", ".go", ".rs", ".java", ".c", ".cpp", ".h", ".hpp",
        ".css", ".html", ".htm", ".sql"
    )

    $extension = [System.IO.Path]::GetExtension($Path).ToLowerInvariant()
    if ($textExtensions -contains $extension) {
        return $true
    }

    return -not ($Bytes -contains 0)
}

function Get-VibeOfflineNormalizedFileHash {
    param(
        [Parameter(Mandatory = $true)]
        [string]$Path
    )

    $rawBytes = [System.IO.File]::ReadAllBytes($Path)
    if (-not (Test-VibeOfflineTextLikeFile -Path $Path -Bytes $rawBytes)) {
        return Get-VibeOfflineBytesHash -Bytes $rawBytes
    }

    $text = [System.Text.Encoding]::UTF8.GetString($rawBytes)
    $normalized = $text.Replace("`r`n", "`n").Replace("`r", "`n")
    return Get-VibeOfflineBytesHash -Bytes ([System.Text.Encoding]::UTF8.GetBytes($normalized))
}

function Get-VibeOfflineSkillDirHash {
    param(
        [Parameter(Mandatory = $true)]
        [string]$DirPath
    )

    $files = @(Get-ChildItem -LiteralPath $DirPath -Recurse -File | Sort-Object FullName)
    $entries = New-Object System.Collections.Generic.List[string]
    $totalBytes = 0

    foreach ($file in $files) {
        $relative = $file.FullName.Substring($DirPath.Length + 1).Replace('\', '/')
        if (
            $relative.Equals("config/skills-lock.json", [System.StringComparison]::OrdinalIgnoreCase) -or
            $relative.EndsWith("/config/skills-lock.json", [System.StringComparison]::OrdinalIgnoreCase)
        ) {
            continue
        }

        $entries.Add(("{0}:{1}" -f $relative, (Get-VibeOfflineNormalizedFileHash -Path $file.FullName)))
        $totalBytes += $file.Length
    }

    $dirHash = Get-VibeOfflineBytesHash -Bytes ([System.Text.Encoding]::UTF8.GetBytes([string]::Join("`n", $entries)))
    return [pscustomobject]@{
        dir_hash   = $dirHash
        file_count = $files.Count
        bytes      = $totalBytes
    }
}

function Get-VibeOfflineCanonicalSkillMap {
    param(
        [Parameter(Mandatory = $true)]
        [string]$RepoRoot
    )

    $map = @{}
    $coreSkillsRoot = Join-Path $RepoRoot "core\skills"
    if (-not (Test-Path -LiteralPath $coreSkillsRoot)) {
        return $map
    }

    foreach ($dir in @(Get-ChildItem -LiteralPath $coreSkillsRoot -Force -Directory | Sort-Object Name)) {
        $skillJsonPath = Join-Path $dir.FullName "skill.json"
        if (-not (Test-Path -LiteralPath $skillJsonPath)) {
            continue
        }

        $skillJson = Read-VibeOfflineJsonUtf8 -Path $skillJsonPath
        $source = if ($skillJson.PSObject.Properties.Name -contains "source_of_truth") { $skillJson.source_of_truth } else { $null }
        $sourceKind = if ($null -ne $source -and $source.PSObject.Properties.Name -contains "kind") { [string]$source.kind } else { "" }
        $sourcePathSpec = if ($null -ne $source -and $source.PSObject.Properties.Name -contains "path") { [string]$source.path } else { "" }
        $skillId = if ($skillJson.PSObject.Properties.Name -contains "skill_id") { [string]$skillJson.skill_id } else { [string]$dir.Name }

        if ($sourceKind -ne "canonical-skill" -or [string]::IsNullOrWhiteSpace($skillId) -or [string]::IsNullOrWhiteSpace($sourcePathSpec)) {
            continue
        }

        $resolvedSourcePath = Join-Path $RepoRoot ($sourcePathSpec.Replace("/", [System.IO.Path]::DirectorySeparatorChar))
        $skillDirectory = $resolvedSourcePath
        $skillMd = $resolvedSourcePath
        if (Test-Path -LiteralPath $resolvedSourcePath -PathType Leaf) {
            $skillDirectory = Split-Path -Parent $resolvedSourcePath
            $skillMd = $resolvedSourcePath
        } else {
            $leafName = [System.IO.Path]::GetFileName($resolvedSourcePath)
            if ($leafName.Equals("SKILL.md", [System.StringComparison]::OrdinalIgnoreCase)) {
                $skillDirectory = Split-Path -Parent $resolvedSourcePath
                $skillMd = $resolvedSourcePath
            } else {
                $skillDirectory = $resolvedSourcePath
                $skillMd = Join-Path $skillDirectory "SKILL.md"
            }
        }

        $map[$skillId] = [pscustomobject]@{
            skill_id  = $skillId
            directory = $skillDirectory
            skill_md  = $skillMd
        }
    }

    return $map
}

function Get-VibeOfflineCanonicalVibeSkillName {
    param(
        [Parameter(Mandatory = $true)]
        [object]$Packaging
    )

    $canonicalPayload = $Packaging.canonical_vibe_payload
    $targetRelpath = "skills/vibe"
    if ($null -ne $canonicalPayload -and $canonicalPayload.PSObject.Properties.Name -contains "target_relpath") {
        $candidate = [string]$canonicalPayload.target_relpath
        if (-not [string]::IsNullOrWhiteSpace($candidate)) {
            $targetRelpath = $candidate
        }
    }

    return [System.IO.Path]::GetFileName($targetRelpath)
}

function Get-VibeOfflineManagedSkillSet {
    param(
        [Parameter(Mandatory = $true)]
        [object]$Packaging
    )

    $managedSet = New-VibeOfflineCaseInsensitiveSet
    $canonicalVibe = Get-VibeOfflineCanonicalVibeSkillName -Packaging $Packaging
    if (-not [string]::IsNullOrWhiteSpace($canonicalVibe)) {
        [void]$managedSet.Add($canonicalVibe)
    }

    $inventory = $null
    if ($Packaging.PSObject.Properties.Name -contains "managed_skill_inventory") {
        $inventory = $Packaging.managed_skill_inventory
    }

    if ($null -eq $inventory -or $null -eq $inventory.public_entry_skills) {
        $defaultProfile = ""
        if ($Packaging.PSObject.Properties.Name -contains "default_profile") {
            $defaultProfile = [string]$Packaging.default_profile
        }
        if (
            -not [string]::IsNullOrWhiteSpace($defaultProfile) -and
            $Packaging.PSObject.Properties.Name -contains "profiles" -and
            $Packaging.profiles.PSObject.Properties.Name -contains $defaultProfile
        ) {
            $selectedProfile = $Packaging.profiles.$defaultProfile
            if ($null -ne $selectedProfile -and $selectedProfile.PSObject.Properties.Name -contains "managed_skill_inventory") {
                $inventory = $selectedProfile.managed_skill_inventory
            }
        }
    }

    if ($null -eq $inventory) {
        throw "Runtime-core packaging manifest missing managed_skill_inventory contract."
    }

    foreach ($field in @("public_entry_skills", "starter_skill_names", "optional_skill_names")) {
        if ($inventory.PSObject.Properties.Name -notcontains $field) {
            continue
        }
        foreach ($name in @($inventory.$field)) {
            $candidate = [string]$name
            if (-not [string]::IsNullOrWhiteSpace($candidate)) {
                [void]$managedSet.Add($candidate)
            }
        }
    }

    Write-Output -NoEnumerate $managedSet
}

function Get-VibeOfflinePresentSkillSet {
    param(
        [Parameter(Mandatory = $true)]
        [string]$SkillsRoot
    )

    $presentSet = New-VibeOfflineCaseInsensitiveSet
    foreach ($name in @(Get-ChildItem -LiteralPath $SkillsRoot -Force -Directory | Select-Object -ExpandProperty Name)) {
        [void]$presentSet.Add([string]$name)
    }
    Write-Output -NoEnumerate $presentSet
}

function Get-VibeOfflineLockIndex {
    param(
        [Parameter(Mandatory = $true)]
        [string]$SkillsLockPath
    )

    $lock = Read-VibeOfflineJsonUtf8 -Path $SkillsLockPath
    $lockSet = New-VibeOfflineCaseInsensitiveSet
    $lockMap = @{}
    foreach ($item in @($lock.skills)) {
        $name = [string]$item.name
        if ([string]::IsNullOrWhiteSpace($name)) {
            continue
        }
        [void]$lockSet.Add($name)
        $lockMap[$name] = $item
    }

    return [pscustomobject]@{
        lock     = $lock
        lock_set = $lockSet
        lock_map = $lockMap
    }
}

function New-VibeOfflineSuiteSummary {
    param(
        [Parameter(Mandatory = $true)]
        [string]$Title,
        [Parameter(Mandatory = $true)]
        [AllowEmptyCollection()]
        [bool[]]$Assertions
    )

    $passed = @($Assertions | Where-Object { $_ }).Count
    $failed = @($Assertions | Where-Object { -not $_ }).Count

    Write-Host ""
    Write-Host ("=== {0} Summary ===" -f $Title)
    Write-Host ("Total assertions: {0}" -f $Assertions.Count)
    Write-Host ("Passed: {0}" -f $passed)
    Write-Host ("Failed: {0}" -f $failed)

    return [pscustomobject]@{
        title       = $Title
        total       = $Assertions.Count
        passed      = $passed
        failed      = $failed
        skipped     = $false
        skip_reason = ""
        gate_passed = ($failed -eq 0)
    }
}

function New-VibeOfflineSkippedSuiteSummary {
    param(
        [Parameter(Mandatory = $true)]
        [string]$Title,
        [Parameter(Mandatory = $true)]
        [string]$Reason
    )

    Write-Host ""
    Write-Host ("=== {0} Summary ===" -f $Title)
    Write-Host "Total assertions: 0"
    Write-Host "Passed: 0"
    Write-Host "Failed: 0"
    Write-Host ("Skipped: {0}" -f $Reason)

    return [pscustomobject]@{
        title       = $Title
        total       = 0
        passed      = 0
        failed      = 0
        skipped     = $true
        skip_reason = $Reason
        gate_passed = $true
    }
}
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