@ai-devkit/agent-manager 0.35.0 → 0.37.0

package/src/__tests__/{adapters → harnesses/claude}/ClaudeCodeAdapter.test.ts

@@ -6,21 +6,21 @@ import type { MockedFunction } from "vitest";
 import * as fs from "fs";
 import * as path from "path";
 
-import { ClaudeCodeAdapter } from "../../providers/claude/ClaudeCodeAdapter.js";
-import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
-import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { ClaudeCodeAdapter } from "../../../harnesses/claude/ClaudeCodeAdapter.js";
+import type { ProcessInfo } from "../../../adapters/AgentAdapter.js";
+import { AgentStatus } from "../../../adapters/AgentAdapter.js";
 import {
   listAgentProcesses,
   enrichProcesses,
   captureProcessSnapshot,
-} from "../../utils/process.js";
-import { batchGetSessionFileBirthtimes } from "../../utils/session.js";
-import type { SessionFile } from "../../utils/session.js";
-import { matchProcessesToSessions, generateAgentName } from "../../utils/matching.js";
-import type { MatchResult } from "../../utils/matching.js";
+} from "../../../utils/process.js";
+import { batchGetSessionFileBirthtimes } from "../../../utils/session.js";
+import type { SessionFile } from "../../../utils/session.js";
+import { matchProcessesToSessions, generateAgentName } from "../../../utils/matching.js";
+import type { MatchResult } from "../../../utils/matching.js";
 import * as os from "os";
-vi.mock("../../utils/process.js", async (importOriginal) => {
-  const actual = (await importOriginal()) as typeof import("../../utils/process.js");
+vi.mock("../../../utils/process.js", async (importOriginal) => {
+  const actual = (await importOriginal()) as typeof import("../../../utils/process.js");
   return {
     ...actual,
     listAgentProcesses: vi.fn(),
@@ -29,17 +29,17 @@ vi.mock("../../utils/process.js", async (importOriginal) => {
   };
 });
 
-vi.mock("../../utils/session.js", async () => {
+vi.mock("../../../utils/session.js", async () => {
   const actual = (await vi.importActual(
-    "../../utils/session",
-  )) as typeof import("../../utils/session");
+    "../../../utils/session",
+  )) as typeof import("../../../utils/session");
   return {
     ...actual,
     batchGetSessionFileBirthtimes: vi.fn(),
   };
 });
 
-vi.mock("../../utils/matching.js", () => ({
+vi.mock("../../../utils/matching.js", () => ({
   matchProcessesToSessions: vi.fn(),
   generateAgentName: vi.fn(),
 }));
@@ -131,6 +131,37 @@ describe("ClaudeCodeAdapter", () => {
       expect(adapter.canHandle(processInfo)).toBe(false);
     });
 
+    it("should return true for claude installed under a path containing spaces", () => {
+      const root = fs.mkdtempSync(path.join(os.tmpdir(), "claude-spaces-"));
+      try {
+        const executable = path.join(root, "Applications", "Some App.app", "Contents", "claude");
+        fs.mkdirSync(path.dirname(executable), { recursive: true });
+        fs.writeFileSync(executable, "");
+
+        expect(
+          adapter.canHandle({
+            pid: 12345,
+            command: `${executable} --resume abc --append-system-prompt be brief/codex`,
+            cwd: "/test",
+            tty: "ttys001",
+          }),
+        ).toBe(true);
+      } finally {
+        fs.rmSync(root, { recursive: true, force: true });
+      }
+    });
+
+    it("should return false when claude only appears in an argument containing spaces", () => {
+      expect(
+        adapter.canHandle({
+          pid: 12345,
+          command: "/usr/bin/vim My Notes/claude",
+          cwd: "/test",
+          tty: "ttys001",
+        }),
+      ).toBe(false);
+    });
+
     it('should return false for processes with "claude" only in path arguments', () => {
       const processInfo = {
         pid: 12345,
@@ -166,11 +197,11 @@ describe("ClaudeCodeAdapter", () => {
       expect(agents).toHaveLength(1);
       expect(agents[0]).toMatchObject({
         type: "claude",
-        status: AgentStatus.IDLE,
+        status: AgentStatus.RUNNING,
         pid: 777,
         projectPath: "/project/app",
         sessionId: "pid-777",
-        summary: "Unknown",
+        summary: "Claude Code process running",
       });
     });
 
@@ -299,7 +330,7 @@ describe("ClaudeCodeAdapter", () => {
       const unmatched = agents.find((a) => a.pid === 200);
       expect(matched?.sessionId).toBe("only-session");
       expect(unmatched?.sessionId).toBe("pid-200");
-      expect(unmatched?.status).toBe(AgentStatus.IDLE);
+      expect(unmatched?.status).toBe(AgentStatus.RUNNING);
 
       fs.rmSync(tmpDir, { recursive: true, force: true });
     });
@@ -316,7 +347,7 @@ describe("ClaudeCodeAdapter", () => {
       expect(agents[0]).toMatchObject({
         pid: 300,
         sessionId: "pid-300",
-        summary: "Unknown",
+        summary: "Claude Code process running",
         projectPath: "",
       });
     });
@@ -396,7 +427,7 @@ describe("ClaudeCodeAdapter", () => {
 
       expect(agents).toHaveLength(1);
       expect(agents[0].sessionId).toBe("pid-41921");
-      expect(agents[0].status).toBe(AgentStatus.IDLE);
+      expect(agents[0].status).toBe(AgentStatus.RUNNING);
     });
 
     it("should use PID file for direct match and skip legacy matching for that process", async () => {
@@ -745,14 +776,14 @@ describe("ClaudeCodeAdapter", () => {
       (adapter as any).projectsDir = projectsDir;
 
       // Simulate JSONL disappearing between existence check and read
-      vi.spyOn((adapter as any).parser, "readSession").mockReturnValueOnce(null);
+      vi.spyOn((adapter as any).parser, "readSessionIncremental").mockReturnValueOnce(null);
 
       const agents = await adapter.detectAgents();
 
       // matchedPids.delete called → process falls back to IDLE
       expect(agents).toHaveLength(1);
       expect(agents[0].sessionId).toBe("pid-66001");
-      expect(agents[0].status).toBe(AgentStatus.IDLE);
+      expect(agents[0].status).toBe(AgentStatus.RUNNING);
 
       fs.rmSync(tmpDir, { recursive: true, force: true });
       vi.restoreAllMocks();
@@ -795,13 +826,13 @@ describe("ClaudeCodeAdapter", () => {
       ]);
 
       // Simulate JSONL disappearing between match and read
-      vi.spyOn((adapter as any).parser, "readSession").mockReturnValueOnce(null);
+      vi.spyOn((adapter as any).parser, "readSessionIncremental").mockReturnValueOnce(null);
 
       const agents = await adapter.detectAgents();
 
       expect(agents).toHaveLength(1);
       expect(agents[0].sessionId).toBe("pid-66002");
-      expect(agents[0].status).toBe(AgentStatus.IDLE);
+      expect(agents[0].status).toBe(AgentStatus.RUNNING);
 
       fs.rmSync(tmpDir, { recursive: true, force: true });
       vi.restoreAllMocks();
@@ -1150,7 +1181,6 @@ describe("ClaudeCodeAdapter", () => {
 
     beforeEach(() => {
       tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "claude-test-"));
-      (adapter as any).projectsDir = path.join(tmpDir, "projects");
     });
 
     afterEach(() => {

package/src/__tests__/{providers → harnesses}/claude/ClaudeSessionLocator.test.ts

@@ -5,7 +5,7 @@ import * as path from "path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { AgentStatus, type ProcessInfo } from "../../../adapters/AgentAdapter.js";
-import { ClaudeSessionLocator } from "../../../providers/claude/ClaudeSessionLocator.js";
+import { ClaudeSessionLocator } from "../../../harnesses/claude/ClaudeSessionLocator.js";
 import { batchGetSessionFileBirthtimes } from "../../../utils/session.js";
 import type { SessionFile } from "../../../utils/session.js";
 
@@ -419,16 +419,5 @@ describe("ClaudeSessionLocator", () => {
       expect(encode("/a/b_c")).toBe(encode("/a/b-c"));
       expect(encode("/a/b_c")).toBe(encode("/a/b.c"));
     });
-
-    it("should resolve to a real session dir when cwd contains underscores", () => {
-      const cwd = "/Users/foo/my_project";
-      const expectedDir = path.join(projectsDir, "-Users-foo-my-project");
-      fs.mkdirSync(expectedDir, { recursive: true });
-      const sessionFile = path.join(expectedDir, "session-underscore.jsonl");
-      fs.writeFileSync(sessionFile, "");
-
-      expect(encode(cwd)).toBe(expectedDir);
-      expect(fs.existsSync(path.join(encode(cwd), "session-underscore.jsonl"))).toBe(true);
-    });
   });
 });

package/src/__tests__/{utils → harnesses/claude}/ClaudeSessionParser.test.ts

@@ -1,12 +1,12 @@
 /**
- * Tests for providers/claude/ClaudeSessionParser.ts — focused on stripping
+ * Tests for harnesses/claude/ClaudeSessionParser.ts — focused on stripping
  * harness-injected XML tags from conversation content.
  */
 
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
-import { ClaudeSessionParser } from "../../providers/claude/ClaudeSessionParser.js";
+import { ClaudeSessionParser } from "../../../harnesses/claude/ClaudeSessionParser.js";
 
 interface JsonlEntry {
   type: "user" | "assistant" | "system";

package/src/__tests__/{print → harnesses/claude/durable}/ClaudeCliProbe.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from "vitest";
-import { ClaudeCliProbe } from "../../providers/claude/durable/ClaudeCliProbe.js";
+import { ClaudeCliProbe } from "../../../../harnesses/claude/durable/ClaudeCliProbe.js";
 
 describe("ClaudeCliProbe", () => {
   it("validates only version/help and requires the print session flags", async () => {

package/src/__tests__/{print → harnesses/claude/durable}/ClaudePrintAgent.integration.test.ts

@@ -6,7 +6,7 @@ import {
   ClaudePrintAgentService,
   DurableAgentRepository,
   type ProcessInspector,
-} from "../../index.js";
+} from "../../../../index.js";
 
 const roots: string[] = [];
 

package/src/__tests__/{print → harnesses/claude/durable}/ClaudePrintAgentService.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it, vi } from "vitest";
 
 describe("ClaudePrintAgentService", () => {
   it("validates before create and does not run Claude", async () => {
-    const api = (await import("../../index.js")) as Record<string, unknown>;
+    const api = (await import("../../../../index.js")) as Record<string, unknown>;
     expect(api).toHaveProperty("ClaudePrintAgentService");
     const probe = {
       validate: vi.fn().mockResolvedValue({ executable: "claude", version: "2.1.220" }),
@@ -20,7 +20,7 @@ describe("ClaudePrintAgentService", () => {
   });
 
   it("runs first and resumed sends and records provider identity/results", async () => {
-    const api = (await import("../../index.js")) as Record<string, unknown>;
+    const api = (await import("../../../../index.js")) as Record<string, unknown>;
     const base = {
       id: "id",
       name: "reviewer",
@@ -80,7 +80,7 @@ describe("ClaudePrintAgentService", () => {
   });
 
   it("rejects a non-Claude target without acquiring or mutating it", async () => {
-    const api = (await import("../../index.js")) as Record<string, unknown>;
+    const api = (await import("../../../../index.js")) as Record<string, unknown>;
     const Service = api.ClaudePrintAgentService as new (options: unknown) => any;
     const target = { id: "id", name: "reviewer", provider: "pi" };
     const repository = {
@@ -101,7 +101,7 @@ describe("ClaudePrintAgentService", () => {
   });
 
   it("does not turn a successful completion write failure into a second completion", async () => {
-    const api = (await import("../../index.js")) as Record<string, unknown>;
+    const api = (await import("../../../../index.js")) as Record<string, unknown>;
     const Service = api.ClaudePrintAgentService as new (options: unknown) => any;
     const target = {
       id: "id",

package/src/__tests__/{print → harnesses/claude/durable}/ClaudePrintRunner.test.ts

@@ -1,8 +1,8 @@
 import { EventEmitter } from "node:events";
 import { PassThrough, Writable } from "node:stream";
 import { describe, expect, it, vi } from "vitest";
-import type { DurableAgent } from "../../index.js";
-import { ClaudePrintRunner } from "../../providers/claude/durable/ClaudePrintRunner.js";
+import type { DurableAgent } from "../../../../index.js";
+import { ClaudePrintRunner } from "../../../../harnesses/claude/durable/ClaudePrintRunner.js";
 
 function agent(): DurableAgent {
   return {

package/src/__tests__/{adapters → harnesses/codex}/CodexAdapter.test.ts

@@ -3,23 +3,24 @@ import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 
-import { CodexAdapter } from "../../providers/codex/CodexAdapter.js";
-import { AgentStatus, type ProcessInfo } from "../../adapters/AgentAdapter.js";
-import { AgentRegistry, type RegistryEntry } from "../../utils/AgentRegistry.js";
-import { batchGetSessionFileBirthtimes, type SessionFile } from "../../utils/session.js";
+import { CodexAdapter } from "../../../harnesses/codex/CodexAdapter.js";
+import { CodexSessionLocator } from "../../../harnesses/codex/CodexSessionLocator.js";
+import { AgentStatus, type ProcessInfo } from "../../../adapters/AgentAdapter.js";
+import { AgentRegistry, type RegistryEntry } from "../../../utils/AgentRegistry.js";
+import { batchGetSessionFileBirthtimes, type SessionFile } from "../../../utils/session.js";
 import {
   captureProcessSnapshot,
   enrichProcesses,
   listAgentProcesses,
-} from "../../utils/process.js";
+} from "../../../utils/process.js";
 import {
   generateAgentName,
   matchProcessesToSessions,
   type MatchResult,
-} from "../../utils/matching.js";
+} from "../../../utils/matching.js";
 
-vi.mock("../../utils/process.js", async (importOriginal) => {
-  const actual = (await importOriginal()) as typeof import("../../utils/process.js");
+vi.mock("../../../utils/process.js", async (importOriginal) => {
+  const actual = (await importOriginal()) as typeof import("../../../utils/process.js");
   return {
     ...actual,
     listAgentProcesses: vi.fn(),
@@ -28,17 +29,17 @@ vi.mock("../../utils/process.js", async (importOriginal) => {
   };
 });
 
-vi.mock("../../utils/session.js", async () => {
+vi.mock("../../../utils/session.js", async () => {
   const actual = (await vi.importActual(
-    "../../utils/session",
-  )) as typeof import("../../utils/session");
+    "../../../utils/session",
+  )) as typeof import("../../../utils/session");
   return {
     ...actual,
     batchGetSessionFileBirthtimes: vi.fn(),
   };
 });
 
-vi.mock("../../utils/matching.js", () => ({
+vi.mock("../../../utils/matching.js", () => ({
   matchProcessesToSessions: vi.fn(),
   generateAgentName: vi.fn(),
 }));
@@ -114,6 +115,251 @@ describe("CodexAdapter", () => {
     ).toBe(false);
   });
 
+  describe("helper process exclusion", () => {
+    const sessionId = "019a0000-0000-7000-8000-000000000001";
+    const helperCommands = [
+      "/Applications/SomeApp.app/Contents/Resources/codex sandbox -c sandbox_permissions=[] -- node /opt/tools/server.js",
+      "/Applications/SomeApp.app/Contents/Resources/codex debug seatbelt -- node /opt/tools/server.js",
+      "codex app-server --listen stdio://",
+      "/usr/local/bin/codex -c model=o3 app-server --listen stdio://",
+      "/home/user/.codex/packages/app-server-daemon/releases/1.2.3/bin/codex",
+      "/home/user/.codex/packages/app-server-daemon/releases/1.2.3/bin/codex app-server --listen ws://127.0.0.1:4500",
+      "codex mcp-server",
+      "codex exec-server",
+      "codex remote-control start",
+      "codex login",
+      "codex mcp list",
+      "codex completion zsh",
+      "codex apply",
+      "codex features list",
+      "C:\\Users\\user\\.codex\\packages\\app-server-daemon\\releases\\1.2.3\\bin\\codex.exe",
+    ];
+    const agentCommands = [
+      "codex",
+      "/opt/homebrew/bin/codex --model o3",
+      "codex -c model_reasoning_effort=high",
+      "codex --sandbox workspace-write --ask-for-approval on-request",
+      "codex -s danger-full-access fix the failing tests",
+      `codex resume ${sessionId}`,
+      "codex resume --last",
+      `codex fork ${sessionId}`,
+      "codex exec --json -",
+      `codex exec resume --json ${sessionId} -`,
+      "codex exec --cd /repos/project summarize the change",
+      "C:\\tools\\codex.exe",
+    ];
+
+    it.each(helperCommands)("does not handle helper command %s", (command) => {
+      expect(adapter.canHandle({ pid: 10, command, cwd: "/repo", tty: "??" })).toBe(false);
+    });
+
+    it.each(agentCommands)("handles agent command %s", (command) => {
+      expect(adapter.canHandle({ pid: 11, command, cwd: "/repo", tty: "ttys001" })).toBe(true);
+    });
+
+    it("does not list helper processes or run session discovery for them", async () => {
+      const locatorSpy = vi.spyOn(CodexSessionLocator.prototype, "matchRunningProcesses");
+      const processes: ProcessInfo[] = helperCommands.map((command, index) => ({
+        pid: 500 + index,
+        command,
+        cwd: "/repo-a",
+        tty: "??",
+      }));
+
+      await expect(adapter.detectAgents({ processes })).resolves.toEqual([]);
+      expect(locatorSpy).not.toHaveBeenCalled();
+      locatorSpy.mockRestore();
+    });
+
+    it("only passes agent processes to session discovery when helpers run alongside", async () => {
+      const locatorSpy = vi.spyOn(CodexSessionLocator.prototype, "matchRunningProcesses");
+      const agentProcess: ProcessInfo = {
+        pid: 100,
+        command: "codex",
+        cwd: "/repo-a",
+        tty: "ttys001",
+      };
+      const processes: ProcessInfo[] = [
+        agentProcess,
+        { pid: 101, command: "codex app-server --listen stdio://", cwd: "/repo-a", tty: "??" },
+        {
+          pid: 102,
+          command: "/Applications/SomeApp.app/Contents/Resources/codex sandbox -- node server.js",
+          cwd: "/repo-a",
+          tty: "??",
+        },
+      ];
+
+      const agents = await adapter.detectAgents({ processes });
+
+      expect(agents.map((agent) => agent.pid)).toEqual([100]);
+      expect(locatorSpy).toHaveBeenCalledTimes(1);
+      expect(locatorSpy.mock.calls[0]![0]).toEqual([agentProcess]);
+      locatorSpy.mockRestore();
+    });
+  });
+
+  // Verified against Codex CLI 0.157.1 (source tag rust-v0.157.1):
+  // - `codex review` runs as `codex exec review` and writes a local rollout
+  //   (session_meta source `exec`), so it is listed.
+  // - `codex cloud` only talks to Codex Cloud over HTTP and writes no rollout.
+  // - `codex agents` is a dashboard over the shared app-server daemon's sessions
+  //   and starts no thread of its own, so it owns no rollout.
+  describe("review, cloud and agents classification (Codex CLI 0.157.1)", () => {
+    const reviewCommands = [
+      "codex review",
+      "codex review --uncommitted",
+      "codex review --base main",
+      "codex review --commit 0123abc --title fix",
+      "codex review -",
+      "/opt/homebrew/bin/codex -c model=o3 review focus on error handling",
+    ];
+    const sessionlessCommands = [
+      "codex cloud",
+      "codex cloud exec --env env_123 fix the flaky test",
+      "codex cloud list",
+      "codex cloud apply task_123",
+      "codex -c model=o3 cloud",
+      "codex agents",
+      "codex agents --remote ws://127.0.0.1:4500",
+      "codex agents -C /repos/project --no-alt-screen",
+      "codex --remote ws://127.0.0.1:4500 agents",
+      "codex --remote-auth-token-env CODEX_TOKEN --remote wss://host:4500 agents",
+      "codex --enable some_feature agents",
+    ];
+
+    it.each(reviewCommands)("lists review command %s", (command) => {
+      expect(adapter.canHandle({ pid: 20, command, cwd: "/repo", tty: "ttys002" })).toBe(true);
+    });
+
+    it.each(sessionlessCommands)("does not list sessionless command %s", (command) => {
+      expect(adapter.canHandle({ pid: 21, command, cwd: "/repo", tty: "ttys002" })).toBe(false);
+    });
+
+    it("passes review processes to session discovery and never lists cloud or agents", async () => {
+      const locatorSpy = vi.spyOn(CodexSessionLocator.prototype, "matchRunningProcesses");
+      const reviewProcess: ProcessInfo = {
+        pid: 300,
+        command: "codex review --uncommitted",
+        cwd: "/repo-a",
+        tty: "ttys003",
+      };
+      const processes: ProcessInfo[] = [
+        reviewProcess,
+        ...sessionlessCommands.map((command, index) => ({
+          pid: 400 + index,
+          command,
+          cwd: "/repo-a",
+          tty: "ttys004",
+        })),
+      ];
+
+      const agents = await adapter.detectAgents({ processes });
+
+      expect(agents.map((agent) => agent.pid)).toEqual([300]);
+      expect(locatorSpy).toHaveBeenCalledTimes(1);
+      expect(locatorSpy.mock.calls[0]![0]).toEqual([reviewProcess]);
+      locatorSpy.mockRestore();
+    });
+  });
+
+  it("handles Codex installed under a path containing spaces", async () => {
+    const executable = path.join(
+      tmpHome,
+      "Applications",
+      "Some App.app",
+      "Contents",
+      "Resources",
+      "codex",
+    );
+    fs.mkdirSync(path.dirname(executable), { recursive: true });
+    fs.writeFileSync(executable, "");
+    const codex: ProcessInfo = {
+      pid: 4321,
+      command: `${executable} exec fix the Other Dir/claude bug`,
+      cwd: "/repo",
+      tty: "ttys001",
+    };
+    const editor: ProcessInfo = {
+      pid: 4322,
+      command: `/usr/bin/vim ${path.join(tmpHome, "Applications", "Some")} App.app/Contents/Resources/codex`,
+      cwd: "/repo",
+      tty: "ttys002",
+    };
+
+    expect(adapter.canHandle(codex)).toBe(true);
+    expect(adapter.canHandle(editor)).toBe(false);
+
+    const agents = await adapter.detectAgents({ processes: [codex, editor] });
+    expect(agents.map((agent) => agent.pid)).toEqual([4321]);
+  });
+
+  // Codex CLI 0.157.1 declares `-i, --image <FILE>...` (clap `num_args = 1..`,
+  // `value_delimiter = ','`), its only variadic root flag. clap keeps taking
+  // image values until a flag or a subcommand name, so a helper subcommand can
+  // follow several images.
+  describe("variadic -i/--image values (Codex CLI 0.157.1)", () => {
+    const helperCommands = [
+      "codex -i a.png b.png cloud",
+      "codex --image a.png b.png app-server",
+      "codex -i a.png -i b.png agents",
+      "codex -i a.png b.png c.png --model o3 mcp list",
+      "codex --image=a.png,b.png cloud",
+      "codex -i a.png,b.png login",
+      "codex -i a.png b.png a",
+      "codex --image a.png b.png cloud-tasks list",
+    ];
+    const agentCommands = [
+      'codex -i a.png "fix the bug"',
+      "codex -i a.png fix the bug",
+      "codex -i a.png b.png",
+      "codex -i a.png resume --last",
+      "codex --image a.png b.png fork --last",
+      "codex -i a.png b.png exec summarize the screenshots",
+      "codex -i a.png b.png e -",
+      "codex -i a.png b.png review",
+      "codex -i a.png --model o3 describe this",
+    ];
+
+    it.each(helperCommands)("does not handle helper command %s", (command) => {
+      expect(adapter.canHandle({ pid: 30, command, cwd: "/repo", tty: "??" })).toBe(false);
+    });
+
+    it.each(agentCommands)("handles agent command %s", (command) => {
+      expect(adapter.canHandle({ pid: 31, command, cwd: "/repo", tty: "ttys003" })).toBe(true);
+    });
+  });
+
+  it("still excludes helper subcommands when Codex lives under a path containing spaces", () => {
+    const executable = path.join(
+      tmpHome,
+      "Applications",
+      "Some App.app",
+      "Contents",
+      "Resources",
+      "codex",
+    );
+    fs.mkdirSync(path.dirname(executable), { recursive: true });
+    fs.writeFileSync(executable, "");
+
+    for (const args of [
+      "sandbox -c sandbox_permissions=[] -- node server.js",
+      "app-server --listen stdio://",
+    ]) {
+      expect(
+        adapter.canHandle({ pid: 4323, command: `${executable} ${args}`, cwd: "/repo", tty: "??" }),
+      ).toBe(false);
+    }
+    expect(
+      adapter.canHandle({
+        pid: 4324,
+        command: `${executable} resume --last`,
+        cwd: "/repo",
+        tty: "ttys003",
+      }),
+    ).toBe(true);
+  });
+
   it("returns no agents when no Codex process is running", async () => {
     mockedListAgentProcesses.mockReturnValue([]);
 
@@ -182,6 +428,25 @@ describe("CodexAdapter", () => {
     });
   });
 
+  it("does not rescan session files for an unmatched process on the next refresh", async () => {
+    const processInfo: ProcessInfo = {
+      pid: 100,
+      command: "codex",
+      cwd: "/repo-a",
+      tty: "ttys001",
+      startTime: new Date("2026-03-18T15:00:00.000Z"),
+    };
+    writeSession("sess-other", "/repo-other", []);
+    mockedListAgentProcesses.mockReturnValue([processInfo]);
+    mockedBatchGetSessionFileBirthtimes.mockReturnValue([]);
+
+    await adapter.detectAgents();
+    const agents = await adapter.detectAgents();
+
+    expect(mockedBatchGetSessionFileBirthtimes).toHaveBeenCalledTimes(1);
+    expect(agents).toMatchObject([{ pid: 100, sessionId: "pid-100" }]);
+  });
+
   it("maps resumed sessions directly by id", async () => {
     const sessionId = "019eabed-4079-7071-9531-b853ddd9914e";
     const processInfo: ProcessInfo = {