agent-relay 3.2.9 → 3.2.11

package/packages/sdk/src/workflows/__tests__/collectors/codex.test.ts

@@ -0,0 +1,82 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+
+import { CodexCollector } from '../../collectors/codex.js';
+
+const tempDirs: string[] = [];
+
+function makeTempDir(prefix: string): string {
+  const dir = mkdtempSync(path.join(os.tmpdir(), prefix));
+  tempDirs.push(dir);
+  return dir;
+}
+
+function createCodexFixture(tempDir: string, cwd: string, createdAtSeconds: number) {
+  const statePath = path.join(tempDir, 'state_5.sqlite');
+  const historyPath = path.join(tempDir, 'history.jsonl');
+  const db = new DatabaseSync(statePath);
+
+  db.exec(`
+    CREATE TABLE threads (
+      id TEXT PRIMARY KEY,
+      cwd TEXT,
+      model_provider TEXT,
+      tokens_used INTEGER,
+      created_at INTEGER,
+      updated_at INTEGER
+    );
+    CREATE TABLE logs (
+      thread_id TEXT,
+      ts INTEGER,
+      level TEXT,
+      message TEXT,
+      line INTEGER
+    );
+  `);
+
+  db.prepare(
+    'INSERT INTO threads (id, cwd, model_provider, tokens_used, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)',
+  ).run('thread-1', cwd, 'openai/gpt-5', 321, createdAtSeconds, createdAtSeconds + 3);
+  db.prepare(
+    'INSERT INTO logs (thread_id, ts, level, message, line) VALUES (?, ?, ?, ?, ?)',
+  ).run('thread-1', createdAtSeconds + 1, 'error', 'Command failed: bad exit code', 12);
+  db.close();
+
+  writeFileSync(historyPath, `${JSON.stringify({ session_id: 'thread-1', ts: createdAtSeconds, text: 'history' })}\n`);
+
+  return { statePath, historyPath };
+}
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    rmSync(tempDirs.pop()!, { recursive: true, force: true });
+  }
+});
+
+describe('CodexCollector', () => {
+  it('matches by cwd and time window and extracts errors from logs', async () => {
+    const tempDir = makeTempDir('codex-fixture-');
+    const cwd = '/repo/codex-project';
+    const createdAtSeconds = 100;
+    const { statePath, historyPath } = createCodexFixture(tempDir, cwd, createdAtSeconds);
+    const collector = new CodexCollector({ statePath, historyPath });
+
+    const report = await collector.collect({
+      cli: 'codex',
+      cwd,
+      startedAt: 100_000,
+      completedAt: 105_000,
+    });
+
+    expect(report).not.toBeNull();
+    expect(report?.sessionId).toBe('thread-1');
+    expect(report?.provider).toBe('openai');
+    expect(report?.model).toBe('gpt-5');
+    expect(report?.tokens).toEqual({ input: 321, output: 0, cacheRead: 0 });
+    expect(report?.errors).toEqual([{ turn: 1, text: 'Command failed: bad exit code' }]);
+    expect(report?.finalStatus).toBe('failed');
+  });
+});

package/packages/sdk/src/workflows/__tests__/collectors/opencode.test.ts

@@ -0,0 +1,178 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { mkdirSync, mkdtempSync, rmSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+
+const tempDirs: string[] = [];
+const originalHome = process.env.HOME;
+
+function makeTempDir(prefix: string): string {
+  const dir = mkdtempSync(path.join(os.tmpdir(), prefix));
+  tempDirs.push(dir);
+  return dir;
+}
+
+function createOpenCodeFixture(homeDir: string, cwd: string, sessionCreatedAt: number): string {
+  const dbDir = path.join(homeDir, '.local', 'share', 'opencode');
+  mkdirSync(dbDir, { recursive: true });
+  const dbPath = path.join(dbDir, 'opencode.db');
+  const db = new DatabaseSync(dbPath);
+
+  db.exec(`
+    CREATE TABLE session (id TEXT PRIMARY KEY, directory TEXT, time_created INTEGER);
+    CREATE TABLE message (id TEXT PRIMARY KEY, session_id TEXT, time_created INTEGER, data TEXT);
+    CREATE TABLE part (id TEXT PRIMARY KEY, message_id TEXT, session_id TEXT, time_created INTEGER, data TEXT);
+  `);
+
+  const insertSession = db.prepare('INSERT INTO session (id, directory, time_created) VALUES (?, ?, ?)');
+  const insertMessage = db.prepare('INSERT INTO message (id, session_id, time_created, data) VALUES (?, ?, ?, ?)');
+  const insertPart = db.prepare('INSERT INTO part (id, message_id, session_id, time_created, data) VALUES (?, ?, ?, ?, ?)');
+
+  insertSession.run('session-1', cwd, sessionCreatedAt);
+  insertSession.run('session-2', '/other/project', sessionCreatedAt + 1000);
+
+  insertMessage.run(
+    'msg-1',
+    'session-1',
+    sessionCreatedAt + 10,
+    JSON.stringify({ role: 'user', tokens: { input: 10, output: 0, cache: { read: 1 } } }),
+  );
+  insertMessage.run(
+    'msg-2',
+    'session-1',
+    sessionCreatedAt + 20,
+    JSON.stringify({
+      role: 'assistant',
+      modelID: 'gpt-5',
+      providerID: 'openai',
+      finish: 'error',
+      cost: 1.25,
+      tokens: { input: 15, output: 20, cache: { read: 4 } },
+    }),
+  );
+  insertMessage.run(
+    'msg-other',
+    'session-2',
+    sessionCreatedAt + 30,
+    JSON.stringify({ role: 'assistant', modelID: 'ignore-me', providerID: 'other', finish: 'completed' }),
+  );
+
+  insertPart.run(
+    'part-1',
+    'msg-1',
+    'session-1',
+    sessionCreatedAt + 11,
+    JSON.stringify({ type: 'text', text: 'Planning work' }),
+  );
+  insertPart.run(
+    'part-2',
+    'msg-2',
+    'session-1',
+    sessionCreatedAt + 21,
+    JSON.stringify({ type: 'tool_call', name: 'write_file' }),
+  );
+  insertPart.run(
+    'part-3',
+    'msg-2',
+    'session-1',
+    sessionCreatedAt + 22,
+    JSON.stringify({ type: 'text', text: 'Error: database locked\nCleanup afterwards' }),
+  );
+  insertPart.run(
+    'part-4',
+    'msg-2',
+    'session-1',
+    sessionCreatedAt + 23,
+    JSON.stringify({ type: 'text', text: 'Completed summary output' }),
+  );
+
+  db.close();
+  return dbPath;
+}
+
+async function importCollectorWithHome(homeDir: string) {
+  process.env.HOME = homeDir;
+  vi.resetModules();
+  vi.doMock('node:module', () => ({
+    createRequire: () => (id: string) => {
+      if (id !== 'better-sqlite3') {
+        throw new Error(`Unexpected module request: ${id}`);
+      }
+
+      return class BetterSqliteCompat {
+        private readonly db: DatabaseSync;
+
+        constructor(filename: string) {
+          this.db = new DatabaseSync(filename, { open: true, readOnly: true });
+        }
+
+        prepare(sql: string) {
+          const statement = this.db.prepare(sql);
+          return {
+            get<T>(params?: unknown): T | undefined {
+              return statement.get(params as never) as T | undefined;
+            },
+            all<T>(params?: unknown): T[] {
+              return statement.all(params as never) as T[];
+            },
+          };
+        }
+
+        pragma(_source: string) {
+          return undefined;
+        }
+
+        close() {
+          this.db.close();
+        }
+      };
+    },
+  }));
+  const module = await import('../../collectors/opencode.js');
+  return module.OpenCodeCollector;
+}
+
+afterEach(() => {
+  vi.resetModules();
+  process.env.HOME = originalHome;
+  while (tempDirs.length > 0) {
+    rmSync(tempDirs.pop()!, { recursive: true, force: true });
+  }
+});
+
+describe('OpenCodeCollector', () => {
+  it('matches by directory and time window, aggregates tokens, and extracts errors', async () => {
+    const homeDir = makeTempDir('opencode-home-');
+    const cwd = path.join(homeDir, 'workspace');
+    const sessionCreatedAt = 10_000;
+    createOpenCodeFixture(homeDir, cwd, sessionCreatedAt);
+    const OpenCodeCollector = await importCollectorWithHome(homeDir);
+
+    const collector = new OpenCodeCollector();
+    const report = await collector.collect({
+      cli: 'opencode',
+      cwd,
+      startedAt: sessionCreatedAt + 100,
+      completedAt: sessionCreatedAt + 500,
+    });
+
+    expect(report).not.toBeNull();
+    expect(report?.sessionId).toBe('session-1');
+    expect(report?.model).toBe('gpt-5');
+    expect(report?.provider).toBe('openai');
+    expect(report?.tokens).toEqual({ input: 25, output: 20, cacheRead: 5 });
+    expect(report?.cost).toBe(1.25);
+    expect(report?.toolCalls).toEqual([{ name: 'write_file', count: 1 }]);
+    expect(report?.errors).toEqual([{ turn: 3, text: 'Error: database locked' }]);
+    expect(report?.finalStatus).toBe('failed');
+    expect(report?.summary).toBe('Completed summary output');
+  });
+
+  it('returns false from canCollect when the database is missing', async () => {
+    const homeDir = makeTempDir('opencode-missing-home-');
+    const OpenCodeCollector = await importCollectorWithHome(homeDir);
+
+    expect(new OpenCodeCollector().canCollect()).toBe(false);
+  });
+});

package/packages/sdk/src/workflows/__tests__/run-summary-table.test.ts

@@ -0,0 +1,160 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { formatRunSummaryTable } from '../run-summary-table.js';
+
+vi.mock('@relaycast/sdk', () => ({
+  RelayCast: vi.fn(),
+  RelayError: class RelayError extends Error {},
+}));
+
+vi.mock('../../relay.js', () => ({
+  AgentRelay: vi.fn(),
+}));
+
+const { WorkflowRunner } = await import('../runner.js');
+
+describe('formatRunSummaryTable', () => {
+  it('renders all-passing steps', () => {
+    const output = formatRunSummaryTable(
+      [
+        { name: 'plan', agent: 'lead', status: 'completed', attempts: 1, durationMs: 1_000 },
+        { name: 'implement', agent: 'worker', status: 'completed', attempts: 1, durationMs: 2_000 },
+      ],
+      new Map([
+        [
+          'plan',
+          {
+            cli: 'claude',
+            sessionId: 's1',
+            model: 'claude-sonnet-4',
+            provider: 'anthropic',
+            durationMs: 1_200,
+            cost: 0.75,
+            tokens: { input: 100, output: 50, cacheRead: 10 },
+            turns: 2,
+            toolCalls: [],
+            errors: [],
+            finalStatus: 'completed',
+            summary: 'planned',
+          },
+        ],
+        [
+          'implement',
+          {
+            cli: 'codex',
+            sessionId: 's2',
+            model: 'gpt-5',
+            provider: 'openai',
+            durationMs: 3_400,
+            cost: 1.25,
+            tokens: { input: 300, output: 90, cacheRead: 20 },
+            turns: 4,
+            toolCalls: [],
+            errors: [{ turn: 2, text: 'Error: recovered after retry' }],
+            finalStatus: 'completed',
+            summary: 'implemented',
+          },
+        ],
+      ]),
+    );
+
+    expect(output).toMatchInlineSnapshot(`
+      "  Step                  Status  Model                 Cost      Tokens    Duration      Errors
+        plan                  pass    claude-sonnet-4      $0.75         160          1s          --
+        implement             pass    gpt-5                $1.25         410          3s   1 (fixed)
+        ────────────────────────────────────────────────────────────────────────────────────────────
+        Total                                              $2.00         570          5s            "
+    `);
+  });
+
+  it('renders a failed step with the first error line', () => {
+    const output = formatRunSummaryTable(
+      [{ name: 'broken-step', agent: 'worker', status: 'failed', attempts: 1, durationMs: 1_500, error: 'boom' }],
+      new Map([
+        [
+          'broken-step',
+          {
+            cli: 'opencode',
+            sessionId: 's3',
+            model: 'gpt-5',
+            provider: 'openai',
+            durationMs: 1_500,
+            cost: 0.01,
+            tokens: { input: 10, output: 5, cacheRead: 0 },
+            turns: 1,
+            toolCalls: [],
+            errors: [{ turn: 1, text: 'Error: database locked' }],
+            finalStatus: 'failed',
+            summary: null,
+          },
+        ],
+      ]),
+    );
+
+    expect(output).toContain('broken-step           FAIL');
+    expect(output).toContain('  └─ Error [turn 1] Error: database locked');
+  });
+
+  it('renders deterministic steps without reports using placeholder columns', () => {
+    const output = formatRunSummaryTable(
+      [{ name: 'lint', agent: 'shell', status: 'completed', attempts: 1, durationMs: 900 }],
+      new Map(),
+    );
+
+    expect(output).toContain('lint                  pass    --');
+    expect(output).toContain('--');
+    // No reports means no cost column
+    expect(output).not.toContain('Cost');
+  });
+
+  it('hides Cost column when no report has reliable cost data', () => {
+    const output = formatRunSummaryTable(
+      [
+        { name: 'gen-code', agent: 'worker', status: 'completed', attempts: 1, durationMs: 5_000 },
+      ],
+      new Map([
+        [
+          'gen-code',
+          {
+            cli: 'claude',
+            sessionId: 's1',
+            model: 'claude-sonnet-4',
+            provider: 'anthropic',
+            durationMs: 5_000,
+            cost: null,
+            tokens: { input: 200, output: 80, cacheRead: 0 },
+            turns: 3,
+            toolCalls: [],
+            errors: [],
+            finalStatus: 'completed',
+            summary: 'done',
+          },
+        ],
+      ]),
+    );
+
+    expect(output).not.toContain('Cost');
+    expect(output).toContain('Tokens');
+    expect(output).toContain('280');
+  });
+});
+
+describe('WorkflowRunner logRunSummary', () => {
+  it('falls back to the legacy summary format when no reports exist', () => {
+    const runner = new WorkflowRunner({ cwd: '/tmp/workflow-runner' });
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    (runner as any).logRunSummary(
+      'sample-workflow',
+      [{ name: 'lint', agent: 'shell', status: 'completed', attempts: 1, output: 'ok' }],
+      'run-1',
+    );
+
+    const combined = logSpy.mock.calls.flat().join('\n');
+    expect(combined).toContain('Workflow "sample-workflow"');
+    expect(combined).toContain('✓ lint [shell]');
+    expect(combined).not.toContain('Step                  Status');
+
+    logSpy.mockRestore();
+  });
+});

package/packages/sdk/src/workflows/__tests__/step-cwd.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect, vi } from 'vitest';
+import path from 'node:path';
+
+vi.mock('@relaycast/sdk', () => ({
+  RelayCast: vi.fn(),
+  RelayError: class RelayError extends Error {},
+}));
+
+vi.mock('../../relay.js', () => ({
+  AgentRelay: vi.fn(),
+}));
+
+const { WorkflowRunner } = await import('../runner.js');
+
+describe('WorkflowRunner step cwd resolution', () => {
+  it('prefers step.cwd over agent.cwd and runner cwd', () => {
+    const runnerRoot = '/runner-root';
+    const runner = new WorkflowRunner({ cwd: runnerRoot });
+
+    const resolved = (runner as any).resolveEffectiveCwd(
+      { name: 'generate', agent: 'worker', task: 'Generate', cwd: 'steps/generate' },
+      { name: 'worker', cli: 'claude', cwd: 'agents/worker' },
+    );
+
+    expect(resolved).toBe(path.resolve(runnerRoot, 'steps/generate'));
+  });
+
+  it('respects step.cwd for deterministic steps', () => {
+    const runnerRoot = '/runner-root';
+    const runner = new WorkflowRunner({ cwd: runnerRoot });
+
+    const resolved = (runner as any).resolveEffectiveCwd({
+      name: 'scaffold',
+      type: 'deterministic',
+      command: 'mkdir -p out',
+      cwd: 'deterministic/setup',
+    });
+
+    expect(resolved).toBe(path.resolve(runnerRoot, 'deterministic/setup'));
+  });
+
+  it('falls back through step.cwd to step.workdir to agent.cwd to runner.cwd', () => {
+    const runnerRoot = '/runner-root';
+    const namedPath = '/named/workdir';
+    const runner = new WorkflowRunner({ cwd: runnerRoot });
+    (runner as any).resolvedPaths.set('generated', namedPath);
+
+    const agentDef = { name: 'worker', cli: 'claude', cwd: 'agents/worker' } as const;
+
+    expect(
+      (runner as any).resolveEffectiveCwd(
+        { name: 's1', agent: 'worker', task: 'Do work', cwd: 'steps/explicit', workdir: 'generated' },
+        agentDef,
+      ),
+    ).toBe(path.resolve(runnerRoot, 'steps/explicit'));
+
+    expect(
+      (runner as any).resolveEffectiveCwd(
+        { name: 's2', agent: 'worker', task: 'Do work', workdir: 'generated' },
+        agentDef,
+      ),
+    ).toBe(namedPath);
+
+    expect(
+      (runner as any).resolveEffectiveCwd({ name: 's3', agent: 'worker', task: 'Do work' }, agentDef),
+    ).toBe(path.resolve(runnerRoot, 'agents/worker'));
+
+    expect(
+      (runner as any).resolveEffectiveCwd({ name: 's4', type: 'deterministic', command: 'pwd' }),
+    ).toBe(runnerRoot);
+  });
+});

package/packages/sdk/src/workflows/builder.ts

@@ -22,6 +22,7 @@ import type {
 } from './types.js';
 import { WorkflowRunner, type WorkflowEventListener, type VariableContext, type StepExecutor } from './runner.js';
 import { formatDryRunReport } from './dry-run-format.js';
+import { createDefaultEventLogger, type LogLevel } from './default-logger.js';
 
 // ── Option types for the builder API ────────────────────────────────────────
 
@@ -47,6 +48,7 @@ export interface AgentOptions {
 export interface AgentStepOptions {
   agent: string;
   task: string;
+  cwd?: string;
   dependsOn?: string[];
   verification?: VerificationCheck;
   timeoutMs?: number;
@@ -57,6 +59,7 @@ export interface AgentStepOptions {
 export interface DeterministicStepOptions {
   type: 'deterministic';
   command: string;
+  cwd?: string;
   /** Capture stdout as step output for downstream steps. Default: true. */
   captureOutput?: boolean;
   /** Fail if command exit code is non-zero. Default: true. */
@@ -104,6 +107,10 @@ export interface WorkflowRunOptions {
   startFrom?: string;
   /** Previous run ID whose cached outputs are used with startFrom. */
   previousRunId?: string;
+  /** Console log verbosity: "verbose" | "normal" (default) | "quiet" | false (silent). */
+  logLevel?: LogLevel;
+  /** Renderer: "listr" for listr2 UI, "default" for console logger, false to disable. */
+  renderer?: 'listr' | 'default' | false;
 }
 
 // ── WorkflowBuilder ─────────────────────────────────────────────────────────
@@ -256,6 +263,7 @@ export class WorkflowBuilder {
       }
       step.type = 'deterministic';
       step.command = options.command;
+      if (options.cwd !== undefined) step.cwd = options.cwd;
       if (options.captureOutput !== undefined) step.captureOutput = options.captureOutput;
       if (options.failOnError !== undefined) step.failOnError = options.failOnError;
       if (options.dependsOn !== undefined) step.dependsOn = options.dependsOn;
@@ -280,6 +288,7 @@ export class WorkflowBuilder {
       }
       step.agent = agentOpts.agent;
       step.task = agentOpts.task;
+      if (agentOpts.cwd !== undefined) step.cwd = agentOpts.cwd;
       if (agentOpts.dependsOn !== undefined) step.dependsOn = agentOpts.dependsOn;
       if (agentOpts.verification !== undefined) step.verification = agentOpts.verification;
       if (agentOpts.timeoutMs !== undefined) step.timeoutMs = agentOpts.timeoutMs;
@@ -329,7 +338,11 @@ export class WorkflowBuilder {
     if (this._timeoutMs !== undefined) config.swarm.timeoutMs = this._timeoutMs;
     if (this._channel !== undefined) config.swarm.channel = this._channel;
     if (this._idleNudge !== undefined) config.swarm.idleNudge = this._idleNudge;
-    if (this._errorHandling !== undefined) config.errorHandling = this._errorHandling;
+    config.errorHandling = this._errorHandling ?? {
+      strategy: 'retry',
+      maxRetries: 2,
+      retryDelayMs: 10_000,
+    };
     if (this._coordination !== undefined) config.coordination = this._coordination;
     if (this._state !== undefined) config.state = this._state;
     if (this._trajectories !== undefined) config.trajectories = this._trajectories;
@@ -363,15 +376,23 @@ export class WorkflowBuilder {
       return report;
     }
 
+    // Wire up default console logger unless explicitly disabled
+    // renderer: "listr" owns the terminal — skip console logger to avoid garbled output
+    // renderer: false implies no output at all
+    const logLevel = options.renderer === 'listr' || options.renderer === false
+      ? false
+      : (options.logLevel ?? 'normal');
+    if (logLevel !== false) {
+      runner.on(createDefaultEventLogger(logLevel));
+    }
+
+    // Wire up user-provided event handler (additive — does not replace the default logger)
     if (options.onEvent) {
       runner.on(options.onEvent);
     }
 
     // Auto-detect RESUME_RUN_ID env var for resuming failed runs
     const resumeRunId = process.env.RESUME_RUN_ID;
-    if (resumeRunId) {
-      return runner.resume(resumeRunId, options.vars);
-    }
 
     const startFrom = this._startFrom ?? options.startFrom ?? process.env.START_FROM;
     const previousRunId = this._previousRunId ?? options.previousRunId ?? process.env.PREVIOUS_RUN_ID;
@@ -379,6 +400,29 @@ export class WorkflowBuilder {
       ? { startFrom, previousRunId }
       : undefined;
 
+    // If listr renderer requested, wire it up and run concurrently
+    // Must be set up BEFORE the resume check so resume runs also get event output
+    if (options.renderer === 'listr') {
+      const { createWorkflowRenderer } = await import('./listr-renderer.js');
+      const renderer = createWorkflowRenderer();
+      runner.on(renderer.onEvent);
+
+      const runPromise = resumeRunId
+        ? runner.resume(resumeRunId, options.vars)
+        : runner.execute(config, options.workflow, options.vars, executeOptions);
+
+      try {
+        const [result] = await Promise.all([runPromise, renderer.start()]);
+        return result;
+      } finally {
+        renderer.unmount();
+      }
+    }
+
+    if (resumeRunId) {
+      return runner.resume(resumeRunId, options.vars);
+    }
+
     return runner.execute(config, options.workflow, options.vars, executeOptions);
   }
 }

package/packages/sdk/src/workflows/cli-session-collector.ts

@@ -0,0 +1,58 @@
+import type { AgentCli } from './types.js';
+import { ClaudeCodeCollector } from './collectors/claude.js';
+import { CodexCollector } from './collectors/codex.js';
+import { OpenCodeCollector } from './collectors/opencode.js';
+
+export interface CliSessionReport {
+  cli: AgentCli;
+  sessionId: string | null;
+  model: string | null;
+  provider: string | null;
+  durationMs: number | null;
+  cost: number | null;
+  tokens: {
+    input: number;
+    output: number;
+    cacheRead: number;
+  } | null;
+  turns: number;
+  toolCalls: { name: string; count: number }[];
+  errors: { turn: number; text: string }[];
+  finalStatus: 'completed' | 'failed' | 'unknown';
+  summary: string | null;
+  raw?: object;
+}
+
+export interface CliSessionQuery {
+  cli: AgentCli;
+  cwd: string;
+  startedAt: number;
+  completedAt: number;
+}
+
+export interface CliSessionCollector {
+  canCollect(): boolean;
+  collect(query: CliSessionQuery): Promise<CliSessionReport | null>;
+}
+
+export function createCollector(cli: AgentCli): CliSessionCollector | null {
+  switch (cli) {
+    case 'opencode':
+      return new OpenCodeCollector();
+    case 'claude':
+      return new ClaudeCodeCollector();
+    case 'codex':
+      return new CodexCollector();
+    default:
+      return null;
+  }
+}
+
+export async function collectCliSession(query: CliSessionQuery): Promise<CliSessionReport | null> {
+  const collector = createCollector(query.cli);
+  if (!collector || !collector.canCollect()) {
+    return null;
+  }
+
+  return collector.collect(query);
+}