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/governance/audit-upstream.ps1

View on GitHub
param(
    [string]$OutputDir = "",
    [switch]$CompareInstalled,
    [string]$InstalledPluginsPath = "",
    [switch]$NoNpm,
    [switch]$NoGitHub,
    [int]$MaxRepos = 0,
    [string]$CorpusManifestPath = "",
    [string]$MirrorRoot = "",
    [switch]$WriteJson
)

$ErrorActionPreference = "Stop"
. (Join-Path $PSScriptRoot '..\common\vibe-governance-helpers.ps1')

function Read-JsonFile {
    param([string]$Path)
    if (-not (Test-Path -LiteralPath $Path)) {
        throw "JSON file not found: $Path"
    }
    return Get-Content -LiteralPath $Path -Raw -Encoding UTF8 | ConvertFrom-Json
}

function Write-TextFile {
    param(
        [string]$Path,
        [string]$Content
    )
    New-Item -ItemType Directory -Force -Path (Split-Path -Parent $Path) | Out-Null
    Set-Content -LiteralPath $Path -Value $Content -Encoding UTF8
}

function Normalize-GitHubRepoUrl {
    param([string]$Url)
    if ([string]::IsNullOrWhiteSpace($Url)) { return "" }
    $u = $Url.Trim()
    $u = $u -replace "\.git$", ""
    $u = $u.TrimEnd("/")
    return $u
}

function Parse-GitHubOwnerRepo {
    param([string]$RepoUrl)
    $u = Normalize-GitHubRepoUrl -Url $RepoUrl
    if ($u -notmatch "^https://github\.com/([^/]+)/([^/]+)$") { return $null }
    return [pscustomobject]@{
        owner = $Matches[1]
        repo = $Matches[2]
    }
}

function Get-GitHubHeaders {
    $token = ""
    if ($env:GITHUB_TOKEN) { $token = $env:GITHUB_TOKEN }
    elseif ($env:GH_TOKEN) { $token = $env:GH_TOKEN }

    $headers = @{
        "Accept"               = "application/vnd.github+json"
        "X-GitHub-Api-Version" = "2022-11-28"
        "User-Agent"           = "vco-skills-codex-upstream-audit"
    }
    if (-not [string]::IsNullOrWhiteSpace($token)) {
        $headers["Authorization"] = "Bearer $token"
    }
    return $headers
}

function Try-InvokeRestJson {
    param(
        [string]$Url,
        [hashtable]$Headers = @{}
    )
    try {
        return Invoke-RestMethod -Uri $Url -Headers $Headers -Method Get -ErrorAction Stop
    } catch {
        return $null
    }
}

function To-GitRemoteUrl {
    param([string]$RepoUrl)
    $u = Normalize-GitHubRepoUrl -Url $RepoUrl
    if ([string]::IsNullOrWhiteSpace($u)) { return "" }
    if ($u.EndsWith(".git")) { return $u }
    return ("{0}.git" -f $u)
}

function Try-ParseSemVer {
    param([string]$TagName)
    if ([string]::IsNullOrWhiteSpace($TagName)) { return $null }
    $t = $TagName.Trim()
    if ($t -match '^v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$') {
        return [pscustomobject]@{
            name  = $TagName
            major = [int]$Matches[1]
            minor = [int]$Matches[2]
            patch = [int]$Matches[3]
        }
    }
    return $null
}

function Try-GitLsRemoteHead {
    param([string]$RepoUrl)
    $remote = To-GitRemoteUrl -RepoUrl $RepoUrl
    if ([string]::IsNullOrWhiteSpace($remote)) { return $null }
    try {
        $lines = @(git ls-remote --symref $remote HEAD 2>$null)
    } catch {
        return $null
    }
    $branch = ""
    $sha = ""
    foreach ($line in $lines) {
        if ($line -match '^ref:\s+refs/heads/([^ ]+)\s+HEAD$') {
            $branch = [string]$Matches[1]
            continue
        }
        if ($line -match '^([a-f0-9]{40})\s+HEAD$') {
            $sha = [string]$Matches[1]
        }
    }
    if ([string]::IsNullOrWhiteSpace($sha)) { return $null }
    return [pscustomobject]@{ branch = $branch; sha = $sha }
}

function Try-GitLsRemoteLatestTag {
    param([string]$RepoUrl)
    $remote = To-GitRemoteUrl -RepoUrl $RepoUrl
    if ([string]::IsNullOrWhiteSpace($remote)) { return "" }
    $tagNames = New-Object System.Collections.Generic.List[string]
    try {
        $lines = @(git ls-remote --tags --refs $remote 2>$null)
    } catch {
        return ""
    }
    foreach ($line in $lines) {
        if ($line -match '^[a-f0-9]{40}\s+refs/tags/(.+)$') {
            $tagNames.Add([string]$Matches[1]) | Out-Null
        }
    }
    if ($tagNames.Count -eq 0) { return "" }
    $best = $null
    foreach ($tagName in $tagNames) {
        $parsed = Try-ParseSemVer -TagName $tagName
        if (-not $parsed) { continue }
        if (-not $best -or
            $parsed.major -gt $best.major -or
            ($parsed.major -eq $best.major -and $parsed.minor -gt $best.minor) -or
            ($parsed.major -eq $best.major -and $parsed.minor -eq $best.minor -and $parsed.patch -gt $best.patch)) {
            $best = $parsed
        }
    }
    if ($best) { return [string]$best.name }
    return [string](@($tagNames | Sort-Object | Select-Object -Last 1))
}

function Try-GetInstalledPluginEntry {
    param(
        [object]$Installed,
        [string]$PluginId
    )
    if (-not $Installed -or -not $Installed.plugins) { return $null }
    $prop = $Installed.plugins.PSObject.Properties | Where-Object { $_.Name -eq $PluginId } | Select-Object -First 1
    if (-not $prop) { return $null }
    $entries = @($prop.Value)
    if ($entries.Count -eq 0) { return $null }
    return ($entries | Select-Object -First 1)
}

function Get-ShortSha {
    param([string]$Sha)
    if ([string]::IsNullOrWhiteSpace($Sha)) { return "" }
    return $Sha.Substring(0, [Math]::Min(7, $Sha.Length))
}

function Resolve-AuditPath {
    param(
        [string]$RepoRoot,
        [string]$Candidate
    )
    if ([string]::IsNullOrWhiteSpace($Candidate)) { return "" }
    return (Resolve-VgoPathSpec -PathSpec $Candidate -RepoRoot $RepoRoot)
}

function Get-MirrorStateText {
    param(
        [string]$Slug,
        [string]$ExpectedHead,
        [object[]]$Roots
    )
    if ([string]::IsNullOrWhiteSpace($Slug) -or $null -eq $Roots -or $Roots.Count -eq 0) {
        return ""
    }
    $states = New-Object System.Collections.Generic.List[string]
    foreach ($root in $Roots) {
        $rootId = [string]$root.id
        $rootPath = [string]$root.path
        if ([string]::IsNullOrWhiteSpace($rootPath) -or -not (Test-Path -LiteralPath $rootPath)) {
            $states.Add(("{0}:missing-root" -f $rootId)) | Out-Null
            continue
        }
        $repoDir = Join-Path $rootPath $Slug
        if (-not (Test-Path -LiteralPath $repoDir)) {
            $states.Add(("{0}:missing" -f $rootId)) | Out-Null
            continue
        }
        if (-not (Test-Path -LiteralPath (Join-Path $repoDir '.git'))) {
            $states.Add(("{0}:present-no-git" -f $rootId)) | Out-Null
            continue
        }
        $actualHead = ""
        try {
            $actualHead = [string](git -C $repoDir rev-parse HEAD 2>$null | Select-Object -First 1)
        } catch {
            $actualHead = ""
        }
        if ([string]::IsNullOrWhiteSpace($actualHead)) {
            $states.Add(("{0}:unresolved" -f $rootId)) | Out-Null
            continue
        }
        if (-not [string]::IsNullOrWhiteSpace($ExpectedHead) -and $actualHead -ne $ExpectedHead) {
            $states.Add(("{0}:drift expected={1} actual={2}" -f $rootId, (Get-ShortSha -Sha $ExpectedHead), (Get-ShortSha -Sha $actualHead))) | Out-Null
        } else {
            $states.Add(("{0}:present@{1}" -f $rootId, (Get-ShortSha -Sha $actualHead))) | Out-Null
        }
    }
    return ($states -join '; ')
}

$repoRoot = [System.IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..\..'))
if ([string]::IsNullOrWhiteSpace($OutputDir)) {
    $OutputDir = Join-Path $repoRoot 'outputs\governance'
}
New-Item -ItemType Directory -Force -Path $OutputDir | Out-Null

$versionGovernancePath = Join-Path $repoRoot 'config\version-governance.json'
$vcoVersion = ""
if (Test-Path -LiteralPath $versionGovernancePath) {
    $versionGovernance = Read-JsonFile -Path $versionGovernancePath
    if ($versionGovernance.release -and $versionGovernance.release.version) {
        $vcoVersion = [string]$versionGovernance.release.version
    }
}

$manifestPath = Join-Path $repoRoot 'config\plugins-manifest.upstream.json'
$lockPath = Join-Path $repoRoot 'config\upstream-lock.json'
$manifest = $null
$lock = $null
if (Test-Path -LiteralPath $manifestPath) { $manifest = Read-JsonFile -Path $manifestPath }
if (Test-Path -LiteralPath $lockPath) { $lock = Read-JsonFile -Path $lockPath }

if ([string]::IsNullOrWhiteSpace($CorpusManifestPath)) {
    $CorpusManifestPath = Join-Path $repoRoot 'config\upstream-corpus-manifest.json'
}
$corpusManifest = $null
if (Test-Path -LiteralPath $CorpusManifestPath) {
    $corpusManifest = Read-JsonFile -Path $CorpusManifestPath
}

$pluginEntries = @()
if ($manifest -and $manifest.plugins) {
    foreach ($tierProperty in @($manifest.plugins.PSObject.Properties)) {
        $tier = [string]$tierProperty.Name
        foreach ($plugin in @($tierProperty.Value)) {
            $repoUrl = ''
            if ($null -ne $plugin -and $plugin.PSObject.Properties.Name -contains 'repo' -and $plugin.repo) {
                $repoUrl = Normalize-GitHubRepoUrl -Url ([string]$plugin.repo)
            }
            if ([string]::IsNullOrWhiteSpace($repoUrl)) { continue }
            $id = if ($plugin.PSObject.Properties.Name -contains 'id' -and $plugin.id) { [string]$plugin.id } elseif ($plugin.PSObject.Properties.Name -contains 'name' -and $plugin.name) { [string]$plugin.name } else { $repoUrl }
            $pluginEntries += [pscustomobject]@{
                source = "plugins-manifest.$tier"
                id = $id
                name = $id
                repo_url = $repoUrl
                slug = ""
                lane = ""
                status = ""
                owner = ""
                next_action = ""
                observed_head_sha = ""
                license = ""
            }
        }
    }
}

$lockEntries = @()
if ($lock -and $lock.dependencies) {
    foreach ($dependency in @($lock.dependencies)) {
        $repoUrl = Normalize-GitHubRepoUrl -Url ([string]$dependency.upstream_repo)
        if ([string]::IsNullOrWhiteSpace($repoUrl)) { continue }
        $lockEntries += [pscustomobject]@{
            source = 'upstream-lock'
            id = [string]$dependency.id
            name = [string]$dependency.id
            repo_url = $repoUrl
            slug = ""
            lane = ""
            status = ""
            owner = ""
            next_action = ""
            observed_head_sha = [string]$dependency.upstream_ref
            license = ""
        }
    }
}

$corpusEntries = @()
$corpusSummary = [ordered]@{}
$mirrorRoots = @()
if ($corpusManifest) {
    foreach ($entry in @($corpusManifest.entries)) {
        $corpusEntries += [pscustomobject]@{
            source = 'upstream-corpus-manifest'
            id = [string]$entry.slug
            name = [string]$entry.slug
            repo_url = Normalize-GitHubRepoUrl -Url ([string]$entry.repo_url)
            slug = [string]$entry.slug
            lane = [string]$entry.lane
            status = [string]$entry.status
            owner = [string]$entry.owner
            next_action = [string]$entry.next_action
            observed_head_sha = [string]$entry.observed_head_sha
            license = [string]$entry.license
        }
    }
    if ($corpusManifest.summary) {
        $corpusSummary = [ordered]@{
            total_entries = [int]$corpusManifest.summary.total_entries
            lane_counts = $corpusManifest.summary.lane_counts
            status_counts = $corpusManifest.summary.status_counts
        }
    }
    foreach ($root in @($corpusManifest.mirror_roots)) {
        $mirrorRoots += [pscustomobject]@{
            id = [string]$root.id
            path = Resolve-AuditPath -RepoRoot $repoRoot -Candidate ([string]$root.path)
            required_for_freshness_gate = [bool]$root.required_for_freshness_gate
        }
    }
}
if (-not [string]::IsNullOrWhiteSpace($MirrorRoot)) {
    $mirrorRoots = @([pscustomobject]@{ id = 'override'; path = Resolve-AuditPath -RepoRoot $repoRoot -Candidate $MirrorRoot; required_for_freshness_gate = $true })
}

$allEntries = @($pluginEntries + $lockEntries + $corpusEntries) | Where-Object { -not [string]::IsNullOrWhiteSpace($_.repo_url) }
$repoToSources = @{}
foreach ($entry in $allEntries) {
    if (-not $entry.repo_url.StartsWith('https://github.com/')) { continue }
    if (-not $repoToSources.ContainsKey($entry.repo_url)) {
        $repoToSources[$entry.repo_url] = New-Object System.Collections.Generic.List[object]
    }
    $repoToSources[$entry.repo_url].Add($entry) | Out-Null
}

$installed = $null
if ($CompareInstalled) {
    if ([string]::IsNullOrWhiteSpace($InstalledPluginsPath)) {
        $InstalledPluginsPath = Join-Path (Resolve-VgoTargetRoot) 'plugins\plugins.json'
    }
    if (Test-Path -LiteralPath $InstalledPluginsPath) {
        $installed = Read-JsonFile -Path $InstalledPluginsPath
    }
}

$githubHeaders = Get-GitHubHeaders
$rows = New-Object System.Collections.Generic.List[object]
$errors = New-Object System.Collections.Generic.List[string]
$repoUrls = @($repoToSources.Keys | Sort-Object)
if ($MaxRepos -gt 0) {
    $repoUrls = $repoUrls | Select-Object -First $MaxRepos
}

foreach ($repoUrl in $repoUrls) {
    $sources = [object[]]$repoToSources[$repoUrl].ToArray()
    $corpusSource = $sources | Where-Object { $_.source -eq 'upstream-corpus-manifest' } | Select-Object -First 1
    $parsed = Parse-GitHubOwnerRepo -RepoUrl $repoUrl
    if (-not $parsed) { continue }

    $slug = if ($corpusSource -and $corpusSource.slug) { [string]$corpusSource.slug } else { [string]$parsed.repo }
    $lane = if ($corpusSource -and $corpusSource.lane) { [string]$corpusSource.lane } else { '' }
    $status = if ($corpusSource -and $corpusSource.status) { [string]$corpusSource.status } else { '' }
    $owner = if ($corpusSource -and $corpusSource.owner) { [string]$corpusSource.owner } else { '' }
    $nextAction = if ($corpusSource -and $corpusSource.next_action) { [string]$corpusSource.next_action } else { '' }
    $observedHead = if ($corpusSource -and $corpusSource.observed_head_sha) { [string]$corpusSource.observed_head_sha } else { '' }
    $license = if ($corpusSource -and $corpusSource.license) { [string]$corpusSource.license } else { '' }

    $defaultBranch = ''
    $headSha = ''
    $headDate = ''
    $latestRelease = ''
    $latestReleaseDate = ''
    $latestTag = ''
    $pushedAt = ''

    $lsRemoteHead = Try-GitLsRemoteHead -RepoUrl $repoUrl
    if ($lsRemoteHead) {
        $defaultBranch = [string]$lsRemoteHead.branch
        $headSha = [string]$lsRemoteHead.sha
    }
    $latestTag = Try-GitLsRemoteLatestTag -RepoUrl $repoUrl

    if (-not $NoGitHub) {
        $repoInfo = Try-InvokeRestJson -Url ("https://api.github.com/repos/{0}/{1}" -f $parsed.owner, $parsed.repo) -Headers $githubHeaders
        if ($repoInfo) {
            if ([string]::IsNullOrWhiteSpace($defaultBranch) -and $repoInfo.default_branch) {
                $defaultBranch = [string]$repoInfo.default_branch
            }
            if ([string]::IsNullOrWhiteSpace($license) -and $repoInfo.license -and $repoInfo.license.spdx_id) {
                $license = [string]$repoInfo.license.spdx_id
            }
            if ($repoInfo.pushed_at) {
                $pushedAt = [string]$repoInfo.pushed_at
            }
        }
        if (-not [string]::IsNullOrWhiteSpace($defaultBranch)) {
            $headInfo = Try-InvokeRestJson -Url ("https://api.github.com/repos/{0}/{1}/commits/{2}" -f $parsed.owner, $parsed.repo, $defaultBranch) -Headers $githubHeaders
            if ($headInfo) {
                if ([string]::IsNullOrWhiteSpace($headSha) -and $headInfo.sha) {
                    $headSha = [string]$headInfo.sha
                }
                if ($headInfo.commit -and $headInfo.commit.author -and $headInfo.commit.author.date) {
                    $headDate = [string]$headInfo.commit.author.date
                }
            }
        }
        $releaseInfo = Try-InvokeRestJson -Url ("https://api.github.com/repos/{0}/{1}/releases/latest" -f $parsed.owner, $parsed.repo) -Headers $githubHeaders
        if ($releaseInfo) {
            if ($releaseInfo.tag_name) { $latestRelease = [string]$releaseInfo.tag_name }
            if ($releaseInfo.published_at) { $latestReleaseDate = [string]$releaseInfo.published_at }
        }
        if ([string]::IsNullOrWhiteSpace($latestTag)) {
            $tagInfo = Try-InvokeRestJson -Url ("https://api.github.com/repos/{0}/{1}/tags?per_page=1&page=1" -f $parsed.owner, $parsed.repo) -Headers $githubHeaders
            if ($tagInfo -and @($tagInfo).Count -gt 0 -and $tagInfo[0].name) {
                $latestTag = [string]$tagInfo[0].name
            }
        }
    }

    $sourceLabels = @($sources | ForEach-Object { $_.id } | Where-Object { -not [string]::IsNullOrWhiteSpace($_) } | Sort-Object -Unique)
    $sourceLabelText = ($sourceLabels -join ', ')

    $installedText = ''
    if ($CompareInstalled) {
        $installedEntries = @()
        foreach ($src in $sources) {
            if (-not $src.source.StartsWith('plugins-manifest.')) { continue }
            if ([string]::IsNullOrWhiteSpace($src.id)) { continue }
            $entry = Try-GetInstalledPluginEntry -Installed $installed -PluginId $src.id
            if (-not $entry) { continue }
            $version = [string]$entry.version
            $sha = Get-ShortSha -Sha ([string]$entry.gitCommitSha)
            $installedEntries += ("{0}={1}({2})" -f $src.id, $version, $sha)
        }
        if ($installedEntries.Count -gt 0) {
            $installedText = ($installedEntries -join '; ')
        }
    }

    $mirrorState = Get-MirrorStateText -Slug $slug -ExpectedHead $observedHead -Roots $mirrorRoots

    $rows.Add([pscustomobject]@{
        slug = $slug
        repo_url = $repoUrl
        sources = $sourceLabelText
        lane = $lane
        status = $status
        owner = $owner
        next_action = $nextAction
        license = $license
        default_branch = $defaultBranch
        head_sha = $headSha
        head_date = $headDate
        observed_head_sha = $observedHead
        latest_release = $latestRelease
        latest_release_date = $latestReleaseDate
        latest_tag = $latestTag
        pushed_at = $pushedAt
        mirror_state = $mirrorState
        installed = $installedText
    }) | Out-Null
}

$npmRows = New-Object System.Collections.Generic.List[object]

$now = Get-Date
$timestamp = $now.ToString('yyyyMMdd-HHmmss')
$reportPath = Join-Path $OutputDir ("upstream-audit_{0}.md" -f $timestamp)
$jsonPath = Join-Path $OutputDir ("upstream-audit_{0}.json" -f $timestamp)

$lines = New-Object System.Collections.Generic.List[string]
$lines.Add('# VCO Upstream Audit') | Out-Null
$lines.Add('') | Out-Null
if (-not [string]::IsNullOrWhiteSpace($vcoVersion)) {
    $lines.Add(("- VCO version: {0}" -f $vcoVersion)) | Out-Null
}
$lines.Add(("- Generated: {0}" -f $now.ToString('s'))) | Out-Null
$lines.Add(('- Repo root: `' + $repoRoot + '`')) | Out-Null
if (-not [string]::IsNullOrWhiteSpace($CorpusManifestPath) -and (Test-Path -LiteralPath $CorpusManifestPath)) {
    $lines.Add(('- Corpus manifest: `' + $CorpusManifestPath + '`')) | Out-Null
}
if ($mirrorRoots.Count -gt 0) {
    $rootText = @($mirrorRoots | ForEach-Object { $_.id + '=`' + $_.path + '`' }) -join '; '
    $lines.Add(("- Mirror roots: {0}" -f $rootText)) | Out-Null
}
if ($CompareInstalled -and -not [string]::IsNullOrWhiteSpace($InstalledPluginsPath)) {
    $lines.Add(('- Installed plugins: `' + $InstalledPluginsPath + '`')) | Out-Null
}

if ($corpusManifest) {
    $lines.Add('') | Out-Null
    $lines.Add('## Upstream Corpus Summary') | Out-Null
    $lines.Add('') | Out-Null
    $lines.Add(("- Tracked entries: {0}" -f [int]$corpusManifest.summary.total_entries)) | Out-Null
    if ($corpusManifest.summary.lane_counts) {
        foreach ($property in @($corpusManifest.summary.lane_counts.PSObject.Properties) | Sort-Object Name) {
            $lines.Add(('- Lane ' + $property.Name + ': ' + $property.Value)) | Out-Null
        }
    }
    if ($corpusManifest.summary.status_counts) {
        foreach ($property in @($corpusManifest.summary.status_counts.PSObject.Properties) | Sort-Object Name) {
            $lines.Add(('- Status ' + $property.Name + ': ' + $property.Value)) | Out-Null
        }
    }
}

$lines.Add('') | Out-Null
$lines.Add('## GitHub Repos') | Out-Null
$lines.Add('') | Out-Null
$lines.Add('| Slug | Repo | Lane | Status | Owner | Branch | Head | Expected | Mirror State | Latest Release | Sources | Next Action |') | Out-Null
$lines.Add('|---|---|---|---|---|---|---|---|---|---|---|---|') | Out-Null
foreach ($row in $rows) {
    $lines.Add(("| {0} | {1} | {2} | {3} | {4} | {5} | {6} | {7} | {8} | {9} | {10} | {11} |" -f
        ($row.slug -replace '\|', '\\|'),
        ($row.repo_url -replace '\|', '\\|'),
        ($row.lane -replace '\|', '\\|'),
        ($row.status -replace '\|', '\\|'),
        ($row.owner -replace '\|', '\\|'),
        ($row.default_branch -replace '\|', '\\|'),
        ((Get-ShortSha -Sha $row.head_sha) -replace '\|', '\\|'),
        ((Get-ShortSha -Sha $row.observed_head_sha) -replace '\|', '\\|'),
        (($row.mirror_state -replace '\|', '\\|') -replace "`n", ' '),
        ($row.latest_release -replace '\|', '\\|'),
        ($row.sources -replace '\|', '\\|'),
        (($row.next_action -replace '\|', '\\|') -replace "`n", ' ')
    )) | Out-Null
}

if ($npmRows.Count -gt 0) {
    $lines.Add('') | Out-Null
    $lines.Add('## npm Packages') | Out-Null
    $lines.Add('') | Out-Null
    $lines.Add('| Package | Latest | Modified |') | Out-Null
    $lines.Add('|---|---|---|') | Out-Null
    foreach ($package in $npmRows) {
        $lines.Add(("| {0} | {1} | {2} |" -f
            ($package.package -replace '\|', '\\|'),
            ($package.latest -replace '\|', '\\|'),
            ($package.modified -replace '\|', '\\|')
        )) | Out-Null
    }
}

if ($errors.Count -gt 0) {
    $lines.Add('') | Out-Null
    $lines.Add('## Errors') | Out-Null
    $lines.Add('') | Out-Null
    foreach ($errorText in $errors) {
        $lines.Add(("- {0}" -f $errorText)) | Out-Null
    }
}

Write-TextFile -Path $reportPath -Content ($lines -join "`n")
$corpusManifestPathResolved = ''
if (Test-Path -LiteralPath $CorpusManifestPath) {
    $corpusManifestPathResolved = [System.IO.Path]::GetFullPath($CorpusManifestPath)
}
if ($WriteJson) {
    $mirrorRootsArtifact = foreach ($root in $mirrorRoots) {
        [ordered]@{
            id = $root.id
            path = $root.path
            required_for_freshness_gate = $root.required_for_freshness_gate
        }
    }
    $artifact = [ordered]@{
        generated_at = [DateTime]::UtcNow.ToString('o')
        repo_root = $repoRoot
        corpus_manifest_path = $corpusManifestPathResolved
        mirror_roots = @($mirrorRootsArtifact)
        corpus_summary = $corpusSummary
        rows = [object[]]$rows.ToArray()
        npm_packages = [object[]]$npmRows.ToArray()
        errors = [string[]]$errors.ToArray()
    }
    $artifact | ConvertTo-Json -Depth 50 | Set-Content -LiteralPath $jsonPath -Encoding UTF8
}

Write-Host 'Upstream audit report written:' -ForegroundColor Green
Write-Host $reportPath
if ($WriteJson) {
    Write-Host 'Upstream audit json written:' -ForegroundColor Green
    Write-Host $jsonPath
}
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