@hienlh/ppm 0.22.0 → 0.22.2

package/src/web/components/layout/command-palette.tsx

@@ -3,19 +3,15 @@ import {
   Terminal,
   MessageSquare,
   GitCommitHorizontal,
-  GitBranch,
   Puzzle,
   Settings,
   Database,
   Search,
-  FileCode,
   FilePlus,
   FolderOpen,
   Loader2,
   Globe,
   Mic,
-  RefreshCw,
-  Plus,
   Columns2,
   Cloud,
   AppWindow,
@@ -33,6 +29,7 @@ import { useIsTouchOnly } from "@/hooks/use-is-touch-only";
 import { useKeybindingsStore } from "@/stores/keybindings-store";
 import { useFileStore, type FileNode } from "@/stores/file-store";
 import { useExtensionStore } from "@/stores/extension-store";
+import { extensionIcon } from "@/lib/extension-icons";
 import { useCompareStore } from "@/stores/compare-store";
 import { usePanelStore } from "@/stores/panel-store";
 import { api } from "@/lib/api-client";
@@ -61,19 +58,6 @@ interface CommandItem {
 
 const isMac = typeof navigator !== "undefined" && /Mac|iPhone|iPad/.test(navigator.userAgent);
 
-/** Map extension icon string names to lucide components */
-const EXT_ICON_MAP: Record<string, React.ElementType> = {
-  "git-branch": GitBranch,
-  "database": Database,
-  "refresh": RefreshCw,
-  "plus": Plus,
-  "terminal": Terminal,
-  "settings": Settings,
-  "search": Search,
-  "file-code": FileCode,
-  "globe": Globe,
-};
-
 /** Format a keybinding combo for display (e.g. "Mod+G" → "⌘G" on Mac, "Ctrl+G" on others) */
 function formatShortcut(combo: string): string {
   if (!combo) return "";
@@ -296,7 +280,7 @@ export function CommandPalette({ open, onClose, initialQuery = "" }: { open: boo
         id: `ext:${cmd.command}`,
         label: cmd.title,
         hint: cmd.category,
-        icon: (cmd.icon && EXT_ICON_MAP[cmd.icon]) || Puzzle,
+        icon: extensionIcon(cmd.icon) ?? Puzzle,
         group: "action" as const,
         keywords: `extension ${cmd.command} ${cmd.category ?? ""}`,
         shortcut: shortcutCombo ? formatShortcut(shortcutCombo) : undefined,

package/src/web/components/layout/editor-panel.tsx

@@ -54,7 +54,7 @@ export function EditorPanel({ panelId, projectName }: EditorPanelProps) {
         panelCount > 1 && "border border-transparent",
         panelCount > 1 && isFocused && "border-primary/30",
       )}
-      onMouseDown={() => { if (usePanelStore.getState().focusedPanelId !== panelId) usePanelStore.getState().setFocusedPanel(panelId); }}
+      onMouseDown={() => { if (usePanelStore.getState().focusedPanelId !== panelId) usePanelStore.getState().setFocusedPanel(panelId, false); }}
     >
       <TabBar panelId={panelId} />
 

package/src/web/components/layout/reparenting-tab.tsx

@@ -65,9 +65,11 @@ export function ReparentingTab({
       if (pid === DOCK_PANEL_ID || isWindowPanelId(pid)) return;
       usePanelStore.getState().setFocusedPanel(pid);
     };
-    wrapper.addEventListener("mousedown", onMouseDown, true);
+    wrapper.addEventListener("pointerdown", onMouseDown, true);
+    wrapper.addEventListener("focusin", onMouseDown, true);
     return () => {
-      wrapper.removeEventListener("mousedown", onMouseDown, true);
+      wrapper.removeEventListener("pointerdown", onMouseDown, true);
+      wrapper.removeEventListener("focusin", onMouseDown, true);
       wrapper.remove();
     };
   }, [wrapper, hiddenContainer]);

package/src/web/components/layout/tab-bar.tsx

@@ -448,6 +448,7 @@ export const TabBar = memo(function TabBar({ panelId }: TabBarProps) {
                   metadata: project ? { projectName: project.name } : undefined,
                 });
               } else {
+                usePanelStore.getState().setFocusedPanel(effectivePanelId, false);
                 openCommandPalette();
               }
             }}
@@ -503,4 +504,3 @@ export const TabBar = memo(function TabBar({ panelId }: TabBarProps) {
     </>
   );
 });
-

package/src/web/components/settings/accounts/account-card.tsx

@@ -278,14 +278,14 @@ export function AccountCard({
                   </button>
                 </TooltipTrigger>
                 <TooltipContent side="top" className="max-w-64 text-xs leading-relaxed">
-                  Keeps a weekly-only Codex account on pace to last until its reset. Each day adds one seventh of the weekly quota. When usage reaches that day's cap, PPM pauses new turns until the next day.
+                  Spreads the weekly quota across five weekdays, adding 20% per weekday. Weekend slots keep the previous cap; unused allowance carries forward. Daily slots start at the reset time and use UTC weekdays.
                 </TooltipContent>
               </Tooltip>
             </div>
             <p className={`text-[10px] tabular-nums ${dailyGuard.enabled && dailyGuard.state.blocked ? "text-error" : "text-text-subtle"}`}>
               {dailyGuard.enabled && dailyGuard.state.blocked
                 ? `${Math.round(dailyGuard.state.used * 100)}% used / ${Math.round(dailyGuard.state.cap * 100)}% daily cap. New turns paused.`
-                : `Day ${dailyGuard.state.day}/7, ${Math.round(dailyGuard.state.cap * 100)}% daily cap`}
+                : `Weekday ${dailyGuard.state.day}/5, ${Math.round(dailyGuard.state.cap * 100)}% daily cap`}
             </p>
           </div>
           {onDailyGuardToggle && (

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

@@ -138,18 +138,18 @@ export function CodexAccountsSection() {
                                 </button>
                               </TooltipTrigger>
                               <TooltipContent side="top" className="max-w-64 text-xs leading-relaxed">
-                                Keeps a weekly-only Codex account on pace to last until its reset. Each day adds one seventh of the weekly quota. When usage reaches that day's cap, PPM pauses new turns until the next day. Turn it off any time to use the remaining quota freely.
+                                Spreads the weekly quota across five weekdays, adding 20% per weekday. Weekend slots keep the previous cap; unused allowance carries forward. Daily slots start at the reset time and use UTC weekdays. Turn it off any time to use the remaining quota freely.
                               </TooltipContent>
                             </Tooltip>
                           </div>
                           <p className={`text-[10px] tabular-nums ${a.dailyGuardEnabled && guard.blocked ? "text-error" : "text-text-subtle"}`}>
                             {a.dailyGuardEnabled && guard.blocked
                               ? `${Math.round(guard.used * 100)}% used / ${Math.round(guard.cap * 100)}% daily cap. New turns paused.`
-                              : `Day ${guard.day}/7, ${Math.round(guard.cap * 100)}% daily cap`}
+                              : `Weekday ${guard.day}/5, ${Math.round(guard.cap * 100)}% daily cap`}
                           </p>
                         </div>
-                        <span className="hidden" title={`Day ${guard.day}/7: hold weekly usage at or below ${Math.round(guard.cap * 100)}% to last until reset.`}>
-                          Daily guard {a.dailyGuardEnabled ? `· Day ${guard.day}/7 cap ${Math.round(guard.cap * 100)}%` : ""}
+                        <span className="hidden" title={`Weekday ${guard.day}/5: hold weekly usage at or below ${Math.round(guard.cap * 100)}% to last until reset.`}>
+                          Daily guard {a.dailyGuardEnabled ? `· Weekday ${guard.day}/5 cap ${Math.round(guard.cap * 100)}%` : ""}
                         </span>
                         <Switch
                           checked={!!a.dailyGuardEnabled}

package/src/web/components/settings/ai-settings-section.tsx

@@ -120,6 +120,42 @@ export function AISettingsSection({ compact }: { compact?: boolean } = {}) {
     <div className={gapSize}>
       <h3 className={`${headingSize} font-medium text-text-secondary`}>AI Settings</h3>
 
+      <div className={fieldGap}>
+        <Label htmlFor="ai-new-chat-provider" className={compact ? labelSize : undefined}>New chat provider</Label>
+        <Select
+          value={settings.new_chat_provider_mode ?? "default"}
+          disabled={saving}
+          onValueChange={(value) => handleSettingsSave({ new_chat_provider_mode: value as "default" | "follow-focus" })}
+        >
+          <SelectTrigger id="ai-new-chat-provider" className={`w-full ${compact ? "h-7 text-[11px]" : ""}`}><SelectValue /></SelectTrigger>
+          <SelectContent>
+            <SelectItem value="follow-focus">Follow last focused chat</SelectItem>
+            <SelectItem value="default">Always use default provider</SelectItem>
+          </SelectContent>
+        </Select>
+        <p className={`${compact ? "text-[9px]" : "text-[11px]"} text-muted-foreground`}>
+          {settings.new_chat_provider_mode === "follow-focus"
+            ? "New tabs follow the last chat you focused in this project, across panels. Existing tabs keep their provider."
+            : "New tabs always use the default provider. Existing tabs keep their provider."}
+        </p>
+      </div>
+
+      <div className={fieldGap}>
+        <Label htmlFor="ai-default-provider" className={compact ? labelSize : undefined}>Default provider</Label>
+        <Select value={settings.default_provider} disabled={saving}
+          onValueChange={(default_provider) => handleSettingsSave({ default_provider })}>
+          <SelectTrigger id="ai-default-provider" className={`w-full ${compact ? "h-7 text-[11px]" : ""}`}><SelectValue /></SelectTrigger>
+          <SelectContent>
+            {providerTabs.map((p) => <SelectItem key={p.id} value={p.id}>{p.name}</SelectItem>)}
+          </SelectContent>
+        </Select>
+        {settings.new_chat_provider_mode === "follow-focus" && (
+          <p className={`${compact ? "text-[9px]" : "text-[11px]"} text-muted-foreground`}>
+            Used when no chat has been focused in this project yet.
+          </p>
+        )}
+      </div>
+
       <div className="flex items-start justify-between gap-3 rounded-md border border-border p-3">
         <div className={fieldGap}>
           <Label htmlFor="ai-share-provider-context" className={compact ? labelSize : undefined}>

package/src/web/components/settings/extension-manager-section.tsx

@@ -1,5 +1,6 @@
 import { useState, useEffect, useCallback } from "react";
 import { Plus, Trash2, Power, PowerOff, Puzzle, FolderSymlink, Loader2 } from "@/lib/icons";
+import { extensionIcon } from "@/lib/extension-icons";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { api } from "@/lib/api-client";
@@ -165,7 +166,13 @@ export function ExtensionManagerSection() {
                 className="flex items-center gap-2 px-2.5 py-2 rounded-lg bg-muted/50 hover:bg-muted transition-colors"
               >
                 <div className="size-8 rounded-md bg-background flex items-center justify-center shrink-0">
-                  <Puzzle className="size-4 text-muted-foreground" />
+                  {/* The manifest's own icon, the same one its panels' tabs get.
+                      A list of puzzle pieces distinguishes nothing, and the
+                      field has been on the API all along. */}
+                  {(() => {
+                    const Icon = extensionIcon(ext.icon) ?? Puzzle;
+                    return <Icon className="size-4 text-muted-foreground" />;
+                  })()}
                 </div>
                 <div className="flex-1 min-w-0">
                   <p className="text-xs font-medium truncate">{ext.displayName || ext.id}</p>

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

@@ -86,11 +86,32 @@ export function useDraft(projectName: string, sessionId: string | null) {
     [projectName],
   );
 
-  // Clear draft (on send)
-  const clear = useCallback(() => {
+  /**
+   * Drop a save that is still waiting on the debounce, without touching the server.
+   *
+   * Called at Enter. The save runs against whatever session the tab is on when the
+   * timer fires — and the first send of a new tab swaps the tab onto its new session
+   * within that second, so a save left armed would write the message just sent as the
+   * new session's draft, to reappear in the composer on the next mount as if unsent.
+   */
+  const cancelPendingSave = useCallback(() => {
+    if (timerRef.current) clearTimeout(timerRef.current);
+    timerRef.current = undefined;
+  }, []);
+
+  /**
+   * Clear the draft once its message has actually been handed to the socket.
+   *
+   * `draftId` names the draft the message was composed under. The first send of a
+   * new tab creates the session and only then sends, so by the time the send
+   * happens `sessionRef` already points at the new session while the draft still
+   * lives under `__new__` — deleting by the current session id would leave it
+   * behind and restore it into the next new tab.
+   */
+  const clear = useCallback((draftId?: string) => {
     if (!projectName) return;
     if (timerRef.current) clearTimeout(timerRef.current);
-    const id = sessionRef.current ?? "__new__";
+    const id = draftId ?? sessionRef.current ?? "__new__";
     api
       .del(`${projectUrl(projectName)}/chat/drafts/${encodeURIComponent(id)}`)
       .catch(() => {});
@@ -104,5 +125,5 @@ export function useDraft(projectName: string, sessionId: string | null) {
     };
   }, []);
 
-  return { draft, draftLoading: loading, saveDraft: save, clearDraft: clear };
+  return { draft, draftLoading: loading, saveDraft: save, clearDraft: clear, cancelPendingSave };
 }

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

@@ -26,8 +26,9 @@ 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): UseUsageReturn {
-  const scope = JSON.stringify([projectName, providerId, sessionId]);
+export function useUsage(projectName: string, providerId = "claude", sessionId?: string, pickedAccountId?: string): 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 [usageLoading, setUsageLoading] = useState(false);
   const timerRef = useRef<ReturnType<typeof setInterval> | null>(null);
@@ -39,11 +40,12 @@ export function useUsage(projectName: string, providerId = "claude", sessionId?:
     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.
     return api
       .get<(UsageInfo & { lastFetchedAt?: string }) | null>(
-        `${projectUrl(projectName)}/chat/usage?providerId=${providerId}${sessionQs}${qs}`,
+        `${projectUrl(projectName)}/chat/usage?providerId=${providerId}${sessionQs}${accountQs}${qs}`,
       )
       .then((data) => {
         if (request !== requestRef.current) return;
@@ -55,7 +57,7 @@ export function useUsage(projectName: string, providerId = "claude", sessionId?:
       .finally(() => {
         if (request === requestRef.current) setUsageLoading(false);
       });
-  }, [projectName, providerId, sessionId, scope]);
+  }, [projectName, providerId, sessionId, previewAccountId, scope]);
 
   // Read cache on mount + auto-read every POLL_INTERVAL
   useEffect(() => {

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

@@ -122,11 +122,17 @@ export class ApiClient {
     }
   }
 
-  async post<T>(path: string, body?: unknown): Promise<T> {
+  /**
+   * No default timeout, unlike `get`: a POST is not idempotent, so cutting one off
+   * mid-flight can leave the server having done the work with nobody to tell. A
+   * caller that would rather fail loudly than wait passes its own `signal`.
+   */
+  async post<T>(path: string, body?: unknown, options?: { signal?: AbortSignal }): Promise<T> {
     const res = await fetch(`${this.baseUrl}${path}`, {
       method: "POST",
       headers: this.headers(),
       body: body != null ? JSON.stringify(body) : undefined,
+      signal: options?.signal,
     });
     return this.handleResponse<T>(res);
   }

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

@@ -212,6 +212,7 @@ export interface AIProviderSettings {
 
 export interface AISettings {
   default_provider: string;
+  new_chat_provider_mode?: "default" | "follow-focus";
   share_provider_context?: boolean;
   providers: Record<string, AIProviderSettings>;
 }

package/src/web/lib/extension-icons.ts

@@ -0,0 +1,70 @@
+/**
+ * The icons an extension may ask for by name, and the glyph each name draws.
+ *
+ * A manifest names an icon the way VS Code's does — `{ "command":
+ * "git-graph.view", "icon": "git-branch" }` — and without a table like this one
+ * the name is inert: every panel an extension opens falls back to the generic
+ * puzzle piece, so a strip holding the graph, a blame, a file history and a
+ * rebase shows four identical tabs.
+ *
+ * Kebab-case, the way a manifest writes it. A name with no entry here is not an
+ * error — the caller's fallback draws instead — but `tests/unit/web/
+ * extension-icons.test.ts` fails when a *bundled* extension asks for one,
+ * because that is the case where the puzzle piece is a bug rather than a
+ * default.
+ */
+import {
+  Database, FileCode, FileDiff, GitBranch, GitCommitHorizontal, Globe, History, ListOrdered, Pencil,
+  Plus, RefreshCw, Search, Settings, Terminal, Trash2, Users,
+} from "@/lib/icons";
+import type { ElementType } from "react";
+import type { ExtensionContributes } from "../../types/extension.ts";
+
+export const EXTENSION_ICONS: Record<string, ElementType> = {
+  // Named by the panels the bundled Git Graph contributes.
+  "git-branch": GitBranch,
+  "git-commit": GitCommitHorizontal,
+  // Fluent draws no compare glyph and PPM re-exports no lucide one, so a
+  // comparison of two refs wears the same icon as any other diff in the app.
+  "git-compare": FileDiff,
+  history: History,
+  users: Users,
+  "list-ordered": ListOrdered,
+  // Named by tree-view item actions.
+  refresh: RefreshCw,
+  edit: Pencil,
+  trash: Trash2,
+  plus: Plus,
+  search: Search,
+  // General-purpose names an extension is likely to reach for.
+  database: Database,
+  terminal: Terminal,
+  settings: Settings,
+  "file-code": FileCode,
+  globe: Globe,
+};
+
+/** The glyph for a manifest icon name, or undefined for one nothing draws. */
+export function extensionIcon(name: string | undefined | null): ElementType | undefined {
+  return name ? EXTENSION_ICONS[name] : undefined;
+}
+
+/**
+ * The icon of the command that opens a panel.
+ *
+ * A panel's viewType *is* its command id — `registerViewCommand` requires the
+ * two to match, because the frontend pairs them by slug — so the manifest entry
+ * that names the command already names the panel, and an extension needs no
+ * second place to declare one. The tab carries the slug (a trailing `.view`
+ * stripped), so both forms are compared.
+ */
+export function viewTypeIcon(
+  contributions: ExtensionContributes | null | undefined,
+  viewType: string | undefined,
+): ElementType | undefined {
+  if (!contributions?.commands || !viewType) return undefined;
+  const command = contributions.commands.find(
+    (c) => c.command === viewType || c.command.replace(/\.view$/, "") === viewType,
+  );
+  return extensionIcon(command?.icon);
+}

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

@@ -0,0 +1,8 @@
+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";
+}

package/src/web/lib/tab-type-icons.ts

@@ -14,6 +14,8 @@ import type { ElementType } from "react";
 import type { TabType } from "@/stores/tab-store";
 import { fileIconElement } from "@/lib/file-icons";
 import { PROVIDER_LOGOS } from "@/lib/provider-logos";
+import { viewTypeIcon } from "@/lib/extension-icons";
+import { useExtensionStore } from "@/stores/extension-store";
 
 export const TAB_TYPE_ICONS: Record<TabType, LucideIcon> = {
   terminal: Terminal,
@@ -70,5 +72,17 @@ export function getTabIcon(tab: TabIconSubject): ElementType {
     const logo = PROVIDER_LOGOS[(tab.metadata?.providerId as string | undefined) ?? "claude"];
     if (logo) return logo;
   }
+  // A panel an extension opened is labelled with the icon its manifest gave the
+  // command that opens it — read here rather than stored on the tab, so a tab
+  // that was already open when the extension declared one picks it up too.
+  // Falls back to the puzzle piece, which is the honest answer for a panel
+  // whose extension has not said what it is.
+  if (tab.type === "extension" || tab.type === "extension-webview") {
+    const contributed = viewTypeIcon(
+      useExtensionStore.getState().contributions,
+      tab.metadata?.viewType as string | undefined,
+    );
+    if (contributed) return contributed;
+  }
   return getTabTypeIcon(tab.type);
 }

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

@@ -89,6 +89,8 @@ export interface PanelStore {
   grid: string[][];
   focusedPanelId: string;
   currentProject: string | null;
+  /** Session-local focus memory, isolated by project; non-chat tabs do not clear it. */
+  lastFocusedChatProviders: Record<string, string>;
 
   /** Keep-alive: per-project grid snapshots (for hidden workspaces) */
   projectGrids: Record<string, string[][]>;
@@ -106,7 +108,7 @@ export interface PanelStore {
   reloadProject: (projectName: string) => void;
 
   // Panel focus
-  setFocusedPanel: (panelId: string) => void;
+  setFocusedPanel: (panelId: string, rememberChat?: boolean) => void;
 
   // Tab operations (operate on focused panel by default)
   openTab: (tab: Omit<Tab, "id">, panelId?: string) => string;
@@ -210,6 +212,7 @@ export const usePanelStore = create<PanelStore>()((set, get) => {
   return {
     ...defaultLayout(),
     currentProject: null,
+    lastFocusedChatProviders: {},
     projectGrids: {},
     projectFocused: {},
     dock: { visible: false, height: 30 },
@@ -459,10 +462,13 @@ export const usePanelStore = create<PanelStore>()((set, get) => {
       get().switchProject(projectName);
     },
 
-    setFocusedPanel: (panelId) => {
+    setFocusedPanel: (panelId, rememberChat = true) => {
       // Focus drives where the next tab opens, so it must stay on a real, on-grid panel.
       if (isWindowPanelId(panelId)) return;
-      if (get().panels[panelId]) set({ focusedPanelId: panelId });
+      const panel = get().panels[panelId];
+      if (!panel) return;
+      set({ focusedPanelId: panelId });
+      if (rememberChat) rememberChatProvider(panel.tabs.find((t) => t.id === panel.activeTabId));
     },
 
     openTab: (tabDef, panelId?) => {
@@ -474,6 +480,15 @@ export const usePanelStore = create<PanelStore>()((set, get) => {
       const panel = get().panels[pid];
       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,
+        } };
+      }
+
       // Terminal: compute next available index if not provided
       if (tabDef.type === "terminal" && !tabDef.metadata?.terminalIndex) {
         const allTabs = Object.values(get().panels).flatMap((p) => p.tabs);
@@ -499,6 +514,7 @@ export const usePanelStore = create<PanelStore>()((set, get) => {
         for (const p of Object.values(get().panels)) {
           const existing = p.tabs.find((t) => t.type === "chat" && t.metadata?.sessionId === sid);
           if (existing) {
+            rememberChatProvider(existing);
             set((s) => ({
               focusedPanelId: focusAfterActivate(p.id),
               panels: {
@@ -664,6 +680,7 @@ export const usePanelStore = create<PanelStore>()((set, get) => {
     setActiveTab: (tabId, panelId?) => {
       const panel = panelId ? get().panels[panelId] : findPanel(tabId);
       if (!panel) return;
+      rememberChatProvider(panel.tabs.find((t) => t.id === tabId));
       const pid = panel.id;
       set((s) => {
         const p = s.panels[pid]!;
@@ -862,3 +879,29 @@ export const usePanelStore = create<PanelStore>()((set, get) => {
     isMobile: () => typeof window !== "undefined" && window.innerWidth < 768,
   };
 });
+
+// Observe activation as well as a provider change in the focused composer. Updates
+// from background chats must never replace the user's most recent focus choice.
+function rememberChatProvider(tab: Tab | undefined) {
+  const state = usePanelStore.getState();
+  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 (!project || state.lastFocusedChatProviders[project] === provider) return;
+  usePanelStore.setState({ lastFocusedChatProviders: {
+    ...state.lastFocusedChatProviders, [project]: provider,
+  } });
+}
+
+usePanelStore.subscribe((state, previous) => {
+  const panel = state.panels[state.focusedPanelId];
+  const tab = panel?.tabs.find((t) => t.id === panel.activeTabId);
+  // A panel's chrome can change the destination for new tabs without focusing
+  // its chat. Actual body/tab focus is recorded explicitly by the actions above.
+  const oldPanel = previous.panels[state.focusedPanelId];
+  const oldTab = oldPanel?.tabs.find((t) => t.id === oldPanel.activeTabId);
+  if (tab?.id === oldTab?.id
+    && tab?.metadata?.providerId === oldTab?.metadata?.providerId
+    && state.currentProject === previous.currentProject) return;
+  rememberChatProvider(tab);
+});