@ai-devkit/agent-manager 0.33.1 → 0.35.0

package/src/__tests__/capacity/codex.test.ts

@@ -13,7 +13,11 @@ const context = { installed: true, checkedAt };
 function apiUsage(overrides: Record<string, unknown> = {}) {
   return {
     rate_limit: {
-      primary_window: { used_percent: 20, limit_window_seconds: 18_000, reset_at: 1_787_220_000 },
+      primary_window: {
+        used_percent: 20,
+        limit_window_seconds: 18_000,
+        reset_at: 1_787_220_000,
+      },
       secondary_window: {
         used_percent: 60,
         limit_window_seconds: 604_800,
@@ -39,13 +43,18 @@ function apiUsage(overrides: Record<string, unknown> = {}) {
 
 describe("Codex auth resolution", () => {
   it("uses CODEX_HOME before HOME", () => {
-    expect(resolveCodexAuthPath({ CODEX_HOME: "/custom/codex", HOME: "/users/test" })).toBe(
-      "/custom/codex/auth.json",
-    );
+    expect(
+      resolveCodexAuthPath({
+        CODEX_HOME: "/custom/codex",
+        HOME: "/users/test",
+      }),
+    ).toBe("/custom/codex/auth.json");
   });
 
   it("falls back to ~/.codex/auth.json", () => {
-    expect(resolveCodexAuthPath({ HOME: "/users/test" })).toBe("/users/test/.codex/auth.json");
+    expect(resolveCodexAuthPath({ HOME: "/users/test" })).toBe(
+      "/users/test/.codex/auth.json",
+    );
   });
 });
 
@@ -53,7 +62,11 @@ describe("Codex API usage mapping", () => {
   it("converts an API window without treating missing data as zero", () => {
     expect(
       toRateWindow(
-        { used_percent: 25, limit_window_seconds: 18_000, reset_at: 1_787_220_000 },
+        {
+          used_percent: 25,
+          limit_window_seconds: 18_000,
+          reset_at: 1_787_220_000,
+        },
         "session",
         "Session",
       ),
@@ -64,7 +77,9 @@ describe("Codex API usage mapping", () => {
       usedPercent: 25,
       resetsAt: "2026-08-20T10:00:00.000Z",
     });
-    expect(toRateWindow({}, "session", "Session")).toMatchObject({ usedPercent: null });
+    expect(toRateWindow({}, "session", "Session")).toMatchObject({
+      usedPercent: null,
+    });
   });
 
   it("maps session, weekly, credits, and extra limits", () => {
@@ -89,16 +104,23 @@ describe("tiered Codex probing", () => {
     const fetch = vi
       .fn()
       .mockResolvedValueOnce(
-        new Response(JSON.stringify({ chatgpt_account_id: "acct-1" }), { status: 200 }),
+        new Response(JSON.stringify({ chatgpt_account_id: "acct-1" }), {
+          status: 200,
+        }),
       )
-      .mockResolvedValueOnce(new Response(JSON.stringify(apiUsage()), { status: 200 }));
+      .mockResolvedValueOnce(
+        new Response(JSON.stringify(apiUsage()), { status: 200 }),
+      );
     const rpc = vi.fn();
     const result = await probeCodexCapacity({
       ...context,
       readFile: async () =>
         JSON.stringify({
           personal_access_token: "pat-secret",
-          tokens: { access_token: "ignored-oauth", account_id: "ignored-account" },
+          tokens: {
+            access_token: "ignored-oauth",
+            account_id: "ignored-account",
+          },
         }),
       fetch,
       rpc,
@@ -107,14 +129,17 @@ describe("tiered Codex probing", () => {
     expect(fetch.mock.calls[0][0]).toBe(
       "https://auth.openai.com/api/accounts/v1/user-auth-credential/whoami",
     );
-    expect(fetch.mock.calls[1][0]).toBe("https://chatgpt.com/backend-api/wham/usage");
+    expect(fetch.mock.calls[1][0]).toBe(
+      "https://chatgpt.com/backend-api/wham/usage",
+    );
     expect(fetch.mock.calls[1][1].headers).toMatchObject({
       Authorization: "Bearer pat-secret",
       "ChatGPT-Account-Id": "acct-1",
     });
     expect(rpc).not.toHaveBeenCalled();
     expect(result).toMatchObject({
-      provider: "codex",
+      harness: "codex",
+      provider: "openai",
       available: "yes",
       creditsRemaining: 12.5,
       authenticated: true,
@@ -129,12 +154,18 @@ describe("tiered Codex probing", () => {
   it("selects a fresh OAuth token without calling whoami", async () => {
     const fetch = vi
       .fn()
-      .mockResolvedValue(new Response(JSON.stringify(apiUsage()), { status: 200 }));
+      .mockResolvedValue(
+        new Response(JSON.stringify(apiUsage()), { status: 200 }),
+      );
     const result = await probeCodexCapacity({
       ...context,
       readFile: async () =>
         JSON.stringify({
-          tokens: { access_token: "oauth-secret", account_id: "acct-2", expires_at: 1_800_000_000 },
+          tokens: {
+            access_token: "oauth-secret",
+            account_id: "acct-2",
+            expires_at: 1_800_000_000,
+          },
         }),
       fetch,
       now: () => new Date("2026-08-20T10:00:00.000Z"),
@@ -158,23 +189,35 @@ describe("tiered Codex probing", () => {
       "stale OAuth token",
       async () =>
         JSON.stringify({
-          tokens: { access_token: "stale-secret", account_id: "acct", expires_at: 1 },
+          tokens: {
+            access_token: "stale-secret",
+            account_id: "acct",
+            expires_at: 1,
+          },
         }),
     ],
     [
       "OAuth 401",
       async () =>
         JSON.stringify({
-          tokens: { access_token: "oauth-secret", account_id: "acct", expires_at: 1_800_000_000 },
+          tokens: {
+            access_token: "oauth-secret",
+            account_id: "acct",
+            expires_at: 1_800_000_000,
+          },
         }),
     ],
   ])("falls back to the CLI for %s", async (name, readFile) => {
     const fetch = vi
       .fn()
-      .mockResolvedValue(new Response("", { status: name === "OAuth 401" ? 401 : 200 }));
+      .mockResolvedValue(
+        new Response("", { status: name === "OAuth 401" ? 401 : 200 }),
+      );
     const rpc = vi.fn(async () => ({
       rateLimits: {
-        rateLimits: { primary: { usedPercent: 5, windowDurationMins: 300, resetsAt: null } },
+        rateLimits: {
+          primary: { usedPercent: 5, windowDurationMins: 300, resetsAt: null },
+        },
       },
       account: { account: { type: "chatgpt" } },
     }));
@@ -190,10 +233,14 @@ describe("tiered Codex probing", () => {
   });
 
   it("falls back to CLI if PAT requests fail", async () => {
-    const rpc = vi.fn(async () => ({ rateLimits: {}, account: { account: null } }));
+    const rpc = vi.fn(async () => ({
+      rateLimits: {},
+      account: { account: null },
+    }));
     const result = await probeCodexCapacity({
       ...context,
-      readFile: async () => JSON.stringify({ personal_access_token: "pat-secret" }),
+      readFile: async () =>
+        JSON.stringify({ personal_access_token: "pat-secret" }),
       fetch: vi.fn().mockRejectedValue(new Error("network failure pat-secret")),
       rpc,
     });
@@ -205,14 +252,20 @@ describe("tiered Codex probing", () => {
     const fetch = vi
       .fn()
       .mockRejectedValueOnce(new Error("PAT failed"))
-      .mockResolvedValueOnce(new Response(JSON.stringify(apiUsage()), { status: 200 }));
+      .mockResolvedValueOnce(
+        new Response(JSON.stringify(apiUsage()), { status: 200 }),
+      );
     const rpc = vi.fn();
     const result = await probeCodexCapacity({
       ...context,
       readFile: async () =>
         JSON.stringify({
           personal_access_token: "pat-secret",
-          tokens: { access_token: "oauth-secret", account_id: "acct", expires_at: 1_800_000_000 },
+          tokens: {
+            access_token: "oauth-secret",
+            account_id: "acct",
+            expires_at: 1_800_000_000,
+          },
         }),
       fetch,
       rpc,
@@ -226,7 +279,9 @@ describe("tiered Codex probing", () => {
   it("uses hardened read-only app-server arguments and both account methods", async () => {
     const rpc = vi.fn(async () => ({
       rateLimits: {
-        rateLimits: { primary: { usedPercent: 5, windowDurationMins: 300, resetsAt: null } },
+        rateLimits: {
+          primary: { usedPercent: 5, windowDurationMins: 300, resetsAt: null },
+        },
       },
       account: { account: { type: "chatgpt" } },
     }));
@@ -239,7 +294,13 @@ describe("tiered Codex probing", () => {
       "account/read",
     ]);
     expect(JSON.stringify(messages)).not.toMatch(/prompt|turn\/start/);
-    expect(CODEX_APP_SERVER_ARGS).toEqual(["-s", "read-only", "-a", "untrusted", "app-server"]);
+    expect(CODEX_APP_SERVER_ARGS).toEqual([
+      "-s",
+      "read-only",
+      "-a",
+      "untrusted",
+      "app-server",
+    ]);
   });
 
   it("uses account/read to distinguish logged-out CLI state", async () => {
@@ -248,11 +309,18 @@ describe("tiered Codex probing", () => {
       readFile: async () => "{}",
       rpc: async () => ({ rateLimits: {}, account: { account: null } }),
     });
-    expect(result).toMatchObject({ authenticated: false, available: "unknown" });
+    expect(result).toMatchObject({
+      authenticated: false,
+      available: "unknown",
+    });
   });
 
   it("never exposes tokens or raw auth content through failures", async () => {
-    const secrets = ["pat-secret-value", "oauth-secret-value", "refresh-secret-value"];
+    const secrets = [
+      "pat-secret-value",
+      "oauth-secret-value",
+      "refresh-secret-value",
+    ];
     const result = await probeCodexCapacity({
       ...context,
       readFile: async () =>

package/src/__tests__/capacity/fixtures/zai-auth.json

@@ -0,0 +1,6 @@
+{
+  "zai": {
+    "type": "api_key",
+    "key": "pi-zai-test-key"
+  }
+}

package/src/__tests__/capacity/fixtures/zai-quota-invalid.json

@@ -0,0 +1,7 @@
+{
+  "success": true,
+  "code": 200,
+  "data": {
+    "limits": {}
+  }
+}

package/src/__tests__/capacity/fixtures/zai-quota.json

@@ -0,0 +1,38 @@
+{
+  "success": true,
+  "code": 200,
+  "data": {
+    "limits": [
+      {
+        "type": "TOKENS_LIMIT",
+        "unit": 3,
+        "number": 5,
+        "percentage": 99,
+        "usage": 1000,
+        "currentValue": 200,
+        "remaining": 700,
+        "nextResetTime": 1787220000000
+      },
+      {
+        "type": "CREDIT_LIMIT",
+        "unit": 6,
+        "number": 1,
+        "percentage": 5,
+        "usage": 200,
+        "currentValue": 80,
+        "remaining": 150,
+        "nextResetTime": 1787824800000
+      },
+      {
+        "type": "TIME_LIMIT",
+        "unit": 5,
+        "number": 1,
+        "percentage": 25,
+        "usage": 100,
+        "currentValue": 20,
+        "remaining": 90,
+        "nextResetTime": 1789812000000
+      }
+    ]
+  }
+}

package/src/__tests__/capacity/index.test.ts

@@ -6,7 +6,8 @@ const checkedAt = "2026-08-09T10:00:00.000Z";
 describe("getCodexCapacityReport", () => {
   it("checks Codex installation before probing", async () => {
     const probe = vi.fn(async (context) => ({
-      provider: "codex",
+      harness: "codex",
+      provider: "openai",
       generatedAt: context.checkedAt,
       authenticated: true,
       available: "yes" as const,
@@ -24,7 +25,12 @@ describe("getCodexCapacityReport", () => {
     });
 
     expect(probe).toHaveBeenCalledWith({ installed: true, checkedAt });
-    expect(report).toMatchObject({ provider: "codex", generatedAt: checkedAt, available: "yes" });
+    expect(report).toMatchObject({
+      harness: "codex",
+      provider: "openai",
+      generatedAt: checkedAt,
+      available: "yes",
+    });
   });
 
   it("redacts unexpected probe failures into a stable unknown result", async () => {
@@ -37,7 +43,8 @@ describe("getCodexCapacityReport", () => {
     });
 
     expect(report).toMatchObject({
-      provider: "codex",
+      harness: "codex",
+      provider: "openai",
       available: "unknown",
       authenticated: null,
       windows: [],

package/src/__tests__/capacity/zai.test.ts

@@ -0,0 +1,186 @@
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it, vi } from "vitest";
+import {
+  parseZaiQuota,
+  probeZaiCapacity,
+  resolveZaiApiKey,
+} from "../../capacity/zai.js";
+
+const checkedAt = "2026-08-20T10:00:00.000Z";
+const fixture = (name: string) =>
+  readFile(
+    fileURLToPath(new URL(`./fixtures/${name}`, import.meta.url)),
+    "utf8",
+  );
+
+describe("z.ai credential resolution", () => {
+  it("prefers Z_AI_API_KEY without reading Pi auth", async () => {
+    const readAuth = vi.fn(async () => fixture("zai-auth.json"));
+    await expect(
+      resolveZaiApiKey({
+        env: { Z_AI_API_KEY: "env-zai-test-key" },
+        readFile: readAuth,
+      }),
+    ).resolves.toBe("env-zai-test-key");
+    expect(readAuth).not.toHaveBeenCalled();
+  });
+
+  it("reads the Pi zai api_key credential from ~/.pi/agent/auth.json", async () => {
+    const readAuth = vi.fn(async () => fixture("zai-auth.json"));
+    await expect(
+      resolveZaiApiKey({ env: { HOME: "/users/test" }, readFile: readAuth }),
+    ).resolves.toBe("pi-zai-test-key");
+    expect(readAuth).toHaveBeenCalledWith(
+      "/users/test/.pi/agent/auth.json",
+      "utf8",
+    );
+  });
+
+  it.each([
+    [
+      "missing",
+      async () =>
+        Promise.reject(Object.assign(new Error("missing"), { code: "ENOENT" })),
+    ],
+    ["invalid JSON", async () => "{"],
+    [
+      "wrong credential type",
+      async () => JSON.stringify({ zai: { type: "oauth", key: "x" } }),
+    ],
+    ["missing key", async () => JSON.stringify({ zai: { type: "api_key" } })],
+  ])(
+    "fails clearly for %s credentials without exposing file content",
+    async (_name, readAuth) => {
+      await expect(
+        resolveZaiApiKey({ env: { HOME: "/users/test" }, readFile: readAuth }),
+      ).rejects.toThrow(/z\.ai API key|z\.ai Pi auth file/);
+    },
+  );
+});
+
+describe("z.ai quota mapping", () => {
+  it("maps token, credit, and monthly MCP windows with recomputed usage", async () => {
+    const report = parseZaiQuota(
+      JSON.parse(await fixture("zai-quota.json")),
+      checkedAt,
+    );
+    expect(report).toMatchObject({
+      harness: "pi",
+      provider: "zai",
+      generatedAt: checkedAt,
+      authenticated: true,
+      available: "yes",
+      creditsRemaining: null,
+    });
+    expect(report.windows).toEqual([
+      {
+        id: "zai:tokens:1",
+        label: "Tokens · 5 hours",
+        limitType: "TOKENS_LIMIT",
+        durationMinutes: 300,
+        usedPercent: 30,
+        resetsAt: "2026-08-20T10:00:00.000Z",
+        total: 1000,
+        current: 200,
+        remaining: 700,
+      },
+      {
+        id: "zai:credit:2",
+        label: "Credit · 1 week",
+        limitType: "CREDIT_LIMIT",
+        durationMinutes: 10080,
+        usedPercent: 40,
+        resetsAt: "2026-08-27T10:00:00.000Z",
+        total: 200,
+        current: 80,
+        remaining: 150,
+      },
+      {
+        id: "zai:time:3",
+        label: "MCP · monthly",
+        limitType: "TIME_LIMIT",
+        durationMinutes: 43200,
+        usedPercent: 20,
+        resetsAt: "2026-09-19T10:00:00.000Z",
+        total: 100,
+        current: 20,
+        remaining: 90,
+      },
+    ]);
+  });
+
+  it("uses and clamps the server percentage when quota amounts are unavailable", () => {
+    const report = parseZaiQuota(
+      {
+        success: true,
+        code: 200,
+        data: {
+          limits: [
+            { type: "TOKENS_LIMIT", unit: 1, number: 1, percentage: 120 },
+            { type: "CREDIT_LIMIT", unit: 5, number: 30, percentage: -5 },
+          ],
+        },
+      },
+      checkedAt,
+    );
+    expect(report.windows.map((window) => window.usedPercent)).toEqual([
+      100, 0,
+    ]);
+  });
+
+  it.each([
+    [
+      "invalid fixture",
+      async () => JSON.parse(await fixture("zai-quota-invalid.json")),
+    ],
+    [
+      "unsuccessful envelope",
+      async () => ({ success: false, code: 401, data: { limits: [] } }),
+    ],
+    [
+      "invalid entry",
+      async () => ({ success: true, code: 200, data: { limits: [{}] } }),
+    ],
+  ])("rejects %s", async (_name, input) => {
+    const value = await input();
+    expect(() => parseZaiQuota(value, checkedAt)).toThrow(/z\.ai quota/);
+  });
+});
+
+describe("z.ai request", () => {
+  it("GETs the global quota endpoint with only Bearer authentication", async () => {
+    const body = await fixture("zai-quota.json");
+    const fetch = vi.fn(async () => new Response(body, { status: 200 }));
+    const report = await probeZaiCapacity({
+      checkedAt,
+      env: { Z_AI_API_KEY: "request-test-key" },
+      fetch,
+    });
+    expect(fetch).toHaveBeenCalledWith(
+      "https://api.z.ai/api/monitor/usage/quota/limit",
+      expect.objectContaining({
+        method: "GET",
+        headers: { Authorization: "Bearer request-test-key" },
+      }),
+    );
+    expect(JSON.stringify(report)).not.toContain("request-test-key");
+  });
+
+  it("rejects non-200 and malformed JSON responses with sanitized errors", async () => {
+    await expect(
+      probeZaiCapacity({
+        checkedAt,
+        env: { Z_AI_API_KEY: "never-expose-this-key" },
+        fetch: vi.fn(async () => new Response("private body", { status: 503 })),
+      }),
+    ).rejects.toThrow("z.ai quota request failed: HTTP 503");
+    await expect(
+      probeZaiCapacity({
+        checkedAt,
+        env: { Z_AI_API_KEY: "never-expose-this-key" },
+        fetch: vi.fn(async () => new Response("not-json", { status: 200 })),
+      }),
+    ).rejects.toThrow("z.ai quota response is not valid JSON");
+  });
+});

package/src/__tests__/providers/copilot/CopilotAdapter.test.ts

@@ -552,6 +552,18 @@ describe("CopilotAdapter", () => {
       });
     });
 
+    it("finds an exact session ID from its session directory", async () => {
+      writeSession("wanted", { events: [sessionStart("wanted", "/repo")] });
+      writeSession("other", { events: [sessionStart("other", "/other")] });
+
+      await expect(adapter.findSessionsById("wanted")).resolves.toEqual([
+        expect.objectContaining({
+          sessionId: "wanted",
+          sessionFilePath: path.join(sessionStateDir, "wanted", "events.jsonl"),
+        }),
+      ]);
+    });
+
     it("applies strict cwd filter", async () => {
       writeSession("keep", { events: [sessionStart("keep", "/repo")] });
       writeSession("drop", { events: [sessionStart("drop", "/other")] });

package/src/__tests__/providers/gemini/GeminiCliAdapter.test.ts

@@ -1185,6 +1185,27 @@ describe("GeminiCliAdapter", () => {
       });
     });
 
+    it("finds an exact session ID from Gemini metadata", async () => {
+      const wantedPath = writeSession(tmpHome, "aaa", "session-one", {
+        sessionId: "wanted",
+        projectHash: hashProjectRoot("/repo"),
+        startTime: "2025-01-01T00:00:00Z",
+        directories: ["/repo"],
+        messages: [{ type: "user", content: "wanted prompt" }],
+      });
+      writeSession(tmpHome, "bbb", "session-two", {
+        sessionId: "other",
+        projectHash: hashProjectRoot("/other"),
+        startTime: "2025-01-01T00:00:00Z",
+        directories: ["/other"],
+        messages: [{ type: "user", content: "other prompt" }],
+      });
+
+      await expect(adapter.findSessionsById("wanted")).resolves.toEqual([
+        expect.objectContaining({ sessionId: "wanted", sessionFilePath: wantedPath }),
+      ]);
+    });
+
     it("applies strict-equality cwd filter against directories[0]", async () => {
       writeSession(tmpHome, "aaa", "session-keep", {
         sessionId: "keep",

package/src/__tests__/providers/grok/GrokAgentMapper.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from "vitest";
+
+import { AgentStatus, type ProcessInfo } from "../../../adapters/AgentAdapter.js";
+import { GrokAgentMapper } from "../../../providers/grok/GrokAgentMapper.js";
+import type { GrokSession } from "../../../providers/grok/GrokSessionParser.js";
+
+function makeProcess(overrides: Partial<ProcessInfo> = {}): ProcessInfo {
+  return { pid: 123, command: "grok", cwd: "/repo/my-app", tty: "ttys001", ...overrides };
+}
+
+function makeSession(overrides: Partial<GrokSession> = {}): GrokSession {
+  return {
+    sessionId: "session-1",
+    projectPath: "/repo/my-app",
+    sessionFilePath: "/home/.grok/sessions/%2Frepo%2Fmy-app/session-1/chat_history.jsonl",
+    sessionStart: new Date(),
+    lastActive: new Date(),
+    lastUserMessage: "Review this change",
+    lastRole: "assistant",
+    ...overrides,
+  };
+}
+
+describe("GrokAgentMapper", () => {
+  const mapper = new GrokAgentMapper();
+
+  it("maps a session to a grok_cli agent pointing at chat_history.jsonl", () => {
+    const agent = mapper.mapSessionToAgent({
+      session: makeSession(),
+      processInfo: makeProcess(),
+    });
+
+    expect(agent).toMatchObject({
+      name: "my-app-123",
+      type: "grok_cli",
+      status: AgentStatus.WAITING,
+      summary: "Review this change",
+      pid: 123,
+      projectPath: "/repo/my-app",
+      sessionId: "session-1",
+      sessionFilePath: "/home/.grok/sessions/%2Frepo%2Fmy-app/session-1/chat_history.jsonl",
+    });
+  });
+
+  it("maps a process-only agent as RUNNING with a pid session id", () => {
+    const agent = mapper.mapProcessOnlyAgent(makeProcess(), "/repo/resolved");
+
+    expect(agent).toMatchObject({
+      type: "grok_cli",
+      status: AgentStatus.RUNNING,
+      summary: "Grok CLI process running",
+      projectPath: "/repo/resolved",
+      sessionId: "pid-123",
+    });
+    expect(agent.sessionFilePath).toBeUndefined();
+  });
+});

package/src/__tests__/{adapters → providers/grok}/GrokCliAdapter.test.ts

@@ -10,18 +10,18 @@ import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 
-import { GrokCliAdapter } from "../../adapters/GrokCliAdapter.js";
-import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
-import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { GrokCliAdapter } from "../../../providers/grok/GrokCliAdapter.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";
+} 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");
+vi.mock("../../../utils/process.js", async (importOriginal) => {
+  const actual = (await importOriginal()) as typeof import("../../../utils/process.js");
   return {
     ...actual,
     listAgentProcesses: vi.fn(),
@@ -30,8 +30,8 @@ vi.mock("../../utils/process.js", async (importOriginal) => {
   };
 });
 
-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(),
@@ -335,6 +335,15 @@ describe("GrokCliAdapter", () => {
       );
     });
 
+    it("finds an exact session ID across project groups", async () => {
+      writeSession({});
+      writeSession({ sessionCwd: "/Users/dev/other", id: "other-session" });
+
+      await expect(adapter.findSessionsById(SESSION_ID)).resolves.toEqual([
+        expect.objectContaining({ sessionId: SESSION_ID, cwd }),
+      ]);
+    });
+
     it("applies the cwd filter against the decoded cwd", async () => {
       writeSession({
         sessionCwd: "/Users/dev/project-a",