throughline 0.3.24 → 0.3.25

package/src/codex-vscode-restore-smoke.test.mjs

@@ -0,0 +1,325 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import {
+  buildCodexVsCodeRestoreSmokeMemory,
+  buildCodexVsCodeRestoreSmokePrompt,
+  inspectCodexVsCodeRestoreSmokeRollout,
+} from './codex-vscode-restore-smoke.mjs';
+
+const REPO_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+
+function makeTempHome() {
+  return mkdtempSync(join(tmpdir(), 'tl-codex-vscode-restore-home-'));
+}
+
+function makeTempProject() {
+  return mkdtempSync(join(tmpdir(), 'tl-codex-vscode-restore-project-'));
+}
+
+function makeFakeCodexAppServer(dir) {
+  const script = join(dir, 'fake-codex-vscode-restore-app-server.mjs');
+  writeFileSync(
+    script,
+    `#!/usr/bin/env node
+import { createInterface } from 'node:readline';
+const rl = createInterface({ input: process.stdin });
+let injected = false;
+function send(message) { process.stdout.write(JSON.stringify(message) + '\\n'); }
+rl.on('line', (line) => {
+  const msg = JSON.parse(line);
+  if (msg.method === 'initialized') return;
+  if (msg.method === 'initialize') {
+    send({ id: msg.id, result: { userAgent: 'fake-codex' } });
+  } else if (msg.method === 'thread/read' || msg.method === 'thread/resume') {
+    send({ id: msg.id, result: { thread: { id: msg.params.threadId, turns: [{ id: 'turn-1' }] } } });
+  } else if (msg.method === 'thread/inject_items') {
+    injected = true;
+    send({ id: msg.id, result: { thread: { id: msg.params.threadId, turns: [{ id: 'turn-1' }, { id: 'memory' }] } } });
+  } else if (msg.method === 'turn/start') {
+    send({ id: msg.id, error: { code: -32601, message: injected ? 'unexpected turn/start' : 'not injected' } });
+  } else {
+    send({ id: msg.id, error: { code: -32601, message: 'unknown method' } });
+  }
+});
+`,
+  );
+  chmodSync(script, 0o755);
+  return script;
+}
+
+function runCli(home, codexHome, project, args = [], extraEnv = {}) {
+  return spawnSync(
+    process.execPath,
+    [join(REPO_ROOT, 'bin/throughline.mjs'), 'codex-vscode-restore-smoke', ...args],
+    {
+      cwd: project,
+      env: {
+        ...process.env,
+        HOME: home,
+        USERPROFILE: home,
+        CODEX_HOME: codexHome,
+        ...extraEnv,
+      },
+      encoding: 'utf8',
+    },
+  );
+}
+
+function writeRollout(codexHome, { project, threadId, rows }) {
+  const dir = join(codexHome, 'sessions', '2026', '05', '07');
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, `rollout-2026-05-07T00-00-00-${threadId}.jsonl`);
+  const allRows = [
+    {
+      timestamp: '2026-05-07T00:00:00.000Z',
+      type: 'session_meta',
+      payload: {
+        id: threadId,
+        cwd: project,
+        source: 'vscode',
+      },
+    },
+    ...rows,
+  ];
+  writeFileSync(path, allRows.map((row) => JSON.stringify(row)).join('\n') + '\n');
+  return path;
+}
+
+function event(timestamp, type, payload) {
+  return {
+    timestamp,
+    type: 'event_msg',
+    payload: {
+      type,
+      ...payload,
+    },
+  };
+}
+
+test('VS Code restore smoke memory uses active-work header and prompt does not leak marker', () => {
+  const marker = 'TL_CODEX_VSCODE_RESTORE_TEST';
+  const memory = buildCodexVsCodeRestoreSmokeMemory({ marker });
+  const prompt = buildCodexVsCodeRestoreSmokePrompt();
+
+  assert.match(memory, /^## Throughline: Active Work Context/);
+  assert.match(memory, new RegExp(marker));
+  assert.doesNotMatch(prompt, new RegExp(marker));
+});
+
+test('codex-vscode-restore-smoke prepare injects hidden marker memory behind explicit env', () => {
+  const home = makeTempHome();
+  const codexHome = makeTempHome();
+  const project = makeTempProject();
+  const fake = makeFakeCodexAppServer(project);
+  const threadId = '019dfdef-1000-7000-8000-000000000001';
+  try {
+    const refused = runCli(home, codexHome, project, [
+      '--prepare',
+      '--codex-thread-id',
+      threadId,
+      '--marker',
+      'TL_CODEX_VSCODE_RESTORE_PREP',
+      '--codex-app-server-bin',
+      fake,
+      '--json',
+    ]);
+    assert.equal(refused.status, 1);
+    assert.equal(JSON.parse(refused.stdout).reason, 'experimental_env_required');
+
+    const result = runCli(
+      home,
+      codexHome,
+      project,
+      [
+        '--prepare',
+        '--codex-thread-id',
+        threadId,
+        '--marker',
+        'TL_CODEX_VSCODE_RESTORE_PREP',
+        '--codex-app-server-bin',
+        fake,
+        '--json',
+      ],
+      { THROUGHLINE_EXPERIMENTAL_CODEX_VSCODE_RESTORE_SMOKE: '1' },
+    );
+    assert.equal(result.status, 0, result.stderr);
+    const payload = JSON.parse(result.stdout);
+    assert.equal(payload.status, 'prepared');
+    assert.equal(payload.restartSafe, false);
+    assert.equal(payload.inject.status, 'injected');
+    assert.equal(payload.prompt.includes(payload.marker), false);
+    assert.deepEqual(payload.verifyArgs.slice(0, 3), [
+      'throughline',
+      'codex-vscode-restore-smoke',
+      '--verify',
+    ]);
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+    rmSync(codexHome, { recursive: true, force: true });
+  }
+});
+
+test('inspectCodexVsCodeRestoreSmokeRollout proves marker only with restart acknowledgement', () => {
+  const codexHome = makeTempHome();
+  const project = makeTempProject();
+  const threadId = '019dfdef-1000-7000-8000-000000000002';
+  const marker = 'TL_CODEX_VSCODE_RESTORE_VERIFY';
+  const preparedAt = '2026-05-07T00:00:10.000Z';
+  try {
+    writeRollout(codexHome, {
+      project,
+      threadId,
+      rows: [
+        event('2026-05-07T00:00:11.000Z', 'user_message', {
+          message:
+            'Throughline VS Code restore smoke: Read the marker from your developer memory and reply with exactly that marker and nothing else.',
+        }),
+        event('2026-05-07T00:00:12.000Z', 'agent_message', { message: marker }),
+      ],
+    });
+
+    const withoutAck = inspectCodexVsCodeRestoreSmokeRollout({
+      threadId,
+      codexHome,
+      projectPath: project,
+      marker,
+      preparedAt,
+    });
+    assert.equal(withoutAck.status, 'marker-visible-restart-unacknowledged');
+    assert.equal(withoutAck.restartSafe, false);
+
+    const withAck = inspectCodexVsCodeRestoreSmokeRollout({
+      threadId,
+      codexHome,
+      projectPath: project,
+      marker,
+      preparedAt,
+      afterVsCodeRestart: true,
+    });
+    assert.equal(withAck.status, 'vscode-restart-visible');
+    assert.equal(withAck.restartSafe, true);
+    assert.equal(withAck.promptMatches.length, 1);
+    assert.equal(withAck.assistantMarkerMatches.length, 1);
+    assert.equal(withAck.userMarkerMatches.length, 0);
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(codexHome, { recursive: true, force: true });
+  }
+});
+
+test('codex-vscode-restore-smoke verify rejects marker leaked in user prompt', () => {
+  const home = makeTempHome();
+  const codexHome = makeTempHome();
+  const project = makeTempProject();
+  const threadId = '019dfdef-1000-7000-8000-000000000003';
+  const marker = 'TL_CODEX_VSCODE_RESTORE_LEAK';
+  try {
+    writeRollout(codexHome, {
+      project,
+      threadId,
+      rows: [
+        event('2026-05-07T00:00:11.000Z', 'user_message', {
+          message: `Throughline VS Code restore smoke: reply with ${marker}`,
+        }),
+        event('2026-05-07T00:00:12.000Z', 'agent_message', { message: marker }),
+      ],
+    });
+
+    const result = runCli(home, codexHome, project, [
+      '--verify',
+      '--codex-thread-id',
+      threadId,
+      '--marker',
+      marker,
+      '--prepared-at',
+      '2026-05-07T00:00:10.000Z',
+      '--after-vscode-restart',
+      '--json',
+    ]);
+    assert.equal(result.status, 1);
+    const payload = JSON.parse(result.stdout);
+    assert.equal(payload.status, 'invalid');
+    assert.equal(payload.reason, 'marker_leaked_in_user_prompt');
+    assert.equal(payload.restartSafe, false);
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+    rmSync(codexHome, { recursive: true, force: true });
+  }
+});
+
+test('inspectCodexVsCodeRestoreSmokeRollout rejects non-exact assistant marker mentions', () => {
+  const codexHome = makeTempHome();
+  const project = makeTempProject();
+  const threadId = '019dfdef-1000-7000-8000-000000000004';
+  const marker = 'TL_CODEX_VSCODE_RESTORE_MENTION';
+  try {
+    writeRollout(codexHome, {
+      project,
+      threadId,
+      rows: [
+        event('2026-05-07T00:00:11.000Z', 'user_message', {
+          message:
+            'Throughline VS Code restore smoke: Read the marker from your developer memory and reply with exactly that marker and nothing else.',
+        }),
+        event('2026-05-07T00:00:12.000Z', 'agent_message', {
+          message: `I can see ${marker}, but this is not an exact marker-only answer.`,
+        }),
+      ],
+    });
+
+    const result = inspectCodexVsCodeRestoreSmokeRollout({
+      threadId,
+      codexHome,
+      projectPath: project,
+      marker,
+      preparedAt: '2026-05-07T00:00:10.000Z',
+      afterVsCodeRestart: true,
+    });
+
+    assert.equal(result.status, 'pending');
+    assert.equal(result.restartSafe, false);
+    assert.equal(result.assistantMarkerMatches.length, 0);
+    assert.equal(result.assistantMarkerMentions.length, 1);
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(codexHome, { recursive: true, force: true });
+  }
+});
+
+test('inspectCodexVsCodeRestoreSmokeRollout rejects exact marker answer without smoke prompt', () => {
+  const codexHome = makeTempHome();
+  const project = makeTempProject();
+  const threadId = '019dfdef-1000-7000-8000-000000000005';
+  const marker = 'TL_CODEX_VSCODE_RESTORE_NO_PROMPT';
+  try {
+    writeRollout(codexHome, {
+      project,
+      threadId,
+      rows: [event('2026-05-07T00:00:12.000Z', 'agent_message', { message: marker })],
+    });
+
+    const result = inspectCodexVsCodeRestoreSmokeRollout({
+      threadId,
+      codexHome,
+      projectPath: project,
+      marker,
+      preparedAt: '2026-05-07T00:00:10.000Z',
+      afterVsCodeRestart: true,
+    });
+
+    assert.equal(result.status, 'invalid');
+    assert.equal(result.reason, 'marker_answer_without_smoke_prompt');
+    assert.equal(result.restartSafe, false);
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(codexHome, { recursive: true, force: true });
+  }
+});

package/src/codex-vscode-rollback-smoke.mjs

@@ -0,0 +1,90 @@
+import { buildCodexRolloutTrimSource } from './codex-rollout-memory.mjs';
+import { defaultCodexHome } from './codex-thread-index.mjs';
+
+export function inspectCodexVsCodeRollbackSmoke({
+  threadId,
+  codexHome = defaultCodexHome(),
+  projectPath = process.cwd(),
+  afterVsCodeRestart = false,
+} = {}) {
+  assertNonEmptyString(threadId, 'threadId');
+
+  const trimSource = buildCodexRolloutTrimSource({
+    threadId,
+    codexHome,
+    projectPath,
+    sourceReason: 'vscode_rollback_nonresurrection_smoke',
+  });
+
+  if (!trimSource) {
+    return {
+      status: 'refused',
+      reason: 'codex_rollout_source_required',
+      proofScope: 'none',
+      restartSafe: false,
+      threadId,
+    };
+  }
+
+  const stats = trimSource.stats ?? {};
+  const restoreSafety = trimSource.restoreSafety ?? null;
+  const base = {
+    threadId,
+    rolloutPath: trimSource.rolloutPath,
+    afterVsCodeRestart: Boolean(afterVsCodeRestart),
+    stats,
+    restoreSafety,
+  };
+
+  if ((stats.rollbackEvents ?? 0) < 1) {
+    return pending(base, 'no_rollback_event_observed');
+  }
+  if ((stats.rolledBackUserMessages ?? 0) < 1) {
+    return pending(base, 'no_rolled_back_user_message_observed');
+  }
+  if ((stats.userMessagesAfterRollback ?? 0) < 1) {
+    return pending(base, 'no_user_message_after_rollback_observed');
+  }
+  if (restoreSafety?.status !== 'ok') {
+    return {
+      ...base,
+      status: 'risk',
+      reason: 'restore_safety_risk',
+      proofScope: 'codex_rollout_restore_safety_only',
+      restartSafe: false,
+    };
+  }
+  if (!afterVsCodeRestart) {
+    return {
+      ...base,
+      status: 'rollback-nonresurrection-visible-restart-unacknowledged',
+      reason: 'rollback_user_text_absent_after_rollback_without_restart_ack',
+      proofScope: 'codex_rollout_restore_safety_only',
+      restartSafe: false,
+    };
+  }
+
+  return {
+    ...base,
+    status: 'vscode-restart-rollback-nonresurrection-visible',
+    reason: 'rollback_user_text_absent_after_restart_ack',
+    proofScope: 'manual_vscode_reload_plus_rollout_restore_safety',
+    restartSafe: true,
+  };
+}
+
+function pending(base, reason) {
+  return {
+    ...base,
+    status: 'pending',
+    reason,
+    proofScope: 'codex_rollout_restore_safety_only',
+    restartSafe: false,
+  };
+}
+
+function assertNonEmptyString(value, name) {
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new Error(`${name} must be a non-empty string`);
+  }
+}

package/src/codex-vscode-rollback-smoke.test.mjs

@@ -0,0 +1,290 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { inspectCodexVsCodeRollbackSmoke } from './codex-vscode-rollback-smoke.mjs';
+
+const REPO_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+
+test('inspectCodexVsCodeRollbackSmoke: passes only with rollback, later user turn, restore safety ok, and restart ack', () => {
+  const codexHome = mkdtempSync(join(tmpdir(), 'tl-codex-rollback-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-rollback-project-'));
+  const threadId = '019dfe10-0000-7000-8000-000000000001';
+  try {
+    writeRollout(codexHome, {
+      project,
+      threadId,
+      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('task_complete'),
+        event('thread_rolled_back', { num_turns: 1 }),
+        event('user_message', { message: 'post restart verifier prompt' }),
+        event('task_started'),
+        event('agent_message', { message: 'post restart answer' }),
+        event('task_complete'),
+      ],
+    });
+
+    const result = inspectCodexVsCodeRollbackSmoke({
+      threadId,
+      codexHome,
+      projectPath: project,
+      afterVsCodeRestart: true,
+    });
+
+    assert.equal(result.status, 'vscode-restart-rollback-nonresurrection-visible');
+    assert.equal(result.restartSafe, true);
+    assert.equal(result.proofScope, 'manual_vscode_reload_plus_rollout_restore_safety');
+    assert.equal(result.stats.rollbackEvents, 1);
+    assert.equal(result.stats.rolledBackUserMessages, 1);
+    assert.equal(result.stats.userMessagesAfterRollback, 1);
+    assert.equal(result.restoreSafety.status, 'ok');
+  } finally {
+    rmSync(codexHome, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('inspectCodexVsCodeRollbackSmoke: does not claim restart safety without restart ack', () => {
+  const codexHome = mkdtempSync(join(tmpdir(), 'tl-codex-rollback-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-rollback-project-'));
+  const threadId = '019dfe10-0000-7000-8000-000000000002';
+  try {
+    writeRollout(codexHome, {
+      project,
+      threadId,
+      events: [
+        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 }),
+        event('user_message', { message: 'post rollback prompt' }),
+        event('task_started'),
+      ],
+    });
+
+    const result = inspectCodexVsCodeRollbackSmoke({
+      threadId,
+      codexHome,
+      projectPath: project,
+    });
+
+    assert.equal(result.status, 'rollback-nonresurrection-visible-restart-unacknowledged');
+    assert.equal(result.restartSafe, false);
+  } finally {
+    rmSync(codexHome, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('inspectCodexVsCodeRollbackSmoke: reports restore safety risk instead of passing', () => {
+  const codexHome = mkdtempSync(join(tmpdir(), 'tl-codex-rollback-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-rollback-project-'));
+  const threadId = '019dfe10-0000-7000-8000-000000000003';
+  try {
+    writeRollout(codexHome, {
+      project,
+      threadId,
+      events: [
+        event('user_message', { message: 'rolled back compacted request' }),
+        event('task_started'),
+        event('agent_message', { message: 'rolled back compacted answer' }),
+        event('task_complete'),
+        compacted([userReplacement('rolled back compacted request')]),
+        event('thread_rolled_back', { num_turns: 1 }),
+        event('user_message', { message: 'post restart verifier prompt' }),
+        event('task_started'),
+      ],
+    });
+
+    const result = inspectCodexVsCodeRollbackSmoke({
+      threadId,
+      codexHome,
+      projectPath: project,
+      afterVsCodeRestart: true,
+    });
+
+    assert.equal(result.status, 'risk');
+    assert.equal(result.reason, 'restore_safety_risk');
+    assert.equal(result.restartSafe, false);
+    assert.equal(result.restoreSafety.rollbackTextRetainedInCompacted, 1);
+  } finally {
+    rmSync(codexHome, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('codex-vscode-rollback-smoke CLI accepts env thread id and prints JSON', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-codex-rollback-user-home-'));
+  const codexHome = mkdtempSync(join(tmpdir(), 'tl-codex-rollback-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-rollback-project-'));
+  const threadId = '019dfe10-0000-7000-8000-000000000004';
+  try {
+    writeRollout(codexHome, {
+      project,
+      threadId,
+      events: [
+        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 }),
+        event('user_message', { message: 'post restart verifier prompt' }),
+        event('task_started'),
+      ],
+    });
+
+    const result = spawnSync(
+      process.execPath,
+      [
+        join(REPO_ROOT, 'bin/throughline.mjs'),
+        'codex-vscode-rollback-smoke',
+        '--verify',
+        '--codex-home',
+        codexHome,
+        '--after-vscode-restart',
+        '--json',
+      ],
+      {
+        cwd: project,
+        env: {
+          ...process.env,
+          HOME: home,
+          USERPROFILE: home,
+          CODEX_THREAD_ID: threadId,
+        },
+        encoding: 'utf8',
+      },
+    );
+
+    assert.equal(result.status, 0, result.stderr);
+    const payload = JSON.parse(result.stdout);
+    assert.equal(payload.status, 'vscode-restart-rollback-nonresurrection-visible');
+    assert.equal(payload.threadId, threadId);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(codexHome, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('codex-vscode-rollback-smoke text output summarizes restore-safety risks', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-codex-rollback-user-home-'));
+  const codexHome = mkdtempSync(join(tmpdir(), 'tl-codex-rollback-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-rollback-project-'));
+  const threadId = '019dfe10-0000-7000-8000-000000000005';
+  try {
+    writeRollout(codexHome, {
+      project,
+      threadId,
+      events: [
+        event('user_message', { message: 'rolled back compacted request' }),
+        event('task_started'),
+        event('agent_message', { message: 'rolled back compacted answer' }),
+        event('task_complete'),
+        compacted([userReplacement('rolled back compacted request')]),
+        event('thread_rolled_back', { num_turns: 1 }),
+        event('user_message', { message: 'post restart verifier prompt' }),
+        event('task_started'),
+      ],
+    });
+
+    const result = spawnSync(
+      process.execPath,
+      [
+        join(REPO_ROOT, 'bin/throughline.mjs'),
+        'codex-vscode-rollback-smoke',
+        '--verify',
+        '--codex-thread-id',
+        threadId,
+        '--codex-home',
+        codexHome,
+        '--after-vscode-restart',
+      ],
+      {
+        cwd: project,
+        env: {
+          ...process.env,
+          HOME: home,
+          USERPROFILE: home,
+        },
+        encoding: 'utf8',
+      },
+    );
+
+    assert.equal(result.status, 1);
+    assert.match(result.stdout, /restore safety:\s+risk/);
+    assert.match(result.stdout, /rollback text retained in compacted:\s+1/);
+    assert.match(
+      result.stdout,
+      /risks: rollback_text_retained_in_compacted_replacement_history:1/,
+    );
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(codexHome, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+function writeRollout(codexHome, { project, threadId, events }) {
+  const dir = join(codexHome, 'sessions', '2026', '05', '07');
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, `rollout-2026-05-07T00-00-00-${threadId}.jsonl`);
+  const rows = [
+    {
+      timestamp: '2026-05-07T00:00:00.000Z',
+      type: 'session_meta',
+      payload: {
+        id: threadId,
+        timestamp: '2026-05-07T00:00:00.000Z',
+        cwd: project,
+        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-07T00:00:01.000Z',
+    type: 'event_msg',
+    payload: {
+      type,
+      ...payload,
+    },
+  };
+}
+
+function compacted(replacementHistory) {
+  return {
+    timestamp: '2026-05-07T00:00:01.000Z',
+    type: 'compacted',
+    payload: {
+      message: '',
+      replacement_history: replacementHistory,
+    },
+  };
+}
+
+function userReplacement(text) {
+  return {
+    type: 'message',
+    role: 'user',
+    content: [{ type: 'input_text', text }],
+  };
+}