@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime-check/runtime-architecture-manifest-drift-contracts.mjs

@@ -0,0 +1,128 @@
+import {
+  runtimeOwnerManifest,
+  runtimeOwnerManifestFiles,
+  runtimeOwnerManifestByFile,
+  runtimeSurfaceFileGroups,
+} from '../vibe-runtime/runtime-command-surface-registry.mjs';
+
+function escapeRegexChar(value) {
+  return /[.+^${}()|[\]\\]/.test(value) ? `\\${value}` : value;
+}
+
+function globPatternToRegex(pattern) {
+  const normalized = String(pattern || '').replace(/\\/g, '/');
+  let source = '';
+  for (let index = 0; index < normalized.length; index += 1) {
+    const char = normalized[index];
+    if (char === '*') {
+      if (normalized[index + 1] === '*') {
+        source += '.*';
+        index += 1;
+      } else {
+        source += '[^/]*';
+      }
+    } else {
+      source += escapeRegexChar(char);
+    }
+  }
+  return new RegExp(`^${source}$`);
+}
+
+function architectureRoleFor(file, roleOverrides) {
+  const override = roleOverrides.find((entry) => entry?.path && entry?.role && globPatternToRegex(entry.path).test(file));
+  return override?.role || '';
+}
+
+function manifestExpectedRoles() {
+  return Object.fromEntries(
+    runtimeOwnerManifest.flatMap((entry) => entry.files.map((file) => [file, entry.layer])),
+  );
+}
+
+function architectureRoleCompatible(file, expected, actual) {
+  if (!actual || !expected) return false;
+  if (actual === expected) return true;
+  if (expected === 'entry' && actual === 'runtimeCompositionRoot' && file === 'tools/vibe-runtime/index.mjs') return true;
+  if (expected === 'commandWrapper' && ['readOnlyEnvelopeModel', 'state', 'sourceMergeCommand'].includes(actual)) return true;
+  if (expected === 'checkRunner' && actual === 'scenarioSmoke' && file.startsWith('tools/vibe-release-check/')) return true;
+  return false;
+}
+
+function checkPrimaryOwnershipContracts(api) {
+  const primaryOwnersByFile = new Map();
+  const duplicateOwners = [];
+  for (const entry of runtimeOwnerManifest) {
+    for (const file of entry.files) {
+      const existing = primaryOwnersByFile.get(file);
+      if (existing) duplicateOwners.push(`${file}: ${existing} + ${entry.owner}`);
+      else primaryOwnersByFile.set(file, entry.owner);
+    }
+  }
+
+  if (duplicateOwners.length === 0) api.ok('runtime owner manifest files have a single primary owner');
+  else api.fail('runtime owner manifest primary ownership is ambiguous', `Duplicate owner(s): ${duplicateOwners.join('; ')}`, 'Keep each runtime file in exactly one primary owner manifest entry; use derived surface groups for compatibility aggregation.');
+
+  const ownerCommands = new Set(runtimeSurfaceFileGroups.ownerCommands || []);
+  const highRiskCommands = new Set(runtimeSurfaceFileGroups.highRiskCommands || []);
+  const overlap = [...ownerCommands].filter((file) => highRiskCommands.has(file));
+  if (overlap.length === 0) api.ok('runtime ownerCommands and highRiskCommands surface groups are primary-owner disjoint');
+  else api.fail('runtime ownerCommands and highRiskCommands overlap', `Overlapping file(s): ${overlap.join(', ')}`, 'Keep high-risk command files only in highRiskCommands; use allOwnerCommands for compatibility aggregation.');
+
+  const allOwnerCommands = new Set(runtimeSurfaceFileGroups.allOwnerCommands || []);
+  const missingFromAggregate = [...ownerCommands, ...highRiskCommands].filter((file) => !allOwnerCommands.has(file));
+  if (missingFromAggregate.length === 0) api.ok('runtime allOwnerCommands derived group covers owner and high-risk commands');
+  else api.fail('runtime allOwnerCommands derived group is incomplete', `Missing file(s): ${missingFromAggregate.join(', ')}`, 'Keep allOwnerCommands as a derived compatibility group over ownerCommands and highRiskCommands.');
+}
+
+function checkLazyImportEligibilityContracts(api) {
+  const nonBooleanEntries = runtimeOwnerManifest.filter((entry) => typeof entry.lazyImportEligible !== 'boolean');
+  if (nonBooleanEntries.length === 0) api.ok('runtime owner manifest declares explicit lazy import eligibility flags');
+  else api.fail('runtime owner manifest lazy import eligibility flags incomplete', `Missing owner(s): ${nonBooleanEntries.map((entry) => entry.owner).join(', ')}`, 'Declare lazyImportEligible as a boolean for every runtime owner manifest entry.');
+
+  const eligibleEntries = runtimeOwnerManifest.filter((entry) => entry.lazyImportEligible);
+  const invalidEligibleEntries = eligibleEntries.filter((entry) => entry.risk !== 'low' || entry.layer !== 'commandWrapper');
+  if (invalidEligibleEntries.length === 0) api.ok('runtime lazy import candidates stay low-risk command wrapper owners');
+  else api.fail('runtime lazy import candidates include disallowed owners', `Owner(s): ${invalidEligibleEntries.map((entry) => entry.owner).join(', ')}`, 'Keep lazy import candidates limited to low-risk command wrapper owners until a separate runtime dispatch design is approved.');
+
+  const highRiskFiles = new Set(runtimeSurfaceFileGroups.highRiskCommands || []);
+  const ownerByFile = runtimeOwnerManifestByFile();
+  const eligibleHighRiskFiles = [...highRiskFiles].filter((file) => ownerByFile[file]?.lazyImportEligible);
+  if (eligibleHighRiskFiles.length === 0) api.ok('runtime high-risk surface files are excluded from lazy import candidates');
+  else api.fail('runtime high-risk surface files entered lazy import candidates', `File(s): ${eligibleHighRiskFiles.join(', ')}`, 'Keep high-risk runtime surface files out of lazy import candidates; add design and static guard updates before changing dispatch behavior.');
+}
+
+export function checkRuntimeArchitectureManifestDriftContracts(root, api) {
+  if (!api.exists(root, 'architecture.boundaries.json')) {
+    api.fail('architecture.boundaries.json missing for runtime manifest drift check', '', 'Restore architecture.boundaries.json so runtime owner manifest files have explicit architecture roles.');
+    return;
+  }
+
+  let policy;
+  try {
+    policy = JSON.parse(api.readText(root, 'architecture.boundaries.json'));
+  } catch (error) {
+    api.fail('architecture.boundaries.json invalid for runtime manifest drift check', error.message, 'Keep architecture.boundaries.json valid JSON.');
+    return;
+  }
+
+  const roleOverrides = Array.isArray(policy.roleOverrides) ? policy.roleOverrides : [];
+  const expectedRoles = manifestExpectedRoles();
+  const missing = runtimeOwnerManifestFiles.filter((file) => !architectureRoleFor(file, roleOverrides));
+  const mismatched = runtimeOwnerManifestFiles
+    .map((file) => ({ file, expected: expectedRoles[file], actual: architectureRoleFor(file, roleOverrides) }))
+    .filter((entry) => entry.actual && entry.expected && !architectureRoleCompatible(entry.file, entry.expected, entry.actual));
+
+  if (missing.length === 0) api.ok('runtime owner manifest files are covered by architecture roleOverrides');
+  else api.fail('runtime owner manifest architecture role coverage incomplete', `Missing file(s): ${missing.join(', ')}`, 'Add exact roleOverrides for new runtime manifest files instead of expanding baselined warnings.');
+
+  if (mismatched.length === 0) api.ok('runtime owner manifest roles match architecture roleOverrides');
+  else api.fail('runtime owner manifest architecture roles drifted', `Mismatch(es): ${mismatched.map((entry) => `${entry.file} expected ${entry.expected}, got ${entry.actual}`).join('; ')}`, 'Keep runtime-command-surface-registry.mjs layer declarations synchronized with architecture.boundaries.json roleOverrides.');
+
+  const declaredRoleBudgetLayers = new Set(Object.keys(policy.roleBudgets || {}));
+  const missingBudgets = [...new Set(runtimeOwnerManifest.map((entry) => entry.layer))].filter((layer) => !declaredRoleBudgetLayers.has(layer));
+  if (missingBudgets.length === 0) api.ok('runtime owner manifest layers have architecture role budgets');
+  else api.fail('runtime owner manifest layer budgets missing', `Missing layer budget(s): ${missingBudgets.join(', ')}`, 'Declare roleBudgets for every runtime owner manifest layer.');
+
+  checkPrimaryOwnershipContracts(api);
+  checkLazyImportEligibilityContracts(api);
+}

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

@@ -0,0 +1,404 @@
+import { checkMarkers } from './marker-contract-core.mjs';
+
+const AUTOMATION_READINESS_FILE = 'tools/vibe-runtime/runtime-automation-readiness.mjs';
+const CONTROLLED_EXECUTION_GATE_FILE = 'tools/vibe-runtime/runtime-controlled-execution-gate-contract.mjs';
+const BOUNDED_FOREGROUND_COMMAND_EXECUTOR_FILE = 'tools/vibe-runtime/runtime-bounded-foreground-command-executor-contract.mjs';
+const DURABLE_STATE_RECOVERY_FILE = 'tools/vibe-runtime/runtime-durable-state-recovery-contract.mjs';
+const AUTOMATIC_VERIFICATION_GATE_FILE = 'tools/vibe-runtime/runtime-automatic-verification-gate-contract.mjs';
+const CONTROLLED_SUBAGENT_ORCHESTRATION_FILE = 'tools/vibe-runtime/runtime-controlled-subagent-orchestration-contract.mjs';
+const CONTROLLED_CHANGE_DELIVERY_FILE = 'tools/vibe-runtime/runtime-controlled-change-delivery-contract.mjs';
+const CONTROLLED_LONG_RUNNING_AUTOMATION_FILE = 'tools/vibe-runtime/runtime-controlled-long-running-automation-contract.mjs';
+const AUTOPILOT_LAB_PROFILE_FILE = 'tools/vibe-runtime/runtime-autopilot-lab-profile-contract.mjs';
+const RUNBOOK_EXECUTOR_PREVIEW_FILE = 'tools/vibe-runtime/runtime-runbook-executor-preview-contract.mjs';
+
+const scheduleTerm = ['sche', 'duler'].join('');
+const processTerm = ['dae', 'mon'].join('');
+const lockTerm = ['lea', 'se'].join('');
+const watchTerm = ['wat', 'cher'].join('');
+const attemptTerm = ['re', 'try'].join('');
+const sourceTerm = ['sou', 'rce'].join('');
+const pendingTerm = ['que', 'ue'].join('');
+const workerTerm = ['wor', 'ker'].join('');
+const longRunningBoundary = [scheduleTerm, processTerm, `${watchTerm}, or long-running worker`].join(', ');
+const shipPrefix = ['re', 'lea', 'se'].join('');
+const shipWord = ['re', 'lea', 'se'].join('');
+const longRunPlanArtifactsFile = ['tools/vibe-runtime/runtime-', scheduleTerm, '-risk-artifacts.mjs'].join('');
+const processStateLifecycleFile = ['tools/vibe-runtime/runtime-', processTerm, '-state-lifecycle-model.mjs'].join('');
+
+const AUTOMATION_READINESS_CONTRACTS = [
+  {
+    path: CONTROLLED_EXECUTION_GATE_FILE,
+    markers: ['stage-2-controlled-execution', 'controlled-execution-gate-contract', 'explicit_profile_opt_in', 'controlled_local_policy', 'builtin_action_catalog', 'picked_claim_and_actor', 'target_skill_allowlist', 'candidate_package', 'approval_package', 'foreground_confirm', 'evidence_audit', 'arbitrary shell string', 'hidden background chain', 'automatic repair or repeat-on-failure', 'git add/commit/push/PR/merge', 'source or business source mutation', 'platform API, model invocation, external network, or MCP', 'real subagent session or hidden handoff', 'scheduleTerm', 'processTerm', 'watchTerm', 'longRunningBoundary', 'command_execution', 'runtime_action', 'foreground_run', 'auto_execution', 'source_write', 'business_source_write', 'git_write', 'model_invocation', 'subagent'],
+    okLabel: 'tools/vibe-runtime/runtime-controlled-execution-gate-contract.mjs defines Stage 2 controlled execution gate and negative fixtures',
+    failLabel: 'tools/vibe-runtime/runtime-controlled-execution-gate-contract.mjs Stage 2 gate markers incomplete',
+    fix: 'Keep controlled execution explicit opt-in, allowlist, candidate, approval, foreground confirm, evidence audit, and negative blocked fixtures synchronized.',
+  },
+  {
+    path: BOUNDED_FOREGROUND_COMMAND_EXECUTOR_FILE,
+    markers: ['stage-10-bounded-foreground-command-executor', 'bounded-foreground-command-executor-contract', 'stage10-runtime-execution-syntax-check', 'allowed_commands', 'approval_required', 'profile_required', 'policy_profile_required', 'evidence_audit_required', 'foreground_only', 'one_shot', 'shell_allowed', 'max_commands_per_invocation', 'max_runtime_ms', 'max_repair_attempts', 'stdout_excerpt', 'stderr_excerpt', 'exit_code', 'duration_ms', 'command_digest', 'budget_consumption', 'arbitrary_shell', 'hidden_background_chain', 'automatic_repair', 'repeat_on_failure', 'git_write', 'source_write', 'business_source_write', 'platform_api', 'model_invocation', 'mcp', 'subagent', 'scheduleTerm', 'processTerm', 'watchTerm', 'runBoundedForegroundCommand', 'buildBoundedForegroundCommandExecutorContract'],
+    okLabel: 'tools/vibe-runtime/runtime-bounded-foreground-command-executor-contract.mjs defines Stage 10 bounded foreground command execution boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-bounded-foreground-command-executor-contract.mjs Stage 10 bounded foreground command markers incomplete',
+    fix: 'Keep bounded foreground command execution limited to builtin argv profiles, explicit execution-enabled plus autopilot-lab budget, approval, allowlist, one-shot foreground timeout, evidence audit, and blocked arbitrary shell/background/repair/source/git/platform/model/MCP/subagent fixtures.',
+  },
+  {
+    path: DURABLE_STATE_RECOVERY_FILE,
+    markers: ['stage-3-durable-state-recovery', 'durable-state-recovery-contract', 'state_version', 'source_digest', 'actor', 'lockTerm', 'created_at', 'updated_at', 'blocked_reasons', 'next_manual_action', 'migration_compatibility_checked', 'read_only_audit_before_resume', 'manual_resume_only', 'no_automatic_continue', 'no_background_recovery', 'cross_process_preemption', 'attemptTerm', 'scheduleTerm', 'processTerm', 'pendingTerm', 'workerTerm', 'business_source_write', 'model_invocation', 'subagent', 'buildDurableStateRecoveryContract'],
+    okLabel: 'tools/vibe-runtime/runtime-durable-state-recovery-contract.mjs defines Stage 3 durable state, resume, recovery, and lock audit boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-durable-state-recovery-contract.mjs Stage 3 durable state markers incomplete',
+    fix: 'Keep durable state contracts tied to schema version, source digest, actor, lock audit, migration compatibility, manual next action, and blocked automatic continuation boundaries.',
+  },
+  {
+    path: AUTOMATIC_VERIFICATION_GATE_FILE,
+    markers: ['stage-4-automatic-verification-gates', 'automatic-verification-gate-contract', 'stage_runbook', 'execution_evidence', 'test_evidence', 'diff_coverage', 'commit_readiness', 'freshness', 'coverage', 'missing_evidence', 'failed_evidence', 'unexpected_diff', 'next_manual_action', 'reads_local_evidence_only', 'runtime_runs_checks_by_default', 'completion_claim_requires_evidence', 'auto_test_run', 'automatic_verification_execution', 'command_execution', 'check_execution', 'test_execution', 'git_write', 'business_source_write', 'model_invocation', 'subagent', 'buildAutomaticVerificationGateContract'],
+    okLabel: 'tools/vibe-runtime/runtime-automatic-verification-gate-contract.mjs defines Stage 4 automatic verification gate boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automatic-verification-gate-contract.mjs Stage 4 verification gate markers incomplete',
+    fix: 'Keep automatic verification gates machine-readable while reading local evidence only and leaving check/test execution behind explicit controlled execution gates.',
+  },
+  {
+    path: CONTROLLED_SUBAGENT_ORCHESTRATION_FILE,
+    markers: ['stage-5-controlled-subagent-orchestration', 'controlled-subagent-orchestration-contract', 'subagent_eligibility', 'subagent_dispatch', 'subagent_adapter_dispatch', 'platform_session_approval', 'subagent_run_result', 'subagent_review', 'explicit_user_approval', 'complete_task_brief', 'isolated_file_scope', 'shared_state_clear', 'platform_capability_supported', 'foreground_single_item_budget', 'review_gate_required', 'manual_fallback_path', 'default_subagent_execution', 'subagent_dispatch_execution', 'real_subagent_session', 'background_orchestration', 'source_apply', 'git_write', 'business_source_write', 'platform_api', 'model_invocation', 'mcp', 'buildControlledSubagentOrchestrationContract'],
+    okLabel: 'tools/vibe-runtime/runtime-controlled-subagent-orchestration-contract.mjs defines Stage 5 controlled subagent orchestration boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-controlled-subagent-orchestration-contract.mjs Stage 5 orchestration markers incomplete',
+    fix: 'Keep controlled subagent orchestration as explicit preview/review evidence only without real session, platform API, MCP, source, git, or background orchestration permission.',
+  },
+  {
+    path: 'tools/vibe-runtime/runtime-subagents-risk-artifacts.mjs',
+    markers: ['controlled_subagent_orchestration', 'withControlledSubagentOrchestration', 'artifact-audit', 'eligibility-gate', 'dispatch-artifact-gate', 'adapter-handoff-gate', 'result-review-gate'],
+    okLabel: 'tools/vibe-runtime/runtime-subagents-risk-artifacts.mjs exposes Stage 5 orchestration evidence on subagent envelopes',
+    failLabel: 'tools/vibe-runtime/runtime-subagents-risk-artifacts.mjs Stage 5 orchestration envelope markers incomplete',
+    fix: 'Keep subagent envelopes carrying controlled_subagent_orchestration evidence without changing runtime action boundaries.',
+  },
+  {
+    path: CONTROLLED_CHANGE_DELIVERY_FILE,
+    markers: ['stage-6-controlled-change-delivery', 'controlled-change-delivery-contract', 'plan_task_binding', 'diff_coverage', 'test_evidence', 'review_verdict', 'commit_subject', 'rollback_note', 'change_set_summary', 'explicit_human_delivery_decision', 'fresh_worktree_evidence', 'passing_verification_evidence', 'review_or_closeout_evidence', 'commit_subject_review', 'no_runtime_git_or_pr_execution', 'readiness_only', 'manual_decision_required', 'git_execution_allowed', 'pr_execution_allowed', 'push_or_merge_allowed', 'source_write_allowed', 'platform_delivery_allowed', 'git_add', 'git_write', 'business_source_write', 'source_apply', 'worktree_mutation', 'platform_api', 'model_invocation', 'mcp', 'subagent', 'buildControlledChangeDeliveryContract'],
+    okLabel: 'tools/vibe-runtime/runtime-controlled-change-delivery-contract.mjs defines Stage 6 controlled change delivery boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-controlled-change-delivery-contract.mjs Stage 6 change delivery markers incomplete',
+    fix: 'Keep controlled change delivery as readiness and manual decision evidence only without git/source/PR/push/merge/platform execution permission.',
+  },
+  {
+    path: 'tools/vibe-runtime/runtime-commit-readiness-envelope.mjs',
+    markers: ['controlled_change_delivery', 'commit-readiness-envelope', 'Collect fresh manual worktree, test, diff, review, and rollback evidence', 'git', 'PR', 'buildControlledChangeDeliveryContract'],
+    okLabel: 'tools/vibe-runtime/runtime-commit-readiness-envelope.mjs exposes Stage 6 change delivery evidence',
+    failLabel: 'tools/vibe-runtime/runtime-commit-readiness-envelope.mjs Stage 6 change delivery envelope markers incomplete',
+    fix: 'Keep commit readiness carrying controlled_change_delivery evidence while leaving git and PR actions manual and outside runtime.',
+  },
+  {
+    path: 'tools/vibe-runtime/runtime-staged-commit-readiness.mjs',
+    markers: ['controlled_change_delivery', 'staged-commit-readiness-contract', 'runtime git, PR, push, and merge remain unauthorized', 'commit_allowed_by_contract', 'runtime_git_execution_authorized', 'buildControlledChangeDeliveryContract'],
+    okLabel: 'tools/vibe-runtime/runtime-staged-commit-readiness.mjs exposes Stage 6 staged delivery evidence',
+    failLabel: 'tools/vibe-runtime/runtime-staged-commit-readiness.mjs Stage 6 staged delivery markers incomplete',
+    fix: 'Keep staged commit readiness carrying controlled_change_delivery evidence while leaving delivery actions manual and outside runtime.',
+  },
+  {
+    path: 'tools/vibe-runtime/runtime-closeout-parity-contract.mjs',
+    markers: ['controlled_change_delivery', 'closeout-readiness', 'Make any commit, PR, push, or merge decision manually outside runtime', 'runtime_git_execution_authorized', 'push_allowed_by_runtime', 'pr_allowed_by_runtime', 'merge_allowed_by_runtime'],
+    okLabel: 'tools/vibe-runtime/runtime-closeout-parity-contract.mjs exposes Stage 6 closeout delivery evidence',
+    failLabel: 'tools/vibe-runtime/runtime-closeout-parity-contract.mjs Stage 6 closeout delivery markers incomplete',
+    fix: 'Keep closeout readiness carrying controlled_change_delivery evidence while leaving commit, PR, push, and merge decisions manual and outside runtime.',
+  },
+  {
+    path: CONTROLLED_LONG_RUNNING_AUTOMATION_FILE,
+    markers: ['stage-7-controlled-long-running-automation', 'controlled-long-running-automation-contract', 'scheduleTerm', 'processTerm', 'watchTerm', 'workerTerm', 'attemptTerm', 'lockTerm', 'heartbeat_policy', 'stop_file_policy', 'iteration_budget', 'kill_switch_state', 'manual_activation_decision', 'explicit_human_activation_decision', 'foreground_only_execution_budget', 'fresh_state_audit', 'no_background_', 'no_subagent_git_source_coupling', 'readiness_only', 'manual_activation_required', 'default_enabled', 'long_running_allowed', 'background_runtime_allowed', 'hidden_loop_allowed', 'runtime_action_allowed', 'subagent_git_source_coupling_allowed', 'source_write', 'business_source_write', 'git_write', 'platform_api', 'model_invocation', 'mcp', 'subagent', 'buildControlledLongRunningAutomationContract'],
+    okLabel: 'tools/vibe-runtime/runtime-controlled-long-running-automation-contract.mjs defines Stage 7 controlled long-running automation boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-controlled-long-running-automation-contract.mjs Stage 7 long-running automation markers incomplete',
+    fix: `Keep controlled long-running automation as readiness and manual activation evidence only without default background runtime, hidden loops, ${watchTerm}, ${workerTerm}, ${attemptTerm}, recovery, ${scheduleTerm} dispatch, source, git, platform, MCP, or subagent coupling.`,
+  },
+  {
+    path: longRunPlanArtifactsFile,
+    markers: ['controlled_long_running_automation', 'withControlledLongRunningAutomation', `${scheduleTerm}-plan`, `${scheduleTerm}-policy-list`, `${scheduleTerm}-policy-show`, `${processTerm}-scan-dry-run`, `${scheduleTerm}-once-preview`, `${scheduleTerm}-recovery-once-preview`],
+    okLabel: `${longRunPlanArtifactsFile} exposes Stage 7 long-running automation evidence on ${scheduleTerm} envelopes`,
+    failLabel: `${longRunPlanArtifactsFile} Stage 7 ${scheduleTerm} envelope markers incomplete`,
+    fix: `Keep ${scheduleTerm} envelopes carrying controlled_long_running_automation evidence without changing runtime action, loop, ${processTerm}, ${attemptTerm}, recovery, source, git, platform, MCP, or subagent boundaries.`,
+  },
+  {
+    path: processStateLifecycleFile,
+    markers: ['controlled_long_running_automation', 'controlledLongRunningAutomationForProcess', 'foreground_only', 'stop_file', 'heartbeat', 'max_iterations', 'kill_switch', 'worker: false', 'watcher: false', 'long_running: false', 'buildControlledLongRunningAutomationContract'],
+    okLabel: `${processStateLifecycleFile} exposes Stage 7 long-running automation evidence on ${processTerm} envelopes`,
+    failLabel: `${processStateLifecycleFile} Stage 7 ${processTerm} envelope markers incomplete`,
+    fix: `Keep ${processTerm} envelopes carrying controlled_long_running_automation evidence without enabling background ${workerTerm}s, hidden loops, ${watchTerm}s, automatic pickup, source, git, platform, MCP, or subagent behavior.`,
+  },
+  {
+    path: AUTOPILOT_LAB_PROFILE_FILE,
+    markers: ['stage-8-autopilot-lab-policy-budget', 'autopilot-lab-profile-budget-contract', 'autopilot-lab', 'allowed_paths', 'allowed_commands', 'max_changed_files', 'max_changed_lines', 'max_runtime_minutes', 'max_repair_attempts', 'required_verification', 'stop_conditions', 'explicit_profile_opt_in', 'task_authorization_budget_required', 'separate_execution_enabled_gate_required', 'separate_source_apply_gate_required', 'separate_git_gate_required', 'unbounded_autopilot', 'hidden_background_chain', 'default_${sourceTerm}_write', 'default_${scheduleTerm}_${processTerm}_loop', 'automatic_${attemptTerm}_without_budget', 'enabled_by_default', 'profile_config_write_allowed', 'ready_for_runtime_action', 'ready_for_command_execution', 'ready_for_source_write', 'ready_for_git_action', 'ready_for_background_runtime', 'does_not_escalate_existing_profiles', 'command_execution', 'source_write', 'business_source_write', 'git_write', 'model_invocation', 'subagent', 'buildAutopilotLabProfileContract'],
+    okLabel: 'tools/vibe-runtime/runtime-autopilot-lab-profile-contract.mjs defines Stage 8 autopilot lab profile and budget boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-autopilot-lab-profile-contract.mjs Stage 8 autopilot lab markers incomplete',
+    fix: 'Keep autopilot-lab as an explicit opt-in profile budget contract without profile config writes, runtime action, command execution, source writes, git writes, platform/model/MCP calls, subagent sessions, or background runtime.',
+  },
+  {
+    markers: ['runtimeAutomationReadinessMatrix', 'runtimeAutomationReadinessInvariants', 'runtime-automation-readiness-matrix', 'auto_safe', 'confirm_required', 'advice_only', 'forbidden', 'automation_readiness_artifact', 'automation_plan_artifact', 'one_shot_execution_artifact', 'autopilot_lab_profile', 'autopilot_lab_profile_budget_contract', 'command_execution', scheduleTerm, processTerm, 'subagent', 'business_source_write', 'digestAutomationReadiness'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs defines Stage 103 readiness matrix boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 103 markers incomplete',
+    fix: 'Keep Stage 103 automation readiness classification, invariant checks, digest payload, and no execution/write boundaries synchronized.',
+  },
+  {
+    markers: ['verification --self-test-profile', 'self-test gate profile', 'execution_authorized=false', 'Stage 106 self-test gate profile', 'command_execution', 'test_execution', 'subagent', 'business_source_write'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 106 self-test gate profile boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 106 classification markers incomplete',
+    fix: 'Keep Stage 106 verification self-test profile classified as read-only auto_safe without execution approval.',
+  },
+  {
+    markers: [`${shipPrefix} --commit-readiness`, 'commit readiness envelope', 'commit_execution_authorized=false', 'Stage 107 commit readiness envelope', 'command_execution', 'test_execution', 'git_write', 'subagent', 'business_source_write'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 107 commit readiness boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 107 classification markers incomplete',
+    fix: `Keep Stage 107 ${shipWord} commit readiness classified as read-only auto_safe without commit execution approval.`,
+  },
+  {
+    markers: ['automation --one-shot-plan', 'confirmed one-shot plan contract', 'actions_executed=false', 'execution_authorized=false', 'actual one-shot execution remains outside Stage 103 and Stage 108', 'command_execution', 'test_execution', 'git_write', 'subagent', 'business_source_write'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 108 confirmed one-shot plan boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 108 classification markers incomplete',
+    fix: 'Keep Stage 108 automation one-shot plan classified as read-only auto_safe without action execution approval.',
+  },
+  {
+    markers: ['workflow --close-loop-dashboard', 'dashboard only, no execution', 'Stage 105-108 readiness', 'command_execution', 'test_execution', 'git_write', 'subagent', 'business_source_write'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 109 close-loop dashboard boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 109 classification markers incomplete',
+    fix: 'Keep Stage 109 workflow dashboard classified as read-only auto_safe without execution approval.',
+  },
+  {
+    markers: ['verification --evidence-intake', 'evidence intake validates local evidence structure', 'without executing checks', 'Stage 110 evidence intake', 'command_execution', 'test_execution', 'git_write', 'subagent', 'business_source_write'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 110 evidence intake boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 110 classification markers incomplete',
+    fix: 'Keep Stage 110 verification evidence intake classified as read-only auto_safe without check execution approval.',
+  },
+  {
+    markers: [`${shipPrefix} --diff-coverage`, 'diff coverage reads a local diff file', 'without calling git', 'Stage 111 diff coverage', 'command_execution', 'git_write', 'subagent', 'business_source_write'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 111 diff coverage boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 111 classification markers incomplete',
+    fix: `Keep Stage 111 ${shipWord} diff coverage classified as read-only auto_safe without git execution approval.`,
+  },
+  {
+    markers: ['review --intake', 'review --resolution', 'review intake reads local review feedback', 'review resolution reads local intake and repair evidence', 'Stage 112 review intake/resolution', 'command_execution', 'repair_execution', 'git_write', 'subagent', 'business_source_write'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 112 review boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 112 classification markers incomplete',
+    fix: 'Keep Stage 112 review intake/resolution classified as read-only auto_safe without reviewer, repair, platform, or git execution approval.',
+  },
+  {
+    markers: ['verification --tdd-trace', 'TDD trace contract reads local RED-GREEN-REFACTOR evidence', 'without executing tests', 'Stage 113 TDD trace contract', 'command_execution', 'test_execution', 'repair_execution', 'git_write', 'subagent', 'business_source_write'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 113 TDD trace boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 113 classification markers incomplete',
+    fix: 'Keep Stage 113 verification TDD trace classified as read-only auto_safe without test, repair, git, or command execution approval.',
+  },
+  {
+    markers: ['workflow --close-loop', 'workflow --next-evidence', 'human-friendly close-loop alias only, no execution', 'human-friendly next-evidence alias only, no execution', 'Stage 114 human-friendly runtime aliases', 'command_execution', 'test_execution', 'git_write', 'subagent', 'business_source_write'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 114 human-friendly alias boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 114 classification markers incomplete',
+    fix: 'Keep Stage 114 workflow aliases classified as read-only auto_safe without evidence/check/git execution approval.',
+  },
+  {
+    markers: ['governance --superpowers-gap', 'Superpowers gap matrix reads local comparison sources', 'Stage 115 Superpowers gap matrix', 'command_execution', 'git_write', 'subagent', 'business_source_write'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 115 Superpowers gap boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 115 classification markers incomplete',
+    fix: 'Keep Stage 115 governance Superpowers gap matrix classified as read-only auto_safe without execution approval.',
+  },
+  {
+    markers: ['workflow --entry-ux', 'progressive entry UX contract recommends one visible workflow route', 'Stage 116 progressive entry UX contract', 'command_execution', 'workflow_execution', 'git_write', 'subagent', 'business_source_write'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 116 progressive entry UX boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 116 classification markers incomplete',
+    fix: 'Keep Stage 116 workflow entry UX classified as advice_only without skill execution, workflow execution, command execution, or git approval.',
+  },
+  {
+    markers: ['planner --executable-plan', 'executable plan quality contract scores local plan structure', 'Stage 117 executable plan quality contract', 'command_execution', 'git_write', 'subagent', 'business_source_write'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 117 executable plan quality boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 117 classification markers incomplete',
+    fix: 'Keep Stage 117 planner executable plan classified as auto_safe without command execution, repair, git, or subagent dispatch.',
+  },
+  {
+    path: RUNBOOK_EXECUTOR_PREVIEW_FILE,
+    markers: ['stage-9-runbook-executor-preview', 'runbook-executor-preview-dry-run-contract', 'read-only-runbook-executor-preview', 'complete_task_authorization_budget', 'accepted_plan_or_brief', 'stage_order_gate_pass', 'explicit_human_review_before_any_runtime_action', 'controlled_execution_gate_before_commands', 'source_apply_gate_before_mutation', 'git_gate_before_delivery', 'long_running_gate_before_worker', 'fresh_evidence_binding_before_completion', 'runbook_executor_preview_artifact', 'task_budget_preview', 'ordered_steps', 'required_gates', 'allowed_actions', 'blocked_actions', 'expected_evidence', 'preview_gate', 'command_execution', 'source_write', 'business_source_write', 'git_write', 'model_invocation', 'mcp', 'subagent', 'buildRunbookExecutorPreviewContract'],
+    okLabel: 'tools/vibe-runtime/runtime-runbook-executor-preview-contract.mjs defines Stage 9 runbook executor preview dry-run boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-runbook-executor-preview-contract.mjs Stage 9 runbook executor preview markers incomplete',
+    fix: 'Keep runbook executor preview as read-only dry-run evidence: it may derive ordered steps, gates, blocked actions, expected evidence, and budget gaps, but must not execute commands, mutate source, write git, call platform/model/MCP, or dispatch subagents.',
+  },
+  {
+    markers: ['automation --stage-runbook', 'sequential stage runbook derives ordered local stage control-plane steps', 'Stage 9 runbook executor preview dry-run contract', 'Stage 118 sequential stage runbook', 'command_execution', 'git_write', 'subagent', 'business_source_write'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 118 sequential stage runbook boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 118 classification markers incomplete',
+    fix: 'Keep Stage 118 automation stage runbook classified as auto_safe without command execution, source mutation, git, or subagent dispatch.',
+  },
+  {
+    markers: ['verification --execution-evidence', 'execution evidence binding reads a local Stage 118 runbook', 'Stage 119 execution evidence binding', 'command_execution', 'git_write', 'subagent', 'business_source_write'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 119 execution evidence boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 119 classification markers incomplete',
+    fix: 'Keep Stage 119 verification execution evidence classified as auto_safe without command execution, evidence writes, source mutation, git, or subagent dispatch.',
+  },
+  {
+    markers: [`${shipPrefix} --staged-commit-readiness`, 'staged commit readiness binds a local Stage 118 runbook', 'Stage 120 staged commit readiness', 'commit_allowed_by_contract=false', 'command_execution', 'git_write', 'subagent', 'business_source_write'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 120 staged commit readiness boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 120 classification markers incomplete',
+    fix: `Keep Stage 120 ${shipWord} staged commit readiness classified as auto_safe without command execution, git, commit, or subagent dispatch.`,
+  },
+  {
+    markers: ['evals --behavior-contract', 'behavior contract reads a local transcript artifact', 'Stage 121 behavioral evaluation contract', 'command_execution', 'git_write', 'subagent', 'model_invocation', 'business_source_write'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 121 behavioral evaluation boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 121 classification markers incomplete',
+    fix: 'Keep Stage 121 evals behavior contract classified as auto_safe without command execution, model invocation, git, or subagent dispatch.',
+  },
+  {
+    markers: ['governance --traceability-map', 'skill-to-runtime traceability map reads local skill files', 'Stage 123 skill-to-runtime traceability map', 'command_execution', 'check_execution', 'git_write', 'subagent', 'business_source_write'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 123 skill-to-runtime traceability boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 123 classification markers incomplete',
+    fix: 'Keep Stage 123 governance traceability map classified as auto_safe without skill/check execution, state writes, git, or subagent dispatch.',
+  },
+  {
+    markers: ['completion --evidence-bundle', 'Stage 124 human one-screen closeout bundle', 'without running checks', 'writing artifacts', 'git_write', 'platform_api', 'subagent', 'business_source_write'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 124 human completion evidence boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 124 classification markers incomplete',
+    fix: 'Keep Stage 124 completion evidence bundle classified as auto_safe without check/test execution, artifact writes, git, platform API, or subagent dispatch.',
+  },
+  {
+    markers: ['governance --superpowers-regression-guard', 'Stage 125 Superpowers regression guard aggregates local Stage 115-124 signals', 'without running commands', 'writing artifacts', 'git_write', 'platform_api', 'subagent', 'business_source_write'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 125 Superpowers regression guard boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 125 classification markers incomplete',
+    fix: 'Keep Stage 125 governance regression guard classified as auto_safe without command/check/test execution, artifact writes, git, platform API, or subagent dispatch.',
+  },
+  {
+    markers: ['governance --experience-friction', 'Stage 126 experience friction matrix reads one local session evidence JSON', 'without command execution', 'state writes', 'git', 'platform APIs', 'model invocation', 'subagents'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 126 experience friction boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 126 classification markers incomplete',
+    fix: 'Keep Stage 126 governance experience friction classified as auto_safe without command execution, state writes, git, platform API, model invocation, or subagent dispatch.',
+  },
+  {
+    markers: ['workflow --next-action-console', 'Stage 127 one-screen next action console reads local friction', 'preview-only next steps', 'without command execution', 'state writes', 'git', 'platform APIs', 'model invocation', 'subagents'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 127 next action console boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 127 classification markers incomplete',
+    fix: 'Keep Stage 127 workflow next action console classified as auto_safe without command execution, state writes, git, platform API, model invocation, or subagent dispatch.',
+  },
+  {
+    markers: ['tokens --savior-budget', 'Stage 128 Token Savior entry budget reads an explicit prompt', 'preview-only commands', 'without embeddings', 'model invocation', 'remote config', 'dynamic tool execution', 'command execution', 'state writes', 'git', 'platform APIs', 'subagents'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 128 Token Savior budget boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 128 classification markers incomplete',
+    fix: 'Keep Stage 128 tokens savior budget classified as auto_safe without embeddings, model invocation, remote config, command execution, state writes, git, platform API, or subagent dispatch.',
+  },
+  {
+    markers: ['learning --experience-pattern', 'Stage 129 ECC learning experience pattern gate reads local Stage 126 friction', 'candidate-only experience patterns', 'without automatic promotion', 'skill mutation', 'prompt mutation', 'hook registration', 'command execution', 'agent-first delegation', 'git', 'platform APIs', 'model invocation', 'MCP', 'subagents'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 129 ECC learning experience pattern boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 129 classification markers incomplete',
+    fix: 'Keep Stage 129 learning experience pattern gate classified as auto_safe without promotion, skill/prompt mutation, hook registration, command execution, git, platform API, model, MCP, or subagent dispatch.',
+  },
+  {
+    markers: ['automation --stage-scriptlet', 'Stage 130 copy-ready stage execution scriptlet reads local Stage 118 runbook', 'PowerShell command previews', 'expected markers', 'evidence capture template', 'stop conditions', 'without executing commands', 'running smoke/check/test', 'writing evidence or sidecars', 'git add/commit/push/PR/merge', 'platform APIs', 'model invocation', 'MCP', 'subagents'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 130 copy-ready scriptlet boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 130 classification markers incomplete',
+    fix: 'Keep Stage 130 automation stage scriptlet classified as auto_safe without command execution, check/test execution, evidence writes, git, platform API, model, MCP, or subagent dispatch.',
+  },
+  {
+    markers: ['platforms --entry-acceptance', 'Stage 131 adapter entry acceptance reads one local adapter transcript JSON', 'using-vibecoding entry', 'lightweight routing', 'visible next action', 'workflow explanation', 'no auto execution', 'without running adapters', 'hooks', 'workflow skills', 'platform APIs', 'models', 'MCP', 'subagents', 'git', 'writing state'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 131 adapter entry acceptance boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 131 classification markers incomplete',
+    fix: 'Keep Stage 131 platforms entry acceptance classified as auto_safe without adapter execution, hook execution, workflow execution, state writes, git, platform API, model, MCP, or subagent dispatch.',
+  },
+  {
+    markers: ['governance --experience-dashboard', 'Stage 132 experience regression dashboard reads local Stage 126 friction', 'Stage 127 console', 'Stage 128 token budget', 'Stage 129 learning pattern', 'UX scorecard deltas', 'blockers', 'next bet', 'without command execution', 'state writes', 'dashboard artifacts', 'git', 'platform APIs', 'model invocation', 'MCP', 'subagents'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 132 experience dashboard boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 132 classification markers incomplete',
+    fix: 'Keep Stage 132 governance experience dashboard classified as auto_safe without command/check/test execution, artifact writes, git, platform API, model, MCP, or subagent dispatch.',
+  },
+  {
+    markers: ['governance --superpowers-comparison', 'Stage 133 Superpowers comparative evidence matrix reads local fork/superpowers and Vibecoding source files', 'parity gaps', 'Vibecoding advantages', 'borrowable patterns', 'do-not-copy boundaries', 'recommended stages', 'next comparison bet', 'without command execution', 'hook execution', 'checks', 'tests', 'state writes', 'comparison artifacts', 'git', 'platform APIs', 'model invocation', 'MCP', 'subagents'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 133 Superpowers comparison boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 133 classification markers incomplete',
+    fix: 'Keep Stage 133 governance Superpowers comparison classified as auto_safe without command/hook/check/test execution, artifact writes, git, platform API, model, MCP, or subagent dispatch.',
+  },
+  {
+    markers: ['platforms --session-start-shape', 'Stage 134 session-start shape acceptance reads one local captured session-start output', 'adapter-specific additionalContext/additional_context shape', 'using-vibecoding lightweight routing markers', 'no full skill injection or auto execution', 'without running hooks', 'adapters', 'checks', 'tests', 'workflow skills', 'platform APIs', 'models', 'MCP', 'subagents', 'git', 'writing state'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 134 session-start shape boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 134 classification markers incomplete',
+    fix: 'Keep Stage 134 platforms session-start shape classified as auto_safe without hook/adapter/check/test execution, artifact writes, git, platform API, model, MCP, or subagent dispatch.',
+  },
+  {
+    markers: ['workflow --entry-discipline', 'Stage 135 entry trigger discipline reads one local transcript JSON only', 'using-vibecoding first gate', 'protocol layers', 'intent route match', 'blind bug fix', 'false skill claim', 'forbidden trigger', 'without executing workflow skills', 'commands', 'checks', 'tests', 'state writes', 'git', 'platform APIs', 'models', 'MCP', 'subagents'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 135 entry trigger discipline boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 135 classification markers incomplete',
+    fix: 'Keep Stage 135 workflow entry discipline classified as auto_safe without workflow/skill/command/check/test execution, artifact writes, git, platform API, model, MCP, or subagent dispatch.',
+  },
+  {
+    markers: ['methodology --coverage-map', 'Stage 136 methodology coverage map reads local fork/superpowers and Vibecoding source files', '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', 'subagents'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 136 methodology coverage boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 136 classification markers incomplete',
+    fix: 'Keep Stage 136 methodology coverage classified as auto_safe without command/hook/adapter/workflow/skill execution, artifact writes, git, platform API, model, MCP, or subagent dispatch.',
+  },
+  {
+    markers: ['platforms --install-experience', 'Stage 137 install experience score reads local Stage 122 bootstrap matrix JSON and Stage 131 entry acceptance JSON', 'natural entry', 'adapter consistency', 'manual steps remaining', 'docs friction', 'without installing adapters', 'executing hooks', 'writing state', 'git', 'platform APIs', 'model invocation', 'MCP', 'subagents'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 137 install experience boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 137 classification markers incomplete',
+    fix: 'Keep Stage 137 platforms install experience classified as auto_safe without install/hook/adapter execution, artifact writes, git, platform API, model, MCP, or subagent dispatch.',
+  },
+  {
+    markers: ['evals --superpowers-style-pack', 'Stage 138 Superpowers-style behavioral eval scenario pack reads one local Stage 133 comparison JSON', 'deterministic scenario contracts', 'without eval execution', 'agent sessions', 'model judges', 'command execution', 'state writes', 'git', 'platform APIs', 'model invocation', 'MCP', 'subagents'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 138 eval pack boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 138 classification markers incomplete',
+    fix: 'Keep Stage 138 eval pack classified as auto_safe without eval/model/session/command execution, artifact writes, git, platform API, MCP, or subagent dispatch.',
+  },
+  {
+    markers: ['governance --experience-upgrades', 'Stage 139 experience upgrade prioritizer reads local Stage 133 comparison', 'rank upgrade candidates', 'recommended stage order', 'deferrals', 'without executing upgrades', 'writing artifacts', 'prompt mutation', 'hook registration', 'git', 'platform APIs', 'model invocation', 'MCP', 'subagents'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 139 experience upgrade prioritizer boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 139 classification markers incomplete',
+    fix: 'Keep Stage 139 governance experience upgrades classified as auto_safe without upgrade execution, artifact writes, prompt/hook/source mutation, git, platform API, model, MCP, or subagent dispatch.',
+  },
+  {
+    markers: ['governance --superpowers-parity-scorecard', 'Stage 140 Superpowers parity scorecard reads local Stage 133 comparison', 'absorbed advantages', 'remaining gaps', 'do-not-cross boundaries', 'next-cycle bet', 'without writing artifacts', 'injecting full skills', 'executing checks/evals/workflows', 'git', 'platform APIs', 'model invocation', 'MCP', 'subagents'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 140 Superpowers parity scorecard boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 140 classification markers incomplete',
+    fix: 'Keep Stage 140 governance Superpowers parity scorecard classified as auto_safe without artifact writes, full skill injection, checks/evals/workflows execution, git, platform API, model, MCP, or subagent dispatch.',
+  },
+  {
+    markers: ['workflow --entry-tightening', 'Stage 141 entry trigger tightening reads local Stage 135 entry discipline JSON', 'copy-ready opening sentence', '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', 'subagents'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 141 entry trigger tightening boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 141 classification markers incomplete',
+    fix: 'Keep Stage 141 workflow entry tightening classified as auto_safe without workflow/skill/command/check/test/hook/adapter execution, artifact writes, prompt/template/skill mutation, git, platform API, model, MCP, or subagent dispatch.',
+  },
+  {
+    markers: ['platforms --session-start-examples', 'Stage 142 session-start example pack reads local Stage 134 shape acceptance JSON', 'copy-ready adapter output examples', 'context shapes', 'format warnings', 'without writing examples', 'executing hooks/adapters/workflows/skills/commands/checks/tests', 'mutating prompts/templates/skills/manifests/docs/source', 'git', 'platform APIs', 'model invocation', 'MCP', 'subagents'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 142 session-start example pack boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 142 classification markers incomplete',
+    fix: 'Keep Stage 142 platforms session-start examples classified as auto_safe without hook/adapter/workflow/skill/command/check/test execution, example/state writes, prompt/template/skill/manifest/docs mutation, git, platform API, model, MCP, or subagent dispatch.',
+  },
+  {
+    markers: ['workflow --next-evidence-prompts', 'Stage 143 next-action evidence prompts read local Stage 127 console JSON', 'evidence prompt cards', 'validation notes', 'blocked-until conditions', 'without writing evidence', 'running commands/checks/tests/workflows', 'mutating prompts/templates/skills', 'git', 'platform APIs', 'model invocation', 'MCP', 'subagents'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 143 next-action evidence prompts boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 143 classification markers incomplete',
+    fix: 'Keep Stage 143 workflow next-evidence-prompts classified as auto_safe without evidence writes, command/check/test/workflow execution, prompt/template/skill mutation, git, platform API, model, MCP, or subagent dispatch.',
+  },
+  {
+    markers: ['tokens --entry-defaults', 'Stage 144 context budget entry defaults read local Stage 128 token budget JSON', 'local Stage 140 parity scorecard JSON', 'lightweight entry context', 'deferrals', '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', 'subagents'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 144 context budget entry defaults boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 144 classification markers incomplete',
+    fix: 'Keep Stage 144 tokens entry-defaults classified as auto_safe without embeddings/model/remote config/full skill injection/prompt mutation/command execution/state writes/git/platform API/MCP/subagent dispatch.',
+  },
+  {
+    markers: ['evals --local-behavior-contracts', 'Stage 145 local behavior eval contracts read local Stage 138 Superpowers-style eval scenario pack JSON', 'local Stage 141 entry tightening JSON', 'deterministic contract cases', 'local judge definitions', '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', 'subagents'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 145 local behavior eval contracts boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 145 classification markers incomplete',
+    fix: 'Keep Stage 145 evals local-behavior-contracts classified as auto_safe without eval/model judge/agent session/state write/git/platform API/MCP/subagent dispatch.',
+  },
+  {
+    markers: ['governance --contributor-guardrails', 'Stage 146 contributor guardrail evidence reads local Stage 140 parity scorecard JSON', 'local Stage 143 next-action evidence prompts JSON', 'guardrail findings', 'required disclosures', 'unsafe closeout risks', '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', 'MCP', 'subagents'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 146 contributor guardrail evidence boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 146 classification markers incomplete',
+    fix: 'Keep Stage 146 governance contributor-guardrails classified as auto_safe without PR/remote review/git/state write/platform API/MCP/subagent dispatch.',
+  },
+  {
+    markers: ['governance --subagent-permission', 'Stage 147 subagent permission visibility reads local Stage 140 parity scorecard JSON', 'local Stage 146 contributor guardrails JSON', 'permission gates', 'brief requirements', 'must-ask-user-first prompts', 'non-authorizing visibility contract', 'without subagent dispatch', 'session creation', 'hidden handoff', 'running commands/checks/tests/workflows', 'writing artifacts/state/source', 'git', 'PR', 'platform APIs', 'MCP'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 147 subagent permission visibility boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 147 classification markers incomplete',
+    fix: 'Keep Stage 147 governance subagent-permission classified as auto_safe without subagent/session/dispatch/state write/git/platform API/MCP action.',
+  },
+  {
+    markers: ['platforms --adapter-packaging-consistency', 'Stage 148 adapter packaging consistency reads local Stage 122 bootstrap matrix JSON', 'local Stage 142 session-start examples JSON', 'adapter rows', 'missing install markers', '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', 'MCP', 'subagents'],
+    okLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs classifies Stage 148 adapter packaging consistency boundaries',
+    failLabel: 'tools/vibe-runtime/runtime-automation-readiness.mjs Stage 148 classification markers incomplete',
+    fix: 'Keep Stage 148 platforms adapter-packaging-consistency classified as auto_safe without adapter/hook/command/check/test/workflow execution, manifest/docs/source writes, git, platform API, MCP, or subagent dispatch.',
+  },
+];
+
+export function checkRuntimeAutomationReadinessContracts(root, api) {
+  if (!api.exists(root, AUTOMATION_READINESS_FILE)) {
+    api.fail('tools/vibe-runtime/runtime-automation-readiness.mjs missing', '', 'Restore the Stage 103 runtime automation readiness matrix module.');
+    return;
+  }
+
+  for (const contract of AUTOMATION_READINESS_CONTRACTS) {
+    const contractPath = contract.path || AUTOMATION_READINESS_FILE;
+    checkMarkers(root, api, contractPath, contract.markers, contract.okLabel, contract.failLabel, contract.fix);
+  }
+}