@hienlh/ppm 0.23.7 → 0.23.8

package/src/web/lib/new-chat-prepare-client.ts

@@ -0,0 +1,167 @@
+/**
+ * Client for `POST /chat/prepare` — the single request a sessionless chat tab fires on
+ * mount. One in-flight (or recently settled) promise per tab id; everything the response
+ * carries is fanned out into the caches each part would otherwise have fetched
+ * separately (settings, provider list, slash items, tags, usage, the account claim), so
+ * none of those fire their own network call while this one covers them.
+ *
+ * The promise is kept for a while after it settles rather than deleted the instant it
+ * resolves — a consumer that mounts a beat later (useUsage's deferred timer, a slash
+ * picker opened right after) still joins the same answer instead of starting a
+ * redundant request.
+ *
+ * Two facts outlive that join window, because they must not be re-learned by asking the
+ * server again: that the tab's current sessionless stretch is already prepared (so a
+ * remount does not POST — and consume an account pick — a second time), and that its
+ * pick came back with no usable account (so the claim hook does not POST `/pick` to be
+ * told the same thing). Both are dropped by `forgetPrepare` once the tab has a session.
+ */
+import { api, projectUrl } from "./api-client";
+import { CHAT_PREPARATION_TIMEOUT_MS, seedChatProviders, type ChatProviderInfo } from "./chat-preparation-cache";
+import { writeChatPreparationSettings, writeChatProviders } from "./chat-preference-local-cache";
+import { projectCacheId, type ProjectCacheRef } from "./browser-cache/cache-keys";
+import { seedSlashItems, registerPendingSlash, type SlashItemsPayload } from "./slash-items-cache";
+import { useSessionListStore, type SessionTagsState } from "@/stores/session-list-store";
+import { seedUsage, usageScopeKey } from "@/hooks/use-usage";
+import { applyAccountClaim } from "@/hooks/use-chat-account-claim";
+import type { ChatPreparationSettings } from "../../shared/chat-preparation-settings";
+import type { UsageInfo } from "../../types/chat";
+
+export interface PickedAccount { id: string; label: string | null }
+export type PrepareDraft = { content: string; attachments: string; updatedAt: string } | null;
+
+export interface PreparedChat {
+  resolvedProviderId: string;
+  providerId: string;
+  settings: ChatPreparationSettings;
+  providers: ChatProviderInfo[];
+  pickedAccount: PickedAccount | null | "timeout" | "skipped";
+  usage: (UsageInfo & { lastFetchedAt?: string }) | null;
+  draft: PrepareDraft;
+  tags: SessionTagsState | null;
+  slash: SlashItemsPayload | null;
+}
+
+export interface PrepareRequestBody {
+  providerId?: string;
+  focusedProvider?: string;
+  skipPick?: boolean;
+}
+
+/** Sends the prepare request. Replaceable in tests, which otherwise depend on whichever
+ * `api-client` module another test file in the same process left mocked. */
+export type PrepareTransport = (path: string, body: PrepareRequestBody, signal: AbortSignal) => Promise<PreparedChat>;
+const defaultTransport: PrepareTransport = (path, body, signal) => api.post<PreparedChat>(path, body, { signal });
+let transport: PrepareTransport = defaultTransport;
+
+const inFlight = new Map<string, Promise<PreparedChat>>();
+/** Tabs whose current sessionless stretch already has a successful prepare. */
+const prepared = new Set<string>();
+/** Tab id → the provider for which prepare's pick found no usable account. */
+const pickedNoAccount = new Map<string, string>();
+
+/** Idempotent per tab id — a second call before the first settles (or within its
+ * post-settle join window) returns the same promise instead of firing a new POST. */
+export function startPrepare(tabId: string, project: ProjectCacheRef, body: PrepareRequestBody): Promise<PreparedChat> {
+  const existing = inFlight.get(tabId);
+  if (existing) return existing;
+  const promise = transport(`${projectUrl(project.name)}/chat/prepare`, body, AbortSignal.timeout(CHAT_PREPARATION_TIMEOUT_MS))
+    .then((result) => {
+      // A tab that got its session (or was forgotten) while this was in flight has
+      // moved on: its caches may still be seeded, but its claim and flags must not be.
+      if (inFlight.get(tabId) === promise) {
+        prepared.add(tabId);
+        applyPrepared(tabId, project, result);
+      } else {
+        applyShared(project, result);
+      }
+      return result;
+    });
+  inFlight.set(tabId, promise);
+  // Only worth registering when the provider is already known — a still-pending tab's
+  // composer will not call fetchSlashItems until the gate resolves it, by which point
+  // this same promise has already seeded the cache directly (see applyPrepared).
+  if (body.providerId) {
+    registerPendingSlash(project.name, body.providerId, promise.then((result) => result.slash, () => null));
+  }
+  // Both branches handled: a failed prepare is reported to whoever awaits `promise`,
+  // and this bookkeeping chain must not surface it a second time as unhandled.
+  const expire = () => {
+    setTimeout(() => { if (inFlight.get(tabId) === promise) inFlight.delete(tabId); }, CHAT_PREPARATION_TIMEOUT_MS);
+  };
+  promise.then(expire, expire);
+  return promise;
+}
+
+/** The tab's in-flight (or recently settled) prepare, or undefined when none was started. */
+export function getPrepare(tabId: string | undefined): Promise<PreparedChat> | undefined {
+  return tabId ? inFlight.get(tabId) : undefined;
+}
+
+/** Whether this tab's current sessionless stretch was already prepared successfully —
+ * true even after the join window, so a remount does not prepare (and pick) again. */
+export function isPrepared(tabId: string): boolean {
+  return prepared.has(tabId);
+}
+
+/** True when this tab's prepare already asked for an account on `provider` and was told
+ * none is usable. That answer is final for the tab: asking `/pick` again would either get
+ * the same null or, worse, advance another provider's round-robin. */
+export function prepareFoundNoAccount(tabId: string, provider: string): boolean {
+  return pickedNoAccount.get(tabId) === provider;
+}
+
+/**
+ * Drops everything kept for a tab once it has a session. From then on nothing may join
+ * the old answer: a design tab's `/clear` remounts under the same tab id, and joining
+ * would restore the `__new__` draft that was just sent and reapply stale settings.
+ */
+export function forgetPrepare(tabId: string): void {
+  inFlight.delete(tabId);
+  prepared.delete(tabId);
+  pickedNoAccount.delete(tabId);
+}
+
+/** Test-only escape hatch: tab ids are reused across `it()` blocks that share a
+ * fixture, and this module's dedupe is keyed on them for real minutes at a time in
+ * production. Production code never calls this. */
+export function __clearPrepareForTest(): void {
+  inFlight.clear();
+  prepared.clear();
+  pickedNoAccount.clear();
+}
+
+/** Test-only: what the join window's own timer does after 30 s, without the wait. */
+export function __expirePrepareJoinForTest(tabId: string): void {
+  inFlight.delete(tabId);
+}
+
+/** Test-only: route the request through `fn` (or back to the real API with null). */
+export function __setPrepareTransportForTest(fn: PrepareTransport | null): void {
+  transport = fn ?? defaultTransport;
+}
+
+/** The caches keyed by project or provider — true for any tab of that project. */
+function applyShared(project: ProjectCacheRef, result: PreparedChat): void {
+  writeChatPreparationSettings(result.settings);
+  writeChatProviders(projectCacheId(project), result.providers);
+  seedChatProviders(project.name, result.providers);
+  if (result.tags) useSessionListStore.getState().seedTags(project, result.tags);
+  if (result.slash) seedSlashItems(project, result.providerId, result.slash);
+}
+
+function applyPrepared(tabId: string, project: ProjectCacheRef, result: PreparedChat): void {
+  applyShared(project, result);
+
+  // "timeout"/"skipped" carry no account to apply; only "timeout" leaves the claim hook
+  // to pick again. A real pick is written into the tab's metadata, and an explicit null
+  // (nothing usable, or a provider without managed accounts) is remembered as final.
+  if (result.pickedAccount === null) pickedNoAccount.set(tabId, result.providerId);
+  const claimed = result.pickedAccount && result.pickedAccount !== "timeout" && result.pickedAccount !== "skipped"
+    ? result.pickedAccount : null;
+  applyAccountClaim(tabId, result.providerId, claimed);
+
+  if (result.usage) {
+    seedUsage(usageScopeKey(project.name, result.providerId, undefined, claimed?.id), result.usage, result.usage.lastFetchedAt ?? null, claimed?.id);
+  }
+}

package/src/web/lib/new-chat-provider.ts

@@ -1,8 +1,3 @@
-import type { AISettings } from "./api-settings";
-
-/** The source is captured when the tab opens, before another panel can gain focus. */
-export function resolveNewChatProvider(settings: AISettings, focusedProvider?: string): string {
-  return settings.new_chat_provider_mode === "follow-focus" && focusedProvider
-    ? focusedProvider
-    : settings.default_provider || "claude";
-}
+// Moved to src/shared so the server's /chat/prepare endpoint can resolve a provider with the
+// exact same logic. Re-exported here so existing importers keep working unchanged.
+export { resolveNewChatProvider } from "../../shared/new-chat-provider.ts";

package/src/web/lib/session-list-merge.ts

@@ -0,0 +1,88 @@
+/**
+ * Pure list operations for the shared session store — sorting, pin
+ * injection, dedupe, id replacement and the bulk-delete cutoff — kept out of
+ * the zustand module so they can be unit tested without importing a store
+ * that reads localStorage at module scope (which throws under bun:test).
+ */
+import { compareSessionsByActivity, type SessionInfo } from "../../types/chat";
+
+export function sortSessions(sessions: SessionInfo[]): SessionInfo[] {
+  return [...sessions].sort(compareSessionsByActivity);
+}
+
+/** Drops every id after its first occurrence, keeping list order otherwise. */
+export function dedupeById(sessions: SessionInfo[]): SessionInfo[] {
+  const seen = new Set<string>();
+  const out: SessionInfo[] = [];
+  for (const s of sessions) {
+    if (seen.has(s.id)) continue;
+    seen.add(s.id);
+    out.push(s);
+  }
+  return out;
+}
+
+/** Insert or replace a session by id, then resort — used for both a locally
+ * created/forked session and one a background sync fetched. */
+export function upsertSession(sessions: SessionInfo[], session: SessionInfo): SessionInfo[] {
+  const idx = sessions.findIndex((s) => s.id === session.id);
+  const next = idx === -1
+    ? [...sessions, session]
+    : sessions.map((s, i) => (i === idx ? { ...s, ...session } : s));
+  return sortSessions(next);
+}
+
+export function removeSession(sessions: SessionInfo[], id: string): SessionInfo[] {
+  return sessions.filter((s) => s.id !== id);
+}
+
+export function renameSession(sessions: SessionInfo[], id: string, title: string): SessionInfo[] {
+  return sessions.map((s) => (s.id === id ? { ...s, title } : s));
+}
+
+/** The provider adopted its own id for a session PPM minted — swap it in place
+ * so history rows and every open tab keep pointing at the same row. If the
+ * new id is somehow already present (a rare migrate-twice race), the stale
+ * row under the old id is dropped rather than showing the same chat twice. */
+export function replaceSessionId(sessions: SessionInfo[], oldId: string, newId: string): SessionInfo[] {
+  if (oldId === newId) return sessions;
+  const hasNew = sessions.some((s) => s.id === newId);
+  const base = hasNew ? sessions.filter((s) => s.id !== oldId) : sessions;
+  return base.map((s) => (s.id === oldId ? { ...s, id: newId } : s));
+}
+
+export function setPinned(sessions: SessionInfo[], id: string, pinned: boolean): SessionInfo[] {
+  return sortSessions(sessions.map((s) => (s.id === id ? { ...s, pinned } : s)));
+}
+
+export function setSessionTag(
+  sessions: SessionInfo[],
+  id: string,
+  tag: { id: number; name: string; color: string } | null,
+): SessionInfo[] {
+  return sessions.map((s) => (s.id === id ? { ...s, tag } : s));
+}
+
+/** A deleted tag stops applying to any cached row that carried it — the
+ * server already cleared it, so cached rows must not keep showing a chip for
+ * a tag that no longer exists. */
+export function clearDeletedTag(sessions: SessionInfo[], tagId: number): SessionInfo[] {
+  return sessions.map((s) => (s.tag?.id === tagId ? { ...s, tag: null } : s));
+}
+
+function sessionActivityTime(session: SessionInfo): number {
+  const updated = session.updatedAt ? Date.parse(session.updatedAt) : NaN;
+  if (Number.isFinite(updated)) return updated;
+  const created = Date.parse(session.createdAt);
+  return Number.isFinite(created) ? created : 0;
+}
+
+/** An approximation of the server's bulk delete, applied to the cached rows until the
+ * re-sync that follows it lands: pinned rows survive, everything else is dropped once its
+ * last activity is older than `days`. The server's rule is narrower — it goes by
+ * `createdAt`, lists only the default provider's sessions and keeps any session that has
+ * forks — so this can briefly hide a row the server kept; the re-sync brings it back. */
+export function removeOlderThan(sessions: SessionInfo[], days: number, now: number = Date.now()): SessionInfo[] {
+  const cutoff = now - days * 24 * 60 * 60 * 1000;
+  return sessions.filter((s) => s.pinned || sessionActivityTime(s) >= cutoff);
+}

package/src/web/lib/slash-items-cache.ts

@@ -1,67 +1,131 @@
-import { api, projectUrl } from "@/lib/api-client";
+import { api, projectUrl } from "./api-client";
 import type { SlashItem } from "@/components/chat/slash-command-picker";
+import { idbGetEntry, idbSet } from "./browser-cache/idb-keyval-cache";
+import { readChatPreparationSettings } from "./chat-preference-local-cache";
+import { projectCacheId, slash as slashKey, type ProjectCacheRef } from "./browser-cache/cache-keys";
+import { registerProjectHydrator } from "./browser-cache/project-cache-hydration";
+import { registerCacheReset } from "./browser-cache/wipe-browser-caches";
 
-export interface SlashItemsPayload {
-  items: SlashItem[];
-  recentNames: string[];
+export interface SlashItemsPayload { items: SlashItem[]; recentNames: string[] }
+export const SLASH_ITEMS_TTL_MS = 30 * 60_000;
+type Entry = { data?: SlashItemsPayload; promise?: Promise<SlashItemsPayload>; expiresAt: number };
+const projects = new Map<string, Entry>();
+const providers = new Map<string, SlashItemsPayload>();
+const listeners = new Set<() => void>();
+const keyFor = (project: string, provider = "claude") => JSON.stringify([project, provider]);
+
+/** Provider-wide skills are immediately usable; project overrides stay local. */
+export function getCachedSlashItems(project: string, provider = "claude"): SlashItemsPayload | undefined {
+  return projects.get(keyFor(project, provider))?.data ?? providers.get(provider);
+}
+export function subscribeSlashItems(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => { listeners.delete(listener); };
+}
+
+function fetchFromServer(project: string, provider: string, sessionId?: string): Promise<SlashItemsPayload> {
+  const query = new URLSearchParams({ providerId: provider });
+  if (sessionId) query.set("sessionId", sessionId);
+  return api.get<SlashItemsPayload>(`${projectUrl(project)}/chat/slash-items?${query}`)
+    .then((data) => ({ items: data.items ?? [], recentNames: data.recentNames ?? [] }));
+}
+
+/** Owns `entry.promise` for `key` until `request` settles — shared by a plain network
+ * fetch and a prepare-registered join so both update the provider-wide entry and
+ * notify listeners the same way once they land. */
+function settle(key: string, entry: Entry, provider: string, request: Promise<SlashItemsPayload>): Promise<SlashItemsPayload> {
+  const promise = request.then((payload) => {
+    if (projects.get(key) === entry) {
+      entry.data = payload;
+      entry.expiresAt = Date.now() + SLASH_ITEMS_TTL_MS;
+      providers.set(provider, { items: payload.items.filter((item) => item.scope !== "project"), recentNames: [] });
+      listeners.forEach((listener) => listener());
+    }
+    return payload;
+  }).finally(() => { if (entry.promise === promise) entry.promise = undefined; });
+  entry.promise = promise;
+  return promise;
+}
+
+export function fetchSlashItems(project: string, provider = "claude", sessionId?: string): Promise<SlashItemsPayload> {
+  const key = keyFor(project, provider);
+  const entry = projects.get(key);
+  if (entry?.promise) return entry.promise;
+  if (entry?.data && Date.now() < entry.expiresAt) return Promise.resolve(entry.data);
+  const owner = entry ?? { expiresAt: 0 };
+  if (!entry) projects.set(key, owner);
+  return settle(key, owner, provider, fetchFromServer(project, provider, sessionId));
 }
 
 /**
- * Per-project cache for the slash-command / skill list.
- *
- * The list is identical for every chat tab in a project but was fetched once per
- * `MessageInput` mount — 23 KB per newly opened tab. The slash picker renders
- * `null` until the list resolves, so that fetch sat directly in front of the
- * first `/` the user typed in every new tab.
+ * Joins a `/chat/prepare` request already in flight for this (project, provider), so the
+ * composer's own mount-time `fetchSlashItems` reuses its slash part instead of firing a
+ * second GET. Falls back to the real request when prepare's slash part came back null
+ * (its own budget ran out server-side).
  *
- * Caches the in-flight promise (not just the result) so simultaneous mounts share
- * one request. Session-scoped: a reload starts empty.
- *
- * Keyed by project AND session, because the list is no longer identical across a
- * project's tabs: a provider that owns its skill runtime answers for itself, so a
- * codex tab and a Claude tab in one project get different lists — and two codex
- * tabs can differ too when they are bound to different accounts.
+ * Only useful for the same key a concurrent `fetchSlashItems` will actually be called
+ * with — a caller that does not yet know the resolved provider has nothing to register.
  */
-const CACHE_TTL_MS = 60_000;
-const cache = new Map<string, { promise: Promise<SlashItemsPayload>; expiresAt: number }>();
-
-export function fetchSlashItems(
-  projectName: string,
-  providerId?: string,
-  sessionId?: string,
-): Promise<SlashItemsPayload> {
-  const key = `${projectName}\0${providerId ?? ""}\0${sessionId ?? ""}`;
-  const cached = cache.get(key);
-  if (cached && Date.now() < cached.expiresAt) return cached.promise;
-
-  const query = new URLSearchParams();
-  if (providerId) query.set("providerId", providerId);
-  if (sessionId) query.set("sessionId", sessionId);
-  const qs = query.size > 0 ? `?${query}` : "";
+export function registerPendingSlash(project: string, provider: string, promise: Promise<SlashItemsPayload | null>): void {
+  const key = keyFor(project, provider);
+  const existing = projects.get(key);
+  if (existing?.promise || (existing?.data && Date.now() < existing.expiresAt)) return;
+  const owner = existing ?? { expiresAt: 0 };
+  if (!existing) projects.set(key, owner);
+  settle(key, owner, provider, promise.then((payload) => payload ?? fetchFromServer(project, provider)));
+}
 
-  const p = api
-    .get<SlashItemsPayload>(`${projectUrl(projectName)}/chat/slash-items${qs}`)
-    .then((data) => ({ items: data.items ?? [], recentNames: data.recentNames ?? [] }))
-    .catch((e) => {
-      // Don't cache failures — the next mount should retry.
-      if (cache.get(key)?.promise === p) cache.delete(key);
-      throw e;
-    });
+/** Seeds a provider's slash list straight from a `/chat/prepare` response — no GET. */
+export function seedSlashItems(project: ProjectCacheRef, provider: string, payload: SlashItemsPayload): void {
+  const key = keyFor(project.name, provider);
+  projects.set(key, { data: payload, expiresAt: Date.now() + SLASH_ITEMS_TTL_MS });
+  providers.set(provider, { items: payload.items.filter((item) => item.scope !== "project"), recentNames: [] });
+  listeners.forEach((listener) => listener());
+  void idbSet(slashKey(projectCacheId(project), provider), payload);
+}
 
-  cache.set(key, { promise: p, expiresAt: Date.now() + CACHE_TTL_MS });
-  return p;
+export function clearSlashItemsCache(project?: string): void {
+  if (!project) { projects.clear(); providers.clear(); return; }
+  for (const [key, entry] of projects) projects.set(key, { data: entry.data, expiresAt: 0 });
 }
 
 /**
- * Drop cached lists so the next mount refetches. Called when the user hits the
- * refresh button in the picker, which also invalidates the server-side cache.
+ * Fills a (project, provider) entry from IndexedDB — stale-while-revalidate.
+ *
+ * The list is shown as soon as it lands, but it keeps the age it was stored with
+ * (`expiresAt = at + TTL`), so a list written days ago is already expired: the next
+ * `fetchSlashItems` or `registerPendingSlash` still refreshes it instead of trusting
+ * it for another half hour. An entry that already has a request in flight but no data
+ * yet — the normal order on a project switch, where the tabs mount (and register their
+ * prepare) right after hydration starts — still gets the data to show meanwhile; only
+ * an entry that already holds data is left alone.
  */
-export function clearSlashItemsCache(projectName?: string): void {
-  if (!projectName) { cache.clear(); return; }
-  // One project now holds several keys (one per provider/session), so a targeted
-  // refresh has to drop every entry belonging to it, not just an exact match.
-  const prefix = `${projectName}\0`;
-  for (const key of cache.keys()) {
-    if (key.startsWith(prefix)) cache.delete(key);
+async function hydrateSlashEntry(project: ProjectCacheRef, provider: string): Promise<void> {
+  const cached = await idbGetEntry<SlashItemsPayload>(slashKey(projectCacheId(project), provider));
+  if (!cached || !Array.isArray(cached.data?.items)) return;
+  const key = keyFor(project.name, provider);
+  const entry = projects.get(key);
+  if (entry?.data) return; // a network answer (or a seed) already landed first
+  const expiresAt = cached.at + SLASH_ITEMS_TTL_MS;
+  if (entry) {
+    entry.data = cached.data;
+    entry.expiresAt = expiresAt;
+  } else {
+    projects.set(key, { data: cached.data, expiresAt });
   }
+  listeners.forEach((listener) => listener());
 }
+
+// Warms the list on project switch, ahead of any tab mounting, for the providers a
+// new tab is most likely to open on: "claude" and whatever the cached settings name as
+// the default. A tab on any other provider hydrates the ordinary way, through its own
+// `fetchSlashItems` call.
+registerProjectHydrator(async (project) => {
+  const likely = new Set(["claude", readChatPreparationSettings()?.default_provider ?? "claude"]);
+  await Promise.all([...likely].map((provider) => hydrateSlashEntry(project, provider)));
+});
+
+registerCacheReset(() => {
+  projects.clear();
+  providers.clear();
+});

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

@@ -29,6 +29,12 @@ import {
 import { saveWindowPanels } from "./window-panel-persistence";
 import { useWindowStore } from "@/components/floating-window/window-store";
 import { tabSessionId } from "@/lib/tab-session-id";
+import { hydrateProjectCache } from "@/lib/browser-cache/project-cache-hydration";
+import { projectCacheId } from "@/lib/browser-cache/cache-keys";
+import { readChatPreparationSettings, readChatProviders } from "@/lib/chat-preference-local-cache";
+import { resolveNewChatProvider } from "@/lib/new-chat-provider";
+import { useProjectStore } from "./project-store";
+import { projectRefForName } from "./session-list-sync-triggers";
 import {
   makeToggleDock,
   makeSetDockVisible,
@@ -65,6 +71,41 @@ function pickDockActiveTab(dockPanel: Panel | undefined, projectName: string): s
   return projTabs[projTabs.length - 1]!.id;
 }
 
+/**
+ * A new sessionless chat tab's metadata, resolved synchronously from the local cache —
+ * "warm" — so the first painted frame already has a provider and permission. When the
+ * cache cannot answer (no settings cached yet, or the resolved provider is not in the
+ * cached list), the pending placeholder is kept and `ChatTab` resolves it over the
+ * network instead.
+ */
+function resolveChatOpenMetadata(project: string | undefined, focusedProvider: string | undefined): Record<string, unknown> {
+  const settings = readChatPreparationSettings();
+  const cachedProviders = project ? readChatProviders(projectCacheId(projectRefForName(project))) : null;
+  const resolvedProviderId = settings ? resolveNewChatProvider(settings, focusedProvider) : null;
+  if (settings && resolvedProviderId && cachedProviders?.some((p) => p.id === resolvedProviderId)) {
+    return {
+      providerId: resolvedProviderId,
+      permissionMode: settings.providers[resolvedProviderId]?.permission_mode ?? "bypassPermissions",
+      // A cached default, which the tab's fresh prepare may still replace — unlike a mode
+      // the user picks or a session ran with (see `permissionReplaceable` in chat-tab.tsx).
+      permissionModeSource: "cache",
+    };
+  }
+  return { providerPending: true, focusedProviderOnOpen: focusedProvider };
+}
+
+/**
+ * The permission for a sessionless chat tab opened on a known provider (`/clear`, a
+ * provider-specific "new chat"), so its chip is not blank until prepare answers. Only
+ * fills in a mode the caller left empty or marked as a cached placeholder; a mode the
+ * caller decided is kept as given.
+ */
+function resolveChatOpenPermission(metadata: Record<string, unknown>, providerId: string): Record<string, unknown> {
+  if (metadata.permissionMode && metadata.permissionModeSource !== "cache") return {};
+  const cached = readChatPreparationSettings()?.providers[providerId]?.permission_mode;
+  return cached ? { permissionMode: cached, permissionModeSource: "cache" } : {};
+}
+
 function pushHistory(history: string[], id: string): string[] {
   const filtered = history.filter((h) => h !== id);
   filtered.push(id);
@@ -232,6 +273,15 @@ export const usePanelStore = create<PanelStore>()((set, get) => {
     redockFromWindow: makeRedockFromWindow(set, get),
 
     switchProject: (projectName) => {
+      // Every switch path lands here, so this is the one place that must start
+      // warming the new project's cache — mounting the tabs that read it comes
+      // right after. `__global__` is a virtual workspace with no server-side
+      // project (and no path), so there is nothing to hydrate for it.
+      if (projectName !== "__global__") {
+        const project = useProjectStore.getState().projects.find((p) => p.name === projectName);
+        if (project) void hydrateProjectCache(project);
+      }
+
       // Window panels are global, not part of any project's layout blob, so they are
       // merged into the flat map once — before the first project reads it.
       hydrateWindowPanels(set, get);
@@ -482,12 +532,11 @@ export const usePanelStore = create<PanelStore>()((set, get) => {
       if (!panel) return "";
 
       if (tabDef.type === "chat" && !tabDef.metadata?.sessionId && !tabDef.metadata?.providerId) {
-        const project = tabDef.projectId ?? (tabDef.metadata?.projectName as string | undefined) ?? get().currentProject;
-        tabDef = { ...tabDef, metadata: {
-          ...tabDef.metadata,
-          providerPending: true,
-          focusedProviderOnOpen: project ? get().lastFocusedChatProviders[project] : undefined,
-        } };
+        const project = tabDef.projectId ?? (tabDef.metadata?.projectName as string | undefined) ?? get().currentProject ?? undefined;
+        const focusedProvider = project ? get().lastFocusedChatProviders[project] : undefined;
+        tabDef = { ...tabDef, metadata: { ...tabDef.metadata, ...resolveChatOpenMetadata(project, focusedProvider) } };
+      } else if (tabDef.type === "chat" && tabDef.metadata && !tabDef.metadata.sessionId && typeof tabDef.metadata.providerId === "string") {
+        tabDef = { ...tabDef, metadata: { ...tabDef.metadata, ...resolveChatOpenPermission(tabDef.metadata, tabDef.metadata.providerId) } };
       }
 
       // Terminal: compute next available index if not provided
@@ -915,6 +964,7 @@ function rememberChatProvider(tab: Tab | undefined) {
   if (tab?.type !== "chat" || tab.metadata?.providerPending) return;
   const project = tab.projectId ?? (tab.metadata?.projectName as string | undefined) ?? state.currentProject;
   const provider = (tab.metadata?.providerId as string | undefined) ?? "claude";
+  if (provider === "default") return; // Unresolved tab placeholder, not a provider.
   if (!project || state.lastFocusedChatProviders[project] === provider) return;
   usePanelStore.setState({ lastFocusedChatProviders: {
     ...state.lastFocusedChatProviders, [project]: provider,

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

@@ -2,6 +2,9 @@ import { create } from "zustand";
 import { api, getAuthToken } from "@/lib/api-client";
 import { resizeImageToWebp } from "@/lib/resize-image";
 import { useProjectFrameworkStore } from "@/stores/project-framework-store";
+import { idbDeletePrefix } from "@/lib/browser-cache/idb-keyval-cache";
+import { projectCacheId, providers as providersKey, type ProjectCacheRef } from "@/lib/browser-cache/cache-keys";
+import { forgetProjectHydration } from "@/lib/browser-cache/project-cache-hydration";
 
 export interface Project {
   name: string;
@@ -75,8 +78,15 @@ export type SortMode = "recent" | "priority" | "name";
 const SORT_KEY = "ppm-project-sort";
 
 function loadSortModeLS(): SortMode {
-  const v = localStorage.getItem(SORT_KEY);
-  return v === "recent" || v === "name" ? v : "priority";
+  // Runs at module load (it seeds the store's initial state below), so a
+  // storage-less environment — a test with no DOM, private browsing with
+  // storage disabled — must fall through to the default rather than throw.
+  try {
+    const v = localStorage.getItem(SORT_KEY);
+    return v === "recent" || v === "name" ? v : "priority";
+  } catch {
+    return "priority";
+  }
 }
 
 /** Sort projects by recent usage (most recent first) */
@@ -105,6 +115,24 @@ function saveCustomOrder(order: string[]) {
   } catch { /* ignore */ }
 }
 
+/**
+ * Evicts a project's browser cache — its IndexedDB entries (slash, sessions,
+ * tags, all sharing the `projectCacheId` prefix), its localStorage provider
+ * list, and its hydration dedupe entry. A rename or a delete leaves the old
+ * `name + path` combination behind for good, so nothing will ever address
+ * this id again; there is nothing left to keep it around for.
+ */
+async function evictProjectCache(project: ProjectCacheRef): Promise<void> {
+  const id = projectCacheId(project);
+  await idbDeletePrefix(`${id}:`);
+  try {
+    localStorage.removeItem(providersKey(id));
+  } catch {
+    // ignore
+  }
+  forgetProjectHydration(id);
+}
+
 /** Resolve display order: custom order if set, else preserve server order */
 export function resolveOrder(projects: ProjectInfo[], customOrder: string[] | null): ProjectInfo[] {
   if (!customOrder) return [...projects];
@@ -273,13 +301,17 @@ export const useProjectStore = create<ProjectStore>((set, get) => ({
   },
 
   renameProject: async (name, newName) => {
+    const before = get().projects.find((p) => p.name === name);
     await api.patch(`/api/projects/${encodeURIComponent(name)}`, { name: newName });
+    if (before) void evictProjectCache(before);
     // Refetch to get updated list
     await get().fetchProjects();
   },
 
   deleteProject: async (name) => {
+    const before = get().projects.find((p) => p.name === name);
     await api.del(`/api/projects/${encodeURIComponent(name)}`);
+    if (before) void evictProjectCache(before);
     set((s) => {
       const projects = s.projects.filter((p) => p.name !== name);
       const customOrder = s.customOrder ? s.customOrder.filter((n) => n !== name) : null;