@jtf19/vibecoding-kit 0.1.0

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

@@ -0,0 +1,140 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+import { assertJsonPathMarkers } from './release-check-json-markers.mjs';
+import { attachCommandResult, releaseCheckSummaryPayload } from './release-check-run-summary.mjs';
+
+export const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+export const baseTmpRoot = path.join(repoRoot, '.tmp');
+export const releaseCheckRunId = `release-check-${process.pid}-${Date.now().toString(36)}`;
+export const tmpRoot = path.join(baseTmpRoot, releaseCheckRunId);
+export const releaseCheckCommandResults = [];
+
+export function formatCommand(command, args) {
+  return [command, ...args].join(' ');
+}
+
+export function writeCommandOutput(result) {
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+}
+
+export function removeTmp() {
+  fs.rmSync(tmpRoot, { recursive: true, force: true });
+  try {
+    fs.rmdirSync(baseTmpRoot);
+  } catch {
+    // Keep .tmp when another release-check run or suite-owned fixture still exists.
+  }
+}
+
+export function suiteTmpTarget(name) {
+  const normalized = String(name || '').trim();
+  if (!normalized || normalized.includes('/') || normalized.includes('\\') || normalized.includes('..')) {
+    throw new Error(`Invalid release-check suite tmp target: ${name}`);
+  }
+  const target = `.tmp/${normalized}`;
+  return { target, absoluteTarget: path.join(repoRoot, target) };
+}
+
+export function withSuiteTmp(name, options = {}, fn) {
+  const targetInfo = suiteTmpTarget(name);
+  fs.rmSync(targetInfo.absoluteTarget, { recursive: true, force: true });
+  try {
+    fs.mkdirSync(targetInfo.absoluteTarget, { recursive: true });
+    return fn(targetInfo);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(targetInfo.absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+export function writeReleaseCheckRunSummary(summary = {}) {
+  fs.mkdirSync(tmpRoot, { recursive: true });
+  const payload = releaseCheckSummaryPayload({
+    summaryId: releaseCheckRunId,
+    summary,
+    commands: releaseCheckCommandResults,
+  });
+  const file = path.join(tmpRoot, 'release-check-run-summary.json');
+  fs.writeFileSync(file, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+  return file;
+}
+
+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 runCheckNotIgnored(paths, options) {
+  const display = `git check-ignore -v ${paths.join(' ')}`;
+  if (!options.quiet) console.log(`\n$ ${display}`);
+
+  const startedAt = Date.now();
+  const result = spawnSync('git', ['check-ignore', '-v', ...paths], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    shell: process.platform === 'win32',
+  });
+  attachCommandResult(releaseCheckCommandResults, display, result, startedAt, result.status !== 0);
+
+  if (!options.quiet) writeCommandOutput(result);
+
+  if (result.status === 0) {
+    if (options.quiet) writeCommandOutput(result);
+    throw new Error(`fork path is ignored: ${paths.join(', ')}`);
+  }
+
+  if (options.quiet) console.log(`[ok] ${display}`);
+  else console.log('[ok] fork paths are not ignored');
+}
+
+export function run(command, args, settings = {}, options = { quiet: false }) {
+  const display = formatCommand(command, args);
+  if (!options.quiet) console.log(`\n$ ${display}`);
+
+  const startedAt = Date.now();
+  const result = spawnSync(command, args, {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    shell: process.platform === 'win32',
+    env: settings.env ? { ...process.env, ...settings.env } : process.env,
+  });
+  attachCommandResult(releaseCheckCommandResults, display, result, startedAt, result.status !== 0 && settings.allowFailure);
+
+  if (!options.quiet) writeCommandOutput(result);
+
+  if (result.status !== 0 && !settings.allowFailure) {
+    if (options.quiet) {
+      console.error(`\n$ ${display}`);
+      writeCommandOutput(result);
+    }
+    throw new Error(`Command failed: ${display}`);
+  }
+
+  if (result.status !== 0 && settings.allowFailure) {
+    if (settings.expectOutput) assertOutputIncludes(result, settings.expectOutput, display);
+    if (settings.expectJsonMarkers) assertJsonPathMarkers(parseJsonOutput(result, display), settings.expectJsonMarkers, display);
+    if (options.quiet) console.log(`[ok] ${display} returned non-zero; accepted for this check`);
+    else console.log('[info] command returned non-zero; accepted for this check');
+    return result;
+  }
+
+  if (options.quiet) console.log(`[ok] ${display}`);
+  if (settings.expectOutput) assertOutputIncludes(result, settings.expectOutput, display);
+  if (settings.expectJsonMarkers) assertJsonPathMarkers(parseJsonOutput(result, display), settings.expectJsonMarkers, display);
+  return result;
+}

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

@@ -0,0 +1,106 @@
+const runtimeSurfaceCapabilityExpectations = [
+  { group: 'automation', stage: 'Stage 103', message: 'runtime surface missing Stage 103 automation capability group' },
+  { group: 'workflow', stage: 'Stage 104', commands: ['workflow --loop-contract'], message: 'runtime surface missing Stage 104 workflow loop contract capability group' },
+  { group: 'methodology', stage: 'Stage 105', commands: ['planner --action-manifest'], message: 'runtime surface missing Stage 105 plan action manifest capability group' },
+  { group: 'verification', stage: 'Stage 106', commands: ['verification --self-test-profile'], message: 'runtime surface missing Stage 106 self-test profile capability group' },
+  { group: 'release', stage: 'Stage 107', commands: ['release --commit-readiness'], message: 'runtime surface missing Stage 107 commit readiness capability group' },
+  { group: 'automation', stage: 'Stage 108', commands: ['automation --one-shot-plan'], message: 'runtime surface missing Stage 108 confirmed one-shot plan capability group' },
+];
+
+const runtimeSurfaceInventoryExpectations = [
+  { stage: 'Stage 99', command: 'completion --evidence-bundle', message: 'runtime surface missing Stage 99 inventory item' },
+  { stage: 'Stage 100', command: 'governance --surface', message: 'runtime surface missing Stage 100 inventory item' },
+  { stage: 'Stage 101', capability: 'runtime capability registry', message: 'runtime surface missing Stage 101 registry inventory item' },
+  { stage: 'Stage 102', command: 'governance --surface --drift-guard', message: 'runtime surface missing Stage 102 drift guard inventory item' },
+  { stage: 'Stage 103', command: 'automation --readiness', message: 'runtime surface missing Stage 103 automation readiness inventory item' },
+  { stage: 'Stage 104', command: 'workflow --loop-contract', message: 'runtime surface missing Stage 104 workflow loop contract inventory item' },
+  { stage: 'Stage 105', command: 'planner --action-manifest', message: 'runtime surface missing Stage 105 plan action manifest inventory item' },
+  { stage: 'Stage 106', command: 'verification --self-test-profile', message: 'runtime surface missing Stage 106 self-test profile inventory item' },
+  { stage: 'Stage 107', command: 'release --commit-readiness', message: 'runtime surface missing Stage 107 commit readiness inventory item' },
+  { stage: 'Stage 108', command: 'automation --one-shot-plan', message: 'runtime surface missing Stage 108 confirmed one-shot plan inventory item' },
+];
+
+const runtimeSurfaceStage113148Expectations = [
+  { group: 'verification', stage: 'Stage 113', commands: ['verification --tdd-trace'], inventoryCommand: 'verification --tdd-trace', message: 'runtime surface missing Stage 113 TDD trace' },
+  { group: 'workflow', stage: 'Stage 114', commands: ['workflow --close-loop', 'workflow --next-evidence'], inventoryCommands: ['workflow --close-loop', 'workflow --next-evidence'], message: 'runtime surface missing Stage 114 human-friendly alias' },
+  { group: 'governance', stage: 'Stage 115', commands: ['governance --superpowers-gap'], inventoryCommand: 'governance --superpowers-gap', message: 'runtime surface missing Stage 115 Superpowers gap matrix' },
+  { group: 'workflow', stage: 'Stage 116', commands: ['workflow --entry-ux'], inventoryCommand: 'workflow --entry-ux', message: 'runtime surface missing Stage 116 progressive entry UX' },
+  { group: 'planner', stage: 'Stage 117', commands: ['planner --executable-plan'], inventoryCommand: 'planner --executable-plan', message: 'runtime surface missing Stage 117 executable plan quality' },
+  { group: 'automation', stage: 'Stage 118', commands: ['automation --stage-runbook'], inventoryCommand: 'automation --stage-runbook', message: 'runtime surface missing Stage 118 sequential stage runbook' },
+  { group: 'verification', stage: 'Stage 119', commands: ['verification --execution-evidence'], inventoryCommand: 'verification --execution-evidence', message: 'runtime surface missing Stage 119 execution evidence' },
+  { group: 'release', stage: 'Stage 120', commands: ['release --staged-commit-readiness'], inventoryCommand: 'release --staged-commit-readiness', message: 'runtime surface missing Stage 120 staged commit readiness' },
+  { group: 'evals', stage: 'Stage 121', commands: ['evals --behavior-contract'], inventoryCommand: 'evals --behavior-contract', message: 'runtime surface missing Stage 121 behavioral evaluation contract' },
+  { group: 'platforms', stage: 'Stage 122', commands: ['platforms --bootstrap-matrix'], inventoryCommand: 'platforms --bootstrap-matrix', message: 'runtime surface missing Stage 122 adapter bootstrap matrix' },
+  { group: 'governance', stage: 'Stage 123', commands: ['governance --traceability-map'], inventoryCommand: 'governance --traceability-map', message: 'runtime surface missing Stage 123 skill-to-runtime traceability' },
+  { group: 'completion', stage: 'Stage 124', commands: ['completion --evidence-bundle'], inventoryCommand: 'completion --evidence-bundle', message: 'runtime surface missing Stage 124 human completion evidence' },
+  { group: 'governance', stage: 'Stage 126', commands: ['governance --experience-friction'], inventoryCommand: 'governance --experience-friction', message: 'runtime surface missing Stage 126 experience friction' },
+  { group: 'workflow', stage: 'Stage 127', commands: ['workflow --next-action-console'], inventoryCommand: 'workflow --next-action-console', message: 'runtime surface missing Stage 127 next action console' },
+  { group: 'tokens', stage: 'Stage 128', commands: ['tokens --savior-budget'], inventoryCommand: 'tokens --savior-budget', message: 'runtime surface missing Stage 128 Token Savior budget' },
+  { group: 'learning', stage: 'Stage 129', commands: ['learning --experience-pattern'], inventoryCommand: 'learning --experience-pattern', message: 'runtime surface missing Stage 129 ECC learning experience pattern' },
+  { group: 'automation', stage: 'Stage 130', commands: ['automation --stage-scriptlet'], inventoryCommand: 'automation --stage-scriptlet', message: 'runtime surface missing Stage 130 copy-ready stage scriptlet' },
+  { group: 'platforms', stage: 'Stage 131', commands: ['platforms --entry-acceptance'], inventoryCommand: 'platforms --entry-acceptance', message: 'runtime surface missing Stage 131 adapter entry acceptance' },
+  { group: 'governance', stage: 'Stage 132', commands: ['governance --experience-dashboard'], inventoryCommand: 'governance --experience-dashboard', message: 'runtime surface missing Stage 132 experience regression dashboard' },
+  { group: 'governance', stage: 'Stage 133', commands: ['governance --superpowers-comparison'], inventoryCommand: 'governance --superpowers-comparison', message: 'runtime surface missing Stage 133 Superpowers comparison' },
+  { group: 'methodology', stage: 'Stage 136', commands: ['methodology --coverage-map'], inventoryCommand: 'methodology --coverage-map', message: 'runtime surface missing Stage 136 methodology coverage' },
+  { group: 'governance', stage: 'Stage 139', commands: ['governance --experience-upgrades'], inventoryCommand: 'governance --experience-upgrades', message: 'runtime surface missing Stage 139 experience upgrade prioritizer' },
+  { group: 'governance', stage: 'Stage 140', commands: ['governance --superpowers-parity-scorecard'], inventoryCommand: 'governance --superpowers-parity-scorecard', message: 'runtime surface missing Stage 140 Superpowers parity scorecard' },
+  { group: 'tokens', stage: 'Stage 144', commands: ['tokens --entry-defaults'], inventoryCommand: 'tokens --entry-defaults', message: 'runtime surface missing Stage 144 context budget entry defaults' },
+  { group: 'evals', stage: 'Stage 145', commands: ['evals --local-behavior-contracts'], inventoryCommand: 'evals --local-behavior-contracts', message: 'runtime surface missing Stage 145 local behavior eval contracts' },
+];
+
+function hasCapabilityGroup(runtimeSurface, expectation) {
+  return runtimeSurface?.capability_groups?.some((group) => {
+    if (group.group !== expectation.group) return false;
+    if (expectation.stage && !group.stages.includes(expectation.stage)) return false;
+    return (expectation.commands || []).every((command) => group.commands.includes(command));
+  });
+}
+
+function hasStageInventory(runtimeSurface, expectation) {
+  return runtimeSurface?.stage_inventory?.some((item) => {
+    if (item.stage !== expectation.stage) return false;
+    if (expectation.command && item.command !== expectation.command) return false;
+    if (expectation.capability && item.capability !== expectation.capability) return false;
+    return true;
+  });
+}
+
+function expectationInventoryCommands(expectation) {
+  if (expectation.inventoryCommands) return expectation.inventoryCommands;
+  if (expectation.inventoryCommand) return [expectation.inventoryCommand];
+  if (expectation.command) return [expectation.command];
+  return [];
+}
+
+function assertNoDuplicateStageCommands(expectations, label) {
+  const seen = new Set();
+  for (const expectation of expectations) {
+    for (const command of expectationInventoryCommands(expectation)) {
+      const key = `${expectation.stage}::${command}`;
+      if (seen.has(key)) throw new Error(`runtime surface expectation duplicate ${label}: ${key}`);
+      seen.add(key);
+    }
+  }
+}
+
+function assertRuntimeSurfaceExpectationModel() {
+  assertNoDuplicateStageCommands(runtimeSurfaceInventoryExpectations, 'inventory');
+  assertNoDuplicateStageCommands(runtimeSurfaceStage113148Expectations, 'stage inventory');
+}
+
+export function assertRuntimeSurfaceExpectations(runtimeSurface) {
+  assertRuntimeSurfaceExpectationModel();
+  for (const expectation of runtimeSurfaceCapabilityExpectations) {
+    if (!hasCapabilityGroup(runtimeSurface, expectation)) throw new Error(expectation.message);
+  }
+  for (const expectation of runtimeSurfaceInventoryExpectations) {
+    if (!hasStageInventory(runtimeSurface, expectation)) throw new Error(expectation.message);
+  }
+  for (const expectation of runtimeSurfaceStage113148Expectations) {
+    if (!hasCapabilityGroup(runtimeSurface, expectation)) throw new Error(`${expectation.message} capability group`);
+    const commands = expectation.inventoryCommands || [expectation.inventoryCommand];
+    for (const command of commands) {
+      if (!hasStageInventory(runtimeSurface, { stage: expectation.stage, command })) throw new Error(`${expectation.message} inventory item`);
+    }
+  }
+}

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

@@ -0,0 +1,112 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  assertJsonMarkers,
+  parseJsonOutput,
+  repoRoot,
+  run,
+} from './release-check-runtime.mjs';
+import { assertRuntimeSurfaceExpectations } from './release-check-runtime-surface-expectations.mjs';
+
+export function runRuntimeSurfaceSmoke(options) {
+  const target = '.tmp/vibe-runtime-surface';
+  const absoluteTarget = path.join(repoRoot, target);
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    const surface = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--surface', '--json', '--root', target], {}, options), 'governance --surface --json');
+    assertJsonMarkers([
+      ['command', surface.command, 'governance'],
+      ['mode', surface.mode, 'runtime-capability-surface'],
+      ['ok', surface.ok, true],
+      ['runtime_surface.stage', surface.runtime_surface?.stage, 'Stage 100'],
+      ['runtime_surface.surface_kind', surface.runtime_surface?.surface_kind, 'runtime-capability-surface'],
+      ['runtime_surface.registry_stage', surface.runtime_surface?.registry_stage, 'Stage 101'],
+      ['runtime_surface.registry_kind', surface.runtime_surface?.registry_kind, 'runtime-capability-registry'],
+      ['runtime_surface.registry_version', surface.runtime_surface?.registry_version, 47],
+      ['runtime_surface.registry_invariants.pass', surface.runtime_surface?.registry_invariants?.pass, true],
+      ['runtime_surface.writes', surface.runtime_surface?.writes, false],
+      ['runtime_surface.state_directory_created', surface.runtime_surface?.state_directory_created, false],
+      ['runtime_surface.boundary_assertions.runtime_surface_artifact', surface.runtime_surface?.boundary_assertions?.runtime_surface_artifact, false],
+      ['runtime_surface.boundary_assertions.capability_registry_artifact', surface.runtime_surface?.boundary_assertions?.capability_registry_artifact, false],
+      ['runtime_surface.boundary_assertions.command_execution', surface.runtime_surface?.boundary_assertions?.command_execution, false],
+      ['runtime_surface.boundary_assertions.workflow_execution', surface.runtime_surface?.boundary_assertions?.workflow_execution, false],
+      ['runtime_surface.boundary_assertions.verification_execution', surface.runtime_surface?.boundary_assertions?.verification_execution, false],
+      ['runtime_surface.boundary_assertions.git', surface.runtime_surface?.boundary_assertions?.git, false],
+      ['runtime_surface.boundary_assertions.push', surface.runtime_surface?.boundary_assertions?.push, false],
+      ['runtime_surface.boundary_assertions.pr', surface.runtime_surface?.boundary_assertions?.pr, false],
+      ['runtime_surface.boundary_assertions.merge', surface.runtime_surface?.boundary_assertions?.merge, false],
+      ['safety.stage', surface.safety?.stage, 'Stage 100'],
+      ['safety.registry_stage', surface.safety?.registry_stage, 'Stage 101'],
+      ['safety.runtime_surface_artifact', surface.safety?.runtime_surface_artifact, false],
+      ['safety.capability_registry_artifact', surface.safety?.capability_registry_artifact, false],
+      ['safety.platform_api', surface.safety?.platform_api, false],
+    ], 'governance --surface --json');
+    if (!surface.runtime_surface?.surface_digest) throw new Error('runtime surface missing surface_digest');
+    if (!surface.runtime_surface?.registry_digest) throw new Error('runtime surface missing registry_digest');
+    if (!surface.runtime_surface?.registry_invariants?.checked?.includes('capability_groups')) throw new Error('runtime surface registry invariants missing capability_groups check');
+    assertRuntimeSurfaceExpectations(surface.runtime_surface);
+    if (!surface.runtime_surface?.capability_groups?.some((group) => group.group === 'completion')) throw new Error('runtime surface missing completion capability group');
+    if (!surface.runtime_surface?.capability_groups?.some((group) => group.group === 'governance' && group.stages.includes('Stage 101'))) throw new Error('runtime surface missing Stage 101 governance capability group');
+    if (!surface.runtime_surface?.closeout_chain?.some((item) => item.command.includes('release --commit-guard'))) throw new Error('runtime surface closeout chain missing commit guard');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('governance --surface JSON output created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--surface', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Capability Surface', 'Stage: Stage 100; Surface: runtime-capability-surface', 'Capability groups:', 'Registry: Stage 101; runtime-capability-registry; pass=true', 'Closeout chain:', 'Boundary: writes=false; runtime_surface_artifact=false; capability_registry_artifact=false', 'Registry digest:'],
+    }, options);
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('governance --surface text output created unexpected state directory');
+
+    for (const forbidden of ['--confirm', '--preview', '--write', '--preflight', '--dispatch', '--dispatch-intent', '--run', '--once', '--scan']) {
+      run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--surface', forbidden, '--root', target], {
+        allowFailure: true,
+        expectOutput: ['governance --surface is read-only'],
+      }, options);
+    }
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--surface', '--intent', 'closeout', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['governance --surface does not accept --intent'],
+    }, options);
+
+    const driftGuard = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--surface', '--drift-guard', '--json', '--root', target], {}, options), 'governance --surface --drift-guard --json');
+    assertJsonMarkers([
+      ['command', driftGuard.command, 'governance'],
+      ['mode', driftGuard.mode, 'runtime-capability-registry-drift-guard'],
+      ['ok', driftGuard.ok, true],
+      ['runtime_registry_drift_guard.stage', driftGuard.runtime_registry_drift_guard?.stage, 'Stage 102'],
+      ['runtime_registry_drift_guard.guard_kind', driftGuard.runtime_registry_drift_guard?.guard_kind, 'runtime-capability-registry-drift-guard'],
+      ['runtime_registry_drift_guard.registry_stage', driftGuard.runtime_registry_drift_guard?.registry_stage, 'Stage 101'],
+      ['runtime_registry_drift_guard.surface_stage', driftGuard.runtime_registry_drift_guard?.surface_stage, 'Stage 100'],
+      ['runtime_registry_drift_guard.guard_pass', driftGuard.runtime_registry_drift_guard?.guard_pass, true],
+      ['runtime_registry_drift_guard.writes', driftGuard.runtime_registry_drift_guard?.writes, false],
+      ['runtime_registry_drift_guard.state_directory_created', driftGuard.runtime_registry_drift_guard?.state_directory_created, false],
+      ['runtime_registry_drift_guard.boundary_assertions.runtime_registry_drift_guard_artifact', driftGuard.runtime_registry_drift_guard?.boundary_assertions?.runtime_registry_drift_guard_artifact, false],
+      ['runtime_registry_drift_guard.boundary_assertions.command_execution', driftGuard.runtime_registry_drift_guard?.boundary_assertions?.command_execution, false],
+      ['runtime_registry_drift_guard.boundary_assertions.workflow_execution', driftGuard.runtime_registry_drift_guard?.boundary_assertions?.workflow_execution, false],
+      ['runtime_registry_drift_guard.boundary_assertions.verification_execution', driftGuard.runtime_registry_drift_guard?.boundary_assertions?.verification_execution, false],
+      ['safety.stage', driftGuard.safety?.stage, 'Stage 102'],
+      ['safety.registry_stage', driftGuard.safety?.registry_stage, 'Stage 101'],
+      ['safety.surface_stage', driftGuard.safety?.surface_stage, 'Stage 100'],
+      ['safety.runtime_registry_drift_guard_artifact', driftGuard.safety?.runtime_registry_drift_guard_artifact, false],
+    ], 'governance --surface --drift-guard --json');
+    if (!driftGuard.runtime_registry_drift_guard?.drift_guard_digest) throw new Error('runtime registry drift guard missing drift_guard_digest');
+    if (!driftGuard.runtime_registry_drift_guard?.checked?.includes('doc_marker_expectations')) throw new Error('runtime registry drift guard missing doc marker expectation check');
+    if (!driftGuard.runtime_registry_drift_guard?.doc_marker_expectations?.some((item) => item.file === 'tools/vibe-release-check/index.mjs')) throw new Error('runtime registry drift guard missing release-check marker expectation');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('governance --surface --drift-guard JSON output created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--surface', '--drift-guard', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Capability Registry Drift Guard', 'Stage: Stage 102; Guard: runtime-capability-registry-drift-guard; pass=true', 'Registry: Stage 101; runtime-capability-registry', 'Surface: Stage 100; runtime-capability-surface', 'Boundary: writes=false; runtime_registry_drift_guard_artifact=false', 'Drift guard digest:'],
+    }, options);
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('governance --surface --drift-guard text output created unexpected state directory');
+
+    for (const forbidden of ['--confirm', '--preview', '--write', '--preflight', '--dispatch', '--dispatch-intent', '--run', '--once', '--scan']) {
+      run('node', ['tools/vibe-runtime/index.mjs', 'governance', '--surface', '--drift-guard', forbidden, '--root', target], {
+        allowFailure: true,
+        expectOutput: ['governance --surface is read-only'],
+      }, options);
+    }
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}

package/tools/vibe-release-check/release-check-runtime-task-artifact-suite.mjs

@@ -0,0 +1,105 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  assertJsonMarkers,
+  assertOutputIncludes,
+  parseJsonOutput,
+  repoRoot,
+  run,
+} from './release-check-runtime.mjs';
+
+export function runRuntimeTaskArtifactSmoke(context, options) {
+  const {
+    target,
+    absoluteTarget,
+    jsonHandoffFile,
+    artifactFiles,
+    taskArtifactFiles,
+  } = context;
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'artifacts', '--dry-run', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Artifacts', 'Mode: dry-run', '--- .vibecoding-state/task-brief.md ---', '# Runtime Task Brief', 'Goal', 'Workflow reason', 'Key decisions', '--- .vibecoding-state/review-gate.md ---', '# Runtime Review Gate', 'Review focus', 'Risk gate', 'Evidence gate', '--- .vibecoding-state/evidence.md ---', '# Runtime Evidence', 'Goal under verification', 'Evidence gaps to fill', 'Acceptance to verify', 'Decisions requiring evidence', 'Action: artifacts were previewed. No files were written.'],
+    }, options);
+    for (const file of artifactFiles) {
+      if (fs.existsSync(file)) throw new Error(`artifacts --dry-run wrote unexpected file: ${file}`);
+    }
+    run('node', ['tools/vibe-runtime/index.mjs', 'tasks', '--dry-run', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Task Artifacts', 'Mode: dry-run', '--- .vibecoding-state/tasks/task-1/brief.md ---', '# Runtime Task Brief: release check task artifact smoke', 'Task identity', 'Readiness: ready', 'Dependencies', 'Dependency readiness', '--- .vibecoding-state/tasks/task-1/report.md ---', '# Runtime Task Report: release check task artifact smoke', 'Verification evidence', '--- .vibecoding-state/tasks/task-1/review-gate.md ---', '# Runtime Task Review Gate: release check task artifact smoke', 'Review state', 'Status: not_started', 'Spec compliance gate', '--- .vibecoding-state/tasks/task-1/evidence.md ---', '# Runtime Task Evidence: release check task artifact smoke', 'Evidence gaps to fill', '--- .vibecoding-state/tasks/task-5/brief.md ---', 'Readiness: waiting', 'Blocked by: task-1', '--- .vibecoding-state/tasks/task.alpha_1/review-gate.md ---', 'Status: waived', 'user accepted documented review risk', 'Action: task artifacts were previewed. No files were written.'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'tasks', '--dry-run', '--task', 'task.alpha_1', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Task Artifacts', 'Mode: dry-run', 'Task filter: task.alpha_1', 'Tasks selected: 1 of 6', '--- .vibecoding-state/tasks/task.alpha_1/review-gate.md ---', 'Status: waived', 'user accepted documented review risk', 'Action: task artifacts were previewed. No files were written.'],
+    }, options);
+    const taskFilterJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'tasks', '--dry-run', '--task', 'task.alpha_1', '--json', '--root', target], {}, options), 'tasks --dry-run --task --json');
+    assertJsonMarkers([
+      ['schema_version', taskFilterJson.schema_version, 1],
+      ['command', taskFilterJson.command, 'tasks'],
+      ['mode', taskFilterJson.mode, 'dry-run'],
+      ['summary.total_tasks', taskFilterJson.summary?.total_tasks, 6],
+      ['summary.selected_count', taskFilterJson.summary?.selected_count, 1],
+      ['summary.selected_task_ids.0', taskFilterJson.summary?.selected_task_ids?.[0], 'task.alpha_1'],
+      ['tasks.0.id', taskFilterJson.tasks?.[0]?.id, 'task.alpha_1'],
+      ['tasks.0.readiness', taskFilterJson.tasks?.[0]?.readiness, 'completed'],
+      ['tasks.0.artifact_paths.review-gate.md', taskFilterJson.tasks?.[0]?.artifact_paths?.['review-gate.md'], '.vibecoding-state/tasks/task.alpha_1/review-gate.md'],
+    ], 'tasks --dry-run --task --json');
+    const dependencyFilterJson = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'tasks', '--dry-run', '--task', 'task-2', '--json', '--root', target], {}, options), 'tasks --dry-run --task dependency --json');
+    assertJsonMarkers([
+      ['summary.selected_count', dependencyFilterJson.summary?.selected_count, 1],
+      ['summary.selected_task_ids.0', dependencyFilterJson.summary?.selected_task_ids?.[0], 'task-2'],
+      ['tasks.0.id', dependencyFilterJson.tasks?.[0]?.id, 'task-2'],
+      ['tasks.0.readiness', dependencyFilterJson.tasks?.[0]?.readiness, 'ready'],
+      ['tasks.0.blocked_by.length', dependencyFilterJson.tasks?.[0]?.blocked_by?.length, 0],
+    ], 'tasks --dry-run --task dependency --json');
+    run('node', ['tools/vibe-runtime/index.mjs', 'tasks', '--dry-run', '--task', 'missing-task', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['Task not found in workflow state: missing-task'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'tasks', '--dry-run', '--task', 'CON', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['Invalid task id: CON'],
+    }, options);
+    for (const file of taskArtifactFiles) {
+      if (fs.existsSync(file)) throw new Error(`tasks --dry-run wrote unexpected file: ${file}`);
+    }
+    run('node', ['tools/vibe-runtime/index.mjs', 'artifacts', '--write', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Artifacts', 'Mode: write', 'task-brief.md', 'review-gate.md', 'evidence.md', 'Action: artifacts were written. No next skill was executed.'],
+    }, options);
+    for (const file of artifactFiles) {
+      if (!fs.existsSync(file)) throw new Error(`artifacts --write did not create expected file: ${file}`);
+    }
+    const [taskBriefFile, reviewGateFile, evidenceFile] = artifactFiles;
+    assertOutputIncludes({ stdout: fs.readFileSync(taskBriefFile, 'utf8') }, ['# Runtime Task Brief', 'Goal', 'release check JSON handoff', 'Workflow reason', 'Key decisions', 'JSON handoff is supported', 'Missing fields are shown as not recorded'], taskBriefFile);
+    assertOutputIncludes({ stdout: fs.readFileSync(reviewGateFile, 'utf8') }, ['# Runtime Review Gate', 'Review focus', 'Key decisions to verify', 'JSON handoff is supported', 'Risk gate', 'Evidence gate'], reviewGateFile);
+    assertOutputIncludes({ stdout: fs.readFileSync(evidenceFile, 'utf8') }, ['# Runtime Evidence', 'Goal under verification', 'release check JSON handoff', 'Evidence gaps to fill', 'Acceptance to verify', 'Decisions requiring evidence', 'JSON handoff is supported'], evidenceFile);
+
+    const taskFilterTarget = '.tmp/vibe-runtime-task-filter-ledger';
+    const absoluteTaskFilterTarget = path.join(repoRoot, taskFilterTarget);
+    fs.rmSync(absoluteTaskFilterTarget, { recursive: true, force: true });
+    fs.mkdirSync(absoluteTaskFilterTarget, { recursive: true });
+    run('node', ['tools/vibe-runtime/index.mjs', 'record-handoff', '--from-file', jsonHandoffFile, '--root', taskFilterTarget], {}, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'tasks', '--write', '--task', 'task.alpha_1', '--root', taskFilterTarget], {
+      expectOutput: ['Vibecoding Runtime Task Artifacts', 'Mode: write', 'Task filter: task.alpha_1', 'Tasks selected: 1 of 6', 'brief.md', 'report.md', 'review-gate.md', 'evidence.md', 'Action: task artifacts were written. No next skill was executed.'],
+    }, options);
+    const selectedTaskFilterFile = path.join(absoluteTaskFilterTarget, '.vibecoding-state', 'tasks', 'task.alpha_1', 'review-gate.md');
+    const unselectedTaskFilterFile = path.join(absoluteTaskFilterTarget, '.vibecoding-state', 'tasks', 'task-1', 'review-gate.md');
+    if (!fs.existsSync(selectedTaskFilterFile)) throw new Error(`tasks --write --task did not create selected task file: ${selectedTaskFilterFile}`);
+    if (fs.existsSync(unselectedTaskFilterFile)) throw new Error(`tasks --write --task created unselected task file: ${unselectedTaskFilterFile}`);
+    fs.rmSync(absoluteTaskFilterTarget, { recursive: true, force: true });
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'tasks', '--write', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Task Artifacts', 'Mode: write', 'brief.md', 'report.md', 'review-gate.md', 'evidence.md', 'Action: task artifacts were written. No next skill was executed.'],
+    }, options);
+    for (const file of taskArtifactFiles) {
+      if (!fs.existsSync(file)) throw new Error(`tasks --write did not create expected file: ${file}`);
+    }
+    const [taskLevelBriefFile, taskLevelReportFile, taskLevelReviewGateFile, taskLevelEvidenceFile] = taskArtifactFiles;
+    const waitingTaskBriefFile = path.join(absoluteTarget, '.vibecoding-state', 'tasks', 'task-5', 'brief.md');
+    const waivedReviewGateFile = path.join(absoluteTarget, '.vibecoding-state', 'tasks', 'task.alpha_1', 'review-gate.md');
+    const needsFixReviewGateFile = path.join(absoluteTarget, '.vibecoding-state', 'tasks', 'task-4', 'review-gate.md');
+    assertOutputIncludes({ stdout: fs.readFileSync(taskLevelBriefFile, 'utf8') }, ['# Runtime Task Brief: release check task artifact smoke', 'Task identity', 'task-1', 'Readiness: ready', 'Blocked by: not recorded', 'Dependencies', 'Dependency readiness', 'task artifacts can be previewed and written', 'No next skill, subagent, git, worktree, or verification command was executed.'], taskLevelBriefFile);
+    assertOutputIncludes({ stdout: fs.readFileSync(waitingTaskBriefFile, 'utf8') }, ['# Runtime Task Brief: release check waiting dependency smoke', 'Readiness: waiting', 'Blocked by: task-1', 'Dependencies', 'task-1', 'Dependency readiness'], waitingTaskBriefFile);
+    assertOutputIncludes({ stdout: fs.readFileSync(taskLevelReportFile, 'utf8') }, ['# Runtime Task Report: release check task artifact smoke', 'Claimed outcome', 'not recorded', 'Verification evidence', 'release-check', 'No implementation was executed.'], taskLevelReportFile);
+    assertOutputIncludes({ stdout: fs.readFileSync(taskLevelReviewGateFile, 'utf8') }, ['# Runtime Task Review Gate: release check task artifact smoke', 'Review state', 'Status: not_started', 'Waiver: not recorded', 'Spec compliance gate', 'Risk gate', 'Evidence gate', 'No reviewer or subagent was invoked.'], taskLevelReviewGateFile);
+    assertOutputIncludes({ stdout: fs.readFileSync(needsFixReviewGateFile, 'utf8') }, ['# Runtime Task Review Gate: release check needs fix review smoke', 'Status: needs_fix', 'fix required before finishing', 'important feedback remains'], needsFixReviewGateFile);
+    assertOutputIncludes({ stdout: fs.readFileSync(waivedReviewGateFile, 'utf8') }, ['# Runtime Task Review Gate: release check waived review smoke', 'Status: waived', 'user accepted documented review risk', 'waived review risk'], waivedReviewGateFile);
+    assertOutputIncludes({ stdout: fs.readFileSync(taskLevelEvidenceFile, 'utf8') }, ['# Runtime Task Evidence: release check task artifact smoke', 'Existing evidence', 'Acceptance to verify', 'Evidence gaps to fill', 'No verification command was executed.'], taskLevelEvidenceFile);
+}