[Bug]: Mobile keeps Send disabled for a saved Antigravity model while sign-in is unchecked or the catalog is incomplete #35413

set -eu
tmp=$(mktemp -d)
mkdir -p "$tmp/user" "$tmp/tmp" "$tmp/t3"
export HOME="$tmp/user" TMPDIR="$tmp/tmp" T3CODE_HOME="$tmp/t3"
export VERIFY_OUTPUT="$tmp/result"
export PATH="$PWD/node_modules/.bin:$PATH"
testfile=apps/mobile/src/lib/verify-antigravity-restart.test.ts
trap 'rm -f "$testfile"; rm -rf "$tmp"' EXIT
cat > "$testfile" <<'TS'
import { appendFileSync } from "node:fs";
import { expect, it } from "vite-plus/test";
import { ProviderInstanceId, type ServerConfig } from "@t3tools/contracts";
import { isModelSelectionUnavailable, resolveSelectableModelSelection, describeUnavailableModelSelection } from "./modelOptions";
it("compares an unchecked existing selection with a ready catalog", () => {
  const selection = { instanceId: ProviderInstanceId.make("google_work"), model: "gemini-3.7-flash-high" };
  const base = { instanceId: selection.instanceId, driver: "antigravity", enabled: true, installed: true, status: "warning", auth: { status: "unknown" }, models: [] };
  const catalog = [{ slug: selection.model, name: "Gemini 3.7 Flash (High)", capabilities: null, isCustom: false }];
  const cases = [
    ["unchecked", base, true],
    ["nonready-missing", { ...base, auth: { status: "authenticated" }, models: [{ ...catalog[0], slug: "another-model" }] }, true],
    ["ready-control", { ...base, status: "ready", auth: { status: "authenticated" }, models: catalog }, false],
  ] as const;
  for (const [name, provider, expected] of cases) {
    const config = { providers: [provider] } as unknown as ServerConfig;
    expect(resolveSelectableModelSelection(config, selection, null)).toEqual(selection);
    const blocked = isModelSelectionUnavailable(config, selection, null);
    expect(blocked).toBe(expected);
    appendFileSync(process.env.VERIFY_OUTPUT!, JSON.stringify({ name, blocked, ...(blocked ? describeUnavailableModelSelection(config, selection, null) : {}) }) + "\n");
  }
});
TS
env -u NODE_ENV vp test run "$testfile"
cat "$VERIFY_OUTPUT"

#!/bin/sh
set -eu
checkout=${1:-$PWD}
cd "$checkout"
checkout=$PWD
fixture=$(mktemp -d "${TMPDIR:-/tmp}/antigravity-mobile-verify.XXXXXX")
mkdir -p "$fixture/user" "$fixture/tmp" "$fixture/t3"
export HOME="$fixture/user" TMPDIR="$fixture/tmp" T3CODE_HOME="$fixture/t3"
export VERIFY_EVIDENCE="$fixture/observations.out"
export PATH="$checkout/node_modules/.bin:$PATH"
server_test="$checkout/apps/server/src/provider/verify-antigravity-mobile-restart.test.ts"
web_test="$checkout/apps/web/src/components/verify-antigravity-mobile-restart.test.ts"
cleanup() { rm -f "$server_test" "$web_test"; rm -rf "$fixture"; }
trap cleanup EXIT INT TERM
# Reuse the repository's provider test harness and its ordinary session fixture.
# The harness supplies an ACP handshake, while exported production functions
# produce snapshots, merge caches, retain selections and decide availability.
awk '/^describe\("Antigravity model catalog"/ { exit } { print }' apps/server/src/provider/AntigravityProvider.test.ts > "$server_test"
cat >> "$server_test" <<'TS'
import { readFileSync, appendFileSync } from "node:fs";
const log = (...values: unknown[]) => appendFileSync(process.env.VERIFY_EVIDENCE!, values.join(" ") + "\n");
import { type ServerConfig as ClientConfig } from "@t3tools/contracts";
import { mergeProviderSnapshot } from "./ProviderRegistry.ts";
import { hydrateCachedProvider } from "./providerStatusCache.ts";
import {
  isModelSelectionUnavailable,
  resolveSelectableModelSelection,
  describeUnavailableModelSelection,
} from "../../../mobile/src/lib/modelOptions.ts";

const selection = { instanceId, model: "gemini-3.7-flash-high" };
const clientConfig = (provider: ServerProvider) => ({ providers: [provider] }) as unknown as ClientConfig;
const unavailable = (provider: ServerProvider) => isModelSelectionUnavailable(clientConfig(provider), selection, null);

it.layer(layerTest)("production Antigravity snapshots into mobile", (it) => {
  it.effect("compares unchecked startup, local refresh, session catalog, cache and missing-model inputs", () => Effect.scoped(Effect.gen(function* () {
    const harness = yield* makeHarness();
    yield* harness.initialize;
    const raw = yield* harness.provider.snapshot.getSnapshot;
    expect(raw).toMatchObject({ installed: true, status: "warning", auth: { status: "unknown" }, models: [] });
    // With no correlated cache, the registry publishes the genuine snapshot unchanged.
    const restart = mergeProviderSnapshot(undefined, raw);
    expect(resolveSelectableModelSelection(clientConfig(restart), selection, null)).toEqual(selection);
    expect(unavailable(restart)).toBe(true);

    // Execute the exact connected-state predicate and send-button expression from
    // production source; this is source-slice execution, not a mounted native UI.
    const ui = readFileSync(new URL("../../../mobile/src/features/threads/ThreadComposer.tsx", import.meta.url), "utf8");
    const hook = readFileSync(new URL("../../../mobile/src/state/use-thread-composer-state.ts", import.meta.url), "utf8");
    const extract = (source: string, pattern: RegExp) => {
      const value = source.match(pattern)?.[1];
      if (!value) throw new Error(`Caller changed: ${pattern}`);
      return value;
    };
    const uiUnavailable = extract(ui, /const modelUnavailable =([\s\S]*?);/);
    const canSendExpression = extract(ui, /const canSend =([\s\S]*?);/);
    const preflight = extract(hook, /(if \(modelUnavailable\) \{\s+alertModelUnavailable\(\);\s+return null;\s+\})/);
    expect(ui).toContain('label="Model unavailable. Open model settings."');
    expect(ui).toContain("disabled={!canSend}");
    const callerResult = (provider: ServerProvider) => {
      const props = { connectionState: "connected", canOperateThread: true, serverConfig: clientConfig(provider), selectedThread: { projectId: null } };
      const modelUnavailable = new Function("props", "currentModelSelection", "isModelSelectionUnavailable", `return (${uiUnavailable});`)(props, selection, isModelSelectionUnavailable);
      const canSend = new Function("props", "hasContent", "contextImports", "composerDraftKey", "isSubmissionLocked", "sendBlockedReason", "modelUnavailable", `return (${canSendExpression});`)(props, true, {}, "draft", false, null, modelUnavailable);
      let alert: unknown = null;
      const result = new Function("modelUnavailable", "alertModelUnavailable", `${preflight}\nreturn "dispatch";`)(modelUnavailable, () => { alert = describeUnavailableModelSelection(clientConfig(provider), selection, null); });
      return { modelUnavailable, canSend, preflight: result, alert };
    };
    const fail = callerResult(restart);
    expect(fail).toEqual({ modelUnavailable: true, canSend: false, preflight: null, alert: { title: "Antigravity model unavailable", detail: "Set up Antigravity on web or desktop, or choose another model." } });
    log("RESTART_NO_STATUS_CACHE", JSON.stringify({ status: restart.status, auth: restart.auth.status, models: restart.models.length, ...fail }));

    const healthRefreshed = yield* harness.provider.snapshot.refresh;
    expect(healthRefreshed).toMatchObject({ status: "warning", auth: { status: "unknown" }, models: [] });
    expect(unavailable(healthRefreshed)).toBe(true);
    log("LOCAL_HEALTH_REFRESH", JSON.stringify({ blocked: unavailable(healthRefreshed), status: healthRefreshed.status, auth: healthRefreshed.auth.status, models: healthRefreshed.models.length }));

    yield* harness.provider.onSessionStarted(started);
    const ready = yield* harness.provider.snapshot.getSnapshot;
    expect(ready).toMatchObject({ status: "ready", auth: { status: "authenticated" } });
    expect(ready.models.some((model) => model.slug === selection.model)).toBe(true);
    expect(unavailable(ready)).toBe(false);
    expect(callerResult(ready)).toEqual({ modelUnavailable: false, canSend: true, preflight: "dispatch", alert: null });
    log("READY_CONTROL_AND_RECOVERY", JSON.stringify(callerResult(ready)));

    const cached = hydrateCachedProvider({ cachedProvider: ready, fallbackProvider: restart });
    const merged = mergeProviderSnapshot(cached, restart);
    expect(merged).toMatchObject({ status: "ready", auth: { status: "authenticated" } });
    expect(unavailable(merged)).toBe(false);
    log("VALID_STATUS_CACHE_CONTROL", JSON.stringify({ blocked: unavailable(merged), status: merged.status, auth: merged.auth.status, models: merged.models.length }));

    const otherModel = ready.models.find((model) => model.slug !== selection.model)!;
    for (const status of ["warning", "error"] as const) {
      const stale = hydrateCachedProvider({ cachedProvider: { ...ready, status, models: [otherModel] }, fallbackProvider: restart });
      const snapshot = stale;
      expect(snapshot.status).toBe(status);
      expect(unavailable(snapshot)).toBe(true);
      log("NONREADY_MISSING_MODEL", JSON.stringify({ status: snapshot.status, auth: snapshot.auth.status, catalog: snapshot.models.map((model) => model.slug), ...callerResult(snapshot) }));
    }
  })));
});
TS
cat > "$web_test" <<'TS'
import { expect, it } from "vite-plus/test";
import { appendFileSync } from "node:fs";
const log = (...values: unknown[]) => appendFileSync(process.env.VERIFY_EVIDENCE!, values.join(" ") + "\n");
import { type ServerProvider } from "@t3tools/contracts";
import { getAntigravitySendBlockReason } from "./ChatView.logic";
it("compares web allowance for the same installed startup and incomplete catalogs", () => {
  const base = { driver: "antigravity", installed: true, status: "warning", auth: { status: "unknown" }, models: [] } as unknown as ServerProvider;
  expect(getAntigravitySendBlockReason(base, "gemini-3.7-flash-high")).toBeNull();
  log("WEB_UNCHECKED_CONTROL", JSON.stringify({ blockReason: getAntigravitySendBlockReason(base, "gemini-3.7-flash-high") }));
  for (const status of ["warning", "error"] as const) {
    const provider = { ...base, status, auth: { status: "authenticated" as const }, models: [{ slug: "other-model", name: "Other", capabilities: null, isCustom: false }] };
    expect(getAntigravitySendBlockReason(provider, "gemini-3.7-flash-high")).toBeNull();
    log("WEB_NONREADY_CONTROL", JSON.stringify({ status, blockReason: getAntigravitySendBlockReason(provider, "gemini-3.7-flash-high") }));
  }
});
TS
printf 'REVISION '; git rev-parse HEAD
env -u NODE_ENV vp test run apps/server/src/provider/verify-antigravity-mobile-restart.test.ts apps/web/src/components/verify-antigravity-mobile-restart.test.ts

cat "$VERIFY_EVIDENCE"