sailfork / t3code-github / apps/ server/ src/ provider/ AntigravityProvider.test.ts

import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { describe, expect, it } from "@effect/vitest";
import {
  ANTIGRAVITY_DEFAULT_MODEL,
  AntigravitySettings,
  ProviderDriverKind,
  ProviderInstanceId,
  ProviderSetupError,
  type ServerProviderUsageLimits,
} from "@t3tools/contracts";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Ref from "effect/Ref";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";
import * as EffectAcpErrors from "effect-acp/errors";
import type * as EffectAcpSchema from "effect-acp/compat";

import * as BackgroundPolicy from "../background/BackgroundPolicy.ts";
import * as ServerConfig from "../config.ts";
import * as ServerSettings from "../serverSettings.ts";
import * as ProviderHostLive from "./ProviderHostLive.ts";
import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
import type * as AcpSessionRuntime from "@t3tools/provider-acp/server/AcpSessionRuntime";
import type { ServerProvider } from "@t3tools/contracts";
import {
  buildAntigravityModelsFromSession,
  makeAntigravityProvider,
} from "./AntigravityProvider.ts";

const decodeSettings = Schema.decodeSync(AntigravitySettings);
const instanceId = ProviderInstanceId.make("antigravity-test");
const driver = ProviderDriverKind.make("antigravity");

const initializeResult = {
  protocolVersion: 1,
  agentCapabilities: {
    loadSession: true,
    promptCapabilities: { image: true, audio: true, embeddedContext: true },
    sessionCapabilities: { list: {}, resume: {} },
  },
  authMethods: [{ id: "oauth-personal", name: "Log in with Google" }],
  agentInfo: {
    name: "antigravity-acp",
    title: "Google Antigravity",
    version: "agy_acp_server_20260818_01_RC01",
  },
} satisfies EffectAcpSchema.InitializeResponse;

const modelOptions = [
  { value: "gemini-3.8-flash-high", name: "Gemini 3.8 Flash (High)" },
  { value: "gemini-3.8-flash-medium", name: "Gemini 3.8 Flash (Medium)" },
  { value: "gemini-3.8-flash-low", name: "Gemini 3.8 Flash (Low)" },
  { value: "gemini-3.7-flash-high", name: "Gemini 3.7 Flash (High)" },
  { value: "gemini-3.7-flash-medium", name: "Gemini 3.7 Flash (Medium)" },
  { value: "gemini-3.7-flash-low", name: "Gemini 3.7 Flash (Low)" },
  { value: "gemini-3.6-flash-high", name: "Gemini 3.6 Flash (High)" },
  { value: "gemini-3.6-flash-medium", name: "Gemini 3.6 Flash (Medium)" },
  { value: "gemini-3.6-flash-low", name: "Gemini 3.6 Flash (Low)" },
  { value: "gemini-pro-agent", name: "Gemini 3.1 Pro (High)" },
  { value: "gemini-3.1-pro-low", name: "Gemini 3.1 Pro (Low)" },
];

const modelConfig = {
  id: "model",
  name: "Model",
  category: "model",
  type: "select",
  currentValue: "gemini-3.7-flash-high",
  options: modelOptions,
} satisfies EffectAcpSchema.SessionConfigOption;

const sessionSetupResult = {
  sessionId: "session-1",
  models: {
    currentModelId: "gemini-3.7-flash-high",
    availableModels: modelOptions.map((option) => ({ modelId: option.value, name: option.name })),
  },
  configOptions: [
    modelConfig,
    {
      id: "mode",
      name: "Session Mode",
      category: "mode",
      type: "select",
      currentValue: "default",
      options: [
        { value: "default", name: "Default" },
        { value: "yolo", name: "YOLO" },
      ],
    },
  ],
} satisfies EffectAcpSchema.NewSessionResponse;

const started = {
  sessionId: "session-1",
  initializeResult,
  sessionSetupResult,
  modelConfigId: "model",
} satisfies AcpSessionRuntime.AcpSessionRuntimeStartResult;

const commands = [
  { name: "plan", description: "Create a plan", input: { type: "text", hint: "What to plan" } },
  { name: "logout", description: "Sign out of Google" },
] satisfies ReadonlyArray<EffectAcpSchema.AvailableCommand>;

const expectedCommands = [
  { name: "plan", description: "Create a plan", input: { hint: "What to plan" } },
  { name: "logout", description: "Sign out of Google" },
];

const layerTest = ProviderHostLive.layer.pipe(
  Layer.provideMerge(
    Layer.mock(BackgroundPolicy.BackgroundPolicy)({
      shouldRunScopeWork: () => Effect.succeed(false),
    }),
  ),
  Layer.provideMerge(ServerSettings.layerTest()),
  Layer.provideMerge(ServerSecretStore.layer),
  Layer.provide(
    ServerConfig.layerTest(process.cwd(), { prefix: "t3-antigravity-provider-test-" }).pipe(
      Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
    ),
  ),
);

type ProbeError = EffectAcpErrors.AcpError | ProviderSetupError;

const makeHarness = Effect.fn("makeAntigravityProviderHarness")(function* (
  options: {
    readonly auth?: { readonly type: string; readonly label: string };
    readonly enabled?: boolean;
    readonly safe?: boolean;
    readonly probeUsage?: Effect.Effect<ServerProviderUsageLimits>;
  } = {},
) {
  const initialProbe = yield* Deferred.make<EffectAcpSchema.InitializeResponse, ProbeError>();
  const probeCalls = yield* Ref.make(0);
  const safetyCalls = yield* Ref.make(0);
  const probe = yield* Ref.make<Effect.Effect<EffectAcpSchema.InitializeResponse, ProbeError>>(
    Deferred.await(initialProbe),
  );
  const safety = yield* Ref.make<Effect.Effect<boolean>>(Effect.succeed(options.safe ?? true));
  const provider = yield* makeAntigravityProvider(
    decodeSettings({ enabled: options.enabled ?? true, customModels: ["do-not-seed-me"] }),
    {
      stampIdentity: (snapshot) => Effect.succeed({ ...snapshot, instanceId, driver }),
      ...(options.auth ? { auth: options.auth } : {}),
      ...(options.probeUsage ? { probeUsage: options.probeUsage } : {}),
      probe: Ref.update(probeCalls, (count) => count + 1).pipe(
        Effect.andThen(Ref.get(probe)),
        Effect.flatten,
      ),
      supportsTextGeneration: Ref.update(safetyCalls, (count) => count + 1).pipe(
        Effect.andThen(Ref.get(safety)),
        Effect.flatten,
      ),
    },
  );
  const initialUpdate = yield* Stream.toPull(
    provider.snapshot.streamChanges.pipe(
      Stream.filter((snapshot) => snapshot.installed || snapshot.status === "error"),
    ),
  );
  const initialize = Deferred.succeed(initialProbe, initializeResult).pipe(
    Effect.andThen(initialUpdate),
    Effect.asVoid,
  );
  // Subscribe before the trigger; yield the returned pull to await the publish.
  const nextPublish = (predicate: (snapshot: ServerProvider) => boolean) =>
    Stream.toPull(provider.snapshot.streamChanges.pipe(Stream.filter(predicate))).pipe(
      Effect.map((pull) => pull.pipe(Effect.map((snapshots) => snapshots[0]))),
    );
  return {
    provider,
    probe,
    probeCalls,
    safety,
    safetyCalls,
    initialProbe,
    initialUpdate,
    initialize,
    nextPublish,
  };
});

describe("Antigravity model catalog", () => {
  it("uses legacy session models only when model config is absent", () => {
    const fromLegacy = buildAntigravityModelsFromSession({
      models: sessionSetupResult.models,
    });
    expect(fromLegacy).toEqual(buildAntigravityModelsFromSession(sessionSetupResult));
    expect(
      buildAntigravityModelsFromSession({
        ...sessionSetupResult,
        configOptions: [{ ...modelConfig, options: [] }],
      }),
    ).toEqual([]);
  });

  it("flattens native option groups without combining distinct model IDs", () => {
    const models = buildAntigravityModelsFromSession({
      configOptions: [
        {
          ...modelConfig,
          currentValue: "gemini-pro-agent",
          options: [
            { groupId: "Flash", name: "Flash", options: [modelOptions[3]!, modelOptions[4]!] },
            { groupId: "Pro", name: "Pro", options: [modelOptions[9]!, modelOptions[3]!] },
          ],
        },
      ],
    });
    expect(models.map((model) => model.slug)).toEqual([
      "gemini-3.7-flash-high",
      "gemini-3.7-flash-medium",
      "gemini-pro-agent",
    ]);
    expect(models.find((model) => model.isDefault)?.slug).toBe("gemini-pro-agent");
    expect(models.find((model) => model.aliases?.includes(ANTIGRAVITY_DEFAULT_MODEL))?.slug).toBe(
      "gemini-pro-agent",
    );
  });

  it("labels models that share a display name with their IDs", () => {
    const models = buildAntigravityModelsFromSession({
      configOptions: [
        {
          ...modelConfig,
          currentValue: "gemini-3.8-flash",
          options: [
            { value: "gemini-3.8-flash", name: "Gemini 3.8 Flash" },
            { value: "gemini-3.8-flash-preview", name: "Gemini 3.8 Flash" },
          ],
        },
      ],
    });
    expect(models.map((model) => model.name)).toEqual([
      "Gemini 3.8 Flash",
      "Gemini 3.8 Flash (gemini-3.8-flash-preview)",
    ]);
  });

  it("offers each model the thinking levels it reported when selected", () => {
    const thinking = (currentValue: string) =>
      ({
        id: "thinking_level",
        name: "Thinking Level",
        category: "thought_level",
        type: "select",
        currentValue,
        options: [
          { value: "low", name: "Low" },
          { value: "high", name: "High" },
        ],
      }) satisfies EffectAcpSchema.SessionConfigOption;
    const models = buildAntigravityModelsFromSession(
      {
        configOptions: [
          {
            ...modelConfig,
            currentValue: "gemini",
            options: [
              { value: "gemini", name: "Gemini" },
              { value: "claude", name: "Claude" },
              { value: "plain", name: "Plain" },
              { value: "unseen", name: "Unseen" },
            ],
          },
          thinking("high"),
        ],
      },
      new Map([
        ["claude", thinking("low")],
        ["plain", null],
      ]),
    );
    const thinkingOf = (slug: string) =>
      models.find((model) => model.slug === slug)?.capabilities?.optionDescriptors?.[0];

    expect(thinkingOf("gemini")).toMatchObject({ id: "thinking_level", currentValue: "high" });
    expect(thinkingOf("claude")).toMatchObject({ id: "thinking_level", currentValue: "low" });
    expect(thinkingOf("plain")).toBeUndefined();
    expect(thinkingOf("unseen")).toMatchObject({ id: "thinking_level" });
    expect(thinkingOf("unseen")).not.toHaveProperty("currentValue");
  });
});

it.layer(layerTest)("Antigravity provider snapshots", (it) => {
  it.effect("does not probe or run helper safety checks while disabled", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const harness = yield* makeHarness({ enabled: false });
        const snapshot = yield* harness.provider.snapshot.refresh;
        expect(snapshot).toMatchObject({
          enabled: false,
          installed: false,
          status: "disabled",
          auth: { status: "unknown" },
          models: [],
          setup: { canAuthenticate: true, canInstall: true },
          showInteractionModeToggle: false,
          supportsConversationRollback: false,
          supportsTextGeneration: false,
        });
        expect(yield* Ref.get(harness.probeCalls)).toBe(0);
        expect(yield* Ref.get(harness.safetyCalls)).toBe(0);
      }),
    ),
  );

  it.effect("treats initialize as installation proof, not account or model discovery", () =>
    Effect.scoped(
      Effect.gen(function* () {
        for (const auth of [
          undefined,
          { type: "oauth-personal", label: "Google account" },
          { type: "oauth-business", label: "Gemini Enterprise" },
          { type: "gemini-api-key", label: "Gemini API key" },
          { type: "agent-platform", label: "Agent Platform" },
        ]) {
          const harness = yield* makeHarness(auth ? { auth } : {});
          expect(yield* harness.provider.snapshot.getSnapshot).toMatchObject({
            installed: false,
            status: "warning",
            auth: { status: "unknown" },
            models: [],
          });
          yield* harness.initialize;
          const snapshot = yield* harness.provider.snapshot.getSnapshot;
          expect(snapshot).toMatchObject({
            installed: true,
            status: "warning",
            version: "agy_acp_server_20260818_01_RC01",
            auth: { status: "unknown", ...(auth ? { type: auth.type } : {}) },
            message:
              auth?.type === "gemini-api-key" || auth?.type === "agent-platform"
                ? `Antigravity is installed. Connect with ${auth.label} to load models.`
                : "Antigravity is installed. Google account access is not checked yet.",
            models: [],
          });
          expect(yield* Ref.get(harness.probeCalls)).toBe(1);
        }
      }),
    ),
  );

  it.effect("does not offer Auto, so Auto threads fall back to Supervised", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const harness = yield* makeHarness();
        yield* harness.initialize;
        // Antigravity has no automatic review; the shared ACP policy would approve every request.
        expect((yield* harness.provider.snapshot.getSnapshot).supportedRuntimeModes).toEqual([
          "approval-required",
          "auto-accept-edits",
          "full-access",
        ]);
      }),
    ),
  );

  it.effect("publishes session metadata and native commands without another health probe", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const harness = yield* makeHarness();
        yield* harness.initialize;
        const nextReady = yield* Stream.toPull(
          harness.provider.snapshot.streamChanges.pipe(
            Stream.filter(
              (snapshot) =>
                snapshot.auth.status === "authenticated" && snapshot.slashCommands.length > 0,
            ),
          ),
        );
        yield* harness.provider.onSessionStarted(started, "/workspace");
        yield* harness.provider.onAvailableCommands(commands, "/workspace");
        const [snapshot] = yield* nextReady;
        expect(snapshot).toMatchObject({
          status: "ready",
          auth: { status: "authenticated", type: "oauth-personal" },
          supportsTextGeneration: true,
        });
        expect(snapshot.models).toEqual(buildAntigravityModelsFromSession(sessionSetupResult));
        expect(snapshot.slashCommands).toEqual(expectedCommands);
        expect((yield* harness.provider.snapshotForCwd("/workspace")).slashCommands).toEqual(
          expectedCommands,
        );
        expect(yield* Ref.get(harness.probeCalls)).toBe(1);
      }),
    ),
  );

  it.effect("clears all account metadata on sign-out and authentication failure", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const auth = { type: "gemini-api-key", label: "Gemini API key" };
        const harness = yield* makeHarness({ auth });
        yield* harness.initialize;
        for (const clear of [harness.provider.onSignedOut, harness.provider.onAuthRequired]) {
          yield* harness.provider.onSessionStarted(started, "/workspace");
          yield* harness.provider.onAvailableCommands(commands, "/workspace");
          yield* clear;
          expect(yield* harness.provider.snapshot.getSnapshot).toMatchObject({
            installed: true,
            status: "warning",
            auth: { status: "unauthenticated", type: auth.type, label: auth.label },
            message: "Connect with Gemini API key to use Antigravity and load models.",
            models: [],
            slashCommands: [],
            skills: [],
            workspaceSnapshots: [],
            supportsTextGeneration: false,
          });
          yield* harness.provider.onAvailableCommands(commands, "/workspace");
          yield* harness.provider.onConfigOptionsUpdated([modelConfig]);
          expect((yield* harness.provider.snapshotForCwd("/workspace")).slashCommands).toEqual([]);
          expect((yield* harness.provider.snapshot.getSnapshot).models).toEqual([]);
        }
        const refreshed = yield* harness.provider.snapshot.refresh;
        expect(refreshed.auth).toEqual({
          status: "unauthenticated",
          type: auth.type,
          label: auth.label,
        });
        expect(refreshed.message).toBe(
          "Connect with Gemini API key to use Antigravity and load models.",
        );
        expect(refreshed.supportsTextGeneration).toBe(false);
      }),
    ),
  );

  it.effect("replaces live model choices and accepts an empty catalog", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const harness = yield* makeHarness();
        yield* harness.initialize;
        yield* harness.provider.onSessionStarted(started, "/workspace");
        yield* harness.provider.onAvailableCommands(commands, "/workspace");
        const before = yield* harness.provider.snapshot.getSnapshot;
        const configOptions = [
          {
            ...modelConfig,
            currentValue: "gemini-3.8-flash-high",
            options: modelOptions.slice(0, 3),
          },
        ];
        const nextSnapshot = yield* Stream.toPull(
          harness.provider.snapshot.streamChanges.pipe(
            Stream.filter((snapshot) => snapshot.models.length === 3),
          ),
        );
        yield* harness.provider.onConfigOptionsUpdated(configOptions);
        expect((yield* nextSnapshot)[0]).toMatchObject({
          models: buildAntigravityModelsFromSession({ configOptions }),
          auth: before.auth,
          workspaceSnapshots: before.workspaceSnapshots,
          slashCommands: expectedCommands,
        });
        yield* harness.provider.onConfigOptionsUpdated([]);
        expect((yield* harness.provider.snapshot.getSnapshot).models).toEqual([]);
      }),
    ),
  );

  it.effect("does not guess a version before a custom launcher's first handshake", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const harness = yield* makeHarness();
        yield* Deferred.succeed(harness.initialProbe, {
          ...initializeResult,
          agentInfo: { ...initializeResult.agentInfo, version: "unknown" },
        });
        yield* harness.initialUpdate;
        expect((yield* harness.provider.snapshot.getSnapshot).version).toBeNull();
      }),
    ),
  );

  it.effect("does not replace a handshake version with an unknown custom-launcher probe", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const harness = yield* makeHarness();
        yield* harness.initialize;
        yield* harness.provider.onSessionStarted({
          ...started,
          initializeResult: {
            ...initializeResult,
            agentInfo: { ...initializeResult.agentInfo, version: "1.4.0" },
          },
        });
        yield* Ref.set(
          harness.probe,
          Effect.succeed({
            ...initializeResult,
            agentInfo: { ...initializeResult.agentInfo, version: "unknown" },
          }),
        );
        expect((yield* harness.provider.snapshot.refresh).version).toBe("1.4.0");
      }),
    ),
  );

  it.effect("replaces one account's catalog instead of combining accounts", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const harness = yield* makeHarness();
        yield* harness.initialize;
        yield* harness.provider.onSessionStarted(started);
        yield* harness.provider.onSignedOut;
        yield* harness.provider.onSessionStarted({
          ...started,
          sessionSetupResult: {
            sessionId: "new-account-session",
            configOptions: [
              { ...modelConfig, currentValue: "gemini-pro-agent", options: [modelOptions[9]!] },
            ],
          },
        });
        expect(
          (yield* harness.provider.snapshot.getSnapshot).models.map((model) => model.slug),
        ).toEqual(["gemini-pro-agent"]);
      }),
    ),
  );

  it.effect("retains known account metadata when a local health check fails", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const harness = yield* makeHarness();
        yield* harness.initialize;
        yield* harness.provider.onSessionStarted(started, "/workspace");
        yield* harness.provider.onAvailableCommands(commands, "/workspace");
        yield* Ref.set(
          harness.probe,
          Effect.fail(EffectAcpErrors.AcpRequestError.internalError("probe failed")),
        );
        const snapshot = yield* harness.provider.snapshot.refresh;
        expect(snapshot).toMatchObject({
          installed: true,
          status: "error",
          auth: { status: "authenticated" },
        });
        expect(snapshot.models).toEqual(buildAntigravityModelsFromSession(sessionSetupResult));
        expect(snapshot.slashCommands).toEqual(expectedCommands);
        expect(snapshot.workspaceSnapshots?.[0]?.cwd).toBe("/workspace");
      }),
    ),
  );

  it.effect("distinguishes missing executables from a failed installed executable", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const harness = yield* makeHarness();
        yield* harness.initialize;
        const failures = [
          {
            error: new EffectAcpErrors.AcpSpawnError({ cause: { code: "ENOENT" } }),
            installed: false,
          },
          {
            error: new EffectAcpErrors.AcpSpawnError({ cause: { code: "EACCES" } }),
            installed: true,
          },
          {
            error: new ProviderSetupError({
              instanceId,
              operation: "resolve",
              detail: "Antigravity is not installed.",
            }),
            installed: false,
          },
        ];
        for (const { error, installed } of failures) {
          yield* harness.provider.onSessionStarted(started, "/workspace");
          yield* harness.provider.onAvailableCommands(commands, "/workspace");
          yield* Ref.set(harness.probe, Effect.fail(error));
          const snapshot = yield* harness.provider.snapshot.refresh;
          expect(snapshot).toMatchObject({
            installed,
            status: "error",
            auth: { status: "authenticated" },
          });
          expect(snapshot.models).toHaveLength(installed ? 11 : 0);
          expect(snapshot.slashCommands).toHaveLength(installed ? 2 : 0);
          expect(snapshot.workspaceSnapshots).toHaveLength(installed ? 1 : 0);
          expect(snapshot.supportsTextGeneration).toBe(installed);
        }
      }),
    ),
  );

  it.effect("does not let an old health result restore a signed-out account", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const harness = yield* makeHarness();
        yield* harness.initialize;
        yield* harness.provider.onSessionStarted(started);
        const releaseProbe = yield* Deferred.make<EffectAcpSchema.InitializeResponse>();
        const probeEntered = yield* Deferred.make<void>();
        yield* Ref.set(
          harness.probe,
          Deferred.succeed(probeEntered, undefined).pipe(
            Effect.andThen(Deferred.await(releaseProbe)),
          ),
        );
        const refresh = yield* harness.provider.snapshot.refresh.pipe(Effect.forkChild);
        yield* Deferred.await(probeEntered);
        yield* harness.provider.onSignedOut;
        yield* Deferred.succeed(releaseProbe, initializeResult);
        const snapshot = yield* Fiber.join(refresh);
        expect(snapshot).toMatchObject({
          auth: { status: "unauthenticated" },
          models: [],
          supportsTextGeneration: false,
        });
      }),
    ),
  );

  it.effect("exposes helper support only when the supplied safety check allows it", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const harness = yield* makeHarness({ safe: false });
        yield* harness.initialize;
        yield* harness.provider.onSessionStarted(started);
        expect((yield* harness.provider.snapshot.getSnapshot).supportsTextGeneration).toBe(false);
        yield* Ref.set(harness.safety, Effect.succeed(true));
        yield* harness.provider.snapshot.refresh;
        expect((yield* harness.provider.snapshot.getSnapshot).supportsTextGeneration).toBe(true);
      }),
    ),
  );

  it.effect("keeps discovered workspace skills through session and command updates", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const harness = yield* makeHarness();
        yield* harness.initialize;
        const skills = [
          {
            name: "deploy",
            description: "Ship it",
            path: "/workspace/.agent/skills/deploy",
            enabled: true,
          },
        ];
        const discovered = yield* harness.provider.snapshotForCwd("/workspace", skills);
        expect(discovered.skills).toEqual(skills);
        yield* harness.provider.onSessionStarted(started, "/workspace");
        yield* harness.provider.onAvailableCommands(commands, "/workspace");
        const after = yield* harness.provider.snapshot.getSnapshot;
        expect(
          after.workspaceSnapshots?.find((entry) => entry.cwd === "/workspace")?.skills,
        ).toEqual(skills);
        expect((yield* harness.provider.snapshotForCwd("/workspace")).skills).toEqual(skills);

        const rescanned = [
          ...skills,
          { name: "review", path: "/workspace/.agent/skills/review", enabled: true },
        ];
        yield* harness.provider.snapshotForCwd("/workspace", rescanned);
        yield* harness.provider.onSessionStarted(started, "/workspace");
        expect(
          (yield* harness.provider.snapshot.getSnapshot).workspaceSnapshots?.find(
            (entry) => entry.cwd === "/workspace",
          )?.skills,
        ).toEqual(rescanned);
      }),
    ),
  );

  it.effect("bounds workspace metadata without starting sessions for workspace lookup", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const harness = yield* makeHarness();
        yield* harness.initialize;
        yield* harness.provider.onSessionStarted(started);
        for (let index = 0; index < 35; index++) {
          yield* harness.provider.onAvailableCommands(commands, `/workspace-${index}`);
        }
        const snapshot = yield* harness.provider.snapshotForCwd("/workspace-34");
        expect(snapshot.workspaceSnapshots).toHaveLength(32);
        expect(snapshot.workspaceSnapshots?.[0]?.cwd).toBe("/workspace-3");
        expect(snapshot.slashCommands).toEqual(expectedCommands);
        expect(yield* Ref.get(harness.probeCalls)).toBe(1);
      }),
    ),
  );

  it.effect(
    "publishes limits, retains a successful read on failure, and clears them on sign-out",
    () =>
      Effect.scoped(
        Effect.gen(function* () {
          const limits: ServerProviderUsageLimits = {
            checkedAt: "2026-10-09T12:00:00.000Z",
            windows: [
              {
                id: "3p-weekly",
                kind: "weekly",
                label: "Claude & GPT (shared) · Weekly",
                usedPercent: 75,
              },
            ],
          };
          const usage = yield* Ref.make(limits);
          const harness = yield* makeHarness({ probeUsage: Ref.get(usage) });
          const published = yield* harness.nextPublish((snapshot) => !!snapshot.usageLimits);
          yield* harness.initialize;
          expect((yield* published)?.usageLimits).toEqual(limits);
          // The second health check is the one the failed background read triggers.
          const checks = yield* Ref.make(0);
          const failedReadApplied = yield* Deferred.make<void>();
          yield* Ref.set(
            harness.probe,
            Ref.updateAndGet(checks, (count) => count + 1).pipe(
              Effect.tap((count) =>
                count === 2 ? Deferred.succeed(failedReadApplied, undefined) : Effect.void,
              ),
              Effect.as(initializeResult),
            ),
          );
          yield* Ref.set(usage, {
            checkedAt: "2026-10-09T12:01:00.000Z",
            windows: [],
            unavailable: { reason: "probeFailed" },
          });
          yield* harness.provider.snapshot.refresh;
          yield* Deferred.await(failedReadApplied);
          expect((yield* harness.provider.snapshot.getSnapshot).usageLimits).toEqual(limits);
          yield* harness.provider.onSignedOut;
          expect((yield* harness.provider.snapshot.getSnapshot).usageLimits).toBeUndefined();
          yield* Ref.set(usage, {
            checkedAt: "2026-10-09T12:02:00.000Z",
            windows: [],
            unavailable: { reason: "unsupported" },
          });
          const unsupported = yield* harness.nextPublish(
            (snapshot) => snapshot.usageLimits?.unavailable?.reason === "unsupported",
          );
          yield* harness.provider.snapshot.refresh;
          expect((yield* unsupported)?.usageLimits?.windows).toEqual([]);
        }),
      ),
  );

  it.effect("a quota read finishing after sign-out cannot restore account limits", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const readStarted = yield* Deferred.make<void>();
        const readResult = yield* Deferred.make<ServerProviderUsageLimits>();
        const usage = yield* Ref.make<Effect.Effect<ServerProviderUsageLimits>>(
          Effect.succeed({ checkedAt: "2026-10-09T12:00:00.000Z", windows: [] }),
        );
        const harness = yield* makeHarness({ probeUsage: Ref.get(usage).pipe(Effect.flatten) });
        yield* harness.initialize;
        yield* Ref.set(harness.probe, Effect.succeed(initializeResult));
        yield* Ref.set(
          usage,
          Deferred.succeed(readStarted, undefined).pipe(Effect.andThen(Deferred.await(readResult))),
        );
        const refresh = yield* harness.provider.snapshot.refresh.pipe(Effect.forkChild);
        yield* Deferred.await(readStarted);
        yield* harness.provider.onSignedOut;
        yield* Deferred.succeed(readResult, {
          checkedAt: "2026-10-09T12:01:00.000Z",
          windows: [
            { id: "gemini-5h", kind: "session", label: "Gemini · 5-hour", usedPercent: 10 },
          ],
        });
        yield* Fiber.join(refresh);
        expect((yield* harness.provider.snapshot.getSnapshot).usageLimits).toBeUndefined();
      }),
    ),
  );

  it.effect("reports ready and starts sessions while one shared quota read is pending", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const reads = yield* Ref.make(0);
        const readStarted = yield* Deferred.make<void>();
        const readResult = yield* Deferred.make<ServerProviderUsageLimits>();
        const harness = yield* makeHarness({
          probeUsage: Ref.update(reads, (count) => count + 1).pipe(
            Effect.andThen(Deferred.succeed(readStarted, undefined)),
            Effect.andThen(Deferred.await(readResult)),
          ),
        });
        const published = yield* harness.nextPublish((snapshot) => !!snapshot.usageLimits);
        yield* harness.initialize;
        yield* Deferred.await(readStarted);
        yield* harness.provider.onSessionStarted(started, "/workspace");
        yield* harness.provider.onSessionStarted(started, "/other");
        const ready = yield* harness.provider.snapshot.getSnapshot;
        expect(ready).toMatchObject({ status: "ready", auth: { status: "authenticated" } });
        expect(ready.usageLimits).toBeUndefined();
        expect(yield* Ref.get(reads)).toBe(1);
        const limits = {
          checkedAt: "2026-10-09T12:00:00.000Z",
          windows: [
            { id: "gemini-5h", kind: "session", label: "Gemini · 5-hour", usedPercent: 10 },
          ],
        } satisfies ServerProviderUsageLimits;
        yield* Deferred.succeed(readResult, limits);
        expect((yield* published)?.usageLimits).toEqual(limits);
      }),
    ),
  );

  it.effect("a quota read for the previous account is dropped after a new sign-in", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const oldReadStarted = yield* Deferred.make<void>();
        const newLimits = {
          checkedAt: "2026-10-09T12:01:00.000Z",
          windows: [{ id: "3p-weekly", kind: "weekly", label: "Weekly", usedPercent: 40 }],
        } satisfies ServerProviderUsageLimits;
        const usage = yield* Ref.make<Effect.Effect<ServerProviderUsageLimits>>(
          Deferred.succeed(oldReadStarted, undefined).pipe(Effect.andThen(Effect.never)),
        );
        const harness = yield* makeHarness({ probeUsage: Ref.get(usage).pipe(Effect.flatten) });
        const published = yield* harness.nextPublish((snapshot) => !!snapshot.usageLimits);
        yield* harness.initialize;
        yield* Deferred.await(oldReadStarted);
        yield* Ref.set(usage, Effect.succeed(newLimits));
        yield* harness.provider.onSignedIn;
        yield* harness.provider.onSessionStarted(started);
        expect((yield* published)?.usageLimits).toEqual(newLimits);
        // Switching again must not republish the previous account's limits, even if the read fails.
        const failed = {
          checkedAt: "2026-10-09T12:02:00.000Z",
          windows: [],
          unavailable: { reason: "probeFailed" },
        } satisfies ServerProviderUsageLimits;
        yield* Ref.set(usage, Effect.succeed(failed));
        const republished = yield* harness.nextPublish(
          (snapshot) => snapshot.usageLimits?.unavailable?.reason === "probeFailed",
        );
        yield* harness.provider.onSignedIn;
        expect((yield* harness.provider.snapshot.getSnapshot).usageLimits).toBeUndefined();
        yield* harness.provider.onSessionStarted(started);
        expect((yield* republished)?.usageLimits).toEqual(failed);
      }),
    ),
  );
});