@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/src/__tests__/utils/jsonlTail.test.ts

@@ -0,0 +1,317 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { ConversationMessage } from "../../adapters/AgentAdapter.js";
+import { JsonlTailReader, type JsonlTailSource } from "../../utils/jsonlTail.js";
+
+const readBytes = vi.hoisted(() => ({ total: 0 }));
+
+vi.mock("fs", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("fs")>();
+  const readSync = ((...args: Parameters<typeof actual.readSync>) => {
+    const n = (actual.readSync as (...a: unknown[]) => number)(...args);
+    readBytes.total += n;
+    return n;
+  }) as typeof actual.readSync;
+  const readFileSync = ((...args: Parameters<typeof actual.readFileSync>) => {
+    const out = (actual.readFileSync as (...a: unknown[]) => string | Buffer)(...args);
+    readBytes.total += Buffer.byteLength(out as string);
+    return out;
+  }) as typeof actual.readFileSync;
+  return { ...actual, readSync, readFileSync, default: { ...actual, readSync, readFileSync } };
+});
+
+interface Line {
+  role?: ConversationMessage["role"];
+  text?: string;
+  key?: string;
+  mirror?: boolean;
+}
+
+/** Line-independent source: every line with role+text is one message. */
+const simpleSource: JsonlTailSource<ConversationMessage> = {
+  parseLine(line) {
+    let entry: Line;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      return null;
+    }
+    if (!entry.role || !entry.text) return null;
+    return { role: entry.role, content: entry.text };
+  },
+};
+
+function fullParse(content: string): ConversationMessage[] {
+  const out: ConversationMessage[] = [];
+  for (const line of content.trim().split("\n")) {
+    const message = simpleSource.parseLine(line);
+    if (message) out.push(message as ConversationMessage);
+  }
+  return out;
+}
+
+/**
+ * Source whose output depends on other lines: a "mirror" line is dropped
+ * when a non-mirror line with the same key exists anywhere in the window
+ * (modeled on Codex's event_msg/response_item de-duplication).
+ */
+interface KeyedItem {
+  key?: string;
+  mirror: boolean;
+  message: ConversationMessage;
+}
+const dedupSource: JsonlTailSource<KeyedItem> = {
+  parseLine(line) {
+    let entry: Line;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      return null;
+    }
+    if (!entry.role || !entry.text) return null;
+    return {
+      key: entry.key,
+      mirror: entry.mirror === true,
+      message: { role: entry.role, content: entry.text },
+    };
+  },
+  finalize(items) {
+    const primary = new Set(items.filter((i) => !i.mirror && i.key).map((i) => i.key));
+    return items.filter((i) => !(i.mirror && i.key && primary.has(i.key))).map((i) => i.message);
+  },
+};
+
+function dedupFullParse(content: string): ConversationMessage[] {
+  const items: KeyedItem[] = [];
+  for (const line of content.trim().split("\n")) {
+    const item = dedupSource.parseLine(line);
+    if (item) items.push(item);
+  }
+  return dedupSource.finalize!(items);
+}
+
+const last = <T>(arr: T[], n: number): T[] => (arr.length > n ? arr.slice(-n) : arr);
+
+describe("JsonlTailReader", () => {
+  let tmpDir: string;
+  let file: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "jsonl-tail-"));
+    file = path.join(tmpDir, "session.jsonl");
+    readBytes.total = 0;
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function mixedContent(count: number): string {
+    const lines: string[] = [];
+    for (let i = 0; i < count; i++) {
+      if (i % 7 === 3) lines.push("not json {");
+      if (i % 11 === 5) lines.push("");
+      if (i % 5 === 0) lines.push(JSON.stringify({ type: "noise", i }));
+      const text = i % 13 === 0 ? `big ${i} ${"x".repeat(300)}` : `msg ${i} ünïcødé ✓ 🚀`;
+      lines.push(JSON.stringify({ role: i % 2 ? "assistant" : "user", text }));
+    }
+    return lines.join("\n") + "\n";
+  }
+
+  it("matches the last N of a full parse for every tail and chunk size", () => {
+    const content = mixedContent(60);
+    fs.writeFileSync(file, content);
+    const full = fullParse(content);
+
+    for (const chunkSize of [7, 64, 333, 65536]) {
+      for (let tail = 1; tail <= full.length + 2; tail++) {
+        const reader = new JsonlTailReader({ chunkSize });
+        expect(reader.read(file, tail, simpleSource)).toEqual(last(full, tail));
+      }
+    }
+  });
+
+  it("handles lines longer than the chunk size and multi-byte characters across chunks", () => {
+    const lines = [
+      JSON.stringify({ role: "user", text: "é".repeat(5000) }),
+      JSON.stringify({ role: "assistant", text: "🚀".repeat(3000) }),
+      JSON.stringify({ role: "user", text: "short" }),
+    ];
+    const content = lines.join("\n");
+    fs.writeFileSync(file, content);
+
+    const reader = new JsonlTailReader({ chunkSize: 100 });
+    expect(reader.read(file, 3, simpleSource)).toEqual(fullParse(content));
+  });
+
+  it("returns an empty list for missing and empty files", () => {
+    const reader = new JsonlTailReader();
+    expect(reader.read(path.join(tmpDir, "missing.jsonl"), 5, simpleSource)).toEqual([]);
+    fs.writeFileSync(file, "");
+    expect(reader.read(file, 5, simpleSource)).toEqual([]);
+  });
+
+  it("reads only a bounded window from the end on the first call", () => {
+    const content = mixedContent(20000);
+    fs.writeFileSync(file, content);
+    const reader = new JsonlTailReader({ chunkSize: 4096 });
+
+    readBytes.total = 0;
+    const result = reader.read(file, 20, simpleSource);
+
+    expect(result).toEqual(last(fullParse(content), 20));
+    expect(readBytes.total).toBeLessThanOrEqual(4 * 4096);
+    expect(content.length).toBeGreaterThan(100 * 4096);
+  });
+
+  it("does not read the file again when it is unchanged", () => {
+    fs.writeFileSync(file, mixedContent(50));
+    const reader = new JsonlTailReader();
+    const first = reader.read(file, 10, simpleSource);
+
+    readBytes.total = 0;
+    expect(reader.read(file, 10, simpleSource)).toEqual(first);
+    expect(readBytes.total).toBe(0);
+  });
+
+  it("parses only appended bytes on later polls", () => {
+    const chunkSize = 4096;
+    let content = mixedContent(5000);
+    fs.writeFileSync(file, content);
+    const reader = new JsonlTailReader({ chunkSize });
+    reader.read(file, 20, simpleSource);
+
+    for (let round = 0; round < 3; round++) {
+      const appended = mixedContent(3 + round).replace(/msg /g, `r${round} `);
+      fs.appendFileSync(file, appended);
+      content += appended;
+
+      readBytes.total = 0;
+      const result = reader.read(file, 20, simpleSource);
+      expect(result).toEqual(last(fullParse(content), 20));
+      expect(readBytes.total).toBeLessThanOrEqual(Buffer.byteLength(appended) + chunkSize);
+    }
+  });
+
+  it("includes an unterminated final line and re-reads it once completed", () => {
+    const head = [
+      JSON.stringify({ role: "user", text: "one" }),
+      JSON.stringify({ role: "assistant", text: "two" }),
+    ].join("\n");
+    fs.writeFileSync(file, head + "\n" + '{"role":"user","te');
+    const reader = new JsonlTailReader({ chunkSize: 16 });
+    expect(reader.read(file, 5, simpleSource)).toEqual(fullParse(head));
+
+    fs.appendFileSync(file, 'xt":"three"}');
+    const complete = fs.readFileSync(file, "utf-8");
+    expect(reader.read(file, 5, simpleSource)).toEqual(fullParse(complete));
+    expect(reader.read(file, 5, simpleSource).at(-1)).toEqual({ role: "user", content: "three" });
+
+    fs.appendFileSync(file, "\n" + JSON.stringify({ role: "assistant", text: "four" }) + "\n");
+    expect(reader.read(file, 5, simpleSource)).toEqual(fullParse(fs.readFileSync(file, "utf-8")));
+  });
+
+  it("resets when the file shrinks (truncation)", () => {
+    fs.writeFileSync(file, mixedContent(40));
+    const reader = new JsonlTailReader({ chunkSize: 64 });
+    reader.read(file, 5, simpleSource);
+
+    const replacement = [
+      JSON.stringify({ role: "user", text: "fresh start" }),
+      JSON.stringify({ role: "assistant", text: "ok" }),
+    ].join("\n");
+    fs.writeFileSync(file, replacement + "\n");
+    expect(reader.read(file, 5, simpleSource)).toEqual(fullParse(replacement));
+  });
+
+  it("resets when the file is replaced by a new inode (rotation)", () => {
+    const original = mixedContent(10);
+    fs.writeFileSync(file, original);
+    const reader = new JsonlTailReader({ chunkSize: 64 });
+    reader.read(file, 5, simpleSource);
+
+    // A larger replacement at a new inode must not be treated as an append.
+    const rotated = mixedContent(30).replace(/msg /g, "rotated ");
+    const staging = path.join(tmpDir, "staging.jsonl");
+    fs.writeFileSync(staging, rotated);
+    fs.renameSync(staging, file);
+
+    expect(reader.read(file, 5, simpleSource)).toEqual(last(fullParse(rotated), 5));
+  });
+
+  it("keeps cache entries separate per variant and per tail", () => {
+    const content = mixedContent(30);
+    fs.writeFileSync(file, content);
+    const reader = new JsonlTailReader();
+    const full = fullParse(content);
+    const onlyUsers: JsonlTailSource<ConversationMessage> = {
+      parseLine: (line) => {
+        const m = simpleSource.parseLine(line);
+        return m && (m as ConversationMessage).role === "user" ? m : null;
+      },
+    };
+
+    expect(reader.read(file, 3, simpleSource, "all")).toEqual(last(full, 3));
+    expect(reader.read(file, 3, onlyUsers, "users")).toEqual(
+      last(
+        full.filter((m) => m.role === "user"),
+        3,
+      ),
+    );
+    expect(reader.read(file, 6, simpleSource, "all")).toEqual(last(full, 6));
+  });
+
+  it("applies finalize over the window, including lines appended later", () => {
+    const lines = [
+      { role: "user", text: "hello", key: "k1" },
+      { role: "user", text: "hello", key: "k1", mirror: true },
+      { role: "assistant", text: "reply", key: "k2", mirror: true },
+    ].map((l) => JSON.stringify(l));
+    let content = lines.join("\n") + "\n";
+    fs.writeFileSync(file, content);
+    const reader = new JsonlTailReader({ chunkSize: 16 });
+
+    expect(reader.read(file, 10, dedupSource, "", 4)).toEqual(dedupFullParse(content));
+
+    // The primary for k2 arrives after its mirror; the mirror must disappear.
+    const primary = JSON.stringify({ role: "assistant", text: "reply", key: "k2" }) + "\n";
+    fs.appendFileSync(file, primary);
+    content += primary;
+    expect(reader.read(file, 10, dedupSource, "", 4)).toEqual(dedupFullParse(content));
+    expect(dedupFullParse(content)).toHaveLength(2);
+  });
+
+  it("stays correct for long append sequences while bounding the retained window", () => {
+    fs.writeFileSync(file, "");
+    const reader = new JsonlTailReader({ chunkSize: 64 });
+    let content = "";
+    for (let i = 0; i < 200; i++) {
+      const chunk =
+        JSON.stringify({ role: "user", text: `q${i}`, key: `u${i}` }) +
+        "\n" +
+        JSON.stringify({ role: "user", text: `q${i}`, key: `u${i}`, mirror: true }) +
+        "\n";
+      fs.appendFileSync(file, chunk);
+      content += chunk;
+      expect(reader.read(file, 5, dedupSource, "", 4)).toEqual(last(dedupFullParse(content), 5));
+    }
+  });
+
+  it("evicts least-recently-used files beyond maxFiles", () => {
+    const reader = new JsonlTailReader({ maxFiles: 2 });
+    const files = ["a", "b", "c"].map((name) => {
+      const p = path.join(tmpDir, `${name}.jsonl`);
+      fs.writeFileSync(p, mixedContent(5));
+      return p;
+    });
+    for (const p of files) reader.read(p, 3, simpleSource);
+
+    readBytes.total = 0;
+    reader.read(files[2], 3, simpleSource);
+    expect(readBytes.total).toBe(0);
+    reader.read(files[0], 3, simpleSource);
+    expect(readBytes.total).toBeGreaterThan(0);
+  });
+});

package/src/__tests__/utils/matchingConstants.test.ts

@@ -0,0 +1,40 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { MATCH_TOLERANCE_MS as reExported } from "../../utils/matching.js";
+import { MATCH_TOLERANCE_MS } from "../../utils/matchingConstants.js";
+
+const SRC_DIR = fileURLToPath(new URL("../../", import.meta.url));
+const CONSTANTS_FILE = path.join(SRC_DIR, "utils", "matchingConstants.ts");
+/** `3 * 60 * 1000`, `180000`, `180_000`, or `3 * 60_000` written in source. */
+const TOLERANCE_LITERAL = /\b3\s*\*\s*60\s*\*\s*1_?000\b|\b180_?000\b|\b3\s*\*\s*60_?000\b/;
+
+function listSourceFiles(dir: string): string[] {
+  const files: string[] = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name !== "__tests__") files.push(...listSourceFiles(full));
+    } else if (entry.name.endsWith(".ts")) {
+      files.push(full);
+    }
+  }
+  return files;
+}
+
+describe("MATCH_TOLERANCE_MS", () => {
+  it("is 3 minutes and re-exported unchanged from utils/matching", () => {
+    expect(MATCH_TOLERANCE_MS).toBe(3 * 60 * 1000);
+    expect(reExported).toBe(MATCH_TOLERANCE_MS);
+  });
+
+  it("is not duplicated as a literal elsewhere in agent-manager source", () => {
+    const offenders = listSourceFiles(SRC_DIR)
+      .filter((file) => file !== CONSTANTS_FILE)
+      .filter((file) => TOLERANCE_LITERAL.test(fs.readFileSync(file, "utf8")))
+      .map((file) => path.relative(SRC_DIR, file));
+
+    expect(offenders).toEqual([]);
+  });
+});

package/src/__tests__/utils/process.test.ts

@@ -4,6 +4,9 @@
 
 import type { MockedFunction } from "vitest";
 
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
 import { execFile, execFileSync } from "child_process";
 import {
   listAgentProcesses,
@@ -13,8 +16,13 @@ import {
   findWrapperProcess,
   findWrapperProcessPids,
   captureProcessSnapshot,
+  createProcessSnapshotCapture,
   filterByProcessNames,
+  executableBasename,
+  executablePath,
+  type ProcessExec,
 } from "../../utils/process.js";
+import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
 
 vi.mock("child_process", () => ({
   execFile: vi.fn(),
@@ -79,6 +87,167 @@ describe("captureProcessSnapshot", () => {
   });
 });
 
+describe("createProcessSnapshotCapture", () => {
+  interface FakeProcess {
+    pid: number;
+    ppid?: number;
+    command: string;
+    cwd?: string;
+    lstart?: string;
+  }
+
+  function createFakeExec(initial: FakeProcess[]) {
+    let table = initial;
+    const calls: Array<{ file: string; args: readonly string[] }> = [];
+    const pidsArg = (args: readonly string[]) =>
+      args[args.indexOf("-p") + 1].split(",").map((pid) => parseInt(pid, 10));
+    const exec: ProcessExec = async (file, args) => {
+      calls.push({ file, args });
+      if (file === "ps" && args.includes("-axo")) {
+        return table.map((p) => `${p.pid} ${p.ppid ?? 1} s001 ${p.command}`).join("\n");
+      }
+      const requested = new Set(pidsArg(args));
+      const rows = table.filter((p) => requested.has(p.pid));
+      if (file === "lsof") {
+        return rows.map((p) => `p${p.pid}\nn${p.cwd ?? "/"}`).join("\n");
+      }
+      if (file === "ps" && args.some((arg) => arg.includes("lstart="))) {
+        return rows.map((p) => `${p.pid} ${p.lstart ?? "Wed Mar 18 23:18:01 2026"}`).join("\n");
+      }
+      throw new Error(`unexpected command: ${file} ${args.join(" ")}`);
+    };
+    return {
+      exec,
+      calls,
+      setTable: (next: FakeProcess[]) => {
+        table = next;
+      },
+      enrichedPids: (file: "lsof" | "lstart") =>
+        calls
+          .filter((call) =>
+            file === "lsof"
+              ? call.file === "lsof"
+              : call.args.some((arg) => arg.includes("lstart=")),
+          )
+          .map((call) => pidsArg(call.args)),
+    };
+  }
+
+  const isGemini = (process: ProcessInfo) => /gemini/.test(process.command);
+
+  it("enriches only candidate PIDs but still returns every name-matched process", async () => {
+    const fake = createFakeExec([
+      { pid: 10, command: "node /opt/gemini.js", cwd: "/g" },
+      { pid: 11, command: "node /opt/vite.js", cwd: "/v" },
+      { pid: 12, command: "/usr/bin/unrelated" },
+    ]);
+    const capture = createProcessSnapshotCapture({ exec: fake.exec });
+
+    const snapshot = await capture(["node"], { isCandidate: isGemini });
+
+    expect(snapshot.map((process) => process.pid)).toEqual([10, 11]);
+    expect(snapshot[0]).toMatchObject({ cwd: "/g", startTime: expect.any(Date) });
+    expect(snapshot[1].cwd).toBe("");
+    expect(snapshot[1].startTime).toBeUndefined();
+    expect(fake.enrichedPids("lsof")).toEqual([[10]]);
+    expect(fake.enrichedPids("lstart")).toEqual([[10]]);
+  });
+
+  it("enriches every name-matched process when no candidate predicate is given", async () => {
+    const fake = createFakeExec([
+      { pid: 10, command: "node /opt/gemini.js" },
+      { pid: 11, command: "node /opt/vite.js" },
+    ]);
+    const capture = createProcessSnapshotCapture({ exec: fake.exec });
+
+    await capture(["node"]);
+
+    expect(fake.enrichedPids("lsof")).toEqual([[10, 11]]);
+    expect(fake.enrichedPids("lstart")).toEqual([[10, 11]]);
+  });
+
+  it("spawns only the base ps when no process is a candidate", async () => {
+    const fake = createFakeExec([
+      { pid: 11, command: "node /opt/vite.js" },
+      { pid: 12, command: "node /opt/eslint-server.js" },
+    ]);
+    const capture = createProcessSnapshotCapture({ exec: fake.exec });
+
+    const snapshot = await capture(["node"], { isCandidate: isGemini });
+
+    expect(snapshot.map((process) => process.pid)).toEqual([11, 12]);
+    expect(fake.calls).toHaveLength(1);
+    expect(fake.calls[0].args).toContain("-axo");
+  });
+
+  it("fetches start times once per live PID across refreshes, but cwd every refresh", async () => {
+    const fake = createFakeExec([
+      { pid: 10, command: "node /opt/gemini.js", lstart: "Wed Mar 18 23:18:01 2026" },
+    ]);
+    const capture = createProcessSnapshotCapture({ exec: fake.exec });
+
+    const first = await capture(["node"], { isCandidate: isGemini });
+    fake.setTable([
+      { pid: 10, command: "node /opt/gemini.js", lstart: "Wed Mar 18 23:18:01 2026" },
+      { pid: 20, command: "node /opt/gemini.js", lstart: "Thu Mar 19 10:00:00 2026" },
+    ]);
+    const second = await capture(["node"], { isCandidate: isGemini });
+    const third = await capture(["node"], { isCandidate: isGemini });
+
+    expect(fake.enrichedPids("lstart")).toEqual([[10], [20]]);
+    expect(fake.enrichedPids("lsof")).toEqual([[10], [10, 20], [10, 20]]);
+    expect(second[0].startTime).toEqual(first[0].startTime);
+    expect(third.map((process) => process.startTime)).toEqual([
+      new Date("Wed Mar 18 23:18:01 2026"),
+      new Date("Thu Mar 19 10:00:00 2026"),
+    ]);
+  });
+
+  it("refetches the start time when a PID is reused by a different process", async () => {
+    const fake = createFakeExec([
+      { pid: 10, command: "node /opt/gemini.js", lstart: "Wed Mar 18 23:18:01 2026" },
+    ]);
+    const capture = createProcessSnapshotCapture({ exec: fake.exec });
+
+    await capture(["node"], { isCandidate: isGemini });
+    fake.setTable([
+      { pid: 10, command: "node /opt/gemini.js --resume", lstart: "Fri Mar 20 08:00:00 2026" },
+    ]);
+    const reused = await capture(["node"], { isCandidate: isGemini });
+
+    expect(fake.enrichedPids("lstart")).toEqual([[10], [10]]);
+    expect(reused[0].startTime).toEqual(new Date("Fri Mar 20 08:00:00 2026"));
+  });
+
+  it("forgets cached start times once the PID disappears", async () => {
+    const fake = createFakeExec([
+      { pid: 10, command: "node /opt/gemini.js", lstart: "Wed Mar 18 23:18:01 2026" },
+    ]);
+    const capture = createProcessSnapshotCapture({ exec: fake.exec });
+
+    await capture(["node"], { isCandidate: isGemini });
+    fake.setTable([]);
+    await capture(["node"], { isCandidate: isGemini });
+    fake.setTable([
+      { pid: 10, command: "node /opt/gemini.js", lstart: "Fri Mar 20 08:00:00 2026" },
+    ]);
+    const restarted = await capture(["node"], { isCandidate: isGemini });
+
+    expect(fake.enrichedPids("lstart")).toEqual([[10], [10]]);
+    expect(restarted[0].startTime).toEqual(new Date("Fri Mar 20 08:00:00 2026"));
+  });
+
+  it("retries start times that could not be read", async () => {
+    const fake = createFakeExec([{ pid: 10, command: "node /opt/gemini.js", lstart: "garbage" }]);
+    const capture = createProcessSnapshotCapture({ exec: fake.exec });
+
+    await capture(["node"], { isCandidate: isGemini });
+    await capture(["node"], { isCandidate: isGemini });
+
+    expect(fake.enrichedPids("lstart")).toEqual([[10], [10]]);
+  });
+});
+
 describe("filterByProcessNames", () => {
   it("matches only argv[0] and normalizes Windows paths and executable suffixes", () => {
     const processes: ProcessInfo[] = [
@@ -92,6 +261,91 @@ describe("filterByProcessNames", () => {
   });
 });
 
+describe("executables installed under paths containing spaces", () => {
+  let root: string;
+  let codexPath: string;
+  let nodePath: string;
+  let editorPath: string;
+
+  function install(relativePath: string): string {
+    const fullPath = path.join(root, relativePath);
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, "");
+    return fullPath;
+  }
+
+  beforeEach(() => {
+    mockedExecFileSync.mockReset();
+    root = fs.mkdtempSync(path.join(os.tmpdir(), "process-spaces-"));
+    codexPath = install("Applications/Some App.app/Contents/Resources/codex");
+    nodePath = install("Applications/Dev Tools/node/bin/node");
+    editorPath = install("usr/bin/vim");
+  });
+
+  afterEach(() => {
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it("recovers argv[0] when its directory contains spaces", () => {
+    expect(executableBasename(`${codexPath} exec --cd /repo`)).toBe("codex");
+    expect(executablePath(`${codexPath} exec --cd /repo`)).toBe(codexPath);
+    expect(executableBasename(`${nodePath} /Users/me/.npm/bin/gemini --yolo`)).toBe("node");
+  });
+
+  it("does not treat arguments containing spaces as part of the executable path", () => {
+    expect(executableBasename(`${editorPath} My Notes/claude`)).toBe("vim");
+    expect(executableBasename(`${codexPath} exec fix the Other Dir/claude bug`)).toBe("codex");
+    expect(executableBasename("/usr/local/bin/node --title my agent/claude")).toBe("node");
+  });
+
+  it("keeps the first-token behaviour for commands without spaces in the path", () => {
+    expect(executableBasename("claude")).toBe("claude");
+    expect(executableBasename("/usr/local/bin/CLAUDE --continue")).toBe("claude");
+    expect(executableBasename("C:\\tools\\node.exe C:\\bin\\pi.js")).toBe("node.exe");
+    expect(executableBasename("  ")).toBe("");
+  });
+
+  it("matches spaced executables by name in filterByProcessNames", () => {
+    const processes: ProcessInfo[] = [
+      { pid: 1, command: `${codexPath} resume --last`, cwd: "", tty: "" },
+      { pid: 2, command: `${nodePath} /opt/gemini.js`, cwd: "", tty: "" },
+      { pid: 3, command: `${editorPath} Some App.app/Contents/Resources/codex`, cwd: "", tty: "" },
+      { pid: 4, command: `${codexPath} exec review My Folder/claude`, cwd: "", tty: "" },
+    ];
+
+    expect(filterByProcessNames(processes, ["codex"])).toEqual([processes[0], processes[3]]);
+    expect(filterByProcessNames(processes, ["node"])).toEqual([processes[1]]);
+    expect(filterByProcessNames(processes, ["claude"])).toEqual([]);
+  });
+
+  it("captures spaced executables with a single base ps call", async () => {
+    const calls: Array<{ file: string; args: readonly string[] }> = [];
+    const exec: ProcessExec = async (file, args) => {
+      calls.push({ file, args });
+      if (file === "ps" && args.includes("-axo")) {
+        return [
+          `100 1 s001 ${codexPath} --sandbox workspace-write`,
+          `200 1 s002 ${editorPath} Some App.app/Contents/Resources/codex`,
+        ].join("\n");
+      }
+      return "";
+    };
+    const capture = createProcessSnapshotCapture({ exec });
+
+    const snapshot = await capture(["codex"]);
+
+    expect(snapshot.map((process) => process.pid)).toEqual([100]);
+    expect(snapshot[0].command).toBe(`${codexPath} --sandbox workspace-write`);
+    expect(calls.filter((call) => call.args.includes("-axo"))).toHaveLength(1);
+  });
+
+  it("lists spaced executables in listAgentProcesses", () => {
+    mockedExecFileSync.mockReturnValue(`100 1 s001 ${codexPath} exec --json\n`);
+
+    expect(listAgentProcesses("codex").map((process) => process.pid)).toEqual([100]);
+  });
+});
+
 describe("listAgentProcesses", () => {
   beforeEach(() => {
     mockedExecFileSync.mockReset();