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/runtime/Write-RequirementDoc.ps1

View on GitHub
param(
    [Parameter(Mandatory)] [string]$Task,
    [string]$Mode = 'interactive_governed',
    [string]$RunId = '',
    [string]$IntentContractPath = '',
    [string]$RuntimeInputPacketPath = '',
    [string]$MemoryContextPath = '',
    [string]$ArtifactRoot = '',
    [AllowEmptyString()] [string]$WorkspaceRoot = '',
    [AllowEmptyString()] [string]$GovernanceScope = '',
    [AllowEmptyString()] [string]$RootRunId = '',
    [AllowEmptyString()] [string]$ParentRunId = '',
    [AllowEmptyString()] [string]$ParentUnitId = '',
    [AllowEmptyString()] [string]$InheritedRequirementDocPath = '',
    [AllowEmptyString()] [string]$InheritedExecutionPlanPath = '',
    [AllowEmptyString()] [string]$DelegationEnvelopePath = ''
)

Set-StrictMode -Version Latest
$ErrorActionPreference = 'Stop'

. (Join-Path $PSScriptRoot 'VibeRuntime.Common.ps1')
. (Join-Path $PSScriptRoot 'VibeSkillRouting.Common.ps1')
. (Join-Path $PSScriptRoot '..\common\AntiProxyGoalDrift.ps1')

function Add-VibeMarkdownSection {
    param(
        [Parameter(Mandatory)] [ref]$Lines,
        [Parameter(Mandatory)] [string]$Heading,
        [AllowEmptyCollection()] [string[]]$BodyLines = @()
    )

    $filteredBodyLines = @($BodyLines | Where-Object { -not [string]::IsNullOrWhiteSpace([string]$_) })
    if (@($filteredBodyLines).Count -eq 0) {
        return
    }

    $Lines.Value += @('', ('## {0}' -f $Heading))
    $Lines.Value += @($filteredBodyLines)
}

function New-VibeBulletLines {
    param([AllowEmptyCollection()] [string[]]$Items = @())

    return @(
        $Items |
            ForEach-Object { [string]$_ } |
            Where-Object { -not [string]::IsNullOrWhiteSpace($_) } |
            ForEach-Object { '- ' + $_ }
    )
}

function Get-VibeDefaultCodeTaskTddEvidenceRequirements {
    return @(
        'Record failing-first evidence for the changed behavior before implementation or defect correction.',
        'Record the green rerun that proves the targeted behavior passed after implementation.',
        'Map the changed behavior to targeted verification evidence; generic suite success alone is insufficient.',
        'If automated failing-first evidence is not appropriate, freeze and honor an explicit code-task TDD exception instead of silently skipping the requirement.'
    )
}

function Get-VibeProductAcceptanceCriteria {
    param(
        [Parameter(Mandatory)] [object]$IntentContract
    )

    $criteria = @()
    foreach ($item in @($IntentContract.acceptance_criteria)) {
        if (-not [string]::IsNullOrWhiteSpace([string]$item)) {
            $criteria += [string]$item
        }
    }
    $criteria += 'The delivered output must satisfy observable behavior implied by the frozen goal and deliverable, not only internal runtime progress.'
    $criteria += 'Full completion wording is allowed only after downstream delivery truth is passing.'
    return @($criteria | Select-Object -Unique)
}

function Get-VibeCompletionLanguagePolicy {
    return @(
        'Full completion wording is allowed only when governance truth, engineering verification truth, workflow completion truth, and product acceptance truth are all passing.',
        '`completed_with_failures`, degraded execution, or pending manual actions must be reported as non-complete states.',
        'If manual spot checks remain pending, the run must be described as requiring manual review rather than fully ready.'
    )
}

function Get-VibeDeliveryTruthContractLines {
    return @(
        'Governance truth: requirement, plan, execution, and cleanup artifacts remain traceable and authoritative.',
        'Engineering verification truth: targeted verification passes or fails explicitly; silence does not count as success.',
        'Workflow completion truth: planned units, delegated lanes, and specialist outputs reconcile back into the governed plan.',
        'Product acceptance truth: observable deliverable behavior satisfies frozen acceptance criteria before full completion language is allowed.'
    )
}

function Get-VibeOptionalFrozenItems {
    param(
        [Parameter(Mandatory)] [object]$IntentContract,
        [Parameter(Mandatory)] [string[]]$PropertyNames
    )

    $items = @()
    foreach ($propertyName in @($PropertyNames)) {
        if ($null -ne $IntentContract -and $IntentContract.PSObject.Properties.Name -contains $propertyName) {
            foreach ($item in @($IntentContract.$propertyName)) {
                if (-not [string]::IsNullOrWhiteSpace([string]$item)) {
                    $items += [string]$item
                }
            }
        }
    }

    return @($items | Select-Object -Unique)
}

function Get-VibeSelectedCapsuleList {
    param(
        [AllowNull()] [object]$ContextPack = $null
    )

    if (
        $null -eq $ContextPack -or
        -not ($ContextPack.PSObject.Properties.Name -contains 'selected_capsules') -or
        $null -eq $ContextPack.selected_capsules
    ) {
        return @()
    }

    return @($ContextPack.selected_capsules | Where-Object { $null -ne $_ })
}

$runtime = Get-VibeRuntimeContext -ScriptPath $PSCommandPath
if ([string]::IsNullOrWhiteSpace($RunId)) {
    $RunId = New-VibeRunId
}

$artifactContract = Get-VibeArtifactContractDescriptor -RepoRoot $runtime.repo_root -RunId $RunId -WorkspaceRoot $WorkspaceRoot -ArtifactRoot $ArtifactRoot
$sessionRoot = Ensure-VibeSessionRoot -RepoRoot $runtime.repo_root -RunId $RunId -Runtime $runtime -WorkspaceRoot $WorkspaceRoot -ArtifactRoot $ArtifactRoot
$hierarchyState = Get-VibeHierarchyState `
    -GovernanceScope $GovernanceScope `
    -RunId $RunId `
    -RootRunId $RootRunId `
    -ParentRunId $ParentRunId `
    -ParentUnitId $ParentUnitId `
    -InheritedRequirementDocPath $InheritedRequirementDocPath `
    -InheritedExecutionPlanPath $InheritedExecutionPlanPath `
    -DelegationEnvelopePath $DelegationEnvelopePath `
    -HierarchyContract $runtime.runtime_input_packet_policy.hierarchy_contract
$hasFrozenIntentContract = -not [string]::IsNullOrWhiteSpace($IntentContractPath) -and (Test-Path -LiteralPath $IntentContractPath)
if ($hasFrozenIntentContract) {
    $intentContract = Get-Content -LiteralPath $IntentContractPath -Raw -Encoding UTF8 | ConvertFrom-Json
} else {
    $intentContract = New-VibeIntentContractObject -Task $Task -Mode $Mode
}

$isChildScope = ([string]$hierarchyState.governance_scope -eq 'child')
Assert-VibeInheritedCanonicalDocumentPaths `
    -HierarchyState $hierarchyState `
    -RepoRoot $runtime.repo_root `
    -WorkspaceRoot $WorkspaceRoot `
    -ArtifactRoot $ArtifactRoot
$docPath = if ($isChildScope) {
    if ([string]::IsNullOrWhiteSpace([string]$hierarchyState.inherited_requirement_doc_path)) {
        throw 'Child-governed requirement stage requires InheritedRequirementDocPath.'
    }
    [string]$hierarchyState.inherited_requirement_doc_path
} else {
    Get-VibeRequirementDocPath `
        -RepoRoot $runtime.repo_root `
        -Task $Task `
        -RunId $RunId `
        -ArtifactRoot $ArtifactRoot `
        -WorkspaceRoot $WorkspaceRoot
}
$primaryRequirementPath = if ($isChildScope) {
    $null
} else {
    [string]$artifactContract.paths.primary_requirement
}
$legacyDocumentationWrite = [bool](
    -not $isChildScope -and
    [string]$artifactContract.legacy_write_mode -eq 'dual_write'
)
$legacyRequirementPath = if ($legacyDocumentationWrite) {
    Get-VibeLegacyRequirementDocPath `
        -RepoRoot $runtime.repo_root `
        -Task $Task `
        -ArtifactRoot $ArtifactRoot `
        -WorkspaceRoot $WorkspaceRoot
} else {
    $null
}
$publishedRequirementPath = if ($isChildScope) { $docPath } else { $primaryRequirementPath }
$antiDriftDraft = New-VgoAntiProxyGoalDriftDraft -PrimaryObjective $intentContract.goal
$productAcceptanceCriteria = Get-VibeProductAcceptanceCriteria -IntentContract $intentContract
$completionLanguagePolicy = Get-VibeCompletionLanguagePolicy
$deliveryTruthContract = Get-VibeDeliveryTruthContractLines
$artifactReviewRequirements = Get-VibeOptionalFrozenItems -IntentContract $intentContract -PropertyNames @('artifact_review_requirements', 'artifactReviewRequirements')
$codeTaskTddEvidenceRequirements = Get-VibeOptionalFrozenItems -IntentContract $intentContract -PropertyNames @('code_task_tdd_evidence_requirements', 'codeTaskTddEvidenceRequirements')
$codeTaskTddExceptions = Get-VibeOptionalFrozenItems -IntentContract $intentContract -PropertyNames @('code_task_tdd_exceptions', 'codeTaskTddExceptions')
$taskSpecificAcceptanceExtensions = Get-VibeOptionalFrozenItems -IntentContract $intentContract -PropertyNames @('task_specific_acceptance_extensions', 'taskSpecificAcceptanceExtensions')
$researchAugmentationSources = Get-VibeOptionalFrozenItems -IntentContract $intentContract -PropertyNames @('research_augmentation_sources', 'researchAugmentationSources')
$baselineDocumentQualityDimensions = Get-VibeOptionalFrozenItems -IntentContract $intentContract -PropertyNames @('baseline_document_quality_dimensions', 'baselineDocumentQualityDimensions')
$baselineUiQualityDimensions = Get-VibeOptionalFrozenItems -IntentContract $intentContract -PropertyNames @('baseline_ui_quality_dimensions', 'baselineUiQualityDimensions')
$manualSpotChecks = if (@($baselineUiQualityDimensions).Count -gt 0) {
    @(
        'Open the primary user-facing flow and confirm the main path works from entry to completion.',
        'Exercise one meaningful unhappy-path or validation-path interaction and record whether behavior matches the frozen requirement.'
    )
} else {
    @('None required beyond automated verification for this task unless the execution scope expands to a user-visible or interactive flow.')
}
$runtimeInputPath = if (-not [string]::IsNullOrWhiteSpace($RuntimeInputPacketPath)) {
    $RuntimeInputPacketPath
} else {
    Get-VibeRuntimeInputPacketPath -RepoRoot $runtime.repo_root -RunId $RunId -ArtifactRoot $ArtifactRoot
}
$runtimeInputPacket = if (-not [string]::IsNullOrWhiteSpace($runtimeInputPath) -and (Test-Path -LiteralPath $runtimeInputPath)) {
    Get-Content -LiteralPath $runtimeInputPath -Raw -Encoding UTF8 | ConvertFrom-Json
} else {
    $null
}
$codeTaskTddDecision = if (
    $hasFrozenIntentContract -and
    $intentContract.PSObject.Properties.Name -contains 'code_task_tdd_decision' -and
    $null -ne $intentContract.code_task_tdd_decision
) {
    $intentContract.code_task_tdd_decision
} elseif (
    $runtimeInputPacket -and
    $runtimeInputPacket.PSObject.Properties.Name -contains 'code_task_tdd_decision' -and
    $null -ne $runtimeInputPacket.code_task_tdd_decision
) {
    $runtimeInputPacket.code_task_tdd_decision
} else {
    $null
}
$hostExplicitTddNotApplicable = (
    $codeTaskTddDecision -and
    [string]$codeTaskTddDecision.source -eq 'host_decision' -and
    [string]$codeTaskTddDecision.mode -eq 'not_applicable'
)
if ($codeTaskTddDecision -and @($codeTaskTddEvidenceRequirements).Count -gt 0 -and -not $hostExplicitTddNotApplicable) {
    $codeTaskTddDecision.mode = 'required'
    $codeTaskTddDecision.source = 'intent_contract'
    $codeTaskTddDecision.reason = 'Explicit code-task TDD evidence requirements were supplied by the intent contract.'
} elseif ($codeTaskTddDecision -and @($codeTaskTddExceptions).Count -gt 0 -and -not $hostExplicitTddNotApplicable) {
    $codeTaskTddDecision.mode = 'exception_approved'
    $codeTaskTddDecision.source = 'intent_contract'
    $codeTaskTddDecision.reason = 'Explicit code-task TDD exception requirements were supplied by the intent contract.'
}
if ($codeTaskTddDecision -and [string]$codeTaskTddDecision.mode -eq 'required' -and @($codeTaskTddEvidenceRequirements).Count -eq 0) {
    $codeTaskTddEvidenceRequirements = Get-VibeDefaultCodeTaskTddEvidenceRequirements
} elseif ($codeTaskTddDecision -and [string]$codeTaskTddDecision.mode -eq 'exception_approved') {
    $codeTaskTddEvidenceRequirements = @()
    if (@($codeTaskTddExceptions).Count -eq 0) {
        $exceptionReason = if ($codeTaskTddDecision -and -not [string]::IsNullOrWhiteSpace([string]$codeTaskTddDecision.exception)) {
            [string]$codeTaskTddDecision.exception
        } else {
            'Host approved a bounded code-task TDD exception; execution must record fallback verification evidence instead of strict red/green sequencing.'
        }
        $codeTaskTddExceptions = @($exceptionReason)
    }
} elseif ($codeTaskTddDecision -and [string]$codeTaskTddDecision.mode -eq 'not_applicable') {
    $codeTaskTddEvidenceRequirements = @()
    if ($hostExplicitTddNotApplicable) {
        $codeTaskTddExceptions = @()
    }
}
$memoryContextPack = if (-not [string]::IsNullOrWhiteSpace($MemoryContextPath) -and (Test-Path -LiteralPath $MemoryContextPath)) {
    Get-Content -LiteralPath $MemoryContextPath -Raw -Encoding UTF8 | ConvertFrom-Json
} else {
    $null
}
$lines = @("# $($intentContract.title)")
Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Goal' -BodyLines @([string]$intentContract.goal)
Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Deliverable' -BodyLines @([string]$intentContract.deliverable)
Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Constraints' -BodyLines (New-VibeBulletLines -Items @($intentContract.constraints))
Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Acceptance Criteria' -BodyLines (New-VibeBulletLines -Items @($intentContract.acceptance_criteria))
Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Product Acceptance Criteria' -BodyLines (New-VibeBulletLines -Items @($productAcceptanceCriteria))
Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Manual Spot Checks' -BodyLines (New-VibeBulletLines -Items @($manualSpotChecks))
Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Completion Language Policy' -BodyLines (New-VibeBulletLines -Items @($completionLanguagePolicy))
Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Delivery Truth Contract' -BodyLines (New-VibeBulletLines -Items @($deliveryTruthContract))
Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Artifact Review Requirements' -BodyLines (New-VibeBulletLines -Items @($artifactReviewRequirements))

if ($codeTaskTddDecision -and [string]$codeTaskTddDecision.mode -ne 'not_applicable') {
    Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Code Task TDD Mode' -BodyLines @(
        ('TDD mode: {0}' -f [string]$codeTaskTddDecision.mode),
        ('Decision source: {0}' -f [string]$codeTaskTddDecision.source),
        ('Reason: {0}' -f [string]$codeTaskTddDecision.reason)
    )
}

Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Code Task TDD Evidence Requirements' -BodyLines (New-VibeBulletLines -Items @($codeTaskTddEvidenceRequirements))
Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Code Task TDD Exceptions' -BodyLines (New-VibeBulletLines -Items @($codeTaskTddExceptions))
Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Baseline Document Quality Dimensions' -BodyLines (New-VibeBulletLines -Items @($baselineDocumentQualityDimensions))
Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Baseline UI Quality Dimensions' -BodyLines (New-VibeBulletLines -Items @($baselineUiQualityDimensions))
Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Task-Specific Acceptance Extensions' -BodyLines (New-VibeBulletLines -Items @($taskSpecificAcceptanceExtensions))
Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Research Augmentation Sources' -BodyLines (New-VibeBulletLines -Items @($researchAugmentationSources))
$nonGoalLines = @(New-VibeBulletLines -Items @($intentContract.non_goals))
if (@($nonGoalLines).Count -gt 0) {
    $lines += @('', 'Non-goals:')
    $lines += @($nonGoalLines)
}
$workflowLevelConfirmation = if (
    $intentContract.PSObject.Properties.Name -contains 'workflow_level_confirmation' -and
    $null -ne $intentContract.workflow_level_confirmation
) {
    $intentContract.workflow_level_confirmation
} else {
    $null
}
if ($workflowLevelConfirmation) {
    $skillSearchGuide = if (
        $runtimeInputPacket -and
        $runtimeInputPacket.PSObject.Properties.Name -contains 'skill_search_guide' -and
        $null -ne $runtimeInputPacket.skill_search_guide
    ) {
        $runtimeInputPacket.skill_search_guide
    } else {
        New-VibeSkillSearchGuideProjection -RepoRoot $runtime.repo_root
    }
    $skillSearchGuideLines = @()
    $workflowLevelLines = @()
    $skillSearchGuideLines += @(Get-VibeSkillSearchGuideLines -SkillSearchGuide $skillSearchGuide)
Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Skill Search Guide' -BodyLines @($skillSearchGuideLines)
    $workflowLevelLines += @(Get-VibeWorkflowLevelConfirmationLines -WorkflowLevelConfirmation $workflowLevelConfirmation)
    Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Workflow Level Confirmation' -BodyLines @($workflowLevelLines)
} else {
    Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Workflow Level Confirmation' -BodyLines @('No workflow level confirmation was recorded in the intent contract.')
}
Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Assumptions' -BodyLines (New-VibeBulletLines -Items @($intentContract.assumptions))

if ($runtimeInputPacket) {
    $entryIntentId = if (
        $runtimeInputPacket.PSObject.Properties.Name -contains 'entry_intent_id' -and
        -not [string]::IsNullOrWhiteSpace([string]$runtimeInputPacket.entry_intent_id)
    ) {
        [string]$runtimeInputPacket.entry_intent_id
    } else {
        'vibe'
    }
    $requestedStageStop = if (
        $runtimeInputPacket.PSObject.Properties.Name -contains 'requested_stage_stop' -and
        -not [string]::IsNullOrWhiteSpace([string]$runtimeInputPacket.requested_stage_stop)
    ) {
        [string]$runtimeInputPacket.requested_stage_stop
    } else {
        'phase_cleanup'
    }
    $requestedGradeFloor = if (
        $runtimeInputPacket.PSObject.Properties.Name -contains 'requested_grade_floor' -and
        -not [string]::IsNullOrWhiteSpace([string]$runtimeInputPacket.requested_grade_floor)
    ) {
        [string]$runtimeInputPacket.requested_grade_floor
    } else {
        'none'
    }

    $hostReentryAction = if (
        $runtimeInputPacket.PSObject.Properties.Name -contains 'continuation_context' -and
        $null -ne $runtimeInputPacket.continuation_context -and
        $runtimeInputPacket.continuation_context.PSObject.Properties.Name -contains 'reentry_action'
    ) {
        [string]$runtimeInputPacket.continuation_context.reentry_action
    } elseif (
        $runtimeInputPacket.PSObject.Properties.Name -contains 'host_reentry_action' -and
        -not [string]::IsNullOrWhiteSpace([string]$runtimeInputPacket.host_reentry_action)
    ) {
        [string]$runtimeInputPacket.host_reentry_action
    } else {
        ''
    }
    $hostRevisionTargetStage = if (
        $runtimeInputPacket.PSObject.Properties.Name -contains 'continuation_context' -and
        $null -ne $runtimeInputPacket.continuation_context -and
        $runtimeInputPacket.continuation_context.PSObject.Properties.Name -contains 'revision_target_stage'
    ) {
        [string]$runtimeInputPacket.continuation_context.revision_target_stage
    } elseif (
        $runtimeInputPacket.PSObject.Properties.Name -contains 'host_revision_target_stage' -and
        -not [string]::IsNullOrWhiteSpace([string]$runtimeInputPacket.host_revision_target_stage)
    ) {
        [string]$runtimeInputPacket.host_revision_target_stage
    } else {
        ''
    }
    $hostRevisionDelta = if (
        $runtimeInputPacket.PSObject.Properties.Name -contains 'continuation_context' -and
        $null -ne $runtimeInputPacket.continuation_context -and
        $runtimeInputPacket.continuation_context.PSObject.Properties.Name -contains 'revision_delta'
    ) {
        @(Get-VibeNormalizedStringList -Values $runtimeInputPacket.continuation_context.revision_delta)
    } elseif (
        $runtimeInputPacket.PSObject.Properties.Name -contains 'host_revision_delta' -and
        $null -ne $runtimeInputPacket.host_revision_delta
    ) {
        @(Get-VibeNormalizedStringList -Values $runtimeInputPacket.host_revision_delta)
    } else {
        @()
    }
    if ([string]$hostReentryAction -eq 'revise' -and @($hostRevisionDelta).Count -gt 0) {
        Add-VibeMarkdownSection -Lines ([ref]$lines) -Heading 'Host Revision Delta' -BodyLines @(
            ('- Re-entry action: {0}' -f [string]$hostReentryAction),
            ('- Revision target stage: {0}' -f $(if ([string]::IsNullOrWhiteSpace($hostRevisionTargetStage)) { 'requirement_doc' } else { [string]$hostRevisionTargetStage })),
            @(New-VibeBulletLines -Items @($hostRevisionDelta))
        )
    }

}

$selectedMemoryCapsules = @(Get-VibeSelectedCapsuleList -ContextPack $memoryContextPack)

$childHandoffPath = $null
if ($isChildScope) {
    if (-not (Test-Path -LiteralPath $docPath)) {
        throw ("Child-governed requirement stage cannot inherit missing canonical requirement doc: {0}" -f $docPath)
    }

    $childHandoffPath = Join-Path $sessionRoot 'child-requirement-handoff.md'
    $handoffLines = @(
        "# Child Requirement Handoff",
        '',
        '- governance_scope: child',
        ('- inherited_requirement_doc: {0}' -f $docPath),
        ('- root_run_id: {0}' -f [string]$hierarchyState.root_run_id),
        ('- parent_run_id: {0}' -f [string]$hierarchyState.parent_run_id),
        ('- parent_unit_id: {0}' -f [string]$hierarchyState.parent_unit_id),
        '- canonical_write_allowed: false',
        '',
        'Child-governed lanes inherit the frozen root requirement and may not create a second canonical requirement surface.'
    )
    Write-VibeMarkdownArtifact -Path $childHandoffPath -Lines $handoffLines
} else {
    Write-VibeMarkdownArtifact -Path $primaryRequirementPath -Lines $lines
    if ($legacyDocumentationWrite) {
        Write-VibeMarkdownArtifact -Path $legacyRequirementPath -Lines $lines
    }
}

$receipt = [pscustomobject]@{
    stage = 'requirement_doc'
    run_id = $RunId
    governance_scope = [string]$hierarchyState.governance_scope
    mode = $Mode
    requirement_doc_path = $publishedRequirementPath
    primary_requirement_path = $primaryRequirementPath
    legacy_requirement_doc_path = $legacyRequirementPath
    child_requirement_handoff_path = $childHandoffPath
    canonical_write_allowed = -not $isChildScope
    inherited_requirement_doc_path = if ($isChildScope) { $docPath } else { $null }
    runtime_input_packet_path = $runtimeInputPath
    code_task_tdd_decision = $codeTaskTddDecision
    memory_context_path = if ($memoryContextPack) { $MemoryContextPath } else { $null }
    memory_context_item_count = if ($memoryContextPack) { @($memoryContextPack.items).Count } else { 0 }
    memory_context_estimated_tokens = if ($memoryContextPack) { [int]$memoryContextPack.estimated_tokens } else { 0 }
    memory_disclosure_level = if ($memoryContextPack -and $memoryContextPack.PSObject.Properties.Name -contains 'disclosure_level') { [string]$memoryContextPack.disclosure_level } else { $null }
    memory_capsule_count = @($selectedMemoryCapsules).Count
    generated_at = (Get-Date).ToUniversalTime().ToString('yyyy-MM-ddTHH:mm:ssZ')
    artifact_contract = [pscustomobject]@{
        artifact_root = [string]$artifactContract.artifact_root
        requirement = [string]$artifactContract.paths.requirement
        manifest = [string]$artifactContract.paths.manifest
        legacy_documentation_write = $legacyDocumentationWrite
        legacy_write_mode = [string]$artifactContract.legacy_write_mode
        legacy_removal_release = [string]$artifactContract.legacy_removal_release
    }
}
$receiptPath = Join-Path $sessionRoot 'requirement-doc-receipt.json'
Write-VibeJsonArtifact -Path $receiptPath -Value $receipt

[pscustomobject]@{
    run_id = $RunId
    governance_scope = [string]$hierarchyState.governance_scope
    session_root = $sessionRoot
    requirement_doc_path = $publishedRequirementPath
    primary_requirement_path = $primaryRequirementPath
    legacy_requirement_doc_path = $legacyRequirementPath
    receipt_path = $receiptPath
    receipt = $receipt
    artifact_contract = $artifactContract
    requirement_artifact_path = [string]$artifactContract.paths.requirement
    artifact_manifest_path = [string]$artifactContract.paths.manifest
}
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: 322kUpdated Claude CodeCodexVerifiedInstall
requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirementsStars: 322kUpdated 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: 322kUpdated 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: 322kUpdated Claude CodeCodexVerifiedInstall