@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-completion-readiness-summary.mjs

@@ -0,0 +1,159 @@
+export function completionEvidenceGaps({
+  productGateResults,
+  relevantDeliveryResults,
+  relevantLocalEvidenceResults,
+  evidenceGateResults,
+  implementationPlanGate,
+  implementationAlignmentGate,
+  crossArtifactRefValidation,
+  engineeringEvidence,
+  expandedMode,
+}) {
+  return [
+    ...productGateResults.flatMap((result) => result.gaps),
+    ...relevantDeliveryResults.flatMap((result) => result.gaps),
+    ...relevantLocalEvidenceResults.flatMap((result) => result.gaps),
+    ...(expandedMode ? evidenceGateResults.flatMap((result) => result.blocked_reasons) : []),
+    ...(expandedMode ? implementationPlanGate.gaps : []),
+    ...(expandedMode ? implementationAlignmentGate.blocked_reasons : []),
+    ...(expandedMode ? crossArtifactRefValidation.blocked_reasons : []),
+    ...(engineeringEvidence.status === 'provided' ? [] : ['engineering evidence file not provided via --from-evidence']),
+  ];
+}
+
+export function completionBlockedReasons({
+  productGateResults,
+  relevantDeliveryResults,
+  evidenceGaps,
+}) {
+  return [
+    ...productGateResults.filter((result) => result.status === 'provided' && !result.gate_ok).flatMap((result) => result.blocked_reasons.map((reason) => `${result.slot}: ${reason}`)),
+    ...relevantDeliveryResults.filter((result) => result.status === 'provided' && !result.gate_ok).flatMap((result) => result.blocked_reasons.map((reason) => `${result.slot}: ${reason}`)),
+    ...evidenceGaps,
+  ];
+}
+
+function gateByKind(gates, gateKind) {
+  return gates.find((gate) => gate?.gate_kind === gateKind) || null;
+}
+
+function evidenceStatusBySlot(results, slot) {
+  return results.find((result) => result?.slot === slot)?.status || 'missing';
+}
+
+function uniqueReasons(reasons) {
+  return [...new Set(reasons.map((reason) => String(reason || '').trim()).filter(Boolean))];
+}
+
+function gateFindings(gate) {
+  return uniqueReasons([...(gate?.blocked_reasons || []), ...(gate?.findings || [])]);
+}
+
+function gateHasProvidedFailure(gate, status) {
+  return status === 'provided' && gate?.ok !== true;
+}
+
+function hasTeamModeLocalBlocker({
+  expandedMode,
+  evidenceGateResults = [],
+  relevantLocalEvidenceResults = [],
+  implementationPlanGate = {},
+  implementationAlignmentGate = {},
+}) {
+  if (!expandedMode) return false;
+  const testEvidenceGate = gateByKind(evidenceGateResults, 'test_evidence_gate');
+  const diffCoverageGate = gateByKind(evidenceGateResults, 'diff_coverage_gate');
+  const commitReadinessGate = gateByKind(evidenceGateResults, 'commit_readiness_gate');
+  const testEvidenceStatus = evidenceStatusBySlot(relevantLocalEvidenceResults, 'test_evidence');
+  const diffCoverageStatus = evidenceStatusBySlot(relevantLocalEvidenceResults, 'diff_coverage');
+  const commitReadinessStatus = evidenceStatusBySlot(relevantLocalEvidenceResults, 'commit_readiness');
+  return (
+    implementationPlanGate?.gate_ok !== true
+    || testEvidenceGate?.ok !== true
+    || diffCoverageGate?.ok !== true
+    || implementationAlignmentGate?.ok !== true
+    || gateHasProvidedFailure(commitReadinessGate, commitReadinessStatus)
+    || testEvidenceStatus !== 'provided'
+    || diffCoverageStatus !== 'provided'
+  );
+}
+
+function hasFullComplianceGap({ blockedReasons = [] }) {
+  return blockedReasons.length > 0;
+}
+
+export function completionReadinessClassification(input) {
+  const context = Array.isArray(input) ? { blockedReasons: input } : input;
+  const blockedReasons = context?.blockedReasons || [];
+  if (blockedReasons.length === 0) return 'full_compliance_ready';
+  if (hasTeamModeLocalBlocker(context || {})) return 'local_evidence_blocked';
+  if (context?.expandedMode && hasFullComplianceGap({ blockedReasons })) return 'team_mode_evidence_ready';
+  return 'full_compliance_incomplete';
+}
+
+export function nextManualActionForCompletion(input) {
+  const classification = completionReadinessClassification(input);
+  if (classification === 'full_compliance_ready') {
+    return 'full_compliance_ready: evidence chain is ready for manual review; report completion only with cited evidence, and keep verification/release/git actions explicit and manual.';
+  }
+  if (classification === 'team_mode_evidence_ready') {
+    return 'team_mode_evidence_ready: local task evidence is aligned, but full compliance evidence is incomplete. Report local task completion only with that caveat, or add the full-chain evidence before full compliance closeout.';
+  }
+  if (classification === 'local_evidence_blocked') {
+    return 'local_evidence_blocked: do not claim task completion. Fix plan, test evidence, diff coverage, task refs, changed-file coverage, or unsafe release boundary findings, then regenerate this bundle.';
+  }
+  return 'full_compliance_incomplete: add the missing product/UI/delivery/traceability/engineering evidence before full compliance closeout; keep verification/release/git actions explicit and manual.';
+}
+
+function localEvidenceMissingReasons({
+  expandedMode,
+  evidenceGateResults = [],
+  relevantLocalEvidenceResults = [],
+  implementationPlanGate = {},
+  implementationAlignmentGate = {},
+}) {
+  const reasons = [];
+  if (expandedMode) {
+    for (const slot of ['implementation_plan', 'test_evidence', 'diff_coverage']) {
+      const result = relevantLocalEvidenceResults.find((item) => item?.slot === slot);
+      if (result?.status !== 'provided') reasons.push(`${slot} file not provided`);
+    }
+    if (implementationPlanGate?.gate_ok !== true) reasons.push(...(implementationPlanGate.gaps || implementationPlanGate.blocked_reasons || []));
+    for (const kind of ['test_evidence_gate', 'diff_coverage_gate']) {
+      const gate = gateByKind(evidenceGateResults, kind);
+      if (gate?.ok !== true) reasons.push(...gateFindings(gate));
+    }
+    if (implementationAlignmentGate?.ok !== true) reasons.push(...(implementationAlignmentGate.blocked_reasons || []));
+  }
+  return uniqueReasons(reasons);
+}
+
+function unsafeReleaseActionReasons({ evidenceGateResults = [], relevantLocalEvidenceResults = [] }) {
+  const commitReadinessStatus = evidenceStatusBySlot(relevantLocalEvidenceResults, 'commit_readiness');
+  if (commitReadinessStatus !== 'provided') return [];
+  const commitReadinessGate = gateByKind(evidenceGateResults, 'commit_readiness_gate');
+  if (commitReadinessGate?.ok === true) return [];
+  return gateFindings(commitReadinessGate).filter((reason) => /commit|git|push|pr|merge|release|authorized|boundary/i.test(reason));
+}
+
+export function completionTaskSummary(input = {}) {
+  const context = Array.isArray(input) ? { blockedReasons: input } : input;
+  const blockedReasons = uniqueReasons(context?.blockedReasons || []);
+  const minimumLocalEvidenceMissing = localEvidenceMissingReasons(context || {});
+  const unsafeReleaseActionsDetected = unsafeReleaseActionReasons(context || {});
+  const excludedFromFullCompliance = new Set([...minimumLocalEvidenceMissing, ...unsafeReleaseActionsDetected]);
+  const fullComplianceEvidenceMissing = blockedReasons.filter((reason) => !excludedFromFullCompliance.has(reason));
+  const readinessClassification = completionReadinessClassification(context || {});
+  return {
+    readiness_classification: readinessClassification,
+    local_task_ready: ['full_compliance_ready', 'team_mode_evidence_ready'].includes(readinessClassification),
+    minimum_local_evidence_missing: minimumLocalEvidenceMissing,
+    full_compliance_evidence_missing: fullComplianceEvidenceMissing,
+    unsafe_release_actions_detected: unsafeReleaseActionsDetected,
+    manual_next_action: nextManualActionForCompletion(context || {}),
+  };
+}
+
+export const completionAllowedFollowup = ['manual evidence review', 'vibe-verification-before-completion', 'vibe-finishing-a-development-branch after explicit user confirmation', 'manual implementation fix after user decision'];
+
+export const completionForbiddenActions = ['execute_tests', 'run_browser', 'run_git', 'git_add', 'commit', 'push', 'pr', 'merge', 'tag', 'history_rewrite', 'write_state', 'invoke_model', 'call_platform_api', 'dispatch_subagent', 'call_mcp', 'mutate_business_source'];

package/tools/vibe-runtime/runtime-confirmed-one-shot-plan.mjs

@@ -0,0 +1,300 @@
+import crypto from 'node:crypto';
+
+const confirmedOneShotPlanStage = 'Stage 108';
+const confirmedOneShotPlanKind = 'confirmed-one-shot-execution-plan';
+
+export function runtimeConfirmedOneShotPlan({ commitReadiness = {}, automationReadiness = {}, registry = {}, registryDigest = '', confirmation = {} } = {}) {
+  const boundaryAssertions = runtimeConfirmedOneShotPlanBoundaryAssertions();
+  const confirmationGate = confirmationGateContract(confirmation);
+  const plannedSteps = plannedExecutionSteps(commitReadiness);
+  const preflightEvidence = preflightEvidenceExpectations(commitReadiness);
+  const plan = {
+    version: 1,
+    stage: confirmedOneShotPlanStage,
+    plan_kind: confirmedOneShotPlanKind,
+    source_bindings: {
+      commit_readiness_stage: commitReadiness.stage || '',
+      commit_readiness_kind: commitReadiness.readiness_kind || '',
+      commit_readiness_digest: commitReadiness.commit_readiness_digest || '',
+      automation_readiness_stage: automationReadiness.stage || '',
+      automation_readiness_kind: automationReadiness.readiness_kind || '',
+      automation_readiness_digest: automationReadiness.readiness_digest || '',
+      registry_stage: registry.registry_stage || '',
+      registry_kind: registry.registry_kind || '',
+      registry_version: registry.registry_version || 0,
+      registry_digest: registryDigest,
+    },
+    confirmation_gate: confirmationGate,
+    execution_contract: {
+      plan_confirmed: confirmationGate.confirm_plan_received === true,
+      confirmation_scope: 'create confirmed one-shot execution plan contract only',
+      confirmation_does_not_execute: true,
+      actions_executed: false,
+      execution_authorized: false,
+      check_execution_authorized: false,
+      git_write_authorized: false,
+      commit_authorized: false,
+      push_authorized: false,
+      pr_authorized: false,
+      merge_authorized: false,
+    },
+    planned_steps: plannedSteps,
+    preflight_evidence_expectations: preflightEvidence,
+    execution_order: plannedSteps.map((item) => item.id),
+    recovery_notes: recoveryNotes(plannedSteps),
+    readiness_state: readinessState({ commitReadiness, confirmationGate, plannedSteps }),
+    next_manual_action: nextManualAction({ confirmationGate, plannedSteps }),
+    allowed_followup: ['manual execution outside Stage 108 after fresh evidence review', 'vibe-verification-before-completion', 'vibe-finishing-a-development-branch'],
+    forbidden_actions: [
+      'executing planned steps from Stage 108',
+      'running checks, tests, repair, formatting, or code generation',
+      'git command, commit, push, PR, merge, tag, reset, checkout, or history rewrite',
+      'sidecar or .vibecoding-state write',
+      'scheduler, daemon, retry, platform API, external network, model, MCP, or subagent invocation',
+      'treating --confirm-plan as --confirm or as action execution approval',
+    ],
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeConfirmedOneShotPlanInvariants(plan);
+  return {
+    ...plan,
+    plan_invariants: invariants,
+    manual_action: invariants.pass
+      ? 'Confirmed one-shot execution plan contract is valid. It confirms the plan shape only; Stage 108 did not execute checks, git, or source changes.'
+      : 'Fix the listed confirmed one-shot plan gaps before using this contract for any manual execution discussion.',
+  };
+}
+
+export function runtimeConfirmedOneShotPlanInvariants(plan) {
+  const steps = plan.planned_steps || [];
+  const missingSourceBindings = ['commit_readiness_digest', 'automation_readiness_digest', 'registry_digest']
+    .filter((key) => !plan.source_bindings?.[key]);
+  const incompleteSteps = steps
+    .filter((item) => !item.id || !item.step_kind || !item.status || item.execution_authorized !== false || item.actions_executed !== false)
+    .map((item) => item.id || item.step_kind || 'unknown');
+  const executableSteps = steps
+    .filter((item) => item.execution_authorized !== false || item.actions_executed !== false)
+    .map((item) => item.id || item.step_kind || 'unknown');
+  const writableBoundaries = Object.entries(plan.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const forbiddenMissing = ['one_shot_execution_artifact', 'one_shot_execution_plan_artifact', 'command_execution', 'test_execution', 'git', 'git_write', 'commit', 'push', 'pr', 'merge', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'business_source_write']
+    .filter((key) => plan.boundary_assertions?.[key] !== false);
+  const contract = plan.execution_contract || {};
+  const findings = [
+    ...(plan.confirmation_gate?.confirm_plan_received !== true ? ['confirm_plan gate must be present before Stage 108 can mark plan_confirmed=true'] : []),
+    ...(contract.plan_confirmed !== true ? ['execution_contract.plan_confirmed must be true after --confirm-plan'] : []),
+    ...(contract.confirmation_does_not_execute !== true ? ['confirmation must explicitly not execute actions'] : []),
+    ...(contract.actions_executed !== false ? ['actions_executed must remain false'] : []),
+    ...(contract.execution_authorized !== false ? ['execution_authorized must remain false'] : []),
+    ...(contract.check_execution_authorized !== false ? ['check_execution_authorized must remain false'] : []),
+    ...(contract.git_write_authorized !== false ? ['git_write_authorized must remain false'] : []),
+    ...(contract.commit_authorized !== false ? ['commit_authorized must remain false'] : []),
+    ...(steps.length === 0 ? ['planned_steps must not be empty'] : []),
+    ...missingSourceBindings.map((item) => `missing source binding: ${item}`),
+    ...incompleteSteps.map((item) => `incomplete or executable planned step: ${item}`),
+    ...executableSteps.map((item) => `planned step must not execute: ${item}`),
+    ...writableBoundaries.map((item) => `boundary assertion must remain false: ${item}`),
+    ...forbiddenMissing.map((item) => `forbidden boundary missing or not false: ${item}`),
+  ];
+  return {
+    pass: findings.length === 0,
+    checked: [
+      'commit_readiness_binding',
+      'automation_readiness_binding',
+      'confirm_plan_gate',
+      'plan_confirmed_not_executed',
+      'planned_steps_not_executed',
+      'read_only_boundary_assertions',
+    ],
+    findings,
+  };
+}
+
+export function runtimeConfirmedOneShotPlanBoundaryAssertions() {
+  return {
+    confirmed_one_shot_plan_artifact: false,
+    one_shot_execution_plan_artifact: false,
+    one_shot_execution_artifact: false,
+    execution_artifact: false,
+    commit_readiness_artifact: false,
+    commit_artifact: false,
+    test_result_artifact: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    test_execution: false,
+    verification_execution: false,
+    repair_execution: false,
+    formatting_execution: false,
+    code_generation: false,
+    runtime_action: false,
+    workflow_execution: false,
+    scheduler: false,
+    daemon: false,
+    retry: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    history_rewrite: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+export function runtimeConfirmedOneShotPlanDigestPayload(plan) {
+  return {
+    stage: plan.stage,
+    plan_kind: plan.plan_kind,
+    source_bindings: plan.source_bindings,
+    confirmation_gate: plan.confirmation_gate,
+    execution_contract: plan.execution_contract,
+    planned_steps: plan.planned_steps,
+    preflight_evidence_expectations: plan.preflight_evidence_expectations,
+    execution_order: plan.execution_order,
+    recovery_notes: plan.recovery_notes,
+    readiness_state: plan.readiness_state,
+    allowed_followup: plan.allowed_followup,
+    forbidden_actions: plan.forbidden_actions,
+    boundary_assertions: plan.boundary_assertions,
+    plan_invariants: plan.plan_invariants,
+  };
+}
+
+export function digestConfirmedOneShotPlan(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function confirmationGateContract(confirmation) {
+  const phrase = String(confirmation.confirmPlan || '').trim();
+  return {
+    gate_kind: 'confirm-plan-contract-only',
+    confirm_plan_received: phrase.length > 0,
+    confirmation_phrase_digest: phrase ? digestConfirmedOneShotPlan({ confirm_plan: phrase }) : '',
+    confirmation_scope: 'confirmed plan contract generation',
+    plan_confirmed: phrase.length > 0,
+    actions_executed: false,
+    execution_authorized: false,
+  };
+}
+
+function plannedExecutionSteps(commitReadiness) {
+  const readinessGates = commitReadiness.readiness_gates || [];
+  const baseSteps = readinessGates.map((gate, index) => ({
+    id: `stage108-step-${String(index + 1).padStart(2, '0')}-${slug(gate.gate_kind || gate.id || 'gate')}`,
+    step_kind: gate.gate_kind || 'readiness-gate',
+    title: `Confirm evidence for ${gate.gate_kind || gate.id || 'readiness gate'}`,
+    source_gate_id: gate.id || '',
+    source_status: gate.status || '',
+    required_evidence: gate.required_evidence || 'fresh manual evidence required',
+    status: 'planned_not_executed',
+    actions_executed: false,
+    execution_authorized: false,
+    check_execution_authorized: false,
+    git_write_authorized: false,
+    stop_conditions: [
+      'fresh evidence is missing or stale',
+      'step would require Stage 108 to run commands or edit files',
+      'step would require git write, platform, network, model, MCP, or subagent access',
+    ],
+  }));
+  return [
+    ...baseSteps,
+    {
+      id: `stage108-step-${String(baseSteps.length + 1).padStart(2, '0')}-manual-execution-boundary`,
+      step_kind: 'manual-execution-boundary',
+      title: 'Keep confirmed one-shot execution outside Stage 108 runtime command',
+      source_gate_id: '',
+      source_status: 'manual_boundary_required',
+      required_evidence: 'explicit human decision outside this read-only contract before any real execution',
+      status: 'planned_not_executed',
+      actions_executed: false,
+      execution_authorized: false,
+      check_execution_authorized: false,
+      git_write_authorized: false,
+      stop_conditions: [
+        'user asks Stage 108 command to execute actions',
+        'execution would create sidecars, run checks, or call git',
+        'requested action changes source, platform, network, model, MCP, or subagent state',
+      ],
+    },
+  ];
+}
+
+function preflightEvidenceExpectations(commitReadiness) {
+  const bundle = commitReadiness.evidence_bundle_requirements || {};
+  const gateEvidence = Array.isArray(bundle.gate_evidence) ? bundle.gate_evidence : [];
+  const bundleItems = gateEvidence.map((item, index) => ({
+    id: `stage108-evidence-${String(index + 1).padStart(2, '0')}`,
+    source: item.gate_id || item.evidence_id || item.category || 'commit-readiness-evidence',
+    required_evidence: item.required_evidence || item.evidence_required || 'fresh manual evidence required',
+    collected_by_stage_108: false,
+    execution_authorized: false,
+  }));
+  return [
+    ...bundleItems,
+    {
+      id: `stage108-evidence-${String(bundleItems.length + 1).padStart(2, '0')}`,
+      source: 'worktree-snapshot',
+      required_evidence: 'fresh git status --short, git diff --stat, and git diff --check captured manually outside Stage 108',
+      collected_by_stage_108: false,
+      execution_authorized: false,
+    },
+  ];
+}
+
+function readinessState({ commitReadiness, confirmationGate, plannedSteps }) {
+  const commitReadinessPass = commitReadiness.readiness_invariants?.pass === true;
+  const blockedStepCount = plannedSteps.filter((item) => item.source_status === 'blocked').length;
+  const evidenceRequiredCount = plannedSteps.filter((item) => item.source_status === 'evidence_required' || item.source_status === 'manual_boundary_required').length;
+  return {
+    plan_contract_valid: commitReadinessPass && confirmationGate.confirm_plan_received === true,
+    plan_confirmed: confirmationGate.confirm_plan_received === true,
+    actions_executed: false,
+    execution_authorized: false,
+    commit_readiness_pass: commitReadinessPass,
+    blocked_step_count: blockedStepCount,
+    manual_evidence_required_count: evidenceRequiredCount,
+    ready_for_manual_discussion: commitReadinessPass && confirmationGate.confirm_plan_received === true,
+    ready_for_runtime_execution: false,
+  };
+}
+
+function recoveryNotes(plannedSteps) {
+  return plannedSteps.map((item) => ({
+    step_id: item.id,
+    recovery: 'Stop and return to the earliest missing evidence gate; do not let Stage 108 repair, retry, or execute the step.',
+    rollback_required: false,
+    rollback_performed: false,
+  }));
+}
+
+function nextManualAction({ confirmationGate, plannedSteps }) {
+  if (!confirmationGate.confirm_plan_received) return 'Provide --confirm-plan <phrase> to confirm plan-contract generation only; this will still not execute actions.';
+  if (plannedSteps.length === 0) return 'Return to Stage 107 and build commit readiness before confirming a one-shot plan.';
+  return 'Review the confirmed plan contract and collect fresh evidence manually before any execution outside Stage 108.';
+}
+
+function slug(value) {
+  const normalized = String(value || '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+  return normalized || 'step';
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+  if (value && typeof value === 'object') return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  return JSON.stringify(value);
+}

package/tools/vibe-runtime/runtime-context-budget-entry-defaults-command.mjs

@@ -0,0 +1,77 @@
+import {
+  ensureRoot,
+  localJsonFileWithinRoot,
+} from './runtime-local-json-input.mjs';
+import {
+  emitReadonlyLocalJsonOutput,
+  readonlyLocalJsonEnvelope,
+} from './runtime-readonly-local-json-output-envelope.mjs';
+import {
+  runtimeContextBudgetEntryDefaults,
+} from './runtime-context-budget-entry-defaults.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 contextBudgetEntryDefaultsEnvelope(root, { budgetFile = '', scorecardFile = '' } = {}) {
+  ensureRoot(root);
+  if (!budgetFile) throw new Error('tokens --entry-defaults requires --from-budget <local-token-budget-json>');
+  if (!scorecardFile) throw new Error('tokens --entry-defaults requires --from-scorecard <local-parity-scorecard-json>');
+  const budgetInput = localJsonFileWithinRoot(root, budgetFile, 'tokens --entry-defaults --from-budget');
+  const scorecardInput = localJsonFileWithinRoot(root, scorecardFile, 'tokens --entry-defaults --from-scorecard');
+  const defaults = runtimeContextBudgetEntryDefaults({
+    budget: budgetInput.data,
+    scorecard: scorecardInput.data,
+    source: {
+      budget_file: budgetInput.relative,
+      budget_digest: budgetInput.digest,
+      scorecard_file: scorecardInput.relative,
+      scorecard_digest: scorecardInput.digest,
+    },
+  });
+  return readonlyLocalJsonEnvelope(root, {
+    mode: 'context-budget-entry-defaults',
+    ok: defaults.ok,
+    payloadKey: 'context_budget_entry_defaults',
+    payload: defaults,
+    safety: { stage: 'Stage 144', ...defaults.boundary_assertions },
+    quality: defaults.entry_defaults_invariants.findings,
+    action: 'context budget entry defaults were computed read-only from local Stage 128 token budget JSON and local Stage 140 parity scorecard JSON. It only recommends which lightweight entry context to surface now, which skill/context blocks to defer until needed, and the fixed token-saving boundary; no embeddings, model, remote config, prompt/template/skill/hook mutation, full skill injection, command/check/test/workflow execution, state/source/artifact writes, git, platform API, MCP, or subagent action occurred.',
+  });
+}
+
+export function printContextBudgetEntryDefaults(envelope) {
+  const defaults = envelope.context_budget_entry_defaults;
+  console.log('Vibecoding Runtime Context Budget Entry Defaults');
+  console.log(`Stage: ${defaults.stage}; Kind: ${defaults.defaults_kind}; pass=${defaults.ok}`);
+  console.log(`Recommended profile: ${defaults.recommended_profile}; budget_profile=${defaults.input_summary.budget_recommended_profile}; max_context_tokens=${defaults.input_summary.budget_max_context_tokens}`);
+  console.log(`Inputs: budget=${defaults.input_summary.budget_stage}; scorecard=${defaults.input_summary.scorecard_stage}; token_axis=${defaults.input_summary.token_context_axis_score}`);
+  printList('Surface now', defaults.surface_now, (item) => `${item.id}: ${item.default}`);
+  printList('Defer until needed', defaults.defer_until_needed, (item) => `${item.id}: ${item.defer}; until=${item.until}`);
+  printList('Token saving boundary', defaults.token_saving_boundary, (item) => `${item.id}: ${item.boundary}`);
+  console.log('Boundary: writes=false; context_budget_entry_defaults_artifact=false; prompt_mutation=false; template_mutation=false; skill_mutation=false; hook_execution=false; adapter_execution=false; full_skill_injection=false; command_execution=false; check_execution=false; test_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; dynamic_tool_execution=false; embeddings=false; remote_config=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; git=false; git_write=false; commit=false; pr=false; push=false; merge=false; business_source_write=false');
+  console.log(`Entry defaults digest: ${defaults.entry_defaults_digest}`);
+  if (envelope.quality.length > 0) printList('Findings', envelope.quality);
+  console.log(`Action: ${envelope.action}`);
+}
+
+export function runContextBudgetEntryDefaultsCommand(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('tokens --entry-defaults is read-only and defaults-only');
+  if (!options.fromBudget) throw new Error('tokens --entry-defaults requires --from-budget <local-token-budget-json>');
+  if (!options.fromScorecard) throw new Error('tokens --entry-defaults requires --from-scorecard <local-parity-scorecard-json>');
+  if (options.fromFile || options.fromTranscript || options.fromFriction || options.fromConsole || options.fromTokenBudget || options.fromLearningPattern || options.fromRunbook || options.fromEvidence || options.fromDiscipline || options.fromExecutablePlan || options.fromPlan || options.fromComparison || options.fromDashboard || options.fromInstallExperience || options.fromEntryDiscipline || options.fromUpgrades || 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 || options.tokenCommandName || options.tokenProfileName || options.tokenFile) throw new Error('tokens --entry-defaults only accepts --from-budget, --from-scorecard, --json, and --root');
+  const envelope = contextBudgetEntryDefaultsEnvelope(options.root, {
+    budgetFile: options.fromBudget,
+    scorecardFile: options.fromScorecard,
+  });
+  emitReadonlyLocalJsonOutput({
+    deps,
+    options,
+    channel: 'tokens',
+    envelope,
+    print: printContextBudgetEntryDefaults,
+  });
+}