@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-methodology-coverage-map.mjs

@@ -0,0 +1,398 @@
+import crypto from 'node:crypto';
+
+const coverageStage = 'Stage 136';
+const coverageKind = 'methodology-coverage-map';
+const coverageTarget = 'fork/superpowers';
+
+const methodologyPatterns = [
+  {
+    id: 'brainstorming',
+    label: 'Brainstorming',
+    superpowers_markers: ['brainstorming', 'Present Options', 'Alternate Approaches'],
+    vibecoding_markers: ['vibe-brainstorming', '需求模糊', 'vibe-planning'],
+    quality_value: 'Prevents unclear feature work from jumping straight to implementation.',
+    valuable_gap_rule: 'Only a gap if Vibecoding lacks an explicit ambiguity-first route.',
+  },
+  {
+    id: 'planning',
+    label: 'Planning',
+    superpowers_markers: ['planning', 'design', 'architecture'],
+    vibecoding_markers: ['vibe-planning', '架构', 'tradeoff'],
+    quality_value: 'Keeps architectural choice and boundary reasoning visible before edits.',
+    valuable_gap_rule: 'Only a gap if planning evidence cannot be routed or verified locally.',
+  },
+  {
+    id: 'writing_plans',
+    label: 'Writing plans',
+    superpowers_markers: ['writing-plans', 'Exact file paths', 'No Placeholders', 'Task Structure'],
+    vibecoding_markers: ['vibe-writing-plans', 'planner --action-manifest', 'plan-to-action manifest', 'planner --lint'],
+    quality_value: 'Turns broad plans into task-sized, file-bound acceptance before execution.',
+    valuable_gap_rule: 'Only a gap if plans cannot be decomposed into local action contracts.',
+  },
+  {
+    id: 'tdd',
+    label: 'TDD',
+    superpowers_markers: ['test-driven-development', 'NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST', 'RED', 'GREEN', 'REFACTOR'],
+    vibecoding_markers: ['vibe-test-driven-development', 'verification --tdd-trace', 'TDD trace', 'RED-GREEN-REFACTOR'],
+    quality_value: 'Preserves test-first discipline while keeping validation evidence inspectable.',
+    valuable_gap_rule: 'Only a gap if TDD evidence cannot be bound without running tests implicitly.',
+  },
+  {
+    id: 'debugging',
+    label: 'Debugging',
+    superpowers_markers: ['systematic-debugging', 'root cause', 'reproduce'],
+    vibecoding_markers: ['vibe-systematic-debugging', 'bug 未复现', '未定位根因', 'vibe-test-driven-development'],
+    quality_value: 'Avoids blind bug fixes by requiring reproduction and root-cause evidence.',
+    valuable_gap_rule: 'Only a gap if debug routing does not block blind fixes.',
+  },
+  {
+    id: 'review',
+    label: 'Review',
+    superpowers_markers: ['requesting-code-review', 'code review', 'review', 'blocking'],
+    vibecoding_markers: ['vibe-requesting-code-review', 'vibe-review', 'review --intake', 'review --resolution'],
+    quality_value: 'Keeps review focused on blockers, risk, evidence, and resolution tracking.',
+    valuable_gap_rule: 'Only a gap if review feedback cannot be intake-bound before repair.',
+  },
+  {
+    id: 'completion',
+    label: 'Completion',
+    superpowers_markers: ['verification-before-completion', 'NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE', 'finishing-a-development-branch'],
+    vibecoding_markers: ['vibe-verification-before-completion', 'vibe-finishing-a-development-branch', 'completion --evidence-bundle', 'release --commit-readiness'],
+    quality_value: 'Prevents completion claims without fresh local validation and commit readiness evidence.',
+    valuable_gap_rule: 'Only a gap if completion can be claimed without evidence gates.',
+  },
+  {
+    id: 'worktree_isolation',
+    label: 'Worktree isolation',
+    superpowers_markers: ['worktree', 'workspace isolation', 'branch isolation'],
+    vibecoding_markers: ['vibe-workspace-isolation', 'worktree=false', 'workspace isolation', '工作区'],
+    quality_value: 'Surfaces isolation decisions before risky or parallel branch work.',
+    valuable_gap_rule: 'Only a gap if risky work has no isolation judgment path.',
+  },
+  {
+    id: 'subagent_driven_development',
+    label: 'Subagent-driven development',
+    superpowers_markers: ['subagent-driven-development', 'fresh subagent', 'dispatch', 'review package'],
+    vibecoding_markers: ['vibe-subagent-driven-development', '用户明确允许', 'subagent=false', 'canCallSubagent'],
+    quality_value: 'Keeps delegation value visible without defaulting to hidden agent sessions.',
+    valuable_gap_rule: 'Partial coverage is acceptable unless explicit permission and review gates are missing.',
+  },
+  {
+    id: 'writing_skills',
+    label: 'Writing skills',
+    superpowers_markers: ['writing-skills', 'Skill Changes Require Evaluation', 'run-skill-tests', 'eval'],
+    vibecoding_markers: ['vibe-writing-skills', 'Workflow Handoff', 'runtime skill', 'skills/'],
+    quality_value: 'Treats skill changes as behavior-shaping code with handoff and evaluation expectations.',
+    valuable_gap_rule: 'Only a gap if skill edits lack boundary, handoff, or validation routing.',
+  },
+  {
+    id: 'contributor_pr_guardrails',
+    label: 'Contributor / PR guardrails',
+    superpowers_markers: ['PULL_REQUEST_TEMPLATE', 'Existing PRs', 'Identify yourself', 'human partner', 'target the `dev` branch'],
+    vibecoding_markers: ['release --commit-readiness', 'governance --pr-readiness', 'governance --pr-review-intake', 'PR', 'commit_execution_authorized=false'],
+    quality_value: 'Turns contribution risk into local evidence requirements without remote PR automation.',
+    valuable_gap_rule: 'Only a gap if local closeout cannot express PR readiness or review intake evidence.',
+  },
+];
+
+const vibecodingSpecificPatterns = [
+  {
+    id: 'local_runtime_contracts',
+    label: 'Local runtime contracts',
+    evidence_markers: ['runtime-capability-registry', 'runtime-check', 'release-check', 'digest'],
+    value: 'Vibecoding makes workflow behavior auditable through deterministic local envelopes and digests.',
+  },
+  {
+    id: 'token_savior_budget',
+    label: 'Token Savior budget',
+    evidence_markers: ['tokens --savior-budget', 'Token Savior', 'skills_to_defer', 'context_budget'],
+    value: 'Vibecoding treats context exposure as a deterministic budget instead of eager full-skill injection.',
+  },
+  {
+    id: 'experience_dashboard',
+    label: 'Experience regression dashboard',
+    evidence_markers: ['governance --experience-dashboard', 'experience dashboard', 'daily_user_friction_delta'],
+    value: 'Vibecoding scores whether the workflow reduces daily user friction over time.',
+  },
+];
+
+export function runtimeMethodologyCoverageMap({ superpowersSources = [], vibecodingSources = [], registry = {}, source = {} } = {}) {
+  const patterns = methodologyPatterns.map((definition) => coverageForPattern(definition, superpowersSources, vibecodingSources));
+  const covered = patterns.filter((pattern) => pattern.status === 'covered');
+  const partial = patterns.filter((pattern) => pattern.status === 'partial');
+  const missing = patterns.filter((pattern) => pattern.status === 'missing' && pattern.superpowers_score > 0);
+  const core = {
+    version: 1,
+    stage: coverageStage,
+    coverage_kind: coverageKind,
+    comparison_target: coverageTarget,
+    source_bindings: sourceBindingSummary(source, superpowersSources, vibecodingSources),
+    registry_binding: {
+      registry_stage: registry.registry_stage || '',
+      registry_kind: registry.registry_kind || '',
+      registry_version: registry.registry_version || 0,
+    },
+    methodology_coverage_map: patterns,
+    covered_patterns: covered.map(patternSummary),
+    partial_patterns: partial.map(patternSummary),
+    missing_patterns: missing.map(patternSummary),
+    vibecoding_specific_patterns: vibecodingSpecificCoverage(vibecodingSources),
+    coverage_summary: coverageSummary(patterns),
+    next_coverage_bet: nextCoverageBet(partial, missing),
+    boundary_assertions: runtimeMethodologyCoverageBoundaryAssertions(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = runtimeMethodologyCoverageInvariants(core);
+  const map = {
+    ...core,
+    ok: invariants.pass,
+    methodology_coverage_invariants: invariants,
+  };
+  return {
+    ...map,
+    coverage_digest: digestMethodologyCoverage(runtimeMethodologyCoverageDigestPayload(map)),
+  };
+}
+
+export function runtimeMethodologyCoverageDigestPayload(map) {
+  return {
+    stage: map.stage,
+    coverage_kind: map.coverage_kind,
+    comparison_target: map.comparison_target,
+    source_bindings: map.source_bindings,
+    registry_binding: map.registry_binding,
+    methodology_coverage_map: map.methodology_coverage_map,
+    covered_patterns: map.covered_patterns,
+    partial_patterns: map.partial_patterns,
+    missing_patterns: map.missing_patterns,
+    vibecoding_specific_patterns: map.vibecoding_specific_patterns,
+    coverage_summary: map.coverage_summary,
+    next_coverage_bet: map.next_coverage_bet,
+    boundary_assertions: map.boundary_assertions,
+    methodology_coverage_invariants: map.methodology_coverage_invariants,
+  };
+}
+
+export function runtimeMethodologyCoverageBoundaryAssertions() {
+  return {
+    methodology_coverage_artifact: false,
+    coverage_map_artifact: false,
+    source_write: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    check_execution: false,
+    smoke_execution: false,
+    test_execution: false,
+    verification_execution: false,
+    hook_execution: false,
+    adapter_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    auto_execution: false,
+    repair_execution: false,
+    prompt_mutation: false,
+    skill_mutation: false,
+    hook_registration: 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 runtimeMethodologyCoverageInvariants(map) {
+  const patternIds = (map.methodology_coverage_map || []).map((pattern) => pattern.id);
+  const expectedIds = methodologyPatterns.map((pattern) => pattern.id);
+  const missingPatternIds = expectedIds.filter((id) => !patternIds.includes(id));
+  const duplicatePatternIds = patternIds.filter((id, index, ids) => ids.indexOf(id) !== index);
+  const unsafeBoundaries = Object.entries(map.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const missingForbidden = Object.keys(runtimeMethodologyCoverageBoundaryAssertions())
+    .filter((key) => map.boundary_assertions?.[key] !== false);
+  const findings = [
+    ...(map.stage === coverageStage ? [] : [`stage must be ${coverageStage}`]),
+    ...(map.coverage_kind === coverageKind ? [] : [`coverage_kind must be ${coverageKind}`]),
+    ...(map.comparison_target === coverageTarget ? [] : [`comparison_target must be ${coverageTarget}`]),
+    ...(map.source_bindings?.superpowers?.present_files > 0 ? [] : ['superpowers source files must be present']),
+    ...(map.source_bindings?.vibecoding?.present_files > 0 ? [] : ['vibecoding source files must be present']),
+    ...(map.registry_binding?.registry_version >= 35 ? [] : ['registry version must be at least 35 for Stage 136']),
+    ...(Array.isArray(map.covered_patterns) ? [] : ['covered_patterns must be a list']),
+    ...(Array.isArray(map.partial_patterns) ? [] : ['partial_patterns must be a list']),
+    ...(Array.isArray(map.missing_patterns) ? [] : ['missing_patterns must be a list']),
+    ...(Array.isArray(map.vibecoding_specific_patterns) ? [] : ['vibecoding_specific_patterns must be a list']),
+    ...(map.coverage_summary?.total_patterns === methodologyPatterns.length ? [] : ['coverage_summary.total_patterns must match Stage 136 methodology pattern count']),
+    ...(map.next_coverage_bet?.target_stage ? [] : ['next_coverage_bet.target_stage is required']),
+    ...missingPatternIds.map((id) => `missing methodology pattern: ${id}`),
+    ...duplicatePatternIds.map((id) => `duplicate methodology pattern: ${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: ['source_bindings', 'registry_binding', 'methodology_pattern_coverage', 'valuable_gap_filter', 'vibecoding_specific_patterns', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+export function digestMethodologyCoverage(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function coverageForPattern(definition, superpowersSources, vibecodingSources) {
+  const superpowersEvidence = evidenceForMarkers(superpowersSources, definition.superpowers_markers);
+  const vibecodingEvidence = evidenceForMarkers(vibecodingSources, definition.vibecoding_markers);
+  const superpowersScore = scoreEvidence(superpowersEvidence);
+  const vibecodingScore = scoreEvidence(vibecodingEvidence);
+  const status = coverageStatus(superpowersScore, vibecodingScore);
+  return {
+    id: definition.id,
+    label: definition.label,
+    quality_value: definition.quality_value,
+    valuable_gap_rule: definition.valuable_gap_rule,
+    superpowers_score: superpowersScore,
+    vibecoding_score: vibecodingScore,
+    status,
+    gap_is_valuable: status !== 'covered' && superpowersScore > 0,
+    superpowers_evidence: superpowersEvidence,
+    vibecoding_evidence: vibecodingEvidence,
+  };
+}
+
+function evidenceForMarkers(sources, markers) {
+  return markers.map((marker) => {
+    const hits = sources.filter((source) => source.present && source.marker_hits?.includes(marker));
+    return {
+      marker,
+      present: hits.length > 0,
+      files: hits.map((source) => source.file).slice(0, 8),
+    };
+  });
+}
+
+function scoreEvidence(evidence) {
+  if (!Array.isArray(evidence) || evidence.length === 0) return 0;
+  return Math.round((evidence.filter((item) => item.present).length / evidence.length) * 100);
+}
+
+function coverageStatus(superpowersScore, vibecodingScore) {
+  if (vibecodingScore >= 67) return 'covered';
+  if (vibecodingScore > 0 || superpowersScore === 0) return 'partial';
+  return 'missing';
+}
+
+function patternSummary(pattern) {
+  return {
+    id: pattern.id,
+    label: pattern.label,
+    status: pattern.status,
+    superpowers_score: pattern.superpowers_score,
+    vibecoding_score: pattern.vibecoding_score,
+    gap_is_valuable: pattern.gap_is_valuable,
+    quality_value: pattern.quality_value,
+    valuable_gap_rule: pattern.valuable_gap_rule,
+  };
+}
+
+function vibecodingSpecificCoverage(vibecodingSources) {
+  return vibecodingSpecificPatterns.map((definition) => {
+    const evidence = evidenceForMarkers(vibecodingSources, definition.evidence_markers);
+    return {
+      id: definition.id,
+      label: definition.label,
+      value: definition.value,
+      score: scoreEvidence(evidence),
+      evidence,
+    };
+  });
+}
+
+function coverageSummary(patterns) {
+  return {
+    total_patterns: patterns.length,
+    covered: patterns.filter((pattern) => pattern.status === 'covered').length,
+    partial: patterns.filter((pattern) => pattern.status === 'partial').length,
+    missing: patterns.filter((pattern) => pattern.status === 'missing').length,
+    valuable_gaps: patterns.filter((pattern) => pattern.gap_is_valuable).length,
+  };
+}
+
+function nextCoverageBet(partial, missing) {
+  const candidate = missing.find((pattern) => pattern.gap_is_valuable) || partial.find((pattern) => pattern.gap_is_valuable) || partial[0];
+  if (!candidate) {
+    return {
+      id: 'preserve-methodology-coverage',
+      target_stage: 'Stage 137',
+      action: 'Move from methodology coverage to install experience scoring without adding automatic execution.',
+    };
+  }
+  return {
+    id: candidate.id,
+    target_stage: 'Stage 137',
+    action: `Use the install experience score to decide whether ${candidate.label} should surface earlier in adapter entry context.`,
+  };
+}
+
+function sourceBindingSummary(source, superpowersSources, vibecodingSources) {
+  return {
+    superpowers_root: stringValue(source.superpowers_root),
+    superpowers_root_digest: stringValue(source.superpowers_root_digest),
+    superpowers: sourceFamilySummary(superpowersSources),
+    vibecoding: sourceFamilySummary(vibecodingSources),
+    source_digest: digestMethodologyCoverage({
+      superpowers_root: stringValue(source.superpowers_root),
+      superpowers: compactSources(superpowersSources),
+      vibecoding: compactSources(vibecodingSources),
+    }),
+  };
+}
+
+function sourceFamilySummary(sources) {
+  return {
+    files: sources.length,
+    present_files: sources.filter((source) => source.present).length,
+    missing_files: sources.filter((source) => !source.present).map((source) => source.file),
+    digest: digestMethodologyCoverage(compactSources(sources)),
+  };
+}
+
+function compactSources(sources) {
+  return sources.map((source) => ({
+    file: source.file,
+    present: source.present,
+    digest: source.digest,
+    marker_hits: source.marker_hits || [],
+  }));
+}
+
+function stringValue(value) {
+  return typeof value === 'string' ? value : '';
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}

package/tools/vibe-runtime/runtime-methodology-coverage-marker-specs.mjs

@@ -0,0 +1,61 @@
+export const methodologyCoverageMarkers = Object.freeze([
+  'brainstorming', 'Present Options', 'Alternate Approaches', 'planning', 'design', 'architecture', 'writing-plans', 'Exact file paths', 'No Placeholders', 'Task Structure',
+  'test-driven-development', 'NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST', 'RED', 'GREEN', 'REFACTOR', 'systematic-debugging', 'root cause', 'reproduce',
+  'requesting-code-review', 'code review', 'review', 'blocking', 'verification-before-completion', 'NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE', 'finishing-a-development-branch',
+  'worktree', 'workspace isolation', 'branch isolation', 'subagent-driven-development', 'fresh subagent', 'dispatch', 'review package', 'writing-skills', 'Skill Changes Require Evaluation', 'run-skill-tests', 'eval',
+  'PULL_REQUEST_TEMPLATE', 'Existing PRs', 'Identify yourself', 'human partner', 'target the `dev` branch',
+  'vibe-brainstorming', '需求模糊', 'vibe-planning', '架构', 'tradeoff', 'vibe-writing-plans', 'planner --action-manifest', 'plan-to-action manifest', 'planner --lint',
+  'vibe-test-driven-development', 'verification --tdd-trace', 'TDD trace', 'RED-GREEN-REFACTOR', 'vibe-systematic-debugging', 'bug 未复现', '未定位根因',
+  'vibe-requesting-code-review', 'vibe-review', 'review --intake', 'review --resolution', 'vibe-verification-before-completion', 'vibe-finishing-a-development-branch', 'completion --evidence-bundle', 'release --commit-readiness',
+  'vibe-workspace-isolation', 'worktree=false', '工作区', 'vibe-subagent-driven-development', '用户明确允许', 'subagent=false', 'canCallSubagent', 'vibe-writing-skills', 'Workflow Handoff', 'runtime skill', 'skills/',
+  'governance --pr-readiness', 'governance --pr-review-intake', 'PR', 'commit_execution_authorized=false', 'runtime-capability-registry', 'runtime-check', 'release-check', 'digest', 'tokens --savior-budget', 'Token Savior', 'skills_to_defer', 'context_budget', 'governance --experience-dashboard', 'experience dashboard', 'daily_user_friction_delta',
+]);
+
+export const methodologyCoverageSuperpowersFiles = Object.freeze([
+  'README.md',
+  'AGENTS.md',
+  'CLAUDE.md',
+  '.github/PULL_REQUEST_TEMPLATE.md',
+  'skills/using-superpowers/SKILL.md',
+  'skills/brainstorming/SKILL.md',
+  'skills/writing-plans/SKILL.md',
+  'skills/executing-plans/SKILL.md',
+  'skills/subagent-driven-development/SKILL.md',
+  'skills/test-driven-development/SKILL.md',
+  'skills/verification-before-completion/SKILL.md',
+  'skills/finishing-a-development-branch/SKILL.md',
+  'skills/writing-skills/SKILL.md',
+  'hooks/session-start',
+  'tests/hooks/test-session-start.sh',
+  'tests/claude-code/run-skill-tests.sh',
+]);
+
+export const methodologyCoverageVibecodingFiles = Object.freeze([
+  'README.md',
+  'CLAUDE.md',
+  'AGENTS.md',
+  'templates/CLAUDE.md',
+  'templates/AGENTS.md',
+  'skills/using-vibecoding/SKILL.md',
+  'skills/vibe-brainstorming/SKILL.md',
+  'skills/vibe-planning/SKILL.md',
+  'skills/vibe-writing-plans/SKILL.md',
+  'skills/vibe-test-driven-development/SKILL.md',
+  'skills/vibe-systematic-debugging/SKILL.md',
+  'skills/vibe-requesting-code-review/SKILL.md',
+  'skills/vibe-review/SKILL.md',
+  'skills/vibe-verification-before-completion/SKILL.md',
+  'skills/vibe-finishing-a-development-branch/SKILL.md',
+  'skills/vibe-workspace-isolation/SKILL.md',
+  'skills/vibe-subagent-driven-development/SKILL.md',
+  'skills/vibe-writing-skills/SKILL.md',
+  'tools/vibe-runtime/README.md',
+  'docs/runtime-roadmap.md',
+  'tools/vibe-runtime/runtime-capability-registry.mjs',
+  'tools/vibe-runtime/runtime-automation-readiness.mjs',
+  'tools/vibe-runtime/runtime-skill-runtime-traceability-map.mjs',
+  'tools/vibe-runtime/runtime-experience-regression-dashboard.mjs',
+  'tools/vibe-runtime/runtime-token-savior-budget.mjs',
+  'tools/vibe-runtime-check/index.mjs',
+  'tools/vibe-release-check/index.mjs',
+]);

package/tools/vibe-runtime/runtime-methodology-coverage-presentation.mjs

@@ -0,0 +1,26 @@
+export function createMethodologyCoveragePresentation({ printList }) {
+  function printMethodologyCoverageMap(envelope) {
+    const map = envelope.methodology_coverage_map;
+    console.log('Vibecoding Runtime Methodology Coverage Map');
+    console.log(`Stage: ${map.stage}; Kind: ${map.coverage_kind}; pass=${map.ok}`);
+    console.log(`Target: ${map.comparison_target}; root=${map.source_bindings.superpowers_root}`);
+    console.log(`Sources: superpowers=${map.source_bindings.superpowers.present_files}/${map.source_bindings.superpowers.files}; vibecoding=${map.source_bindings.vibecoding.present_files}/${map.source_bindings.vibecoding.files}`);
+    console.log(`Coverage summary: covered=${map.coverage_summary.covered}; partial=${map.coverage_summary.partial}; missing=${map.coverage_summary.missing}; valuable_gaps=${map.coverage_summary.valuable_gaps}`);
+    for (const pattern of map.methodology_coverage_map) {
+      console.log(`- ${pattern.id}: status=${pattern.status}; superpowers=${pattern.superpowers_score}; vibecoding=${pattern.vibecoding_score}; valuable_gap=${pattern.gap_is_valuable}`);
+    }
+    printList('Covered patterns', map.covered_patterns.map((item) => `${item.id}: ${item.label}; ${item.quality_value}`));
+    const partialLines = map.partial_patterns.length > 0 ? map.partial_patterns.map((item) => `${item.id}: ${item.label}; ${item.valuable_gap_rule}`) : ['none'];
+    printList('Partial patterns', partialLines);
+    const missingLines = map.missing_patterns.length > 0 ? map.missing_patterns.map((item) => `${item.id}: ${item.label}; ${item.valuable_gap_rule}`) : ['none'];
+    printList('Missing patterns', missingLines);
+    printList('Vibecoding-specific patterns', map.vibecoding_specific_patterns.map((item) => `${item.id}: score=${item.score}; ${item.value}`));
+    console.log(`Next coverage bet: ${map.next_coverage_bet.id}; target=${map.next_coverage_bet.target_stage}; ${map.next_coverage_bet.action}`);
+    console.log('Boundary: writes=false; methodology_coverage_artifact=false; coverage_map_artifact=false; source_write=false; sidecar_write=false; state_directory_created=false; command_execution=false; check_execution=false; smoke_execution=false; test_execution=false; verification_execution=false; hook_execution=false; adapter_execution=false; workflow_execution=false; skill_execution=false; runtime_action=false; auto_execution=false; repair_execution=false; prompt_mutation=false; skill_mutation=false; hook_registration=false; dynamic_tool_execution=false; embeddings=false; remote_config=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; git=false; git_write=false; git_add=false; commit=false; pr=false; push=false; merge=false; business_source_write=false');
+    console.log(`Coverage digest: ${map.coverage_digest}`);
+    if (envelope.quality.length > 0) printList('Findings', envelope.quality);
+    console.log(`Action: ${envelope.action}`);
+  }
+
+  return { printMethodologyCoverageMap };
+}

package/tools/vibe-runtime/runtime-methodology-gate-model.mjs

@@ -0,0 +1,154 @@
+export function methodologyCriterion(id, ok, passedEvidence, blockedReason, { asList }) {
+  return {
+    id,
+    status: ok ? 'passed' : 'blocked',
+    evidence: ok ? asList(passedEvidence) : [],
+    blocked_reason: ok ? '' : String(blockedReason || `${id} is not satisfied`),
+  };
+}
+
+export function buildMethodologyCriteria({
+  kind,
+  state,
+  source,
+  automationEvidence = {},
+  asList,
+  tasksFromState,
+}) {
+  const criterion = (id, ok, passedEvidence, blockedReason) => methodologyCriterion(id, ok, passedEvidence, blockedReason, { asList });
+  const acceptance = asList(state?.acceptance);
+  const evidence = asList(state?.evidence);
+  const risks = asList(state?.risks);
+  const files = asList(state?.files);
+  const scope = asList(state?.scope);
+  const decisions = asList(state?.key_decisions);
+  const tasks = tasksFromState(state || {});
+  const currentSkill = state?.current_skill || '';
+  const nextSkill = state?.next_skill || '';
+  const rows = [criterion('workflow_valid', source.workflow_valid, source.workflow_file || 'workflow state valid', source.workflow_failures.join('; ') || 'workflow state is invalid')];
+
+  if (kind === 'spec') {
+    rows.push(
+      criterion('goal', Boolean(state?.goal), state?.goal || '', 'goal is not recorded'),
+      criterion('scope', scope.length > 0, scope, 'scope is not recorded'),
+      criterion('acceptance', acceptance.length > 0, acceptance, 'acceptance is not recorded'),
+      criterion('handoff_to_plan', ['vibe-planning', 'vibe-writing-plans', 'vibe-test-driven-development'].includes(nextSkill), nextSkill, `next_skill is ${nextSkill || 'not recorded'}`),
+    );
+  } else if (kind === 'plan') {
+    rows.push(
+      criterion('files', files.length > 0, files, 'files are not recorded'),
+      criterion('tasks', tasks.length > 0, tasks.map((task) => task.id), 'tasks are not recorded'),
+      criterion('acceptance', acceptance.length > 0, acceptance, 'acceptance is not recorded'),
+      criterion('risks', risks.length > 0, risks, 'risks are not recorded'),
+    );
+  } else if (kind === 'tdd') {
+    rows.push(
+      criterion('behavior_acceptance', acceptance.length > 0, acceptance, 'behavior acceptance is not recorded'),
+      criterion('red_or_verification_signal', evidence.length > 0, evidence, 'red/verification evidence is not recorded'),
+      criterion('handoff_to_execution', ['vibe-executing-plans', 'vibe-implementation'].includes(nextSkill), nextSkill, `next_skill is ${nextSkill || 'not recorded'}`),
+    );
+  } else if (kind === 'debug') {
+    rows.push(
+      criterion('reproduction_or_evidence', evidence.length > 0, evidence, 'debug evidence is not recorded'),
+      criterion('root_cause_decision', decisions.length > 0, decisions, 'root cause decision is not recorded'),
+      criterion('handoff_after_root_cause', ['vibe-test-driven-development', 'vibe-planning', 'none'].includes(nextSkill), nextSkill, `next_skill is ${nextSkill || 'not recorded'}`),
+    );
+  } else if (kind === 'review') {
+    rows.push(
+      criterion('review_scope', files.length > 0 || tasks.length > 0, files.length > 0 ? files : tasks.map((task) => task.id), 'review scope is not recorded'),
+      criterion('review_evidence', evidence.length > 0, evidence, 'review evidence is not recorded'),
+      criterion('risk_classification', risks.length > 0 || tasks.some((task) => task.review), risks, 'review risk classification is not recorded'),
+    );
+  } else if (kind === 'completion') {
+    rows.push(
+      criterion('fresh_verification_evidence', evidence.length > 0, evidence, 'fresh verification evidence is not recorded'),
+      criterion('acceptance_coverage', acceptance.length > 0, acceptance, 'acceptance coverage is not recorded'),
+      criterion('completion_skill', currentSkill === 'vibe-verification-before-completion', currentSkill, `current_skill is ${currentSkill || 'not recorded'}`),
+    );
+  } else if (kind === 'automation') {
+    rows.push(
+      criterion('approved_dispatch', automationEvidence.dispatch_files.length > 0, automationEvidence.dispatch_files, 'subagent dispatch artifact is not recorded'),
+      criterion('result_ingested', automationEvidence.result_files.length > 0, automationEvidence.result_files, 'subagent result ingestion artifact is not recorded'),
+      criterion('review_gate', automationEvidence.review_files.length > 0, automationEvidence.review_files, 'subagent review gate artifact is not recorded'),
+      criterion('bounded_hook_run', automationEvidence.hook_run_files.length > 0, automationEvidence.hook_run_files, 'bounded hook run artifact is not recorded'),
+      criterion('trace_or_governance', automationEvidence.trace_or_governance_files.length > 0, automationEvidence.trace_or_governance_files, 'trace or governance artifact is not recorded'),
+    );
+  }
+  return rows;
+}
+
+export function buildMethodologyGatePayloadModel({
+  kind,
+  source,
+  state,
+  catalog,
+  createdAt,
+  boundaryAssertions,
+  digestObject,
+  methodologyGateKinds,
+  automationEvidence = {},
+  asList,
+  tasksFromState,
+}) {
+  if (!methodologyGateKinds.has(kind)) throw new Error(`unsupported methodology gate kind: ${kind}`);
+  const criteria = buildMethodologyCriteria({ kind, state, source, automationEvidence, asList, tasksFromState });
+  const blockedReasons = criteria.filter((item) => item.status !== 'passed').map((item) => `${item.id}: ${item.blocked_reason}`);
+  const payload = {
+    version: 1,
+    stage: 'Stage 32',
+    kind,
+    created_at: createdAt,
+    outcome: blockedReasons.length === 0 ? 'passed' : 'blocked',
+    source: {
+      workflow_file: source.workflow_file,
+      workflow_digest: source.workflow_digest,
+      workflow_present: source.workflow_present,
+    },
+    catalog_digest: catalog.catalog_digest,
+    criteria,
+    blocked_reasons: blockedReasons,
+    boundary_assertions: boundaryAssertions,
+    local_only: true,
+    no_execution: true,
+    no_external_delivery: true,
+  };
+  return { ...payload, gate_digest: digestObject(payload) };
+}
+
+export function validateMethodologyGateArtifactModel({
+  artifact,
+  jsonSchemaVersion,
+  methodologyGateKinds,
+  expectedCatalogDigest,
+  boundaryAssertions,
+  digestObject,
+}) {
+  const failures = [];
+  if (artifact.schema_version !== jsonSchemaVersion) failures.push('schema_version must be 1');
+  if (artifact.command !== 'methodology') failures.push('command must be methodology');
+  if (artifact.mode !== 'methodology-gate') failures.push('mode must be methodology-gate');
+  const gate = artifact.methodology_gate || {};
+  if (gate.stage !== 'Stage 32') failures.push('methodology_gate.stage must be Stage 32');
+  if (!methodologyGateKinds.has(gate.kind)) failures.push('methodology gate kind is not supported');
+  if (!['passed', 'blocked'].includes(gate.outcome)) failures.push('methodology gate outcome must be passed or blocked');
+  const digestPayload = { ...gate };
+  delete digestPayload.writes;
+  delete digestPayload.gate_digest;
+  if (gate.gate_digest !== digestObject(digestPayload)) failures.push('methodology gate digest mismatch');
+  if (gate.catalog_digest !== expectedCatalogDigest) failures.push('methodology catalog digest mismatch');
+  for (const [key, expected] of Object.entries(boundaryAssertions)) {
+    if (gate.boundary_assertions?.[key] !== expected) failures.push(`methodology boundary ${key} must be false`);
+  }
+  if (!Array.isArray(gate.criteria)) failures.push('methodology criteria must be an array');
+  if (!Array.isArray(gate.blocked_reasons)) failures.push('methodology blocked_reasons must be an array');
+  if (Array.isArray(gate.criteria) && Array.isArray(gate.blocked_reasons)) {
+    const expectedBlocked = gate.criteria.filter((item) => item.status !== 'passed').map((item) => `${item.id}: ${item.blocked_reason}`);
+    if (gate.outcome === 'passed' && expectedBlocked.length > 0) failures.push('passed methodology gate must not contain blocked criteria');
+    if (gate.outcome === 'blocked' && expectedBlocked.length === 0) failures.push('blocked methodology gate must contain blocked criteria');
+    if (digestObject(expectedBlocked) !== digestObject(gate.blocked_reasons)) failures.push('methodology blocked_reasons mismatch criteria');
+  }
+  if (gate.local_only !== true) failures.push('methodology local_only must be true');
+  if (gate.no_execution !== true) failures.push('methodology no_execution must be true');
+  if (gate.no_external_delivery !== true) failures.push('methodology no_external_delivery must be true');
+  return failures;
+}

package/tools/vibe-runtime/runtime-methodology-gate-output-envelope.mjs

@@ -0,0 +1,4 @@
+export function emitMethodologyGateOutput({ deps, options, envelope, printGate }) {
+  if (options.json) deps.writeJsonEnvelope('methodology', envelope);
+  else printGate(envelope, { printList: deps.printList });
+}