@ai-devkit/agent-manager 0.39.0 → 0.41.0

package/src/AgentManager.ts

@@ -8,6 +8,8 @@
 import type {
   AgentAdapter,
   AgentInfo,
+  AgentStatus,
+  AgentType,
   SessionSummary,
   ListSessionsOptions,
   ProcessInfo,
@@ -45,6 +47,20 @@ export interface AgentManagerOptions {
     | (() => AgentRuntimeProvider | Promise<AgentRuntimeProvider>);
   fetchHerdrAgentPanes?: () => Promise<readonly HerdrAgentPane[]>;
   onRuntimeDiscoveryError?: (error: unknown) => void;
+  /**
+   * Daemon-side enriched agents ({@link DaemonClient.listAgents} wire
+   * shape: `AgentInfo` with `lastActive` as an ISO string). A non-null
+   * result is authoritative for every harness type — all local adapters
+   * are skipped. Returning null or throwing forces the local path;
+   * omitting it disables daemon consumption.
+   */
+  fetchEnrichedAgents?: () => Promise<Array<
+    Omit<AgentInfo, "lastActive" | "type" | "status"> & {
+      type: string;
+      status: string;
+      lastActive: string;
+    }
+  > | null>;
 }
 
 class AgentNotRunningError extends Error {
@@ -162,7 +178,27 @@ export class AgentManager {
     const allAgents: AgentInfo[] = [];
     const errors: Array<{ type: string; error: Error }> = [];
 
-    const adapters = Array.from(this.adapters.values());
+    // A non-null daemon answer is authoritative for every harness type, so
+    // local adapters only run when the daemon is absent.
+    let daemonAgents: AgentInfo[] | null = null;
+    if (this.options.fetchEnrichedAgents) {
+      try {
+        const enriched = await this.options.fetchEnrichedAgents();
+        if (enriched) {
+          daemonAgents = enriched.map((a) => ({
+            ...a,
+            type: a.type as AgentType,
+            status: a.status as AgentStatus,
+            lastActive: new Date(a.lastActive),
+          }));
+        }
+      } catch {
+        daemonAgents = null;
+      }
+    }
+    if (daemonAgents) allAgents.push(...daemonAgents);
+
+    const adapters = daemonAgents ? [] : Array.from(this.adapters.values());
     const processNames = Array.from(
       new Set(
         adapters.flatMap((adapter) => (adapter.processNames ? [...adapter.processNames] : [])),

package/src/__tests__/AgentManager.test.ts

@@ -478,6 +478,90 @@ describe("AgentManager", () => {
     });
   });
 
+  describe("listAgents — daemon enrichment", () => {
+    const wireAgent = (overrides: Record<string, unknown> = {}) => ({
+      name: "daemon-claude",
+      type: "claude",
+      status: "waiting",
+      summary: "daemon summary",
+      pid: 777,
+      projectPath: "/daemon/proj",
+      sessionId: "daemon-sid",
+      lastActive: "2026-10-08T12:00:00.000Z",
+      ...overrides,
+    });
+
+    it("serves agents from the daemon and skips all local adapters", async () => {
+      const local = new MockAdapter("claude", [createMockAgent({ name: "local-claude" })]);
+      const detectSpy = vi.spyOn(local, "detectAgents");
+      const m = new AgentManager(new AgentRegistry(path.join(tmpDir, "agents.json")), undefined, {
+        fetchEnrichedAgents: async () => [wireAgent()],
+      });
+      m.registerAdapter(local);
+
+      const agents = await m.listAgents();
+      expect(detectSpy).not.toHaveBeenCalled();
+      expect(agents).toHaveLength(1);
+      expect(agents[0].name).toBe("daemon-claude");
+      expect(agents[0].lastActive).toEqual(new Date("2026-10-08T12:00:00.000Z"));
+    });
+
+    it("falls back to all-local when the daemon returns null", async () => {
+      const m = new AgentManager(new AgentRegistry(path.join(tmpDir, "agents.json")), undefined, {
+        fetchEnrichedAgents: async () => null,
+      });
+      m.registerAdapter(new MockAdapter("claude", [createMockAgent({ name: "local-claude" })]));
+      const agents = await m.listAgents();
+      expect(agents.map((a) => a.name)).toEqual(["local-claude"]);
+    });
+
+    it("falls back to all-local when the daemon call throws", async () => {
+      const m = new AgentManager(new AgentRegistry(path.join(tmpDir, "agents.json")), undefined, {
+        fetchEnrichedAgents: async () => {
+          throw new Error("socket gone");
+        },
+      });
+      m.registerAdapter(new MockAdapter("claude", [createMockAgent({ name: "local-claude" })]));
+      const agents = await m.listAgents();
+      expect(agents.map((a) => a.name)).toEqual(["local-claude"]);
+    });
+
+    it("serves every type from the daemon in one sweep", async () => {
+      const claudeLocal = new MockAdapter("claude", [createMockAgent({ name: "local-claude" })]);
+      const codexLocal = new MockAdapter("codex", [
+        createMockAgent({ name: "local-codex", type: "codex" }),
+      ]);
+      const claudeSpy = vi.spyOn(claudeLocal, "detectAgents");
+      const codexSpy = vi.spyOn(codexLocal, "detectAgents");
+      const m = new AgentManager(new AgentRegistry(path.join(tmpDir, "agents.json")), undefined, {
+        fetchEnrichedAgents: async () => [
+          wireAgent(),
+          wireAgent({ type: "codex", name: "daemon-codex", pid: 888 }),
+        ],
+      });
+      m.registerAdapter(claudeLocal);
+      m.registerAdapter(codexLocal);
+
+      const agents = await m.listAgents();
+      expect(claudeSpy).not.toHaveBeenCalled();
+      expect(codexSpy).not.toHaveBeenCalled();
+      expect(agents.map((a) => a.name).sort()).toEqual(["daemon-claude", "daemon-codex"]);
+    });
+
+    it("treats an empty daemon answer as authoritative", async () => {
+      const local = new MockAdapter("claude", [createMockAgent({ name: "local-claude" })]);
+      const detectSpy = vi.spyOn(local, "detectAgents");
+      const m = new AgentManager(new AgentRegistry(path.join(tmpDir, "agents.json")), undefined, {
+        fetchEnrichedAgents: async () => [],
+      });
+      m.registerAdapter(local);
+
+      const agents = await m.listAgents();
+      expect(detectSpy).not.toHaveBeenCalled();
+      expect(agents).toEqual([]);
+    });
+  });
+
   describe("listAgents — registry persistence", () => {
     let tmpDir: string;
     let regPath: string;

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

@@ -0,0 +1,210 @@
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it, vi } from "vitest";
+import { parseDevinCapacity } from "../../capacity/providers/devin.js";
+import { probeDevinCapacity } from "../../capacity/sources/devin.js";
+import { resolveDevinCredential } from "../../harnesses/devin/credentials.js";
+
+const checkedAt = "2026-10-05T10:00:00.000Z";
+const fixture = (name: string) =>
+  readFile(fileURLToPath(new URL(`./fixtures/${name}`, import.meta.url)), "utf8");
+
+const credentialFiles = async (path: string): Promise<string> => {
+  if (path === "/users/test/.local/share/devin/credentials.toml") {
+    return fixture("devin-credentials.toml");
+  }
+  if (path === "/users/test/.config/devin/config.json") {
+    return fixture("devin-config.json");
+  }
+  throw Object.assign(new Error("missing"), { code: "ENOENT" });
+};
+
+describe("devin credential resolution", () => {
+  it("prefers DEVIN_API_KEY and DEVIN_ORG_ID without reading files", async () => {
+    const reader = vi.fn(credentialFiles);
+    await expect(
+      resolveDevinCredential({
+        env: { DEVIN_API_KEY: "env-key", DEVIN_ORG_ID: "org-env" },
+        readFile: reader,
+      }),
+    ).resolves.toEqual({ key: "env-key", orgId: "org-env" });
+    expect(reader).not.toHaveBeenCalled();
+  });
+
+  it("reads the key from credentials.toml and org from config.json", async () => {
+    const reader = vi.fn(credentialFiles);
+    await expect(
+      resolveDevinCredential({ env: { HOME: "/users/test" }, readFile: reader }),
+    ).resolves.toEqual({ key: "devin-test-key", orgId: "org-test1234" });
+    expect(reader).toHaveBeenCalledWith("/users/test/.local/share/devin/credentials.toml", "utf8");
+    expect(reader).toHaveBeenCalledWith("/users/test/.config/devin/config.json", "utf8");
+  });
+
+  it.each([
+    [
+      "missing credentials file",
+      async (path: string) => {
+        if (path.endsWith("config.json")) return fixture("devin-config.json");
+        throw Object.assign(new Error("missing"), { code: "ENOENT" });
+      },
+      /Devin API key not found/,
+    ],
+    [
+      "malformed credentials file",
+      async (path: string) => {
+        if (path.endsWith("credentials.toml")) return "not = [valid";
+        return fixture("devin-config.json");
+      },
+      /credentials file is malformed/,
+    ],
+    [
+      "credentials without key",
+      async (path: string) => {
+        if (path.endsWith("credentials.toml")) return 'api_server_url = "https://x"';
+        return fixture("devin-config.json");
+      },
+      /Devin API key not found/,
+    ],
+    [
+      "missing config file",
+      async (path: string) => {
+        if (path.endsWith("credentials.toml")) return fixture("devin-credentials.toml");
+        throw Object.assign(new Error("missing"), { code: "ENOENT" });
+      },
+      /Devin organization id not found/,
+    ],
+    [
+      "config without org_id",
+      async (path: string) => {
+        if (path.endsWith("credentials.toml")) return fixture("devin-credentials.toml");
+        return JSON.stringify({ devin: {} });
+      },
+      /Devin organization id not found/,
+    ],
+  ])("fails clearly for %s without exposing file content", async (_name, readFileImpl, pattern) => {
+    await expect(
+      resolveDevinCredential({ env: { HOME: "/users/test" }, readFile: readFileImpl }),
+    ).rejects.toThrow(pattern);
+  });
+});
+
+describe("devin quota mapping", () => {
+  it("maps daily and weekly windows with credits", async () => {
+    const report = parseDevinCapacity(JSON.parse(await fixture("devin-quota.json")));
+    expect(report).toMatchObject({
+      authenticated: true,
+      available: "yes",
+      creditsRemaining: 12.5,
+    });
+    expect(report.windows).toEqual([
+      {
+        id: "devin:daily",
+        label: "Daily",
+        durationMinutes: 1440,
+        usedPercent: 25,
+        resetsAt: "2026-10-06T08:00:00.000Z",
+      },
+      {
+        id: "devin:weekly",
+        label: "Weekly",
+        durationMinutes: 10080,
+        usedPercent: 60,
+        resetsAt: "2026-10-11T08:00:00.000Z",
+      },
+    ]);
+  });
+
+  it("omits the daily window when hide_daily_quota is true", () => {
+    const report = parseDevinCapacity({
+      is_quota_plan: true,
+      has_quota_allocation: true,
+      daily_percentage: 90,
+      weekly_percentage: 10,
+      hide_daily_quota: true,
+    });
+    expect(report.windows.map((window) => window.id)).toEqual(["devin:weekly"]);
+  });
+
+  it("reports authenticated unknown availability for non-quota plans", async () => {
+    const report = parseDevinCapacity(JSON.parse(await fixture("devin-quota-nonplan.json")));
+    expect(report).toEqual({
+      authenticated: true,
+      available: "unknown",
+      windows: [],
+      creditsRemaining: null,
+    });
+  });
+
+  it("clamps percentages and degrades missing fields honestly", () => {
+    const report = parseDevinCapacity({
+      is_quota_plan: true,
+      has_quota_allocation: true,
+      daily_percentage: 140,
+      weekly_reset_at: "not-a-date",
+      overage_balance: "unknown",
+    });
+    const [daily, weekly] = report.windows;
+    expect(daily.usedPercent).toBe(100);
+    expect(weekly.usedPercent).toBeNull();
+    expect(weekly.resetsAt).toBeNull();
+    expect(report.creditsRemaining).toBeNull();
+    expect(report.available).toBe("no");
+  });
+
+  it("rejects non-object responses", () => {
+    expect(() => parseDevinCapacity("nope")).toThrow(/Devin quota/);
+    expect(() => parseDevinCapacity(null)).toThrow(/Devin quota/);
+  });
+});
+
+describe("devin request", () => {
+  it("GETs the org quota endpoint with only Bearer authentication", async () => {
+    const body = await fixture("devin-quota.json");
+    const fetch = vi.fn(async () => new Response(body, { status: 200 }));
+    const report = await probeDevinCapacity({
+      checkedAt,
+      env: { DEVIN_API_KEY: "request-test-key", DEVIN_ORG_ID: "org-abc" },
+      fetch,
+    });
+    expect(fetch).toHaveBeenCalledWith(
+      "https://app.devin.ai/api/org-abc/billing/quota/usage",
+      expect.objectContaining({
+        method: "GET",
+        headers: { Authorization: "Bearer request-test-key" },
+      }),
+    );
+    expect(report.harness).toBe("devin");
+    expect(report.provider).toBe("devin");
+    expect(JSON.stringify(report)).not.toContain("request-test-key");
+  });
+
+  it.each([401, 403])("reports HTTP %i as unauthenticated", async (status) => {
+    const report = await probeDevinCapacity({
+      checkedAt,
+      env: { DEVIN_API_KEY: "request-test-key", DEVIN_ORG_ID: "org-abc" },
+      fetch: vi.fn(async () => new Response("denied", { status })),
+    });
+    expect(report).toMatchObject({
+      authenticated: false,
+      available: "unknown",
+      windows: [],
+    });
+  });
+
+  it("rejects other non-200 and malformed JSON responses with sanitized errors", async () => {
+    await expect(
+      probeDevinCapacity({
+        checkedAt,
+        env: { DEVIN_API_KEY: "never-expose-this-key", DEVIN_ORG_ID: "org-abc" },
+        fetch: vi.fn(async () => new Response("private body", { status: 503 })),
+      }),
+    ).rejects.toThrow("Devin quota request failed: HTTP 503");
+    await expect(
+      probeDevinCapacity({
+        checkedAt,
+        env: { DEVIN_API_KEY: "never-expose-this-key", DEVIN_ORG_ID: "org-abc" },
+        fetch: vi.fn(async () => new Response("not-json", { status: 200 })),
+      }),
+    ).rejects.toThrow("Devin quota response is not valid JSON");
+  });
+});

package/src/__tests__/capacity/fixtures/devin-config.json

@@ -0,0 +1,6 @@
+{
+  "version": 1,
+  "devin": {
+    "org_id": "org-test1234"
+  }
+}

package/src/__tests__/capacity/fixtures/devin-credentials.toml

@@ -0,0 +1,4 @@
+windsurf_api_key = "devin-test-key"
+api_server_url = "https://server.codeium.com"
+devin_webapp_host = "app.devin.ai"
+devin_api_url = "https://api.devin.ai"

package/src/__tests__/capacity/fixtures/devin-quota-nonplan.json

@@ -0,0 +1,5 @@
+{
+  "is_quota_plan": false,
+  "has_quota_allocation": false,
+  "overage_balance": 0.0
+}

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

@@ -0,0 +1,10 @@
+{
+  "is_quota_plan": true,
+  "has_quota_allocation": true,
+  "daily_percentage": 25,
+  "weekly_percentage": 60,
+  "daily_reset_at": "2026-10-06T00:00:00-08:00",
+  "weekly_reset_at": "2026-10-11T00:00:00-08:00",
+  "overage_balance": 12.5,
+  "hide_daily_quota": false
+}

package/src/__tests__/fixtures.test.ts

@@ -0,0 +1,247 @@
+/**
+ * Fixture replay: materialize each committed bundle into a fake HOME,
+ * run the adapter's detectAgents with the recorded processes + frozen
+ * clock, and require byte-identical output to `expected`.
+ *
+ * The same bundles are consumed by devkit-harness Rust tests — this file is
+ * the TS↔TS side of the parity oracle.
+ */
+
+import { describe, it, expect, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import Database from "better-sqlite3";
+import { createBuiltinAdapters } from "../harnesses/index.js";
+import { CodexAdapter } from "../harnesses/codex/CodexAdapter.js";
+import { PiAdapter } from "../harnesses/pi/PiAdapter.js";
+import { GeminiCliAdapter } from "../harnesses/gemini/GeminiCliAdapter.js";
+import { CopilotAdapter } from "../harnesses/copilot/CopilotAdapter.js";
+import { AgentRegistry, type RegistryEntry } from "../utils/AgentRegistry.js";
+import { expand, expandNow, normalizeAgents, withFrozenClock } from "../fixtures/bundle.js";
+import type { FixtureBundle } from "../fixtures/bundle.js";
+import { captureLive, FIXTURES_ROOT } from "../fixtures/capture.js";
+
+const bundlePaths = fs.existsSync(FIXTURES_ROOT)
+  ? fs
+      .readdirSync(FIXTURES_ROOT, { withFileTypes: true })
+      .flatMap((d) =>
+        d.isDirectory()
+          ? fs
+              .readdirSync(path.join(FIXTURES_ROOT, d.name))
+              .filter((f) => f.endsWith(".json"))
+              .map((f) => path.join(FIXTURES_ROOT, d.name, f))
+          : [],
+      )
+  : [];
+
+/** Adapters whose detect path consults AgentRegistry. */
+const REGISTRY_AWARE = new Set(["codex", "pi", "gemini_cli", "copilot"]);
+
+function adapterFor(type: string, registry?: AgentRegistry) {
+  // Adapters that consult the registry during detection get the seeded
+  // isolated instance so replay never reads real ~/.ai-devkit state.
+  if (type === "codex" && registry) return new CodexAdapter(registry);
+  if (type === "pi" && registry) return new PiAdapter(registry);
+  if (type === "gemini_cli" && registry) return new GeminiCliAdapter(registry);
+  if (type === "copilot" && registry) return new CopilotAdapter(registry);
+  const adapter = createBuiltinAdapters().find((a) => a.type === type);
+  if (!adapter) throw new Error(`no builtin adapter for "${type}"`);
+  return adapter;
+}
+
+/** Seed an isolated registry at `<home>/.ai-devkit/agents.json`. */
+function seedRegistry(bundle: FixtureBundle, home: string, nowIso: string): AgentRegistry | undefined {
+  if (!REGISTRY_AWARE.has(bundle.adapter)) return undefined;
+  const registry = new AgentRegistry(path.join(home, ".ai-devkit", "agents.json"));
+  const entries = (bundle.registry ?? []).map(
+    (e) =>
+      ({
+        name: "",
+        type: bundle.adapter,
+        runtime: "tmux",
+        runtimeRef: null,
+        cwd: "",
+        startedAt: nowIso,
+        sessionId: "",
+        sessionFilePath: "",
+        pinned: false,
+        ...expand(expandNow(e as Record<string, unknown>, nowIso), home),
+      }) as RegistryEntry,
+  );
+  registry.registerBatch(entries);
+  return registry;
+}
+
+/** Materialize a bundle into a temp HOME; returns cleanup + replay inputs. */
+function materialize(bundle: FixtureBundle) {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "fixture-home-"));
+  // "$TODAY" resolves to the local `YYYY/MM/DD` day key at write time — Codex
+  // date-dir discovery derives day keys from process start times in local
+  // time, so static dirs would drift across replay days/timezones.
+  const now = new Date();
+  const todayKey = [
+    String(now.getFullYear()).padStart(4, "0"),
+    String(now.getMonth() + 1).padStart(2, "0"),
+    String(now.getDate()).padStart(2, "0"),
+  ].join("/");
+  for (const [rel, content] of Object.entries(bundle.home)) {
+    const p = path.join(home, expand(rel.split("$TODAY").join(todayKey), home));
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, expand(content.split("$TODAY").join(todayKey), home));
+  }
+  // SQLite stores (OpenCode's opencode.db) materialize from ordered SQL
+  // statements — binary dbs can't travel in the JSON `home` map.
+  for (const [rel, stmts] of Object.entries(bundle.sqlite ?? {})) {
+    const p = path.join(home, expand(rel.split("$TODAY").join(todayKey), home));
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    const db = new Database(p);
+    try {
+      for (const stmt of stmts) {
+        db.exec(expand(stmt.split("$TODAY").join(todayKey), home));
+      }
+    } finally {
+      db.close();
+    }
+  }
+  // "$NOW" resolves to the instant home files were written — legacy
+  // cwd+birthtime matching compares process start times against real file
+  // creation times, so a static timestamp would drift out of tolerance.
+  const nowIso = new Date().toISOString();
+  // Deterministic mtimes for adapters that read them (Grok lastActive /
+  // latest-session pick) — "$NOW" resolves like the process sentinel.
+  for (const [rel, mt] of Object.entries(bundle.mtimes ?? {})) {
+    const p = path.join(home, expand(rel.split("$TODAY").join(todayKey), home));
+    const ms = mt === "$NOW" ? Date.parse(nowIso) : mt;
+    fs.utimesSync(p, ms / 1000, ms / 1000);
+  }
+  // JSON round-tripped Date fields (e.g. ProcessInfo.startTime) come back as
+  // ISO strings — adapters expect real Date instances.
+  const processes = expandNow(expand(bundle.processes, home), nowIso).map((p) => ({
+    ...p,
+    startTime: p.startTime ? new Date(p.startTime) : undefined,
+  }));
+  const frozenNow = bundle.frozenNow === "$NOW" ? Date.parse(nowIso) : bundle.frozenNow;
+  // Pids whose startTime resolves to the materialization instant — Codex
+  // derives session day-dirs from start times, so only these paths contain
+  // the replay-day key and normalize to $TODAY.
+  const nowPids = new Set(
+    bundle.processes.filter((p) => p.startTime === "$NOW").map((p) => p.pid),
+  );
+  return {
+    home,
+    processes,
+    frozenNow,
+    todayKey,
+    // Only $NOW resolves — $FIXTURE_HOME and $TODAY stay literal to match
+    // the normalized actual form.
+    expected: expandNow(bundle.expected, nowIso),
+    cleanup: () => fs.rmSync(home, { recursive: true, force: true }),
+    nowIso,
+    nowPids,
+  };
+}
+
+describe("fixture replay (TS parity oracle)", () => {
+  const saved = process.env.HOME;
+  afterEach(() => {
+    if (saved === undefined) delete process.env.HOME;
+    else process.env.HOME = saved;
+  });
+
+  if (bundlePaths.length === 0) {
+    it.todo("no fixture bundles committed yet — run AI_DEVKIT_FIXTURE_CAPTURE=1");
+    return;
+  }
+
+  for (const bundlePath of bundlePaths) {
+    it(`replays ${path.relative(FIXTURES_ROOT, bundlePath)}`, async () => {
+      const bundle: FixtureBundle = JSON.parse(fs.readFileSync(bundlePath, "utf8"));
+      const { home, processes, frozenNow, expected, cleanup, todayKey, nowIso, nowPids } =
+        materialize(bundle);
+      // Pin XDG to the fixture's canonical share dir — an ambient
+      // XDG_DATA_HOME would resolve the real opencode.db into replay.
+      const savedXdg = process.env.XDG_DATA_HOME;
+      // Same for ANTIGRAVITY_CLI_HOME — clearing it falls the adapter
+      // back to the pinned HOME's canonical base dir.
+      const savedAgy = process.env.ANTIGRAVITY_CLI_HOME;
+      try {
+        process.env.HOME = home;
+        process.env.XDG_DATA_HOME = path.join(home, ".local", "share");
+        delete process.env.ANTIGRAVITY_CLI_HOME;
+        const registry = seedRegistry(bundle, home, nowIso);
+        const agents = await withFrozenClock(frozenNow, () =>
+          adapterFor(bundle.adapter, registry).detectAgents({ processes }),
+        );
+        // Day-key dirs normalize back to $TODAY only for agents whose
+        // process startTime was $NOW — static-start agents keep concrete
+        // dates so live bundles stay replayable on any day.
+        const actual = JSON.parse(JSON.stringify(normalizeAgents(agents, home))).map((a) =>
+          nowPids.has(a.pid)
+            ? JSON.parse(JSON.stringify(a).split(todayKey).join("$TODAY"))
+            : a,
+        );
+        expect(actual).toEqual(expected);
+      } finally {
+        if (savedXdg === undefined) delete process.env.XDG_DATA_HOME;
+        else process.env.XDG_DATA_HOME = savedXdg;
+        if (savedAgy === undefined) delete process.env.ANTIGRAVITY_CLI_HOME;
+        else process.env.ANTIGRAVITY_CLI_HOME = savedAgy;
+        cleanup();
+      }
+    });
+  }
+});
+
+// Opt-in live capture: AI_DEVKIT_FIXTURE_CAPTURE=1 npx vitest run fixtures
+describe.runIf(process.env.AI_DEVKIT_FIXTURE_CAPTURE === "1")("fixture capture (live)", () => {
+  it("captures claude bundle from the live machine", async () => {
+    const out = await captureLive(adapterFor("claude"), "live");
+    expect(fs.existsSync(out)).toBe(true);
+  }, 30000);
+
+  it("captures codex bundle from the live machine", async () => {
+    const out = await captureLive(adapterFor("codex"), "live");
+    expect(fs.existsSync(out)).toBe(true);
+  }, 30000);
+
+  it("captures pi bundle from the live machine", async () => {
+    const out = await captureLive(adapterFor("pi"), "live");
+    expect(fs.existsSync(out)).toBe(true);
+  }, 30000);
+
+  it("captures gemini_cli bundle from the live machine", async () => {
+    const out = await captureLive(adapterFor("gemini_cli"), "live");
+    expect(fs.existsSync(out)).toBe(true);
+  }, 30000);
+
+  it("captures copilot bundle from the live machine", async () => {
+    const out = await captureLive(adapterFor("copilot"), "live");
+    expect(fs.existsSync(out)).toBe(true);
+  }, 30000);
+
+  it("captures grok_cli bundle from the live machine", async () => {
+    const out = await captureLive(adapterFor("grok_cli"), "live");
+    expect(fs.existsSync(out)).toBe(true);
+  }, 30000);
+
+  it("captures opencode bundle from the live machine", async () => {
+    const out = await captureLive(adapterFor("opencode"), "live");
+    expect(fs.existsSync(out)).toBe(true);
+  }, 30000);
+
+  it("captures devin bundle from the live machine", async () => {
+    const out = await captureLive(adapterFor("devin"), "live");
+    expect(fs.existsSync(out)).toBe(true);
+  }, 30000);
+
+  it("captures kiro bundle from the live machine", async () => {
+    const out = await captureLive(adapterFor("kiro"), "live");
+    expect(fs.existsSync(out)).toBe(true);
+  }, 30000);
+
+  it("captures antigravity_cli bundle from the live machine", async () => {
+    const out = await captureLive(adapterFor("antigravity_cli"), "live");
+    expect(fs.existsSync(out)).toBe(true);
+  }, 30000);
+});