throughline 0.3.24 → 0.4.0

package/src/codex-rollout-memory.test.mjs

@@ -0,0 +1,610 @@
+import assert from 'node:assert/strict';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+
+import {
+  buildCodexRolloutTrimSource,
+  inspectCodexPlannedRollbackRestoreSafety,
+  parseCodexRolloutFile,
+} from './codex-rollout-memory.mjs';
+
+test('parseCodexRolloutFile: applies rollback events before rendering active work', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-codex-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-project-'));
+  try {
+    const rollout = writeRollout(home, {
+      id: '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9',
+      cwd: project,
+      events: [
+        event('user_message', { message: '# AGENTS.md instructions for /repo\nskip me' }),
+        event('user_message', { message: 'start active task' }),
+        event('task_started'),
+        event('agent_message', { message: 'turn one answer' }),
+        event('task_complete'),
+        event('user_message', { message: '<hook_prompt hook_run_id="stop">skip me</hook_prompt>' }),
+        event('user_message', { message: 'continue active task' }),
+        event('task_started'),
+        event('agent_message', { message: 'turn two answer' }),
+        event('task_complete'),
+        event('user_message', { message: 'rolled back request' }),
+        event('task_started'),
+        event('agent_message', { message: 'rolled back answer' }),
+        event('task_complete'),
+        event('thread_rolled_back', { num_turns: 1 }),
+        responseItem({
+          type: 'message',
+          role: 'developer',
+          content: [
+            {
+              type: 'input_text',
+              text: '## Throughline Trim Memory Preview\n\ninjected trim memory',
+            },
+          ],
+        }),
+        event('agent_message', { message: 'post rollback continuation' }),
+        responseItem({
+          type: 'message',
+          role: 'developer',
+          content: [
+            {
+              type: 'input_text',
+              text: '## Throughline: Active Work Context\n\ninjected active-work memory',
+            },
+          ],
+        }),
+        responseItem({
+          type: 'message',
+          role: 'developer',
+          content: [{ type: 'input_text', text: '[caveat] unrelated developer notice' }],
+        }),
+        event('user_message', { message: 'new request after rollback' }),
+        event('task_started'),
+        event('agent_message', { message: 'new answer after rollback' }),
+        event('task_complete'),
+      ],
+    });
+
+    const parsed = parseCodexRolloutFile(rollout);
+
+    assert.equal(parsed.activeTurnCount, 4);
+    assert.equal(parsed.stats.rolledBackTurns, 1);
+    assert.equal(parsed.stats.injectedDeveloperMessages, 1);
+    assert.deepEqual(
+      parsed.entries.map((entry) => entry.text),
+      [
+        'start active task',
+        'turn one answer',
+        'continue active task',
+        'turn two answer',
+        'post rollback continuation',
+        'new request after rollback',
+        'new answer after rollback',
+      ],
+    );
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('parseCodexRolloutFile: keeps final post-rollback assistant continuation as synthetic turn', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-codex-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-project-'));
+  try {
+    const rollout = writeRollout(home, {
+      id: '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9',
+      cwd: project,
+      events: [
+        event('user_message', { message: 'stable request' }),
+        event('task_started'),
+        event('agent_message', { message: 'stable answer' }),
+        event('task_complete'),
+        event('user_message', { message: 'rolled back request' }),
+        event('task_started'),
+        event('agent_message', { message: 'rolled back answer' }),
+        event('thread_rolled_back', { num_turns: 1 }),
+        responseItem({
+          type: 'message',
+          role: 'developer',
+          content: [
+            {
+              type: 'input_text',
+              text: '## Throughline Trim Memory Preview\n\ninjected trim memory',
+            },
+          ],
+        }),
+        event('agent_message', { message: 'continuation after rollback' }),
+        event('agent_message', { message: 'still same synthetic turn' }),
+      ],
+    });
+
+    const parsed = parseCodexRolloutFile(rollout);
+    const trimParsed = parseCodexRolloutFile(rollout, { includeInFlightTurn: false });
+
+    assert.equal(parsed.activeTurnCount, 2);
+    assert.equal(trimParsed.activeTurnCount, 1);
+    assert.equal(trimParsed.stats.inFlightTurnsExcluded, 1);
+    assert.deepEqual(
+      parsed.entries.map((entry) => [entry.turn, entry.role, entry.text]),
+      [
+        [1, 'user', 'stable request'],
+        [1, 'assistant', 'stable answer'],
+        ['rollout-11', 'assistant', 'continuation after rollback'],
+        ['rollout-11', 'assistant', 'still same synthetic turn'],
+      ],
+    );
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('parseCodexRolloutFile: rollback removes synthetic continuation inside rolled-back tail', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-codex-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-project-'));
+  try {
+    const rollout = writeRollout(home, {
+      id: '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9',
+      cwd: project,
+      events: [
+        event('user_message', { message: 'kept request' }),
+        event('task_started'),
+        event('agent_message', { message: 'kept answer' }),
+        event('task_complete'),
+        event('user_message', { message: 'removed request one' }),
+        event('task_started'),
+        event('agent_message', { message: 'removed answer one' }),
+        event('task_complete'),
+        event('thread_rolled_back', { num_turns: 1 }),
+        event('agent_message', { message: 'post rollback continuation' }),
+        event('user_message', { message: 'removed request two' }),
+        event('task_started'),
+        event('agent_message', { message: 'removed answer two' }),
+        event('task_complete'),
+        event('thread_rolled_back', { num_turns: 2 }),
+      ],
+    });
+
+    const parsed = parseCodexRolloutFile(rollout);
+
+    assert.equal(parsed.activeTurnCount, 1);
+    assert.deepEqual(
+      parsed.entries.map((entry) => [entry.turn, entry.role, entry.text]),
+      [
+        [1, 'user', 'kept request'],
+        [1, 'assistant', 'kept answer'],
+      ],
+    );
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('parseCodexRolloutFile: keeps final pending messages as current synthetic turn', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-codex-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-project-'));
+  try {
+    const rollout = writeRollout(home, {
+      id: '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9',
+      cwd: project,
+      events: [
+        event('user_message', { message: 'finished request' }),
+        event('task_started'),
+        event('agent_message', { message: 'finished answer' }),
+        event('task_complete'),
+        event('agent_message', { message: 'follow-up after task complete' }),
+      ],
+    });
+
+    const parsed = parseCodexRolloutFile(rollout);
+
+    assert.equal(parsed.activeTurnCount, 2);
+    assert.deepEqual(
+      parsed.entries.map((entry) => [entry.turn, entry.role, entry.text]),
+      [
+        [1, 'user', 'finished request'],
+        [1, 'assistant', 'finished answer'],
+        ['rollout-6', 'assistant', 'follow-up after task complete'],
+      ],
+    );
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('parseCodexRolloutFile: trim source can exclude the current in-flight turn', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-codex-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-project-'));
+  try {
+    const rollout = writeRollout(home, {
+      id: '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9',
+      cwd: project,
+      events: [
+        event('user_message', { message: 'finished request' }),
+        event('task_started'),
+        event('agent_message', { message: 'finished answer' }),
+        event('task_complete'),
+        event('user_message', { message: 'current request' }),
+        event('task_started'),
+        event('agent_message', { message: 'current answer still running' }),
+      ],
+    });
+
+    const defaultParsed = parseCodexRolloutFile(rollout);
+    const trimParsed = parseCodexRolloutFile(rollout, { includeInFlightTurn: false });
+
+    assert.equal(defaultParsed.activeTurnCount, 2);
+    assert.equal(trimParsed.activeTurnCount, 1);
+    assert.equal(trimParsed.stats.inFlightTurnsExcluded, 1);
+    assert.deepEqual(
+      trimParsed.entries.map((entry) => [entry.turn, entry.role, entry.text]),
+      [
+        [1, 'user', 'finished request'],
+        [1, 'assistant', 'finished answer'],
+      ],
+    );
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('parseCodexRolloutFile: splits post-complete assistant continuation before next task', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-codex-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-project-'));
+  try {
+    const rollout = writeRollout(home, {
+      id: '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9',
+      cwd: project,
+      events: [
+        event('user_message', { message: 'first request' }),
+        event('task_started'),
+        event('agent_message', { message: 'first answer' }),
+        event('task_complete'),
+        event('agent_message', { message: 'post-complete continuation' }),
+        event('user_message', { message: 'next request' }),
+        event('task_started'),
+        event('agent_message', { message: 'next answer' }),
+        event('task_complete'),
+      ],
+    });
+
+    const parsed = parseCodexRolloutFile(rollout);
+
+    assert.equal(parsed.activeTurnCount, 3);
+    assert.equal(parsed.stats.syntheticContinuationTurns, 1);
+    assert.deepEqual(
+      parsed.entries.map((entry) => [entry.turn, entry.role, entry.text]),
+      [
+        [1, 'user', 'first request'],
+        [1, 'assistant', 'first answer'],
+        ['rollout-8', 'assistant', 'post-complete continuation'],
+        [2, 'user', 'next request'],
+        [2, 'assistant', 'next answer'],
+      ],
+    );
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('parseCodexRolloutFile: splits assistant-only continuation when next user is logged after task start', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-codex-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-project-'));
+  try {
+    const rollout = writeRollout(home, {
+      id: '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9',
+      cwd: project,
+      events: [
+        event('user_message', { message: 'first request' }),
+        event('task_started'),
+        event('agent_message', { message: 'first answer' }),
+        event('task_complete'),
+        event('agent_message', { message: 'post-complete continuation' }),
+        event('task_started'),
+        event('user_message', { message: 'next request' }),
+        event('agent_message', { message: 'next answer' }),
+        event('task_complete'),
+      ],
+    });
+
+    const parsed = parseCodexRolloutFile(rollout);
+
+    assert.equal(parsed.activeTurnCount, 3);
+    assert.equal(parsed.stats.syntheticContinuationTurns, 1);
+    assert.deepEqual(
+      parsed.entries.map((entry) => [entry.turn, entry.role, entry.text]),
+      [
+        [1, 'user', 'first request'],
+        [1, 'assistant', 'first answer'],
+        ['rollout-7', 'assistant', 'post-complete continuation'],
+        [2, 'user', 'next request'],
+        [2, 'assistant', 'next answer'],
+      ],
+    );
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('parseCodexRolloutFile: maps function calls to active turn details', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-codex-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-project-'));
+  try {
+    const rollout = writeRollout(home, {
+      id: '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9',
+      cwd: project,
+      events: [
+        event('user_message', { message: 'inspect files' }),
+        event('task_started'),
+        responseItem({
+          type: 'function_call',
+          name: 'exec_command',
+          arguments: '{"cmd":"rtk rg TODO"}',
+          call_id: 'call_123',
+        }),
+        responseItem({
+          type: 'function_call_output',
+          call_id: 'call_123',
+          output: 'Chunk ID: abc\nOutput:\nTODO item\n',
+        }),
+        event('agent_message', { message: 'found TODO item' }),
+        event('task_complete'),
+      ],
+    });
+
+    const parsed = parseCodexRolloutFile(rollout);
+
+    assert.equal(parsed.stats.toolInputs, 1);
+    assert.equal(parsed.stats.toolOutputs, 1);
+    assert.deepEqual(parsed.activeTurns[0].details, [
+      {
+        time: '2026-05-06T00:40:51.500Z',
+        kind: 'tool_input',
+        tool_name: 'exec_command',
+        source_id: 'call_123',
+        input_text: '{"cmd":"rtk rg TODO"}',
+        output_text: null,
+      },
+      {
+        time: '2026-05-06T00:40:51.500Z',
+        kind: 'tool_output',
+        tool_name: 'exec_command',
+        source_id: 'call_123:output',
+        input_text: null,
+        output_text: 'Chunk ID: abc\nOutput:\nTODO item\n',
+      },
+    ]);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('parseCodexRolloutFile: flags rollback text retained in compacted replacement history', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-codex-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-project-'));
+  try {
+    const rollout = writeRollout(home, {
+      id: '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9',
+      cwd: project,
+      events: [
+        event('user_message', { message: 'stable request' }),
+        event('task_started'),
+        event('agent_message', { message: 'stable answer' }),
+        event('task_complete'),
+        event('user_message', { message: 'rolled back compacted request' }),
+        event('task_started'),
+        event('agent_message', { message: 'rolled back compacted answer' }),
+        event('task_complete'),
+        compacted([
+          userReplacement('stable request'),
+          userReplacement('rolled back compacted request'),
+        ]),
+        event('context_compacted'),
+        event('thread_rolled_back', { num_turns: 1 }),
+        responseItem({
+          type: 'message',
+          role: 'user',
+          content: [{ type: 'input_text', text: 'rolled back compacted request' }],
+        }),
+        event('user_message', { message: 'rolled back compacted request' }),
+        event('task_started'),
+        event('agent_message', { message: 'restart answer' }),
+        event('task_complete'),
+      ],
+    });
+
+    const parsed = parseCodexRolloutFile(rollout);
+
+    assert.equal(parsed.stats.compactedRows, 1);
+    assert.equal(parsed.stats.compactedReplacementUserMessages, 2);
+    assert.equal(parsed.stats.rolledBackUserMessages, 1);
+    assert.equal(parsed.stats.userMessagesAfterRollback, 2);
+    assert.equal(parsed.stats.latestRollbackAt, '2026-05-06T00:40:51.000Z');
+    assert.equal(parsed.stats.rollbackTextRetainedInCompacted, 1);
+    assert.equal(parsed.stats.resurrectedUserMessages, 2);
+    assert.equal(parsed.restoreSafety.status, 'risk');
+    assert.deepEqual(
+      parsed.restoreSafety.risks.map((risk) => risk.type),
+      [
+        'rollback_text_retained_in_compacted_replacement_history',
+        'rolled_back_user_text_reappeared_after_rollback',
+      ],
+    );
+    assert.deepEqual(parsed.restoreSafety.retainedTexts, [
+      {
+        textPreview: 'rolled back compacted request',
+        rolledBackCount: 1,
+        compactedReplacementCount: 1,
+      },
+    ]);
+    assert.deepEqual(parsed.restoreSafety.rolledBackTexts, [
+      {
+        textPreview: 'rolled back compacted request',
+        count: 1,
+      },
+    ]);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('inspectCodexPlannedRollbackRestoreSafety flags pre-rollback compacted retention', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-codex-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-project-'));
+  try {
+    const rollout = writeRollout(home, {
+      id: '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9',
+      cwd: project,
+      events: [
+        event('user_message', { message: 'stable request' }),
+        event('task_started'),
+        event('agent_message', { message: 'stable answer' }),
+        event('task_complete'),
+        event('user_message', { message: 'would be rolled back from compacted history' }),
+        event('task_started'),
+        event('agent_message', { message: 'candidate answer' }),
+        event('task_complete'),
+        compacted([
+          userReplacement('stable request'),
+          userReplacement('would be rolled back from compacted history'),
+        ]),
+        event('context_compacted'),
+      ],
+    });
+
+    const oneTurn = inspectCodexPlannedRollbackRestoreSafety({
+      rolloutPath: rollout,
+      rollbackTurns: 1,
+    });
+    const zeroTurns = inspectCodexPlannedRollbackRestoreSafety({
+      rolloutPath: rollout,
+      rollbackTurns: 0,
+    });
+
+    assert.equal(oneTurn.status, 'risk');
+    assert.equal(oneTurn.plannedRollbackUserMessages, 1);
+    assert.equal(oneTurn.rollbackTextRetainedInCompacted, 1);
+    assert.deepEqual(oneTurn.risks.map((risk) => risk.type), [
+      'planned_rollback_text_retained_in_compacted_replacement_history',
+    ]);
+    assert.deepEqual(oneTurn.retainedTexts, [
+      {
+        textPreview: 'would be rolled back from compacted history',
+        plannedRollbackCount: 1,
+        compactedReplacementCount: 1,
+      },
+    ]);
+    assert.equal(zeroTurns.status, 'ok');
+    assert.equal(zeroTurns.rollbackTextRetainedInCompacted, 0);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('buildCodexRolloutTrimSource: returns trim source for explicit current-project Codex thread', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-codex-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-project-'));
+  try {
+    writeRollout(home, {
+      id: '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9',
+      cwd: project,
+      events: [
+        event('user_message', { message: 'implement rollout source' }),
+        event('task_started'),
+        event('agent_message', { message: 'rollout source implemented' }),
+        event('task_complete'),
+      ],
+    });
+
+    const source = buildCodexRolloutTrimSource({
+      threadId: '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9',
+      codexHome: home,
+      projectPath: project,
+    });
+
+    assert.equal(source.source, 'codex-rollout');
+    assert.equal(source.capturedTurns, 1);
+    assert.equal(source.threadId, '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9');
+    assert.equal(source.contextEstimate.method, 'chars_div_4');
+    assert.equal(source.contextEstimate.activeTurns, 1);
+    assert.ok(source.contextEstimate.activeEstimatedTokens > 0);
+    assert.equal(source.contextEstimate.turns.length, 1);
+    assert.equal(source.restoreSafety.status, 'ok');
+    assert.match(source.memoryPreview.text, /Active Work Thread \(Codex Rollout\)/);
+    assert.match(source.memoryPreview.text, /implement rollout source/);
+    assert.match(source.memoryPreview.text, /rolled-back tail turns are not included/);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+function writeRollout(home, { id, cwd, events }) {
+  const dir = join(home, 'sessions', '2026', '05', '06');
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, `rollout-2026-05-06T09-40-50-${id}.jsonl`);
+  const rows = [
+    {
+      timestamp: '2026-05-06T00:40:50.000Z',
+      type: 'session_meta',
+      payload: {
+        id,
+        timestamp: '2026-05-06T00:40:50.000Z',
+        cwd,
+        source: 'vscode',
+        cli_version: '0.128.0-alpha.1',
+      },
+    },
+    ...events,
+  ];
+  writeFileSync(path, rows.map((row) => JSON.stringify(row)).join('\n') + '\n');
+  return path;
+}
+
+function event(type, payload = {}) {
+  return {
+    timestamp: '2026-05-06T00:40:51.000Z',
+    type: 'event_msg',
+    payload: {
+      type,
+      ...payload,
+    },
+  };
+}
+
+function responseItem(payload) {
+  return {
+    timestamp: '2026-05-06T00:40:51.500Z',
+    type: 'response_item',
+    payload,
+  };
+}
+
+function compacted(replacementHistory) {
+  return {
+    timestamp: '2026-05-06T00:40:51.250Z',
+    type: 'compacted',
+    payload: {
+      message: '',
+      replacement_history: replacementHistory,
+    },
+  };
+}
+
+function userReplacement(text) {
+  return {
+    type: 'message',
+    role: 'user',
+    content: [{ type: 'input_text', text }],
+  };
+}

package/src/codex-sidecar-cli.test.mjs

@@ -0,0 +1,75 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const REPO_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+
+test('codex-sidecar-diagnostics CLI exits 0 only for configured diagnostics', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-sidecar-cli-'));
+  try {
+    const bin = join(dir, 'fake-sidecar');
+    writeFileSync(bin, '#!/usr/bin/env bash\nprintf "ok\\n"\nexit 0\n');
+    chmodSync(bin, 0o755);
+
+    const result = spawnSync(
+      process.execPath,
+      [join(REPO_ROOT, 'bin/throughline.mjs'), 'codex-sidecar-diagnostics', '--project', '/repo'],
+      {
+        env: {
+          ...process.env,
+          THROUGHLINE_CODEX_SIDECAR_BIN: bin,
+        },
+        encoding: 'utf8',
+      },
+    );
+
+    assert.equal(result.status, 0, result.stderr);
+    const json = JSON.parse(result.stdout);
+    assert.equal(json.status, 'configured');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('codex-sidecar-dry-run CLI exits 0 for normalized dry-run request', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-sidecar-dry-run-cli-'));
+  try {
+    const bin = join(dir, 'fake-sidecar');
+    writeFileSync(
+      bin,
+      '#!/usr/bin/env bash\nprintf \'{"status":"dry-run","workflow":"risk-check","normalizedRequest":{"dryRun":true}}\\n\'\n',
+    );
+    chmodSync(bin, 0o755);
+
+    const result = spawnSync(
+      process.execPath,
+      [
+        join(REPO_ROOT, 'bin/throughline.mjs'),
+        'codex-sidecar-dry-run',
+        '--project',
+        '/repo',
+        '--preset',
+        'risk-check',
+        'check risks',
+      ],
+      {
+        env: {
+          ...process.env,
+          THROUGHLINE_CODEX_SIDECAR_BIN: bin,
+        },
+        encoding: 'utf8',
+      },
+    );
+
+    assert.equal(result.status, 0, result.stderr);
+    const json = JSON.parse(result.stdout);
+    assert.equal(json.status, 'dry-run');
+    assert.equal(json.workflow, 'risk-check');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});