@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-next-action-console.mjs

@@ -0,0 +1,388 @@
+import crypto from 'node:crypto';
+
+const nextActionStage = 'Stage 127';
+const nextActionKind = 'one-screen-next-action-console';
+
+export function runtimeNextActionConsole({ friction = {}, runbook = null, evidence = null, source = {} } = {}) {
+  const normalizedFriction = normalizeFriction(friction);
+  const normalizedRunbook = normalizeRunbook(runbook);
+  const normalizedEvidence = normalizeEvidence(evidence);
+  const topFix = selectTopFix(normalizedFriction.priority_fixes);
+  const position = currentPosition({ friction: normalizedFriction, runbook: normalizedRunbook, evidence: normalizedEvidence, topFix });
+  const nextAction = recommendedNextAction({ friction: normalizedFriction, runbook: normalizedRunbook, evidence: normalizedEvidence, topFix });
+  const consoleCore = {
+    version: 1,
+    stage: nextActionStage,
+    console_kind: nextActionKind,
+    source_bindings: sourceBindingSummary(source, normalizedFriction, normalizedRunbook, normalizedEvidence),
+    current_position: position,
+    recommended_next_action: nextAction,
+    why_now: whyNow(normalizedFriction, topFix),
+    copy_ready_command_preview: copyReadyCommandPreview({ source, friction: normalizedFriction, runbook: normalizedRunbook, evidence: normalizedEvidence, topFix }),
+    evidence_needed_next: evidenceNeededNext(normalizedFriction, normalizedRunbook, normalizedEvidence),
+    do_not_do_yet: doNotDoYet(normalizedFriction, topFix),
+    boundary_assertions: runtimeNextActionConsoleBoundaryAssertions(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeNextActionConsoleInvariants(consoleCore);
+  const console = {
+    ...consoleCore,
+    ok: invariants.pass,
+    next_action_console_invariants: invariants,
+  };
+  return {
+    ...console,
+    console_digest: digestNextActionConsole(runtimeNextActionConsoleDigestPayload(console)),
+  };
+}
+
+export function runtimeNextActionConsoleDigestPayload(console) {
+  return {
+    stage: console.stage,
+    console_kind: console.console_kind,
+    source_bindings: console.source_bindings,
+    current_position: console.current_position,
+    recommended_next_action: console.recommended_next_action,
+    why_now: console.why_now,
+    copy_ready_command_preview: console.copy_ready_command_preview,
+    evidence_needed_next: console.evidence_needed_next,
+    do_not_do_yet: console.do_not_do_yet,
+    boundary_assertions: console.boundary_assertions,
+    next_action_console_invariants: console.next_action_console_invariants,
+  };
+}
+
+export function runtimeNextActionConsoleBoundaryAssertions() {
+  return {
+    next_action_console_artifact: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    source_write: false,
+    command_execution: false,
+    check_execution: false,
+    test_execution: false,
+    verification_execution: false,
+    runtime_action: false,
+    workflow_execution: false,
+    skill_execution: false,
+    auto_execution: false,
+    repair_execution: false,
+    evidence_write: false,
+    runbook_write: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+export function runtimeNextActionConsoleInvariants(console) {
+  const unsafeBoundaries = Object.entries(console.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const missingForbidden = ['command_execution', 'check_execution', 'test_execution', 'runtime_action', 'workflow_execution', 'skill_execution', 'git', 'git_write', 'commit', 'pr', 'push', 'merge', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'business_source_write', 'state_directory_created']
+    .filter((key) => console.boundary_assertions?.[key] !== false);
+  const commandExecutors = console.copy_ready_command_preview
+    .filter((item) => item.preview_only !== true || /(^|\s)(git\s+(commit|push|merge|tag)|gh\s+pr|npm\s+test|node\s+.*--confirm|--run|--once|--auto-run)(\s|$)/i.test(item.command))
+    .map((item) => item.id);
+  const findings = [
+    ...(console.stage === nextActionStage ? [] : [`stage must be ${nextActionStage}`]),
+    ...(console.console_kind === nextActionKind ? [] : [`console_kind must be ${nextActionKind}`]),
+    ...(console.source_bindings?.friction_file ? [] : ['source friction file binding is required']),
+    ...(console.source_bindings?.friction_digest ? [] : ['source friction digest binding is required']),
+    ...(console.current_position?.friction_level ? [] : ['current_position friction level is required']),
+    ...(console.recommended_next_action?.action ? [] : ['recommended_next_action.action is required']),
+    ...(Array.isArray(console.copy_ready_command_preview) && console.copy_ready_command_preview.length > 0 ? [] : ['copy_ready_command_preview must contain at least one preview command']),
+    ...(Array.isArray(console.evidence_needed_next) ? [] : ['evidence_needed_next must be a list']),
+    ...(Array.isArray(console.do_not_do_yet) && console.do_not_do_yet.length > 0 ? [] : ['do_not_do_yet must contain explicit non-actions']),
+    ...unsafeBoundaries.map((key) => `boundary assertion must remain false: ${key}`),
+    ...missingForbidden.map((key) => `forbidden boundary missing or not false: ${key}`),
+    ...commandExecutors.map((id) => `copy-ready command preview must remain non-executing and preview-only: ${id}`),
+  ];
+  return {
+    pass: findings.length === 0,
+    checked: ['source_binding', 'current_position', 'recommended_next_action', 'copy_ready_preview', 'evidence_needed_next', 'do_not_do_yet', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+export function digestNextActionConsole(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function normalizeFriction(input) {
+  const matrix = objectValue(input.experience_friction_matrix || input);
+  const dimensions = listValue(matrix.dimensions).map((dimension) => ({
+    id: stringValue(dimension.id),
+    severity: stringValue(dimension.severity || 'low'),
+    score: numberValue(dimension.score),
+    weighted_score: numberValue(dimension.weighted_score),
+    fix: stringValue(dimension.fix),
+  })).filter((dimension) => dimension.id);
+  const priorityFixes = listValue(matrix.priority_fixes).map((fix) => ({
+    id: stringValue(fix.id),
+    severity: stringValue(fix.severity || 'low'),
+    score: numberValue(fix.score),
+    recommended_stage: stringValue(fix.recommended_stage || 'Stage 127'),
+    fix: stringValue(fix.fix),
+  })).filter((fix) => fix.id);
+  return {
+    stage: stringValue(matrix.stage || 'Stage 126'),
+    matrix_kind: stringValue(matrix.matrix_kind || 'experience-friction-matrix'),
+    friction_score: numberValue(matrix.friction_score),
+    friction_level: stringValue(matrix.friction_level || 'unknown'),
+    manual_next_action: stringValue(matrix.manual_next_action),
+    source_bindings: objectValue(matrix.source_bindings),
+    recommended_stage_sequence: listValue(matrix.recommended_stage_sequence).map(stringValue).filter(Boolean),
+    dimensions,
+    priority_fixes: priorityFixes,
+    friction_digest: stringValue(matrix.friction_digest || input.friction_digest),
+  };
+}
+
+function normalizeRunbook(input) {
+  if (!input) return { provided: false, stage_count: 0, current_stage: '', next_stage: '', digest: '' };
+  const runbook = objectValue(input.sequential_stage_runbook || input.stage_runbook || input);
+  const stages = listValue(runbook.stages || runbook.stage_sequence || runbook.runbook_stages || runbook.steps);
+  const current = stages.find((stage) => hasAny(stringValue(stage.status), ['current', 'in_progress', 'active'])) || stages[0] || {};
+  const next = stages.find((stage) => hasAny(stringValue(stage.status), ['pending', 'next'])) || stages[1] || current;
+  return {
+    provided: true,
+    stage: stringValue(runbook.stage || 'Stage 118'),
+    runbook_kind: stringValue(runbook.runbook_kind || runbook.kind || 'sequential-stage-runbook'),
+    stage_count: stages.length,
+    current_stage: stringValue(current.stage || current.id || current.name || runbook.current_stage),
+    next_stage: stringValue(next.stage || next.id || next.name || runbook.next_stage),
+    digest: stringValue(runbook.stage_runbook_digest || runbook.runbook_digest || runbook.sequential_stage_runbook_digest),
+  };
+}
+
+function normalizeEvidence(input) {
+  if (!input) return { provided: false, status: 'not_provided', categories: [], blockers: [] };
+  const evidence = objectValue(input.execution_evidence_binding || input.evidence_intake || input.completion_evidence_bundle || input);
+  const validation = listValue(evidence.validation_evidence || evidence.evidence || evidence.bound_evidence || evidence.commands);
+  const blockers = [
+    ...listValue(evidence.blockers),
+    ...listValue(evidence.findings),
+    ...listValue(evidence.evidence_gaps),
+  ].map(stringValue).filter(Boolean);
+  return {
+    provided: true,
+    status: stringValue(evidence.status || evidence.result || (blockers.length > 0 ? 'blocked' : 'provided')),
+    categories: validation.map((item) => stringValue(item.category || item.kind || item.type || item.command || item)).filter(Boolean),
+    blockers,
+    digest: stringValue(evidence.execution_evidence_digest || evidence.evidence_intake_digest || evidence.completion_evidence_bundle_digest),
+  };
+}
+
+function currentPosition({ friction, runbook, evidence, topFix }) {
+  return {
+    stage: nextActionStage,
+    friction_level: friction.friction_level,
+    friction_score: friction.friction_score,
+    top_friction: topFix.id || 'none',
+    top_friction_severity: topFix.severity || 'low',
+    runbook_present: runbook.provided,
+    runbook_current_stage: runbook.current_stage,
+    runbook_next_stage: runbook.next_stage,
+    evidence_present: evidence.provided,
+    evidence_status: evidence.status,
+  };
+}
+
+function recommendedNextAction({ friction, runbook, evidence, topFix }) {
+  if (!topFix.id) {
+    return {
+      id: 'keep-current-loop',
+      action: 'Keep the current workflow loop; no high-priority daily-use friction was detected.',
+      target_stage: 'Stage 127',
+      minimum_input: 'existing Stage 126 friction matrix',
+    };
+  }
+  if (['evidence_gap', 'completion_claim_risk'].includes(topFix.id)) {
+    return {
+      id: 'bind-evidence-before-claiming-done',
+      action: 'Bind fresh local evidence before claiming completion or preparing staged commit readiness.',
+      target_stage: runbook.provided ? 'Stage 119 or Stage 120' : 'Stage 127 then Stage 119/120',
+      minimum_input: evidence.provided ? 'review existing evidence binding and close remaining blockers' : 'local validation evidence JSON',
+    };
+  }
+  if (topFix.id === 'token_overhead') {
+    return {
+      id: 'prepare-token-savior-budget',
+      action: 'Use the friction matrix as input to a deterministic Token Savior entry budget.',
+      target_stage: 'Stage 128',
+      minimum_input: 'Stage 126 friction matrix',
+    };
+  }
+  if (topFix.id === 'command_discovery_cost') {
+    return {
+      id: 'prepare-copy-ready-scriptlet',
+      action: 'Generate a copy-ready scriptlet preview from the runbook, but do not execute it.',
+      target_stage: 'Stage 130',
+      minimum_input: 'Stage 118 runbook JSON',
+    };
+  }
+  if (topFix.id === 'adapter_bootstrap_gap') {
+    return {
+      id: 'verify-adapter-entry-experience',
+      action: 'Capture adapter entry transcript and verify it with the entry acceptance contract.',
+      target_stage: 'Stage 131',
+      minimum_input: 'local adapter transcript JSON',
+    };
+  }
+  if (topFix.id === 'superpowers_parity_gap') {
+    return {
+      id: 'refresh-experience-regression-dashboard',
+      action: 'Bind comparison, token, learning, and daily-friction evidence into the experience dashboard.',
+      target_stage: 'Stage 132',
+      minimum_input: 'Stage 126-131 local envelopes',
+    };
+  }
+  return {
+    id: 'use-one-screen-console',
+    action: friction.manual_next_action || topFix.fix || 'Use this one-screen console to choose the next manual step.',
+    target_stage: topFix.recommended_stage || 'Stage 127',
+    minimum_input: 'Stage 126 friction matrix',
+  };
+}
+
+function whyNow(friction, topFix) {
+  if (!topFix.id) return 'The current friction score is low enough that the best improvement is to preserve the visible local loop.';
+  return `Stage 126 measured ${friction.friction_level || 'unknown'} friction (${friction.friction_score}/100); the highest actionable dimension is ${topFix.id}, so the next step should remove that daily-use decision cost first.`;
+}
+
+function copyReadyCommandPreview({ source, friction, runbook, evidence, topFix }) {
+  const root = '<root>';
+  const frictionFile = source.friction_file || '<local-friction-json>';
+  const commands = [
+    {
+      id: 'refresh-console',
+      purpose: 'Rebuild the one-screen next action console from the current friction matrix.',
+      command: `node tools/vibe-runtime/index.mjs workflow --next-action-console --from-friction ${frictionFile} --json --root ${root}`,
+      preview_only: true,
+    },
+  ];
+  if (['evidence_gap', 'completion_claim_risk'].includes(topFix.id) || !evidence.provided) {
+    commands.push({
+      id: 'bind-execution-evidence-preview',
+      purpose: 'Preview the expected evidence binding command when a Stage 118 runbook and local evidence exist.',
+      command: 'node tools/vibe-runtime/index.mjs verification --execution-evidence --from-runbook <local-runbook-json> --from-file <local-evidence-json> --json --root <root>',
+      preview_only: true,
+    });
+  }
+  if (topFix.id === 'token_overhead' || friction.recommended_stage_sequence.includes('Stage 128')) {
+    commands.push({
+      id: 'token-budget-preview',
+      purpose: 'Preview the next Token Savior budget command planned for Stage 128.',
+      command: `node tools/vibe-runtime/index.mjs tokens --savior-budget --prompt <text> --from-friction ${frictionFile} --json --root ${root}`,
+      preview_only: true,
+    });
+  }
+  if (topFix.id === 'command_discovery_cost' || runbook.provided) {
+    commands.push({
+      id: 'scriptlet-preview',
+      purpose: 'Preview the Stage 130 copy-ready scriptlet command without running it.',
+      command: 'node tools/vibe-runtime/index.mjs automation --stage-scriptlet --from-runbook <local-runbook-json> --json --root <root>',
+      preview_only: true,
+    });
+  }
+  return commands;
+}
+
+function evidenceNeededNext(friction, runbook, evidence) {
+  const needed = [];
+  if (!runbook.provided) needed.push({ id: 'stage-runbook', reason: 'A Stage 118 runbook makes the current and next stage explicit.', command_family: 'automation --stage-runbook' });
+  if (!evidence.provided || evidence.blockers.length > 0) needed.push({ id: 'local-validation-evidence', reason: 'Completion and commit-readiness claims need fresh local evidence binding.', command_family: 'verification --execution-evidence' });
+  if (friction.priority_fixes.some((fix) => fix.id === 'token_overhead')) needed.push({ id: 'token-budget-input', reason: 'Token overhead should feed Stage 128 budget selection.', command_family: 'tokens --savior-budget' });
+  if (needed.length === 0) needed.push({ id: 'none-blocking', reason: 'Provided runbook and evidence are sufficient for the current one-screen recommendation.', command_family: 'manual-review' });
+  return needed;
+}
+
+function doNotDoYet(friction, topFix) {
+  const base = [
+    'do not execute preview commands from this console automatically',
+    'do not git add, commit, push, PR, merge, or tag from this contract',
+    'do not call platform APIs, external network, model, MCP, or subagent from this contract',
+  ];
+  if (['evidence_gap', 'completion_claim_risk'].includes(topFix.id)) base.push('do not claim completion until fresh local evidence is bound');
+  if (friction.recommended_stage_sequence.includes('Stage 128')) base.push('do not load full skill or full repository context before a Token Savior budget is selected');
+  return base;
+}
+
+function selectTopFix(priorityFixes) {
+  return [...listValue(priorityFixes)]
+    .sort((left, right) => severityRank(right.severity) - severityRank(left.severity) || numberValue(right.score) - numberValue(left.score))[0] || {};
+}
+
+function sourceBindingSummary(source, friction, runbook, evidence) {
+  return {
+    friction_file: stringValue(source.friction_file),
+    friction_digest: stringValue(source.friction_digest || friction.friction_digest),
+    friction_stage: friction.stage,
+    friction_score: friction.friction_score,
+    runbook_file: stringValue(source.runbook_file),
+    runbook_digest: stringValue(source.runbook_digest || runbook.digest),
+    evidence_file: stringValue(source.evidence_file),
+    evidence_digest: stringValue(source.evidence_digest || evidence.digest),
+  };
+}
+
+function severityRank(value) {
+  return { high: 3, medium: 2, low: 1 }[String(value || '').toLowerCase()] || 0;
+}
+
+function numberValue(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : 0;
+}
+
+function objectValue(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function listValue(value) {
+  if (Array.isArray(value)) return value;
+  if (typeof value === 'string' && value.trim()) return [value.trim()];
+  return [];
+}
+
+function stringValue(value) {
+  if (value === null || value === undefined) return '';
+  if (typeof value === 'string') return value.trim();
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+  return flattenText(value).trim();
+}
+
+function flattenText(value) {
+  if (Array.isArray(value)) return value.map(flattenText).join('\n');
+  if (value && typeof value === 'object') return Object.values(value).map(flattenText).join('\n');
+  return String(value || '');
+}
+
+function hasAny(text, markers) {
+  const normalized = String(text || '').toLowerCase();
+  return markers.some((marker) => normalized.includes(String(marker).toLowerCase()));
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}

package/tools/vibe-runtime/runtime-next-action-evidence-prompts-command.mjs

@@ -0,0 +1,84 @@
+import {
+  ensureRoot,
+  localJsonFileWithinRoot,
+} from './runtime-local-json-input.mjs';
+import {
+  emitReadonlyLocalJsonOutput,
+  readonlyLocalJsonEnvelope,
+} from './runtime-readonly-local-json-output-envelope.mjs';
+import {
+  runtimeNextActionEvidencePrompts,
+} from './runtime-next-action-evidence-prompts.mjs';
+
+function printList(title, items, format = (item) => String(item)) {
+  if (!items || items.length === 0) return;
+  console.log(`${title}:`);
+  for (const item of items) console.log(`- ${format(item)}`);
+}
+
+export function nextActionEvidencePromptsEnvelope(root, { consoleFile = '', dashboardFile = '', upgradesFile = '' } = {}) {
+  ensureRoot(root);
+  if (!consoleFile) throw new Error('workflow --next-evidence-prompts requires --from-console <local-console-json>');
+  if (!dashboardFile) throw new Error('workflow --next-evidence-prompts requires --from-dashboard <local-dashboard-json>');
+  if (!upgradesFile) throw new Error('workflow --next-evidence-prompts requires --from-upgrades <local-upgrades-json>');
+  const consoleInput = localJsonFileWithinRoot(root, consoleFile, 'workflow --next-evidence-prompts --from-console');
+  const dashboardInput = localJsonFileWithinRoot(root, dashboardFile, 'workflow --next-evidence-prompts --from-dashboard');
+  const upgradesInput = localJsonFileWithinRoot(root, upgradesFile, 'workflow --next-evidence-prompts --from-upgrades');
+  const prompts = runtimeNextActionEvidencePrompts({
+    console: consoleInput.data,
+    dashboard: dashboardInput.data,
+    upgrades: upgradesInput.data,
+    source: {
+      console_file: consoleInput.relative,
+      console_digest: consoleInput.digest,
+      dashboard_file: dashboardInput.relative,
+      dashboard_digest: dashboardInput.digest,
+      upgrades_file: upgradesInput.relative,
+      upgrades_digest: upgradesInput.digest,
+    },
+  });
+  return readonlyLocalJsonEnvelope(root, {
+    mode: 'next-action-evidence-prompts',
+    ok: prompts.ok,
+    payloadKey: 'next_action_evidence_prompts',
+    payload: prompts,
+    safety: { stage: 'Stage 143', ...prompts.boundary_assertions },
+    quality: prompts.prompts_invariants.findings,
+    action: 'next-action evidence prompts were computed read-only from local Stage 127 console JSON, local Stage 132 dashboard JSON, and local Stage 139 upgrades JSON. It only emits evidence prompt cards, copy-ready validation notes, and blocked-until conditions; no evidence sidecar, state, source, prompt/template/skill mutation, command/check/test/workflow execution, git, platform API, external network, model, MCP, or subagent action occurred.',
+  });
+}
+
+export function printNextActionEvidencePrompts(envelope) {
+  const prompts = envelope.next_action_evidence_prompts;
+  console.log('Vibecoding Runtime Next-action Evidence Prompts');
+  console.log(`Stage: ${prompts.stage}; Kind: ${prompts.prompts_kind}; pass=${prompts.ok}`);
+  console.log(`Selected next action: ${prompts.selected_next_action.id}; target=${prompts.selected_next_action.target_stage}; upgrade=${prompts.selected_next_action.upgrade_candidate}`);
+  console.log(`Evidence prompts: ${prompts.input_summary.evidence_prompt_count}; dashboard_score=${prompts.input_summary.dashboard_score}; console_next=${prompts.input_summary.console_next_action_id}`);
+  printList('Evidence prompt cards', prompts.evidence_prompt_cards, (card) => `${card.id}: ${card.severity}; ${card.prompt}`);
+  printList('Copy-ready validation notes', prompts.copy_ready_validation_notes, (note) => `${note.id}: ${note.note}`);
+  printList('Blocked until', prompts.blocked_until, (item) => `${item.id}: ${item.condition}`);
+  console.log('Boundary: writes=false; next_action_evidence_prompts_artifact=false; evidence_prompt_artifact=false; console_artifact=false; dashboard_artifact=false; upgrade_artifact=false; source_write=false; sidecar_write=false; state_directory_created=false; evidence_write=false; validation_note_write=false; command_execution=false; check_execution=false; smoke_execution=false; test_execution=false; verification_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; auto_execution=false; prompt_mutation=false; template_mutation=false; skill_mutation=false; hook_execution=false; adapter_execution=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; git=false; git_write=false; git_add=false; commit=false; pr=false; push=false; merge=false; business_source_write=false');
+  console.log(`Prompts digest: ${prompts.prompts_digest}`);
+  if (envelope.quality.length > 0) printList('Findings', envelope.quality);
+  console.log(`Action: ${envelope.action}`);
+}
+
+export function runNextActionEvidencePromptsCommand(options, deps) {
+  if (options.confirm || options.dryRun || options.write || options.preflight || options.dispatch || options.dispatchIntent || options.scan || options.once || options.run || options.autoRun || options.fromDispatch || options.dispatchEvent || options.actor || options.approval) throw new Error('workflow --next-evidence-prompts is read-only and prompt-only');
+  if (!options.fromConsole) throw new Error('workflow --next-evidence-prompts requires --from-console <local-console-json>');
+  if (!options.fromDashboard) throw new Error('workflow --next-evidence-prompts requires --from-dashboard <local-dashboard-json>');
+  if (!options.fromUpgrades) throw new Error('workflow --next-evidence-prompts requires --from-upgrades <local-upgrades-json>');
+  if (options.fromFile || options.fromTranscript || options.fromFriction || options.fromRunbook || options.fromEvidence || options.fromDiscipline || options.fromScorecard || options.fromExecutablePlan || options.fromPlan || options.fromComparison || options.fromInstallExperience || options.fromEntryDiscipline || options.fromBootstrapMatrix || options.fromEntryAcceptance || options.selectedStage || options.task || options.commitSubject || options.confirmPlan || options.fromGap || options.evidenceFile || options.diffFile || options.reviewFile || options.tddFile || options.methodologyIntent || options.methodologyKind || options.learningObservationFiles.length > 0 || options.learningInstinctFile || options.tokenCompactionFiles.length > 0 || options.prompt) throw new Error('workflow --next-evidence-prompts only accepts --from-console, --from-dashboard, --from-upgrades, --json, and --root');
+  const envelope = nextActionEvidencePromptsEnvelope(options.root, {
+    consoleFile: options.fromConsole,
+    dashboardFile: options.fromDashboard,
+    upgradesFile: options.fromUpgrades,
+  });
+  emitReadonlyLocalJsonOutput({
+    deps,
+    options,
+    channel: 'workflow',
+    envelope,
+    print: printNextActionEvidencePrompts,
+  });
+}