@ai-devkit/agent-manager 0.35.0 → 0.37.0

package/src/{providers → harnesses}/claude/ClaudeSessionParser.ts

@@ -1,7 +1,14 @@
 import * as fs from "fs";
 import * as path from "path";
-import type { ConversationMessage } from "../../adapters/AgentAdapter.js";
+import type { ConversationMessage, ConversationOptions } from "../../adapters/AgentAdapter.js";
 import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import {
+  IncrementalJsonlSummary,
+  reduceJsonlContent,
+  type JsonlSummaryBounds,
+  type JsonlSummaryReducer,
+} from "../../utils/IncrementalJsonlSummary.js";
+import { JsonlTailReader, normalizeTail } from "../../utils/jsonlTail.js";
 
 /**
  * Content block within a Claude Code JSONL message entry.
@@ -51,6 +58,23 @@ export interface ClaudeSession {
   firstUserMessage?: string;
 }
 
+/**
+ * O(1) running summary folded from session entries; `toSession` turns it into
+ * a `ClaudeSession`. Timestamps are epoch ms so cached state stays immutable.
+ */
+interface ClaudeSummaryState {
+  seenFirstLine: boolean;
+  /** A bounded cold start skipped the middle: later lines are not the session's first. */
+  pastHead?: boolean;
+  sessionStartMs?: number;
+  lastActiveMs?: number;
+  lastCwd?: string;
+  lastEntryType?: string;
+  isInterrupted: boolean;
+  lastUserMessage?: string;
+  firstUserMessage?: string;
+}
+
 /**
  * Top-level JSONL entry types that represent conversation/agent state.
  *
@@ -63,6 +87,11 @@ export interface ClaudeSession {
  */
 const CONVERSATION_ENTRY_TYPES = new Set(["user", "assistant", "system", "progress", "thinking"]);
 
+export interface ClaudeSessionParserOptions {
+  /** Cold-start scan bounds for `readSessionIncremental` (see IncrementalJsonlSummary). */
+  summaryBounds?: JsonlSummaryBounds | false;
+}
+
 /**
  * Parses Claude Code session JSONL files into structured data.
  *
@@ -71,6 +100,17 @@ const CONVERSATION_ENTRY_TYPES = new Set(["user", "assistant", "system", "progre
  * event (user turn, assistant response, tool call, etc.).
  */
 export class ClaudeSessionParser {
+  /** Incremental reader backing `getConversation({ tail })`. */
+  private readonly tailReader = new JsonlTailReader();
+
+  private readonly sessionCache: IncrementalJsonlSummary<ClaudeSummaryState>;
+
+  constructor(options: ClaudeSessionParserOptions = {}) {
+    this.sessionCache = new IncrementalJsonlSummary(this.summaryReducer, {
+      bounds: options.summaryBounds,
+    });
+  }
+
   /**
    * Parse a session JSONL file into a ClaudeSession summary.
    *
@@ -81,8 +121,6 @@ export class ClaudeSessionParser {
    * Returns null if the file is unreadable or empty.
    */
   readSession(filePath: string, projectPath: string): ClaudeSession | null {
-    const sessionId = path.basename(filePath, ".jsonl");
-
     let content: string;
     try {
       content = fs.readFileSync(filePath, "utf-8");
@@ -90,74 +128,113 @@ export class ClaudeSessionParser {
       return null;
     }
 
-    const allLines = content.trim().split("\n");
-    if (allLines.length === 0) {
-      return null;
-    }
+    return this.toSession(filePath, projectPath, reduceJsonlContent(this.summaryReducer, content));
+  }
 
-    const sessionStart = this.parseSessionStart(allLines[0]);
+  /**
+   * Same result as `readSession`, but backed by a per-instance incremental
+   * cache so repeated refreshes only parse bytes appended since the last call.
+   * Call `pruneSessionCache()` once per refresh to evict files no longer read.
+   *
+   * The first read of a large transcript is a bounded head + tail scan (see
+   * `summaryReducer.skip`); fields whose entries lie only in the skipped
+   * middle fall back to their defaults instead of forcing a full parse.
+   */
+  readSessionIncremental(filePath: string, projectPath: string): ClaudeSession | null {
+    const result = this.sessionCache.read(filePath);
+    return result ? this.toSession(filePath, projectPath, result.state) : null;
+  }
 
-    let lastEntryType: string | undefined;
-    let lastActive: Date | undefined;
-    let lastCwd: string | undefined;
-    let isInterrupted = false;
-    let lastUserMessage: string | undefined;
-    let firstUserMessage: string | undefined;
+  /** Evict cached summaries for files not read since the previous prune. */
+  pruneSessionCache(): void {
+    this.sessionCache.prune();
+  }
 
-    for (const line of allLines) {
-      try {
-        const entry: SessionEntry = JSON.parse(line);
+  /**
+   * Fold one JSONL entry into the O(1) session summary. Mirrors the fields
+   * `readSession` exposes: session start comes from the first line only;
+   * everything else tracks the latest matching entry.
+   *
+   * `skip` (bounded cold start) keeps the head's session start and first user
+   * message and clears every "latest" field, so those come from the tail only:
+   * a first user message beyond the head stays undefined, and a last user
+   * message before the tail window stays undefined.
+   */
+  private readonly summaryReducer: JsonlSummaryReducer<ClaudeSummaryState> = {
+    initial: () => ({ seenFirstLine: false, isInterrupted: false }),
+    reduce: (state, value) => {
+      const next: ClaudeSummaryState = { ...state, seenFirstLine: true };
+      if (!state.seenFirstLine) {
+        next.sessionStartMs = this.parseSessionStart(value);
+      }
+      if (!value || typeof value !== "object") {
+        return next;
+      }
 
-        if (entry.timestamp) {
-          const ts = new Date(entry.timestamp);
-          if (!Number.isNaN(ts.getTime())) {
-            lastActive = ts;
-          }
+      const entry = value as SessionEntry;
+      if (entry.timestamp) {
+        const ts = new Date(entry.timestamp).getTime();
+        if (!Number.isNaN(ts)) {
+          next.lastActiveMs = ts;
         }
+      }
 
-        if (typeof entry.cwd === "string" && entry.cwd.trim().length > 0) {
-          lastCwd = entry.cwd;
-        }
+      if (typeof entry.cwd === "string" && entry.cwd.trim().length > 0) {
+        next.lastCwd = entry.cwd;
+      }
 
-        if (entry.type && CONVERSATION_ENTRY_TYPES.has(entry.type)) {
-          lastEntryType = entry.type;
-
-          if (entry.type === "user") {
-            const msgContent = entry.message?.content;
-            isInterrupted =
-              Array.isArray(msgContent) &&
-              msgContent.some(
-                (c) =>
-                  (c.type === "text" && c.text?.includes("[Request interrupted")) ||
-                  (c.type === "tool_result" && c.content?.includes("[Request interrupted")),
-              );
-
-            const text = this.extractUserMessageText(msgContent);
-            if (text) {
-              lastUserMessage = text;
-              if (!firstUserMessage) {
-                firstUserMessage = text;
-              }
+      if (entry.type && CONVERSATION_ENTRY_TYPES.has(entry.type)) {
+        next.lastEntryType = entry.type;
+
+        if (entry.type === "user") {
+          const msgContent = entry.message?.content;
+          next.isInterrupted =
+            Array.isArray(msgContent) &&
+            msgContent.some(
+              (c) =>
+                (c.type === "text" && c.text?.includes("[Request interrupted")) ||
+                (c.type === "tool_result" && c.content?.includes("[Request interrupted")),
+            );
+
+          const text = this.extractUserMessageText(msgContent);
+          if (text) {
+            next.lastUserMessage = text;
+            if (!next.firstUserMessage && !state.pastHead) {
+              next.firstUserMessage = text;
             }
-          } else {
-            isInterrupted = false;
           }
+        } else {
+          next.isInterrupted = false;
         }
-      } catch {
-        continue;
       }
-    }
 
+      return next;
+    },
+    skip: (state) => ({
+      seenFirstLine: true,
+      pastHead: true,
+      sessionStartMs: state.sessionStartMs,
+      firstUserMessage: state.firstUserMessage,
+      isInterrupted: false,
+    }),
+  };
+
+  private toSession(
+    filePath: string,
+    projectPath: string,
+    state: ClaudeSummaryState,
+  ): ClaudeSession {
+    const sessionStartMs = state.sessionStartMs ?? state.lastActiveMs;
     return {
-      sessionId,
-      projectPath: projectPath || lastCwd || "",
-      lastCwd,
-      sessionStart: sessionStart || lastActive || new Date(),
-      lastActive: lastActive || new Date(),
-      lastEntryType,
-      isInterrupted,
-      lastUserMessage,
-      firstUserMessage,
+      sessionId: path.basename(filePath, ".jsonl"),
+      projectPath: projectPath || state.lastCwd || "",
+      lastCwd: state.lastCwd,
+      sessionStart: sessionStartMs !== undefined ? new Date(sessionStartMs) : new Date(),
+      lastActive: state.lastActiveMs !== undefined ? new Date(state.lastActiveMs) : new Date(),
+      lastEntryType: state.lastEntryType,
+      isInterrupted: state.isInterrupted,
+      lastUserMessage: state.lastUserMessage,
+      firstUserMessage: state.firstUserMessage,
     };
   }
 
@@ -199,10 +276,20 @@ export class ClaudeSessionParser {
    * Read the full conversation from a session JSONL file.
    *
    * Default mode returns only text content from user/assistant/system messages.
-   * Verbose mode also includes tool_use and tool_result blocks.
+   * Verbose mode also includes tool_use and tool_result blocks. With `tail`,
+   * only the last N messages are read (from the end of the file).
    */
-  getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
+  getConversation(sessionFilePath: string, options?: ConversationOptions): ConversationMessage[] {
     const verbose = options?.verbose ?? false;
+    const tail = normalizeTail(options?.tail);
+    if (tail !== undefined) {
+      return this.tailReader.read(
+        sessionFilePath,
+        tail,
+        { parseLine: (line) => this.lineToMessage(line, verbose) },
+        String(verbose),
+      );
+    }
 
     let content: string;
     try {
@@ -215,58 +302,63 @@ export class ClaudeSessionParser {
     const messages: ConversationMessage[] = [];
 
     for (const line of lines) {
-      let entry: SessionEntry;
-      try {
-        entry = JSON.parse(line);
-      } catch {
-        continue;
-      }
+      const message = this.lineToMessage(line, verbose);
+      if (message) messages.push(message);
+    }
 
-      let role: ConversationMessage["role"];
-      if (entry.type === "user") {
-        role = "user";
-      } else if (entry.type === "assistant") {
-        role = "assistant";
-      } else if (entry.type === "system") {
-        role = "system";
-      } else {
-        continue;
-      }
+    return messages;
+  }
 
-      const text = this.extractConversationContent(entry.message?.content, role, verbose);
-      if (!text) continue;
+  /** Convert one JSONL line into a conversation message, or null when it is not one. */
+  private lineToMessage(line: string, verbose: boolean): ConversationMessage | null {
+    let entry: SessionEntry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      return null;
+    }
 
-      messages.push({
-        role,
-        content: text,
-        timestamp: entry.timestamp,
-      });
+    let role: ConversationMessage["role"];
+    if (entry.type === "user") {
+      role = "user";
+    } else if (entry.type === "assistant") {
+      role = "assistant";
+    } else if (entry.type === "system") {
+      role = "system";
+    } else {
+      return null;
     }
 
-    return messages;
+    const text = this.extractConversationContent(entry.message?.content, role, verbose);
+    if (!text) return null;
+
+    return {
+      role,
+      content: text,
+      timestamp: entry.timestamp,
+    };
   }
 
   /**
-   * Parse session start time from the first JSONL line.
+   * Parse session start time (epoch ms) from the first JSONL entry.
    *
    * Claude Code may emit a "file-history-snapshot" as the first entry,
    * which stores its timestamp inside "snapshot.timestamp" rather than
    * at the root level.
    */
-  private parseSessionStart(firstLine: string): Date | null {
-    try {
-      const firstEntry = JSON.parse(firstLine);
-      const rawTs: string | undefined = firstEntry.timestamp || firstEntry.snapshot?.timestamp;
-      if (rawTs) {
-        const ts = new Date(rawTs);
-        if (!Number.isNaN(ts.getTime())) {
-          return ts;
-        }
+  private parseSessionStart(firstEntry: unknown): number | undefined {
+    if (!firstEntry || typeof firstEntry !== "object") {
+      return undefined;
+    }
+    const entry = firstEntry as { timestamp?: string; snapshot?: { timestamp?: string } };
+    const rawTs = entry.timestamp || entry.snapshot?.timestamp;
+    if (rawTs) {
+      const ts = new Date(rawTs).getTime();
+      if (!Number.isNaN(ts)) {
+        return ts;
       }
-    } catch {
-      /* malformed first line */
     }
-    return null;
+    return undefined;
   }
 
   /**

package/src/{providers → harnesses}/codex/CodexAdapter.ts

@@ -5,21 +5,143 @@ import type {
   AgentInfo,
   ProcessInfo,
   ConversationMessage,
+  ConversationOptions,
   SessionSummary,
   ListSessionsOptions,
   AgentDetectionContext,
 } from "../../adapters/AgentAdapter.js";
-import {
-  captureProcessSnapshot,
-  executableBasename,
-  filterByProcessNames,
-} from "../../utils/process.js";
-import { safeReadFile } from "../../utils/session.js";
+import { executablePath } from "../../utils/process.js";
 import { AgentRegistry } from "../../utils/AgentRegistry.js";
 import { CodexAgentMapper } from "./CodexAgentMapper.js";
 import { CodexSessionLocator, type CodexDirectMatch } from "./CodexSessionLocator.js";
 import { CodexSessionMapping } from "./CodexSessionMapping.js";
 import { CodexSessionParser } from "./CodexSessionParser.js";
+import { findHarnessProcesses, homeDir, matchesExecutable } from "../shared.js";
+
+/**
+ * Codex subcommands that never own a local agent session: long-running helpers
+ * (app-server, sandbox, MCP/exec servers) and short-lived management commands.
+ * Interactive `codex`, `resume`, `fork`, `exec` and `review` remain detected.
+ *
+ * Classification of `review`, `cloud` and `agents` checked against Codex CLI
+ * 0.157.1 (source tag rust-v0.157.1, codex-rs/cli/src/main.rs):
+ * - `review` is detected: it runs as `codex exec review`, starting a
+ *   non-ephemeral thread in-process (source `exec`, originator `codex_exec`), so
+ *   it writes a `session_meta` rollout under ~/.codex/sessions like `codex exec`.
+ * - `cloud` is excluded: it browses and applies Codex Cloud tasks over HTTP and
+ *   never starts a local thread or rollout.
+ * - `agents` is excluded: it opens a dashboard over every session on the shared
+ *   app-server daemon without starting a thread of its own; the daemon, not
+ *   this process, owns and writes those sessions' rollouts.
+ */
+const CODEX_HELPER_SUBCOMMANDS = new Set([
+  "agents",
+  "app",
+  "app-server",
+  "apply",
+  "a",
+  "archive",
+  "cloud",
+  "cloud-tasks",
+  "completion",
+  "debug",
+  "delete",
+  "doctor",
+  "exec-server",
+  "features",
+  "help",
+  "login",
+  "logout",
+  "mcp",
+  "mcp-server",
+  "migrate-rollouts",
+  "plugin",
+  "queue",
+  "remote-control",
+  "responses-api-proxy",
+  "sandbox",
+  "stdio-to-uds",
+  "unarchive",
+  "update",
+]);
+
+/**
+ * Known root Codex subcommand names and aliases, including the hidden ones in
+ * Codex CLI 0.157.1. A variadic flag's values stop at these, as clap stops there.
+ */
+const CODEX_SUBCOMMANDS = new Set([
+  ...CODEX_HELPER_SUBCOMMANDS,
+  "e",
+  "exec",
+  "execpolicy",
+  "fork",
+  "resume",
+  "review",
+  "tcp-tunnel",
+]);
+
+/** Global Codex flags that consume the following argument as their value. */
+const CODEX_VALUE_FLAGS = new Set([
+  "-c",
+  "--config",
+  "-m",
+  "--model",
+  "-p",
+  "--profile",
+  "-s",
+  "--sandbox",
+  "-a",
+  "--ask-for-approval",
+  "-C",
+  "--cd",
+  "--add-dir",
+  "--enable",
+  "--disable",
+  "--local-provider",
+  "--remote",
+  "--remote-auth-token-env",
+]);
+
+/**
+ * Global Codex flags that take one or more values (clap `num_args = 1..`).
+ * `-i, --image <FILE>...` is the only one in Codex CLI 0.157.1.
+ */
+const CODEX_VARIADIC_VALUE_FLAGS = new Set(["-i", "--image"]);
+
+const CODEX_APP_SERVER_DAEMON_DIR = "app-server-daemon";
+
+function isCodexHelperCommand(command: string): boolean {
+  const trimmed = command.trim();
+  // Resolve argv[0] first so an install path containing spaces is not read as arguments.
+  const executable = executablePath(trimmed);
+  const args = trimmed.slice(executable.length).trim().split(/\s+/).filter(Boolean);
+  if (executable.replace(/\\/g, "/").split("/").includes(CODEX_APP_SERVER_DAEMON_DIR)) {
+    return true;
+  }
+
+  const subcommand = firstPositionalArgument(args);
+  return subcommand !== undefined && CODEX_HELPER_SUBCOMMANDS.has(subcommand);
+}
+
+function firstPositionalArgument(args: string[]): string | undefined {
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--") return undefined;
+    if (!arg.startsWith("-")) return arg;
+    if (arg.includes("=")) continue;
+    if (CODEX_VALUE_FLAGS.has(arg)) {
+      index++;
+    } else if (CODEX_VARIADIC_VALUE_FLAGS.has(arg)) {
+      // Like clap, take values until the next flag or subcommand name.
+      while (index + 1 < args.length && isVariadicFlagValue(args[index + 1])) index++;
+    }
+  }
+  return undefined;
+}
+
+function isVariadicFlagValue(arg: string): boolean {
+  return !arg.startsWith("-") && !CODEX_SUBCOMMANDS.has(arg);
+}
 
 interface MappedAgentResult {
   agents: AgentInfo[];
@@ -35,22 +157,32 @@ export class CodexAdapter implements AgentAdapter {
   private readonly mapper: CodexAgentMapper;
   private readonly codexSessionsDir: string;
   private readonly sessionMappingPath: string;
+  private locator?: CodexSessionLocator;
 
   constructor(registry: AgentRegistry = AgentRegistry.default()) {
-    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
     this.registry = registry;
     this.parser = new CodexSessionParser();
     this.mapper = new CodexAgentMapper(this.parser);
-    this.codexSessionsDir = path.join(homeDir, ".codex", "sessions");
-    this.sessionMappingPath = path.join(homeDir, ".codex", "ai-devkit", "sessions.json");
+    this.codexSessionsDir = path.join(homeDir(), ".codex", "sessions");
+    this.sessionMappingPath = path.join(homeDir(), ".codex", "ai-devkit", "sessions.json");
   }
 
   canHandle(processInfo: ProcessInfo): boolean {
-    const base = executableBasename(processInfo.command);
-    return base === "codex" || base === "codex.exe";
+    return (
+      matchesExecutable(processInfo.command, "codex") && !isCodexHelperCommand(processInfo.command)
+    );
   }
 
   async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
+    try {
+      return await this.detectRunningAgents(context);
+    } finally {
+      // Drop cached summaries for sessions that were not part of this refresh
+      this.parser.pruneSessionCache();
+    }
+  }
+
+  private async detectRunningAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
     const processes = await this.getCodexProcesses(context);
     if (processes.length === 0) return [];
 
@@ -59,10 +191,7 @@ export class CodexAdapter implements AgentAdapter {
     const locatorResult = this.createLocator().matchRunningProcesses(cacheResult.fallback);
 
     const directResult = this.mapDirectMatches(locatorResult.direct);
-    const legacyResult = this.mapLegacyMatches(
-      locatorResult.legacyMatches,
-      locatorResult.contentCache,
-    );
+    const legacyResult = this.mapLegacyMatches(locatorResult.legacyMatches);
     const unmatchedProcesses = this.findUnmatchedProcesses(locatorResult.fallback, [
       ...directResult.agents,
       ...legacyResult.agents,
@@ -78,7 +207,7 @@ export class CodexAdapter implements AgentAdapter {
     ];
   }
 
-  getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
+  getConversation(sessionFilePath: string, options?: ConversationOptions): ConversationMessage[] {
     return this.parser.getConversation(sessionFilePath, options);
   }
 
@@ -104,13 +233,13 @@ export class CodexAdapter implements AgentAdapter {
   }
 
   private async getCodexProcesses(context?: AgentDetectionContext): Promise<ProcessInfo[]> {
-    const snapshot = context?.processes ?? (await captureProcessSnapshot(this.processNames));
-    const relevant = filterByProcessNames(snapshot, this.processNames);
-    return relevant.filter((processInfo) => this.canHandle(processInfo));
+    return (await findHarnessProcesses(this, context)).processes;
   }
 
+  /** Reused across refreshes so the locator's session_meta and negative caches persist. */
   private createLocator(): CodexSessionLocator {
-    return new CodexSessionLocator({ sessionsDir: this.codexSessionsDir }, this.parser);
+    this.locator ??= new CodexSessionLocator({ sessionsDir: this.codexSessionsDir }, this.parser);
+    return this.locator;
   }
 
   private createSessionMapping(): CodexSessionMapping {
@@ -125,7 +254,7 @@ export class CodexAdapter implements AgentAdapter {
     const agents: AgentInfo[] = [];
 
     for (const match of matches) {
-      const session = this.parser.readSession(match.filePath);
+      const session = this.parser.readSessionIncremental(match.filePath);
       if (session) {
         agents.push(this.mapper.mapSessionToAgent(session, match.process, match.filePath));
       } else {
@@ -153,8 +282,7 @@ export class CodexAdapter implements AgentAdapter {
         continue;
       }
 
-      const content = safeReadFile(entry.sessionFilePath);
-      const session = this.parser.readSession(entry.sessionFilePath, content);
+      const session = this.parser.readSessionIncremental(entry.sessionFilePath);
       if (!session) {
         fallback.push(processInfo);
         continue;
@@ -171,7 +299,7 @@ export class CodexAdapter implements AgentAdapter {
     const fallback: ProcessInfo[] = [];
 
     for (const match of matches) {
-      const session = this.parser.readSession(match.sessionFile.filePath);
+      const session = this.parser.readSessionIncremental(match.sessionFile.filePath);
       if (session) {
         agents.push(
           this.mapper.mapSessionToAgent(session, match.process, match.sessionFile.filePath),
@@ -186,16 +314,12 @@ export class CodexAdapter implements AgentAdapter {
 
   private mapLegacyMatches(
     matches: Array<{ process: ProcessInfo; session: { filePath: string } }>,
-    contentCache: Map<string, string>,
   ): MappedAgentResult {
     const agents: AgentInfo[] = [];
     const fallback: ProcessInfo[] = [];
 
     for (const match of matches) {
-      const session = this.parser.readSession(
-        match.session.filePath,
-        contentCache.get(match.session.filePath),
-      );
+      const session = this.parser.readSessionIncremental(match.session.filePath);
       if (session) {
         agents.push(this.mapper.mapSessionToAgent(session, match.process, match.session.filePath));
       } else {

package/src/{providers → harnesses}/codex/CodexAgentMapper.ts

@@ -1,7 +1,7 @@
 import type { AgentInfo, ProcessInfo } from "../../adapters/AgentAdapter.js";
-import { AgentStatus } from "../../adapters/AgentAdapter.js";
 import { generateAgentName } from "../../utils/matching.js";
 import type { CodexSessionParser, CodexSession } from "./CodexSessionParser.js";
+import { processOnlyAgent } from "../shared.js";
 
 export class CodexAgentMapper {
   constructor(private readonly parser: CodexSessionParser) {}
@@ -21,15 +21,6 @@ export class CodexAgentMapper {
   }
 
   mapProcessOnlyAgent(processInfo: ProcessInfo): AgentInfo {
-    return {
-      name: generateAgentName(processInfo.cwd || "", processInfo.pid),
-      type: "codex",
-      status: AgentStatus.RUNNING,
-      summary: "Codex process running",
-      pid: processInfo.pid,
-      projectPath: processInfo.cwd || "",
-      sessionId: `pid-${processInfo.pid}`,
-      lastActive: new Date(),
-    };
+    return processOnlyAgent("codex", processInfo, { summary: "Codex process running" });
   }
 }