@just-every/manager 0.2.0

package/src/connectors/gemini.ts

@@ -0,0 +1,106 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { SessionStore } from '../storage/session-store.js';
+import { SessionStatus } from '../constants.js';
+
+export interface GeminiLaunchRequest {
+  command?: string;
+  args?: string[];
+  autoRestart?: boolean;
+  maxRestarts?: number;
+}
+
+export interface GeminiLaunchResponse {
+  localSessionId: string;
+  toolSessionId: string;
+  command: string;
+  args: string[];
+}
+
+type ProcessState = {
+  command: string;
+  args: string[];
+  env: NodeJS.ProcessEnv;
+  autoRestart: boolean;
+  maxRestarts: number;
+  restarts: number;
+  child?: ReturnType<typeof spawn>;
+};
+
+export class GeminiConnector {
+  #store: SessionStore;
+  #sessions = new Map<string, ProcessState>();
+
+  constructor(store: SessionStore) {
+    this.#store = store;
+  }
+
+  async launch(request: GeminiLaunchRequest = {}): Promise<GeminiLaunchResponse> {
+    const command = request.command ?? process.env.MANAGER_GEMINI_COMMAND ?? 'gemini';
+    const args = request.args ?? [];
+    const session = this.#store.createSession('gemini', command, args);
+    const sessionLogDir = process.env.MANAGER_GEMINI_LOG_DIR ?? path.join(process.env.HOME || '', '.gemini', 'sessions');
+    await fs.mkdir(sessionLogDir, { recursive: true });
+    const env = {
+      ...process.env,
+      MANAGER_SESSION_ID: session.id,
+      MANAGER_GEMINI_SESSION_ID: session.toolSessionId,
+      GEMINI_SESSION_LOG: path.join(sessionLogDir, `${session.toolSessionId}.jsonl`),
+    };
+    const state: ProcessState = {
+      command,
+      args,
+      env,
+      autoRestart: request.autoRestart !== false,
+      maxRestarts: request.maxRestarts ?? 3,
+      restarts: 0,
+    };
+    this.#sessions.set(session.id, state);
+    this.spawnProcess(session.id, state);
+
+    return {
+      localSessionId: session.id,
+      toolSessionId: session.toolSessionId,
+      command,
+      args,
+    };
+  }
+
+  private spawnProcess(sessionId: string, state: ProcessState) {
+    const child = spawn(state.command, state.args, {
+      env: state.env,
+      stdio: 'ignore',
+    });
+    state.child = child;
+    this.#store.updateStatus(sessionId, SessionStatus.Running);
+
+    child.once('exit', (code) => this.handleExit(sessionId, state, code));
+    child.once('error', (err) => {
+      console.error('[gemini] failed to launch', err);
+      this.handleExit(sessionId, state, -1);
+    });
+  }
+
+  private handleExit(sessionId: string, state: ProcessState, code: number | null) {
+    const exitCode = code ?? -1;
+    const successful = exitCode === 0;
+    this.#store.updateStatus(sessionId, successful ? SessionStatus.Completed : SessionStatus.Failed, exitCode);
+    if (state.autoRestart && !successful && state.restarts < state.maxRestarts) {
+      state.restarts += 1;
+      const delay = Math.min(1000 * state.restarts, 5000);
+      setTimeout(() => {
+        console.warn(`[gemini] restarting session ${sessionId} attempt ${state.restarts}`);
+        this.spawnProcess(sessionId, state);
+      }, delay);
+      return;
+    }
+    this.#sessions.delete(sessionId);
+  }
+}
+
+export function describeGeminiConnector(): string {
+  const command = process.env.MANAGER_GEMINI_COMMAND ?? 'gemini';
+  const logDir = process.env.MANAGER_GEMINI_LOG_DIR ?? path.join(process.env.HOME || '', '.gemini', 'sessions');
+  return `command=${command} logDir=${logDir}`;
+}

package/src/constants.ts

@@ -0,0 +1,32 @@
+import os from 'node:os';
+import path from 'node:path';
+
+export const DEFAULT_HOST = '127.0.0.1';
+export const DEFAULT_PORT = Number(process.env.MANAGERD_PORT ?? 7765);
+
+export const MANAGERD_HOME = (() => {
+  if (process.env.MANAGERD_HOME) {
+    return path.resolve(process.env.MANAGERD_HOME);
+  }
+  return path.join(os.homedir(), '.managerd');
+})();
+
+export const DATA_DIRS = {
+  root: MANAGERD_HOME,
+  logs: path.join(MANAGERD_HOME, 'logs'),
+  sessions: path.join(MANAGERD_HOME, 'sessions'),
+};
+
+export const DB_PATH = path.join(MANAGERD_HOME, 'state.db');
+export const PID_FILE = path.join(MANAGERD_HOME, 'managerd.pid');
+export const DEFAULT_CODEX_HISTORY = path.join(os.homedir(), '.codex', 'sessions');
+export const DEFAULT_CODEX_TRANSCRIPT = 'output.json';
+
+export enum SessionStatus {
+  Launching = 'launching',
+  Running = 'running',
+  Failed = 'failed',
+  Completed = 'completed',
+}
+
+export type AgentType = 'codex' | 'claude' | 'gemini';

package/src/daemon/http-server.ts

@@ -0,0 +1,234 @@
+import http, { IncomingMessage, ServerResponse } from 'node:http';
+import { URL } from 'node:url';
+import { DEFAULT_HOST, DEFAULT_PORT, SessionStatus } from '../constants.js';
+import { SessionStore, createSessionStore } from '../storage/session-store.js';
+import { CodexConnector, describeCodexConnector } from '../connectors/codex.js';
+import { GeminiConnector, describeGeminiConnector } from '../connectors/gemini.js';
+import { EventStore, createEventStore } from '../storage/event-store.js';
+import { CodexIngestor } from '../ingestion/codex-ingestor.js';
+import { ClaudeIngestor, ClaudeHookEvent } from '../ingestion/claude-ingestor.js';
+import { GeminiIngestor, GeminiSessionPayload } from '../ingestion/gemini-ingestor.js';
+import { GeminiLogWatcher } from '../watchers/gemini-log-watcher.js';
+import { logger } from '../utils/logger.js';
+
+export interface ManagerDaemonOptions {
+  host?: string;
+  port?: number;
+}
+
+export class ManagerDaemon {
+  #store: SessionStore;
+  #codex: CodexConnector;
+  #gemini: GeminiConnector;
+  #events: EventStore;
+  #codexIngestor: CodexIngestor;
+  #claudeIngestor: ClaudeIngestor;
+  #geminiIngestor: GeminiIngestor;
+  #geminiWatcher: GeminiLogWatcher;
+  #server?: http.Server;
+  #startedAt = Date.now();
+  #host: string;
+  #port: number;
+
+  constructor(store: SessionStore = createSessionStore(), options: ManagerDaemonOptions = {}) {
+    this.#store = store;
+    this.#codex = new CodexConnector(this.#store);
+    this.#gemini = new GeminiConnector(this.#store);
+    this.#events = createEventStore();
+    this.#codexIngestor = new CodexIngestor(this.#events);
+    this.#claudeIngestor = new ClaudeIngestor(this.#store, this.#events);
+    this.#geminiIngestor = new GeminiIngestor(this.#events);
+    this.#geminiWatcher = new GeminiLogWatcher(this.#store, this.#geminiIngestor);
+    this.#host = options.host ?? DEFAULT_HOST;
+    this.#port = options.port ?? DEFAULT_PORT;
+  }
+
+  async start(): Promise<void> {
+    if (this.#server) return;
+    this.#server = http.createServer((req, res) => {
+      this.route(req, res).catch((err) => {
+        logger.error({ err }, 'unhandled daemon error');
+        this.writeJson(res, 500, { ok: false, error: 'internal_error' });
+      });
+    });
+
+    await new Promise<void>((resolve) => {
+      this.#server!.listen(this.#port, this.#host, () => {
+        logger.info({ host: this.#host, port: this.#port }, 'managerd listening');
+        resolve();
+      });
+    });
+    this.#geminiWatcher.start();
+  }
+
+  async stop(): Promise<void> {
+    this.#geminiWatcher.stop();
+    if (!this.#server) return;
+    await new Promise<void>((resolve, reject) => {
+      this.#server!.close((err) => (err ? reject(err) : resolve()));
+    });
+    this.#server = undefined;
+  }
+
+  private async route(req: IncomingMessage, res: ServerResponse) {
+    const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+
+    if (req.method === 'GET' && url.pathname === '/healthz') {
+      return this.writeJson(res, 200, { ok: true });
+    }
+
+    if (req.method === 'GET' && url.pathname === '/status') {
+      const sessions = this.#store.listRecent(5);
+      return this.writeJson(res, 200, {
+        ok: true,
+        uptimeMs: Date.now() - this.#startedAt,
+        codex: describeCodexConnector(),
+        gemini: describeGeminiConnector(),
+        runningSessions: sessions.filter((s) => s.status === SessionStatus.Running).length,
+        sessions,
+      });
+    }
+
+    if (req.method === 'GET' && url.pathname === '/sessions') {
+      return this.writeJson(res, 200, { ok: true, sessions: this.#store.listRecent(25) });
+    }
+
+    if (req.method === 'POST' && url.pathname === '/rpc/launch') {
+      const body = await this.parseJson(req);
+      const agent = body?.agent ?? 'codex';
+      if (agent === 'codex') {
+        const result = await this.#codex.launch({
+          command: body?.command,
+          args: body?.args,
+          disableManagedFlags: body?.disableManagedFlags,
+          autoRestart: body?.autoRestart !== false,
+          maxRestarts: body?.maxRestarts ?? 3,
+        });
+        return this.writeJson(res, 200, { ok: true, result });
+      }
+      if (agent === 'gemini') {
+        const result = await this.#gemini.launch({
+          command: body?.command,
+          args: body?.args,
+          autoRestart: body?.autoRestart !== false,
+          maxRestarts: body?.maxRestarts ?? 3,
+        });
+        return this.writeJson(res, 200, { ok: true, result });
+      }
+      return this.writeJson(res, 400, { ok: false, error: 'unsupported_agent' });
+    }
+
+    if (req.method === 'POST' && url.pathname === '/hooks/claude') {
+      return this.handleClaudeHook(req, res);
+    }
+
+    if (req.method === 'POST' && url.pathname === '/rpc/gemini/ingest') {
+      return this.handleGeminiIngest(req, res);
+    }
+
+    if (req.method === 'POST' && url.pathname === '/rpc/sessions/events') {
+      const body = await this.parseJson(req);
+      const sessionId = body?.sessionId;
+      const limit = Number(body?.limit ?? 20);
+      if (!sessionId) {
+        return this.writeJson(res, 400, { ok: false, error: 'missing_session_id' });
+      }
+      const session = this.#store.get(sessionId);
+      if (!session) {
+        return this.writeJson(res, 404, { ok: false, error: 'session_not_found' });
+      }
+      let warnings: string[] = [];
+      try {
+        const result = await this.#codexIngestor.ingest(session);
+        warnings = result.warnings;
+      } catch (err: any) {
+        warnings.push(`Ingestion failed: ${err.message}`);
+      }
+      const events = this.#events.listBySession(sessionId, limit);
+      return this.writeJson(res, 200, { ok: true, session, events, warnings });
+    }
+
+    this.writeJson(res, 404, { ok: false, error: 'not_found' });
+  }
+
+  private async handleClaudeHook(_req: IncomingMessage, res: ServerResponse) {
+    const body = await this.parseJson(_req);
+    const incoming = Array.isArray(body?.events) ? body.events : [body];
+    if (!incoming.length) {
+      return this.writeJson(res, 400, { ok: false, error: 'no_events' });
+    }
+
+    const results = incoming.map((raw) => {
+      if (!raw || typeof raw !== 'object') {
+        return { ok: false, error: 'invalid_event' };
+      }
+      const eventName = raw.event ?? raw.type;
+      const sessionId = raw.sessionId ?? raw.session_id;
+      if (!eventName || !sessionId) {
+        return { ok: false, error: 'missing_fields', sessionId };
+      }
+      const hookEvent: ClaudeHookEvent = {
+        event: String(eventName),
+        sessionId: String(sessionId),
+        timestamp: raw.timestamp,
+        payload: raw.payload ?? raw.data ?? raw,
+      };
+      try {
+        const result = this.#claudeIngestor.ingest(hookEvent);
+        return { ok: true, sessionId: hookEvent.sessionId, inserted: result.inserted };
+      } catch (err: any) {
+        logger.error({ err }, 'claude hook ingestion failed');
+        return { ok: false, sessionId: hookEvent.sessionId, error: err?.message ?? 'ingest_failed' };
+      }
+    });
+
+    const ok = results.every((item) => item.ok);
+    return this.writeJson(res, ok ? 202 : 207, { ok, results });
+  }
+
+  private async handleGeminiIngest(req: IncomingMessage, res: ServerResponse) {
+    const body = await this.parseJson(req);
+    const data: GeminiSessionPayload | undefined = body?.data;
+    const fileHint: string | undefined = body?.filePath;
+    if (!data || typeof data !== 'object') {
+      return this.writeJson(res, 400, { ok: false, error: 'missing_payload' });
+    }
+    const providedId = body?.sessionId ?? data.sessionId ?? data['id'];
+    const sessionId = (providedId || fileHint || `gemini-${Date.now()}`).toString();
+    let session = this.#store.findByToolSession('gemini', sessionId);
+    if (!session) {
+      session = this.#store.createSession('gemini', 'gemini-cli', [], { toolSessionId: sessionId });
+    }
+    try {
+      const result = this.#geminiIngestor.ingest(session, data);
+      return this.writeJson(res, 200, { ok: true, inserted: result.inserted, warnings: result.warnings });
+    } catch (err: any) {
+      logger.error({ err }, 'gemini ingest failed');
+      return this.writeJson(res, 500, { ok: false, error: err?.message ?? 'ingest_failed' });
+    }
+  }
+
+  private async parseJson(req: IncomingMessage): Promise<any> {
+    const chunks: Buffer[] = [];
+    for await (const chunk of req) {
+      chunks.push(chunk as Buffer);
+    }
+    const raw = Buffer.concat(chunks).toString('utf8');
+    if (!raw) return {};
+    try {
+      return JSON.parse(raw);
+    } catch (err) {
+      logger.warn({ err }, 'failed to parse json');
+      return {};
+    }
+  }
+
+  private writeJson(res: ServerResponse, status: number, payload: any) {
+    const body = JSON.stringify(payload);
+    res.writeHead(status, {
+      'content-type': 'application/json',
+      'content-length': Buffer.byteLength(body),
+    });
+    res.end(body);
+  }
+}

package/src/daemon/index.ts

@@ -0,0 +1,61 @@
+import process from 'node:process';
+import fs from 'node:fs/promises';
+import { ManagerDaemon } from './http-server.js';
+import { ensureBaseDirs } from '../storage/session-store.js';
+import { DATA_DIRS, PID_FILE } from '../constants.js';
+import { logger } from '../utils/logger.js';
+
+export async function startDaemon() {
+  await ensureBaseDirs(DATA_DIRS.root);
+  await ensurePidAvailable();
+  const daemon = new ManagerDaemon();
+  let cleanedUp = false;
+  const cleanup = async () => {
+    if (cleanedUp) return;
+    cleanedUp = true;
+    await daemon.stop().catch(() => {});
+    await removePidFile();
+  };
+  process.on('SIGINT', async () => {
+    logger.info('received SIGINT, shutting down');
+    await cleanup();
+    process.exit(0);
+  });
+  process.on('SIGTERM', async () => {
+    logger.info('received SIGTERM, shutting down');
+    await cleanup();
+    process.exit(0);
+  });
+  process.on('exit', () => {
+    void cleanup();
+  });
+  await daemon.start();
+  await fs.writeFile(PID_FILE, String(process.pid), 'utf8');
+  logger.info('managerd is running. Press Ctrl+C to exit.');
+}
+
+async function ensurePidAvailable() {
+  try {
+    const contents = await fs.readFile(PID_FILE, 'utf8');
+    const pid = Number(contents.trim());
+    if (Number.isFinite(pid) && isProcessAlive(pid)) {
+      throw new Error(`managerd already running (pid ${pid})`);
+    }
+    await removePidFile();
+  } catch {
+    // no-op
+  }
+}
+
+async function removePidFile() {
+  await fs.unlink(PID_FILE).catch(() => {});
+}
+
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/ingestion/claude-ingestor.ts

@@ -0,0 +1,170 @@
+import { SessionRecord, SessionStore } from '../storage/session-store.js';
+import { EventStore, AgentEventRecord } from '../storage/event-store.js';
+import { SessionStatus } from '../constants.js';
+
+export interface ClaudeHookEvent {
+  event: string;
+  sessionId: string;
+  timestamp?: string;
+  payload?: Record<string, any>;
+}
+
+export interface ClaudeIngestResult {
+  inserted: number;
+}
+
+export class ClaudeIngestor {
+  constructor(private store: SessionStore, private events: EventStore) {}
+
+  ensureSession(sessionId: string): SessionRecord {
+    const existing = this.store.findByToolSession('claude', sessionId);
+    if (existing) {
+      return existing;
+    }
+    return this.store.createSession('claude', 'claude-code', [], { toolSessionId: sessionId });
+  }
+
+  ingest(hook: ClaudeHookEvent): ClaudeIngestResult {
+    const session = this.ensureSession(hook.sessionId);
+    const timestamp = parseTimestamp(hook.timestamp);
+    const baseSequence = this.events.maxSequence(session.id);
+    const record = mapClaudeHookToEvent(session.id, baseSequence + 1, hook, timestamp);
+    if (!record) {
+      return { inserted: 0 };
+    }
+    this.events.insert([record]);
+    if (record.eventType === 'session_start') {
+      this.store.updateStatus(session.id, SessionStatus.Running);
+    }
+    if (record.eventType === 'session_end') {
+      this.store.updateStatus(session.id, SessionStatus.Completed);
+    }
+    return { inserted: 1 };
+  }
+}
+
+function parseTimestamp(value?: string): number {
+  if (!value) return Date.now();
+  const ms = Date.parse(value);
+  return Number.isNaN(ms) ? Date.now() : ms;
+}
+
+function mapClaudeHookToEvent(
+  sessionId: string,
+  sequence: number,
+  hook: ClaudeHookEvent,
+  timestamp: number,
+): AgentEventRecord | null {
+  const payload = hook.payload ?? {};
+  const type = (hook.event || '').toLowerCase();
+  switch (type) {
+    case 'sessionstart':
+      return {
+        id: buildEventId(sessionId, sequence),
+        sessionId,
+        eventType: 'session_start',
+        sequence,
+        timestamp,
+        role: 'system',
+        text: payload.summary ?? null,
+        rawPayload: JSON.stringify(hook),
+        sourceFile: 'claude-hook',
+      };
+    case 'sessionend':
+      return {
+        id: buildEventId(sessionId, sequence),
+        sessionId,
+        eventType: 'session_end',
+        sequence,
+        timestamp,
+        role: 'system',
+        text: payload.summary ?? 'Session ended',
+        rawPayload: JSON.stringify(hook),
+        sourceFile: 'claude-hook',
+      };
+    case 'userpromptsubmit':
+    case 'userprompt':
+      return {
+        id: buildEventId(sessionId, sequence),
+        sessionId,
+        eventType: 'user_prompt',
+        sequence,
+        timestamp,
+        role: 'user',
+        text: payload.prompt ?? payload.text ?? '',
+        rawPayload: JSON.stringify(hook),
+        sourceFile: 'claude-hook',
+      };
+    case 'pretooluse':
+      return {
+        id: buildEventId(sessionId, sequence),
+        sessionId,
+        eventType: 'tool_use',
+        sequence,
+        timestamp,
+        role: 'assistant',
+        text: payload.commentary ?? null,
+        toolName: payload.toolName ?? payload.tool?.name ?? 'unknown_tool',
+        toolInput: safeStringify(payload.input ?? payload.toolInput),
+        rawPayload: JSON.stringify(hook),
+        sourceFile: 'claude-hook',
+      };
+    case 'posttooluse':
+      return {
+        id: buildEventId(sessionId, sequence),
+        sessionId,
+        eventType: 'tool_result',
+        sequence,
+        timestamp,
+        role: 'assistant',
+        text: payload.commentary ?? null,
+        toolName: payload.toolName ?? payload.tool?.name ?? 'unknown_tool',
+        toolOutput: safeStringify(payload.result ?? payload.toolOutput ?? payload.output),
+        errorType: payload.error?.type ?? null,
+        errorMessage: payload.error?.message ?? null,
+        rawPayload: JSON.stringify(hook),
+        sourceFile: 'claude-hook',
+      };
+    case 'permissionrequest':
+      return {
+        id: buildEventId(sessionId, sequence),
+        sessionId,
+        eventType: 'permission_request',
+        sequence,
+        timestamp,
+        role: 'assistant',
+        text: payload.reason ?? payload.prompt ?? 'Permission requested',
+        toolInput: safeStringify(payload.details),
+        rawPayload: JSON.stringify(hook),
+        sourceFile: 'claude-hook',
+      };
+    case 'notification':
+      return {
+        id: buildEventId(sessionId, sequence),
+        sessionId,
+        eventType: 'notification',
+        sequence,
+        timestamp,
+        role: 'system',
+        text: payload.message ?? payload.text ?? 'Notification',
+        errorType: payload.severity ?? null,
+        rawPayload: JSON.stringify(hook),
+        sourceFile: 'claude-hook',
+      };
+    default:
+      return null;
+  }
+}
+
+function buildEventId(sessionId: string, sequence: number): string {
+  return `${sessionId}:claude:${sequence}`;
+}
+
+function safeStringify(input: unknown): string | null {
+  if (input == null) return null;
+  try {
+    return JSON.stringify(input);
+  } catch {
+    return String(input);
+  }
+}

package/src/ingestion/codex-ingestor.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it, beforeEach, afterEach } from 'vitest';
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { CodexIngestor } from './codex-ingestor.js';
+import { createEventStore } from '../storage/event-store.js';
+import { SessionRecord } from '../storage/session-store.js';
+import { SessionStatus } from '../constants.js';
+
+describe('CodexIngestor', () => {
+  let tmpDir: string;
+  let store: ReturnType<typeof createEventStore>;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'codex-history-'));
+    process.env.MANAGER_CODEX_HISTORY = tmpDir;
+    process.env.MANAGERD_STORAGE = 'memory';
+    store = createEventStore();
+  });
+
+  afterEach(async () => {
+    delete process.env.MANAGER_CODEX_HISTORY;
+    delete process.env.MANAGERD_STORAGE;
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  const baseSession: SessionRecord = {
+    id: 'session-local',
+    agentType: 'codex',
+    toolSessionId: 'tool-session',
+    status: SessionStatus.Running,
+    command: 'codex',
+    args: [],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    exitCode: null,
+  };
+
+  it('ingests simple text messages from output.json', async () => {
+    const sessionDir = path.join(tmpDir, baseSession.toolSessionId);
+    await fs.mkdir(sessionDir, { recursive: true });
+    await fs.writeFile(
+      path.join(sessionDir, 'output.json'),
+      JSON.stringify({
+        messages: [
+          { role: 'user', content: 'hello' },
+          { role: 'assistant', content: 'hi there' },
+        ],
+      }),
+    );
+
+    const ingestor = new CodexIngestor(store);
+    const result = await ingestor.ingest(baseSession);
+
+    expect(result.events).toBe(2);
+    const events = store.listBySession(baseSession.id, 10);
+    expect(events).toHaveLength(2);
+    expect(events[1].eventType).toBe('message');
+    expect(events[1].text).toBe('hello');
+    expect(events[0].text).toBe('hi there');
+  });
+
+  it('ingests structured tool use blocks', async () => {
+    const sessionDir = path.join(tmpDir, baseSession.toolSessionId);
+    await fs.mkdir(sessionDir, { recursive: true });
+    await fs.writeFile(
+      path.join(sessionDir, 'output.json'),
+      JSON.stringify({
+        messages: [
+          {
+            role: 'assistant',
+            content: [
+              { type: 'text', text: 'running command' },
+              { type: 'tool_use', name: 'run_cmd', input: { cmd: 'ls' } },
+              { type: 'tool_result', content: { stdout: 'README.md' } },
+            ],
+          },
+        ],
+      }),
+    );
+
+    const ingestor = new CodexIngestor(store);
+    const result = await ingestor.ingest(baseSession);
+
+    expect(result.events).toBe(3);
+    const events = store.listBySession(baseSession.id, 5);
+    expect(events.map((e) => e.eventType)).toContain('tool_use');
+    const toolUse = events.find((e) => e.eventType === 'tool_use');
+    expect(toolUse?.toolName).toBe('run_cmd');
+    expect(toolUse?.toolInput).toContain('ls');
+    const toolResult = events.find((e) => e.eventType === 'tool_result');
+    expect(toolResult?.toolOutput).toContain('README');
+  });
+});