@ai-devkit/agent-manager 0.32.0 → 0.33.0

package/src/__tests__/durable/CodexPrintRunner.test.ts

@@ -1,189 +1,309 @@
-import { EventEmitter } from 'node:events';
-import { PassThrough, Writable } from 'node:stream';
-import { describe, expect, it, vi } from 'vitest';
-import type { CodexDurableAgent } from '../../index.js';
+import { EventEmitter } from "node:events";
+import { PassThrough, Writable } from "node:stream";
+import { describe, expect, it, vi } from "vitest";
+import type { CodexDurableAgent } from "../../index.js";
 
-const SESSION = '22222222-2222-4222-8222-222222222222';
+const SESSION = "22222222-2222-4222-8222-222222222222";
 
 function agent(providerSessionId: string | null = null): CodexDurableAgent {
-    return {
-        id: '11111111-1111-4111-8111-111111111111', name: 'reviewer', provider: 'codex', mode: 'durable',
-        cwd: '/project', providerSessionId, state: 'running', sessionHealth: 'uninitialized',
-        createdAt: '', updatedAt: '', lastActiveAt: null, lastResult: null, activeRun: null,
-    };
+  return {
+    id: "11111111-1111-4111-8111-111111111111",
+    name: "reviewer",
+    provider: "codex",
+    mode: "durable",
+    cwd: "/project",
+    providerSessionId,
+    state: "running",
+    sessionHealth: "uninitialized",
+    createdAt: "",
+    updatedAt: "",
+    lastActiveAt: null,
+    lastResult: null,
+    activeRun: null,
+  };
 }
 
 function fakeSpawn(lines: string[], exitCode = 0, chunks = false) {
-    const promptChunks: Buffer[] = [];
-    const child = new EventEmitter() as any;
-    child.pid = 4242;
-    child.stdout = new PassThrough();
-    child.stderr = new PassThrough();
-    child.kill = vi.fn();
-    child.stdin = new Writable({
-        write(chunk, _encoding, callback) { promptChunks.push(Buffer.from(chunk)); callback(); },
-        final(callback) {
-            const output = lines.join('\n');
-            if (chunks) {
-                const bytes = Buffer.from(output);
-                child.stdout.write(bytes.subarray(0, 7));
-                child.stdout.write(bytes.subarray(7));
-            } else child.stdout.write(output);
-            child.stdout.end();
-            queueMicrotask(() => child.emit('close', exitCode, null));
-            callback();
-        },
-    });
-    const spawn = vi.fn(() => child);
-    return { child, spawn, promptChunks };
+  const promptChunks: Buffer[] = [];
+  const child = new EventEmitter() as any;
+  child.pid = 4242;
+  child.stdout = new PassThrough();
+  child.stderr = new PassThrough();
+  child.kill = vi.fn();
+  child.stdin = new Writable({
+    write(chunk, _encoding, callback) {
+      promptChunks.push(Buffer.from(chunk));
+      callback();
+    },
+    final(callback) {
+      const output = lines.join("\n");
+      if (chunks) {
+        const bytes = Buffer.from(output);
+        child.stdout.write(bytes.subarray(0, 7));
+        child.stdout.write(bytes.subarray(7));
+      } else child.stdout.write(output);
+      child.stdout.end();
+      queueMicrotask(() => child.emit("close", exitCode, null));
+      callback();
+    },
+  });
+  const spawn = vi.fn(() => child);
+  return { child, spawn, promptChunks };
 }
 
 function events(session = SESSION): string[] {
-    return [
-        JSON.stringify({ type: 'thread.started', thread_id: session }),
-        JSON.stringify({ type: 'turn.started' }),
-        JSON.stringify({ type: 'future.event', anything: true }),
-        JSON.stringify({ type: 'item.completed', item: { type: 'agent_message', text: 'first' } }),
-        JSON.stringify({ type: 'item.completed', item: { type: 'agent_message', text: 'final' } }),
-        JSON.stringify({ type: 'turn.completed' }),
-        '',
-    ];
+  return [
+    JSON.stringify({ type: "thread.started", thread_id: session }),
+    JSON.stringify({ type: "turn.started" }),
+    JSON.stringify({ type: "future.event", anything: true }),
+    JSON.stringify({ type: "item.completed", item: { type: "agent_message", text: "first" } }),
+    JSON.stringify({ type: "item.completed", item: { type: "agent_message", text: "final" } }),
+    JSON.stringify({ type: "turn.completed" }),
+    "",
+  ];
 }
 
 async function runner(fixture: ReturnType<typeof fakeSpawn>, maxLineBytes?: number) {
-    const api = await import('../../index.js') as Record<string, unknown>;
-    expect(api).toHaveProperty('CodexPrintRunner');
-    const Runner = api.CodexPrintRunner as new (options: unknown) => any;
-    return new Runner({ spawn: fixture.spawn, maxLineBytes, processInspector: {
-        getIdentity: () => ({ pid: 4242, startedAt: 'provider-start' }),
-    } });
+  const api = (await import("../../index.js")) as Record<string, unknown>;
+  expect(api).toHaveProperty("CodexPrintRunner");
+  const Runner = api.CodexPrintRunner as new (options: unknown) => any;
+  return new Runner({
+    spawn: fixture.spawn,
+    maxLineBytes,
+    processInspector: {
+      getIdentity: () => ({ pid: 4242, startedAt: "provider-start" }),
+    },
+  });
 }
 
-describe('CodexPrintRunner', () => {
-    it('constructs default process dependencies without spawning', async () => {
-        const api = await import('../../index.js') as Record<string, unknown>;
-        const Runner = api.CodexPrintRunner as new () => any;
-        expect(new Runner()).toBeDefined();
-    });
+describe("CodexPrintRunner", () => {
+  it("constructs default process dependencies without spawning", async () => {
+    const api = (await import("../../index.js")) as Record<string, unknown>;
+    const Runner = api.CodexPrintRunner as new () => any;
+    expect(new Runner()).toBeDefined();
+  });
 
-    it('binds an initial thread before returning ordered assistant output', async () => {
-        const fixture = fakeSpawn(events(), 0, true);
-        const instance = await runner(fixture);
-        const order: string[] = [];
-        const result = await instance.run({
-            agent: agent(), prompt: 'secret prompt', executable: 'fake-codex',
-            onSpawn: async () => { expect(fixture.promptChunks).toHaveLength(0); order.push('spawn'); },
-            onSession: async (id: string) => { expect(id).toBe(SESSION); order.push('session'); },
-        });
-
-        expect(order).toEqual(['spawn', 'session']);
-        expect(fixture.spawn).toHaveBeenCalledWith('fake-codex', ['exec', '--json', '-'], expect.objectContaining({
-            cwd: '/project', shell: false, stdio: ['pipe', 'pipe', 'pipe'],
-        }));
-        expect(JSON.stringify(fixture.spawn.mock.calls)).not.toContain('secret prompt');
-        expect(Buffer.concat(fixture.promptChunks).toString()).toBe('secret prompt');
-        expect(result).toEqual({ sessionId: SESSION, result: 'final', messages: ['first', 'final'], exitCode: 0 });
+  it("binds an initial thread before returning ordered assistant output", async () => {
+    const fixture = fakeSpawn(events(), 0, true);
+    const instance = await runner(fixture);
+    const order: string[] = [];
+    const result = await instance.run({
+      agent: agent(),
+      prompt: "secret prompt",
+      executable: "fake-codex",
+      onSpawn: async () => {
+        expect(fixture.promptChunks).toHaveLength(0);
+        order.push("spawn");
+      },
+      onSession: async (id: string) => {
+        expect(id).toBe(SESSION);
+        order.push("session");
+      },
     });
 
-    it('resumes the exact stored UUID and rejects a mismatch', async () => {
-        const mismatch = '33333333-3333-4333-8333-333333333333';
-        const fixture = fakeSpawn(events(mismatch));
-        const instance = await runner(fixture);
-        await expect(instance.run({ agent: agent(SESSION), prompt: 'later', onSpawn: vi.fn(), onSession: vi.fn() }))
-            .rejects.toMatchObject({ code: 'CODEX_SESSION_MISMATCH' });
-        expect(fixture.spawn.mock.calls[0]![1]).toEqual(['exec', 'resume', '--json', SESSION, '-']);
+    expect(order).toEqual(["spawn", "session"]);
+    expect(fixture.spawn).toHaveBeenCalledWith(
+      "fake-codex",
+      ["exec", "--json", "-"],
+      expect.objectContaining({
+        cwd: "/project",
+        shell: false,
+        stdio: ["pipe", "pipe", "pipe"],
+      }),
+    );
+    expect(JSON.stringify(fixture.spawn.mock.calls)).not.toContain("secret prompt");
+    expect(Buffer.concat(fixture.promptChunks).toString()).toBe("secret prompt");
+    expect(result).toEqual({
+      sessionId: SESSION,
+      result: "final",
+      messages: ["first", "final"],
+      exitCode: 0,
     });
+  });
 
-    it.each([
-        ['malformed JSON', ['{bad\n'], 'CODEX_PROTOCOL'],
-        ['non-object JSON', ['[]\n'], 'CODEX_PROTOCOL'],
-        ['truncated JSON', ['{}'], 'CODEX_PROTOCOL'],
-        ['missing thread', [JSON.stringify({ type: 'item.completed', item: { type: 'agent_message', text: 'x' } }), JSON.stringify({ type: 'turn.completed' }), ''], 'CODEX_PROTOCOL'],
-        ['missing assistant', [JSON.stringify({ type: 'thread.started', thread_id: SESSION }), JSON.stringify({ type: 'turn.completed' }), ''], 'CODEX_RESULT_MISSING'],
-        ['missing completion', [JSON.stringify({ type: 'thread.started', thread_id: SESSION }), JSON.stringify({ type: 'item.completed', item: { type: 'agent_message', text: 'x' } }), ''], 'CODEX_PROTOCOL'],
-    ])('rejects %s', async (_name, lines, code) => {
-        const fixture = fakeSpawn(lines as string[]);
-        await expect((await runner(fixture)).run({
-            agent: agent(), prompt: 'x', onSpawn: vi.fn(), onSession: vi.fn(),
-        })).rejects.toMatchObject({ code });
-    });
+  it("resumes the exact stored UUID and rejects a mismatch", async () => {
+    const mismatch = "33333333-3333-4333-8333-333333333333";
+    const fixture = fakeSpawn(events(mismatch));
+    const instance = await runner(fixture);
+    await expect(
+      instance.run({
+        agent: agent(SESSION),
+        prompt: "later",
+        onSpawn: vi.fn(),
+        onSession: vi.fn(),
+      }),
+    ).rejects.toMatchObject({ code: "CODEX_SESSION_MISMATCH" });
+    expect(fixture.spawn.mock.calls[0]![1]).toEqual(["exec", "resume", "--json", SESSION, "-"]);
+  });
 
-    it('rejects oversized output, non-zero exit, and missing process identity without leaking stderr', async () => {
-        const oversized = fakeSpawn([`${'x'.repeat(20)}\n`]);
-        await expect((await runner(oversized, 10)).run({
-            agent: agent(), prompt: 'x', onSpawn: vi.fn(), onSession: vi.fn(),
-        })).rejects.toMatchObject({ code: 'CODEX_PROTOCOL' });
-        const oversizedWithoutNewline = fakeSpawn(['x'.repeat(20)]);
-        await expect((await runner(oversizedWithoutNewline, 10)).run({
-            agent: agent(), prompt: 'x', onSpawn: vi.fn(), onSession: vi.fn(),
-        })).rejects.toMatchObject({ code: 'CODEX_PROTOCOL' });
-
-        const failed = fakeSpawn(events(), 1);
-        failed.child.stderr.end('secret-looking provider diagnostic');
-        await expect((await runner(failed)).run({
-            agent: agent(), prompt: 'x', onSpawn: vi.fn(), onSession: vi.fn(),
-        })).rejects.toMatchObject({ code: 'CODEX_PROCESS' });
-
-        const missing = fakeSpawn([]);
-        missing.child.pid = undefined;
-        await expect((await runner(missing)).run({
-            agent: agent(), prompt: 'x', onSpawn: vi.fn(), onSession: vi.fn(),
-        })).rejects.toMatchObject({ code: 'CODEX_PROCESS' });
-    });
+  it.each([
+    ["malformed JSON", ["{bad\n"], "CODEX_PROTOCOL"],
+    ["non-object JSON", ["[]\n"], "CODEX_PROTOCOL"],
+    ["truncated JSON", ["{}"], "CODEX_PROTOCOL"],
+    [
+      "missing thread",
+      [
+        JSON.stringify({ type: "item.completed", item: { type: "agent_message", text: "x" } }),
+        JSON.stringify({ type: "turn.completed" }),
+        "",
+      ],
+      "CODEX_PROTOCOL",
+    ],
+    [
+      "missing assistant",
+      [
+        JSON.stringify({ type: "thread.started", thread_id: SESSION }),
+        JSON.stringify({ type: "turn.completed" }),
+        "",
+      ],
+      "CODEX_RESULT_MISSING",
+    ],
+    [
+      "missing completion",
+      [
+        JSON.stringify({ type: "thread.started", thread_id: SESSION }),
+        JSON.stringify({ type: "item.completed", item: { type: "agent_message", text: "x" } }),
+        "",
+      ],
+      "CODEX_PROTOCOL",
+    ],
+  ])("rejects %s", async (_name, lines, code) => {
+    const fixture = fakeSpawn(lines as string[]);
+    await expect(
+      (await runner(fixture)).run({
+        agent: agent(),
+        prompt: "x",
+        onSpawn: vi.fn(),
+        onSession: vi.fn(),
+      }),
+    ).rejects.toMatchObject({ code });
+  });
 
-    it('rejects invalid or duplicate thread identities', async () => {
-        for (const lines of [
-            [JSON.stringify({ type: 'thread.started', thread_id: 'bad' }), ''],
-            [
-                JSON.stringify({ type: 'thread.started', thread_id: SESSION }),
-                JSON.stringify({ type: 'thread.started', thread_id: SESSION }),
-                '',
-            ],
-        ]) {
-            const fixture = fakeSpawn(lines);
-            await expect((await runner(fixture)).run({
-                agent: agent(), prompt: 'x', onSpawn: vi.fn(), onSession: vi.fn(),
-            })).rejects.toMatchObject({ code: 'CODEX_PROTOCOL' });
-        }
-    });
+  it("rejects oversized output, non-zero exit, and missing process identity without leaking stderr", async () => {
+    const oversized = fakeSpawn([`${"x".repeat(20)}\n`]);
+    await expect(
+      (await runner(oversized, 10)).run({
+        agent: agent(),
+        prompt: "x",
+        onSpawn: vi.fn(),
+        onSession: vi.fn(),
+      }),
+    ).rejects.toMatchObject({ code: "CODEX_PROTOCOL" });
+    const oversizedWithoutNewline = fakeSpawn(["x".repeat(20)]);
+    await expect(
+      (await runner(oversizedWithoutNewline, 10)).run({
+        agent: agent(),
+        prompt: "x",
+        onSpawn: vi.fn(),
+        onSession: vi.fn(),
+      }),
+    ).rejects.toMatchObject({ code: "CODEX_PROTOCOL" });
 
-    it('classifies callback processing failure and kills when spawn persistence fails', async () => {
-        const callbackFailure = fakeSpawn(events());
-        await expect((await runner(callbackFailure)).run({
-            agent: agent(), prompt: 'x', onSpawn: vi.fn(),
-            onSession: vi.fn().mockRejectedValue(new Error('storage unavailable')),
-        })).rejects.toMatchObject({ code: 'CODEX_PROTOCOL' });
-
-        const spawnFailure = fakeSpawn([]);
-        const failure = new Error('cannot persist process');
-        await expect((await runner(spawnFailure)).run({
-            agent: agent(), prompt: 'x', onSpawn: vi.fn().mockRejectedValue(failure), onSession: vi.fn(),
-        })).rejects.toBe(failure);
-        expect(spawnFailure.child.kill).toHaveBeenCalledOnce();
-    });
+    const failed = fakeSpawn(events(), 1);
+    failed.child.stderr.end("secret-looking provider diagnostic");
+    await expect(
+      (await runner(failed)).run({
+        agent: agent(),
+        prompt: "x",
+        onSpawn: vi.fn(),
+        onSession: vi.fn(),
+      }),
+    ).rejects.toMatchObject({ code: "CODEX_PROCESS" });
+
+    const missing = fakeSpawn([]);
+    missing.child.pid = undefined;
+    await expect(
+      (await runner(missing)).run({
+        agent: agent(),
+        prompt: "x",
+        onSpawn: vi.fn(),
+        onSession: vi.fn(),
+      }),
+    ).rejects.toMatchObject({ code: "CODEX_PROCESS" });
+  });
+
+  it("rejects invalid or duplicate thread identities", async () => {
+    for (const lines of [
+      [JSON.stringify({ type: "thread.started", thread_id: "bad" }), ""],
+      [
+        JSON.stringify({ type: "thread.started", thread_id: SESSION }),
+        JSON.stringify({ type: "thread.started", thread_id: SESSION }),
+        "",
+      ],
+    ]) {
+      const fixture = fakeSpawn(lines);
+      await expect(
+        (await runner(fixture)).run({
+          agent: agent(),
+          prompt: "x",
+          onSpawn: vi.fn(),
+          onSession: vi.fn(),
+        }),
+      ).rejects.toMatchObject({ code: "CODEX_PROTOCOL" });
+    }
+  });
 
-    it('rejects an unverifiable positive PID', async () => {
-        const api = await import('../../index.js') as Record<string, unknown>;
-        const fixture = fakeSpawn([]);
-        const Runner = api.CodexPrintRunner as new (options: unknown) => any;
-        const instance = new Runner({ spawn: fixture.spawn, processInspector: { getIdentity: () => null } });
-        await expect(instance.run({
-            agent: agent(), prompt: 'x', onSpawn: vi.fn(), onSession: vi.fn(),
-        })).rejects.toMatchObject({ code: 'CODEX_PROCESS' });
-        expect(fixture.child.kill).toHaveBeenCalledOnce();
+  it("classifies callback processing failure and kills when spawn persistence fails", async () => {
+    const callbackFailure = fakeSpawn(events());
+    await expect(
+      (await runner(callbackFailure)).run({
+        agent: agent(),
+        prompt: "x",
+        onSpawn: vi.fn(),
+        onSession: vi.fn().mockRejectedValue(new Error("storage unavailable")),
+      }),
+    ).rejects.toMatchObject({ code: "CODEX_PROTOCOL" });
+
+    const spawnFailure = fakeSpawn([]);
+    const failure = new Error("cannot persist process");
+    await expect(
+      (await runner(spawnFailure)).run({
+        agent: agent(),
+        prompt: "x",
+        onSpawn: vi.fn().mockRejectedValue(failure),
+        onSession: vi.fn(),
+      }),
+    ).rejects.toBe(failure);
+    expect(spawnFailure.child.kill).toHaveBeenCalledOnce();
+  });
+
+  it("rejects an unverifiable positive PID", async () => {
+    const api = (await import("../../index.js")) as Record<string, unknown>;
+    const fixture = fakeSpawn([]);
+    const Runner = api.CodexPrintRunner as new (options: unknown) => any;
+    const instance = new Runner({
+      spawn: fixture.spawn,
+      processInspector: { getIdentity: () => null },
     });
+    await expect(
+      instance.run({
+        agent: agent(),
+        prompt: "x",
+        onSpawn: vi.fn(),
+        onSession: vi.fn(),
+      }),
+    ).rejects.toMatchObject({ code: "CODEX_PROCESS" });
+    expect(fixture.child.kill).toHaveBeenCalledOnce();
+  });
 
-    it('classifies a child spawn error as a process failure', async () => {
-        const fixture = fakeSpawn([]);
-        fixture.child.stdin = new Writable({
-            write(_chunk, _encoding, callback) { callback(); },
-            final(callback) {
-                queueMicrotask(() => fixture.child.emit('error', new Error('spawn failed')));
-                callback();
-            },
-        });
-        await expect((await runner(fixture)).run({
-            agent: agent(), prompt: 'x', onSpawn: vi.fn(), onSession: vi.fn(),
-        })).rejects.toMatchObject({ code: 'CODEX_PROCESS' });
+  it("classifies a child spawn error as a process failure", async () => {
+    const fixture = fakeSpawn([]);
+    fixture.child.stdin = new Writable({
+      write(_chunk, _encoding, callback) {
+        callback();
+      },
+      final(callback) {
+        queueMicrotask(() => fixture.child.emit("error", new Error("spawn failed")));
+        callback();
+      },
     });
+    await expect(
+      (await runner(fixture)).run({
+        agent: agent(),
+        prompt: "x",
+        onSpawn: vi.fn(),
+        onSession: vi.fn(),
+      }),
+    ).rejects.toMatchObject({ code: "CODEX_PROCESS" });
+  });
 });

package/src/__tests__/fixtures/fake-claude.cjs

@@ -1,24 +1,31 @@
 #!/usr/bin/env node
-const fs = require('node:fs');
+const fs = require("node:fs");
 
 const args = process.argv.slice(2);
-if (args[0] === '--version') {
-  process.stdout.write('fake-claude 2.1.220\n');
+if (args[0] === "--version") {
+  process.stdout.write("fake-claude 2.1.220\n");
   process.exit(0);
 }
-if (args[0] === '--help') {
-  process.stdout.write('--print -p --session-id --resume --output-format stream-json --verbose\n');
+if (args[0] === "--help") {
+  process.stdout.write("--print -p --session-id --resume --output-format stream-json --verbose\n");
   process.exit(0);
 }
 
-let prompt = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', (chunk) => { prompt += chunk; });
-process.stdin.on('end', () => {
-  const flag = args.includes('--session-id') ? '--session-id' : '--resume';
+let prompt = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => {
+  prompt += chunk;
+});
+process.stdin.on("end", () => {
+  const flag = args.includes("--session-id") ? "--session-id" : "--resume";
   const sessionId = args[args.indexOf(flag) + 1];
   const capture = process.env.AI_DEVKIT_FAKE_CLAUDE_CAPTURE;
-  if (capture) fs.appendFileSync(capture, `${JSON.stringify({ args, prompt, cwd: process.cwd() })}\n`);
-  process.stdout.write(`${JSON.stringify({ type: 'system', subtype: 'init', session_id: sessionId })}\n`);
-  process.stdout.write(`${JSON.stringify({ type: 'result', session_id: sessionId, result: `answer:${prompt}` })}\n`);
+  if (capture)
+    fs.appendFileSync(capture, `${JSON.stringify({ args, prompt, cwd: process.cwd() })}\n`);
+  process.stdout.write(
+    `${JSON.stringify({ type: "system", subtype: "init", session_id: sessionId })}\n`,
+  );
+  process.stdout.write(
+    `${JSON.stringify({ type: "result", session_id: sessionId, result: `answer:${prompt}` })}\n`,
+  );
 });

package/src/__tests__/fixtures/fake-codex.cjs

@@ -1,45 +1,56 @@
 #!/usr/bin/env node
-const fs = require('node:fs');
+const fs = require("node:fs");
 
-const SESSION = '22222222-2222-4222-8222-222222222222';
-const MISMATCH = '33333333-3333-4333-8333-333333333333';
+const SESSION = "22222222-2222-4222-8222-222222222222";
+const MISMATCH = "33333333-3333-4333-8333-333333333333";
 const args = process.argv.slice(2);
 
-if (args[0] === '--version') {
-  process.stdout.write('codex-cli 0.147.0\n');
+if (args[0] === "--version") {
+  process.stdout.write("codex-cli 0.147.0\n");
   process.exit(0);
 }
-if (args[0] === 'exec' && args.at(-1) === '--help') {
-  process.stdout.write(args[1] === 'resume'
-    ? 'Usage: codex exec resume [SESSION_ID] [PROMPT]\n--json\n- stdin\n'
-    : 'Usage: codex exec [PROMPT]\nresume\n--json\n- stdin\n');
+if (args[0] === "exec" && args.at(-1) === "--help") {
+  process.stdout.write(
+    args[1] === "resume"
+      ? "Usage: codex exec resume [SESSION_ID] [PROMPT]\n--json\n- stdin\n"
+      : "Usage: codex exec [PROMPT]\nresume\n--json\n- stdin\n",
+  );
   process.exit(0);
 }
 
-let prompt = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', (chunk) => { prompt += chunk; });
-process.stdin.on('end', () => {
-  const mode = process.env.AI_DEVKIT_FAKE_CODEX_MODE || 'success';
-  const isResume = args[1] === 'resume';
+let prompt = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => {
+  prompt += chunk;
+});
+process.stdin.on("end", () => {
+  const mode = process.env.AI_DEVKIT_FAKE_CODEX_MODE || "success";
+  const isResume = args[1] === "resume";
   const requested = isResume ? args[3] : null;
-  const sessionId = mode === 'mismatch' ? MISMATCH : (requested || SESSION);
+  const sessionId = mode === "mismatch" ? MISMATCH : requested || SESSION;
   const capture = process.env.AI_DEVKIT_FAKE_CODEX_CAPTURE;
-  if (capture) fs.appendFileSync(capture, `${JSON.stringify({ args, prompt, cwd: process.cwd() })}\n`);
-  if (mode === 'fail-before-bind') process.exit(1);
-  if (mode !== 'missing-thread') process.stdout.write(`${JSON.stringify({ type: 'thread.started', thread_id: sessionId })}\n`);
-  if (mode === 'fail-after-bind') process.exit(1);
-  if (mode === 'malformed') return process.stdout.write('{bad\n');
-  if (mode === 'oversized') return process.stdout.write(`${'x'.repeat(1024 * 1024 + 1)}\n`);
-  if (mode === 'truncated') return process.stdout.write('{');
-  process.stdout.write(`${JSON.stringify({ type: 'turn.started' })}\n`);
-  if (mode !== 'missing-result') {
-    process.stdout.write(`${JSON.stringify({ type: 'item.completed', item: { id: 'item_0', type: 'agent_message', text: 'first' } })}\n`);
-    process.stdout.write(`${JSON.stringify({ type: 'item.completed', item: { id: 'item_1', type: 'agent_message', text: `answer:${prompt}` } })}\n`);
+  if (capture)
+    fs.appendFileSync(capture, `${JSON.stringify({ args, prompt, cwd: process.cwd() })}\n`);
+  if (mode === "fail-before-bind") process.exit(1);
+  if (mode !== "missing-thread")
+    process.stdout.write(`${JSON.stringify({ type: "thread.started", thread_id: sessionId })}\n`);
+  if (mode === "fail-after-bind") process.exit(1);
+  if (mode === "malformed") return process.stdout.write("{bad\n");
+  if (mode === "oversized") return process.stdout.write(`${"x".repeat(1024 * 1024 + 1)}\n`);
+  if (mode === "truncated") return process.stdout.write("{");
+  process.stdout.write(`${JSON.stringify({ type: "turn.started" })}\n`);
+  if (mode !== "missing-result") {
+    process.stdout.write(
+      `${JSON.stringify({ type: "item.completed", item: { id: "item_0", type: "agent_message", text: "first" } })}\n`,
+    );
+    process.stdout.write(
+      `${JSON.stringify({ type: "item.completed", item: { id: "item_1", type: "agent_message", text: `answer:${prompt}` } })}\n`,
+    );
   }
-  if (mode !== 'missing-completion') process.stdout.write(`${JSON.stringify({ type: 'turn.completed', usage: {} })}\n`);
-  if (mode === 'stderr-failure') {
-    process.stderr.write('secret-looking diagnostic');
+  if (mode !== "missing-completion")
+    process.stdout.write(`${JSON.stringify({ type: "turn.completed", usage: {} })}\n`);
+  if (mode === "stderr-failure") {
+    process.stderr.write("secret-looking diagnostic");
     process.exitCode = 1;
   }
 });