@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-release-check/release-check-runtime-task-fixture-specs.mjs

@@ -0,0 +1,270 @@
+import path from 'node:path';
+
+const artifactRootDirectoryName = ['.vibecoding', '-state'].join('');
+
+export const runtimeTaskFixtureSpecs = [
+  {
+    key: 'invalidTaskIdHandoffFile',
+    fileName: 'runtime-invalid-task-id-handoff.json',
+    content: `{
+  "current_skill": "vibe-test-driven-development",
+  "next_skill": "vibe-executing-plans",
+  "handoff": {
+    "tasks": [
+      {
+        "id": "..\\\\escape-review",
+        "title": "invalid task id smoke",
+        "status": "pending"
+      }
+    ]
+  },
+  "stop_condition": "none"
+}
+`,
+  },
+  {
+    key: 'emptyTaskIdHandoffFile',
+    fileName: 'runtime-empty-task-id-handoff.json',
+    content: `{
+  "current_skill": "vibe-test-driven-development",
+  "next_skill": "vibe-executing-plans",
+  "handoff": {
+    "tasks": [
+      {
+        "id": "",
+        "title": "empty task id smoke",
+        "status": "pending"
+      }
+    ]
+  },
+  "stop_condition": "none"
+}
+`,
+  },
+  {
+    key: 'reservedTaskIdHandoffFile',
+    fileName: 'runtime-reserved-task-id-handoff.json',
+    content: `{
+  "current_skill": "vibe-test-driven-development",
+  "next_skill": "vibe-executing-plans",
+  "handoff": {
+    "tasks": [
+      {
+        "id": "CON.txt",
+        "title": "reserved task id smoke",
+        "status": "pending"
+      },
+      {
+        "id": "COM1",
+        "title": "reserved task id smoke",
+        "status": "pending"
+      },
+      {
+        "id": "LPT1",
+        "title": "reserved task id smoke",
+        "status": "pending"
+      }
+    ]
+  },
+  "stop_condition": "none"
+}
+`,
+  },
+  {
+    key: 'trailingDotTaskIdHandoffFile',
+    fileName: 'runtime-trailing-dot-task-id-handoff.json',
+    content: `{
+  "current_skill": "vibe-test-driven-development",
+  "next_skill": "vibe-executing-plans",
+  "handoff": {
+    "tasks": [
+      {
+        "id": "task.",
+        "title": "trailing dot task id smoke",
+        "status": "pending"
+      }
+    ]
+  },
+  "stop_condition": "none"
+}
+`,
+  },
+  {
+    key: 'invalidFencedJsonTaskIdHandoffFile',
+    fileName: 'runtime-invalid-fenced-json-task-id-handoff.md',
+    content: `## Workflow Handoff
+
+\`\`\`json
+{
+  "current_skill": "vibe-test-driven-development",
+  "next_skill": "vibe-executing-plans",
+  "handoff": {
+    "tasks": [
+      {
+        "id": "NUL",
+        "title": "invalid fenced JSON task id smoke",
+        "status": "pending"
+      }
+    ]
+  },
+  "stop_condition": "none"
+}
+\`\`\`
+`,
+  },
+  {
+    key: 'invalidFencedJsonReviewWaiverHandoffFile',
+    fileName: 'runtime-invalid-fenced-json-review-waiver-handoff.md',
+    content: `## Workflow Handoff
+
+\`\`\`json
+{
+  "current_skill": "vibe-test-driven-development",
+  "next_skill": "vibe-executing-plans",
+  "handoff": {
+    "tasks": [
+      {
+        "id": "task-fenced-waived-without-reason",
+        "title": "invalid fenced review waiver smoke",
+        "status": "completed",
+        "review_status": "waived"
+      }
+    ]
+  },
+  "stop_condition": "none"
+}
+\`\`\`
+`,
+  },
+  {
+    key: 'invalidReviewWaiverHandoffFile',
+    fileName: 'runtime-invalid-review-waiver-handoff.json',
+    content: `{
+  "current_skill": "vibe-test-driven-development",
+  "next_skill": "vibe-executing-plans",
+  "handoff": {
+    "tasks": [
+      {
+        "id": "task-waived-without-reason",
+        "title": "invalid review waiver smoke",
+        "status": "completed",
+        "review_status": "waived"
+      }
+    ]
+  },
+  "stop_condition": "none"
+}
+`,
+  },
+  {
+    key: 'duplicateTaskIdHandoffFile',
+    fileName: 'runtime-duplicate-task-id-handoff.json',
+    content: `{
+  "current_skill": "vibe-test-driven-development",
+  "next_skill": "vibe-executing-plans",
+  "handoff": {
+    "scope": ["duplicate task id smoke"],
+    "risks": ["duplicate ids can overwrite task artifacts"],
+    "acceptance": ["duplicate task ids fail before writes"],
+    "files": ["tools/vibe-runtime/index.mjs"],
+    "evidence": ["release-check"],
+    "tasks": [
+      {
+        "id": "task-dup",
+        "title": "duplicate task id smoke first",
+        "status": "pending"
+      },
+      {
+        "id": "task-dup",
+        "title": "duplicate task id smoke second",
+        "status": "pending"
+      }
+    ]
+  },
+  "stop_condition": "none"
+}
+`,
+  },
+  {
+    key: 'unknownDependencyHandoffFile',
+    fileName: 'runtime-unknown-dependency-handoff.json',
+    content: `{
+  "current_skill": "vibe-test-driven-development",
+  "next_skill": "vibe-executing-plans",
+  "handoff": {
+    "tasks": [
+      {
+        "id": "task-dependent",
+        "title": "unknown dependency smoke",
+        "status": "pending",
+        "depends_on": ["missing-task"]
+      }
+    ]
+  },
+  "stop_condition": "none"
+}
+`,
+  },
+  {
+    key: 'selfDependencyHandoffFile',
+    fileName: 'runtime-self-dependency-handoff.json',
+    content: `{
+  "current_skill": "vibe-test-driven-development",
+  "next_skill": "vibe-executing-plans",
+  "handoff": {
+    "tasks": [
+      {
+        "id": "task-self",
+        "title": "self dependency smoke",
+        "status": "pending",
+        "depends_on": ["task-self"]
+      }
+    ]
+  },
+  "stop_condition": "none"
+}
+`,
+  },
+  {
+    key: 'cyclicDependencyHandoffFile',
+    fileName: 'runtime-cyclic-dependency-handoff.json',
+    content: `{
+  "current_skill": "vibe-test-driven-development",
+  "next_skill": "vibe-executing-plans",
+  "handoff": {
+    "tasks": [
+      {
+        "id": "task-a",
+        "title": "cycle dependency smoke a",
+        "status": "pending",
+        "depends_on": ["task-b"]
+      },
+      {
+        "id": "task-b",
+        "title": "cycle dependency smoke b",
+        "status": "pending",
+        "depends_on": ["task-a"]
+      }
+    ]
+  },
+  "stop_condition": "none"
+}
+`,
+  },
+];
+
+export const runtimeTaskIds = ['task-1', 'task-2', 'task-3', 'task-4', 'task-5', 'task.alpha_1'];
+
+export const runtimeRootArtifactFileNames = ['task-brief.md', 'review-gate.md', 'evidence.md'];
+
+export const runtimeTaskArtifactFileNames = ['brief.md', 'report.md', 'review-gate.md', 'evidence.md'];
+
+export function runtimeTaskArtifactPaths(absoluteTarget) {
+  const artifactRoot = path.join(absoluteTarget, artifactRootDirectoryName);
+  return {
+    artifactFiles: runtimeRootArtifactFileNames.map((fileName) => path.join(artifactRoot, fileName)),
+    taskArtifactFiles: runtimeTaskIds.flatMap((taskId) =>
+      runtimeTaskArtifactFileNames.map((fileName) => path.join(artifactRoot, 'tasks', taskId, fileName)),
+    ),
+  };
+}

package/tools/vibe-release-check/release-check-runtime-task-fixtures.mjs

@@ -0,0 +1,19 @@
+import { writeSmokeTextFixtures } from './release-check-json-assertion-helpers.mjs';
+import {
+  runtimeTaskArtifactPaths,
+  runtimeTaskFixtureSpecs,
+  runtimeTaskIds,
+} from './release-check-runtime-task-fixture-specs.mjs';
+
+export function buildRuntimeTaskFixtures({ tmpRoot, absoluteTarget }) {
+  const fixtureFiles = writeSmokeTextFixtures(tmpRoot, runtimeTaskFixtureSpecs);
+  const { artifactFiles, taskArtifactFiles } = runtimeTaskArtifactPaths(absoluteTarget);
+
+  return {
+    ...fixtureFiles,
+    taskIds: runtimeTaskIds,
+    artifactFiles,
+    taskArtifactFiles,
+    cleanupFiles: runtimeTaskFixtureSpecs.map(({ key }) => fixtureFiles[key]),
+  };
+}

package/tools/vibe-release-check/release-check-runtime.mjs

@@ -0,0 +1,53 @@
+import crypto from 'node:crypto';
+
+export {
+  baseTmpRoot,
+  formatCommand,
+  releaseCheckCommandResults,
+  releaseCheckRunId,
+  removeTmp,
+  repoRoot,
+  run,
+  runCheckNotIgnored,
+  suiteTmpTarget,
+  tmpRoot,
+  withSuiteTmp,
+  writeCommandOutput,
+  writeReleaseCheckRunSummary,
+} from './release-check-runtime-smoke-harness.mjs';
+
+export function assertOutputIncludes(result, expected, label) {
+  const output = `${result.stdout || ''}${result.stderr || ''}`;
+  const missing = expected.filter((marker) => !output.includes(marker));
+  if (missing.length > 0) {
+    throw new Error(`${label} output missing marker(s): ${missing.join(', ')}`);
+  }
+}
+
+export function parseJsonOutput(result, label) {
+  try {
+    return JSON.parse(result.stdout || '');
+  } catch (error) {
+    throw new Error(`${label} output is not valid JSON: ${error.message}`);
+  }
+}
+
+export function assertJsonMarkers(checks, label) {
+  for (const [name, actual, expected] of checks) {
+    if (actual !== expected) {
+      throw new Error(`${label} JSON marker mismatch for ${name}: expected ${expected}, got ${actual}`);
+    }
+  }
+}
+
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+export function digestObject(value) {
+  return crypto.createHash('sha256').update(stableJson(value)).digest('hex');
+}

package/tools/vibe-release-check/release-check-stage103-118-fixtures.mjs

@@ -0,0 +1,214 @@
+const automationReadinessRequiredEntries = Object.freeze([
+  ['auto_safe', 'governance --surface --drift-guard', 'automation readiness missing drift guard auto_safe entry'],
+  ['auto_safe', 'planner --action-manifest', 'automation readiness missing plan action manifest auto_safe entry'],
+  ['auto_safe', 'verification --self-test-profile', 'automation readiness missing self-test profile auto_safe entry'],
+  ['auto_safe', 'release --commit-readiness', 'automation readiness missing commit readiness auto_safe entry'],
+  ['auto_safe', 'automation --one-shot-plan', 'automation readiness missing confirmed one-shot plan auto_safe entry'],
+  ['auto_safe', 'workflow --close-loop-dashboard', 'automation readiness missing close-loop dashboard auto_safe entry'],
+  ['auto_safe', 'verification --evidence-intake', 'automation readiness missing evidence intake auto_safe entry'],
+  ['auto_safe', 'release --diff-coverage', 'automation readiness missing diff coverage auto_safe entry'],
+  ['auto_safe', 'release --diff-read', 'automation readiness missing git diff read auto_safe entry'],
+  ['confirm_required', 'tests --run', 'automation readiness missing tests run confirm_required entry'],
+  ['confirm_required', 'sdd --consume-adapter-result', 'automation readiness missing SDD adapter result consumption confirm_required entry'],
+  ['auto_safe', 'review --intake', 'automation readiness missing review intake auto_safe entry'],
+  ['auto_safe', 'review --resolution', 'automation readiness missing review resolution auto_safe entry'],
+  ['auto_safe', 'verification --tdd-trace', 'automation readiness missing TDD trace auto_safe entry'],
+  ['auto_safe', 'workflow --close-loop', 'automation readiness missing close-loop alias auto_safe entry'],
+  ['auto_safe', 'workflow --next-evidence', 'automation readiness missing next-evidence alias auto_safe entry'],
+  ['auto_safe', 'governance --superpowers-gap', 'automation readiness missing Superpowers gap matrix auto_safe entry'],
+  ['advice_only', 'workflow --entry-ux', 'automation readiness missing progressive entry UX advice_only entry'],
+  ['auto_safe', 'planner --executable-plan', 'automation readiness missing executable plan quality auto_safe entry'],
+  ['auto_safe', 'automation --stage-runbook', 'automation readiness missing sequential stage runbook auto_safe entry'],
+  ['auto_safe', 'verification --execution-evidence', 'automation readiness missing execution evidence binding auto_safe entry'],
+  ['auto_safe', 'release --staged-commit-readiness', 'automation readiness missing staged commit readiness auto_safe entry'],
+  ['auto_safe', 'release --closeout-readiness', 'automation readiness missing closeout readiness auto_safe entry'],
+  ['auto_safe', 'evals --behavior-contract', 'automation readiness missing behavioral evaluation contract auto_safe entry'],
+  ['auto_safe', 'governance --traceability-map', 'automation readiness missing skill-to-runtime traceability auto_safe entry'],
+  ['auto_safe', 'governance --experience-friction', 'automation readiness missing experience friction auto_safe entry'],
+  ['auto_safe', 'workflow --next-action-console', 'automation readiness missing next action console auto_safe entry'],
+  ['auto_safe', 'workflow --next-evidence-prompts', 'automation readiness missing next-action evidence prompts auto_safe entry'],
+  ['auto_safe', 'tokens --savior-budget', 'automation readiness missing Token Savior budget auto_safe entry'],
+  ['auto_safe', 'tokens --entry-defaults', 'automation readiness missing context budget entry defaults auto_safe entry'],
+  ['auto_safe', 'learning --experience-pattern', 'automation readiness missing ECC learning experience pattern auto_safe entry'],
+  ['auto_safe', 'automation --stage-scriptlet', 'automation readiness missing copy-ready stage scriptlet auto_safe entry'],
+  ['auto_safe', 'platforms --entry-acceptance', 'automation readiness missing adapter entry acceptance auto_safe entry'],
+  ['auto_safe', 'platforms --session-start-shape', 'automation readiness missing session-start shape acceptance auto_safe entry'],
+  ['auto_safe', 'governance --experience-dashboard', 'automation readiness missing experience regression dashboard auto_safe entry'],
+  ['auto_safe', 'governance --superpowers-comparison', 'automation readiness missing Superpowers comparison auto_safe entry'],
+  ['auto_safe', 'methodology --coverage-map', 'automation readiness missing methodology coverage map auto_safe entry'],
+  ['auto_safe', 'platforms --install-experience', 'automation readiness missing install experience auto_safe entry'],
+  ['auto_safe', 'evals --superpowers-style-pack', 'automation readiness missing Superpowers-style eval pack auto_safe entry'],
+  ['auto_safe', 'evals --local-behavior-contracts', 'automation readiness missing local behavior eval contracts auto_safe entry'],
+  ['auto_safe', 'governance --experience-upgrades', 'automation readiness missing experience upgrade prioritizer auto_safe entry'],
+  ['confirm_required', 'evals --run-behavior', 'automation readiness missing eval behavior confirm_required entry'],
+  ['confirm_required', 'release --gate', 'automation readiness missing release gate confirm_required entry'],
+  ['advice_only', 'advice --hub', 'automation readiness missing advice hub advice_only entry'],
+  ['advice_only', 'workflow --loop-contract', 'automation readiness missing workflow loop contract advice_only entry'],
+]);
+
+function hasCategorizedCommand(readiness, category, command) {
+  return readiness?.categorized?.[category]?.some((item) => item.command === command);
+}
+
+export function stage105PlanFixtureText() {
+  return [
+    '# Stage 105 fixture plan',
+    '',
+    '## Task 1',
+    '- [ ] Add `tools/vibe-runtime/runtime-plan-action-manifest.mjs` with `plan_action_manifest` output fields.',
+    '- [ ] Update `tools/vibe-runtime/README.md` and `docs/runtime-roadmap.md` markers.',
+    '- [ ] Validate with `node --check tools/vibe-runtime/index.mjs` and `node tools/vibe-runtime-check/index.mjs --root .tmp/vibe-plan-action-manifest`.',
+    '',
+    'Acceptance: action_items, docs_expectations, code_expectations, check_expectations, execution_authorized=false, and plan_action_manifest_digest are present.',
+    'Boundary: no automation plan, no command execution, no test execution, no git, no push, no pr, no merge.',
+  ].join('\n');
+}
+
+export function stage106PlanFixtureText() {
+  return [
+    '# Stage 106 fixture plan',
+    '',
+    '## Task 1',
+    '- [ ] Add `tools/vibe-runtime/runtime-self-test-gate-profile.mjs` with `self_test_gate_profile` output fields.',
+    '- [ ] Update `tools/vibe-runtime/README.md` and `docs/runtime-roadmap.md` Stage 106 markers.',
+    '- [ ] Validate with `node --check tools/vibe-runtime/index.mjs`, `node tools/vibe-runtime-check/index.mjs --root .tmp/vibe-self-test-profile`, `node tools/vibe-release-check/index.mjs --quiet`, and `git diff --check`.',
+    '',
+    'Acceptance: gate_items, evidence_requirements, recommended_order, status=planned_not_run, execution_authorized=false, and self_test_gate_profile_digest are present.',
+    'Boundary: no check execution, no test execution, no repair execution, no git, no push, no pr, no merge.',
+  ].join('\n');
+}
+
+export function stage107PlanFixtureText() {
+  return [
+    '# Stage 107 fixture plan',
+    '',
+    '## Task 1',
+    '- [ ] Add `tools/vibe-runtime/runtime-commit-readiness-envelope.mjs` with `commit_readiness` output fields.',
+    '- [ ] Update `tools/vibe-runtime/README.md` and `docs/runtime-roadmap.md` Stage 107 markers.',
+    '- [ ] Validate with `node --check tools/vibe-runtime/index.mjs`, `node tools/vibe-runtime-check/index.mjs --root .tmp/vibe-commit-readiness`, `node tools/vibe-release-check/index.mjs --quiet`, and `git diff --check`.',
+    '',
+    'Acceptance: readiness_gates, evidence_bundle_requirements, readiness_order, readiness_state.commit_ready=false, commit_execution_authorized=false, and commit_readiness_digest are present.',
+    'Boundary: no check execution, no test execution, no git, no commit, no push, no pr, no merge.',
+  ].join('\n');
+}
+
+export function stage108PlanFixtureText() {
+  return [
+    '# Stage 108 fixture plan',
+    '',
+    '## Task 1',
+    '- [ ] Add `tools/vibe-runtime/runtime-confirmed-one-shot-plan.mjs` with `confirmed_one_shot_plan` output fields.',
+    '- [ ] Update `tools/vibe-runtime/README.md` and `docs/runtime-roadmap.md` Stage 108 markers.',
+    '- [ ] Validate with `node --check tools/vibe-runtime/index.mjs`, `node tools/vibe-runtime-check/index.mjs --root .tmp/vibe-confirmed-one-shot-plan`, `node tools/vibe-release-check/index.mjs --quiet`, and `git diff --check`.',
+    '',
+    'Acceptance: confirmation_gate, execution_contract, planned_steps, preflight_evidence_expectations, readiness_state.ready_for_runtime_execution=false, actions_executed=false, and confirmed_one_shot_plan_digest are present.',
+    'Boundary: no action execution, no check execution, no test execution, no git, no commit, no push, no pr, no merge.',
+  ].join('\n');
+}
+
+export function stage109CloseLoopDashboardPlanFixtureText() {
+  return ['# Stage 109 fixture plan', '', '## Task 1', '- [ ] Add `tools/vibe-runtime/runtime-close-loop-dashboard.mjs` with `close_loop_dashboard` output fields.', '- [ ] Update `tools/vibe-runtime/README.md` and `docs/runtime-roadmap.md` Stage 109 markers.', '- [ ] Validate with `node --check tools/vibe-runtime/index.mjs`, `node tools/vibe-runtime-check/index.mjs --root .tmp/vibe-close-loop-dashboard`, `node tools/vibe-release-check/index.mjs --quiet`, and `git diff --check`.', '', 'Acceptance: plan_status, docs_status, code_status, self_test_status, commit_status, one_shot_status, dashboard_invariants, close_loop_dashboard_digest, planned_not_run, commit_ready=false, ready_for_runtime_execution=false, actions_executed=false, and execution_authorized=false are present.', 'Boundary: dashboard only, no execution, no check execution, no test execution, no git, no commit, no push, no pr, no merge.'].join('\n');
+}
+
+export function stage113TddTracePlanFixtureText() {
+  return ['Stage 113 fixture plan', '', '- [ ] Add tdd', '', 'Verification command: node --check tools/vibe-runtime/runtime-tdd-trace-contract.mjs', 'Interfaces: tdd_trace_contract, cycle_order, red_verified, green_verified, refactor_verified, covered_action_items, coverage, tdd_trace_digest.', 'Acceptance: local RED -> GREEN -> REFACTOR trace binds to plan action items without running tests or commands.', 'Boundary: Stage 113 only reads local TDD trace evidence; no test execution, no command execution, no repair, no git, no state write.'].join('\n');
+}
+
+export function stage114HumanFriendlyAliasPlanFixtureText() {
+  return ['Stage 114 fixture plan', '', '- [ ] Add human friendly alias', '', 'Docs: update tools/vibe-runtime/README.md and docs/runtime-roadmap.md.', 'Code: update tools/vibe-runtime/index.mjs and tools/vibe-runtime/runtime-human-friendly-aliases.mjs.', 'Verification command: node tools/vibe-runtime-check/index.mjs --root D:/workspace_mine/vibe-coading', 'Acceptance: workflow aliases expose Plan, Docs, Code, Self-test, Diff, Review, TDD, Commit, and Next evidence without executing commands.', 'Boundary: Stage 114 only reads explicit local files and composes envelopes; no command execution, no check execution, no test execution, no repair, no git, no state write.'].join('\n');
+}
+
+export function stage110EvidenceIntakePlanFixtureText() {
+  return [
+    '# Stage 110 fixture plan',
+    '',
+    '## Task 1',
+    '- [ ] Add `tools/vibe-runtime/runtime-evidence-intake-envelope.mjs` with evidence_intake output fields.',
+    '- [ ] Validate with node --check tools/vibe-runtime/index.mjs.',
+    '',
+    'Acceptance: evidence_items, freshness_findings, gate_coverage, blocked_reasons, evidence_intake_invariants, command_executed_by_stage_110=false, execution_authorized=false, and evidence_intake_digest are present.',
+    'Boundary: no check execution, no test execution, no git, no commit, no push, no pr, no merge.',
+  ].join('\n');
+}
+
+export function stage110EvidenceIntakeFixture() {
+  return {
+    created_at: '2026-07-18T00:00:00.000Z',
+    checks: [
+      { command: 'node --check tools/vibe-runtime/index.mjs', exit_status: 0, key_output: 'ok', artifact: '.tmp/vibe-evidence-intake/node-check-index.txt', freshness: 'fresh', coverage: ['syntax'], gate_id: 'stage106-gate-01-syntax' },
+      { command: 'node --check tools/vibe-runtime/runtime-evidence-intake-envelope.mjs', exit_status: 0, key_output: 'ok', artifact: '.tmp/vibe-evidence-intake/node-check-module.txt', freshness: 'fresh', coverage: ['syntax'], gate_id: 'stage106-gate-02-syntax' },
+      { command: 'git diff --check -- tools/vibe-runtime/runtime-evidence-intake-envelope.mjs tools/vibe-runtime/index.mjs', exit_status: 0, key_output: 'ok', artifact: '.tmp/vibe-evidence-intake/diff-check.txt', freshness: 'fresh', coverage: ['diff_hygiene'], gate_id: 'stage106-gate-03-diff_hygiene' },
+      { command: 'manual boundary review', exit_status: 0, key_output: 'Stage 110 did not execute checks, write state, call git, network, platform, model, MCP, or subagent.', artifact: '.tmp/vibe-evidence-intake/boundary-review.txt', freshness: 'fresh', coverage: ['manual_verification'], gate_id: 'stage106-gate-04-manual_verification' },
+    ],
+  };
+}
+
+export function stage111DiffCoverageExpectedFiles() {
+  return [
+    'tools/vibe-runtime/runtime-diff-coverage-envelope.mjs',
+    'tools/vibe-runtime/index.mjs',
+    'tools/vibe-runtime/runtime-capability-registry.mjs',
+    'tools/vibe-runtime/runtime-automation-readiness.mjs',
+    'tools/vibe-runtime-check/index.mjs',
+    'tools/vibe-release-check/index.mjs',
+    'tools/vibe-runtime/README.md',
+    'docs/runtime-roadmap.md',
+  ];
+}
+
+export function stage112ReviewPlanFixtureText() {
+  return [
+    '# Stage 112 fixture plan',
+    '',
+    '## Task 1',
+    '- [ ] Add `tools/vibe-runtime/runtime-review-envelope.mjs` pure review intake and resolution envelope fields.',
+    '- [ ] Update `tools/vibe-runtime/index.mjs` CLI review --intake and review --resolution dispatch.',
+    '- [ ] Sync `tools/vibe-runtime/runtime-capability-registry.mjs` and `tools/vibe-runtime/runtime-automation-readiness.mjs`.',
+    '- [ ] Sync `tools/vibe-runtime-check/index.mjs` and `tools/vibe-release-check/index.mjs` validation markers.',
+    '- [ ] Document `tools/vibe-runtime/README.md` and `docs/runtime-roadmap.md`.',
+    '',
+    'Interfaces: review_intake, review_items, impacted_files, impacted_action_items, required_evidence, review_intake_digest, review_resolution, resolution_items, resolved, accepted_risk, missing_evidence, review_resolution_digest.',
+    'Verification: node --check changed runtime files, runtime-check, release-check, and git diff --check evidence captured manually outside Stage 112.',
+    'Acceptance: local review feedback binds to planned files and local repair evidence closes all required evidence without reviewer invocation or repair execution.',
+    'Review: local boundary review confirms no reviewer, no repair, no git, no command execution, no state write, no network, no model, no MCP, no subagent.',
+    'Completion boundary: Stage 112 only reads local review and evidence files.',
+  ].join('\n');
+}
+
+export function stage112ReviewFixture() {
+  return {
+    created_at: '2026-07-18T00:00:00.000Z',
+    review_items: [{
+      id: 'review-runtime-boundary',
+      severity: 'high',
+      comment: 'Confirm Stage 112 review envelope keeps reviewer invocation and repair execution disabled.',
+      impacted_files: ['tools/vibe-runtime/runtime-review-envelope.mjs', 'tools/vibe-runtime/index.mjs'],
+      required_evidence: ['boundary review confirms no reviewer invocation', 'resolution smoke covers local evidence binding'],
+    }],
+  };
+}
+
+export function stage112ResolutionEvidenceFixture() {
+  return { created_at: '2026-07-18T00:10:00.000Z', resolutions: [{ id: 'resolution-runtime-boundary', review_id: 'review-runtime-boundary', status: 'resolved', evidence: 'boundary review confirms no reviewer invocation; resolution smoke covers local evidence binding' }] };
+}
+
+export function stage113TddTraceFixture() {
+  return {
+    created_at: '2026-07-18T00:20:00.000Z',
+    red: { command: 'node test/stage113-red.test.mjs', exit_status: 1, expected_failure: true, key_output: 'RED expected failure observed before implementation' },
+    green: { command: 'node test/stage113-green.test.mjs', exit_status: 0, key_output: 'GREEN passing output observed after minimal implementation' },
+    refactor: { command: 'node test/stage113-refactor.test.mjs', exit_status: 0, key_output: 'REFACTOR passing output observed after cleanup' },
+    covered_action_items: ['stage105-action-01-add-tdd'],
+  };
+}
+
+export function stage115ProgressiveEntryUxGapFixture() {
+  return { superpowers_gap_matrix: { stage: 'Stage 115', gap_kind: 'superpowers-gap-matrix', gap_matrix_digest: 'fixture-stage115-gap-digest', dimensions: [{ id: 'entry_ux', recommended_stage: 'Stage 116' }, { id: 'execution_loop', recommended_stage: 'Stage 118' }] } };
+}
+
+export function assertAutomationReadinessCatalog(readiness) {
+  for (const [category, command, message] of automationReadinessRequiredEntries) {
+    if (!hasCategorizedCommand(readiness, category, command)) throw new Error(message);
+  }
+  if (!readiness?.categorized?.forbidden?.some((item) => item.command.includes('automation --once'))) throw new Error('automation readiness missing actual execution forbidden entry');
+}

package/tools/vibe-release-check/release-check-stage103-118-smoke-specs.mjs

@@ -0,0 +1,97 @@
+export function stage112ReviewIntakeJsonMarkers(intake) {
+  return [
+    ['command', intake.command, 'review'],
+    ['mode', intake.mode, 'review-intake-envelope'],
+    ['ok', intake.ok, true],
+    ['review_intake.stage', intake.review_intake?.stage, 'Stage 112'],
+    ['review_intake.review_kind', intake.review_intake?.review_kind, 'review-intake-envelope'],
+    ['review_intake.source_bindings.plan_action_manifest_stage', intake.review_intake?.source_bindings?.plan_action_manifest_stage, 'Stage 105'],
+    ['review_intake.source_bindings.registry_stage', intake.review_intake?.source_bindings?.registry_stage, 'Stage 101'],
+    ['review_intake.source_bindings.registry_version', intake.review_intake?.source_bindings?.registry_version, 47],
+    ['review_intake.review_intake.review_item_count', intake.review_intake?.review_intake?.review_item_count, 1],
+    ['review_intake.review_intake.reviewer_invoked_by_stage_112', intake.review_intake?.review_intake?.reviewer_invoked_by_stage_112, false],
+    ['review_intake.review_intake.repair_executed_by_stage_112', intake.review_intake?.review_intake?.repair_executed_by_stage_112, false],
+    ['review_intake.review_intake.execution_authorized', intake.review_intake?.review_intake?.execution_authorized, false],
+    ['review_intake.review_items.0.id', intake.review_intake?.review_items?.[0]?.id, 'review-runtime-boundary'],
+    ['review_intake.review_items.0.feedback_category', intake.review_intake?.review_items?.[0]?.feedback_category, 'blocking_bug'],
+    ['review_intake.review_feedback_gate.stage', intake.review_intake?.review_feedback_gate?.stage, 'Stage 26'],
+    ['review_intake.review_feedback_gate.gate_kind', intake.review_intake?.review_feedback_gate?.gate_kind, 'skill-driven-review-feedback-gate'],
+    ['review_intake.review_feedback_gate.selected_skill', intake.review_intake?.review_feedback_gate?.selected_skill, 'vibe-receiving-code-review'],
+    ['review_intake.review_feedback_gate.category_counts.blocking_bug', intake.review_intake?.review_feedback_gate?.category_counts?.blocking_bug, 1],
+    ['review_intake.next_task_gate.blocked', intake.review_intake?.next_task_gate?.blocked, true],
+    ['review_intake.review_intake_invariants.pass', intake.review_intake?.review_intake_invariants?.pass, true],
+    ['review_intake.boundary_assertions.review_intake_artifact', intake.review_intake?.boundary_assertions?.review_intake_artifact, false],
+    ['review_intake.boundary_assertions.review_resolution_artifact', intake.review_intake?.boundary_assertions?.review_resolution_artifact, false],
+    ['review_intake.boundary_assertions.reviewer_invocation', intake.review_intake?.boundary_assertions?.reviewer_invocation, false],
+    ['review_intake.boundary_assertions.repair_execution', intake.review_intake?.boundary_assertions?.repair_execution, false],
+    ['review_intake.boundary_assertions.command_execution', intake.review_intake?.boundary_assertions?.command_execution, false],
+    ['review_intake.boundary_assertions.git', intake.review_intake?.boundary_assertions?.git, false],
+    ['review_intake.boundary_assertions.git_write', intake.review_intake?.boundary_assertions?.git_write, false],
+    ['review_intake.boundary_assertions.commit', intake.review_intake?.boundary_assertions?.commit, false],
+    ['review_intake.boundary_assertions.push', intake.review_intake?.boundary_assertions?.push, false],
+    ['review_intake.boundary_assertions.pr', intake.review_intake?.boundary_assertions?.pr, false],
+    ['review_intake.boundary_assertions.merge', intake.review_intake?.boundary_assertions?.merge, false],
+    ['safety.stage', intake.safety?.stage, 'Stage 112'],
+  ];
+}
+
+export function stage112ReviewResolutionJsonMarkers(resolution) {
+  return [
+    ['command', resolution.command, 'review'],
+    ['mode', resolution.mode, 'review-resolution-envelope'],
+    ['ok', resolution.ok, true],
+    ['review_resolution.stage', resolution.review_resolution?.stage, 'Stage 112'],
+    ['review_resolution.review_kind', resolution.review_resolution?.review_kind, 'review-resolution-envelope'],
+    ['review_resolution.source_bindings.registry_stage', resolution.review_resolution?.source_bindings?.registry_stage, 'Stage 101'],
+    ['review_resolution.source_bindings.registry_version', resolution.review_resolution?.source_bindings?.registry_version, 47],
+    ['review_resolution.review_resolution.resolution_item_count', resolution.review_resolution?.review_resolution?.resolution_item_count, 1],
+    ['review_resolution.review_resolution.resolved_count', resolution.review_resolution?.review_resolution?.resolved_count, 1],
+    ['review_resolution.review_resolution.missing_evidence_count', resolution.review_resolution?.review_resolution?.missing_evidence_count, 0],
+    ['review_resolution.review_resolution.reviewer_invoked_by_stage_112', resolution.review_resolution?.review_resolution?.reviewer_invoked_by_stage_112, false],
+    ['review_resolution.review_resolution.repair_executed_by_stage_112', resolution.review_resolution?.review_resolution?.repair_executed_by_stage_112, false],
+    ['review_resolution.review_resolution.execution_authorized', resolution.review_resolution?.review_resolution?.execution_authorized, false],
+    ['review_resolution.resolved', resolution.review_resolution?.resolved, true],
+    ['review_resolution.review_feedback_gate.stage', resolution.review_resolution?.review_feedback_gate?.stage, 'Stage 26'],
+    ['review_resolution.review_feedback_gate.phase', resolution.review_resolution?.review_feedback_gate?.phase, 'resolution_check'],
+    ['review_resolution.next_task_gate.blocked', resolution.review_resolution?.next_task_gate?.blocked, false],
+    ['review_resolution.missing_evidence.length', resolution.review_resolution?.missing_evidence?.length, 0],
+    ['review_resolution.review_resolution_invariants.pass', resolution.review_resolution?.review_resolution_invariants?.pass, true],
+    ['review_resolution.boundary_assertions.review_intake_artifact', resolution.review_resolution?.boundary_assertions?.review_intake_artifact, false],
+    ['review_resolution.boundary_assertions.review_resolution_artifact', resolution.review_resolution?.boundary_assertions?.review_resolution_artifact, false],
+    ['review_resolution.boundary_assertions.reviewer_invocation', resolution.review_resolution?.boundary_assertions?.reviewer_invocation, false],
+    ['review_resolution.boundary_assertions.repair_execution', resolution.review_resolution?.boundary_assertions?.repair_execution, false],
+    ['review_resolution.boundary_assertions.command_execution', resolution.review_resolution?.boundary_assertions?.command_execution, false],
+    ['review_resolution.boundary_assertions.git', resolution.review_resolution?.boundary_assertions?.git, false],
+    ['review_resolution.boundary_assertions.git_write', resolution.review_resolution?.boundary_assertions?.git_write, false],
+    ['review_resolution.boundary_assertions.commit', resolution.review_resolution?.boundary_assertions?.commit, false],
+    ['review_resolution.boundary_assertions.push', resolution.review_resolution?.boundary_assertions?.push, false],
+    ['review_resolution.boundary_assertions.pr', resolution.review_resolution?.boundary_assertions?.pr, false],
+    ['review_resolution.boundary_assertions.merge', resolution.review_resolution?.boundary_assertions?.merge, false],
+    ['safety.stage', resolution.safety?.stage, 'Stage 112'],
+  ];
+}
+
+export function stage112ReviewIntakeTextExpectations() {
+  return [
+    'Vibecoding Runtime Review Intake Envelope',
+    'Stage: Stage 112; Kind: review-intake-envelope; pass=true',
+    'Review: items=1; impacted_files=2',
+    'reviewer_invoked_by_stage_112=false; repair_executed_by_stage_112=false',
+    'Review feedback gate: stage=Stage 26; kind=skill-driven-review-feedback-gate; phase=triage; next_task_blocked=true',
+    'Review feedback blockers:',
+    'Boundary: writes=false; review_intake_artifact=false; review_resolution_artifact=false; command_execution=false; repair_execution=false; reviewer_invocation=false; git=false; git_write=false; commit=false',
+    'Review intake digest:',
+  ];
+}
+
+export function stage112ReviewResolutionTextExpectations() {
+  return [
+    'Vibecoding Runtime Review Resolution Envelope',
+    'Stage: Stage 112; Kind: review-resolution-envelope; pass=true',
+    'Resolution: items=1; resolved=1; accepted_risk=0; missing_evidence=0',
+    'reviewer_invoked_by_stage_112=false; repair_executed_by_stage_112=false',
+    'Review feedback gate: stage=Stage 26; kind=skill-driven-review-feedback-gate; phase=resolution_check; next_task_blocked=false',
+    'Boundary: writes=false; review_intake_artifact=false; review_resolution_artifact=false; command_execution=false; repair_execution=false; reviewer_invocation=false; git=false; git_write=false; commit=false',
+    'Review resolution digest:',
+  ];
+}