@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-workflow-presentation.mjs

@@ -0,0 +1,355 @@
+export function createWorkflowPresentation({ printList }) {
+  function printHumanFriendlyAlias(envelope) {
+    const alias = envelope.human_friendly_alias;
+    console.log('Vibecoding Runtime Human-friendly Alias');
+    console.log(`Kind: ${alias.alias_kind}; pass=${alias.human_friendly_alias_invariants.pass}`);
+    for (const label of alias.labels) {
+      const section = alias.sections[label] || {};
+      console.log(`${label}: pass=${section.pass}; ${section.summary}; execution_authorized=false`);
+    }
+    if (alias.next_evidence) console.log(`Next evidence: ${alias.next_evidence.kind}; ${alias.next_evidence.action}`);
+    console.log(`Source bindings: plan_action_manifest=${alias.source_bindings.plan_action_manifest_digest || 'not-provided'}; close_loop_dashboard=${alias.source_bindings.close_loop_dashboard_digest || 'not-provided'}; evidence=${alias.source_bindings.evidence_intake_digest || 'not-provided'}; diff=${alias.source_bindings.diff_coverage_digest || 'not-provided'}; review=${alias.source_bindings.review_intake_digest || 'not-provided'}; tdd=${alias.source_bindings.tdd_trace_digest || 'not-provided'}; registry=${alias.source_bindings.registry_digest}`);
+    printList('Allowed followup', alias.allowed_followup);
+    printList('Forbidden actions', alias.forbidden_actions);
+    console.log('Boundary: writes=false; human_friendly_alias_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(`Human-friendly alias digest: ${alias.human_friendly_alias_digest}`);
+    if (alias.evidence_gaps?.length > 0) printList('Evidence gaps', alias.evidence_gaps.map((gap) => `${gap.kind}: ${gap.action}`));
+    if (alias.human_friendly_alias_invariants.findings.length > 0) printList('Findings', alias.human_friendly_alias_invariants.findings);
+    console.log(`Manual action: ${alias.manual_action}`);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printNextActionConsole(envelope) {
+    const panel = envelope.next_action_console;
+    console.log('Vibecoding Runtime One-screen Next Action Console');
+    console.log(`Stage: ${panel.stage}; Kind: ${panel.console_kind}; pass=${panel.ok}`);
+    console.log(`Current position: friction=${panel.current_position.friction_level}; score=${panel.current_position.friction_score}; top=${panel.current_position.top_friction}`);
+    console.log(`Recommended next action: ${panel.recommended_next_action.id}; target=${panel.recommended_next_action.target_stage}`);
+    console.log(`Action: ${panel.recommended_next_action.action}`);
+    console.log(`Why now: ${panel.why_now}`);
+    printList('Copy-ready command preview', panel.copy_ready_command_preview.map((item) => `${item.id}: ${item.command}`));
+    printList('Evidence needed next', panel.evidence_needed_next.map((item) => `${item.id}: ${item.reason}`));
+    printList('Do not do yet', panel.do_not_do_yet);
+    console.log('Boundary: writes=false; next_action_console_artifact=false; command_execution=false; check_execution=false; test_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; evidence_write=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(`Next action console digest: ${panel.console_digest}`);
+    console.log(`Contract action: ${envelope.action}`);
+  }
+
+  function printEntryTriggerDiscipline(envelope) {
+    const discipline = envelope.entry_trigger_discipline;
+    console.log('Vibecoding Runtime Entry Trigger Discipline Contract');
+    console.log(`Stage: ${discipline.stage}; Kind: ${discipline.discipline_kind}; pass=${discipline.pass}`);
+    console.log(`Intent: ${discipline.intent}; Transcript: ${discipline.source_bindings.transcript_file}; Messages: ${discipline.transcript_summary.message_count}`);
+    console.log(`Expected route: ${discipline.expected_route.required_workflow.join(' -> ')}`);
+    console.log(`Protocol layers: L0=${discipline.protocol_layers.l0_lightweight_routing}; L1=${discipline.protocol_layers.l1_full_workflow_when_risky}; L2=${discipline.protocol_layers.l2_confirmed_execution_only}`);
+    for (const gate of discipline.trigger_results) console.log(`- ${gate.gate}: pass=${gate.pass}`);
+    if (discipline.missed_workflow_risks.length > 0) printList('Missed workflow risks', discipline.missed_workflow_risks);
+    console.log(`Minimum next action: ${discipline.minimum_next_action}`);
+    console.log('Boundary: writes=false; entry_discipline_artifact=false; transcript_write=false; source_write=false; sidecar_write=false; state_directory_created=false; command_execution=false; check_execution=false; test_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; auto_execution=false; git=false; git_write=false; git_add=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(`Entry discipline digest: ${discipline.discipline_digest}`);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printCloseLoopDashboard(envelope) {
+    const dashboard = envelope.close_loop_dashboard;
+    console.log('Vibecoding Runtime Close-loop Dashboard');
+    console.log(`Stage: ${dashboard.stage}; Kind: ${dashboard.dashboard_kind}; pass=${dashboard.dashboard_invariants.pass}`);
+    console.log(`Plan: pass=${dashboard.plan_status.pass}; action_items=${dashboard.plan_status.action_item_count}; execution_authorized=false`);
+    console.log(`Docs: expectations=${dashboard.docs_status.expectation_count}; gaps=${dashboard.docs_status.gaps.length}`);
+    console.log(`Code: expectations=${dashboard.code_status.expectation_count}; gaps=${dashboard.code_status.gaps.length}`);
+    console.log(`Self-test: gates=${dashboard.self_test_status.gate_count}; planned_not_run=${dashboard.self_test_status.planned_not_run_count}; test_execution_authorized=false`);
+    console.log(`Commit: gates=${dashboard.commit_status.readiness_gate_count}; subject_guard_pass=${dashboard.commit_status.subject_guard_pass}; commit_ready=false; commit_execution_authorized=false`);
+    console.log(`One-shot: confirmation_provided=${dashboard.one_shot_status.confirmation_provided}; plan_confirmed=${dashboard.one_shot_status.plan_confirmed}; ready_for_runtime_execution=false; actions_executed=false; execution_authorized=false`);
+    console.log(`Source bindings: plan_action_manifest=${dashboard.source_bindings.plan_action_manifest_digest}; self_test_gate_profile=${dashboard.source_bindings.self_test_gate_profile_digest}; commit_readiness=${dashboard.source_bindings.commit_readiness_digest}; confirmed_one_shot_plan=${dashboard.source_bindings.confirmed_one_shot_plan_digest || 'not-provided'}; automation_readiness=${dashboard.source_bindings.automation_readiness_digest}; registry=${dashboard.source_bindings.registry_digest}`);
+    printList('Allowed followup', dashboard.allowed_followup);
+    printList('Forbidden actions', dashboard.forbidden_actions);
+    console.log('Boundary: writes=false; close_loop_dashboard_artifact=false; command_execution=false; test_execution=false; check_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(`Close-loop dashboard digest: ${dashboard.close_loop_dashboard_digest}`);
+    if (dashboard.dashboard_invariants.findings.length > 0) printList('Findings', dashboard.dashboard_invariants.findings);
+    console.log(`Manual action: ${dashboard.manual_action}`);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printWorkflowReadiness(envelope) {
+    const readiness = envelope.workflow_readiness;
+    console.log('Vibecoding Runtime Workflow Readiness');
+    console.log(`Stage: ${readiness.stage}; Intent: ${readiness.normalized_intent}; Ready: ${readiness.ready_to_start ? 'true' : 'false'}`);
+    console.log(`First skill: ${readiness.route_summary.first_skill}`);
+    console.log(`Workflow: ${readiness.route_summary.selected_workflow.join(' -> ')}`);
+    console.log(`Required gates: ${readiness.required_gate_kinds.length > 0 ? readiness.required_gate_kinds.join(', ') : 'none'}`);
+    for (const gate of readiness.gate_previews) console.log(`- ${gate.kind}: ${gate.outcome}; blocked=${gate.blocked_count}`);
+    console.log(`Runtime readiness: ${readiness.runtime_readiness_summary.grade} (${readiness.runtime_readiness_summary.overall_score})`);
+    console.log(`Advice lane: ${readiness.advice_hub_summary.primary_lane}; command=${readiness.advice_hub_summary.recommended_command}`);
+    console.log(`Manual action: ${readiness.manual_action}`);
+    console.log(`Verification: ${readiness.verification_hint}`);
+    console.log('Boundary: writes=false; workflow_readiness_artifact=false; methodology_gate_write=false; command_execution=false; runtime_action=false; git=false; worktree=false; pr=false; push=false; merge=false; platform_api=false; subagent=false; mcp=false');
+    console.log(`Readiness digest: ${readiness.readiness_digest}`);
+    if (readiness.blocked_reasons.length > 0) printList('Blocked reasons', readiness.blocked_reasons);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printWorkflowCockpit(envelope) {
+    const cockpit = envelope.workflow_cockpit;
+    console.log('Vibecoding Runtime Workflow Cockpit');
+    console.log(`Stage: ${cockpit.stage}; Phase: ${cockpit.current_phase}; Intent: ${cockpit.normalized_intent}`);
+    console.log(`Next skill: ${cockpit.recommended_next_skill}`);
+    console.log(`Readiness: ${cockpit.readiness_summary.ready_to_start ? 'ready' : 'blocked'}`);
+    console.log(`Plan lint: ${cockpit.plan_lint_summary.status}`);
+    if (cockpit.self_check_summary) {
+      const summary = cockpit.self_check_summary;
+      console.log(`Self-check loop: profile=${summary.profile_check.status}; entry=${summary.entry_check.current_phase}; readiness_blockers=${summary.readiness_check.blocker_count}; completion=${summary.completion_check.status}`);
+      console.log(`Evidence gaps: blockers=${summary.evidence_gap_count}; required=${summary.required_evidence_count}`);
+    }
+    console.log(`Primary advice: ${cockpit.advice_summary.primary_lane} -> ${cockpit.advice_summary.primary_command}`);
+    printList('Required evidence', cockpit.required_evidence);
+    printList('Forbidden actions', cockpit.forbidden_actions);
+    console.log(`Manual action: ${cockpit.next_manual_action}`);
+    console.log('Boundary: writes=false; workflow_cockpit_artifact=false; command_execution=false; runtime_action=false; git=false; worktree=false; platform_api=false; subagent=false');
+    console.log(`Cockpit digest: ${cockpit.cockpit_digest}`);
+    if (cockpit.blocked_reasons.length > 0) printList('Blocked reasons', cockpit.blocked_reasons);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printWorkflowReceipt(envelope) {
+    const receipt = envelope.workflow_receipt;
+    console.log('Vibecoding Runtime Workflow Receipt');
+    console.log(`Stage: ${receipt.stage}; Layer: ${receipt.recommended_layer}; Intent: ${receipt.normalized_intent}`);
+    console.log(`Selected skill: ${receipt.selected_skill}`);
+    console.log(`Visible sentence: ${receipt.user_visible_sentence}`);
+    console.log(`Handoff required: ${receipt.handoff_required ? 'true' : 'false'}`);
+    printList('False-claim guardrails', receipt.false_claim_guardrails);
+    console.log('Boundary: writes=false; workflow_receipt_artifact=false; skill_execution=false; command_execution=false; runtime_action=false; platform_api=false; subagent=false');
+    console.log(`Receipt digest: ${receipt.receipt_digest}`);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printWorkflowStart(envelope) {
+    const start = envelope.workflow_start;
+    console.log('Vibecoding Runtime Workflow Start');
+    console.log(`Stage: ${start.stage}; Intent: ${start.normalized_intent}`);
+    console.log(`Entry: ${start.entry_contract_summary.required_decision}; pass=${start.entry_contract_summary.pass ? 'true' : 'false'}`);
+    console.log(`Visible receipt: ${start.receipt_summary.user_visible_sentence}`);
+    console.log(`Phase: ${start.cockpit_summary.current_phase}; Next skill: ${start.cockpit_summary.recommended_next_skill}`);
+    console.log(`Readiness: ${start.readiness_summary.ready_to_start ? 'ready' : 'blocked'}`);
+    console.log(`Plan lint: ${start.plan_lint_summary.status}`);
+    console.log(`Entry summary: ${start.entry_summary?.entry_classification || 'unknown'}; state_gap_expected=${start.entry_summary?.state_gap_is_expected ? 'true' : 'false'}; blockers=${start.entry_summary?.readiness_blocker_count ?? start.blocked_reasons.length}`);
+    console.log(`First decision: ${start.entry_summary?.first_user_decision || start.next_manual_action}`);
+    if (start.start_here_contract) {
+      const contract = start.start_here_contract;
+      console.log(`Start Here Contract: profile=${contract.automation_profile}; first_skill=${contract.expected_first_skill}; skill_path=${contract.skill_path}`);
+      console.log(`Visible first sentence: ${contract.visible_first_sentence}`);
+      console.log(`Next gate: ${contract.next_gate}; validation_strategy_required=${contract.validation_strategy_required_before_change}`);
+      printList('Stop conditions', contract.stop_conditions);
+    }
+    if (start.profile_contract_summary?.skill_first_receipt) {
+      const profileReceipt = start.profile_contract_summary.skill_first_receipt;
+      console.log(`Skill-first receipt: skill=${profileReceipt.selected_skill}; next_gate=${profileReceipt.next_gate}; skill_execution_claimed=${profileReceipt.skill_execution_claimed}`);
+      console.log(`Route reason: ${profileReceipt.route_reason}`);
+      printList('Must not do yet', profileReceipt.must_not_do_yet);
+    }
+    printList('Forbidden actions', start.forbidden_actions);
+    console.log(`Manual action: ${start.next_manual_action}`);
+    console.log('Boundary: writes=false; workflow_start_artifact=false; skill_execution=false; command_execution=false; runtime_action=false; git=false; platform_api=false; subagent=false');
+    console.log(`Start digest: ${start.start_digest}`);
+    if (start.blocked_reasons.length > 0) printList('Blocked reasons', start.blocked_reasons);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printSessionStart(envelope) {
+    const alias = envelope.session_start_alias;
+    const start = envelope.workflow_start;
+    console.log('Vibecoding Runtime Session Start');
+    console.log(`Stage: ${alias.stage}; Kind: ${alias.alias_kind}; canonical=${alias.canonical_command}`);
+    console.log(`Selected skill: ${alias.selected_skill}`);
+    console.log(`Manual action: ${alias.next_manual_action}`);
+    if (start?.start_here_contract) {
+      const contract = start.start_here_contract;
+      console.log(`Start Here Contract: profile=${contract.automation_profile}; first_skill=${contract.expected_first_skill}; skill_path=${contract.skill_path}`);
+      console.log(`Visible first sentence: ${contract.visible_first_sentence}`);
+      console.log(`Next gate: ${contract.next_gate}; validation_strategy_required=${contract.validation_strategy_required_before_change}`);
+      printList('Stop conditions', contract.stop_conditions);
+    }
+    printList('Forbidden actions', start?.forbidden_actions || []);
+    console.log('Boundary: writes=false; session_start_alias_artifact=false; workflow_start_artifact=false; skill_execution=false; command_execution=false; runtime_action=false; git=false; git_write=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; business_source_write=false');
+    console.log(`Alias digest: ${alias.alias_digest}`);
+    console.log(`Workflow start digest: ${alias.workflow_start_digest}`);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printSkillSelect(envelope) {
+    const alias = envelope.skill_select_alias;
+    const receipt = envelope.workflow_receipt;
+    console.log('Vibecoding Runtime Skill Select');
+    console.log(`Stage: ${alias.stage}; Kind: ${alias.alias_kind}; canonical=${alias.canonical_command}`);
+    console.log(`Selected skill: ${alias.selected_skill}`);
+    console.log(`Visible sentence: ${alias.user_visible_sentence}`);
+    console.log(`Skill execution claimed: ${alias.skill_execution_claimed}`);
+    console.log(`Workflow execution claimed: ${alias.workflow_execution_claimed}`);
+    printList('False-claim guardrails', receipt?.false_claim_guardrails || []);
+    console.log('Boundary: writes=false; skill_select_alias_artifact=false; workflow_receipt_artifact=false; skill_execution=false; workflow_execution=false; command_execution=false; runtime_action=false; git=false; git_write=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; business_source_write=false');
+    console.log(`Alias digest: ${alias.alias_digest}`);
+    console.log(`Receipt digest: ${alias.workflow_receipt_digest}`);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printSessionCheckpoint(envelope) {
+    const checkpoint = envelope.session_checkpoint;
+    console.log('Vibecoding Runtime Session Checkpoint');
+    console.log(`Stage: ${checkpoint.stage}; Kind: ${checkpoint.checkpoint_kind}`);
+    console.log(`Intent: ${checkpoint.route.normalized_intent}; Selected skill: ${checkpoint.selected_skill}`);
+    console.log(`Next gate: ${checkpoint.route.next_gate}`);
+    console.log(`Manual action: ${checkpoint.next_manual_action}`);
+    console.log(`Evidence source: ${checkpoint.evidence_summary.source_file || 'not provided'}`);
+    printList('Blocked gates', checkpoint.blocked_gates);
+    printList('Forbidden actions', checkpoint.forbidden_actions);
+    console.log('Boundary: writes=false; session_checkpoint_artifact=false; skill_execution=false; command_execution=false; runtime_action=false; git=false; git_write=false; platform_api=false; subagent=false; business_source_write=false');
+    console.log(`Checkpoint digest: ${checkpoint.checkpoint_digest}`);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printSessionHandoff(envelope) {
+    const handoff = envelope.session_handoff;
+    console.log('Vibecoding Runtime Session Handoff');
+    console.log(`Stage: ${handoff.stage}; Kind: ${handoff.checkpoint_kind}`);
+    console.log(`Current skill: ${handoff.handoff_contract.current_skill}; Next skill/gate: ${handoff.handoff_contract.next_skill}`);
+    console.log(`Manual action: ${handoff.next_manual_action}`);
+    console.log(`Stop condition: ${handoff.handoff_contract.stop_condition}`);
+    printList('Risks', handoff.handoff_contract.handoff.risks);
+    printList('Forbidden actions', handoff.forbidden_actions);
+    console.log('Boundary: writes=false; session_handoff_artifact=false; skill_execution=false; command_execution=false; runtime_action=false; git=false; git_write=false; platform_api=false; subagent=false; business_source_write=false');
+    console.log(`Handoff digest: ${handoff.handoff_digest}`);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printSessionResume(envelope) {
+    const resume = envelope.session_resume;
+    console.log('Vibecoding Runtime Session Resume');
+    console.log(`Stage: ${resume.stage}; Kind: ${resume.resume_kind}; source=${resume.source_file}`);
+    console.log(`Selected skill: ${resume.selected_skill}`);
+    console.log(`Next gate: ${resume.route.next_gate || 'manual_workflow_judgment'}`);
+    console.log(`Manual action: ${resume.next_manual_action}`);
+    console.log(`Source verification: ${resume.resume_verification.pass ? 'pass' : 'blocked'}`);
+    printList('Blocked gates', resume.blocked_gates);
+    console.log('Boundary: writes=false; session_resume_artifact=false; skill_execution=false; command_execution=false; runtime_action=false; git=false; git_write=false; platform_api=false; subagent=false; business_source_write=false');
+    console.log(`Resume digest: ${resume.resume_digest}`);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printWorkflowRunPlan(envelope) {
+    const plan = envelope.workflow_run_plan;
+    console.log('Vibecoding Runtime Workflow Run Plan');
+    console.log(`Stage: ${plan.stage}; Kind: ${plan.plan_kind}; pass=${plan.ok}`);
+    console.log(`Intent: ${plan.normalized_intent}; Selected skill: ${plan.selected_skill}; claimed_used=${plan.selected_skill_claimed_used}`);
+    console.log(`Workflow start: ${plan.workflow_start_summary.entry_classification}; blockers=${plan.workflow_start_summary.readiness_blocker_count}`);
+    printList('Required inputs', plan.required_inputs.map((item) => `${item.id}: ${item.status}; required=${item.required}`));
+    console.log(`Expected handoff: ${plan.expected_handoff.handoff_kind}; sidecar_required=${plan.expected_handoff.handoff_sidecar_required}; sidecar_written=${plan.expected_handoff.handoff_sidecar_written}`);
+    printList('Evidence requirements', plan.evidence_requirements.map((item) => `${item.id}: ${item.status}; required=${item.required}`));
+    printList('Stop conditions', plan.stop_conditions);
+    printList('Single-step chain', plan.single_step_chain.map((item) => `${item.step_id}: ${item.target_skill}; execution_authorized=${item.execution_authorized}; sidecar_write_authorized=${item.sidecar_write_authorized}`));
+    printList('Forbidden actions', plan.forbidden_actions);
+    console.log('Boundary: writes=false; workflow_run_plan_artifact=false; evidence_write=false; workflow_execution=false; skill_execution=false; command_execution=false; check_execution=false; test_execution=false; runtime_action=false; auto_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(`Run plan digest: ${plan.run_plan_digest}`);
+    if (plan.workflow_run_plan_invariants.findings.length > 0) printList('Findings', plan.workflow_run_plan_invariants.findings);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printEntryRuntimeSummary(envelope) {
+    const summary = envelope.entry_runtime_summary;
+    console.log('Vibecoding Runtime Entry Summary');
+    console.log(`Stage: ${summary.stage}; Intent: ${summary.normalized_intent}; pass=${summary.ok}`);
+    console.log(`Entry: ${summary.entry_decision.classification}; skill=${summary.entry_decision.selected_skill}; blockers=${summary.entry_decision.readiness_blocker_count}`);
+    console.log(`Token profile: ${summary.token_budget.recommended_profile}; max_context_tokens=${summary.token_budget.max_context_tokens}`);
+    console.log(`Learning: ${summary.learning_advice.recommended_next_learning_step}; automatic_promotion=${summary.learning_advice.automatic_promotion}`);
+    console.log(`Context load: ${summary.context_load_plan.plan_kind}; profile=${summary.context_load_plan.recommended_profile}; full_skill_text_loaded=${summary.context_load_plan.full_skill_text_loaded}`);
+    printList('Context load order', summary.context_load_plan.load_order.map((item) => `${item.id}: ${item.load}; limit=${item.token_limit}; ${item.reason}`));
+    printList('Expansion triggers', summary.defer_policy.expansion_triggers.map((item) => `${item.id}: ${item.load}; ${item.condition}`));
+    printList('Never defer', summary.defer_policy.never_defer);
+    printList('Surface now', summary.surface_now.map((item) => `${item.id}: ${item.value}; ${item.reason}`));
+    printList('Defer until needed', summary.defer_until_needed.map((item) => `${item.id}: ${item.value}; ${item.reason}`));
+    printList('Forbidden actions', summary.forbidden_actions);
+    console.log(`Manual action: ${summary.next_manual_action}`);
+    console.log('Boundary: writes=false; entry_runtime_summary_artifact=false; command_execution=false; check_execution=false; test_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; auto_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(`Entry summary digest: ${summary.summary_digest}`);
+    if (summary.entry_runtime_summary_invariants.findings.length > 0) printList('Findings', summary.entry_runtime_summary_invariants.findings);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printProgressiveEntryUx(envelope) {
+    const contract = envelope.progressive_entry_ux;
+    console.log('Vibecoding Runtime Progressive Entry UX');
+    console.log(`Stage: ${contract.stage}; Kind: ${contract.contract_kind}; pass=${contract.entry_ux_invariants.pass}`);
+    console.log(`Intent: ${contract.normalized_intent}`);
+    console.log(`Recommended workflow: ${contract.recommended_workflow}`);
+    console.log(`Why: ${contract.why_this_route}`);
+    console.log(`Minimum next action: ${contract.minimum_next_action}`);
+    console.log(`Visible sentence: ${contract.visible_sentence}`);
+    console.log(`Bootstrap policy: ${contract.bootstrap_policy.marker}; session_create=${contract.bootstrap_policy.session_create}; skill_execution_claimed=${contract.bootstrap_policy.skill_execution_claimed}`);
+    printList('Do not do yet', contract.do_not_do_yet);
+    console.log(`Gap binding: provided=${contract.source_bindings.gap_matrix_provided}; file=${contract.source_bindings.gap_file || 'none'}; stage116_gap_found=${contract.source_bindings.stage116_gap_found}`);
+    console.log('Boundary: writes=false; progressive_entry_ux_artifact=false; command_execution=false; skill_execution=false; workflow_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(`Entry UX digest: ${contract.contract_digest}`);
+    if (contract.entry_ux_invariants.findings.length > 0) printList('Findings', contract.entry_ux_invariants.findings);
+    console.log(`Manual action: ${contract.manual_action}`);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printWorkflowSequence(envelope) {
+    const sequence = envelope.workflow_sequence;
+    console.log('Vibecoding Runtime Workflow Sequence');
+    console.log(`Stage: ${sequence.stage}; Intent: ${sequence.normalized_intent}`);
+    printList('Phase order', sequence.phase_order);
+    printList('Entry criteria', sequence.phase_entry_criteria);
+    printList('Exit evidence', sequence.phase_exit_evidence);
+    printList('Handoff points', sequence.handoff_points);
+    printList('Stop conditions', sequence.stop_conditions);
+    console.log('Boundary: writes=false; workflow_sequence_artifact=false; skill_execution=false; command_execution=false; runtime_action=false; git=false; platform_api=false; subagent=false');
+    console.log(`Sequence digest: ${sequence.sequence_digest}`);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printWorkflowLoopContract(envelope) {
+    const contract = envelope.workflow_loop_contract;
+    console.log('Vibecoding Runtime Workflow Loop Contract');
+    console.log(`Stage: ${contract.stage}; Kind: ${contract.contract_kind}; pass=${contract.loop_contract_invariants.pass}`);
+    console.log(`Intent: ${contract.normalized_intent}`);
+    printList('Loop phases', contract.loop_phases);
+    for (const phase of contract.phase_contracts) {
+      console.log(`- ${phase.phase}: ${phase.recommended_skill_or_command}; exit=${phase.exit_receipt}`);
+    }
+    console.log(`Source bindings: workflow_start=${contract.source_bindings.workflow_start_digest}; workflow_sequence=${contract.source_bindings.workflow_sequence_digest}; automation_readiness=${contract.source_bindings.automation_readiness_digest}; registry=${contract.source_bindings.registry_digest}`);
+    if (contract.next_gate_summary) {
+      const gate = contract.next_gate_summary;
+      console.log(`Next gate: current=${gate.current_gate}; pass=${gate.pass}; next=${gate.next_gate}`);
+      printList('Next gate evidence', gate.required_evidence);
+      printList('Next gate blocked actions', gate.blocked_actions);
+    }
+    printList('Allowed followup', contract.allowed_followup);
+    printList('Forbidden actions', contract.forbidden_actions);
+    console.log('Boundary: writes=false; workflow_loop_contract_artifact=false; automation_plan_artifact=false; command_execution=false; runtime_action=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(`Loop contract digest: ${contract.loop_contract_digest}`);
+    if (contract.loop_contract_invariants.findings.length > 0) printList('Findings', contract.loop_contract_invariants.findings);
+    console.log(`Manual action: ${contract.manual_action}`);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  return {
+    printHumanFriendlyAlias,
+    printNextActionConsole,
+    printEntryTriggerDiscipline,
+    printCloseLoopDashboard,
+    printWorkflowReadiness,
+    printWorkflowCockpit,
+    printWorkflowReceipt,
+    printWorkflowStart,
+    printSessionStart,
+    printSkillSelect,
+    printSessionCheckpoint,
+    printSessionHandoff,
+    printSessionResume,
+    printWorkflowRunPlan,
+    printEntryRuntimeSummary,
+    printProgressiveEntryUx,
+    printWorkflowSequence,
+    printWorkflowLoopContract,
+  };
+}

package/tools/vibe-runtime/runtime-workflow-readiness-model.mjs

@@ -0,0 +1,176 @@
+import {
+  normalizeSkillRouteRegistryIntent,
+  skillRouteRegistryIntents,
+} from './runtime-skill-route-registry.mjs';
+
+export function workflowReadinessBoundaryAssertions() {
+  return {
+    writes: false,
+    state_directory_created: false,
+    workflow_readiness_artifact: false,
+    methodology_gate_write: false,
+    sidecar_write: false,
+    skill_execution: false,
+    command_execution: false,
+    runtime_action: false,
+    auto_execution: false,
+    external_network: false,
+    model_invocation: false,
+    platform_api: false,
+    git: false,
+    worktree: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    shell_interception: false,
+    business_source_write: false,
+    source_merge: false,
+  };
+}
+
+export function normalizeWorkflowReadinessIntent(intent) {
+  const value = String(intent || '').trim().toLowerCase().replace(/_/g, '-');
+  if (value === 'release') return 'release';
+  const normalized = normalizeSkillRouteRegistryIntent(value);
+  const known = new Set([...skillRouteRegistryIntents(), 'release']);
+  return known.has(normalized) ? normalized : 'unknown';
+}
+
+export function workflowReadinessRouteIntent(intent) {
+  if (intent === 'release') return 'completion';
+  if (intent === 'unknown') return 'unknown';
+  return intent;
+}
+
+export function workflowReadinessAdviceIntent(intent) {
+  if (intent === 'debug') return 'bug';
+  if (intent === 'review') return 'review';
+  if (intent === 'completion' || intent === 'release') return 'closeout';
+  if (intent === 'unknown') return 'unknown';
+  return 'feature';
+}
+
+export function workflowReadinessGateKinds(route, intent, methodologyGateKinds) {
+  const selected = intent === 'release' ? ['completion'] : intent === 'unknown' ? [] : route.gate_kinds || [];
+  return [...new Set(selected)].filter((kind) => methodologyGateKinds.has(kind));
+}
+
+export function workflowReadinessGatePreview(envelope) {
+  const gate = envelope.methodology_gate;
+  return {
+    kind: gate.kind,
+    outcome: gate.outcome,
+    blocked_count: gate.blocked_reasons.length,
+    blocked_reasons: gate.blocked_reasons,
+    criteria: gate.criteria.map((item) => ({ id: item.id, status: item.status, blocked_reason: item.blocked_reason || '' })),
+    writes: false,
+    methodology_gate_artifact: false,
+  };
+}
+
+export function workflowReadinessRuntimeSummary(envelope) {
+  return {
+    stage: envelope.safety.stage,
+    readiness_kind: envelope.mode,
+    overall_score: envelope.readiness.overall_score,
+    grade: envelope.readiness.grade,
+    blocked_count: envelope.readiness.blocked_reasons.length,
+    warnings: envelope.readiness.warnings.slice(0, 5),
+    state_present: envelope.state_present,
+    writes: false,
+    observability_snapshot: false,
+  };
+}
+
+export function workflowReadinessAdviceHubSummary(envelope) {
+  const advice = envelope.advice_hub;
+  return {
+    stage: advice.stage,
+    advice_kind: advice.advice_kind,
+    normalized_intent: advice.normalized_intent,
+    primary_lane: advice.primary_lane,
+    recommended_command: advice.primary_recommendation.recommended_command,
+    manual_action: advice.primary_recommendation.manual_action,
+    verification_hint: advice.primary_recommendation.verification_hint,
+    advice_digest: advice.advice_digest,
+    writes: false,
+    state_directory_created: false,
+  };
+}
+
+export function workflowReadinessManualAction(intent, ready, route, blockedReasons) {
+  if (intent === 'unknown') return 'Clarify the workflow goal, scope, constraints, and acceptance criteria before entering implementation, review, or completion.';
+  if (!ready) return `Do not enter ${route.first_skill} yet. Resolve the blocked workflow gate evidence first: ${blockedReasons.slice(0, 3).join('; ')}`;
+  if (intent === 'implementation') return 'Enter the implementation workflow only after preserving the plan/TDD handoff; keep execution bounded to the accepted plan.';
+  if (intent === 'review') return 'Enter review with explicit scope, evidence, severity focus, and required-change criteria.';
+  if (intent === 'completion' || intent === 'release') return 'Enter completion verification with fresh command evidence before making completion or release claims.';
+  if (intent === 'debug') return 'Enter implementation only after reproduction, evidence, and root-cause status are recorded.';
+  return `Enter ${route.first_skill} and preserve the workflow handoff before the next stage.`;
+}
+
+export function workflowReadinessVerificationHint(intent) {
+  if (intent === 'implementation') return 'Check the plan and TDD gate previews; then run targeted syntax/unit/smoke checks for the files changed during implementation.';
+  if (intent === 'review') return 'Review scoped diffs and evidence only; prioritize blockers and high-risk issues before non-blocking style feedback.';
+  if (intent === 'completion' || intent === 'release') return 'Use Stage 84-style final verification: syntax, behavior, negative boundary, no-state where relevant, release/runtime checks, and diff check.';
+  if (intent === 'debug') return 'Verify a minimal reproduction and one root-cause hypothesis before changing code.';
+  if (intent === 'unknown') return 'No workflow readiness can be trusted until the intent is clarified.';
+  return 'Verify the required gate previews before entering the next workflow step.';
+}
+
+export function buildWorkflowReadinessModel({
+  inputIntent,
+  normalizedIntent,
+  route,
+  requiredGateKinds,
+  gatePreviews,
+  runtimeReadiness,
+  adviceHub,
+  digestObject,
+}) {
+  const blockedReasons = [...new Set([
+    ...(normalizedIntent === 'unknown' ? ['unknown workflow readiness intent; clarify goal, scope, constraints, and acceptance before starting'] : []),
+    ...gatePreviews.flatMap((gate) => gate.blocked_reasons.map((reason) => `${gate.kind}: ${reason}`)),
+  ])];
+  const readyToStart = normalizedIntent !== 'unknown' && blockedReasons.length === 0;
+  const boundaryAssertions = workflowReadinessBoundaryAssertions();
+  const readiness = {
+    version: 1,
+    stage: 'Stage 85',
+    readiness_kind: 'workflow-readiness-gate',
+    input_intent: inputIntent,
+    normalized_intent: normalizedIntent,
+    route_summary: {
+      stage: route.stage,
+      route_kind: route.route_kind,
+      intent: route.intent,
+      first_skill: route.first_skill,
+      selected_workflow: route.selected_workflow,
+      gate_kinds: route.gate_kinds,
+      rationale: route.rationale,
+      stop_condition: route.stop_condition,
+      route_digest: route.route_digest,
+    },
+    required_gate_kinds: requiredGateKinds,
+    gate_previews: gatePreviews,
+    runtime_readiness_summary: workflowReadinessRuntimeSummary(runtimeReadiness),
+    advice_hub_summary: workflowReadinessAdviceHubSummary(adviceHub),
+    ready_to_start: readyToStart,
+    blocked_reasons: blockedReasons,
+    manual_action: workflowReadinessManualAction(normalizedIntent, readyToStart, route, blockedReasons),
+    verification_hint: workflowReadinessVerificationHint(normalizedIntent),
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  return {
+    readiness: { ...readiness, readiness_digest: digestObject(readiness) },
+    blockedReasons,
+    boundaryAssertions,
+  };
+}