@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/index.mjs

@@ -0,0 +1,3117 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import crypto from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { printList } from './runtime-list-presentation.mjs';
+import { validateTaskId } from './runtime-cli-args.mjs';
+import { runRuntimeCli } from './runtime-cli-main.mjs';
+import { createRuntimeCliHandlerDeps } from './runtime-command-container.mjs';
+import {
+  createRuntimeGovernanceCommandDeps,
+  createRuntimeInteractionCommandDeps,
+  createRuntimeTokensCommandDeps,
+  createRuntimeWorkflowCommandDeps,
+} from './runtime-entry-deps-builder.mjs';
+import { runtimeCommandWrapperDeps } from './runtime-command-wrapper-deps.mjs';
+import {
+  confirmedOneShotPlanEnvelope as confirmedOneShotPlanCommandEnvelope,
+  runAutomationCommand,
+  runtimeAutomationReadinessEnvelope as runtimeAutomationReadinessCommandEnvelope,
+} from './runtime-automation-command.mjs';
+import {
+  runtimeAutomationReadinessMatrix,
+} from './runtime-automation-readiness.mjs';
+import {
+  digestCloseLoopDashboard,
+  runtimeCloseLoopDashboard,
+  runtimeCloseLoopDashboardDigestPayload,
+} from './runtime-close-loop-dashboard.mjs';
+import {
+  digestEvidenceIntake,
+  runtimeEvidenceIntakeDigestPayload,
+  runtimeEvidenceIntakeEnvelope,
+} from './runtime-evidence-intake-envelope.mjs';
+import {
+  digestExecutionEvidenceBinding,
+  runtimeExecutionEvidenceBinder,
+  runtimeExecutionEvidenceDigestPayload,
+} from './runtime-execution-evidence-binder.mjs';
+import {
+  digestDiffCoverage,
+  runtimeDiffCoverageDigestPayload,
+  runtimeDiffCoverageEnvelope,
+} from './runtime-diff-coverage-envelope.mjs';
+import {
+  digestReviewEnvelope,
+  runtimeReviewIntakeDigestPayload,
+  runtimeReviewIntakeEnvelope,
+  runtimeReviewResolutionDigestPayload,
+  runtimeReviewResolutionEnvelope,
+} from './runtime-review-envelope.mjs';
+import {
+  digestHumanFriendlyAlias,
+  runtimeHumanFriendlyAliasDigestPayload,
+  runtimeHumanFriendlyCloseLoopAlias,
+  runtimeHumanFriendlyNextEvidenceAlias,
+} from './runtime-human-friendly-aliases.mjs';
+import {
+  digestTddTraceContract,
+  runtimeTddTraceContract,
+  runtimeTddTraceDigestPayload,
+} from './runtime-tdd-trace-contract.mjs';
+import {
+  digestExecutablePlanContract,
+  runtimeExecutablePlanContract,
+  runtimeExecutablePlanContractDigestPayload,
+} from './runtime-executable-plan-contract.mjs';
+import {
+  digestPlanActionManifest,
+  runtimePlanActionManifest,
+  runtimePlanActionManifestDigestPayload,
+} from './runtime-plan-action-manifest.mjs';
+import {
+  digestCommitReadiness,
+  runtimeCommitReadinessDigestPayload,
+  runtimeCommitReadinessEnvelope,
+} from './runtime-commit-readiness-envelope.mjs';
+import {
+  digestStagedCommitReadiness,
+  runtimeStagedCommitReadiness,
+  runtimeStagedCommitReadinessDigestPayload,
+} from './runtime-staged-commit-readiness.mjs';
+import {
+  digestSelfTestGateProfile,
+  runtimeSelfTestGateProfile,
+  runtimeSelfTestGateProfileDigestPayload,
+} from './runtime-self-test-gate-profile.mjs';
+import {
+  digestWorkflowLoopContract,
+  runtimeWorkflowLoopContract,
+  runtimeWorkflowLoopContractDigestPayload,
+} from './runtime-workflow-loop-contract.mjs';
+import {
+  digestProgressiveEntryUx,
+  runtimeProgressiveEntryUx,
+  runtimeProgressiveEntryUxDigestPayload,
+} from './runtime-progressive-entry-ux.mjs';
+import {
+  digestSuperpowersGapMatrix,
+  runtimeSuperpowersGapDigestPayload,
+  runtimeSuperpowersGapMatrix,
+} from './runtime-superpowers-gap-matrix.mjs';
+import {
+  digestSuperpowersComparison,
+  runtimeSuperpowersComparisonDigestPayload,
+  runtimeSuperpowersComparisonMatrix,
+} from './runtime-superpowers-comparison-matrix.mjs';
+import {
+  digestExperienceFriction,
+  runtimeExperienceFrictionDigestPayload,
+  runtimeExperienceFrictionMatrix,
+} from './runtime-experience-friction-matrix.mjs';
+import {
+  digestNextActionConsole,
+  runtimeNextActionConsole,
+  runtimeNextActionConsoleDigestPayload,
+} from './runtime-next-action-console.mjs';
+import {
+  digestTokenSaviorBudget,
+  runtimeTokenSaviorBudget,
+  runtimeTokenSaviorBudgetDigestPayload,
+} from './runtime-token-savior-budget.mjs';
+import {
+  digestExperienceLearningPattern,
+  runtimeExperienceLearningPattern,
+  runtimeExperienceLearningPatternDigestPayload,
+} from './runtime-experience-learning-pattern.mjs';
+import {
+  digestExperienceRegressionDashboard,
+  runtimeExperienceRegressionDashboard,
+  runtimeExperienceRegressionDashboardDigestPayload,
+} from './runtime-experience-regression-dashboard.mjs';
+import {
+  runExperienceUpgradePrioritizerCommand,
+} from './runtime-experience-upgrade-command.mjs';
+import {
+  ensureRoot,
+  localJsonFileWithinRoot,
+} from './runtime-local-json-input.mjs';
+import { stateDirectory } from './runtime-state-directory-model.mjs';
+import {
+  runSuperpowersParityScorecardCommand,
+} from './runtime-superpowers-parity-command.mjs';
+import {
+  runContributorGuardrailCommand,
+} from './runtime-contributor-guardrail-command.mjs';
+import {
+  runSubagentPermissionCommand,
+} from './runtime-subagent-permission-command.mjs';
+// Stage 140: index.mjs keeps only CLI parsing/dispatch; command output boundaries live in runtime-superpowers-parity-command.mjs.
+import {
+  runtimeSuperpowersRegressionGuard,
+} from './runtime-superpowers-regression-guard.mjs';
+import {
+  runtimeBehavioralEvaluationContract,
+} from './runtime-behavioral-evaluation-contract.mjs';
+import {
+  digestSuperpowersStyleEvalPack,
+  runtimeSuperpowersStyleEvalPack,
+  runtimeSuperpowersStyleEvalPackDigestPayload,
+} from './runtime-superpowers-style-eval-pack.mjs';
+import {
+  digestEntryTriggerDiscipline,
+  runtimeEntryTriggerDiscipline,
+  runtimeEntryTriggerDisciplineDigestPayload,
+} from './runtime-entry-trigger-discipline.mjs';
+import {
+  runEntryTriggerTighteningCommand,
+} from './runtime-entry-trigger-tightening-command.mjs';
+import {
+  runNextActionEvidencePromptsCommand,
+} from './runtime-next-action-evidence-prompts-command.mjs';
+import {
+  digestMethodologyCoverage,
+  runtimeMethodologyCoverageDigestPayload,
+  runtimeMethodologyCoverageMap,
+} from './runtime-methodology-coverage-map.mjs';
+import {
+  runtimeSkillRuntimeTraceabilityMap,
+} from './runtime-skill-runtime-traceability-map.mjs';
+import {
+  runtimeCapabilityRegistry,
+  runtimeCapabilityRegistryDriftGuard,
+  runtimeCapabilityRegistryInvariants,
+} from './runtime-capability-registry.mjs';
+import { createRuntimeControlPlaneCommands } from './runtime-control-plane-command.mjs';
+import { createRuntimeInteractionCommands } from './runtime-interaction-command.mjs';
+import { createRuntimeWorkflowStateHelpers } from './runtime-workflow-state-helpers.mjs';
+import { createRuntimeWorkflowLedgerCommand } from './runtime-workflow-ledger-command.mjs';
+import { createRuntimeReplyCommand } from './runtime-reply-command.mjs';
+import { createRuntimeHooksCommand } from './runtime-hooks-command.mjs';
+import { createRuntimePlatformCommand } from './runtime-platform-command.mjs';
+import { createRuntimeSubagentsCommand } from './runtime-subagents-command.mjs';
+import { createRuntimeSddLoopCommand } from './runtime-sdd-loop-command.mjs';
+import { createRuntimeWorkspaceCommand } from './runtime-workspace-isolation-command.mjs';
+import { createRuntimeDispatchCommand } from './runtime-dispatch-command.mjs';
+import { createRuntimeExecutionCommand } from './runtime-execution-command.mjs';
+import { approvalProfileBinding, approvalProfileBindingFailures, candidateProfileBinding, candidateProfileBindingFailures, orderedProfileBinding } from './runtime-execution-enabled-bridge-model.mjs';
+import { controlledForegroundBinding, controlledForegroundEnvelopeFailures, foregroundEvidenceDigestPayload, foregroundPreflightFailures, foregroundPreflightGates } from './runtime-execution-enabled-run-envelope.mjs';
+import { buildExecutionEnabledPreflight, buildExecutionProfilePreflightEnvelope } from './runtime-execution-enabled-preflight-model.mjs';
+import { createSourcePatchPlanEnvelope } from './runtime-source-patch-plan-model.mjs';
+import { createRuntimeSourceMergeArtifacts } from './runtime-source-merge-artifacts.mjs';
+import { createRuntimePolicyCatalog } from './runtime-policy-catalog.mjs';
+import { plannerAllowedWorkflows as plannerAllowedWorkflowsForPolicy } from './runtime-planner-route-model.mjs';
+import { createRuntimeSourceMergeEntryCommands } from './runtime-source-merge-entry-command.mjs';
+import { createRuntimeSourceMergeCommand } from './runtime-source-merge-command.mjs';
+import { createRuntimeTraceCommand } from './runtime-trace-command.mjs';
+import { createRuntimeLeaseCommand } from './runtime-lease-command.mjs';
+import { createRuntimeSchedulerCommand } from './runtime-scheduler-command.mjs';
+import { createRuntimeDaemonCommand } from './runtime-daemon-command.mjs';
+import { createRuntimeQueueCommand } from './runtime-queue-command.mjs';
+import { createRuntimeRecoveryCommand } from './runtime-recovery-command.mjs';
+import { createRuntimeRetryCommand } from './runtime-retry-command.mjs';
+import { runtimeTestRunProfiles } from './runtime-test-run-command.mjs';
+import { createRuntimeObservabilityCommand } from './runtime-observability-command.mjs';
+import { createRuntimeGovernanceCommand } from './runtime-governance-command.mjs';
+import {
+  buildVerificationDrivenRepairLoopPlan,
+  printVerificationDrivenRepairLoopPlan,
+} from './runtime-verification-repair-loop-plan.mjs';
+import * as runtimeStatePaths from './runtime-state-paths.mjs';
+import * as runtimeStateIo from './runtime-state-io.mjs';
+
+const runtimeContractRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const runtimeEntryContractMarkers = "Stage 45 source-sandbox-apply-only source-verification-only Stage 46 source-verification-gate merge-readiness-only verification-passed-merge-readiness-required Stage 47 merge-approval-only controlled-merge-apply-only auto_apply Stage 48 controlled-merge-apply-completed controlled-local-marker-apply Stage 49 Stage 54 workflow-route-policy platform-ranking-policy mutex-fallback-policy eval-judge-policy safety-boundary-policy Stage 57 governancePrReadinessPayload not_performed_offline_boundary human_submit_pr created_pr: false pushed: false merged: false Stage 58 governancePrReviewIntakePayload input_evidence_digest governanceRootRelativeEvidenceFilePath created_pr: false pushed: false merged: false Stage 85 mode: 'workflow-readiness-gate' Stage 87 mode: 'workflow-cockpit' Stage 90 acceptance_kind: 'workflow-bootstrap-acceptance' mode: 'workflow-bootstrap-acceptance' Stage 94 sequence_kind: 'execution-choreography' mode: 'execution-choreography' Stage 95 brief_kind: 'workflow-onboarding-brief' mode: 'workflow-onboarding-brief' Stage 100 runtimeSurfaceBoundaryAssertions runtimeSurfaceCapabilityGroups runtimeSurfaceStageInventory runtimeSurfaceCloseoutChain Stage 104 Stage 116 progressive-entry-ux-contract Stage 135 entry-trigger-discipline-contract";
+if (!runtimeEntryContractMarkers.includes('Stage 54')) throw new Error('runtime entry contract markers missing');
+const {
+  stateDirectoryName,
+  workflowFileName,
+  taskArtifactsDirectoryName,
+  dispatchesDirectoryName,
+  dispatchClaimsDirectoryName,
+  executionsDirectoryName,
+  executionCandidatesDirectoryName,
+  executionApprovalsDirectoryName,
+  autoRunLocksDirectoryName,
+  executionQueueDirectoryName,
+  recoveryPackagesDirectoryName,
+  recoveryClassificationsDirectoryName,
+  recoveryRunsDirectoryName,
+  retryPackagesDirectoryName,
+  retryRunsDirectoryName,
+  observabilityDirectoryName,
+  schedulerPlansDirectoryName,
+  schedulerHookPlansDirectoryName,
+  schedulerRunsDirectoryName,
+  schedulerLeasesDirectoryName,
+  approvalLifecycleDirectoryName,
+  daemonRunsDirectoryName,
+  daemonLoopsDirectoryName,
+  daemonHeartbeatsDirectoryName,
+  daemonStopDirectoryName,
+  replyDraftsDirectoryName,
+  replyReviewsDirectoryName,
+  replyApprovalsDirectoryName,
+  replyOutboxDirectoryName,
+  replySendRunsDirectoryName,
+  runtimeTracesDirectoryName,
+  governanceDirectoryName,
+  methodologyGatesDirectoryName,
+  hookIntentsDirectoryName,
+  subagentEligibilityDirectoryName,
+  subagentDispatchesDirectoryName,
+  subagentAdapterDispatchesDirectoryName,
+  subagentRunLeasesDirectoryName,
+  subagentRunResultsDirectoryName,
+  subagentResultsDirectoryName,
+  subagentReviewsDirectoryName,
+  hookRunsDirectoryName,
+  hookHeartbeatsDirectoryName,
+  platformCapabilitiesDirectoryName,
+  platformSessionApprovalsDirectoryName,
+  platformSessionsDirectoryName,
+  platformSessionLeasesDirectoryName,
+  platformSessionResultsDirectoryName,
+  platformSessionCancellationsDirectoryName,
+  platformSessionIntakeDirectoryName,
+  platformSessionReviewsDirectoryName,
+  sourceChangeCandidatesDirectoryName,
+  sourceSandboxRunsDirectoryName,
+  sourceVerificationsDirectoryName,
+  mergeReadinessDirectoryName,
+  mergeApprovalsDirectoryName,
+  mergeAppliesDirectoryName,
+  plannerRoutesDirectoryName,
+  plannerPlansDirectoryName,
+  plannerBriefsDirectoryName,
+  routerPlansDirectoryName,
+  routerApprovalsDirectoryName,
+  orchestratorPlansDirectoryName,
+  orchestratorDispatchPlansDirectoryName,
+  evalSuitesDirectoryName,
+  evalRunsDirectoryName,
+  evalReportsDirectoryName,
+  releaseGatesDirectoryName,
+  releaseNotesDirectoryName,
+  feedbackLedgersDirectoryName,
+  learningDirectoryName,
+  tokenEconomyDirectoryName,
+} = runtimeStatePaths;
+const {
+  workflowPath,
+  artifactPath,
+  taskArtifactsDirectory,
+  dispatchesDirectory,
+  dispatchClaimsDirectory,
+  executionsDirectory,
+  executionCandidatesDirectory,
+  executionApprovalsDirectory,
+  autoRunLocksDirectory,
+  executionQueueDirectory,
+  recoveryPackagesDirectory,
+  recoveryClassificationsDirectory,
+  recoveryRunsDirectory,
+  retryPackagesDirectory,
+  retryRunsDirectory,
+  observabilityDirectory,
+  schedulerPlansDirectory,
+  schedulerHookPlansDirectory,
+  schedulerRunsDirectory,
+  schedulerLeasesDirectory,
+  approvalLifecycleDirectory,
+  daemonLoopsDirectory,
+  daemonHeartbeatsDirectory,
+  daemonStopDirectory,
+  replyDraftsDirectory,
+  replyReviewsDirectory,
+  replyApprovalsDirectory,
+  replyOutboxDirectory,
+  replySendRunsDirectory,
+  runtimeTracesDirectory,
+  governanceDirectory,
+  methodologyGatesDirectory,
+  hookIntentsDirectory,
+  subagentEligibilityDirectory,
+  subagentDispatchesDirectory,
+  subagentAdapterDispatchesDirectory,
+  subagentRunLeasesDirectory,
+  subagentRunResultsDirectory,
+  subagentResultsDirectory,
+  subagentReviewsDirectory,
+  hookRunsDirectory,
+  hookHeartbeatsDirectory,
+  platformCapabilitiesDirectory,
+  platformSessionApprovalsDirectory,
+  platformSessionsDirectory,
+  platformSessionLeasesDirectory,
+  platformSessionResultsDirectory,
+  platformSessionCancellationsDirectory,
+  platformSessionIntakeDirectory,
+  platformSessionReviewsDirectory,
+  sourceChangeCandidatesDirectory,
+  sourceSandboxRunsDirectory,
+  sourceVerificationsDirectory,
+  mergeReadinessDirectory,
+  mergeApprovalsDirectory,
+  mergeAppliesDirectory,
+  plannerRoutesDirectory,
+  plannerPlansDirectory,
+  plannerBriefsDirectory,
+  routerPlansDirectory,
+  routerApprovalsDirectory,
+  orchestratorPlansDirectory,
+  orchestratorDispatchPlansDirectory,
+  evalSuitesDirectory,
+  evalRunsDirectory,
+  evalReportsDirectory,
+  releaseGatesDirectory,
+  releaseNotesDirectory,
+  feedbackLedgersDirectory,
+  learningDirectory,
+  tokenEconomyDirectory,
+  approvalLifecycleFileName,
+  approvalLifecycleFilePath,
+  safeStateArtifactFilePath,
+  candidateFilePath,
+  approvalFilePath,
+  autoRunLockFilePath,
+  queueFilePath,
+  recoveryFilePath,
+  recoveryClassificationFilePath,
+  schedulerPlanFilePath,
+  schedulerHookPlanFilePath,
+  retryPackageFilePath,
+  daemonLoopFilePath,
+  replyDraftFilePath,
+  replyReviewFilePath,
+  replyApprovalFilePath,
+  replyOutboxFilePath,
+  replySendRunFilePath,
+  runtimeTraceFilePath,
+  governanceFilePath,
+  governancePrReadinessFilePath,
+  governancePrReviewIntakeFilePath,
+  governanceAnyFilePath,
+  hookIntentFilePath,
+  subagentEligibilityFilePath,
+  subagentDispatchFilePath,
+  subagentAdapterDispatchFilePath,
+  subagentRunLeaseFilePath,
+  subagentRunResultFilePath,
+  subagentResultFilePath,
+  subagentReviewFilePath,
+  hookRunFilePath,
+  hookHeartbeatFilePath,
+  platformCapabilityFilePath,
+  platformSessionApprovalFilePath,
+  platformSessionFilePath,
+  platformSessionLeaseFilePath,
+  platformSessionResultFilePath,
+  platformSessionCancellationFilePath,
+  platformSessionIntakeFilePath,
+  platformSessionReviewFilePath,
+  sourceChangeCandidateFilePath,
+  sourceSandboxRunFilePath,
+  sourceVerificationFilePath,
+  mergeReadinessFilePath,
+  mergeApprovalFilePath,
+  mergeApplyFilePath,
+  plannerRouteFilePath,
+  plannerPlanFilePath,
+  plannerBriefsFilePath,
+  routerPlanFilePath,
+  routerApprovalFilePath,
+  orchestratorPlanFilePath,
+  orchestratorDispatchPlanFilePath,
+  evalSuiteFilePath,
+  evalRunFilePath,
+  evalReportFilePath,
+  releaseGateFilePath,
+  releaseNotesFilePath,
+  feedbackLedgerFilePath,
+  learningObservationFilePath,
+  learningCandidateInstinctFilePath,
+  learningPromotionFilePath,
+  tokenCompactionFilePath,
+  tokenMetricsFilePath,
+  plannerRouteSnapshotPath,
+  plannerPlanSnapshotPath,
+  plannerBriefsSnapshotPath,
+  routerPlanSnapshotPath,
+  routerApprovalSnapshotPath,
+  orchestratorPlanSnapshotPath,
+  orchestratorDispatchPlanSnapshotPath,
+  evalSuiteSnapshotPath,
+  evalRunSnapshotPath,
+  evalReportSnapshotPath,
+  releaseGateSnapshotPath,
+  releaseNotesSnapshotPath,
+  feedbackLedgerSnapshotPath,
+} = runtimeStatePaths;
+const {
+  readJsonArtifact,
+  writeStateArtifact,
+  fileDigest,
+  optionalFileDigest,
+  stableJson,
+  digestObject,
+} = runtimeStateIo;
+
+const stage11RuntimeActionName = 'generate-supervised-handoff-package';
+const runtimeActionCatalogStage = 'Stage 18';
+const runtimeActionCatalogVersion = 1;
+const approvalLifecycleStage = 'Stage 17';
+const approvalLifecycleStates = new Set(['previewed', 'requested', 'approved', 'rejected', 'expired', 'revoked', 'consumed']);
+const approvalLifecycleTerminalStates = new Set(['rejected', 'expired', 'revoked', 'consumed']);
+const stage11ExecutionStaleAfterMs = 30 * 60 * 1000;
+const stage12CandidateStaleAfterMs = 30 * 60 * 1000;
+const stage13ApprovalStaleAfterMs = 30 * 60 * 1000;
+const stage11AllowedExecutionSkills = new Set([
+  'vibe-verification-before-completion',
+  'vibe-review',
+  'vibe-requesting-code-review',
+  'vibe-receiving-code-review',
+  'vibe-systematic-debugging',
+  'vibe-test-driven-development',
+  'vibe-executing-plans',
+]);
+const allowedExecutionStatuses = new Set(['planned', 'running', 'succeeded', 'failed', 'timed_out', 'cancelled']);
+const stage11TerminalStatuses = new Set(['succeeded', 'failed', 'timed_out', 'cancelled']);
+const forbiddenDispatchActions = [
+  'git_write',
+  'worktree_write',
+  'subagent_dispatch',
+  'daemon',
+  'mcp_runtime',
+  'business_source_write',
+];
+// Stage 11.2 Stage 11.3 Stage 11.4 Stage 11.5 Stage 11.6 Stage 11.7 Stage 11.8 Stage 11.9 Stage 11.10
+// Stage 12 Stage 13 Stage 14 Stage 15 Stage 16
+const claimStaleAfterMs = 30 * 60 * 1000;
+const executionPolicy = {
+  name: 'stage-9-supervised-executor',
+  version: 1,
+};
+const autoRunPolicyProfiles = {
+  strict: {
+    profile: 'strict',
+    mode: 'review-only',
+    default_enabled: false,
+    allowed_target_skills: [],
+    allowed_runtime_actions: [],
+    forbidden_actions: forbiddenDispatchActions,
+    expected_writes: [],
+    risk_ceiling: 'none',
+    approval: { required: true, stale_after_ms: stage13ApprovalStaleAfterMs },
+    limits: { max_active_runs: 0, max_queue_items: 50 },
+  },
+  'controlled-local-runtime': {
+    profile: 'controlled-local-runtime',
+    mode: 'controlled-local-runtime',
+    default_enabled: false,
+    allowed_target_skills: [...stage11AllowedExecutionSkills].sort(),
+    allowed_runtime_actions: [stage11RuntimeActionName],
+    forbidden_actions: forbiddenDispatchActions,
+    expected_writes: [path.join(stateDirectoryName, executionsDirectoryName, '<timestamp>-<dispatch-hash>.execution.json').replace(/\\/g, '/')],
+    risk_ceiling: 'state-only-runtime-action',
+    approval: { required: true, stale_after_ms: stage13ApprovalStaleAfterMs },
+    limits: { max_active_runs: 1, max_queue_items: 50 },
+  },
+  'review-only': {
+    profile: 'review-only',
+    mode: 'review-only',
+    default_enabled: false,
+    allowed_target_skills: ['vibe-review', 'vibe-requesting-code-review', 'vibe-receiving-code-review'].sort(),
+    allowed_runtime_actions: [],
+    forbidden_actions: forbiddenDispatchActions,
+    expected_writes: [],
+    risk_ceiling: 'no-runtime-action',
+    approval: { required: true, stale_after_ms: stage13ApprovalStaleAfterMs },
+    limits: { max_active_runs: 0, max_queue_items: 50 },
+  },
+};
+const schedulerPolicyProfiles = {
+  'scheduler-dry-run': {
+    profile: 'scheduler-dry-run',
+    mode: 'plan-only',
+    default_enabled: false,
+    allowed_scheduler_actions: ['plan'],
+    allowed_runtime_actions: [],
+    auto_run_allowed: false,
+    recovery_apply_allowed: false,
+    retry_allowed: false,
+  },
+  'single-local-auto-run': {
+    profile: 'single-local-auto-run',
+    mode: 'single-shot-local-auto-run',
+    default_enabled: false,
+    allowed_scheduler_actions: ['plan', 'once'],
+    allowed_runtime_actions: [stage11RuntimeActionName],
+    auto_run_allowed: true,
+    recovery_apply_allowed: false,
+    retry_allowed: false,
+  },
+  'recovery-only': {
+    profile: 'recovery-only',
+    mode: 'recovery-plan-only',
+    default_enabled: false,
+    allowed_scheduler_actions: ['plan', 'recover-once'],
+    allowed_runtime_actions: [],
+    auto_run_allowed: false,
+    recovery_apply_allowed: false,
+    retry_allowed: false,
+  },
+  'scheduler-recovery-once': {
+    profile: 'scheduler-recovery-once',
+    mode: 'single-shot-recovery-apply',
+    default_enabled: false,
+    allowed_scheduler_actions: ['plan', 'recover-once'],
+    allowed_runtime_actions: [],
+    auto_run_allowed: false,
+    recovery_apply_allowed: false,
+    retry_allowed: false,
+  },
+};
+const schedulerRuntimeBudget = {
+  stage: 'Stage 22',
+  max_runs_per_invocation: 1,
+  max_active_scheduler_runs: 1,
+  max_retry_attempts: 0,
+  max_consecutive_failures: 1,
+  max_lock_age_ms: stage11ExecutionStaleAfterMs,
+  kill_switch: false,
+  retry_allowed: false,
+  recovery_apply_allowed: false,
+};
+const recoveryClassificationPolicy = {
+  name: 'stage-24-recovery-classification-policy',
+  version: 1,
+  stage: 'Stage 24',
+  source: 'builtin-data-only',
+  apply_allowed: false,
+};
+const recoveryPolicy = {
+  name: 'stage-25-confirmed-recovery-policy',
+  version: 1,
+  stage: 'Stage 25',
+  default_enabled: false,
+  max_recovery_items_per_invocation: 1,
+  allowed_actions: ['record_recovery_decision', 'mark_scheduler_lease_failed', 'package_retry_candidate'],
+  source_mutation: false,
+  business_source_write: false,
+  delete_allowed: false,
+  retry_execute_allowed: false,
+  automatic_retry: false,
+  remote_config: false,
+  dynamic_code: false,
+};
+const boundedRetryPolicy = {
+  name: 'stage-27-bounded-auto-retry-policy',
+  version: 1,
+  stage: 'Stage 27',
+  default_enabled: false,
+  max_retry_attempts: 1,
+  transient_only: true,
+  approval_required: true,
+  allowed_runtime_actions: [stage11RuntimeActionName],
+  source_mutation: false,
+  business_source_write: false,
+  automatic_retry: false,
+  remote_config: false,
+  dynamic_code: false,
+};
+const boundedRetryBudget = {
+  stage: 'Stage 27',
+  max_retry_attempts: 1,
+  max_retry_runs_per_invocation: 1,
+  max_active_retry_runs: 0,
+  kill_switch: false,
+  transient_only: true,
+  approval_required: true,
+  default_enabled: false,
+};
+const replyPolicy = {
+  name: 'reply-a-d-local-pipeline-policy',
+  version: 1,
+  stage: 'Reply A-D',
+  default_enabled: false,
+  external_delivery: false,
+  send_allowed: false,
+  model_invocation: false,
+  platform_api: false,
+  approval_required: true,
+  adapters: ['local-disabled'],
+};
+const recoveryActionCatalog = {
+  stage: 'Stage 25',
+  version: 1,
+  source: 'builtin-data-only',
+  default_allow_unknown: false,
+  actions: [
+    {
+      id: 'record_recovery_decision',
+      categories: ['lease_stale', 'execution_failed', 'execution_timed_out', 'execution_running_stale', 'approval_missing', 'approval_blocked', 'policy_mismatch', 'catalog_mismatch', 'readiness_blocked', 'scheduler_lease_active', 'unknown'],
+      writes: [path.join(stateDirectoryName, recoveryRunsDirectoryName, '<timestamp>.recovery-run.json').replace(/\\/g, '/')],
+      idempotency: 'classification_digest:finding_digest:action',
+    },
+    {
+      id: 'mark_scheduler_lease_failed',
+      categories: ['scheduler_lease_active'],
+      writes: [path.join(stateDirectoryName, recoveryRunsDirectoryName, '<timestamp>.recovery-run.json').replace(/\\/g, '/')],
+      idempotency: 'classification_digest:finding_digest:action',
+    },
+    {
+      id: 'package_retry_candidate',
+      categories: ['execution_failed', 'execution_timed_out'],
+      writes: [path.join(stateDirectoryName, recoveryRunsDirectoryName, '<timestamp>.recovery-run.json').replace(/\\/g, '/'), path.join(stateDirectoryName, retryPackagesDirectoryName, '<timestamp>.retry-package.json').replace(/\\/g, '/')],
+      idempotency: 'classification_digest:finding_digest:action',
+    },
+  ],
+};
+const artifactFileNames = {
+  taskBrief: 'task-brief.md',
+  reviewGate: 'review-gate.md',
+  evidence: 'evidence.md',
+};
+const taskArtifactFileNames = {
+  brief: 'brief.md',
+  report: 'report.md',
+  reviewGate: 'review-gate.md',
+  evidence: 'evidence.md',
+};
+const allowedStatuses = new Set([
+  'idle',
+  'handoff-recorded',
+  'waiting-confirmation',
+  'next-suggested',
+  'stopped',
+]);
+const allowedTaskStatuses = new Set(['pending', 'in_progress', 'completed', 'blocked']);
+const allowedReviewStatuses = new Set(['not_started', 'requested', 'clean', 'needs_fix', 'waived']);
+const taskIdPattern = /^[A-Za-z0-9._-]+$/;
+const windowsReservedTaskBasenames = new Set([
+  'CON',
+  'PRN',
+  'AUX',
+  'NUL',
+  'COM1',
+  'COM2',
+  'COM3',
+  'COM4',
+  'COM5',
+  'COM6',
+  'COM7',
+  'COM8',
+  'COM9',
+  'LPT1',
+  'LPT2',
+  'LPT3',
+  'LPT4',
+  'LPT5',
+  'LPT6',
+  'LPT7',
+  'LPT8',
+  'LPT9',
+]);
+const taskIdRequirement = 'Use only letters, numbers, dot, underscore, and hyphen; path separators, traversal, Windows reserved device names, and trailing dots or spaces are not allowed.';
+const jsonSchemaVersion = 1;
+const adapterRuntimeBridge = {
+  supported: true,
+  mode: 'manual',
+  canReadDispatchIntent: true,
+  canAutoExecuteSkill: false,
+  canCallSubagent: false,
+  canTouchGit: false,
+};
+const platformCapabilities = {
+  claude: {
+    entry_file: 'CLAUDE.md',
+    mode: 'manual',
+    session_create: false,
+    platform_api: false,
+    stdin_automation: false,
+    adapter_dry_run: true,
+  },
+  cursor: {
+    entry_file: 'AGENTS.md',
+    mode: 'manual',
+    session_create: false,
+    platform_api: false,
+    stdin_automation: false,
+    adapter_dry_run: true,
+  },
+  codex: {
+    entry_file: 'AGENTS.md',
+    mode: 'manual',
+    session_create: false,
+    platform_api: false,
+    stdin_automation: false,
+    adapter_dry_run: true,
+  },
+};
+const platformHints = {
+  claude: {
+    entry_file: 'CLAUDE.md',
+    instruction: 'Load the target workflow skill from .vibecoding/skills/ and continue from the current Workflow Handoff.',
+  },
+  cursor: {
+    entry_file: 'AGENTS.md',
+    instruction: 'Continue with the target workflow skill manually using the current handoff.',
+  },
+  codex: {
+    entry_file: 'AGENTS.md',
+    instruction: 'Use the target workflow skill as the next manual step.',
+  },
+};
+const allowedTransitions = new Set([
+  'using-vibecoding->vibe-brainstorming',
+  'using-vibecoding->vibe-planning',
+  'using-vibecoding->vibe-writing-skills',
+  'using-vibecoding->vibe-writing-plans',
+  'using-vibecoding->vibe-workspace-isolation',
+  'using-vibecoding->vibe-dispatching-parallel-work',
+  'using-vibecoding->vibe-subagent-driven-development',
+  'using-vibecoding->vibe-test-driven-development',
+  'using-vibecoding->vibe-implementation',
+  'using-vibecoding->vibe-systematic-debugging',
+  'using-vibecoding->vibe-requesting-code-review',
+  'using-vibecoding->vibe-receiving-code-review',
+  'using-vibecoding->vibe-verification-before-completion',
+  'using-vibecoding->vibe-finishing-a-development-branch',
+  'using-vibecoding->vibe-context-compact',
+  'vibe-brainstorming->vibe-planning',
+  'vibe-brainstorming->vibe-implementation',
+  'vibe-planning->vibe-implementation',
+  'vibe-planning->vibe-writing-plans',
+  'vibe-writing-skills->vibe-writing-plans',
+  'vibe-writing-skills->vibe-test-driven-development',
+  'vibe-writing-skills->vibe-planning',
+  'vibe-writing-plans->vibe-test-driven-development',
+  'vibe-writing-plans->vibe-workspace-isolation',
+  'vibe-writing-plans->vibe-dispatching-parallel-work',
+  'vibe-writing-plans->vibe-planning',
+  'vibe-workspace-isolation->vibe-writing-plans',
+  'vibe-workspace-isolation->vibe-dispatching-parallel-work',
+  'vibe-workspace-isolation->vibe-subagent-driven-development',
+  'vibe-workspace-isolation->vibe-test-driven-development',
+  'vibe-workspace-isolation->vibe-executing-plans',
+  'vibe-workspace-isolation->vibe-finishing-a-development-branch',
+  'vibe-dispatching-parallel-work->vibe-workspace-isolation',
+  'vibe-dispatching-parallel-work->vibe-subagent-driven-development',
+  'vibe-dispatching-parallel-work->vibe-test-driven-development',
+  'vibe-dispatching-parallel-work->vibe-executing-plans',
+  'vibe-dispatching-parallel-work->vibe-writing-plans',
+  'vibe-dispatching-parallel-work->vibe-planning',
+  'vibe-test-driven-development->vibe-implementation',
+  'vibe-test-driven-development->vibe-executing-plans',
+  'vibe-test-driven-development->vibe-planning',
+  'vibe-implementation->vibe-verification-before-completion',
+  'vibe-implementation->vibe-planning',
+  'vibe-implementation->vibe-systematic-debugging',
+  'vibe-executing-plans->vibe-verification-before-completion',
+  'vibe-executing-plans->vibe-systematic-debugging',
+  'vibe-executing-plans->vibe-writing-plans',
+  'vibe-executing-plans->vibe-planning',
+  'vibe-executing-plans->vibe-subagent-driven-development',
+  'vibe-executing-plans->vibe-dispatching-parallel-work',
+  'vibe-systematic-debugging->vibe-test-driven-development',
+  'vibe-systematic-debugging->vibe-implementation',
+  'vibe-systematic-debugging->vibe-planning',
+  'vibe-debugging->vibe-systematic-debugging',
+  'vibe-debugging->vibe-implementation',
+  'vibe-debugging->vibe-planning',
+  'vibe-verification->vibe-verification-before-completion',
+  'vibe-verification->vibe-debugging',
+  'vibe-verification->vibe-implementation',
+  'vibe-verification->vibe-planning',
+  'vibe-verification-before-completion->vibe-finishing-a-development-branch',
+  'vibe-verification-before-completion->vibe-verification',
+  'vibe-verification-before-completion->vibe-systematic-debugging',
+  'vibe-verification-before-completion->vibe-implementation',
+  'vibe-verification-before-completion->vibe-planning',
+  'vibe-requesting-code-review->vibe-review',
+  'vibe-requesting-code-review->vibe-verification-before-completion',
+  'vibe-requesting-code-review->vibe-planning',
+  'vibe-review->vibe-receiving-code-review',
+  'vibe-review->vibe-test-driven-development',
+  'vibe-review->vibe-verification-before-completion',
+  'vibe-review->vibe-planning',
+  'vibe-receiving-code-review->vibe-test-driven-development',
+  'vibe-receiving-code-review->vibe-implementation',
+  'vibe-receiving-code-review->vibe-systematic-debugging',
+  'vibe-receiving-code-review->vibe-planning',
+  'vibe-receiving-code-review->vibe-verification-before-completion',
+  'vibe-subagent-driven-development->vibe-verification-before-completion',
+  'vibe-subagent-driven-development->vibe-dispatching-parallel-work',
+  'vibe-subagent-driven-development->vibe-writing-plans',
+  'vibe-subagent-driven-development->vibe-workspace-isolation',
+  'vibe-subagent-driven-development->vibe-test-driven-development',
+  'vibe-subagent-driven-development->vibe-executing-plans',
+  'vibe-subagent-driven-development->vibe-receiving-code-review',
+  'vibe-subagent-driven-development->vibe-systematic-debugging',
+  'vibe-finishing-a-development-branch->vibe-verification-before-completion',
+  'vibe-finishing-a-development-branch->vibe-implementation',
+  'vibe-finishing-a-development-branch->none',
+  'vibe-context-compact->vibe-planning',
+  'vibe-context-compact->vibe-debugging',
+  'vibe-context-compact->vibe-implementation',
+  'vibe-context-compact->vibe-verification',
+  'vibe-context-compact->none',
+]);
+
+
+let runtimeExecutionCommand;
+function executionCommand() {
+  if (!runtimeExecutionCommand) throw new Error('runtime execution command is not initialized');
+  return runtimeExecutionCommand;
+}
+function listApprovalFiles(...args) {
+  return executionCommand().listApprovalFiles(...args);
+}
+function listApprovalLifecycleFiles(...args) {
+  return executionCommand().listApprovalLifecycleFiles(...args);
+}
+function executionFilePath(...args) {
+  return executionCommand().executionFilePath(...args);
+}
+function listExecutionFiles(...args) {
+  return executionCommand().listExecutionFiles(...args);
+}
+function readExecutionFile(...args) {
+  return executionCommand().readExecutionFile(...args);
+}
+function lifecycleSummary(...args) {
+  return executionCommand().lifecycleSummary(...args);
+}
+function executionAgeMs(...args) {
+  return executionCommand().executionAgeMs(...args);
+}
+function executionAuditState(...args) {
+  return executionCommand().executionAuditState(...args);
+}
+function executionSafety(...args) {
+  return executionCommand().executionSafety(...args);
+}
+function candidateSafety(...args) {
+  return executionCommand().candidateSafety(...args);
+}
+function approvalSafety(...args) {
+  return executionCommand().approvalSafety(...args);
+}
+function autoRunSafety(...args) {
+  return executionCommand().autoRunSafety(...args);
+}
+function validateCandidateArtifact(...args) {
+  return executionCommand().validateCandidateArtifact(...args);
+}
+function validateApprovalArtifact(...args) {
+  return executionCommand().validateApprovalArtifact(...args);
+}
+function executionIdempotencyKey(...args) {
+  return executionCommand().executionIdempotencyKey(...args);
+}
+function runtimeActionCatalogSnapshot(...args) {
+  return executionCommand().runtimeActionCatalogSnapshot(...args);
+}
+function runtimeActionCatalogDigest(...args) {
+  return executionCommand().runtimeActionCatalogDigest(...args);
+}
+function runtimeActionById(...args) {
+  return executionCommand().runtimeActionById(...args);
+}
+function evaluateRuntimeActionCatalog(...args) {
+  return executionCommand().evaluateRuntimeActionCatalog(...args);
+}
+function validateRuntimeActionCatalog(...args) {
+  return executionCommand().validateRuntimeActionCatalog(...args);
+}
+function actionCatalogEnvelope(...args) {
+  return executionCommand().actionCatalogEnvelope(...args);
+}
+function policyProfileSnapshot(...args) {
+  return executionCommand().policyProfileSnapshot(...args);
+}
+function validatePolicySnapshot(...args) {
+  return executionCommand().validatePolicySnapshot(...args);
+}
+function policyEvaluationEnvelope(...args) {
+  return executionCommand().policyEvaluationEnvelope(...args);
+}
+function executionPolicySnapshot(...args) {
+  return executionCommand().executionPolicySnapshot(...args);
+}
+function validateExecutionPolicySnapshot(...args) {
+  return executionCommand().validateExecutionPolicySnapshot(...args);
+}
+function validateRuntimeActionContract(...args) {
+  return executionCommand().validateRuntimeActionContract(...args);
+}
+function validateTerminalEvidence(...args) {
+  return executionCommand().validateTerminalEvidence(...args);
+}
+function validateExecutionEnvelope(...args) {
+  return executionCommand().validateExecutionEnvelope(...args);
+}
+function executionSummary(...args) {
+  return executionCommand().executionSummary(...args);
+}
+function executionEventPath(...args) {
+  return executionCommand().executionEventPath(...args);
+}
+function executionPlan(...args) {
+  return executionCommand().executionPlan(...args);
+}
+function findActiveExecutionByIdempotencyKey(...args) {
+  return executionCommand().findActiveExecutionByIdempotencyKey(...args);
+}
+function assertNoActiveExecution(...args) {
+  return executionCommand().assertNoActiveExecution(...args);
+}
+function executionHistorySummary(...args) {
+  return executionCommand().executionHistorySummary(...args);
+}
+function executionCandidateEnvelope(...args) {
+  return executionCommand().executionCandidateEnvelope(...args);
+}
+function candidateArtifactPath(...args) {
+  return executionCommand().candidateArtifactPath(...args);
+}
+function writeCandidateArtifact(...args) {
+  return executionCommand().writeCandidateArtifact(...args);
+}
+function approvalArtifactPath(...args) {
+  return executionCommand().approvalArtifactPath(...args);
+}
+function executionApprovalEnvelope(...args) {
+  return executionCommand().executionApprovalEnvelope(...args);
+}
+function writeApprovalArtifact(...args) {
+  return executionCommand().writeApprovalArtifact(...args);
+}
+function approvalLifecycleDigestPayload(...args) {
+  return executionCommand().approvalLifecycleDigestPayload(...args);
+}
+function approvalLifecycleEnvelope(...args) {
+  return executionCommand().approvalLifecycleEnvelope(...args);
+}
+function validateApprovalLifecycleArtifact(...args) {
+  return executionCommand().validateApprovalLifecycleArtifact(...args);
+}
+function readApprovalLifecycle(...args) {
+  return executionCommand().readApprovalLifecycle(...args);
+}
+function writeApprovalLifecycle(...args) {
+  return executionCommand().writeApprovalLifecycle(...args);
+}
+function validateApprovalLifecycleBinding(...args) {
+  return executionCommand().validateApprovalLifecycleBinding(...args);
+}
+function approvalLifecycleCurrentState(...args) {
+  return executionCommand().approvalLifecycleCurrentState(...args);
+}
+function approvalLifecycleAuditEnvelope(...args) {
+  return executionCommand().approvalLifecycleAuditEnvelope(...args);
+}
+function runApprovals(...args) {
+  return executionCommand().runApprovals(...args);
+}
+function readApprovalForAutoRun(...args) {
+  return executionCommand().readApprovalForAutoRun(...args);
+}
+function assertAutoRunLock(...args) {
+  return executionCommand().assertAutoRunLock(...args);
+}
+function controlledAutoRunEnvelope(...args) {
+  return executionCommand().controlledAutoRunEnvelope(...args);
+}
+function assertExecutionClaimReady(...args) {
+  return executionCommand().assertExecutionClaimReady(...args);
+}
+function executionPreflightEnvelope(...args) {
+  return executionCommand().executionPreflightEnvelope(...args);
+}
+function executionEnvelope(...args) {
+  return executionCommand().executionEnvelope(...args);
+}
+function supervisedRunBaseEnvelope(...args) {
+  return executionCommand().supervisedRunBaseEnvelope(...args);
+}
+function terminalSupervisedRunEnvelope(...args) {
+  return executionCommand().terminalSupervisedRunEnvelope(...args);
+}
+function completeSupervisedRunEnvelope(...args) {
+  return executionCommand().completeSupervisedRunEnvelope(...args);
+}
+function writeExecutionEnvelope(...args) {
+  return executionCommand().writeExecutionEnvelope(...args);
+}
+function writeExecutionPayload(...args) {
+  return executionCommand().writeExecutionPayload(...args);
+}
+function writeRunningThenCompleteExecution(...args) {
+  return executionCommand().writeRunningThenCompleteExecution(...args);
+}
+function safetyFlag(...args) {
+  return executionCommand().safetyFlag(...args);
+}
+function runExecute(...args) {
+  return executionCommand().runExecute(...args);
+}
+function executionsAuditEnvelope(...args) {
+  return executionCommand().executionsAuditEnvelope(...args);
+}
+function runExecutions(...args) {
+  return executionCommand().runExecutions(...args);
+}
+function runActions(...args) {
+  return executionCommand().runActions(...args);
+}
+function policyAuditEnvelope(...args) {
+  return executionCommand().policyAuditEnvelope(...args);
+}
+function runPolicies(...args) {
+  return executionCommand().runPolicies(...args);
+}
+
+let runtimeLeaseCommand;
+function leaseCommand() {
+  if (!runtimeLeaseCommand) throw new Error('runtime lease command is not initialized');
+  return runtimeLeaseCommand;
+}
+function listSchedulerLeaseFiles(...args) {
+  return leaseCommand().listSchedulerLeaseFiles(...args);
+}
+function schedulerLeasePath(...args) {
+  return leaseCommand().schedulerLeasePath(...args);
+}
+function leaseSummaryFromLock(...args) {
+  return leaseCommand().leaseSummaryFromLock(...args);
+}
+function leaseSummaryFromExecution(...args) {
+  return leaseCommand().leaseSummaryFromExecution(...args);
+}
+function leaseAuditEnvelope(...args) {
+  return leaseCommand().leaseAuditEnvelope(...args);
+}
+function validateLeaseItem(...args) {
+  return leaseCommand().validateLeaseItem(...args);
+}
+function activeSchedulerLease(...args) {
+  return leaseCommand().activeSchedulerLease(...args);
+}
+function writeSchedulerLease(...args) {
+  return leaseCommand().writeSchedulerLease(...args);
+}
+function completeSchedulerLease(...args) {
+  return leaseCommand().completeSchedulerLease(...args);
+}
+function runLeases(...args) {
+  return leaseCommand().runLeases(...args);
+}
+
+let runtimeQueueCommand;
+function queueCommand() {
+  if (!runtimeQueueCommand) throw new Error('runtime queue command is not initialized');
+  return runtimeQueueCommand;
+}
+function listQueueFiles(...args) {
+  return queueCommand().listQueueFiles(...args);
+}
+function queueSnapshotPath(...args) {
+  return queueCommand().queueSnapshotPath(...args);
+}
+function queueScanEnvelope(...args) {
+  return queueCommand().queueScanEnvelope(...args);
+}
+function validateQueueArtifact(...args) {
+  return queueCommand().validateQueueArtifact(...args);
+}
+function writeQueueSnapshot(...args) {
+  return queueCommand().writeQueueSnapshot(...args);
+}
+function queueAuditEnvelope(...args) {
+  return queueCommand().queueAuditEnvelope(...args);
+}
+function categorizeQueueBlockedItem(...args) {
+  return queueCommand().categorizeQueueBlockedItem(...args);
+}
+function runQueue(...args) {
+  return queueCommand().runQueue(...args);
+}
+
+let runtimeRecoveryCommand;
+let runtimeRetryCommand;
+let runtimeObservabilityCommand;
+function recoveryCommand() {
+  if (!runtimeRecoveryCommand) throw new Error('runtime recovery command is not initialized');
+  return runtimeRecoveryCommand;
+}
+function listRecoveryClassificationFiles(...args) {
+  return recoveryCommand().listRecoveryClassificationFiles(...args);
+}
+function listRecoveryRunFiles(...args) {
+  return recoveryCommand().listRecoveryRunFiles(...args);
+}
+function recoveryPackagePath(...args) {
+  return recoveryCommand().recoveryPackagePath(...args);
+}
+function recoveryEnvelope(...args) {
+  return recoveryCommand().recoveryEnvelope(...args);
+}
+function validateRecoveryArtifact(...args) {
+  return recoveryCommand().validateRecoveryArtifact(...args);
+}
+function writeRecoveryPackage(...args) {
+  return recoveryCommand().writeRecoveryPackage(...args);
+}
+function recoveryClassificationPath(...args) {
+  return recoveryCommand().recoveryClassificationPath(...args);
+}
+function recoveryRunPath(...args) {
+  return recoveryCommand().recoveryRunPath(...args);
+}
+function recoveryPolicySnapshot(...args) {
+  return recoveryCommand().recoveryPolicySnapshot(...args);
+}
+function recoveryActionCatalogSnapshot(...args) {
+  return recoveryCommand().recoveryActionCatalogSnapshot(...args);
+}
+function recoverySafety(...args) {
+  return recoveryCommand().recoverySafety(...args);
+}
+function recoveryFinding(...args) {
+  return recoveryCommand().recoveryFinding(...args);
+}
+function sourcePathForRecoveryFinding(...args) {
+  return recoveryCommand().sourcePathForRecoveryFinding(...args);
+}
+function schedulerLeaseFindings(...args) {
+  return recoveryCommand().schedulerLeaseFindings(...args);
+}
+function recoveryClassificationEnvelope(...args) {
+  return recoveryCommand().recoveryClassificationEnvelope(...args);
+}
+function validateRecoveryPolicySnapshot(...args) {
+  return recoveryCommand().validateRecoveryPolicySnapshot(...args);
+}
+function validateRecoveryActionCatalogSnapshot(...args) {
+  return recoveryCommand().validateRecoveryActionCatalogSnapshot(...args);
+}
+function validateRecoveryClassificationArtifact(...args) {
+  return recoveryCommand().validateRecoveryClassificationArtifact(...args);
+}
+function writeRecoveryClassification(...args) {
+  return recoveryCommand().writeRecoveryClassification(...args);
+}
+function recoveryClassificationAuditEnvelope(...args) {
+  return recoveryCommand().recoveryClassificationAuditEnvelope(...args);
+}
+function selectRecoveryFinding(...args) {
+  return recoveryCommand().selectRecoveryFinding(...args);
+}
+function recoveryRunAlreadyApplied(...args) {
+  return recoveryCommand().recoveryRunAlreadyApplied(...args);
+}
+function recoveryApplyEnvelopeFromClassification(...args) {
+  return recoveryCommand().recoveryApplyEnvelopeFromClassification(...args);
+}
+function recoveryApplyEnvelope(...args) {
+  return recoveryCommand().recoveryApplyEnvelope(...args);
+}
+function writeRecoveryApply(...args) {
+  return recoveryCommand().writeRecoveryApply(...args);
+}
+function printRecoveryClassification(...args) {
+  return recoveryCommand().printRecoveryClassification(...args);
+}
+function printRecoveryClassificationAudit(...args) {
+  return recoveryCommand().printRecoveryClassificationAudit(...args);
+}
+function printRecoveryApply(...args) {
+  return recoveryCommand().printRecoveryApply(...args);
+}
+function printRecovery(...args) {
+  return recoveryCommand().printRecovery(...args);
+}
+function recoveryAuditEnvelope(...args) {
+  return recoveryCommand().recoveryAuditEnvelope(...args);
+}
+function printRecoveryAudit(...args) {
+  return recoveryCommand().printRecoveryAudit(...args);
+}
+function runRecovery(...args) {
+  return recoveryCommand().runRecovery(...args);
+}
+
+function retryCommand() {
+  if (!runtimeRetryCommand) throw new Error('runtime retry command is not initialized');
+  return runtimeRetryCommand;
+}
+function listRetryPackageFiles(...args) {
+  return retryCommand().listRetryPackageFiles(...args);
+}
+function listRetryRunFiles(...args) {
+  return retryCommand().listRetryRunFiles(...args);
+}
+function retryHealthSummary(...args) {
+  return retryCommand().retryHealthSummary(...args);
+}
+function retryPolicySnapshot(...args) {
+  return retryCommand().retryPolicySnapshot(...args);
+}
+function retryBudgetSnapshot(...args) {
+  return retryCommand().retryBudgetSnapshot(...args);
+}
+function retryRunPath(...args) {
+  return retryCommand().retryRunPath(...args);
+}
+function retryRunAlreadyApplied(...args) {
+  return retryCommand().retryRunAlreadyApplied(...args);
+}
+function validateRetryPackageArtifact(...args) {
+  return retryCommand().validateRetryPackageArtifact(...args);
+}
+function retryGateEnvelope(...args) {
+  return retryCommand().retryGateEnvelope(...args);
+}
+function writeRetryRun(...args) {
+  return retryCommand().writeRetryRun(...args);
+}
+function retryPackageAuditEnvelope(...args) {
+  return retryCommand().retryPackageAuditEnvelope(...args);
+}
+function printRetry(...args) {
+  return retryCommand().printRetry(...args);
+}
+function printRetryPackageAudit(...args) {
+  return retryCommand().printRetryPackageAudit(...args);
+}
+function runRetry(...args) {
+  return retryCommand().runRetry(...args);
+}
+
+function observabilityCommand() {
+  if (!runtimeObservabilityCommand) throw new Error('runtime observability command is not initialized');
+  return runtimeObservabilityCommand;
+}
+function readinessEnvelope(...args) {
+  return observabilityCommand().readinessEnvelope(...args);
+}
+function loopHealthSummary(...args) {
+  return observabilityCommand().loopHealthSummary(...args);
+}
+function replyHealthSummary(...args) {
+  return observabilityCommand().replyHealthSummary(...args);
+}
+function traceHealthSummary(...args) {
+  return observabilityCommand().traceHealthSummary(...args);
+}
+function validateObservabilityArtifact(...args) {
+  return observabilityCommand().validateObservabilityArtifact(...args);
+}
+function writeObservabilitySnapshot(...args) {
+  return observabilityCommand().writeObservabilitySnapshot(...args);
+}
+function printObservability(...args) {
+  return observabilityCommand().printObservability(...args);
+}
+function runObservability(...args) {
+  return observabilityCommand().runObservability(...args);
+}
+
+let runtimeGovernanceCommand;
+function governanceCommand() {
+  if (!runtimeGovernanceCommand) throw new Error('runtime governance command is not initialized');
+  return runtimeGovernanceCommand;
+}
+function listGovernanceFiles(...args) {
+  return governanceCommand().listGovernanceFiles(...args);
+}
+function governanceEnvelope(...args) {
+  return governanceCommand().governanceEnvelope(...args);
+}
+function validateGovernanceArtifact(...args) {
+  return governanceCommand().validateGovernanceArtifact(...args);
+}
+function governanceConvergenceEnvelope(...args) {
+  return governanceCommand().governanceConvergenceEnvelope(...args);
+}
+function runtimeSurfaceEnvelope(...args) {
+  return governanceCommand().runtimeSurfaceEnvelope(...args);
+}
+// Stage 81 contract marker: governance --advice is read-only.
+function governanceAdviceEnvelope(...args) {
+  return governanceCommand().governanceAdviceEnvelope(...args);
+}
+function localDirectoryWithinRoot(...args) {
+  return governanceCommand().localDirectoryWithinRoot(...args);
+}
+function sourceDescriptor(...args) {
+  return governanceCommand().sourceDescriptor(...args);
+}
+function runGovernance(...args) {
+  return governanceCommand().runGovernance(...args);
+}
+
+function listStateFiles(root, directory, extension) {
+  const resolved = directory(root);
+  if (!fs.existsSync(resolved)) return [];
+  return fs.readdirSync(resolved, { withFileTypes: true })
+    .filter((entry) => entry.isFile())
+    .map((entry) => entry.name)
+    .filter((name) => name.endsWith(extension))
+    .sort();
+}
+
+function latestStateFile(root, directory, extension) {
+  const files = listStateFiles(root, directory, extension);
+  return files.length > 0 ? files[files.length - 1] : '';
+}
+
+
+const runtimeWorkflowStateHelpers = createRuntimeWorkflowStateHelpers({
+  fs,
+  path,
+  process,
+  ensureRoot,
+  workflowPath,
+  readWorkflow,
+  writeWorkflow,
+  writeJsonEnvelope,
+  artifactFileNames,
+  taskArtifactFileNames,
+  stateDirectoryName,
+  taskArtifactsDirectoryName,
+  allowedStatuses,
+  allowedTaskStatuses,
+  allowedReviewStatuses,
+  taskIdRequirement,
+  validateTaskId,
+});
+const {
+  asList,
+  validateState,
+  normalizeTasks,
+  workflowSummary,
+  tasksFromState,
+  jsonTaskSummaries,
+  scalarValue,
+  collectList,
+  readinessCounts,
+  taskSummaryStatus,
+  taskReadinessDetails,
+  taskReadinessSummaryLine,
+  taskReadinessMap,
+  reviewSummaryStatus,
+  reviewSummaryLine,
+  parseHandoffFile,
+  runStatus,
+  runValidateHandoff,
+  runRecordHandoff,
+  printWorkflow,
+  handoffQuality,
+  printHandoffQuality,
+  nextAdvice,
+  markdownList,
+  generateArtifacts,
+  generateTaskArtifacts,
+  filterTaskArtifacts,
+} = runtimeWorkflowStateHelpers;
+
+const runtimeHooksCommand = createRuntimeHooksCommand({
+  jsonSchemaVersion,
+  stateDirectoryName,
+  workflowFileName,
+  hookRunsDirectoryName,
+  hookHeartbeatsDirectoryName,
+  ensureRoot,
+  stateDirectory,
+  workflowPath,
+  fileDigest,
+  digestObject,
+  validateCommonArtifactSafety,
+  writeStateArtifact,
+  writeJsonEnvelope,
+  printList,
+  readJsonArtifact,
+  listStateFiles,
+  hookIntentsDirectory,
+  hookRunsDirectory,
+  hookHeartbeatsDirectory,
+  hookIntentFilePath,
+  hookRunFilePath,
+  hookHeartbeatFilePath,
+});
+const {
+  runHooks,
+  listHookRunFiles,
+  validateHookIntentArtifact,
+  validateHookRunArtifact,
+} = runtimeHooksCommand;
+
+const runtimePlatformCommand = createRuntimePlatformCommand({
+  jsonSchemaVersion,
+  stateDirectoryName,
+  platformSessionApprovalsDirectoryName,
+  platformSessionsDirectoryName,
+  platformSessionLeasesDirectoryName,
+  platformSessionResultsDirectoryName,
+  platformSessionIntakeDirectoryName,
+  platformSessionReviewsDirectoryName,
+  ensureRoot,
+  stateDirectory,
+  workflowPath,
+  fileDigest,
+  digestObject,
+  writeStateArtifact,
+  writeJsonEnvelope,
+  printList,
+  readJsonArtifact,
+  listStateFiles,
+  platformCapabilitiesDirectory,
+  platformSessionApprovalsDirectory,
+  platformSessionsDirectory,
+  platformSessionLeasesDirectory,
+  platformSessionResultsDirectory,
+  platformSessionCancellationsDirectory,
+  platformSessionIntakeDirectory,
+  platformSessionReviewsDirectory,
+  platformCapabilityFilePath,
+  platformSessionApprovalFilePath,
+  platformSessionFilePath,
+  platformSessionLeaseFilePath,
+  platformSessionResultFilePath,
+  platformSessionCancellationFilePath,
+  platformSessionIntakeFilePath,
+  platformSessionReviewFilePath,
+  subagentDispatchFilePath,
+  validateSubagentDispatchArtifact: (...args) => validateSubagentDispatchArtifact(...args),
+});
+const {
+  platformCapabilityCatalog,
+  validatePlatformCapabilityArtifact,
+  runPlatforms,
+  platformSessionApprovalSnapshotPath,
+  listPlatformSessionApprovalFiles,
+  platformSessionApprovalEnvelope,
+  validatePlatformSessionApprovalArtifact,
+  writePlatformSessionApproval,
+  printPlatformSessionApproval,
+  printPlatformSession,
+  printPlatformSessionCancel,
+  listPlatformSessionFiles,
+  listPlatformSessionLeaseFiles,
+  listPlatformSessionResultFiles,
+  listPlatformSessionCancellationFiles,
+  platformSessionEnvelope,
+  validatePlatformSessionArtifact,
+  writePlatformSession,
+  platformSessionCancelEnvelope,
+  validatePlatformSessionCancelArtifact,
+  writePlatformSessionCancel,
+  platformSessionIntakeSnapshotPath,
+  platformSessionReviewSnapshotPath,
+  listPlatformSessionIntakeFiles,
+  listPlatformSessionReviewFiles,
+  platformSessionResultIntakeEnvelope,
+  validatePlatformSessionIntakeArtifact,
+  writePlatformSessionIntake,
+  platformSessionReviewEnvelope,
+  validatePlatformSessionReviewArtifact,
+  writePlatformSessionReview,
+  printPlatformSessionResultReview,
+} = runtimePlatformCommand;
+
+
+const runtimeSubagentsCommand = createRuntimeSubagentsCommand({
+  jsonSchemaVersion,
+  stateDirectoryName,
+  subagentEligibilityDirectoryName,
+  subagentDispatchesDirectoryName,
+  subagentAdapterDispatchesDirectoryName,
+  schedulerRunsDirectoryName,
+  subagentRunLeasesDirectoryName,
+  subagentRunResultsDirectoryName,
+  subagentResultsDirectoryName,
+  subagentReviewsDirectoryName,
+  ensureRoot,
+  workflowPath,
+  readWorkflow,
+  validateState,
+  tasksFromState,
+  asList,
+  validateTaskId,
+  fileDigest,
+  digestObject,
+  validateCommonArtifactSafety,
+  readJsonArtifact,
+  writeStateArtifact,
+  writeJsonEnvelope,
+  listStateFiles,
+  printList,
+  subagentEligibilityDirectory,
+  subagentDispatchesDirectory,
+  subagentAdapterDispatchesDirectory,
+  schedulerRunsDirectory,
+  subagentRunLeasesDirectory,
+  subagentRunResultsDirectory,
+  subagentResultsDirectory,
+  subagentReviewsDirectory,
+  subagentEligibilityFilePath,
+  subagentDispatchFilePath,
+  subagentAdapterDispatchFilePath,
+  subagentRunLeaseFilePath,
+  subagentRunResultFilePath,
+  subagentResultFilePath,
+  subagentReviewFilePath,
+  schedulerHookPlanFilePath,
+  validateSchedulerHookPlanArtifact,
+  safeStateArtifactFilePath,
+  orchestratorDispatchPlanFilePath,
+  validateOrchestratorArtifact: (...args) => validateOrchestratorArtifact(...args),
+  platformCapabilityFilePath,
+  validatePlatformCapabilityArtifact,
+  getPlatformCommand: () => runtimePlatformCommand,
+});
+const {
+  subagentEligibilityGateIds,
+  subagentEligibilityRequiredEvidence,
+  orchestratorDispatchTargetForTask,
+  subagentEligibilityBridgeGateResults,
+  listSubagentDispatchFiles,
+  listSubagentResultFiles,
+  listSubagentReviewFiles,
+  validateSubagentDispatchArtifact,
+  validateSubagentSingleShotRunArtifact,
+  validateSubagentResultArtifact,
+  validateSubagentReviewArtifact,
+  runSubagents,
+} = runtimeSubagentsCommand;
+
+const runtimeSddLoopCommand = createRuntimeSddLoopCommand({
+  ensureRoot,
+  writeJsonEnvelope,
+  spawnSync,
+});
+const { runSdd } = runtimeSddLoopCommand;
+
+const runtimeWorkspaceCommand = createRuntimeWorkspaceCommand({
+  ensureRoot,
+  writeJsonEnvelope,
+});
+const { runWorkspace } = runtimeWorkspaceCommand;
+
+const {
+  runtimePolicyCatalogSnapshot,
+  runtimePolicyCatalogDigest,
+  validateRuntimePolicyCatalogDigest,
+  validateRuntimePolicyCatalog,
+} = createRuntimePolicyCatalog({
+  digestObject,
+  plannerAllowedWorkflows: plannerAllowedWorkflowsForPolicy,
+  platformCapabilityCatalog,
+  evalCatalogDefinition: (...args) => evalCatalogDefinition(...args),
+});
+
+const runtimeControlPlane = createRuntimeControlPlaneCommands({
+  jsonSchemaVersion,
+  stateDirectoryName,
+  plannerRoutesDirectoryName,
+  plannerPlansDirectoryName,
+  plannerBriefsDirectoryName,
+  routerPlansDirectoryName,
+  routerApprovalsDirectoryName,
+  orchestratorPlansDirectoryName,
+  orchestratorDispatchPlansDirectoryName,
+  evalSuitesDirectoryName,
+  evalRunsDirectoryName,
+  evalReportsDirectoryName,
+  releaseGatesDirectoryName,
+  releaseNotesDirectoryName,
+  feedbackLedgersDirectoryName,
+  hookIntentsDirectoryName,
+  runtimeTracesDirectoryName,
+  governanceDirectoryName,
+  methodologyGatesDirectoryName,
+  orchestratorDispatchTargetForTask,
+  subagentEligibilityBridgeGateResults,
+  subagentEligibilityGateIds,
+  subagentEligibilityRequiredEvidence,
+  ensureRoot,
+  localJsonFileWithinRoot,
+  stateDirectory,
+  workflowPath,
+  readWorkflow,
+  workflowSummary,
+  listStateFiles,
+  latestStateFile,
+  fileDigest, readJsonArtifact,
+  digestObject,
+  validateCommonArtifactSafety,
+  runtimeTraceGroup,
+  validateRuntimePolicyCatalogDigest,
+  runtimePolicyCatalogDigest,
+  platformCapabilityCatalog, governanceConvergenceEnvelope, workflowLoopContractEnvelope: (...args) => workflowLoopContractEnvelope(...args), runtimeAutomationReadinessCommandEnvelope, runtimeCapabilityRegistry, runtimePlanActionManifest, runtimePlanActionManifestDigestPayload, digestPlanActionManifest, runtimeExecutablePlanContract, runtimeExecutablePlanContractDigestPayload, digestExecutablePlanContract, runtimeSelfTestGateProfile, runtimeSelfTestGateProfileDigestPayload, digestSelfTestGateProfile, runtimeCommitReadinessEnvelope, runtimeCommitReadinessDigestPayload, digestCommitReadiness, runtimeStagedCommitReadiness, runtimeStagedCommitReadinessDigestPayload, digestStagedCommitReadiness, runtimeEvidenceIntakeEnvelope, runtimeEvidenceIntakeDigestPayload, digestEvidenceIntake, runtimeExecutionEvidenceBinder, runtimeExecutionEvidenceDigestPayload, digestExecutionEvidenceBinding, runtimeTddTraceContract, runtimeTddTraceDigestPayload, digestTddTraceContract, buildVerificationDrivenRepairLoopPlan, printVerificationDrivenRepairLoopPlan, runtimeReviewIntakeEnvelope, runtimeReviewIntakeDigestPayload, runtimeReviewResolutionEnvelope, runtimeReviewResolutionDigestPayload, digestReviewEnvelope, runtimeDiffCoverageEnvelope, runtimeDiffCoverageDigestPayload, digestDiffCoverage,
+  validateHookIntentArtifact,
+  hookIntentFilePath,
+  plannerRouteFilePath,
+  plannerPlanFilePath,
+  plannerBriefsFilePath,
+  routerPlanFilePath,
+  routerApprovalFilePath,
+  orchestratorPlanFilePath,
+  orchestratorDispatchPlanFilePath,
+  evalSuiteFilePath,
+  evalRunFilePath,
+  evalReportFilePath,
+  releaseGateFilePath,
+  releaseNotesFilePath,
+  feedbackLedgerFilePath, plannerRouteSnapshotPath, plannerPlanSnapshotPath, plannerBriefsSnapshotPath, routerPlanSnapshotPath, routerApprovalSnapshotPath, orchestratorPlanSnapshotPath, orchestratorDispatchPlanSnapshotPath, evalSuiteSnapshotPath, evalRunSnapshotPath, evalReportSnapshotPath, releaseGateSnapshotPath, releaseNotesSnapshotPath, feedbackLedgerSnapshotPath,
+  plannerRoutesDirectory,
+  plannerPlansDirectory,
+  plannerBriefsDirectory,
+  routerPlansDirectory,
+  routerApprovalsDirectory,
+  orchestratorPlansDirectory,
+  orchestratorDispatchPlansDirectory,
+  evalSuitesDirectory,
+  evalRunsDirectory,
+  evalReportsDirectory,
+  releaseGatesDirectory,
+  releaseNotesDirectory,
+  feedbackLedgersDirectory,
+  runtimeTracesDirectory,
+  governanceDirectory,
+  methodologyGatesDirectory,
+  writeStateArtifact,
+  writeJsonEnvelope,
+  printList,
+  runtimeBehavioralEvaluationContract,
+  runtimeSuperpowersStyleEvalPack,
+  runtimeSuperpowersStyleEvalPackDigestPayload,
+  digestSuperpowersStyleEvalPack,
+});
+const {
+  runPlanner,
+  runRouter,
+  runOrchestrator,
+  runVerification,
+  runReview,
+  runRelease,
+  releaseCommandDeps,
+  runFeedback,
+  runEvals, plannerAllowedWorkflows, evalCatalogDefinition, localTextEvidenceDescriptor, planLintEnvelope, planActionManifestEnvelope, selfTestGateProfileEnvelope, commitReadinessEnvelope, evidenceIntakeEnvelope, diffCoverageEnvelope, reviewIntakeEnvelope, tddTraceEnvelope, validateReleaseGateArtifact,
+  validatePlannerArtifact,
+  validateRouterArtifact,
+  validateOrchestratorArtifact,
+  validateEvalArtifact,
+  validateFeedbackLedgerArtifact,
+} = runtimeControlPlane;
+function currentGitHead(root) {
+  const headPath = path.join(root, '.git', 'HEAD');
+  if (!fs.existsSync(headPath)) return 'no-git-head';
+  const head = fs.readFileSync(headPath, 'utf8').trim();
+  if (!head.startsWith('ref: ')) return head || 'empty-git-head';
+  const refPath = path.join(root, '.git', head.slice(5).trim());
+  if (!fs.existsSync(refPath)) return head;
+  return fs.readFileSync(refPath, 'utf8').trim() || head;
+}
+
+function parseIsoTimestamp(value) {
+  if (typeof value !== 'string' || value.trim() === '') return NaN;
+  const time = Date.parse(value);
+  return Number.isNaN(time) ? NaN : time;
+}
+
+function taskDirectory(root, taskId) {
+  validateTaskId(taskId);
+  return path.join(taskArtifactsDirectory(root), taskId);
+}
+
+function taskArtifactPath(root, taskId, fileName) {
+  return path.join(taskDirectory(root, taskId), fileName);
+}
+
+function readWorkflow(root) {
+  const file = workflowPath(root);
+  if (!fs.existsSync(file)) return null;
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+function writeWorkflow(root, state) {
+  const directory = stateDirectory(root);
+  fs.mkdirSync(directory, { recursive: true });
+  fs.writeFileSync(workflowPath(root), `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+}
+
+function writeJsonEnvelope(command, payload) {
+  console.log(JSON.stringify({ schema_version: jsonSchemaVersion, command, ...payload }, null, 2));
+}
+
+function hasActualStopCondition(value) {
+  const stopCondition = String(value || '').trim();
+  return stopCondition !== '' && stopCondition.toLowerCase() !== 'none';
+}
+
+function validateCommonArtifactSafety(safety, expectedStage) {
+  const failures = [];
+  if (safety?.stage !== expectedStage) failures.push(`safety.stage must be ${expectedStage}`);
+  for (const key of ['runtime_action', 'auto_execution', 'platform_api', 'skill_execution', 'business_source_write', 'subagent', 'mcp', 'daemon', 'git', 'worktree', 'dispatch_event_modified', 'claim_modified']) {
+    if (safety?.[key] !== false) failures.push(`safety.${key} must be false`);
+  }
+  return failures;
+}
+
+function listSchedulerPlanFiles(root) {
+  const directory = schedulerPlansDirectory(root);
+  if (!fs.existsSync(directory)) return [];
+  return fs.readdirSync(directory, { withFileTypes: true })
+    .filter((entry) => entry.isFile())
+    .map((entry) => entry.name)
+    .filter((name) => name.endsWith('.scheduler-plan.json'))
+    .sort();
+}
+
+function listSchedulerHookPlanFiles(root) {
+  return listStateFiles(root, schedulerHookPlansDirectory, '.scheduler-hook-plan.json');
+}
+
+function listDaemonLoopFiles(root) {
+  return listStateFiles(root, daemonLoopsDirectory, '.daemon-loop.json');
+}
+
+function listReplyDraftFiles(root) {
+  return listStateFiles(root, replyDraftsDirectory, '.reply-draft.json');
+}
+
+function listReplyReviewFiles(root) {
+  return listStateFiles(root, replyReviewsDirectory, '.reply-review.json');
+}
+
+function listReplyApprovalFiles(root) {
+  return listStateFiles(root, replyApprovalsDirectory, '.reply-approval.json');
+}
+
+function listReplyOutboxFiles(root) {
+  return listStateFiles(root, replyOutboxDirectory, '.reply-outbox.json');
+}
+
+function listReplySendRunFiles(root) {
+  return listStateFiles(root, replySendRunsDirectory, '.reply-send-run.json');
+}
+
+let runtimeTraceCommand;
+function traceCommand() {
+  if (!runtimeTraceCommand) throw new Error('runtime trace command is not initialized');
+  return runtimeTraceCommand;
+}
+function runtimeTraceSnapshotPath(...args) {
+  return traceCommand().runtimeTraceSnapshotPath(...args);
+}
+function runtimeTraceGroups(...args) {
+  return traceCommand().runtimeTraceGroups(...args);
+}
+function runtimeTraceGroup(...args) {
+  return traceCommand().runtimeTraceGroup(...args);
+}
+function runtimeTraceReferences(...args) {
+  return traceCommand().runtimeTraceReferences(...args);
+}
+function runtimeTraceEnvelope(...args) {
+  return traceCommand().runtimeTraceEnvelope(...args);
+}
+function validateRuntimeTraceArtifact(...args) {
+  return traceCommand().validateRuntimeTraceArtifact(...args);
+}
+function writeRuntimeTrace(...args) {
+  return traceCommand().writeRuntimeTrace(...args);
+}
+function runtimeTraceAuditEnvelope(...args) {
+  return traceCommand().runtimeTraceAuditEnvelope(...args);
+}
+function printRuntimeTrace(...args) {
+  return traceCommand().printRuntimeTrace(...args);
+}
+function runTraces(...args) {
+  return traceCommand().runTraces(...args);
+}
+
+function observabilitySnapshotPath(root) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  return path.join(observabilityDirectory(root), `${timestamp}.observability.json`);
+}
+
+function runtimeAutomationReadinessEnvelope(root) {
+  return runtimeAutomationReadinessCommandEnvelope(root, { digestObject });
+}
+
+function confirmedOneShotPlanEnvelope(root, planFile, { intent = 'implementation', subject = '', confirmPlan = '' } = {}) {
+  return confirmedOneShotPlanCommandEnvelope(root, planFile, { intent, subject, confirmPlan }, { commitReadinessEnvelope, digestObject });
+}
+
+function runAutomation(options) {
+  return runAutomationCommand(options, {
+    writeJsonEnvelope,
+    localTextEvidenceDescriptor,
+    commitReadinessEnvelope,
+    workflowStartEnvelope,
+    tokenSaviorBudgetEnvelope,
+    learningAdviceEnvelope,
+    digestObject,
+  });
+}
+
+function nextActionConsoleEnvelope(root, { frictionFile = '', runbookFile = '', evidenceFile = '' } = {}) {
+  ensureRoot(root);
+  const frictionInput = localJsonFileWithinRoot(root, frictionFile, 'workflow --next-action-console --from-friction');
+  const runbookInput = runbookFile ? localJsonFileWithinRoot(root, runbookFile, 'workflow --next-action-console --from-runbook') : null;
+  const evidenceInput = evidenceFile ? localJsonFileWithinRoot(root, evidenceFile, 'workflow --next-action-console --from-evidence') : null;
+  const base = runtimeNextActionConsole({
+    friction: frictionInput.data,
+    runbook: runbookInput?.data || null,
+    evidence: evidenceInput?.data || null,
+    source: {
+      friction_file: frictionInput.relative,
+      friction_digest: frictionInput.digest,
+      runbook_file: runbookInput?.relative || '',
+      runbook_digest: runbookInput?.digest || '',
+      evidence_file: evidenceInput?.relative || '',
+      evidence_digest: evidenceInput?.digest || '',
+    },
+  });
+  const console = {
+    ...base,
+    console_digest: digestNextActionConsole(runtimeNextActionConsoleDigestPayload(base)),
+  };
+  return {
+    mode: 'one-screen-next-action-console',
+    ok: console.ok,
+    state_present: fs.existsSync(stateDirectory(root)),
+    next_action_console: console,
+    safety: { stage: 'Stage 127', ...console.boundary_assertions },
+    quality: console.next_action_console_invariants.findings,
+    action: 'one-screen next action console was computed read-only from local Stage 126 friction JSON plus optional local runbook and evidence JSON. It only renders preview commands and evidence needs; no state directory, sidecar, command, check, test, workflow skill execution, runtime action, evidence write, git, commit, push, PR, merge, platform API, external network, model, MCP, subagent, worktree, or business source write occurred.',
+  };
+}
+
+function tokenSaviorBudgetEnvelope(root, { prompt = '', frictionFile = '' } = {}) {
+  ensureRoot(root);
+  if (!String(prompt || '').trim()) throw new Error('tokens --savior-budget requires --prompt <text>');
+  const frictionInput = frictionFile ? localJsonFileWithinRoot(root, frictionFile, 'tokens --savior-budget --from-friction') : null;
+  const base = runtimeTokenSaviorBudget({
+    prompt,
+    friction: frictionInput?.data || null,
+    source: {
+      friction_file: frictionInput?.relative || '',
+      friction_digest: frictionInput?.digest || '',
+    },
+  });
+  const budget = {
+    ...base,
+    budget_digest: digestTokenSaviorBudget(runtimeTokenSaviorBudgetDigestPayload(base)),
+  };
+  return {
+    mode: 'token-savior-entry-budget-contract',
+    ok: budget.ok,
+    state_present: fs.existsSync(stateDirectory(root)),
+    token_savior_budget: budget,
+    safety: { stage: 'Stage 128', ...budget.boundary_assertions },
+    quality: budget.token_savior_budget_invariants.findings,
+    action: 'token savior entry budget was computed read-only from an explicit prompt plus optional local Stage 126 friction JSON. It only recommends deterministic context budget, skill surfacing, deferrals, and command previews; no state directory, sidecar, command execution, dynamic tool execution, embeddings, remote config, model, platform API, git, commit, push, PR, merge, MCP, subagent, worktree, or business source write occurred.',
+  };
+}
+
+function printTokenSaviorBudget(envelope) {
+  const budget = envelope.token_savior_budget;
+  console.log('Vibecoding Runtime Token Savior Entry Budget');
+  console.log(`Stage: ${budget.stage}; Kind: ${budget.budget_kind}; pass=${budget.ok}`);
+  console.log(`Recommended profile: ${budget.recommended_profile}; max_context_tokens=${budget.context_budget.max_context_tokens}`);
+  console.log(`Prompt: estimated_tokens=${budget.prompt_summary.estimated_tokens}; friction_score=${budget.friction_summary.friction_score}; top_friction=${budget.friction_summary.top_friction || 'none'}`);
+  printList('Skills to surface', budget.skills_to_surface.map((item) => `${item.skill}: ${item.reason}`));
+  printList('Skills to defer', budget.skills_to_defer.map((item) => `${item.skill}: ${item.reason}`));
+  printList('Commands to surface', budget.commands_to_surface.map((item) => `${item.id}: ${item.command}`));
+  printList('Token saving reasoning', budget.token_saving_reasoning);
+  console.log('Boundary: writes=false; token_savior_budget_artifact=false; command_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; dynamic_tool_execution=false; embeddings=false; remote_config=false; shell_interception=false; command_mutation=false; git=false; git_write=false; commit=false; pr=false; push=false; merge=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; business_source_write=false');
+  console.log(`Token savior budget digest: ${budget.budget_digest}`);
+  console.log(`Action: ${envelope.action}`);
+}
+
+const {
+  sourceChangeCandidateSnapshotPath, sourceSandboxRunSnapshotPath, sourceVerificationSnapshotPath,
+  sourceChangeCandidateEnvelope, validateSourceChangeCandidateArtifact, writeSourceChangeCandidate,
+  sourceSandboxRunEnvelope, validateSourceSandboxRunArtifact, writeSourceSandboxRun,
+  sourceVerificationEnvelope, validateSourceVerificationArtifact, writeSourceVerification,
+  mergeReadinessSnapshotPath, mergeApprovalSnapshotPath, mergeApplySnapshotPath,
+  mergeReadinessEnvelope, validateMergeReadinessArtifact, writeMergeReadiness,
+  mergeApprovalEnvelope, validateMergeApprovalArtifact, writeMergeApproval,
+  mergeApplyEnvelope, validateMergeApplyArtifact, writeMergeApply,
+  sourcePatchPlanEnvelope,
+} = createRuntimeSourceMergeArtifacts({ fs, path, process, spawnSync, jsonSchemaVersion, stateDirectoryName, sourceChangeCandidatesDirectoryName, sourceSandboxRunsDirectoryName, sourceVerificationsDirectoryName, mergeReadinessDirectoryName, mergeApprovalsDirectoryName, mergeAppliesDirectoryName, ensureRoot, workflowPath, fileDigest, digestObject, currentGitHead, writeStateArtifact, readJsonArtifact, latestStateFile, platformSessionReviewFilePath, validatePlatformSessionReviewArtifact, sourceChangeCandidatesDirectory, sourceSandboxRunsDirectory, sourceVerificationsDirectory, sourceChangeCandidateFilePath, sourceSandboxRunFilePath, sourceVerificationFilePath, mergeReadinessDirectory, mergeApprovalsDirectory, mergeAppliesDirectory, mergeReadinessFilePath, mergeApprovalFilePath, mergeApplyFilePath, runtimeTracesDirectory, runtimeTraceFilePath, validateRuntimeTraceArtifact, governanceDirectory, governanceFilePath, validateGovernanceArtifact, methodologyGatesDirectory, methodologyGateFilePath: (...args) => methodologyGateFilePath(...args), validateMethodologyGateArtifact: (...args) => validateMethodologyGateArtifact(...args), createSourcePatchPlanEnvelope });
+
+const { runMerge, runSource } = createRuntimeSourceMergeEntryCommands({
+  path,
+  ensureRoot,
+  writeJsonEnvelope,
+  printSourceArtifact,
+  printMergeArtifact,
+  runtimeSourceMergeCommand: () => runtimeSourceMergeCommand,
+  sourcePatchPlanEnvelope,
+  sourceChangeCandidateSnapshotPath,
+  sourceSandboxRunSnapshotPath,
+  sourceVerificationSnapshotPath,
+  sourceChangeCandidateEnvelope,
+  sourceSandboxRunEnvelope,
+  sourceVerificationEnvelope,
+  writeSourceChangeCandidate,
+  writeSourceSandboxRun,
+  writeSourceVerification,
+  mergeReadinessSnapshotPath,
+  mergeApprovalSnapshotPath,
+  mergeApplySnapshotPath,
+  mergeReadinessEnvelope,
+  mergeApprovalEnvelope,
+  mergeApplyEnvelope,
+  writeMergeReadiness,
+  writeMergeApproval,
+  writeMergeApply,
+});
+
+const methodologyGateKinds = new Set(['spec', 'plan', 'tdd', 'debug', 'review', 'completion', 'automation']);
+
+const runtimeInteraction = createRuntimeInteractionCommands(createRuntimeInteractionCommandDeps({
+  core: {
+    jsonSchemaVersion,
+    stateDirectoryName,
+    methodologyGatesDirectoryName,
+    learningDirectoryName,
+    tokenEconomyDirectoryName,
+    methodologyGateKinds,
+    ensureRoot,
+    readJsonArtifact,
+    writeJsonEnvelope,
+    printList,
+    stableStringify: stableJson,
+  },
+  pathSafety: {
+    localJsonFileWithinRoot,
+    safeStateArtifactFilePath,
+    localTextEvidenceDescriptor,
+    localDirectoryWithinRoot,
+    sourceDescriptor,
+  },
+  state: {
+    stateDirectory,
+    workflowFileName,
+    workflowPath,
+    readWorkflow,
+    tasksFromState,
+    validateState,
+    workflowSummary,
+    asList,
+    listStateFiles,
+    fileDigest,
+    digestObject,
+    validateCommonArtifactSafety,
+    validateRuntimePolicyCatalogDigest,
+    runtimePolicyCatalogDigest,
+    writeStateArtifact,
+  },
+  artifacts: {
+    listSubagentDispatchFiles,
+    listSubagentResultFiles,
+    listSubagentReviewFiles,
+    listHookRunFiles,
+    runtimeTracesDirectory,
+    listGovernanceFiles,
+    governanceAdviceEnvelope,
+    readinessEnvelope,
+    runtimeCapabilityRegistry,
+    planLintEnvelope,
+    planActionManifestEnvelope,
+    selfTestGateProfileEnvelope,
+    commitReadinessEnvelope,
+    confirmedOneShotPlanEnvelope,
+    evidenceIntakeEnvelope,
+    diffCoverageEnvelope,
+    reviewIntakeEnvelope,
+    tddTraceEnvelope,
+  },
+  workflow: createRuntimeWorkflowCommandDeps({
+    directories: {
+      methodologyGatesDirectory,
+      learningDirectory,
+      tokenEconomyDirectory,
+    },
+    automation: {
+      runtimeAutomationReadinessCommandEnvelope,
+    },
+    dashboard: {
+      nextActionConsoleEnvelope,
+      digestCloseLoopDashboard,
+      runtimeCloseLoopDashboard,
+      runtimeCloseLoopDashboardDigestPayload,
+    },
+    aliases: {
+      digestHumanFriendlyAlias,
+      runtimeHumanFriendlyAliasDigestPayload,
+      runtimeHumanFriendlyCloseLoopAlias,
+      runtimeHumanFriendlyNextEvidenceAlias,
+    },
+    loopContract: {
+      digestWorkflowLoopContract,
+      runtimeWorkflowLoopContract,
+      runtimeWorkflowLoopContractDigestPayload,
+    },
+    entryExperience: {
+      digestProgressiveEntryUx,
+      runtimeProgressiveEntryUx,
+      runtimeProgressiveEntryUxDigestPayload,
+      digestEntryTriggerDiscipline,
+      runtimeEntryTriggerDiscipline,
+      runtimeEntryTriggerDisciplineDigestPayload,
+    },
+    nextAction: {
+      digestNextActionConsole,
+      runtimeNextActionConsole,
+      runtimeNextActionConsoleDigestPayload,
+    },
+  }),
+  learningAndTokens: createRuntimeTokensCommandDeps({
+    learningState: {
+      learningObservationFilePath,
+      learningCandidateInstinctFilePath,
+      learningPromotionFilePath,
+    },
+    tokenEconomy: {
+      tokenCompactionFilePath,
+      tokenMetricsFilePath,
+      digestTokenSaviorBudget,
+      runtimeTokenSaviorBudget,
+      runtimeTokenSaviorBudgetDigestPayload,
+    },
+    experienceLearning: {
+      digestExperienceLearningPattern,
+      runtimeExperienceLearningPattern,
+      runtimeExperienceLearningPatternDigestPayload,
+    },
+  }),
+  methodology: {
+    digestMethodologyCoverage,
+    runtimeMethodologyCoverageDigestPayload,
+    runtimeMethodologyCoverageMap,
+  },
+  completion: {
+    digestSelfTestGateProfile,
+    runtimeSelfTestGateProfile,
+    runtimeSelfTestGateProfileDigestPayload,
+    digestCommitReadiness,
+    runtimeCommitReadinessDigestPayload,
+    runtimeCommitReadinessEnvelope,
+    digestStagedCommitReadiness,
+    runtimeStagedCommitReadiness,
+    runtimeStagedCommitReadinessDigestPayload,
+    digestDiffCoverage,
+    runtimeDiffCoverageDigestPayload,
+    runtimeDiffCoverageEnvelope,
+  },
+}));
+const {
+  runCompletion,
+  completionEvidenceBundleEnvelope,
+  runBootstrap,
+  runOnboarding,
+  runAdvice,
+  runEntry,
+  runMethodology, methodologyGateFilePath, validateMethodologyGateArtifact,
+  runLearning,
+  humanFriendlyCloseLoopEnvelope,
+  humanFriendlyNextEvidenceEnvelope,
+  workflowReadinessEnvelope,
+  workflowReadinessBoundaryAssertions,
+  workflowCockpitEnvelope,
+  workflowReceiptEnvelope,
+  workflowStartEnvelope,
+  progressiveEntryUxEnvelope,
+  workflowSequenceEnvelope,
+  workflowLoopContractEnvelope, entryTriggerDisciplineEnvelope,
+  closeLoopDashboardEnvelope,
+  printHumanFriendlyAlias,
+  printNextActionConsole,
+  printWorkflowReadiness,
+  printWorkflowCockpit,
+  printWorkflowReceipt,
+  printWorkflowStart,
+  printSessionStart,
+  printSkillSelect,
+  printSessionCheckpoint,
+  printSessionHandoff,
+  printSessionResume,
+  printSessionClose,
+  printWorkflowRunPlan,
+  printEntryRuntimeSummary,
+  printProgressiveEntryUx,
+  printWorkflowSequence,
+  printWorkflowLoopContract, printEntryTriggerDiscipline,
+  printCloseLoopDashboard,
+  learningAdviceEnvelope,
+  tokenAdviceEnvelope,
+  tokenAuditEnvelope,
+  tokenCompactionEnvelope,
+  tokenMetricsEnvelope,
+  tokenProfileEnvelope,
+  tokenRewritePreviewEnvelope,
+  writeTokenCompaction,
+  writeTokenMetrics,
+} = runtimeInteraction;
+
+let runtimeSourceMergeCommand;
+function printSourceArtifact(...args) {
+  return runtimeSourceMergeCommand.printSourceArtifact(...args);
+}
+function printMergeArtifact(...args) {
+  return runtimeSourceMergeCommand.printMergeArtifact(...args);
+}
+
+let runtimeSchedulerCommand;
+function schedulerCommand() {
+  if (!runtimeSchedulerCommand) throw new Error('runtime scheduler command is not initialized');
+  return runtimeSchedulerCommand;
+}
+function schedulerPolicySnapshot(...args) {
+  return schedulerCommand().schedulerPolicySnapshot(...args);
+}
+function runtimeBudgetSnapshot(...args) {
+  return schedulerCommand().runtimeBudgetSnapshot(...args);
+}
+function validateSchedulerPolicySnapshot(...args) {
+  return schedulerCommand().validateSchedulerPolicySnapshot(...args);
+}
+function validateRuntimeBudgetSnapshot(...args) {
+  return schedulerCommand().validateRuntimeBudgetSnapshot(...args);
+}
+function schedulerSafety(...args) {
+  return schedulerCommand().schedulerSafety(...args);
+}
+function schedulerPlanSnapshotPath(...args) {
+  return schedulerCommand().schedulerPlanSnapshotPath(...args);
+}
+function schedulerHookPlanSnapshotPath(...args) {
+  return schedulerCommand().schedulerHookPlanSnapshotPath(...args);
+}
+function schedulerRunPath(...args) {
+  return schedulerCommand().schedulerRunPath(...args);
+}
+function schedulerPlanEnvelope(...args) {
+  return schedulerCommand().schedulerPlanEnvelope(...args);
+}
+function validateSchedulerPlanArtifact(...args) {
+  return schedulerCommand().validateSchedulerPlanArtifact(...args);
+}
+function writeSchedulerPlan(...args) {
+  return schedulerCommand().writeSchedulerPlan(...args);
+}
+function schedulerHookPlanEnvelope(...args) {
+  return schedulerCommand().schedulerHookPlanEnvelope(...args);
+}
+function validateSchedulerHookPlanArtifact(...args) {
+  return schedulerCommand().validateSchedulerHookPlanArtifact(...args);
+}
+function writeSchedulerHookPlan(...args) {
+  return schedulerCommand().writeSchedulerHookPlan(...args);
+}
+function schedulerHookPlanAuditEnvelope(...args) {
+  return schedulerCommand().schedulerHookPlanAuditEnvelope(...args);
+}
+function printSchedulerHookPlan(...args) {
+  return schedulerCommand().printSchedulerHookPlan(...args);
+}
+function printSchedulerHookPlanAudit(...args) {
+  return schedulerCommand().printSchedulerHookPlanAudit(...args);
+}
+function schedulerPlanAuditEnvelope(...args) {
+  return schedulerCommand().schedulerPlanAuditEnvelope(...args);
+}
+function printSchedulerPlan(...args) {
+  return schedulerCommand().printSchedulerPlan(...args);
+}
+function printSchedulerPlanAudit(...args) {
+  return schedulerCommand().printSchedulerPlanAudit(...args);
+}
+function schedulerPolicyAuditEnvelope(...args) {
+  return schedulerCommand().schedulerPolicyAuditEnvelope(...args);
+}
+function printSchedulerPolicyAudit(...args) {
+  return schedulerCommand().printSchedulerPolicyAudit(...args);
+}
+
+let runtimeDaemonCommand;
+function daemonCommand() {
+  if (!runtimeDaemonCommand) throw new Error('runtime daemon command is not initialized');
+  return runtimeDaemonCommand;
+}
+function daemonEnvelope(...args) {
+  return daemonCommand().daemonEnvelope(...args);
+}
+function daemonLoopAuditEnvelope(...args) {
+  return daemonCommand().daemonLoopAuditEnvelope(...args);
+}
+function printDaemon(...args) {
+  return daemonCommand().printDaemon(...args);
+}
+function printDaemonLoopAudit(...args) {
+  return daemonCommand().printDaemonLoopAudit(...args);
+}
+
+
+function writeSchedulerRun(...args) {
+  return schedulerCommand().writeSchedulerRun(...args);
+}
+function schedulerOncePreviewEnvelope(...args) {
+  return schedulerCommand().schedulerOncePreviewEnvelope(...args);
+}
+function schedulerOnceEnvelope(...args) {
+  return schedulerCommand().schedulerOnceEnvelope(...args);
+}
+function schedulerOnceRecoveryPreviewEnvelope(...args) {
+  return schedulerCommand().schedulerOnceRecoveryPreviewEnvelope(...args);
+}
+function schedulerOnceRecoveryEnvelope(...args) {
+  return schedulerCommand().schedulerOnceRecoveryEnvelope(...args);
+}
+function printSchedulerRecoveryOnce(...args) {
+  return schedulerCommand().printSchedulerRecoveryOnce(...args);
+}
+function printSchedulerOnce(...args) {
+  return schedulerCommand().printSchedulerOnce(...args);
+}
+function runSchedulerPolicies(...args) {
+  return schedulerCommand().runSchedulerPolicies(...args);
+}
+function runScheduler(...args) {
+  return schedulerCommand().runScheduler(...args);
+}
+
+function daemonSafety(...args) {
+  return daemonCommand().daemonSafety(...args);
+}
+
+function schedulerScanEnvelope(...args) {
+  return schedulerCommand().schedulerScanEnvelope(...args);
+}
+function printSchedulerScan(...args) {
+  return schedulerCommand().printSchedulerScan(...args);
+}
+
+function daemonStopFilePath(...args) {
+  return daemonCommand().daemonStopFilePath(...args);
+}
+function runDaemon(...args) {
+  return daemonCommand().runDaemon(...args);
+}
+
+const runtimeDispatchCommand = createRuntimeDispatchCommand({
+  jsonSchemaVersion,
+  stateDirectoryName,
+  workflowFileName,
+  dispatchesDirectoryName,
+  dispatchClaimsDirectoryName,
+  ensureRoot,
+  workflowPath,
+  dispatchesDirectory,
+  dispatchClaimsDirectory,
+  writeJsonEnvelope,
+  printList,
+  taskIdPattern,
+  taskIdRequirement,
+  windowsReservedTaskBasenames,
+  allowedTransitions,
+  adapterRuntimeBridge,
+  platformHints,
+  platformCapabilities,
+  forbiddenDispatchActions,
+  claimStaleAfterMs,
+  hasActualStopCondition,
+  tasksFromState,
+  readinessCounts,
+  reviewSummaryStatus,
+  jsonTaskSummaries,
+  parseIsoTimestamp,
+  optionalFileDigest,
+});
+const {
+  runDispatches,
+  validateDispatchActor,
+  dispatchClaimFilePath,
+  dispatchEventFilePath,
+  dispatchIntentEnvelope,
+  printDispatchIntent,
+  confirmDispatchEnvelope,
+  writeDispatchEvent,
+  printConfirmDispatch,
+  dispatchEventSummary,
+  readDispatchEventFile,
+  dispatchEventDigest,
+  claimAudit,
+  claimAuditQuality,
+  listDispatchEvents,
+  verifyDispatchEvent,
+  dispatchClaimSafety,
+  readDispatchClaimFile,
+  listDispatchClaims,
+  claimSummary,
+  validateDispatchEventOrThrow,
+} = runtimeDispatchCommand;
+
+runtimeExecutionCommand = createRuntimeExecutionCommand({
+  fs,
+  path,
+  process,
+  crypto,
+  spawnSync,
+  jsonSchemaVersion,
+  stateDirectoryName,
+  executionsDirectoryName,
+  executionCandidatesDirectoryName,
+  executionApprovalsDirectoryName,
+  autoRunLocksDirectoryName,
+  approvalLifecycleDirectoryName,
+  stage11RuntimeActionName,
+  runtimeActionCatalogStage,
+  runtimeActionCatalogVersion,
+  approvalLifecycleStage,
+  approvalLifecycleStates,
+  approvalLifecycleTerminalStates,
+  stage11ExecutionStaleAfterMs,
+  stage12CandidateStaleAfterMs,
+  stage13ApprovalStaleAfterMs,
+  stage11AllowedExecutionSkills,
+  allowedExecutionStatuses,
+  stage11TerminalStatuses,
+  forbiddenDispatchActions,
+  executionPolicy,
+  autoRunPolicyProfiles,
+  ensureRoot,
+  workflowPath,
+  readWorkflow,
+  tasksFromState,
+  readinessCounts,
+  reviewSummaryStatus,
+  hasActualStopCondition,
+  writeJsonEnvelope,
+  printList,
+  readJsonArtifact,
+  writeStateArtifact,
+  fileDigest,
+  digestObject,
+  parseIsoTimestamp,
+  validateCommonArtifactSafety,
+  runtimePolicyCatalogSnapshot,
+  runtimePolicyCatalogDigest,
+  validateRuntimePolicyCatalog,
+  executionsDirectory,
+  executionCandidatesDirectory,
+  executionApprovalsDirectory,
+  approvalLifecycleDirectory,
+  autoRunLocksDirectory,
+  candidateFilePath,
+  approvalFilePath,
+  approvalLifecycleFilePath,
+  autoRunLockFilePath,
+  dispatchEventFilePath,
+  dispatchClaimFilePath,
+  readDispatchEventFile,
+  verifyDispatchEvent,
+  validateDispatchEventOrThrow,
+  dispatchEventDigest,
+  dispatchEventSummary,
+  readDispatchClaimFile,
+  validateDispatchActor,
+  claimSummary,
+  candidateProfileBinding,
+  candidateProfileBindingFailures,
+  approvalProfileBinding,
+  approvalProfileBindingFailures,
+  controlledForegroundBinding,
+  controlledForegroundEnvelopeFailures,
+  foregroundEvidenceDigestPayload,
+  foregroundPreflightGates,
+  foregroundPreflightFailures,
+  buildExecutionEnabledPreflight,
+  buildExecutionProfilePreflightEnvelope,
+  runtimeTestRunProfiles,
+});
+
+runtimeSourceMergeCommand = createRuntimeSourceMergeCommand({
+  fs,
+  path,
+  process,
+  ensureRoot,
+  workflowPath,
+  writeJsonEnvelope,
+  printList,
+  readJsonArtifact,
+  fileDigest,
+  listStateFiles,
+  sourceChangeCandidatesDirectory,
+  sourceSandboxRunsDirectory,
+  sourceVerificationsDirectory,
+  mergeReadinessDirectory,
+  mergeApprovalsDirectory,
+  mergeAppliesDirectory,
+  sourceChangeCandidateFilePath,
+  sourceSandboxRunFilePath,
+  sourceVerificationFilePath,
+  mergeReadinessFilePath,
+  mergeApprovalFilePath,
+  mergeApplyFilePath,
+  sourceChangeCandidateEnvelope,
+  sourceVerificationEnvelope,
+  mergeReadinessEnvelope,
+  validateSourceChangeCandidateArtifact,
+  validateSourceSandboxRunArtifact,
+  validateSourceVerificationArtifact,
+  validateMergeReadinessArtifact,
+  validateMergeApprovalArtifact,
+  validateMergeApplyArtifact,
+});
+
+runtimeLeaseCommand = createRuntimeLeaseCommand({
+  fs,
+  path,
+  process,
+  crypto,
+  jsonSchemaVersion,
+  stage11ExecutionStaleAfterMs,
+  ensureRoot,
+  workflowPath,
+  writeJsonEnvelope,
+  printList,
+  readJsonArtifact,
+  fileDigest,
+  autoRunLocksDirectory,
+  executionsDirectory,
+  schedulerLeasesDirectory,
+  listExecutionFiles,
+  readExecutionFile,
+  validateExecutionEnvelope,
+  executionHistorySummary,
+  schedulerSafety,
+});
+
+runtimeQueueCommand = createRuntimeQueueCommand({
+  fs,
+  path,
+  process,
+  jsonSchemaVersion,
+  stage11RuntimeActionName,
+  stage11ExecutionStaleAfterMs,
+  stage12CandidateStaleAfterMs,
+  ensureRoot,
+  workflowPath,
+  writeJsonEnvelope,
+  printList,
+  readJsonArtifact,
+  fileDigest,
+  validateCommonArtifactSafety,
+  executionQueueDirectory,
+  executionCandidatesDirectory,
+  executionApprovalsDirectory,
+  autoRunLocksDirectory,
+  candidateFilePath,
+  autoRunLockFilePath,
+  queueFilePath,
+  validateCandidateArtifact,
+  validateApprovalArtifact,
+  approvalLifecycleCurrentState,
+  executionHistorySummary,
+  policyEvaluationEnvelope,
+  orderedProfileBinding,
+});
+
+runtimeSchedulerCommand = createRuntimeSchedulerCommand({
+  fs,
+  path,
+  process,
+  jsonSchemaVersion,
+  stateDirectoryName,
+  schedulerPlansDirectoryName,
+  schedulerHookPlansDirectoryName,
+  schedulerRunsDirectoryName,
+  schedulerLeasesDirectoryName,
+  stage11RuntimeActionName,
+  stage11AllowedExecutionSkills,
+  schedulerPolicyProfiles,
+  schedulerRuntimeBudget,
+  ensureRoot,
+  workflowPath,
+  writeJsonEnvelope,
+  printList,
+  readJsonArtifact,
+  writeStateArtifact,
+  fileDigest,
+  digestObject,
+  validateCommonArtifactSafety,
+  schedulerPlansDirectory,
+  schedulerHookPlansDirectory,
+  schedulerRunsDirectory,
+  schedulerPlanFilePath,
+  schedulerHookPlanFilePath,
+  hookIntentFilePath,
+  validateHookIntentArtifact,
+  listSchedulerPlanFiles,
+  listSchedulerHookPlanFiles,
+  queueScanEnvelope,
+  recoveryClassificationEnvelope,
+  executionPolicySnapshot,
+  runtimeActionCatalogDigest,
+  listDispatchEvents,
+  listDispatchClaims,
+  claimSummary,
+  listExecutionFiles,
+  readExecutionFile,
+  executionsDirectory,
+  executionSummary,
+  validateExecutionEnvelope,
+  dispatchesDirectory,
+  readDispatchEventFile,
+  verifyDispatchEvent,
+  daemonSafety,
+  activeSchedulerLease,
+  writeSchedulerLease,
+  completeSchedulerLease,
+  controlledAutoRunEnvelope,
+  writeRunningThenCompleteExecution,
+  recoveryPolicySnapshot,
+  recoveryActionCatalogSnapshot,
+  validateRecoveryClassificationArtifact,
+  writeRecoveryClassification,
+  selectRecoveryFinding,
+  recoveryApplyEnvelopeFromClassification,
+  writeRecoveryApply,
+});
+
+runtimeDaemonCommand = createRuntimeDaemonCommand({
+  fs,
+  path,
+  process,
+  crypto,
+  jsonSchemaVersion,
+  stateDirectoryName,
+  daemonRunsDirectoryName,
+  daemonHeartbeatsDirectoryName,
+  daemonStopDirectoryName,
+  forbiddenDispatchActions,
+  ensureRoot,
+  localJsonFileWithinRoot,
+  stateDirectory,
+  workflowPath,
+  writeJsonEnvelope,
+  writeStateArtifact,
+  printList,
+  readJsonArtifact,
+  digestObject,
+  daemonLoopsDirectory,
+  daemonHeartbeatsDirectory,
+  daemonStopDirectory,
+  daemonLoopFilePath,
+  listDaemonLoopFiles,
+  schedulerScanEnvelope,
+  printSchedulerScan,
+  schedulerOncePreviewEnvelope,
+  activeSchedulerLease,
+});
+
+runtimeRecoveryCommand = createRuntimeRecoveryCommand({
+  fs,
+  path,
+  process,
+  crypto,
+  jsonSchemaVersion,
+  stateDirectoryName,
+  recoveryRunsDirectoryName,
+  retryPackagesDirectoryName,
+  recoveryPolicy,
+  recoveryActionCatalog,
+  schedulerRuntimeBudget,
+  ensureRoot,
+  workflowPath,
+  writeJsonEnvelope,
+  printList,
+  readJsonArtifact,
+  writeStateArtifact,
+  fileDigest,
+  digestObject,
+  asList,
+  validateCommonArtifactSafety,
+  safeStateArtifactFilePath,
+  executionsDirectory,
+  recoveryPackagesDirectory,
+  recoveryClassificationsDirectory,
+  recoveryRunsDirectory,
+  retryPackagesDirectory,
+  autoRunLocksDirectory,
+  schedulerLeasesDirectory,
+  executionFilePath,
+  listExecutionFiles,
+  readExecutionFile,
+  approvalFilePath,
+  candidateFilePath,
+  autoRunLockFilePath,
+  recoveryFilePath,
+  recoveryClassificationFilePath,
+  queueScanEnvelope,
+  categorizeQueueBlockedItem,
+  leaseAuditEnvelope,
+  listSchedulerLeaseFiles,
+  activeSchedulerLease,
+  schedulerPolicySnapshot,
+  runtimeBudgetSnapshot,
+  validateSchedulerPolicySnapshot,
+  validateRuntimeBudgetSnapshot,
+});
+
+runtimeRetryCommand = createRuntimeRetryCommand({
+  fs,
+  path,
+  process,
+  jsonSchemaVersion,
+  boundedRetryPolicy,
+  boundedRetryBudget,
+  ensureRoot,
+  workflowPath,
+  writeJsonEnvelope,
+  printList,
+  readJsonArtifact,
+  writeStateArtifact,
+  listStateFiles,
+  fileDigest,
+  digestObject,
+  retryPackagesDirectory,
+  retryRunsDirectory,
+  retryPackageFilePath,
+  executionFilePath,
+  readExecutionFile,
+  approvalFilePath,
+  candidateFilePath,
+  validateApprovalArtifact,
+  validateCandidateArtifact,
+  executionPolicySnapshot,
+  runtimeActionCatalogDigest,
+  approvalLifecycleCurrentState,
+  activeSchedulerLease,
+  autoRunLockFilePath,
+});
+
+
+const runtimeReplyCommand = createRuntimeReplyCommand({
+  jsonSchemaVersion,
+  replyPolicy,
+  workflowFileName,
+  ensureRoot,
+  workflowPath,
+  readWorkflow,
+  listDispatchEvents,
+  listExecutionFiles,
+  latestStateFile,
+  fileDigest,
+  optionalFileDigest,
+  digestObject,
+  writeStateArtifact,
+  writeJsonEnvelope,
+  printList,
+  readJsonArtifact,
+  executionsDirectory,
+  schedulerRunsDirectory,
+  recoveryRunsDirectory,
+  retryRunsDirectory,
+  observabilityDirectory,
+  runtimeTracesDirectory,
+  replyDraftsDirectory,
+  replyReviewsDirectory,
+  replyApprovalsDirectory,
+  replyOutboxDirectory,
+  replySendRunsDirectory,
+  replyDraftFilePath,
+  replyReviewFilePath,
+  replyApprovalFilePath,
+  replyOutboxFilePath,
+  replySendRunFilePath,
+  listReplyDraftFiles,
+  listReplyReviewFiles,
+  listReplyApprovalFiles,
+  listReplyOutboxFiles,
+  listReplySendRunFiles,
+});
+const { validateReplyArtifact, runReply } = runtimeReplyCommand;
+
+runtimeTraceCommand = createRuntimeTraceCommand({
+  fs,
+  path,
+  process,
+  jsonSchemaVersion,
+  stateDirectoryName,
+  ensureRoot,
+  stateDirectory,
+  writeJsonEnvelope,
+  printList,
+  readJsonArtifact,
+  writeStateArtifact,
+  listStateFiles,
+  fileDigest,
+  digestObject,
+  validateCommonArtifactSafety,
+  safeStateArtifactFilePath,
+  runtimeTracesDirectory,
+  runtimeTraceFilePath,
+  schedulerPlansDirectory,
+  schedulerHookPlansDirectory,
+  schedulerRunsDirectory,
+  recoveryClassificationsDirectory,
+  recoveryRunsDirectory,
+  retryPackagesDirectory,
+  retryRunsDirectory,
+  daemonLoopsDirectory,
+  daemonHeartbeatsDirectory,
+  replyDraftsDirectory,
+  replyReviewsDirectory,
+  replyApprovalsDirectory,
+  replyOutboxDirectory,
+  replySendRunsDirectory,
+  observabilityDirectory,
+  methodologyGatesDirectory,
+  hookIntentsDirectory,
+  hookRunsDirectory,
+  hookHeartbeatsDirectory,
+  subagentDispatchesDirectory,
+  subagentRunResultsDirectory,
+  subagentResultsDirectory,
+  subagentReviewsDirectory,
+  platformCapabilitiesDirectory,
+  platformSessionApprovalsDirectory,
+  platformSessionsDirectory,
+  platformSessionLeasesDirectory,
+  platformSessionResultsDirectory,
+  platformSessionCancellationsDirectory,
+  platformSessionIntakeDirectory,
+  platformSessionReviewsDirectory,
+  sourceChangeCandidatesDirectory,
+  sourceSandboxRunsDirectory,
+  sourceVerificationsDirectory,
+  mergeReadinessDirectory,
+  mergeApprovalsDirectory,
+  mergeAppliesDirectory,
+  plannerRoutesDirectory,
+  plannerPlansDirectory,
+  plannerBriefsDirectory,
+  routerPlansDirectory,
+  routerApprovalsDirectory,
+  orchestratorPlansDirectory,
+  orchestratorDispatchPlansDirectory,
+  evalSuitesDirectory,
+  evalRunsDirectory,
+  evalReportsDirectory,
+  releaseGatesDirectory,
+  feedbackLedgersDirectory,
+  validateSubagentResultArtifact,
+  validateSubagentReviewArtifact,
+  validateHookRunArtifact,
+  validateSubagentSingleShotRunArtifact,
+  validateSubagentDispatchArtifact,
+  validatePlatformCapabilityArtifact,
+  validatePlatformSessionApprovalArtifact,
+  validatePlatformSessionArtifact,
+  validatePlatformSessionCancelArtifact,
+  validatePlatformSessionIntakeArtifact,
+  validatePlatformSessionReviewArtifact,
+  validateSourceChangeCandidateArtifact,
+  validateSourceSandboxRunArtifact,
+  validateSourceVerificationArtifact,
+  validateMergeReadinessArtifact,
+  validateMergeApprovalArtifact,
+  validateMergeApplyArtifact,
+  validatePlannerArtifact,
+  validateRouterArtifact,
+  validateOrchestratorArtifact,
+  validateEvalArtifact,
+  validateReleaseGateArtifact,
+  validateFeedbackLedgerArtifact,
+});
+
+runtimeObservabilityCommand = createRuntimeObservabilityCommand({
+  fs,
+  path,
+  process,
+  jsonSchemaVersion,
+  ensureRoot,
+  workflowPath,
+  writeJsonEnvelope,
+  printList,
+  readJsonArtifact,
+  writeStateArtifact,
+  listStateFiles,
+  fileDigest,
+  digestObject,
+  validateCommonArtifactSafety,
+  runtimeTracesDirectory,
+  observabilitySnapshotPath,
+  daemonLoopsDirectory,
+  daemonHeartbeatsDirectory,
+  daemonStopFilePath,
+  listDaemonLoopFiles,
+  listReplyDraftFiles,
+  listReplyApprovalFiles,
+  listReplyOutboxFiles,
+  listReplySendRunFiles,
+  replyDraftsDirectory,
+  replyApprovalsDirectory,
+  replyOutboxDirectory,
+  replySendRunsDirectory,
+  validateReplyArtifact,
+  runtimeTraceReferences,
+  validateRuntimeTraceArtifact,
+  queueScanEnvelope,
+  leaseAuditEnvelope,
+  recoveryEnvelope,
+  retryHealthSummary,
+});
+
+
+runtimeGovernanceCommand = createRuntimeGovernanceCommand(createRuntimeGovernanceCommandDeps({
+  core: {
+    fs,
+    path,
+    process,
+    crypto,
+    jsonSchemaVersion,
+    runtimeContractRoot,
+    stateDirectoryName,
+    ensureRoot,
+    stateDirectory,
+    writeJsonEnvelope,
+    printList,
+    stableStringify: stableJson,
+    asList,
+    localJsonFileWithinRoot,
+  },
+  state: {
+    readJsonArtifact,
+    writeStateArtifact,
+    listStateFiles,
+    latestStateFile,
+    safeStateArtifactFilePath,
+    fileDigest,
+    digestObject,
+    validateCommonArtifactSafety,
+  },
+  files: {
+    runtimeTracesDirectory,
+    observabilityDirectory,
+    governanceDirectory,
+    replyReviewsDirectory,
+    subagentDispatchesDirectory,
+    subagentResultsDirectory,
+    subagentReviewsDirectory,
+    hookRunsDirectory,
+    runtimeTraceFilePath,
+    governanceFilePath,
+    governancePrReadinessFilePath,
+    governancePrReviewIntakeFilePath,
+    governanceAnyFilePath,
+    replyReviewFilePath,
+    subagentDispatchFilePath,
+    subagentResultFilePath,
+    subagentReviewFilePath,
+    hookRunFilePath,
+    platformSessionIntakeFilePath,
+    platformSessionReviewFilePath,
+    listReplyReviewFiles,
+    listSubagentDispatchFiles,
+    listSubagentResultFiles,
+    listSubagentReviewFiles,
+    listHookRunFiles,
+  },
+  artifactValidation: {
+    validateReplyArtifact,
+    validateObservabilityArtifact,
+    validateRuntimeTraceArtifact,
+    validateSubagentDispatchArtifact,
+    validateSubagentResultArtifact,
+    validateSubagentReviewArtifact,
+    validateHookRunArtifact,
+    validatePlatformSessionIntakeArtifact,
+    validatePlatformSessionReviewArtifact,
+  },
+  catalogs: {
+    runtimeTraceGroups,
+    runtimePolicyCatalogDigest,
+    runtimePolicyCatalogSnapshot,
+    evalCatalogDefinition,
+    runtimeCapabilityRegistry,
+    runtimeCapabilityRegistryDriftGuard,
+    runtimeCapabilityRegistryInvariants,
+    runtimeAutomationReadinessMatrix,
+    runtimeSkillRuntimeTraceabilityMap,
+  },
+  experience: {
+    runtimeSuperpowersGapMatrix,
+    runtimeSuperpowersGapDigestPayload,
+    digestSuperpowersGapMatrix,
+    runtimeSuperpowersComparisonMatrix,
+    runtimeSuperpowersComparisonDigestPayload,
+    digestSuperpowersComparison,
+    runtimeSuperpowersRegressionGuard,
+    runtimeExperienceFrictionMatrix,
+    runtimeExperienceFrictionDigestPayload,
+    digestExperienceFriction,
+    runtimeExperienceRegressionDashboard,
+    runtimeExperienceRegressionDashboardDigestPayload,
+    digestExperienceRegressionDashboard,
+  },
+  commands: {
+    runExperienceUpgradePrioritizerCommand,
+    runSuperpowersParityScorecardCommand,
+    runContributorGuardrailCommand,
+    runSubagentPermissionCommand,
+  },
+}));
+
+const runtimeWorkflowLedgerCommand = createRuntimeWorkflowLedgerCommand({
+  fs,
+  path,
+  process,
+  ensureRoot,
+  readWorkflow,
+  writeJsonEnvelope,
+  validateState,
+  tasksFromState,
+  jsonTaskSummaries,
+  taskSummaryStatus,
+  taskReadinessSummaryLine,
+  reviewSummaryStatus,
+  generateArtifacts,
+  generateTaskArtifacts,
+  filterTaskArtifacts,
+  nextAdvice,
+  stateDirectory,
+  stateDirectoryName,
+  taskArtifactsDirectoryName,
+  artifactPath,
+  taskDirectory,
+  taskArtifactPath,
+  confirmDispatchEnvelope,
+  writeDispatchEvent,
+  printConfirmDispatch,
+  dispatchIntentEnvelope,
+  printDispatchIntent,
+});
+const { runArtifacts, runNext, runReset, runTasks } = runtimeWorkflowLedgerCommand;
+
+runRuntimeCli({
+  argv: process.argv.slice(2),
+  handlerDeps: createRuntimeCliHandlerDeps({
+    commands: {
+      runEntry,
+      runAdvice,
+      runStatus,
+      runValidateHandoff,
+      runRecordHandoff,
+      runNext,
+      runDispatches,
+      runExecute,
+      runExecutions,
+      runActions,
+      runApprovals,
+      runPolicies,
+      runQueue,
+      runLeases,
+      runRecovery,
+      runObservability,
+      runScheduler,
+      runSchedulerPolicies,
+      runRetry,
+      runDaemon,
+      runReply,
+      runTraces,
+      runGovernance,
+      runAutomation,
+      runMethodology,
+      runVerification,
+      runReview,
+      runCompletion,
+      runBootstrap,
+      runOnboarding,
+      runLearning,
+      runHooks,
+      runSubagents,
+      runSdd,
+      runWorkspace,
+      runPlatforms,
+      runSource,
+      runMerge,
+      runPlanner,
+      runRouter,
+      runOrchestrator,
+      runEvals,
+      runFeedback,
+      runArtifacts,
+      runTasks,
+      runReset,
+    },
+    wrappers: runtimeCommandWrapperDeps({
+      ensureRoot,
+      humanFriendlyCloseLoopEnvelope,
+      humanFriendlyNextEvidenceEnvelope,
+      nextActionConsoleEnvelope,
+      entryTriggerDisciplineEnvelope,
+      runEntryTriggerTighteningCommand,
+      runNextActionEvidencePromptsCommand,
+      closeLoopDashboardEnvelope,
+      workflowLoopContractEnvelope,
+      workflowCockpitEnvelope,
+      workflowReceiptEnvelope,
+      workflowStartEnvelope,
+      completionEvidenceBundleEnvelope,
+      digestObject,
+      tokenSaviorBudgetEnvelope,
+      learningAdviceEnvelope,
+      progressiveEntryUxEnvelope,
+      workflowSequenceEnvelope,
+      printHumanFriendlyAlias,
+      printNextActionConsole,
+      printEntryTriggerDiscipline,
+      printCloseLoopDashboard,
+      printWorkflowLoopContract,
+      printWorkflowCockpit,
+      printWorkflowReceipt,
+      printWorkflowStart,
+      printSessionStart,
+      printSkillSelect,
+      printSessionCheckpoint,
+      printSessionHandoff,
+      printSessionResume,
+      printSessionClose,
+      printWorkflowRunPlan,
+      printEntryRuntimeSummary,
+      printProgressiveEntryUx,
+      printWorkflowSequence,
+      printList,
+      printTokenSaviorBudget,
+      tokenAdviceEnvelope,
+      tokenAuditEnvelope,
+      tokenCompactionEnvelope,
+      tokenMetricsEnvelope,
+      tokenProfileEnvelope,
+      tokenRewritePreviewEnvelope,
+      tokenSaviorBudgetEnvelope,
+      writeJsonEnvelope,
+      spawnSync,
+      writeTokenCompaction,
+      writeTokenMetrics,
+      releaseCommandDeps,
+    }),
+  }),
+});