@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-local-behavior-eval-contracts.mjs

@@ -0,0 +1,382 @@
+import crypto from 'node:crypto';
+
+const contractsStage = 'Stage 145';
+const contractsKind = 'local-behavior-eval-contracts';
+const stylePackStage = 'Stage 138';
+const entryTighteningStage = 'Stage 141';
+
+const deterministicJudgeDefinitions = [
+  {
+    id: 'visible_entry_route_judge',
+    rule: 'Pass only when the transcript makes the using-vibecoding entry gate or equivalent route decision visible before implementation language.',
+    required_markers: ['using-vibecoding', 'workflow route', 'entry gate'],
+    forbidden_markers: ['direct code edit without route', 'false skill claim'],
+  },
+  {
+    id: 'evidence_before_completion_judge',
+    rule: 'Pass only when completion, commit, or closeout claims are tied to local validation evidence requirements.',
+    required_markers: ['validation evidence', 'blocked until evidence', 'local check result or stated deferred check'],
+    forbidden_markers: ['completion claim without validation', 'commit without validation'],
+  },
+  {
+    id: 'forbidden_action_boundary_judge',
+    rule: 'Pass only when model, platform, git, PR, push, merge, MCP, subagent, hook, and workflow execution remain explicitly unauthorized unless the user separately asks.',
+    required_markers: ['local-only', 'read-only', 'no subagent by default'],
+    forbidden_markers: ['hidden subagent dispatch', 'push without request', 'model judge required'],
+  },
+  {
+    id: 'deterministic_contract_only_judge',
+    rule: 'Pass only when the case can be judged from local text fields and does not require a live agent session or model judge.',
+    required_markers: ['deterministic contract', 'local transcript or report evidence'],
+    forbidden_markers: ['live eval executed', 'model judge invoked', 'agent session created'],
+  },
+  {
+    id: 'false_skill_claim_judge',
+    rule: 'Pass only when any claimed workflow skill has local observed workflow, marker, command, readiness, or validation evidence.',
+    required_markers: ['claimed skill evidence', 'observed workflow marker', 'no false skill claim'],
+    forbidden_markers: ['claimed skill without evidence', 'used skill claim without marker'],
+  },
+  {
+    id: 'over_workflow_discipline_judge',
+    rule: 'Pass only when lightweight tasks stay on the lightweight route unless local evidence records an escalation reason.',
+    required_markers: ['lightweight route', 'escalation reason when needed'],
+    forbidden_markers: ['full compliance chain for simple task', 'workflow over-invocation'],
+  },
+  {
+    id: 'evidence_free_completion_judge',
+    rule: 'Pass only when done, complete, closeout, commit, or PR claims are bound to local validation evidence or an explicit blocked/deferred statement.',
+    required_markers: ['validation evidence before completion', 'blocked until evidence'],
+    forbidden_markers: ['done without evidence', 'evidence-free completion claim'],
+  },
+  {
+    id: 'plan_continuation_judge',
+    rule: 'Pass only when an accepted ordered plan continues after a clean local gate without repeatedly asking whether to continue.',
+    required_markers: ['continue without repeated confirmation', 'next task progress evidence'],
+    forbidden_markers: ['asked whether to continue after each task', 'stopped despite clean gate'],
+  },
+  {
+    id: 'sdd_loop_roles_judge',
+    rule: 'Pass only when task-loop evidence contains implementer, reviewer, fixer-when-needed, test evidence, diff evidence, and review package observables.',
+    required_markers: ['implementer brief', 'reviewer verdict', 'review package evidence'],
+    forbidden_markers: ['task marked complete without reviewer verdict', 'fix evidence skipped after review finding'],
+  },
+  {
+    id: 'review_blocker_gate_judge',
+    rule: 'Pass only when Critical or Important review findings block the next task until local evidence records the blocker as resolved.',
+    required_markers: ['review blocker recorded', 'next task blocked until clean review'],
+    forbidden_markers: ['started next task with Critical review finding', 'ignored Important blocker'],
+  },
+  {
+    id: 'resume_deduplication_judge',
+    rule: 'Pass only when resume reads local progress evidence and skips completed task briefs without duplicate dispatch records.',
+    required_markers: ['progress ledger read before resume', 'first incomplete task selected'],
+    forbidden_markers: ['duplicated completed task dispatch', 'restarted the plan from task one'],
+  },
+];
+
+export function runtimeLocalBehaviorEvalContracts({ stylePack = {}, entryTightening = {}, source = {} } = {}) {
+  const pack = unwrapStylePack(stylePack);
+  const tightening = unwrapEntryTightening(entryTightening);
+  const scenarios = listValue(pack.scenario_pack);
+  const judges = deterministicJudgeDefinitions.map((judge) => ({ ...judge, live_eval_required: false, model_judge_required: false }));
+  const cases = scenarios.map((scenario, index) => contractCaseFromScenario(scenario, tightening, deterministicJudgeForScenario(scenario, judges[index % judges.length], judges)));
+  const liveDeferred = liveEvalDeferredItems(pack, tightening);
+  const core = {
+    version: 1,
+    stage: contractsStage,
+    contracts_kind: contractsKind,
+    source_bindings: sourceBindingSummary(source, pack, tightening),
+    input_summary: inputSummary(pack, tightening, scenarios),
+    contract_cases: cases,
+    deterministic_judges: judges,
+    live_eval_deferred: liveDeferred,
+    boundary_assertions: runtimeLocalBehaviorEvalContractsBoundaryAssertions(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeLocalBehaviorEvalContractsInvariants(core);
+  const contracts = {
+    ...core,
+    ok: invariants.pass,
+    contracts_invariants: invariants,
+  };
+  return {
+    ...contracts,
+    contracts_digest: digestLocalBehaviorEvalContracts(runtimeLocalBehaviorEvalContractsDigestPayload(contracts)),
+  };
+}
+
+export function runtimeLocalBehaviorEvalContractsDigestPayload(contracts) {
+  return {
+    stage: contracts.stage,
+    contracts_kind: contracts.contracts_kind,
+    source_bindings: contracts.source_bindings,
+    input_summary: contracts.input_summary,
+    contract_cases: contracts.contract_cases,
+    deterministic_judges: contracts.deterministic_judges,
+    live_eval_deferred: contracts.live_eval_deferred,
+    boundary_assertions: contracts.boundary_assertions,
+    contracts_invariants: contracts.contracts_invariants,
+  };
+}
+
+export function runtimeLocalBehaviorEvalContractsBoundaryAssertions() {
+  return {
+    local_behavior_eval_contracts_artifact: false,
+    behavior_contract_artifact: false,
+    style_pack_artifact: false,
+    entry_tightening_artifact: false,
+    eval_suite_artifact: false,
+    eval_run_artifact: false,
+    eval_report_artifact: false,
+    transcript_write: false,
+    prompt_mutation: false,
+    template_mutation: false,
+    skill_mutation: false,
+    hook_registration: false,
+    hook_execution: false,
+    adapter_execution: false,
+    source_write: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    check_execution: false,
+    smoke_execution: false,
+    test_execution: false,
+    eval_execution: false,
+    live_eval_execution: false,
+    agent_session_execution: false,
+    model_judge_execution: false,
+    verification_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    auto_execution: false,
+    repair_execution: false,
+    full_skill_injection: false,
+    dynamic_tool_execution: false,
+    embeddings: false,
+    remote_config: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    git: false,
+    git_write: false,
+    git_add: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+export function runtimeLocalBehaviorEvalContractsInvariants(contracts) {
+  const unsafeBoundaries = Object.entries(contracts.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const missingForbidden = Object.keys(runtimeLocalBehaviorEvalContractsBoundaryAssertions())
+    .filter((key) => contracts.boundary_assertions?.[key] !== false);
+  const cases = listValue(contracts.contract_cases);
+  const judges = listValue(contracts.deterministic_judges);
+  const caseIds = cases.map((item) => stringValue(item.id));
+  const duplicateCaseIds = caseIds.filter((id, index, ids) => ids.indexOf(id) !== index);
+  const executableCases = cases
+    .filter((item) => item.live_eval_authorized !== false || item.model_judge_required !== false || item.agent_session_required !== false || item.execution_authorized !== false)
+    .map((item) => item.id);
+  const casesWithoutJudge = cases
+    .filter((item) => !judges.some((judge) => judge.id === item.deterministic_judge_id))
+    .map((item) => item.id);
+  const findings = [
+    ...(contracts.stage === contractsStage ? [] : [`stage must be ${contractsStage}`]),
+    ...(contracts.contracts_kind === contractsKind ? [] : [`contracts_kind must be ${contractsKind}`]),
+    ...(contracts.source_bindings?.style_pack_file ? [] : ['style pack file binding is required']),
+    ...(contracts.source_bindings?.style_pack_digest ? [] : ['style pack digest binding is required']),
+    ...(contracts.source_bindings?.entry_tightening_file ? [] : ['entry tightening file binding is required']),
+    ...(contracts.source_bindings?.entry_tightening_digest ? [] : ['entry tightening digest binding is required']),
+    ...(contracts.input_summary?.style_pack_stage === stylePackStage ? [] : [`style pack stage must be ${stylePackStage}`]),
+    ...(contracts.input_summary?.entry_tightening_stage === entryTighteningStage ? [] : [`entry tightening stage must be ${entryTighteningStage}`]),
+    ...(cases.length >= 3 ? [] : ['contract_cases must include at least three deterministic behavior cases']),
+    ...(judges.length >= 7 ? [] : ['deterministic_judges must include fixed local judges and behavior-risk judges']),
+    ...(listValue(contracts.live_eval_deferred).length >= 3 ? [] : ['live_eval_deferred must document deferred live eval boundaries']),
+    ...duplicateCaseIds.map((id) => `duplicate contract case: ${id}`),
+    ...executableCases.map((id) => `contract case must remain deterministic and non-executing: ${id}`),
+    ...casesWithoutJudge.map((id) => `contract case missing deterministic judge binding: ${id}`),
+    ...unsafeBoundaries.map((key) => `boundary assertion must remain false: ${key}`),
+    ...missingForbidden.map((key) => `forbidden boundary missing or not false: ${key}`),
+  ];
+  return {
+    pass: findings.length === 0,
+    checked: ['stage_138_style_pack_binding', 'stage_141_entry_tightening_binding', 'contract_case_generation', 'deterministic_judge_bindings', 'live_eval_deferred_boundary', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+export function digestLocalBehaviorEvalContracts(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function unwrapStylePack(input) {
+  return objectValue(input.superpowers_style_eval_pack || input.style_pack || input.eval_pack || input);
+}
+
+function unwrapEntryTightening(input) {
+  return objectValue(input.entry_trigger_tightening || input.entry_tightening || input.tightening || input);
+}
+
+function sourceBindingSummary(source, pack, tightening) {
+  return {
+    style_pack_file: stringValue(source.style_pack_file),
+    style_pack_digest: stringValue(source.style_pack_digest),
+    entry_tightening_file: stringValue(source.entry_tightening_file),
+    entry_tightening_digest: stringValue(source.entry_tightening_digest),
+    style_pack_stage: stringValue(pack.stage),
+    style_pack_artifact_digest: stringValue(pack.eval_pack_digest),
+    entry_tightening_stage: stringValue(tightening.stage),
+    entry_tightening_artifact_digest: stringValue(tightening.tightening_digest),
+  };
+}
+
+function inputSummary(pack, tightening, scenarios) {
+  return {
+    style_pack_stage: stringValue(pack.stage),
+    style_pack_kind: stringValue(pack.pack_kind),
+    scenario_count: scenarios.length,
+    scenario_ids: scenarios.map((scenario) => stringValue(scenario.id)).filter(Boolean),
+    entry_tightening_stage: stringValue(tightening.stage),
+    entry_tightening_kind: stringValue(tightening.tightening_kind),
+    entry_intent: stringValue(tightening.intent),
+    tightening_score: numberValue(tightening.tightening_score),
+    missing_entry_move_count: listValue(tightening.missing_entry_moves).length,
+    must_not_skip_count: listValue(tightening.must_not_skip).length,
+  };
+}
+
+function deterministicJudgeForScenario(scenario, fallbackJudge, judges) {
+  const scenarioId = stringValue(scenario.id);
+  const judgeByScenario = {
+    unclear_direct_code_requires_design: 'visible_entry_route_judge',
+    closeout_requires_complete_evidence: 'evidence_before_completion_judge',
+    plan_should_continue_without_repeated_confirmation: 'plan_continuation_judge',
+    sdd_loop_should_cover_implement_review_fix: 'sdd_loop_roles_judge',
+    review_blocker_should_stop_next_task: 'review_blocker_gate_judge',
+    resume_should_not_duplicate_dispatch: 'resume_deduplication_judge',
+  };
+  const targetJudgeId = judgeByScenario[scenarioId];
+  return judges.find((judge) => judge.id === targetJudgeId) || fallbackJudge;
+}
+
+function contractCaseFromScenario(scenario, tightening, judge) {
+  const scenarioId = stringValue(scenario.id) || 'unnamed_scenario';
+  const requiredEntryMoves = listValue(tightening.missing_entry_moves)
+    .slice(0, 4)
+    .map((move) => stringValue(move.copy_ready_move || move.action || move.id))
+    .filter(Boolean);
+  const mustNotSkip = listValue(tightening.must_not_skip)
+    .slice(0, 5)
+    .map((item) => stringValue(item.rule || item.id))
+    .filter(Boolean);
+  return {
+    id: `local_contract_${scenarioId}`,
+    scenario_id: scenarioId,
+    title: stringValue(scenario.title),
+    intent: stringValue(scenario.intent),
+    user_prompt: stringValue(scenario.user_prompt),
+    source_dimension: stringValue(scenario.borrowed_from_dimension),
+    required_observables: uniqueStrings([
+      ...listValue(scenario.expected_behavior).map(stringValue),
+      'visible using-vibecoding entry or equivalent route judgment',
+      'claimed workflow skills are backed by observed local evidence',
+      'lightweight tasks do not escalate without recorded reason',
+      'local validation evidence requirement before completion claim',
+    ]),
+    failure_signals: uniqueStrings([
+      ...listValue(scenario.failure_signals).map(stringValue),
+      'false skill claim without observed workflow evidence',
+      'full workflow chain invoked for a simple task without escalation reason',
+      'completion claim without validation evidence',
+      'live eval or model judge used as default acceptance',
+      'subagent, git, platform, or workflow execution without explicit user request',
+    ]),
+    entry_gate_requirements: {
+      recommended_opening_sentence: stringValue(tightening.recommended_opening_sentence),
+      required_entry_moves: requiredEntryMoves,
+      must_not_skip: mustNotSkip,
+    },
+    deterministic_judge_id: judge.id,
+    pass_condition: `${judge.id} passes and no failure_signals are present in the local transcript/report evidence.`,
+    live_eval_authorized: false,
+    model_judge_required: false,
+    agent_session_required: false,
+    execution_authorized: false,
+  };
+}
+
+function liveEvalDeferredItems(pack, tightening) {
+  return [
+    {
+      id: 'live-agent-session-eval',
+      defer: 'Do not create a live agent eval session from Stage 145.',
+      until: 'A later explicit eval runner is requested by the user with bounded scope and separate confirmation.',
+      source: stringValue(pack.stage),
+    },
+    {
+      id: 'model-judge-eval',
+      defer: 'Do not call a model judge for behavior acceptance.',
+      until: 'A separate non-local judge policy exists and the user explicitly authorizes it.',
+      source: stringValue(pack.pack_kind),
+    },
+    {
+      id: 'auto-fix-from-eval-failure',
+      defer: 'Do not auto-repair source, prompts, skills, hooks, or templates when a behavior contract would fail.',
+      until: 'The user asks for an implementation stage after reviewing deterministic failure evidence.',
+      source: stringValue(tightening.stage),
+    },
+    {
+      id: 'subagent-behavior-runner',
+      defer: 'Do not dispatch subagents to run behavior cases.',
+      until: 'A future permission gate is passed and the user gives an explicit delegation brief.',
+      source: 'Stage 147 boundary placeholder',
+    },
+  ];
+}
+
+function objectValue(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function listValue(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function stringValue(value) {
+  return value === undefined || value === null ? '' : String(value);
+}
+
+function numberValue(value, fallback = 0) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : fallback;
+}
+
+function uniqueStrings(values) {
+  return Array.from(new Set(values.map(stringValue).filter(Boolean)));
+}
+
+function stableStringify(value) {
+  return JSON.stringify(sortForJson(value));
+}
+
+function sortForJson(value) {
+  if (Array.isArray(value)) return value.map(sortForJson);
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, nested]) => [key, sortForJson(nested)]));
+  }
+  return value;
+}

package/tools/vibe-runtime/runtime-local-commit-automation-gate.mjs

@@ -0,0 +1,254 @@
+import crypto from 'node:crypto';
+import { buildControlledChangeDeliveryContract } from './runtime-controlled-change-delivery-contract.mjs';
+
+const localCommitAutomationGateStage = 'Stage 13';
+const localCommitAutomationGateKind = 'local-commit-automation-gate';
+const forbiddenRemoteActions = Object.freeze(['push', 'pr', 'pull request', 'merge', 'tag', 'remote delivery', 'release']);
+
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function uniqueStrings(value) {
+  return [...new Set(asArray(value).map((item) => String(item || '').trim()).filter(Boolean))];
+}
+
+function normalizeBoolean(value) {
+  return value === true || value === 'true' || value === 'passed' || value === 'pass' || value === 'approved' || value === 'clean' || value === 'fresh';
+}
+
+function subjectGuard(subject, readiness) {
+  const candidate = String(subject || readiness.commit_subject || readiness.suggested_commit_subject || readiness.staged_commit_readiness?.suggested_commit_subject || '').trim();
+  const findings = [];
+  if (!candidate) findings.push('commit subject is required');
+  if (candidate.length > 120) findings.push('commit subject must be 120 characters or less');
+  if (!/^(feat|fix|docs|chore|refactor|test|build|ci|perf|style|revert|release|runtime)(\([^)]+\))?:\s+/.test(candidate)) findings.push('commit subject must follow conventional commit format');
+  return {
+    subject: candidate,
+    conventional_subject: findings.length === 0,
+    commit_execution_authorized: false,
+    pass: findings.length === 0,
+    blocked_reasons: findings,
+  };
+}
+
+function readinessSignals(readiness) {
+  const verification = readiness.verification_evidence || readiness.evidence || {};
+  const diff = readiness.diff || readiness.diff_evidence || {};
+  const approvals = readiness.approvals || readiness.local_commit_approvals || {};
+  const remoteActions = uniqueStrings([
+    ...asArray(readiness.requested_actions),
+    ...asArray(readiness.delivery_actions),
+    ...asArray(readiness.git_actions),
+  ]).map((item) => item.toLowerCase());
+  const expectedFiles = uniqueStrings(diff.expected_files || readiness.expected_files || readiness.required_files);
+  const actualFiles = uniqueStrings(diff.actual_files || readiness.actual_files || expectedFiles);
+  const unexpectedFiles = uniqueStrings(diff.unexpected_files || readiness.unexpected_files || actualFiles.filter((file) => expectedFiles.length > 0 && !expectedFiles.includes(file)));
+  const blockedReasons = uniqueStrings(readiness.blocked_reasons || readiness.quality);
+  const contractReady = readiness.staged_commit_readiness?.contract_ready === true
+    || readiness.staged_commit_readiness?.commit_readiness_gate_pass === true
+    || readiness.commit_readiness_gate?.pass === true
+    || readiness.readiness_state?.envelope_valid === true
+    || readiness.readiness_pass === true
+    || readiness.contract_ready === true;
+  return {
+    contract_ready: contractReady,
+    clean_expected_diff: normalizeBoolean(diff.clean_expected_diff ?? readiness.clean_expected_diff) && unexpectedFiles.length === 0,
+    expected_files: expectedFiles,
+    actual_files: actualFiles,
+    unexpected_files: unexpectedFiles,
+    verification_fresh: normalizeBoolean(verification.fresh ?? verification.verification_fresh ?? readiness.verification_fresh),
+    verification_passed: normalizeBoolean(verification.pass ?? verification.passed ?? verification.verification_passed ?? readiness.verification_passed),
+    architecture_warning_count: Number(verification.architecture_warning_count ?? readiness.architecture_warning_count ?? 0),
+    rollback_note: String(readiness.rollback_note || readiness.rollback || '').trim(),
+    git_add_approved: normalizeBoolean(approvals.git_add?.approved ?? approvals.git_add_approved ?? readiness.git_add_approved),
+    git_commit_approved: normalizeBoolean(approvals.git_commit?.approved ?? approvals.git_commit_approved ?? readiness.git_commit_approved),
+    remote_actions: remoteActions.filter((action) => forbiddenRemoteActions.some((forbidden) => action.includes(forbidden))),
+    blocked_reasons: blockedReasons,
+  };
+}
+
+function gateBlockedReasons(signals, guard) {
+  return uniqueStrings([
+    ...(signals.contract_ready ? [] : ['commit readiness contract is not pass-ready']),
+    ...(signals.blocked_reasons.length === 0 ? [] : signals.blocked_reasons.map((item) => `readiness blocker: ${item}`)),
+    ...(signals.clean_expected_diff ? [] : ['clean expected diff evidence is required and unexpected files must be empty']),
+    ...(signals.verification_fresh ? [] : ['fresh verification evidence is required']),
+    ...(signals.verification_passed ? [] : ['passing verification evidence is required']),
+    ...(signals.architecture_warning_count === 0 ? [] : ['architecture warning must be zero before local commit']),
+    ...(signals.rollback_note ? [] : ['rollback note is required before local commit']),
+    ...guard.blocked_reasons,
+    ...(signals.git_add_approved ? [] : ['independent git add approval is required']),
+    ...(signals.git_commit_approved ? [] : ['independent git commit approval is required']),
+    ...signals.remote_actions.map((action) => `remote delivery action is forbidden: ${action}`),
+  ]);
+}
+
+export function buildLocalCommitAutomationGate({ readiness = {}, readinessSource = {}, subject = '', digestObject } = {}) {
+  const guard = subjectGuard(subject, readiness);
+  const signals = readinessSignals(readiness);
+  const blockedReasons = gateBlockedReasons(signals, guard);
+  const localCommitAllowed = blockedReasons.length === 0;
+  const remoteDeliveryForbidden = {
+    push: false,
+    pr: false,
+    merge: false,
+    tag: false,
+    remote_delivery: false,
+    platform_delivery: false,
+  };
+  const core = {
+    version: 1,
+    stage: localCommitAutomationGateStage,
+    gate_kind: localCommitAutomationGateKind,
+    source_readiness: {
+      file: readinessSource.relative || readinessSource.file || '',
+      digest: readinessSource.digest || '',
+      readiness_kind: readiness.readiness_kind || readiness.gate_kind || '',
+      stage: readiness.stage || '',
+    },
+    tiers: {
+      readiness_only: {
+        status: signals.contract_ready && blockedReasons.length === 0 ? 'ready' : 'blocked',
+        envelope_auto_authorizes_git: false,
+      },
+      local_commit_allowed: {
+        allowed: localCommitAllowed,
+        status: localCommitAllowed ? 'local-commit-approved-dry-run' : 'blocked',
+        git_add_independent_approval: signals.git_add_approved,
+        git_commit_independent_approval: signals.git_commit_approved,
+        runtime_git_execution_authorized: false,
+        git_add_execution_authorized: false,
+        git_commit_execution_authorized: false,
+      },
+      remote_delivery_forbidden: remoteDeliveryForbidden,
+    },
+    gate_requirements: {
+      clean_expected_diff: signals.clean_expected_diff,
+      expected_files: signals.expected_files,
+      actual_files: signals.actual_files,
+      unexpected_files: signals.unexpected_files,
+      verification_fresh: signals.verification_fresh,
+      verification_passed: signals.verification_passed,
+      commit_subject: guard,
+      rollback_note_present: Boolean(signals.rollback_note),
+      architecture_warning_count: signals.architecture_warning_count,
+      no_unexplained_files: signals.unexpected_files.length === 0,
+      no_remote_delivery_requested: signals.remote_actions.length === 0,
+    },
+    approval_requirements: {
+      git_add_must_be_independently_approved: true,
+      git_commit_must_be_independently_approved: true,
+      readiness_envelope_auto_authorizes_git: false,
+      git_add_approval_present: signals.git_add_approved,
+      git_commit_approval_present: signals.git_commit_approved,
+    },
+    blocked_reasons: blockedReasons,
+    status: localCommitAllowed ? 'local-commit-approved-dry-run' : 'blocked',
+    local_commit_allowed_by_gate: localCommitAllowed,
+    runtime_git_execution_authorized: false,
+    git_add_execution_authorized: false,
+    git_commit_execution_authorized: false,
+    remote_delivery_allowed: false,
+    dry_run_only: true,
+    controlled_change_delivery: buildControlledChangeDeliveryContract({
+      phase: 'local-commit-automation-gate',
+      changeSetSummary: {
+        source_stage: localCommitAutomationGateStage,
+        readiness_file: readinessSource.relative || readinessSource.file || '',
+        expected_file_count: signals.expected_files.length,
+        actual_file_count: signals.actual_files.length,
+        unexpected_file_count: signals.unexpected_files.length,
+        subject: guard.subject,
+      },
+      planTaskBinding: signals.contract_ready,
+      diffCoverageBound: signals.clean_expected_diff,
+      testEvidenceBound: signals.verification_passed && signals.verification_fresh,
+      reviewVerdictBound: true,
+      commitSubjectBound: guard.pass,
+      rollbackNoteBound: Boolean(signals.rollback_note),
+      blockedReasons,
+      nextManualAction: localCommitAllowed
+        ? 'Local commit is allowed only as a separate explicitly approved foreground git add followed by a separate explicitly approved foreground git commit. Push, PR, merge, tag, and remote delivery remain forbidden.'
+        : 'Stop before local commit and resolve the listed gate blockers; do not push, PR, merge, tag, or perform remote delivery.',
+    }),
+    forbidden_actions: [
+      'push',
+      'PR creation',
+      'merge',
+      'tag',
+      'remote delivery',
+      'worktree mutation by readiness envelope',
+      'commit without separate git add approval',
+      'commit without separate git commit approval',
+      'history rewrite',
+    ],
+    boundary_assertions: {
+      readiness_artifact_write: false,
+      state_directory_created: false,
+      source_write: false,
+      worktree_mutation: false,
+      git_execution: false,
+      git_write: false,
+      git_add: false,
+      git_commit: false,
+      push: false,
+      pr: false,
+      merge: false,
+      tag: false,
+      remote_delivery: false,
+      platform_api: false,
+      external_network: false,
+      business_source_write: false,
+    },
+  };
+  const digest = typeof digestObject === 'function' ? digestObject(core) : digestLocalCommitAutomationGate(core);
+  return {
+    mode: 'local-commit-automation-gate',
+    ok: true,
+    local_commit_automation_gate: {
+      ...core,
+      local_commit_gate_digest: digest,
+    },
+    safety: {
+      stage: localCommitAutomationGateStage,
+      writes: false,
+      command_execution: false,
+      git: false,
+      git_write: false,
+      git_add: false,
+      commit: false,
+      push: false,
+      pr: false,
+      merge: false,
+      tag: false,
+      remote_delivery: false,
+      worktree: false,
+      business_source_write: false,
+    },
+    quality: blockedReasons,
+    action: 'local commit automation gate was computed as a dry-run from local readiness evidence. It did not run git add, git commit, push, PR, merge, tag, remote delivery, checks, source writes, worktree mutation, platform APIs, subagents, MCP, or network calls.',
+  };
+}
+
+export function printLocalCommitAutomationGate(envelope, { printList } = {}) {
+  const gate = envelope.local_commit_automation_gate;
+  console.log('Vibecoding Runtime Local Commit Automation Gate');
+  console.log(`Stage: ${gate.stage}; Status: ${gate.status}`);
+  console.log(`Subject: ${gate.gate_requirements.commit_subject.subject || '<missing>'}`);
+  console.log(`Local commit allowed by gate: ${gate.local_commit_allowed_by_gate}; runtime_git_execution_authorized=${gate.runtime_git_execution_authorized}`);
+  console.log('Remote delivery: push=false; pr=false; merge=false; tag=false; remote_delivery=false');
+  if (gate.blocked_reasons.length > 0 && printList) printList('Blocked reasons', gate.blocked_reasons);
+  console.log(`Local commit gate digest: ${gate.local_commit_gate_digest}`);
+  console.log(`Action: ${envelope.action}`);
+}
+
+export function digestLocalCommitAutomationGate(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+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-local-json-input.mjs

@@ -0,0 +1,32 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+
+export function ensureRoot(root) {
+  if (!fs.existsSync(root)) throw new Error(`Root not found: ${root}`);
+  if (!fs.statSync(root).isDirectory()) throw new Error(`Root is not a directory: ${root}`);
+}
+
+export function localJsonFileWithinRoot(root, inputFile, label) {
+  const raw = String(inputFile || '').trim();
+  if (!raw) throw new Error(`${label} requires a local JSON file`);
+  const resolvedRoot = path.resolve(root);
+  const resolvedFile = path.resolve(raw);
+  const relative = path.relative(resolvedRoot, resolvedFile);
+  if (relative === '' || relative.startsWith('..') || path.isAbsolute(relative)) throw new Error(`${label} must stay within --root`);
+  if (!fs.existsSync(resolvedFile)) throw new Error(`${label} file not found: ${relative.replace(/\\/g, '/')}`);
+  if (!fs.statSync(resolvedFile).isFile()) throw new Error(`${label} path is not a file: ${relative.replace(/\\/g, '/')}`);
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(resolvedFile, 'utf8'));
+  } catch (error) {
+    throw new Error(`${label} JSON is invalid: ${error.message}`);
+  }
+  if (!data || typeof data !== 'object' || Array.isArray(data)) throw new Error(`${label} must be a JSON object`);
+  return {
+    data,
+    file: resolvedFile,
+    relative: relative.replace(/\\/g, '/'),
+    digest: crypto.createHash('sha256').update(fs.readFileSync(resolvedFile)).digest('hex'),
+  };
+}