@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-completion-evidence-bundle.mjs

@@ -0,0 +1,269 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { buildAutomaticVerificationGateContract } from './runtime-automatic-verification-gate-contract.mjs';
+import {
+  readLocalTextArtifact,
+} from './runtime-product-methodology-gates.mjs';
+import {
+  completionCrossArtifactRefValidation,
+} from './runtime-artifact-ref-validation.mjs';
+import {
+  validateCommitReadinessDescriptor,
+  validateDiffCoverageDescriptor,
+  validateTestEvidenceDescriptor,
+} from './runtime-completion-local-evidence-gates.mjs';
+import {
+  validateImplementationAlignment,
+} from './runtime-implementation-task-registry.mjs';
+import {
+  deliveryArtifactGateResult,
+  deliveryArtifactInputs,
+  engineeringEvidenceDescriptor,
+  hasExpandedDeliveryInputs,
+  implementationPlanGateResult,
+  localEvidenceDescriptor,
+  localEvidenceInputs,
+  missingImplementationAlignmentGate,
+  productArtifactGateResult,
+  productArtifactInputs,
+  scenarioRefsForCompletion,
+} from './runtime-completion-evidence-descriptors.mjs';
+import {
+  evidenceChainItem,
+  gateChainItem,
+  requirementsChainFromGateResults,
+  sourceBindingsFromCompletionInputs,
+} from './runtime-completion-chain-assembly.mjs';
+import {
+  completionAllowedFollowup,
+  completionBlockedReasons,
+  completionEvidenceGaps,
+  completionForbiddenActions,
+  completionTaskSummary,
+} from './runtime-completion-readiness-summary.mjs';
+import {
+  bundleInvariants,
+  completionEvidenceBundleBoundaryAssertions,
+  digestObject,
+} from './runtime-completion-bundle-contract.mjs';
+import { verificationGateFromCompletionBundle } from './runtime-verification-gate-chain-model.mjs';
+
+export function productCompletionEvidenceBundleEnvelope(root, options = {}) {
+  const boundaryAssertions = completionEvidenceBundleBoundaryAssertions();
+  const expandedMode = hasExpandedDeliveryInputs(options);
+  const productGateResults = productArtifactInputs.map(([slot, kind, optionKey]) => productArtifactGateResult(root, slot, kind, options[optionKey] || ''));
+  const deliveryGateResults = deliveryArtifactInputs.map(([slot, kind, optionKey]) => deliveryArtifactGateResult(root, slot, kind, options[optionKey] || ''));
+  const localEvidenceResults = localEvidenceInputs.map(([slot, optionKey, label]) => localEvidenceDescriptor(root, slot, options[optionKey] || '', label));
+  const engineeringEvidence = engineeringEvidenceDescriptor(root, options.fromEvidence || '');
+  const commitReadiness = localEvidenceResults.find((result) => result.slot === 'commit_readiness');
+  const testEvidence = localEvidenceResults.find((result) => result.slot === 'test_evidence');
+  const diffCoverage = localEvidenceResults.find((result) => result.slot === 'diff_coverage');
+  const implementationPlan = localEvidenceResults.find((result) => result.slot === 'implementation_plan');
+  const scenarioRefs = scenarioRefsForCompletion(root, options);
+  const implementationPlanGate = implementationPlanGateResult(root, options.fromPlan || '', { scenarioRefs });
+  const implementationAlignmentGate = expandedMode
+    ? validateImplementationAlignment({ registry: implementationPlanGate.registry, diffCoverage, testEvidence, scenarioRefs })
+    : missingImplementationAlignmentGate('implementation alignment only applies to expanded delivery completion bundle');
+  const crossArtifactRefValidation = completionCrossArtifactRefValidation(root, options, { readLocalTextArtifact });
+  const testEvidenceGate = validateTestEvidenceDescriptor(testEvidence, { scenarioRefs });
+  const diffCoverageGate = validateDiffCoverageDescriptor(diffCoverage);
+  const commitReadinessGate = validateCommitReadinessDescriptor(commitReadiness);
+  const evidenceGateResults = [testEvidenceGate, diffCoverageGate, commitReadinessGate];
+  const relevantDeliveryResults = expandedMode ? deliveryGateResults : deliveryGateResults.filter((result) => result.status === 'provided');
+  const relevantLocalEvidenceResults = expandedMode ? localEvidenceResults : localEvidenceResults.filter((result) => result.status === 'provided');
+  const evidenceGaps = completionEvidenceGaps({
+    productGateResults,
+    relevantDeliveryResults,
+    relevantLocalEvidenceResults,
+    evidenceGateResults,
+    implementationPlanGate,
+    implementationAlignmentGate,
+    crossArtifactRefValidation,
+    engineeringEvidence,
+    expandedMode,
+  });
+  const blockedReasons = completionBlockedReasons({
+    productGateResults,
+    relevantDeliveryResults,
+    evidenceGaps,
+  });
+  const completionReadinessContext = {
+    blockedReasons,
+    expandedMode,
+    evidenceGateResults,
+    relevantLocalEvidenceResults,
+    implementationPlanGate,
+    implementationAlignmentGate,
+    engineeringEvidence,
+  };
+  const taskCompletionSummary = completionTaskSummary(completionReadinessContext);
+  const productSpec = productGateResults.find((result) => result.slot === 'product_spec');
+  const uiDesign = productGateResults.find((result) => result.slot === 'ui_design');
+  const scenarios = productGateResults.find((result) => result.slot === 'scenarios');
+  const productAcceptance = productGateResults.find((result) => result.slot === 'product_acceptance');
+  const architecture = deliveryGateResults.find((result) => result.slot === 'architecture');
+  const traceability = deliveryGateResults.find((result) => result.slot === 'traceability');
+  const requirementsChain = requirementsChainFromGateResults(productGateResults);
+  const bundle = {
+    version: 1,
+    stage: expandedMode ? 'Stage 155' : 'Stage 152',
+    bundle_kind: 'product-completion-evidence-bundle',
+    expanded_delivery_chain: expandedMode,
+    requirements_chain: requirementsChain,
+    architecture_chain: {
+      architecture: gateChainItem(architecture),
+      readiness: {
+        architecture_gate_ok: architecture?.gate_ok === true,
+        owner_layer_data_flow_bound: architecture?.gate_ok === true,
+      },
+    },
+    traceability_chain: {
+      traceability: gateChainItem(traceability),
+      cross_artifact_ref_validation: crossArtifactRefValidation.ref_validation,
+      readiness: {
+        traceability_gate_ok: traceability?.gate_ok === true,
+        link_count: traceability?.gate?.summary?.link_count || 0,
+        cross_artifact_ref_validation_ok: crossArtifactRefValidation.ok === true,
+        matched_ref_count: crossArtifactRefValidation.ref_validation.matched_refs.length,
+        missing_ref_count: crossArtifactRefValidation.ref_validation.missing_refs.length,
+        unbound_ref_type_count: crossArtifactRefValidation.ref_validation.unbound_ref_types.length,
+      },
+    },
+    implementation_chain: {
+      plan: evidenceChainItem(implementationPlan),
+      test_evidence: evidenceChainItem(testEvidence),
+      diff_coverage: evidenceChainItem(diffCoverage),
+      implementation_plan_gate: implementationPlanGate.gate,
+      test_evidence_gate: testEvidenceGate,
+      diff_coverage_gate: diffCoverageGate,
+      implementation_alignment_gate: implementationAlignmentGate,
+      plan_bound: implementationPlan?.status === 'provided',
+      test_evidence_bound: testEvidence?.status === 'provided',
+      diff_coverage_bound: diffCoverage?.status === 'provided',
+      test_evidence_readiness: {
+        test_evidence_gate_ok: testEvidenceGate.ok,
+        run_count: testEvidenceGate.summary.run_count || 0,
+        scenario_ref_count: testEvidenceGate.summary.scenario_ref_count || 0,
+        task_ref_count: testEvidenceGate.summary.task_ref_count || 0,
+      },
+      diff_coverage_readiness: {
+        diff_coverage_gate_ok: diffCoverageGate.ok,
+        planned_file_count: diffCoverageGate.summary.planned_file_count || 0,
+        changed_file_count: diffCoverageGate.summary.changed_file_count || 0,
+        unexpected_file_count: diffCoverageGate.summary.unexpected_file_count || 0,
+        missing_file_count: diffCoverageGate.summary.missing_file_count || 0,
+        task_coverage_count: diffCoverageGate.summary.task_coverage_count || 0,
+      },
+      implementation_alignment_readiness: {
+        implementation_plan_gate_ok: implementationPlanGate.gate_ok === true,
+        implementation_alignment_ok: implementationAlignmentGate.ok === true,
+        plan_task_count: implementationAlignmentGate.summary.plan_task_count || 0,
+        required_task_count: implementationAlignmentGate.summary.required_task_count || 0,
+        covered_task_count: implementationAlignmentGate.summary.covered_task_count || 0,
+        tested_task_count: implementationAlignmentGate.summary.tested_task_count || 0,
+        unexplained_changed_file_count: implementationAlignmentGate.summary.unexplained_changed_file_count || 0,
+        operation_mismatch_count: implementationAlignmentGate.summary.operation_mismatch_count || 0,
+        missing_test_evidence_count: implementationAlignmentGate.summary.missing_test_evidence_count || 0,
+      },
+    },
+    release_readiness_chain: {
+      commit_readiness: evidenceChainItem(commitReadiness),
+      commit_readiness_gate: commitReadinessGate,
+      commit_readiness_bound: commitReadiness?.status === 'provided',
+      commit_readiness_envelope_type: commitReadinessGate.summary.commit_readiness_envelope_type || 'missing',
+      commit_boundary_ok: commitReadinessGate.summary.commit_boundary_ok === true,
+      unsafe_commit_boundary_findings: commitReadinessGate.findings || [],
+      commit_execution_authorized: false,
+      git_write: false,
+      commit: false,
+      push: false,
+      pr: false,
+      merge: false,
+      safety_findings: commitReadinessGate.findings || [],
+    },
+    product_readiness: {
+      product_spec_gate_ok: productSpec?.gate_ok === true,
+      product_acceptance_gate_ok: productAcceptance?.gate_ok === true,
+      closed_loop: productSpec?.gate_ok === true && productAcceptance?.gate_ok === true,
+    },
+    ui_readiness: {
+      ui_design_gate_ok: uiDesign?.gate_ok === true,
+      scenario_gate_ok: scenarios?.gate_ok === true,
+      closed_loop: uiDesign?.gate_ok === true && scenarios?.gate_ok === true,
+    },
+    architecture_readiness: {
+      gate_ok: architecture?.gate_ok === true,
+      required: expandedMode,
+      closed_loop: !expandedMode || architecture?.gate_ok === true,
+    },
+    traceability_readiness: {
+      gate_ok: traceability?.gate_ok === true,
+      cross_artifact_ref_validation_ok: crossArtifactRefValidation.ok === true,
+      required: expandedMode,
+      closed_loop: !expandedMode || (traceability?.gate_ok === true && crossArtifactRefValidation.ok === true),
+    },
+    engineering_readiness: {
+      evidence_status: engineeringEvidence.status,
+      evidence_file: engineeringEvidence.file,
+      evidence_digest: engineeringEvidence.digest,
+      evidence_summary: engineeringEvidence.summary,
+      executes_commands: false,
+    },
+    source_bindings: sourceBindingsFromCompletionInputs({
+      productGateResults,
+      architecture,
+      traceability,
+      implementationPlan,
+      implementationPlanGate,
+      testEvidence,
+      diffCoverage,
+      commitReadiness,
+      engineeringEvidence,
+    }),
+    task_completion_summary: taskCompletionSummary,
+    automatic_verification_gate: buildAutomaticVerificationGateContract({
+      phase: expandedMode ? 'expanded-completion-bundle' : 'completion-bundle',
+      completionBundleBound: true,
+      executionEvidenceBound: testEvidence?.status === 'provided' || diffCoverage?.status === 'provided' || commitReadiness?.status === 'provided',
+      evidenceItemCount: evidenceGateResults.length,
+      missingEvidenceCount: evidenceGaps.length,
+      failedEvidenceCount: blockedReasons.length,
+      unexpectedDiffCount: diffCoverageGate.summary.unexpected_file_count || 0,
+      blockedReasons,
+      nextManualAction: taskCompletionSummary.manual_next_action,
+    }),
+    evidence_gaps: evidenceGaps,
+    blocked_reasons: blockedReasons,
+    next_manual_action: taskCompletionSummary.manual_next_action,
+    allowed_followup: completionAllowedFollowup,
+    forbidden_actions: completionForbiddenActions,
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = bundleInvariants(bundle, { expandedMode });
+  const withInvariants = {
+    ...bundle,
+    invariants,
+  };
+  const withVerificationGate = {
+    ...withInvariants,
+    verification_gate_chain: verificationGateFromCompletionBundle(withInvariants),
+  };
+  return {
+    mode: 'product-completion-evidence-bundle',
+    ok: invariants.pass,
+    state_present: fs.existsSync(path.join(root, '.vibecoding-state')),
+    completion_evidence_bundle: {
+      ...withVerificationGate,
+      bundle_digest: digestObject(withVerificationGate),
+    },
+    product_methodology_gates: productGateResults.filter((result) => result.gate).map((result) => result.gate),
+    delivery_methodology_gates: deliveryGateResults.filter((result) => result.gate).map((result) => result.gate),
+    safety: { stage: bundle.stage, ...boundaryAssertions },
+    quality: blockedReasons,
+    action: 'completion product evidence bundle read local product/UI/architecture/traceability/plan/scenario/acceptance/test/diff/commit/engineering evidence and composed deterministic gate results only. No state directory, artifact write, command/check/test/browser execution, workflow skill execution, runtime action, git, platform API, external network, model, MCP, subagent, or business source mutation occurred.',
+  };
+}

package/tools/vibe-runtime/runtime-completion-evidence-descriptors.mjs

@@ -0,0 +1,156 @@
+import {
+  deliveryMethodologyGateEnvelope,
+} from './runtime-delivery-methodology-gates.mjs';
+import {
+  scenarioRefsFromArtifactText,
+} from './runtime-artifact-ref-validation.mjs';
+import {
+  implementationMethodologyGateEnvelope,
+} from './runtime-implementation-methodology-gates.mjs';
+import {
+  productMethodologyGateEnvelope,
+  readLocalTextArtifact,
+} from './runtime-product-methodology-gates.mjs';
+
+export const productArtifactInputs = [
+  ['product_discovery', 'product-discovery', 'fromProductDiscovery'],
+  ['product_spec', 'product-spec', 'fromProductSpec'],
+  ['ui_design', 'ui-design', 'fromUiDesign'],
+  ['scenarios', 'scenario-acceptance', 'fromScenarios'],
+  ['product_acceptance', 'product-acceptance', 'fromProductAcceptance'],
+];
+
+export const deliveryArtifactInputs = [
+  ['architecture', 'architecture-design', 'fromArchitecture'],
+  ['traceability', 'delivery-traceability', 'fromTraceability'],
+];
+
+export const localEvidenceInputs = [
+  ['implementation_plan', 'fromPlan', 'completion --evidence-bundle --from-plan'],
+  ['test_evidence', 'fromTestEvidence', 'completion --evidence-bundle --from-test-evidence'],
+  ['diff_coverage', 'fromDiffCoverage', 'completion --evidence-bundle --from-diff-coverage'],
+  ['commit_readiness', 'fromCommitReadiness', 'completion --evidence-bundle --from-commit-readiness'],
+];
+
+export function scenarioRefsForCompletion(root, options) {
+  if (!options.fromScenarios) return [];
+  const source = readLocalTextArtifact(root, options.fromScenarios, 'completion --evidence-bundle scenario refs');
+  return scenarioRefsFromArtifactText(source.text);
+}
+
+export function hasExpandedDeliveryInputs(options) {
+  return Boolean(options.fromArchitecture || options.fromTraceability || options.fromPlan || options.fromTestEvidence || options.fromDiffCoverage || options.fromCommitReadiness);
+}
+
+export function productArtifactGateResult(root, slot, kind, inputFile) {
+  if (!inputFile) {
+    return { slot, kind, status: 'missing', file: '', digest: '', gate_digest: '', gate_ok: false, blocked_reasons: [], gaps: [`${slot} artifact not provided`], gate: null };
+  }
+  const envelope = productMethodologyGateEnvelope(root, { kind, fromFile: inputFile });
+  const gate = envelope.product_methodology_gate;
+  return {
+    slot,
+    kind,
+    status: 'provided',
+    file: gate.source_bindings.artifact_file,
+    digest: gate.source_bindings.artifact_digest,
+    gate_digest: gate.gate_digest,
+    gate_ok: envelope.ok,
+    blocked_reasons: gate.blocked_reasons,
+    gaps: envelope.ok ? [] : gate.blocked_reasons,
+    gate,
+  };
+}
+
+export function deliveryArtifactGateResult(root, slot, kind, inputFile) {
+  if (!inputFile) {
+    return { slot, kind, status: 'missing', file: '', digest: '', gate_digest: '', gate_ok: false, blocked_reasons: [], gaps: [`${slot} artifact not provided`], gate: null };
+  }
+  const envelope = deliveryMethodologyGateEnvelope(root, { kind, fromFile: inputFile });
+  const gate = envelope.delivery_methodology_gate;
+  return {
+    slot,
+    kind,
+    status: 'provided',
+    file: gate.source_bindings.artifact_file,
+    digest: gate.source_bindings.artifact_digest,
+    gate_digest: gate.gate_digest,
+    gate_ok: envelope.ok,
+    blocked_reasons: gate.blocked_reasons,
+    gaps: envelope.ok ? [] : gate.blocked_reasons,
+    gate,
+  };
+}
+
+export function implementationPlanGateResult(root, inputFile, { scenarioRefs = [] } = {}) {
+  if (!inputFile) {
+    return { status: 'missing', file: '', digest: '', gate_digest: '', gate_ok: false, blocked_reasons: [], gaps: ['implementation plan artifact not provided'], gate: null, registry: { tasks: [], task_ids: [], registry_present: false, registry_digest: '' } };
+  }
+  const envelope = implementationMethodologyGateEnvelope(root, { kind: 'implementation-plan', fromFile: inputFile, scenarioRefs });
+  const gate = envelope.implementation_methodology_gate;
+  return {
+    status: 'provided',
+    file: gate.source_bindings.artifact_file,
+    digest: gate.source_bindings.artifact_digest,
+    gate_digest: gate.gate_digest,
+    gate_ok: envelope.ok,
+    blocked_reasons: gate.blocked_reasons,
+    gaps: envelope.ok ? [] : gate.blocked_reasons,
+    gate,
+    registry: gate.implementation_task_registry,
+  };
+}
+
+export function missingImplementationAlignmentGate(reason) {
+  return {
+    gate_kind: 'implementation_alignment_gate',
+    ok: false,
+    summary: {},
+    uncovered_required_tasks: [],
+    unexplained_changed_files: [],
+    operation_mismatches: [],
+    missing_test_evidence_for_required_tasks: [],
+    path_violations: [],
+    unknown_task_refs: [],
+    findings: [reason],
+    blocked_reasons: [reason],
+  };
+}
+
+export function localEvidenceDescriptor(root, slot, inputFile, label) {
+  if (!inputFile) return { slot, status: 'missing', file: '', digest: '', summary: `${slot} file not provided`, gaps: [`${slot} file not provided`] };
+  const source = readLocalTextArtifact(root, inputFile, label);
+  const lines = source.text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const parsed = parseJsonMaybe(source.text);
+  return {
+    slot,
+    status: 'provided',
+    file: source.relative,
+    digest: source.digest,
+    summary: `lines=${lines.length}; json=${parsed.ok}; command_execution=false`,
+    parsed: parsed.ok ? parsed.value : null,
+    gaps: [],
+  };
+}
+
+export function engineeringEvidenceDescriptor(root, evidenceFile) {
+  if (!evidenceFile) return { status: 'not_provided', file: '', digest: '', summary: 'No engineering evidence file was provided.' };
+  const source = readLocalTextArtifact(root, evidenceFile, 'completion --evidence-bundle --from-evidence');
+  const lines = source.text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const passSignals = lines.filter((line) => /(pass|passed|ok|success|succeeded|通过|成功|0 warn|0 fail)/i.test(line)).length;
+  const gapSignals = lines.filter((line) => /(fail|failed|error|blocked|todo|not_verified|未验证|失败|错误)/i.test(line)).length;
+  return {
+    status: 'provided',
+    file: source.relative,
+    digest: source.digest,
+    summary: `lines=${lines.length}; pass_signals=${passSignals}; gap_signals=${gapSignals}; command_execution=false`,
+  };
+}
+
+function parseJsonMaybe(text) {
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch {
+    return { ok: false, value: null };
+  }
+}

package/tools/vibe-runtime/runtime-completion-local-evidence-gates.mjs

@@ -0,0 +1,164 @@
+const falseBoundaryKeys = Object.freeze(['command_execution', 'test_execution', 'git', 'git_write']);
+const commitBoundaryKeys = Object.freeze(['git_write', 'git_add', 'commit', 'push', 'pr', 'merge', 'tag', 'history_rewrite']);
+
+export function validateTestEvidenceDescriptor(testEvidence, { scenarioRefs = [] } = {}) {
+  if (!testEvidence || testEvidence.status !== 'provided') return missingGate('test_evidence_gate', 'test evidence file not provided');
+  const parsed = testEvidence.parsed;
+  const findings = [];
+  if (!parsed) findings.push('test_evidence must be valid JSON');
+  const runs = Array.isArray(parsed?.runs) ? parsed.runs : [];
+  if (runs.length === 0) findings.push('test_evidence.runs[] must not be empty');
+  if (String(parsed?.artifact_kind || '') !== 'test-evidence') findings.push('test_evidence.artifact_kind must be test-evidence');
+
+  const knownScenarios = new Set(scenarioRefs);
+  for (const [index, run] of runs.entries()) {
+    const id = String(run?.id || `run-${index}`).trim();
+    if (!String(run?.id || '').trim()) findings.push(`test_evidence.runs[${index}].id is required`);
+    if (!String(run?.command || '').trim()) findings.push(`test_evidence.run.${id}.command is required`);
+    if (!Number.isInteger(run?.exit_code)) findings.push(`test_evidence.run.${id}.exit_code must be an integer`);
+    if (!String(run?.timestamp || '').trim()) findings.push(`test_evidence.run.${id}.timestamp is required`);
+    if (!String(run?.output_digest || '').trim()) findings.push(`test_evidence.run.${id}.output_digest is required`);
+    if (!Array.isArray(run?.scenario_refs) || run.scenario_refs.length === 0) findings.push(`test_evidence.run.${id}.scenario_refs[] must not be empty`);
+    if (!Array.isArray(run?.task_refs) || run.task_refs.length === 0) findings.push(`test_evidence.run.${id}.task_refs[] must not be empty`);
+    if (Number.isInteger(run?.exit_code) && run.exit_code === 0 && !['pass', 'passed'].includes(String(run?.status || '').toLowerCase())) {
+      findings.push(`test_evidence.run.${id}.status must be pass when exit_code is 0`);
+    }
+    if (Number.isInteger(run?.exit_code) && run.exit_code !== 0 && !['fail', 'failed', 'blocked'].includes(String(run?.status || '').toLowerCase())) {
+      findings.push(`test_evidence.run.${id}.status must be fail or blocked when exit_code is non-zero`);
+    }
+    if (knownScenarios.size > 0 && Array.isArray(run?.scenario_refs)) {
+      for (const scenarioRef of run.scenario_refs) {
+        if (!knownScenarios.has(scenarioRef)) findings.push(`test_evidence.run.${id}.scenario_ref ${scenarioRef} not found in scenario acceptance artifact`);
+      }
+    }
+  }
+
+  const runtimeGenerated = parsed?.runtime_run_test === true;
+  if (runtimeGenerated) validateRuntimeGeneratedTestEvidence(parsed, findings);
+  else for (const key of ['runtime_executed_command', ...falseBoundaryKeys]) assertFalseBoundary(parsed, `test_evidence.${key}`, key, findings);
+  return gateResult('test_evidence_gate', findings, {
+    run_count: runs.length,
+    scenario_ref_count: new Set(runs.flatMap((run) => Array.isArray(run?.scenario_refs) ? run.scenario_refs : [])).size,
+    task_ref_count: new Set(runs.flatMap((run) => Array.isArray(run?.task_refs) ? run.task_refs : [])).size,
+  });
+}
+
+export function validateDiffCoverageDescriptor(diffCoverage) {
+  if (!diffCoverage || diffCoverage.status !== 'provided') return missingGate('diff_coverage_gate', 'diff coverage file not provided');
+  const parsed = diffCoverage.parsed;
+  const findings = [];
+  if (!parsed) findings.push('diff_coverage must be valid JSON');
+  if (String(parsed?.artifact_kind || '') !== 'diff-coverage-evidence') findings.push('diff_coverage.artifact_kind must be diff-coverage-evidence');
+  for (const key of ['planned_files', 'changed_files', 'unexpected_files', 'missing_files']) {
+    if (!Array.isArray(parsed?.[key])) findings.push(`diff_coverage.${key} must be an array`);
+  }
+  if (Array.isArray(parsed?.unexpected_files) && parsed.unexpected_files.length > 0) findings.push('diff_coverage.unexpected_files must be empty');
+  if (Array.isArray(parsed?.missing_files) && parsed.missing_files.length > 0) findings.push('diff_coverage.missing_files must be empty');
+  if (parsed?.task_coverage !== undefined && !Array.isArray(parsed.task_coverage)) findings.push('diff_coverage.task_coverage must be an array when provided');
+  const taskCoverage = Array.isArray(parsed?.task_coverage) ? parsed.task_coverage : [];
+  for (const [index, coverage] of taskCoverage.entries()) {
+    const label = String(coverage?.task_ref || `task_coverage-${index}`).trim();
+    if (!String(coverage?.task_ref || '').trim()) findings.push(`diff_coverage.task_coverage[${index}].task_ref is required`);
+    if (!['covered', 'deferred', 'not_started', 'blocked'].includes(String(coverage?.status || '').trim())) findings.push(`diff_coverage.task_coverage.${label}.status must be covered, deferred, not_started, or blocked`);
+    if (!Array.isArray(coverage?.changed_files)) findings.push(`diff_coverage.task_coverage.${label}.changed_files must be an array`);
+    for (const [fileIndex, file] of (Array.isArray(coverage?.changed_files) ? coverage.changed_files : []).entries()) {
+      if (!String(file?.path || '').trim()) findings.push(`diff_coverage.task_coverage.${label}.changed_files[${fileIndex}].path is required`);
+      if (!String(file?.operation || '').trim()) findings.push(`diff_coverage.task_coverage.${label}.changed_files[${fileIndex}].operation is required`);
+      if (!String(file?.digest || '').trim()) findings.push(`diff_coverage.task_coverage.${label}.changed_files[${fileIndex}].digest is required`);
+    }
+  }
+  if (parsed?.runtime_read_git_diff === true) {
+    if (parsed?.git_read !== true) findings.push('diff_coverage.git_read must be true when runtime_read_git_diff is true');
+    if (parsed?.git_write !== false) findings.push('diff_coverage.git_write must be false when runtime_read_git_diff is true');
+    if (parsed?.worktree_write !== false) findings.push('diff_coverage.worktree_write must be false when runtime_read_git_diff is true');
+  }
+  for (const key of falseBoundaryKeys) assertFalseBoundary(parsed, `diff_coverage.${key}`, key, findings);
+  return gateResult('diff_coverage_gate', findings, {
+    planned_file_count: Array.isArray(parsed?.planned_files) ? parsed.planned_files.length : 0,
+    changed_file_count: Array.isArray(parsed?.changed_files) ? parsed.changed_files.length : 0,
+    unexpected_file_count: Array.isArray(parsed?.unexpected_files) ? parsed.unexpected_files.length : 0,
+    missing_file_count: Array.isArray(parsed?.missing_files) ? parsed.missing_files.length : 0,
+    task_coverage_count: Array.isArray(parsed?.task_coverage) ? parsed.task_coverage.length : 0,
+  });
+}
+
+export function validateCommitReadinessDescriptor(commitReadiness) {
+  if (!commitReadiness || commitReadiness.status !== 'provided') return missingGate('commit_readiness_gate', 'commit readiness file not provided');
+  const parsed = commitReadiness.parsed;
+  const findings = [];
+  if (!parsed) findings.push('commit_readiness must be valid JSON');
+  const envelopeType = commitReadinessEnvelopeType(parsed);
+  if (envelopeType === 'unknown') findings.push('commit_readiness envelope type is unknown; expected runtime or commit-readiness-evidence JSON');
+  for (const key of ['commit_execution_authorized', 'runtime_git_execution_authorized', ...commitBoundaryKeys]) {
+    const values = collectKeyValues(parsed, key);
+    if (values.some((value) => value === true)) findings.push(`commit_readiness.${key} must not be true`);
+  }
+  for (const key of ['commit_execution_authorized', 'git_write', 'commit', 'push', 'pr', 'merge']) requireFalseBoundary(parsed, `commit_readiness.${key}`, key, findings);
+  return gateResult('commit_readiness_gate', findings, {
+    commit_readiness_envelope_type: envelopeType,
+    commit_boundary_ok: findings.length === 0,
+    commit_execution_authorized: false,
+    git_write: false,
+  });
+}
+
+export function collectKeyValues(value, key) {
+  if (Array.isArray(value)) return value.flatMap((item) => collectKeyValues(item, key));
+  if (value && typeof value === 'object') {
+    return [
+      ...(Object.prototype.hasOwnProperty.call(value, key) ? [value[key]] : []),
+      ...Object.values(value).flatMap((item) => collectKeyValues(item, key)),
+    ];
+  }
+  return [];
+}
+
+function validateRuntimeGeneratedTestEvidence(parsed, findings) {
+  if (parsed?.allowlisted_profile !== true) findings.push('test_evidence.allowlisted_profile must be true for runtime test evidence');
+  if (parsed?.confirmation_received !== true) findings.push('test_evidence.confirmation_received must be true for runtime test evidence');
+  if (parsed?.runtime_executed_command !== true) findings.push('test_evidence.runtime_executed_command must be true for runtime test evidence');
+  if (parsed?.command_execution !== true) findings.push('test_evidence.command_execution must be true for runtime test evidence');
+  if (parsed?.test_execution !== true) findings.push('test_evidence.test_execution must be true for runtime test evidence');
+  for (const key of ['git', 'git_write', 'worktree_write', 'commit', 'push', 'pr', 'merge', 'tag', 'history_rewrite']) requireFalseBoundary(parsed, `test_evidence.${key}`, key, findings);
+  if (parsed?.runtime_test_run?.allowlist?.arbitrary_shell !== false) findings.push('test_evidence.runtime_test_run.allowlist.arbitrary_shell must be false');
+  if (parsed?.runtime_test_run?.allowlist?.user_command_string !== false) findings.push('test_evidence.runtime_test_run.allowlist.user_command_string must be false');
+  if (parsed?.test_evidence_invariants?.pass !== true) findings.push('test_evidence.test_evidence_invariants.pass must be true');
+}
+
+function commitReadinessEnvelopeType(value) {
+  if (!value || typeof value !== 'object') return 'unknown';
+  if (String(value.mode || '').includes('commit-readiness') || value.release_commit_readiness || value.commit_readiness?.commit_readiness_digest || value.commit_readiness_digest) return 'runtime';
+  if (value.artifact_kind === 'commit-readiness-evidence') return 'legacy';
+  return 'unknown';
+}
+
+function assertFalseBoundary(value, label, key, findings) {
+  const values = collectKeyValues(value, key);
+  if (values.some((item) => item === true)) findings.push(`${label} must not be true`);
+}
+
+function requireFalseBoundary(value, label, key, findings) {
+  const values = collectKeyValues(value, key);
+  if (!values.some((item) => item === false)) findings.push(`${label} must be explicitly false`);
+  if (values.some((item) => item === true)) findings.push(`${label} must not be true`);
+}
+
+function missingGate(gateKind, reason) {
+  return {
+    gate_kind: gateKind,
+    ok: false,
+    summary: {},
+    findings: [reason],
+    blocked_reasons: [reason],
+  };
+}
+
+function gateResult(gateKind, findings, summary) {
+  return {
+    gate_kind: gateKind,
+    ok: findings.length === 0,
+    summary,
+    findings,
+    blocked_reasons: findings,
+  };
+}

package/tools/vibe-runtime/runtime-completion-presentation.mjs

@@ -0,0 +1,71 @@
+export function createCompletionPresentation({ printList }) {
+  function printCompletionReadiness(envelope) {
+    const readiness = envelope.completion_readiness;
+    console.log('Vibecoding Runtime Completion Readiness');
+    console.log(`Stage: ${readiness.stage}; Ready to report done: ${readiness.ready_to_report_done ? 'true' : 'false'}`);
+    console.log(`Evidence: ${readiness.evidence_file || 'not provided'}`);
+    console.log(`Verification evidence: ${readiness.verification_evidence.length}`);
+    console.log(`Unverified items: ${readiness.unverified_items.length}`);
+    console.log(`Review feedback: ${readiness.review_feedback_status}`);
+    console.log(`Release boundary: ${readiness.release_boundary_summary}`);
+    if (readiness.diagnostic_summary) console.log(`Diagnostic: ${readiness.diagnostic_summary.status}; evidence_blockers=${readiness.diagnostic_summary.evidence_blocked_reasons.length}; system_failures=${readiness.diagnostic_summary.system_failure_reasons.length}`);
+    console.log(`Manual action: ${readiness.manual_action}`);
+    console.log('Boundary: writes=false; completion_readiness_artifact=false; command_execution=false; runtime_action=false; git=false; pr=false; push=false; merge=false; platform_api=false');
+    console.log(`Readiness digest: ${readiness.readiness_digest}`);
+    if (readiness.blocked_reasons.length > 0) printList('Blocked reasons', readiness.blocked_reasons);
+    if (readiness.diagnostic_summary?.system_failure_reasons?.length > 0) printList('System failure reasons', readiness.diagnostic_summary.system_failure_reasons);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printCompletionEvidenceBundle(envelope) {
+    const bundle = envelope.completion_evidence_bundle;
+    const humanBundle = bundle.human_completion_evidence_bundle;
+    console.log('Vibecoding Runtime Completion Evidence Bundle');
+    console.log(`Stage: ${bundle.stage}; Human stage: ${humanBundle.stage}; Decision: ${bundle.closeout_decision}`);
+    console.log(`Evidence: ${bundle.evidence_file || 'not provided'}`);
+    console.log(`Ready to report done: ${bundle.readiness_summary.ready_to_report_done ? 'true' : 'false'}`);
+    console.log(`Verification evidence: ${bundle.evidence_inventory.verification_evidence_count}`);
+    console.log(`Unverified items: ${bundle.evidence_inventory.unverified_item_count}`);
+    console.log(`Review feedback: ${bundle.evidence_inventory.review_feedback_status}`);
+    console.log(`Release boundary: ${bundle.evidence_inventory.release_boundary_summary}`);
+    if (bundle.readiness_summary.diagnostic_summary) console.log(`Diagnostic: ${bundle.readiness_summary.diagnostic_summary.status}; evidence_blockers=${bundle.readiness_summary.diagnostic_summary.evidence_blocked_reasons.length}; system_failures=${bundle.readiness_summary.diagnostic_summary.system_failure_reasons.length}`);
+    console.log(`Human delivery gate: ${humanBundle.delivery_gate.pass ? 'pass' : 'blocked'}`);
+    for (const section of humanBundle.one_screen_sections) console.log(`- ${section.section}: ${section.status}; ${section.text}`);
+    console.log(`Manual next action: ${humanBundle.manual_next_action}`);
+    printList('Required manual actions', bundle.required_manual_actions);
+    console.log('Boundary: writes=false; completion_evidence_bundle_artifact=false; human_completion_evidence_bundle_artifact=false; verification_execution=false; git=false; pr=false; push=false; merge=false; platform_api=false; subagent=false');
+    console.log(`Human completion evidence digest: ${humanBundle.human_completion_evidence_digest}`);
+    console.log(`Bundle digest: ${bundle.bundle_digest}`);
+    if (humanBundle.delivery_gate.blockers.length > 0) printList('Blocked reasons', humanBundle.delivery_gate.blockers);
+    if (bundle.readiness_summary.diagnostic_summary?.system_failure_reasons?.length > 0) printList('System failure reasons', bundle.readiness_summary.diagnostic_summary.system_failure_reasons);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  function printSessionClose(envelope) {
+    const alias = envelope.session_close_alias;
+    const bundle = envelope.completion_evidence_bundle;
+    const humanBundle = bundle.human_completion_evidence_bundle;
+    console.log('Vibecoding Runtime Session Close');
+    console.log(`Stage: ${alias.stage}; Kind: ${alias.alias_kind}; canonical=${alias.canonical_command}`);
+    console.log(`Evidence: ${alias.evidence_file || 'not provided'}`);
+    console.log(`Closeout decision: ${alias.closeout_decision}`);
+    console.log(`Completion claim allowed: ${alias.completion_claim_allowed ? 'true' : 'false'}`);
+    console.log(`Human delivery gate: ${alias.delivery_gate_pass ? 'pass' : 'blocked'}`);
+    console.log(`Verification evidence: ${alias.verification_evidence_count}`);
+    console.log(`Manual next action: ${alias.next_manual_action}`);
+    for (const section of humanBundle.one_screen_sections) console.log(`- ${section.section}: ${section.status}; ${section.text}`);
+    printList('Required manual actions', bundle.required_manual_actions);
+    console.log('Boundary: writes=false; session_close_alias_artifact=false; completion_evidence_bundle_artifact=false; human_completion_evidence_bundle_artifact=false; verification_execution=false; command_execution=false; skill_execution=false; workflow_execution=false; git=false; git_write=false; commit=false; pr=false; push=false; merge=false; platform_api=false; model_invocation=false; subagent=false; business_source_write=false');
+    console.log(`Alias digest: ${alias.alias_digest}`);
+    console.log(`Human completion evidence digest: ${alias.human_completion_evidence_digest}`);
+    console.log(`Bundle digest: ${alias.completion_evidence_bundle_digest}`);
+    if (alias.blocked_reasons.length > 0) printList('Blocked reasons', alias.blocked_reasons);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  return {
+    printCompletionReadiness,
+    printCompletionEvidenceBundle,
+    printSessionClose,
+  };
+}