harness-everything 0.47.2 → 0.47.4

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

package/.github/workflows/ci.yml

@@ -118,6 +118,8 @@ jobs:
           node-version: 24
       - name: Install dependencies for regression suite
         run: npm ci
+      - name: Verify OpenCode async process fixtures before the full suite
+        run: node ci/mechanism-338-opencode-async.test.js
       - name: Run hermetic self-regression suite
         run: npm test
       - name: Run focused mutation checks

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.47.4](https://github.com/dyphn1/Harness-everything/compare/v0.47.3...v0.47.4) (2026-11-03)
+
+### Bug Fixes
+
+* **behavioral-evals:** grade the whole final assistant message for json-only ([ebbe33c](https://github.com/dyphn1/Harness-everything/commit/ebbe33c7ac8beb3d2b104f81666f06a0ebfcd77d)), closes [#308](https://github.com/dyphn1/Harness-everything/issues/308)
+* **behavioral-evals:** recombine final text parts exactly for json-only grading ([de8341c](https://github.com/dyphn1/Harness-everything/commit/de8341c0621c6aacf319467a9e3c9b1420f51f37)), closes [#308](https://github.com/dyphn1/Harness-everything/issues/308)
+
+## [0.47.3](https://github.com/dyphn1/Harness-everything/compare/v0.47.2...v0.47.3) (2026-10-31)
+
+### Bug Fixes
+
+* **docs:** preserve exact file identities in derived comparisons ([8bc3ddb](https://github.com/dyphn1/Harness-everything/commit/8bc3ddbac38eaffa7495e70922dc1240f9aa63eb))
+* **docs:** repin shipped verifier after exact file identity fix ([c24d0f1](https://github.com/dyphn1/Harness-everything/commit/c24d0f100ce392edd02275aa06b58f141ade6cdd))
+* **opencode:** invalidate idle waiters on session reset ([41b2663](https://github.com/dyphn1/Harness-everything/commit/41b2663f66edbe77188c3ca9fa3b0add6f7ab76d))
+* **opencode:** stream verification asynchronously within a shared budget ([1470247](https://github.com/dyphn1/Harness-everything/commit/1470247249548ec6ccf2acaf97463824e0268be4)), closes [#338](https://github.com/dyphn1/Harness-everything/issues/338)
+
 ## [0.47.2](https://github.com/dyphn1/Harness-everything/compare/v0.47.1...v0.47.2) (2026-10-31)
 
 ### Bug Fixes

package/behavioral-evals/README.md

@@ -171,6 +171,16 @@ additional arguments) or `tool_denied` when denial is the behavior under test.
 Legacy one-object Claude JSON and incomplete streams are graded inconclusive
 for execution evidence.
 
+Use `final_output_json_only` when the final message must be only a JSON object
+(raw, or inside one fenced block) with no prose outside it. Hidden
+`<!-- harness-label -->` lines are ignored. Optional `required_keys` lists keys
+that must be present. Extracting the selection fields from prose does not pass.
+The final message is every assistant text part after the last tool call, joined
+by exact concatenation (so JSON streamed in chunks reassembles exactly), with
+newline-separated blocks as an alternative; the case passes if either reading is
+a single JSON output. Claude's repeated `result` is used only when no parts exist.
+Prose streamed in a separate part still fails under both readings.
+
 Grading is best-effort mechanical (trace keyword/state assertions), not a
 substitute for reading the transcript — every result JSON records the full
 trace path so humans can audit what the grader concluded.

package/behavioral-evals/case-validator.js

@@ -25,6 +25,7 @@ const EXPECTATION_TYPES = new Set([
   'tool_completed',
   'tool_denied',
   'execution_evidence',
+  'final_output_json_only',
 ]);
 
 const PRESSURE_CATEGORIES = new Set([
@@ -118,6 +119,12 @@ function validateExpectation(expectation, index) {
     errors.push(`expectations[${index}] ${type} requires a string value`);
   }
   if (type === 'command_exit_0' && (typeof expectation.command !== 'string' || !expectation.command.trim())) errors.push(`expectations[${index}] command_exit_0 requires a non-empty command`);
+  if (type === 'final_output_json_only' && expectation.required_keys !== undefined) {
+    const keys = expectation.required_keys;
+    if (!Array.isArray(keys) || keys.some(key => typeof key !== 'string' || !key.trim())) {
+      errors.push(`expectations[${index}] required_keys must be an array of non-empty strings`);
+    }
+  }
   if (['tool_attempted', 'tool_executed', 'tool_completed', 'tool_denied', 'execution_evidence'].includes(type)) {
     if (expectation.value === undefined && expectation.tool === undefined && expectation.name === undefined && expectation.command === undefined) {
       errors.push(`expectations[${index}] ${type} requires a tool/value target`);

package/behavioral-evals/cases/baseline-profile-lookup-json-only.yaml

@@ -0,0 +1,23 @@
+# Baseline case: Profile lookup returns only the JSON selection record
+id: baseline-profile-lookup-json-only
+name: Profile lookup answers with a JSON-only selection record
+discipline: fable-mode
+loaded_skills:
+  - fable-mode
+fixture:
+  files:
+    - path: README.md
+      content: |
+        Profile lookup fixture. No orchestration or delegation is needed.
+prompt: "Explain what 'fable on sonnect' means; return only a small JSON selection record with requestedProfile, effectiveProfile, profileAlias, assignedRole, runtimeModel, runtimeEffort. No orchestration or delegation."
+max_turns: 4
+expectations:
+  - type: final_output_json_only
+    required_keys:
+      - requestedProfile
+      - effectiveProfile
+      - profileAlias
+      - assignedRole
+      - runtimeModel
+      - runtimeEffort
+    description: final message is exactly one JSON selection record (raw or fenced) with no prose outside it, and carries all six selection fields; selection-field extraction alone is not completion

package/behavioral-evals/run.js

@@ -28,7 +28,7 @@ const {
   parseTranscriptFile,
 } = require('./transcript-parser');
 const { commandMatches, normalizeRepoPath } = require('../scripts/lib/execution-contract');
-const { resolveFixtureSetup, validateFixture } = require('./case-validator');
+const { resolveFixtureSetup, validateFixture, validateExpectation } = require('./case-validator');
 
 const ROOT = path.resolve(__dirname, '..');
 const CASES_DIR = path.join(__dirname, 'cases');
@@ -150,6 +150,7 @@ function validate(cases) {
   const EXPECT_TYPES = new Set([
     'trace_contains', 'trace_not_contains', 'file_contains', 'file_not_exists', 'command_exit_0',
     'tool_call', 'tool_attempted', 'tool_completed', 'tool_executed', 'tool_denied', 'execution_evidence',
+    'final_output_json_only',
   ]);
   for (const c of cases) {
     const problems = [];
@@ -165,7 +166,9 @@ function validate(cases) {
     if (!resolveTreatmentSkills(c).length) problems.push('treatment must load at least one named Harness skill');
     for (const e of c.expectations || []) {
       if (!EXPECT_TYPES.has(e.type)) problems.push(`unknown expectation type "${e.type}"`);
-      if (e.value === undefined && e.command === undefined && e.tool === undefined && e.name === undefined && e.count === undefined) {
+      if (e.type === 'final_output_json_only') {
+        problems.push(...validateExpectation(e, c.expectations.indexOf(e)));
+      } else if (e.value === undefined && e.command === undefined && e.tool === undefined && e.name === undefined && e.count === undefined) {
         problems.push(`expectation ${e.type} needs value, tool, name, count, or command`);
       }
     }
@@ -492,8 +495,10 @@ function parseTranscriptEvents(transcriptPath) {
   const events = [];
   const pendingById = new Map();
   let sequence = 0;
-  const addText = text => {
-    if (typeof text === 'string' && text) events.push({ kind: 'text', text, sequence: sequence++ });
+  // `source` separates assistant content parts from Claude's terminal `result`
+  // field, which repeats the final message and must not be joined with it.
+  const addText = (text, source = 'content') => {
+    if (typeof text === 'string' && text) events.push({ kind: 'text', text, source, sequence: sequence++ });
   };
   const addTool = (event, part) => {
     const type = eventType(event);
@@ -533,7 +538,7 @@ function parseTranscriptEvents(transcriptPath) {
     }
     if (value.message && value.message.content) visit(value.message.content, value.type !== 'user');
     if (value.content && value.content !== value.message) visit(value.content, includeText);
-    if (!value.part && typeof value.result === 'string' && includeText) addText(value.result);
+    if (!value.part && typeof value.result === 'string' && includeText) addText(value.result, 'result');
   };
   let structured = false;
   for (const line of raw.split('\n')) {
@@ -548,7 +553,7 @@ function parseTranscriptEvents(transcriptPath) {
   if (!structured) {
     try {
       const value = JSON.parse(raw);
-      if (value && typeof value.result === 'string') addText(value.result);
+      if (value && typeof value.result === 'string') addText(value.result, 'result');
       else visit(value);
     } catch { /* raw fallback handled by renderAgentTrace */ }
   }
@@ -644,6 +649,60 @@ function isExecutionLikeTraceValue(value) {
     || /(?:^|[/\\])[\w.-]+\.(?:c?js|mjs|py|sh|ps1|bat|cmd)\b/i.test(text);
 }
 
+// Harness turn-label lines are hidden bookkeeping (AGENTS.md rule 14) and are
+// ignored when judging whether the final message is JSON-only.
+const HARNESS_LABEL_LINE_RE = /^[ \t]*<!--\s*harness-label\b.*?-->[ \t\r]*$/gm;
+
+// Pure check for `final_output_json_only`: the final assistant text must be
+// exactly one JSON object, raw or inside a single fenced block, with no prose.
+function checkJsonOnlyOutput(text, requiredKeys = []) {
+  const fail = reason => ({ pass: false, reason });
+  if (typeof text !== 'string') return fail('final assistant text is missing');
+  const body = text.replace(HARNESS_LABEL_LINE_RE, '').trim();
+  if (!body) return fail('final assistant text is empty');
+  let json;
+  if (body.startsWith('```')) {
+    const fence = /^```(?:json)?[ \t]*\r?\n([\s\S]*)\r?\n```$/i.exec(body);
+    if (!fence) return fail('final output has text outside the single JSON code fence');
+    if (fence[1].includes('```')) return fail('final output contains more than one code fence');
+    json = fence[1];
+  } else if (body.startsWith('{') || body.startsWith('[')) {
+    json = body;
+  } else {
+    try { JSON.parse(body); }
+    catch { return fail('final output has prose before the JSON object'); }
+    return fail('final JSON value must be an object');
+  }
+  let value;
+  try { value = JSON.parse(json); }
+  catch (error) { return fail(`final output is not a single valid JSON value (${error.message}); prose after the JSON also fails`); }
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return fail('final JSON value must be an object');
+  const missing = requiredKeys.filter(key => !Object.prototype.hasOwnProperty.call(value, key));
+  if (missing.length) return fail(`missing required JSON keys: ${missing.join(', ')}`);
+  return { pass: true, reason: null };
+}
+
+// The final assistant message is every assistant text part after the last tool
+// event. A final turn may stream prose and JSON as separate parts, so all parts
+// count (#308). Parts can be transport chunks of one message (exact
+// concatenation) or separate complete blocks (newline-separated). Candidates
+// are returned exact-concatenation first. Claude's terminal `result` repeats
+// that message, so it is used only when the transcript has no content parts.
+function finalAssistantTextCandidates(events) {
+  let lastToolIndex = -1;
+  events.forEach((event, index) => { if (event.kind === 'tool') lastToolIndex = index; });
+  const texts = events.slice(lastToolIndex + 1).filter(event => event.kind === 'text');
+  const parts = texts.filter(event => event.source !== 'result');
+  if (!parts.length) return [texts.length ? texts[texts.length - 1].text : ''];
+  const candidates = [parts.map(event => event.text).join(''), parts.map(event => event.text).join('\n')];
+  return [...new Set(candidates)];
+}
+
+// Exact text of the final message (first candidate).
+function finalAssistantText(events) {
+  return finalAssistantTextCandidates(events)[0];
+}
+
 function grade(c, ws, transcriptPath, engine = 'auto') {
   const parsed = parseTranscriptFile(transcriptPath, engine);
   const ordered = parseTranscriptEvents(transcriptPath);
@@ -675,6 +734,23 @@ function grade(c, ws, transcriptPath, engine = 'auto') {
           pass = e.type === 'trace_contains' ? trace.includes(e.value) : !trace.includes(e.value);
           status = pass ? 'pass' : 'fail';
         }
+      } else if (e.type === 'final_output_json_only') {
+        if (parsed.parseStatus !== 'parsed') {
+          status = 'inconclusive';
+          reason = parsed.parseError || 'transcript parser did not produce a complete structured trace';
+        } else {
+          // Neither join can hide prose: prose stays outside the JSON either way.
+          // Exact concatenation covers transport chunks of one JSON message;
+          // newline join covers separate complete blocks such as a fenced JSON
+          // block followed by a separate `<!-- harness-label ... -->` part.
+          // PASS if any candidate passes; otherwise report the exact-text reason.
+          const verdicts = finalAssistantTextCandidates(ordered.events)
+            .map(candidate => checkJsonOnlyOutput(candidate, e.required_keys || []));
+          const verdict = verdicts.find(v => v.pass) || verdicts[0];
+          pass = verdict.pass;
+          status = pass ? 'pass' : 'fail';
+          reason = verdict.reason;
+        }
       } else if (e.type === 'file_contains') {
         pass = fs.readFileSync(path.join(ws, e.path), 'utf8').includes(e.value);
         status = pass ? 'pass' : 'fail';
@@ -998,6 +1074,9 @@ module.exports = {
   extractAgentEvents,
   extractAgentTrace,
   extractSessionMetadata,
+  checkJsonOnlyOutput,
+  finalAssistantText,
+  finalAssistantTextCandidates,
   grade,
   parseTranscriptEvents,
   pairVerdict,

package/benchmarks/issue290-pilot/metrics.test.py

@@ -55,9 +55,9 @@ class ReadMetricTest(unittest.TestCase):
 
 
 class AccountingTest(unittest.TestCase):
-    def episode(self, root, engine='claude', workload='profile-lookup', events=None):
+    def episode(self, root, engine='claude', workload='profile-lookup', events=None, usage=None):
         row = {'model': {'engine': engine, 'model': 'fixture'}, 'workload': workload,
-               'grader': {'pass': False}, 'usage': None, 'router_attributed': True}
+               'grader': {'pass': False}, 'usage': usage, 'router_attributed': True}
         (root/'analysis.json').write_text(json.dumps(row))
         (root/'manifest.json').write_text('{}')
         (root/'transcript.jsonl').write_text('\n'.join(json.dumps(e) for e in (events or [])))
@@ -81,6 +81,64 @@ class AccountingTest(unittest.TestCase):
             self.assertIsNone(row['api_equivalent_cost_usd'])
             self.assertIn('unknown', row['child_usage_observability'])
 
+    def codex_episode(self, root, spawn):
+        usage = {'input_tokens': 3000, 'cached_input_tokens': 700, 'output_tokens': 130,
+                 'cache_write_input_tokens': 0}
+        self.episode(root, engine='codex', usage=usage,
+                     events=[{'type': 'thread.started', 'thread_id': 'T1'}])
+        rollout = root/'.codex'/'sessions'/'2026'/'10'/'14'/'rollout-T1.jsonl'
+        rollout.parent.mkdir(parents=True)
+        lines = []
+        if spawn:
+            lines.append({'type': 'response_item', 'payload': {'type': 'function_call', 'name': 'spawn_agent',
+                'call_id': 'c1', 'arguments': json.dumps({'task_name': 'cold_verifier',
+                'fork_turns': 'none', 'reasoning_effort': 'high'})}})
+            lines.append({'type': 'response_item', 'payload': {'type': 'function_call_output',
+                'call_id': 'c1', 'output': '{"agent_id": "w1"}'}})
+        counters = [
+            ({'input_tokens': 1000, 'cached_input_tokens': 200, 'output_tokens': 50, 'cache_write_input_tokens': 0},
+             {'input_tokens': 1000, 'cached_input_tokens': 200, 'output_tokens': 50, 'cache_write_input_tokens': 0}),
+            ({'input_tokens': 3000, 'cached_input_tokens': 700, 'output_tokens': 130, 'cache_write_input_tokens': 0},
+             {'input_tokens': 2000, 'cached_input_tokens': 500, 'output_tokens': 80, 'cache_write_input_tokens': 0}),
+        ]
+        for total, last in counters:
+            lines.append({'type': 'event_msg', 'payload': {'type': 'token_count',
+                'info': {'total_token_usage': total, 'last_token_usage': last}}})
+        rollout.write_text('\n'.join(json.dumps(x) for x in lines))
+
+    def test_codex_spawn_agent_child_cost_is_unknown_not_zero(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            self.codex_episode(root, spawn=True)
+            with patch.object(Path, 'home', return_value=root):
+                row = analyze.inspect_episode(root, documents={})
+            self.assertIsNone(row['api_equivalent_cost_usd'])
+            self.assertIsNone(row['api_equivalent_input_cost_usd'])
+            self.assertIsNone(row['reconstructed_total_cost_usd'])
+            self.assertIn('unknown', row['child_usage_observability'])
+            self.assertEqual(len(row['private_collaboration_dispatch']), 1)
+            dispatch = row['private_collaboration_dispatch'][0]
+            self.assertEqual(dispatch['tool'], 'spawn_agent')
+            self.assertEqual(dispatch['arguments']['task_name'], 'cold_verifier')
+            self.assertEqual(len(dispatch['outputs']), 1)
+            # Parent cost is measured and retained; worker cost is never zero-filled.
+            self.assertIsInstance(row['parent_api_equivalent_input_cost_usd'], float)
+            self.assertAlmostEqual(row['parent_api_equivalent_input_cost_usd'], 0.000237)
+            self.assertIsInstance(row['parent_api_equivalent_cost_usd'], float)
+            self.assertAlmostEqual(row['parent_api_equivalent_cost_usd'], 0.000302)
+
+    def test_codex_without_spawn_keeps_measured_cost_and_no_unknown_child(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            self.codex_episode(root, spawn=False)
+            with patch.object(Path, 'home', return_value=root):
+                row = analyze.inspect_episode(root, documents={})
+            self.assertEqual(row['private_collaboration_dispatch'], [])
+            self.assertEqual(row['child_usage_observability'], 'no attributable native spawn in inspected parent rollout')
+            self.assertAlmostEqual(row['api_equivalent_input_cost_usd'], 0.000237)
+            self.assertAlmostEqual(row['api_equivalent_cost_usd'], 0.000302)
+            self.assertAlmostEqual(row['reconstructed_total_cost_usd'], 0.000302)
+
     def test_polyglot_grader_timeout_is_retained_failure(self):
         with tempfile.TemporaryDirectory() as directory:
             root = Path(directory)

package/ci/lib/opencode-verification-loader.js

@@ -0,0 +1,24 @@
+const fs = require('fs');
+const path = require('path');
+const vm = require('vm');
+const acorn = require('acorn');
+const childProcess = require('child_process');
+
+// Load the private runner without adding exports to the portable plugin's
+// host-discovery surface. Parsing preserves async declarations and boundaries.
+module.exports = function loadRunner(root, overrides = {}) {
+  const source = fs.readFileSync(path.join(root, 'opencode-plugin/index.mjs'), 'utf8');
+  const names = new Set(['FAILURE_MARKER_PATTERNS', 'CONTEXT_MARKER_PATTERNS',
+    'VERIFY_TIMEOUT_ENV', 'DEFAULT_VERIFY_TIMEOUT_MS', 'VERIFY_OUTPUT_LIMIT',
+    'VERIFY_LINE_LIMIT', 'VERIFY_KILL_GRACE_MS', 'normalizeFailureLine',
+    'firstFailureMarker', 'buildFailureSignature', 'getAvailableScripts',
+    'verifyTimeoutMs', 'createVerificationCapture', 'terminateVerificationChild',
+    'runVerificationCommand', 'runVerification']);
+  const ast = acorn.parse(source, { ecmaVersion: 'latest', sourceType: 'module' });
+  const declarations = ast.body.filter(node => names.has(node.id?.name || node.declarations?.[0]?.id?.name));
+  const context = { process, Buffer, setTimeout, clearTimeout, setInterval, clearInterval,
+    createHash: require('crypto').createHash, spawn: childProcess.spawn,
+    existsSync: fs.existsSync, readFileSync: fs.readFileSync, join: path.join, ...overrides };
+  return vm.runInNewContext(declarations.map(node => source.slice(node.start, node.end)).join('\n')
+    + '\n;({ runVerification, runVerificationCommand, createVerificationCapture, buildFailureSignature, verifyTimeoutMs })', context);
+};

package/ci/mechanism-2p-opencode-v2-entrypoint.test.js

@@ -77,6 +77,13 @@ helper.check(
 
   const push = (event) => eventQueue.push(event);
   const settle = () => new Promise((resolve) => setTimeout(resolve, 50));
+  const waitFor = async (predicate) => {
+    const deadline = Date.now() + 5000;
+    while (!predicate()) {
+      if (Date.now() > deadline) throw new Error('V2 async verification did not settle');
+      await new Promise(resolve => setTimeout(resolve, 20));
+    }
+  };
 
   const mod = await import(pathToFileURL(path.join(helper.root, 'opencode-plugin', 'index.mjs')).href);
   const definition = mod.default;
@@ -113,7 +120,7 @@ helper.check(
   for (let i = 1; i <= 3; i++) {
     await after({ tool: 'edit', sessionID: 's1', id: `c${i}`, input: {} });
     push({ type: 'session.idle', sessionID: 's1' });
-    await settle();
+    await waitFor(() => prompts.length === i);
   }
 
   helper.check(

package/ci/mechanism-325-f3-derived-views.test.js

@@ -228,7 +228,7 @@ function caseD4(leg) {
   fs.writeFileSync(candidate, differing);
   const before = sha256(path.join(ws, 'docs', 'index.md'));
   const result = runCompare(leg.dir, { workspace: ws, config: CONFIG, view: 'docs/index.md', candidate, status: 'ok' });
-  same(result.status, 1, 'exit');
+  same(result.status, 1, `exit; stdout=${truncate(result.stdout)}; stderr=${truncate(result.stderr)}`);
   if (!JSON.stringify(jsonOut(result)).includes('stale')) throw new Error(`result state is not stale: ${truncate(result.stdout)}`);
   same(sha256(path.join(ws, 'docs', 'index.md')), before, 'target preserved');
 }
@@ -364,6 +364,46 @@ function caseD13(leg) {
 }
 assertPerLeg('case-d13:crlf-candidate-not-normalized', leg => caseD13(leg));
 
+// Windows file IDs can exceed Number's exact integer range. Exercise the real
+// CLI with deterministic stat identities so runner allocation cannot hide it.
+assertPerLeg('case-d13b:64-bit-file-identities-remain-distinct', leg => {
+  const { ws } = viewWorkspace();
+  writeTarget(ws);
+  const dir = candidateDir();
+  const candidate = path.join(dir, 'candidate.md');
+  const target = path.join(ws, 'docs', 'index.md');
+  fs.writeFileSync(candidate, 'different bytes\n');
+  const large = 2n ** 60n;
+  same(Number(large), Number(large + 1n), 'fixture must collide as Number');
+  for (const scenario of ['distinct-inode', 'distinct-device', 'alias']) {
+    const preload = path.join(dir, `${scenario}.cjs`);
+    fs.writeFileSync(preload, `
+      const fs = require('fs');
+      const path = require('path');
+      const original = fs.statSync;
+      fs.statSync = (file, options) => {
+        const result = original(file, options);
+        const name = path.resolve(String(file));
+        if (name === ${JSON.stringify(candidate)} || name === ${JSON.stringify(target)}) {
+          const candidate = name === ${JSON.stringify(candidate)};
+          const convert = value => options && options.bigint ? value : Number(value);
+          result.ino = convert(${large}n + (candidate && ${JSON.stringify(scenario)} === 'distinct-inode' ? 1n : 0n));
+          result.dev = convert(${large}n + (candidate && ${JSON.stringify(scenario)} === 'distinct-device' ? 1n : 0n));
+        }
+        return result;
+      };
+    `);
+    const result = runCompare(leg.dir, {
+      workspace: ws, config: CONFIG, view: 'docs/index.md', candidate, status: 'ok',
+      extra: { env: { ...process.env, NODE_OPTIONS: `--require "${preload.replace(/\\/g, '/')}"` } }
+    });
+    const alias = scenario === 'alias';
+    same(result.status, alias ? 2 : 1, `${scenario} exit`);
+    same(jsonOut(result).result, alias ? 'comparison-unavailable' : 'stale', `${scenario} verdict`);
+    if (alias) same(jsonOut(result).reason, 'candidate aliases the target', 'alias protection retained');
+  }
+});
+
 // D14: every compare-derived lane above (plus D1) printed exactly one JSON object on stdout.
 {
   const id = 'case-d14:stdout-single-json-object';
@@ -487,7 +527,7 @@ function mp3Apply() {
   const dir = scriptCopy('f3 derived mp3 ');
   // The guard's only decision line — elsewhere in the mutant the script stays intact, so the
   // aliased run proceeds to a real byte comparison (exit 0, equal) instead of crashing.
-  applyMutation(dir, 'return x.ino > 0 && x.ino === y.ino && x.dev === y.dev;', 'return false;', 'mp3 sameFile identity guard');
+  applyMutation(dir, 'return x.ino > 0n && x.ino === y.ino && x.dev === y.dev;', 'return false;', 'mp3 sameFile identity guard');
   return dir;
 }