@hienlh/ppm 0.23.2 → 0.23.4

package/src/web/components/settings/accounts/codex-accounts-section.tsx

@@ -27,6 +27,7 @@ import { CodexRotationDialog } from "./codex-rotation-dialog";
 import { CodexUsageRows } from "./codex-usage-rows";
 import { CODEX_SIGNED_OUT_HINT, useCodexAccounts, type CodexAccount } from "./use-codex-accounts";
 import { CodexSignInAgainDialog } from "./codex-sign-in-again-dialog";
+import { ResetCreditsChip } from "./account-usage-extras";
 import { AccountHint } from "./account-hint";
 import { codexPlanLabel } from "../../../../shared/codex-plan-label.ts";
 import { dailyGuardState } from "../../../../shared/codex-daily-guard.ts";
@@ -135,6 +136,11 @@ export function CodexAccountsSection() {
                     </Tooltip>
                   </div>
                   <CodexUsageRows usage={u} />
+                  {u.resetCredits && (
+                    <div className="text-[10px] text-text-subtle">
+                      <ResetCreditsChip credits={u.resetCredits} />
+                    </div>
+                  )}
                   {u.session == null && (() => {
                     const guard = dailyGuardState(u.weekly);
                     return guard ? (

package/src/web/components/settings/accounts/use-accounts-data.ts

@@ -31,7 +31,10 @@ export interface AccountsData {
 /** Utilisation across all four buckets, as a comparable string. */
 function utilisationKey(entry: AccountUsageEntry): string {
   const u = entry.usage;
-  return [u.session?.utilization, u.weekly?.utilization, u.weeklyOpus?.utilization, u.weeklySonnet?.utilization].join("|");
+  return [
+    u.session?.utilization, u.weekly?.utilization, u.weeklyOpus?.utilization, u.weeklySonnet?.utilization,
+    ...(u.weeklyScoped ?? []).map((b) => `${b.label}:${b.utilization}`),
+  ].join("|");
 }
 
 export function useAccountsData(enabled = true): AccountsData {

package/src/web/components/settings/accounts/use-codex-accounts.ts

@@ -2,7 +2,7 @@
 
 import { useCallback, useEffect, useRef, useState } from "react";
 import { api, getAuthToken } from "@/lib/api-client";
-import type { LimitBucket } from "../../../../types/chat";
+import type { LimitBucket, ResetCredits } from "../../../../types/chat";
 import type { CodexStrategy } from "./codex-rotation-dialog";
 
 export type Strategy = CodexStrategy;
@@ -25,6 +25,8 @@ export interface Usage {
   sevenDay?: number;
   session?: LimitBucket;
   weekly?: LimitBucket;
+  /** Free rate-limit resets Codex has granted the account. */
+  resetCredits?: ResetCredits;
 }
 interface DevicePending { id: string; userCode: string; verificationUrl: string }
 interface BrowserPending { id: string; authUrl: string }

package/src/web/hooks/use-chat-account-claim.ts

@@ -0,0 +1,36 @@
+import { useCallback, useEffect, useRef } from "react";
+import { pickAccountForTab, type PickedAccount } from "@/lib/api-settings";
+import { usePanelStore } from "@/stores/panel-store";
+import { patchTabMetadata } from "@/lib/patch-tab-metadata";
+
+/** One claim per tab/provider, shared by background preparation and an early send. */
+export function useChatAccountClaim(tabId: string | undefined, providerId: string, enabled: boolean) {
+  const claims = useRef(new Map<string, Promise<PickedAccount | null>>());
+  const mounted = useRef(true);
+  useEffect(() => { mounted.current = true; return () => { mounted.current = false; }; }, []);
+  const claim = useCallback((provider: string): Promise<PickedAccount | null> => {
+    if (!tabId) return Promise.resolve(null);
+    const metadata = usePanelStore.getState().getPanelForTab(tabId)?.tabs.find((t) => t.id === tabId)?.metadata;
+    if (metadata?.pickedAccountProvider === provider && typeof metadata.pickedAccountId === "string") {
+      return Promise.resolve({ id: metadata.pickedAccountId, label: typeof metadata.pickedAccountLabel === "string" ? metadata.pickedAccountLabel : null });
+    }
+    const applyClaim = (picked: PickedAccount | null) => {
+      const current = usePanelStore.getState().getPanelForTab(tabId)?.tabs.find((t) => t.id === tabId)?.metadata;
+      if (picked && mounted.current && current && !current.sessionId && (!current.pickedAccountId || current.pickedAccountProvider !== provider)
+        && (current.providerPending || current.providerId === provider)) {
+        patchTabMetadata(tabId, { pickedAccountId: picked.id, pickedAccountLabel: picked.label, pickedAccountProvider: provider });
+      }
+      return picked;
+    };
+    const existing = claims.current.get(provider);
+    if (existing) return existing.then(applyClaim);
+    const promise = pickAccountForTab(provider, AbortSignal.timeout(30_000)).then(applyClaim).catch((error) => {
+      if (claims.current.get(provider) === promise) claims.current.delete(provider);
+      throw error;
+    });
+    claims.current.set(provider, promise);
+    return promise;
+  }, [tabId]);
+  useEffect(() => { if (enabled) void claim(providerId).catch(() => {}); }, [enabled, providerId, claim]);
+  return claim;
+}

package/src/web/hooks/use-chat.ts

@@ -226,6 +226,7 @@ export function useChat(
   const replayTurnUserMsgRef = useRef<string | null>(null);
   /** When the last full-transcript fetch completed — guards redundant idle refetches */
   const historyLoadedAtRef = useRef(0);
+  const initialHistoryPendingRef = useRef(false);
   const sessionIdRef = useRef(sessionId);
   sessionIdRef.current = sessionId;
   // Held in a ref so the socket handler always calls the latest callback without
@@ -560,6 +561,18 @@ export function useChat(
           if (routeToFinalizedParent(ev as ChatEvent, pid)) { /* nested */ }
           break;
         }
+        // Background Codex agents can finish after the root answer. Update the
+        // finalized card without flushing empty streaming refs over history.
+        if (phaseRef.current === "idle" && trId?.startsWith("subagent-")) {
+          setMessages(prev => prev.map(message => {
+            if (!message.events?.some(e => e.type === "tool_use" && e.toolUseId === trId)) return message;
+            return { ...message, events: message.events.map(e =>
+              e.type === "tool_use" && e.toolUseId === trId
+                ? { ...e, result: { output: ev.output, isError: ev.isError, exitCode: ev.exitCode } }
+                : e) };
+          }));
+          break;
+        }
         upsertStreamingEvent((e) => !!trId && e.type === "tool_result" && (e as any).toolUseId === trId);
         syncMessages();
         break;
@@ -629,6 +642,11 @@ export function useChat(
       }
 
       case "error": {
+        if (ev.parentToolUseId) {
+          if (routeToParent(ev as ChatEvent, ev.parentToolUseId)) syncMessages();
+          else routeToFinalizedParent(ev as ChatEvent, ev.parentToolUseId);
+          break;
+        }
         if (!isReplayingRef.current) attemptRef.current?.fail();
         setMessages((prev) => {
           const last = prev[prev.length - 1];
@@ -724,6 +742,8 @@ export function useChat(
       }
 
       case "done": {
+        // A nested completion must never finalize or reset the root stream.
+        if (ev.parentToolUseId) break;
         if (!isReplayingRef.current) attemptRef.current?.finish(!!streamingContentRef.current.trim());
         // Idempotent: may receive duplicate done (provider + stream loop finally)
         if (phaseRef.current === "idle") break;
@@ -976,7 +996,7 @@ export function useChat(
         resyncInFlightRef.current = false;
         replayTruncatedRef.current = false;
         const historyFresh = Date.now() - historyLoadedAtRef.current < 5000;
-        if (replayWasTruncated || !(wasIdle && historyFresh)) refetchRef.current?.();
+        if (replayWasTruncated || !(wasIdle && (historyFresh || initialHistoryPendingRef.current))) refetchRef.current?.();
         setIsReconnecting(false);
       }
       // If streaming, turn_events message will follow
@@ -1173,6 +1193,7 @@ export function useChat(
     const staleIds = new Set(messagesRef.current.map((m) => m.id));
 
     if (sessionId && projectName) {
+      initialHistoryPendingRef.current = true;
       setMessagesLoading(true);
       // Via api.get, not raw fetch: the loading screen is gated on this settling,
       // and a stalled request would otherwise hold the transcript hostage until
@@ -1220,7 +1241,10 @@ export function useChat(
           }
         })
         .finally(() => {
-          if (!cancelled) setMessagesLoading(false);
+          if (!cancelled) {
+            initialHistoryPendingRef.current = false;
+            setMessagesLoading(false);
+          }
         });
     } else {
       setMessages([]);
@@ -1228,6 +1252,7 @@ export function useChat(
 
     return () => {
       cancelled = true;
+      initialHistoryPendingRef.current = false;
       historyRequestRef.current?.abort();
       historyRequestRef.current = null;
       if (syncRafRef.current) clearTimeout(syncRafRef.current);

package/src/web/hooks/use-draft.ts

@@ -24,11 +24,29 @@ interface DraftResult {
   updatedAt: string;
 }
 
-export function useDraft(projectName: string, sessionId: string | null) {
-  const [draft, setDraft] = useState<DraftState | null>(null);
+export function useDraft(projectName: string, sessionId: string | null, tabId?: string) {
+  // The server save is debounced and can fail while offline. Keep the visible
+  // composer's draft in this browser tab too, including across a recovery reload.
+  const keyForSession = useCallback((id: string | null) =>
+    `ppm-chat-draft:${JSON.stringify([projectName, tabId ?? null, id ?? "__new__"])}`, [projectName, tabId]);
+  const localKey = keyForSession(sessionId);
+  const [recoveredDraft] = useState<DraftState | null>(() => {
+    try {
+      const value = JSON.parse(sessionStorage.getItem(localKey) ?? "null");
+      if (typeof value?.content !== "string" || !Array.isArray(value.attachments)) return null;
+      return { content: value.content, attachments: value.attachments.filter(
+        (a: DraftAttachment) => typeof a?.name === "string" && typeof a?.path === "string",
+      ) };
+    } catch { return null; }
+  });
+  const recoveryRef = useRef({ projectName, sessionId, draft: recoveredDraft });
+  const localKeyRef = useRef(localKey);
+  localKeyRef.current = localKey;
+  const [draft, setDraft] = useState<DraftState | null>(recoveredDraft);
   const [loading, setLoading] = useState(true);
   const timerRef = useRef<ReturnType<typeof setTimeout>>(undefined);
   const sessionRef = useRef(sessionId);
+  const editRevision = useRef(0);
   sessionRef.current = sessionId;
 
   const effectiveId = sessionId ?? "__new__";
@@ -40,6 +58,13 @@ export function useDraft(projectName: string, sessionId: string | null) {
       return;
     }
     let cancelled = false;
+    const revision = editRevision.current;
+    // StrictMode repeats mount effects. Keep the recovered value for both
+    // runs, but never reuse it after navigating to another conversation.
+    if (recoveryRef.current.projectName !== projectName || recoveryRef.current.sessionId !== sessionId) {
+      recoveryRef.current.draft = null;
+    }
+    const keepRecoveredDraft = recoveryRef.current.draft !== null;
     setLoading(true);
     // Releasing the gate only reveals the composer; a draft arriving afterwards
     // is still applied, and MessageInput refuses to overwrite typed text.
@@ -51,7 +76,7 @@ export function useDraft(projectName: string, sessionId: string | null) {
         `${projectUrl(projectName)}/chat/drafts/${encodeURIComponent(effectiveId)}`,
       )
       .then((data) => {
-        if (cancelled) return;
+        if (cancelled || keepRecoveredDraft || editRevision.current !== revision) return;
         if (data) {
           let attachments: DraftAttachment[] = [];
           try { attachments = JSON.parse(data.attachments); } catch { /* ignore */ }
@@ -60,7 +85,7 @@ export function useDraft(projectName: string, sessionId: string | null) {
           setDraft(null);
         }
       })
-      .catch(() => { if (!cancelled) setDraft(null); })
+      .catch(() => { if (!cancelled && !keepRecoveredDraft && editRevision.current === revision) setDraft(null); })
       .finally(() => {
         clearTimeout(releaseTimer);
         if (!cancelled) setLoading(false);
@@ -71,7 +96,11 @@ export function useDraft(projectName: string, sessionId: string | null) {
   // Debounced save (1s)
   const save = useCallback(
     (content: string, attachments?: DraftAttachment[]) => {
+      ++editRevision.current;
       if (!projectName) return;
+      try {
+        sessionStorage.setItem(localKeyRef.current, JSON.stringify({ content, attachments: attachments ?? [] }));
+      } catch { /* Storage may be unavailable; the server draft still applies. */ }
       if (timerRef.current) clearTimeout(timerRef.current);
       timerRef.current = setTimeout(() => {
         const id = sessionRef.current ?? "__new__";
@@ -99,6 +128,21 @@ export function useDraft(projectName: string, sessionId: string | null) {
     timerRef.current = undefined;
   }, []);
 
+  // Only explicit create/fork transitions move the unsent draft. Picking an
+  // unrelated history session must leave its draft under the original owner.
+  const moveDraft = useCallback((nextSessionId: string) => {
+    const oldKey = localKeyRef.current;
+    const nextKey = keyForSession(nextSessionId);
+    if (oldKey === nextKey) return;
+    try {
+      const value = sessionStorage.getItem(oldKey);
+      if (value !== null) {
+        sessionStorage.setItem(nextKey, value);
+        sessionStorage.removeItem(oldKey);
+      }
+    } catch { /* Preserve the old copy if the new write fails. */ }
+  }, [keyForSession]);
+
   /**
    * Clear the draft once its message has actually been handed to the socket.
    *
@@ -109,14 +153,20 @@ export function useDraft(projectName: string, sessionId: string | null) {
    * behind and restore it into the next new tab.
    */
   const clear = useCallback((draftId?: string) => {
+    ++editRevision.current;
     if (!projectName) return;
+    recoveryRef.current.draft = null;
+    try {
+      sessionStorage.removeItem(localKeyRef.current);
+      if (draftId) sessionStorage.removeItem(keyForSession(draftId === "__new__" ? null : draftId));
+    } catch { /* Storage unavailable. */ }
     if (timerRef.current) clearTimeout(timerRef.current);
     const id = draftId ?? sessionRef.current ?? "__new__";
     api
       .del(`${projectUrl(projectName)}/chat/drafts/${encodeURIComponent(id)}`)
       .catch(() => {});
     setDraft(null);
-  }, [projectName]);
+  }, [projectName, keyForSession]);
 
   // Cleanup timer on unmount
   useEffect(() => {
@@ -125,5 +175,5 @@ export function useDraft(projectName: string, sessionId: string | null) {
     };
   }, []);
 
-  return { draft, draftLoading: loading, saveDraft: save, clearDraft: clear, cancelPendingSave };
+  return { draft, draftLoading: loading, saveDraft: save, clearDraft: clear, cancelPendingSave, moveDraft };
 }

package/src/web/hooks/use-file-index-invalidation.ts

@@ -0,0 +1,29 @@
+import { useEffect } from "react";
+import { useProjectStore } from "@/stores/project-store";
+import { useFileStore, relativeProjectPath } from "@/stores/file-store";
+import { onFsChanged } from "@/components/os-explorer/explorer-store";
+
+/** Keep on-demand indexes fresh even while the mobile file drawer is closed. */
+export function useFileIndexInvalidation(): void {
+  useEffect(() => {
+    const changed = (event: Event) => {
+      const projectName = (event as CustomEvent).detail?.projectName;
+      const store = useFileStore.getState();
+      if (projectName && projectName === store.indexProjectName) store.invalidateIndex();
+    };
+    window.addEventListener("file:changed", changed);
+    const unsubscribeFs = onFsChanged((directory) => {
+      const store = useFileStore.getState();
+      const project = useProjectStore.getState().projects.find((p) => p.name === store.indexProjectName);
+      if (project && relativeProjectPath(project.path, directory) !== null) store.invalidateIndex();
+    });
+    const unsubscribeProject = useProjectStore.subscribe((state, previous) => {
+      if (state.activeProject?.name !== previous.activeProject?.name) useFileStore.getState().reset();
+    });
+    return () => {
+      window.removeEventListener("file:changed", changed);
+      unsubscribeFs();
+      unsubscribeProject();
+    };
+  }, []);
+}

package/src/web/hooks/use-usage.ts

@@ -3,6 +3,8 @@ import { api, projectUrl } from "@/lib/api-client";
 import type { UsageInfo } from "../../types/chat";
 
 const POLL_INTERVAL = 120_000; // read cache every 2min
+type UsageSnapshot = { scope: string; usage: UsageInfo; fetchedAt: string | null };
+const usageCache = new Map<string, UsageSnapshot>();
 
 interface UseUsageReturn {
   usageInfo: UsageInfo;
@@ -26,23 +28,22 @@ interface UseUsageReturn {
  * `sessionId` scopes the reported account to this session's binding. Without it the header
  * shows whichever account ran last across every open session, which is wrong for all but one.
  */
-export function useUsage(projectName: string, providerId = "claude", sessionId?: string, pickedAccountId?: string): UseUsageReturn {
+export function useUsage(projectName: string, providerId = "claude", sessionId?: string, pickedAccountId?: string, enabled = true): UseUsageReturn {
   const previewAccountId = providerId === "codex" && !sessionId ? pickedAccountId : undefined;
-  const scope = JSON.stringify([projectName, providerId, sessionId, previewAccountId]);
-  const [snapshot, setSnapshot] = useState<{ scope: string; usage: UsageInfo; fetchedAt: string | null } | null>(null);
+  const scope = JSON.stringify([projectName, providerId, sessionId, pickedAccountId]);
+  const [snapshot, setSnapshot] = useState<UsageSnapshot | null>(null);
   const [usageLoading, setUsageLoading] = useState(false);
   const timerRef = useRef<ReturnType<typeof setInterval> | null>(null);
   const requestRef = useRef(0);
 
   const doFetch = useCallback((forceRefresh = false): Promise<void> => {
-    if (!projectName) return Promise.resolve();
+    if (!enabled || !projectName) return Promise.resolve();
     const request = ++requestRef.current;
     setUsageLoading(true);
     const qs = forceRefresh ? "&refresh=1" : "";
     const sessionQs = sessionId ? `&session=${encodeURIComponent(sessionId)}` : "";
     const accountQs = previewAccountId ? `&accountId=${encodeURIComponent(previewAccountId)}` : "";
-    // Via api.get, not raw fetch: the toolbar's loading state is gated on this
-    // settling, and a raw fetch has no timeout to stop it stalling forever.
+    // Use the API client's timeout for provider reads that can stall.
     return api
       .get<(UsageInfo & { lastFetchedAt?: string }) | null>(
         `${projectUrl(projectName)}/chat/usage?providerId=${providerId}${sessionQs}${accountQs}${qs}`,
@@ -51,25 +52,30 @@ export function useUsage(projectName: string, providerId = "claude", sessionId?:
         if (request !== requestRef.current) return;
         // Each response is a snapshot, not a patch. Missing fields must clear
         // old account labels/limits, especially when switching providers.
-        setSnapshot({ scope, usage: data ?? {}, fetchedAt: data?.lastFetchedAt ?? null });
+        const matchesAccount = !pickedAccountId || data?.activeAccountId === pickedAccountId;
+        const next = { scope, usage: matchesAccount ? data ?? {} : {}, fetchedAt: matchesAccount ? data?.lastFetchedAt ?? null : null };
+        usageCache.set(scope, next);
+        setSnapshot(next);
       })
       .catch(() => {})
       .finally(() => {
         if (request === requestRef.current) setUsageLoading(false);
       });
-  }, [projectName, providerId, sessionId, previewAccountId, scope]);
+  }, [projectName, providerId, sessionId, previewAccountId, pickedAccountId, scope, enabled]);
 
   // Read cache on mount + auto-read every POLL_INTERVAL
   useEffect(() => {
     setSnapshot(null);
     setUsageLoading(false);
-    doFetch();
+    if (!enabled) return;
+    const initialTimer = setTimeout(() => doFetch(), 500);
     timerRef.current = setInterval(() => doFetch(), POLL_INTERVAL);
     return () => {
       ++requestRef.current;
+      clearTimeout(initialTimer);
       if (timerRef.current) clearInterval(timerRef.current);
     };
-  }, [doFetch]);
+  }, [doFetch, enabled]);
 
   /** Manual refresh — asks BE for fresh usage. */
   const refreshUsage = useCallback(() => doFetch(true), [doFetch]);
@@ -77,6 +83,6 @@ export function useUsage(projectName: string, providerId = "claude", sessionId?:
   const reloadUsage = useCallback(() => doFetch(), [doFetch]);
 
   // Hide the previous scope synchronously, before the new effect runs.
-  const current = snapshot?.scope === scope ? snapshot : null;
+  const current = enabled ? snapshot?.scope === scope ? snapshot : usageCache.get(scope) : null;
   return { usageInfo: current?.usage ?? {}, usageLoading, lastFetchedAt: current?.fetchedAt ?? null, refreshUsage, reloadUsage };
 }

package/src/web/lib/api-settings.ts

@@ -1,4 +1,5 @@
 import { api } from "./api-client";
+import { clearChatPreparationCache } from "./chat-preparation-cache";
 
 export interface OAuthProfileData {
   account?: {
@@ -85,9 +86,9 @@ export interface PickedAccount {
  * Null means nothing is usable right now (Claude) or no managed account exists (Codex, which
  * then runs on the ambient ~/.codex login).
  */
-export function pickAccountForTab(providerId: string): Promise<PickedAccount | null> {
+export function pickAccountForTab(providerId: string, signal?: AbortSignal): Promise<PickedAccount | null> {
   const path = providerId === "codex" ? "/api/codex-accounts/pick" : "/api/accounts/pick";
-  return api.post<PickedAccount | null>(path);
+  return api.post<PickedAccount | null>(path, undefined, { signal });
 }
 
 export function addAccount(params: { apiKey: string; label?: string }): Promise<AccountInfo> {
@@ -121,6 +122,8 @@ export interface AccountUsageEntry {
     weekly?: import("../../types/chat").LimitBucket;
     weeklyOpus?: import("../../types/chat").LimitBucket;
     weeklySonnet?: import("../../types/chat").LimitBucket;
+    /** Per-model weekly limits ("Fable", …). */
+    weeklyScoped?: import("../../types/chat").ScopedLimitBucket[];
   };
 }
 
@@ -226,7 +229,10 @@ export function getAISettings(): Promise<AISettings> {
 }
 
 export function updateAISettings(settings: Partial<AISettings>): Promise<AISettings> {
-  return api.put<AISettings>("/api/settings/ai", settings);
+  return api.put<AISettings>("/api/settings/ai", settings).then((result) => {
+    clearChatPreparationCache();
+    return result;
+  });
 }
 
 // ── Proxy ────────────────────────────────────────────────────────────

package/src/web/lib/chat-preparation-cache.ts

@@ -0,0 +1,63 @@
+import { api, projectUrl } from "./api-client";
+import type { AISettings } from "./api-settings";
+
+export interface ChatProviderInfo { id: string; name: string }
+const TTL_MS = 60_000;
+export const CHAT_PREPARATION_TIMEOUT_MS = 30_000;
+type Entry<T> = { value?: T; expires: number; request?: Promise<T> };
+const settings = new Map<string, Entry<AISettings>>();
+const providers = new Map<string, Entry<ChatProviderInfo[]>>();
+let generation = 0;
+export function chatPreparationGeneration(): number { return generation; }
+
+function cached<T>(cache: Map<string, Entry<T>>, key: string, fetch: () => Promise<T>): Promise<T> {
+  const previous = cache.get(key);
+  if (previous?.value !== undefined && previous.expires > Date.now()) return Promise.resolve(previous.value);
+  if (previous?.request) return previous.request;
+  const entry: Entry<T> = { expires: 0 };
+  cache.set(key, entry);
+  entry.request = new Promise<T>((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error("Chat preparation timed out. Please retry.")), CHAT_PREPARATION_TIMEOUT_MS);
+    Promise.resolve().then(fetch).then(resolve, reject).finally(() => clearTimeout(timer));
+  }).then((value) => {
+    if (cache.get(key) === entry) {
+      entry.value = value;
+      entry.expires = Date.now() + TTL_MS;
+      entry.request = undefined;
+    }
+    return value;
+  }, (error) => {
+    if (cache.get(key) === entry) cache.delete(key);
+    throw error;
+  });
+  return entry.request;
+}
+
+/** Only provider selection and permissions are retained; never account credentials. */
+export function getChatPreparationSettings(projectName = ""): Promise<AISettings> {
+  return cached(settings, projectName, async () => {
+    const value = await api.get<AISettings>("/api/settings/ai", { signal: AbortSignal.timeout(CHAT_PREPARATION_TIMEOUT_MS) });
+    return {
+      default_provider: value.default_provider,
+      new_chat_provider_mode: value.new_chat_provider_mode,
+      providers: Object.fromEntries(Object.entries(value.providers).map(([id, provider]) =>
+        [id, { permission_mode: provider.permission_mode }])),
+    };
+  });
+}
+
+export function getChatProviders(projectName: string): Promise<ChatProviderInfo[]> {
+  return cached(providers, projectName, () => api.get<ChatProviderInfo[]>(`${projectUrl(projectName)}/chat/providers`,
+    { signal: AbortSignal.timeout(CHAT_PREPARATION_TIMEOUT_MS) }));
+}
+
+export function peekChatProviders(projectName: string): ChatProviderInfo[] | undefined {
+  const entry = providers.get(projectName);
+  return entry && entry.expires > Date.now() ? entry.value : undefined;
+}
+
+export function clearChatPreparationCache(): void {
+  ++generation;
+  settings.clear();
+  providers.clear();
+}

package/src/web/stores/file-store.ts

@@ -84,6 +84,7 @@ interface FileStore {
    */
   inflight: Map<string, InflightLoad>;
   indexStatus: "idle" | "loading" | "ready" | "error";
+  indexProjectName: string | null;
   selectedFiles: string[];
   inlineAction: InlineAction | null;
   clipboard: ClipboardState | null;
@@ -142,6 +143,7 @@ interface InflightLoad {
   prefetch: boolean;
 }
 
+let indexRequest = 0;
 export const useFileStore = create<FileStore>((set, get) => ({
   tree: [],
   fileIndex: [],
@@ -151,6 +153,7 @@ export const useFileStore = create<FileStore>((set, get) => ({
   loadedPaths: new Set<string>(),
   inflight: new Map<string, InflightLoad>(),
   indexStatus: "idle",
+  indexProjectName: null,
   selectedFiles: [],
   inlineAction: null,
   clipboard: null,
@@ -292,19 +295,21 @@ export const useFileStore = create<FileStore>((set, get) => ({
   },
 
   loadIndex: async (projectName: string) => {
-    set({ indexStatus: "loading" });
+    const request = ++indexRequest;
+    set({ indexStatus: "loading", indexProjectName: projectName, fileIndex: [] });
     try {
       const data = await api.get<FileEntry[]>(
         `${projectUrl(projectName)}/files/index`,
       );
-      set({ fileIndex: data, indexStatus: "ready" });
+      if (request === indexRequest) set({ fileIndex: data, indexStatus: "ready" });
     } catch {
-      set({ indexStatus: "error" });
+      if (request === indexRequest) set({ indexStatus: "error" });
     }
   },
 
   invalidateIndex: () => {
-    set({ indexStatus: "idle", fileIndex: [] });
+    ++indexRequest;
+    set({ indexStatus: "idle", fileIndex: [], indexProjectName: null });
   },
 
   invalidateFolder: async (projectName: string, folderPath: string) => {
@@ -370,6 +375,7 @@ export const useFileStore = create<FileStore>((set, get) => ({
   clearSelection: () => set({ selectedFiles: [] }),
 
   reset: () => {
+    ++indexRequest;
     cancelPrefetch();
     // Abort all in-flight requests
     for (const load of get().inflight.values()) load.controller.abort();
@@ -382,6 +388,7 @@ export const useFileStore = create<FileStore>((set, get) => ({
       loadedPaths: new Set(),
       inflight: new Map(),
       indexStatus: "idle",
+      indexProjectName: null,
       selectedFiles: [],
       inlineAction: null,
       clipboard: null,

package/src/web/theme/adapters/monaco-adapter.ts

@@ -56,9 +56,8 @@ loader.config({ paths: { vs: "/assets/monaco/vs" } });
 
 let monacoRef: typeof import("monaco-editor") | null = null;
 
-async function ensureDefined(theme: PpmTheme): Promise<string> {
+function ensureDefined(monaco: typeof import("monaco-editor"), theme: PpmTheme): string {
   const name = monacoThemeName(theme);
-  const monaco = monacoRef ?? (monacoRef = await loader.init());
   monaco.editor.defineTheme(name, {
     base: theme.mode === "dark" ? "vs-dark" : "vs",
     inherit: true,
@@ -78,18 +77,25 @@ function currentTheme(): PpmTheme {
 
 let subscribed = false;
 
+function applyCurrentTheme(): void {
+  // Theme changes on chat-only sessions must not download the editor runtime.
+  if (!monacoRef) return;
+  monacoRef.editor.setTheme(ensureDefined(monacoRef, currentTheme()));
+}
+
+/** Register the current theme before an Editor or DiffEditor creates its model. */
+export function prepareMonacoTheme(monaco: typeof import("monaco-editor")): void {
+  monacoRef = monaco;
+  initMonacoThemeSync();
+  applyCurrentTheme();
+}
+
 /**
- * Define + activate the Monaco theme for the current app theme, and keep it in
- * sync on theme changes. `monaco.editor.setTheme` applies globally to every
- * mounted editor. Idempotent.
+ * Subscribe without loading Monaco. Once an editor calls prepareMonacoTheme,
+ * theme changes apply globally to all mounted editors. Idempotent.
  */
 export function initMonacoThemeSync(): void {
   if (subscribed || typeof window === "undefined") return;
   subscribed = true;
-  const apply = async () => {
-    const name = await ensureDefined(currentTheme());
-    (monacoRef ?? (monacoRef = await loader.init())).editor.setTheme(name);
-  };
-  window.addEventListener(THEME_CHANGE_EVENT, () => void apply());
-  void apply();
+  window.addEventListener(THEME_CHANGE_EVENT, applyCurrentTheme);
 }