fix(server): poll provider usage only while visible

apps/mobile/src/features/threads/NewTaskDraftScreen.tsx

@@ -643,14 +643,15 @@ export function NewTaskDraftScreen(props: {
       return null;
     }
 
-    const message = flow.buildPendingTaskMessage(creationMetadata, {
+    flow.setSubmitting(true);
+    const message = await flow.buildPendingTaskMessage(creationMetadata, {
       currentCheckoutBranch: queuesInsteadOfStarting ? null : flow.currentCheckoutBranchName,
     });
     if (!message) {
+      flow.setSubmitting(false);
       return null;
     }
     // Persist locally before clearing or leaving the draft; server setup runs on the thread.
-    flow.setSubmitting(true);
     const queued = await settlePromise(() => enqueueThreadOutboxMessage(message));
     flow.setSubmitting(false);
     if (AsyncResult.isFailure(queued)) {

apps/mobile/src/features/threads/ThreadDetailScreen.tsx

@@ -1,3 +1,4 @@
+import { useInstanceLimitsRefresh } from "../usage/useInstanceLimitsRefresh";
 import { ChildThreadApprovals } from "./ChildThreadApprovals";
 import { useOpenThreadInspector } from "./thread-inspector-navigation";
 import { useSidebarWorkspaceTabs } from "../layout/workspace/useSystemWorkspaceTabBar";
@@ -983,6 +984,18 @@ function ThreadDetailBody(
           usageLimitsPanel.now,
         )
       : null;
+  useInstanceLimitsRefresh(
+    appAtomRegistry,
+    props.environmentId,
+    props.selectedThread.modelSelection.instanceId,
+    props.serverConfig?.providers.find(
+      (provider) => provider.instanceId === props.selectedThread.modelSelection.instanceId,
+    )?.driver,
+    usageLimitsPanel !== null &&
+      (props.showContent ?? true) &&
+      activeUserInputRequestId === null &&
+      props.connectionStateLabel === "connected",
+  );
   const showUsageLimits = (report: UsageLimitsReport | null) =>
     setUsageLimitsPanel(
       report === null

apps/mobile/src/features/threads/new-task-flow-provider.test.tsx

@@ -4,6 +4,10 @@ import { EnvironmentRegistry } from "@t3tools/client-runtime/connection";
 import { createEnvironmentSubscriptionAtomFamily } from "@t3tools/client-runtime/state/runtime";
 import {
   AuthFilesystemReadScope,
+  DEFAULT_SERVER_SETTINGS,
+  ProviderDriverKind,
+  ProviderInstanceId,
+  type ServerProvider,
   EnvironmentId,
   ProjectId,
   type VcsListRefsResult,
@@ -20,6 +24,7 @@ import type { ComposerDraft } from "../../state/use-composer-drafts";
 
 const mocks = vi.hoisted(() => ({
   projects: vi.fn(),
+  config: vi.fn(),
   status: vi.fn(),
   refs: vi.fn(),
   readFile: vi.fn(),
@@ -43,7 +48,7 @@ vi.mock("../../state/atom-registry", () => ({
 vi.mock("../../state/entities", () => ({
   useProjects: mocks.projects,
   useThreadShells: () => [],
-  useEnvironmentServerConfig: () => null,
+  useEnvironmentServerConfig: mocks.config,
   useServerConfigs: () => new Map(),
 }));
 vi.mock("../../state/vcs", () => ({
@@ -58,6 +63,14 @@ vi.mock("../../state/session", () => ({
 vi.mock("../../state/presentation", () => ({
   useEnvironmentPresentation: mocks.presentation,
 }));
+vi.mock("../../state/server", () => ({
+  serverEnvironment: {
+    refreshProviders: {
+      label: "refresh providers",
+      run: async () => AsyncResult.success({ providers: [] }),
+    },
+  },
+}));
 vi.mock("../../state/orchestration", () => ({ orchestrationEnvironment: {} }));
 vi.mock("../../state/threads", () => ({ olderSettledThreads: {}, threadFamilies: {} }));
 vi.mock("../../state/pull-requests", () => ({ composerPullRequests: {} }));
@@ -132,6 +145,7 @@ function setup() {
   vi.clearAllMocks();
   const registry = AtomRegistry.make();
   mocks.registry.mockReturnValue(registry);
+  mocks.config.mockReturnValue(null);
   const projects = [project("one", "a"), project("one", "b"), project("two", "b")];
   mocks.projects.mockReturnValue(projects);
   mocks.presentation.mockReturnValue({
@@ -365,3 +379,52 @@ it("uses cached repository capability and branch defaults while offline", async
   expect(screen.current.draftKey).toBe(draftKey);
   expect(screen.current.selectedBranchName).toBe("main");
 });
+
+it.each(["removed", "disabled", "valid"] as const)(
+  "queues the displayed model when the saved pick is %s",
+  async (state) => {
+    using screen = setup();
+    const primary = { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" };
+    const saved = { instanceId: ProviderInstanceId.make("claude_work"), model: "sonnet" };
+    const providers: ServerProvider[] = [primary, ...(state === "removed" ? [] : [saved])].map(
+      (selection) => ({
+        instanceId: selection.instanceId,
+        driver: ProviderDriverKind.make(selection === primary ? "codex" : "claudeAgent"),
+        enabled: selection === primary || state !== "disabled",
+        installed: true,
+        version: "1",
+        status: "ready",
+        auth: { status: "authenticated" },
+        checkedAt: "2026-01-01T00:00:00Z",
+        models: [],
+        slashCommands: [],
+        skills: [],
+      }),
+    );
+    mocks.config.mockReturnValue({
+      providers,
+      settings: {
+        ...DEFAULT_SERVER_SETTINGS,
+        defaultModelSelection: primary,
+        providerInstances: {
+          [primary.instanceId]: { driver: "codex", config: {} },
+          [saved.instanceId]: { driver: "claudeAgent", config: { enabled: state !== "disabled" } },
+        },
+      },
+    });
+    await screen.render(true);
+    act(() => {
+      screen.current.setPrompt("hello");
+      mocks.writeSettings(screen.current.draftKey!, { modelSelection: saved });
+    });
+    const shown = state === "valid" ? saved : primary;
+    expect(screen.current.selectedModel).toEqual(shown);
+    const message = await screen.current.buildPendingTaskMessage({
+      commandId: "command",
+      messageId: "message",
+      threadId: "thread",
+      createdAt: "2026-01-01T00:00:00Z",
+    });
+    expect(message?.modelSelection).toEqual(shown);
+  },
+);

apps/mobile/src/features/threads/new-task-flow-provider.tsx

@@ -1,5 +1,7 @@
 import { ActiveNewTaskContext } from "../../state/active-new-task";
 import { resolveNewThreadModelSelection } from "@t3tools/shared/usageLimits";
+import { refreshNewThreadUsage } from "@t3tools/client-runtime/state/usage";
+import { serverEnvironment } from "../../state/server";
 import { useNowMinuteMs } from "../../lib/clock";
 import * as Dialog from "../../components/ui/Dialog";
 import React, { useEffect, useRef, useState } from "react";
@@ -196,7 +198,7 @@ type NewTaskFlowContextValue = {
     options?: {
       readonly currentCheckoutBranch?: string | null;
     },
-  ) => QueuedThreadMessage | null;
+  ) => Promise<QueuedThreadMessage | null>;
   readonly setPrompt: (value: string) => void;
   readonly replaceAttachments: (attachments: ReadonlyArray<DraftComposerAttachment>) => void;
   /** Appends draft attachments; returns how many the live cap rejected. */
@@ -717,21 +719,43 @@ export function NewTaskFlowProvider(
     }
   };
 
-  const buildPendingTaskMessage = (
+  const buildPendingTaskMessage = async (
     metadata: TurnCommandMetadata,
     options?: { readonly currentCheckoutBranch?: string | null },
-  ): QueuedThreadMessage | null => {
+  ): Promise<QueuedThreadMessage | null> => {
     if (!selectedProject || !selectedProjectDraftKey) {
       return null;
     }
     const draft = getComposerDraftSnapshot(selectedProjectDraftKey);
     const text = draft.text.trim();
-    const draftModelSelection =
-      resolveSelectableModelSelection(
-        selectedEnvironmentServerConfig,
-        draft.modelSelection ?? null,
-        selectedProject.id,
-      ) ?? selectedModel;
+    const savedSelection = resolveSelectableModelSelection(
+      selectedEnvironmentServerConfig,
+      draft.modelSelection ?? null,
+      selectedProject.id,
+    );
+    const selectionInput = {
+      defaultSelection: selectedDefaultModel,
+      explicitSelection:
+        savedSelection ?? (projectDefaultModelSelection ? null : stickyModelSelection),
+      fallbackSelection: selectedEnvironmentServerConfig?.settings.fallbackModelSelection ?? null,
+      providers: selectedEnvironmentServerConfig?.providers ?? [],
+      ...(selectedEnvironmentServerConfig
+        ? { settings: selectedEnvironmentServerConfig.settings }
+        : {}),
+      projectId: selectedProject.id,
+      now: Date.now(),
+    };
+    const providers = await refreshNewThreadUsage({
+      registry: appAtomRegistry,
+      server: serverEnvironment,
+      environmentId: selectedProject.environmentId,
+      input: selectionInput,
+    });
+    const refreshedSelection = resolveNewThreadModelSelection({
+      ...selectionInput,
+      providers,
+    }).selection;
+    const draftModelSelection = savedSelection ?? refreshedSelection;
     if ((text.length === 0 && draft.attachments.length === 0) || !draftModelSelection) {
       return null;
     }

apps/mobile/src/features/usage/UsageLimitsSection.tsx

@@ -14,6 +14,7 @@ import {
   formatDuration,
   formatResetsIn,
   limitsNotice,
+  STALE_USAGE_NOTICE,
   paceOf,
   paceRemainingPercent,
   remainingPercent,
@@ -197,6 +198,9 @@ export function AccountLimits(props: {
         </View>
         {props.trailing}
       </View>
+      {limits.stale ? (
+        <Text className="text-sm text-foreground-muted">{STALE_USAGE_NOTICE}</Text>
+      ) : null}
       {notice ? (
         <Text className="text-sm text-foreground-muted">{notice}</Text>
       ) : (