@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-automation-command.mjs

@@ -0,0 +1,367 @@
+import {
+  automationConfirmedPlanActionText,
+  automationReadinessActionText,
+  automationReadinessBoundaryText,
+  automationStageRunbookActionText,
+} from './runtime-automation-boundary-text.mjs';
+import {
+  emitReadonlyLocalJsonOutput,
+  readonlyLocalJsonEnvelope,
+  readonlyLocalStatePresent,
+} from './runtime-readonly-local-json-output-envelope.mjs';
+import {
+  ensureRoot,
+  localJsonFileWithinRoot,
+} from './runtime-local-json-input.mjs';
+import {
+  buildAutomationPlanEnvelopeModel,
+} from './runtime-automation-plan-model.mjs';
+import {
+  automationPolicySnapshot,
+} from './runtime-automation-policy-model.mjs';
+import {
+  buildEntryRuntimeSummaryEnvelopeModel,
+  learningAdviceIntentForWorkflowIntent,
+} from './runtime-entry-summary-model.mjs';
+import {
+  digestAutomationReadiness,
+  runtimeAutomationReadinessDigestPayload,
+  runtimeAutomationReadinessMatrix,
+} from './runtime-automation-readiness.mjs';
+import {
+  digestConfirmedOneShotPlan,
+  runtimeConfirmedOneShotPlan,
+  runtimeConfirmedOneShotPlanDigestPayload,
+} from './runtime-confirmed-one-shot-plan.mjs';
+import {
+  digestSequentialStageRunbook,
+  runtimeSequentialStageRunbook,
+  runtimeSequentialStageRunbookDigestPayload,
+  runtimeSequentialStageRunbookInvariants,
+} from './runtime-sequential-stage-runbook.mjs';
+import {
+  buildRunbookExecutorPreviewContract,
+} from './runtime-runbook-executor-preview-contract.mjs';
+import {
+  digestStageScriptlet,
+  runtimeStageScriptlet,
+  runtimeStageScriptletDigestPayload,
+} from './runtime-stage-scriptlet.mjs';
+import {
+  runtimeCapabilityRegistry,
+} from './runtime-capability-registry.mjs';
+
+function printList(title, items) {
+  if (!items || items.length === 0) return;
+  console.log(`${title}:`);
+  for (const item of items) {
+    console.log(`- ${item}`);
+  }
+}
+
+export function runtimeAutomationReadinessEnvelope(root, { digestObject }) {
+  ensureRoot(root);
+  const registry = runtimeCapabilityRegistry();
+  const registryPayload = {
+    registry_stage: registry.registry_stage,
+    registry_kind: registry.registry_kind,
+    registry_version: registry.registry_version,
+    capability_groups: registry.capability_groups,
+    stage_inventory: registry.stage_inventory,
+    closeout_chain: registry.closeout_chain,
+    boundary_assertions: registry.boundary_assertions,
+  };
+  const registryDigest = digestObject(registryPayload);
+  const matrix = runtimeAutomationReadinessMatrix(registry, registryDigest);
+  const readiness = {
+    ...matrix,
+    readiness_digest: digestAutomationReadiness(runtimeAutomationReadinessDigestPayload(matrix)),
+  };
+  return readonlyLocalJsonEnvelope(root, {
+    mode: 'runtime-automation-readiness-matrix',
+    ok: readiness.readiness_invariants.pass,
+    payloadKey: 'runtime_automation_readiness',
+    payload: readiness,
+    safety: { stage: 'Stage 103', registry_stage: registry.registry_stage, ...readiness.boundary_assertions },
+    quality: readiness.readiness_invariants.findings,
+    action: automationReadinessActionText,
+  });
+}
+
+function automationPlanEnvelope(root, { prompt = '' } = {}, { workflowStartEnvelope, tokenSaviorBudgetEnvelope, learningAdviceEnvelope, digestObject }) {
+  ensureRoot(root);
+  if (!String(prompt || '').trim()) throw new Error('automation --plan requires --prompt <text>');
+  const workflowStart = workflowStartEnvelope(root, { prompt });
+  const normalizedIntent = workflowStart.workflow_start?.normalized_intent || 'unknown';
+  const tokenBudget = tokenSaviorBudgetEnvelope(root, { prompt });
+  const learningAdvice = learningAdviceEnvelope(root, { intent: learningAdviceIntentForWorkflowIntent(normalizedIntent) });
+  const entryRuntimeSummary = buildEntryRuntimeSummaryEnvelopeModel({
+    prompt,
+    inputIntent: normalizedIntent,
+    workflowStartEnvelope: workflowStart,
+    tokenSaviorBudgetEnvelope: tokenBudget,
+    learningAdviceEnvelope: learningAdvice,
+    digestObject,
+  });
+  return buildAutomationPlanEnvelopeModel({
+    prompt,
+    workflowStartEnvelope: workflowStart,
+    tokenSaviorBudgetEnvelope: tokenBudget,
+    learningAdviceEnvelope: learningAdvice,
+    entryRuntimeSummaryEnvelope: entryRuntimeSummary,
+    policy: automationPolicySnapshot({ profile: 'advice-only' }),
+    statePresent: readonlyLocalStatePresent(root),
+    digestObject,
+  });
+}
+
+function printAutomationPlan(envelope) {
+  const plan = envelope.automation_plan;
+  console.log('Vibecoding Runtime Automation Plan');
+  console.log(`Stage: ${plan.stage}; Kind: ${plan.plan_kind}; pass=${plan.automation_plan_invariants.pass}`);
+  console.log(`Profile: ${plan.profile}; max_risk=${plan.max_risk}; requires_confirm=${plan.requires_confirm}`);
+  for (const item of plan.plan_items) console.log(`- ${item.id}: ${item.status}; executes=${item.executes}; writes=${item.writes}; ${item.recommendation}`);
+  printList('Allowed actions', plan.allowed_actions);
+  printList('Forbidden actions', plan.forbidden_actions);
+  console.log(`Source bindings: workflow_start=${plan.source_bindings.workflow_start_digest}; token_budget=${plan.source_bindings.token_savior_budget_digest}; learning_advice=${plan.source_bindings.learning_advice_digest}; entry_summary=${plan.source_bindings.entry_runtime_summary_digest || 'not-provided'}; policy=${plan.source_bindings.policy_profile}`);
+  console.log('Boundary: writes=false; automation_plan_artifact=false; state_directory_created=false; sidecar_write=false; command_execution=false; test_execution=false; git_diff_read=false; git_write=false; workflow_execution=false; skill_execution=false; subagent=false; business_source_write=false');
+  console.log(`Automation plan digest: ${plan.plan_digest}`);
+  if (plan.automation_plan_invariants.findings.length > 0) printList('Findings', plan.automation_plan_invariants.findings);
+  console.log(`Action: ${envelope.action}`);
+}
+
+function printRuntimeAutomationReadiness(envelope) {
+  const readiness = envelope.runtime_automation_readiness;
+  console.log('Vibecoding Runtime Automation Readiness Matrix');
+  console.log(`Stage: ${readiness.stage}; Kind: ${readiness.readiness_kind}; pass=${readiness.readiness_invariants.pass}`);
+  console.log(`Registry: ${readiness.registry_stage}; ${readiness.registry_kind}; version=${readiness.registry_version}`);
+  for (const category of readiness.categories) {
+    console.log(`- ${category.category}: ${readiness.category_counts[category.category]} entries; ${category.rule}`);
+  }
+  console.log('Transition: automation_readiness_only=true; automation_plan_created=false; one_shot_execution_created=false');
+  if (readiness.autopilot_lab_profile) console.log(`Autopilot lab: stage=${readiness.autopilot_lab_profile.stage}; budget_complete=${readiness.autopilot_lab_profile.budget_complete}; ready_for_runtime_action=${readiness.autopilot_lab_profile.ready_for_runtime_action}`);
+  console.log(automationReadinessBoundaryText);
+  console.log(`Registry digest: ${readiness.registry_digest}`);
+  console.log(`Readiness digest: ${readiness.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 stageRunbookEnvelope(root, planFile, { executablePlanFile = '' } = {}, { localTextEvidenceDescriptor, digestObject }) {
+  ensureRoot(root);
+  if (!planFile) throw new Error('automation --stage-runbook requires --from-plan <local-plan-file>');
+  const source = localTextEvidenceDescriptor(root, planFile, 'automation --stage-runbook source plan');
+  let executablePlan = null;
+  if (executablePlanFile) {
+    const executableSource = localTextEvidenceDescriptor(root, executablePlanFile, 'automation --stage-runbook executable plan');
+    const parsed = JSON.parse(executableSource.text);
+    executablePlan = parsed.executable_plan_contract || parsed;
+  }
+  const automationEnvelope = runtimeAutomationReadinessEnvelope(root, { digestObject });
+  const automationReadiness = automationEnvelope.runtime_automation_readiness;
+  const registry = runtimeCapabilityRegistry();
+  const runbook = runtimeSequentialStageRunbook({
+    sourcePlan: {
+      file: source.relative,
+      digest: source.digest,
+      line_count: source.text.split(/\r?\n/).length,
+      text: source.text,
+    },
+    executablePlan,
+    registry,
+    registryDigest: automationReadiness.registry_digest,
+  });
+  const runbookStructuralDigest = digestSequentialStageRunbook(runtimeSequentialStageRunbookDigestPayload(runbook));
+  const runbookExecutorPreview = buildRunbookExecutorPreviewContract({
+    runbook: {
+      ...runbook,
+      stage_runbook_digest: runbookStructuralDigest,
+    },
+    autopilotLabProfile: automationReadiness.autopilot_lab_profile,
+    registryDigest: automationReadiness.registry_digest,
+  });
+  const sequentialStageRunbookWithPreview = {
+    ...runbook,
+    runbook_executor_preview: runbookExecutorPreview,
+  };
+  const sequentialStageRunbook = {
+    ...sequentialStageRunbookWithPreview,
+    runbook_invariants: runtimeSequentialStageRunbookInvariants(sequentialStageRunbookWithPreview),
+  };
+  sequentialStageRunbook.stage_runbook_digest = digestSequentialStageRunbook(runtimeSequentialStageRunbookDigestPayload(sequentialStageRunbook));
+  return readonlyLocalJsonEnvelope(root, {
+    mode: 'sequential-stage-runbook',
+    ok: sequentialStageRunbook.runbook_invariants.pass,
+    payloadKey: 'sequential_stage_runbook',
+    payload: sequentialStageRunbook,
+    safety: { stage: 'Stage 118', ...sequentialStageRunbook.boundary_assertions },
+    quality: [...sequentialStageRunbook.runbook_invariants.findings, ...sequentialStageRunbook.blocked_reasons],
+    action: automationStageRunbookActionText,
+  });
+}
+
+function printStageRunbook(envelope) {
+  const runbook = envelope.sequential_stage_runbook;
+  console.log('Vibecoding Runtime Sequential Stage Runbook');
+  console.log(`Stage: ${runbook.stage}; Kind: ${runbook.runbook_kind}; pass=${runbook.runbook_invariants.pass}`);
+  console.log(`Stages: ${runbook.stage_sequence.length}; ready_for_evidence_binding=${runbook.ready_for_evidence_binding}; blocked=${runbook.blocked_reasons.length}`);
+  console.log(`Stage order gate: pass=${runbook.stage_order_gate.pass}; per_stage_gates=${runbook.stage_order_gate.per_stage_gates.length}; blocked=${runbook.stage_order_gate.blocked_reasons.length}; auto_execution=${runbook.stage_order_gate.auto_execution}; command_execution=${runbook.stage_order_gate.command_execution}; git_write=${runbook.stage_order_gate.git_write}`);
+  if (runbook.runbook_executor_preview) {
+    const preview = runbook.runbook_executor_preview;
+    console.log(`Runbook executor preview: stage=${preview.stage}; pass=${preview.runbook_executor_preview_invariants.pass}; preview_ok=${preview.preview_gate.ok}; steps=${preview.ordered_steps.length}; budget_complete=${preview.task_budget_preview.budget_complete}; ready_for_runtime_action=${preview.ready_for_runtime_action}`);
+    console.log(`Runbook executor preview digest: ${preview.runbook_executor_preview_digest}`);
+  }
+  for (const item of runbook.stage_sequence.slice(0, 12)) console.log(`- ${item.stage_id}: files=${item.files_to_change.length}; validations=${item.validation_commands.length}; stop_if=${item.stop_if.length}; execution_authorized=false; ${item.title}`);
+  console.log(`Source bindings: executable_plan=${runbook.source_bindings.executable_plan_digest || 'not_provided'}; registry=${runbook.source_bindings.registry_digest}`);
+  printList('Execution order', runbook.execution_order);
+  printList('Evidence required', runbook.evidence_required);
+  printList('Blocked reasons', runbook.blocked_reasons);
+  printList('Forbidden actions', runbook.forbidden_actions);
+  console.log('Boundary: writes=false; stage_runbook_artifact=false; runbook_artifact=false; source_write=false; plan_mutation=false; sidecar_write=false; state_directory_created=false; command_execution=false; check_execution=false; test_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(`Stage runbook digest: ${runbook.stage_runbook_digest}`);
+  if (runbook.runbook_invariants.findings.length > 0) printList('Findings', runbook.runbook_invariants.findings);
+  console.log(`Manual action: ${runbook.manual_action}`);
+  console.log(`Action: ${envelope.action}`);
+}
+
+function stageScriptletEnvelope(root, { runbookFile = '', consoleFile = '', selectedStage = '' } = {}) {
+  ensureRoot(root);
+  if (!runbookFile) throw new Error('automation --stage-scriptlet requires --from-runbook <local-runbook-json>');
+  const runbookInput = localJsonFileWithinRoot(root, runbookFile, 'automation --stage-scriptlet --from-runbook');
+  const consoleInput = consoleFile ? localJsonFileWithinRoot(root, consoleFile, 'automation --stage-scriptlet --from-console') : null;
+  const base = runtimeStageScriptlet({
+    runbook: runbookInput.data,
+    console: consoleInput?.data || null,
+    selectedStage,
+    source: {
+      runbook_file: runbookInput.relative,
+      runbook_digest: runbookInput.digest,
+      console_file: consoleInput?.relative || '',
+      console_digest: consoleInput?.digest || '',
+    },
+  });
+  const scriptlet = {
+    ...base,
+    scriptlet_digest: digestStageScriptlet(runtimeStageScriptletDigestPayload(base)),
+  };
+  return readonlyLocalJsonEnvelope(root, {
+    mode: 'copy-ready-stage-execution-scriptlet',
+    ok: scriptlet.ok,
+    payloadKey: 'stage_scriptlet',
+    payload: scriptlet,
+    safety: { stage: 'Stage 130', ...scriptlet.boundary_assertions },
+    quality: scriptlet.stage_scriptlet_invariants.findings,
+    action: 'copy-ready stage execution scriptlet was computed read-only from local Stage 118 runbook JSON plus optional local Stage 127 console JSON. It only renders copy-ready PowerShell command previews, expected markers, evidence capture template, and stop conditions; no command, smoke, check, test, workflow, skill, runtime action, evidence write, sidecar write, source mutation, git add, commit, push, PR, merge, platform API, external network, model, MCP, subagent, worktree, or business source write occurred.',
+  });
+}
+
+function printStageScriptlet(envelope) {
+  const scriptlet = envelope.stage_scriptlet;
+  console.log('Vibecoding Runtime Copy-ready Stage Execution Scriptlet');
+  console.log(`Stage: ${scriptlet.stage}; Kind: ${scriptlet.scriptlet_kind}; pass=${scriptlet.ok}`);
+  console.log(`Target stage: ${scriptlet.target_stage}; selected=${scriptlet.selected_stage_count}; runbook_stages=${scriptlet.runbook_summary.stage_count}; console_provided=${scriptlet.console_summary.provided}`);
+  for (const item of scriptlet.scriptlet_steps.slice(0, 12)) console.log(`- ${item.id}: ${item.purpose}; preview_only=true; execution_authorized=false; ${item.powershell_command}`);
+  printList('PowerShell commands', scriptlet.powershell_commands);
+  printList('Expected markers', scriptlet.expected_markers);
+  printList('Stop if', scriptlet.stop_if);
+  console.log(`Evidence template: schema_version=${scriptlet.evidence_capture_template.schema_version}; items=${scriptlet.evidence_capture_template.evidence_items.length}; writes_by_stage130=false`);
+  console.log(`copy_boundary: preview_only=${scriptlet.copy_boundary.preview_only}; execution_authorized=${scriptlet.copy_boundary.execution_authorized}; commands_executed=${scriptlet.copy_boundary.commands_executed}; evidence_written=${scriptlet.copy_boundary.evidence_written}; git_write_authorized=${scriptlet.copy_boundary.git_write_authorized}`);
+  console.log('Boundary: writes=false; stage_scriptlet_artifact=false; scriptlet_artifact=false; evidence_write=false; sidecar_write=false; state_directory_created=false; command_execution=false; check_execution=false; smoke_execution=false; test_execution=false; validation_execution=false; workflow_execution=false; skill_execution=false; runtime_action=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(`Stage scriptlet digest: ${scriptlet.scriptlet_digest}`);
+  if (scriptlet.stage_scriptlet_invariants.findings.length > 0) printList('Findings', scriptlet.stage_scriptlet_invariants.findings);
+  console.log(`Action: ${envelope.action}`);
+}
+
+export function confirmedOneShotPlanEnvelope(root, planFile, { intent = 'implementation', subject = '', confirmPlan = '' } = {}, { commitReadinessEnvelope, digestObject }) {
+  ensureRoot(root);
+  if (!planFile) throw new Error('automation --one-shot-plan requires --from-file <local-plan-file>');
+  if (!subject) throw new Error('automation --one-shot-plan requires --subject <commit-subject>');
+  if (!confirmPlan) throw new Error('automation --one-shot-plan requires --confirm-plan <phrase>');
+  const commitReadiness = commitReadinessEnvelope(root, planFile, { intent, subject }).commit_readiness;
+  const automationEnvelope = runtimeAutomationReadinessEnvelope(root, { digestObject });
+  const automationReadiness = automationEnvelope.runtime_automation_readiness;
+  const registry = runtimeCapabilityRegistry();
+  const confirmedPlan = runtimeConfirmedOneShotPlan({
+    commitReadiness,
+    automationReadiness,
+    registry,
+    registryDigest: automationReadiness.registry_digest,
+    confirmation: { confirmPlan },
+  });
+  const confirmedOneShotPlan = {
+    ...confirmedPlan,
+    confirmed_one_shot_plan_digest: digestConfirmedOneShotPlan(runtimeConfirmedOneShotPlanDigestPayload(confirmedPlan)),
+  };
+  return readonlyLocalJsonEnvelope(root, {
+    mode: 'confirmed-one-shot-plan',
+    ok: confirmedOneShotPlan.plan_invariants.pass,
+    payloadKey: 'confirmed_one_shot_plan',
+    payload: confirmedOneShotPlan,
+    safety: { stage: 'Stage 108', ...confirmedOneShotPlan.boundary_assertions },
+    quality: confirmedOneShotPlan.plan_invariants.findings,
+    action: automationConfirmedPlanActionText,
+  });
+}
+
+function printConfirmedOneShotPlan(envelope) {
+  const plan = envelope.confirmed_one_shot_plan;
+  console.log('Vibecoding Runtime Confirmed One-shot Execution Plan');
+  console.log(`Stage: ${plan.stage}; Kind: ${plan.plan_kind}; pass=${plan.plan_invariants.pass}`);
+  console.log(`Confirmation: plan_confirmed=${plan.confirmation_gate.plan_confirmed}; actions_executed=false; execution_authorized=false`);
+  console.log(`Readiness: contract_valid=${plan.readiness_state.plan_contract_valid}; ready_for_runtime_execution=false; manual_evidence_required=${plan.readiness_state.manual_evidence_required_count}`);
+  for (const item of plan.planned_steps.slice(0, 12)) console.log(`- ${item.id}: ${item.step_kind}; status=planned_not_executed; actions_executed=false; execution_authorized=false`);
+  console.log(`Source bindings: commit_readiness=${plan.source_bindings.commit_readiness_digest}; automation_readiness=${plan.source_bindings.automation_readiness_digest}; registry=${plan.source_bindings.registry_digest}`);
+  printList('Execution order', plan.execution_order);
+  printList('Forbidden actions', plan.forbidden_actions);
+  console.log('Boundary: writes=false; confirmed_one_shot_plan_artifact=false; one_shot_execution_plan_artifact=false; one_shot_execution_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(`Confirmed one-shot plan digest: ${plan.confirmed_one_shot_plan_digest}`);
+  if (plan.plan_invariants.findings.length > 0) printList('Findings', plan.plan_invariants.findings);
+  console.log(`Manual action: ${plan.manual_action}`);
+  console.log(`Action: ${envelope.action}`);
+}
+
+export function runAutomationCommand(options, deps) {
+  const { digestObject } = deps;
+  ensureRoot(options.root);
+  const modes = [options.automationPlan, options.automationReadiness, options.automationOneShotPlan, options.automationStageRunbook, options.automationStageScriptlet].filter(Boolean);
+  if (modes.length !== 1) throw new Error('automation requires exactly one of --plan, --readiness, --one-shot-plan, --stage-runbook, or --stage-scriptlet');
+  if (options.automationPlan) {
+    if (options.write || options.scan || options.once || options.fromDispatch || options.dispatchEvent || options.actor || options.approval || options.run || options.autoRun || options.confirm || options.dryRun || options.preflight || options.dispatch || options.dispatchIntent || options.recoveryPreview || options.hooksPreview || options.candidate || options.approvalPackage) throw new Error('automation --plan is read-only and does not accept execution, dispatch, preview, confirm, dry-run, run, scan, once, preflight, approval, or write flags');
+    if (!options.prompt) throw new Error('automation --plan requires --prompt <text>');
+    if (options.fromFile || options.fromPlan || options.fromRunbook || options.fromConsole || options.selectedStage || options.fromExecutablePlan || options.commitSubject || options.confirmPlan || options.fromReadiness || options.fromFriction || options.methodologyIntent || options.methodologyKind || options.governanceReport || options.task || options.plannerFile || options.plannerFromHook || options.profile || options.learningObservationFiles.length > 0 || options.learningInstinctFile || options.tokenCompactionFiles.length > 0) throw new Error('automation --plan only accepts --prompt, --json, and --root');
+    const envelope = automationPlanEnvelope(options.root, { prompt: options.prompt }, deps);
+    emitReadonlyLocalJsonOutput({ deps, options, channel: 'automation', envelope, print: printAutomationPlan });
+    return;
+  }
+  if (options.automationStageScriptlet) {
+    if (options.write || options.scan || options.once || options.fromDispatch || options.dispatchEvent || options.actor || options.approval || options.run || options.autoRun || options.confirm || options.dryRun || options.preflight || options.dispatch || options.dispatchIntent || options.recoveryPreview || options.hooksPreview || options.candidate || options.approvalPackage) throw new Error('automation --stage-scriptlet is read-only and does not accept execution, dispatch, preview, confirm, dry-run, run, scan, once, preflight, approval, or write flags');
+    if (!options.fromRunbook) throw new Error('automation --stage-scriptlet requires --from-runbook <local-runbook-json>');
+    if (options.fromPlan || options.fromFile || options.fromExecutablePlan || options.commitSubject || options.confirmPlan || options.fromReadiness || options.fromFriction || options.methodologyIntent || options.methodologyKind || options.governanceReport || options.task || options.plannerFile || options.plannerFromHook || options.learningObservationFiles.length > 0 || options.learningInstinctFile || options.tokenCompactionFiles.length > 0) throw new Error('automation --stage-scriptlet only accepts one local runbook file, optional --from-console, optional --stage, --json, and --root');
+    const envelope = stageScriptletEnvelope(options.root, { runbookFile: options.fromRunbook, consoleFile: options.fromConsole, selectedStage: options.selectedStage });
+    emitReadonlyLocalJsonOutput({ deps, options, channel: 'automation', envelope, print: printStageScriptlet });
+    return;
+  }
+  if (options.automationStageRunbook) {
+    if (options.write || options.scan || options.once || options.fromDispatch || options.dispatchEvent || options.actor || options.approval || options.run || options.autoRun || options.confirm || options.dryRun || options.preflight || options.dispatch || options.dispatchIntent || options.recoveryPreview || options.hooksPreview || options.candidate || options.approvalPackage) throw new Error('automation --stage-runbook is read-only and does not accept execution, dispatch, preview, confirm, dry-run, run, scan, once, preflight, or write flags');
+    if (!options.fromPlan) throw new Error('automation --stage-runbook requires --from-plan <local-plan-file>');
+    if (options.fromFile || options.fromRunbook || options.fromConsole || options.selectedStage || options.commitSubject || options.confirmPlan || options.fromReadiness || options.methodologyIntent || options.methodologyKind || options.governanceReport || options.task || options.plannerFile || options.plannerFromHook || options.learningObservationFiles.length > 0 || options.learningInstinctFile || options.tokenCompactionFiles.length > 0) throw new Error('automation --stage-runbook only accepts one local plan file, optional --from-executable-plan, and read-only output flags');
+    const envelope = stageRunbookEnvelope(options.root, options.fromPlan, { executablePlanFile: options.fromExecutablePlan }, deps);
+    emitReadonlyLocalJsonOutput({ deps, options, channel: 'automation', envelope, print: printStageRunbook });
+    return;
+  }
+  if (options.automationOneShotPlan) {
+    if (options.write || options.scan || options.once || options.fromDispatch || options.dispatchEvent || options.actor || options.approval || options.run || options.autoRun || options.confirm || options.dryRun || options.preflight || options.dispatch || options.dispatchIntent || options.recoveryPreview || options.hooksPreview || options.candidate || options.approvalPackage) throw new Error('automation --one-shot-plan is read-only and does not accept execution, dispatch, preview, confirm, dry-run, run, scan, once, preflight, or write flags');
+    if (!options.fromFile) throw new Error('automation --one-shot-plan requires --from-file <local-plan-file>');
+    if (!options.commitSubject) throw new Error('automation --one-shot-plan requires --subject <commit-subject>');
+    if (!options.confirmPlan) throw new Error('automation --one-shot-plan requires --confirm-plan <phrase>');
+    if (options.fromReadiness || options.fromRunbook || options.fromConsole || options.selectedStage || options.fromExecutablePlan || options.methodologyKind || options.governanceReport || options.task || options.plannerFile || options.plannerFromHook || options.learningObservationFiles.length > 0 || options.learningInstinctFile || options.tokenCompactionFiles.length > 0) throw new Error('automation --one-shot-plan only accepts one local plan file, one subject, --confirm-plan, optional intent, and read-only output flags');
+    const envelope = confirmedOneShotPlanEnvelope(options.root, options.fromFile, { intent: options.methodologyIntent || 'implementation', subject: options.commitSubject, confirmPlan: options.confirmPlan }, deps);
+    emitReadonlyLocalJsonOutput({ deps, options, channel: 'automation', envelope, print: printConfirmedOneShotPlan });
+    return;
+  }
+  if (options.write || options.scan || options.once || options.fromDispatch || options.dispatchEvent || options.actor || options.approval || options.run || options.autoRun || options.confirm || options.dryRun || options.preflight || options.dispatch || options.dispatchIntent || options.recoveryPreview || options.hooksPreview || options.candidate || options.approvalPackage) throw new Error('automation --readiness is read-only and does not accept execution, dispatch, preview, confirm, run, scan, once, or write flags');
+  if (options.fromFile || options.fromPlan || options.fromRunbook || options.fromConsole || options.selectedStage || options.fromFriction || options.fromExecutablePlan || options.fromReadiness || options.methodologyIntent || options.methodologyKind || options.governanceReport || options.task || options.confirmPlan || options.commitSubject) throw new Error('automation --readiness does not accept workflow, methodology, governance, task, commit subject, confirmation, or evidence inputs');
+  const envelope = runtimeAutomationReadinessEnvelope(options.root, { digestObject });
+  emitReadonlyLocalJsonOutput({ deps, options, channel: 'automation', envelope, print: printRuntimeAutomationReadiness });
+}

package/tools/vibe-runtime/runtime-automation-plan-model.mjs

@@ -0,0 +1,239 @@
+import {
+  automationPolicySnapshot,
+} from './runtime-automation-policy-model.mjs';
+
+export function automationPlanBoundaryAssertions() {
+  return {
+    automation_plan_artifact: false,
+    writes: false,
+    state_directory_created: false,
+    sidecar_write: false,
+    source_write: false,
+    prompt_write: false,
+    prompt_mutation: false,
+    template_mutation: false,
+    skill_mutation: false,
+    hook_registration: false,
+    command_execution: false,
+    check_execution: false,
+    test_execution: false,
+    verification_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    foreground_run: false,
+    auto_execution: false,
+    repair_execution: false,
+    evidence_repair: false,
+    output_mutation: false,
+    dynamic_tool_execution: false,
+    hidden_daemon: false,
+    background_watcher: false,
+    embeddings: false,
+    remote_config: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    git: false,
+    git_diff_read: false,
+    git_write: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+export function buildAutomationPlanEnvelopeModel({
+  prompt = '',
+  workflowStartEnvelope,
+  tokenSaviorBudgetEnvelope,
+  learningAdviceEnvelope,
+  entryRuntimeSummaryEnvelope = null,
+  policy = automationPolicySnapshot(),
+  statePresent = false,
+  digestObject,
+} = {}) {
+  const entrySummary = entryRuntimeSummaryEnvelope?.entry_runtime_summary || null;
+  const start = workflowStartEnvelope?.workflow_start || {};
+  const budget = tokenSaviorBudgetEnvelope?.token_savior_budget || {};
+  const advice = learningAdviceEnvelope?.learning_advice || {};
+  const boundaryAssertions = automationPlanBoundaryAssertions();
+  const sourceBindings = {
+    workflow_start_digest: start.start_digest || '',
+    token_savior_budget_digest: budget.budget_digest || '',
+    learning_advice_digest: advice.advice_digest || '',
+    entry_runtime_summary_digest: entrySummary?.summary_digest || '',
+    policy_profile: policy.profile || '',
+  };
+  const plan = {
+    version: 1,
+    stage: 'Stage 146',
+    plan_kind: 'read-only-automation-plan',
+    prompt: String(prompt || '').trim(),
+    normalized_intent: start.normalized_intent || '',
+    profile: policy.profile || 'advice-only',
+    max_risk: policy.max_risk || 'low',
+    requires_confirm: policy.requires_confirm === true,
+    allowed_actions: asList(policy.allowed_actions),
+    forbidden_actions: asList(policy.forbidden_actions),
+    source_bindings: sourceBindings,
+    context_load_plan: entrySummary?.context_load_plan || null,
+    defer_policy: entrySummary?.defer_policy || null,
+    plan_items: automationPlanItems({ start, budget, advice, entrySummary }),
+    confirmation_gates: automationConfirmationGates(),
+    policy,
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = automationPlanInvariants(plan);
+  const withInvariants = {
+    ...plan,
+    ok: invariants.pass,
+    automation_plan_invariants: invariants,
+  };
+  return {
+    mode: 'automation-plan',
+    ok: invariants.pass,
+    state_present: Boolean(statePresent || workflowStartEnvelope?.state_present || tokenSaviorBudgetEnvelope?.state_present || learningAdviceEnvelope?.state_present),
+    automation_plan: {
+      ...withInvariants,
+      plan_digest: digestObject(automationPlanDigestPayload(withInvariants)),
+    },
+    source_envelopes: sourceBindings,
+    safety: { stage: 'Stage 146', ...boundaryAssertions },
+    quality: invariants.findings,
+    action: 'automation plan was computed read-only from workflow start, token budget, learning advice, and the selected automation policy profile. It only recommends visible next steps and deferred higher-risk automation stages; no state directory, sidecar, command, check, test, workflow skill run, runtime action, git diff read, git write, commit, push, PR, merge, platform API, external network, model, MCP, subagent, worktree, or business source write occurred.',
+  };
+}
+
+export function automationPlanDigestPayload(plan) {
+  return {
+    stage: plan.stage,
+    plan_kind: plan.plan_kind,
+    prompt: plan.prompt,
+    normalized_intent: plan.normalized_intent,
+    profile: plan.profile,
+    max_risk: plan.max_risk,
+    requires_confirm: plan.requires_confirm,
+    allowed_actions: plan.allowed_actions,
+    forbidden_actions: plan.forbidden_actions,
+    source_bindings: plan.source_bindings,
+    context_load_plan: plan.context_load_plan,
+    defer_policy: plan.defer_policy,
+    plan_items: plan.plan_items,
+    confirmation_gates: plan.confirmation_gates,
+    boundary_assertions: plan.boundary_assertions,
+    automation_plan_invariants: plan.automation_plan_invariants,
+  };
+}
+
+export function automationPlanInvariants(plan) {
+  const boundary = plan.boundary_assertions || {};
+  const unsafeBoundaries = Object.entries(boundary)
+    .filter(([key, value]) => key !== 'profile' && value !== false)
+    .map(([key]) => key);
+  const missingBoundary = Object.keys(automationPlanBoundaryAssertions())
+    .filter((key) => key !== 'profile' && boundary[key] !== false);
+  const findings = [
+    ...(plan.stage === 'Stage 146' ? [] : ['stage must be Stage 146']),
+    ...(plan.plan_kind === 'read-only-automation-plan' ? [] : ['plan_kind must be read-only-automation-plan']),
+    ...(plan.profile === 'advice-only' ? [] : ['P0 automation plan must use advice-only profile']),
+    ...(plan.max_risk === 'low' ? [] : ['P0 max_risk must be low']),
+    ...(plan.requires_confirm === false ? [] : ['P0 plan generation must not require confirm']),
+    ...(Array.isArray(plan.allowed_actions) && plan.allowed_actions.length > 0 ? [] : ['allowed_actions must not be empty']),
+    ...(Array.isArray(plan.forbidden_actions) && plan.forbidden_actions.length > 0 ? [] : ['forbidden_actions must not be empty']),
+    ...(plan.source_bindings?.workflow_start_digest ? [] : ['workflow_start_digest is required']),
+    ...(plan.source_bindings?.token_savior_budget_digest ? [] : ['token_savior_budget_digest is required']),
+    ...(plan.source_bindings?.learning_advice_digest ? [] : ['learning_advice_digest is required']),
+    ...(plan.source_bindings?.entry_runtime_summary_digest ? [] : ['entry_runtime_summary_digest is required']),
+    ...(plan.context_load_plan?.plan_kind === 'entry-context-load-plan' ? [] : ['context_load_plan.plan_kind must be entry-context-load-plan']),
+    ...(plan.defer_policy?.policy_kind === 'entry-context-defer-policy' ? [] : ['defer_policy.policy_kind must be entry-context-defer-policy']),
+    ...(Array.isArray(plan.plan_items) && plan.plan_items.length >= 3 ? [] : ['plan_items must include workflow, token, and learning items']),
+    ...(plan.writes === false ? [] : ['writes must remain false']),
+    ...(plan.state_directory_created === false ? [] : ['state_directory_created must remain false']),
+    ...unsafeBoundaries.map((key) => `boundary assertion must remain false: ${key}`),
+    ...missingBoundary.map((key) => `boundary assertion missing or not false: ${key}`),
+  ];
+  return {
+    pass: findings.length === 0,
+    checked: ['policy_profile', 'source_envelope_bindings', 'context_load_plan_binding', 'defer_policy_binding', 'visible_plan_items', 'confirmation_gates', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+function automationPlanItems({ start, budget, advice, entrySummary }) {
+  const contextPlan = entrySummary?.context_load_plan || null;
+  const defer = entrySummary?.defer_policy || null;
+  return [
+    {
+      id: 'workflow-entry-summary',
+      stage: 'P0',
+      status: 'recommend_only',
+      source_digest: start.start_digest || '',
+      capability: 'workflow entry routing summary',
+      recommendation: start.next_manual_action || start.entry_summary?.first_user_decision || '',
+      executes: false,
+      writes: false,
+    },
+    {
+      id: 'token-budget-summary',
+      stage: 'P0',
+      status: 'recommend_only',
+      source_digest: budget.budget_digest || '',
+      capability: 'token saving and context loading guidance',
+      recommendation: contextPlan
+        ? `Load ${contextPlan.load_order.length} compact context steps with ${contextPlan.recommended_profile}; defer ${defer?.deferred_items?.length || 0} raw context groups.`
+        : budget.recommended_profile ? `Use ${budget.recommended_profile} before loading deferred context.` : '',
+      context_load_plan_bound: Boolean(contextPlan),
+      defer_policy_bound: Boolean(defer),
+      executes: false,
+      writes: false,
+    },
+    {
+      id: 'learning-advice-summary',
+      stage: 'P0',
+      status: 'recommend_only',
+      source_digest: advice.advice_digest || '',
+      capability: 'experience learning next-step guidance',
+      recommendation: advice.recommended_next_learning_step || advice.manual_action || '',
+      automatic_promotion: advice.promotion_boundary?.automatic_promotion === true,
+      executes: false,
+      writes: false,
+    },
+    {
+      id: 'higher-risk-automation-boundary',
+      stage: 'P1_plus',
+      status: 'blocked_pending_later_stage',
+      capability: 'tests, git diff, evidence repair, subagent dispatch, and source changes',
+      recommendation: 'Keep higher-risk automation behind profile upgrade, explicit approval, sidecar evidence, and separate validation.',
+      requires_confirm: true,
+      executes: false,
+      writes: false,
+    },
+  ];
+}
+
+function automationConfirmationGates() {
+  return {
+    approve_supported_in_p0: false,
+    sidecar_write_requires_future_confirm: true,
+    test_run_requires_future_confirm: true,
+    git_diff_read_requires_future_boundary: true,
+    subagent_requires_future_permission: true,
+    business_source_write_requires_future_explicit_approval: true,
+    automatic_learning_promotion: false,
+  };
+}
+
+function asList(value) {
+  return Array.isArray(value) ? value.slice() : [];
+}