@ai-devkit/agent-manager 0.36.0 → 0.37.0

package/src/__tests__/harnesses/antigravity/AntigravityCliAdapter.subprocess.test.ts

@@ -0,0 +1,133 @@
+/**
+ * Subprocess budget tests for AntigravityCliAdapter (#257).
+ *
+ * `child_process` is mocked so every spawn is recorded; the real process
+ * utilities and AgentManager run on top of it. Detection must never use the
+ * synchronous child_process APIs and must reuse the shared snapshot.
+ */
+
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import * as childProcess from "child_process";
+
+import { AntigravityCliAdapter } from "../../../harnesses/antigravity/AntigravityCliAdapter.js";
+import type { ProcessInfo } from "../../../adapters/AgentAdapter.js";
+import { AgentManager } from "../../../AgentManager.js";
+import { AgentRegistry } from "../../../utils/AgentRegistry.js";
+import { createProcessSnapshotCapture } from "../../../utils/process.js";
+
+vi.mock("child_process", async (importOriginal) => {
+  const actual = (await importOriginal()) as typeof import("child_process");
+  const forbidden = (name: string) =>
+    vi.fn(() => {
+      throw new Error(`unexpected child_process.${name} call`);
+    });
+  return {
+    ...actual,
+    execFile: vi.fn(),
+    exec: forbidden("exec"),
+    spawn: forbidden("spawn"),
+    execFileSync: forbidden("execFileSync"),
+    execSync: forbidden("execSync"),
+    spawnSync: forbidden("spawnSync"),
+  };
+});
+
+const AGY_PID = 4242;
+const AGY_CWD = "/Users/dev/my-project";
+
+type ExecFileCallback = (error: Error | null, stdout: string, stderr: string) => void;
+
+/** Fake `ps`/`lsof` output for one running agy process plus an unrelated one. */
+function fakeExecFile(file: string, args: readonly string[]): string {
+  if (file === "ps" && args[0] === "-axo") {
+    return [`${AGY_PID} 1 ttys010 /usr/local/bin/agy`, "77 1 ttys011 node server.js"].join("\n");
+  }
+  if (file === "lsof") return `p${AGY_PID}\nn${AGY_CWD}\n`;
+  if (file === "ps" && args[0] === "-o") return `${AGY_PID} Wed Mar 18 23:18:01 2026\n`;
+  throw new Error(`unexpected execFile ${file} ${args.join(" ")}`);
+}
+
+const mockedExecFile = childProcess.execFile as unknown as ReturnType<typeof vi.fn>;
+const syncApis = ["execFileSync", "execSync", "spawnSync"] as const;
+const allSpawnApis = [...syncApis, "execFile", "exec", "spawn"] as const;
+
+function callCount(api: (typeof allSpawnApis)[number]): number {
+  return (childProcess[api] as unknown as ReturnType<typeof vi.fn>).mock.calls.length;
+}
+
+describe("AntigravityCliAdapter subprocess usage", () => {
+  let base: string;
+
+  beforeEach(() => {
+    base = fs.mkdtempSync(path.join(os.tmpdir(), "agy-subprocess-test-"));
+    process.env.ANTIGRAVITY_CLI_HOME = base;
+    for (const api of allSpawnApis) {
+      (childProcess[api] as unknown as ReturnType<typeof vi.fn>).mockClear();
+    }
+    mockedExecFile.mockImplementation(
+      (file: string, args: readonly string[], _opts: unknown, cb: ExecFileCallback) => {
+        try {
+          cb(null, fakeExecFile(file, args), "");
+        } catch (error) {
+          cb(error as Error, "", "");
+        }
+      },
+    );
+  });
+
+  afterEach(() => {
+    delete process.env.ANTIGRAVITY_CLI_HOME;
+    fs.rmSync(base, { recursive: true, force: true });
+  });
+
+  it("spawns no subprocess when the injected snapshot has no agy process", async () => {
+    const adapter = new AntigravityCliAdapter();
+    const snapshot: ProcessInfo[] = [{ pid: 77, command: "node server.js", cwd: "/x", tty: "" }];
+
+    expect(await adapter.detectAgents({ processes: snapshot })).toEqual([]);
+
+    for (const api of allSpawnApis) expect(callCount(api)).toBe(0);
+  });
+
+  it("spawns no subprocess when the injected snapshot contains an agy process", async () => {
+    const adapter = new AntigravityCliAdapter();
+    const snapshot: ProcessInfo[] = [
+      { pid: AGY_PID, command: "agy", cwd: AGY_CWD, tty: "ttys010", startTime: new Date() },
+    ];
+
+    const agents = await adapter.detectAgents({ processes: snapshot });
+
+    expect(agents.map((agent) => agent.pid)).toEqual([AGY_PID]);
+    for (const api of allSpawnApis) expect(callCount(api)).toBe(0);
+  });
+
+  it("never calls synchronous child_process APIs when capturing its own snapshot", async () => {
+    const adapter = new AntigravityCliAdapter();
+
+    const agents = await adapter.detectAgents();
+
+    expect(agents).toHaveLength(1);
+    expect(agents[0]).toMatchObject({ pid: AGY_PID, projectPath: AGY_CWD });
+    for (const api of syncApis) expect(callCount(api)).toBe(0);
+  });
+
+  it("makes a full listAgents() refresh spawn exactly one ps + lsof + ps lstart set", async () => {
+    // A fresh capture: the shared one caches start times from earlier tests (#266).
+    const manager = new AgentManager(
+      new AgentRegistry(path.join(base, "agents.json")),
+      createProcessSnapshotCapture(),
+    );
+    manager.registerAdapter(new AntigravityCliAdapter());
+
+    const agents = await manager.listAgents();
+
+    expect(agents.map((agent) => agent.pid)).toEqual([AGY_PID]);
+    const spawned = mockedExecFile.mock.calls.map(
+      ([file, args]) => `${file} ${(args as string[])[0]}`,
+    );
+    expect(spawned.sort()).toEqual(["lsof -a", "ps -axo", "ps -o"]);
+    for (const api of syncApis) expect(callCount(api)).toBe(0);
+  });
+});

package/src/__tests__/{adapters → harnesses/antigravity}/AntigravityCliAdapter.test.ts

@@ -11,23 +11,28 @@ import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 
-import { AntigravityCliAdapter } from "../../adapters/AntigravityCliAdapter.js";
-import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
-import { AgentStatus } from "../../adapters/AgentAdapter.js";
-import { listAgentProcesses, enrichProcesses } from "../../utils/process.js";
-import { generateAgentName } from "../../utils/matching.js";
-
-vi.mock("../../utils/process.js", async (importOriginal) => {
-  const actual = (await importOriginal()) as typeof import("../../utils/process.js");
+import { AntigravityCliAdapter } from "../../../harnesses/antigravity/AntigravityCliAdapter.js";
+import type { ProcessInfo } from "../../../adapters/AgentAdapter.js";
+import { AgentStatus } from "../../../adapters/AgentAdapter.js";
+import {
+  listAgentProcesses,
+  enrichProcesses,
+  captureProcessSnapshot,
+} from "../../../utils/process.js";
+import { generateAgentName } from "../../../utils/matching.js";
+
+vi.mock("../../../utils/process.js", async (importOriginal) => {
+  const actual = (await importOriginal()) as typeof import("../../../utils/process.js");
   return {
     ...actual,
     listAgentProcesses: vi.fn(),
     enrichProcesses: vi.fn(),
+    captureProcessSnapshot: vi.fn(),
   };
 });
 
-vi.mock("../../utils/matching.js", async (importOriginal) => {
-  const actual = (await importOriginal()) as typeof import("../../utils/matching.js");
+vi.mock("../../../utils/matching.js", async (importOriginal) => {
+  const actual = (await importOriginal()) as typeof import("../../../utils/matching.js");
   return {
     ...actual,
     generateAgentName: vi.fn(),
@@ -36,6 +41,9 @@ vi.mock("../../utils/matching.js", async (importOriginal) => {
 
 const mockedListAgentProcesses = listAgentProcesses as MockedFunction<typeof listAgentProcesses>;
 const mockedEnrichProcesses = enrichProcesses as MockedFunction<typeof enrichProcesses>;
+const mockedCaptureProcessSnapshot = captureProcessSnapshot as MockedFunction<
+  typeof captureProcessSnapshot
+>;
 const mockedGenerateAgentName = generateAgentName as MockedFunction<typeof generateAgentName>;
 
 const CONVERSATION_ID = "10485e13-2742-4e9e-b286-ac0606f0cb1e";
@@ -82,6 +90,7 @@ describe("AntigravityCliAdapter", () => {
 
     mockedListAgentProcesses.mockReset();
     mockedEnrichProcesses.mockReset();
+    mockedCaptureProcessSnapshot.mockReset();
     mockedGenerateAgentName.mockReset();
 
     mockedEnrichProcesses.mockImplementation((procs) => procs);
@@ -133,10 +142,9 @@ describe("AntigravityCliAdapter", () => {
     };
   }
 
-  describe("initialization", () => {
-    it("exposes the antigravity_cli type", () => {
-      expect(adapter.type).toBe("antigravity_cli");
-    });
+  it("exposes the antigravity_cli type and the agy process name", () => {
+    expect(adapter.type).toBe("antigravity_cli");
+    expect(adapter.processNames).toEqual(["agy"]);
   });
 
   describe("canHandle", () => {
@@ -156,21 +164,51 @@ describe("AntigravityCliAdapter", () => {
       expect(adapter.canHandle(proc({ command: "node app.js" }))).toBe(false);
     });
 
+    it("returns true for agy installed under a path containing spaces", () => {
+      const executable = path.join(base, "Antigravity App.app", "bin", "agy");
+      fs.mkdirSync(path.dirname(executable), { recursive: true });
+      fs.writeFileSync(executable, "");
+
+      expect(adapter.canHandle(proc({ command: `${executable} --prompt fix it` }))).toBe(true);
+      expect(adapter.canHandle(proc({ command: "/usr/bin/vim My Notes/agy" }))).toBe(false);
+    });
+
     it('returns false when "agy" appears only in an argument path', () => {
       expect(adapter.canHandle(proc({ command: "node /path/to/agy-thing.js" }))).toBe(false);
     });
   });
 
   describe("detectAgents", () => {
-    it("returns [] when there are no agy processes", async () => {
-      mockedListAgentProcesses.mockReturnValue([]);
+    it("uses context.processes when provided and never captures its own snapshot", async () => {
+      writeTranscript({});
+      writeRegistry({ [cwd]: CONVERSATION_ID });
+
+      const agents = await adapter.detectAgents({
+        processes: [proc(), proc({ pid: 7, command: "node server.js" })],
+      });
+
+      expect(agents.map((a) => a.pid)).toEqual([4242]);
+      expect(agents[0].sessionId).toBe(CONVERSATION_ID);
+      expect(mockedCaptureProcessSnapshot).not.toHaveBeenCalled();
+      expect(mockedListAgentProcesses).not.toHaveBeenCalled();
+      expect(mockedEnrichProcesses).not.toHaveBeenCalled();
+    });
+
+    it("falls back to the async captureProcessSnapshot without context", async () => {
+      mockedCaptureProcessSnapshot.mockResolvedValue([]);
+
       expect(await adapter.detectAgents()).toEqual([]);
+      expect(mockedCaptureProcessSnapshot).toHaveBeenCalledWith(["agy"], {
+        isCandidate: expect.any(Function),
+      });
+      expect(mockedListAgentProcesses).not.toHaveBeenCalled();
+      expect(mockedEnrichProcesses).not.toHaveBeenCalled();
     });
 
     it("resolves the conversation via last_conversations.json (cwd -> id)", async () => {
       writeTranscript({});
       writeRegistry({ [cwd]: CONVERSATION_ID });
-      mockedListAgentProcesses.mockReturnValue([proc()]);
+      mockedCaptureProcessSnapshot.mockResolvedValue([proc()]);
 
       const agents = await adapter.detectAgents();
 
@@ -190,7 +228,7 @@ describe("AntigravityCliAdapter", () => {
     it("falls back to a process-only RUNNING agent when the cwd is not in the registry", async () => {
       writeTranscript({});
       writeRegistry({ "/some/other/cwd": CONVERSATION_ID });
-      mockedListAgentProcesses.mockReturnValue([proc()]);
+      mockedCaptureProcessSnapshot.mockResolvedValue([proc()]);
 
       const agents = await adapter.detectAgents();
 
@@ -203,7 +241,7 @@ describe("AntigravityCliAdapter", () => {
     it("is process-only when the mapped conversation has no transcript", async () => {
       writeTranscript({ transcript: false });
       writeRegistry({ [cwd]: CONVERSATION_ID });
-      mockedListAgentProcesses.mockReturnValue([proc()]);
+      mockedCaptureProcessSnapshot.mockResolvedValue([proc()]);
 
       const agents = await adapter.detectAgents();
 
@@ -220,10 +258,10 @@ describe("AntigravityCliAdapter", () => {
       ]);
     });
 
-    it("accepts a bare conversation id and skips malformed lines", () => {
+    it("skips malformed lines", () => {
       const file = writeTranscript({ records: [userRecord("hi")] });
       fs.appendFileSync(file, "\n{bad json");
-      expect(adapter.getConversation(CONVERSATION_ID)).toEqual([{ role: "user", content: "hi" }]);
+      expect(adapter.getConversation(file)).toEqual([{ role: "user", content: "hi" }]);
     });
 
     it("excludes SYSTEM records unless verbose", () => {
@@ -260,14 +298,14 @@ describe("AntigravityCliAdapter", () => {
         records: [userRecord("go"), toolRecord("ran: echo hi"), modelRecord("done")],
       });
       writeRegistry({ [cwd]: CONVERSATION_ID });
-      mockedListAgentProcesses.mockReturnValue([proc()]);
+      mockedCaptureProcessSnapshot.mockResolvedValue([proc()]);
       expect((await detectFirst()).status).toBe(AgentStatus.WAITING);
     });
 
     it("marks RUNNING when the last transcript turn is a USER_INPUT message", async () => {
       writeTranscript({ records: [userRecord("still there?")] });
       writeRegistry({ [cwd]: CONVERSATION_ID });
-      mockedListAgentProcesses.mockReturnValue([proc()]);
+      mockedCaptureProcessSnapshot.mockResolvedValue([proc()]);
       expect((await detectFirst()).status).toBe(AgentStatus.RUNNING);
     });
 
@@ -275,14 +313,14 @@ describe("AntigravityCliAdapter", () => {
       const old = new Date(Date.now() - 10 * 60 * 1000);
       writeTranscript({ records: [userRecord("go", old)] });
       writeRegistry({ [cwd]: CONVERSATION_ID });
-      mockedListAgentProcesses.mockReturnValue([proc()]);
+      mockedCaptureProcessSnapshot.mockResolvedValue([proc()]);
       expect((await detectFirst()).status).toBe(AgentStatus.IDLE);
     });
 
     it("uses the last user request as the agent summary", async () => {
       writeTranscript({ records: [userRecord("refactor the parser"), modelRecord("on it")] });
       writeRegistry({ [cwd]: CONVERSATION_ID });
-      mockedListAgentProcesses.mockReturnValue([proc()]);
+      mockedCaptureProcessSnapshot.mockResolvedValue([proc()]);
       expect((await detectFirst()).summary).toBe("refactor the parser");
     });
   });
@@ -292,6 +330,16 @@ describe("AntigravityCliAdapter", () => {
       expect(await adapter.listSessions()).toEqual([]);
     });
 
+    it("ignores a malformed registry and non-string conversation ids", async () => {
+      writeTranscript({});
+      fs.mkdirSync(path.join(base, "cache"), { recursive: true });
+      fs.writeFileSync(path.join(base, "cache", "last_conversations.json"), "{not json");
+      expect(await adapter.listSessions()).toEqual([]);
+
+      writeRegistry({ [cwd]: 42 as unknown as string, "/Users/dev/other": "" });
+      expect(await adapter.listSessions()).toEqual([]);
+    });
+
     it("lists sessions from the registry with cwd + first user message", async () => {
       writeTranscript({});
       writeRegistry({ [cwd]: CONVERSATION_ID });
@@ -321,4 +369,28 @@ describe("AntigravityCliAdapter", () => {
       expect(filtered[0].cwd).toBe("/Users/dev/project-a");
     });
   });
+
+  describe("findSessionsById", () => {
+    it("finds a registered conversation by id", async () => {
+      writeTranscript({});
+      writeRegistry({ [cwd]: CONVERSATION_ID });
+
+      expect(await adapter.findSessionsById(CONVERSATION_ID)).toEqual([
+        expect.objectContaining({
+          type: "antigravity_cli",
+          sessionId: CONVERSATION_ID,
+          cwd,
+          firstUserMessage: "fix the bug",
+        }),
+      ]);
+    });
+
+    it("ignores transcripts that are not in the registry, like listSessions", async () => {
+      writeTranscript({});
+      writeRegistry({});
+
+      expect(await adapter.findSessionsById(CONVERSATION_ID)).toEqual([]);
+      expect(await adapter.listSessions()).toEqual([]);
+    });
+  });
 });

package/src/__tests__/harnesses/builtinAdapters.test.ts

@@ -0,0 +1,33 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+import { AGENT_TYPES } from "../../adapters/AgentAdapter.js";
+import { createBuiltinAdapters } from "../../harnesses/index.js";
+import { AgentRegistry } from "../../utils/AgentRegistry.js";
+
+describe("createBuiltinAdapters", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "builtin-adapters-"));
+    // Several adapters default to AgentRegistry.default(), which opens ~/.ai-devkit/agents.db.
+    vi.spyOn(AgentRegistry, "default").mockReturnValue(
+      new AgentRegistry(path.join(tmpDir, "agents.json")),
+    );
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("returns exactly one adapter per built-in agent type", () => {
+    const adapters = createBuiltinAdapters();
+    try {
+      expect(adapters.map((adapter) => adapter.type).sort()).toEqual([...AGENT_TYPES].sort());
+    } finally {
+      for (const adapter of adapters) (adapter as { close?: () => void }).close?.();
+    }
+  });
+});

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

@@ -1,8 +1,8 @@
 import { describe, expect, it } from "vitest";
 
 import { AgentStatus, type ProcessInfo } from "../../../adapters/AgentAdapter.js";
-import { ClaudeAgentMapper } from "../../../providers/claude/ClaudeAgentMapper.js";
-import type { ClaudeSession } from "../../../providers/claude/ClaudeSessionParser.js";
+import { ClaudeAgentMapper } from "../../../harnesses/claude/ClaudeAgentMapper.js";
+import type { ClaudeSession } from "../../../harnesses/claude/ClaudeSessionParser.js";
 import type { SessionFile } from "../../../utils/session.js";
 
 function makeProcess(overrides: Partial<ProcessInfo> = {}): ProcessInfo {
@@ -65,7 +65,7 @@ describe("ClaudeAgentMapper", () => {
     });
   });
 
-  it("maps unmatched processes to the existing process-only fallback shape", () => {
+  it("maps unmatched processes to the shared process-only placeholder", () => {
     const mapper = new ClaudeAgentMapper();
 
     const agent = mapper.mapProcessOnlyAgent(makeProcess({ pid: 456, cwd: "/repo/tooling" }));
@@ -73,8 +73,8 @@ describe("ClaudeAgentMapper", () => {
     expect(agent).toMatchObject({
       name: "tooling-456",
       type: "claude",
-      status: AgentStatus.IDLE,
-      summary: "Unknown",
+      status: AgentStatus.RUNNING,
+      summary: "Claude Code process running",
       pid: 456,
       projectPath: "/repo/tooling",
       sessionId: "pid-456",

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[] = [];