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/release-cut.ps1

View on GitHub
param(
    [string]$Version = '',
    [string]$Updated = '',
    [switch]$RunGates,
    [switch]$Preview,
    [string]$PreviewOutputPath = ''
)

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

function Read-Text {
    param([string]$Path)
    return Get-Content -LiteralPath $Path -Raw -Encoding UTF8
}

function Write-Text {
    param(
        [string]$Path,
        [string]$Content
    )
    Write-VgoUtf8NoBomText -Path $Path -Content $Content
}

function Read-Json {
    param([Parameter(Mandatory)] [string]$Path)
    return (Read-Text -Path $Path | ConvertFrom-Json)
}

function Write-Json {
    param(
        [Parameter(Mandatory)] [string]$Path,
        [Parameter(Mandatory)] [object]$Payload
    )

    Write-Text -Path $Path -Content ($Payload | ConvertTo-Json -Depth 100)
}

function Ensure-TrailingNewline {
    param([Parameter(Mandatory)] [string]$Path)

    if (-not (Test-Path -LiteralPath $Path)) {
        return
    }

    $bytes = [System.IO.File]::ReadAllBytes($Path)
    if ($bytes.Length -eq 0) {
        return
    }

    $lastByte = $bytes[$bytes.Length - 1]
    if ($lastByte -ne 0x0A -and $lastByte -ne 0x0D) {
        Append-VgoUtf8NoBomText -Path $Path -Content ([Environment]::NewLine)
    }
}

function Test-LegacyReleaseDocumentsEnabled {
    param([Parameter(Mandatory)] [string]$RepoRoot)

    $contractPath = Join-Path $RepoRoot 'config/live-document-contract.json'
    if (-not (Test-Path -LiteralPath $contractPath -PathType Leaf)) {
        return $true
    }

    $contract = Read-Json -Path $contractPath
    if ($null -eq $contract.artifact_sink -or
        -not ($contract.artifact_sink.PSObject.Properties.Name -contains 'legacy_write_mode')) {
        return $true
    }

    return ([string]$contract.artifact_sink.legacy_write_mode -ne 'disabled')
}

function Update-MaintenanceSection {
    param(
        [string]$Path,
        [string]$Version,
        [string]$Updated
    )

    $text = Read-Text -Path $Path
    $updatedText = $text
    $updatedText = [regex]::Replace($updatedText, '(?m)^- Version:\s*.+$', "- Version: $Version")
    $updatedText = [regex]::Replace($updatedText, '(?m)^- Updated:\s*.+$', "- Updated: $Updated")
    if ($updatedText -ne $text) {
        Write-Text -Path $Path -Content $updatedText
    }
}

function Ensure-ChangelogHeader {
    param(
        [string]$Path,
        [string]$Version,
        [string]$Updated
    )

    $text = Read-Text -Path $Path
    $header = "## v$Version ($Updated)"
    if ($text -match [regex]::Escape($header)) {
        return
    }

    $entry = @(
        $header,
        '',
        '- Release cut by `scripts/governance/release-cut.ps1`.',
        '- Fill in detailed release notes before merge.',
        ''
    ) -join "`n"

    if ($text -match '(?m)^# .+$') {
        $updated = [regex]::Replace($text, '(?m)^(# .+)$', "`$1`n`n$entry", 1)
    } else {
        $updated = "$entry`n$text"
    }
    Write-Text -Path $Path -Content $updated
}

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

    $sourceConfigPath = Join-Path $RepoRoot 'config/distribution-manifest-sources.json'
    if (-not (Test-Path -LiteralPath $sourceConfigPath)) {
        throw "distribution manifest source config missing: $sourceConfigPath"
    }

    $sourceConfig = Read-Json -Path $sourceConfigPath
    $outputs = New-Object System.Collections.Generic.List[string]

    foreach ($item in @($sourceConfig.lane_manifests)) {
        if ($null -ne $item -and $item.PSObject.Properties.Name -contains 'output_path' -and -not [string]::IsNullOrWhiteSpace([string]$item.output_path)) {
            [void]$outputs.Add([string]$item.output_path)
        }
    }

    foreach ($item in @($sourceConfig.public_manifests)) {
        if ($null -ne $item -and $item.PSObject.Properties.Name -contains 'output_path' -and -not [string]::IsNullOrWhiteSpace([string]$item.output_path)) {
            [void]$outputs.Add([string]$item.output_path)
        }
    }

    return @($outputs.ToArray())
}

function Sync-DistManifestOutputs {
    param([Parameter(Mandatory)] [string]$RepoRoot)

    $toolPath = Join-Path $RepoRoot 'scripts/build/sync_dist_release_manifests.py'
    if (-not (Test-Path -LiteralPath $toolPath)) {
        throw "distribution manifest sync tool missing: $toolPath"
    }

    $pythonSpec = Resolve-VgoPythonCommandSpec
    $arguments = @($pythonSpec.prefix_arguments) + @($toolPath, '--repo-root', $RepoRoot)
    & $pythonSpec.host_path @arguments
    if ($LASTEXITCODE -ne 0) {
        throw 'distribution manifest sync failed'
    }
}

function Test-ScriptDeclaresParameter {
    param(
        [Parameter(Mandatory)] [string]$ScriptPath,
        [Parameter(Mandatory)] [string]$ParameterName
    )

    $tokens = $null
    $parseErrors = $null
    $ast = [System.Management.Automation.Language.Parser]::ParseFile($ScriptPath, [ref]$tokens, [ref]$parseErrors)
    if ($null -eq $ast -or $null -eq $ast.ParamBlock) {
        return $false
    }

    foreach ($parameter in @($ast.ParamBlock.Parameters)) {
        if ($null -ne $parameter.Name -and $parameter.Name.VariablePath.UserPath -eq $ParameterName) {
            return $true
        }
    }

    return $false
}

function Invoke-ReleaseGateScript {
    param([Parameter(Mandatory)] [string]$GatePath)

    if (Test-ScriptDeclaresParameter -ScriptPath $GatePath -ParameterName 'WriteArtifacts') {
        & $GatePath -WriteArtifacts:$true
        return
    }

    & $GatePath
}

function Invoke-SyncBundledVibeScript {
    param(
        [Parameter(Mandatory)] [string]$ScriptPath,
        [switch]$Preview,
        [string]$PreviewOutputPath = '',
        [switch]$PruneBundledExtras
    )

    $arguments = @()
    if ($Preview -and (Test-ScriptDeclaresParameter -ScriptPath $ScriptPath -ParameterName 'Preview')) {
        $arguments += '-Preview'
    }

    if (-not [string]::IsNullOrWhiteSpace($PreviewOutputPath) -and (Test-ScriptDeclaresParameter -ScriptPath $ScriptPath -ParameterName 'PreviewOutputPath')) {
        $arguments += '-PreviewOutputPath'
        $arguments += $PreviewOutputPath
    }

    if ($PruneBundledExtras -and (Test-ScriptDeclaresParameter -ScriptPath $ScriptPath -ParameterName 'PruneBundledExtras')) {
        $arguments += '-PruneBundledExtras'
    }

    & $ScriptPath @arguments
}

function Get-ReleaseSummary {
    param(
        [Parameter(Mandatory)] [psobject]$Governance,
        [Parameter(Mandatory)] [string]$Version
    )

    if ($Governance.PSObject.Properties.Name -contains 'release' -and
        $null -ne $Governance.release -and
        $Governance.release.PSObject.Properties.Name -contains 'notes' -and
        -not [string]::IsNullOrWhiteSpace([string]$Governance.release.notes)) {
        return [string]$Governance.release.notes
    }

    return ("governed release surface for v{0}" -f $Version)
}

function Update-ReleasesReadmeSurface {
    param(
        [Parameter(Mandatory)] [string]$Path,
        [Parameter(Mandatory)] [string]$Version,
        [Parameter(Mandatory)] [string]$Updated,
        [Parameter(Mandatory)] [string]$Summary
    )

    $text = Read-Text -Path $Path
    $currentLine = ('- [`v{0}.md`](v{0}.md): {1}' -f $Version, $Summary)
    $recentLine = ('- [`v{0}.md`](v{0}.md) - {1} - {2}' -f $Version, $Updated, $Summary)
    $lines = New-Object System.Collections.Generic.List[string]
    foreach ($line in ([regex]::Split($text, '\r?\n'))) {
        [void]$lines.Add([string]$line)
    }

    $currentHeaderIndex = -1
    $runtimeHeaderIndex = -1
    $recentHeaderIndex = -1
    $olderNotesIndex = -1
    for ($i = 0; $i -lt $lines.Count; $i++) {
        $trimmed = $lines[$i].Trim()
        if ($trimmed -eq '### Current Release Surface' -and $currentHeaderIndex -lt 0) {
            $currentHeaderIndex = $i
            continue
        }
        if ($trimmed -eq '### Release Runtime / Proof Handoff' -and $runtimeHeaderIndex -lt 0) {
            $runtimeHeaderIndex = $i
            continue
        }
        if ($trimmed -eq '## Recent Governed Releases' -and $recentHeaderIndex -lt 0) {
            $recentHeaderIndex = $i
            continue
        }
        if ($trimmed -eq 'Older release notes remain in this directory as historical version records, but they are not part of the active release surface.' -and $olderNotesIndex -lt 0) {
            $olderNotesIndex = $i
        }
    }

    if ($currentHeaderIndex -lt 0 -or $runtimeHeaderIndex -lt 0 -or $runtimeHeaderIndex -le $currentHeaderIndex) {
        throw "unable to locate 'Current Release Surface' section in $Path"
    }

    $currentBodyStart = $currentHeaderIndex + 1
    $currentBodyCount = $runtimeHeaderIndex - $currentBodyStart
    $lines.RemoveRange($currentBodyStart, $currentBodyCount)
    $currentSectionLines = [string[]]@('', $currentLine, '')
    $lines.InsertRange($currentBodyStart, $currentSectionLines)

    if ($recentHeaderIndex -lt 0 -or $olderNotesIndex -lt 0 -or $olderNotesIndex -le $recentHeaderIndex) {
        throw "unable to locate 'Recent Governed Releases' section in $Path"
    }

    $existingRecentLines = @(
        $lines.GetRange($recentHeaderIndex + 1, $olderNotesIndex - ($recentHeaderIndex + 1)) |
            Where-Object { -not [string]::IsNullOrWhiteSpace($_) }
    )
    $filteredRecentLines = @(
        $existingRecentLines | Where-Object {
            $_ -notmatch ('^\-\s+\[`v' + [regex]::Escape($Version) + '\.md`\]\(v' + [regex]::Escape($Version) + '\.md\)')
        }
    )
    $lines.RemoveRange($recentHeaderIndex + 1, $olderNotesIndex - ($recentHeaderIndex + 1))
    $recentSectionLines = [string[]](@('', $recentLine) + @($filteredRecentLines) + @(''))
    $lines.InsertRange($recentHeaderIndex + 1, $recentSectionLines)

    Write-Text -Path $Path -Content ($lines -join "`n")
}

function New-ReleaseNoteTemplate {
    param(
        [Parameter(Mandatory)] [string]$Version,
        [Parameter(Mandatory)] [string]$Updated,
        [Parameter(Mandatory)] [string]$Head,
        [Parameter(Mandatory)] [string]$Summary
    )

    return @(
        "# VCO Release v$Version",
        '',
        "- Date: $Updated",
        "- Commit(base): $Head",
        '',
        '## Highlights',
        '',
        ('- Initial governed summary: {0}' -f $Summary),
        '',
        '## Validation Notes',
        '',
        '- Fill in the exact verification commands and outcomes before merge.',
        '',
        '## Migration Notes',
        '',
        '- Record only user-facing behavior, compatibility, or operator migration notes that remain true for this release.'
    ) -join "`n"
}

function Get-ReleaseGateFallbackScripts {
    return @(
        'scripts/verify/vibe-version-consistency-gate.ps1',
        'scripts/verify/vibe-dist-manifest-gate.ps1',
        'scripts/verify/vibe-release-notes-quality-gate.ps1',
        'scripts/verify/vibe-version-packaging-gate.ps1',
        'scripts/verify/vibe-config-parity-gate.ps1',
        'scripts/verify/vibe-nested-bundled-parity-gate.ps1',
        'scripts/verify/vibe-mirror-edit-hygiene-gate.ps1',
        'scripts/verify/vibe-bom-frontmatter-gate.ps1',
        'scripts/verify/vibe-wave40-63-board-gate.ps1',
        'scripts/verify/vibe-capability-dedup-gate.ps1',
        'scripts/verify/vibe-adaptive-routing-readiness-gate.ps1',
        'scripts/verify/vibe-upstream-value-ops-gate.ps1',
        'scripts/verify/vibe-release-install-runtime-coherence-gate.ps1',
        'scripts/verify/vibe-upstream-corpus-manifest-gate.ps1',
        'scripts/verify/vibe-wave121-upstream-mapping-gate.ps1',
        'scripts/verify/vibe-operator-preview-contract-gate.ps1',
        'scripts/verify/vibe-output-fixture-migration-stage2-gate.ps1',
        'scripts/verify/vibe-wave124-ops-cockpit-v2-gate.ps1',
        'scripts/verify/vibe-wave125-gate-family-convergence-gate.ps1',
        'scripts/verify/vibe-upstream-mirror-freshness-gate.ps1',
        'scripts/verify/vibe-docling-contract-gate.ps1',
        'scripts/verify/vibe-connector-admission-gate.ps1',
        'scripts/verify/vibe-role-pack-governance-gate.ps1',
        'scripts/verify/vibe-capability-catalog-gate.ps1',
        'scripts/verify/vibe-promotion-board-gate.ps1',
        'scripts/verify/vibe-pilot-scenarios.ps1',
        'scripts/verify/vibe-deep-extraction-pilot-gate.ps1',
        'scripts/verify/vibe-memory-runtime-v3-gate.ps1',
        'scripts/verify/vibe-mem0-softrollout-gate.ps1',
        'scripts/verify/vibe-letta-policy-conformance-gate.ps1',
        'scripts/verify/vibe-browserops-scorecard-gate.ps1',
        'scripts/verify/vibe-browserops-softrollout-gate.ps1',
        'scripts/verify/vibe-desktopops-replay-gate.ps1',
        'scripts/verify/vibe-desktopops-softrollout-gate.ps1',
        'scripts/verify/vibe-docling-contract-v2-gate.ps1',
        'scripts/verify/vibe-connector-scorecard-gate.ps1',
        'scripts/verify/vibe-connector-action-ledger-gate.ps1',
        'scripts/verify/vibe-prompt-intelligence-productization-gate.ps1',
        'scripts/verify/vibe-cross-plane-task-contract-gate.ps1',
        'scripts/verify/vibe-cross-plane-replay-gate.ps1',
        'scripts/verify/vibe-promotion-scorecard-gate.ps1',
        'scripts/verify/vibe-ops-cockpit-gate.ps1',
        'scripts/verify/vibe-rollback-drill-gate.ps1',
        'scripts/verify/vibe-release-train-v2-gate.ps1',
        'scripts/verify/vibe-release-truth-consistency-gate.ps1',
        'scripts/verify/vibe-wave64-82-closure-gate.ps1',
        'scripts/verify/vibe-gate-reliability-gate.ps1',
        'scripts/verify/vibe-memory-quality-eval-gate.ps1',
        'scripts/verify/vibe-openworld-runtime-eval-gate.ps1',
        'scripts/verify/vibe-document-failure-taxonomy-gate.ps1',
        'scripts/verify/vibe-prompt-intelligence-eval-gate.ps1',
        'scripts/verify/vibe-candidate-quality-board-gate.ps1',
        'scripts/verify/vibe-role-pack-v2-gate.ps1',
        'scripts/verify/vibe-subagent-handoff-gate.ps1',
        'scripts/verify/vibe-discovery-intake-scorecard-gate.ps1',
        'scripts/verify/vibe-capability-lifecycle-gate.ps1',
        'scripts/verify/vibe-connector-sandbox-simulation-gate.ps1',
        'scripts/verify/vibe-skill-harvest-v2-gate.ps1',
        'scripts/verify/vibe-ops-dashboard-gate.ps1',
        'scripts/verify/vibe-release-evidence-bundle-gate.ps1',
        'scripts/verify/vibe-manual-apply-policy-gate.ps1',
        'scripts/verify/vibe-rollout-proposal-boundedness-gate.ps1',
        'scripts/verify/vibe-upstream-reaudit-matrix-gate.ps1',
        'scripts/verify/vibe-wave83-100-closure-gate.ps1'
    )
}

function Get-ReleaseGateScriptsFromContract {
    param([psobject]$PreviewContract)

    if ($null -ne $PreviewContract -and
        $PreviewContract.PSObject.Properties.Name -contains 'operators' -and
        $null -ne $PreviewContract.operators) {
        $operators = $PreviewContract.operators
        $releaseCutOperator = $null
        if ($operators -is [System.Collections.IDictionary]) {
            if ($operators.Contains('release-cut')) {
                $releaseCutOperator = $operators['release-cut']
            }
        } elseif ($null -ne $operators.PSObject -and $operators.PSObject.Properties.Name -contains 'release-cut') {
            $releaseCutOperator = $operators.'release-cut'
        }

        if ($null -ne $releaseCutOperator -and
            $releaseCutOperator.PSObject.Properties.Name -contains 'apply_gates' -and
            $null -ne $releaseCutOperator.apply_gates) {
            $applyGates = @($releaseCutOperator.apply_gates | Where-Object { -not [string]::IsNullOrWhiteSpace([string]$_) })
            if ($applyGates.Count -gt 0) {
                return @($applyGates)
            }
        }
    }

    return @(Get-ReleaseGateFallbackScripts)
}

function Get-ReleasePostcheckScriptsFromContract {
    param(
        [psobject]$PreviewContract,
        [string[]]$FallbackScripts = @()
    )

    if ($null -ne $PreviewContract -and
        $PreviewContract.PSObject.Properties.Name -contains 'operators' -and
        $null -ne $PreviewContract.operators) {
        $operators = $PreviewContract.operators
        $releaseCutOperator = $null
        if ($operators -is [System.Collections.IDictionary]) {
            if ($operators.Contains('release-cut')) {
                $releaseCutOperator = $operators['release-cut']
            }
        } elseif ($null -ne $operators.PSObject -and $operators.PSObject.Properties.Name -contains 'release-cut') {
            $releaseCutOperator = $operators.'release-cut'
        }

        if ($null -ne $releaseCutOperator -and
            $releaseCutOperator.PSObject.Properties.Name -contains 'postcheck_gates' -and
            $null -ne $releaseCutOperator.postcheck_gates) {
            $postcheckGates = @($releaseCutOperator.postcheck_gates | Where-Object { -not [string]::IsNullOrWhiteSpace([string]$_) })
            if ($postcheckGates.Count -gt 0) {
                return @($postcheckGates)
            }
        }
    }

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

    return @(Get-ReleaseGateFallbackScripts)
}

function Get-PreviewReceiptPath {
    param(
        [string]$RepoRoot,
        [string]$RequestedPath,
        [psobject]$Contract
    )

    if (-not [string]::IsNullOrWhiteSpace($RequestedPath)) {
        return $RequestedPath
    }

    $root = if ($null -ne $Contract -and $Contract.PSObject.Properties.Name -contains 'preview_output_root') {
        [string]$Contract.preview_output_root
    } else {
        'outputs/governance/preview'
    }
    return Join-Path $RepoRoot (Join-Path $root 'release-cut.json')
}

$context = Get-VgoGovernanceContext -ScriptPath $PSCommandPath -EnforceExecutionContext
$repoRoot = $context.repoRoot
$governancePath = $context.governancePath
$governance = $context.governance

$previewContractPath = Join-Path $repoRoot 'config/operator-preview-contract.json'
$previewContract = if (Test-Path -LiteralPath $previewContractPath) {
    Get-Content -LiteralPath $previewContractPath -Raw -Encoding UTF8 | ConvertFrom-Json
} else {
    $null
}

if ([string]::IsNullOrWhiteSpace($Version)) {
    $Version = [string]$governance.release.version
}
if ([string]::IsNullOrWhiteSpace($Updated)) {
    $Updated = (Get-Date -Format 'yyyy-MM-dd')
}

$maintenanceFiles = @($governance.version_markers.maintenance_files)
$changelogPath = Join-Path $repoRoot ([string]$governance.version_markers.changelog_path)
$ledgerRel = [string]$governance.logs.release_ledger_jsonl
$ledgerPath = Join-Path $repoRoot $ledgerRel
$releaseNotesDir = Join-Path $repoRoot ([string]$governance.logs.release_notes_dir)
$releaseNotePath = Join-Path $releaseNotesDir ("v{0}.md" -f $Version)
$releaseReadmeRel = 'docs/releases/README.md'
$releaseReadmePath = Join-Path $repoRoot $releaseReadmeRel
$legacyReleaseDocumentsEnabled = Test-LegacyReleaseDocumentsEnabled -RepoRoot $repoRoot
$distManifestRels = @(Get-DistManifestOutputRelativePaths -RepoRoot $repoRoot)
$releaseSummary = Get-ReleaseSummary -Governance $governance -Version $Version
$syncScript = Join-Path $repoRoot 'scripts\governance\sync-bundled-vibe.ps1'
$applyGateScripts = if ($RunGates) { Get-ReleaseGateScriptsFromContract -PreviewContract $previewContract } else { @() }
$postcheckGateScripts = if ($RunGates) { Get-ReleasePostcheckScriptsFromContract -PreviewContract $previewContract -FallbackScripts $applyGateScripts } else { @() }
$head = (git -C $repoRoot rev-parse --short HEAD).Trim()

if ($Preview) {
    $previewPath = Get-PreviewReceiptPath -RepoRoot $repoRoot -RequestedPath $PreviewOutputPath -Contract $previewContract
    $previewRoot = Split-Path -Parent $previewPath
    $releaseDocumentActions = if ($legacyReleaseDocumentsEnabled) {
        @(
            [ordered]@{ path = [string]$governance.version_markers.changelog_path; action = 'ensure release changelog header' },
            [ordered]@{ path = (Get-VgoRelativePathPortable -BasePath $repoRoot -TargetPath $releaseNotePath); action = 'create release notes if missing with governed section skeleton' },
            [ordered]@{ path = $releaseReadmeRel; action = 'update current release surface and recent governed releases entry' }
        )
    } else {
        @()
    }
    $plannedFileActions = @(
        [ordered]@{ path = 'config/version-governance.json'; action = 'update release.version + release.updated' },
        [ordered]@{ path = $ledgerRel; action = 'append release ledger record' }
    ) + @($releaseDocumentActions) + @($maintenanceFiles | ForEach-Object {
        [ordered]@{ path = [string]$_; action = 'update maintenance section version/updated' }
    }) + @($distManifestRels | ForEach-Object {
        [ordered]@{ path = [string]$_; action = 'sync generated dist manifest from authoritative source config' }
    })

    $syncPreviewPath = Join-Path $previewRoot 'sync-bundled-vibe-from-release-cut.json'
    if (Test-Path -LiteralPath $syncScript) {
        # operator-preview contract requires sync-bundled-vibe.ps1 -Preview before apply.
        Invoke-SyncBundledVibeScript -ScriptPath $syncScript -Preview -PreviewOutputPath $syncPreviewPath -PruneBundledExtras
        if ($LASTEXITCODE -ne 0) {
            throw 'sync-bundled-vibe preview failed'
        }
    }

    $artifact = [ordered]@{
        operator = 'release-cut'
        contract_version = if ($null -ne $previewContract -and $previewContract.PSObject.Properties.Name -contains 'contract_version') { $previewContract.contract_version } else { 1 }
        mode = 'preview'
        precheck = [ordered]@{
            repo_root = $repoRoot
            canonical_target_id = $context.canonicalTarget.id
            sync_source_target_id = $context.syncSourceTarget.id
            current_version = [string]$governance.release.version
            requested_version = $Version
            requested_updated = $Updated
            git_head = $head
            run_gates = [bool]$RunGates
        }
        preview = [ordered]@{
            generated_at = (Get-Date).ToString('s')
            planned_file_actions = $plannedFileActions
            sync_preview_receipt = if (Test-Path -LiteralPath $syncPreviewPath) { (Get-VgoRelativePathPortable -BasePath $repoRoot -TargetPath $syncPreviewPath) } else { $null }
            planned_gates = $applyGateScripts
        }
        postcheck = [ordered]@{
            verify_after_apply = $postcheckGateScripts
        }
    }
    Write-VgoUtf8NoBomText -Path $previewPath -Content ($artifact | ConvertTo-Json -Depth 100)
    Write-Host ("Preview receipt written: {0}" -f $previewPath) -ForegroundColor Yellow
    return
}

$governance.release.version = $Version
$governance.release.updated = $Updated
$governanceJson = $governance | ConvertTo-Json -Depth 30
Write-Text -Path $governancePath -Content $governanceJson

foreach ($rel in $maintenanceFiles) {
    $path = Join-Path $repoRoot $rel
    if (-not (Test-Path -LiteralPath $path)) {
        throw "maintenance file missing: $rel"
    }
    Update-MaintenanceSection -Path $path -Version $Version -Updated $Updated
}

if ($legacyReleaseDocumentsEnabled) {
    Ensure-ChangelogHeader -Path $changelogPath -Version $Version -Updated $Updated
}

New-Item -ItemType Directory -Force -Path (Split-Path -Parent $ledgerPath) | Out-Null
Ensure-TrailingNewline -Path $ledgerPath
$entry = [ordered]@{
    recorded_at = (Get-Date).ToString('s')
    version = $Version
    updated = $Updated
    git_head = $head
    actor = $env:USERNAME
}

# Pre-write duplicate check: only append if (version, git_head) combination doesn't exist
$shouldAppend = $true
if (Test-Path -LiteralPath $ledgerPath) {
    $existingLines = Get-Content -LiteralPath $ledgerPath -Encoding UTF8
    foreach ($line in $existingLines) {
        if (-not [string]::IsNullOrWhiteSpace($line)) {
            $existingEntry = $line | ConvertFrom-Json
            if ($existingEntry.version -eq $Version -and $existingEntry.git_head -eq $head) {
                $shouldAppend = $false
                Write-Host ("Skipping duplicate ledger entry: version={0}, git_head={1} already recorded at {2}" -f $Version, $head, $existingEntry.recorded_at) -ForegroundColor Yellow
                break
            }
        }
    }
}

if ($shouldAppend) {
    Append-VgoUtf8NoBomText -Path $ledgerPath -Content (($entry | ConvertTo-Json -Compress) + [Environment]::NewLine)
}

if ($legacyReleaseDocumentsEnabled) {
    New-Item -ItemType Directory -Force -Path $releaseNotesDir | Out-Null
    if (-not (Test-Path -LiteralPath $releaseNotePath)) {
        $note = New-ReleaseNoteTemplate -Version $Version -Updated $Updated -Head $head -Summary $releaseSummary
        Write-Text -Path $releaseNotePath -Content $note
    }

    if (Test-Path -LiteralPath $releaseReadmePath) {
        Update-ReleasesReadmeSurface -Path $releaseReadmePath -Version $Version -Updated $Updated -Summary $releaseSummary
    }
}

if (Test-Path -LiteralPath $syncScript) {
    Invoke-SyncBundledVibeScript -ScriptPath $syncScript -PruneBundledExtras
    if ($LASTEXITCODE -ne 0) {
        throw 'sync-bundled-vibe failed'
    }
}

Sync-DistManifestOutputs -RepoRoot $repoRoot

if ($RunGates) {
    foreach ($rel in $applyGateScripts) {
        $gatePath = Join-Path $repoRoot $rel
        if (-not (Test-Path -LiteralPath $gatePath)) {
            throw "required gate script missing: $rel"
        }
        Invoke-ReleaseGateScript -GatePath $gatePath
        if ($LASTEXITCODE -ne 0) {
            throw "gate failed: $rel"
        }
    }
}

Write-Host 'Release cut complete.' -ForegroundColor Green
Write-Host ("version={0}, updated={1}" -f $Version, $Updated)
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