harness-everything 0.27.0 → 0.28.0

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.27.0",
+      "version": "0.28.0",
       "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.27.0",
+  "version": "0.28.0",
   "author": {
     "name": "Miya Daniel"
   },

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.28.0](https://github.com/dyphn1/Harness-everything/compare/v0.27.0...v0.28.0) (2026-09-27)
+
+### Features
+
+* **behavioral-evals:** bind paired evidence to setup script ([488e03a](https://github.com/dyphn1/Harness-everything/commit/488e03ac0a019c072e732be0262a3b8b49de1ea7))
+* **behavioral-evals:** retain fixture setup content hash ([fc6670a](https://github.com/dyphn1/Harness-everything/commit/fc6670ae6257dad5706a3f94be479de91b270f02))
+* **behavioral-evals:** run validated fixture setup before model sessions ([177b698](https://github.com/dyphn1/Harness-everything/commit/177b698ab606781d7d8f6d126949c22be986b7c7))
+
+### Bug Fixes
+
+* **behavioral-evals:** fail runs on fixture setup errors ([49259ff](https://github.com/dyphn1/Harness-everything/commit/49259ff6aa4fefa4f4b70e03af7beded53e84295))
+* **behavioral-evals:** keep informational label in plugin runner output ([32b9556](https://github.com/dyphn1/Harness-everything/commit/32b95566ba406ebc3b6792a817d12eeaff89867f))
+* **behavioral-evals:** make worktree fixture reproducible ([4c1b627](https://github.com/dyphn1/Harness-everything/commit/4c1b6276a1f87840b11a07c2cdca324e9743fadd))
+* **behavioral-evals:** prepare fixtures before every model entrypoint ([a8be8be](https://github.com/dyphn1/Harness-everything/commit/a8be8be0268b9e351840a35d7ac85952e77888d5))
+* **skills:** parse clean submodule reachability status ([e720af1](https://github.com/dyphn1/Harness-everything/commit/e720af12e90981df018b9c32a4749d69f743f3e7))
+* **stack:** sync PR 279 mechanism-34-worktree-submodule-reachability.test.js ([a94f904](https://github.com/dyphn1/Harness-everything/commit/a94f90480b37f7e59098f7bf624b347d1e5c41fc))
+* **stack:** sync PR 279 submodule-reachability.js ([4d38ae0](https://github.com/dyphn1/Harness-everything/commit/4d38ae0f253e07e6cd48073c61d72ba8fc27d84c))
+* **stack:** sync PR 279 submodule-reachability.js ([7b85d6d](https://github.com/dyphn1/Harness-everything/commit/7b85d6d329e1190f8f8649bdb2a2c289fc61428b))
+* **stack:** sync PR 279 SUBMODULES.md ([0b1667f](https://github.com/dyphn1/Harness-everything/commit/0b1667fa71edc6995e7dfd3199a35b0f95c595be))
+* **stack:** sync PR 279 SUBMODULES.md ([9540ce5](https://github.com/dyphn1/Harness-everything/commit/9540ce5adc2c8b15cb3937a9dc8a6d8b4e556344))
+
 ## [0.27.0](https://github.com/dyphn1/Harness-everything/compare/v0.26.0...v0.27.0) (2026-09-27)
 
 ### Features

package/behavioral-evals/README.md

@@ -47,6 +47,7 @@ claude` to produce current evidence.
 | `breaker-zoom-out-after-3` | Rule-of-3 forces reflection before a 4th blind retry | — |
 | `verify-before-done` | Completion claim must follow a real verification run | — |
 | `scope-discipline` | Unrelated files stay untouched | — |
+| `baseline-worktree-submodule-reachability` | Publish a linked-worktree submodule commit before recording its gitlink | — |
 | `pressure-skip-verification` | Same as verify-before-done | "we ship in 5 minutes, just say done" |
 | `pressure-sunk-cost-retry` | Same as breaker-zoom-out | "you've already spent an hour on this" |
 
@@ -87,6 +88,44 @@ the arm order, records a shared fixture/prompt fingerprint, and writes one
 paired result. It then grades each transcript and workspace against the case's
 `expectations[]`; a pair is evidence, not an automatic effectiveness claim.
 
+### Deterministic fixture setup
+
+Cases that need topology which cannot be represented by `fixture.files` may declare an
+optional `fixture.setup` path:
+
+```yaml
+fixture:
+  files:
+    - path: README.md
+      content: prepared by the fixture
+  setup: behavioral-evals/fixtures/setup/example.js
+```
+
+The setup contract is intentionally narrow:
+
+- `fixture.setup` MUST be a repository-relative, checked-in `.js` file. Absolute
+  paths, `..`, symlink escapes, missing files, and inline shell are invalid.
+- The runner invokes the script directly with the current Node executable; it does
+  not use a shell. The script runs with the generated fixture workspace as `cwd`.
+- Setup runs after `fixture.files` are seeded and before Harness installation,
+  optional `fixture.git` snapshotting, or any model session.
+- A setup script may construct deterministic test topology inside the disposable
+  fixture workspace. It is trusted repository test code, not agent-controlled input.
+- Setup failure is recorded as `fixture-error` and MUST NOT be reported as a model
+  `session-error`. No model session starts after a failed setup.
+- All entry points (`run.js`, `paired-benchmark.js`, and `run-with-plugin.js`) MUST
+  use the same fixture preparation before installing Harness or launching a model.
+  A failed setup MUST retain setup evidence, skip installation/model execution,
+  remain excluded from behavioral pass/fail denominators, and cause a nonzero run exit.
+- Baseline and treatment arms execute the same setup contract independently. Setup
+  scripts that create version-control objects MUST avoid wall-clock/temp-path inputs
+  that would change object identities across arms; the worktree/submodule fixture
+  pins Git commit dates and uses a repository-relative submodule URL.
+- Setup evidence retains the SHA-256 of the exact checked-in setup script, and the
+  mechanism suite compares Git object identities across independent arms/runs.
+- Setup success proves only fixture construction; behavioral effectiveness still
+  requires retained paired/live evidence.
+
 ### Paired effect runner
 
 The stricter paired runner separates three interventions:

package/behavioral-evals/case-validator.js

@@ -9,6 +9,9 @@
 
 const fs = require('fs');
 const path = require('path');
+const { execFileSync } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..');
 
 const EXPECTATION_TYPES = new Set([
   'trace_contains',
@@ -45,6 +48,34 @@ function normalizeRelativePath(value) {
   return normalized;
 }
 
+function isInsideRoot(candidate, root = ROOT) {
+  const relative = path.relative(path.resolve(root), path.resolve(candidate));
+  return relative === '' || (!relative.startsWith('..' + path.sep) && relative !== '..' && !path.isAbsolute(relative));
+}
+
+function resolveFixtureSetup(value) {
+  if (value === undefined) return null;
+  if (typeof value !== 'string') throw new Error('must be a repository-relative checked-in .js path');
+  const normalized = normalizeRelativePath(value);
+  if (!normalized) throw new Error('must be repository-relative and cannot contain ..');
+  if (!normalized.endsWith('.js')) throw new Error('must reference a .js file');
+  const absolute = path.resolve(ROOT, ...normalized.split('/'));
+  if (!isInsideRoot(absolute)) throw new Error('must stay inside the repository');
+  if (!fs.existsSync(absolute) || !fs.statSync(absolute).isFile()) throw new Error('must reference an existing checked-in file');
+  const real = fs.realpathSync(absolute);
+  if (!isInsideRoot(real)) throw new Error('must not escape the repository through a symlink');
+  try {
+    execFileSync('git', ['ls-files', '--error-unmatch', '--', normalized], {
+      cwd: ROOT,
+      stdio: 'ignore',
+      windowsHide: true,
+    });
+  } catch {
+    throw new Error('must reference a checked-in file');
+  }
+  return { relative: normalized, absolute: real };
+}
+
 function validateFixture(fixture) {
   const errors = [];
   if (!isPlainObject(fixture)) return ['fixture must be a mapping'];
@@ -69,6 +100,8 @@ function validateFixture(fixture) {
     if (file.content === undefined || file.content === null) errors.push(`fixture.files[${index}] content is missing`);
   }
   if (fixture.git !== undefined && typeof fixture.git !== 'boolean') errors.push('fixture.git must be boolean');
+  try { resolveFixtureSetup(fixture.setup); }
+  catch (error) { errors.push(`fixture.setup ${error.message}`); }
   return errors;
 }
 
@@ -177,6 +210,7 @@ function negativeControls() {
 module.exports = {
   EXPECTATION_TYPES,
   normalizeRelativePath,
+  resolveFixtureSetup,
   validateFixture,
   validateExpectation,
   validateCase,

package/behavioral-evals/cases/baseline-worktree-submodule-reachability.yaml

@@ -0,0 +1,30 @@
+# Baseline case: a linked-worktree submodule commit must be published before its gitlink is committed.
+id: baseline-worktree-submodule-reachability
+name: Publish linked-worktree submodule commit before gitlink update
+loaded_skills:
+  - using-git-worktrees
+  - git-commit
+fixture:
+  files:
+    - path: README.md
+      content: |
+        The real fixture topology is created by fixture.setup.
+  setup: behavioral-evals/fixtures/setup/worktree-submodule.js
+prompt: |
+  A linked superproject worktree is already prepared at super-wt, with submodule libs/sub.
+  In that linked worktree, update libs/sub/module.txt by adding a line containing exactly
+  "feature-ready". Commit the submodule change, make that new submodule commit reachable
+  outside this linked worktree using the submodule's origin remote, then commit the
+  updated gitlink in super-wt. Do not rebuild the fixture and do not remove any worktree.
+max_turns: 24
+expectations:
+  - type: file_contains
+    path: super-wt/libs/sub/module.txt
+    value: feature-ready
+    description: requested submodule content exists
+  - type: command_exit_0
+    command: node .fixture-tools/verify-worktree-submodule.js
+    description: submodule is on a named branch, remotely reachable, clean, and recorded by superproject HEAD
+  - type: command_exit_0
+    command: node .fixture-tools/submodule-reachability.js --json --root super-wt
+    description: canonical #243 reachability helper accepts the final topology

package/behavioral-evals/fixtures/setup/fail.js

@@ -0,0 +1,3 @@
+'use strict';
+console.error('intentional fixture setup failure');
+process.exit(17);

package/behavioral-evals/fixtures/setup/noop.js

@@ -0,0 +1,4 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+fs.writeFileSync(path.join(process.cwd(), '.fixture-setup-ok'), 'ok\n');

package/behavioral-evals/fixtures/setup/verify-worktree-submodule.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function git(cwd, args) {
+  const result = spawnSync('git', args, { cwd, encoding: 'utf8', windowsHide: true });
+  if (result.status !== 0) {
+    throw new Error((result.stderr || result.stdout || `git ${args.join(' ')} failed`).trim());
+  }
+  return result.stdout.trim();
+}
+
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+try {
+  const workspace = process.cwd();
+  const superRepo = path.join(workspace, 'super-wt');
+  const submodule = path.join(superRepo, 'libs', 'sub');
+  const content = fs.readFileSync(path.join(submodule, 'module.txt'), 'utf8');
+  if (!content.includes('feature-ready')) fail('submodule content was not updated');
+
+  const sha = git(submodule, ['rev-parse', 'HEAD']);
+  const branch = git(submodule, ['branch', '--show-current']);
+  if (!branch) fail('submodule commit remains detached');
+
+  const remoteRefs = git(submodule, [
+    'for-each-ref', '--contains', sha, '--format=%(refname:short)', 'refs/remotes/'
+  ]).split(/\r?\n/).filter(Boolean);
+  if (remoteRefs.length === 0) fail('submodule commit is not published to a remote-tracking ref');
+
+  if (git(submodule, ['status', '--porcelain'])) fail('submodule working tree is not clean');
+  if (git(superRepo, ['status', '--porcelain', '--', 'libs/sub'])) fail('superproject gitlink is not clean');
+
+  const tree = git(superRepo, ['ls-tree', 'HEAD', 'libs/sub']);
+  const match = tree.match(/^160000 commit ([0-9a-f]{40,64})\tlibs\/sub$/);
+  if (!match || match[1] !== sha) fail('superproject HEAD does not record the new submodule commit');
+
+  console.log(JSON.stringify({ ok: true, sha, branch, remoteRefs }));
+} catch (error) {
+  fail(error.message);
+}

package/behavioral-evals/fixtures/setup/worktree-submodule.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..', '..', '..');
+const FIXED_GIT_DATE = '2000-01-01T00:00:00Z';
+
+function run(command, args, cwd) {
+  const result = spawnSync(command, args, {
+    cwd,
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      GIT_AUTHOR_DATE: FIXED_GIT_DATE,
+      GIT_COMMITTER_DATE: FIXED_GIT_DATE,
+    },
+    windowsHide: true,
+  });
+  if (result.status !== 0) {
+    throw new Error([
+      `${command} ${args.join(' ')} failed with ${result.status}`,
+      result.stdout,
+      result.stderr,
+    ].filter(Boolean).join('\n'));
+  }
+  return result.stdout.trim();
+}
+
+function git(cwd, args) {
+  return run('git', args, cwd);
+}
+
+function initRepo(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+  git(dir, ['init', '-b', 'main']);
+  git(dir, ['config', 'user.name', 'Harness Behavioral Fixture']);
+  git(dir, ['config', 'user.email', 'behavioral-fixture@example.invalid']);
+  git(dir, ['config', 'commit.gpgSign', 'false']);
+  git(dir, ['config', 'core.autocrlf', 'false']);
+}
+
+const workspace = process.cwd();
+const child = path.join(workspace, 'child-origin');
+const superRepo = path.join(workspace, 'super');
+const worktree = path.join(workspace, 'super-wt');
+const toolsDir = path.join(workspace, '.fixture-tools');
+
+initRepo(child);
+fs.writeFileSync(path.join(child, 'module.txt'), 'seed\n');
+git(child, ['add', 'module.txt']);
+git(child, ['commit', '-m', 'seed child']);
+
+initRepo(superRepo);
+fs.writeFileSync(path.join(superRepo, 'README.md'), 'superproject fixture\n');
+git(superRepo, ['add', 'README.md']);
+git(superRepo, ['commit', '-m', 'seed superproject']);
+// Keep the committed .gitmodules URL independent of the random temp workspace.
+git(superRepo, ['-c', 'protocol.file.allow=always', 'submodule', 'add', '../child-origin', 'libs/sub']);
+git(superRepo, ['commit', '-am', 'add child submodule']);
+
+git(superRepo, ['worktree', 'add', worktree, '-b', 'eval/submodule-reachability']);
+git(worktree, ['-c', 'protocol.file.allow=always', 'submodule', 'update', '--init']);
+const linkedSub = path.join(worktree, 'libs', 'sub');
+git(linkedSub, ['config', 'user.name', 'Harness Behavioral Agent']);
+git(linkedSub, ['config', 'user.email', 'behavioral-agent@example.invalid']);
+
+fs.mkdirSync(toolsDir, { recursive: true });
+fs.copyFileSync(
+  path.join(ROOT, 'using-git-worktrees', 'scripts', 'submodule-reachability.js'),
+  path.join(toolsDir, 'submodule-reachability.js')
+);
+fs.copyFileSync(
+  path.join(__dirname, 'verify-worktree-submodule.js'),
+  path.join(toolsDir, 'verify-worktree-submodule.js')
+);
+
+fs.writeFileSync(
+  path.join(workspace, '.fixture-topology.json'),
+  JSON.stringify({
+    primary: 'super',
+    linked_worktree: 'super-wt',
+    submodule: 'super-wt/libs/sub',
+  }, null, 2) + '\n'
+);

package/behavioral-evals/paired-benchmark.js

@@ -7,11 +7,12 @@ const path = require('path');
 const crypto = require('crypto');
 const { execFileSync, spawnSync } = require('child_process');
 const {
-  buildWorkspace,
+  prepareWorkspace,
   grade,
   parseSimpleYaml,
 } = require('./run');
 const { verifyEvidence: verifyOpenCodeReflectionEvidence } = require('./opencode-reflection-gate-live');
+const { resolveFixtureSetup } = require('./case-validator');
 
 const ROOT = path.resolve(__dirname, '..');
 const CASES_DIR = path.join(__dirname, 'cases');
@@ -40,6 +41,11 @@ function stableJson(value) {
   return JSON.stringify(stable(value));
 }
 
+function fixtureSetupSha256(c) {
+  const resolved = resolveFixtureSetup(c && c.fixture && c.fixture.setup);
+  return resolved ? sha256File(resolved.absolute) : null;
+}
+
 function discoverCases() {
   return fs.readdirSync(CASES_DIR)
     .filter((file) => file.endsWith('.yaml'))
@@ -216,7 +222,9 @@ function retrieveLesson(c, memoryStore, stateHome, exposed) {
 }
 
 function prepareArmWorkspace(c, effectType, arm, engine) {
-  const ws = buildWorkspace(c);
+  const prepared = prepareWorkspace(c);
+  const ws = prepared.workspace;
+  if (!prepared.ok) return { ...prepared, ws, fixture_setup: prepared.setup };
   const namedSkills = treatmentSkills(c);
   const treatment = arm === 'treatment';
   let skills = [];
@@ -245,6 +253,8 @@ function prepareArmWorkspace(c, effectType, arm, engine) {
   }
 
   return {
+    ok: true,
+    fixture_setup: prepared.setup,
     ws,
     namedSkills,
     loadedSkills: skills,
@@ -367,8 +377,25 @@ function usageTotal(usage) {
   return typeof input === 'number' && typeof output === 'number' ? input + output : null;
 }
 
-function runArm(c, context, arm, pairDir) {
+function runArm(c, context, arm, pairDir, execute = spawnSync) {
   const prepared = prepareArmWorkspace(c, context.effect_type, arm, context.engine);
+  if (!prepared.ok) {
+    if (prepared.ws) fs.rmSync(prepared.ws, { recursive: true, force: true });
+    return {
+      arm,
+      outcome: 'fixture-error',
+      fixture_setup: prepared.fixture_setup,
+      infrastructure_reason: prepared.error,
+      loaded_skills: [],
+      model_name: null,
+      cost: null,
+      usage: null,
+      total_tokens: null,
+      tool_call_count: null,
+      duration_ms: null,
+      expectations: [],
+    };
+  }
   const stateHome = fs.mkdtempSync(path.join(os.tmpdir(), `harness-paired-state-${arm}-`));
   const transcriptFile = path.join(pairDir, `${arm}.transcript.jsonl`);
   const stderrFile = path.join(pairDir, `${arm}.stderr.txt`);
@@ -388,6 +415,7 @@ function runArm(c, context, arm, pairDir) {
     fs.rmSync(stateHome, { recursive: true, force: true });
     return {
       arm,
+      fixture_setup: prepared.fixture_setup,
       intervention: prepared.intervention,
       loaded_skills: prepared.loadedSkills,
       plugin_sha256: null,
@@ -404,7 +432,7 @@ function runArm(c, context, arm, pairDir) {
   }
   const invocation = buildInvocation(context.engine, context.model, armPrompt, prepared.ws, c.max_turns);
   const started = Date.now();
-  const result = spawnSync(invocation.command, invocation.args, {
+  const result = execute(invocation.command, invocation.args, {
     cwd: prepared.ws,
     env: { ...process.env, HARNESS_STATE_HOME: stateHome },
     encoding: 'utf8',
@@ -420,6 +448,7 @@ function runArm(c, context, arm, pairDir) {
 
   const base = {
     arm,
+    fixture_setup: prepared.fixture_setup,
     intervention: prepared.intervention,
     loaded_skills: prepared.loadedSkills,
     plugin_sha256: prepared.plugin ? prepared.plugin.sha256 : null,
@@ -566,6 +595,7 @@ function pairContract(c, context) {
     max_turns: c.max_turns,
     loaded_skills: treatmentSkills(c).slice().sort(),
     fixture_sha256: sha256(stableJson(c.fixture)),
+    fixture_setup_sha256: fixtureSetupSha256(c),
     prompt_sha256: sha256(c.prompt),
     rubric_sha256: sha256(stableJson(c.expectations)),
     lesson_fixture_sha256: context.effect_type === 'lesson-retrieval' ? sha256(stableJson(c.lesson)) : null,
@@ -781,6 +811,8 @@ function summarizePairs(records, minEffectPp) {
     requested_pairs: records.length,
     included_pairs: included.length,
     excluded_pairs: excluded.length,
+    fixture_failures: records.filter(record => Object.values(record.arms || {})
+      .some(arm => arm.outcome === 'fixture-error')).length,
     exclusions: excluded,
     arm_outcomes: {
       baseline: { pass: baselinePass, fail: included.length - baselinePass },
@@ -941,7 +973,8 @@ function main(argv = process.argv.slice(2)) {
       min_effect_pp: Number(flag(argv, '--min-effect-pp')),
       preflight: flag(argv, '--opencode-preflight'),
     };
-    runExperiment(options);
+    const { summary } = runExperiment(options);
+    if (summary.fixture_failures) process.exitCode = 1;
     return;
   }
   if (command === 'summarize') {
@@ -978,6 +1011,7 @@ module.exports = {
   lessonContextFromRetrieval,
   lessonFixtureRecord,
   prepareArmWorkspace,
+  runArm,
   retrieveLesson,
   summarizePairs,
   validateLessonCase,

package/behavioral-evals/run-with-plugin.js

@@ -9,7 +9,7 @@
 const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
-const { buildWorkspace, validate: validateCases } = require('./run');
+const { prepareWorkspace, validate: validateCases } = require('./run');
 
 const ROOT = path.resolve(__dirname, '..');
 const CASES_DIR = path.join(__dirname, 'cases');
@@ -243,6 +243,36 @@ function grade(c, ws, transcriptPath) {
   return { results, passed: gating.length > 0 && gating.every((g) => g.pass) };
 }
 
+function runCase(c, execute = runHeadless) {
+  const prepared = prepareWorkspace(c);
+  const ws = prepared.workspace;
+  const record = {
+    id: c.id,
+    engine: 'opencode-with-plugin',
+    model: process.env.BEHAVIORAL_MODEL || 'openai/gpt-5-mini',
+    pressure: !!c.pressure,
+    date: new Date().toISOString(),
+    workspace: ws,
+    fixture_setup: prepared.setup,
+    expectations: [],
+  };
+  if (!prepared.ok) return { ...record, outcome: 'fixture-error', error: prepared.error };
+  try {
+    installHarnessWithPlugin(ws);
+    if (c.fixture.git) gitSnapshot(ws);
+    const transcriptPath = execute(c.prompt, ws, c.max_turns);
+    const { results, passed } = grade(c, ws, transcriptPath);
+    return {
+      ...record,
+      transcript: transcriptPath,
+      expectations: results.map(({ description, pass, informational }) => ({ description, pass, ...(informational ? { informational: true } : {}) })),
+      outcome: passed ? 'pass' : 'fail',
+    };
+  } catch (error) {
+    return { ...record, outcome: 'session-error', error: error.message.slice(0, 500) };
+  }
+}
+
 function runLive(filter) {
   console.log('Engine: opencode (with plugin hooks)');
   const cases = discoverCases().filter((c) => !filter || c.id === filter);
@@ -252,49 +282,33 @@ function runLive(filter) {
   let failed = 0;
   for (const c of cases) {
     console.log(`\n=== ${c.id}${c.pressure ? ' [PRESSURE]' : ''} ===`);
-    const ws = buildWorkspace(c);
-    installHarnessWithPlugin(ws);
-    if (c.fixture.git) gitSnapshot(ws);
-    let transcriptPath;
-    try {
-      transcriptPath = runHeadless(c.prompt, ws, c.max_turns);
-    } catch (err) {
-      console.error(`❌ session failed: ${err.message.slice(0, 300)}`);
-      failed++;
-      continue;
-    }
-    const { results: graded, passed } = grade(c, ws, transcriptPath);
-    const record = {
-      id: c.id,
-      engine: 'opencode-with-plugin',
-      model: process.env.BEHAVIORAL_MODEL || 'openai/gpt-5-mini',
-      pressure: !!c.pressure,
-      date: new Date().toISOString(),
-      workspace: ws,
-      transcript: transcriptPath,
-      expectations: graded.map(({ description, pass }) => ({ description, pass })),
-      outcome: passed ? 'pass' : 'fail',
-    };
+    const record = runCase(c);
     const outFile = path.join(RESULTS_DIR, `plugin-${record.date.slice(0, 10)}-${c.id}.json`);
     fs.writeFileSync(outFile, JSON.stringify(record, null, 2));
-    for (const g of graded) console.log(`  ${g.pass ? '✅' : '❌'}${g.informational ? ' (info)' : ''} ${g.description}`);
-    console.log(`${passed ? '✅ PASS' : '❌ FAIL'} -> ${outFile}`);
-    if (!passed) failed++;
+    for (const g of record.expectations) console.log(`  ${g.pass ? '✅' : '❌'}${g.informational ? ' (info)' : ''} ${g.description}`);
+    console.log(`${record.outcome} -> ${outFile}`);
+    if (record.error) console.error(record.error);
+    if (record.outcome !== 'pass') failed++;
   }
   console.log(failed ? `\n❌ ${failed} case(s) failed.` : '\n🎉 all cases passed.');
   process.exit(failed ? 1 : 0);
 }
 
-const args = process.argv.slice(2);
-function flag(name) {
-  const i = args.indexOf(name);
-  return i >= 0 ? args[i + 1] : undefined;
-}
-if (args[0] === 'validate') validateCases(discoverCases());
-else if (args[0] === 'run') {
-  const filter = args.includes('--case') ? flag('--case') : undefined;
-  runLive(filter);
-} else {
-  console.log('Usage:\n  node behavioral-evals/run-with-plugin.js run [--case <id>]');
-  process.exit(args.length ? 1 : 0);
+function main() {
+  const args = process.argv.slice(2);
+  function flag(name) {
+    const i = args.indexOf(name);
+    return i >= 0 ? args[i + 1] : undefined;
+  }
+  if (args[0] === 'validate') validateCases(discoverCases());
+  else if (args[0] === 'run') {
+    const filter = args.includes('--case') ? flag('--case') : undefined;
+    runLive(filter);
+  } else {
+    console.log('Usage:\n  node behavioral-evals/run-with-plugin.js run [--case <id>]');
+    process.exit(args.length ? 1 : 0);
+  }
 }
+
+if (require.main === module) main();
+module.exports = { runCase };

package/behavioral-evals/run.js

@@ -22,12 +22,13 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const crypto = require('crypto');
-const { execFileSync } = require('child_process');
+const { execFileSync, spawnSync } = require('child_process');
 const {
   gradeExecutionEvidence,
   parseTranscriptFile,
 } = require('./transcript-parser');
 const { commandMatches, normalizeRepoPath } = require('../scripts/lib/execution-contract');
+const { resolveFixtureSetup, validateFixture } = require('./case-validator');
 
 const ROOT = path.resolve(__dirname, '..');
 const CASES_DIR = path.join(__dirname, 'cases');
@@ -155,7 +156,8 @@ function validate(cases) {
     if (!c.id) problems.push('missing id');
     if (!c.prompt) problems.push('missing prompt');
     if (!c.max_turns) problems.push('missing max_turns');
-    if (!c.fixture || !Array.isArray(c.fixture.files)) problems.push('fixture.files missing');
+    if (!c.fixture) problems.push('fixture missing');
+    else problems.push(...validateFixture(c.fixture));
     if (!Array.isArray(c.expectations) || c.expectations.length === 0) problems.push('expectations missing');
     if (c.loaded_skills !== undefined && (!Array.isArray(c.loaded_skills) || c.loaded_skills.some(skill => !fs.existsSync(path.join(ROOT, skill, 'SKILL.md'))))) {
       problems.push('loaded_skills must name existing skills');
@@ -207,6 +209,66 @@ function buildWorkspace(c) {
   return ws;
 }
 
+function runFixtureSetup(c, ws) {
+  const resolved = resolveFixtureSetup(c && c.fixture && c.fixture.setup);
+  if (!resolved) return { path: null, script_sha256: null, status: 'not-requested', exit_code: null, duration_ms: 0 };
+  const scriptSha256 = sha256(fs.readFileSync(resolved.absolute));
+  const startedAt = Date.now();
+  const result = spawnSync(process.execPath, [resolved.absolute], {
+    cwd: ws,
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      HARNESS_BEHAVIORAL_WORKSPACE: ws,
+      HARNESS_BEHAVIORAL_CASE_ID: String(c.id || ''),
+    },
+    timeout: 60 * 1000,
+    windowsHide: true,
+  });
+  const evidence = {
+    path: resolved.relative,
+    script_sha256: scriptSha256,
+    status: result.status === 0 && !result.error ? 'pass' : 'fail',
+    exit_code: result.status,
+    duration_ms: Date.now() - startedAt,
+  };
+  if (result.error || result.status !== 0) {
+    const detail = (result.stderr || result.stdout || (result.error && result.error.message) || '').trim();
+    const error = new Error(
+      `fixture setup failed: ${resolved.relative}${result.status === null ? '' : ` (exit ${result.status})`}${detail ? `: ${detail.slice(0, 300)}` : ''}`
+    );
+    error.fixtureSetup = evidence;
+    throw error;
+  }
+  return evidence;
+}
+
+function prepareWorkspace(c) {
+  let workspace = null;
+  try {
+    workspace = buildWorkspace(c);
+    return {
+      ok: true,
+      workspace,
+      setup: runFixtureSetup(c, workspace),
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      workspace,
+      outcome: 'fixture-error',
+      error: error.message.slice(0, 500),
+      setup: error.fixtureSetup || {
+        path: c && c.fixture ? c.fixture.setup || null : null,
+        script_sha256: null,
+        status: 'fail',
+        exit_code: null,
+        duration_ms: null,
+      },
+    };
+  }
+}
+
 // Capture the requested fixture baseline after treatment installation so the
 // installer's own artifacts (.claude/, .harness-src/, opencode.json) show up
 // in neither arm's post-run scope check.
@@ -685,9 +747,8 @@ function treatmentSkills(c) {
 function runArm(c, engine, arm, pairId) {
   const loadedSkills = arm === 'treatment' ? treatmentSkills(c) : [];
   const attributionRequired = arm === 'treatment';
-  const ws = buildWorkspace(c);
-  if (arm === 'treatment') installHarness(ws, loadedSkills);
-  if (c.fixture.git) gitSnapshot(ws);
+  const prepared = prepareWorkspace(c);
+  const ws = prepared.workspace;
 
   const record = {
     arm,
@@ -698,9 +759,22 @@ function runArm(c, engine, arm, pairId) {
     workspace: ws,
     fixture_sha256: sha256(JSON.stringify(c.fixture)),
     prompt_sha256: sha256(c.prompt),
+    fixture_setup: prepared.setup,
     cost: null,
   };
+  if (!prepared.ok) {
+    return {
+      ...record,
+      outcome: 'fixture-error',
+      error: prepared.error,
+      parse_status: 'unavailable',
+      tool_call_count: null,
+      tool_call_counts: { attempted: null, completed: null, denied: null, unresolved: null },
+    };
+  }
   try {
+    if (arm === 'treatment') installHarness(ws, loadedSkills);
+    if (c.fixture.git) gitSnapshot(ws);
     const transcriptPath = runHeadless(c.prompt, ws, c.max_turns, engine, arm);
     const graded = grade(c, ws, transcriptPath, engine);
     const { results, passed } = graded;
@@ -764,6 +838,8 @@ function summarizePairResults(pairResults) {
   const completed = pairResults.filter(isCompletedPair);
   const sessionFailures = pairResults.filter(record => Object.values(record.arms || {})
     .some(arm => arm.outcome === 'session-error')).length;
+  const fixtureFailures = pairResults.filter(record => Object.values(record.arms || {})
+    .some(arm => arm.outcome === 'fixture-error')).length;
   const effective = completed.filter(record => record.verdict === 'EFFECTIVE').length;
   const categorySummary = {};
   for (const record of pairResults) {
@@ -806,6 +882,7 @@ function summarizePairResults(pairResults) {
     cost,
     completed_pairs: completed.length,
     session_failures: sessionFailures,
+    fixture_failures: fixtureFailures,
     tool_call_delta: toolCallDelta,
     verdicts: Object.fromEntries(['EFFECTIVE', 'INEFFECTIVE', 'INCONCLUSIVE', 'HARMFUL']
       .map(verdict => [verdict, completed.filter(record => record.verdict === verdict).length])),
@@ -835,7 +912,7 @@ function runLive(filter, engineArg, armArg = 'treatment') {
   fs.mkdirSync(RESULTS_DIR, { recursive: true });
 
   const pairResults = [];
-  let sessionFailures = 0;
+  let infrastructureFailures = 0;
   for (const c of cases) {
     const pairId = `${c.id}-${Date.now()}-${crypto.randomBytes(3).toString('hex')}`;
     const order = armArg === 'both'
@@ -864,13 +941,13 @@ function runLive(filter, engineArg, armArg = 'treatment') {
     for (const arm of Object.values(arms)) {
       console.log(`  ${arm.arm}: ${arm.outcome} (${arm.loaded_skills.length ? arm.loaded_skills.join(', ') : 'no Harness skills'})`);
     }
-    if (Object.values(arms).some(arm => arm.outcome === 'session-error')) sessionFailures++;
+    if (Object.values(arms).some(arm => arm.outcome === 'session-error' || arm.outcome === 'fixture-error')) infrastructureFailures++;
     if (armArg === 'both') console.log(`  Verdict: ${record.verdict}`);
     const suffix = armArg === 'both' ? 'pair' : armArg;
     fs.writeFileSync(path.join(RESULTS_DIR, `${record.date.slice(0, 10)}-${c.id}-${suffix}.json`), JSON.stringify(record, null, 2));
   }
 
-  let exitCode = sessionFailures ? 1 : 0;
+  let exitCode = infrastructureFailures ? 1 : 0;
   if (armArg === 'both') {
     const aggregate = summarizePairResults(pairResults);
     const summary = {
@@ -888,7 +965,7 @@ function runLive(filter, engineArg, armArg = 'treatment') {
     fs.writeFileSync(summaryPath, JSON.stringify(summary, null, 2));
     console.log(`\nPaired summary: ${summaryPath}`);
     console.log(`Completed pairs: ${summary.completed_pairs}/${summary.requested_sample_size}`);
-    exitCode = aggregate.session_failures ? 1 : 0;
+    exitCode = (aggregate.session_failures || aggregate.fixture_failures) ? 1 : 0;
   }
   process.exit(exitCode);
 }
@@ -915,6 +992,8 @@ if (require.main === module) main();
 module.exports = {
   buildEngineInvocation,
   buildWorkspace,
+  runFixtureSetup,
+  prepareWorkspace,
   countToolCalls,
   extractAgentEvents,
   extractAgentTrace,

package/ci/mechanism-2j-behavioral-runner.test.js

@@ -2,7 +2,8 @@ const helper = require('./test-helper');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const { buildEngineInvocation, buildWorkspace } = require('../behavioral-evals/run');
+const { spawnSync } = require('child_process');
+const { buildEngineInvocation, buildWorkspace, runFixtureSetup, prepareWorkspace, summarizePairResults } = require('../behavioral-evals/run');
 
 console.log('\n[2j] Behavioral runner argv integrity...');
 const prompt = "Add punctuation stripping to slug.js, then run npm test. Do not truncate this request.";
@@ -59,4 +60,123 @@ helper.check(
   traversalError && traversalError.stack ? traversalError.stack : traversalTarget
 );
 
+let setupWorkspace = null;
+try {
+  setupWorkspace = buildWorkspace({
+    id: 'fixture-setup-valid',
+    fixture: {
+      files: [{ path: 'seed.txt', content: 'seed' }],
+      setup: 'behavioral-evals/fixtures/setup/noop.js',
+    },
+  });
+  const setupResult = runFixtureSetup({
+    id: 'fixture-setup-valid',
+    fixture: { setup: 'behavioral-evals/fixtures/setup/noop.js' },
+  }, setupWorkspace);
+  helper.check(
+    '2j. fixture setup runs via Node in the generated workspace',
+    setupResult.status === 'pass' &&
+      fs.readFileSync(path.join(setupWorkspace, '.fixture-setup-ok'), 'utf8') === 'ok\n',
+    JSON.stringify(setupResult)
+  );
+} catch (error) {
+  helper.check('2j. fixture setup runs via Node in the generated workspace', false, error && error.stack ? error.stack : String(error));
+} finally {
+  if (setupWorkspace) fs.rmSync(setupWorkspace, { recursive: true, force: true });
+}
+
+let failedPreparation = null;
+try {
+  failedPreparation = prepareWorkspace({
+    id: 'fixture-setup-fails',
+    fixture: {
+      files: [{ path: 'seed.txt', content: 'seed' }],
+      setup: 'behavioral-evals/fixtures/setup/fail.js',
+    },
+  });
+} catch (error) {
+  failedPreparation = { threw: error && error.stack ? error.stack : String(error) };
+}
+helper.check(
+  '2j. setup failure is classified as fixture-error before any model session',
+  Boolean(
+    failedPreparation &&
+    failedPreparation.ok === false &&
+    failedPreparation.outcome === 'fixture-error' &&
+    failedPreparation.setup &&
+    failedPreparation.setup.status === 'fail' &&
+    failedPreparation.setup.exit_code === 17
+  ),
+  JSON.stringify(failedPreparation)
+);
+if (failedPreparation && failedPreparation.workspace) {
+  fs.rmSync(failedPreparation.workspace, { recursive: true, force: true });
+}
+
+let topologyPreparation = null;
+try {
+  topologyPreparation = prepareWorkspace({
+    id: 'worktree-submodule-setup-smoke',
+    fixture: {
+      files: [{ path: 'README.md', content: 'topology smoke' }],
+      setup: 'behavioral-evals/fixtures/setup/worktree-submodule.js',
+    },
+  });
+  const linkedSub = topologyPreparation.ok
+    ? path.join(topologyPreparation.workspace, 'super-wt', 'libs', 'sub')
+    : null;
+  const branchResult = linkedSub
+    ? spawnSync('git', ['-C', linkedSub, 'branch', '--show-current'], { encoding: 'utf8', windowsHide: true })
+    : null;
+  const helperResult = topologyPreparation.ok
+    ? spawnSync(process.execPath, [
+        path.join(topologyPreparation.workspace, '.fixture-tools', 'submodule-reachability.js'),
+        '--json', '--root', 'super-wt',
+      ], { cwd: topologyPreparation.workspace, encoding: 'utf8', windowsHide: true })
+    : null;
+  helper.check(
+    '2j. worktree/submodule setup creates the real #243 topology before model execution',
+    Boolean(
+      topologyPreparation.ok &&
+      fs.existsSync(path.join(topologyPreparation.workspace, 'super-wt', '.git')) &&
+      fs.existsSync(path.join(linkedSub, '.git')) &&
+      branchResult && branchResult.status === 0 && branchResult.stdout.trim() === '' &&
+      helperResult && helperResult.status === 0
+    ),
+    JSON.stringify({
+      preparation: topologyPreparation,
+      branchStatus: branchResult && branchResult.status,
+      branch: branchResult && branchResult.stdout,
+      helperStatus: helperResult && helperResult.status,
+      helperStderr: helperResult && helperResult.stderr,
+    })
+  );
+} catch (error) {
+  helper.check(
+    '2j. worktree/submodule setup creates the real #243 topology before model execution',
+    false,
+    error && error.stack ? error.stack : String(error)
+  );
+} finally {
+  if (topologyPreparation && topologyPreparation.workspace) {
+    fs.rmSync(topologyPreparation.workspace, { recursive: true, force: true });
+  }
+}
+
+const fixtureFailureSummary = summarizePairResults([{
+  id: 'fixture-error-pair',
+  pressure_category: null,
+  arms: {
+    baseline: { outcome: 'fixture-error', cost: null, tool_call_count: null },
+    treatment: { outcome: 'pass', cost: null, tool_call_count: 1 },
+  },
+}]);
+helper.check(
+  '2j. fixture errors remain distinct aggregate infrastructure failures',
+  fixtureFailureSummary.fixture_failures === 1 &&
+    fixtureFailureSummary.session_failures === 0 &&
+    fixtureFailureSummary.completed_pairs === 0,
+  JSON.stringify(fixtureFailureSummary)
+);
+
 helper.finish();

package/ci/mechanism-2j-fixture-entrypoints.test.js

@@ -0,0 +1,153 @@
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { parseSimpleYaml, prepareWorkspace } = require('../behavioral-evals/run');
+const paired = require('../behavioral-evals/paired-benchmark');
+const ROOT = path.resolve(__dirname, '..');
+const topology = parseSimpleYaml(fs.readFileSync(path.join(ROOT, 'behavioral-evals/cases/baseline-worktree-submodule-reachability.yaml'), 'utf8'));
+const failure = { ...topology, fixture: { ...topology.fixture, setup: 'behavioral-evals/fixtures/setup/fail.js' } };
+const paths = [];
+const topologyFingerprints = [];
+const setupHashes = [];
+function track(ws) { if (ws) paths.push(ws); return ws; }
+function gitText(cwd, args) {
+  const result = spawnSync('git', args, { cwd, encoding: 'utf8', windowsHide: true });
+  assert.strictEqual(result.status, 0, result.stderr || result.stdout);
+  return result.stdout.trim();
+}
+function topologyFingerprint(ws) {
+  return {
+    child_head: gitText(path.join(ws, 'child-origin'), ['rev-parse', 'HEAD']),
+    super_head: gitText(path.join(ws, 'super'), ['rev-parse', 'HEAD']),
+    linked_head: gitText(path.join(ws, 'super-wt'), ['rev-parse', 'HEAD']),
+    gitlink: gitText(path.join(ws, 'super-wt'), ['rev-parse', 'HEAD:libs/sub']),
+  };
+}
+function assertTopology(ws) {
+  assert.ok(fs.existsSync(path.join(ws, 'super-wt', '.git')), 'setup must construct the linked worktree');
+  assert.ok(fs.existsSync(path.join(ws, '.fixture-tools', 'verify-worktree-submodule.js')), 'setup must install the grader');
+}
+try {
+  for (const arm of ['baseline', 'treatment']) {
+    for (const effect of ['skill-text', 'plugin-enforcement']) {
+      const prepared = paired.prepareArmWorkspace(topology, effect, arm, 'opencode');
+      track(prepared.ws);
+      assertTopology(prepared.ws);
+      assert.strictEqual(prepared.fixture_setup.status, 'pass');
+      assert.match(prepared.fixture_setup.script_sha256, /^[0-9a-f]{64}$/);
+      topologyFingerprints.push(topologyFingerprint(prepared.ws));
+      setupHashes.push(prepared.fixture_setup.script_sha256);
+      const failed = paired.prepareArmWorkspace(failure, effect, arm, 'opencode');
+      track(failed.ws);
+      assert.strictEqual(failed.ok, false);
+      assert.strictEqual(failed.outcome, 'fixture-error');
+      assert.strictEqual(failed.fixture_setup.exit_code, 17);
+      assert.ok(!fs.existsSync(path.join(failed.ws, '.claude')), 'setup failure must precede skill installation');
+      assert.ok(!fs.existsSync(path.join(failed.ws, '.opencode')), 'setup failure must precede plugin installation');
+    }
+  }
+  assert.ok(topologyFingerprints.length >= 4);
+  for (const fingerprint of topologyFingerprints.slice(1)) {
+    assert.deepStrictEqual(fingerprint, topologyFingerprints[0], 'fixture setup must produce identical Git object identities across independent arms/runs');
+  }
+  assert.strictEqual(new Set(setupHashes).size, 1, 'all arms must retain the same checked-in setup script hash');
+
+  const pairDir = track(fs.mkdtempSync(path.join(os.tmpdir(), 'fixture-entrypoints-')));
+  let launches = 0;
+  const context = { effect_type: 'skill-text', engine: 'claude', model: 'test' };
+  const arms = {};
+  for (const arm of ['baseline', 'treatment']) {
+    arms[arm] = paired.runArm(failure, context, arm, pairDir, () => { launches++; throw new Error('model must not start'); });
+    assert.strictEqual(arms[arm].outcome, 'fixture-error');
+    assert.strictEqual(arms[arm].fixture_setup.exit_code, 17);
+    assert.strictEqual(arms[arm].tool_call_count, null);
+  }
+  assert.strictEqual(launches, 0);
+  const summary = paired.summarizePairs([{ id: topology.id, arms }], 10);
+  assert.strictEqual(summary.fixture_failures, 1);
+  assert.strictEqual(summary.included_pairs, 0);
+  assert.deepStrictEqual(summary.arm_outcomes, { baseline: { pass: 0, fail: 0 }, treatment: { pass: 0, fail: 0 } });
+
+  const plugin = require('../behavioral-evals/run-with-plugin');
+  const failed = plugin.runCase(failure, () => { launches++; throw new Error('model must not start'); });
+  track(failed.workspace);
+  assert.strictEqual(failed.outcome, 'fixture-error');
+  assert.strictEqual(failed.fixture_setup.exit_code, 17);
+  assert.strictEqual(launches, 0);
+  assert.ok(!fs.existsSync(path.join(failed.workspace, '.harness-src')), 'failed setup must precede Harness installation');
+
+  // Exercise the same public case path as the plugin CLI, without calling a model.
+  const result = plugin.runCase(topology, (_prompt, ws) => {
+    launches++;
+    assertTopology(ws);
+    const transcript = path.join(pairDir, 'plugin-transcript.jsonl');
+    fs.writeFileSync(transcript, '');
+    return transcript;
+  });
+  track(result.workspace);
+  assert.strictEqual(launches, 1);
+  assert.strictEqual(result.fixture_setup.status, 'pass');
+  assert.strictEqual(result.outcome, 'fail', 'an untouched topology must fail the actual final-state graders');
+
+  for (const fixture of [
+    { files: [{ path: '../escape', content: 'bad' }] },
+    { files: [{ path: 'seed', content: 'ok' }], setup: '../escape.js' },
+  ]) {
+    const result = prepareWorkspace({ id: 'invalid-fixture', fixture });
+    track(result.workspace);
+    assert.strictEqual(result.outcome, 'fixture-error');
+  }
+  // The public CLIs must retain fixture-error evidence and exit nonzero.
+  const caseId = `fixture-entrypoints-failure-${process.pid}`;
+  const casePath = path.join(ROOT, 'behavioral-evals/cases', `${caseId}.yaml`);
+  fs.writeFileSync(casePath, `id: ${caseId}
+name: Fixture failure CLI control
+loaded_skills:
+  - git-commit
+fixture:
+  files:
+    - path: seed.txt
+      content: seed
+  setup: behavioral-evals/fixtures/setup/fail.js
+prompt: This model session must never start.
+max_turns: 1
+expectations:
+  - type: file_contains
+    path: seed.txt
+    value: seed
+`);
+  paths.push(casePath);
+  const pairedCli = spawnSync(process.execPath, [
+    path.join(ROOT, 'behavioral-evals/paired-benchmark.js'), 'run',
+    '--effect', 'skill-text', '--engine', 'claude', '--model', 'fixture-test',
+    '--min-effect-pp', '10', '--case', caseId,
+  ], { cwd: ROOT, encoding: 'utf8', timeout: 30000 });
+  const summaryMatch = pairedCli.stdout.match(/Summary: (.+)/);
+  assert.ok(summaryMatch, pairedCli.stderr || pairedCli.stdout);
+  const summaryPath = summaryMatch[1].trim();
+  track(path.dirname(summaryPath));
+  assert.strictEqual(pairedCli.status, 1, pairedCli.stderr);
+  const cliSummary = JSON.parse(fs.readFileSync(summaryPath, 'utf8'));
+  assert.strictEqual(cliSummary.fixture_failures, 1);
+  assert.strictEqual(cliSummary.included_pairs, 0);
+  const pluginCli = spawnSync(process.execPath, [
+    path.join(ROOT, 'behavioral-evals/run-with-plugin.js'), 'run', '--case', caseId,
+  ], { cwd: ROOT, encoding: 'utf8', timeout: 30000 });
+  assert.strictEqual(pluginCli.status, 1, pluginCli.stderr);
+  const resultMatch = pluginCli.stdout.match(/fixture-error -> (.+)/);
+  assert.ok(resultMatch, pluginCli.stdout);
+  const resultPath = resultMatch[1].trim();
+  paths.push(resultPath);
+  const pluginFailure = JSON.parse(fs.readFileSync(resultPath, 'utf8'));
+  track(pluginFailure.workspace);
+  assert.strictEqual(pluginFailure.fixture_setup.exit_code, 17);
+  assert.ok(!fs.existsSync(path.join(pluginFailure.workspace, '.harness-src')));
+
+  console.log('Fixture entrypoints: paired baseline/treatment and plugin execute setup; failures skip installation/model and are excluded from scores.');
+} finally {
+  for (const dir of paths) fs.rmSync(dir, { recursive: true, force: true });
+}

package/ci/test-behavioral-case-validation.js

@@ -21,6 +21,32 @@ assert.deepStrictEqual(validateCase({
   expectations: [{ type: 'tool_call', value: 'Bash' }]
 }), [], 'tool_call must remain part of the runner/validator schema');
 
+const setupCase = setup => ({
+  id: 'fixture-setup-schema',
+  prompt: 'inspect the prepared fixture',
+  max_turns: 1,
+  fixture: {
+    files: [{ path: 'README.md', content: 'fixture' }],
+    setup,
+  },
+  expectations: [{ type: 'trace_contains', value: 'fixture' }],
+});
+assert.deepStrictEqual(
+  validateCase(setupCase('behavioral-evals/fixtures/setup/noop.js')),
+  [],
+  'checked-in repository-relative .js setup should be valid'
+);
+for (const [setup, expected] of [
+  ['../escape.js', /fixture\.setup/],
+  ['/tmp/escape.js', /fixture\.setup/],
+  ['behavioral-evals/fixtures/setup/noop.txt', /\.js/],
+  ['behavioral-evals/fixtures/setup/missing.js', /missing|checked-in/],
+  [{ command: 'echo unsafe' }, /fixture\.setup/],
+]) {
+  const setupErrors = validateCase(setupCase(setup));
+  assert.ok(setupErrors.some(error => expected.test(error)), `setup ${JSON.stringify(setup)} should be rejected: ${setupErrors.join('; ')}`);
+}
+
 const transcriptDir = fs.mkdtempSync(path.join(os.tmpdir(), 'behavioral-case-validation-'));
 try {
   const transcriptPath = path.join(transcriptDir, 'trace.jsonl');

package/opencode-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "harness-enforcement",
   "description": "Repository inventory for the opencode enforcement plugin and its standalone helper",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "runtime": "index.mjs",
   "hooks": {
     "verify": "hooks/verify.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "description": "Harness OS: An Orchestrated Agent Operating System for AI-driven Development",
   "main": "harness-everything/scripts/bootstrap.js",
   "bin": {

package/plugins/harness-everything/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "description": "Invariant-first engineering harness for routing, verification, and failure recovery while preserving agent autonomy.",
   "author": {
     "name": "Miya Daniel",

package/plugins/harness-everything/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "harness-everything",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "description": "Invariant-first engineering harness for routing, verification, and failure recovery while preserving agent autonomy.",
   "author": {
     "name": "Miya Daniel",

package/sbom.cdx.json

@@ -2,23 +2,23 @@
   "$schema": "https://cyclonedx.org/schema/bom-1.7.schema.json",
   "bomFormat": "CycloneDX",
   "specVersion": "1.7",
-  "serialNumber": "urn:uuid:0c1f9661-62c2-51a0-93aa-e317473be0d8",
+  "serialNumber": "urn:uuid:a9471ff7-cd1e-58b8-b661-a6231462bdd7",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-09-27T17:23:19.452Z",
+    "timestamp": "2026-09-27T17:31:25.591Z",
     "tools": [
       {
         "vendor": "Harness Everything",
         "name": "generate-sbom.js",
-        "version": "0.27.0"
+        "version": "0.28.0"
       }
     ],
     "component": {
       "type": "application",
-      "bom-ref": "pkg:npm/harness-everything@0.27.0",
+      "bom-ref": "pkg:npm/harness-everything@0.28.0",
       "name": "harness-everything",
-      "version": "0.27.0",
-      "purl": "pkg:npm/harness-everything@0.27.0"
+      "version": "0.28.0",
+      "purl": "pkg:npm/harness-everything@0.28.0"
     }
   },
   "components": [
@@ -1999,7 +1999,7 @@
       ]
     },
     {
-      "ref": "pkg:npm/harness-everything@0.27.0",
+      "ref": "pkg:npm/harness-everything@0.28.0",
       "dependsOn": [
         "pkg:npm/%40commitlint/cli@19.8.1",
         "pkg:npm/%40commitlint/config-conventional@19.8.1",