happy-stacks 0.3.0 → 0.5.0

package/scripts/utils/review/findings.test.mjs

@@ -0,0 +1,85 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { formatTriageMarkdown, parseCodeRabbitPlainOutput, parseCodexReviewText } from './findings.mjs';
+
+test('parseCodeRabbitPlainOutput parses CodeRabbit plain blocks', () => {
+  const out = [
+    '============================================================================',
+    'File: cli/src/utils/spawnHappyCLI.invocation.test.ts',
+    'Line: 17 to 31',
+    'Type: potential_issue',
+    '',
+    'Comment:',
+    'Dynamic imports may be cached, causing test isolation issues.',
+    '',
+    'Some more details.',
+    '',
+    'Prompt for AI Agent:',
+    'Do the thing.',
+    '',
+    '============================================================================',
+    'File: expo-app/sources/app/(app)/_layout.tsx',
+    'Line: 29 to 35',
+    'Type: potential_issue',
+    '',
+    'Comment:',
+    "Hooks order violation: useUnistyles() called after conditional return.",
+    '',
+    'More details.',
+  ].join('\n');
+
+  const findings = parseCodeRabbitPlainOutput(out);
+  assert.equal(findings.length, 2);
+  assert.equal(findings[0].file, 'cli/src/utils/spawnHappyCLI.invocation.test.ts');
+  assert.deepEqual(findings[0].lines, { start: 17, end: 31 });
+  assert.equal(findings[0].type, 'potential_issue');
+  assert.equal(findings[0].title, 'Dynamic imports may be cached, causing test isolation issues.');
+  assert.match(findings[0].comment, /Some more details/);
+  assert.match(findings[0].prompt, /Do the thing/);
+});
+
+test('parseCodexReviewText extracts findings JSON trailer', () => {
+  const review = [
+    'Overall verdict: looks good.',
+    '',
+    '===FINDINGS_JSON===',
+    JSON.stringify(
+      [
+        {
+          severity: 'major',
+          file: 'server/sources/main.light.ts',
+          title: 'Do not exit after startup',
+          recommendation: 'Remove process.exit(0) on success.',
+        },
+      ],
+      null,
+      2
+    ),
+  ].join('\n');
+
+  const findings = parseCodexReviewText(review);
+  assert.equal(findings.length, 1);
+  assert.equal(findings[0].file, 'server/sources/main.light.ts');
+  assert.equal(findings[0].severity, 'major');
+});
+
+test('formatTriageMarkdown includes required workflow fields', () => {
+  const md = formatTriageMarkdown({
+    runLabel: 'review-123',
+    baseRef: 'upstream/main',
+    findings: [
+      {
+        reviewer: 'coderabbit',
+        id: 'CR-001',
+        file: 'cli/src/x.ts',
+        title: 'Thing',
+        type: 'potential_issue',
+      },
+    ],
+  });
+  assert.match(md, /Final decision: \*\*TBD\*\*/);
+  assert.match(md, /Verified in validation worktree:/);
+  assert.match(md, /Commit:/);
+});
+

package/scripts/utils/review/head_slice.mjs

@@ -0,0 +1,153 @@
+import { runCapture } from '../proc/proc.mjs';
+
+function normalizePath(p) {
+  return String(p ?? '').replace(/\\/g, '/').replace(/^\/+/, '');
+}
+
+function parseNameStatusZ(buf) {
+  const raw = String(buf ?? '');
+  if (!raw) return [];
+  const parts = raw.split('\0').filter((x) => x.length);
+  const entries = [];
+  let i = 0;
+  while (i < parts.length) {
+    const status = parts[i++];
+    const code = status[0] ?? '';
+    if (!code) break;
+    if (code === 'R' || code === 'C') {
+      const from = parts[i++] ?? '';
+      const to = parts[i++] ?? '';
+      entries.push({ code, status, from, to });
+      continue;
+    }
+    const path = parts[i++] ?? '';
+    entries.push({ code, status, path });
+  }
+  return entries;
+}
+
+export async function getChangedOps({ cwd, baseRef, headRef = 'HEAD', env = process.env } = {}) {
+  const out = await runCapture('git', ['diff', '--name-status', '--find-renames', '-z', `${baseRef}...${headRef}`], { cwd, env });
+  const entries = parseNameStatusZ(out);
+  const checkout = new Set();
+  const remove = new Set();
+  for (const e of entries) {
+    if (e.code === 'A' || e.code === 'M' || e.code === 'T') {
+      checkout.add(normalizePath(e.path));
+      continue;
+    }
+    if (e.code === 'D') {
+      remove.add(normalizePath(e.path));
+      continue;
+    }
+    if (e.code === 'R' || e.code === 'C') {
+      if (e.from) remove.add(normalizePath(e.from));
+      if (e.to) checkout.add(normalizePath(e.to));
+      continue;
+    }
+  }
+  const all = new Set([...checkout, ...remove]);
+  return { checkout, remove, all };
+}
+
+function subset(set, allowed) {
+  const out = new Set();
+  for (const v of set) {
+    if (allowed.has(v)) out.add(v);
+  }
+  return out;
+}
+
+function difference(set, blocked) {
+  const out = new Set();
+  for (const v of set) {
+    if (!blocked.has(v)) out.add(v);
+  }
+  return out;
+}
+
+async function batched(args, batchSize, fn) {
+  const list = Array.from(args);
+  for (let i = 0; i < list.length; i += batchSize) {
+    // eslint-disable-next-line no-await-in-loop
+    await fn(list.slice(i, i + batchSize));
+  }
+}
+
+async function gitCommit({ cwd, env, message }) {
+  await runCapture(
+    'git',
+    [
+      '-c',
+      'user.name=Happy Review',
+      '-c',
+      'user.email=review@happy.local',
+      '-c',
+      'commit.gpgsign=false',
+      'commit',
+      '-q',
+      '--no-verify',
+      '-m',
+      message,
+    ],
+    { cwd, env }
+  );
+  const sha = (await runCapture('git', ['rev-parse', 'HEAD'], { cwd, env })).trim();
+  return sha;
+}
+
+async function applyOpsFromHead({ cwd, env, headCommit, checkoutPaths, removePaths }) {
+  if (removePaths.size) {
+    await batched(Array.from(removePaths), 200, async (batch) => {
+      await runCapture('git', ['rm', '-q', '--ignore-unmatch', '--', ...batch], { cwd, env });
+    });
+  }
+  if (checkoutPaths.size) {
+    // Prefer batching over pathspec-from-file to maximize compatibility.
+    await batched(Array.from(checkoutPaths), 100, async (batch) => {
+      await runCapture('git', ['checkout', headCommit, '--', ...batch], { cwd, env });
+    });
+  }
+  // Stage all changes introduced by the operations.
+  await runCapture('git', ['add', '-A'], { cwd, env });
+}
+
+/**
+ * Create two local commits inside an ephemeral worktree:
+ * - baseSliceCommit: baseRef plus all NON-slice changes from headCommit
+ * - headSliceCommit: baseSliceCommit plus slice changes from headCommit (resulting tree equals headCommit)
+ *
+ * These commits are intended solely for review tooling (CodeRabbit/Codex) so the reviewer sees:
+ * - full, final code at HEAD
+ * - a focused diff for the slice (baseSliceCommit..headSliceCommit)
+ */
+export async function createHeadSliceCommits({
+  cwd,
+  env = process.env,
+  baseRef,
+  headCommit,
+  ops,
+  slicePaths,
+  label = 'slice',
+} = {}) {
+  const sliceSet = new Set((Array.isArray(slicePaths) ? slicePaths : []).map(normalizePath).filter(Boolean));
+  const sliceCheckout = subset(ops.checkout, sliceSet);
+  const sliceRemove = subset(ops.remove, sliceSet);
+  const nonSliceCheckout = difference(ops.checkout, sliceSet);
+  const nonSliceRemove = difference(ops.remove, sliceSet);
+
+  // Start from baseRef.
+  await runCapture('git', ['checkout', '-q', '--detach', baseRef], { cwd, env });
+
+  // Commit non-slice changes.
+  await applyOpsFromHead({ cwd, env, headCommit, checkoutPaths: nonSliceCheckout, removePaths: nonSliceRemove });
+  const baseSliceCommit = await gitCommit({ cwd, env, message: `chore(review): base for ${label}` });
+
+  // Commit slice changes.
+  await applyOpsFromHead({ cwd, env, headCommit, checkoutPaths: sliceCheckout, removePaths: sliceRemove });
+  const headSliceCommit = await gitCommit({ cwd, env, message: `chore(review): ${label}` });
+
+  // Ensure working tree is at the head slice commit for downstream tools.
+  await runCapture('git', ['checkout', '-q', headSliceCommit], { cwd, env });
+  return { baseSliceCommit, headSliceCommit };
+}

package/scripts/utils/review/head_slice.test.mjs

@@ -0,0 +1,91 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { run, runCapture } from '../proc/proc.mjs';
+import { createHeadSliceCommits, getChangedOps } from './head_slice.mjs';
+
+function gitEnv() {
+  const clean = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (k.startsWith('HAPPY_STACKS_') || k.startsWith('HAPPY_LOCAL_')) continue;
+    clean[k] = v;
+  }
+  return {
+    ...clean,
+    GIT_AUTHOR_NAME: 'Test',
+    GIT_AUTHOR_EMAIL: 'test@example.com',
+    GIT_COMMITTER_NAME: 'Test',
+    GIT_COMMITTER_EMAIL: 'test@example.com',
+  };
+}
+
+test('createHeadSliceCommits produces a focused diff while keeping full HEAD code', async (t) => {
+  const repo = await mkdtemp(join(tmpdir(), 'happy-review-head-slice-'));
+  const env = gitEnv();
+
+  const wt = join(repo, 'wt');
+  try {
+    await run('git', ['init', '-q'], { cwd: repo, env });
+    await run('git', ['checkout', '-q', '-b', 'main'], { cwd: repo, env });
+    await mkdir(join(repo, 'expo-app'), { recursive: true });
+    await mkdir(join(repo, 'cli'), { recursive: true });
+    await mkdir(join(repo, 'server'), { recursive: true });
+    await writeFile(join(repo, 'expo-app', 'a.txt'), 'base-a\n', 'utf-8');
+    await writeFile(join(repo, 'cli', 'c.txt'), 'base-c\n', 'utf-8');
+    await writeFile(join(repo, 'server', 'b.txt'), 'base-b\n', 'utf-8');
+    await run('git', ['add', '.'], { cwd: repo, env });
+    await run('git', ['commit', '-q', '-m', 'chore: base'], { cwd: repo, env });
+
+    // HEAD commit with mixed changes across areas.
+    await writeFile(join(repo, 'expo-app', 'a.txt'), 'head-a\n', 'utf-8');
+    await writeFile(join(repo, 'expo-app', 'new.txt'), 'new\n', 'utf-8');
+    await writeFile(join(repo, 'cli', 'c.txt'), 'head-c\n', 'utf-8');
+    await rm(join(repo, 'server', 'b.txt'));
+    await run('git', ['add', '-A'], { cwd: repo, env });
+    await run('git', ['commit', '-q', '-m', 'feat: head'], { cwd: repo, env });
+
+    const headCommit = (await runCapture('git', ['rev-parse', 'HEAD'], { cwd: repo, env })).trim();
+    const baseCommit = (await runCapture('git', ['rev-parse', 'HEAD^'], { cwd: repo, env })).trim();
+
+    // Create an ephemeral worktree to run the slice commit builder in isolation.
+    await run('git', ['worktree', 'add', '--detach', wt, baseCommit], { cwd: repo, env });
+
+    const ops = await getChangedOps({ cwd: repo, baseRef: baseCommit, headRef: headCommit, env });
+    const { baseSliceCommit, headSliceCommit } = await createHeadSliceCommits({
+      cwd: wt,
+      env,
+      baseRef: baseCommit,
+      headCommit,
+      ops,
+      slicePaths: ['expo-app/a.txt', 'expo-app/new.txt'],
+      label: 'expo-app',
+    });
+
+    // Working tree should match full HEAD.
+    const a = await readFile(join(wt, 'expo-app', 'a.txt'), 'utf-8');
+    const c = await readFile(join(wt, 'cli', 'c.txt'), 'utf-8');
+    assert.equal(a, 'head-a\n');
+    assert.equal(c, 'head-c\n');
+    await assert.rejects(async () => await readFile(join(wt, 'server', 'b.txt'), 'utf-8'));
+
+    // Diff between slice commits should include only expo-app changes.
+    const diffNames = (
+      await runCapture('git', ['diff', '--name-only', `${baseSliceCommit}...${headSliceCommit}`], { cwd: wt, env })
+    )
+      .trim()
+      .split('\n')
+      .filter(Boolean)
+      .sort();
+    assert.deepEqual(diffNames, ['expo-app/a.txt', 'expo-app/new.txt']);
+  } finally {
+    try {
+      await run('git', ['worktree', 'remove', '--force', wt], { cwd: repo, env });
+      await run('git', ['worktree', 'prune'], { cwd: repo, env });
+    } catch {
+      // ignore cleanup errors (best-effort)
+    }
+    await rm(repo, { recursive: true, force: true });
+  }
+});

package/scripts/utils/review/instructions/deep.md

@@ -0,0 +1,20 @@
+You are running a deep, long-form code review.
+
+Goals:
+- Find correctness bugs, edge cases, and regressions vs upstream/main.
+- Find performance problems (big-O, unnecessary allocations, redundant work) and reliability issues.
+- Find security and safety issues (filesystem access, env handling, process spawning, injection risks).
+- Find maintainability issues (duplication, unclear ownership boundaries, inconsistent patterns).
+- Ensure i18n coverage is complete: do not introduce hardcoded user-visible strings.
+
+Constraints:
+- Prefer fixes that are unified/coherent and avoid duplicating logic.
+- Avoid “brittle” tests that assert on wording/phrasing or hardcoded text; test real behavior and observable outcomes.
+- Do not suggest broad refactors unless clearly justified and low-risk.
+- Treat every recommendation as a suggestion: validate against best practices and the existing codebase patterns; do not propose changes that conflict with project invariants.
+- If a recommendation is uncertain, depends on product/UX decisions, or might have hidden tradeoffs, explicitly mark it as "needs discussion".
+
+Output:
+- Provide specific, actionable recommendations with file paths and a brief rationale.
+- Call out any items that are uncertain or require product/UX decisions separately.
+- Be exhaustive: include all findings you notice, not only the highest-signal ones.

package/scripts/utils/review/runners/coderabbit.mjs

@@ -0,0 +1,61 @@
+import { runCaptureResult } from '../../proc/proc.mjs';
+import { join } from 'node:path';
+
+function normalizeType(raw) {
+  const t = String(raw ?? '').trim().toLowerCase();
+  if (!t) return 'committed';
+  if (t === 'all' || t === 'committed' || t === 'uncommitted') return t;
+  throw new Error(`[review] invalid coderabbit type: ${raw} (expected: all|committed|uncommitted)`);
+}
+
+export function buildCodeRabbitReviewArgs({ repoDir, baseRef, baseCommit, type, configFiles }) {
+  const args = ['review', '--plain', '--no-color', '--type', normalizeType(type), '--cwd', repoDir];
+  const base = String(baseRef ?? '').trim();
+  const bc = String(baseCommit ?? '').trim();
+  if (base && bc) {
+    throw new Error('[review] coderabbit: baseRef and baseCommit are mutually exclusive');
+  }
+  if (base) args.push('--base', base);
+  if (bc) args.push('--base-commit', bc);
+  const files = Array.isArray(configFiles) ? configFiles.filter(Boolean) : [];
+  if (files.length) args.push('--config', ...files);
+  return args;
+}
+
+export function buildCodeRabbitEnv({ env, homeDir }) {
+  const merged = { ...(env ?? {}) };
+  const dir = String(homeDir ?? '').trim();
+  if (!dir) return merged;
+
+  merged.HOME = dir;
+  merged.USERPROFILE = dir;
+  merged.CODERABBIT_HOME = join(dir, '.coderabbit');
+  merged.XDG_CONFIG_HOME = join(dir, '.config');
+  merged.XDG_CACHE_HOME = join(dir, '.cache');
+  merged.XDG_STATE_HOME = join(dir, '.local', 'state');
+  merged.XDG_DATA_HOME = join(dir, '.local', 'share');
+  return merged;
+}
+
+export async function runCodeRabbitReview({
+  repoDir,
+  baseRef,
+  baseCommit,
+  env,
+  type = 'committed',
+  configFiles = [],
+  streamLabel,
+  teeFile,
+  teeLabel,
+}) {
+  const homeDir = (env?.HAPPY_STACKS_CODERABBIT_HOME_DIR ?? env?.HAPPY_LOCAL_CODERABBIT_HOME_DIR ?? '').toString().trim();
+  const args = buildCodeRabbitReviewArgs({ repoDir, baseRef, baseCommit, type, configFiles });
+  const res = await runCaptureResult('coderabbit', args, {
+    cwd: repoDir,
+    env: buildCodeRabbitEnv({ env, homeDir }),
+    streamLabel,
+    teeFile,
+    teeLabel,
+  });
+  return { ...res, stdout: res.out, stderr: res.err };
+}

package/scripts/utils/review/runners/coderabbit.test.mjs

@@ -0,0 +1,59 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { join } from 'node:path';
+
+import { buildCodeRabbitEnv, buildCodeRabbitReviewArgs } from './coderabbit.mjs';
+
+test('buildCodeRabbitReviewArgs builds committed review args by default', () => {
+  const repoDir = '/tmp/repo';
+  const args = buildCodeRabbitReviewArgs({ repoDir, baseRef: 'upstream/main', type: undefined, configFiles: [] });
+  assert.deepEqual(args, ['review', '--plain', '--no-color', '--type', 'committed', '--cwd', repoDir, '--base', 'upstream/main']);
+});
+
+test('buildCodeRabbitReviewArgs uses --base-commit when provided', () => {
+  const repoDir = '/tmp/repo';
+  const args = buildCodeRabbitReviewArgs({ repoDir, baseCommit: 'abc123', type: 'committed', configFiles: [] });
+  assert.deepEqual(args, ['review', '--plain', '--no-color', '--type', 'committed', '--cwd', repoDir, '--base-commit', 'abc123']);
+});
+
+test('buildCodeRabbitReviewArgs rejects providing both baseRef and baseCommit', () => {
+  assert.throws(
+    () => buildCodeRabbitReviewArgs({ repoDir: '/tmp/repo', baseRef: 'upstream/main', baseCommit: 'abc123', type: 'committed', configFiles: [] }),
+    /mutually exclusive/
+  );
+});
+
+test('buildCodeRabbitReviewArgs includes --config when files are provided', () => {
+  const repoDir = '/tmp/repo';
+  const args = buildCodeRabbitReviewArgs({
+    repoDir,
+    baseRef: 'upstream/main',
+    type: 'committed',
+    configFiles: ['/tmp/a.md', '/tmp/b.md'],
+  });
+  assert.deepEqual(args, [
+    'review',
+    '--plain',
+    '--no-color',
+    '--type',
+    'committed',
+    '--cwd',
+    repoDir,
+    '--base',
+    'upstream/main',
+    '--config',
+    '/tmp/a.md',
+    '/tmp/b.md',
+  ]);
+});
+
+test('buildCodeRabbitEnv overrides HOME/XDG paths when a homeDir is provided', () => {
+  const env = buildCodeRabbitEnv({ env: { PATH: '/bin' }, homeDir: '/tmp/cr-home' });
+  assert.equal(env.PATH, '/bin');
+  assert.equal(env.HOME, '/tmp/cr-home');
+  assert.equal(env.CODERABBIT_HOME, join('/tmp/cr-home', '.coderabbit'));
+  assert.equal(env.XDG_CONFIG_HOME, join('/tmp/cr-home', '.config'));
+  assert.equal(env.XDG_CACHE_HOME, join('/tmp/cr-home', '.cache'));
+  assert.equal(env.XDG_STATE_HOME, join('/tmp/cr-home', '.local', 'state'));
+  assert.equal(env.XDG_DATA_HOME, join('/tmp/cr-home', '.local', 'share'));
+});

package/scripts/utils/review/runners/codex.mjs

@@ -0,0 +1,61 @@
+import { runCaptureResult } from '../../proc/proc.mjs';
+
+export function extractCodexReviewFromJsonl(jsonlText) {
+  const lines = String(jsonlText ?? '')
+    .split('\n')
+    .map((l) => l.trim())
+    .filter(Boolean);
+
+  // JSONL events typically look like: { "type": "...", "payload": {...} } or similar.
+  // We keep this resilient by searching for keys matching the exec output format.
+  for (const line of lines) {
+    let obj = null;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const candidates = [obj, obj?.msg, obj?.payload, obj?.event, obj?.data, obj?.result].filter(Boolean);
+    for (const c of candidates) {
+      const exited =
+        c?.ExitedReviewMode ??
+        (c?.type === 'ExitedReviewMode' ? c : null) ??
+        (c?.event?.type === 'ExitedReviewMode' ? c.event : null) ??
+        (c?.payload?.type === 'ExitedReviewMode' ? c.payload : null);
+
+      const reviewOutput = exited?.review_output ?? exited?.reviewOutput ?? null;
+      if (reviewOutput) return reviewOutput;
+    }
+  }
+  return null;
+}
+
+export function buildCodexReviewArgs({ baseRef, jsonMode, prompt }) {
+  const args = ['exec', 'review', '--dangerously-bypass-approvals-and-sandbox'];
+
+  // Codex review targets are mutually exclusive:
+  // - --base / --commit / --uncommitted are distinct "targets"
+  // - Providing a PROMPT switches to the "custom instructions" target and cannot be combined with the above.
+  // Therefore, when reviewing a target (base/commit/uncommitted), we do not pass a prompt.
+  if (baseRef) args.push('--base', baseRef);
+
+  if (jsonMode) {
+    args.push('--json');
+  }
+
+  const p = String(prompt ?? '').trim();
+  if (!baseRef && p) args.push(p);
+  if (!baseRef && !p) args.push('--uncommitted');
+  return args;
+}
+
+export async function runCodexReview({ repoDir, baseRef, env, jsonMode, streamLabel, teeFile, teeLabel, prompt }) {
+  const merged = { ...(env ?? {}) };
+  const codexHome =
+    (merged.HAPPY_STACKS_CODEX_HOME_DIR ?? merged.HAPPY_LOCAL_CODEX_HOME_DIR ?? merged.CODEX_HOME ?? '').toString().trim();
+  if (codexHome) merged.CODEX_HOME = codexHome;
+
+  const args = buildCodexReviewArgs({ baseRef, jsonMode, prompt });
+  const res = await runCaptureResult('codex', args, { cwd: repoDir, env: merged, streamLabel, teeFile, teeLabel });
+  return { ...res, stdout: res.out, stderr: res.err };
+}

package/scripts/utils/review/runners/codex.test.mjs

@@ -0,0 +1,35 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { buildCodexReviewArgs, extractCodexReviewFromJsonl } from './codex.mjs';
+
+test('buildCodexReviewArgs uses --base and avoids --cd', () => {
+  const args = buildCodexReviewArgs({ baseRef: 'upstream/main', jsonMode: false });
+  assert.equal(args.includes('--cd'), false);
+  assert.deepEqual(args, ['exec', 'review', '--dangerously-bypass-approvals-and-sandbox', '--base', 'upstream/main']);
+});
+
+test('buildCodexReviewArgs uses --experimental-json when jsonMode is true', () => {
+  const args = buildCodexReviewArgs({ baseRef: 'upstream/main', jsonMode: true });
+  assert.deepEqual(args, ['exec', 'review', '--dangerously-bypass-approvals-and-sandbox', '--base', 'upstream/main', '--json']);
+});
+
+test('buildCodexReviewArgs appends a prompt when provided', () => {
+  const args = buildCodexReviewArgs({ baseRef: null, jsonMode: false, prompt: 'be thorough' });
+  assert.deepEqual(args, ['exec', 'review', '--dangerously-bypass-approvals-and-sandbox', 'be thorough']);
+});
+
+test('extractCodexReviewFromJsonl finds review_output in multiple event shapes', () => {
+  const out1 = extractCodexReviewFromJsonl(
+    JSON.stringify({ msg: { ExitedReviewMode: { review_output: { a: 1 } } } }) + '\n'
+  );
+  assert.deepEqual(out1, { a: 1 });
+
+  const out2 = extractCodexReviewFromJsonl(JSON.stringify({ type: 'ExitedReviewMode', review_output: { b: 2 } }) + '\n');
+  assert.deepEqual(out2, { b: 2 });
+
+  const out3 = extractCodexReviewFromJsonl(
+    JSON.stringify({ event: { type: 'ExitedReviewMode', reviewOutput: { c: 3 } } }) + '\n'
+  );
+  assert.deepEqual(out3, { c: 3 });
+});