harness-everything 0.38.0 → 0.40.0

package/benchmarks/results/reviews/pr353-r6-2026-10-22/peer-a-probe.log

@@ -0,0 +1,62 @@
+# worktree /Users/daniel.chang/Desktop/Skills/Harness-everything/.worktrees/353-r6-b
+PASS p1-control-eligible — expected eligible, got eligible
+PASS p1-joint-origin-task-substitution — expected rejected, got rejected (decision unresolved, codes identity-mismatch / cached unresolved)
+DIFF p1-plan-only-substitution — expected rejected, got accepted (decision eligible, codes )
+DIFF p1-config-bytes-substitution — expected rejected, got accepted (decision eligible, codes )
+PASS p2-asset-irrelevant — expected ready, got ready (ready)
+PASS p2-governed-path-unchanged — expected unavailable, got unavailable (inventory-unsupported)
+PASS p2-role-frontmatter-asset — expected unavailable, got unavailable (inventory-unsupported)
+DIFF p2-masked-frontmatter-asset — expected unavailable, got ready (ready)
+# summary: 5 match, 3 diverge of 8
+
+
+# worktree /Users/daniel.chang/Desktop/Skills/Harness-everything/.worktrees/353-r6-a
+PASS p1-control-eligible — expected eligible, got eligible
+PASS p1-joint-origin-task-substitution — expected rejected, got rejected (decision unresolved, codes identity-mismatch / cached unresolved)
+PASS p1-plan-only-substitution — expected rejected, got rejected (decision unresolved, codes identity-mismatch)
+PASS p1-config-bytes-substitution — expected rejected, got rejected (decision unresolved, codes config-capture-mismatch)
+PASS p2-asset-irrelevant — expected ready, got ready (ready)
+PASS p2-governed-path-unchanged — expected unavailable, got unavailable (inventory-unsupported)
+PASS p2-role-frontmatter-asset — expected unavailable, got unavailable (inventory-unsupported)
+PASS p2-masked-frontmatter-asset — expected unavailable, got unavailable (inventory-unsupported)
+# summary: 8 match, 0 diverge of 8
+
+
+# worktree /Users/daniel.chang/Desktop/Skills/Harness-everything/.worktrees/353-r6-a
+PASS p2-asset-irrelevant — expected ready, got ready (ready)
+PASS p2-governed-path-unchanged — expected unavailable, got unavailable (inventory-unsupported)
+PASS p2-role-frontmatter-asset — expected unavailable, got unavailable (inventory-unsupported)
+PASS p2-masked-frontmatter-asset — expected unavailable, got unavailable (inventory-unsupported)
+PASS p2-new-binary-governed-record — expected unavailable, got unavailable (inventory-unsupported)
+PASS p2-deleted-binary-governed-record — expected unavailable, got unavailable (inventory-unsupported)
+PASS p2-binary-bytes-covered-by-both-digests — expected differ, got differ
+PASS p2-producer-core-parity — expected no-errors, got no-errors
+PASS p2-malformed-record-rejected — expected invalid-input, got invalid-input
+# summary: 9 match, 0 diverge of 9
+# worktree /Users/daniel.chang/Desktop/Skills/Harness-everything/.worktrees/353-r6-b
+PASS p2-asset-irrelevant — expected ready, got ready (ready)
+PASS p2-governed-path-unchanged — expected unavailable, got unavailable (inventory-unsupported)
+PASS p2-role-frontmatter-asset — expected unavailable, got unavailable (inventory-unsupported)
+DIFF p2-masked-frontmatter-asset — expected unavailable, got ready (ready)
+PASS p2-new-binary-governed-record — expected unavailable, got unavailable (inventory-unsupported)
+PASS p2-deleted-binary-governed-record — expected unavailable, got unavailable (inventory-unsupported)
+PASS p2-binary-bytes-covered-by-both-digests — expected differ, got differ
+PASS p2-producer-core-parity — expected no-errors, got no-errors
+PASS p2-malformed-record-rejected — expected invalid-input, got invalid-input
+# summary: 8 match, 1 diverge of 9
+
+
+# worktree /Users/daniel.chang/Desktop/Skills/Harness-everything/.worktrees/353-r6-a
+PASS p1-control-eligible — expected eligible, got eligible
+PASS p1-joint-origin-task-substitution — expected rejected, got rejected (decision unresolved, codes identity-mismatch / cached unresolved)
+PASS p1-plan-only-substitution — expected rejected, got rejected (decision unresolved, codes identity-mismatch)
+PASS p1-config-bytes-substitution — expected rejected, got rejected (decision unresolved, codes config-capture-mismatch)
+DIFF p1-fully-joint-self-consistent-substitution — expected rejected, got accepted (decision eligible, codes )
+# summary: 4 match, 1 diverge of 5
+# worktree /Users/daniel.chang/Desktop/Skills/Harness-everything/.worktrees/353-r6-b
+PASS p1-control-eligible — expected eligible, got eligible
+PASS p1-joint-origin-task-substitution — expected rejected, got rejected (decision unresolved, codes identity-mismatch / cached unresolved)
+DIFF p1-plan-only-substitution — expected rejected, got accepted (decision eligible, codes )
+DIFF p1-config-bytes-substitution — expected rejected, got accepted (decision eligible, codes )
+DIFF p1-fully-joint-self-consistent-substitution — expected rejected, got accepted (decision eligible, codes )
+# summary: 2 match, 3 diverge of 5

package/benchmarks/results/reviews/pr353-r6-2026-10-22/peer-a-probe.txt

@@ -0,0 +1,313 @@
+#!/usr/bin/env node
+'use strict';
+
+// Independent cross-review probe (scratch, outside every repository).
+// Usage: node cross-review-probe.js <worktree-root> [case]
+// Cases: p1 | p2 | all
+// It builds one normative Git repository per case, then exercises the S2a producer/events/core of the
+// worktree under review. It prints a machine-readable verdict per case; it never writes into a repository.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { spawnSync } = require('child_process');
+
+const ROOT = path.resolve(process.argv[2] || '.');
+const ONLY = process.argv[3] || 'all';
+const TMP = process.env.PROBE_TMPDIR || os.tmpdir();
+const DERIVE_CONFIG = JSON.parse(fs.readFileSync(path.join(ROOT, 'ci/fixtures/doc-obligations/derive/config.json'), 'utf8'));
+const FIXTURE = path.join(ROOT, 'ci/fixtures/doc-obligations/derive/missing-approval');
+
+const sha256 = value => crypto.createHash('sha256').update(value).digest('hex');
+const clone = value => JSON.parse(JSON.stringify(value));
+const stable = value => JSON.stringify(value, (key, item) =>
+  (item && typeof item === 'object' && !Array.isArray(item)
+    ? Object.fromEntries(Object.keys(item).sort().map(k => [k, item[k]])) : item));
+
+function git(cwd, args) {
+  const env = { ...process.env };
+  for (const key of Object.keys(env)) if (key.startsWith('GIT_')) delete env[key];
+  env.GIT_AUTHOR_DATE = '2026-01-01T00:00:00Z';
+  env.GIT_COMMITTER_DATE = '2026-01-01T00:00:00Z';
+  const out = spawnSync('git', args, { cwd, encoding: 'utf8', env, timeout: 20000 });
+  if (out.status !== 0) throw new Error(`git ${args[0]} failed: ${out.stderr}`);
+  return out.stdout;
+}
+function writeFiles(root, files) {
+  for (const [rel, content] of Object.entries(files)) {
+    const target = path.join(root, rel);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, Buffer.from(content));
+  }
+}
+function makeRepo(baseFiles, binaryFiles = {}) {
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(TMP, 'probe-')));
+  git(root, ['init', '-q']);
+  writeFiles(root, { '.agents/harness-everything/project-docs.json': JSON.stringify(DERIVE_CONFIG, null, 2) + '\n', ...baseFiles });
+  writeFiles(root, binaryFiles);
+  git(root, ['add', '-A']);
+  git(root, ['-c', 'user.name=probe', '-c', 'user.email=probe@invalid', '-c', 'commit.gpgsign=false', 'commit', '-q', '--no-verify', '-m', 'baseline']);
+  return { root, commit: git(root, ['rev-parse', 'HEAD']).trim() };
+}
+function readTree(dir) {
+  const files = {};
+  const walk = current => {
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else files[path.relative(dir, full).split(path.sep).join('/')] = fs.readFileSync(full);
+    }
+  };
+  if (fs.existsSync(dir)) walk(dir);
+  return files;
+}
+
+class FakeOrigin {
+  constructor(context) { this.context = clone(context); this.refs = new Map(); }
+  issueEvent(reference, event) { this.refs.set(reference, clone(event)); }
+  resolveContext() { return { status: 'accepted', context: clone(this.context), originRef: 'fake-origin:context' }; }
+  resolveEvent({ reference }) {
+    if (!this.refs.has(reference)) return { status: 'rejected', diagnostics: [{ code: 'origin-untrusted', message: 'not issued' }] };
+    const event = clone(this.refs.get(reference));
+    return { status: 'accepted', event, originRef: event.originRef, correlation: { toolCorrelationId: event.toolCorrelationId || null } };
+  }
+}
+const CONTEXT = repo => ({
+  baseline: { root: repo.root, commit: repo.commit },
+  workspaceId: 'fake-workspace', sessionId: 'session-s2a-001', workflowId: 'wf-s2a-001', workflowRevision: 2,
+  taskId: 'task-s2a-001', principals: { author: 'author-principal', executors: ['executor-principal'] },
+  activeHost: { hostId: 'fake-host' }, baselineReference: 'fake-origin:workflow-start-baseline'
+});
+const TASK = {
+  taskId: 'task-s2a-001',
+  requirements: [
+    { id: 'req-docs', stepType: 'doc-change', summary: 'Update the PRD REQ text', acceptance: 'normative PRD text is reviewed', bindings: [] },
+    { id: 'req-verify', stepType: 'verification', summary: 'Verify the PRD change', acceptance: 'objective doc checks are recorded', bindings: [{ id: 'verification-loop' }] }
+  ]
+};
+function producerInput(repo) {
+  return {
+    workspaceRoot: repo.root, baseline: { root: repo.root, commit: repo.commit },
+    workflow: { workflowId: 'wf-s2a-001', workflowRevision: 2, sessionId: 'session-s2a-001' },
+    task: clone(TASK), scope: { prdRoot: 'docs/prd/' }, activeHost: { hostId: 'fake-host' }, prdRoot: 'docs/prd/'
+  };
+}
+function buildEvents(snapshot, repo) {
+  const events = {};
+  const digests = {};
+  for (const obligation of snapshot.obligations || []) {
+    for (const rel of (obligation.scope && obligation.scope.paths) || []) {
+      const abs = path.join(repo.root, rel);
+      digests[rel] = fs.existsSync(abs) ? sha256(fs.readFileSync(abs)) : null;
+    }
+  }
+  for (const obligation of snapshot.obligations || []) {
+    if (obligation.strength !== 'MUST' || obligation.applicability === 'N/A') continue;
+    const capability = obligation.capability;
+    const ref = `ref-${capability}`;
+    const common = {
+      eventId: `evt-${capability}`, producerId: 'fake-producer', identity: clone(snapshot.identity),
+      paths: [...(obligation.scope.paths || [])], provenance: 'fake-origin:fixture', capability,
+      originRef: `fake-origin:event:${ref}`
+    };
+    if (capability === 'quality-review') {
+      events[ref] = { ...common, kind: 'review', principalId: 'reviewer-principal', verdict: 'approve',
+        summary: `fixture review for ${capability}: approve`, reviewedArtifactDigests: clone(digests),
+        independentOf: ['author-principal', 'executor-principal'] };
+    } else {
+      events[ref] = { ...common, kind: 'execution', principalId: 'executor-principal', command: `fixture-check ${capability}`,
+        argv: ['fixture-check', capability], cwd: '.', exitCode: 0, signal: null, toolCorrelationId: `tool-${capability}`,
+        startIdentity: clone(snapshot.identity), endIdentity: clone(snapshot.identity), resultRef: `result-${capability}`,
+        artifactDigests: clone(digests) };
+    }
+  }
+  return events;
+}
+function codesOf(...results) {
+  const codes = new Set();
+  for (const result of results) {
+    for (const item of [...(result && result.diagnostics || []), ...(result && result.rejected || []), ...(result && result.unsatisfied || [])]) {
+      if (item && typeof item.code === 'string') codes.add(item.code);
+      if (item && typeof item.reasonCode === 'string') codes.add(item.reasonCode);
+    }
+  }
+  return [...codes].sort();
+}
+
+const CORE = path.join(ROOT, 'hooks/scripts/lib/doc-reconciliation-core.js');
+const PRODUCER = path.join(ROOT, 'hooks/scripts/lib/doc-reconciliation-producer.js');
+const EVENTS = path.join(ROOT, 'hooks/scripts/lib/doc-reconciliation-events.js');
+function load() {
+  for (const file of [CORE, PRODUCER, EVENTS]) delete require.cache[require.resolve(file)];
+  return { core: require(CORE), producer: require(PRODUCER), events: require(EVENTS) };
+}
+
+const results = [];
+function record(id, expected, actual, detail) {
+  results.push({ id, expected, actual, pass: expected === actual, detail });
+  console.log(`${expected === actual ? 'PASS' : 'DIFF'} ${id} — expected ${expected}, got ${actual}${detail ? ` (${detail})` : ''}`);
+}
+
+// ---- P1 probes -----------------------------------------------------------------------------------------------
+
+function flow(mods, repo) {
+  const origin = new FakeOrigin(CONTEXT(repo));
+  const produced = mods.producer.produceDocSnapshot(producerInput(repo), { originProvider: origin });
+  if (produced.state !== 'ready' || !produced.snapshot) return { produced, codes: codesOf(produced) };
+  const snapshot = produced.snapshot;
+  const events = buildEvents(snapshot, repo);
+  for (const [ref, event] of Object.entries(events)) origin.issueEvent(ref, event);
+  const accepted = mods.events.acceptDocEvents({ snapshot, eventRefs: Object.keys(events) }, { originProvider: origin });
+  const decision = mods.core.checkAcceptedDocEvidence({ snapshot, accepted, mode: 'verification' });
+  return { produced, snapshot, events, accepted, decision, origin, codes: codesOf(produced, accepted, decision) };
+}
+function rewriteCached(accepted, snapshot) {
+  const out = clone(accepted);
+  out.identity = clone(snapshot.identity);
+  out.originContext = clone(snapshot.originContext);
+  for (const key of Object.keys(out.acceptedIndex || {})) out.acceptedIndex[key].identity = clone(snapshot.identity);
+  return out;
+}
+
+function p1Probes(mods) {
+  const files = { base: readTree(path.join(FIXTURE, 'base')), candidate: readTree(path.join(FIXTURE, 'candidate')) };
+  const repo = makeRepo(files.base);
+  try {
+    writeFiles(repo.root, files.candidate);
+    const base = flow(mods, repo);
+    if (!base.snapshot) { record('p1-control-eligible', 'eligible', 'no-snapshot', base.codes.join(',')); return; }
+    record('p1-control-eligible', 'eligible', base.decision.eligible ? 'eligible' : 'not-eligible', base.codes.join(','));
+
+    // (1) Joint captured-origin + provider task substitution (the packet's named attack).
+    {
+      const snapshot = clone(base.snapshot);
+      snapshot.originContext.taskId = 'task-s2a-002';
+      base.origin.context.taskId = 'task-s2a-002';
+      const accepted = mods.events.acceptDocEvents({ snapshot, eventRefs: Object.keys(base.events) }, { originProvider: base.origin });
+      const decision = mods.core.checkAcceptedDocEvidence({ snapshot, accepted, mode: 'verification' });
+      const cached = clone(base.accepted); cached.originContext = clone(snapshot.originContext);
+      const replay = mods.core.checkAcceptedDocEvidence({ snapshot, accepted: cached, mode: 'verification' });
+      record('p1-joint-origin-task-substitution', 'rejected', (decision.eligible || replay.eligible) ? 'accepted' : 'rejected',
+        `decision ${decision.decision}, codes ${codesOf(accepted, decision).join(',')} / cached ${replay.decision}`);
+    }
+    // (2) Plan-only substitution: the captured plan names another workflow, the plan digest is recomputed,
+    //     the identity and the origin context keep the original tuple.
+    {
+      const snapshot = clone(base.snapshot);
+      snapshot.taskSemantics.workflow.workflowId = 'wf-substituted';
+      snapshot.identity.taskScopeDigest = mods.core._internals.structuredDigest('doc-task-scope-v1', snapshot.taskSemantics);
+      const cached = rewriteCached(base.accepted, snapshot);
+      const decision = mods.core.checkAcceptedDocEvidence({ snapshot, accepted: cached, mode: 'verification' });
+      record('p1-plan-only-substitution', 'rejected', decision.eligible ? 'accepted' : 'rejected',
+        `decision ${decision.decision}, codes ${codesOf(decision).join(',')}`);
+    }
+    // (3) Config-bytes substitution: the captured config bytes are replaced, every digest that names them is
+    //     recomputed, and the cached acceptance is restated to match.
+    {
+      const snapshot = clone(base.snapshot);
+      const source = snapshot.config.capture.sources.find(item => item.presence === 'present');
+      source.bytes = Buffer.from('{"governed":[]}\n');
+      source.digest = sha256(source.bytes);
+      snapshot.config.digest = mods.core._internals.configDigest(snapshot.config);
+      snapshot.identity.configDigest = snapshot.config.digest;
+      snapshot.taskSemantics.configDigest = snapshot.config.digest;
+      snapshot.identity.taskScopeDigest = mods.core._internals.structuredDigest('doc-task-scope-v1', snapshot.taskSemantics);
+      const cached = rewriteCached(base.accepted, snapshot);
+      const decision = mods.core.checkAcceptedDocEvidence({ snapshot, accepted: cached, mode: 'verification' });
+      record('p1-config-bytes-substitution', 'rejected', decision.eligible ? 'accepted' : 'rejected',
+        `decision ${decision.decision}, codes ${codesOf(decision).join(',')}`);
+    }
+    // (4) Fully joint, self-consistent substitution: captured origin context, provider context, identity,
+    //     captured plan and every digest that names them, plus the cached acceptance, all restated together.
+    {
+      const snapshot = clone(base.snapshot);
+      snapshot.originContext.taskId = 'task-s2a-002';
+      base.origin.context.taskId = 'task-s2a-002';
+      snapshot.identity.taskId = 'task-s2a-002';
+      snapshot.taskSemantics.task.taskId = 'task-s2a-002';
+      snapshot.identity.taskScopeDigest = mods.core._internals.structuredDigest('doc-task-scope-v1', snapshot.taskSemantics);
+      const cached = rewriteCached(base.accepted, snapshot);
+      const decision = mods.core.checkAcceptedDocEvidence({ snapshot, accepted: cached, mode: 'verification' });
+      record('p1-fully-joint-self-consistent-substitution', 'rejected', decision.eligible ? 'accepted' : 'rejected',
+        `decision ${decision.decision}, codes ${codesOf(decision).join(',')}`);
+    }
+  } finally { fs.rmSync(repo.root, { recursive: true, force: true }); }
+}
+
+// ---- P2 probes -----------------------------------------------------------------------------------------------
+
+const BINARY = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0a, 0x1a, 0x0a, 0x00, 0xff, 0xfe, 0x80, 0x81]);
+const ROLE_FRONT = Buffer.from('---\nrole: prd\nid: PRD-GRPH-999\nrevision: 1\nstatus: draft\n---\n### REQ-GRPH-999\n\nbinary requirement\n\nAcceptance: evaluate it.\n');
+const MASKED_FRONT = Buffer.concat([Buffer.from('---\nrole: prd\nid: PRD-GRPH-999\n'), Buffer.from([0xff]), Buffer.from('\n---\nbody\n')]);
+
+function p2Probes(mods) {
+  const files = { base: readTree(path.join(FIXTURE, 'base')), candidate: readTree(path.join(FIXTURE, 'candidate')) };
+  const cases = [
+    ['p2-asset-irrelevant', 'assets/logo.png', BINARY, 'ready'],
+    ['p2-governed-path-unchanged', 'docs/prd/diagram.png', BINARY, 'unavailable'],
+    ['p2-role-frontmatter-asset', 'assets/role.dat', Buffer.concat([ROLE_FRONT, BINARY]), 'unavailable'],
+    ['p2-masked-frontmatter-asset', 'assets/masked.dat', MASKED_FRONT, 'unavailable']
+  ];
+  for (const [id, rel, bytes, expected] of cases) {
+    const repo = makeRepo(files.base, { [rel]: bytes });
+    try {
+      writeFiles(repo.root, { ...files.candidate, [rel]: bytes });
+      const origin = new FakeOrigin(CONTEXT(repo));
+      const produced = mods.producer.produceDocSnapshot(producerInput(repo), { originProvider: origin });
+      const actual = produced.state === 'ready' ? 'ready' : 'unavailable';
+      record(id, expected, actual, codesOf(produced).join(',') || produced.state);
+    } finally { fs.rmSync(repo.root, { recursive: true, force: true }); }
+  }
+
+  // New and deleted record identity: a binary record that only exists on one side of the capture.
+  for (const [id, rel, mode, expected] of [
+    ['p2-new-binary-governed-record', 'docs/prd/new.bin', 'new', 'unavailable'],
+    ['p2-deleted-binary-governed-record', 'docs/prd/old.bin', 'deleted', 'unavailable']
+  ]) {
+    const repo = makeRepo(mode === 'new' ? files.base : { ...files.base, [rel]: BINARY });
+    try {
+      if (mode === 'new') writeFiles(repo.root, { ...files.candidate, [rel]: BINARY });
+      else writeFiles(repo.root, files.candidate);
+      const origin = new FakeOrigin(CONTEXT(repo));
+      const produced = mods.producer.produceDocSnapshot(producerInput(repo), { originProvider: origin });
+      const actual = produced.state === 'ready' ? 'ready' : 'unavailable';
+      record(id, expected, actual, codesOf(produced).join(',') || produced.state);
+    } finally { fs.rmSync(repo.root, { recursive: true, force: true }); }
+  }
+
+  // Binary bytes stay in the whole-project hash, and producer/core re-derivation agree on the same snapshot.
+  {
+    const plain = makeRepo(files.base);
+    const withAsset = makeRepo(files.base, { 'assets/logo.png': BINARY });
+    try {
+      writeFiles(plain.root, files.candidate);
+      writeFiles(withAsset.root, { ...files.candidate, 'assets/logo.png': BINARY });
+      const plainOrigin = new FakeOrigin(CONTEXT(plain));
+      const assetOrigin = new FakeOrigin(CONTEXT(withAsset));
+      const plainSnapshot = mods.producer.produceDocSnapshot(producerInput(plain), { originProvider: plainOrigin });
+      const assetSnapshot = mods.producer.produceDocSnapshot(producerInput(withAsset), { originProvider: assetOrigin });
+      const digestsDiffer = plainSnapshot.snapshot.identity.candidateDigest !== assetSnapshot.snapshot.identity.candidateDigest
+        && plainSnapshot.snapshot.identity.baselineDigest !== assetSnapshot.snapshot.identity.baselineDigest;
+      record('p2-binary-bytes-covered-by-both-digests', 'differ', digestsDiffer ? 'differ' : 'same');
+      const errors = mods.core._internals.validateSnapshot(assetSnapshot.snapshot);
+      record('p2-producer-core-parity', 'no-errors', errors.length ? JSON.stringify(errors) : 'no-errors');
+      // A record whose stored bytes do not match its digest must not verify.
+      const tampered = clone(assetSnapshot.snapshot);
+      const record0 = tampered.candidate.records.find(item => item.path === 'assets/logo.png');
+      record0.digest = '0'.repeat(64);
+      const tamperedErrors = mods.core._internals.validateSnapshot(tampered);
+      record('p2-malformed-record-rejected', 'invalid-input',
+        tamperedErrors.some(item => item.code === 'invalid-input') ? 'invalid-input' : JSON.stringify(tamperedErrors));
+    } finally {
+      fs.rmSync(plain.root, { recursive: true, force: true });
+      fs.rmSync(withAsset.root, { recursive: true, force: true });
+    }
+  }
+}
+
+const mods = load();
+console.log(`# worktree ${ROOT}`);
+if (ONLY === 'p1' || ONLY === 'all') p1Probes(mods);
+if (ONLY === 'p2' || ONLY === 'all') p2Probes(mods);
+console.log(`# summary: ${results.filter(r => r.pass).length} match, ${results.filter(r => !r.pass).length} diverge of ${results.length}`);

package/benchmarks/results/reviews/pr353-r6-2026-10-22/peer-b-probe.log

@@ -0,0 +1,51 @@
+== 353-r6-a (/Users/daniel.chang/Desktop/Skills/Harness-everything/.worktrees/353-r6-a) ==
+{"name":"frontmatter-role-nonclassified","state":"unavailable","codes":["inventory-unsupported"]}
+{"name":"req-citing-test","state":"unavailable","codes":["inventory-unsupported"]}
+{"name":"req-block-nonclassified","state":"ready","musts":[],"requirementSync":{"applicability":"N/A","scope":[],"citedReqs":[]}}
+{"name":"deleted-req-block","state":"ready","musts":[],"requirementSync":{"applicability":"N/A","scope":[],"citedReqs":[]}}
+{"name":"irrelevant-asset-control","state":"ready","musts":[],"requirementSync":{"applicability":"N/A","scope":[],"citedReqs":[]}}
+---
+== 353-r6-b (/Users/daniel.chang/Desktop/Skills/Harness-everything/.worktrees/353-r6-b) ==
+{"name":"frontmatter-role-nonclassified","state":"unavailable","codes":["inventory-unsupported"]}
+{"name":"req-citing-test","state":"unavailable","codes":["inventory-unsupported"]}
+{"name":"req-block-nonclassified","state":"ready","musts":[],"requirementSync":{"applicability":"N/A","scope":[],"citedReqs":[]}}
+{"name":"deleted-req-block","state":"ready","musts":[],"requirementSync":{"applicability":"N/A","scope":[],"citedReqs":[]}}
+{"name":"irrelevant-asset-control","state":"ready","musts":[],"requirementSync":{"applicability":"N/A","scope":[],"citedReqs":[]}}
+
+
+== 353-r6-a (/Users/daniel.chang/Desktop/Skills/Harness-everything/.worktrees/353-r6-a) ==
+{"name":"frontmatter-role-nonclassified","state":"unavailable","codes":["inventory-unsupported"]}
+{"name":"req-citing-test","state":"unavailable","codes":["inventory-unsupported"]}
+{"name":"req-block-nonclassified","state":"ready","musts":[],"requirementSync":{"applicability":"N/A","scope":[],"citedReqs":[]}}
+{"name":"deleted-req-block","state":"ready","musts":[],"requirementSync":{"applicability":"N/A","scope":[],"citedReqs":[]}}
+{"name":"req-citation-scope","state":"ready","musts":["doc-change:requirement-sync"],"requirementSync":{"applicability":"unknown","scope":["src/lint.js"],"citedReqs":[]}}
+{"name":"irrelevant-asset-control","state":"ready","musts":[],"requirementSync":{"applicability":"N/A","scope":[],"citedReqs":[]}}
+---
+== 353-r6-b (/Users/daniel.chang/Desktop/Skills/Harness-everything/.worktrees/353-r6-b) ==
+{"name":"frontmatter-role-nonclassified","state":"unavailable","codes":["inventory-unsupported"]}
+{"name":"req-citing-test","state":"unavailable","codes":["inventory-unsupported"]}
+{"name":"req-block-nonclassified","state":"ready","musts":[],"requirementSync":{"applicability":"N/A","scope":[],"citedReqs":[]}}
+{"name":"deleted-req-block","state":"ready","musts":[],"requirementSync":{"applicability":"N/A","scope":[],"citedReqs":[]}}
+{"name":"req-citation-scope","state":"ready","musts":["doc-change:requirement-sync"],"requirementSync":{"applicability":"unknown","scope":["src/lint.js"],"citedReqs":[]}}
+{"name":"irrelevant-asset-control","state":"ready","musts":[],"requirementSync":{"applicability":"N/A","scope":[],"citedReqs":[]}}
+
+
+== 353-r6-a (/Users/daniel.chang/Desktop/Skills/Harness-everything/.worktrees/353-r6-a) ==
+{"name":"frontmatter-role-nonclassified","state":"unavailable","codes":["inventory-unsupported"]}
+{"name":"req-citing-test","state":"unavailable","codes":["inventory-unsupported"]}
+{"name":"req-block-nonclassified","state":"ready","musts":[],"requirementSync":{"applicability":"N/A","scope":[],"citedReqs":[]}}
+{"name":"deleted-req-block","state":"ready","musts":[],"requirementSync":{"applicability":"N/A","scope":[],"citedReqs":[]}}
+{"name":"req-citation-scope","state":"ready","musts":["doc-change:requirement-sync"],"requirementSync":{"applicability":"unknown","scope":["src/lint.js"],"citedReqs":[]}}
+{"name":"irrelevant-asset-control","state":"ready","musts":[],"requirementSync":{"applicability":"N/A","scope":[],"citedReqs":[]}}
+{"name":"undecodable-test-path-no-req","state":"unavailable","codes":["inventory-unsupported"]}
+{"name":"undecodable-code-path-no-req","state":"unavailable","codes":["inventory-unsupported"]}
+---
+== 353-r6-b (/Users/daniel.chang/Desktop/Skills/Harness-everything/.worktrees/353-r6-b) ==
+{"name":"frontmatter-role-nonclassified","state":"unavailable","codes":["inventory-unsupported"]}
+{"name":"req-citing-test","state":"unavailable","codes":["inventory-unsupported"]}
+{"name":"req-block-nonclassified","state":"ready","musts":[],"requirementSync":{"applicability":"N/A","scope":[],"citedReqs":[]}}
+{"name":"deleted-req-block","state":"ready","musts":[],"requirementSync":{"applicability":"N/A","scope":[],"citedReqs":[]}}
+{"name":"req-citation-scope","state":"ready","musts":["doc-change:requirement-sync"],"requirementSync":{"applicability":"unknown","scope":["src/lint.js"],"citedReqs":[]}}
+{"name":"irrelevant-asset-control","state":"ready","musts":[],"requirementSync":{"applicability":"N/A","scope":[],"citedReqs":[]}}
+{"name":"undecodable-test-path-no-req","state":"ready","musts":[],"requirementSync":{"applicability":"N/A","scope":[],"citedReqs":[]}}
+{"name":"undecodable-code-path-no-req","state":"unavailable","codes":["inventory-unsupported"]}

package/benchmarks/results/reviews/pr353-r6-2026-10-22/peer-b-probe.txt

@@ -0,0 +1,94 @@
+'use strict';
+// Independent cross-review probe (leg B as reviewer). Read-only against both implementation worktrees.
+// Uses only the harness API common to both legs (makeRepo/writeFiles with Buffer content).
+const path = require('path');
+const fs = require('fs');
+
+const BINARY = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0a, 0x1a, 0x0a, 0x00, 0xff, 0xfe, 0x80, 0x81]);
+const PRD = '---\nid: PRD-GRPH-001\nrevision: 1\nstatus: draft\n---\n### REQ-GRPH-001\n\nThe rule.\n\nAcceptance: it holds.\n';
+
+function load(root) {
+  const H = require(path.join(root, 'ci/fixtures/doc-obligations/reconciliation-s2a/harness.js'));
+  const P = require(path.join(root, 'hooks/scripts/lib/doc-reconciliation-producer.js'));
+  return { H, P };
+}
+
+function describe(snapshot) {
+  if (!snapshot) return null;
+  const req = (snapshot.obligations || []).find(o => o.capability === 'requirement-sync');
+  const musts = (snapshot.obligations || []).filter(o => o.strength === 'MUST' && o.applicability !== 'N/A').map(o => o.id).sort();
+  return {
+    musts,
+    requirementSync: req ? { applicability: req.applicability, scope: (req.scope.paths || []).slice(), citedReqs: req.citedReqs || [] } : null
+  };
+}
+
+function runCase(root, name, build) {
+  const { H, P } = load(root);
+  const files = build();
+  const repo = H.makeRepo(files.base);
+  try {
+    H.writeFiles(repo.root, files.candidate);
+    const origin = new H.FakeOrigin({ context: H.fakeContext({}, repo) });
+    const produced = P.produceDocSnapshot(H.producerInput(repo), { originProvider: origin });
+    if (produced.state !== 'ready') {
+      return { name, state: produced.state, codes: H.codesOf(produced) };
+    }
+    return { name, state: 'ready', ...describe(produced.snapshot) };
+  } finally { H.removeRepo(repo.root); }
+}
+
+const CASES = {
+  // A candidate record whose bytes carry a role: prd frontmatter, at a path no config glob classifies.
+  'frontmatter-role-nonclassified': () => ({
+    base: { 'docs/prd/graph.md': PRD, 'assets/role.dat': BINARY },
+    candidate: { 'docs/prd/graph.md': PRD, 'assets/role.dat': Buffer.concat([Buffer.from('---\nrole: prd\nid: PRD-GRPH-999\nrevision: 1\nstatus: draft\n---\n### REQ-GRPH-999\n\nBinary requirement.\n'), BINARY]) }
+  }),
+  // A candidate record whose bytes are a REQ-citing test, at a test path.
+  'req-citing-test': () => ({
+    base: { 'docs/prd/graph.md': PRD, 'tests/fixture.dat': BINARY },
+    candidate: { 'docs/prd/graph.md': PRD, 'tests/fixture.dat': Buffer.concat([Buffer.from('// REQ-GRPH-001\nit("requires the rule", () => { expect(true).toBe(true); });\n'), BINARY]) }
+  }),
+  // A candidate record whose bytes declare a REQ block at a path no config glob classifies, with a changed
+  // test that cites that REQ id.
+  'req-block-nonclassified': () => ({
+    base: { 'docs/prd/graph.md': PRD, 'tests/req.test.js': '// REQ-GRPH-001\nit("a", () => {});\n', 'assets/req.md': BINARY },
+    candidate: { 'docs/prd/graph.md': PRD, 'tests/req.test.js': '// REQ-GRPH-001\nit("b", () => {});\n', 'assets/req.md': Buffer.concat([Buffer.from('### REQ-GRPH-001\n\nThe binary declares the requirement.\n'), BINARY]) }
+  }),
+  // The same, with the record deleted in the candidate (new/deleted record identity).
+  'deleted-req-block': () => ({
+    base: { 'docs/prd/graph.md': PRD, 'tests/req.test.js': '// REQ-GRPH-001\nit("a", () => {});\n', 'assets/req.md': Buffer.concat([Buffer.from('### REQ-GRPH-001\n\nThe binary declares the requirement.\n'), BINARY]) },
+    candidate: { 'docs/prd/graph.md': PRD, 'tests/req.test.js': '// REQ-GRPH-001\nit("b", () => {});\n', 'assets/req.md': null }
+  }),
+  // A live requirement-sync surface (changed code + changed REQ-citing test) plus a candidate record whose
+  // bytes declare the cited REQ at a path no config glob classifies.
+  'req-citation-scope': () => ({
+    base: { 'src/lint.js': 'exports.run = () => 1;\n', 'tests/req.test.js': '// REQ-GRPH-001\nit("a", () => {});\n', 'assets/req.md': BINARY },
+    candidate: { 'src/lint.js': 'exports.run = () => 2;\n', 'tests/req.test.js': '// REQ-GRPH-001\nit("b", () => {});\n', 'assets/req.md': Buffer.concat([Buffer.from('### REQ-GRPH-001\n\nThe binary declares the requirement.\n'), BINARY]) }
+  }),
+  // Control: an ordinary irrelevant binary asset must not change the document obligations.
+  'irrelevant-asset-control': () => ({
+    base: { 'docs/prd/graph.md': PRD, 'assets/logo.png': BINARY },
+    candidate: { 'docs/prd/graph.md': PRD, 'assets/logo.png': Buffer.concat([BINARY, Buffer.from([1])]) }
+  }),
+  // An undecodable record at a REQ-test path with no REQ id: the packet forbids silently dropping a test
+  // input, so this case separates "fails closed" from "omitted".
+  'undecodable-test-path-no-req': () => ({
+    base: { 'docs/prd/graph.md': PRD, 'tests/plain.dat': BINARY },
+    candidate: { 'docs/prd/graph.md': PRD, 'tests/plain.dat': Buffer.concat([BINARY, Buffer.from([1])]) }
+  }),
+  // An undecodable record at a code path with no REQ id.
+  'undecodable-code-path-no-req': () => ({
+    base: { 'docs/prd/graph.md': PRD, 'src/plain.js': BINARY },
+    candidate: { 'docs/prd/graph.md': PRD, 'src/plain.js': Buffer.concat([BINARY, Buffer.from([1])]) }
+  })
+};
+
+const root = path.resolve(process.argv[2]);
+console.log(`== ${path.basename(root)} (${root}) ==`);
+for (const [name, build] of Object.entries(CASES)) {
+  let outcome;
+  try { outcome = runCase(root, name, build); }
+  catch (error) { outcome = { name, state: 'ERROR', detail: error.message.split('\n')[0] }; }
+  console.log(JSON.stringify(outcome));
+}

package/benchmarks/results/reviews/pr353-r6-2026-10-22/semantic-transitions.txt

@@ -0,0 +1,25 @@
+'use strict';
+const fs=require('fs'),path=require('path'),assert=require('assert/strict');
+const root=path.resolve(process.argv[2]);
+const H=require(path.join(root,'ci/fixtures/doc-obligations/reconciliation-s2a/harness.js'));
+const binary=Buffer.from([0x89,0,0xff]);let passed=0,failed=0;
+for(const leg of H.LEGS) for(const vector of ['frontmatter','req-test']) {
+ const P=require(path.join(leg.lib,'doc-reconciliation-producer.js'));
+ const files=H.vectorFiles('normative');const name=vector==='frontmatter'?'assets/role.dat':'tests/fixture.dat';
+ const repo=H.makeRepo({...files.base,[name]:binary});
+ try {
+  H.writeFiles(repo.root,files.candidate);
+  const content=vector==='frontmatter'?'---\nrole: prd\nid: PRD-GRPH-999\nrevision: 1\nstatus: draft\n---\n### REQ-GRPH-999\n\nThe binary candidate carries a requirement.\n\nAcceptance: evaluate this requirement.\n':'// REQ-GRPH-001\nit("requires the rule", () => { expect(true).toBe(true); });\n';
+  fs.writeFileSync(path.join(repo.root,name),Buffer.concat([Buffer.from(content),binary]));
+  const provider=new H.FakeOrigin({context:H.fakeContext({},repo)});
+  const produced=P.produceDocSnapshot(H.producerInput(repo),{originProvider:provider});
+  if(produced.state==='ready') {
+   const obligations=produced.snapshot.obligations;
+   const relevant=vector==='frontmatter'?obligations.some(o=>o.strength==='MUST'&&o.applicability!=='N/A'&&o.scope.paths.includes(name)):obligations.some(o=>o.capability==='requirement-sync'&&o.applicability!=='N/A');
+   assert(relevant,'candidate semantic content was omitted after probing only baseline bytes');
+  }
+  passed++;console.log('PASS',leg.name,vector,produced.state);
+ } catch(e) { failed++; console.error('FAIL',leg.name,vector,e.message); }
+ finally{H.removeRepo(repo.root);}
+}
+console.log(JSON.stringify({passed,failed}));process.exitCode=failed?1:0;

package/benchmarks/results/reviews/pr353-r6-2026-10-22/source.sha256

@@ -0,0 +1,9 @@
+5c3bcb7b7be96eee74e42885c436fdcb71da7c20e51cd372362f6bfc9cb08dc6  CHANGELOG.md
+58a327f0c4ee3f97f321ecfae1a3e05e398b3073c8b891da03bd7e6962d5b09a  ci/fixtures/doc-obligations/reconciliation-s2a/harness.js
+0080edd1826c70d141a61b513d2a3be9c42d060e979f34ac74dd6519f2a5dbf0  ci/mechanism-325-3b-s2a-core.test.js
+d4f4ec39e56f31cc15797cf79b9342edb3037c887057f81c5b7eb80bdc82323e  ci/mechanism-325-3b-s2a-producer.test.js
+10f2cb94c45a765d5ec7aa8edd8f9d2e5821c25119cae1c3446309e9f8a958d5  docs/doc-workflow-reconciliation.md
+b4345651686c7b7d8e4ed66e416137aa3b42e17fa5c42bbf03c69b4eb8dad471  hooks/scripts/lib/doc-reconciliation-core.js
+f8f5683fba9ea071e0cec83fdd7ca88c85a178f7ab9dabc98bb4b57b62b11599  hooks/scripts/lib/doc-reconciliation-producer.js
+b4345651686c7b7d8e4ed66e416137aa3b42e17fa5c42bbf03c69b4eb8dad471  plugins/harness-everything/hooks/scripts/lib/doc-reconciliation-core.js
+f8f5683fba9ea071e0cec83fdd7ca88c85a178f7ab9dabc98bb4b57b62b11599  plugins/harness-everything/hooks/scripts/lib/doc-reconciliation-producer.js