@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-release-check/release-check-workflow-ux-smoke.mjs

@@ -0,0 +1,456 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  completionEvidenceBundleFixtures,
+} from './release-check-completion-fixtures.mjs';
+import {
+  assertJsonMarkers,
+  parseJsonOutput,
+  repoRoot,
+  run,
+} from './release-check-runtime.mjs';
+
+function assertEntrySummaryContextStrategy(entrySummary) {
+  assertJsonMarkers([
+    ['entry_runtime_summary.context_load_plan.plan_kind', entrySummary.entry_runtime_summary?.context_load_plan?.plan_kind, 'entry-context-load-plan'],
+    ['entry_runtime_summary.context_load_plan.full_skill_text_loaded', entrySummary.entry_runtime_summary?.context_load_plan?.full_skill_text_loaded, false],
+    ['entry_runtime_summary.defer_policy.policy_kind', entrySummary.entry_runtime_summary?.defer_policy?.policy_kind, 'entry-context-defer-policy'],
+    ['entry_runtime_summary.defer_policy.hidden_discard', entrySummary.entry_runtime_summary?.defer_policy?.hidden_discard, false],
+    ['entry_runtime_summary.defer_policy.prompt_mutation', entrySummary.entry_runtime_summary?.defer_policy?.prompt_mutation, false],
+  ], 'workflow --entry-summary --json');
+}
+
+function assertAutomationPlanContextStrategy(automationPlan) {
+  assertJsonMarkers([
+    ['automation_plan.context_load_plan.plan_kind', automationPlan.automation_plan?.context_load_plan?.plan_kind, 'entry-context-load-plan'],
+    ['automation_plan.context_load_plan.full_skill_text_loaded', automationPlan.automation_plan?.context_load_plan?.full_skill_text_loaded, false],
+    ['automation_plan.defer_policy.policy_kind', automationPlan.automation_plan?.defer_policy?.policy_kind, 'entry-context-defer-policy'],
+    ['automation_plan.defer_policy.hidden_discard', automationPlan.automation_plan?.defer_policy?.hidden_discard, false],
+  ], 'automation --plan --json');
+}
+
+function assertLearningRunObservationPreview(target, absoluteTarget, options) {
+  const runFile = path.join(absoluteTarget, 'learning-run-input.json');
+  fs.writeFileSync(runFile, `${JSON.stringify({
+    command: 'automation',
+    mode: 'automation-plan',
+    ok: true,
+    domain: 'workflow',
+    confidence_delta: 0.2,
+    preferences: ['Keep automation read-only until an explicit approval boundary exists.'],
+    project_constraints: ['Do not mutate workflow skills, templates, hooks, or business source from learning preview.'],
+    observations: ['P2 should produce a candidate instinct preview without a learning sidecar write.'],
+    action: 'read-only automation plan completed with token-saving context strategy',
+  })}\n`);
+  const preview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'learning', '--observe-from-run', '--from-file', path.join(target, 'learning-run-input.json'), '--json', '--root', target], {}, options), 'learning --observe-from-run --json');
+  assertJsonMarkers([
+    ['command', preview.command, 'learning'],
+    ['mode', preview.mode, 'learning-run-observation-preview'],
+    ['learning_observation_preview.preview_kind', preview.learning_observation_preview?.preview_kind, 'learning-observation-preview'],
+    ['learning_observation_preview.status', preview.learning_observation_preview?.status, 'observation_recorded'],
+    ['candidate_instinct_preview.preview_kind', preview.candidate_instinct_preview?.preview_kind, 'candidate-instinct-preview'],
+    ['candidate_instinct_preview.automatic_promotion', preview.candidate_instinct_preview?.automatic_promotion, false],
+    ['candidate_instinct_preview.writes_formal_skills', preview.candidate_instinct_preview?.writes_formal_skills, false],
+    ['safety.writes', preview.safety?.writes, false],
+    ['safety.learning_observation_artifact', preview.safety?.learning_observation_artifact, false],
+    ['safety.candidate_instinct_artifact', preview.safety?.candidate_instinct_artifact, false],
+    ['safety.state_directory_created', preview.safety?.state_directory_created, false],
+  ], 'learning --observe-from-run --json');
+  if (!preview.learning_observation_preview?.learning_observation_preview_digest) throw new Error('learning run preview missing observation digest');
+  if (!preview.candidate_instinct_preview?.candidate_instinct_preview_digest) throw new Error('learning run preview missing candidate digest');
+  run('node', ['tools/vibe-runtime/index.mjs', 'learning', '--observe-from-run', '--from-file', path.join(target, 'learning-run-input.json'), '--confirm', '--root', target], {
+    allowFailure: true,
+    expectOutput: ['learning --observe-from-run is read-only'],
+  }, options);
+  if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('learning run preview smoke created unexpected state directory');
+}
+
+function assertAutomationAndLearningPreview(target, absoluteTarget, options) {
+  const automationPlan = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--plan', '--prompt', '开始P0', '--json', '--root', target], {}, options), 'automation --plan --json');
+  assertJsonMarkers([
+    ['command', automationPlan.command, 'automation'],
+    ['mode', automationPlan.mode, 'automation-plan'],
+    ['automation_plan.stage', automationPlan.automation_plan?.stage, 'Stage 146'],
+    ['automation_plan.plan_kind', automationPlan.automation_plan?.plan_kind, 'read-only-automation-plan'],
+    ['automation_plan.profile', automationPlan.automation_plan?.profile, 'advice-only'],
+    ['automation_plan.max_risk', automationPlan.automation_plan?.max_risk, 'low'],
+    ['automation_plan.requires_confirm', automationPlan.automation_plan?.requires_confirm, false],
+    ['automation_plan.boundary_assertions.automation_plan_artifact', automationPlan.automation_plan?.boundary_assertions?.automation_plan_artifact, false],
+    ['automation_plan.boundary_assertions.state_directory_created', automationPlan.automation_plan?.boundary_assertions?.state_directory_created, false],
+    ['automation_plan.boundary_assertions.command_execution', automationPlan.automation_plan?.boundary_assertions?.command_execution, false],
+    ['automation_plan.boundary_assertions.test_execution', automationPlan.automation_plan?.boundary_assertions?.test_execution, false],
+    ['automation_plan.boundary_assertions.git_diff_read', automationPlan.automation_plan?.boundary_assertions?.git_diff_read, false],
+    ['automation_plan.boundary_assertions.subagent', automationPlan.automation_plan?.boundary_assertions?.subagent, false],
+    ['automation_plan.boundary_assertions.business_source_write', automationPlan.automation_plan?.boundary_assertions?.business_source_write, false],
+    ['safety.stage', automationPlan.safety?.stage, 'Stage 146'],
+  ], 'automation --plan --json');
+  assertAutomationPlanContextStrategy(automationPlan);
+  if (!automationPlan.automation_plan?.plan_digest) throw new Error('automation plan missing plan_digest');
+  if (!automationPlan.source_envelopes?.workflow_start_digest) throw new Error('automation plan missing workflow start source digest');
+  if (!automationPlan.source_envelopes?.token_savior_budget_digest) throw new Error('automation plan missing token budget source digest');
+  if (!automationPlan.source_envelopes?.learning_advice_digest) throw new Error('automation plan missing learning advice source digest');
+  run('node', ['tools/vibe-runtime/index.mjs', 'automation', '--plan', '--prompt', '开始P0', '--confirm', '--root', target], {
+    allowFailure: true,
+    expectOutput: ['automation --plan is read-only'],
+  }, options);
+  assertLearningRunObservationPreview(target, absoluteTarget, options);
+}
+
+function assertWorkflowRunPlan(target, options) {
+  const runPlan = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--run-plan', '--prompt', 'Fix-login-error', '--json', '--root', target], {}, options), 'workflow --run-plan --json');
+  assertJsonMarkers([
+    ['command', runPlan.command, 'workflow'],
+    ['mode', runPlan.mode, 'workflow-skill-run-plan'],
+    ['workflow_run_plan.stage', runPlan.workflow_run_plan?.stage, 'P7'],
+    ['workflow_run_plan.plan_kind', runPlan.workflow_run_plan?.plan_kind, 'workflow-skill-run-plan'],
+    ['workflow_run_plan.normalized_intent', runPlan.workflow_run_plan?.normalized_intent, 'debug'],
+    ['workflow_run_plan.selected_skill', runPlan.workflow_run_plan?.selected_skill, 'vibe-systematic-debugging'],
+    ['workflow_run_plan.selected_skill_claimed_used', runPlan.workflow_run_plan?.selected_skill_claimed_used, false],
+    ['workflow_run_plan.expected_handoff.handoff_sidecar_required', runPlan.workflow_run_plan?.expected_handoff?.handoff_sidecar_required, true],
+    ['workflow_run_plan.expected_handoff.handoff_sidecar_written', runPlan.workflow_run_plan?.expected_handoff?.handoff_sidecar_written, false],
+    ['workflow_run_plan.single_step_chain.0.execution_authorized', runPlan.workflow_run_plan?.single_step_chain?.[0]?.execution_authorized, false],
+    ['workflow_run_plan.single_step_chain.0.sidecar_write_authorized', runPlan.workflow_run_plan?.single_step_chain?.[0]?.sidecar_write_authorized, false],
+    ['workflow_run_plan.workflow_run_plan_invariants.pass', runPlan.workflow_run_plan?.workflow_run_plan_invariants?.pass, true],
+    ['workflow_run_plan.boundary_assertions.workflow_run_plan_artifact', runPlan.workflow_run_plan?.boundary_assertions?.workflow_run_plan_artifact, false],
+    ['workflow_run_plan.boundary_assertions.skill_execution', runPlan.workflow_run_plan?.boundary_assertions?.skill_execution, false],
+    ['workflow_run_plan.boundary_assertions.evidence_write', runPlan.workflow_run_plan?.boundary_assertions?.evidence_write, false],
+    ['workflow_run_plan.boundary_assertions.subagent', runPlan.workflow_run_plan?.boundary_assertions?.subagent, false],
+    ['safety.stage', runPlan.safety?.stage, 'P7'],
+  ], 'workflow --run-plan --json');
+  if (!runPlan.workflow_run_plan?.run_plan_digest) throw new Error('workflow run plan missing run_plan_digest');
+  if (!runPlan.source_envelopes?.workflow_start_digest) throw new Error('workflow run plan missing workflow start source digest');
+  run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--run-plan', '--intent', 'debug', '--root', target], {
+    expectOutput: ['Vibecoding Runtime Workflow Run Plan', 'Stage: P7', 'Selected skill: vibe-systematic-debugging', 'execution_authorized=false', 'Boundary: writes=false; workflow_run_plan_artifact=false'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--run-plan', '--intent', 'debug', '--confirm', '--root', target], {
+    allowFailure: true,
+    expectOutput: ['workflow read-only modes do not accept'],
+  }, options);
+}
+
+function assertSessionContinuityAliases(target, absoluteTarget, options) {
+  const checkpoint = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'session', '--checkpoint', '--prompt', 'Fix-login-error', '--json', '--root', target], {}, options), 'session --checkpoint --json');
+  assertJsonMarkers([
+    ['command', checkpoint.command, 'session'],
+    ['mode', checkpoint.mode, 'session-checkpoint'],
+    ['session_checkpoint.stage', checkpoint.session_checkpoint?.stage, 'Stage 23'],
+    ['session_checkpoint.checkpoint_kind', checkpoint.session_checkpoint?.checkpoint_kind, 'session-checkpoint'],
+    ['session_checkpoint.selected_skill', checkpoint.session_checkpoint?.selected_skill, 'vibe-systematic-debugging'],
+    ['session_checkpoint.boundary_assertions.session_checkpoint_artifact', checkpoint.session_checkpoint?.boundary_assertions?.session_checkpoint_artifact, false],
+    ['session_checkpoint.boundary_assertions.skill_execution', checkpoint.session_checkpoint?.boundary_assertions?.skill_execution, false],
+    ['session_checkpoint.boundary_assertions.command_execution', checkpoint.session_checkpoint?.boundary_assertions?.command_execution, false],
+    ['session_checkpoint.boundary_assertions.git_write', checkpoint.session_checkpoint?.boundary_assertions?.git_write, false],
+    ['safety.stage', checkpoint.safety?.stage, 'Stage 23'],
+  ], 'session --checkpoint --json');
+  if (!checkpoint.session_checkpoint?.checkpoint_digest) throw new Error('session checkpoint missing checkpoint_digest');
+  const checkpointFile = path.join(absoluteTarget, 'session-checkpoint.json');
+  fs.writeFileSync(checkpointFile, `${JSON.stringify(checkpoint)}\n`, 'utf8');
+
+  const handoff = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'session', '--handoff', '--prompt', 'Fix-login-error', '--json', '--root', target], {}, options), 'session --handoff --json');
+  assertJsonMarkers([
+    ['command', handoff.command, 'session'],
+    ['mode', handoff.mode, 'session-handoff'],
+    ['session_handoff.stage', handoff.session_handoff?.stage, 'Stage 23'],
+    ['session_handoff.checkpoint_kind', handoff.session_handoff?.checkpoint_kind, 'session-handoff'],
+    ['session_handoff.selected_skill', handoff.session_handoff?.selected_skill, 'vibe-systematic-debugging'],
+    ['session_handoff.boundary_assertions.session_handoff_artifact', handoff.session_handoff?.boundary_assertions?.session_handoff_artifact, false],
+    ['session_handoff.boundary_assertions.workflow_execution', handoff.session_handoff?.boundary_assertions?.workflow_execution, false],
+    ['session_handoff.boundary_assertions.subagent', handoff.session_handoff?.boundary_assertions?.subagent, false],
+    ['safety.stage', handoff.safety?.stage, 'Stage 23'],
+  ], 'session --handoff --json');
+  if (!handoff.session_handoff?.handoff_digest) throw new Error('session handoff missing handoff_digest');
+
+  const resume = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'session', '--resume', '--from-file', path.join(target, 'session-checkpoint.json'), '--json', '--root', target], {}, options), 'session --resume --json');
+  assertJsonMarkers([
+    ['command', resume.command, 'session'],
+    ['mode', resume.mode, 'session-resume'],
+    ['session_resume.stage', resume.session_resume?.stage, 'Stage 23'],
+    ['session_resume.resume_kind', resume.session_resume?.resume_kind, 'session-resume'],
+    ['session_resume.source_checkpoint_kind', resume.session_resume?.source_checkpoint_kind, 'session-checkpoint'],
+    ['session_resume.selected_skill', resume.session_resume?.selected_skill, 'vibe-systematic-debugging'],
+    ['session_resume.resume_verification.pass', resume.session_resume?.resume_verification?.pass, true],
+    ['session_resume.boundary_assertions.session_resume_artifact', resume.session_resume?.boundary_assertions?.session_resume_artifact, false],
+    ['session_resume.boundary_assertions.skill_execution', resume.session_resume?.boundary_assertions?.skill_execution, false],
+    ['session_resume.boundary_assertions.git_write', resume.session_resume?.boundary_assertions?.git_write, false],
+    ['safety.stage', resume.safety?.stage, 'Stage 23'],
+  ], 'session --resume --json');
+  if (!resume.session_resume?.resume_digest) throw new Error('session resume missing resume_digest');
+
+  run('node', ['tools/vibe-runtime/index.mjs', 'session', '--checkpoint', '--prompt', 'Fix-login-error', '--root', target], {
+    expectOutput: ['Vibecoding Runtime Session Checkpoint', 'Stage: Stage 23', 'Selected skill: vibe-systematic-debugging', 'Boundary: writes=false; session_checkpoint_artifact=false'],
+  }, options);
+  run('node', ['tools/vibe-runtime/index.mjs', 'session', '--resume', '--from-file', path.join(target, 'session-checkpoint.json'), '--root', target], {
+    expectOutput: ['Vibecoding Runtime Session Resume', 'Stage: Stage 23', 'Source verification: pass', 'Boundary: writes=false; session_resume_artifact=false'],
+  }, options);
+
+  for (const [mode, flag] of [['--checkpoint', '--confirm'], ['--handoff', '--run'], ['--resume', '--confirm']]) {
+    const args = mode === '--resume'
+      ? ['tools/vibe-runtime/index.mjs', 'session', mode, '--from-file', path.join(target, 'session-checkpoint.json'), flag, '--root', target]
+      : ['tools/vibe-runtime/index.mjs', 'session', mode, '--intent', 'debug', flag, '--root', target];
+    run('node', args, {
+      allowFailure: true,
+      expectOutput: [`session ${mode} is read-only`],
+    }, options);
+  }
+}
+
+function assertSessionSkillAliases(target, start, receipt, options) {
+  const sessionStart = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'session', '--start', '--prompt', 'Fix-login-error', '--json', '--root', target], {}, options), 'session --start --json');
+  assertJsonMarkers([
+    ['command', sessionStart.command, 'session'],
+    ['mode', sessionStart.mode, 'agent-session-start-alias'],
+    ['session_start_alias.stage', sessionStart.session_start_alias?.stage, 'Stage 16'],
+    ['session_start_alias.alias_kind', sessionStart.session_start_alias?.alias_kind, 'agent-session-start-alias'],
+    ['session_start_alias.canonical_command', sessionStart.session_start_alias?.canonical_command, 'workflow --start'],
+    ['session_start_alias.canonical_mode', sessionStart.session_start_alias?.canonical_mode, 'unified-workflow-start'],
+    ['session_start_alias.selected_skill', sessionStart.session_start_alias?.selected_skill, start.workflow_start?.receipt_summary?.selected_skill],
+    ['session_start_alias.start_contract_digest', sessionStart.session_start_alias?.start_contract_digest, start.workflow_start?.start_here_contract?.contract_digest],
+    ['session_start_alias.workflow_start_digest', sessionStart.session_start_alias?.workflow_start_digest, start.workflow_start?.start_digest],
+    ['session_start_alias.skill_execution_claimed', sessionStart.session_start_alias?.skill_execution_claimed, false],
+    ['session_start_alias.command_execution_claimed', sessionStart.session_start_alias?.command_execution_claimed, false],
+    ['session_start_alias.subagent_dispatch_claimed', sessionStart.session_start_alias?.subagent_dispatch_claimed, false],
+    ['session_start_alias.git_write_claimed', sessionStart.session_start_alias?.git_write_claimed, false],
+    ['workflow_start.start_here_contract.expected_first_skill', sessionStart.workflow_start?.start_here_contract?.expected_first_skill, start.workflow_start?.start_here_contract?.expected_first_skill],
+    ['workflow_start.start_here_contract.skill_path', sessionStart.workflow_start?.start_here_contract?.skill_path, start.workflow_start?.start_here_contract?.skill_path],
+    ['workflow_start.boundary_assertions.workflow_start_artifact', sessionStart.workflow_start?.boundary_assertions?.workflow_start_artifact, false],
+    ['safety.stage', sessionStart.safety?.stage, 'Stage 93'],
+  ], 'session --start --json');
+  if (!sessionStart.session_start_alias?.alias_digest) throw new Error('session start alias missing alias_digest');
+  run('node', ['tools/vibe-runtime/index.mjs', 'session', '--start', '--prompt', 'Fix-login-error', '--root', target], {
+    expectOutput: ['Vibecoding Runtime Session Start', 'Stage: Stage 16', 'canonical=workflow --start', 'Selected skill: vibe-systematic-debugging', 'Boundary: writes=false; session_start_alias_artifact=false'],
+  }, options);
+
+  const skillSelect = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'skill', '--select', '--intent', 'review', '--json', '--root', target], {}, options), 'skill --select --json');
+  assertJsonMarkers([
+    ['command', skillSelect.command, 'skill'],
+    ['mode', skillSelect.mode, 'skill-select-alias'],
+    ['skill_select_alias.stage', skillSelect.skill_select_alias?.stage, 'Stage 16'],
+    ['skill_select_alias.alias_kind', skillSelect.skill_select_alias?.alias_kind, 'skill-select-alias'],
+    ['skill_select_alias.canonical_command', skillSelect.skill_select_alias?.canonical_command, 'workflow --receipt'],
+    ['skill_select_alias.canonical_mode', skillSelect.skill_select_alias?.canonical_mode, 'visible-skill-invocation'],
+    ['skill_select_alias.selected_skill', skillSelect.skill_select_alias?.selected_skill, receipt.workflow_receipt?.selected_skill],
+    ['skill_select_alias.workflow_receipt_digest', skillSelect.skill_select_alias?.workflow_receipt_digest, receipt.workflow_receipt?.receipt_digest],
+    ['skill_select_alias.skill_execution_claimed', skillSelect.skill_select_alias?.skill_execution_claimed, false],
+    ['skill_select_alias.workflow_execution_claimed', skillSelect.skill_select_alias?.workflow_execution_claimed, false],
+    ['skill_select_alias.command_execution_claimed', skillSelect.skill_select_alias?.command_execution_claimed, false],
+    ['skill_select_alias.subagent_dispatch_claimed', skillSelect.skill_select_alias?.subagent_dispatch_claimed, false],
+    ['skill_select_alias.git_write_claimed', skillSelect.skill_select_alias?.git_write_claimed, false],
+    ['workflow_receipt.selected_skill', skillSelect.workflow_receipt?.selected_skill, receipt.workflow_receipt?.selected_skill],
+    ['workflow_receipt.boundary_assertions.workflow_receipt_artifact', skillSelect.workflow_receipt?.boundary_assertions?.workflow_receipt_artifact, false],
+    ['safety.stage', skillSelect.safety?.stage, 'Stage 92'],
+  ], 'skill --select --json');
+  if (!skillSelect.skill_select_alias?.alias_digest) throw new Error('skill select alias missing alias_digest');
+  run('node', ['tools/vibe-runtime/index.mjs', 'skill', '--select', '--intent', 'review', '--root', target], {
+    expectOutput: ['Vibecoding Runtime Skill Select', 'Stage: Stage 16', 'canonical=workflow --receipt', 'Selected skill: vibe-requesting-code-review', 'Skill execution claimed: false', 'Boundary: writes=false; skill_select_alias_artifact=false'],
+  }, options);
+
+  const sessionCloseEvidenceFile = `${target}/session-close-done.md`;
+  fs.writeFileSync(path.join(repoRoot, sessionCloseEvidenceFile), completionEvidenceBundleFixtures.doneText, 'utf8');
+  const canonicalClose = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'completion', '--evidence-bundle', '--from-file', sessionCloseEvidenceFile, '--json', '--root', target], {}, options), 'completion --evidence-bundle for session close --json');
+  const sessionClose = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'session', '--close', '--from-file', sessionCloseEvidenceFile, '--json', '--root', target], {}, options), 'session --close --json');
+  assertJsonMarkers([
+    ['command', sessionClose.command, 'session'],
+    ['mode', sessionClose.mode, 'session-close-evidence-alias'],
+    ['session_close_alias.stage', sessionClose.session_close_alias?.stage, 'Stage 20'],
+    ['session_close_alias.alias_kind', sessionClose.session_close_alias?.alias_kind, 'session-close-evidence-alias'],
+    ['session_close_alias.canonical_command', sessionClose.session_close_alias?.canonical_command, 'completion --evidence-bundle'],
+    ['session_close_alias.canonical_mode', sessionClose.session_close_alias?.canonical_mode, 'completion-evidence-bundle'],
+    ['session_close_alias.closeout_decision', sessionClose.session_close_alias?.closeout_decision, canonicalClose.completion_evidence_bundle?.closeout_decision],
+    ['session_close_alias.delivery_gate_pass', sessionClose.session_close_alias?.delivery_gate_pass, true],
+    ['session_close_alias.completion_claim_allowed', sessionClose.session_close_alias?.completion_claim_allowed, true],
+    ['session_close_alias.git_action_allowed', sessionClose.session_close_alias?.git_action_allowed, false],
+    ['session_close_alias.platform_action_allowed', sessionClose.session_close_alias?.platform_action_allowed, false],
+    ['session_close_alias.subagent_allowed', sessionClose.session_close_alias?.subagent_allowed, false],
+    ['session_close_alias.completion_evidence_bundle_digest', sessionClose.session_close_alias?.completion_evidence_bundle_digest, canonicalClose.completion_evidence_bundle?.bundle_digest],
+    ['session_close_alias.human_completion_evidence_digest', sessionClose.session_close_alias?.human_completion_evidence_digest, canonicalClose.completion_evidence_bundle?.human_completion_evidence_bundle?.human_completion_evidence_digest],
+    ['session_close_alias.completion_readiness_digest', sessionClose.session_close_alias?.completion_readiness_digest, canonicalClose.completion_readiness?.readiness_digest],
+    ['session_close_alias.command_execution_claimed', sessionClose.session_close_alias?.command_execution_claimed, false],
+    ['session_close_alias.skill_execution_claimed', sessionClose.session_close_alias?.skill_execution_claimed, false],
+    ['session_close_alias.subagent_dispatch_claimed', sessionClose.session_close_alias?.subagent_dispatch_claimed, false],
+    ['session_close_alias.git_write_claimed', sessionClose.session_close_alias?.git_write_claimed, false],
+    ['completion_evidence_bundle.stage', sessionClose.completion_evidence_bundle?.stage, 'Stage 99'],
+    ['completion_evidence_bundle.human_completion_evidence_bundle.stage', sessionClose.completion_evidence_bundle?.human_completion_evidence_bundle?.stage, 'Stage 124'],
+    ['completion_evidence_bundle.boundary_assertions.completion_evidence_bundle_artifact', sessionClose.completion_evidence_bundle?.boundary_assertions?.completion_evidence_bundle_artifact, false],
+    ['safety.stage', sessionClose.safety?.stage, 'Stage 124'],
+  ], 'session --close --json');
+  if (!sessionClose.session_close_alias?.alias_digest) throw new Error('session close alias missing alias_digest');
+  run('node', ['tools/vibe-runtime/index.mjs', 'session', '--close', '--from-file', sessionCloseEvidenceFile, '--root', target], {
+    expectOutput: ['Vibecoding Runtime Session Close', 'Stage: Stage 20', 'canonical=completion --evidence-bundle', 'Human delivery gate: pass', 'Boundary: writes=false; session_close_alias_artifact=false'],
+  }, options);
+
+  assertSessionContinuityAliases(target, path.join(repoRoot, target), options);
+
+  for (const [command, flag] of [['session', '--confirm'], ['session', '--write'], ['skill', '--confirm'], ['skill', '--run']]) {
+    const args = command === 'session'
+      ? ['tools/vibe-runtime/index.mjs', command, '--start', '--intent', 'feature', flag, '--root', target]
+      : ['tools/vibe-runtime/index.mjs', command, '--select', '--intent', 'review', flag, '--root', target];
+    run('node', args, {
+      allowFailure: true,
+      expectOutput: [`${command} --${command === 'session' ? 'start' : 'select'} is read-only`],
+    }, options);
+  }
+  for (const flag of ['--confirm', '--run']) {
+    run('node', ['tools/vibe-runtime/index.mjs', 'session', '--close', flag, '--root', target], {
+      allowFailure: true,
+      expectOutput: ['session --close is read-only'],
+    }, options);
+  }
+}
+
+export function runWorkflowEntryExperienceSmoke(options) {
+  const target = '.tmp/vibe-workflow-entry-experience';
+  const absoluteTarget = path.join(repoRoot, target);
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    const contract = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'entry', '--contract', '--intent', 'feature', '--json', '--root', target], {}, options), 'entry --contract --json');
+    assertJsonMarkers([
+      ['command', contract.command, 'entry'],
+      ['mode', contract.mode, 'workflow-entry-contract'],
+      ['entry_contract.stage', contract.entry_contract?.stage, 'Stage 91'],
+      ['entry_contract.contract_kind', contract.entry_contract?.contract_kind, 'workflow-entry-contract'],
+      ['entry_contract.expected_first_step', contract.entry_contract?.expected_first_step, 'using-vibecoding'],
+      ['entry_contract.contract_pass', contract.entry_contract?.contract_pass, true],
+      ['entry_contract.boundary_assertions.entry_contract_artifact', contract.entry_contract?.boundary_assertions?.entry_contract_artifact, false],
+      ['entry_contract.boundary_assertions.source_write', contract.entry_contract?.boundary_assertions?.source_write, false],
+      ['safety.stage', contract.safety?.stage, 'Stage 91'],
+    ], 'entry --contract --json');
+    if (!contract.entry_contract?.contract_digest) throw new Error('entry contract missing contract_digest');
+
+    const receipt = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--receipt', '--intent', 'review', '--json', '--root', target], {}, options), 'workflow --receipt --json');
+    assertJsonMarkers([
+      ['command', receipt.command, 'workflow'],
+      ['mode', receipt.mode, 'visible-skill-invocation'],
+      ['workflow_receipt.stage', receipt.workflow_receipt?.stage, 'Stage 92'],
+      ['workflow_receipt.receipt_kind', receipt.workflow_receipt?.receipt_kind, 'visible-skill-invocation'],
+      ['workflow_receipt.selected_skill', receipt.workflow_receipt?.selected_skill, 'vibe-requesting-code-review'],
+      ['workflow_receipt.boundary_assertions.workflow_receipt_artifact', receipt.workflow_receipt?.boundary_assertions?.workflow_receipt_artifact, false],
+      ['safety.stage', receipt.safety?.stage, 'Stage 92'],
+    ], 'workflow --receipt --json');
+    if (!receipt.workflow_receipt?.receipt_digest) throw new Error('workflow receipt missing receipt_digest');
+
+    const start = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--start', '--prompt', 'Fix-login-error', '--json', '--root', target], {}, options), 'workflow --start --json');
+    assertJsonMarkers([
+      ['command', start.command, 'workflow'],
+      ['mode', start.mode, 'unified-workflow-start'],
+      ['workflow_start.stage', start.workflow_start?.stage, 'Stage 93'],
+      ['workflow_start.start_kind', start.workflow_start?.start_kind, 'unified-workflow-start'],
+      ['workflow_start.normalized_intent', start.workflow_start?.normalized_intent, 'debug'],
+      ['workflow_start.entry_contract_summary.expected_first_step', start.workflow_start?.entry_contract_summary?.expected_first_step, 'using-vibecoding'],
+      ['workflow_start.receipt_summary.selected_skill', start.workflow_start?.receipt_summary?.selected_skill, 'vibe-systematic-debugging'],
+      ['workflow_start.entry_summary.entry_classification', start.workflow_start?.entry_summary?.entry_classification, 'evidence_needed'],
+      ['workflow_start.entry_summary.state_gap_is_expected', start.workflow_start?.entry_summary?.state_gap_is_expected, false],
+      ['workflow_start.entry_summary.blocking_safety_issues.length', start.workflow_start?.entry_summary?.blocking_safety_issues?.length, 0],
+      ['workflow_start.entry_summary.state_gap_count', start.workflow_start?.entry_summary?.state_gap_count, 3],
+      ['workflow_start.entry_summary.planning_gap_count', start.workflow_start?.entry_summary?.planning_gap_count, 4],
+      ['workflow_start.entry_summary.readiness_blocker_count', start.workflow_start?.entry_summary?.readiness_blocker_count, 12],
+      ['workflow_start.boundary_assertions.workflow_start_artifact', start.workflow_start?.boundary_assertions?.workflow_start_artifact, false],
+      ['safety.stage', start.safety?.stage, 'Stage 93'],
+    ], 'workflow --start --json');
+    if (!start.workflow_start?.start_digest) throw new Error('workflow start missing start_digest');
+
+    assertSessionSkillAliases(target, start, receipt, options);
+
+    const cockpit = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--cockpit', '--intent', 'implementation', '--json', '--root', target], {}, options), 'workflow --cockpit --json');
+    assertJsonMarkers([
+      ['command', cockpit.command, 'workflow'],
+      ['mode', cockpit.mode, 'workflow-cockpit'],
+      ['workflow_cockpit.stage', cockpit.workflow_cockpit?.stage, 'Stage 87'],
+      ['workflow_cockpit.cockpit_kind', cockpit.workflow_cockpit?.cockpit_kind, 'workflow-cockpit'],
+      ['workflow_cockpit.self_check_summary.summary_kind', cockpit.workflow_cockpit?.self_check_summary?.summary_kind, 'workflow-cockpit-self-check'],
+      ['workflow_cockpit.self_check_summary.profile_check.status', cockpit.workflow_cockpit?.self_check_summary?.profile_check?.status, 'external_read_only_check'],
+      ['workflow_cockpit.self_check_summary.entry_check.recommended_command', cockpit.workflow_cockpit?.self_check_summary?.entry_check?.recommended_command, 'workflow --start --prompt <request> --json'],
+      ['workflow_cockpit.self_check_summary.readiness_check.ready_to_start', cockpit.workflow_cockpit?.self_check_summary?.readiness_check?.ready_to_start, false],
+      ['workflow_cockpit.self_check_summary.completion_check.recommended_command', cockpit.workflow_cockpit?.self_check_summary?.completion_check?.recommended_command, 'completion --readiness --from-file <local-completion-evidence-file> --json'],
+      ['workflow_cockpit.self_check_summary.boundary.command_execution', cockpit.workflow_cockpit?.self_check_summary?.boundary?.command_execution, false],
+      ['workflow_cockpit.self_check_summary.boundary.skill_execution', cockpit.workflow_cockpit?.self_check_summary?.boundary?.skill_execution, false],
+      ['workflow_cockpit.self_check_summary.boundary.subagent', cockpit.workflow_cockpit?.self_check_summary?.boundary?.subagent, false],
+      ['workflow_cockpit.boundary_assertions.workflow_cockpit_artifact', cockpit.workflow_cockpit?.boundary_assertions?.workflow_cockpit_artifact, false],
+      ['safety.stage', cockpit.safety?.stage, 'Stage 87'],
+    ], 'workflow --cockpit --json');
+    if (!cockpit.workflow_cockpit?.cockpit_digest) throw new Error('workflow cockpit missing cockpit_digest');
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--cockpit', '--intent', 'implementation', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Workflow Cockpit', 'Stage: Stage 87', 'Self-check loop:', 'Evidence gaps:', 'Boundary: writes=false; workflow_cockpit_artifact=false'],
+    }, options);
+
+    assertWorkflowRunPlan(target, options);
+
+    const entrySummary = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-summary', '--prompt', '继续优化入口token和学习建议', '--json', '--root', target], {}, options), 'workflow --entry-summary --json');
+    assertJsonMarkers([
+      ['command', entrySummary.command, 'workflow'],
+      ['mode', entrySummary.mode, 'entry-runtime-summary'],
+      ['entry_runtime_summary.stage', entrySummary.entry_runtime_summary?.stage, 'Stage 145'],
+      ['entry_runtime_summary.summary_kind', entrySummary.entry_runtime_summary?.summary_kind, 'entry-runtime-summary'],
+      ['entry_runtime_summary.token_budget.recommended_profile', entrySummary.entry_runtime_summary?.token_budget?.recommended_profile, 'tiny_entry'],
+      ['entry_runtime_summary.learning_advice.automatic_promotion', entrySummary.entry_runtime_summary?.learning_advice?.automatic_promotion, false],
+      ['entry_runtime_summary.boundary_assertions.entry_runtime_summary_artifact', entrySummary.entry_runtime_summary?.boundary_assertions?.entry_runtime_summary_artifact, false],
+      ['entry_runtime_summary.boundary_assertions.command_execution', entrySummary.entry_runtime_summary?.boundary_assertions?.command_execution, false],
+      ['entry_runtime_summary.boundary_assertions.skill_execution', entrySummary.entry_runtime_summary?.boundary_assertions?.skill_execution, false],
+      ['entry_runtime_summary.boundary_assertions.auto_execution', entrySummary.entry_runtime_summary?.boundary_assertions?.auto_execution, false],
+      ['entry_runtime_summary.boundary_assertions.subagent', entrySummary.entry_runtime_summary?.boundary_assertions?.subagent, false],
+      ['safety.stage', entrySummary.safety?.stage, 'Stage 145'],
+    ], 'workflow --entry-summary --json');
+    assertEntrySummaryContextStrategy(entrySummary);
+    if (!entrySummary.entry_runtime_summary?.summary_digest) throw new Error('entry runtime summary missing summary_digest');
+    if (!entrySummary.source_envelopes?.workflow_start_digest) throw new Error('entry runtime summary missing workflow start source digest');
+    if (!entrySummary.source_envelopes?.token_savior_budget_digest) throw new Error('entry runtime summary missing token budget source digest');
+    if (!entrySummary.source_envelopes?.learning_advice_digest) throw new Error('entry runtime summary missing learning advice source digest');
+    assertAutomationAndLearningPreview(target, absoluteTarget, options);
+
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('automation plan smoke created unexpected state directory');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('workflow entry summary smoke created unexpected state directory');
+
+    const entrySummaryText = run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-summary', '--prompt', '继续优化入口token和学习建议', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Entry Summary', 'Stage: Stage 145', 'Token profile: tiny_entry', 'Learning:', 'Boundary: writes=false; entry_runtime_summary_artifact=false'],
+    }, options);
+    if (entrySummaryText.status !== 0) throw new Error('workflow --entry-summary text output failed');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--entry-summary', '--prompt', '继续优化入口token和学习建议', '--confirm', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['workflow read-only modes do not accept'],
+    }, options);
+
+    const sequence = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--sequence', '--intent', 'implementation', '--json', '--root', target], {}, options), 'workflow --sequence --json');
+    assertJsonMarkers([
+      ['command', sequence.command, 'workflow'],
+      ['mode', sequence.mode, 'execution-choreography'],
+      ['workflow_sequence.stage', sequence.workflow_sequence?.stage, 'Stage 94'],
+      ['workflow_sequence.sequence_kind', sequence.workflow_sequence?.sequence_kind, 'execution-choreography'],
+      ['workflow_sequence.normalized_intent', sequence.workflow_sequence?.normalized_intent, 'implementation'],
+      ['workflow_sequence.boundary_assertions.workflow_sequence_artifact', sequence.workflow_sequence?.boundary_assertions?.workflow_sequence_artifact, false],
+      ['safety.stage', sequence.safety?.stage, 'Stage 94'],
+    ], 'workflow --sequence --json');
+    if (!sequence.workflow_sequence?.sequence_digest) throw new Error('workflow sequence missing sequence_digest');
+
+    const brief = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'onboarding', '--brief', '--json', '--root', target], {}, options), 'onboarding --brief --json');
+    assertJsonMarkers([
+      ['command', brief.command, 'onboarding'],
+      ['mode', brief.mode, 'workflow-onboarding-brief'],
+      ['onboarding_brief.stage', brief.onboarding_brief?.stage, 'Stage 95'],
+      ['onboarding_brief.brief_kind', brief.onboarding_brief?.brief_kind, 'workflow-onboarding-brief'],
+      ['onboarding_brief.boundary_assertions.onboarding_brief_artifact', brief.onboarding_brief?.boundary_assertions?.onboarding_brief_artifact, false],
+      ['safety.stage', brief.safety?.stage, 'Stage 95'],
+    ], 'onboarding --brief --json');
+    if (!brief.onboarding_brief?.brief_digest) throw new Error('onboarding brief missing brief_digest');
+
+    run('node', ['tools/vibe-doctor/index.mjs', '--workflow-entry', target], {
+      allowFailure: true,
+      expectOutput: ['Vibecoding Kit Doctor', 'workflow entry'],
+    }, options);
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--start', '--prompt', '继续分析下一轮优化点', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Workflow Start', 'Stage: Stage 93', 'Entry summary: planning_needed; state_gap_expected=true', 'First decision: Confirm goal, scope, acceptance, and validation strategy before implementation', 'Boundary: writes=false; workflow_start_artifact=false'],
+    }, options);
+
+    for (const forbidden of ['--confirm', '--write', '--preflight', '--run']) {
+      run('node', ['tools/vibe-runtime/index.mjs', 'workflow', '--start', '--intent', 'feature', forbidden, '--root', target], {
+        allowFailure: true,
+        expectOutput: ['workflow read-only modes do not accept'],
+      }, options);
+    }
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('workflow entry experience smoke created unexpected state directory');
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}