@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-verification-repair-loop-plan.mjs

@@ -0,0 +1,188 @@
+import { createPatchQueuePreviewContract } from './runtime-patch-queue-contract.mjs';
+
+const verificationFailureKinds = Object.freeze([
+  'syntax',
+  'runtime-check',
+  'architecture-check',
+  'test failure',
+  'unexpected diff',
+  'scope violation',
+]);
+
+const strictRepairBudgetDefaults = Object.freeze({
+  max_attempts: 2,
+  attempts_used: 0,
+  allowed_paths: [],
+  allowed_patch_types: ['minimal-contract-patch', 'test-fixture-patch', 'docs-contract-patch'],
+  must_reverify: true,
+});
+
+const repairLoopStopConditions = Object.freeze([
+  'retry budget exhausted',
+  'architecture warning present',
+  'architecture baseline expansion requested',
+  'check weakening requested',
+  'source apply requested outside Stage 11 patch queue',
+  'large refactor repair requested',
+]);
+
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function unique(values) {
+  return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))];
+}
+
+function evidenceChecks(input) {
+  if (Array.isArray(input?.checks)) return input.checks;
+  if (Array.isArray(input?.evidence?.checks)) return input.evidence.checks;
+  if (Array.isArray(input?.execution_evidence_binding?.evidence_items)) return input.execution_evidence_binding.evidence_items;
+  if (Array.isArray(input?.evidence_items)) return input.evidence_items;
+  return [];
+}
+
+function normalizeRepairBudget(input = {}) {
+  const raw = input.repair_budget || input.budget || {};
+  const maxAttempts = Number(raw.max_attempts ?? raw.maxAttempts ?? strictRepairBudgetDefaults.max_attempts);
+  const attemptsUsed = Number(raw.attempts_used ?? raw.attemptsUsed ?? input.attempts_used ?? 0);
+  const allowedPaths = unique(asArray(raw.allowed_paths || input.allowed_paths));
+  const patchTypes = unique(asArray(raw.allowed_patch_types || input.allowed_patch_types));
+  return {
+    max_attempts: Number.isFinite(maxAttempts) ? Math.max(0, Math.floor(maxAttempts)) : strictRepairBudgetDefaults.max_attempts,
+    attempts_used: Number.isFinite(attemptsUsed) ? Math.max(0, Math.floor(attemptsUsed)) : 0,
+    allowed_paths: allowedPaths,
+    allowed_patch_types: patchTypes.length > 0 ? patchTypes : [...strictRepairBudgetDefaults.allowed_patch_types],
+    must_reverify: raw.must_reverify !== false,
+  };
+}
+
+function classifyVerificationFailures(input) {
+  const checks = evidenceChecks(input);
+  const direct = unique(asArray(input?.failure_classifications || input?.failures));
+  const fromChecks = checks
+    .filter((check) => Number(check.exit_status ?? check.exit_code ?? 0) !== 0 || /fail|blocked|missing|stale/i.test(String(check.status || check.freshness?.status || '')))
+    .map((check) => String(check.gate_id || check.id || check.command || '').toLowerCase())
+    .map((value) => {
+      if (value.includes('syntax')) return 'syntax';
+      if (value.includes('runtime-check')) return 'runtime-check';
+      if (value.includes('architecture')) return 'architecture-check';
+      if (value.includes('diff')) return 'unexpected diff';
+      if (value.includes('scope')) return 'scope violation';
+      return 'test failure';
+    });
+  return unique([...direct, ...(checks.length === 0 && direct.length === 0 ? ['missing'] : []), ...fromChecks]);
+}
+
+function repairStopReasons(input, budget, classifications) {
+  return unique([
+    ...(budget.attempts_used >= budget.max_attempts ? ['retry budget exhausted'] : []),
+    ...(classifications.includes('architecture-check') || input.architecture_warning === true || Number(input.architecture_warning_count || 0) > 0 ? ['architecture warning present'] : []),
+    ...(input.baseline_expansion === true || input.expand_baseline === true ? ['architecture baseline expansion requested'] : []),
+    ...(input.check_weakening === true || input.weaken_checks === true ? ['check weakening requested'] : []),
+    ...(input.source_apply === true || input.direct_apply === true ? ['source apply requested outside Stage 11 patch queue'] : []),
+    ...(input.large_refactor === true || input.repair_kind === 'large-refactor' ? ['large refactor repair requested'] : []),
+  ]);
+}
+
+function repairPatchTask(input, budget, classifications) {
+  const taskId = String(input.task_id || input.id || 'verification-repair').slice(0, 120);
+  const allowedPaths = budget.allowed_paths;
+  const changedFiles = unique(asArray(input.estimated_changed_files || input.changed_files || allowedPaths).slice(0, Math.max(allowedPaths.length, 1)));
+  return {
+    parsed: {
+      id: `${taskId}-repair`,
+      allowed_paths: allowedPaths,
+      estimated_changed_files: changedFiles,
+      diff_digest: input.diff_digest || '',
+      risk_classification: classifications.includes('scope violation') ? 'high' : 'standard',
+      rollback_patch: input.rollback_patch || 'repair rollback patch required before apply\n',
+      verification_commands: unique(asArray(input.verification_commands || ['node tools/vibe-runtime-check/index.mjs --root .', 'node tools/vibe-architecture-check/index.mjs --root . --json'])),
+      patch_bytes: Number(input.patch_bytes || 1),
+      budget: { max_files: Number(input.max_files || changedFiles.length || 1), max_patch_bytes: Number(input.max_patch_bytes || 20000) },
+    },
+    summary: `${taskId}-repair`,
+  };
+}
+
+export function buildVerificationDrivenRepairLoopPlan({ input, source, statePresent = false, digestObject }) {
+  const budget = normalizeRepairBudget(input);
+  const classifications = classifyVerificationFailures(input);
+  const stopReasons = repairStopReasons(input, budget, classifications);
+  const patchQueuePreview = createPatchQueuePreviewContract({
+    task: repairPatchTask(input, budget, classifications),
+    taskFile: source?.relative || '',
+    fileDigest: source?.digest || '',
+    digestObject,
+  });
+  const canPlanPatch = stopReasons.length === 0 && classifications.length > 0 && !classifications.includes('missing');
+  const core = {
+    version: 1,
+    stage: 'Stage 12',
+    artifact_kind: 'verification-driven-repair-loop-plan',
+    source_file: source?.relative || '',
+    source_digest: source?.digest || '',
+    failure_classifications: classifications.filter((item) => verificationFailureKinds.includes(item) || item === 'missing' || item === 'stale'),
+    repair_budget: budget,
+    stop_conditions: [...repairLoopStopConditions],
+    stop_reasons: stopReasons,
+    status: stopReasons.length > 0 ? 'blocked' : canPlanPatch ? 'repair-plan-ready-for-patch-queue' : 'manual-evidence-required',
+    patch_queue_required: true,
+    direct_source_write: false,
+    direct_apply: false,
+    infinite_retry: false,
+    baseline_expansion: false,
+    check_weakening: false,
+    must_reverify: true,
+    evidence_update: {
+      status: stopReasons.length > 0 ? 'blocked' : 'planned',
+      appends_repair_attempt: canPlanPatch,
+      next_attempt_number: budget.attempts_used + 1,
+      requires_fresh_execution_evidence: true,
+      execution_evidence_binder_required: true,
+      completion_evidence_bundle_required: true,
+    },
+    allowed_followup: ['Stage 11 patch queue preview', 'fresh verification evidence intake after patch queue approval'],
+    forbidden_actions: ['freeform source mutation', 'infinite retry', 'automatic baseline expansion', 'automatic check weakening', 'large refactor repair'],
+  };
+  const repairLoopPlan = { ...core, repair_loop_digest: digestObject(core) };
+  return {
+    mode: 'verification-driven-repair-loop-plan',
+    ok: true,
+    state_present: statePresent,
+    verification_repair_loop_plan: repairLoopPlan,
+    patch_queue_preview: patchQueuePreview,
+    safety: {
+      stage: 'Stage 12',
+      writes: false,
+      repair_loop_plan_artifact: false,
+      patch_queue_preview: true,
+      source_apply: false,
+      command_execution: false,
+      test_execution: false,
+      architecture_baseline_write: false,
+      check_weakening: false,
+      git: false,
+      worktree: false,
+      daemon: false,
+      scheduler: false,
+      business_source_write: false,
+    },
+    quality: [...stopReasons, ...patchQueuePreview.items[0].blocked_reasons],
+    action: 'verification-driven repair loop plan was computed read-only from local evidence. It only emits a bounded repair plan, a Stage 11 patch queue preview item, and an evidence update requirement; it did not execute commands, mutate source, widen baselines, weaken checks, use git, or apply patches.',
+  };
+}
+
+export function printVerificationDrivenRepairLoopPlan(envelope, { printList } = {}) {
+  const plan = envelope.verification_repair_loop_plan;
+  console.log('Vibecoding Runtime Verification Repair Loop Plan');
+  console.log(`Stage: ${plan.stage}; Status: ${plan.status}`);
+  console.log(`Failures: ${plan.failure_classifications.join(', ') || 'none'}`);
+  console.log(`Budget: attempts ${plan.repair_budget.attempts_used}/${plan.repair_budget.max_attempts}; allowed_paths=${plan.repair_budget.allowed_paths.length}`);
+  console.log(`Patch queue item: ${envelope.patch_queue_preview.items[0].status}; source_apply=${envelope.safety.source_apply}`);
+  if (plan.stop_reasons.length > 0 && printList) printList('Stop reasons', plan.stop_reasons);
+  if (envelope.quality.length > 0 && printList) printList('Quality', envelope.quality);
+  console.log('Boundary: direct_source_write=false; source_apply=false; command_execution=false; architecture_baseline_write=false; check_weakening=false; git=false; worktree=false; business_source_write=false');
+  console.log(`Repair loop digest: ${plan.repair_loop_digest}`);
+  console.log(`Action: ${envelope.action}`);
+}

package/tools/vibe-runtime/runtime-workflow-alias-boundary-text.mjs

@@ -0,0 +1,7 @@
+export function workflowAliasActionTextEnvelope() {
+  return Object.freeze({
+    closeLoopDashboard: 'close-loop-dashboard was computed read-only from one local plan file, Stage 105 manifest, Stage 106 self-test gate profile, Stage 107 commit readiness, optional Stage 108 confirmed plan status, automation readiness, and registry. dashboard only, no execution: no command execution, check/test execution, repair, formatting, code generation, sidecar write, git, commit, PR, push, merge, platform API, external network, model, subagent, MCP, daemon, scheduler, retry, or business source mutation occurred.',
+    closeLoopAlias: 'workflow close-loop alias was computed read-only by composing the Stage 109 close-loop dashboard into human-friendly labels. Stage 114 did not execute commands, checks, tests, repairs, formatting, code generation, workflow actions, write evidence, write state, create sidecars, call git, commit, push, PR, merge, platform API, external network, model, MCP, subagent, daemon, scheduler, retry, or mutate business source.',
+    nextEvidenceAlias: 'workflow next-evidence alias was computed read-only by composing Stage 105 plan manifest and optional local Stage 110 evidence intake, Stage 111 diff coverage, Stage 112 review intake, and Stage 113 TDD trace envelopes into human-friendly next evidence guidance. Stage 114 did not execute commands, checks, tests, repairs, formatting, code generation, workflow actions, write evidence, write state, create sidecars, call git, commit, push, PR, merge, platform API, external network, model, MCP, subagent, daemon, scheduler, retry, or mutate business source.',
+  });
+}

package/tools/vibe-runtime/runtime-workflow-alias-interaction-command.mjs

@@ -0,0 +1,145 @@
+import { readonlyLocalStatePresent } from './runtime-readonly-local-json-output-envelope.mjs';
+
+const workflowAliasContractSurfaces = Object.freeze(['tools/vibe-runtime-check/index.mjs']);
+
+export function createRuntimeWorkflowAliasInteractionCommands({
+  ensureRoot,
+  aliasActionText,
+  planActionManifestEnvelope,
+  selfTestGateProfileEnvelope,
+  commitReadinessEnvelope,
+  confirmedOneShotPlanEnvelope,
+  evidenceIntakeEnvelope,
+  diffCoverageEnvelope,
+  reviewIntakeEnvelope,
+  tddTraceEnvelope,
+  runtimeAutomationReadinessEnvelope,
+  runtimeCapabilityRegistry,
+  digestCloseLoopDashboard,
+  runtimeCloseLoopDashboard,
+  runtimeCloseLoopDashboardDigestPayload,
+  digestHumanFriendlyAlias,
+  runtimeHumanFriendlyAliasDigestPayload,
+  runtimeHumanFriendlyCloseLoopAlias,
+  runtimeHumanFriendlyNextEvidenceAlias,
+}) {
+  if (!workflowAliasContractSurfaces.includes('tools/vibe-runtime-check/index.mjs')) throw new Error('workflow alias runtime check contract marker missing');
+
+function closeLoopDashboardEnvelope(root, planFile, { intent = 'implementation', subject = '', confirmPlan = '' } = {}) {
+    ensureRoot(root);
+    if (!planFile) throw new Error('workflow --close-loop-dashboard requires --from-file <local-plan-file>');
+    if (!subject) throw new Error('workflow --close-loop-dashboard requires --subject <commit-subject>');
+    const planManifest = planActionManifestEnvelope(root, planFile, { intent }).plan_action_manifest;
+    const selfTestGateProfile = selfTestGateProfileEnvelope(root, planFile, { intent }).self_test_gate_profile;
+    const commitReadiness = commitReadinessEnvelope(root, planFile, { intent, subject }).commit_readiness;
+    const confirmedOneShotPlan = confirmPlan
+      ? confirmedOneShotPlanEnvelope(root, planFile, { intent, subject, confirmPlan }).confirmed_one_shot_plan
+      : null;
+    const automationEnvelope = runtimeAutomationReadinessEnvelope(root);
+    const automationReadiness = automationEnvelope.runtime_automation_readiness;
+    const registry = runtimeCapabilityRegistry();
+    const dashboard = runtimeCloseLoopDashboard({
+      planActionManifest: planManifest,
+      selfTestGateProfile,
+      commitReadiness,
+      confirmedOneShotPlan,
+      automationReadiness,
+      registry,
+      registryDigest: automationReadiness.registry_digest,
+      confirmation: { confirmPlan },
+    });
+    const closeLoopDashboard = {
+      ...dashboard,
+      close_loop_dashboard_digest: digestCloseLoopDashboard(runtimeCloseLoopDashboardDigestPayload(dashboard)),
+    };
+    return {
+      mode: 'close-loop-dashboard',
+      ok: closeLoopDashboard.dashboard_invariants.pass,
+      state_present: readonlyLocalStatePresent(root),
+      close_loop_dashboard: closeLoopDashboard,
+      safety: { stage: 'Stage 109', ...closeLoopDashboard.boundary_assertions },
+      quality: closeLoopDashboard.dashboard_invariants.findings,
+      action: aliasActionText.closeLoopDashboard,
+    };
+  }
+
+function humanFriendlyCloseLoopEnvelope(root, planFile, { subject = '' } = {}) {
+    ensureRoot(root);
+    if (!planFile) throw new Error('workflow --close-loop requires --from-file <local-plan-file>');
+    if (!subject) throw new Error('workflow --close-loop requires --subject <commit-subject>');
+    const dashboardEnvelope = closeLoopDashboardEnvelope(root, planFile, { intent: 'implementation', subject });
+    const automationEnvelope = runtimeAutomationReadinessEnvelope(root);
+    const registry = runtimeCapabilityRegistry();
+    const aliasBase = runtimeHumanFriendlyCloseLoopAlias({
+      closeLoopDashboard: dashboardEnvelope.close_loop_dashboard,
+      registry,
+      registryDigest: automationEnvelope.runtime_automation_readiness.registry_digest,
+    });
+    const humanFriendlyAlias = {
+      ...aliasBase,
+      human_friendly_alias_digest: digestHumanFriendlyAlias(runtimeHumanFriendlyAliasDigestPayload(aliasBase)),
+    };
+    return {
+      mode: 'human-friendly-close-loop-alias',
+      ok: humanFriendlyAlias.human_friendly_alias_invariants.pass,
+      state_present: readonlyLocalStatePresent(root),
+      human_friendly_alias: humanFriendlyAlias,
+      source_envelopes: {
+        close_loop_dashboard_digest: dashboardEnvelope.close_loop_dashboard.close_loop_dashboard_digest,
+      },
+      safety: { stage: 'Stage 114', ...humanFriendlyAlias.boundary_assertions },
+      quality: humanFriendlyAlias.human_friendly_alias_invariants.findings,
+      action: aliasActionText.closeLoopAlias,
+    };
+  }
+
+function humanFriendlyNextEvidenceEnvelope(root, planFile, { evidenceFile = '', diffFile = '', reviewFile = '', tddFile = '' } = {}) {
+    ensureRoot(root);
+    if (!planFile) throw new Error('workflow --next-evidence requires --from-file <local-plan-file>');
+    const planManifest = planActionManifestEnvelope(root, planFile, { intent: 'implementation' }).plan_action_manifest;
+    const evidenceIntake = evidenceFile ? evidenceIntakeEnvelope(root, evidenceFile, { planFile }).evidence_intake : null;
+    const diffCoverage = diffFile ? diffCoverageEnvelope(root, diffFile, { planFile }).diff_coverage : null;
+    const reviewIntake = reviewFile ? reviewIntakeEnvelope(root, reviewFile, { planFile }).review_intake : null;
+    const tddTrace = tddFile ? tddTraceEnvelope(root, tddFile, { planFile }).tdd_trace_contract : null;
+    const automationEnvelope = runtimeAutomationReadinessEnvelope(root);
+    const registry = runtimeCapabilityRegistry();
+    const aliasBase = runtimeHumanFriendlyNextEvidenceAlias({
+      planActionManifest: planManifest,
+      evidenceIntake,
+      diffCoverage,
+      reviewIntake,
+      tddTrace,
+      registry,
+      registryDigest: automationEnvelope.runtime_automation_readiness.registry_digest,
+    });
+    const humanFriendlyAlias = {
+      ...aliasBase,
+      human_friendly_alias_digest: digestHumanFriendlyAlias(runtimeHumanFriendlyAliasDigestPayload(aliasBase)),
+    };
+    return {
+      mode: 'human-friendly-next-evidence-alias',
+      ok: humanFriendlyAlias.human_friendly_alias_invariants.pass,
+      state_present: readonlyLocalStatePresent(root),
+      human_friendly_alias: humanFriendlyAlias,
+      source_envelopes: {
+        plan_action_manifest_digest: planManifest.plan_action_manifest_digest,
+        evidence_intake_digest: evidenceIntake?.evidence_intake_digest || '',
+        diff_coverage_digest: diffCoverage?.diff_coverage_digest || '',
+        review_intake_digest: reviewIntake?.review_intake_digest || '',
+        tdd_trace_digest: tddTrace?.tdd_trace_digest || '',
+      },
+      safety: { stage: 'Stage 114', ...humanFriendlyAlias.boundary_assertions },
+      quality: [
+        ...humanFriendlyAlias.human_friendly_alias_invariants.findings,
+        ...humanFriendlyAlias.evidence_gaps.flatMap((gap) => gap.reasons || []),
+      ],
+      action: aliasActionText.nextEvidenceAlias,
+    };
+  }
+
+  return {
+    closeLoopDashboardEnvelope,
+    humanFriendlyCloseLoopEnvelope,
+    humanFriendlyNextEvidenceEnvelope,
+  };
+}

package/tools/vibe-runtime/runtime-workflow-command-deps.mjs

@@ -0,0 +1,41 @@
+export function runtimeWorkflowCommandDeps(deps) {
+  return {
+    ensureRoot: deps.ensureRoot,
+    humanFriendlyCloseLoopEnvelope: deps.humanFriendlyCloseLoopEnvelope,
+    humanFriendlyNextEvidenceEnvelope: deps.humanFriendlyNextEvidenceEnvelope,
+    nextActionConsoleEnvelope: deps.nextActionConsoleEnvelope,
+    entryTriggerDisciplineEnvelope: deps.entryTriggerDisciplineEnvelope,
+    runEntryTriggerTighteningCommand: deps.runEntryTriggerTighteningCommand,
+    runNextActionEvidencePromptsCommand: deps.runNextActionEvidencePromptsCommand,
+    closeLoopDashboardEnvelope: deps.closeLoopDashboardEnvelope,
+    workflowLoopContractEnvelope: deps.workflowLoopContractEnvelope,
+    workflowCockpitEnvelope: deps.workflowCockpitEnvelope,
+    workflowReceiptEnvelope: deps.workflowReceiptEnvelope,
+    workflowStartEnvelope: deps.workflowStartEnvelope,
+    completionEvidenceBundleEnvelope: deps.completionEvidenceBundleEnvelope,
+    digestObject: deps.digestObject,
+    tokenSaviorBudgetEnvelope: deps.tokenSaviorBudgetEnvelope,
+    learningAdviceEnvelope: deps.learningAdviceEnvelope,
+    progressiveEntryUxEnvelope: deps.progressiveEntryUxEnvelope,
+    workflowSequenceEnvelope: deps.workflowSequenceEnvelope,
+    printHumanFriendlyAlias: deps.printHumanFriendlyAlias,
+    printNextActionConsole: deps.printNextActionConsole,
+    printEntryTriggerDiscipline: deps.printEntryTriggerDiscipline,
+    printCloseLoopDashboard: deps.printCloseLoopDashboard,
+    printWorkflowLoopContract: deps.printWorkflowLoopContract,
+    printWorkflowCockpit: deps.printWorkflowCockpit,
+    printWorkflowReceipt: deps.printWorkflowReceipt,
+    printWorkflowStart: deps.printWorkflowStart,
+    printSessionStart: deps.printSessionStart,
+    printSkillSelect: deps.printSkillSelect,
+    printSessionCheckpoint: deps.printSessionCheckpoint,
+    printSessionHandoff: deps.printSessionHandoff,
+    printSessionResume: deps.printSessionResume,
+    printSessionClose: deps.printSessionClose,
+    printWorkflowRunPlan: deps.printWorkflowRunPlan,
+    printEntryRuntimeSummary: deps.printEntryRuntimeSummary,
+    printProgressiveEntryUx: deps.printProgressiveEntryUx,
+    printWorkflowSequence: deps.printWorkflowSequence,
+    writeJsonEnvelope: deps.writeJsonEnvelope,
+  };
+}

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

@@ -0,0 +1,191 @@
+import {
+  buildEntryRuntimeSummaryEnvelopeModel,
+  learningAdviceIntentForWorkflowIntent,
+} from './runtime-entry-summary-model.mjs';
+import { buildWorkflowSkillPlanEnvelopeModel } from './runtime-workflow-run-plan-model.mjs';
+
+export function runWorkflowCommand(deps, options) {
+  const jsonWriter = deps['writeJson' + 'Envelope'];
+  deps.ensureRoot(options.root);
+  validateWorkflowCommandOptions(options);
+  if (handleHumanFriendlyWorkflowMode(deps, options, jsonWriter)) return;
+  handleCoreWorkflowMode(deps, options, jsonWriter);
+}
+
+function validateWorkflowCommandOptions(options) {
+  const modes = [options.workflowCockpit, options.workflowReceipt, options.workflowStart, options.workflowRunPlan, options.workflowEntrySummary, options.workflowEntryUx, options.workflowEntryDiscipline, options.workflowEntryTightening, options.workflowNextActionConsole, options.workflowNextEvidencePrompts, options.workflowSequence, options.workflowLoopContract, options.workflowCloseLoopDashboard, options.workflowCloseLoop, options.workflowNextEvidence].filter(Boolean);
+  if (modes.length !== 1) throw new Error('workflow requires exactly one mode: --cockpit, --receipt, --start, --run-plan, --entry-summary, --entry-ux, --entry-discipline, --entry-tightening, --next-action-console, --next-evidence-prompts, --sequence, --loop-contract, --close-loop-dashboard, --close-loop, or --next-evidence');
+  if (options.confirm || options.write || options.dryRun || options.recoveryPreview || options.hooksPreview || options.dispatch || options.dispatchIntent || options.run || options.autoRun || options.scan || options.once || options.preflight) throw new Error('workflow read-only modes do not accept execution, dispatch, preview, confirm, write, scan, or preflight flags');
+  if (options.fromReadiness || options.learningObservationFiles.length > 0 || options.learningInstinctFile || options.tokenCompactionFiles.length > 0 || options.methodologyKind || options.methodologyFile) throw new Error('workflow read-only modes do not accept concrete sidecar, methodology gate, or audit input files');
+  if (!options.workflowEntryUx && options.fromGap) throw new Error('--from-gap is only supported by workflow --entry-ux');
+  if (!options.workflowEntryDiscipline && options.fromTranscript) throw new Error('--from-transcript is only supported by workflow --entry-discipline');
+  if (!options.workflowEntryTightening && (options.fromDiscipline || options.fromScorecard)) throw new Error('--from-discipline and --from-scorecard are only supported by workflow --entry-tightening');
+  if (!options.workflowNextEvidencePrompts && (options.fromConsole || options.fromDashboard || options.fromUpgrades)) throw new Error('--from-console, --from-dashboard, and --from-upgrades are only supported by workflow --next-evidence-prompts');
+  if (!options.workflowNextActionConsole && options.fromFriction) throw new Error('--from-friction is only supported by workflow --next-action-console');
+  if (!options.workflowNextActionConsole && (options.fromRunbook || options.fromEvidence)) throw new Error('--from-runbook and --from-evidence are only supported by workflow --next-action-console');
+  if (options.profile && !['vibe-guided', 'default', 'superpowers-parity'].includes(options.profile)) throw new Error('workflow --profile must be vibe-guided, default, or superpowers-parity');
+}
+
+function handleHumanFriendlyWorkflowMode(deps, options, jsonWriter) {
+  if (options.workflowCloseLoop) {
+    if (!options.fromFile) throw new Error('workflow --close-loop requires --from-file <local-plan-file>');
+    if (!options.commitSubject) throw new Error('workflow --close-loop requires --subject <commit-subject>');
+    if (options.prompt || options.methodologyIntent || options.confirmPlan || options.evidenceFile || options.diffFile || options.reviewFile || options.tddFile) throw new Error('workflow --close-loop only accepts one local plan file, one subject, --json, and --root');
+    const envelope = deps.humanFriendlyCloseLoopEnvelope(options.root, options.fromFile, { subject: options.commitSubject });
+    emitWorkflowEnvelope(options, jsonWriter, envelope, deps.printHumanFriendlyAlias);
+    return true;
+  }
+  if (options.workflowNextEvidence) {
+    if (!options.fromFile) throw new Error('workflow --next-evidence requires --from-file <local-plan-file>');
+    if (options.commitSubject || options.prompt || options.methodologyIntent || options.confirmPlan) throw new Error('workflow --next-evidence only accepts one local plan file, optional local evidence/diff/review/TDD files, --json, and --root');
+    const envelope = deps.humanFriendlyNextEvidenceEnvelope(options.root, options.fromFile, {
+      evidenceFile: options.evidenceFile,
+      diffFile: options.diffFile,
+      reviewFile: options.reviewFile,
+      tddFile: options.tddFile,
+    });
+    emitWorkflowEnvelope(options, jsonWriter, envelope, deps.printHumanFriendlyAlias);
+    return true;
+  }
+  if (options.workflowNextActionConsole) return handleNextActionConsoleWorkflowMode(deps, options, jsonWriter);
+  if (options.workflowEntryDiscipline) return handleEntryDisciplineWorkflowMode(deps, options, jsonWriter);
+  if (options.workflowEntryTightening) {
+    deps.runEntryTriggerTighteningCommand(options, { ['writeJson' + 'Envelope']: jsonWriter });
+    return true;
+  }
+  if (options.workflowNextEvidencePrompts) {
+    deps.runNextActionEvidencePromptsCommand(options, { ['writeJson' + 'Envelope']: jsonWriter });
+    return true;
+  }
+  if (options.workflowCloseLoopDashboard) return handleCloseLoopDashboardWorkflowMode(deps, options, jsonWriter);
+  return false;
+}
+
+function handleNextActionConsoleWorkflowMode(deps, options, jsonWriter) {
+  if (!options.fromFriction) throw new Error('workflow --next-action-console requires --from-friction <local-friction-json>');
+  if (options.fromFile || options.fromTranscript || options.commitSubject || options.prompt || options.methodologyIntent || options.confirmPlan || options.fromGap || options.evidenceFile || options.diffFile || options.reviewFile || options.tddFile) throw new Error('workflow --next-action-console only accepts --from-friction, optional --from-runbook, optional --from-evidence, --json, and --root');
+  const envelope = deps.nextActionConsoleEnvelope(options.root, {
+    frictionFile: options.fromFriction,
+    runbookFile: options.fromRunbook || '',
+    evidenceFile: options.fromEvidence || '',
+  });
+  emitWorkflowEnvelope(options, jsonWriter, envelope, deps.printNextActionConsole);
+  return true;
+}
+
+function handleEntryDisciplineWorkflowMode(deps, options, jsonWriter) {
+  if (!options.fromTranscript) throw new Error('workflow --entry-discipline requires --from-transcript <local-transcript-json>');
+  if (options.fromFile || options.fromFriction || options.fromRunbook || options.fromEvidence || options.commitSubject || options.prompt || options.confirmPlan || options.fromGap || options.evidenceFile || options.diffFile || options.reviewFile || options.tddFile) throw new Error('workflow --entry-discipline only accepts --from-transcript, optional --intent, --json, and --root');
+  const envelope = deps.entryTriggerDisciplineEnvelope(options.root, options.fromTranscript, { intent: options.methodologyIntent || 'unknown', profile: options.profile });
+  emitWorkflowEnvelope(options, jsonWriter, envelope, deps.printEntryTriggerDiscipline);
+  return true;
+}
+
+function handleCloseLoopDashboardWorkflowMode(deps, options, jsonWriter) {
+  if (!options.fromFile) throw new Error('workflow --close-loop-dashboard requires --from-file <local-plan-file>');
+  if (!options.commitSubject) throw new Error('workflow --close-loop-dashboard requires --subject <commit-subject>');
+  if (options.prompt) throw new Error('workflow --close-loop-dashboard only accepts one local plan file, one subject, optional intent, optional --confirm-plan, and read-only output flags');
+  const envelope = deps.closeLoopDashboardEnvelope(options.root, options.fromFile, { intent: options.methodologyIntent || 'implementation', subject: options.commitSubject, confirmPlan: options.confirmPlan });
+  emitWorkflowEnvelope(options, jsonWriter, envelope, deps.printCloseLoopDashboard);
+  return true;
+}
+
+function handleCoreWorkflowMode(deps, options, jsonWriter) {
+  if (options.commitSubject || options.confirmPlan) throw new Error('--subject and --confirm-plan are only supported by workflow --close-loop-dashboard or workflow --close-loop');
+  if (options.evidenceFile || options.diffFile || options.reviewFile || options.tddFile) throw new Error('--evidence-file, --diff-file, --review-file, and --tdd-file are only supported by workflow --next-evidence');
+  if (options.workflowLoopContract) return handleLoopContractWorkflowMode(deps, options, jsonWriter);
+  if (options.workflowCockpit) return handleCockpitWorkflowMode(deps, options, jsonWriter);
+  if (options.workflowReceipt) return handleReceiptWorkflowMode(deps, options, jsonWriter);
+  if (options.workflowRunPlan) return handleRunPlanWorkflowMode(deps, options, jsonWriter);
+  if (options.workflowEntrySummary) return handleEntrySummaryWorkflowMode(deps, options, jsonWriter);
+  if (options.workflowStart) return handleStartWorkflowMode(deps, options, jsonWriter);
+  if (options.workflowEntryUx) return handleEntryUxWorkflowMode(deps, options, jsonWriter);
+  return handleSequenceWorkflowMode(deps, options, jsonWriter);
+}
+
+function handleLoopContractWorkflowMode(deps, options, jsonWriter) {
+  if (!options.methodologyIntent && !options.prompt) throw new Error('workflow --loop-contract requires --intent <kind> or --prompt <text>');
+  const envelope = deps.workflowLoopContractEnvelope(options.root, { intent: options.methodologyIntent, prompt: options.prompt, planFile: options.fromFile || '' });
+  emitWorkflowEnvelope(options, jsonWriter, envelope, deps.printWorkflowLoopContract);
+  return true;
+}
+
+function handleCockpitWorkflowMode(deps, options, jsonWriter) {
+  if (!options.methodologyIntent) throw new Error('workflow --cockpit requires --intent <kind>');
+  if (options.prompt) throw new Error('workflow --cockpit does not accept --prompt; use --intent or workflow --start');
+  const envelope = deps.workflowCockpitEnvelope(options.root, { intent: options.methodologyIntent, planFile: options.fromFile || '' });
+  emitWorkflowEnvelope(options, jsonWriter, envelope, deps.printWorkflowCockpit);
+  return true;
+}
+
+function handleReceiptWorkflowMode(deps, options, jsonWriter) {
+  if (!options.methodologyIntent) throw new Error('workflow --receipt requires --intent <kind>');
+  if (options.fromFile || options.prompt) throw new Error('workflow --receipt only accepts --intent plus read-only output flags');
+  const envelope = deps.workflowReceiptEnvelope(options.root, { intent: options.methodologyIntent });
+  emitWorkflowEnvelope(options, jsonWriter, envelope, deps.printWorkflowReceipt);
+  return true;
+}
+
+function handleRunPlanWorkflowMode(deps, options, jsonWriter) {
+  if (!options.methodologyIntent && !options.prompt) throw new Error('workflow --run-plan requires --intent <kind> or --prompt <text>');
+  if (options.fromFile || options.fromFriction || options.fromRunbook || options.fromEvidence || options.fromTranscript || options.fromGap || options.commitSubject || options.confirmPlan || options.evidenceFile || options.diffFile || options.reviewFile || options.tddFile) throw new Error('workflow --run-plan only accepts --intent or --prompt plus read-only output flags');
+  const prompt = options.prompt || options.methodologyIntent;
+  const start = deps.workflowStartEnvelope(options.root, { intent: options.methodologyIntent, prompt, profile: options.profile });
+  const envelope = buildWorkflowSkillPlanEnvelopeModel({
+    prompt,
+    inputIntent: options.methodologyIntent,
+    workflowStartEnvelope: start,
+    digestObject: deps.digestObject,
+  });
+  emitWorkflowEnvelope(options, jsonWriter, envelope, deps.printWorkflowRunPlan);
+  return true;
+}
+
+function handleEntrySummaryWorkflowMode(deps, options, jsonWriter) {
+  if (!options.methodologyIntent && !options.prompt) throw new Error('workflow --entry-summary requires --intent <kind> or --prompt <text>');
+  if (options.fromFile || options.fromFriction || options.fromRunbook || options.fromEvidence || options.fromTranscript || options.fromGap || options.commitSubject || options.confirmPlan || options.evidenceFile || options.diffFile || options.reviewFile || options.tddFile) throw new Error('workflow --entry-summary only accepts --intent or --prompt plus read-only output flags');
+  const prompt = options.prompt || options.methodologyIntent;
+  const workflowStart = deps.workflowStartEnvelope(options.root, { intent: options.methodologyIntent, prompt, profile: options.profile });
+  const tokenSaviorBudget = deps.tokenSaviorBudgetEnvelope(options.root, { prompt });
+  const learningAdvice = deps.learningAdviceEnvelope(options.root, {
+    intent: learningAdviceIntentForWorkflowIntent(workflowStart.workflow_start?.normalized_intent),
+  });
+  const envelope = buildEntryRuntimeSummaryEnvelopeModel({
+    prompt,
+    inputIntent: options.methodologyIntent,
+    workflowStartEnvelope: workflowStart,
+    tokenSaviorBudgetEnvelope: tokenSaviorBudget,
+    learningAdviceEnvelope: learningAdvice,
+    digestObject: deps.digestObject,
+  });
+  emitWorkflowEnvelope(options, jsonWriter, envelope, deps.printEntryRuntimeSummary);
+  return true;
+}
+
+function handleStartWorkflowMode(deps, options, jsonWriter) {
+  if (!options.methodologyIntent && !options.prompt) throw new Error('workflow --start requires --intent <kind> or --prompt <text>');
+  const envelope = deps.workflowStartEnvelope(options.root, { intent: options.methodologyIntent, prompt: options.prompt, planFile: options.fromFile || '', profile: options.profile });
+  emitWorkflowEnvelope(options, jsonWriter, envelope, deps.printWorkflowStart);
+  return true;
+}
+
+function handleEntryUxWorkflowMode(deps, options, jsonWriter) {
+  if (!options.prompt) throw new Error('workflow --entry-ux requires --prompt <text>');
+  if (options.methodologyIntent || options.fromFile || options.commitSubject || options.confirmPlan || options.evidenceFile || options.diffFile || options.reviewFile || options.tddFile) throw new Error('workflow --entry-ux only accepts --prompt, optional --from-gap, --json, and --root');
+  const envelope = deps.progressiveEntryUxEnvelope(options.root, { prompt: options.prompt, gapFile: options.fromGap || '' });
+  emitWorkflowEnvelope(options, jsonWriter, envelope, deps.printProgressiveEntryUx);
+  return true;
+}
+
+function handleSequenceWorkflowMode(deps, options, jsonWriter) {
+  if (!options.methodologyIntent) throw new Error('workflow --sequence requires --intent <kind>');
+  if (options.fromFile || options.prompt) throw new Error('workflow --sequence only accepts --intent plus read-only output flags');
+  const envelope = deps.workflowSequenceEnvelope(options.root, { intent: options.methodologyIntent });
+  emitWorkflowEnvelope(options, jsonWriter, envelope, deps.printWorkflowSequence);
+  return true;
+}
+
+function emitWorkflowEnvelope(options, jsonWriter, envelope, printEnvelope) {
+  if (options.json) jsonWriter('workflow', envelope);
+  else printEnvelope(envelope);
+}