fix(eval): make opencode NDJSON output parseable + gate only latest eval round

src/adapters/adapter.test.ts

@@ -1,4 +1,6 @@
 import { EventEmitter } from 'node:events';
+import fs from 'node:fs';
+import path from 'node:path';
 import { vi } from 'vitest';
 import type { AgentAdapter, AgentInvocation, AgentResponse } from './base.js';
 import { AdapterRegistry, parseAdapterExtraArgs } from './index.js';
@@ -207,3 +209,256 @@ describe('adapter extraArgs passthrough', () => {
     expect(argv[1]).toBe('--dangerously-bypass-approvals-and-sandbox');
   });
 });
+
+describe('OpenCodeAdapter NDJSON output collapse', () => {
+  beforeEach(() => {
+    spawnMock.mockReset();
+  });
+
+  const fixturePath = path.resolve(
+    __dirname,
+    '..',
+    '..',
+    'tests',
+    'fixtures',
+    'fake-agents',
+    'opencode-ndjson-text-parts.json',
+  );
+
+  it('collapses the event stream into text-part contents (prose + trailing verdict)', async () => {
+    const ndjson = fs.readFileSync(fixturePath, 'utf8');
+    spawnMock.mockImplementation(() => makeFakeChild(0, ndjson));
+
+    const adapter = new OpenCodeAdapter();
+    const response = await adapter.invoke({ prompt: 'review this' });
+
+    expect(response.success).toBe(true);
+    expect(response.output).toContain('All 12 tests pass.');
+    expect(response.output).toContain('"passed": true');
+    // Raw NDJSON event framing must not leak through.
+    expect(response.output).not.toContain('"type":"step_start"');
+    expect(response.output).not.toContain('"type":"tool_use"');
+  });
+
+  it('joins multiple text events in stream order (real streams emit many)', async () => {
+    const ndjson = fs.readFileSync(fixturePath, 'utf8');
+    spawnMock.mockImplementation(() => makeFakeChild(0, ndjson));
+
+    const adapter = new OpenCodeAdapter();
+    const response = await adapter.invoke({ prompt: 'review this' });
+
+    const zeroFindings = response.output.indexOf('zero-findings recheck');
+    const verdict = response.output.indexOf('All 12 tests pass');
+    expect(zeroFindings).toBeGreaterThanOrEqual(0);
+    expect(verdict).toBeGreaterThan(zeroFindings);
+  });
+
+  it('end-to-end: collapsed output yields a passed rubric through extractRubricJson', async () => {
+    const ndjson = fs.readFileSync(fixturePath, 'utf8');
+    spawnMock.mockImplementation(() => makeFakeChild(0, ndjson));
+
+    const adapter = new OpenCodeAdapter();
+    const response = await adapter.invoke({ prompt: 'review this' });
+
+    // The real production parser — not a mirror. Mirrors drift.
+    const { extractRubricJson } = await import('../core/rubric.js');
+    const parsed = extractRubricJson(response.output);
+    expect(parsed).not.toBeNull();
+    expect(parsed?.passed).toBe(true);
+    expect(parsed?.stage).toBe('code_critic');
+  });
+
+  it('preserves the verdict even when the final line is truncated (context-limit tail)', async () => {
+    const ndjson = fs.readFileSync(fixturePath, 'utf8');
+    // Cut mid-event: a context-limit kill can truncate the stream before the
+    // final step_finish. The text part (with the rubric) must still survive.
+    const truncated = ndjson.split('\n').slice(0, -1).join('\n') + '\n{"type":"step_finish","timestamp":1785417871';
+    spawnMock.mockImplementation(() => makeFakeChild(0, truncated));
+
+    const adapter = new OpenCodeAdapter();
+    const response = await adapter.invoke({ prompt: 'review this' });
+
+    expect(response.success).toBe(true);
+    expect(response.output).toContain('"passed": true');
+  });
+
+  it('falls back to raw stdout when no text part parses', async () => {
+    const garbage = 'opencode: something went wrong\n{"type":"error","message":"boom"';
+    spawnMock.mockImplementation(() => makeFakeChild(0, garbage));
+
+    const adapter = new OpenCodeAdapter();
+    const response = await adapter.invoke({ prompt: 'hi' });
+
+    expect(response.output).toBe(garbage);
+  });
+
+  it('skips valid-JSON non-event lines (null, numbers) without crashing', async () => {
+    const mixed = 'null\n42\n{"type":"step_start"}\n{"type":"text","part":{"text":"verdict here"}}';
+    spawnMock.mockImplementation(() => makeFakeChild(0, mixed));
+
+    const adapter = new OpenCodeAdapter();
+    const response = await adapter.invoke({ prompt: 'hi' });
+
+    expect(response.success).toBe(true);
+    expect(response.output).toBe('verdict here');
+  });
+
+  it('skips text events whose part.text is not a string (shape-change guard)', async () => {
+    // The typeof guard is the load-bearing line against a future opencode
+    // shape change (e.g. part.text becoming an object). A truthy check would
+    // push a non-string into parts and emit "[object Object]" into the output
+    // that feeds rubric extraction — this test pins the guard.
+    const mixed = [
+      '{"type":"text","part":{"text":{"nested":true}}}',
+      '{"type":"text","part":{"text":42}}',
+      '{"type":"text","part":{"text":"real verdict here"}}',
+    ].join('\n');
+    spawnMock.mockImplementation(() => makeFakeChild(0, mixed));
+
+    const adapter = new OpenCodeAdapter();
+    const response = await adapter.invoke({ prompt: 'hi' });
+
+    expect(response.success).toBe(true);
+    expect(response.output).toBe('real verdict here');
+    expect(response.output).not.toContain('[object Object]');
+  });
+
+  it('verdict survives a later text event containing real braces (extractRubricJson scan)', async () => {
+    const stream = [
+      '{"type":"step_start","part":{"id":"a","type":"step-start"}}',
+      '{"type":"text","part":{"text":"{\\"passed\\": true, \\"stage\\": \\"code_critic\\", \\"findings\\": []}"}}',
+      '{"type":"text","part":{"text":"Note: the fix touched { src/foo.ts } and { src/bar.ts } (see commit 4b8b12f)."}}',
+      '{"type":"step_finish","part":{"id":"b","reason":"stop","type":"step-finish"}}',
+    ].join('\n');
+    spawnMock.mockImplementation(() => makeFakeChild(0, stream));
+
+    const adapter = new OpenCodeAdapter();
+    const response = await adapter.invoke({ prompt: 'review this' });
+
+    const { extractRubricJson } = await import('../core/rubric.js');
+    const parsed = extractRubricJson(response.output);
+    expect(parsed).not.toBeNull();
+    expect(parsed?.passed).toBe(true);
+  });
+
+  it('extractRubricJson ignores a trailing object without a passed key', async () => {
+    const { extractRubricJson } = await import('../core/rubric.js');
+    const output = [
+      'I reviewed the diff. Verdict:',
+      '{"passed": true, "stage": "code_critic", "findings": []}',
+      '{"note": "this is a trailing note, not a verdict"}',
+    ].join('\n');
+    const parsed = extractRubricJson(output);
+    expect(parsed).not.toBeNull();
+    expect(parsed?.passed).toBe(true);
+    expect(parsed?.stage).toBe('code_critic');
+  });
+
+  it('extractRubricJson returns null when no object has a passed key', async () => {
+    const { extractRubricJson } = await import('../core/rubric.js');
+    const output = 'I began my review but ran out of context before finishing.';
+    expect(extractRubricJson(output)).toBeNull();
+  });
+
+  it('extractRubricJson never picks a nested passed object over the top-level verdict', async () => {
+    const { extractRubricJson } = await import('../core/rubric.js');
+
+    // t1: failing verdict + trailing tool result with nested passed:true —
+    // must return the FAILING verdict, not false-green the gate.
+    const t1 = [
+      'V: {"passed": false, "stage": "code_critic", "findings": [{"category":"product_bug","detail":"x"}]}',
+      'Tool output: {"results": [{"name": "syntax", "passed": true}]}',
+    ].join('\n');
+    const r1 = extractRubricJson(t1);
+    expect(r1).not.toBeNull();
+    expect(r1?.passed).toBe(false);
+    expect(r1?.stage).toBe('code_critic');
+
+    // t2: passing verdict + trailing object with nested passed:false —
+    // must return the PASSING verdict, not false-strand the parent.
+    const t2 = [
+      'V: {"passed": true, "stage": "code_critic", "findings": []}',
+      '{"checks": {"lint": {"passed": false}}}',
+    ].join('\n');
+    const r2 = extractRubricJson(t2);
+    expect(r2).not.toBeNull();
+    expect(r2?.passed).toBe(true);
+    expect(r2?.stage).toBe('code_critic');
+  });
+
+  it('extractRubricJson handles the custom-critic shape (nested assertions in the top-level verdict)', async () => {
+    const { extractRubricJson } = await import('../core/rubric.js');
+    const output = JSON.stringify({
+      passed: true,
+      stage: 'credit_ledger_integrity',
+      assertions: [
+        { name: 'append_only', passed: true, evidence: 'ledger is append-only' },
+        { name: 'audit_fields', passed: true, evidence: 'created_at set' },
+      ],
+      findings: [],
+    });
+    const parsed = extractRubricJson(output);
+    expect(parsed).not.toBeNull();
+    expect(parsed?.passed).toBe(true);
+    expect(parsed?.stage).toBe('credit_ledger_integrity');
+  });
+
+  it('collapses NDJSON on a non-zero exit (failure path)', async () => {
+    const ndjson = fs.readFileSync(fixturePath, 'utf8');
+    spawnMock.mockImplementation(() => makeFakeChild(1, ndjson));
+
+    const adapter = new OpenCodeAdapter();
+    const response = await adapter.invoke({ prompt: 'review this' });
+
+    expect(response.success).toBe(false);
+    // The collapse applies on failure paths too (documented divergence from
+    // claude/codex, which return raw stdout).
+    expect(response.output).toContain('"passed": true');
+    expect(response.output).not.toContain('"type":"step_start"');
+  });
+
+  it('collapses NDJSON on a spawn error (failure path)', async () => {
+    const ndjson = fs.readFileSync(fixturePath, 'utf8');
+    const child = new EventEmitter() as FakeChild;
+    child.stdin = { write: () => undefined, end: () => undefined };
+    child.stdout = new EventEmitter();
+    child.stderr = new EventEmitter();
+    child.kill = () => undefined;
+    setImmediate(() => {
+      child.stdout.emit('data', Buffer.from(ndjson));
+      child.emit('error', new Error('spawn ENOENT'));
+    });
+    spawnMock.mockImplementation(() => child);
+
+    const adapter = new OpenCodeAdapter();
+    const response = await adapter.invoke({ prompt: 'review this' });
+
+    expect(response.success).toBe(false);
+    expect(response.output).toContain('"passed": true');
+  });
+
+  it('collapses NDJSON on a timeout (failure path)', async () => {
+    const ndjson = fs.readFileSync(fixturePath, 'utf8');
+    const child = new EventEmitter() as FakeChild;
+    child.stdin = { write: () => undefined, end: () => undefined };
+    child.stdout = new EventEmitter();
+    child.stderr = new EventEmitter();
+    // The adapter's timeout handler kills the child; a real child then emits
+    // 'close'. Emit it so the promise resolves through the timedOut branch.
+    child.kill = () => {
+      setImmediate(() => child.emit('close', 1));
+    };
+    setImmediate(() => {
+      child.stdout.emit('data', Buffer.from(ndjson));
+      // Never emit 'close' on our own — the adapter's timeout must fire.
+    });
+    spawnMock.mockImplementation(() => child);
+
+    const adapter = new OpenCodeAdapter(50);
+    const response = await adapter.invoke({ prompt: 'review this' });
+
+    expect(response.success).toBe(false);
+    expect(response.error).toContain('timed out');
+    expect(response.output).toContain('"passed": true');
+  });
+});

src/adapters/opencode-adapter.ts

@@ -2,6 +2,55 @@ import spawn from 'cross-spawn';
 import { DEFAULT_JOB_TIMEOUT_MS } from '../core/runtime-config.js';
 import type { AgentAdapter, AgentInvocation, AgentResponse } from './base.js';
 
+/**
+ * opencode --format json emits a stream of NDJSON events (step_start, tool_use,
+ * text, step_finish...). The assistant's actual message content lives in the
+ * `text` events' `part.text`. Collapse the stream into those text parts joined
+ * by newlines so downstream consumers (rubric extraction, job_result, worker
+ * output) see plain text like the claude adapter produces — not raw event
+ * bytes. Returns null when no text part parsed (e.g. an error banner or empty
+ * stdout) so callers can fall back to the raw stream.
+ *
+ * NOTE: the collapse is applied on ALL resolve paths (success, timeout,
+ * non-zero exit, spawn error), unlike the claude/codex adapters which return
+ * raw stdout on failure. This is deliberate (a partial NDJSON stream is more
+ * useful collapsed), but it means a failed opencode job's stored output drops
+ * the raw event stream (including any error-type event) — observability only,
+ * since rubric extraction runs only on success.
+ *
+ * Schema pin: this matches the event shape opencode emits today (each line is
+ * `{"type":"text", ..., "part":{"type":"text","text":"..."}}`). If a future
+ * opencode bump changes the part shape (e.g. a `parts[]` array), this collapse
+ * silently degrades to the raw-stream fallback — the fixture
+ * `tests/fixtures/fake-agents/opencode-ndjson-text-parts.json` and the
+ * end-to-end test in `src/adapters/adapter.test.ts` will catch it. Re-verify
+ * against live output when bumping opencode.
+ */
+export const extractTextPartsFromNdjson = (stdout: string): string | null => {
+  const parts: string[] = [];
+  for (const line of stdout.split('\n')) {
+    if (!line.trim()) {
+      continue;
+    }
+    let event: unknown;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      // Skip malformed lines — a context-limit kill can truncate the tail mid-event.
+      continue;
+    }
+    if (!event || typeof event !== 'object') {
+      // Valid JSON that isn't an event object (e.g. `null`, numbers) — skip.
+      continue;
+    }
+    const record = event as { type?: unknown; part?: { text?: unknown } };
+    if (record.type === 'text' && typeof record.part?.text === 'string') {
+      parts.push(record.part.text);
+    }
+  }
+  return parts.length > 0 ? parts.join('\n') : null;
+};
+
 export class OpenCodeAdapter implements AgentAdapter {
   public readonly name = 'opencode';
   private readonly timeoutMs: number;
@@ -54,7 +103,7 @@ export class OpenCodeAdapter implements AgentAdapter {
         if (timedOut) {
           resolve({
             success: false,
-            output: stdout,
+            output: extractTextPartsFromNdjson(stdout) ?? stdout,
             error: `opencode invocation timed out after ${effectiveTimeout}ms`,
             durationMs,
           });
@@ -63,7 +112,7 @@ export class OpenCodeAdapter implements AgentAdapter {
 
         resolve({
           success: code === 0,
-          output: stdout,
+          output: extractTextPartsFromNdjson(stdout) ?? stdout,
           error: code === 0 ? undefined : stderr || `opencode exited with code ${code ?? 'unknown'}`,
           durationMs,
         });
@@ -73,7 +122,7 @@ export class OpenCodeAdapter implements AgentAdapter {
         clearTimeout(timeout);
         resolve({
           success: false,
-          output: stdout,
+          output: extractTextPartsFromNdjson(stdout) ?? stdout,
           error: error.message,
           durationMs: Date.now() - startedAt,
         });