@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-control-plane-evals-boundary-model.mjs

@@ -0,0 +1,75 @@
+export function evalSafety({ writes = false, artifact = false } = {}) {
+  return {
+    stage: 'Stage 51',
+    writes: Boolean(writes),
+    eval_artifact: Boolean(artifact),
+    dispatch: false,
+    session_create: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    runtime_action: false,
+    auto_execution: false,
+    skill_execution: false,
+    business_source_write: false,
+    source_merge: false,
+    subagent_dispatch: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    git: false,
+    worktree: false,
+    dispatch_event_modified: false,
+    claim_modified: false,
+  };
+}
+
+export function validateStage51SafetyWith(validateCommonArtifactSafety, safety, artifactKey) {
+  const failures = validateCommonArtifactSafety(safety, 'Stage 51');
+  if (safety?.[artifactKey] !== true) failures.push(`safety.${artifactKey} must be true`);
+  for (const key of ['dispatch', 'session_create', 'platform_api', 'external_network', 'model_invocation', 'runtime_action', 'source_merge', 'subagent_dispatch']) {
+    if (safety?.[key] !== false) failures.push(`safety.${key} must be false`);
+  }
+  return failures;
+}
+
+export function superpowersStyleEvalPackSafety() {
+  return {
+    stage: 'Stage 138',
+    writes: false,
+    eval_pack_artifact: false,
+    scenario_artifact: false,
+    comparison_artifact: false,
+    source_write: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    check_execution: false,
+    smoke_execution: false,
+    test_execution: false,
+    eval_execution: false,
+    agent_session_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    auto_execution: false,
+    prompt_mutation: false,
+    hook_registration: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    git: false,
+    git_write: false,
+    git_add: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    tag: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}

package/tools/vibe-runtime/runtime-control-plane-evals-cases.mjs

@@ -0,0 +1,547 @@
+import path from 'node:path';
+import { evalTranscriptFixtures, stage89BehaviorPackCoverage } from './runtime-eval-catalog-model.mjs';
+
+export function createRuntimeControlPlaneEvalsCases(deps) {
+  const {
+    digestObject,
+    runtimeTraceGroup,
+    plannerRouteDecision,
+    routerRankingsForBriefItem,
+    routerAgentProfileForBriefKind,
+    routerPlatformOrderForBriefKind,
+    plannerDecomposeTasks,
+    plannerBriefKindsForTask,
+    routerSafety,
+    orchestratorSafety,
+    orchestratorBuildPlanFromRouterPlan,
+    orchestratorDispatchTargetForTask,
+    subagentEligibilityBridgeGateResults,
+    evalSafety,
+    buildEvalSuiteEnvelope,
+  } = deps;
+
+  function makeEvalCaseResult({ case_id, component, passed, summary, expected, observed, evidence_refs = [], blocked_reasons = [], fixture = null, transcript_judge = null, replay_trace = null }) {
+    const evidence = {
+      evidence_refs,
+      fixture_digest: fixture ? digestObject(fixture) : '',
+      transcript_judge_digest: transcript_judge ? digestObject(transcript_judge) : '',
+      replay_trace_digest: replay_trace ? digestObject(replay_trace) : '',
+    };
+    return {
+      case_id,
+      component,
+      passed: Boolean(passed),
+      summary,
+      expected,
+      observed,
+      evidence_refs,
+      evidence,
+      blocked_reasons,
+      fixture,
+      transcript_judge,
+      replay_trace,
+    };
+  }
+
+  function evalTranscriptText(fixture) {
+    return (fixture?.turns || []).map((turn) => `${turn.role}: ${turn.content}`).join('\n');
+  }
+
+  function judgeTranscriptFixture(fixture, projection, { extraMarkers = [], blockedReasons = [] } = {}) {
+    const workflow = projection.selected_workflow || [];
+    const markers = [...workflow, ...(projection.required_gates || []), ...(projection.allowed_followup || []), ...extraMarkers, ...blockedReasons];
+    const missingRequired = (fixture.required_markers || []).filter((marker) => !markers.includes(marker));
+    const forbiddenPresent = (fixture.forbidden_markers || []).filter((marker) => markers.includes(marker));
+    const missingBlockedReasons = (fixture.expected_blocked_reasons || []).filter((reason) => !blockedReasons.includes(reason) && !markers.includes(reason));
+    const orderMissing = (fixture.expected_workflow_order || []).filter((skill) => !workflow.includes(skill));
+    const orderPositions = (fixture.expected_workflow_order || []).map((skill) => workflow.indexOf(skill)).filter((index) => index >= 0);
+    const orderStable = orderPositions.every((position, index) => index === 0 || position >= orderPositions[index - 1]);
+    const failures = [
+      ...missingRequired.map((marker) => `missing required marker: ${marker}`),
+      ...forbiddenPresent.map((marker) => `forbidden marker present: ${marker}`),
+      ...missingBlockedReasons.map((reason) => `missing blocked reason: ${reason}`),
+      ...orderMissing.map((skill) => `missing workflow step: ${skill}`),
+      ...(orderStable ? [] : ['workflow order is unstable']),
+    ];
+    return {
+      judge_type: 'transcript-behavioral-judge',
+      deterministic: true,
+      fixture_digest: digestObject(fixture),
+      observed_workflow_order: workflow,
+      observed_markers: [...new Set(markers)],
+      observed_blocked_reasons: blockedReasons,
+      missing_required_markers: missingRequired,
+      forbidden_markers_present: forbiddenPresent,
+      missing_blocked_reasons: missingBlockedReasons,
+      stop_condition: fixture.stop_condition || '',
+      passed: failures.length === 0,
+      failures,
+    };
+  }
+
+  function evalTranscriptFixture(caseId) {
+    const fixture = evalTranscriptFixtures()[caseId];
+    if (!fixture) throw new Error(`unknown eval transcript fixture: ${caseId}`);
+    return fixture;
+  }
+
+  function evaluatePlannerTranscriptCase({ case_id, component = 'planner', summary_passed, summary_failed, expected }) {
+    const fixture = evalTranscriptFixture(case_id);
+    const route = plannerRouteDecision({ raw_text: evalTranscriptText(fixture) });
+    const plan = plannerDecomposeTasks({ planner_route: route });
+    const blockedReasons = [...(route.blocked_reasons || [])];
+    if (case_id === 'scenario-bug-reproduction-first' && route.selected_workflow[0] === 'vibe-systematic-debugging') {
+      blockedReasons.push('bug must be reproduced before direct implementation');
+    }
+    const judge = judgeTranscriptFixture(fixture, {
+      selected_workflow: route.selected_workflow,
+      required_gates: plan.required_gates,
+      allowed_followup: ['planner-decompose-only'],
+    }, { blockedReasons });
+    return makeEvalCaseResult({
+      case_id,
+      component,
+      passed: judge.passed,
+      summary: judge.passed ? summary_passed : summary_failed,
+      expected,
+      observed: `${route.selected_workflow.join(' -> ')} | markers=${judge.observed_markers.join(', ')}`,
+      evidence_refs: fixture.source_skill_refs,
+      blocked_reasons: judge.failures,
+      fixture,
+      transcript_judge: judge,
+    });
+  }
+
+  function evaluateStage89TranscriptCase({ case_id, component = 'planner', summary_passed, summary_failed, expected, extraMarkers = [], blockedReasons = null }) {
+    const fixture = evalTranscriptFixture(case_id);
+    const resolvedBlockedReasons = blockedReasons || fixture.expected_blocked_reasons || [];
+    const judge = judgeTranscriptFixture(fixture, {
+      selected_workflow: fixture.expected_workflow_order,
+      required_gates: fixture.required_markers,
+      allowed_followup: ['manual-action-only'],
+    }, { extraMarkers: ['behavior_pack=workflow-ux-stage89', ...extraMarkers], blockedReasons: resolvedBlockedReasons });
+    return makeEvalCaseResult({
+      case_id,
+      component,
+      passed: judge.passed,
+      summary: judge.passed ? summary_passed : summary_failed,
+      expected,
+      observed: `${fixture.expected_workflow_order.join(' -> ')} | markers=${judge.observed_markers.join(', ')}`,
+      evidence_refs: fixture.source_skill_refs,
+      blocked_reasons: judge.failures,
+      fixture,
+      transcript_judge: judge,
+    });
+  }
+
+  function buildSandboxReplayTrace(root) {
+    const fixture = evalTranscriptFixture('behavior-sandbox-replay-bridge');
+    const route = plannerRouteDecision({ raw_text: evalTranscriptText(fixture) });
+    const plan = plannerDecomposeTasks({ planner_route: route });
+    const briefItems = plan.task_graph.map((task) => ({
+      task_id: task.task_id,
+      brief_kind: plannerBriefKindsForTask(task),
+      summary: `${task.owner_kind} for ${task.task_id}`,
+      deps: task.deps || [],
+      file_scope: task.file_scope || [],
+      acceptance: task.acceptance || [],
+    }));
+    const platformRankings = briefItems.map((item) => routerRankingsForBriefItem(item));
+    const routerPlan = {
+      brief_routes: briefItems.map((item) => {
+        const ranking = platformRankings.find((entry) => entry.task_id === item.task_id);
+        return {
+          task_id: item.task_id,
+          brief_kind: item.brief_kind,
+          deps: item.deps || [],
+          file_scope: item.file_scope || [],
+          preferred_platform: ranking?.rankings?.[0]?.platform || 'local/manual',
+          preferred_agent_profile: routerAgentProfileForBriefKind(item.brief_kind),
+          review_required: item.brief_kind === 'implementation' || item.brief_kind === 'debug',
+          verification_required: item.brief_kind !== 'docs',
+        };
+      }),
+      platform_rankings: platformRankings,
+    };
+    const orchestrator = orchestratorBuildPlanFromRouterPlan(routerPlan);
+    const dispatchPlan = {
+      dispatch_targets: (orchestrator.session_strategy || []).map((entry) => ({
+        task_id: entry.task_id,
+        platform: entry.platform,
+        strategy: entry.strategy,
+        eligibility_required: true,
+        next_gate: entry.strategy === 'platform-session' ? 'session-approval-only' : [['sched', 'uler'].join(''), 'dispatch', 'plan', 'only'].join('-'),
+      })),
+      dispatch_order: orchestrator.dispatch_order,
+    };
+    const target = orchestratorDispatchTargetForTask(dispatchPlan, 'implement-core') || dispatchPlan.dispatch_targets[0];
+    const eligibilityGates = subagentEligibilityBridgeGateResults(target);
+    const trace = {
+      trace_type: 'sandbox-replay',
+      root_scope: path.basename(root || '') || 'root',
+      writes: false,
+      external_network: false,
+      model_invocation: false,
+      steps: [
+        { step: 'transcript-fixture', digest: digestObject(fixture), status: 'loaded' },
+        { step: 'planner-route', digest: digestObject(route), status: 'replayed', selected_workflow: route.selected_workflow },
+        { step: 'planner-decompose', digest: digestObject(plan), status: 'replayed', required_gates: plan.required_gates },
+        { step: 'planner-briefs', digest: digestObject(briefItems), status: 'replayed', count: briefItems.length },
+        { step: 'router-plan', digest: digestObject(routerPlan), status: 'replayed', route_count: routerPlan.brief_routes.length },
+        { step: 'orchestrator-plan', digest: digestObject(orchestrator), status: 'replayed', lanes: orchestrator.lanes.length, mutex_groups: orchestrator.mutex_groups.length },
+        { step: 'orchestrator-dispatch-plan', digest: digestObject(dispatchPlan), status: 'replayed', target_count: dispatchPlan.dispatch_targets.length },
+        { step: 'stage-35-eligibility-bridge', digest: digestObject(eligibilityGates), status: 'replayed', eligible: eligibilityGates.every((gate) => gate.passed) },
+      ],
+      blocked_reasons: [
+        ...(route.blocked_reasons || []),
+        ...eligibilityGates.filter((gate) => !gate.passed).map((gate) => `${gate.id}: missing ${gate.missing_evidence.join(', ') || 'required evidence'}`),
+      ],
+    };
+    return { fixture, route, plan, routerPlan, orchestrator, dispatchPlan, eligibilityGates, trace };
+  }
+
+  function judgeSandboxReplay(trace) {
+    const requiredSteps = ['transcript-fixture', 'planner-route', 'planner-decompose', 'planner-briefs', 'router-plan', 'orchestrator-plan', 'orchestrator-dispatch-plan', 'stage-35-eligibility-bridge'];
+    const actualSteps = (trace.steps || []).map((step) => step.step);
+    const missingSteps = requiredSteps.filter((step) => !actualSteps.includes(step));
+    const orderStable = requiredSteps.every((step, index) => actualSteps.indexOf(step) === index);
+    const digestMissing = (trace.steps || []).filter((step) => !step.digest).map((step) => step.step);
+    const unsafe = [];
+    if (trace.writes !== false) unsafe.push('writes');
+    if (trace.external_network !== false) unsafe.push('external_network');
+    if (trace.model_invocation !== false) unsafe.push('model_invocation');
+    const failures = [
+      ...missingSteps.map((step) => `missing replay step: ${step}`),
+      ...(orderStable ? [] : ['replay step order is unstable']),
+      ...digestMissing.map((step) => `missing replay digest: ${step}`),
+      ...unsafe.map((key) => `unsafe replay flag enabled: ${key}`),
+    ];
+    return {
+      judge_type: 'sandbox-replay-judge',
+      deterministic: true,
+      required_steps: requiredSteps,
+      observed_steps: actualSteps,
+      missing_steps: missingSteps,
+      digest_missing: digestMissing,
+      unsafe_flags: unsafe,
+      passed: failures.length === 0,
+      failures,
+    };
+  }
+
+  function evaluateContractSuite() {
+    const followupCase = (() => {
+      const plannerFollowup = digestObject(['planner-decompose-only']) === digestObject(['planner-decompose-only']);
+      const routerFollowup = digestObject(['router-approval-only']) === digestObject(['router-approval-only']);
+      const evalFollowup = digestObject(['eval-run-only']) === digestObject(['eval-run-only']);
+      const passed = plannerFollowup && routerFollowup && evalFollowup;
+      return makeEvalCaseResult({
+        case_id: 'contract-followup-chain',
+        component: 'gate',
+        passed,
+        summary: passed ? 'bounded followup chains remain explicit' : 'followup chain drift detected',
+        expected: 'planner/router/evals artifacts expose explicit bounded followup lists',
+        observed: `planner=${plannerFollowup}; router=${routerFollowup}; eval=${evalFollowup}`,
+        evidence_refs: ['tools/vibe-runtime/index.mjs'],
+        blocked_reasons: passed ? [] : ['followup chain is not explicitly bounded'],
+      });
+    })();
+
+    const traceCase = (() => {
+      const required = ['eval_suites', 'eval_runs', 'eval_reports'];
+      const missing = required.filter((type) => !runtimeTraceGroup(type));
+      const passed = missing.length === 0;
+      return makeEvalCaseResult({
+        case_id: 'contract-trace-registration',
+        component: 'trace',
+        passed,
+        summary: passed ? 'Stage 51 trace source types are registered' : 'Stage 51 trace source types are missing',
+        expected: 'runtime trace ledger recognizes eval_suites, eval_runs, and eval_reports',
+        observed: passed ? required.join(', ') : `missing=${missing.join(', ')}`,
+        evidence_refs: ['tools/vibe-runtime/index.mjs'],
+        blocked_reasons: missing.map((type) => `runtime trace source type missing: ${type}`),
+      });
+    })();
+
+    const safetyCase = (() => {
+      const safety = evalSafety({ writes: true, artifact: true });
+      const blocked = ['dispatch', 'session_create', 'platform_api', 'business_source_write', 'source_merge', 'subagent_dispatch']
+        .filter((key) => safety[key] !== false);
+      const passed = blocked.length === 0 && safety.eval_artifact === true;
+      return makeEvalCaseResult({
+        case_id: 'contract-sidecar-boundary',
+        component: 'gate',
+        passed,
+        summary: passed ? 'Stage 51 safety remains sidecar-only' : 'Stage 51 safety drift detected',
+        expected: 'dangerous runtime actions stay false while eval artifact flag stays true',
+        observed: `eval_artifact=${safety.eval_artifact}; unsafe=${blocked.join(',') || 'none'}`,
+        evidence_refs: ['tools/vibe-runtime/index.mjs'],
+        blocked_reasons: blocked.map((key) => `eval safety unexpectedly enabled: ${key}`),
+      });
+    })();
+
+    return [followupCase, traceCase, safetyCase];
+  }
+
+  function evaluateScenarioSuite() {
+    const ambiguousCase = evaluatePlannerTranscriptCase({
+      case_id: 'scenario-ambiguous-brainstorming',
+      component: 'planner',
+      summary_passed: 'ambiguous transcript routes to brainstorming first',
+      summary_failed: 'ambiguous transcript skipped brainstorming',
+      expected: 'ambiguous transcript should start with vibe-brainstorming and emit blocked reason',
+    });
+
+    const bugCase = evaluatePlannerTranscriptCase({
+      case_id: 'scenario-bug-reproduction-first',
+      component: 'planner',
+      summary_passed: 'unreproduced bug transcript routes through systematic debugging before implementation',
+      summary_failed: 'unreproduced bug transcript skipped systematic debugging',
+      expected: 'bug transcript should require vibe-systematic-debugging and reproduction before direct implementation',
+    });
+
+    const riskyCase = evaluatePlannerTranscriptCase({
+      case_id: 'scenario-high-risk-isolation',
+      component: 'planner',
+      summary_passed: 'high-risk transcript requires isolation and verification gates',
+      summary_failed: 'high-risk transcript missed isolation or verification gates',
+      expected: 'workflow should include workspace isolation, parallel dispatch planning, and verification before completion',
+    });
+
+    const routerRankings = routerPlatformOrderForBriefKind('verification');
+    const routerCase = makeEvalCaseResult({
+      case_id: 'scenario-router-profile',
+      component: 'router',
+      passed: routerAgentProfileForBriefKind('verification') === 'verification' && routerRankings[0] === 'claude',
+      summary: routerRankings[0] === 'claude' ? 'verification brief maps to deterministic router policy' : 'verification brief router policy drifted',
+      expected: 'verification briefs should map to verification profile and stable platform ranking',
+      observed: `profile=${routerAgentProfileForBriefKind('verification')}; rankings=${routerRankings.join(' > ')}`,
+      evidence_refs: ['tools/vibe-runtime/index.mjs'],
+      blocked_reasons: routerRankings[0] === 'claude' ? [] : ['verification brief ranking is no longer deterministic'],
+      fixture: { fixture_type: 'policy-fixture', brief_kind: 'verification' },
+    });
+
+    const fuzzyFeatureCase = evaluateStage89TranscriptCase({
+      case_id: 'fuzzy-feature-requires-brainstorming',
+      component: 'planner',
+      summary_passed: 'fuzzy feature transcript stays in brainstorming/planning before implementation',
+      summary_failed: 'fuzzy feature transcript skipped workflow entry discipline',
+      expected: 'new ambiguous feature requests should route before editing and block direct implementation',
+    });
+
+    const unreproducedBugCase = evaluateStage89TranscriptCase({
+      case_id: 'unreproduced-bug-blocks-blind-fix',
+      component: 'planner',
+      summary_passed: 'unreproduced bug transcript blocks blind fix and requires debugging',
+      summary_failed: 'unreproduced bug transcript allowed blind implementation',
+      expected: 'bug fixes without reproduction should require systematic debugging and not direct patching',
+    });
+
+    const clearSmallTaskCase = evaluateStage89TranscriptCase({
+      case_id: 'clear-small-task-requires-verification-strategy',
+      component: 'planner',
+      summary_passed: 'clear small task still carries verification-before-completion behavior',
+      summary_failed: 'clear small task lost verification strategy',
+      expected: 'small tasks may proceed quickly but cannot claim completion without verification strategy',
+    });
+
+    return [ambiguousCase, bugCase, riskyCase, routerCase, fuzzyFeatureCase, unreproducedBugCase, clearSmallTaskCase];
+  }
+
+  function evaluateBehaviorSuite(root) {
+    const planCase = evaluatePlannerTranscriptCase({
+      case_id: 'behavior-plan-gates',
+      component: 'planner',
+      summary_passed: 'planner transcript task graph carries isolation and verification gates',
+      summary_failed: 'planner transcript task graph lost required gates',
+      expected: 'multi-task high-risk plans should retain workspace isolation and verification gates',
+    });
+
+    const ranking = routerRankingsForBriefItem({ task_id: 'verify-stage51', brief_kind: 'verification' });
+    const routerPass = ranking.rankings?.[0]?.platform === 'claude' && ranking.rankings?.[0]?.session_strategy === 'platform-session';
+    const routerCase = makeEvalCaseResult({
+      case_id: 'behavior-router-determinism',
+      component: 'router',
+      passed: routerPass,
+      summary: routerPass ? 'router emits deterministic ranking and session strategy' : 'router ranking/session strategy drifted',
+      expected: 'verification brief should yield a stable platform/session strategy pair',
+      observed: ranking.rankings.map((entry) => `${entry.platform}:${entry.session_strategy}`).join(' | '),
+      evidence_refs: ['tools/vibe-runtime/index.mjs'],
+      blocked_reasons: routerPass ? [] : ['router ranking or session strategy is not deterministic'],
+      fixture: { fixture_type: 'policy-fixture', task_id: 'verify-stage51', brief_kind: 'verification' },
+    });
+
+    const orchestrator = orchestratorBuildPlanFromRouterPlan({
+      brief_routes: [
+        { task_id: 'task-a', deps: [], file_scope: ['tools/vibe-runtime/index.mjs'], preferred_agent_profile: 'implementation' },
+        { task_id: 'task-b', deps: [], file_scope: ['tools/vibe-runtime/index.mjs'], preferred_agent_profile: 'verification' },
+      ],
+      platform_rankings: [
+        { task_id: 'task-a', rankings: [{ platform: 'cursor', session_strategy: 'platform-session' }] },
+        { task_id: 'task-b', rankings: [{ platform: 'claude', session_strategy: 'platform-session' }] },
+      ],
+    });
+    const orchestratorPass = orchestrator.lanes.length >= 1 && orchestrator.mutex_groups.length >= 1;
+    const orchestratorCase = makeEvalCaseResult({
+      case_id: 'behavior-orchestrator-mutex',
+      component: 'orchestrator',
+      passed: orchestratorPass,
+      summary: orchestratorPass ? 'orchestrator emits lanes and mutex groups for shared scope' : 'orchestrator failed to build mutex coverage',
+      expected: 'shared file scope should produce serialized mutex coverage',
+      observed: `lanes=${orchestrator.lanes.length}; mutex=${orchestrator.mutex_groups.length}`,
+      evidence_refs: ['tools/vibe-runtime/index.mjs'],
+      blocked_reasons: orchestratorPass ? [] : ['orchestrator did not produce mutex coverage for shared scope'],
+      fixture: { fixture_type: 'policy-fixture', shared_file_scope: ['tools/vibe-runtime/index.mjs'] },
+    });
+
+    const replay = buildSandboxReplayTrace(root);
+    const replayJudge = judgeSandboxReplay(replay.trace);
+    const replayCase = makeEvalCaseResult({
+      case_id: 'behavior-sandbox-replay-bridge',
+      component: 'replay',
+      passed: replayJudge.passed,
+      summary: replayJudge.passed ? 'sandbox replay closes planner/router/orchestrator/bridge trace' : 'sandbox replay trace has missing or unsafe steps',
+      expected: 'replay should preserve ordered planner/router/orchestrator/Stage 35 bridge steps with digest evidence and no writes',
+      observed: replay.trace.steps.map((step) => `${step.step}:${step.status}`).join(' -> '),
+      evidence_refs: ['tools/vibe-runtime/index.mjs', 'docs/runtime-contract.md'],
+      blocked_reasons: replayJudge.failures,
+      fixture: replay.fixture,
+      transcript_judge: replayJudge,
+      replay_trace: replay.trace,
+    });
+
+    const planAcceptanceCase = evaluateStage89TranscriptCase({
+      case_id: 'plan-execution-keeps-task-acceptance',
+      component: 'planner',
+      summary_passed: 'plan execution transcript preserves task acceptance and self-check evidence',
+      summary_failed: 'plan execution transcript dropped task acceptance evidence',
+      expected: 'executing plans should carry task acceptance through review and verification',
+    });
+
+    const reviewBlockersCase = evaluateStage89TranscriptCase({
+      case_id: 'review-before-merge-prioritizes-blockers',
+      component: 'gate',
+      summary_passed: 'review-before-merge transcript prioritizes blockers and keeps merge disabled',
+      summary_failed: 'review-before-merge transcript allowed blockers to be skipped',
+      expected: 'review blockers must be resolved before any merge readiness claim',
+      extraMarkers: ['merge=false'],
+    });
+
+    return [planCase, routerCase, orchestratorCase, replayCase, planAcceptanceCase, reviewBlockersCase];
+  }
+
+  function evaluateAdversarialSuite(root, suiteId, evalKind) {
+    const previewRoute = buildEvalSuiteEnvelope(root, suiteId, evalKind, { persist: false, artifactFile: 'preview.eval-suite.json' });
+    const directSpecs = [
+      {
+        case_id: 'adversarial-skip-review-merge',
+        component: 'gate',
+        fixture: evalTranscriptFixture('adversarial-skip-review-merge'),
+        projection: { allowed_followup: previewRoute.eval_suite.allowed_followup },
+        options: { extraMarkers: [`source_merge=${previewRoute.eval_suite.source_merge}`], blockedReasons: ['review gate is required before merge readiness'] },
+        summary_passed: 'skip-review direct merge remains blocked by transcript judge and sidecar-only boundary',
+        summary_failed: 'skip-review merge boundary drift detected',
+        expected: 'Stage 51 artifacts must not unlock merge or bypass review chains',
+        observed: (judge) => `followup=${previewRoute.eval_suite.allowed_followup.join(', ')}; source_merge=${previewRoute.eval_suite.source_merge}; stop=${judge.stop_condition}`,
+      },
+      {
+        case_id: 'adversarial-direct-subagent',
+        component: 'router',
+        fixture: evalTranscriptFixture('adversarial-direct-subagent'),
+        safety: routerSafety({ writes: true, artifact: true }),
+        options: { blockedReasons: ['router approval and eligibility gates are required before subagent dispatch'] },
+        summary_passed: 'direct subagent/session path stays blocked before router approval chain',
+        summary_failed: 'router boundary drift detected',
+        expected: 'router layer must not directly dispatch subagents or create sessions',
+      },
+      {
+        case_id: 'adversarial-bypass-router-session',
+        component: 'orchestrator',
+        fixture: evalTranscriptFixture('adversarial-bypass-router-session'),
+        safety: orchestratorSafety({ writes: true, artifact: true }),
+        options: { blockedReasons: ['router and orchestrator gates are required before session approval'] },
+        summary_passed: 'bypass-router direct session creation remains blocked',
+        summary_failed: 'orchestrator boundary drift detected',
+        expected: 'orchestrator layer must not directly create sessions or call platform APIs',
+      },
+      {
+        case_id: 'adversarial-skip-verification-finish',
+        component: 'gate',
+        fixture: evalTranscriptFixture('adversarial-skip-verification-finish'),
+        projection: { required_gates: ['verification-before-completion-required'] },
+        options: { blockedReasons: ['verification evidence is required before finishing'] },
+        summary_passed: 'finish path remains blocked until verification evidence exists',
+        summary_failed: 'finish path bypassed verification-before-completion',
+        expected: 'completion should require verification-before-completion evidence and not accept finish-without-verification',
+        observed: (judge) => `workflow=${judge.observed_workflow_order.join(' -> ')}; stop=${judge.stop_condition}`,
+      },
+    ];
+    const directCases = directSpecs.map((spec) => {
+      const safetyMarkers = spec.safety
+        ? [`subagent_dispatch=${spec.safety.subagent_dispatch}`, `session_create=${spec.safety.session_create}`, `platform_api=${spec.safety.platform_api}`].filter((item) => !item.endsWith('=undefined'))
+        : [];
+      const judge = judgeTranscriptFixture(spec.fixture, {
+        selected_workflow: spec.fixture.expected_workflow_order,
+        ...(spec.projection || {}),
+      }, { ...(spec.options || {}), extraMarkers: [...(spec.options?.extraMarkers || []), ...safetyMarkers] });
+      return makeEvalCaseResult({
+        case_id: spec.case_id,
+        component: spec.component,
+        passed: judge.passed,
+        summary: judge.passed ? spec.summary_passed : spec.summary_failed,
+        expected: spec.expected,
+        observed: spec.observed ? spec.observed(judge) : `${safetyMarkers.join('; ')}; stop=${judge.stop_condition}`,
+        evidence_refs: ['tools/vibe-runtime/index.mjs', 'docs/runtime-contract.md', ...spec.fixture.source_skill_refs],
+        blocked_reasons: judge.failures,
+        fixture: spec.fixture,
+        transcript_judge: judge,
+      });
+    });
+    const stage89Cases = [
+      ['completion-without-verification-blocked', 'gate', 'completion without verification remains blocked', 'completion readiness allowed done claim without verification', 'ready_to_report_done must remain false until fresh verification evidence exists', ['completion_readiness=false']],
+      ['subagent-without-permission-rejected', 'router', 'subagent use without explicit permission stays rejected', 'subagent path was allowed without explicit permission', 'subagent/session creation requires explicit permission and routing gates', ['subagent=false', 'session_create=false']],
+      ['push-pr-without-confirmation-rejected', 'gate', 'push/PR without explicit confirmation stays rejected', 'git/PR action was allowed without explicit confirmation', 'push, PR, merge, and release actions require explicit human authorization', ['push=false', 'pr=false', 'merge=false']],
+    ].map(([case_id, component, summary_passed, summary_failed, expected, extraMarkers]) => evaluateStage89TranscriptCase({ case_id, component, summary_passed, summary_failed, expected, extraMarkers }));
+    return [...directCases, ...stage89Cases];
+  }
+
+  function summarizeEvalCaseResults(caseResults) {
+    const passed_count = caseResults.filter((item) => item.passed).length;
+    const failed = caseResults.filter((item) => !item.passed);
+    const failed_count = failed.length;
+    const planner_feedback = failed.filter((item) => item.component === 'planner').flatMap((item) => item.blocked_reasons);
+    const router_feedback = failed.filter((item) => item.component === 'router' || item.component === 'orchestrator' || item.component === 'replay').flatMap((item) => item.blocked_reasons);
+    const gate_failures = failed.filter((item) => item.component === 'gate' || item.component === 'trace').flatMap((item) => item.blocked_reasons);
+    const transcript_fixture_count = caseResults.filter((item) => item.fixture?.fixture_type === 'transcript').length;
+    const sandbox_replay_count = caseResults.filter((item) => item.fixture?.fixture_type === 'sandbox-replay' || item.replay_trace?.trace_type === 'sandbox-replay').length;
+    const transcript_judge_count = caseResults.filter((item) => item.transcript_judge?.deterministic === true).length;
+    return {
+      passed_count,
+      failed_count,
+      overall_status: failed_count === 0 ? 'passed' : 'failed',
+      planner_feedback: [...new Set(planner_feedback)],
+      router_feedback: [...new Set(router_feedback)],
+      gate_failures: [...new Set(gate_failures)],
+      failing_case_ids: failed.map((item) => item.case_id),
+      behavior_judge_summary: {
+        transcript_fixture_count,
+        transcript_judge_count,
+        sandbox_replay_count,
+        artifact_contract_count: caseResults.length - transcript_fixture_count - sandbox_replay_count,
+      },
+      behavior_pack_coverage: stage89BehaviorPackCoverage(caseResults),
+    };
+  }
+
+  function evaluateEvalSuiteCases(root, suite) {
+    return suite.eval_kind === 'contract' ? evaluateContractSuite()
+      : suite.eval_kind === 'scenario' ? evaluateScenarioSuite()
+        : suite.eval_kind === 'behavior' ? evaluateBehaviorSuite(root)
+          : evaluateAdversarialSuite(root, suite.suite_id, suite.eval_kind);
+  }
+
+  return {
+    evaluateEvalSuiteCases,
+    summarizeEvalCaseResults,
+  };
+}