@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-release-check/release-check-token-suite.mjs

@@ -0,0 +1,260 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function releaseCheckTokenSuiteHandlers({ repoRoot, run, parseJsonOutput, assertJsonMarkers }) {
+function runTokenCompactionSmoke(options) {
+  const target = '.tmp/vibe-token-compaction';
+  const absoluteTarget = path.join(repoRoot, target);
+  const evidenceDirectory = path.join(absoluteTarget, 'evidence');
+  const outputFile = path.join(evidenceDirectory, 'git-status.txt');
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(evidenceDirectory, { recursive: true });
+    fs.writeFileSync(outputFile, [
+      'On branch main',
+      'Your branch is up to date with origin/main.',
+      '',
+      'Changes not staged for commit:',
+      '  (use "git add <file>..." to update what will be committed)',
+      '  (use "git restore <file>..." to discard changes in working directory)',
+      ' M tools/vibe-runtime/index.mjs',
+      ' M tools/vibe-runtime-check/index.mjs',
+      '?? .tmp/vibe-token-compaction/',
+      '',
+    ].join('\n'), 'utf8');
+
+    const catalog = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--catalog', '--json', '--root', target], {}, options), 'tokens --catalog --json');
+    assertJsonMarkers([
+      ['command', catalog.command, 'tokens'],
+      ['mode', catalog.mode, 'token-compactor-catalog'],
+      ['catalog.stage', catalog.catalog?.stage, 'Stage 63'],
+      ['catalog.deterministic', catalog.catalog?.deterministic, true],
+      ['catalog.pure_function', catalog.catalog?.pure_function, true],
+      ['catalog.shell_interception', catalog.catalog?.shell_interception, false],
+      ['catalog.command_execution', catalog.catalog?.command_execution, false],
+      ['catalog.external_network', catalog.catalog?.external_network, false],
+      ['catalog.model_invocation', catalog.catalog?.model_invocation, false],
+    ], 'tokens --catalog --json');
+    if (!catalog.catalog?.catalog_digest) throw new Error('tokens catalog missing digest');
+    if (!catalog.catalog?.compactors?.some((compactor) => compactor.id === 'git-status')) throw new Error('tokens catalog missing git-status compactor');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('tokens --catalog created state directory');
+
+    const preview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--compact-output', '--command', 'git status', '--from-file', 'evidence/git-status.txt', '--preview', '--json', '--root', target], {}, options), 'tokens --compact-output --preview --json');
+    assertJsonMarkers([
+      ['command', preview.command, 'tokens'],
+      ['mode', preview.mode, 'token-compaction'],
+      ['token_compaction.stage', preview.token_compaction?.stage, 'Stage 63'],
+      ['token_compaction.artifact_kind', preview.token_compaction?.artifact_kind, 'token-compaction'],
+      ['token_compaction.compactor_id', preview.token_compaction?.compactor_id, 'git-status'],
+      ['token_compaction.source_file', preview.token_compaction?.source_file, 'evidence/git-status.txt'],
+      ['token_compaction.deterministic', preview.token_compaction?.deterministic, true],
+      ['token_compaction.pure_function', preview.token_compaction?.pure_function, true],
+      ['token_compaction.original_output_retained_by_digest', preview.token_compaction?.original_output_retained_by_digest, true],
+      ['safety.writes', preview.safety?.writes, false],
+      ['safety.token_compaction_artifact', preview.safety?.token_compaction_artifact, false],
+      ['safety.shell_interception', preview.safety?.shell_interception, false],
+      ['safety.command_execution', preview.safety?.command_execution, false],
+      ['safety.output_mutation', preview.safety?.output_mutation, false],
+      ['safety.original_output_hidden', preview.safety?.original_output_hidden, false],
+    ], 'tokens --compact-output --preview --json');
+    if (!preview.token_compaction?.full_output_digest) throw new Error('token compaction preview missing full output digest');
+    if (!preview.token_compaction?.compacted_digest) throw new Error('token compaction preview missing compacted digest');
+    if (!preview.token_compaction?.token_compaction_digest) throw new Error('token compaction preview missing token compaction digest');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('tokens --compact-output preview created state directory');
+
+    const confirmed = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--compact-output', '--command', 'git status', '--from-file', 'evidence/git-status.txt', '--confirm', '--json', '--root', target], {}, options), 'tokens --compact-output --confirm --json');
+    const tokenFile = confirmed.token_compaction_file;
+    if (!tokenFile || !tokenFile.endsWith('.token-compaction.json')) throw new Error('tokens --compact-output confirm did not return token sidecar file');
+    const tokenPath = path.join(absoluteTarget, '.vibecoding-state', 'token-economy', tokenFile);
+    if (!fs.existsSync(tokenPath)) throw new Error('tokens --compact-output confirm did not write token sidecar');
+    const extraStateEntries = fs.readdirSync(path.join(absoluteTarget, '.vibecoding-state')).filter((entry) => entry !== 'token-economy');
+    if (extraStateEntries.length > 0) throw new Error(`token compaction smoke wrote unexpected state entries: ${extraStateEntries.join(', ')}`);
+
+    const verified = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--verify', tokenFile, '--json', '--root', target], {}, options), `tokens --verify ${tokenFile} --json`);
+    if (verified.verification?.ok !== true) throw new Error(`token compaction verify failed for ${tokenFile}`);
+
+    const badToken = JSON.parse(fs.readFileSync(tokenPath, 'utf8'));
+    badToken.token_compaction.compacted_text += ' drift';
+    fs.writeFileSync(path.join(absoluteTarget, '.vibecoding-state', 'token-economy', 'bad-drift.token-compaction.json'), `${JSON.stringify(badToken, null, 2)}\n`, 'utf8');
+    run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--verify', 'bad-drift.token-compaction.json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['token compaction verification failed:', 'token_compaction.compacted_text drift', 'token compaction digest mismatch'],
+    }, options);
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--compact-output', '--command', 'git status', '--from-file', '../outside.txt', '--preview', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['token.output_file must not include traversal'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+function runTokenMetricsSmoke(options) {
+  const target = '.tmp/vibe-token-metrics';
+  const absoluteTarget = path.join(repoRoot, target);
+  const evidenceDirectory = path.join(absoluteTarget, 'evidence');
+  const outputFile = path.join(evidenceDirectory, 'git-status.txt');
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(evidenceDirectory, { recursive: true });
+    fs.writeFileSync(outputFile, [
+      '## main...origin/main',
+      ' M tools/vibe-runtime/index.mjs',
+      ' M tools/vibe-runtime-check/index.mjs',
+      '',
+    ].join('\n'), 'utf8');
+
+    const profile = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--profile', '--name', 'balanced', '--json', '--root', target], {}, options), 'tokens --profile --name balanced --json');
+    assertJsonMarkers([
+      ['command', profile.command, 'tokens'],
+      ['mode', profile.mode, 'token-profile'],
+      ['profile.stage', profile.profile?.stage, 'Stage 64'],
+      ['profile.profile_kind', profile.profile?.profile_kind, 'token-profile'],
+      ['profile.name', profile.profile?.name, 'balanced'],
+      ['profile.shell_interception', profile.profile?.shell_interception, false],
+      ['profile.command_execution', profile.profile?.command_execution, false],
+      ['profile.output_mutation', profile.profile?.output_mutation, false],
+    ], 'tokens --profile --name balanced --json');
+    if (!profile.profile?.profile_digest) throw new Error('token profile missing digest');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('tokens --profile created state directory');
+
+    const rewrite = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--rewrite-preview', '--command', 'git status', '--json', '--root', target], {}, options), 'tokens --rewrite-preview --command git status --json');
+    assertJsonMarkers([
+      ['command', rewrite.command, 'tokens'],
+      ['mode', rewrite.mode, 'token-rewrite-preview'],
+      ['rewrite_preview.stage', rewrite.rewrite_preview?.stage, 'Stage 64'],
+      ['rewrite_preview.preview_kind', rewrite.rewrite_preview?.preview_kind, 'token-rewrite-preview'],
+      ['rewrite_preview.suggested_command', rewrite.rewrite_preview?.suggested_command, 'git status --short --branch'],
+      ['rewrite_preview.execute', rewrite.rewrite_preview?.execute, false],
+      ['rewrite_preview.shell_interception', rewrite.rewrite_preview?.shell_interception, false],
+      ['rewrite_preview.command_mutation', rewrite.rewrite_preview?.command_mutation, false],
+    ], 'tokens --rewrite-preview --command git status --json');
+    if (!rewrite.rewrite_preview?.rewrite_preview_digest) throw new Error('rewrite preview missing digest');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('tokens --rewrite-preview created state directory');
+
+    const confirmed = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--compact-output', '--command', 'git status', '--from-file', 'evidence/git-status.txt', '--confirm', '--json', '--root', target], {}, options), 'tokens --compact-output --confirm --json');
+    const compactionFile = confirmed.token_compaction_file;
+    if (!compactionFile || !compactionFile.endsWith('.token-compaction.json')) throw new Error('token metrics smoke setup did not return token compaction file');
+
+    const metricsPreview = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--metrics', '--from-compactions', compactionFile, '--preview', '--json', '--root', target], {}, options), 'tokens --metrics --preview --json');
+    assertJsonMarkers([
+      ['command', metricsPreview.command, 'tokens'],
+      ['mode', metricsPreview.mode, 'token-metrics'],
+      ['token_metrics.stage', metricsPreview.token_metrics?.stage, 'Stage 64'],
+      ['token_metrics.artifact_kind', metricsPreview.token_metrics?.artifact_kind, 'token-metrics'],
+      ['token_metrics.totals.compaction_count', metricsPreview.token_metrics?.totals?.compaction_count, 1],
+      ['token_metrics.deterministic', metricsPreview.token_metrics?.deterministic, true],
+      ['token_metrics.pure_function', metricsPreview.token_metrics?.pure_function, true],
+      ['safety.writes', metricsPreview.safety?.writes, false],
+      ['safety.token_metrics_artifact', metricsPreview.safety?.token_metrics_artifact, false],
+      ['safety.shell_interception', metricsPreview.safety?.shell_interception, false],
+      ['safety.command_execution', metricsPreview.safety?.command_execution, false],
+    ], 'tokens --metrics --preview --json');
+    if (!metricsPreview.token_metrics?.token_metrics_digest) throw new Error('token metrics preview missing digest');
+    if (fs.readdirSync(path.join(absoluteTarget, '.vibecoding-state', 'token-economy')).some((entry) => entry.endsWith('.token-metrics.json'))) throw new Error('tokens --metrics preview wrote token metrics sidecar');
+
+    const metricsConfirmed = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--metrics', '--from-compactions', compactionFile, '--confirm', '--json', '--root', target], {}, options), 'tokens --metrics --confirm --json');
+    const metricsFile = metricsConfirmed.token_metrics_file;
+    if (!metricsFile || !metricsFile.endsWith('.token-metrics.json')) throw new Error('tokens --metrics confirm did not return token metrics sidecar file');
+    const metricsPath = path.join(absoluteTarget, '.vibecoding-state', 'token-economy', metricsFile);
+    if (!fs.existsSync(metricsPath)) throw new Error('tokens --metrics confirm did not write token metrics sidecar');
+    const extraStateEntries = fs.readdirSync(path.join(absoluteTarget, '.vibecoding-state')).filter((entry) => entry !== 'token-economy');
+    if (extraStateEntries.length > 0) throw new Error(`token metrics smoke wrote unexpected state entries: ${extraStateEntries.join(', ')}`);
+
+    const metricsVerified = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--verify', metricsFile, '--json', '--root', target], {}, options), `tokens --verify ${metricsFile} --json`);
+    if (metricsVerified.verification?.ok !== true) throw new Error(`token metrics verify failed for ${metricsFile}`);
+
+    const badMetrics = JSON.parse(fs.readFileSync(metricsPath, 'utf8'));
+    badMetrics.token_metrics.totals.estimated_tokens_saved += 1;
+    fs.writeFileSync(path.join(absoluteTarget, '.vibecoding-state', 'token-economy', 'bad-drift.token-metrics.json'), `${JSON.stringify(badMetrics, null, 2)}\n`, 'utf8');
+    run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--verify', 'bad-drift.token-metrics.json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['token metrics verification failed:', 'token_metrics.totals drift', 'token metrics digest mismatch'],
+    }, options);
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--profile', '--name', 'unsafe', '--json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['unsupported token profile: unsafe'],
+    }, options);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+function runTokenAdviceSmoke(options) {
+  const target = '.tmp/vibe-token-advice';
+  const absoluteTarget = path.join(repoRoot, target);
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+
+    const statusAdvice = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--advice', '--intent', 'status', '--json', '--root', target], {}, options), 'tokens --advice --intent status --json');
+    assertJsonMarkers([
+      ['command', statusAdvice.command, 'tokens'],
+      ['mode', statusAdvice.mode, 'token-saving-advice'],
+      ['token_advice.stage', statusAdvice.token_advice?.stage, 'Stage 79'],
+      ['token_advice.advice_kind', statusAdvice.token_advice?.advice_kind, 'token-saving-advice'],
+      ['token_advice.intent', statusAdvice.token_advice?.intent, 'status'],
+      ['token_advice.recommended_profile', statusAdvice.token_advice?.recommended_profile, 'minimal'],
+      ['token_advice.writes', statusAdvice.token_advice?.writes, false],
+      ['token_advice.state_directory_created', statusAdvice.token_advice?.state_directory_created, false],
+      ['safety.writes', statusAdvice.safety?.writes, false],
+      ['safety.token_advice_artifact', statusAdvice.safety?.token_advice_artifact, false],
+      ['safety.shell_interception', statusAdvice.safety?.shell_interception, false],
+      ['safety.command_execution', statusAdvice.safety?.command_execution, false],
+      ['safety.command_mutation', statusAdvice.safety?.command_mutation, false],
+      ['safety.output_mutation', statusAdvice.safety?.output_mutation, false],
+    ], 'tokens --advice --intent status --json');
+    if (!statusAdvice.token_advice?.catalog_digest) throw new Error('token advice missing catalog digest');
+    if (!statusAdvice.token_advice?.profile_digest) throw new Error('token advice missing profile digest');
+    if (!statusAdvice.token_advice?.advice_digest) throw new Error('token advice missing advice digest');
+    if (!statusAdvice.token_advice?.recommended_compactors?.some((compactor) => compactor.id === 'git-status')) throw new Error('token advice missing git-status compactor');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('tokens --advice created state directory');
+
+    const textAdvice = run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--advice', '--intent', 'verification', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Token Economy', 'Mode: token-saving-advice', 'Intent: verification; Profile: minimal', 'Action: token saving advice was computed read-only'],
+    }, options);
+    if (textAdvice.status !== 0) throw new Error('tokens --advice text output failed');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('tokens --advice text created state directory');
+
+    const commandAdvice = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--advice', '--command', 'git status', '--json', '--root', target], {}, options), 'tokens --advice --command git status --json');
+    assertJsonMarkers([
+      ['token_advice.intent', commandAdvice.token_advice?.intent, 'command'],
+      ['token_advice.command', commandAdvice.token_advice?.command, 'git status'],
+      ['token_advice.recommended_profile', commandAdvice.token_advice?.recommended_profile, 'minimal'],
+      ['token_advice.recommended_rewrites.0.suggested_command', commandAdvice.token_advice?.recommended_rewrites?.[0]?.suggested_command, 'git status --short --branch'],
+      ['token_advice.recommended_rewrites.0.execute', commandAdvice.token_advice?.recommended_rewrites?.[0]?.execute, false],
+      ['token_advice.recommended_rewrites.0.command_mutation', commandAdvice.token_advice?.recommended_rewrites?.[0]?.command_mutation, false],
+    ], 'tokens --advice --command git status --json');
+
+    const unknownAdvice = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--advice', '--intent', 'unknown-kind', '--json', '--root', target], {}, options), 'tokens --advice --intent unknown-kind --json');
+    assertJsonMarkers([
+      ['token_advice.intent', unknownAdvice.token_advice?.intent, 'unknown'],
+      ['token_advice.recommended_profile', unknownAdvice.token_advice?.recommended_profile, 'balanced'],
+    ], 'tokens --advice --intent unknown-kind --json');
+    if (!unknownAdvice.quality?.some((item) => item.includes('unknown token advice intent'))) throw new Error('token advice unknown intent did not report quality marker');
+
+    for (const forbidden of ['--confirm', '--preview', '--write', '--preflight', '--dispatch', '--dispatch-intent', '--run', '--once', '--scan']) {
+      run('node', ['tools/vibe-runtime/index.mjs', 'tokens', '--advice', '--intent', 'status', forbidden, '--root', target], {
+        allowFailure: true,
+        expectOutput: forbidden === '--once' || forbidden === '--scan' || forbidden === '--run' || forbidden === '--write'
+          ? ['tokens supports deterministic compaction, advice']
+          : ['tokens advice is read-only'],
+      }, options);
+    }
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+
+  return {
+    runTokenCompactionSmoke,
+    runTokenMetricsSmoke,
+    runTokenAdviceSmoke,
+  };
+}

package/tools/vibe-release-check/release-check-workflow-entry-suite.mjs

@@ -0,0 +1,195 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  assertJsonMarkers,
+  parseJsonOutput,
+  repoRoot,
+  run,
+} from './release-check-runtime.mjs';
+
+export function runBootstrapAcceptanceSmoke(options) {
+  const target = '.tmp/vibe-bootstrap-acceptance';
+  const absoluteTarget = path.join(repoRoot, target);
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    const acceptance = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'bootstrap', '--acceptance', '--json', '--root', target], {}, options), 'bootstrap --acceptance --json');
+    assertJsonMarkers([
+      ['command', acceptance.command, 'bootstrap'],
+      ['mode', acceptance.mode, 'workflow-bootstrap-acceptance'],
+      ['bootstrap_acceptance.stage', acceptance.bootstrap_acceptance?.stage, 'Stage 90'],
+      ['bootstrap_acceptance.acceptance_kind', acceptance.bootstrap_acceptance?.acceptance_kind, 'workflow-bootstrap-acceptance'],
+      ['bootstrap_acceptance.expected_first_skill', acceptance.bootstrap_acceptance?.expected_first_skill, 'vibe-brainstorming'],
+      ['bootstrap_acceptance.observed_route_summary.first_skill', acceptance.bootstrap_acceptance?.observed_route_summary?.first_skill, 'vibe-brainstorming'],
+      ['bootstrap_acceptance.pass', acceptance.bootstrap_acceptance?.pass, true],
+      ['bootstrap_acceptance.boundary_assertions.bootstrap_acceptance_artifact', acceptance.bootstrap_acceptance?.boundary_assertions?.bootstrap_acceptance_artifact, false],
+      ['bootstrap_acceptance.boundary_assertions.source_write', acceptance.bootstrap_acceptance?.boundary_assertions?.source_write, false],
+      ['safety.stage', acceptance.safety?.stage, 'Stage 90'],
+      ['safety.writes', acceptance.safety?.writes, false],
+    ], 'bootstrap --acceptance --json');
+    if (!acceptance.bootstrap_acceptance?.acceptance_digest) throw new Error('bootstrap acceptance missing acceptance_digest');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('bootstrap acceptance JSON output created unexpected state directory');
+
+    const custom = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'bootstrap', '--acceptance', '--prompt', 'Review-diff-before-merge', '--json', '--root', target], {}, options), 'bootstrap --acceptance custom --json');
+    assertJsonMarkers([
+      ['bootstrap_acceptance.inferred_intent', custom.bootstrap_acceptance?.inferred_intent, 'review'],
+      ['bootstrap_acceptance.pass', custom.bootstrap_acceptance?.pass, true],
+    ], 'bootstrap --acceptance custom --json');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'bootstrap', '--acceptance', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Bootstrap Acceptance', 'Stage: Stage 90; Pass: true', 'Boundary: writes=false; bootstrap_acceptance_artifact=false'],
+    }, options);
+
+    for (const forbidden of ['--confirm', '--write', '--preflight', '--run']) {
+      run('node', ['tools/vibe-runtime/index.mjs', 'bootstrap', '--acceptance', forbidden, '--root', target], {
+        allowFailure: true,
+        expectOutput: ['bootstrap --acceptance is read-only'],
+      }, options);
+    }
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+export function runMethodologyRouteSmoke(options) {
+  const target = '.tmp/vibe-methodology-route';
+  const absoluteTarget = path.join(repoRoot, target);
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+    const route = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--route', '--intent', 'feature', '--json', '--root', target], {}, options), 'methodology --route --intent feature --json');
+    assertJsonMarkers([
+      ['command', route.command, 'methodology'],
+      ['mode', route.mode, 'methodology-route'],
+      ['methodology_route.stage', route.methodology_route?.stage, 'Stage 60'],
+      ['methodology_route.registry_stage', route.methodology_route?.registry_stage, 'Stage 21'],
+      ['methodology_route.registry_kind', route.methodology_route?.registry_kind, 'skill-route-registry-drift-guard'],
+      ['methodology_route.route_registry_id', route.methodology_route?.route_registry_id, 'skill-route:feature'],
+      ['methodology_route.required_skill', route.methodology_route?.required_skill, 'vibe-brainstorming'],
+      ['methodology_route.next_gate', route.methodology_route?.next_gate, 'spec'],
+      ['methodology_route.handoff_required', route.methodology_route?.handoff_required, true],
+      ['methodology_route.route_kind', route.methodology_route?.route_kind, 'workflow-methodology-route'],
+      ['methodology_route.intent', route.methodology_route?.intent, 'feature'],
+      ['methodology_route.first_skill', route.methodology_route?.first_skill, 'vibe-brainstorming'],
+      ['methodology_route.writes', route.methodology_route?.writes, false],
+      ['methodology_route.state_directory_created', route.methodology_route?.state_directory_created, false],
+      ['methodology_route.trigger_discipline.user_rules_priority', route.methodology_route?.trigger_discipline?.user_rules_priority, true],
+      ['methodology_route.trigger_discipline.no_false_skill_claims', route.methodology_route?.trigger_discipline?.no_false_skill_claims, true],
+      ['safety.writes', route.safety?.writes, false],
+      ['safety.skill_execution', route.safety?.skill_execution, false],
+      ['safety.subagent', route.safety?.subagent, false],
+      ['safety.runtime_action', route.safety?.runtime_action, false],
+      ['safety.git', route.safety?.git, false],
+      ['safety.worktree', route.safety?.worktree, false],
+    ], 'methodology --route --intent feature --json');
+    if (!route.methodology_route?.selected_workflow?.includes('vibe-test-driven-development')) throw new Error('methodology route did not include expected workflow sequence');
+    if (!route.methodology_route?.route_digest) throw new Error('methodology route missing route_digest');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('methodology route created unexpected state directory');
+
+    const unknown = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--route', '--intent', 'unknown-kind', '--json', '--root', target], {}, options), 'methodology --route --intent unknown-kind --json');
+    assertJsonMarkers([
+      ['methodology_route.intent', unknown.methodology_route?.intent, 'unknown-kind'],
+      ['methodology_route.route_registry_id', unknown.methodology_route?.route_registry_id, 'skill-route:unknown-fallback'],
+      ['methodology_route.first_skill', unknown.methodology_route?.first_skill, 'using-vibecoding'],
+      ['methodology_route.required_skill', unknown.methodology_route?.required_skill, 'using-vibecoding'],
+      ['methodology_route.state_directory_created', unknown.methodology_route?.state_directory_created, false],
+    ], 'methodology --route --intent unknown-kind --json');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('unknown methodology route created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--route', '--json', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['methodology --route requires --intent <kind>'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--route', '--intent', 'feature', '--confirm', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['methodology route is read-only'],
+    }, options);
+
+    const gate = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'methodology', '--gate', '--kind', 'tdd', '--confirm', '--json', '--root', target], {}, options), 'methodology --gate --kind tdd --confirm --json');
+    const gateFile = gate.methodology_gate_file;
+    if (!gateFile || !gateFile.endsWith('.tdd.methodology-gate.json')) throw new Error('methodology gate confirm did not return a methodology sidecar file');
+    const gatePath = path.join(absoluteTarget, '.vibecoding-state', 'methodology-gates', gateFile);
+    if (!fs.existsSync(gatePath)) throw new Error('methodology gate confirm did not write methodology sidecar');
+    const extraStateEntries = fs.readdirSync(path.join(absoluteTarget, '.vibecoding-state')).filter((entry) => entry !== 'methodology-gates');
+    if (extraStateEntries.length > 0) throw new Error(`methodology gate wrote unexpected state entries: ${extraStateEntries.join(', ')}`);
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}
+
+export function runEntryAdviceSmoke(options) {
+  const target = '.tmp/vibe-entry-advice';
+  const absoluteTarget = path.join(repoRoot, target);
+  fs.rmSync(absoluteTarget, { recursive: true, force: true });
+
+  try {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'entry', '--advice', '--intent', 'feature', '--root', target], {
+      expectOutput: ['Vibecoding Runtime Entry Advice', 'Intent: feature', 'Recommended layer: L2', 'First skill: vibe-brainstorming', 'Advice digest:', 'No state directory'],
+    }, options);
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('entry advice text output created unexpected state directory');
+
+    const advice = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'entry', '--advice', '--intent', 'feature', '--json', '--root', target], {}, options), 'entry --advice --intent feature --json');
+    assertJsonMarkers([
+      ['command', advice.command, 'entry'],
+      ['mode', advice.mode, 'entry-advice'],
+      ['entry_advice.stage', advice.entry_advice?.stage, 'Stage 78'],
+      ['entry_advice.advice_kind', advice.entry_advice?.advice_kind, 'agent-entry-next-step-advice'],
+      ['entry_advice.intent', advice.entry_advice?.intent, 'feature'],
+      ['entry_advice.recommended_layer', advice.entry_advice?.recommended_layer, 'L2'],
+      ['entry_advice.first_skill', advice.entry_advice?.first_skill, 'vibe-brainstorming'],
+      ['entry_advice.writes', advice.entry_advice?.writes, false],
+      ['entry_advice.state_directory_created', advice.entry_advice?.state_directory_created, false],
+      ['entry_advice.no_execution', advice.entry_advice?.no_execution, true],
+      ['safety.writes', advice.safety?.writes, false],
+      ['safety.entry_advice_artifact', advice.safety?.entry_advice_artifact, false],
+      ['safety.skill_execution', advice.safety?.skill_execution, false],
+      ['safety.subagent', advice.safety?.subagent, false],
+      ['safety.runtime_action', advice.safety?.runtime_action, false],
+      ['safety.git', advice.safety?.git, false],
+      ['safety.worktree', advice.safety?.worktree, false],
+    ], 'entry --advice --intent feature --json');
+    if (!advice.entry_advice?.selected_workflow?.includes('vibe-test-driven-development')) throw new Error('entry advice did not include expected workflow sequence');
+    if (!advice.entry_advice?.manual_action) throw new Error('entry advice missing manual_action');
+    if (!advice.entry_advice?.verification_hint) throw new Error('entry advice missing verification_hint');
+    if (!advice.entry_advice?.advice_digest) throw new Error('entry advice missing advice_digest');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('entry advice JSON output created unexpected state directory');
+
+    const unknown = parseJsonOutput(run('node', ['tools/vibe-runtime/index.mjs', 'entry', '--advice', '--intent', 'unknown-kind', '--json', '--root', target], {}, options), 'entry --advice --intent unknown-kind --json');
+    assertJsonMarkers([
+      ['entry_advice.intent', unknown.entry_advice?.intent, 'unknown-kind'],
+      ['entry_advice.first_skill', unknown.entry_advice?.first_skill, 'using-vibecoding'],
+      ['entry_advice.recommended_layer', unknown.entry_advice?.recommended_layer, 'L2'],
+      ['entry_advice.state_directory_created', unknown.entry_advice?.state_directory_created, false],
+    ], 'entry --advice --intent unknown-kind --json');
+    if (!String(unknown.entry_advice?.manual_action || '').includes('Clarify the goal')) throw new Error('entry advice unknown fallback did not ask for clarification');
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('entry advice unknown fallback created unexpected state directory');
+
+    run('node', ['tools/vibe-runtime/index.mjs', 'entry', '--advice', '--intent', 'feature', '--confirm', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['entry advice and contract are read-only'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'entry', '--advice', '--intent', 'feature', '--write', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['entry advice and contract are read-only'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'entry', '--advice', '--intent', 'feature', '--dispatch', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['entry advice and contract are read-only'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'entry', '--advice', '--intent', 'feature', '--preflight', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['entry advice and contract are read-only'],
+    }, options);
+    run('node', ['tools/vibe-runtime/index.mjs', 'entry', '--advice', '--intent', 'feature', '--preview', '--root', target], {
+      allowFailure: true,
+      expectOutput: ['entry advice and contract are read-only'],
+    }, options);
+    if (fs.existsSync(path.join(absoluteTarget, '.vibecoding-state'))) throw new Error('entry advice negative checks created unexpected state directory');
+  } finally {
+    if (!options.keepTmp) fs.rmSync(absoluteTarget, { recursive: true, force: true });
+  }
+}

package/tools/vibe-release-check/release-check-workflow-governance-fixtures.mjs

@@ -0,0 +1,138 @@
+// Contract surface covered by tools/vibe-release-check workflow governance smoke.
+export const workflowPlannerInputText = [
+  'Implement planner route and decomposition for multiple tasks.',
+  'Need workflow selection, conflict groups, and verification coverage.',
+  '- update runtime command surface',
+  '- sync docs and checks',
+  'High risk because this touches routing and trace audit.',
+].join('\n');
+
+export const prReviewIntakeEvidenceText = `${JSON.stringify({
+  pr_url_or_id: 'https://example.invalid/org/repo/pull/58',
+  target_branch: 'main',
+  target_scope: 'runtime-governance',
+  human_submitted: true,
+  existing_pr_search: { status: 'performed_manually', evidence_file: '' },
+  review_status: 'clean',
+  feedback_items: [],
+  ci_status: 'passed',
+  failed_jobs: [],
+  checks: ['node --check', 'runtime-check'],
+  log_excerpt: 'all checks passed',
+}, null, 2)}\n`;
+
+export function plannerRoutePreviewJsonMarkers(routePreview) {
+  return [
+    ['command', routePreview.command, 'planner'],
+    ['mode', routePreview.mode, 'planner-route'],
+    ['planner_route.stage', routePreview.planner_route?.stage, 'Stage 49'],
+    ['planner_route.writes', routePreview.planner_route?.writes, false],
+    ['planner_route.dispatch', routePreview.planner_route?.dispatch, false],
+    ['safety.writes', routePreview.safety?.writes, false],
+  ];
+}
+
+export function plannerRouteConfirmJsonMarkers(routeConfirm) {
+  return [
+    ['command', routeConfirm.command, 'planner'],
+    ['mode', routeConfirm.mode, 'planner-route'],
+    ['planner_route.stage', routeConfirm.planner_route?.stage, 'Stage 49'],
+    ['planner_route.allowed_followup.0', routeConfirm.planner_route?.allowed_followup?.[0], 'planner-decompose-only'],
+    ['planner_route.dispatch', routeConfirm.planner_route?.dispatch, false],
+    ['planner_route.session_create', routeConfirm.planner_route?.session_create, false],
+    ['planner_route.platform_api', routeConfirm.planner_route?.platform_api, false],
+    ['safety.planner_artifact', routeConfirm.safety?.planner_artifact, true],
+  ];
+}
+
+export function plannerPlanConfirmJsonMarkers(planConfirm) {
+  return [
+    ['command', planConfirm.command, 'planner'],
+    ['mode', planConfirm.mode, 'planner-plan'],
+    ['planner_plan.stage', planConfirm.planner_plan?.stage, 'Stage 49'],
+    ['planner_plan.allowed_followup.0', planConfirm.planner_plan?.allowed_followup?.[0], 'planner-briefs-only'],
+    ['planner_plan.allowed_followup.1', planConfirm.planner_plan?.allowed_followup?.[1], `sche${'duler-plan-only'}`],
+    ['planner_plan.dispatch', planConfirm.planner_plan?.dispatch, false],
+    ['safety.planner_artifact', planConfirm.safety?.planner_artifact, true],
+  ];
+}
+
+export function plannerBriefsConfirmJsonMarkers(briefsConfirm) {
+  return [
+    ['command', briefsConfirm.command, 'planner'],
+    ['mode', briefsConfirm.mode, 'planner-briefs'],
+    ['planner_briefs.stage', briefsConfirm.planner_briefs?.stage, 'Stage 49'],
+    ['planner_briefs.allowed_followup.0', briefsConfirm.planner_briefs?.allowed_followup?.[0], 'router-plan-only'],
+    ['planner_briefs.dispatch', briefsConfirm.planner_briefs?.dispatch, false],
+    ['planner_briefs.session_create', briefsConfirm.planner_briefs?.session_create, false],
+    ['safety.planner_artifact', briefsConfirm.safety?.planner_artifact, true],
+  ];
+}
+
+export function plannerVerifyJsonMarkers(plannerVerify) {
+  return [
+    ['mode', plannerVerify.mode, 'planner-artifact-verify'],
+    ['verification.ok', plannerVerify.verification?.ok, true],
+  ];
+}
+
+export function prReadinessPreviewJsonMarkers(preview) {
+  return [
+    ['command', preview.command, 'governance'],
+    ['mode', preview.mode, 'governance-pr-readiness'],
+    ['pr_readiness.stage', preview.pr_readiness?.stage, 'Stage 57'],
+    ['pr_readiness.artifact_kind', preview.pr_readiness?.artifact_kind, 'pr-readiness-governance'],
+    ['pr_readiness.optional', preview.pr_readiness?.optional, true],
+    ['pr_readiness.sidecar_only', preview.pr_readiness?.sidecar_only, true],
+    ['pr_readiness.default_enabled', preview.pr_readiness?.default_enabled, false],
+    ['pr_readiness.release_chain_required', preview.pr_readiness?.release_chain_required, false],
+    ['pr_readiness.actions_not_taken.created_pr', preview.pr_readiness?.actions_not_taken?.created_pr, false],
+    ['pr_readiness.actions_not_taken.pushed', preview.pr_readiness?.actions_not_taken?.pushed, false],
+    ['pr_readiness.actions_not_taken.merged', preview.pr_readiness?.actions_not_taken?.merged, false],
+    ['pr_readiness.existing_pr_search.status', preview.pr_readiness?.existing_pr_search?.status, 'not_performed_offline_boundary'],
+    ['safety.writes', preview.safety?.writes, false],
+    ['safety.pr', preview.safety?.pr, false],
+    ['safety.push', preview.safety?.push, false],
+    ['safety.merge', preview.safety?.merge, false],
+    ['safety.platform_api', preview.safety?.platform_api, false],
+    ['safety.external_network', preview.safety?.external_network, false],
+    ['safety.git', preview.safety?.git, false],
+    ['safety.worktree', preview.safety?.worktree, false],
+  ];
+}
+
+export function prReadinessVerifyJsonMarkers(verified) {
+  return [
+    ['summary.kind', verified.summary?.kind, 'pr-readiness-governance'],
+    ['verification.ok', verified.verification?.ok, true],
+  ];
+}
+
+export function prReviewIntakePreviewJsonMarkers(preview) {
+  return [
+    ['command', preview.command, 'governance'],
+    ['mode', preview.mode, 'governance-pr-review-intake'],
+    ['pr_review_intake.stage', preview.pr_review_intake?.stage, 'Stage 58'],
+    ['pr_review_intake.artifact_kind', preview.pr_review_intake?.artifact_kind, 'pr-review-intake-governance'],
+    ['pr_review_intake.optional', preview.pr_review_intake?.optional, true],
+    ['pr_review_intake.sidecar_only', preview.pr_review_intake?.sidecar_only, true],
+    ['pr_review_intake.default_enabled', preview.pr_review_intake?.default_enabled, false],
+    ['pr_review_intake.release_chain_required', preview.pr_review_intake?.release_chain_required, false],
+    ['pr_review_intake.input_evidence_file', preview.pr_review_intake?.input_evidence_file, 'evidence/pr-review-ci.json'],
+    ['pr_review_intake.status', preview.pr_review_intake?.status, 'evidence_recorded'],
+    ['pr_review_intake.review_evidence.review_status', preview.pr_review_intake?.review_evidence?.review_status, 'clean'],
+    ['pr_review_intake.ci_evidence.ci_status', preview.pr_review_intake?.ci_evidence?.ci_status, 'passed'],
+    ['safety.writes', preview.safety?.writes, false],
+    ['safety.platform_api', preview.safety?.platform_api, false],
+    ['safety.external_network', preview.safety?.external_network, false],
+    ['safety.git', preview.safety?.git, false],
+    ['safety.worktree', preview.safety?.worktree, false],
+  ];
+}
+
+export function prReviewIntakeVerifyJsonMarkers(verified) {
+  return [
+    ['summary.kind', verified.summary?.kind, 'pr-review-intake-governance'],
+    ['verification.ok', verified.verification?.ok, true],
+  ];
+}