@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-control-plane-planning-listing.mjs

@@ -0,0 +1,48 @@
+export function createRuntimeControlPlanePlanningListing({
+  listStateFiles,
+  plannerRoutesDirectory,
+  plannerPlansDirectory,
+  plannerBriefsDirectory,
+  routerPlansDirectory,
+  routerApprovalsDirectory,
+  orchestratorPlansDirectory,
+  orchestratorDispatchPlansDirectory,
+}) {
+  function listPlannerRouteFiles(root) {
+    return listStateFiles(root, plannerRoutesDirectory, '.planner-route.json');
+  }
+
+  function listPlannerPlanFiles(root) {
+    return listStateFiles(root, plannerPlansDirectory, '.planner-plan.json');
+  }
+
+  function listPlannerBriefsFiles(root) {
+    return listStateFiles(root, plannerBriefsDirectory, '.planner-briefs.json');
+  }
+
+  function listRouterPlanFiles(root) {
+    return listStateFiles(root, routerPlansDirectory, '.router-plan.json');
+  }
+
+  function listRouterApprovalFiles(root) {
+    return listStateFiles(root, routerApprovalsDirectory, '.router-approval.json');
+  }
+
+  function listOrchestratorPlanFiles(root) {
+    return listStateFiles(root, orchestratorPlansDirectory, '.orchestrator-plan.json');
+  }
+
+  function listOrchestratorDispatchPlanFiles(root) {
+    return listStateFiles(root, orchestratorDispatchPlansDirectory, '.orchestrator-dispatch-plan.json');
+  }
+
+  return {
+    listPlannerRouteFiles,
+    listPlannerPlanFiles,
+    listPlannerBriefsFiles,
+    listRouterPlanFiles,
+    listRouterApprovalFiles,
+    listOrchestratorPlanFiles,
+    listOrchestratorDispatchPlanFiles,
+  };
+}

package/tools/vibe-runtime/runtime-control-plane-planning-presentation.mjs

@@ -0,0 +1,246 @@
+import path from 'node:path';
+import process from 'node:process';
+
+export function createRuntimeControlPlanePlanningPresentation({ printList }) {
+  function printPlanLint(envelope) {
+    const lint = envelope.plan_lint;
+    console.log('Vibecoding Runtime Plan Quality Lint');
+    console.log(`Stage: ${lint.stage}; Ready: ${lint.execution_ready ? 'true' : 'false'}`);
+    console.log(`Source: ${lint.source_file}`);
+    console.log(`Checks: ${lint.summary.check_count}; Blockers: ${lint.summary.blocker_count}; Warnings: ${lint.summary.warning_count}`);
+    for (const check of lint.checks) console.log(`- ${check.id}: ${check.status}`);
+    console.log(`Manual action: ${lint.manual_action}`);
+    console.log('Boundary: writes=false; plan_lint_artifact=false; command_execution=false; runtime_action=false; git=false; worktree=false; platform_api=false; subagent=false');
+    console.log(`Lint digest: ${lint.lint_digest}`);
+    if (lint.blocking_findings.length > 0) printList('Blocking findings', lint.blocking_findings);
+    if (lint.warnings.length > 0) printList('Warnings', lint.warnings);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printPlanActionManifest(envelope) {
+    const manifest = envelope.plan_action_manifest;
+    console.log('Vibecoding Runtime Plan-to-Action Manifest');
+    console.log(`Stage: ${manifest.stage}; Kind: ${manifest.manifest_kind}; pass=${manifest.manifest_invariants.pass}`);
+    console.log(`Source: ${manifest.source_plan.file}; Lines: ${manifest.source_plan.line_count}`);
+    console.log(`Action items: ${manifest.action_items.length}; Docs expectations: ${manifest.docs_expectations.length}; Code expectations: ${manifest.code_expectations.length}; Check expectations: ${manifest.check_expectations.length}`);
+    for (const item of manifest.action_items.slice(0, 12)) console.log(`- ${item.id}: ${item.phase}; execution_authorized=false; ${item.title}`);
+    console.log(`Source bindings: plan_lint=${manifest.source_bindings.plan_lint_digest}; workflow_loop_contract=${manifest.source_bindings.workflow_loop_contract_digest}; automation_readiness=${manifest.source_bindings.automation_readiness_digest}; registry=${manifest.source_bindings.registry_digest}`);
+    printList('Allowed followup', manifest.allowed_followup);
+    printList('Forbidden actions', manifest.forbidden_actions);
+    console.log('Boundary: writes=false; plan_action_manifest_artifact=false; automation_plan_artifact=false; command_execution=false; test_execution=false; repair_execution=false; formatting_execution=false; code_generation=false; git=false; pr=false; push=false; merge=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; business_source_write=false');
+    console.log(`Plan action manifest digest: ${manifest.plan_action_manifest_digest}`);
+    if (manifest.manifest_invariants.findings.length > 0) printList('Findings', manifest.manifest_invariants.findings);
+    console.log(`Manual action: ${manifest.manual_action}`);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printExecutablePlanContract(envelope) {
+    const contract = envelope.executable_plan_contract;
+    console.log('Vibecoding Runtime Executable Plan Quality Contract');
+    console.log(`Stage: ${contract.stage}; Kind: ${contract.contract_kind}; pass=${contract.executable_plan_invariants.pass}`);
+    console.log(`Source: ${contract.source_plan.file}; Lines: ${contract.source_plan.line_count}`);
+    console.log(`Plan quality score: ${contract.plan_quality_score}/${contract.quality_threshold}; pass=${contract.plan_quality_pass}`);
+    console.log(`Tasks: ${contract.task_readiness.length}; Missing requirements: ${contract.missing_requirements.length}; Blocked reasons: ${contract.blocked_reasons.length}`);
+    console.log(`Task quality: pass=${contract.task_quality_contract.pass}; per_task_gates=${contract.task_quality_contract.per_task_gates.length}; blocking_gaps=${contract.task_quality_contract.blocking_gaps.length}`);
+    console.log(`Failure mode: blocking_gaps_only=${contract.failure_mode.blocking_gaps_only}; auto_repair=${contract.failure_mode.auto_repair}; plan_mutation=${contract.failure_mode.plan_mutation}`);
+    for (const item of contract.task_readiness.slice(0, 12)) console.log(`- ${item.id}: ${item.readiness_status}; execution_authorized=false; files=${item.files_to_change.length}; checks=${item.verification_commands.length}; markers=${item.expected_output_markers.length}; stop_conditions=${item.stop_conditions.length}; ${item.title}`);
+    console.log(`Source bindings: plan_lint=${contract.source_bindings.plan_lint_digest}; registry=${contract.source_bindings.registry_digest}`);
+    printList('Missing requirements', contract.missing_requirements);
+    printList('Blocked reasons', contract.blocked_reasons);
+    printList('Allowed followup', contract.allowed_followup);
+    printList('Forbidden actions', contract.forbidden_actions);
+    console.log('Boundary: writes=false; executable_plan_artifact=false; plan_repair_artifact=false; source_write=false; sidecar_write=false; state_directory_created=false; command_execution=false; check_execution=false; test_execution=false; repair_execution=false; action_item_execution=false; git=false; git_write=false; commit=false; pr=false; push=false; merge=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; business_source_write=false');
+    console.log(`Executable plan digest: ${contract.executable_plan_digest}`);
+    if (contract.executable_plan_invariants.findings.length > 0) printList('Findings', contract.executable_plan_invariants.findings);
+    console.log(`Manual action: ${contract.manual_action}`);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printSelfTestGateProfile(envelope) {
+    const profile = envelope.self_test_gate_profile;
+    console.log('Vibecoding Runtime Self-test Gate Profile');
+    console.log(`Stage: ${profile.stage}; Kind: ${profile.profile_kind}; pass=${profile.profile_invariants.pass}`);
+    console.log(`Gate items: ${profile.gate_items.length}; syntax=${profile.coverage.categories.syntax}; runtime_contract=${profile.coverage.categories.runtime_contract}; release_contract=${profile.coverage.categories.release_contract}; diff_hygiene=${profile.coverage.categories.diff_hygiene}`);
+    for (const item of profile.gate_items.slice(0, 12)) console.log(`- ${item.id}: ${item.category}; status=planned_not_run; execution_authorized=false; ${item.command}`);
+    console.log(`Source bindings: plan_action_manifest=${profile.source_bindings.plan_action_manifest_digest}; registry=${profile.source_bindings.registry_digest}`);
+    printList('Recommended order', profile.recommended_order);
+    printList('Forbidden actions', profile.forbidden_actions);
+    console.log('Boundary: writes=false; self_test_gate_profile_artifact=false; test_result_artifact=false; command_execution=false; test_execution=false; repair_execution=false; git=false; pr=false; push=false; merge=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; business_source_write=false');
+    console.log(`Self-test gate profile digest: ${profile.self_test_gate_profile_digest}`);
+    if (profile.profile_invariants.findings.length > 0) printList('Findings', profile.profile_invariants.findings);
+    console.log(`Manual action: ${profile.manual_action}`);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printCommitReadiness(envelope) {
+    const readiness = envelope.commit_readiness;
+    console.log('Vibecoding Runtime Commit Readiness Envelope');
+    console.log(`Stage: ${readiness.stage}; Kind: ${readiness.readiness_kind}; pass=${readiness.readiness_invariants.pass}`);
+    console.log(`Readiness: envelope_valid=${readiness.readiness_state.envelope_valid}; commit_ready=false; manual_evidence_required=${readiness.readiness_state.manual_evidence_required}; commit_execution_authorized=false`);
+    console.log(`Commit subject: guard_pass=${readiness.commit_subject.guard_pass}; subject_count=${readiness.commit_subject.subject_count}; commit_execution_authorized=false`);
+    for (const item of readiness.readiness_gates) console.log(`- ${item.id}: ${item.gate_kind}; status=${item.status}; execution_authorized=false; commit_execution_authorized=false`);
+    console.log(`Source bindings: plan_action_manifest=${readiness.source_bindings.plan_action_manifest_digest}; self_test_gate_profile=${readiness.source_bindings.self_test_gate_profile_digest}; commit_guard=${readiness.source_bindings.commit_guard_digest}; registry=${readiness.source_bindings.registry_digest}`);
+    printList('Readiness order', readiness.readiness_order);
+    printList('Forbidden actions', readiness.forbidden_actions);
+    console.log('Boundary: writes=false; commit_readiness_artifact=false; commit_artifact=false; command_execution=false; test_execution=false; git=false; git_write=false; commit=false; pr=false; push=false; merge=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; business_source_write=false');
+    console.log(`Commit readiness digest: ${readiness.commit_readiness_digest}`);
+    if (readiness.readiness_invariants.findings.length > 0) printList('Findings', readiness.readiness_invariants.findings);
+    console.log(`Manual action: ${readiness.manual_action}`);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printStagedCommitReadiness(envelope) {
+    const readiness = envelope.staged_commit_readiness;
+    console.log('Vibecoding Runtime Staged Commit Readiness Contract');
+    console.log(`Stage: ${readiness.stage}; Kind: ${readiness.readiness_kind}; pass=${readiness.staged_commit_readiness_invariants.pass}`);
+    console.log(`Readiness: stage_id=${readiness.stage_id}; evidence_pass=${readiness.evidence_pass}; diff_coverage_required=${readiness.diff_coverage_required}; diff_coverage_evidence_bound=${readiness.commit_readiness_gate.diff_coverage_evidence_bound}; contract_ready=${readiness.staged_commit_readiness.contract_ready}; commit_allowed_by_contract=false`);
+    console.log(`Commit readiness gate: pass=${readiness.commit_readiness_gate.pass}; required_categories=${readiness.commit_readiness_gate.required_evidence_categories.length}; missing_categories=${readiness.commit_readiness_gate.missing_evidence_categories.length}; stage_119_category_gate_pass=${readiness.commit_readiness_gate.stage_119_category_gate_pass}; git=false`);
+    console.log(`Subject: pass=${readiness.subject_guard.pass}; subject=${readiness.subject_guard.subject}; expected=${readiness.subject_guard.expected_subject || 'not-provided'}; suggested=${readiness.suggested_commit_subject || 'not-provided'}; commit_execution_authorized=false`);
+    for (const item of readiness.stage_evidence_category_gate) console.log(`- evidence category gate: ${item.stage_id}; pass=${item.pass}; diff_coverage_evidence_bound=${item.diff_coverage_evidence_bound}; source_gate_found=${item.source_gate_found}; execution_authorized=false`);
+    for (const item of readiness.stage_evidence_status) console.log(`- evidence: ${item.stage_id}; ready_for_next_stage=${item.ready_for_next_stage}; status=${item.status}; execution_authorized=false`);
+    printList('Required files', readiness.required_files);
+    printList('Validation commands', readiness.validation_commands);
+    console.log(`Source bindings: runbook=${readiness.source_bindings.stage_runbook_digest || 'not-provided'}; execution_evidence=${readiness.source_bindings.execution_evidence_digest || 'not-provided'}; registry=${readiness.source_bindings.registry_digest}`);
+    printList('Blocked reasons', readiness.blocked_reasons);
+    printList('Forbidden actions', readiness.forbidden_actions);
+    console.log('Boundary: writes=false; staged_commit_readiness_artifact=false; commit_artifact=false; evidence_artifact_write=false; source_write=false; runbook_mutation=false; evidence_mutation=false; worktree_mutation=false; sidecar_write=false; state_directory_created=false; command_execution=false; check_execution=false; test_execution=false; repair_execution=false; runtime_action=false; git=false; git_write=false; commit=false; pr=false; push=false; merge=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; business_source_write=false');
+    console.log(`Staged commit readiness digest: ${readiness.staged_commit_readiness_digest}`);
+    if (readiness.staged_commit_readiness_invariants.findings.length > 0) printList('Findings', readiness.staged_commit_readiness_invariants.findings);
+    console.log(`Manual action: ${readiness.manual_action}`);
+    console.log(`Next action: ${readiness.manual_or_agent_commit_next_action}`);
+    console.log(`Recovery: ${readiness.recovery_guidance}`);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printEvidenceIntake(envelope) {
+    const intake = envelope.evidence_intake;
+    console.log('Vibecoding Runtime Evidence Intake Envelope');
+    console.log(`Stage: ${intake.stage}; Kind: ${intake.intake_kind}; pass=${intake.evidence_intake_invariants.pass}`);
+    console.log(`Evidence: checks=${intake.evidence_intake.check_count}; structure_valid=${intake.evidence_intake.structure_valid}; freshness_valid=${intake.evidence_intake.freshness_valid}; gate_coverage_complete=${intake.evidence_intake.gate_coverage_complete}`);
+    console.log(`Gate coverage: expected=${intake.gate_coverage.expected_gate_ids.length}; covered=${intake.gate_coverage.covered_gate_ids.length}; missing=${intake.gate_coverage.missing_gate_ids.length}; stage_110_executed_checks=false`);
+    for (const item of intake.evidence_items) console.log(`- ${item.id}: gate=${item.gate_id || 'none'}; exit_status=${item.exit_status}; fresh=${item.freshness.fresh}; command_executed_by_stage_110=false; execution_authorized=false`);
+    console.log(`Source bindings: evidence=${intake.source_evidence.digest}; plan_action_manifest=${intake.source_bindings.plan_action_manifest_digest || 'not-provided'}; self_test_gate_profile=${intake.source_bindings.self_test_gate_profile_digest || 'not-provided'}; registry=${intake.source_bindings.registry_digest}`);
+    printList('Forbidden actions', intake.forbidden_actions);
+    console.log('Boundary: writes=false; evidence_intake_artifact=false; evidence_artifact_write=false; command_execution=false; check_execution=false; test_execution=false; git=false; git_write=false; commit=false; pr=false; push=false; merge=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; business_source_write=false');
+    console.log(`Evidence intake digest: ${intake.evidence_intake_digest}`);
+    if (intake.freshness_findings.length > 0) printList('Freshness findings', intake.freshness_findings.map((item) => `${item.id}: ${item.reason}`));
+    if (intake.blocked_reasons.length > 0) printList('Blocked reasons', intake.blocked_reasons);
+    console.log(`Manual action: ${intake.manual_action}`);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printExecutionEvidenceBinding(envelope) {
+    const binding = envelope.execution_evidence_binding;
+    console.log('Vibecoding Runtime Execution Evidence Binding');
+    console.log(`Stage: ${binding.stage}; Kind: ${binding.binding_kind}; pass=${binding.execution_evidence_invariants.pass}`);
+    console.log(`Binding: stages=${binding.execution_evidence_binding.runbook_stage_count}; evidence=${binding.execution_evidence_binding.evidence_item_count}; selected_stage=${binding.execution_evidence_binding.selected_stage}; ready_for_next_stage=${binding.ready_for_next_stage}`);
+    console.log(`Evidence category gate: pass=${binding.execution_evidence_binding.category_gate_pass}; required_categories=${binding.execution_evidence_binding.required_evidence_category_count}; missing_categories=${binding.execution_evidence_binding.missing_evidence_category_count}; first_class=tdd_trace,review,diff_coverage`);
+    for (const item of binding.stage_evidence_status.slice(0, 12)) console.log(`- ${item.stage_id}: status=${item.status}; matched=${item.matched_evidence_count}; categories=${item.evidence_category_gate.covered_categories.join(',') || 'none'}; missing_categories=${item.missing_evidence_categories.join(',') || 'none'}; missing=${item.missing_evidence.length}; stale=${item.stale_evidence.length}; failed=${item.failed_commands.length}; execution_authorized=false`);
+    console.log(`Source bindings: runbook=${binding.source_bindings.stage_runbook_digest || 'not-provided'}; evidence=${binding.source_evidence.digest}; registry=${binding.source_bindings.registry_digest}`);
+    printList('Missing evidence categories', binding.missing_evidence_categories.map((item) => `${item.stage_id}: ${item.category}`));
+    printList('Missing evidence', binding.missing_evidence.map((item) => `${item.stage_id}: ${item.requirement}`));
+    printList('Stale evidence', binding.stale_evidence.map((item) => `${item.stage_id}: ${item.command || item.evidence_id}`));
+    printList('Failed commands', binding.failed_commands.map((item) => `${item.stage_id}: ${item.command || item.evidence_id}; exit_status=${item.exit_status}`));
+    printList('Blocked reasons', binding.blocked_reasons);
+    printList('Forbidden actions', binding.forbidden_actions);
+    console.log('Boundary: writes=false; execution_evidence_artifact=false; evidence_artifact_write=false; source_write=false; runbook_mutation=false; sidecar_write=false; state_directory_created=false; command_execution=false; check_execution=false; test_execution=false; repair_execution=false; runtime_action=false; git=false; git_write=false; commit=false; pr=false; push=false; merge=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; business_source_write=false');
+    console.log(`Execution evidence digest: ${binding.execution_evidence_digest}`);
+    if (binding.execution_evidence_invariants.findings.length > 0) printList('Findings', binding.execution_evidence_invariants.findings);
+    console.log(`Manual action: ${binding.manual_action}`);
+    console.log(`Resume guidance: ${binding.resume_guidance}`);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printTddTraceContract(envelope) {
+    const contract = envelope.tdd_trace_contract;
+    console.log('Vibecoding Runtime TDD Trace Contract');
+    console.log(`Stage: ${contract.stage}; Kind: ${contract.trace_kind}; pass=${contract.tdd_trace_invariants.pass}`);
+    console.log(`Cycle: ${contract.cycle_order.expected}; valid=${contract.cycle_order.valid}; test_execution_by_stage_113=false; command_execution_by_stage_113=false`);
+    console.log(`RED: verified=${contract.red_verified.verified}; exit_status=${contract.red_verified.exit_status}; expected_failure=${contract.red_verified.expected_failure}; execution_authorized=false`);
+    console.log(`GREEN: verified=${contract.green_verified.verified}; exit_status=${contract.green_verified.exit_status}; execution_authorized=false`);
+    console.log(`REFACTOR: verified=${contract.refactor_verified.verified}; exit_status=${contract.refactor_verified.exit_status}; skipped=${contract.refactor_verified.skipped}; execution_authorized=false`);
+    console.log(`Coverage: covered=${contract.coverage.covered_action_items.length}; expected=${contract.coverage.expected_action_items.length}; missing=${contract.coverage.missing_expected_action_items.length}; plan_bound=${contract.coverage.plan_bound}`);
+    if (contract.verification_gate_chain) console.log(`Verification gate: ready_for_closeout=${contract.verification_gate_chain.ready_for_closeout}; can_claim_verified=${contract.verification_gate_chain.can_claim_verified}; blockers=${contract.verification_gate_chain.blocked_reasons.length}`);
+    console.log(`Source bindings: trace=${contract.source_trace.digest}; plan_action_manifest=${contract.source_bindings.plan_action_manifest_digest || 'not-provided'}; registry=${contract.source_bindings.registry_digest}`);
+    printList('Covered action items', contract.covered_action_items);
+    printList('Forbidden actions', contract.forbidden_actions);
+    console.log('Boundary: writes=false; tdd_trace_artifact=false; test_result_artifact=false; command_execution=false; check_execution=false; test_execution=false; repair_execution=false; git=false; git_write=false; commit=false; pr=false; push=false; merge=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; business_source_write=false');
+    console.log(`TDD trace digest: ${contract.tdd_trace_digest}`);
+    if (contract.blocked_reasons.length > 0) printList('Blocked reasons', contract.blocked_reasons);
+    console.log(`Manual action: ${contract.manual_action}`);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printPlanner(envelope, file = '') {
+    console.log('Vibecoding Runtime Planner');
+    console.log(`Mode: ${envelope.mode}`);
+    if (envelope.planner_route) {
+      console.log(`Intent: ${envelope.planner_route.intent_type}`);
+      console.log(`Risk: ${envelope.planner_route.risk_level} (${envelope.planner_route.risk_score})`);
+      console.log(`Workflow: ${(envelope.planner_route.selected_workflow || []).join(' -> ')}`);
+    } else if (envelope.planner_plan) {
+      console.log(`Tasks: ${(envelope.planner_plan.task_graph || []).length}`);
+      console.log(`Conflicts: ${(envelope.planner_plan.conflict_groups || []).length}`);
+    } else if (envelope.planner_briefs) {
+      console.log(`Brief kind: ${envelope.planner_briefs.brief_kind}`);
+      console.log(`Brief items: ${(envelope.planner_briefs.brief_items || []).length}`);
+    } else if (envelope.summary) {
+      console.log(`File: ${envelope.summary.file}`);
+      console.log(`Artifact mode: ${envelope.summary.artifact_mode || 'list'}`);
+    }
+    if (file) console.log(`Artifact: ${path.relative(process.cwd(), file)}`);
+    if (envelope.quality?.length > 0) printList('Blocked reasons', envelope.quality);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printRouter(envelope, file = '') {
+    console.log('Vibecoding Runtime Router');
+    console.log(`Mode: ${envelope.mode}`);
+    if (envelope.router_plan) {
+      console.log(`Routes: ${(envelope.router_plan.brief_routes || []).length}`);
+      console.log(`Blocked: ${(envelope.router_plan.blocked_reasons || []).length}`);
+    } else if (envelope.router_approval) {
+      console.log(`Approval: ${envelope.router_approval.approval_status}`);
+      console.log(`Plan: ${envelope.router_approval.plan_file}`);
+    } else if (envelope.summary) {
+      console.log(`File: ${envelope.summary.file}`);
+      console.log(`Artifact mode: ${envelope.summary.artifact_mode || 'list'}`);
+    }
+    if (file) console.log(`Artifact: ${path.relative(process.cwd(), file)}`);
+    if (envelope.quality?.length > 0) printList('Blocked reasons', envelope.quality);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printOrchestrator(envelope, file = '') {
+    console.log('Vibecoding Runtime Orchestrator');
+    console.log(`Mode: ${envelope.mode}`);
+    if (envelope.orchestrator_plan) {
+      console.log(`Lanes: ${(envelope.orchestrator_plan.lanes || []).length}`);
+      console.log(`Dispatch order: ${(envelope.orchestrator_plan.dispatch_order || []).length}`);
+    } else if (envelope.orchestrator_dispatch_plan) {
+      console.log(`Targets: ${(envelope.orchestrator_dispatch_plan.dispatch_targets || []).length}`);
+      console.log(`Status: ${envelope.orchestrator_dispatch_plan.dispatch_plan_status}`);
+    } else if (envelope.summary) {
+      console.log(`File: ${envelope.summary.file}`);
+      console.log(`Artifact mode: ${envelope.summary.artifact_mode || 'list'}`);
+    }
+    if (file) console.log(`Artifact: ${path.relative(process.cwd(), file)}`);
+    if (envelope.quality?.length > 0) printList('Blocked reasons', envelope.quality);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  return {
+    printPlanLint,
+    printPlanActionManifest,
+    printExecutablePlanContract,
+    printSelfTestGateProfile,
+    printCommitReadiness,
+    printStagedCommitReadiness,
+    printEvidenceIntake,
+    printExecutionEvidenceBinding,
+    printTddTraceContract,
+    printPlanner,
+    printRouter,
+    printOrchestrator,
+  };
+}