@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-human-completion-evidence-model.mjs

@@ -0,0 +1,220 @@
+export function completionReadinessBoundaryAssertions() {
+  return {
+    writes: false,
+    state_directory_created: false,
+    completion_readiness_artifact: false,
+    sidecar_write: false,
+    skill_execution: false,
+    command_execution: false,
+    runtime_action: false,
+    auto_execution: false,
+    external_network: false,
+    model_invocation: false,
+    platform_api: false,
+    git: false,
+    worktree: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    shell_interception: false,
+    business_source_write: false,
+    source_merge: false,
+  };
+}
+
+export function completionEvidenceSummary({ text = '', source = null } = {}) {
+  if (!source) return { status: 'not_provided', evidence_file: '', evidence_digest: '', verification_evidence: [], unverified_items: ['completion evidence file not provided'], review_feedback_status: 'unknown', release_boundary_summary: 'manual authorization unknown' };
+  const evidenceText = String(text || '');
+  const lines = evidenceText.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const verificationEvidence = lines.filter((line) => /(pass|passed|ok|succeeded|success|通过|完成|node --check|runtime-check|release-check|diff --check)/i.test(line)).slice(0, 20);
+  const unverifiedItems = lines.filter((line) => /(fail|failed|error|todo|unverified|not run|未验证|失败|错误|待验证|blocked)/i.test(line)).slice(0, 20);
+  const reviewFeedbackStatus = /(needs[_ -]?fix|unresolved|review feedback pending|未处理)/i.test(evidenceText) ? 'unresolved' : /(review|审查)/i.test(evidenceText) ? 'recorded' : 'not_recorded';
+  const gitReleaseMentioned = /(commit|push|pr|merge|tag|release|发布)/i.test(evidenceText);
+  const gitReleaseExplicitlyNotRequested = /(?:no|not|without|禁止|不|未).{0,32}(?:commit|push|pr|merge|tag|release|发布)|(?:commit|push|pr|merge|tag|release|发布).{0,32}(?:not requested|not run|not executed|未请求|未执行|不执行|不需要)/i.test(evidenceText);
+  const releaseBoundarySummary = gitReleaseMentioned
+    ? gitReleaseExplicitlyNotRequested
+      ? 'git/release action explicitly not requested'
+      : /(approved|human|manual|确认|授权)/i.test(evidenceText) ? 'manual authorization mentioned' : 'release/git action mentioned without clear manual authorization'
+    : 'no release/git action requested';
+  return {
+    status: 'provided',
+    evidence_file: source.relative,
+    evidence_digest: source.digest,
+    verification_evidence: verificationEvidence,
+    unverified_items: unverifiedItems,
+    review_feedback_status: reviewFeedbackStatus,
+    release_boundary_summary: releaseBoundarySummary,
+  };
+}
+
+export function completionReadinessDiagnosticSummary({ blockedReasons = [], evidenceStatus = '' } = {}) {
+  const reasons = Array.isArray(blockedReasons) ? blockedReasons : [];
+  const systemFailureReasons = reasons.filter((reason) => /system failure|exception|stack trace|internal error|runtime crash|schema violation/i.test(String(reason || '')));
+  const evidenceBlockedReasons = reasons.filter((reason) => !systemFailureReasons.includes(reason));
+  const status = systemFailureReasons.length > 0
+    ? 'system_failure'
+    : evidenceBlockedReasons.length > 0 || evidenceStatus === 'not_provided'
+      ? 'blocked_by_evidence'
+      : 'ready';
+  return {
+    status,
+    ok: status === 'ready',
+    blocked_reason_count: reasons.length,
+    evidence_blocked_reasons: evidenceBlockedReasons,
+    system_failure_reasons: systemFailureReasons,
+    explanation: status === 'system_failure'
+      ? 'The readiness check encountered system-failure indicators and should not be treated as ordinary missing evidence.'
+      : status === 'blocked_by_evidence'
+        ? 'The readiness check completed successfully, but delivery is blocked by missing or insufficient user/CI evidence.'
+        : 'The readiness check completed and has enough local evidence to report completion.',
+  };
+}
+
+export function completionEvidenceBundleBoundaryAssertions(readinessBoundaryAssertions) {
+  return {
+    ...readinessBoundaryAssertions,
+    completion_readiness_artifact: false,
+    completion_evidence_bundle_artifact: false,
+    human_completion_evidence_bundle_artifact: false,
+    verification_execution: false,
+    release_notes_artifact: false,
+    release_gate_artifact: false,
+    commit_guard_artifact: false,
+  };
+}
+
+export function humanCompletionEvidenceBundleInvariants(bundle) {
+  const findings = [];
+  if (bundle.stage !== 'Stage 124') findings.push('stage must be Stage 124');
+  if (bundle.bundle_kind !== 'human-completion-evidence-bundle') findings.push('bundle_kind must be human-completion-evidence-bundle');
+  if (!bundle.source_bindings?.completion_readiness_digest) findings.push('completion readiness digest binding is required');
+  if (!bundle.source_bindings?.registry_digest) findings.push('registry digest binding is required');
+  if (!Array.isArray(bundle.one_screen_sections) || bundle.one_screen_sections.length !== 5) findings.push('one-screen bundle must expose exactly five human sections');
+  if (bundle.delivery_gate?.git_action_allowed !== false) findings.push('git action must remain disallowed by human completion bundle');
+  if (bundle.delivery_gate?.platform_action_allowed !== false) findings.push('platform action must remain disallowed by human completion bundle');
+  if (bundle.delivery_gate?.subagent_allowed !== false) findings.push('subagent must remain disallowed by human completion bundle');
+  const unsafeBoundaries = Object.entries(bundle.boundary_assertions || {}).filter(([, value]) => value !== false).map(([key]) => key);
+  findings.push(...unsafeBoundaries.map((key) => `boundary assertion must remain false: ${key}`));
+  return {
+    pass: findings.length === 0,
+    checked: ['source_bindings', 'one_screen_sections', 'delivery_gate', 'manual_next_action', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+export function buildHumanCompletionEvidenceBundleModel({ readiness, registry, boundaryAssertions, digestObject }) {
+  const evidenceReceipt = {
+    evidence_file: readiness.evidence_file,
+    evidence_digest: readiness.evidence_digest,
+    evidence_status: readiness.evidence_status,
+    verification_evidence_count: readiness.verification_evidence.length,
+    unverified_item_count: readiness.unverified_items.length,
+    review_feedback_status: readiness.review_feedback_status,
+    release_boundary_summary: readiness.release_boundary_summary,
+  };
+  const presentSections = {
+    result: true,
+    verification: readiness.verification_evidence.length > 0,
+    review: readiness.review_feedback_status !== 'not_recorded' && readiness.review_feedback_status !== 'unresolved',
+    release_boundary: !readiness.release_boundary_summary.includes('without clear manual authorization'),
+    next_action: true,
+  };
+  const requiredSections = Object.keys(presentSections);
+  const missingSections = Object.entries(presentSections).filter(([, present]) => !present).map(([section]) => section);
+  const blockers = [...readiness.blocked_reasons, ...missingSections.map((section) => `one-screen section missing or blocked: ${section}`)];
+  const gatePass = blockers.length === 0;
+  const core = {
+    version: 1,
+    stage: 'Stage 124',
+    bundle_kind: 'human-completion-evidence-bundle',
+    source_bindings: {
+      completion_readiness_stage: readiness.stage,
+      completion_readiness_kind: readiness.readiness_kind,
+      completion_readiness_digest: readiness.readiness_digest,
+      completion_evidence_bundle_stage: 'Stage 99',
+      registry_stage: registry.registry_stage,
+      registry_kind: registry.registry_kind,
+      registry_version: registry.registry_version,
+      registry_digest: digestObject(registry),
+    },
+    one_screen_sections: [
+      { section: 'Result', status: readiness.ready_to_report_done ? 'ready' : 'blocked', text: readiness.ready_to_report_done ? 'Ready to report completion with evidence.' : 'Blocked before completion claim.' },
+      { section: 'Verification', status: presentSections.verification ? 'recorded' : 'missing', text: `${readiness.verification_evidence.length} verification evidence line(s) recorded.` },
+      { section: 'Review', status: readiness.review_feedback_status, text: readiness.review_feedback_status === 'recorded' ? 'Review evidence is recorded.' : readiness.review_feedback_status === 'unresolved' ? 'Review feedback is unresolved.' : 'Review evidence is not recorded.' },
+      { section: 'Release boundary', status: presentSections.release_boundary ? 'safe' : 'blocked', text: readiness.release_boundary_summary },
+      { section: 'Next action', status: gatePass ? 'report_only' : 'fix_evidence_first', text: gatePass ? 'Report completion only; keep commit, push, PR, merge, and release manual.' : 'Resolve blockers before claiming done.' },
+    ],
+    evidence_receipt: evidenceReceipt,
+    delivery_gate: {
+      pass: gatePass,
+      required_sections: requiredSections,
+      present_sections: presentSections,
+      missing_sections: missingSections,
+      blockers,
+      completion_claim_allowed: gatePass,
+      git_action_allowed: false,
+      platform_action_allowed: false,
+      subagent_allowed: false,
+    },
+    copy_ready_summary: gatePass
+      ? `Completion is ready to report. Verification evidence: ${readiness.verification_evidence.length}; review=${readiness.review_feedback_status}; release boundary=${readiness.release_boundary_summary}.`
+      : `Completion is blocked. Blockers: ${blockers.join('; ')}`,
+    manual_next_action: gatePass ? 'Tell the user what changed and cite the evidence; do not imply git/PR/release actions were performed.' : 'Collect or rerun the missing local evidence, resolve review feedback, then regenerate this bundle.',
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = humanCompletionEvidenceBundleInvariants(core);
+  return {
+    ...core,
+    human_completion_evidence_invariants: invariants,
+    human_completion_evidence_digest: digestObject({ ...core, human_completion_evidence_invariants: invariants }),
+  };
+}
+
+export function buildCompletionEvidenceBundleModel({ readiness, registry, boundaryAssertions, digestObject }) {
+  const humanBundle = buildHumanCompletionEvidenceBundleModel({ readiness, registry, boundaryAssertions, digestObject });
+  const manualActions = readiness.ready_to_report_done
+    ? ['report_completion_with_listed_evidence', 'keep_git_pr_release_actions_manual']
+    : ['resolve_blocked_reasons_before_claiming_done', 'rerun_fresh_verification_or_update_evidence'];
+  const bundle = {
+    version: 1,
+    stage: 'Stage 99',
+    bundle_kind: 'completion-evidence-bundle',
+    source_kind: readiness.evidence_status === 'provided' ? 'local-completion-evidence-file' : 'not_provided',
+    evidence_file: readiness.evidence_file,
+    evidence_digest: readiness.evidence_digest,
+    readiness_summary: {
+      stage: readiness.stage,
+      readiness_kind: readiness.readiness_kind,
+      ready_to_report_done: readiness.ready_to_report_done,
+      readiness_digest: readiness.readiness_digest,
+      blocked_reasons: readiness.blocked_reasons,
+      diagnostic_summary: readiness.diagnostic_summary,
+    },
+    evidence_inventory: {
+      verification_evidence_count: readiness.verification_evidence.length,
+      verification_evidence: readiness.verification_evidence,
+      unverified_item_count: readiness.unverified_items.length,
+      unverified_items: readiness.unverified_items,
+      review_feedback_status: readiness.review_feedback_status,
+      release_boundary_summary: readiness.release_boundary_summary,
+    },
+    human_completion_evidence_bundle: humanBundle,
+    closeout_decision: humanBundle.delivery_gate.pass ? 'ready_to_report_done' : 'blocked_before_completion_claim',
+    required_manual_actions: manualActions,
+    forbidden_actions: ['execute_tests', 'run_git', 'commit', 'push', 'pr', 'merge', 'tag', 'write_sidecar', 'mutate_worktree', 'invoke_model', 'call_platform_api', 'dispatch_subagent'],
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  return { ...bundle, bundle_digest: digestObject(bundle) };
+}

package/tools/vibe-runtime/runtime-human-friendly-aliases.mjs

@@ -0,0 +1,250 @@
+import crypto from 'node:crypto';
+
+const humanAliasStage = 'Stage 114';
+const closeLoopAliasKind = 'human-friendly-close-loop-alias';
+const nextEvidenceAliasKind = 'human-friendly-next-evidence-alias';
+
+export function runtimeHumanFriendlyCloseLoopAlias({ closeLoopDashboard = {}, registry = {}, registryDigest = '' } = {}) {
+  const boundaryAssertions = runtimeHumanFriendlyAliasBoundaryAssertions();
+  const sections = {
+    Plan: statusSection(closeLoopDashboard.plan_status?.pass === true, `action_items=${count(closeLoopDashboard.plan_status?.action_item_count)}`),
+    Docs: statusSection((closeLoopDashboard.docs_status?.gaps || []).length === 0, `expectations=${count(closeLoopDashboard.docs_status?.expectation_count)}`),
+    Code: statusSection((closeLoopDashboard.code_status?.gaps || []).length === 0, `expectations=${count(closeLoopDashboard.code_status?.expectation_count)}`),
+    'Self-test': statusSection(closeLoopDashboard.self_test_status?.all_gates_planned_not_run === true, `planned_not_run=${count(closeLoopDashboard.self_test_status?.planned_not_run_count)}`),
+    Diff: statusSection(false, 'not provided by close-loop alias'),
+    Review: statusSection(false, 'not provided by close-loop alias'),
+    TDD: statusSection(false, 'not provided by close-loop alias'),
+    Commit: statusSection(closeLoopDashboard.commit_status?.subject_guard_pass === true, 'commit_ready=false'),
+    'Next evidence': statusSection(true, closeLoopDashboard.next_manual_action || 'Collect local evidence before any manual execution or commit.'),
+  };
+  const alias = {
+    version: 1,
+    stage: humanAliasStage,
+    alias_kind: closeLoopAliasKind,
+    source_bindings: {
+      close_loop_dashboard_stage: closeLoopDashboard.stage || '',
+      close_loop_dashboard_kind: closeLoopDashboard.dashboard_kind || '',
+      close_loop_dashboard_digest: closeLoopDashboard.close_loop_dashboard_digest || '',
+      registry_stage: registry.registry_stage || '',
+      registry_kind: registry.registry_kind || '',
+      registry_version: registry.registry_version || 0,
+      registry_digest: registryDigest,
+    },
+    labels: Object.keys(sections),
+    sections,
+    next_manual_action: closeLoopDashboard.next_manual_action || 'Collect local close-loop evidence manually; this alias did not execute anything.',
+    allowed_followup: ['manual evidence collection', 'workflow --next-evidence with local evidence files', 'manual commit only after explicit human action'],
+    forbidden_actions: humanAliasForbiddenActions(),
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeHumanFriendlyAliasInvariants(alias);
+  return {
+    ...alias,
+    human_friendly_alias_invariants: invariants,
+    manual_action: invariants.pass ? alias.next_manual_action : 'Resolve alias source binding or boundary gaps before using this summary.',
+  };
+}
+
+export function runtimeHumanFriendlyNextEvidenceAlias({
+  planActionManifest = {},
+  evidenceIntake = null,
+  diffCoverage = null,
+  reviewIntake = null,
+  tddTrace = null,
+  registry = {},
+  registryDigest = '',
+} = {}) {
+  const boundaryAssertions = runtimeHumanFriendlyAliasBoundaryAssertions();
+  const evidenceInputs = {
+    evidence: evidenceStatus('Evidence', evidenceIntake, evidenceIntake?.evidence_intake_invariants, evidenceIntake?.blocked_reasons),
+    diff: evidenceStatus('Diff', diffCoverage, diffCoverage?.diff_coverage_invariants, diffCoverage?.blocked_reasons),
+    review: evidenceStatus('Review', reviewIntake, reviewIntake?.review_intake_invariants, reviewIntake?.blocked_reasons),
+    tdd: evidenceStatus('TDD', tddTrace, tddTrace?.tdd_trace_invariants, tddTrace?.blocked_reasons),
+  };
+  const gaps = nextEvidenceGaps(evidenceInputs);
+  const sections = {
+    Plan: statusSection(planActionManifest.manifest_invariants?.pass === true, `action_items=${count(planActionManifest.action_items?.length)}`),
+    Docs: statusSection((planActionManifest.docs_expectations || []).length > 0, `expectations=${count(planActionManifest.docs_expectations?.length)}`),
+    Code: statusSection((planActionManifest.code_expectations || []).length > 0, `expectations=${count(planActionManifest.code_expectations?.length)}`),
+    'Self-test': statusSection(Boolean(evidenceIntake), evidenceInputs.evidence.summary),
+    Diff: statusSection(evidenceInputs.diff.status === 'usable', evidenceInputs.diff.summary),
+    Review: statusSection(evidenceInputs.review.status === 'usable', evidenceInputs.review.summary),
+    TDD: statusSection(evidenceInputs.tdd.status === 'usable', evidenceInputs.tdd.summary),
+    Commit: statusSection(gaps.length === 0, gaps.length === 0 ? 'evidence complete for manual commit readiness review' : 'manual commit remains blocked by evidence gaps'),
+    'Next evidence': statusSection(true, gaps[0]?.action || 'No missing local evidence category detected; proceed to manual review and commit readiness.'),
+  };
+  const alias = {
+    version: 1,
+    stage: humanAliasStage,
+    alias_kind: nextEvidenceAliasKind,
+    source_bindings: {
+      plan_action_manifest_stage: planActionManifest.stage || '',
+      plan_action_manifest_digest: planActionManifest.plan_action_manifest_digest || '',
+      evidence_intake_stage: evidenceIntake?.stage || '',
+      evidence_intake_digest: evidenceIntake?.evidence_intake_digest || '',
+      diff_coverage_stage: diffCoverage?.stage || '',
+      diff_coverage_digest: diffCoverage?.diff_coverage_digest || '',
+      review_intake_stage: reviewIntake?.stage || '',
+      review_intake_digest: reviewIntake?.review_intake_digest || '',
+      tdd_trace_stage: tddTrace?.stage || '',
+      tdd_trace_digest: tddTrace?.tdd_trace_digest || '',
+      registry_stage: registry.registry_stage || '',
+      registry_kind: registry.registry_kind || '',
+      registry_version: registry.registry_version || 0,
+      registry_digest: registryDigest,
+    },
+    labels: Object.keys(sections),
+    sections,
+    evidence_inputs: evidenceInputs,
+    evidence_gaps: gaps,
+    next_evidence: gaps[0] || { kind: 'manual-review', action: 'Review all local evidence manually before commit readiness.' },
+    allowed_followup: ['provide local evidence JSON', 'provide local diff file', 'provide local review JSON', 'provide local TDD trace JSON', 'manual commit readiness review'],
+    forbidden_actions: humanAliasForbiddenActions(),
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeHumanFriendlyAliasInvariants(alias);
+  return {
+    ...alias,
+    human_friendly_alias_invariants: invariants,
+    manual_action: invariants.pass ? alias.next_evidence.action : 'Resolve alias source binding or boundary gaps before using this next-evidence summary.',
+  };
+}
+
+export function runtimeHumanFriendlyAliasInvariants(alias) {
+  const writableBoundaries = Object.entries(alias.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const forbiddenMissing = ['human_friendly_alias_artifact', 'command_execution', 'check_execution', 'test_execution', 'repair_execution', 'git', 'git_write', 'commit', 'push', 'pr', 'merge', 'platform_api', 'external_network', 'model_invocation', 'subagent', 'mcp', 'business_source_write']
+    .filter((key) => alias.boundary_assertions?.[key] !== false);
+  const findings = [
+    ...(alias.stage === humanAliasStage ? [] : ['alias stage must be Stage 114']),
+    ...(alias.source_bindings?.registry_digest ? [] : ['missing registry digest binding']),
+    ...(alias.labels?.includes('Plan') && alias.labels?.includes('Next evidence') ? [] : ['human labels must include Plan and Next evidence']),
+    ...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: ['human_friendly_labels', 'source_bindings', 'no_execution', 'no_writes', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+export function runtimeHumanFriendlyAliasBoundaryAssertions() {
+  return {
+    human_friendly_alias_artifact: false,
+    close_loop_alias_artifact: false,
+    next_evidence_alias_artifact: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    check_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 runtimeHumanFriendlyAliasDigestPayload(alias) {
+  return {
+    stage: alias.stage,
+    alias_kind: alias.alias_kind,
+    source_bindings: alias.source_bindings,
+    labels: alias.labels,
+    sections: alias.sections,
+    evidence_inputs: alias.evidence_inputs,
+    evidence_gaps: alias.evidence_gaps,
+    next_evidence: alias.next_evidence,
+    next_manual_action: alias.next_manual_action,
+    allowed_followup: alias.allowed_followup,
+    forbidden_actions: alias.forbidden_actions,
+    boundary_assertions: alias.boundary_assertions,
+    human_friendly_alias_invariants: alias.human_friendly_alias_invariants,
+  };
+}
+
+export function digestHumanFriendlyAlias(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function evidenceStatus(label, envelope, invariants, blockedReasons = []) {
+  if (!envelope) return { label, status: 'missing', summary: `${label} evidence file not provided`, blocked_reasons: [`${label} evidence file not provided`] };
+  const blocked = blockedReasons || [];
+  const usable = invariants?.pass === true && blocked.length === 0;
+  return {
+    label,
+    status: usable ? 'usable' : 'blocked',
+    summary: usable ? `${label} evidence usable` : `${label} evidence has ${blocked.length || invariants?.findings?.length || 1} gap(s)`,
+    blocked_reasons: blocked.length > 0 ? blocked : invariants?.findings || [],
+  };
+}
+
+function nextEvidenceGaps(inputs) {
+  const order = [
+    ['evidence', 'Self-test evidence', 'Provide --evidence-file with local check output JSON.'],
+    ['diff', 'Diff evidence', 'Provide --diff-file with local git diff output saved by the user.'],
+    ['review', 'Review evidence', 'Provide --review-file with local review feedback JSON.'],
+    ['tdd', 'TDD evidence', 'Provide --tdd-file with local RED-GREEN-REFACTOR trace JSON when TDD applies.'],
+  ];
+  return order.flatMap(([key, kind, action]) => {
+    const item = inputs[key];
+    if (!item || item.status === 'usable') return [];
+    return [{ kind, status: item.status, action, reasons: item.blocked_reasons || [] }];
+  });
+}
+
+function statusSection(pass, summary) {
+  return { pass: Boolean(pass), summary: String(summary || ''), execution_authorized: false };
+}
+
+function count(value) {
+  return Number.isFinite(Number(value)) ? Number(value) : 0;
+}
+
+function humanAliasForbiddenActions() {
+  return [
+    'executing tests, checks, repair, formatting, code generation, or workflow actions',
+    'creating or rewriting evidence, diff, review, TDD, sidecar, or .vibecoding-state artifacts',
+    'git command, commit, push, PR, merge, tag, reset, checkout, or history rewrite',
+    'platform API, external network, model, MCP, subagent, scheduler, daemon, or retry invocation',
+    'treating a human-friendly alias as execution, commit, push, PR, or merge permission',
+  ];
+}
+
+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-implementation-methodology-command.mjs

@@ -0,0 +1,17 @@
+import {
+  implementationMethodologyGateEnvelope,
+} from './runtime-implementation-methodology-gates.mjs';
+import { emitMethodologyGateOutput } from './runtime-methodology-gate-output-envelope.mjs';
+import { printImplementationMethodologyGate } from './runtime-methodology-presentation.mjs';
+
+export function runImplementationMethodologyGateCommand(deps, options) {
+  if (options.confirm || options.dryRun || options.write || options.scan || options.once || options.preflight || options.dispatch || options.dispatchIntent || options.run || options.autoRun) {
+    throw new Error('implementation methodology gate is read-only and does not accept execution, dispatch, preview, confirm, write, scan, or preflight flags');
+  }
+  if (!options.fromFile) throw new Error('methodology --gate implementation artifact checks require --from-file <local-artifact-file>');
+  const envelope = implementationMethodologyGateEnvelope(options.root, {
+    kind: options.methodologyKind,
+    fromFile: options.fromFile,
+  });
+  emitMethodologyGateOutput({ deps, options, envelope, printGate: printImplementationMethodologyGate });
+}

package/tools/vibe-runtime/runtime-implementation-methodology-gates.mjs

@@ -0,0 +1,164 @@
+import crypto from 'node:crypto';
+import { runtimeStatePresent } from './runtime-state-presence-model.mjs';
+import {
+  productMethodologyBoundaryAssertions,
+  readLocalTextArtifact,
+} from './runtime-product-methodology-gates.mjs';
+import {
+  parseImplementationTaskRegistry,
+  validateImplementationTaskRegistry,
+} from './runtime-implementation-task-registry.mjs';
+
+export const implementationMethodologyGateKinds = new Set(['implementation-plan']);
+
+const falseBoundaryKeys = ['writes', 'state_directory_created', 'command_execution', 'test_execution', 'skill_execution', 'subagent', 'mcp', 'git'];
+const requiredSections = ['Goal', 'Architecture Binding', 'Implementation Task Registry', 'Delivery Traceability', 'Boundary'];
+
+export function normalizeImplementationMethodologyKind(kind) {
+  return String(kind || '').trim().toLowerCase().replace(/_/g, '-');
+}
+
+export function implementationMethodologyGateEnvelope(root, { kind = '', fromFile = '', scenarioRefs = [] } = {}) {
+  const gateKind = normalizeImplementationMethodologyKind(kind);
+  if (!implementationMethodologyGateKinds.has(gateKind)) throw new Error(`unsupported implementation methodology gate kind: ${kind}`);
+  const source = readLocalTextArtifact(root, fromFile, `methodology --gate --kind ${gateKind}`);
+  const validation = validateImplementationPlanArtifact(source.text, { scenarioRefs });
+  const boundaryAssertions = implementationMethodologyBoundaryAssertions();
+  const checks = validation.checks;
+  const blockedReasons = checks.filter((check) => !check.pass).map((check) => `${check.id}: ${check.reason}`);
+  const gate = {
+    version: 1,
+    stage: 'Stage 156',
+    gate_kind: gateKind,
+    artifact_kind: 'implementation-plan',
+    gate_outcome: blockedReasons.length === 0 ? 'pass' : 'blocked',
+    source_bindings: {
+      artifact_file: source.relative,
+      artifact_digest: source.digest,
+      expected_source_skill: 'vibe-writing-plans',
+      declared_source_skill: validation.declared_source_skill,
+      declared_next_skill: validation.declared_next_skill,
+      implementation_task_registry_digest: validation.registry.registry_digest,
+    },
+    implementation_task_registry: {
+      tasks: validation.registry.tasks,
+      task_ids: validation.registry.task_ids,
+      registry_digest: validation.registry.registry_digest,
+    },
+    implementation_task_registry_gate: validation.registryGate,
+    checks,
+    blocked_reasons: blockedReasons,
+    summary: {
+      required_section_count: requiredSections.length,
+      ...validation.registryGate.summary,
+    },
+    invariants: {
+      pass: blockedReasons.length === 0 && Object.values(boundaryAssertions).every((value) => value === false),
+      checked: ['source_binding', 'implementation_task_registry', 'required_sections', 'boundary_assertions'],
+    },
+    next_manual_action: blockedReasons.length === 0
+      ? 'Implementation task contract is complete enough for deterministic diff/test alignment; no workflow, test, browser, subagent, git, or platform action was run.'
+      : 'Fix the listed implementation plan task registry gaps manually, then rerun methodology --gate with the same local file.',
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  return {
+    mode: 'implementation-methodology-gate',
+    ok: gate.invariants.pass,
+    state_present: runtimeStatePresent(root),
+    implementation_methodology_gate: {
+      ...gate,
+      gate_digest: digestImplementationMethodologyGate(implementationMethodologyGateDigestPayload(gate)),
+    },
+    safety: { stage: gate.stage, ...boundaryAssertions },
+    quality: blockedReasons,
+    action: 'methodology implementation gate read one local implementation plan artifact and computed deterministic task registry checks only. No state directory, artifact write, workflow skill execution, command/check/test/browser execution, runtime action, git, platform API, external network, model, MCP, subagent, or business source mutation occurred.',
+  };
+}
+
+export function implementationMethodologyBoundaryAssertions() {
+  return {
+    ...productMethodologyBoundaryAssertions(),
+    implementation_plan_artifact_write: false,
+    diff_coverage_artifact: false,
+    test_evidence_artifact: false,
+    commit_readiness_artifact: false,
+    git_add: false,
+    history_rewrite: false,
+  };
+}
+
+export function implementationMethodologyGateDigestPayload(gate) {
+  return {
+    version: gate.version,
+    stage: gate.stage,
+    gate_kind: gate.gate_kind,
+    artifact_kind: gate.artifact_kind,
+    source_bindings: gate.source_bindings,
+    implementation_task_registry: gate.implementation_task_registry,
+    checks: gate.checks,
+    summary: gate.summary,
+    boundary_assertions: gate.boundary_assertions,
+    writes: gate.writes,
+    state_directory_created: gate.state_directory_created,
+  };
+}
+
+export function digestImplementationMethodologyGate(payload) {
+  return crypto.createHash('sha256').update(stableStringify(payload)).digest('hex');
+}
+
+function validateImplementationPlanArtifact(text, { scenarioRefs = [] } = {}) {
+  const frontmatter = parseFrontmatter(text);
+  const registry = parseImplementationTaskRegistry(text);
+  const registryGate = validateImplementationTaskRegistry(registry, { scenarioRefs });
+  const checks = [];
+  for (const section of requiredSections) addCheck(checks, `section.${section}`, hasSection(text, section), `missing section: ${section}`);
+  addCheck(checks, 'implementation_task_registry.non_empty', registry.tasks.length > 0, 'Implementation Task Registry must define at least one task');
+  for (const reason of registryGate.blocked_reasons) addCheck(checks, `implementation_task_registry.${checks.length}`, false, reason);
+  for (const key of falseBoundaryKeys) addCheck(checks, `boundary.${key}`, boundaryFalse(text, key), `Boundary must declare ${key}: false`);
+  return {
+    declared_source_skill: frontmatter.source_skill || 'vibe-writing-plans',
+    declared_next_skill: frontmatter.next_skill || '',
+    registry,
+    registryGate,
+    checks,
+  };
+}
+
+function parseFrontmatter(text) {
+  const match = text.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+  if (!match) return {};
+  return Object.fromEntries(match[1].split(/\r?\n/).map((line) => line.match(/^([A-Za-z0-9_-]+):\s*(.*?)\s*$/)).filter(Boolean).map(([, key, value]) => [key, stripQuotes(value)]));
+}
+
+function hasSection(text, section) {
+  return new RegExp(`(^|\\n)##\\s+${escapeRegex(section)}\\s*(\\n|$)`, 'i').test(text);
+}
+
+function boundaryFalse(text, key) {
+  return new RegExp(`(^|\\n)\\s*-?\\s*${escapeRegex(key)}\\s*:\\s*false\\s*(\\n|$)`, 'i').test(text);
+}
+
+function addCheck(checks, id, pass, reason) {
+  checks.push({ id, pass: Boolean(pass), reason: pass ? 'ok' : reason });
+}
+
+function stripQuotes(value) {
+  return String(value || '').trim().replace(/^['"]|['"]$/g, '');
+}
+
+function escapeRegex(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}