harness-everything 0.10.0 → 0.11.1

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "harness-everything",
       "source": "./",
       "description": "Harness OS: an orchestrated agent operating system — tier routing, circuit breaker guardrails, verification gates, WAL session memory, and self-evolving workspace rules.",
-      "version": "0.10.0",
+      "version": "0.11.1",
       "author": {
         "name": "Miya Daniel"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "harness-everything",
   "description": "Harness OS: an orchestrated agent operating system — tier routing, circuit breaker guardrails, verification gates, WAL session memory, and self-evolving workspace rules.",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "author": {
     "name": "Miya Daniel"
   },

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.11.1](https://github.com/dyphn1/Harness-everything/compare/v0.11.0...v0.11.1) (2026-09-18)
+
+### Bug Fixes
+
+* **workflow:** admit all trusted controller commands ([65ec5f3](https://github.com/dyphn1/Harness-everything/commit/65ec5f31e9d218d7c32e1d9ed82992814be79b9b))
+* **workflow:** share controller command contract ([b9ba2dc](https://github.com/dyphn1/Harness-everything/commit/b9ba2dc59a5c2dce10533aad79b9a5303b921506))
+* **workflow:** validate shared controller command set ([8d3247d](https://github.com/dyphn1/Harness-everything/commit/8d3247d51d8aa0f1cfa61328c1061cb239dfba6a))
+
+## [0.11.0](https://github.com/dyphn1/Harness-everything/compare/v0.10.0...v0.11.0) (2026-09-18)
+
+### Features
+
+* **contract-integrity:** add trace reconciliation audit ([bb99f7a](https://github.com/dyphn1/Harness-everything/commit/bb99f7a8c29e14bd718a896ef30c7b820dcb2d7c))
+* **contract-integrity:** bind evidence to current living spec ([77f203a](https://github.com/dyphn1/Harness-everything/commit/77f203a1f59d968d1a4075e3441e2113adeb0942))
+* **contract-integrity:** define trace and probe schema ([d688f8a](https://github.com/dyphn1/Harness-everything/commit/d688f8a7dba66e3e7faa8e33fd3d659b09982143))
+* **contract-integrity:** expose audit and regression scripts ([fa33f11](https://github.com/dyphn1/Harness-everything/commit/fa33f118b4a1995ce02feb69e76b0145d6b7e5d2))
+
+### Bug Fixes
+
+* **contract-integrity:** align runtime validation with schema ([b4d702a](https://github.com/dyphn1/Harness-everything/commit/b4d702a248f7f088e4ce97dee21b92250390a451))
+
 ## [0.10.0](https://github.com/dyphn1/Harness-everything/compare/v0.9.0...v0.10.0) (2026-09-18)
 
 ### Features

package/ci/contract-integrity.test.js

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..');
+const {
+  DRIFT,
+  evaluateTrace,
+  markdown,
+  validateTrace,
+} = require(path.join(ROOT, 'contract-integrity/scripts/audit.js'));
+const { evaluateEvidence } = require(path.join(ROOT, 'tdd/scripts/quality-gate.js'));
+
+let failed = 0;
+function check(condition, message, detail = '') {
+  if (condition) console.log(`  PASS ${message}`);
+  else {
+    console.error(`  FAIL ${message}${detail ? ` — ${detail}` : ''}`);
+    failed++;
+  }
+}
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function fixture(name) {
+  return JSON.parse(fs.readFileSync(path.join(ROOT, 'contract-integrity', 'fixtures', name), 'utf8'));
+}
+function tddEvidence(specPath = 'docs/specs/api.md', section = 'REQ-001') {
+  const value = JSON.parse(fs.readFileSync(path.join(ROOT, 'tdd', 'fixtures', 'pass-evidence.json'), 'utf8'));
+  value.requirements[0].source.path = specPath;
+  value.requirements[0].source.section = section;
+  return value;
+}
+function req(report, id = 'REQ-001') {
+  return report.requirements.find(item => item.requirementId === id);
+}
+
+console.log('=== Contract Integrity Phase 1 (#84) ===');
+
+const baseline = fixture('consistent-trace.json');
+const baselineTdd = tddEvidence();
+const legacyQuality = evaluateEvidence(baselineTdd);
+check(legacyQuality.result === 'PASS' && legacyQuality.score === 100, '#58 completeness evaluator remains independently backward compatible');
+
+const baselineReport = evaluateTrace(baseline, { tddEvidence: baselineTdd });
+check(baselineReport.result === 'PASS' && baselineReport.completionGate === 'PASS', 'fully traced current contract passes strict reconciliation');
+check(baselineReport.scores.completenessScore === 100 && baselineReport.scores.protectionScore === 100 && baselineReport.scores.contractIntegrityScore === 100, 'integrity score is min(100 completeness, 100 protection)');
+check(req(baselineReport).drift.length === 1 && req(baselineReport).drift[0] === 'CONSISTENT', 'consistent requirement has no fabricated drift category');
+check(req(baselineReport).protection.status === 'PROTECTED' && req(baselineReport).protection.required === 1, 'only predeclared required probe evidence determines protection');
+
+const drift = fixture('ticket-drift-trace.json');
+const driftReport = evaluateTrace(drift, { tddEvidence: baselineTdd });
+check(driftReport.result === 'FAIL', 'strict mode fails when ticket feedback moves behavior ahead of living contract');
+check(req(driftReport).drift.includes('STALE_SPEC') && req(driftReport).drift.includes('UNTRACED_CHANGE'), 'ticket-ahead fixture reports exact stale-spec and untraced-change categories');
+check(req(driftReport).reasonCodes.some(code => code.startsWith('ticket-ahead-of-contract:')), 'drift report points to the ticket that outran the contract');
+
+const reconciled = fixture('reconciled-trace.json');
+const reconciledTdd = tddEvidence('docs/specs/api.md', 'REQ-001-v2');
+const reconciledReport = evaluateTrace(reconciled, { tddEvidence: reconciledTdd });
+check(reconciledReport.result === 'PASS' && req(reconciledReport).drift.includes('CONSISTENT'), 'ADR amendment + living spec/test/implementation revision reconciliation restores PASS');
+check(reconciledReport.graph.links.some(link => link.relation === 'supersedes' && link.from === 'ADR-002' && link.to === 'ADR-001'), 'decision supersession is linked instead of appending ticket chronology to old ADR');
+
+const staleQuality = evaluateTrace(reconciled, { tddEvidence: tddEvidence('docs/old-api.md', 'REQ-001') });
+check(req(staleQuality).drift.includes('STALE_TEST') && req(staleQuality).reasonCodes.includes('tdd-source-not-current-spec'), '#58 evidence bound to an old source cannot certify the current living spec');
+check(staleQuality.result === 'FAIL', 'stale #58 source binding blocks strict completion despite a 100 completeness score');
+
+const staleProbe = clone(reconciled);
+staleProbe.probes[0].sourceSection = 'docs/old-api.md#REQ-001';
+const staleProbeReport = evaluateTrace(staleProbe, { tddEvidence: reconciledTdd });
+check(req(staleProbeReport).protection.status === 'NOT_EVALUATED', 'probe derived from a stale source section is rejected as protection evidence');
+check(staleProbeReport.scores.protectionScore === 0 && staleProbeReport.scores.contractIntegrityScore === 0, 'stale probe evidence fails closed to zero protection');
+
+const padding = clone(baseline);
+padding.probes[0].status = 'SURVIVED';
+padding.probes[0].failureClass = 'none';
+for (let i = 0; i < 10; i++) {
+  padding.probes.push({
+    probeId: `PAD-${i}`,
+    requirementId: 'REQ-001',
+    status: 'KILLED',
+    sourceSection: 'docs/specs/api.md#REQ-001',
+    evidenceRef: `probe:padding-${i}`,
+    workspaceIsolation: 'isolated',
+    failureClass: 'contract',
+  });
+}
+const paddedReport = evaluateTrace(padding, { tddEvidence: baselineTdd });
+check(req(paddedReport).protection.status === 'SURVIVED' && paddedReport.scores.protectionScore === 0, 'extra killed probes cannot dilute one surviving predeclared required probe');
+check(paddedReport.result === 'FAIL', 'padding tests/probes cannot turn a weak protection result green');
+
+const invalidKill = clone(baseline);
+invalidKill.probes[0].failureClass = 'build';
+const invalidErrors = validateTrace(invalidKill);
+check(invalidErrors.some(error => /KILLED requires failureClass=contract/.test(error)), 'compile/build failure cannot be counted as a killed contract probe');
+const invalidKillReport = evaluateTrace(invalidKill, { tddEvidence: baselineTdd });
+check(invalidKillReport.errors.length > 0 && invalidKillReport.result === 'FAIL', 'invalid probe evidence fails closed rather than lowering thresholds');
+
+const notEvaluated = clone(baseline);
+notEvaluated.probes = [];
+const notEvaluatedReport = evaluateTrace(notEvaluated, { tddEvidence: baselineTdd });
+check(req(notEvaluatedReport).protection.status === 'NOT_EVALUATED', 'missing required probe is explicit NOT_EVALUATED');
+check(notEvaluatedReport.completionGate === 'NOT_EVALUATED' && notEvaluatedReport.result === 'FAIL', 'strict mode cannot authorize completion without protection evidence');
+
+const auditOnly = clone(baseline);
+auditOnly.mode = 'audit';
+auditOnly.requirements[0].ticketIds = [];
+auditOnly.requirements[0].testIds = [];
+auditOnly.requirements[0].implementationIds = [];
+auditOnly.requirements[0].requiredProbeIds = [];
+auditOnly.probes = [];
+const auditReport = evaluateTrace(auditOnly, { tddEvidence: null });
+check(auditReport.result === 'AUDIT' && auditReport.gateEligible === false, 'audit-only adoption reports legacy debt without claiming completion eligibility');
+check(req(auditReport).drift.includes('UNTRACED_CHANGE') && req(auditReport).drift.includes('STALE_TEST') && req(auditReport).drift.includes('STALE_IMPLEMENTATION') && req(auditReport).drift.includes('NOT_EVALUATED'), 'legacy audit exposes missing ticket/test/implementation/protection links');
+
+const sourceDefect = clone(baseline);
+sourceDefect.requirements[0].sourceValidity = 'SOURCE_DEFECT';
+const defectReport = evaluateTrace(sourceDefect, { tddEvidence: baselineTdd });
+check(req(defectReport).drift.includes('SOURCE_DEFECT') && defectReport.result === 'FAIL', 'source defect stays distinct and fail-closed in strict mode');
+
+const sourceConflict = clone(baseline);
+sourceConflict.requirements[0].sourceValidity = 'SOURCE_CONFLICT';
+const conflictReport = evaluateTrace(sourceConflict, { tddEvidence: baselineTdd });
+check(req(conflictReport).drift.includes('SOURCE_CONFLICT') && conflictReport.result === 'FAIL', 'source conflict stays distinct and fail-closed');
+
+const supersession = clone(baseline);
+supersession.requirements.unshift({
+  requirementId: 'REQ-OLD',
+  revision: 1,
+  status: 'SUPERSEDED',
+  specId: 'SPEC-001',
+  decisionIds: [],
+  ticketIds: [],
+  testIds: [],
+  implementationIds: [],
+  requiredProbeIds: [],
+  sourceValidity: 'VALID',
+  supersededBy: 'REQ-001',
+});
+const supersessionReport = evaluateTrace(supersession, { tddEvidence: baselineTdd });
+check(req(supersessionReport, 'REQ-OLD').drift.includes('INTENTIONAL_SUPERSESSION'), 'explicit requirement supersession is distinguished from stale/untraced drift');
+check(supersessionReport.result === 'PASS', 'historical superseded requirement does not poison the current contract gate');
+
+const reportMd = markdown(driftReport);
+check(/Contract Integrity Report/.test(reportMd) && /STALE_SPEC/.test(reportMd) && /min\(completeness, protection\)/.test(reportMd), 'Markdown report exposes drift and score formula');
+check(Object.keys(driftReport.driftCounts).every(status => DRIFT.has(status)), 'machine report uses only the declared drift vocabulary');
+check(driftReport.graph.nodes.some(node => node.kind === 'REQUIREMENT') && driftReport.graph.links.some(link => link.relation === 'protected-by'), 'machine report publishes a traceable contract graph');
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-contract-integrity-'));
+try {
+  const tracePath = path.join(tmp, 'trace.json');
+  const tddPath = path.join(tmp, 'tdd.json');
+  const jsonPath = path.join(tmp, 'report.json');
+  const mdPath = path.join(tmp, 'report.md');
+  fs.writeFileSync(tracePath, JSON.stringify(baseline), 'utf8');
+  fs.writeFileSync(tddPath, JSON.stringify(baselineTdd), 'utf8');
+  const cli = spawnSync(process.execPath, [
+    path.join(ROOT, 'contract-integrity/scripts/audit.js'),
+    tracePath,
+    '--tdd-evidence', tddPath,
+    '--output', jsonPath,
+    '--markdown', mdPath,
+  ], { encoding: 'utf8' });
+  check(cli.status === 0 && fs.existsSync(jsonPath) && fs.existsSync(mdPath), 'strict CLI writes both machine-readable JSON and concise Markdown reports');
+  const cliReport = JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
+  check(cliReport.result === 'PASS' && /Contract Integrity Report/.test(fs.readFileSync(mdPath, 'utf8')), 'CLI reports retain deterministic PASS evidence');
+
+  const auditPath = path.join(tmp, 'audit.json');
+  fs.writeFileSync(auditPath, JSON.stringify(auditOnly), 'utf8');
+  const auditCli = spawnSync(process.execPath, [path.join(ROOT, 'contract-integrity/scripts/audit.js'), auditPath], { encoding: 'utf8' });
+  check(auditCli.status === 0 && /Contract Integrity: AUDIT/.test(auditCli.stdout), 'audit mode exits zero for migration/debt inventory without pretending to pass');
+
+  const strictMissing = clone(notEvaluated);
+  fs.writeFileSync(tracePath, JSON.stringify(strictMissing), 'utf8');
+  const strictCli = spawnSync(process.execPath, [
+    path.join(ROOT, 'contract-integrity/scripts/audit.js'), tracePath, '--tdd-evidence', tddPath,
+  ], { encoding: 'utf8' });
+  check(strictCli.status === 1 && /Gate: NOT_EVALUATED/.test(strictCli.stdout), 'strict CLI returns failure for valid-but-incomplete protection evidence');
+
+  fs.writeFileSync(tracePath, '{', 'utf8');
+  const malformedCli = spawnSync(process.execPath, [path.join(ROOT, 'contract-integrity/scripts/audit.js'), tracePath], { encoding: 'utf8' });
+  check(malformedCli.status === 2, 'malformed trace returns infrastructure/schema exit 2');
+} finally {
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+const unknownField = clone(baseline);
+unknownField.artifacts[0].agentScore = 100;
+check(validateTrace(unknownField).some(error => /unknown field: agentScore/.test(error)), 'runtime rejects fields that the JSON schema does not permit');
+
+const absolutePath = clone(baseline);
+absolutePath.artifacts[0].path = path.resolve(ROOT, 'docs/adr/0001-api-contract.md');
+check(validateTrace(absolutePath).some(error => /repo-relative/.test(error)), 'trace report rejects machine-specific absolute artifact paths');
+
+const schema = JSON.parse(fs.readFileSync(path.join(ROOT, 'contract-integrity/schemas/trace.schema.json'), 'utf8'));
+check(schema.properties?.probes?.items?.properties?.status?.enum?.includes('SURVIVED'), 'versioned trace schema includes probe disposition vocabulary');
+check(schema.properties?.requirements?.items?.properties?.requiredProbeIds?.uniqueItems === true, 'schema prevents duplicate required-probe padding');
+
+console.log(`\n${failed === 0 ? 'PASS' : 'FAIL'}: #84 contract integrity phase 1 (${failed} failure${failed === 1 ? '' : 's'})`);
+process.exit(failed === 0 ? 0 : 1);

package/ci/mechanism-2ah-workflow-lifecycle.test.js

@@ -113,6 +113,24 @@ try {
   check(gate('Write', { file_path: path.join(linked, 'src.js') }).status === 2, 'blocked state still prohibits mutation');
   for (let i = 0; i < 3; i++) { check(control('start').status === 0, 'bounded replan attempt ' + i); control('block', '--evidence', 'fixture blocker'); }
   check(control('start').status === 2 && read(file).state === 'blocked', 'exhausted replan budget remains blocked');
+  check(read(file).budget?.state === 'budget-exhausted' && read(file).budget?.reasonCode === 'replan-budget-exhausted', 'Fable replan exhaustion is auditable before recovery');
+  const dispositionPath = path.join(runtimeRoot, 'hooks/scripts/workflow-disposition.js');
+  const resetCommand = `node "${dispositionPath}" reset-budget --session-id ${sessionId} --evidence fixture-fable-budget-reset`;
+  check(gate('Bash', { command: resetCommand }, repo).status === 0, 'blocked Fable workflow admits trusted reset-budget controller through gate');
+  check(gate('Bash', { command: resetCommand + ' && echo bypass' }, repo).status === 2, 'controller shell chaining is not exempted');
+  check(gate('Bash', { command: resetCommand + ' | echo bypass' }, repo).status === 2, 'controller pipe composition is not exempted');
+  check(gate('Bash', { command: `node "${dispositionPath}" reset-budget --session-id ${sessionId} --evidence $(echo bypass)` }, repo).status === 2, 'controller command substitution is not exempted');
+  check(gate('Bash', { command: `node "${path.join(runtimeRoot, 'hooks/scripts/not-workflow-disposition.js')}" reset-budget --session-id ${sessionId} --evidence wrong-path` }, repo).status === 2, 'wrong controller script path is not exempted');
+  check(control('reset-budget', '--evidence', 'fixture-fable-budget-reset').status === 0, 'reset-budget executes after gate admission');
+  const fableReset = read(file);
+  check(fableReset.state === 'pending' && fableReset.budget?.state === 'active' && fableReset.budget?.epoch === 1, 'budget reset returns Fable workflow to pending with audited epoch');
+  check(gate('Write', { file_path: path.join(repo, 'still-primary.js') }, repo).status === 2, 'budget reset does not weaken primary-tree worktree isolation');
+  const restartCommand = `node "${dispositionPath}" start --session-id ${sessionId}`;
+  check(gate('Bash', { command: restartCommand }, repo).status === 0, 'trusted start controller remains admitted after reset');
+  check(control('start').status === 0 && read(file).state === 'running', 'Fable workflow resumes after audited budget reset');
+  const revisionCommand = `node "${dispositionPath}" revision --session-id ${sessionId} --evidence fixture-revision`;
+  check(gate('Bash', { command: revisionCommand }, repo).status === 0, 'revision controller is admitted through workflow gate');
+  check(control('revision', '--evidence', 'fixture-revision').status === 0 && read(file).budget?.counters?.revisionRounds === 1, 'revision controller reaches budget accounting');
   fs.writeFileSync(file, '{broken');
   check(route('continue').status === 2 && fs.readFileSync(file, 'utf8') === '{broken', 'router cannot overwrite unreadable unresolved state');
   check(stop().status === 2, 'malformed state cannot silently pass completion');
@@ -120,7 +138,22 @@ try {
   check(gate('Write', { file_path: path.join(linked, 'src.js') }).status === 2 && stop().status === 2, 'partial JSON state cannot bypass workflow gates');
   fs.unlinkSync(file);
   check(route('Fix this checkout bug with a regression test').status === 0 && read(file).strategy === 'iterative-single', 'bounded fix selects iterative lifecycle');
-  check(gate('Write', { file_path: path.join(repo, 'small.js') }, repo).status === 0, 'ordinary iterative mutation does not require isolation');
+  const iterationLimit = read(file).workflowPlan.limits.maxIterations;
+  check(Number.isInteger(iterationLimit) && iterationLimit > 0, 'iterative route exposes a numeric iteration budget');
+  for (let i = 0; i < iterationLimit; i++) {
+    check(gate('Write', { file_path: path.join(repo, `small-${i}.js`) }, repo).status === 0, `iterative mutation ${i + 1}/${iterationLimit} stays within budget`);
+  }
+  check(gate('Write', { file_path: path.join(repo, 'small-overflow.js') }, repo).status === 2, 'iteration beyond maxIterations is blocked');
+  const iterativeExhausted = read(file);
+  check(iterativeExhausted.state === 'blocked' && iterativeExhausted.budget?.state === 'budget-exhausted' &&
+    iterativeExhausted.budget?.reasonCode === 'iteration-budget-exhausted', 'iterative exhaustion records blocked budget state');
+  const iterativeResetCommand = `node "${dispositionPath}" reset-budget --session-id ${sessionId} --evidence fixture-iteration-budget-reset`;
+  check(gate('Bash', { command: iterativeResetCommand }, repo).status === 0, 'iteration-exhausted workflow admits reset-budget through gate');
+  check(control('reset-budget', '--evidence', 'fixture-iteration-budget-reset').status === 0, 'iteration budget reset executes');
+  check(read(file).state === 'pending' && read(file).budget?.epoch === 1 && read(file).budget?.counters?.iterations === 0, 'iteration budget reset is audited and clears counters');
+  const iterativeStartCommand = `node "${dispositionPath}" start --session-id ${sessionId}`;
+  check(gate('Bash', { command: iterativeStartCommand }, repo).status === 0, 'iterative workflow restart is admitted through gate');
+  check(control('start').status === 0 && read(file).state === 'running', 'iteration-exhausted workflow resumes after reset');
   check(stop().status === 2, 'direct/iterative route cannot complete unverified mutation');
   check(stop({ stop_hook_active: true }).status === 0 && read(file).state === 'blocked', 'iterative retry reports incomplete state');
   check(control('start').status === 0, 'blocked iterative route can resume without a Fable stage map');

package/contract-integrity/fixtures/consistent-trace.json

@@ -0,0 +1,94 @@
+{
+  "schemaVersion": "1.0.0",
+  "mode": "strict",
+  "artifacts": [
+    {
+      "id": "ADR-001",
+      "kind": "ADR",
+      "path": "docs/adr/0001-api-contract.md",
+      "status": "ACTIVE",
+      "revision": 1,
+      "supersedes": [],
+      "evidenceRef": null
+    },
+    {
+      "id": "SPEC-001",
+      "kind": "SPEC",
+      "path": "docs/specs/api.md",
+      "status": "ACTIVE",
+      "revision": 1,
+      "supersedes": [],
+      "evidenceRef": null
+    },
+    {
+      "id": "TICKET-001",
+      "kind": "TICKET",
+      "path": "tickets/001.md",
+      "status": "ACTIVE",
+      "revision": 1,
+      "requirementId": "REQ-001",
+      "requirementRevision": 1,
+      "changeImpact": "implementation",
+      "supersedes": [],
+      "evidenceRef": null
+    },
+    {
+      "id": "TEST-001",
+      "kind": "TEST",
+      "path": "tests/api.test.js",
+      "status": "ACTIVE",
+      "revision": 1,
+      "requirementId": "REQ-001",
+      "requirementRevision": 1,
+      "supersedes": [],
+      "evidenceRef": "tests/api.test.js#contract"
+    },
+    {
+      "id": "IMPL-001",
+      "kind": "IMPLEMENTATION",
+      "path": "src/api.js",
+      "status": "ACTIVE",
+      "revision": 1,
+      "requirementId": "REQ-001",
+      "requirementRevision": 1,
+      "supersedes": [],
+      "evidenceRef": "commit:baseline"
+    }
+  ],
+  "requirements": [
+    {
+      "requirementId": "REQ-001",
+      "revision": 1,
+      "status": "CURRENT",
+      "specId": "SPEC-001",
+      "decisionIds": [
+        "ADR-001"
+      ],
+      "ticketIds": [
+        "TICKET-001"
+      ],
+      "testIds": [
+        "TEST-001"
+      ],
+      "implementationIds": [
+        "IMPL-001"
+      ],
+      "requiredProbeIds": [
+        "PROBE-001"
+      ],
+      "sourceValidity": "VALID",
+      "supersededBy": null
+    }
+  ],
+  "probes": [
+    {
+      "probeId": "PROBE-001",
+      "requirementId": "REQ-001",
+      "status": "KILLED",
+      "sourceSection": "docs/specs/api.md#REQ-001",
+      "evidenceRef": "probe:baseline-red",
+      "workspaceIsolation": "isolated",
+      "failureClass": "contract"
+    }
+  ]
+}

package/contract-integrity/fixtures/reconciled-trace.json

@@ -0,0 +1,105 @@
+{
+  "schemaVersion": "1.0.0",
+  "mode": "strict",
+  "artifacts": [
+    {
+      "id": "ADR-001",
+      "kind": "ADR",
+      "path": "docs/adr/0001-api-contract.md",
+      "status": "SUPERSEDED",
+      "revision": 1,
+      "supersedes": [],
+      "evidenceRef": null
+    },
+    {
+      "id": "ADR-002",
+      "kind": "ADR",
+      "path": "docs/adr/0002-api-contract-v2.md",
+      "status": "ACTIVE",
+      "revision": 2,
+      "supersedes": [
+        "ADR-001"
+      ],
+      "evidenceRef": "decision:approved-v2"
+    },
+    {
+      "id": "SPEC-001",
+      "kind": "SPEC",
+      "path": "docs/specs/api.md",
+      "status": "ACTIVE",
+      "revision": 2,
+      "supersedes": [],
+      "evidenceRef": "spec:REQ-001-v2"
+    },
+    {
+      "id": "TICKET-001",
+      "kind": "TICKET",
+      "path": "tickets/001.md",
+      "status": "ACTIVE",
+      "revision": 2,
+      "requirementId": "REQ-001",
+      "requirementRevision": 2,
+      "changeImpact": "architecture",
+      "supersedes": [],
+      "evidenceRef": "feedback:approved-v2"
+    },
+    {
+      "id": "TEST-001",
+      "kind": "TEST",
+      "path": "tests/api.test.js",
+      "status": "ACTIVE",
+      "revision": 2,
+      "requirementId": "REQ-001",
+      "requirementRevision": 2,
+      "supersedes": [],
+      "evidenceRef": "tests/api.test.js#contract-v2"
+    },
+    {
+      "id": "IMPL-001",
+      "kind": "IMPLEMENTATION",
+      "path": "src/api.js",
+      "status": "ACTIVE",
+      "revision": 2,
+      "requirementId": "REQ-001",
+      "requirementRevision": 2,
+      "supersedes": [],
+      "evidenceRef": "commit:implemented-v2"
+    }
+  ],
+  "requirements": [
+    {
+      "requirementId": "REQ-001",
+      "revision": 2,
+      "status": "CURRENT",
+      "specId": "SPEC-001",
+      "decisionIds": [
+        "ADR-002"
+      ],
+      "ticketIds": [
+        "TICKET-001"
+      ],
+      "testIds": [
+        "TEST-001"
+      ],
+      "implementationIds": [
+        "IMPL-001"
+      ],
+      "requiredProbeIds": [
+        "PROBE-001"
+      ],
+      "sourceValidity": "VALID",
+      "supersededBy": null
+    }
+  ],
+  "probes": [
+    {
+      "probeId": "PROBE-001",
+      "requirementId": "REQ-001",
+      "status": "KILLED",
+      "sourceSection": "docs/specs/api.md#REQ-001-v2",
+      "evidenceRef": "probe:v2-red",
+      "workspaceIsolation": "isolated",
+      "failureClass": "contract"
+    }
+  ]
+}

package/contract-integrity/fixtures/ticket-drift-trace.json

@@ -0,0 +1,94 @@
+{
+  "schemaVersion": "1.0.0",
+  "mode": "strict",
+  "artifacts": [
+    {
+      "id": "ADR-001",
+      "kind": "ADR",
+      "path": "docs/adr/0001-api-contract.md",
+      "status": "ACTIVE",
+      "revision": 1,
+      "supersedes": [],
+      "evidenceRef": null
+    },
+    {
+      "id": "SPEC-001",
+      "kind": "SPEC",
+      "path": "docs/specs/api.md",
+      "status": "ACTIVE",
+      "revision": 1,
+      "supersedes": [],
+      "evidenceRef": null
+    },
+    {
+      "id": "TICKET-001",
+      "kind": "TICKET",
+      "path": "tickets/001.md",
+      "status": "ACTIVE",
+      "revision": 2,
+      "requirementId": "REQ-001",
+      "requirementRevision": 2,
+      "changeImpact": "behavior",
+      "supersedes": [],
+      "evidenceRef": "feedback:changed-acceptance"
+    },
+    {
+      "id": "TEST-001",
+      "kind": "TEST",
+      "path": "tests/api.test.js",
+      "status": "ACTIVE",
+      "revision": 1,
+      "requirementId": "REQ-001",
+      "requirementRevision": 1,
+      "supersedes": [],
+      "evidenceRef": "tests/api.test.js#contract"
+    },
+    {
+      "id": "IMPL-001",
+      "kind": "IMPLEMENTATION",
+      "path": "src/api.js",
+      "status": "ACTIVE",
+      "revision": 1,
+      "requirementId": "REQ-001",
+      "requirementRevision": 1,
+      "supersedes": [],
+      "evidenceRef": "commit:baseline"
+    }
+  ],
+  "requirements": [
+    {
+      "requirementId": "REQ-001",
+      "revision": 1,
+      "status": "CURRENT",
+      "specId": "SPEC-001",
+      "decisionIds": [
+        "ADR-001"
+      ],
+      "ticketIds": [
+        "TICKET-001"
+      ],
+      "testIds": [
+        "TEST-001"
+      ],
+      "implementationIds": [
+        "IMPL-001"
+      ],
+      "requiredProbeIds": [
+        "PROBE-001"
+      ],
+      "sourceValidity": "VALID",
+      "supersededBy": null
+    }
+  ],
+  "probes": [
+    {
+      "probeId": "PROBE-001",
+      "requirementId": "REQ-001",
+      "status": "KILLED",
+      "sourceSection": "docs/specs/api.md#REQ-001",
+      "evidenceRef": "probe:baseline-red",
+      "workspaceIsolation": "isolated",
+      "failureClass": "contract"
+    }
+  ]
+}