@ai-devkit/agent-manager 0.37.0 → 0.39.0

package/src/__tests__/{readiness → harnesses/readiness}/AgentReadiness.test.ts

@@ -1,21 +1,23 @@
 import path from "node:path";
 import { describe, expect, it, vi } from "vitest";
 import {
-  AGENTS,
   getAgentReadinessReport,
   getAgentReadinessReports,
   type AgentReadinessOptions,
   type ReadinessAgentType,
-} from "../../index.js";
+} 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<ReadinessAgentType, string> = {
+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",
 };
@@ -56,7 +58,18 @@ function fixture(overrides: Partial<AgentReadinessOptions> = {}) {
       litellm: { key: "litellm-secret", env: { LITELLM_BASE_URL: "https://litellm.example.test" } },
     }),
   };
-  for (const directory of [".claude", ".codex", ".copilot", ".grok", ".config/opencode", ".pi"]) {
+  for (const directory of [
+    ".claude",
+    ".codex",
+    ".copilot",
+    ".gemini",
+    ".grok",
+    ".kiro",
+    ".gemini/antigravity-cli",
+    ".config/opencode",
+    ".config/devin",
+    ".pi",
+  ]) {
     files[path.join(homeDir, directory)] = "<dir>";
   }
   for (const root of Object.values(skillRoots)) {
@@ -64,7 +77,9 @@ function fixture(overrides: Partial<AgentReadinessOptions> = {}) {
       files[path.join(homeDir, root, skill, "SKILL.md")] = "# skill";
     }
   }
-  const executablePaths = Object.values(AGENTS).map((agent) => path.join("/bin", agent.command));
+  const executablePaths = Object.values(HARNESS_RUNTIME_PROFILES).map((agent) =>
+    path.join("/bin", agent.command),
+  );
   const options: AgentReadinessOptions = {
     homeDir,
     path: "/bin",
@@ -86,6 +101,8 @@ function fixture(overrides: Partial<AgentReadinessOptions> = {}) {
         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: "" };
+      if (command === "devin")
+        return { stdout: "Logged in (via Devin).\n\nUser:\n  Name: test-user\n", stderr: "" };
       throw new Error(`unexpected command ${command}`);
     }),
     codexAuth: async () => true,
@@ -103,20 +120,31 @@ describe("agent readiness", () => {
     expect(Object.keys(reports)).toEqual([
       "claude",
       "codex",
-      "copilot",
+      "gemini_cli",
       "grok_cli",
+      "kiro",
+      "antigravity_cli",
       "opencode",
+      "copilot",
       "pi",
+      "devin",
     ]);
-    expect(reports).not.toHaveProperty("gemini_cli");
     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).toMatchObject({ status: "info", present: 3, required: 3 });
+      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,
@@ -133,13 +161,16 @@ describe("agent readiness", () => {
       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, AGENTS.codex.command);
+    const codexPath = path.join(spacedBin, HARNESS_RUNTIME_PROFILES.codex.command);
     const { options } = fixture({
       path: [spacedBin, "/usr/local/bin"].join(path.delimiter),
       access: async (target) => {
@@ -255,4 +286,41 @@ describe("agent readiness", () => {
       status: "pass",
     });
   });
+
+  it("checks Devin auth from devin auth status output", async () => {
+    const { options } = fixture({
+      runCommand: vi.fn(async (command) => {
+        if (command === "devin")
+          return { stdout: "Logged in (via Devin).\n\nUser:\n  Name: 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: "" };
+        throw new Error(`unexpected command ${command}`);
+      }),
+    });
+
+    const report = await getAgentReadinessReport("devin", options);
+
+    expect(report.auth).toMatchObject({
+      state: "authenticated",
+      source: "devin auth status",
+      provider: null,
+      availableProviders: ["devin"],
+      status: "pass",
+    });
+  });
+
+  it("reports Devin as unauthenticated without a login line", async () => {
+    const { options } = fixture({
+      runCommand: vi.fn(async (command) => {
+        if (command === "devin") return { stdout: "Not logged in\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("devin", options);
+
+    expect(report.auth).toMatchObject({ state: "unauthenticated", status: "fail" });
+  });
 });

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);
+  });
+});

package/src/__tests__/print/DurableAgent.test.ts

@@ -1,18 +1,9 @@
 import { describe, expect, it } from "vitest";
+import { DurableAgentBusyError } from "../../durable/DurableAgent.js";
 
-describe("durable-agent public domain", () => {
-  it("exports a classified busy error without exposing prompt data", async () => {
-    const api = (await import("../../index.js")) as Record<string, unknown>;
-
-    expect(api).toHaveProperty("DurableAgentBusyError");
-    const ErrorType = api.DurableAgentBusyError as new (
-      agentId: string,
-      name: string,
-    ) => Error & {
-      code: string;
-      agentId: string;
-    };
-    const error = new ErrorType("agent-id", "reviewer");
+describe("durable-agent errors", () => {
+  it("classifies a busy error without exposing prompt data", () => {
+    const error = new DurableAgentBusyError("agent-id", "reviewer");
 
     expect(error).toMatchObject({
       name: "DurableAgentBusyError",

package/src/__tests__/print/DurableAgentRepository.test.ts

@@ -2,6 +2,7 @@ import fs from "fs";
 import os from "os";
 import path from "path";
 import { afterEach, describe, expect, it } from "vitest";
+import { DurableAgentRepository } from "../../durable/DurableAgentRepository.js";
 
 const tempDirs: string[] = [];
 
@@ -9,12 +10,6 @@ afterEach(() => {
   for (const dir of tempDirs.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
 });
 
-async function loadStore(): Promise<any> {
-  const api = (await import("../../index.js")) as Record<string, unknown>;
-  expect(api).toHaveProperty("DurableAgentRepository");
-  return api.DurableAgentRepository;
-}
-
 function fixture(): { root: string; cwd: string; dbPath: string } {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), "durable-agent-store-"));
   tempDirs.push(root);
@@ -25,7 +20,6 @@ function fixture(): { root: string; cwd: string; dbPath: string } {
 
 describe("DurableAgentRepository create/list/resolve", () => {
   it("creates distinct durable identities with a canonical cwd and lists them", async () => {
-    const DurableAgentRepository = await loadStore();
     const { cwd, dbPath } = fixture();
     const repository = new DurableAgentRepository({
       dbPath,
@@ -51,7 +45,6 @@ describe("DurableAgentRepository create/list/resolve", () => {
   });
 
   it("resolves exact ids and names and rejects duplicate names", async () => {
-    const DurableAgentRepository = await loadStore();
     const { cwd, dbPath } = fixture();
     const repository = new DurableAgentRepository({ dbPath });
     const agent = await repository.create({ name: "Reviewer", cwd });
@@ -65,7 +58,6 @@ describe("DurableAgentRepository create/list/resolve", () => {
   });
 
   it("rejects a missing cwd", async () => {
-    const DurableAgentRepository = await loadStore();
     const { root, dbPath } = fixture();
     const repository = new DurableAgentRepository({ dbPath });
 
@@ -77,7 +69,6 @@ describe("DurableAgentRepository create/list/resolve", () => {
 
 describe("DurableAgentRepository run ownership", () => {
   it("fails fast when another exact owner is live and completes only for its token", async () => {
-    const DurableAgentRepository = await loadStore();
     const { cwd, dbPath } = fixture();
     const live = new Map<number, string>([[process.pid, "owner-start"]]);
     const processInspector = {
@@ -112,7 +103,6 @@ describe("DurableAgentRepository run ownership", () => {
   });
 
   it("retains busy for a live provider then recovers a dead run without signaling it", async () => {
-    const DurableAgentRepository = await loadStore();
     const { cwd, dbPath } = fixture();
     const live = new Map<number, string>([
       [process.pid, "owner-start"],
@@ -151,7 +141,6 @@ describe("DurableAgentRepository run ownership", () => {
   });
 
   it("reconciles an interrupted run to degraded during list", async () => {
-    const DurableAgentRepository = await loadStore();
     const { cwd, dbPath } = fixture();
     const live = new Map<number, string>([[process.pid, "owner-start"]]);
     const repository = new DurableAgentRepository({
@@ -179,7 +168,6 @@ describe("DurableAgentRepository run ownership", () => {
   });
 
   it("rejects send acquisition when the bound cwd is replaced by a symlink", async () => {
-    const DurableAgentRepository = await loadStore();
     const { root, cwd, dbPath } = fixture();
     const repository = new DurableAgentRepository({ dbPath });
     const agent = await repository.create({ name: "bound", cwd });

package/src/__tests__/runtime/ManagedAgentRuntime.test.ts

@@ -15,7 +15,7 @@ import {
 } from "../../runtime/ManagedAgentRuntime.js";
 import type { AgentInfo } from "../../adapters/AgentAdapter.js";
 import type { AgentRegistry, RegistryEntry } from "../../utils/AgentRegistry.js";
-import type { TmuxManager } from "../../terminal/TmuxManager.js";
+import type { TmuxManager } from "../../runtime/tmux/TmuxManager.js";
 import type { InteractiveAgentRuntime } from "../../runtime/types.js";
 
 function makeAgent(overrides: Partial<AgentInfo> = {}): AgentInfo {

package/src/__tests__/terminal/GhosttyBackend.test.ts

@@ -0,0 +1,271 @@
+import { execFile } from "child_process";
+import { writeFile } from "fs/promises";
+import type { Mock } from "vitest";
+
+import { ghosttyBackend } from "../../terminal/backends/ghostty.js";
+import { TerminalType, type TerminalLocation } from "../../terminal/types.js";
+import { TtyWriter } from "../../terminal/TtyWriter.js";
+import { getProcessCwdsAsync } from "../../utils/process.js";
+
+vi.mock("child_process", async () => {
+  const actual = await vi.importActual<typeof import("child_process")>("child_process");
+  return { ...actual, execFile: vi.fn() };
+});
+
+vi.mock("fs/promises", async () => {
+  const actual = await vi.importActual<typeof import("fs/promises")>("fs/promises");
+  return { ...actual, writeFile: vi.fn() };
+});
+
+vi.mock("../../utils/process.js", async () => {
+  const actual =
+    await vi.importActual<typeof import("../../utils/process.js")>("../../utils/process.js");
+  return { ...actual, getProcessCwdsAsync: vi.fn() };
+});
+
+const mockedExecFile = execFile as unknown as Mock;
+const mockedGetProcessCwds = getProcessCwdsAsync as unknown as Mock;
+const mockedWriteFile = writeFile as unknown as Mock;
+const SEP = "\x1f";
+
+interface FakeTerminal {
+  id: string;
+  name: string;
+  dir: string;
+}
+
+/**
+ * Fake `ps`, process cwds and Ghostty AppleScript. `processes` rows are
+ * `pid ppid tty comm`; `cwds` maps pid to its working directory. Writing an
+ * OSC 2 title to a TTY renames the terminal listed in `ttyOwner`.
+ */
+function fakeSystem(opts: {
+  processes: string[];
+  cwds?: Record<number, string>;
+  terminals: FakeTerminal[];
+  ttyOwner?: Record<string, string>;
+  osascriptResult?: string;
+}) {
+  const terminals = opts.terminals.map((t) => ({ ...t }));
+  mockedGetProcessCwds.mockImplementation(async (pids: number[]) => {
+    const cwds = new Map<number, string>();
+    for (const pid of pids) if (opts.cwds?.[pid]) cwds.set(pid, opts.cwds[pid]);
+    return cwds;
+  });
+  mockedWriteFile.mockImplementation(async (tty: string, data: string) => {
+    // eslint-disable-next-line no-control-regex
+    const title = /^\x1b\]2;(.*)\x07$/.exec(data)?.[1];
+    const owner = terminals.find((t) => t.id === opts.ttyOwner?.[tty]);
+    if (owner && title !== undefined) owner.name = title;
+  });
+  mockedExecFile.mockImplementation((...args: unknown[]) => {
+    const [cmd, argv] = args as [string, string[]];
+    const cb = args[args.length - 1] as (err: Error | null, r?: { stdout: string }) => void;
+    let stdout = "";
+    if (cmd === "ps") stdout = opts.processes.join("\n") + "\n";
+    else if (cmd === "osascript" && argv[1].includes("repeat with t in terminals")) {
+      stdout = terminals.map((t) => [t.id, t.name, t.dir].join(SEP)).join("\n") + "\n";
+    } else if (cmd === "osascript") stdout = opts.osascriptResult ?? "ok\n";
+    cb(null, { stdout });
+    return {};
+  });
+  return terminals;
+}
+
+const GHOSTTY = "500 1 ?? /Applications/Ghostty.app/Contents/MacOS/ghostty";
+
+describe("Ghostty terminal backend", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("find", () => {
+    it("ignores TTYs when Ghostty is not running", async () => {
+      fakeSystem({ processes: ["600 1 ttys001 /usr/bin/login"], terminals: [] });
+
+      expect(await ghosttyBackend.find("/dev/ttys001")).toBeNull();
+      expect(mockedExecFile).not.toHaveBeenCalledWith(
+        "osascript",
+        expect.anything(),
+        expect.anything(),
+      );
+    });
+
+    it("ignores TTYs whose session was not started by Ghostty", async () => {
+      fakeSystem({
+        processes: [GHOSTTY, "600 500 ttys001 /usr/bin/login", "700 1 ttys002 /usr/bin/login"],
+        terminals: [{ id: "T1", name: "zsh", dir: "/repo" }],
+      });
+
+      expect(await ghosttyBackend.find("/dev/ttys002")).toBeNull();
+      expect(mockedWriteFile).not.toHaveBeenCalled();
+    });
+
+    it("matches by working directory when it pairs one terminal with one TTY", async () => {
+      fakeSystem({
+        processes: [
+          GHOSTTY,
+          "600 500 ttys001 /usr/bin/login",
+          "601 600 ttys001 -zsh",
+          "602 601 ttys001 claude",
+          "700 500 ttys002 /usr/bin/login",
+          "701 700 ttys002 -zsh",
+        ],
+        cwds: { 601: "/repo/a", 602: "/repo/a", 701: "/repo/b" },
+        terminals: [
+          { id: "T1", name: "claude", dir: "/repo/a" },
+          { id: "T2", name: "zsh", dir: "/repo/b" },
+        ],
+      });
+
+      expect(await ghosttyBackend.find("/dev/ttys001")).toEqual({
+        type: TerminalType.GHOSTTY,
+        identifier: "T1",
+        tty: "/dev/ttys001",
+      });
+      expect(mockedWriteFile).not.toHaveBeenCalled();
+    });
+
+    it("uses a title marker when two terminals share the directory, then restores the title", async () => {
+      const terminals = fakeSystem({
+        processes: [
+          GHOSTTY,
+          "600 500 ttys001 /usr/bin/login",
+          "601 600 ttys001 claude",
+          "700 500 ttys002 /usr/bin/login",
+          "701 700 ttys002 codex",
+        ],
+        cwds: { 601: "/repo", 701: "/repo" },
+        terminals: [
+          { id: "T1", name: "first agent", dir: "/repo" },
+          { id: "T2", name: "second agent", dir: "/repo" },
+        ],
+        ttyOwner: { "/dev/ttys001": "T1", "/dev/ttys002": "T2" },
+      });
+
+      const location = await ghosttyBackend.find("/dev/ttys002");
+
+      expect(location?.identifier).toBe("T2");
+      const titles = mockedWriteFile.mock.calls.map(([tty, data]) => [tty, data]);
+      expect(titles).toHaveLength(2);
+      expect(titles[0][0]).toBe("/dev/ttys002");
+      // eslint-disable-next-line no-control-regex
+      expect(titles[0][1]).toMatch(/^\x1b\]2;ai-devkit-\d+-\d+\x07$/);
+      expect(titles[1]).toEqual(["/dev/ttys002", "\x1b]2;second agent\x07"]);
+      expect(terminals.find((t) => t.id === "T2")?.name).toBe("second agent");
+    });
+
+    it("does not trust a unique directory match when another Ghostty TTY has a process there", async () => {
+      // T1's own working directory is unreported; T2 sits in the agent's directory.
+      fakeSystem({
+        processes: [
+          GHOSTTY,
+          "600 500 ttys001 /usr/bin/login",
+          "601 600 ttys001 claude",
+          "700 500 ttys002 /usr/bin/login",
+          "701 700 ttys002 -zsh",
+        ],
+        cwds: { 601: "/repo", 701: "/repo" },
+        terminals: [
+          { id: "T1", name: "claude", dir: "" },
+          { id: "T2", name: "zsh", dir: "/repo" },
+        ],
+        ttyOwner: { "/dev/ttys001": "T1", "/dev/ttys002": "T2" },
+      });
+
+      expect((await ghosttyBackend.find("/dev/ttys001"))?.identifier).toBe("T1");
+      expect(mockedWriteFile).toHaveBeenCalled();
+    });
+
+    it("returns null when no terminal shows the marker", async () => {
+      vi.useFakeTimers();
+      try {
+        fakeSystem({
+          processes: [GHOSTTY, "600 500 ttys001 /usr/bin/login"],
+          terminals: [
+            { id: "T1", name: "a", dir: "/x" },
+            { id: "T2", name: "b", dir: "/y" },
+          ],
+        });
+
+        const result = ghosttyBackend.find("/dev/ttys001");
+        await vi.runAllTimersAsync();
+
+        expect(await result).toBeNull();
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
+    it("returns null instead of throwing when Ghostty is not scriptable", async () => {
+      mockedGetProcessCwds.mockResolvedValue(new Map());
+      mockedExecFile.mockImplementation((...args: unknown[]) => {
+        const [cmd] = args as [string];
+        const cb = args[args.length - 1] as (err: Error | null, r?: { stdout: string }) => void;
+        if (cmd === "osascript") cb(new Error("Not authorized to send Apple events"));
+        else cb(null, { stdout: `${GHOSTTY}\n600 500 ttys001 /usr/bin/login\n` });
+        return {};
+      });
+
+      expect(await ghosttyBackend.find("/dev/ttys001")).toBeNull();
+    });
+  });
+
+  describe("focus, send and sendKey", () => {
+    const location: TerminalLocation = {
+      type: TerminalType.GHOSTTY,
+      identifier: "T1",
+      tty: "/dev/ttys001",
+    };
+    const scripts = () =>
+      mockedExecFile.mock.calls.filter(([cmd]) => cmd === "osascript").map(([, argv]) => argv[1]);
+
+    it("focuses the terminal by id and activates Ghostty", async () => {
+      fakeSystem({ processes: [], terminals: [] });
+
+      expect(await ghosttyBackend.focus(location)).toBe(true);
+      expect(scripts()[0]).toContain('every terminal whose id is "T1"');
+      expect(scripts()[0]).toContain("focus t");
+      expect(scripts()[0]).toContain("activate");
+    });
+
+    it("reports a failed focus when the terminal is gone", async () => {
+      fakeSystem({ processes: [], terminals: [], osascriptResult: "not_found\n" });
+
+      expect(await ghosttyBackend.focus(location)).toBe(false);
+    });
+
+    it("pastes the message with input text, then types a carriage return", async () => {
+      fakeSystem({ processes: [], terminals: [] });
+
+      await TtyWriter.send(location, 'say "hi"\nnext');
+
+      expect(scripts()).toHaveLength(2);
+      expect(scripts()[0]).toContain('input text "say \\"hi\\"\\nnext" to t');
+      expect(scripts()[1]).toContain('perform action "text:\\\\x0d" on t');
+    });
+
+    it("throws when the terminal is gone", async () => {
+      fakeSystem({ processes: [], terminals: [], osascriptResult: "not_found\n" });
+
+      await expect(TtyWriter.send(location, "hello")).rejects.toThrow(
+        "Ghostty terminal not found for TTY /dev/ttys001",
+      );
+    });
+
+    // Ghostty parses `text:` with Zig escapes; AppleScript doubles each backslash.
+    it.each([
+      ["2", "text:2"],
+      ["\x1b", "text:\\\\x1b"],
+      ["\r", "text:\\\\x0d"],
+      ["\\", "text:\\\\\\\\"],
+    ])("types key %j with the Ghostty action %s", async (key, action) => {
+      fakeSystem({ processes: [], terminals: [] });
+
+      await TtyWriter.sendKey(location, key);
+
+      expect(scripts()[0]).toContain(`perform action "${action}" on t`);
+      expect(scripts()[0]).not.toContain("send key");
+    });
+  });
+});

package/src/__tests__/terminal/TmuxManager.test.ts

@@ -1,6 +1,6 @@
 import { execFile } from "child_process";
 import type { MockedFunction } from "vitest";
-import { TmuxManager } from "../../terminal/TmuxManager.js";
+import { TmuxManager } from "../../runtime/tmux/TmuxManager.js";
 
 vi.mock("child_process", () => ({
   execFile: vi.fn(),

package/src/adapters/AgentAdapter.ts

@@ -16,6 +16,7 @@ export const AGENT_TYPES = [
   "opencode",
   "copilot",
   "pi",
+  "devin",
 ] as const;
 
 /**