harness-everything 0.47.3 → 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.3",
+      "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.3",
+  "version": "0.47.4",
   "author": {
     "name": "Miya Daniel"
   },

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 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

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/test-behavioral-case-validation.js

@@ -5,8 +5,8 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { parseSimpleYaml } = require('../behavioral-evals/run');
-const { grade, parseTranscriptEvents } = require('../behavioral-evals/run');
-const { validateCase, validateDirectory, negativeControls } = require('../behavioral-evals/case-validator');
+const { grade, parseTranscriptEvents, checkJsonOnlyOutput, finalAssistantText } = require('../behavioral-evals/run');
+const { validateCase, validateDirectory, validateExpectation, negativeControls } = require('../behavioral-evals/case-validator');
 const { canonicalRubric, extractTrace } = require('./ab-test-harness');
 
 const casesDir = path.join(__dirname, '..', 'behavioral-evals', 'cases');
@@ -85,4 +85,149 @@ try {
   fs.rmSync(transcriptDir, { recursive: true, force: true });
 }
 
-console.log(`Behavioral case validation passed (${fs.readdirSync(casesDir).filter(name => name.endsWith('.yaml')).length} cases + negative controls + ordered execution evidence).`);
+// final_output_json_only: pure checker, validator schema, shipped #308 case, and
+// end-to-end grading over the final assistant message.
+const SELECTION_KEYS = ['requestedProfile', 'effectiveProfile', 'profileAlias', 'assignedRole', 'runtimeModel', 'runtimeEffort'];
+const SELECTION = { requestedProfile: 'fable', effectiveProfile: 'sonnet', profileAlias: 'fable-on-sonnet', assignedRole: 'worker', runtimeModel: 'claude-haiku-5-5', runtimeEffort: 'low' };
+const LABEL = '<!-- harness-label {"judgement":"done","routing":"direct"} -->';
+const RAW = JSON.stringify(SELECTION);
+const FENCED = '```json\n' + JSON.stringify(SELECTION, null, 2) + '\n```';
+const PASS_CASES = [
+  ['raw JSON object', RAW],
+  ['fenced json block', FENCED],
+  ['untagged fence', '```\n' + RAW + '\n```'],
+  ['raw JSON followed by harness-label line', RAW + '\n' + LABEL],
+  ['fenced JSON followed by harness-label line', FENCED + '\n' + LABEL],
+];
+for (const [name, text] of PASS_CASES) {
+  const verdict = checkJsonOnlyOutput(text, SELECTION_KEYS);
+  assert.strictEqual(verdict.pass, true, `${name} should pass: ${verdict.reason}`);
+}
+const FAIL_CASES = [
+  // The #308 pilot: correct fields, explanatory prose outside the JSON.
+  ['prose before JSON (#308)', `"Fable on sonnect" means the fable profile runs on sonnet.\n\n${FENCED}`, /prose before/],
+  ['prose after fence', `${FENCED}\nThat is the selection record.`, /outside the single JSON code fence/],
+  ['prose after raw JSON', `${RAW}\nThat is the selection record.`, /not a single valid JSON value/],
+  ['two fenced blocks', `${FENCED}\n${FENCED}`, /more than one code fence/],
+  ['missing required key', JSON.stringify({ ...SELECTION, runtimeEffort: undefined }), /missing required JSON keys: runtimeEffort/],
+  ['non-object JSON (array)', JSON.stringify([SELECTION]), /must be an object/],
+  ['non-object JSON (scalar)', '"fable"', /must be an object/],
+  ['empty final text', '', /empty/],
+  ['label-only final text', LABEL, /empty/],
+  ['missing final text', undefined, /missing/],
+];
+for (const [name, text, expected] of FAIL_CASES) {
+  const verdict = checkJsonOnlyOutput(text, SELECTION_KEYS);
+  assert.strictEqual(verdict.pass, false, `${name} should fail`);
+  assert.match(verdict.reason, expected, `${name} should give a clear reason`);
+}
+assert.strictEqual(checkJsonOnlyOutput(RAW).pass, true, 'required_keys defaults to no key requirement');
+
+for (const requiredKeys of ['requestedProfile', [''], ['  '], [1], ['ok', null]]) {
+  const errors = validateExpectation({ type: 'final_output_json_only', required_keys: requiredKeys }, 0);
+  assert.ok(errors.some(error => /required_keys must be an array of non-empty strings/.test(error)), `required_keys ${JSON.stringify(requiredKeys)} should be rejected`);
+}
+assert.deepStrictEqual(validateExpectation({ type: 'final_output_json_only' }, 0), [], 'final_output_json_only without required_keys is valid');
+assert.deepStrictEqual(validateExpectation({ type: 'final_output_json_only', required_keys: SELECTION_KEYS }, 0), [], 'final_output_json_only with string keys is valid');
+
+const profileCasePath = path.join(casesDir, 'baseline-profile-lookup-json-only.yaml');
+const profileCase = parseSimpleYaml(fs.readFileSync(profileCasePath, 'utf8'));
+assert.deepStrictEqual(validateCase(profileCase, { fileName: 'baseline-profile-lookup-json-only.yaml' }), [], 'profile-lookup JSON-only case should validate');
+assert.deepStrictEqual(profileCase.expectations.map(expectation => expectation.type), ['final_output_json_only'], 'profile-lookup case should assert JSON-only output');
+assert.deepStrictEqual(profileCase.expectations[0].required_keys, SELECTION_KEYS, 'profile-lookup case should require the six selection keys');
+assert.match(profileCase.prompt, /return only a small JSON selection record with requestedProfile, effectiveProfile, profileAlias, assignedRole, runtimeModel, runtimeEffort\. No orchestration or delegation\./, 'profile-lookup prompt should match the #308 wording');
+
+const jsonOnlyDir = fs.mkdtempSync(path.join(os.tmpdir(), 'behavioral-json-only-'));
+try {
+  const writeTranscript = (name, finalText) => {
+    const transcriptPath = path.join(jsonOnlyDir, name);
+    const events = [
+      { type: 'tool_use', part: { type: 'tool', tool: 'Read', callID: 'read-1', state: { status: 'completed', input: { file_path: 'README.md' } } } },
+      { type: 'text', part: { type: 'text', text: 'Checking the profile table first.' } },
+      { type: 'tool_use', part: { type: 'tool', tool: 'Read', callID: 'read-2', state: { status: 'completed', input: { file_path: 'profiles.md' } } } },
+      { type: 'text', part: { type: 'text', text: finalText } },
+    ];
+    fs.writeFileSync(transcriptPath, events.map(event => JSON.stringify(event)).join('\n'));
+    return transcriptPath;
+  };
+  const jsonOnlyExpectation = { expectations: [{ type: 'final_output_json_only', required_keys: SELECTION_KEYS }] };
+  let transcriptCount = 0;
+  const gradeFinal = finalText => grade(jsonOnlyExpectation, jsonOnlyDir, writeTranscript(`final-${transcriptCount++}.jsonl`, finalText));
+  assert.strictEqual(gradeFinal(RAW).passed, true, 'raw JSON final message should pass end to end');
+  assert.strictEqual(gradeFinal(`${FENCED}\n${LABEL}`).passed, true, 'fenced JSON with harness-label should pass end to end');
+  const prose = gradeFinal(`Fable on sonnect means a profile.\n${FENCED}`);
+  assert.strictEqual(prose.passed, false, 'prose before JSON must fail end to end');
+  assert.strictEqual(prose.results[0].status, 'fail');
+  assert.match(prose.results[0].reason, /prose before/);
+  // Prose from an earlier turn (before the last tool call) is not the final message.
+  const earlierProse = writeTranscript('earlier-prose.jsonl', RAW);
+  assert.strictEqual(grade(jsonOnlyExpectation, jsonOnlyDir, earlierProse).passed, true, 'only the final assistant message is graded');
+
+  // Multi-part final messages: the final turn may stream several text parts.
+  const writeParts = (name, finalParts) => {
+    const transcriptPath = path.join(jsonOnlyDir, name);
+    const events = [
+      { type: 'tool_use', part: { type: 'tool', tool: 'Read', callID: 'read-1', state: { status: 'completed', input: { file_path: 'profiles.md' } } } },
+      ...finalParts.map(text => ({ type: 'text', part: { type: 'text', text } })),
+    ];
+    fs.writeFileSync(transcriptPath, events.map(event => JSON.stringify(event)).join('\n'));
+    return transcriptPath;
+  };
+  const proseThenJson = grade(jsonOnlyExpectation, jsonOnlyDir, writeParts('prose-part-json-part.jsonl', ['"Fable on sonnect" means the fable profile on sonnet.', FENCED]));
+  assert.strictEqual(proseThenJson.passed, false, 'prose part + JSON part must fail (#308 false pass)');
+  assert.match(proseThenJson.results[0].reason, /prose before/);
+  const jsonThenProse = grade(jsonOnlyExpectation, jsonOnlyDir, writeParts('json-part-prose-part.jsonl', [FENCED, 'That is the selection record.']));
+  assert.strictEqual(jsonThenProse.passed, false, 'JSON part + prose part must fail');
+  const splitBody = JSON.stringify(SELECTION, null, 2);
+  const cut = splitBody.indexOf('"assignedRole"');
+  const splitJson = grade(jsonOnlyExpectation, jsonOnlyDir, writeParts('split-json.jsonl', ['```json\n' + splitBody.slice(0, cut), splitBody.slice(cut) + '\n```']));
+  assert.strictEqual(splitJson.passed, true, `JSON split across text parts should pass: ${splitJson.results[0].reason}`);
+
+  // Transport chunks cut inside a JSON string value, a key, and the fence opener.
+  // Exact concatenation must rebuild the message; a '\n' join would break it.
+  const valueCut = RAW.indexOf('fable') + 2;
+  const keyCut = RAW.indexOf('requestedProfile') + 5;
+  const splitValueParts = [RAW.slice(0, valueCut), RAW.slice(valueCut)];
+  const splitValuePath = writeParts('split-inside-value.jsonl', splitValueParts);
+  assert.strictEqual(finalAssistantText(parseTranscriptEvents(splitValuePath).events), RAW, 'split-inside-value parts must concatenate to the exact raw JSON');
+  assert.throws(() => JSON.parse(RAW.slice(0, valueCut) + '\n' + RAW.slice(valueCut)), 'a newline join inside a JSON string must not parse (the #308 reviewer case)');
+  const POSITIVE_SPLITS = [
+    ['split inside a JSON string value', splitValueParts],
+    ['split inside a JSON key', [RAW.slice(0, keyCut), RAW.slice(keyCut)]],
+    ['split inside the fence opener', ['```js', 'on\n' + JSON.stringify(SELECTION, null, 2) + '\n```']],
+    ['fenced JSON block followed by a harness-label part', [FENCED, LABEL]],
+  ];
+  POSITIVE_SPLITS.forEach(([name, parts], index) => {
+    const result = grade(jsonOnlyExpectation, jsonOnlyDir, writeParts(`positive-split-${index}.jsonl`, parts));
+    assert.strictEqual(result.passed, true, `${name} should pass end to end: ${result.results[0].reason}`);
+  });
+  const NEGATIVE_SPLITS = [
+    ['prose chunk glued to JSON start', ['Here:', RAW], /prose before/],
+    ['prose after a split JSON', [RAW.slice(0, 10), RAW.slice(10), ' done'], /not a single valid JSON value/],
+  ];
+  NEGATIVE_SPLITS.forEach(([name, parts, expected], index) => {
+    const result = grade(jsonOnlyExpectation, jsonOnlyDir, writeParts(`negative-split-${index}.jsonl`, parts));
+    assert.strictEqual(result.passed, false, `${name} must fail end to end`);
+    assert.match(result.results[0].reason, expected, `${name} should give a clear reason`);
+  });
+
+  // Claude stream-json: assistant content parts plus a terminal `result` that
+  // repeats them. The repeat must not be double-counted, and must not mask prose.
+  const writeClaude = (name, contentTexts, resultText) => {
+    const transcriptPath = path.join(jsonOnlyDir, name);
+    const lines = [
+      { type: 'assistant', message: { content: [{ type: 'tool_use', id: 'tu-1', name: 'Read', input: { file_path: 'profiles.md' } }] } },
+      { type: 'user', message: { content: [{ type: 'tool_result', tool_use_id: 'tu-1', content: 'ok' }] } },
+      { type: 'assistant', message: { content: contentTexts.map(text => ({ type: 'text', text })) } },
+      { type: 'result', subtype: 'success', result: resultText },
+    ];
+    fs.writeFileSync(transcriptPath, lines.map(line => JSON.stringify(line)).join('\n'));
+    return transcriptPath;
+  };
+  assert.strictEqual(grade(jsonOnlyExpectation, jsonOnlyDir, writeClaude('claude-result-repeat.jsonl', [FENCED], FENCED)).passed, true, 'Claude result repeat must not double the JSON');
+  assert.strictEqual(grade(jsonOnlyExpectation, jsonOnlyDir, writeClaude('claude-prose-parts.jsonl', ['Here is the record.', FENCED], FENCED)).passed, false, 'Claude prose content part must fail even when result holds only JSON');
+} finally {
+  fs.rmSync(jsonOnlyDir, { recursive: true, force: true });
+}
+
+console.log(`Behavioral case validation passed (${fs.readdirSync(casesDir).filter(name => name.endsWith('.yaml')).length} cases + negative controls + ordered execution evidence + json-only final output).`);

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.47.3",
+  "version": "0.47.4",
   "runtime": "index.mjs",
   "hooks": {
     "verify": "hooks/verify.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.47.3",
+  "version": "0.47.4",
   "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.47.3",
+  "version": "0.47.4",
   "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.47.3",
+  "version": "0.47.4",
   "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:1aa302d2-c2eb-59e7-aed3-a0dae8f57f06",
+  "serialNumber": "urn:uuid:9486ee85-4d20-5c13-b980-a501dc02e9fa",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-10-31T16:31:35.736Z",
+    "timestamp": "2026-11-03T01:39:16.935Z",
     "tools": [
       {
         "vendor": "Harness Everything",
         "name": "generate-sbom.js",
-        "version": "0.47.3"
+        "version": "0.47.4"
       }
     ],
     "component": {
       "type": "application",
-      "bom-ref": "pkg:npm/harness-everything@0.47.3",
+      "bom-ref": "pkg:npm/harness-everything@0.47.4",
       "name": "harness-everything",
-      "version": "0.47.3",
-      "purl": "pkg:npm/harness-everything@0.47.3"
+      "version": "0.47.4",
+      "purl": "pkg:npm/harness-everything@0.47.4"
     }
   },
   "components": [
@@ -2033,7 +2033,7 @@
       ]
     },
     {
-      "ref": "pkg:npm/harness-everything@0.47.3",
+      "ref": "pkg:npm/harness-everything@0.47.4",
       "dependsOn": [
         "pkg:npm/%40commitlint/cli@19.8.1",
         "pkg:npm/%40commitlint/config-conventional@19.8.1",