@jtf19/vibecoding-kit 0.1.0

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

@@ -0,0 +1,175 @@
+const automationProfileDefinitions = Object.freeze({
+  'advice-only': Object.freeze({
+    profile: 'advice-only',
+    label: 'Advice only',
+    max_risk: 'low',
+    requires_confirm: false,
+    allowed_actions: Object.freeze([
+      'read_runtime_entry_summary',
+      'read_token_budget_summary',
+      'read_learning_advice_summary',
+      'recommend_context_loading',
+      'recommend_manual_next_step',
+    ]),
+  }),
+  'sidecar-only': Object.freeze({
+    profile: 'sidecar-only',
+    label: 'Sidecar only',
+    max_risk: 'medium',
+    requires_confirm: true,
+    allowed_actions: Object.freeze([
+      'read_runtime_summaries',
+      'write_local_state_sidecars_after_confirmation',
+      'audit_sidecar_shape',
+    ]),
+  }),
+  'local-foreground-run': Object.freeze({
+    profile: 'local-foreground-run',
+    label: 'Local foreground run',
+    max_risk: 'medium',
+    requires_confirm: true,
+    allowed_actions: Object.freeze([
+      'read_runtime_summaries',
+      'run_allowlisted_foreground_commands_after_confirmation',
+      'write_execution_evidence_sidecars_after_confirmation',
+    ]),
+  }),
+  'sandbox-patch': Object.freeze({
+    profile: 'sandbox-patch',
+    label: 'Sandbox patch',
+    max_risk: 'high',
+    requires_confirm: true,
+    allowed_actions: Object.freeze([
+      'read_runtime_summaries',
+      'generate_patch_plan_after_confirmation',
+      'apply_patch_to_sandbox_after_confirmation',
+    ]),
+  }),
+  'autopilot-lab': Object.freeze({
+    profile: 'autopilot-lab',
+    label: 'Autopilot lab',
+    max_risk: 'highest',
+    requires_confirm: true,
+    allowed_actions: Object.freeze([
+      'read_runtime_summaries',
+      'preview_task_authorization_budget',
+      'validate_allowed_paths_and_commands',
+      'recommend_bounded_autopilot_next_step',
+    ]),
+  }),
+  'confirmed-worktree-apply': Object.freeze({
+    profile: 'confirmed-worktree-apply',
+    label: 'Confirmed worktree apply',
+    max_risk: 'highest',
+    requires_confirm: true,
+    allowed_actions: Object.freeze([
+      'read_runtime_summaries',
+      'apply_to_worktree_after_explicit_approval',
+      'require_post_apply_evidence',
+    ]),
+  }),
+});
+
+const forbiddenDefaults = Object.freeze([
+  'autopilot_lab_profile_without_complete_budget',
+  'autopilot_profile_config_write_without_separate_confirmation',
+  'autopilot_runtime_action_without_execution_gate',
+  'autopilot_source_write_without_source_apply_gate',
+  'autopilot_git_write_without_git_gate',
+  'autopilot_background_runtime_without_long_running_gate',
+  'hidden_daemon',
+  'background_watcher',
+  'implicit_subagent',
+  'platform_api_call',
+  'external_network_call',
+  'model_invocation',
+  'unapproved_command_run',
+  'unallowlisted_command_run',
+  'git_write',
+  'git_commit',
+  'git_push',
+  'git_merge',
+  'git_tag',
+  'pull_request_create',
+  'business_source_write_without_explicit_approval',
+  'evidence_result_fabrication',
+]);
+
+export function automationProfileNames() {
+  return Object.keys(automationProfileDefinitions);
+}
+
+export function automationPolicyProfiles() {
+  return automationProfileNames().map((name) => cloneProfile(automationProfileDefinitions[name]));
+}
+
+export function automationForbiddenDefaults() {
+  return forbiddenDefaults.slice();
+}
+
+export function automationPolicyProfile(profile = 'advice-only') {
+  const normalized = String(profile || 'advice-only').trim() || 'advice-only';
+  const selected = automationProfileDefinitions[normalized];
+  if (!selected) throw new Error(`Unknown automation profile: ${normalized}`);
+  return cloneProfile(selected);
+}
+
+export function automationPolicySnapshot({ profile = 'advice-only' } = {}) {
+  const selected = automationPolicyProfile(profile);
+  return {
+    version: 1,
+    policy_kind: 'automation-policy-profile',
+    profile: selected.profile,
+    label: selected.label,
+    max_risk: selected.max_risk,
+    requires_confirm: selected.requires_confirm,
+    allowed_actions: selected.allowed_actions.slice(),
+    forbidden_actions: forbiddenDefaults.slice(),
+    profile_catalog: automationPolicyProfiles(),
+    boundary_assertions: automationPolicyBoundaryAssertions(selected.profile),
+    local_only: true,
+    deterministic: true,
+  };
+}
+
+export function automationPolicyBoundaryAssertions(profile = 'advice-only') {
+  return {
+    profile,
+    writes: false,
+    state_directory_created: false,
+    hidden_daemon: false,
+    background_watcher: false,
+    command_execution: false,
+    check_execution: false,
+    test_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    git: false,
+    git_diff_read: false,
+    git_write: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    source_write: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+function cloneProfile(profile) {
+  return {
+    profile: profile.profile,
+    label: profile.label,
+    max_risk: profile.max_risk,
+    requires_confirm: profile.requires_confirm,
+    allowed_actions: profile.allowed_actions.slice(),
+  };
+}

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

@@ -0,0 +1,347 @@
+import crypto from 'node:crypto';
+import { buildAutopilotLabProfileContract } from './runtime-autopilot-lab-profile-contract.mjs';
+
+const automationReadinessStage = 'Stage 103';
+const automationReadinessKind = 'runtime-automation-readiness-matrix';
+
+const readinessCategories = [
+  {
+    category: 'auto_safe',
+    label: 'Deterministic read-only automation-safe checks',
+    rule: 'May be called by a future automation plan because it is deterministic, local, read-only, and produces only a report envelope.',
+  },
+  {
+    category: 'confirm_required',
+    label: 'Explicit confirmation required before local state write',
+    rule: 'May write local sidecars or state only through existing explicit confirmation gates; never runs implicitly from Stage 103.',
+  },
+  {
+    category: 'advice_only',
+    label: 'Advice and workflow orientation only',
+    rule: 'Provides guidance, receipts, contracts, or recommendations; future automation may read it but must not treat it as execution approval.',
+  },
+  {
+    category: 'forbidden',
+    label: 'Permanently forbidden automation boundary',
+    rule: 'Must not be automated by this runtime surface without a separate explicit user action outside Stage 103.',
+  },
+];
+
+const commandClassifications = {
+  'entry --advice': { category: 'advice_only', reason: 'entry advice chooses a workflow lane but must not act for the user' },
+  'entry --contract': { category: 'advice_only', reason: 'entry contract shapes the next manual workflow step' },
+  'advice --hub': { category: 'advice_only', reason: 'unified advice hub aggregates guidance only' },
+  'methodology --readiness': { category: 'advice_only', reason: 'workflow readiness is an orientation judgment, not approval to execute' },
+  'workflow --cockpit': { category: 'advice_only', reason: 'workflow cockpit is a visible control panel, not an executor' },
+  'workflow --receipt': { category: 'advice_only', reason: 'workflow receipt makes routing visible but does not execute' },
+  'workflow --start': { category: 'advice_only', reason: 'workflow start panel is low-friction guidance only' },
+  'workflow --run-plan': { category: 'advice_only', reason: 'P7 workflow run plan computes a selected skill, required inputs, handoff, stop conditions, evidence requirements, and one controlled single-step plan chain without executing skills, writing evidence/state/source, running commands/checks/tests, git, platform APIs, model invocation, MCP, or subagents' },
+  'workflow --entry-ux': { category: 'advice_only', reason: 'progressive entry UX contract recommends one visible workflow route without executing skills or injecting full context' },
+  'workflow --next-action-console': { category: 'auto_safe', reason: 'Stage 127 one-screen next action console reads local friction, runbook, and evidence JSON to render preview-only next steps without command execution, state writes, git, platform APIs, model invocation, or subagents' },
+  'workflow --entry-discipline': { category: 'auto_safe', reason: 'Stage 135 entry trigger discipline reads one local transcript JSON only to validate the using-vibecoding first gate, protocol layers, intent route match, and no direct implementation, blind bug fix, false skill claim, forbidden trigger, auto execution, git, platform APIs, model invocation, MCP, or subagents without executing workflow skills, commands, checks, tests, writing state, or mutating artifacts' },
+  'workflow --entry-tightening': { category: 'auto_safe', reason: 'Stage 141 entry trigger tightening reads local Stage 135 entry discipline JSON and local Stage 140 parity scorecard JSON to recommend missing entry moves, a copy-ready opening sentence, and must-not-skip boundaries without executing workflow skills, commands, checks, tests, hooks, adapters, writing artifacts/state/source, mutating prompts/templates/skills, git, platform APIs, model invocation, MCP, or subagents' },
+  'workflow --next-evidence-prompts': { category: 'auto_safe', reason: 'Stage 143 next-action evidence prompts read local Stage 127 console JSON, Stage 132 dashboard JSON, and Stage 139 upgrades JSON to emit evidence prompt cards, validation notes, and blocked-until conditions without writing evidence, running commands/checks/tests/workflows, mutating prompts/templates/skills, git, platform APIs, model invocation, MCP, or subagents' },
+  'workflow --sequence': { category: 'advice_only', reason: 'workflow sequence guides order without dispatching work' },
+  'workflow --loop-contract': { category: 'advice_only', reason: 'workflow loop contract makes the plan/docs/code/self-test/commit-readiness loop visible but is not execution approval' },
+  'workflow --close-loop-dashboard': { category: 'auto_safe', reason: 'dashboard only, no execution; deterministically aggregates Stage 105-108 readiness without running checks or git' },
+  'workflow --close-loop': { category: 'auto_safe', reason: 'human-friendly close-loop alias only, no execution; composes Stage 109 dashboard labels without running checks, git, repair, or writing artifacts' },
+  'workflow --next-evidence': { category: 'auto_safe', reason: 'human-friendly next-evidence alias only, no execution; composes local Stage 105 and optional Stage 110-113 envelopes without running checks, git, review, TDD, or writing artifacts' },
+  'onboarding --brief': { category: 'advice_only', reason: 'onboarding brief explains protocol and entry expectations' },
+  'completion --readiness': { category: 'auto_safe', reason: 'completion readiness is deterministic and read-only' },
+  'readiness --gates': { category: 'auto_safe', reason: 'Stage 24 readiness gate split reads local evidence and separates report_done, local_commit, review_request, handoff, and release_candidate blockers without changing readiness --score semantics or authorizing git/PR/release actions' },
+  'completion --evidence-bundle': { category: 'auto_safe', reason: 'completion evidence bundle packages local evidence into a Stage 124 human one-screen closeout bundle without running checks, writing artifacts, invoking git/platform APIs, or dispatching subagents' },
+  'completion --repair-plan': { category: 'confirm_required', reason: 'P6 evidence repair plan reads one local completion bundle; only explicit confirmation may write a local repair-plan sidecar and it never mutates original evidence, test results, review results, git state, or business source' },
+  'release --gate': { category: 'confirm_required', reason: 'release gate may write a local release gate sidecar only after explicit confirmation' },
+  'release --verify-gate': { category: 'auto_safe', reason: 'release gate verification reads and verifies an existing local artifact' },
+  'release --notes': { category: 'confirm_required', reason: 'release notes can persist local release evidence only after explicit confirmation' },
+  'release --verify-notes': { category: 'auto_safe', reason: 'release notes verification reads and verifies an existing local artifact' },
+  'release --commit-guard': { category: 'auto_safe', reason: 'commit guard checks text hygiene without invoking git' },
+  'release --commit-readiness': { category: 'auto_safe', reason: 'commit readiness envelope binds local evidence requirements while keeping commit_execution_authorized=false' },
+  'release --diff-coverage': { category: 'auto_safe', reason: 'diff coverage reads a local diff file and plan manifest without calling git or writing artifacts' },
+  'release --diff-read': { category: 'auto_safe', reason: 'git diff evidence runs only fixed read-only git diff commands, binds a local plan manifest, and keeps git_write=false plus worktree_write=false without state writes or test execution' },
+  'release --suite-plan': { category: 'auto_safe', reason: 'timing suite plan reads one local timing JSON and recommends a targeted suite without changing package scripts, suite order, required gate, failure strictness, git, state, or worktree' },
+  'tests --run': { category: 'confirm_required', reason: 'test run evidence requires explicit confirmation and executes only fixed foreground allowlisted profiles; no arbitrary shell string, git write, worktree write, failure repair, platform API, model invocation, MCP, subagent, or business source write' },
+  'subagents --adapter-dispatch': { category: 'confirm_required', reason: 'P8/P30 adapter dispatch requires explicit confirmation plus a passing explicit permission gate before writing one local adapter handoff sidecar from existing dispatch and platform capability artifacts; preview is read-only and neither path creates a session, calls platform APIs, invokes models, runs subagents, uses git, writes worktree, or mutates business source' },
+  'sdd --plan': { category: 'auto_safe', reason: 'Stage 149 SDD loop plan reads one local implementation plan and emits task brief plus implementer/reviewer/fixer dispatch intent without writing state, executing commands/tests/workflows, invoking models, platform APIs, subagents, git, worktree, or source writes' },
+  'sdd --task-brief': { category: 'confirm_required', reason: 'P16 SDD task brief previews read-only by default; explicit confirmation writes only local markdown plus JSON sidecars under SDD state and never executes commands/tests, calls platforms/models/subagents, mutates source, writes git, creates worktrees, PRs, pushes, or merges' },
+  'sdd --review-package': { category: 'confirm_required', reason: 'P17 SDD review package uses fixed read-only git rev-parse/log/diff commands for explicit base..head and active task brief/report digest binding; explicit confirmation writes only local diff markdown plus JSON sidecars under SDD state and never mutates source, runs tests, writes git, creates worktrees, commits, pushes, PRs, merges, calls platforms/models/MCP, or invokes subagents' },
+  'sdd --run-loop': { category: 'confirm_required', reason: 'Stage 149 SDD run-loop requires explicit confirmation and writes only local progress plus task brief and adapter dispatch sidecars for one pending task; it does not call subagents, invoke models/platform APIs, execute tests/commands, write source, use git, create worktrees, PRs, pushes, or merges' },
+  'sdd --evidence-chain': { category: 'confirm_required', reason: 'Stage 149 SDD evidence-chain requires explicit confirmation, runs only one fixed allowlisted test profile, reads fixed git diff summaries, and writes local evidence plus progress sidecars while preserving failure facts; it does not call subagents, invoke models/platform APIs, write source, use git write, create worktrees, PRs, pushes, or merges' },
+  'sdd --consume-adapter-result': { category: 'confirm_required', reason: 'P18 SDD adapter result consumption requires explicit confirmation and reads one local adapter result plus existing SDD dispatch/progress/report artifacts, validates DONE/QUESTIONS/BLOCKED report status, and writes only local progress and consumption sidecars; it does not call adapters, subagents, models, platform APIs, write source, use git write, create worktrees, PRs, pushes, or merges' },
+  'workspace --isolate-plan': { category: 'auto_safe', reason: 'Stage 150 workspace isolate-plan reads an optional local plan and emits an isolation contract preview only; no state write, source write, command/test execution, git, worktree creation, platform API, model, MCP, subagent, PR, push, or merge occurs' },
+  'workspace --create': { category: 'confirm_required', reason: 'Stage 150 workspace create requires explicit confirmation and writes only local workspace isolation contract sidecars under .vibecoding-state/workspaces; it does not create git worktrees, mutate source, execute commands/tests, write git, commit, push, PR, merge, call platform APIs, invoke models, MCP, or subagents' },
+  'workspace --status': { category: 'auto_safe', reason: 'Stage 150 workspace status reads local isolation contract sidecars only without state writes, source writes, command execution, git, worktree action, platform API, model, MCP, subagent, PR, push, or merge' },
+  'workspace --cleanup-plan': { category: 'auto_safe', reason: 'Stage 150 workspace cleanup-plan reads local isolation contract sidecars and emits manual cleanup guidance without deleting files, removing worktrees, running git, mutating source, or writing state' },
+  'source --patch-plan': { category: 'auto_safe', reason: 'P9 source patch plan reads one local task artifact and emits a sandbox patch plan, path allowlist, approval requirement, rollback guidance requirement, and post-apply evidence requirement without writing state/source, running commands/tests, git, platform APIs, model invocation, MCP, or subagents' },
+  'source --sandbox-apply': { category: 'confirm_required', reason: 'P9 sandbox apply is an explicit alias for the existing confirmed source sandbox sidecar path; it writes only local sandbox-run state and never writes main worktree, git, commits, pushes, PRs, platform APIs, models, MCP, subagents, or business source' },
+  'source --apply-to-worktree': { category: 'confirm_required', reason: 'P9 source apply-to-worktree requires explicit confirmation plus a verified merge approval and delegates to the existing Stage 48 controlled allowlisted apply; no git, commit, push, PR, daemon, watcher, hidden execution, platform API, model invocation, MCP, or subagent is allowed' },
+  'release --staged-commit-readiness': { category: 'auto_safe', reason: 'staged commit readiness binds a local Stage 118 runbook and local Stage 119 execution evidence while keeping commit_allowed_by_contract=false and never invoking git' },
+  'release --closeout-readiness': { category: 'auto_safe', reason: 'P13 closeout readiness reads local SDD ledger, test evidence, diff evidence, and task commit readiness JSON to recommend manual commit, no-commit, PR, or stop without writing state, running git, pushing, opening PRs, merging, platform APIs, models, MCP, subagents, worktrees, or source writes' },
+  'release --task-commit-readiness': { category: 'auto_safe', reason: 'Stage 151 task commit readiness reads one local task result, requires superpowers-parity-task-commits, isolated workspace evidence, clean review, passing required tests, non-main branch evidence, and a commit subject while keeping runtime git execution false and writing nothing' },
+  'release --task-commit': { category: 'confirm_required', reason: 'Stage 151 task commit gate requires explicit confirmation and a passing task commit readiness artifact to write only a local manual git decision sidecar; it does not run git add, commit, push, PR, merge, checks, tests, source writes, platform APIs, models, MCP, or subagents' },
+  'review --intake': { category: 'auto_safe', reason: 'review intake reads local review feedback and optional plan manifest without invoking reviewers, repair_execution, platform APIs, or git' },
+  'review --resolution': { category: 'auto_safe', reason: 'review resolution reads local intake and repair evidence without invoking reviewers, repair_execution, platform APIs, or git' },
+  'governance --compatibility --report': { category: 'auto_safe', reason: 'compatibility report is deterministic and read-only' },
+  'governance --pr-readiness': { category: 'confirm_required', reason: 'PR readiness can write a local governance sidecar only after explicit confirmation' },
+  'governance --pr-review-intake': { category: 'confirm_required', reason: 'PR review intake can write local governance intake only after explicit confirmation' },
+  'governance --convergence --report': { category: 'auto_safe', reason: 'convergence report is deterministic and read-only' },
+  'governance --superpowers-gap': { category: 'auto_safe', reason: 'Superpowers gap matrix reads local comparison sources and registry only; no execution, network, platform API, git, subagent, or state write' },
+  'governance --superpowers-regression-guard': { category: 'auto_safe', reason: 'Stage 125 Superpowers regression guard aggregates local Stage 115-124 signals without running commands, writing artifacts, invoking git/platform APIs, or dispatching subagents' },
+  'governance --experience-friction': { category: 'auto_safe', reason: 'Stage 126 experience friction matrix reads one local session evidence JSON and deterministically scores daily-use friction without command execution, state writes, git, platform APIs, model invocation, or subagents' },
+  'governance --experience-dashboard': { category: 'auto_safe', reason: 'Stage 132 experience regression dashboard reads local Stage 126 friction plus optional Stage 127 console, Stage 128 token budget, and Stage 129 learning pattern JSON to report deterministic UX scorecard deltas, blockers, and next bet without command execution, state writes, dashboard artifacts, git, platform APIs, model invocation, MCP, or subagents' },
+  'governance --experience-upgrades': { category: 'auto_safe', reason: 'Stage 139 experience upgrade prioritizer reads local Stage 133 comparison, local Stage 132 dashboard, and optional Stage 137 install experience JSON to rank upgrade candidates, recommended stage order, and deferrals without executing upgrades, writing artifacts, prompt mutation, hook registration, git, platform APIs, model invocation, MCP, or subagents' },
+  'governance --superpowers-parity-scorecard': { category: 'auto_safe', reason: 'Stage 140 Superpowers parity scorecard reads local Stage 133 comparison, Stage 135 entry discipline, Stage 137 install experience, and Stage 139 upgrades JSON to explain absorbed advantages, remaining gaps, do-not-cross boundaries, and next-cycle bet without writing artifacts, injecting full skills, executing checks/evals/workflows, git, platform APIs, model invocation, MCP, or subagents' },
+  'governance --contributor-guardrails': { category: 'auto_safe', reason: 'Stage 146 contributor guardrail evidence reads local Stage 140 parity scorecard JSON and local Stage 143 next-action evidence prompts JSON to emit guardrail findings, required disclosures, unsafe closeout risks, and a non-authorizing closeout contract without creating PRs, searching remote PR/review state, pushing, merging, running commands/checks/tests/workflows, auto-fixing, writing artifacts/state/source, git, platform APIs, model invocation, MCP, or subagents' },
+  'governance --subagent-permission': { category: 'auto_safe', reason: 'Stage 147 subagent permission visibility reads local Stage 140 parity scorecard JSON and local Stage 146 contributor guardrails JSON to emit permission gates, brief requirements, must-ask-user-first prompts, and a non-authorizing visibility contract without subagent dispatch, session creation, hidden handoff, running commands/checks/tests/workflows, writing artifacts/state/source, git, PR, push, merge, platform APIs, model invocation, MCP, or worktree action' },
+  'governance --superpowers-comparison': { category: 'auto_safe', reason: 'Stage 133 Superpowers comparative evidence matrix reads local fork/superpowers and Vibecoding source files to report parity gaps, Vibecoding advantages, borrowable patterns, do-not-copy boundaries, recommended stages, and next comparison bet without command execution, hook execution, checks, tests, state writes, comparison artifacts, git, platform APIs, model invocation, MCP, or subagents' },
+  'governance --traceability-map': { category: 'auto_safe', reason: 'skill-to-runtime traceability map reads local skill files and the runtime capability registry without executing skills, checks, git, subagents, or writing state' },
+  'governance --advice': { category: 'advice_only', reason: 'governance advice explains closeout lanes without running release actions' },
+  'governance --surface': { category: 'auto_safe', reason: 'capability surface is deterministic read-only inventory' },
+  'governance --surface --drift-guard': { category: 'auto_safe', reason: 'drift guard checks local contracts without writing state' },
+  'automation --readiness': { category: 'auto_safe', reason: 'automation readiness matrix only classifies capabilities' },
+  'automation --one-shot-plan': { category: 'auto_safe', reason: 'confirmed one-shot plan contract binds local readiness evidence while keeping actions_executed=false and execution_authorized=false' },
+  'automation --stage-runbook': { category: 'auto_safe', reason: 'sequential stage runbook derives ordered local stage control-plane steps and attaches a Stage 9 runbook executor preview dry-run contract without executing commands, writing runbooks, mutating source, or invoking git/subagents' },
+  'automation --stage-scriptlet': { category: 'auto_safe', reason: 'Stage 130 copy-ready stage execution scriptlet reads local Stage 118 runbook and optional Stage 127 console JSON to render PowerShell command previews, expected markers, evidence capture template, and stop conditions without executing commands, running smoke/check/test, writing evidence or sidecars, mutating source, git add/commit/push/PR/merge, platform APIs, model invocation, MCP, or subagents' },
+  'evals --catalog': { category: 'auto_safe', reason: 'eval catalog reads builtin suite metadata without writing state or running sessions' },
+  'evals --run-contract': { category: 'confirm_required', reason: 'eval suite/run/report sidecars may be written only after explicit confirmation' },
+  'evals --run-scenario': { category: 'confirm_required', reason: 'eval suite/run/report sidecars may be written only after explicit confirmation' },
+  'evals --run-behavior': { category: 'confirm_required', reason: 'eval suite/run/report sidecars may be written only after explicit confirmation' },
+  'evals --run-adversarial': { category: 'confirm_required', reason: 'eval suite/run/report sidecars may be written only after explicit confirmation' },
+  'evals --behavior-contract': { category: 'auto_safe', reason: 'behavior contract reads a local transcript artifact and returns a deterministic report without writing state or invoking git/subagents' },
+  'evals --transcript-intake': { category: 'auto_safe', reason: 'P21 platform transcript intake reads one local platform-exported JSON inside the project root, validates transcript shape and boundary markers, and returns a normalized report without executing transcript commands, writing state/source, git, platform APIs, model invocation, MCP, or subagents' },
+  'evals --superpowers-style-pack': { category: 'auto_safe', reason: 'Stage 138 Superpowers-style behavioral eval scenario pack reads one local Stage 133 comparison JSON to emit deterministic scenario contracts without eval execution, agent sessions, model judges, command execution, state writes, git, platform APIs, model invocation, MCP, or subagents' },
+  'evals --local-behavior-contracts': { category: 'auto_safe', reason: 'Stage 145 local behavior eval contracts read local Stage 138 Superpowers-style eval scenario pack JSON and local Stage 141 entry tightening JSON to emit deterministic contract cases, local judge definitions, and live-eval deferrals without running evals, creating agent sessions, invoking model judges, writing artifacts/state/source, mutating prompts/templates/skills/hooks, git, platform APIs, MCP, or subagents' },
+  'evals --verify': { category: 'auto_safe', reason: 'eval verify reads and verifies an existing local eval artifact without writing state' },
+  'platforms --catalog': { category: 'auto_safe', reason: 'platform catalog reads builtin platform capability metadata without platform API calls or state writes' },
+  'platforms --bootstrap-matrix': { category: 'auto_safe', reason: 'adapter bootstrap matrix reads local adapter manifests and install docs without installing adapters, executing hooks, writing state, git, or platform APIs' },
+  'platforms --entry-acceptance': { category: 'auto_safe', reason: 'Stage 131 adapter entry acceptance reads one local adapter transcript JSON and deterministically validates using-vibecoding entry, lightweight routing, visible next action, workflow explanation, and no auto execution without running adapters, hooks, workflow skills, platform APIs, models, MCP, subagents, git, or writing state' },
+  'platforms --session-start-shape': { category: 'auto_safe', reason: 'Stage 134 session-start shape acceptance reads one local captured session-start output and deterministically validates adapter-specific additionalContext/additional_context shape, using-vibecoding lightweight routing markers, and no full skill injection or auto execution without running hooks, adapters, checks, tests, workflow skills, platform APIs, models, MCP, subagents, git, or writing state' },
+  'platforms --session-start-examples': { category: 'auto_safe', reason: 'Stage 142 session-start example pack reads local Stage 134 shape acceptance JSON and local Stage 137 install experience JSON to emit copy-ready adapter output examples, context shapes, and format warnings without writing examples, executing hooks/adapters/workflows/skills/commands/checks/tests, mutating prompts/templates/skills/manifests/docs/source, installing adapters, state writes, git, platform APIs, model invocation, MCP, subagents, or worktree action' },
+  'platforms --adapter-packaging-consistency': { category: 'auto_safe', reason: 'Stage 148 adapter packaging consistency reads local Stage 122 bootstrap matrix JSON and local Stage 142 session-start examples JSON to emit adapter rows, missing install markers, and copy-ready fix notes without installing adapters, executing hooks/adapters/commands/checks/tests/workflows, mutating plugin manifests/install docs/source/prompts/templates/skills, writing state/artifacts, git, platform APIs, model invocation, MCP, subagents, or worktree action' },
+  'platforms --install-experience': { category: 'auto_safe', reason: 'Stage 137 install experience score reads local Stage 122 bootstrap matrix JSON and Stage 131 entry acceptance JSON to score natural entry, adapter consistency, manual steps remaining, and docs friction without installing adapters, executing hooks, writing state, git, platform APIs, model invocation, MCP, or subagents' },
+  'platforms --probe': { category: 'confirm_required', reason: 'platform probe can write a local capability sidecar only after explicit confirmation' },
+  'platforms --list': { category: 'auto_safe', reason: 'platform artifact list reads local capability artifacts without platform API calls' },
+  'platforms --show': { category: 'auto_safe', reason: 'platform artifact show reads one local capability artifact without platform API calls' },
+  'platforms --verify': { category: 'auto_safe', reason: 'platform artifact verify reads and validates one local capability artifact without platform API calls' },
+  'tokens --catalog': { category: 'auto_safe', reason: 'token catalog is deterministic and read-only' },
+  'tokens --compact-output': { category: 'auto_safe', reason: 'token compact output is deterministic local text transformation guidance' },
+  'tokens --profile': { category: 'auto_safe', reason: 'token profile reports deterministic local token economy metadata' },
+  'tokens --metrics': { category: 'auto_safe', reason: 'token metrics read local compaction evidence without executing models' },
+  'tokens --rewrite-preview': { category: 'auto_safe', reason: 'token rewrite preview is read-only and does not mutate source' },
+  'tokens --advice': { category: 'advice_only', reason: 'token advice recommends deterministic token-saving actions without performing them' },
+  'tokens --savior-budget': { category: 'auto_safe', reason: 'Stage 128 Token Savior entry budget reads an explicit prompt and optional local Stage 126 friction JSON to recommend deterministic context budgets, skill surfacing, deferrals, and preview-only commands without embeddings, model invocation, remote config, dynamic tool execution, command execution, state writes, git, platform APIs, or subagents' },
+  'tokens --entry-defaults': { category: 'auto_safe', reason: 'Stage 144 context budget entry defaults read local Stage 128 token budget JSON and local Stage 140 parity scorecard JSON to recommend lightweight entry context, deferrals, and token-saving boundaries without embeddings, model invocation, remote config, full skill injection, prompt/template/skill/hook mutation, command execution, state writes, git, platform APIs, MCP, or subagents' },
+  'learning --observe': { category: 'confirm_required', reason: 'learning observation can write local learning sidecar only after explicit confirmation' },
+  'learning --observe-from-run': { category: 'auto_safe', reason: 'learning run observation preview reads one local JSON input and proposes observation plus candidate instinct without writing state, formal skills, prompts, hooks, git, platform APIs, models, MCP, subagents, or business source' },
+  'learning --instincts': { category: 'auto_safe', reason: 'learning instincts lists local candidate evidence without mutating skills' },
+  'learning --promote': { category: 'confirm_required', reason: 'learning promotion can write a local promotion sidecar but must not mutate skills automatically' },
+  'learning --advice': { category: 'advice_only', reason: 'learning advice can explain promotion boundaries but does not mutate skills' },
+  'learning --experience-pattern': { category: 'auto_safe', reason: 'Stage 129 ECC learning experience pattern gate reads local Stage 126 friction and optional verified Stage 61 observations to propose candidate-only experience patterns without automatic promotion, skill mutation, prompt mutation, hook registration, command execution, agent-first delegation, git, platform APIs, model invocation, MCP, or subagents' },
+  'methodology --catalog': { category: 'auto_safe', reason: 'methodology catalog is deterministic and read-only' },
+  'methodology --route': { category: 'advice_only', reason: 'methodology route recommends workflow direction without executing it' },
+  'methodology --coverage-map': { category: 'auto_safe', reason: 'Stage 136 methodology coverage map reads local fork/superpowers and Vibecoding source files to report covered, partial, missing, and Vibecoding-specific methodology patterns without command execution, hook execution, adapter execution, workflow execution, skill execution, state writes, git, platform APIs, model invocation, MCP, or subagents' },
+  'planner --lint': { category: 'auto_safe', reason: 'planner lint is deterministic and read-only' },
+  'planner --action-manifest': { category: 'auto_safe', reason: 'plan-to-action manifest deterministically derives local expectations while keeping execution_authorized=false' },
+  'planner --executable-plan': { category: 'auto_safe', reason: 'executable plan quality contract scores local plan structure without executing checks, repairing plans, writing state, git, or dispatching subagents' },
+  'verification --self-test-profile': { category: 'auto_safe', reason: 'self-test gate profile deterministically classifies check expectations while keeping execution_authorized=false' },
+  'verification --evidence-intake': { category: 'auto_safe', reason: 'evidence intake validates local evidence structure, freshness, and gate coverage without executing checks' },
+  'verification --execution-evidence': { category: 'auto_safe', reason: 'execution evidence binding reads a local Stage 118 runbook and local evidence JSON without executing commands, writing evidence, mutating source, git, or dispatching subagents' },
+  'verification --tdd-trace': { category: 'auto_safe', reason: 'TDD trace contract reads local RED-GREEN-REFACTOR evidence without executing tests, checks, repair_execution, git, or writing artifacts' },
+};
+
+const forbiddenAutomationEntries = [
+  { capability: 'git write automation', command: 'git commit|push|merge|tag|reset|checkout', reason: 'git history and remote state require explicit user action outside Stage 103' },
+  { capability: 'platform automation', command: 'platform api|pull request|external review', reason: 'platform and PR side effects are outside the local deterministic readiness matrix' },
+  { capability: 'external network automation', command: 'network|remote service', reason: 'Stage 103 is local-only and does not call external systems' },
+  { capability: 'model invocation automation', command: 'model|llm|agent generation', reason: 'Stage 103 must not invoke models or depend on nondeterministic generation' },
+  { capability: 'subagent session automation', command: 'subagent|session create|agent dispatch', reason: 'subagent/session creation requires explicit user permission and later gates' },
+  { capability: 'business source mutation', command: 'write business source|auto-fix|auto-edit', reason: 'Stage 103 classifies runtime capabilities and never mutates business code' },
+  { capability: 'one-shot execution', command: 'automation --once|automation --run|execute action', reason: 'actual one-shot execution remains outside Stage 103 and Stage 108 read-only plan contracts' },
+];
+
+export function runtimeAutomationReadinessMatrix(registry, registryDigest = '') {
+  const matrixEntries = registry.capability_groups.flatMap((group) => group.commands.map((command) => {
+    const classification = commandClassifications[command];
+    return {
+      stage: group.stages.join(', '),
+      stages: group.stages,
+      capability: `${group.group} capability command`,
+      command,
+      group: group.group,
+      category: classification?.category || 'unclassified',
+      reason: classification?.reason || 'missing explicit automation readiness classification',
+    };
+  }));
+
+  const categorized = Object.fromEntries(readinessCategories.map((item) => [item.category, []]));
+  for (const entry of matrixEntries) {
+    if (categorized[entry.category]) categorized[entry.category].push(entry);
+  }
+  categorized.forbidden = forbiddenAutomationEntries.map((item) => ({
+    stage: automationReadinessStage,
+    stages: [automationReadinessStage],
+    group: 'automation-boundary',
+    category: 'forbidden',
+    ...item,
+  }));
+
+  const boundaryAssertions = runtimeAutomationReadinessBoundaryAssertions();
+  const autopilotLabProfile = buildAutopilotLabProfileContract();
+  const matrix = {
+    version: 1,
+    stage: automationReadinessStage,
+    readiness_kind: automationReadinessKind,
+    registry_stage: registry.registry_stage,
+    registry_kind: registry.registry_kind,
+    registry_version: registry.registry_version,
+    registry_digest: registryDigest,
+    categories: readinessCategories,
+    category_counts: Object.fromEntries(Object.entries(categorized).map(([key, value]) => [key, value.length])),
+    matrix_entries: matrixEntries,
+    categorized,
+    autopilot_lab_profile: autopilotLabProfile,
+    transition_contract: {
+      automation_readiness_only: true,
+      automation_plan_created: false,
+      one_shot_execution_created: false,
+      next_stage: 'Stage 104 workflow loop contract, Stage 105 plan-to-action manifest, Stage 106 self-test gate profile, Stage 107 commit readiness envelope, Stage 108 confirmed one-shot execution plan, Stage 109 close-loop dashboard, Stage 110 evidence intake, Stage 111 diff coverage, Stage 112 review intake/resolution, Stage 113 TDD trace contract, Stage 114 human-friendly runtime aliases, Stage 115 Superpowers gap matrix, Stage 116 progressive entry UX contract, Stage 117 executable plan quality contract, Stage 118 sequential stage runbook with Stage 9 runbook executor preview, Stage 119 execution evidence binding, Stage 120 staged commit readiness, Stage 121 behavioral evaluation contract, Stage 122 adapter bootstrap conformance matrix, Stage 123 skill-to-runtime traceability map, Stage 124 human completion evidence bundle, Stage 125 Superpowers regression guard, Stage 126 experience friction matrix, Stage 127 one-screen next action console, Stage 128 Token Savior entry budget, Stage 129 ECC learning experience pattern gate, Stage 130 copy-ready stage execution scriptlet, Stage 131 adapter entry acceptance contract, Stage 132 experience regression dashboard, Stage 133 Superpowers comparative evidence matrix, Stage 134 session-start shape acceptance, Stage 135 entry trigger discipline contract, Stage 136 methodology coverage map, Stage 137 install experience score, Stage 138 Superpowers-style behavioral eval scenario pack, Stage 139 experience upgrade prioritizer, Stage 140 Superpowers parity scorecard, Stage 141 entry trigger tightening, Stage 142 session-start example pack, and Stage 143 next-action evidence prompts may prepare or validate local evidence, context budget expectations, candidate learning patterns, manual script previews, installed-entry transcripts, UX scorecard baselines, Superpowers parity gap evidence, captured session-start output shape evidence, transcript trigger-discipline evidence, methodology coverage evidence, install experience scoring evidence, scenario contracts, upgrade ordering, parity closeout, copy-ready entry-opening guidance, copy-ready session-start adapter examples, and next-action evidence prompt cards before any separate manual execution decision; Stage 103 must not run checks or commit automatically.',
+      confirmed_execution_boundary: 'Confirmed one-shot execution planning may be represented by Stage 108, but actual execution remains outside Stage 103 and Stage 108.',
+    },
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+
+  const invariants = runtimeAutomationReadinessInvariants(matrix, registry);
+  return {
+    ...matrix,
+    readiness_invariants: invariants,
+    manual_action: invariants.pass
+      ? 'Automation readiness matrix is complete. Use it only as boundary input to future read-only contracts; do not execute classified commands from Stage 103.'
+      : 'Fix the listed automation readiness classification gaps before using this matrix for later automation boundary planning.',
+  };
+}
+
+export function runtimeAutomationReadinessInvariants(matrix, registry) {
+  const validCategories = new Set(readinessCategories.map((item) => item.category));
+  const entryKeys = matrix.matrix_entries.map((item) => `${item.group}:${item.command}`);
+  const duplicateEntries = entryKeys.filter((item, index, items) => items.indexOf(item) !== index);
+  const unclassified = matrix.matrix_entries
+    .filter((item) => !validCategories.has(item.category) || item.category === 'forbidden')
+    .map((item) => `${item.group}:${item.command}:${item.category}`);
+  const registryCommandKeys = registry.capability_groups.flatMap((group) => group.commands.map((command) => `${group.group}:${command}`));
+  const missingRegistryCommands = registryCommandKeys
+    .filter((item) => !entryKeys.includes(item));
+  const unsafeAutoSafe = matrix.matrix_entries
+    .filter((item) => item.category === 'auto_safe')
+    .filter((item) => item.command !== 'governance --subagent-permission')
+    .filter((item) => /--confirm|--run|--dispatch|--write|--once|--scan|subagent|push|merge|--pr-|\bpr\b/i.test(item.command))
+    .map((item) => `${item.group}:${item.command}`);
+  const writableCommandsOutsideConfirm = matrix.matrix_entries
+    .filter((item) => item.command !== 'learning --observe-from-run')
+    .filter((item) => /--gate|--notes|--observe|--promote|--pr-readiness|--pr-review-intake/i.test(item.command))
+    .filter((item) => item.category !== 'confirm_required')
+    .map((item) => `${item.group}:${item.command}:${item.category}`);
+  const writableBoundaries = Object.entries(matrix.boundary_assertions)
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const missingForbiddenBoundaries = ['git_write', 'push', 'pr', 'merge', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'business_source_write']
+    .filter((key) => matrix.boundary_assertions[key] !== false);
+  const missingCategories = readinessCategories
+    .map((item) => item.category)
+    .filter((category) => !Object.prototype.hasOwnProperty.call(matrix.categorized, category));
+
+  const findings = [
+    ...duplicateEntries.map((item) => `duplicate automation readiness entry: ${item}`),
+    ...unclassified.map((item) => `missing explicit automation readiness classification: ${item}`),
+    ...missingRegistryCommands.map((item) => `registry capability command missing from matrix: ${item}`),
+    ...unsafeAutoSafe.map((item) => `auto_safe entry must remain read-only and non-dispatching: ${item}`),
+    ...writableCommandsOutsideConfirm.map((item) => `write-capable command must be confirm_required: ${item}`),
+    ...writableBoundaries.map((item) => `boundary assertion must remain false: ${item}`),
+    ...missingForbiddenBoundaries.map((item) => `forbidden boundary missing or not false: ${item}`),
+    ...(matrix.autopilot_lab_profile?.autopilot_lab_gate_pass === true ? [] : ['autopilot-lab profile budget contract must pass']),
+    ...(matrix.autopilot_lab_profile?.ready_for_runtime_action === false ? [] : ['autopilot-lab readiness must not authorize runtime action']),
+    ...(matrix.autopilot_lab_profile?.boundary_assertions?.command_execution === false ? [] : ['autopilot-lab command execution boundary must remain false']),
+    ...missingCategories.map((item) => `missing automation readiness category: ${item}`),
+  ];
+
+  return {
+    pass: findings.length === 0,
+    checked: [
+      'registry_capability_command_coverage',
+      'explicit_command_classifications',
+      'category_partition',
+      'auto_safe_read_only_boundary',
+      'confirm_required_write_boundary',
+      'forbidden_boundary_assertions',
+      'transition_contract',
+      'autopilot_lab_profile_budget_contract',
+    ],
+    findings,
+  };
+}
+
+export function runtimeAutomationReadinessBoundaryAssertions() {
+  return {
+    automation_readiness_artifact: false,
+    automation_plan_artifact: false,
+    one_shot_execution_artifact: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    check_execution: false,
+    test_execution: false,
+    runtime_action: false,
+    workflow_execution: false,
+    verification_execution: false,
+    scheduler: false,
+    daemon: false,
+    retry: false,
+    git: false,
+    git_write: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+export function runtimeAutomationReadinessDigestPayload(matrix) {
+  return {
+    stage: matrix.stage,
+    readiness_kind: matrix.readiness_kind,
+    registry_stage: matrix.registry_stage,
+    registry_kind: matrix.registry_kind,
+    registry_version: matrix.registry_version,
+    registry_digest: matrix.registry_digest,
+    categories: matrix.categories,
+    category_counts: matrix.category_counts,
+    matrix_entries: matrix.matrix_entries,
+    categorized: matrix.categorized,
+    autopilot_lab_profile: matrix.autopilot_lab_profile,
+    transition_contract: matrix.transition_contract,
+    boundary_assertions: matrix.boundary_assertions,
+    readiness_invariants: matrix.readiness_invariants,
+  };
+}
+
+export function digestAutomationReadiness(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}