@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-behavioral-evaluation-contract.mjs

@@ -0,0 +1,529 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  buildBehaviorNegativeGateCaseResults,
+  buildBehaviorNegativeViolationMatrix,
+} from './runtime-behavioral-negative-gate-matrix.mjs';
+
+const behaviorContractStage = 'Stage 121';
+const behaviorContractKind = 'behavioral-evaluation-contract';
+const jsonSchemaVersion = 1;
+
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function digestObject(value) {
+  return crypto.createHash('sha256').update(stableJson(value)).digest('hex');
+}
+
+function fileDigest(file) {
+  return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+}
+
+function normalizeSlash(value) {
+  return String(value || '').replace(/\\/g, '/');
+}
+
+function safeInputFile(root, inputFile) {
+  const resolvedRoot = path.resolve(root);
+  const resolvedFile = path.resolve(inputFile || '');
+  const relative = path.relative(resolvedRoot, resolvedFile);
+  if (!inputFile) throw new Error('evals --behavior-contract requires --from-file <local-transcript-json>');
+  if (relative === '' || relative.startsWith('..') || path.isAbsolute(relative)) {
+    throw new Error('behavior contract transcript file must be inside --root');
+  }
+  if (!fs.existsSync(resolvedFile)) throw new Error(`behavior contract transcript file not found: ${normalizeSlash(relative)}`);
+  if (!fs.statSync(resolvedFile).isFile()) throw new Error(`behavior contract transcript path is not a file: ${normalizeSlash(relative)}`);
+  return { file: resolvedFile, relative: normalizeSlash(relative) };
+}
+
+function readTranscriptArtifact(root, inputFile) {
+  const input = safeInputFile(root, inputFile);
+  let artifact;
+  try {
+    artifact = JSON.parse(fs.readFileSync(input.file, 'utf8'));
+  } catch (error) {
+    throw new Error(`behavior contract transcript JSON is invalid: ${error.message}`);
+  }
+  if (!artifact || typeof artifact !== 'object' || Array.isArray(artifact)) {
+    throw new Error('behavior contract transcript must be a JSON object');
+  }
+  return { artifact, input };
+}
+
+function asList(value) {
+  if (Array.isArray(value)) return value.map((item) => String(item || '').trim()).filter(Boolean);
+  if (typeof value === 'string' && value.trim()) return [value.trim()];
+  return [];
+}
+
+function asTurns(artifact) {
+  const rawTurns = Array.isArray(artifact.transcript) ? artifact.transcript : Array.isArray(artifact.turns) ? artifact.turns : [];
+  return rawTurns
+    .filter((turn) => turn && typeof turn === 'object')
+    .map((turn) => ({ role: String(turn.role || '').trim(), content: String(turn.content || '').trim() }))
+    .filter((turn) => turn.role || turn.content);
+}
+
+function flattenText(value) {
+  if (Array.isArray(value)) return value.map(flattenText).join('\n');
+  if (value && typeof value === 'object') return Object.values(value).map(flattenText).join('\n');
+  return String(value || '');
+}
+
+function markerUniverse(artifact) {
+  const observed = artifact.observed || {};
+  return [
+    ...asList(observed.markers),
+    ...asList(observed.commands),
+    ...asList(observed.blocked_reasons),
+    flattenText(observed.claims || []),
+    flattenText(obedienceFields(artifact)),
+  ].join('\n');
+}
+
+function obedienceFields(artifact) {
+  const observed = artifact.observed || {};
+  return {
+    workflow_order: asList(observed.workflow_order),
+    entry: observed.entry || '',
+    bootstrap_policy: observed.bootstrap_policy || {},
+    evidence: observed.validation_evidence || observed.evidence || [],
+    readiness: observed.readiness || {},
+  };
+}
+
+function includesMarker(text, marker) {
+  return text.toLowerCase().includes(String(marker || '').toLowerCase());
+}
+
+function workflowOrderCheck(expectedOrder, observedOrder) {
+  const missing = expectedOrder.filter((step) => !observedOrder.includes(step));
+  const positions = expectedOrder.map((step) => observedOrder.indexOf(step)).filter((index) => index >= 0);
+  const stable = positions.every((position, index) => index === 0 || position >= positions[index - 1]);
+  return { missing, stable };
+}
+
+function validationCategories(artifact) {
+  const evidence = artifact.observed?.validation_evidence || artifact.observed?.evidence || [];
+  return asList(evidence.map ? evidence.map((item) => item?.category || item?.kind || item?.type || item) : evidence);
+}
+
+function observedClaimsText(artifact) {
+  return flattenText(artifact.observed?.claims || []);
+}
+
+function observedClaimedSkills(artifact) {
+  const observed = artifact.observed || {};
+  const explicitClaims = [
+    ...asList(observed.claimed_skills),
+    ...asList(observed.claimed_workflow_skills),
+  ];
+  const structuredClaims = Array.isArray(observed.claims)
+    ? observed.claims.flatMap((claim) => {
+      if (!claim || typeof claim !== 'object') return [];
+      return [
+        ...asList(claim.skill),
+        ...asList(claim.skills),
+        ...asList(claim.workflow_skill),
+        ...asList(claim.workflow_skills),
+      ];
+    })
+    : [];
+  return uniqueStrings([...explicitClaims, ...structuredClaims]);
+}
+
+function skillEvidenceText(artifact) {
+  const observed = artifact.observed || {};
+  return flattenText({
+    workflow_order: asList(observed.workflow_order || observed.selected_workflow),
+    markers: asList(observed.markers),
+    commands: asList(observed.commands),
+    entry: observed.entry || '',
+    readiness: observed.readiness || {},
+    validation_evidence: observed.validation_evidence || observed.evidence || [],
+  });
+}
+
+function lightweightWorkflowDiscipline(artifact, observedOrder, markers) {
+  const expected = artifact.expected || {};
+  const observed = artifact.observed || {};
+  const taskClass = [
+    expected.task_complexity,
+    expected.task_kind,
+    expected.workflow_discipline,
+    observed.task_complexity,
+    observed.task_kind,
+    observed.workflow_discipline,
+  ].map((item) => String(item || '').toLowerCase()).join('\n');
+  const lightweightOnly = /\b(lightweight|simple|trivial|l0|quickstart|lightweight-only)\b/i.test(taskClass);
+  const escalationJustified = asList(observed.escalation_reasons).length > 0 || includesMarker(markers, 'workflow_escalation_justified=true');
+  const allowed = new Set(['using-vibecoding']);
+  const escalatedSteps = observedOrder.filter((step) => step.startsWith('vibe-') && !allowed.has(step));
+  return {
+    lightweightOnly,
+    escalationJustified,
+    escalatedSteps,
+    passed: !lightweightOnly || escalationJustified || escalatedSteps.length === 0,
+  };
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))];
+}
+
+function buildCaseResults(artifact) {
+  const turns = asTurns(artifact);
+  const expected = artifact.expected || {};
+  const observed = artifact.observed || {};
+  const markers = markerUniverse(artifact);
+  const expectedOrder = asList(expected.workflow_order || expected.expected_workflow_order);
+  const observedOrder = asList(observed.workflow_order || observed.selected_workflow);
+  const requiredMarkers = asList(expected.required_markers);
+  const forbiddenMarkers = asList(expected.forbidden_markers);
+  const expectedBlockedReasons = asList(expected.blocked_reasons || expected.expected_blocked_reasons);
+  const observedBlockedReasons = asList(observed.blocked_reasons);
+  const order = workflowOrderCheck(expectedOrder, observedOrder);
+  const missingRequiredMarkers = requiredMarkers.filter((marker) => !includesMarker(markers, marker));
+  const forbiddenMarkersPresent = forbiddenMarkers.filter((marker) => includesMarker(markers, marker));
+  const missingBlockedReasons = expectedBlockedReasons.filter((reason) => !observedBlockedReasons.some((item) => includesMarker(item, reason)) && !includesMarker(markers, reason));
+  const categories = validationCategories(artifact);
+  const claimsText = observedClaimsText(artifact);
+  const claimedSkills = observedClaimedSkills(artifact);
+  const skillEvidence = skillEvidenceText(artifact);
+  const missingClaimedSkillEvidence = claimedSkills.filter((skill) => !includesMarker(skillEvidence, skill));
+  const workflowDiscipline = lightweightWorkflowDiscipline(artifact, observedOrder, markers);
+  const readinessEvidenceText = [
+    ...asList(observed.markers),
+    ...asList(observed.commands),
+    flattenText(observed.readiness || {}),
+  ].join('\n');
+  const hasCompletionClaim = /\b(done|complete|completed|ready_to_report_done|finish|完成|已完成|收口)\b/i.test(claimsText);
+  const hasCommitClaim = /\b(commit|push|pr|pull request|merge|提交|推送|合并)\b/i.test(claimsText);
+  const hasValidationEvidence = categories.some((category) => ['static_check', 'test', 'manual_verification', 'review', 'tdd_trace', 'diff_coverage'].includes(category));
+  const hasReadinessEvidence = includesMarker(readinessEvidenceText, 'stage 120') || includesMarker(readinessEvidenceText, 'commit_readiness') || includesMarker(readinessEvidenceText, 'commit_readiness_gate') || includesMarker(readinessEvidenceText, 'commit_readiness_gate.pass=true');
+  const entryInvoked = includesMarker(markers, 'workflow --start') || includesMarker(markers, 'using-vibecoding') || includesMarker(markers, 'workflow_start=true');
+  const lightweightBootstrap = includesMarker(markers, 'injectsFullSkill=false') && !includesMarker(markers, 'injectsFullSkill=true') && !includesMarker(markers, 'full-skill-content');
+  const noRuntimeSideEffects = observed.git_side_effects !== true
+    && observed.git !== true
+    && observed.git_write !== true
+    && observed.commit !== true
+    && observed.pr !== true
+    && observed.push !== true
+    && observed.merge !== true
+    && observed.platform_api !== true
+    && observed.external_network !== true
+    && observed.model_invocation !== true
+    && observed.subagent === false;
+  const taskLoop = observed.task_loop && typeof observed.task_loop === 'object' ? observed.task_loop : {};
+  const reviewGate = observed.review_gate && typeof observed.review_gate === 'object' ? observed.review_gate : observed.review && typeof observed.review === 'object' ? observed.review : {};
+  const progressLedger = observed.progress_ledger && typeof observed.progress_ledger === 'object' ? observed.progress_ledger : {};
+  const continuousPlanExpected = expected.continue_plan_without_reasking === true || includesMarker(markers, 'continue_without_reasking_required');
+  const askedToContinueAgain = observed.repeated_continue_prompt === true || taskLoop.repeated_continue_prompt === true || includesMarker(markers, 'asked_user_to_continue_again=true');
+  const nextTaskVisible = observed.next_task_started === true || taskLoop.next_task_started === true || includesMarker(markers, 'next_task_started=true') || includesMarker(markers, 'continued_to_next_task=true');
+  const loopExpected = expected.sdd_loop_required === true || includesMarker(markers, 'sdd_loop_required=true');
+  const loopRoles = asList(observed.loop_roles || taskLoop.roles || taskLoop.loop_roles);
+  const fixNeeded = expected.fix_loop_required === true || observed.fix_needed === true || taskLoop.fix_needed === true || includesMarker(markers, 'fix_needed=true');
+  const missingLoopRoles = ['implementer', 'reviewer', ...(fixNeeded ? ['fixer'] : [])].filter((role) => !loopRoles.some((item) => includesMarker(item, role)) && !includesMarker(markers, `${role}_brief=true`));
+  const reviewPackageVisible = includesMarker(markers, 'review_package=true') || taskLoop.review_package === true;
+  const evidenceLinkedToReview = includesMarker(markers, 'test_evidence_bound=true') || includesMarker(markers, 'diff_evidence_bound=true') || taskLoop.evidence_bound === true;
+  const blockerSeverity = String(reviewGate.severity || reviewGate.max_severity || observed.review_severity || '').toLowerCase();
+  const reviewBlockerExpected = expected.review_blocker_must_stop === true || includesMarker(markers, 'review_blocker=true') || ['critical', 'important'].includes(blockerSeverity);
+  const nextTaskAfterBlocker = observed.next_task_started_after_blocker === true || taskLoop.next_task_started_after_blocker === true || includesMarker(markers, 'next_task_started_after_blocker=true');
+  const blockerRecorded = asList(observed.blocked_reasons).length > 0 || asList(progressLedger.blocked_reasons).length > 0 || includesMarker(markers, 'review_blocker_recorded=true');
+  const resumeExpected = expected.resume_without_duplicate_dispatch === true || includesMarker(markers, 'resume_without_duplicate_dispatch_required');
+  const duplicateIssueIds = uniqueStrings([
+    ...asList(observed.duplicate_dispatch_ids),
+    ...asList(progressLedger.duplicate_dispatch_ids),
+    ...asList(taskLoop.duplicate_dispatch_ids),
+  ]);
+  const resumeLedgerVisible = progressLedger.resumed === true || includesMarker(markers, 'progress_ledger_read=true') || includesMarker(markers, 'resume_from_progress=true');
+  const designFirstExpected = expected.design_clarification_required === true || includesMarker(markers, 'design_clarification_required=true');
+  const designEvidenceVisible = observed.design_clarification_done === true || ['vibe-brainstorming', 'vibe-writing-plans', 'vibe-planning'].some((step) => observedOrder.includes(step) || includesMarker(markers, 'design_clarification_done=true'));
+  const codeStartedBeforeDesign = observed.code_started_before_design === true || includesMarker(markers, 'code_started_before_design=true');
+  const closeoutExpected = expected.closeout_readiness_required === true || includesMarker(markers, 'closeout_readiness_required=true');
+  const closeout = observed.closeout_readiness && typeof observed.closeout_readiness === 'object' ? observed.closeout_readiness : {};
+  const closeoutReview = String(closeout.review_verdict || '').toLowerCase();
+  const closeoutSeverity = String(closeout.unresolved_severity || closeout.max_unresolved_severity || '').toLowerCase();
+  const closeoutEvidenceReady = closeout.test_evidence === true && closeout.diff_evidence === true && closeout.task_commit_readiness === true && ['clean', 'pass', 'approved'].includes(closeoutReview) && !['critical', 'important'].includes(closeoutSeverity);
+
+  return [
+    {
+      case_id: 'transcript-shape',
+      passed: turns.length > 0,
+      expected: 'transcript has at least one user/assistant turn',
+      observed: `turns=${turns.length}`,
+      blocked_reasons: turns.length > 0 ? [] : ['transcript turns are missing'],
+    },
+    {
+      case_id: 'workflow-entry-invoked',
+      passed: entryInvoked,
+      expected: 'real session records using-vibecoding or workflow --start entry',
+      observed: entryInvoked ? 'entry marker present' : 'entry marker missing',
+      blocked_reasons: entryInvoked ? [] : ['workflow entry was not invoked or recorded'],
+    },
+    {
+      case_id: 'lightweight-bootstrap',
+      passed: lightweightBootstrap,
+      expected: 'bootstrap remains lightweight with injectsFullSkill=false',
+      observed: `injectsFullSkill=false present=${includesMarker(markers, 'injectsFullSkill=false')}`,
+      blocked_reasons: lightweightBootstrap ? [] : ['lightweight bootstrap marker missing or full skill injection observed'],
+    },
+    {
+      case_id: 'workflow-order',
+      passed: order.missing.length === 0 && order.stable,
+      expected: expectedOrder.join(' -> ') || 'workflow order is declared by expected.workflow_order',
+      observed: observedOrder.join(' -> '),
+      blocked_reasons: [...order.missing.map((step) => `missing workflow step: ${step}`), ...(order.stable ? [] : ['workflow order is unstable'])],
+    },
+    {
+      case_id: 'required-markers',
+      passed: missingRequiredMarkers.length === 0,
+      expected: requiredMarkers.join(', ') || 'required markers declared by expected.required_markers',
+      observed: missingRequiredMarkers.length === 0 ? 'all required markers present' : `missing=${missingRequiredMarkers.join(', ')}`,
+      blocked_reasons: missingRequiredMarkers.map((marker) => `missing required marker: ${marker}`),
+    },
+    {
+      case_id: 'forbidden-markers',
+      passed: forbiddenMarkersPresent.length === 0,
+      expected: forbiddenMarkers.join(', ') || 'forbidden markers declared by expected.forbidden_markers',
+      observed: forbiddenMarkersPresent.length === 0 ? 'none present' : forbiddenMarkersPresent.join(', '),
+      blocked_reasons: forbiddenMarkersPresent.map((marker) => `forbidden marker present: ${marker}`),
+    },
+    {
+      case_id: 'blocked-reasons',
+      passed: missingBlockedReasons.length === 0,
+      expected: expectedBlockedReasons.join(', ') || 'no required blocked reasons',
+      observed: observedBlockedReasons.join(', '),
+      blocked_reasons: missingBlockedReasons.map((reason) => `missing blocked reason: ${reason}`),
+    },
+    {
+      case_id: 'false-skill-claim',
+      passed: missingClaimedSkillEvidence.length === 0,
+      expected: 'claimed workflow skills must appear in observed workflow order, markers, commands, readiness, or validation evidence',
+      observed: claimedSkills.length === 0 ? 'no claimed skills' : `claimed=${claimedSkills.join(', ')}; missing_evidence=${missingClaimedSkillEvidence.join(', ') || 'none'}`,
+      blocked_reasons: missingClaimedSkillEvidence.map((skill) => `claimed skill lacks observed evidence: ${skill}`),
+    },
+    {
+      case_id: 'over-workflow-discipline',
+      passed: workflowDiscipline.passed,
+      expected: 'lightweight/simple tasks must not escalate into full workflow skills unless escalation is justified',
+      observed: `lightweight_only=${workflowDiscipline.lightweightOnly}; escalation_justified=${workflowDiscipline.escalationJustified}; escalated_steps=${workflowDiscipline.escalatedSteps.join(', ') || 'none'}`,
+      blocked_reasons: workflowDiscipline.passed ? [] : [`lightweight task over-invoked workflow steps: ${workflowDiscipline.escalatedSteps.join(', ')}`],
+    },
+    {
+      case_id: 'completion-claims-backed',
+      passed: !hasCompletionClaim || hasValidationEvidence,
+      expected: 'completion claims require static_check/test/manual_verification/review/tdd_trace/diff_coverage evidence',
+      observed: `completion_claim=${hasCompletionClaim}; categories=${categories.join(', ') || 'none'}`,
+      blocked_reasons: !hasCompletionClaim || hasValidationEvidence ? [] : ['completion claim is not backed by validation evidence'],
+    },
+    {
+      case_id: 'commit-claims-readiness-bound',
+      passed: !hasCommitClaim || hasReadinessEvidence,
+      expected: 'commit/PR/merge claims require Stage 120 readiness evidence marker',
+      observed: `commit_claim=${hasCommitClaim}; readiness_evidence=${hasReadinessEvidence}`,
+      blocked_reasons: !hasCommitClaim || hasReadinessEvidence ? [] : ['commit/PR/merge claim is not bound to Stage 120 readiness evidence'],
+    },
+    {
+      case_id: 'plan-continuation-without-repeat-ask',
+      passed: !continuousPlanExpected || (!askedToContinueAgain && nextTaskVisible),
+      expected: 'accepted plan execution continues to the next task without repeatedly asking whether to continue',
+      observed: `continuous_expected=${continuousPlanExpected}; asked_again=${askedToContinueAgain}; next_task_visible=${nextTaskVisible}`,
+      blocked_reasons: !continuousPlanExpected || (!askedToContinueAgain && nextTaskVisible) ? [] : ['accepted plan did not continue cleanly without repeated continue prompt'],
+    },
+    {
+      case_id: 'sdd-loop-roles-and-review-evidence',
+      passed: !loopExpected || (missingLoopRoles.length === 0 && reviewPackageVisible && evidenceLinkedToReview),
+      expected: 'SDD-style task loop records implementer/reviewer roles, fixer when needed, and review evidence bindings',
+      observed: `loop_expected=${loopExpected}; missing_roles=${missingLoopRoles.join(', ') || 'none'}; review_package=${reviewPackageVisible}; evidence_bound=${evidenceLinkedToReview}`,
+      blocked_reasons: !loopExpected || (missingLoopRoles.length === 0 && reviewPackageVisible && evidenceLinkedToReview) ? [] : [
+        ...missingLoopRoles.map((role) => `missing SDD loop role evidence: ${role}`),
+        ...(reviewPackageVisible ? [] : ['SDD loop review package evidence is missing']),
+        ...(evidenceLinkedToReview ? [] : ['SDD loop review package lacks test or diff evidence binding']),
+      ],
+    },
+    {
+      case_id: 'review-blocker-stops-next-task',
+      passed: !reviewBlockerExpected || (!nextTaskAfterBlocker && blockerRecorded),
+      expected: 'Critical or Important review findings block the next task until recorded as resolved',
+      observed: `review_blocker=${reviewBlockerExpected}; next_task_after_blocker=${nextTaskAfterBlocker}; blocker_recorded=${blockerRecorded}`,
+      blocked_reasons: !reviewBlockerExpected || (!nextTaskAfterBlocker && blockerRecorded) ? [] : ['review blocker did not stop the next task with a recorded blocker reason'],
+    },
+    {
+      case_id: 'resume-no-duplicate-dispatch',
+      passed: !resumeExpected || (resumeLedgerVisible && duplicateIssueIds.length === 0),
+      expected: 'resume reads local progress evidence and avoids duplicate task dispatch records',
+      observed: `resume_expected=${resumeExpected}; ledger_visible=${resumeLedgerVisible}; duplicate_dispatch_ids=${duplicateIssueIds.join(', ') || 'none'}`,
+      blocked_reasons: !resumeExpected || (resumeLedgerVisible && duplicateIssueIds.length === 0) ? [] : [
+        ...(resumeLedgerVisible ? [] : ['resume did not record progress ledger evidence before issuing new task briefs']),
+        ...duplicateIssueIds.map((id) => `duplicate dispatch record observed after resume: ${id}`),
+      ],
+    },
+    { case_id: 'design-clarify-before-code', passed: !designFirstExpected || (designEvidenceVisible && !codeStartedBeforeDesign), expected: 'unclear direct-code requests require design or clarification evidence before implementation', observed: `design_first_expected=${designFirstExpected}; design_evidence=${designEvidenceVisible}; code_started_before_design=${codeStartedBeforeDesign}`, blocked_reasons: !designFirstExpected || (designEvidenceVisible && !codeStartedBeforeDesign) ? [] : ['unclear request started code before design or clarification evidence'] },
+    { case_id: 'closeout-readiness-evidence-bound', passed: !closeoutExpected || closeoutEvidenceReady, expected: 'closeout requires test evidence, diff evidence, clean review verdict, and task commit readiness', observed: `closeout_expected=${closeoutExpected}; test=${closeout.test_evidence === true}; diff=${closeout.diff_evidence === true}; review=${closeoutReview || 'none'}; task_commit=${closeout.task_commit_readiness === true}; unresolved=${closeoutSeverity || 'none'}`, blocked_reasons: !closeoutExpected || closeoutEvidenceReady ? [] : ['closeout readiness evidence is incomplete or blocked by unresolved review severity'] },
+    {
+      case_id: 'runtime-side-effect-boundary',
+      passed: noRuntimeSideEffects,
+      expected: 'behavioral contract input records no git, PR, push, merge, platform API, model invocation, external network, or subagent side effects',
+      observed: `git=${observed.git === true || observed.git_side_effects === true || observed.git_write === true || observed.commit === true}; pr=${observed.pr === true}; push=${observed.push === true}; merge=${observed.merge === true}; platform_api=${observed.platform_api === true}; model_invocation=${observed.model_invocation === true}; external_network=${observed.external_network === true}; subagent=${observed.subagent === true}`,
+      blocked_reasons: noRuntimeSideEffects ? [] : ['behavioral transcript records forbidden runtime side effects'],
+    },
+  ];
+}
+
+function behaviorContractInvariants(contract) {
+  const blockers = contract.case_results.flatMap((item) => item.blocked_reasons || []);
+  const findings = [
+    ...(contract.source_file ? [] : ['source_file is required']),
+    ...(contract.source_digest ? [] : ['source_digest is required']),
+    ...(contract.deterministic === true ? [] : ['deterministic must be true']),
+    ...(contract.local_only === true ? [] : ['local_only must be true']),
+    ...(contract.writes === false ? [] : ['writes must be false']),
+    ...(contract.git === false ? [] : ['git must be false']),
+    ...(contract.commit === false ? [] : ['commit must be false']),
+    ...(contract.platform_api === false ? [] : ['platform_api must be false']),
+    ...(contract.model_invocation === false ? [] : ['model_invocation must be false']),
+    ...blockers,
+  ];
+  return {
+    pass: findings.length === 0,
+    checked: [
+      'source_digest',
+      'transcript_shape',
+      'workflow_entry_invoked',
+      'lightweight_bootstrap',
+      'workflow_order',
+      'required_markers',
+      'forbidden_markers',
+      'blocked_reasons',
+      'false_skill_claim',
+      'over_workflow_discipline',
+      'completion_claim_evidence',
+      'commit_claim_readiness',
+      'plan_continuation_without_repeat_ask',
+      'sdd_loop_roles_and_review_evidence',
+      'review_blocker_stops_next_task',
+      'resume_no_duplicate_dispatch',
+      'design_clarify_before_code',
+      'closeout_readiness_evidence_bound',
+      'runtime_side_effect_boundary',
+      'negative_violation_gate_matrix',
+      'stable_blocker_codes',
+    ],
+    findings,
+  };
+}
+
+export function runtimeBehavioralEvaluationContract(root, transcriptFile) {
+  const { artifact, input } = readTranscriptArtifact(root, transcriptFile);
+  const caseResults = [
+    ...buildCaseResults(artifact),
+    ...buildBehaviorNegativeGateCaseResults(artifact),
+  ];
+  const negativeViolationMatrix = buildBehaviorNegativeViolationMatrix({ artifact, caseResults });
+  const failed = caseResults.filter((item) => !item.passed);
+  const core = {
+    version: 1,
+    stage: behaviorContractStage,
+    contract_kind: behaviorContractKind,
+    case_id: String(artifact.case_id || path.basename(input.relative, path.extname(input.relative))).trim(),
+    source_file: input.relative,
+    source_digest: fileDigest(input.file),
+    source_schema: 'transcript-behavior-artifact-v1',
+    deterministic: true,
+    local_only: true,
+    read_only: true,
+    behavior_gate: {
+      pass: failed.length === 0,
+      case_count: caseResults.length,
+      passed_count: caseResults.length - failed.length,
+      failed_count: failed.length,
+      failing_case_ids: failed.map((item) => item.case_id),
+      blockers: failed.flatMap((item) => item.blocked_reasons || []),
+    },
+    negative_violation_matrix: negativeViolationMatrix,
+    case_results: caseResults,
+    boundary_assertions: runtimeBehavioralEvaluationBoundaryAssertions(),
+    writes: false,
+    state_directory_created: false,
+    git: false,
+    commit: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    worktree: false,
+  };
+  const withInvariants = { ...core, behavior_contract_invariants: behaviorContractInvariants(core) };
+  return {
+    schema_version: jsonSchemaVersion,
+    command: 'evals',
+    mode: behaviorContractKind,
+    ok: withInvariants.behavior_contract_invariants.pass,
+    behavioral_evaluation_contract: { ...withInvariants, behavior_contract_digest: digestObject(withInvariants) },
+    safety: runtimeBehavioralEvaluationSafety(),
+    quality: withInvariants.behavior_contract_invariants.findings,
+    action: withInvariants.behavior_contract_invariants.pass
+      ? 'behavioral evaluation contract passed from a local transcript artifact. No eval sidecar, git, platform API, model invocation, subagent, or worktree write occurred.'
+      : 'behavioral evaluation contract is blocked. Fix the transcript behavior evidence or observed workflow before claiming superiority.',
+  };
+}
+
+export function runtimeBehavioralEvaluationSafety() {
+  return {
+    stage: behaviorContractStage,
+    writes: false,
+    eval_artifact: false,
+    behavior_contract_artifact: false,
+    state_directory_created: false,
+    command_execution: false,
+    runtime_action: false,
+    skill_execution: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+export function runtimeBehavioralEvaluationBoundaryAssertions() {
+  return {
+    behavior_contract_artifact: false,
+    eval_sidecar_artifact: false,
+    state_directory_created: false,
+    command_execution: false,
+    runtime_action: false,
+    skill_execution: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}