@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/src/__tests__/harnesses/pi/durable/PiPrintRunner.test.ts

@@ -0,0 +1,252 @@
+import { EventEmitter } from "node:events";
+import { PassThrough, Writable } from "node:stream";
+import { describe, expect, it, vi } from "vitest";
+import type { PiDurableAgent } from "../../../../durable/DurableAgent.js";
+import { PiPrintRunner } from "../../../../harnesses/pi/durable/PiPrintRunner.js";
+
+const SESSION = "22222222-2222-4222-8222-222222222222";
+function agent(sessionHealth: PiDurableAgent["sessionHealth"] = "uninitialized"): PiDurableAgent {
+  return {
+    id: "11111111-1111-4111-8111-111111111111",
+    name: "reviewer",
+    provider: "pi",
+    mode: "durable",
+    cwd: "/project",
+    providerSessionId: SESSION,
+    state: "running",
+    sessionHealth,
+    createdAt: "",
+    updatedAt: "",
+    lastActiveAt: null,
+    lastResult: null,
+    activeRun: null,
+  };
+}
+function fakeSpawn(lines: string[], exitCode = 0) {
+  const promptChunks: Buffer[] = [];
+  const child = new EventEmitter() as any;
+  child.pid = 4242;
+  child.stdout = new PassThrough();
+  child.stderr = new PassThrough();
+  child.kill = vi.fn();
+  child.stdin = new Writable({
+    write(chunk, _encoding, callback) {
+      promptChunks.push(Buffer.from(chunk));
+      callback();
+    },
+    final(callback) {
+      child.stdout.end(lines.join("\n"));
+      queueMicrotask(() => child.emit("close", exitCode, null));
+      callback();
+    },
+  });
+  return { child, spawn: vi.fn(() => child), promptChunks };
+}
+function events(session = SESSION): string[] {
+  return [
+    JSON.stringify({ type: "session", version: 3, id: session, cwd: "/project" }),
+    JSON.stringify({
+      type: "message_end",
+      message: { role: "assistant", content: [{ type: "text", text: "first" }] },
+    }),
+    JSON.stringify({
+      type: "message_end",
+      message: {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "hidden" },
+          { type: "text", text: "final" },
+        ],
+      },
+    }),
+    JSON.stringify({ type: "agent_end", messages: [] }),
+    "",
+  ];
+}
+async function runner(fixture: ReturnType<typeof fakeSpawn>, maxLineBytes?: number) {
+  return new PiPrintRunner({
+    spawn: fixture.spawn,
+    maxLineBytes,
+    processInspector: { getIdentity: () => ({ pid: 4242, startedAt: "start" }) },
+  });
+}
+
+describe("PiPrintRunner", () => {
+  it("binds a first session and returns the last completed assistant text", async () => {
+    const fixture = fakeSpawn(events());
+    const instance = await runner(fixture);
+    const order: string[] = [];
+    const result = await instance.run({
+      agent: agent(),
+      prompt: "secret",
+      executable: "fake-pi",
+      onSpawn: async () => {
+        expect(fixture.promptChunks).toHaveLength(0);
+        order.push("spawn");
+      },
+    });
+    expect(order).toEqual(["spawn"]);
+    expect(fixture.spawn).toHaveBeenCalledWith(
+      "fake-pi",
+      ["--mode", "json", "--session-id", SESSION],
+      expect.objectContaining({ cwd: "/project", shell: false }),
+    );
+    expect(Buffer.concat(fixture.promptChunks).toString()).toBe("secret");
+    expect(result).toEqual({
+      sessionId: SESSION,
+      result: "final",
+      messages: ["first", "final"],
+      exitCode: 0,
+    });
+  });
+
+  it("resumes the exact stored session and rejects mismatch", async () => {
+    const fixture = fakeSpawn(events("33333333-3333-4333-8333-333333333333"));
+    await expect(
+      (await runner(fixture)).run({ agent: agent("healthy"), prompt: "later", onSpawn: vi.fn() }),
+    ).rejects.toMatchObject({ code: "PI_SESSION_MISMATCH" });
+    expect(fixture.spawn.mock.calls[0]![1]).toEqual(["--mode", "json", "--session", SESSION]);
+  });
+
+  it.each([
+    ["malformed", ["{bad\n"], "PI_PROTOCOL"],
+    ["non-object", ["[]\n"], "PI_PROTOCOL"],
+    ["truncated", ["{}"], "PI_PROTOCOL"],
+    ["missing session", [JSON.stringify({ type: "agent_end" }), ""], "PI_PROTOCOL"],
+    [
+      "missing result",
+      [JSON.stringify({ type: "session", id: SESSION }), JSON.stringify({ type: "agent_end" }), ""],
+      "PI_RESULT_MISSING",
+    ],
+    [
+      "missing end",
+      [
+        JSON.stringify({ type: "session", id: SESSION }),
+        JSON.stringify({
+          type: "message_end",
+          message: { role: "assistant", content: [{ type: "text", text: "x" }] },
+        }),
+        "",
+      ],
+      "PI_PROTOCOL",
+    ],
+  ])("rejects %s output", async (_name, lines, code) => {
+    await expect(
+      (await runner(fakeSpawn(lines as string[]))).run({
+        agent: agent(),
+        prompt: "x",
+        onSpawn: vi.fn(),
+      }),
+    ).rejects.toMatchObject({ code });
+  });
+
+  it("rejects oversized output, failed processes, and unverifiable identities", async () => {
+    await expect(
+      (await runner(fakeSpawn(["x".repeat(20)]), 10)).run({
+        agent: agent(),
+        prompt: "x",
+        onSpawn: vi.fn(),
+      }),
+    ).rejects.toMatchObject({ code: "PI_PROTOCOL" });
+    await expect(
+      (await runner(fakeSpawn(events(), 1))).run({ agent: agent(), prompt: "x", onSpawn: vi.fn() }),
+    ).rejects.toMatchObject({ code: "PI_PROCESS" });
+    const fixture = fakeSpawn([]);
+    await expect(
+      new PiPrintRunner({
+        spawn: fixture.spawn,
+        processInspector: { getIdentity: () => null },
+      }).run({
+        agent: agent(),
+        prompt: "x",
+        onSpawn: vi.fn(),
+      }),
+    ).rejects.toMatchObject({ code: "PI_PROCESS" });
+    expect(fixture.child.kill).toHaveBeenCalledOnce();
+  });
+
+  it("rejects invalid and duplicate session identities", async () => {
+    for (const lines of [
+      [JSON.stringify({ type: "session", id: "bad" }), ""],
+      [
+        JSON.stringify({ type: "session", id: SESSION }),
+        JSON.stringify({ type: "session", id: SESSION }),
+        "",
+      ],
+    ])
+      await expect(
+        (await runner(fakeSpawn(lines))).run({
+          agent: agent(),
+          prompt: "x",
+          onSpawn: vi.fn(),
+          onSession: vi.fn(),
+        }),
+      ).rejects.toMatchObject({ code: "PI_PROTOCOL" });
+  });
+
+  it("kills on spawn persistence failure", async () => {
+    const spawnFailure = fakeSpawn([]);
+    const failure = new Error("cannot persist");
+    await expect(
+      (await runner(spawnFailure)).run({
+        agent: agent(),
+        prompt: "x",
+        onSpawn: vi.fn().mockRejectedValue(failure),
+        onSession: vi.fn(),
+      }),
+    ).rejects.toBe(failure);
+    expect(spawnFailure.child.kill).toHaveBeenCalledOnce();
+  });
+
+  it("classifies spawn errors and a missing PID as process failures", async () => {
+    const errored = fakeSpawn([]);
+    errored.child.stdin = new Writable({
+      write(_chunk, _encoding, callback) {
+        callback();
+      },
+      final(callback) {
+        queueMicrotask(() => errored.child.emit("error", new Error("spawn")));
+        callback();
+      },
+    });
+    await expect(
+      (await runner(errored)).run({
+        agent: agent(),
+        prompt: "x",
+        onSpawn: vi.fn(),
+        onSession: vi.fn(),
+      }),
+    ).rejects.toMatchObject({ code: "PI_PROCESS" });
+    const missing = fakeSpawn([]);
+    missing.child.pid = undefined;
+    await expect(
+      (await runner(missing)).run({
+        agent: agent(),
+        prompt: "x",
+        onSpawn: vi.fn(),
+        onSession: vi.fn(),
+      }),
+    ).rejects.toMatchObject({ code: "PI_PROCESS" });
+    expect(missing.child.kill).toHaveBeenCalledOnce();
+  });
+
+  it("accepts string assistant content and ignores empty or unrelated messages", async () => {
+    const lines = [
+      JSON.stringify({ type: "session", id: SESSION }),
+      JSON.stringify({ type: "future" }),
+      JSON.stringify({ type: "message_end", message: { role: "user", content: "ignored" } }),
+      JSON.stringify({ type: "message_end", message: { role: "assistant", content: " " } }),
+      JSON.stringify({ type: "message_end", message: { role: "assistant", content: "answer" } }),
+      JSON.stringify({ type: "agent_end" }),
+      "",
+    ];
+    await expect(
+      (await runner(fakeSpawn(lines))).run({
+        agent: agent(),
+        prompt: "x",
+        onSpawn: vi.fn(),
+        onSession: vi.fn(),
+      }),
+    ).resolves.toMatchObject({ result: "answer" });
+  });
+});

package/src/__tests__/harnesses/pi/durable/PiStreamParser.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+import { PiStreamParser } from "../../../../harnesses/pi/durable/PiStreamParser.js";
+
+const SESSION = "22222222-2222-4222-8222-222222222222";
+
+describe("PiStreamParser", () => {
+  it("ignores blank lines and normalizes unexpected parser failures", () => {
+    const parser = new PiStreamParser(SESSION, 1024);
+    parser.accept("\n");
+    parser.fail(new Error("unexpected"));
+
+    expect(parser.hasFailed()).toBe(true);
+    expect(() => parser.result({ code: 0, signal: null })).toThrowError(
+      expect.objectContaining({ code: "PI_PROTOCOL", message: "Pi stream processing failed." }),
+    );
+  });
+
+  it("includes the terminating signal in process failures", () => {
+    const parser = new PiStreamParser(SESSION, 1024);
+    parser.accept(`${JSON.stringify({ type: "session", id: SESSION })}\n`);
+
+    expect(() => parser.result({ code: null, signal: "SIGTERM" })).toThrowError(
+      expect.objectContaining({ code: "PI_PROCESS", message: "Pi print run failed (SIGTERM)" }),
+    );
+  });
+});

package/src/__tests__/harnesses/readiness/AgentReadiness.test.ts

@@ -0,0 +1,285 @@
+import path from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import {
+  getAgentReadinessReport,
+  getAgentReadinessReports,
+  type AgentReadinessOptions,
+  type ReadinessAgentType,
+} from "../../../harnesses/readiness/AgentReadiness.js";
+import { HARNESS_RUNTIME_PROFILES } from "../../../harnesses/runtimeProfiles.js";
+
+type Files = Record<string, string>;
+
+const builtInSkillNames = ["agent-management", "memory", "verify"];
+const skillRoots: Record<string, string> = {
+  claude: ".claude/skills",
+  codex: ".codex/skills",
+  copilot: ".copilot/skills",
+  gemini_cli: ".gemini/skills",
+  grok_cli: ".grok/skills",
+  antigravity_cli: ".gemini/config/skills",
+  opencode: ".config/opencode/skill",
+  pi: ".pi/agent/skills",
+};
+
+function fixture(overrides: Partial<AgentReadinessOptions> = {}) {
+  const homeDir = "/home/test";
+  const assetRoot = "/assets";
+  const files: Files = {
+    [path.join(homeDir, ".codex", "hooks", "codex-session-mapping.cjs")]: "codex-hook",
+    [path.join(assetRoot, "codex", "codex-session-mapping.cjs")]: "codex-hook",
+    [path.join(homeDir, ".codex", "hooks.json")]: JSON.stringify({
+      hooks: {
+        SessionStart: [
+          {
+            hooks: [{ type: "command", command: "node ~/.codex/hooks/codex-session-mapping.cjs" }],
+          },
+        ],
+      },
+    }),
+    [path.join(homeDir, ".codex", "ai-devkit", "sessions.json")]: JSON.stringify({
+      "123": "/sessions/codex.jsonl",
+    }),
+    "/sessions/codex.jsonl": "",
+    [path.join(homeDir, ".claude", "hooks", "claude-prompt-hook.js")]: "claude-hook",
+    [path.join(assetRoot, "claude", "claude-prompt-hook.js")]: "claude-hook",
+    [path.join(homeDir, ".claude", "settings.json")]: JSON.stringify({
+      hooks: {
+        PreToolUse: [
+          { hooks: [{ type: "command", command: "node ~/.claude/hooks/claude-prompt-hook.js" }] },
+        ],
+      },
+    }),
+    [path.join(homeDir, ".pi", "agent", "sessions.json")]: JSON.stringify({
+      "456": "/sessions/missing-pi.jsonl",
+    }),
+    [path.join(homeDir, ".pi", "agent", "auth.json")]: JSON.stringify({
+      anthropic: { access: "access-secret", refresh: "refresh-secret" },
+      litellm: { key: "litellm-secret", env: { LITELLM_BASE_URL: "https://litellm.example.test" } },
+    }),
+  };
+  for (const directory of [
+    ".claude",
+    ".codex",
+    ".copilot",
+    ".gemini",
+    ".grok",
+    ".kiro",
+    ".gemini/antigravity-cli",
+    ".config/opencode",
+    ".pi",
+  ]) {
+    files[path.join(homeDir, directory)] = "<dir>";
+  }
+  for (const root of Object.values(skillRoots)) {
+    for (const skill of builtInSkillNames) {
+      files[path.join(homeDir, root, skill, "SKILL.md")] = "# skill";
+    }
+  }
+  const executablePaths = Object.values(HARNESS_RUNTIME_PROFILES).map((agent) =>
+    path.join("/bin", agent.command),
+  );
+  const options: AgentReadinessOptions = {
+    homeDir,
+    path: "/bin",
+    assetRoot,
+    builtInSkillNames,
+    skillRoots,
+    readFile: async (target) => {
+      if (!(target in files)) throw new Error("missing");
+      return files[target];
+    },
+    access: async (target) => {
+      if (executablePaths.includes(target) || target in files) return;
+      throw new Error("missing");
+    },
+    runCommand: vi.fn(async (command) => {
+      if (command === "pi") return { stdout: "npm:@ai-devkit/pi-session-tracker\n", stderr: "" };
+      if (command === "claude") return { stdout: JSON.stringify({ loggedIn: true }), stderr: "" };
+      if (command === "gh")
+        return { stdout: "github.com\n  Logged in to github.com account test-user\n", stderr: "" };
+      if (command === "opencode")
+        return { stdout: "●  litellm api\n●  OpenAI oauth\n", stderr: "" };
+      throw new Error(`unexpected command ${command}`);
+    }),
+    codexAuth: async () => true,
+    ...overrides,
+  };
+  return { options, files };
+}
+
+describe("agent readiness", () => {
+  it("reports every readiness-supported adapter with generic checks and only real integrations", async () => {
+    const { options } = fixture();
+
+    const reports = await getAgentReadinessReports(options);
+
+    expect(Object.keys(reports)).toEqual([
+      "claude",
+      "codex",
+      "gemini_cli",
+      "grok_cli",
+      "kiro",
+      "antigravity_cli",
+      "opencode",
+      "copilot",
+      "pi",
+    ]);
+    for (const [agent, report] of Object.entries(reports) as Array<
+      [ReadinessAgentType, (typeof reports)[ReadinessAgentType]]
+    >) {
+      expect(report.type).toBe(agent);
+      expect(report.executable.status).toBe("pass");
+      expect(report.globalConfig.status).toBe("pass");
+      expect(report.builtInSkills.status).toBe("info");
+    }
+    expect(reports.gemini_cli.builtInSkills).toMatchObject({ present: 3, required: 3 });
+    expect(reports.antigravity_cli.builtInSkills).toMatchObject({ present: 3, required: 3 });
+    expect(reports.kiro.builtInSkills).toMatchObject({
+      path: null,
+      present: 0,
+      required: 3,
+      missing: builtInSkillNames,
+    });
+    expect(reports.codex.integration).toMatchObject({
+      label: "ai-devkit hook",
+      installed: true,
+      status: "pass",
+    });
+    expect(reports.claude.integration).toMatchObject({
+      label: "ai-devkit hook",
+      installed: true,
+      status: "pass",
+    });
+    expect(reports.pi.integration).toMatchObject({
+      label: "ai-devkit plugin",
+      installed: true,
+      status: "pass",
+    });
+    expect(reports.copilot.integration).toBeUndefined();
+    expect(reports.gemini_cli.integration).toBeUndefined();
+    expect(reports.grok_cli.integration).toBeUndefined();
+    expect(reports.kiro.integration).toBeUndefined();
+    expect(reports.antigravity_cli.integration).toBeUndefined();
+    expect(reports.opencode.integration).toBeUndefined();
+  });
+
+  it("resolves agent executables from PATH directories containing spaces", async () => {
+    const spacedBin = "/Applications/Some App.app/Contents/Resources";
+    const codexPath = path.join(spacedBin, HARNESS_RUNTIME_PROFILES.codex.command);
+    const { options } = fixture({
+      path: [spacedBin, "/usr/local/bin"].join(path.delimiter),
+      access: async (target) => {
+        if (target === codexPath || target.startsWith("/home/test")) return;
+        throw new Error("missing");
+      },
+    });
+
+    const report = await getAgentReadinessReport("codex", options);
+
+    expect(report.executable).toMatchObject({ command: "codex", path: codexPath, status: "pass" });
+  });
+
+  it("parses Pi provider names without returning credential values", async () => {
+    const { options } = fixture();
+
+    const report = await getAgentReadinessReport("pi", options);
+    const serialized = JSON.stringify(report);
+
+    expect(report.auth).toMatchObject({
+      state: "authenticated",
+      provider: null,
+      availableProviders: ["anthropic", "litellm"],
+      status: "pass",
+    });
+    expect(serialized).not.toContain("access-secret");
+    expect(serialized).not.toContain("refresh-secret");
+    expect(serialized).not.toContain("litellm-secret");
+    expect(serialized).not.toContain("litellm.example.test");
+  });
+
+  it("accepts Pi session tracker display names from pi list output", async () => {
+    const { options } = fixture({
+      runCommand: vi.fn(async (command) => {
+        if (command === "pi") return { stdout: "session tracker\n", stderr: "" };
+        if (command === "claude") return { stdout: JSON.stringify({ loggedIn: true }), stderr: "" };
+        throw new Error(`unexpected command ${command}`);
+      }),
+    });
+
+    const report = await getAgentReadinessReport("pi", options);
+
+    expect(report.integration).toMatchObject({
+      label: "ai-devkit plugin",
+      installed: true,
+      status: "pass",
+    });
+  });
+
+  it("reports missing built-in skills as informational readiness", async () => {
+    const { options, files } = fixture();
+    delete files[path.join(options.homeDir!, skillRoots.codex, "verify", "SKILL.md")];
+
+    const report = await getAgentReadinessReport("codex", options);
+
+    expect(report.builtInSkills).toMatchObject({
+      status: "info",
+      present: 2,
+      required: 3,
+      missing: ["verify"],
+    });
+    expect(report.status).toBe("pass");
+  });
+
+  it("checks OpenCode auth from auth list output", async () => {
+    const { options } = fixture({
+      runCommand: vi.fn(async (command) => {
+        if (command === "opencode") {
+          return {
+            stdout: "\x1B[32m●\x1B[0m  litellm api\n●  OpenAI oauth\n●  GitLab Duo GITLAB_TOKEN\n",
+            stderr: "",
+          };
+        }
+        if (command === "pi") return { stdout: "npm:@ai-devkit/pi-session-tracker\n", stderr: "" };
+        if (command === "claude") return { stdout: JSON.stringify({ loggedIn: true }), stderr: "" };
+        throw new Error(`unexpected command ${command}`);
+      }),
+    });
+
+    const report = await getAgentReadinessReport("opencode", options);
+
+    expect(report.auth).toMatchObject({
+      state: "authenticated",
+      source: "opencode auth list",
+      provider: null,
+      availableProviders: ["GitLab Duo", "OpenAI", "litellm"],
+      status: "pass",
+    });
+  });
+
+  it("checks Copilot auth through GitHub CLI authentication", async () => {
+    const { options } = fixture({
+      runCommand: vi.fn(async (command) => {
+        if (command === "gh")
+          return {
+            stdout: "github.com\n  Logged in to github.com account test-user\n",
+            stderr: "",
+          };
+        if (command === "pi") return { stdout: "npm:@ai-devkit/pi-session-tracker\n", stderr: "" };
+        if (command === "claude") return { stdout: JSON.stringify({ loggedIn: true }), stderr: "" };
+        if (command === "opencode") return { stdout: "●  litellm api\n", stderr: "" };
+        throw new Error(`unexpected command ${command}`);
+      }),
+    });
+
+    const report = await getAgentReadinessReport("copilot", options);
+
+    expect(report.auth).toMatchObject({
+      state: "authenticated",
+      source: "gh auth status --hostname github.com",
+      provider: "github",
+      availableProviders: ["GitHub"],
+      status: "pass",
+    });
+  });
+});

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

@@ -0,0 +1,110 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  HARNESS_RUNTIME_PROFILES,
+  runtimeAgentMatchesHarness,
+} from "../../harnesses/runtimeProfiles.js";
+
+describe("harness runtime profiles", () => {
+  it("keeps launch and runtime identity metadata together", () => {
+    expect(HARNESS_RUNTIME_PROFILES.antigravity_cli).toMatchObject({
+      command: "agy",
+      runtimeKind: "agy",
+      discoveryAliases: ["agy", "antigravity", "antigravity_cli"],
+    });
+    expect(HARNESS_RUNTIME_PROFILES.antigravity_cli.matches("/usr/local/bin/agy")).toBe(true);
+  });
+
+  it("recognizes agent commands without matching similar argument text", () => {
+    expect(HARNESS_RUNTIME_PROFILES.copilot.matches("/opt/copilot-cli/1.0/copilot")).toBe(true);
+    expect(HARNESS_RUNTIME_PROFILES.copilot.matches("node /repo/copilot-cli/script.js")).toBe(
+      false,
+    );
+    expect(HARNESS_RUNTIME_PROFILES.grok_cli.matches("/Users/dev/.grok/bin/grok --approve")).toBe(
+      true,
+    );
+    expect(HARNESS_RUNTIME_PROFILES.grok_cli.matches("node /repo/grok-cli/script.js")).toBe(false);
+    expect(
+      HARNESS_RUNTIME_PROFILES.gemini_cli.matches("node --no-warnings /usr/local/bin/gemini"),
+    ).toBe(true);
+  });
+
+  it("matches runtime discovery names through the owning harness profile", () => {
+    expect(runtimeAgentMatchesHarness("kiro-cli", "kiro")).toBe(true);
+    expect(runtimeAgentMatchesHarness("gemini", "gemini_cli")).toBe(true);
+    expect(runtimeAgentMatchesHarness("codex", "claude")).toBe(false);
+  });
+});
+
+describe("harness matchers with executables under paths containing spaces", () => {
+  let root: 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(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), "runtime-profiles-spaces-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it("recognizes argv[0] under a spaced directory", () => {
+    const codex = install("Applications/Some App.app/Contents/Resources/codex");
+    const claude = install("Users/dev/My Tools/bin/claude");
+
+    expect(HARNESS_RUNTIME_PROFILES.codex.matches(`${codex} --sandbox workspace-write`)).toBe(true);
+    expect(HARNESS_RUNTIME_PROFILES.codex.matches(codex)).toBe(true);
+    expect(HARNESS_RUNTIME_PROFILES.claude.matches(`${claude} --continue`)).toBe(true);
+    expect(HARNESS_RUNTIME_PROFILES.claude.matches(`${codex} exec --cd /repo`)).toBe(false);
+  });
+
+  it("recognizes argv[0] by distribution name under a spaced directory", () => {
+    const copilot = install("opt/Home Brew/Caskroom/copilot-cli/1.0.60/copilot");
+
+    expect(HARNESS_RUNTIME_PROFILES.copilot.matches(`${copilot} --allow-all-tools`)).toBe(true);
+  });
+
+  it("does not treat arguments containing spaces as the executable", () => {
+    const vim = install("usr/bin/vim");
+    const codex = install("Applications/Some App.app/Contents/Resources/codex");
+
+    expect(HARNESS_RUNTIME_PROFILES.claude.matches(`${vim} My Notes/claude`)).toBe(false);
+    expect(
+      HARNESS_RUNTIME_PROFILES.claude.matches(`${codex} exec review the Other Dir/claude`),
+    ).toBe(false);
+    expect(HARNESS_RUNTIME_PROFILES.copilot.matches(`${vim} Some Dir/copilot-cli/notes.md`)).toBe(
+      false,
+    );
+    expect(HARNESS_RUNTIME_PROFILES.claude.matches("/usr/bin/vim My Notes/claude")).toBe(false);
+  });
+
+  it("recognizes spaced argv[0] in script-aware matchers", () => {
+    const pi = install("Users/dev/Node Tools/bin/pi");
+    const kiro = install("Applications/Kiro CLI.app/Contents/MacOS/kiro-cli");
+    const node = install("Applications/Dev Tools/node/bin/node");
+
+    expect(HARNESS_RUNTIME_PROFILES.pi.matches(`${pi} --model x`)).toBe(true);
+    expect(HARNESS_RUNTIME_PROFILES.kiro.matches(`${kiro} chat`)).toBe(true);
+    expect(
+      HARNESS_RUNTIME_PROFILES.gemini_cli.matches(`${node} /Users/dev/.npm/bin/gemini --yolo`),
+    ).toBe(true);
+    expect(HARNESS_RUNTIME_PROFILES.pi.matches(`${node} /opt/pi-tools/script.js`)).toBe(false);
+  });
+
+  it("does not match agent words inside an executable directory", () => {
+    const node = install("opt/Dev pi gemini/bin/node");
+
+    expect(HARNESS_RUNTIME_PROFILES.pi.matches(`${node} /repo/script.js`)).toBe(false);
+    expect(HARNESS_RUNTIME_PROFILES.gemini_cli.matches(`${node} /repo/script.js`)).toBe(false);
+    expect(HARNESS_RUNTIME_PROFILES.gemini_cli.matches(`${node} /repo/bin/gemini`)).toBe(true);
+    expect(HARNESS_RUNTIME_PROFILES.pi.matches(`${node} --title pi`)).toBe(true);
+  });
+});