diff --git a/packages/desktop/package.json b/packages/desktop/package.json
index 1c0fa57d..a908ac31 100644
--- a/packages/desktop/package.json
+++ b/packages/desktop/package.json
@@ -2,7 +2,7 @@
   "name": "@start/desktop",
   "private": true,
   "productName": "Start",
-  "version": "0.1.0-alpha.34",
+  "version": "0.1.0-alpha.35",
   "license": "MIT",
   "description": "your coding assistant",
   "type": "module",
diff --git a/packages/desktop/src/main/chat.ts b/packages/desktop/src/main/chat.ts
index 6d5f0c5c..01b3fb09 100644
--- a/packages/desktop/src/main/chat.ts
+++ b/packages/desktop/src/main/chat.ts
@@ -28,7 +28,7 @@ import { sessionWorkspacePath, tabFromSession, tabFromSessionStatus } from '@mai
 import { closeStartDb, openStartDb } from '@main/db';
 import { historyDetail, imageAttachments, textContent } from '@main/details';
 import { chatEvent } from '@main/events';
-import { addWorktree, getGitBranch, gitTopLevel, listWorktrees } from '@main/git';
+import { addWorktree, discardWorktree, getGitBranch, gitMainWorktree, listWorktrees } from '@main/git';
 import {
   agentEndError,
   clampThinkingLevel,
@@ -40,17 +40,19 @@ import {
   providerAuthKind,
   providerAuthLabel,
   providerAuthSlots,
+  subscriptionProviderId,
   textDelta,
   thinkingDelta
 } from '@main/helpers';
 import { historyTurns } from '@main/history';
 import { disposeMcpClients } from '@main/mcp/clients';
 import { mcpToolsForSession, warmMcpServers } from '@main/mcp/tools';
+import { modelScore } from '@main/models';
 import { createStartResourceLoader } from '@main/prompt/loader';
 import { resolveAuthBackend } from '@main/providers/auth';
 import { InMemorySettingsBackend } from '@main/providers/settings';
-import { warmWebSearchTools } from '@main/providers/tools/search/index';
 import { createStartCustomTools } from '@main/providers/tools/index';
+import { warmWebSearchTools } from '@main/providers/tools/search/index';
 import type { SessionController, SessionEnvironment, SessionSummary } from '@main/providers/tools/sessions';
 import type { WorktreeOwner } from '@main/providers/tools/worktree';
 import { disposeWorkspaceFinders, refreshWorkspaceFinder, warmWorkspaceFinder } from '@main/search/client';
@@ -67,7 +69,6 @@ import {
   updateSessionTitle,
   upsertSessionOnStart
 } from '@main/sessions';
-import { modelScore } from '@main/models';
 import { readStartState, type StartState, updateStartState } from '@main/storage';
 import { SubagentNameAllocator } from '@main/subagents/allocator';
 import type { WorkflowModelOption } from '@main/subagents/types';
@@ -101,11 +102,19 @@ import {
   type SwitchWorkspaceResult,
   type WorkspaceFolder
 } from '@main/types';
+import type { ProviderUsageCredential } from '@main/usage/types';
 import { directoryStatus, workspaceDisplayName } from '@main/utils/workspace';
 import { sendToMainWindowIfOpen, sendToRendererWindows } from '@main/window';
 import { activateWorkspaceAccess } from '@main/workspace/access';
 import { workspaceHistoryWith } from '@main/workspace/history';
-import { isManagedWorktree, worktreeBranch, worktreePathFor, worktreeSlug } from '@main/workspace/worktree';
+import {
+  isManagedWorktree,
+  managedWorktreeRepoFolder,
+  repoFolderName,
+  worktreeBranch,
+  worktreePathFor,
+  worktreeSlug
+} from '@main/workspace/worktree';
 import type { WebContents } from 'electron';
 import electron from 'electron';
 
@@ -204,6 +213,12 @@ interface MobileSessionChange {
   workspacePath: string;
 }
 
+interface ManagedWorktree {
+  path: string;
+  branch: string;
+  repoRoot: string;
+}
+
 type MobileSessionChangeHandler = (change: MobileSessionChange) => void;
 
 const visibleQueuedMessage = (message: PendingQueuedMessage): QueuedMessage => ({
@@ -687,20 +702,40 @@ export class ChatService {
     };
   }
 
-  private async addManagedWorktree(branchName?: string, base?: string): Promise<string> {
-    const repoRoot = await gitTopLevel(this.workspaceCwd);
-    if (!repoRoot) return '';
+  private async addManagedWorktree(cwd: string, branchName?: string, base?: string): Promise<ManagedWorktree> {
+    const repoRoot = await gitMainWorktree(cwd);
+    if (!repoRoot) throw new Error(`${cwd} is not a Git repository.`);
+    if (isManagedWorktree(baseDir, repoRoot))
+      throw new Error(`Could not resolve the primary Git repository for ${cwd}.`);
     const slug = `${worktreeSlug(branchName ?? '')}-${randomBytes(4).toString('hex')}`;
-    const worktree = await addWorktree(repoRoot, worktreePathFor(baseDir, repoRoot, slug), {
-      branch: worktreeBranch(slug),
-      ...(base ? { base } : {})
-    });
-    return worktree ? worktree.path : '';
+    const branch = worktreeBranch(slug);
+    const worktreePath = worktreePathFor(baseDir, repoRoot, slug);
+    const worktree = await addWorktree(repoRoot, worktreePath, { branch, ...(base ? { base } : {}) });
+    return { branch, repoRoot, path: worktree.path };
+  }
+
+  private async withManagedWorktree<T>(
+    cwd: string,
+    run: (workspacePath: string) => Promise<T>,
+    branchName?: string,
+    base?: string
+  ): Promise<T> {
+    const worktree = await this.addManagedWorktree(cwd, branchName, base);
+    try {
+      return await run(worktree.path);
+    } catch (error) {
+      await discardWorktree(worktree.repoRoot, worktree.path, worktree.branch);
+      throw error;
+    }
   }
 
   async createWorktreeTab(branchName?: string, base?: string): Promise<AgentTab> {
-    const worktreePath = await this.addManagedWorktree(branchName, base);
-    return worktreePath ? this.createTab(worktreePath) : this.createTab();
+    return this.withManagedWorktree(
+      this.workspaceCwd,
+      (workspacePath) => this.createTab(workspacePath),
+      branchName,
+      base
+    );
   }
 
   private async createBackgroundSession(workspacePath: string): Promise<AgentSession> {
@@ -781,22 +816,42 @@ export class ChatService {
     return this.sessionResult(session);
   }
 
-  private async workspaceRootForCwd(cwd: string): Promise<string> {
+  private knownWorkspaceRootFor(cwd: string, candidates: readonly string[] = []): string {
+    const folder = managedWorktreeRepoFolder(baseDir, cwd);
+    if (!folder) return '';
+
+    const history = Object.keys(this.appState.workspaceHistory ?? {});
+    return (
+      [...new Set([this.workspaceCwd, ...history, ...candidates])].find(
+        (candidate) => !isManagedWorktree(baseDir, candidate) && repoFolderName(candidate) === folder
+      ) ?? ''
+    );
+  }
+
+  private async workspaceRootForCwd(cwd: string, candidates: readonly string[] = []): Promise<string> {
     if (!cwd || !isManagedWorktree(baseDir, cwd)) return cwd;
 
     const cached = this.worktreeRepoCache.get(cwd);
     if (cached) return cached;
 
-    const repoRoot = (await listWorktrees(cwd)).find((tree) => tree.isMain)?.path ?? cwd;
-    this.worktreeRepoCache.set(cwd, repoRoot);
+    const known = this.knownWorkspaceRootFor(cwd, candidates);
+    if (known) {
+      this.worktreeRepoCache.set(cwd, known);
+      return known;
+    }
+
+    const resolved = await gitMainWorktree(cwd);
+    const repoRoot = !isManagedWorktree(baseDir, resolved) ? resolved : '';
+    if (repoRoot) this.worktreeRepoCache.set(cwd, repoRoot);
     return repoRoot;
   }
 
   private async warmWorkspaceRoots(cwds: string[]): Promise<void> {
-    await Promise.all([...new Set(cwds)].map((cwd) => this.workspaceRootForCwd(cwd)));
+    await Promise.all([...new Set(cwds)].map((cwd) => this.workspaceRootForCwd(cwd, cwds)));
   }
 
   private async managedWorktreesFor(repoRoot: string): Promise<WorktreeRef[]> {
+    if (!repoRoot) return [];
     return (await listWorktrees(repoRoot))
       .filter((tree) => isManagedWorktree(baseDir, tree.path))
       .map((tree) => ({ path: tree.path, branch: tree.branch }));
@@ -826,38 +881,36 @@ export class ChatService {
     const sessions = await SessionManager.listAll();
     const folders = new Map<string, WorkspaceFolder>();
     const rawAttention = this.workspaceAttentionStatuses();
-    await this.warmWorkspaceRoots([
-      this.workspaceCwd,
-      ...rawAttention.keys(),
-      ...sessions.flatMap((session) => (session.cwd ? [session.cwd] : []))
-    ]);
-    const attentionStatuses = await this.resolvedAttentionStatuses(rawAttention);
-    const activeRoot = await this.workspaceRootForCwd(this.workspaceCwd);
-    folders.set(activeRoot, {
-      sessionCount: 0,
-      path: activeRoot,
-      modified: Date.now(),
-      name: workspaceDisplayName(activeRoot),
-      ...this.workspaceAttention(activeRoot, attentionStatuses)
+    const workspaceHistory = this.appState.workspaceHistory ?? {};
+    const sessionCwds = sessions.flatMap((session) => (session.cwd ? [session.cwd] : []));
+    const workspaceCwds = [this.workspaceCwd, ...Object.keys(workspaceHistory), ...rawAttention.keys(), ...sessionCwds];
+    await this.warmWorkspaceRoots(workspaceCwds);
+    const activeRoot = await this.workspaceRootForCwd(this.workspaceCwd, workspaceCwds);
+    const attentionStatuses = await this.resolvedAttentionStatuses(rawAttention, workspaceCwds);
+    const workspaceFolder = (path: string, modified: number, sessionCount: number): WorkspaceFolder => ({
+      path,
+      modified,
+      sessionCount,
+      active: path === activeRoot,
+      name: workspaceDisplayName(path),
+      ...this.workspaceAttention(path, attentionStatuses)
     });
+    if (activeRoot) {
+      folders.set(activeRoot, workspaceFolder(activeRoot, Date.now(), 0));
+    }
 
-    const workspaceHistory = this.appState.workspaceHistory ?? {};
     for (const [workspacePath, lastOpenedAt] of Object.entries(workspaceHistory)) {
-      if (folders.has(workspacePath)) continue;
+      const root = await this.workspaceRootForCwd(workspacePath, workspaceCwds);
+      if (!root || folders.has(root)) continue;
 
-      folders.set(workspacePath, {
-        sessionCount: 0,
-        path: workspacePath,
-        modified: lastOpenedAt,
-        name: workspaceDisplayName(workspacePath),
-        ...this.workspaceAttention(workspacePath, attentionStatuses)
-      });
+      folders.set(root, workspaceFolder(root, lastOpenedAt, 0));
     }
 
     for (const session of sessions) {
       if (!session.cwd || session.messageCount === 0) continue;
 
-      const root = await this.workspaceRootForCwd(session.cwd);
+      const root = await this.workspaceRootForCwd(session.cwd, workspaceCwds);
+      if (!root) continue;
       const current = folders.get(root);
       const modified = session.modified.getTime();
       if (current) {
@@ -865,26 +918,14 @@ export class ChatService {
         current.sessionCount += 1;
         Object.assign(current, this.workspaceAttention(root, attentionStatuses));
       } else {
-        folders.set(root, {
-          modified,
-          sessionCount: 1,
-          path: root,
-          name: workspaceDisplayName(root),
-          ...this.workspaceAttention(root, attentionStatuses)
-        });
+        folders.set(root, workspaceFolder(root, modified, 1));
       }
     }
 
     for (const workspacePath of attentionStatuses.keys()) {
       if (folders.has(workspacePath)) continue;
 
-      folders.set(workspacePath, {
-        sessionCount: 0,
-        path: workspacePath,
-        modified: Date.now(),
-        name: workspaceDisplayName(workspacePath),
-        ...this.workspaceAttention(workspacePath, attentionStatuses)
-      });
+      folders.set(workspacePath, workspaceFolder(workspacePath, Date.now(), 0));
     }
 
     const list = [...folders.values()].sort((a, b) => b.modified - a.modified);
@@ -898,7 +939,7 @@ export class ChatService {
 
     const missingCandidates = [...missingPaths];
     const currentStatuses = await Promise.all(missingCandidates.map((workspacePath) => directoryStatus(workspacePath)));
-    const currentActiveRoot = await this.workspaceRootForCwd(this.workspaceCwd);
+    const currentActiveRoot = await this.workspaceRootForCwd(this.workspaceCwd, workspaceCwds);
     const confirmedMissingPaths = new Set(
       missingCandidates.filter(
         (workspacePath, index) => workspacePath !== currentActiveRoot && currentStatuses[index] === 'missing'
@@ -1015,6 +1056,24 @@ export class ChatService {
     ];
   }
 
+  async getProviderUsageCredential(provider: ProviderKey): Promise<ProviderUsageCredential | null> {
+    const providerId = subscriptionProviderId(provider);
+    const credential = this.authStorage.get(providerId);
+    if (credential?.type !== 'oauth') return null;
+    const token = await this.authStorage.getApiKey(providerId, { includeFallback: false });
+    if (!token) return null;
+
+    const accountId = credential.accountId;
+    return {
+      token,
+      ...(typeof accountId === 'string' && accountId ? { accountId } : {})
+    };
+  }
+
+  prepareProviderUsageCredentials(): void {
+    this.authStorage.reload();
+  }
+
   async setApiKey(provider: string, apiKey: string): Promise<ProviderAuthStatus[]> {
     const cleanProvider = provider.trim().toLowerCase();
     const cleanApiKey = apiKey.trim();
@@ -1037,7 +1096,7 @@ export class ChatService {
   }
 
   async loginSubscription(provider: string, webContents: WebContents): Promise<ProviderLoginResult> {
-    const providerId = provider === 'openai' ? 'openai-codex' : provider;
+    const providerId = subscriptionProviderId(provider);
     this.authInputReject?.(new Error('Login restarted.'));
     this.clearSubscriptionAuthInput();
 
@@ -1979,15 +2038,18 @@ export class ChatService {
     kind: SessionNotice['kind'],
     webContents?: WebContents
   ): void {
-    this.notices.set(sessionId, {
+    const payload: SessionNotice = {
       kind,
       sessionId,
       workspacePath,
       createdAt: Date.now()
-    });
+    };
+    this.notices.set(sessionId, payload);
     this.persistNotices();
-    webContents?.send('chat:recent-sessions-changed', { workspacePath });
-    webContents?.send('chat:notice', { tabId: sessionId, payload: this.notices.get(sessionId), workspacePath });
+    const notice = { tabId: sessionId, payload, workspacePath };
+    sendToRendererWindows('chat:recent-sessions-changed', { workspacePath });
+    if (webContents) webContents.send('chat:notice', notice);
+    else sendToMainWindowIfOpen('chat:notice', notice);
   }
 
   private persistNotices(): void {
@@ -2035,10 +2097,14 @@ export class ChatService {
     return this.collapseTopStatuses(statuses);
   }
 
-  private async resolvedAttentionStatuses(raw: Map<string, AgentTabStatus>): Promise<Map<string, AgentTabStatus>> {
+  private async resolvedAttentionStatuses(
+    raw: Map<string, AgentTabStatus>,
+    candidates: readonly string[] = []
+  ): Promise<Map<string, AgentTabStatus>> {
     const grouped = new Map<string, AgentTabStatus[]>();
     for (const [workspacePath, status] of raw) {
-      const root = await this.workspaceRootForCwd(workspacePath);
+      const root = await this.workspaceRootForCwd(workspacePath, candidates);
+      if (!root) continue;
       grouped.set(root, [...(grouped.get(root) ?? []), status]);
     }
 
@@ -2098,13 +2164,13 @@ export class ChatService {
 
     return {
       ...base,
-      sessions: this.sessionController(),
+      sessions: this.sessionController(cwd),
       customTools: subagentSessionTools,
       worktreeOwners: (path) => this.worktreeOwners(path)
     };
   }
 
-  private sessionController(): SessionController {
+  private sessionController(cwd: string): SessionController {
     const toSummary = (tab: AgentTab) => ({
       id: tab.id,
       status: tab.status,
@@ -2124,7 +2190,7 @@ export class ChatService {
         if (!session) return;
         this.generate(session, sessionWorkspacePath(session, this.workspaceCwd), prompt, []).catch(() => {});
       },
-      create: (input) => this.startSession(input)
+      create: (input) => this.startSession({ ...input, cwd })
     };
   }
 
@@ -2137,17 +2203,32 @@ export class ChatService {
   }
 
   async startSession({
+    cwd = this.workspaceCwd,
     prompt,
     environment,
     attachments = []
   }: {
+    cwd?: string;
     prompt: string;
     environment: SessionEnvironment;
     attachments?: ImageAttachment[];
   }): Promise<SessionSummary> {
-    const worktreePath =
-      environment.type === 'worktree' ? await this.addManagedWorktree(environment.branch, environment.base) : '';
-    const workspacePath = worktreePath || this.workspaceCwd;
+    if (environment.type === 'worktree') {
+      return this.withManagedWorktree(
+        cwd,
+        (workspacePath) => this.startBackgroundSession(workspacePath, prompt, attachments),
+        environment.branch,
+        environment.base
+      );
+    }
+    return this.startBackgroundSession(cwd, prompt, attachments);
+  }
+
+  private async startBackgroundSession(
+    workspacePath: string,
+    prompt: string,
+    attachments: ImageAttachment[]
+  ): Promise<SessionSummary> {
     const session = await this.createBackgroundSession(workspacePath);
     this.generate(session, workspacePath, prompt, attachments).catch(() => {});
     return {
@@ -2256,7 +2337,7 @@ export class ChatService {
     const apiKeyStatus = this.authStorage.getAuthStatus(key);
     const hasApiKey = apiKeyStatus.configured;
     const supportsSubscription = key === 'anthropic' || key === 'openai';
-    const subscriptionProvider = key === 'openai' ? 'openai-codex' : key;
+    const subscriptionProvider = subscriptionProviderId(key);
     const hasSubscription =
       supportsSubscription &&
       (this.authStorage.get(subscriptionProvider)?.type === 'oauth' ||
diff --git a/packages/desktop/src/main/git.ts b/packages/desktop/src/main/git.ts
index e2541554..f8e943dc 100644
--- a/packages/desktop/src/main/git.ts
+++ b/packages/desktop/src/main/git.ts
@@ -1,5 +1,5 @@
 import { execFile, spawn } from 'node:child_process';
-import { readFile, stat } from 'node:fs/promises';
+import { readFile, rm, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import { resolveInside } from '@main/utils/workspace';
@@ -47,6 +47,7 @@ type UntrackedFileData = {
 const maxPatchFiles = 2000;
 const maxUntrackedFiles = 64;
 const gitShowTimeoutMs = 4000;
+const gitWorktreeAddTimeoutMs = 60_000;
 const gitWorktreeTimeoutMs = 10_000;
 const maxPatchLines = 200_000;
 const gitMaxBuffer = 32 * 1024 * 1024;
@@ -483,22 +484,35 @@ export const listWorktrees = async (cwd: string): Promise<GitWorktree[]> => {
   }
 };
 
+export const gitMainWorktree = async (cwd: string): Promise<string> => {
+  const main = (await listWorktrees(cwd)).find((tree) => tree.isMain);
+  return main?.path ?? gitTopLevel(cwd);
+};
+
 export const addWorktree = async (
   cwd: string,
   worktreePath: string,
   options: { branch?: string; base?: string } = {}
-): Promise<GitWorktree | undefined> => {
+): Promise<GitWorktree> => {
+  const branchExisted = options.branch
+    ? Boolean(
+        (await git(cwd, ['for-each-ref', '--count=1', '--format=%(refname)', `refs/heads/${options.branch}`])).trim()
+      )
+    : false;
   try {
     const args = ['worktree', 'add', '--quiet'];
     if (options.branch) args.push('-b', options.branch);
     args.push(worktreePath);
     if (options.base) args.push(options.base);
 
-    await git(cwd, args, gitWorktreeTimeoutMs);
+    await git(cwd, args, gitWorktreeAddTimeoutMs);
     const target = path.resolve(worktreePath);
-    return (await listWorktrees(cwd)).find((tree) => path.resolve(tree.path) === target);
-  } catch {
-    return;
+    const worktree = (await listWorktrees(cwd)).find((tree) => path.resolve(tree.path) === target);
+    if (!worktree) throw new Error(`Git created ${worktreePath}, but it could not be verified.`);
+    return worktree;
+  } catch (error) {
+    await discardWorktree(cwd, worktreePath, branchExisted ? '' : (options.branch ?? ''));
+    throw error;
   }
 };
 
@@ -519,3 +533,12 @@ export const removeWorktree = async (
     return false;
   }
 };
+
+export const discardWorktree = async (cwd: string, worktreePath: string, branch: string): Promise<void> => {
+  const removed = await removeWorktree(cwd, worktreePath, { force: true });
+  if (!removed) {
+    await rm(worktreePath, { recursive: true, force: true }).catch(() => {});
+    await git(cwd, ['worktree', 'prune'], gitWorktreeTimeoutMs).catch(() => {});
+  }
+  if (branch) await git(cwd, ['branch', '-D', branch], gitWorktreeTimeoutMs).catch(() => {});
+};
diff --git a/packages/desktop/src/main/helpers.ts b/packages/desktop/src/main/helpers.ts
index 26f89a3b..bbb454e6 100644
--- a/packages/desktop/src/main/helpers.ts
+++ b/packages/desktop/src/main/helpers.ts
@@ -61,6 +61,8 @@ export const providerAuthSlots = (provider: string): string[] => {
   return [provider];
 };
 
+export const subscriptionProviderId = (provider: string) => (provider === 'openai' ? 'openai-codex' : provider);
+
 export const isProviderModel = (model: { provider: string; id: string; name?: string }, provider: ProviderKey) => {
   const haystack = `${model.provider} ${model.id} ${model.name ?? ''}`.toLowerCase();
   if (provider === 'openai') {
diff --git a/packages/desktop/src/main/index.ts b/packages/desktop/src/main/index.ts
index 7c7b7982..977eb479 100644
--- a/packages/desktop/src/main/index.ts
+++ b/packages/desktop/src/main/index.ts
@@ -55,6 +55,7 @@ import {
 } from '@main/settings';
 import type { ChatStatus } from '@main/types';
 import { checkForUpdatesNow, registerUpdateIpc, startAutoUpdateChecks, stopAutoUpdateChecks } from '@main/updates';
+import { ProviderUsageService } from '@main/usage/index';
 import { logger } from '@main/utils/logger';
 import { setStayAwake, shouldStayAwake } from '@main/utils/power';
 import { resolveInside } from '@main/utils/workspace';
@@ -102,6 +103,7 @@ let quitCleanupStarted = false;
 let appQuitConfirmationOpen = false;
 let appSettings: AppSettings | null = null;
 let stopResourceRefresh: (() => void) | null = null;
+let providerUsage: ProviderUsageService | null = null;
 let stopMainWindowChanged: (() => void) | null = null;
 
 const mobileResult = (
@@ -328,9 +330,11 @@ const registerComposerShortcut = (accelerator: string) => {
 const menuActions = () => ({
   onShowSettings: showSettings,
   onShowShortcuts: showShortcuts,
-  onQuickAccess: () => toggleQuickAccess('menu'),
   onNewSession: () => startNewSession('menu'),
   onCheckForUpdates: () => checkForUpdatesNow(),
+  onQuickAccess: () => toggleQuickAccess('menu'),
+  onShowProviders: () => showSettings('providers'),
+  providerUsage: providerUsage?.getUsage() ?? null,
   recentSessions: chat.getStatusItemRecentSessions(),
   onOpenRecentSession: (sessionId: string) => openRecentSession(sessionId),
   composerShortcut: appSettings?.composerShortcut ?? defaultAppSettings.composerShortcut
@@ -430,6 +434,15 @@ if (!singleInstanceLock) {
     registerComposerShortcut(appSettings.composerShortcut);
     activateWorkspaceAccess(chat.getWorkspaceCwd());
 
+    if (isMac) {
+      providerUsage = new ProviderUsageService({
+        onChange: () => installStatusItem(menuActions()),
+        prepareCredentials: () => chat.prepareProviderUsageCredentials(),
+        getCredential: (provider) => chat.getProviderUsageCredential(provider)
+      });
+      providerUsage.start();
+    }
+
     installApplicationMenu(menuActions());
     installStatusItem(menuActions());
     stopWorkspaceChanged = onWorkspaceChanged((workspace) => {
@@ -439,6 +452,7 @@ if (!singleInstanceLock) {
       if (!focused) return;
 
       gitChanges.flushPendingRefreshes();
+      providerUsage?.refreshIfStale().catch(() => {});
       chat
         .refreshActiveSessionResources()
         .then((refreshed) => {
@@ -460,6 +474,7 @@ if (!singleInstanceLock) {
       getWorkspace(workspacePath ?? chat.getWorkspaceCwd())
     );
     ipcMain.handle('app:settings', () => appSettings);
+    ipcMain.handle('app:provider-usage', () => providerUsage?.getUsage() ?? []);
     ipcMain.handle('app:mobile-relay-code', () => desktopRelay.currentCode);
     ipcMain.handle('app:probe-mobile-relay', (_event, settings: { relayUrl: string; relayToken: string }) =>
       probeRelay(settings.relayUrl, settings.relayToken)
@@ -614,6 +629,8 @@ const runQuitCleanup = async () => {
   stopMainWindowChanged?.();
   stopMainWindowChanged = null;
   stopAutoUpdateChecks();
+  providerUsage?.stop();
+  providerUsage = null;
   desktopRelay.stop();
   setStayAwake(false);
   await destroyBrowserSilently();
diff --git a/packages/desktop/src/main/menu.ts b/packages/desktop/src/main/menu.ts
index 4fa6ecd3..ff03f8bf 100644
--- a/packages/desktop/src/main/menu.ts
+++ b/packages/desktop/src/main/menu.ts
@@ -1,5 +1,6 @@
 import { appIconPath, appMenuName, isMac, isProd, trayIconPath } from '@main/application';
 import type { StatusItemRecentSession } from '@main/types';
+import type { ProviderUsage } from '@main/usage/types';
 import type { Tray as ElectronTray, MenuItemConstructorOptions } from 'electron';
 import electron from 'electron';
 
@@ -11,8 +12,10 @@ type MenuActions = {
   onNewSession: () => void;
   onQuickAccess: () => void;
   onShowSettings: () => void;
+  onShowProviders: () => void;
   onShowShortcuts: () => void;
   onCheckForUpdates: () => void;
+  providerUsage: ProviderUsage[] | null;
   recentSessions: StatusItemRecentSession[];
   onOpenRecentSession: (id: string) => void;
 };
@@ -60,11 +63,36 @@ const recentSessionItems = (
   ];
 };
 
+const usageProviders = [
+  { id: 'openai', name: 'OpenAI' },
+  { id: 'anthropic', name: 'Anthropic' }
+] as const;
+
+const usageSublabel = (usage: ProviderUsage | undefined) => {
+  if (!usage) return 'Unavailable';
+  return `${usage.remainingPercent}% remaining`;
+};
+
+const providerUsageItems = (usage: ProviderUsage[] | null, onShowProviders: () => void): MenuItemOptions[] => {
+  if (!usage) return [];
+  return [
+    { type: 'separator' },
+    { label: 'Usage', enabled: false },
+    ...usageProviders.map((provider) => ({
+      label: provider.name,
+      click: onShowProviders,
+      sublabel: usageSublabel(usage.find((item) => item.id === provider.id))
+    }))
+  ];
+};
+
 export const installStatusItem = ({
   onNewSession,
   onQuickAccess,
+  providerUsage,
   onShowSettings,
   recentSessions,
+  onShowProviders,
   composerShortcut,
   onOpenRecentSession
 }: MenuActions) => {
@@ -86,6 +114,7 @@ export const installStatusItem = ({
         click: onQuickAccess
       },
       ...recentSessionItems(recentSessions, onOpenRecentSession),
+      ...providerUsageItems(providerUsage, onShowProviders),
       { type: 'separator' },
       {
         label: 'Settings',
diff --git a/packages/desktop/src/main/providers/tools/sessions.ts b/packages/desktop/src/main/providers/tools/sessions.ts
index f9775633..01fd9743 100644
--- a/packages/desktop/src/main/providers/tools/sessions.ts
+++ b/packages/desktop/src/main/providers/tools/sessions.ts
@@ -57,12 +57,16 @@ interface CreateArgs {
 export const runCreateSession = async (controller: SessionController, { prompt, environment }: CreateArgs) => {
   if (!prompt.trim()) return toolResult('Provide a non-empty prompt.', null);
   const env: SessionEnvironment = environment ?? { type: 'local' };
-  const session = await controller.create({ prompt, environment: env });
-  const message =
-    env.type === 'worktree' && !session.isolated
-      ? `Could not isolate a worktree (not a git repository or git failed). Started a local session ${session.id} at ${session.workspacePath} instead.`
-      : `Created ${session.isolated ? 'worktree' : 'local'} session ${session.id} at ${session.workspacePath}`;
-  return toolResult(message, null);
+  try {
+    const session = await controller.create({ prompt, environment: env });
+    return toolResult(
+      `Created ${session.isolated ? 'worktree' : 'local'} session ${session.id} at ${session.workspacePath}`,
+      null
+    );
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : 'The session could not be created.';
+    return toolResult(`Could not create ${env.type} session: ${reason}`, null);
+  }
 };
 
 export const runListSessions = (
diff --git a/packages/desktop/src/main/types.ts b/packages/desktop/src/main/types.ts
index 254a208b..5850f3ad 100644
--- a/packages/desktop/src/main/types.ts
+++ b/packages/desktop/src/main/types.ts
@@ -234,9 +234,10 @@ export type ScopedChatEvent<T> = {
 export type WorkspaceFolder = {
   name: string;
   path: string;
+  active: boolean;
   modified: number;
-  status?: AgentTabStatus;
   sessionCount: number;
+  status?: AgentTabStatus;
   noticeKind?: SessionNoticeKind;
 };
 
diff --git a/packages/desktop/src/main/usage/index.ts b/packages/desktop/src/main/usage/index.ts
new file mode 100644
index 00000000..48d47bc1
--- /dev/null
+++ b/packages/desktop/src/main/usage/index.ts
@@ -0,0 +1,84 @@
+import type { ProviderKey } from '@main/types';
+import { fetchProviderUsage } from '@main/usage/providers';
+import type { ProviderUsage, ProviderUsageCredential } from '@main/usage/types';
+import { logger } from '@main/utils/logger';
+
+const refreshIntervalMs = 5 * 60 * 1000;
+const providers: ProviderKey[] = ['openai', 'anthropic'];
+
+interface ProviderUsageServiceOptions {
+  onChange: () => void;
+  prepareCredentials: () => void;
+  getCredential: (provider: ProviderKey) => Promise<ProviderUsageCredential | null>;
+}
+
+export class ProviderUsageService {
+  private lastUsage = '[]';
+  private lastRefreshAt = 0;
+  private refreshPromise: Promise<void> | null = null;
+  private usage = new Map<ProviderKey, ProviderUsage>();
+  private timer: ReturnType<typeof setInterval> | null = null;
+
+  constructor(private readonly options: ProviderUsageServiceOptions) {}
+
+  start(): void {
+    if (this.timer) return;
+    this.refresh().catch(() => {});
+    this.timer = setInterval(() => this.refresh().catch(() => {}), refreshIntervalMs);
+  }
+
+  stop(): void {
+    if (!this.timer) return;
+    clearInterval(this.timer);
+    this.timer = null;
+  }
+
+  refresh(): Promise<void> {
+    this.refreshPromise ??= this.refreshProviders().finally(() => {
+      this.refreshPromise = null;
+    });
+    return this.refreshPromise;
+  }
+
+  async refreshIfStale(): Promise<void> {
+    if (Date.now() - this.lastRefreshAt < refreshIntervalMs) return;
+    await this.refresh();
+  }
+
+  getUsage(): ProviderUsage[] {
+    return providers.flatMap((provider) => {
+      const usage = this.usage.get(provider);
+      return usage ? [usage] : [];
+    });
+  }
+
+  private async refreshProviders(): Promise<void> {
+    this.lastRefreshAt = Date.now();
+    this.options.prepareCredentials();
+    await Promise.all(
+      providers.map(async (provider) => {
+        try {
+          const credential = await this.options.getCredential(provider);
+          if (!credential) {
+            this.usage.delete(provider);
+            return;
+          }
+
+          this.usage.set(provider, await fetchProviderUsage(provider, credential));
+        } catch (error) {
+          this.usage.delete(provider);
+          logger.error(`${provider} usage`, error);
+        }
+      })
+    );
+
+    this.emitChange();
+  }
+
+  private emitChange(): void {
+    const serialized = JSON.stringify(this.getUsage());
+    if (serialized === this.lastUsage) return;
+    this.lastUsage = serialized;
+    this.options.onChange();
+  }
+}
diff --git a/packages/desktop/src/main/usage/providers.ts b/packages/desktop/src/main/usage/providers.ts
new file mode 100644
index 00000000..134e5514
--- /dev/null
+++ b/packages/desktop/src/main/usage/providers.ts
@@ -0,0 +1,121 @@
+import { timestampValue } from '@main/details';
+import type { ProviderKey } from '@main/types';
+import type { ProviderUsage, ProviderUsageCredential } from '@main/usage/types';
+import * as v from 'valibot';
+
+const requestTimeoutMs = 10_000;
+
+const codexWindowSchema = v.looseObject({
+  used_percent: v.number(),
+  reset_at: v.optional(v.nullable(v.number()))
+});
+
+const codexUsageSchema = v.looseObject({
+  rate_limit: v.looseObject({
+    primary_window: v.optional(v.nullable(codexWindowSchema)),
+    secondary_window: v.optional(v.nullable(codexWindowSchema))
+  })
+});
+
+const claudeWindowSchema = v.looseObject({
+  utilization: v.number(),
+  resets_at: v.optional(v.nullable(v.string()))
+});
+
+const claudeUsageSchema = v.looseObject({
+  five_hour: v.optional(v.nullable(claudeWindowSchema)),
+  seven_day: v.optional(v.nullable(claudeWindowSchema))
+});
+
+interface UsageWindow {
+  resetAt?: number;
+  usedPercent: number;
+}
+
+const clampPercent = (value: number) => Math.min(100, Math.max(0, value));
+
+const timestampFromSeconds = (value: number | null) => {
+  if (!value || value <= 0) return 0;
+  return value * 1000;
+};
+
+const selectUsage = (id: ProviderKey, name: string, windows: UsageWindow[]) => {
+  const selected = [...windows].sort(
+    (left, right) => right.usedPercent - left.usedPercent || (left.resetAt ?? Infinity) - (right.resetAt ?? Infinity)
+  )[0];
+  if (!selected) throw new Error(`${name} did not return a supported usage window.`);
+
+  return {
+    id,
+    ...(selected.resetAt ? { resetAt: selected.resetAt } : {}),
+    remainingPercent: Math.round(100 - clampPercent(selected.usedPercent))
+  } satisfies ProviderUsage;
+};
+
+const parseCodexUsage = (value: unknown) => {
+  const result = v.safeParse(codexUsageSchema, value);
+  if (!result.success) throw new Error('OpenAI returned an invalid usage response.');
+
+  const windows = [result.output.rate_limit.primary_window, result.output.rate_limit.secondary_window].flatMap(
+    (window): UsageWindow[] => {
+      if (!window) return [];
+      const resetAt = timestampFromSeconds(window.reset_at ?? null);
+      return [
+        {
+          ...(resetAt ? { resetAt } : {}),
+          usedPercent: window.used_percent
+        }
+      ];
+    }
+  );
+
+  return selectUsage('openai', 'OpenAI', windows);
+};
+
+const parseClaudeUsage = (value: unknown) => {
+  const result = v.safeParse(claudeUsageSchema, value);
+  if (!result.success) throw new Error('Anthropic returned an invalid usage response.');
+
+  const windows = [result.output.five_hour, result.output.seven_day].flatMap((window): UsageWindow[] => {
+    if (!window) return [];
+    const resetAt = timestampValue(window.resets_at);
+    return [
+      {
+        ...(resetAt ? { resetAt } : {}),
+        usedPercent: window.utilization
+      }
+    ];
+  });
+
+  return selectUsage('anthropic', 'Anthropic', windows);
+};
+
+const fetchJson = async (url: string, headers: Record<string, string>) => {
+  const response = await fetch(url, {
+    headers,
+    signal: AbortSignal.timeout(requestTimeoutMs)
+  });
+  if (!response.ok) throw new Error(`Usage request failed with status ${response.status}.`);
+  return response.json() as Promise<unknown>;
+};
+
+export const fetchProviderUsage = async (provider: ProviderKey, credential: ProviderUsageCredential) => {
+  if (provider === 'openai') {
+    if (!credential.accountId) throw new Error('OpenAI account ID is unavailable.');
+    const value = await fetchJson('https://chatgpt.com/backend-api/wham/usage', {
+      'ChatGPT-Account-Id': credential.accountId,
+      Authorization: `Bearer ${credential.token}`
+    });
+    return parseCodexUsage(value);
+  }
+
+  const value = await fetchJson('https://api.anthropic.com/api/oauth/usage', {
+    'User-Agent': 'claude-code/2.1.80',
+    'anthropic-beta': 'oauth-2025-04-20',
+    Authorization: `Bearer ${credential.token}`
+  });
+  return parseClaudeUsage(value);
+};
+
+export const parseProviderUsage = (provider: ProviderKey, value: unknown) =>
+  provider === 'openai' ? parseCodexUsage(value) : parseClaudeUsage(value);
diff --git a/packages/desktop/src/main/usage/types.ts b/packages/desktop/src/main/usage/types.ts
new file mode 100644
index 00000000..bafad7f3
--- /dev/null
+++ b/packages/desktop/src/main/usage/types.ts
@@ -0,0 +1,8 @@
+import type { ProviderUsage as PublicProviderUsage } from '@preload/index';
+
+export type ProviderUsage = PublicProviderUsage;
+
+export interface ProviderUsageCredential {
+  token: string;
+  accountId?: string;
+}
diff --git a/packages/desktop/src/main/workspace/worktree.ts b/packages/desktop/src/main/workspace/worktree.ts
index 4b1932d3..b85e1cee 100644
--- a/packages/desktop/src/main/workspace/worktree.ts
+++ b/packages/desktop/src/main/workspace/worktree.ts
@@ -24,6 +24,12 @@ export const managedWorktreeRoot = (baseDir: string) => path.join(baseDir, 'work
 export const worktreePathFor = (baseDir: string, repoRoot: string, slug: string) =>
   path.join(managedWorktreeRoot(baseDir), repoFolderName(repoRoot), slug);
 
+export const managedWorktreeRepoFolder = (baseDir: string, candidate: string) => {
+  const relative = relativeInside(managedWorktreeRoot(baseDir), candidate);
+  if (!relative) return '';
+  return relative.split(path.sep)[0] ?? '';
+};
+
 export const isManagedWorktree = (baseDir: string, candidate: string) => {
   const relative = relativeInside(managedWorktreeRoot(baseDir), candidate);
   return relative !== null && relative !== '';
diff --git a/packages/desktop/src/preload/index.ts b/packages/desktop/src/preload/index.ts
index 6e4d81db..d268cefc 100644
--- a/packages/desktop/src/preload/index.ts
+++ b/packages/desktop/src/preload/index.ts
@@ -78,6 +78,12 @@ export interface ProviderAuthStatus {
   hasCredentials: boolean;
 }
 
+export interface ProviderUsage {
+  resetAt?: number;
+  remainingPercent: number;
+  id: 'anthropic' | 'openai';
+}
+
 export interface ProviderLoginResult {
   ok: boolean;
   error?: string;
@@ -247,6 +253,7 @@ export interface GitFileBlob {
 export interface WorkspaceFolder {
   name: string;
   path: string;
+  active: boolean;
   modified: number;
   sessionCount: number;
   status?: AgentTabStatus;
@@ -399,6 +406,7 @@ const api = {
     onWorkspaceChanged: (listener: (workspace: WorkspaceInfo) => void): IpcDisposer =>
       onIpc<[WorkspaceInfo]>('app:workspace-changed', listener),
     settings: (): Promise<AppSettings> => ipcRenderer.invoke('app:settings'),
+    providerUsage: (): Promise<ProviderUsage[]> => ipcRenderer.invoke('app:provider-usage'),
     mobileRelayCode: (): Promise<string> => ipcRenderer.invoke('app:mobile-relay-code'),
     onMobileRelayCode: (listener: (code: string) => void): IpcDisposer =>
       onIpc<[string]>('app:mobile-relay-code', listener),
diff --git a/packages/desktop/src/renderer/src/shared/attention-status.ts b/packages/desktop/src/renderer/src/shared/attention.ts
similarity index 87%
rename from packages/desktop/src/renderer/src/shared/attention-status.ts
rename to packages/desktop/src/renderer/src/shared/attention.ts
index 1e24f281..5c771956 100644
--- a/packages/desktop/src/renderer/src/shared/attention-status.ts
+++ b/packages/desktop/src/renderer/src/shared/attention.ts
@@ -34,12 +34,9 @@ export const topAttentionStatus = (statuses: AttentionState[]): AttentionState =
   return '';
 };
 
-export const workspaceFoldersAttention = (
-  folders: WorkspaceFolder[],
-  activeWorkspacePath: string
-): { kind: AttentionState; countLabel: string } => {
+export const workspaceFoldersAttention = (folders: WorkspaceFolder[]): { kind: AttentionState; countLabel: string } => {
   const statuses = folders
-    .filter((folder) => folder.path !== activeWorkspacePath)
+    .filter((folder) => !folder.active)
     .map((folder) => attentionStatus(folder.status, folder.noticeKind));
   return { kind: topAttentionStatus(statuses), countLabel: attentionCountLabel(attentionStatusCount(statuses)) };
 };
diff --git a/packages/desktop/src/renderer/src/shared/badge.tsx b/packages/desktop/src/renderer/src/shared/badge.tsx
index 9b4f93ea..f12c4b44 100644
--- a/packages/desktop/src/renderer/src/shared/badge.tsx
+++ b/packages/desktop/src/renderer/src/shared/badge.tsx
@@ -1,4 +1,4 @@
-import type { AttentionState } from '@renderer/shared/attention-status';
+import type { AttentionState } from '@renderer/shared/attention';
 import { tw } from '@renderer/utils/tw';
 
 interface AttentionBadgeProps {
diff --git a/packages/desktop/src/renderer/src/shared/chat/events.ts b/packages/desktop/src/renderer/src/shared/chat/events.ts
index 7d9a9981..5aec26e3 100644
--- a/packages/desktop/src/renderer/src/shared/chat/events.ts
+++ b/packages/desktop/src/renderer/src/shared/chat/events.ts
@@ -338,8 +338,8 @@ export const useChatEvents = (options: UseChatEventsOptions) => {
       setTurns((current) => [...current, createTurn('system', payload)]);
     });
 
-    const offNotice = window.pi.chat.onNotice(({ payload }) => {
-      if (payload) playAttentionSound();
+    const offNotice = window.pi.chat.onNotice(({ tabId, payload }) => {
+      if (payload && !activeScopedSession(tabId)) playAttentionSound();
     });
 
     const offStatusChanged = window.pi.chat.onStatusChanged(refreshChatState);
diff --git a/packages/desktop/src/renderer/src/shared/chat/use-chat.ts b/packages/desktop/src/renderer/src/shared/chat/use-chat.ts
index 8597bdfa..3c4b408a 100644
--- a/packages/desktop/src/renderer/src/shared/chat/use-chat.ts
+++ b/packages/desktop/src/renderer/src/shared/chat/use-chat.ts
@@ -14,6 +14,7 @@ import { buildRecallList } from '@renderer/shared/chat/recall';
 import { useChatSend } from '@renderer/shared/chat/send';
 import { useTurnSummary } from '@renderer/shared/chat/turn-summary';
 import { clearFinderItemsCache } from '@renderer/shared/finder/use-items';
+import { refreshProviderUsage } from '@renderer/shared/settings/state';
 import type { SettingsTab } from '@renderer/shared/settings/tab';
 import { clearSlashCommandsCache } from '@renderer/shared/slash-commands';
 import { scrollSessionToBottom } from '@renderer/shared/turn/scroll';
@@ -102,7 +103,7 @@ export const useChat = ({ onShowChat, onShowSettings, textareaRef }: UseChatOpti
 
   const applyStatus = useCallback(
     (nextStatus: ChatStatus) => {
-      primeWorkspaceFolders(nextStatus.workspacePath);
+      primeWorkspaceFolders();
       setWorkspacePath(nextStatus.workspacePath);
       selectedModelKeyState.value = nextStatus.selectedModelKey ?? '';
       setSelectedModelKey(nextStatus.selectedModelKey ?? '');
@@ -331,7 +332,7 @@ export const useChat = ({ onShowChat, onShowSettings, textareaRef }: UseChatOpti
       selectedModelKeyState.value = result.status.selectedModelKey ?? '';
       setSelectedModelKey(result.status.selectedModelKey ?? '');
       if (result.status.thinkingLevel) setThinkingLevel(result.status.thinkingLevel);
-      primeWorkspaceFolders(result.status.workspacePath);
+      primeWorkspaceFolders();
       textareaRef.current?.focus();
       return true;
     },
@@ -447,6 +448,7 @@ export const useChat = ({ onShowChat, onShowSettings, textareaRef }: UseChatOpti
   const refreshSettings = useCallback(() => {
     loadModels().catch(() => {});
     loadAuthProviders().catch(() => {});
+    refreshProviderUsage();
   }, [loadAuthProviders, loadModels]);
 
   return {
diff --git a/packages/desktop/src/renderer/src/shared/composer/workspace.tsx b/packages/desktop/src/renderer/src/shared/composer/workspace.tsx
index 12d5f358..517ce7cb 100644
--- a/packages/desktop/src/renderer/src/shared/composer/workspace.tsx
+++ b/packages/desktop/src/renderer/src/shared/composer/workspace.tsx
@@ -1,4 +1,4 @@
-import { workspaceFoldersAttention } from '@renderer/shared/attention-status';
+import { workspaceFoldersAttention } from '@renderer/shared/attention';
 import { AttentionBadge } from '@renderer/shared/badge';
 import { useWorkspaceFolders } from '@renderer/shared/workspace/folders';
 import { useWorkspace } from '@renderer/shared/workspace/info';
@@ -16,8 +16,8 @@ interface WorkspaceProps {
 export const Workspace = ({ workspacePath, onChooseDirectory, onSelectWorkspace }: WorkspaceProps) => {
   const [open, setOpen] = useState(false);
   const workspace = useWorkspace(workspacePath);
-  const { folders } = useWorkspaceFolders({ workspacePath });
-  const { kind: attention, countLabel } = workspaceFoldersAttention(folders, workspacePath);
+  const { folders } = useWorkspaceFolders();
+  const { kind: attention, countLabel } = workspaceFoldersAttention(folders);
 
   if (!workspace) return null;
 
@@ -42,12 +42,7 @@ export const Workspace = ({ workspacePath, onChooseDirectory, onSelectWorkspace
         <AppMenu.Portal>
           <AppMenu.Positioner side="top" sideOffset={12} className="z-50" collisionPadding={12}>
             <MenuPanel className="w-64">
-              <WorkspaceMenu
-                folders={folders}
-                onSelect={onSelectWorkspace}
-                workspacePath={workspacePath}
-                onChooseDirectory={onChooseDirectory}
-              />
+              <WorkspaceMenu folders={folders} onSelect={onSelectWorkspace} onChooseDirectory={onChooseDirectory} />
             </MenuPanel>
           </AppMenu.Positioner>
         </AppMenu.Portal>
diff --git a/packages/desktop/src/renderer/src/shared/sessions.tsx b/packages/desktop/src/renderer/src/shared/sessions.tsx
index 7f276786..d7cb61e1 100644
--- a/packages/desktop/src/renderer/src/shared/sessions.tsx
+++ b/packages/desktop/src/renderer/src/shared/sessions.tsx
@@ -5,7 +5,7 @@ import {
   attentionStatusCount,
   sessionAttentionStatus,
   topAttentionStatus
-} from '@renderer/shared/attention-status';
+} from '@renderer/shared/attention';
 import { AttentionBadge } from '@renderer/shared/badge';
 import { Indicator } from '@renderer/shared/indicator';
 import { appHotkeys, useAppHotkey } from '@renderer/ui/hotkeys';
diff --git a/packages/desktop/src/renderer/src/shared/settings/providers.tsx b/packages/desktop/src/renderer/src/shared/settings/providers.tsx
index d1e3efbc..b190b004 100644
--- a/packages/desktop/src/renderer/src/shared/settings/providers.tsx
+++ b/packages/desktop/src/renderer/src/shared/settings/providers.tsx
@@ -1,5 +1,8 @@
-import type { ProviderAuthStatus } from '@preload/index';
-import { AnthropicIcon, ChevronDownIcon, OpenAIIcon } from '@renderer/ui/icons';
+import type { ProviderAuthStatus, ProviderUsage } from '@preload/index';
+import { providerUsage } from '@renderer/shared/settings/state';
+import { usageLabel } from '@renderer/shared/settings/usage';
+import { AnthropicIcon, ChevronDownIcon, OpenAIIcon, UsageIcon } from '@renderer/ui/icons';
+import { Tooltip } from '@renderer/ui/tooltip';
 import { closeMotionTransition, openMotionTransition } from '@renderer/ui/motion';
 import { tw } from '@renderer/utils/tw';
 import { AnimatePresence, motion } from 'motion/react';
@@ -37,6 +40,7 @@ interface ProviderHeadingProps {
   authLabel: string;
   connected: boolean;
   authDetail: string;
+  usage?: ProviderUsage;
 }
 
 const providerStatus = (providers: ProviderAuthStatus[], provider: ProviderKey) =>
@@ -53,9 +57,22 @@ const ProviderAvatar = ({ provider }: { provider: ProviderKey }) => (
   </div>
 );
 
-const ProviderHeading = ({ name, authLabel, connected, authDetail }: ProviderHeadingProps) => (
+const ProviderHeading = ({ name, authLabel, connected, authDetail, usage }: ProviderHeadingProps) => (
   <div class="min-w-0 flex-1">
-    <h3 class="m-0 text-sm leading-5 font-medium text-ink">{name}</h3>
+    <h3 class="m-0 flex items-center gap-1 text-sm leading-5 font-medium text-ink">
+      {name}
+      {usage && (
+        <Tooltip label={usageLabel(usage)}>
+          <button
+            type="button"
+            aria-label={`${name} usage`}
+            class="relative grid size-4 place-items-center border-0 bg-transparent p-0 text-soft transition-colors hover:text-ink before:absolute before:-inset-1"
+          >
+            <UsageIcon class="size-3.5" />
+          </button>
+        </Tooltip>
+      )}
+    </h3>
     <p class="m-0 text-xs leading-4 text-soft">
       {connected ? (
         <>
@@ -111,6 +128,7 @@ export const Providers = ({
         const authDetail = connected ? connectionDetail(auth?.label) : '';
         const expandable = !hasCredentials;
         const open = expandable && openProvider === provider.key;
+        const usage = connected ? providerUsage.value.find((item) => item.id === provider.key) : undefined;
 
         return (
           <div class={tw(index > 0 ? 'pt-4 pb-4' : 'pb-4')} key={provider.key}>
@@ -127,6 +145,7 @@ export const Providers = ({
                   authLabel={authLabel}
                   connected={connected}
                   authDetail={authDetail}
+                  {...(usage ? { usage } : {})}
                 />
                 <ChevronDownIcon
                   class={tw('size-4 flex-none text-soft transition-transform duration-150', open && 'rotate-180')}
@@ -140,6 +159,7 @@ export const Providers = ({
                   authLabel={authLabel}
                   connected={connected}
                   authDetail={authDetail}
+                  {...(usage ? { usage } : {})}
                 />
                 <button
                   type="button"
diff --git a/packages/desktop/src/renderer/src/shared/settings/state.ts b/packages/desktop/src/renderer/src/shared/settings/state.ts
index 873844d7..48517e3f 100644
--- a/packages/desktop/src/renderer/src/shared/settings/state.ts
+++ b/packages/desktop/src/renderer/src/shared/settings/state.ts
@@ -1,8 +1,17 @@
-import type { AppSettingsResult } from '@preload/index';
+import type { AppSettingsResult, ProviderUsage } from '@preload/index';
 import { signal } from '@preact/signals';
 
 export const keepAwake = signal(true);
 export const composerShortcut = signal('Control+Space');
+export const providerUsage = signal<ProviderUsage[]>([]);
+
+export const refreshProviderUsage = async () => {
+  try {
+    providerUsage.value = await window.pi.app.providerUsage();
+  } catch {
+    providerUsage.value = [];
+  }
+};
 
 export const updateKeepAwake = async (enabled: boolean): Promise<AppSettingsResult> => {
   try {
diff --git a/packages/desktop/src/renderer/src/shared/settings/usage.ts b/packages/desktop/src/renderer/src/shared/settings/usage.ts
new file mode 100644
index 00000000..55109076
--- /dev/null
+++ b/packages/desktop/src/renderer/src/shared/settings/usage.ts
@@ -0,0 +1,18 @@
+import type { ProviderUsage } from '@preload/index';
+
+const resetDelay = (resetAt: number, now: number) => {
+  const remainingMs = resetAt - now;
+  if (remainingMs <= 0) return 'soon';
+
+  const minutes = Math.ceil(remainingMs / 60_000);
+  if (minutes < 60) return `in ${minutes}m`;
+
+  const hours = Math.ceil(remainingMs / 3_600_000);
+  if (hours < 48) return `in ${hours}h`;
+  return `in ${Math.ceil(remainingMs / 86_400_000)}d`;
+};
+
+export const usageLabel = (usage: ProviderUsage, now = Date.now()) => {
+  const reset = usage.resetAt ? ` / resets ${resetDelay(usage.resetAt, now)}` : '';
+  return `${usage.remainingPercent}% remaining${reset}`;
+};
diff --git a/packages/desktop/src/renderer/src/shared/turn/articles.tsx b/packages/desktop/src/renderer/src/shared/turn/articles.tsx
index 00dec1ab..760c68f6 100644
--- a/packages/desktop/src/renderer/src/shared/turn/articles.tsx
+++ b/packages/desktop/src/renderer/src/shared/turn/articles.tsx
@@ -7,6 +7,7 @@ import type { RefObject } from 'preact';
 import { memo } from 'preact/compat';
 
 interface TurnArticlesProps {
+  initialEnd: boolean;
   onRangeChange: () => void;
   preserveScrollEnd: boolean;
   virtualRef: RefObject<VirtualHandle | null>;
@@ -19,7 +20,7 @@ const estimateTurnIdHeight = (turnId: string) => {
   return turn ? estimateTurnHeight(turn) : 44;
 };
 
-export const TurnArticles = memo(({ virtualRef, onRangeChange, preserveScrollEnd }: TurnArticlesProps) => {
+export const TurnArticles = memo(({ initialEnd, onRangeChange, preserveScrollEnd, virtualRef }: TurnArticlesProps) => {
   const turnIds = turnIdsState.value;
 
   if (!turnIds.length) return null;
@@ -31,15 +32,16 @@ export const TurnArticles = memo(({ virtualRef, onRangeChange, preserveScrollEnd
       getKey={turnKey}
       className="w-full"
       apiRef={virtualRef}
+      initialEnd={initialEnd}
       onRangeChange={onRangeChange}
       itemClassName="flex flex-col"
-      estimateHeight={estimateTurnIdHeight}
-      preserveScrollEnd={preserveScrollEnd}
       renderItem={(turnId, index) => {
         const assistant = readTurn(turnId)?.role === 'assistant';
         const actionText = assistant ? turnActionTextAt((i) => readTurn(turnIds[i] ?? ''), index) : '';
         return <TurnArticleById turnId={turnId} {...(actionText ? { actionText } : {})} />;
       }}
+      estimateHeight={estimateTurnIdHeight}
+      preserveScrollEnd={preserveScrollEnd}
     />
   );
 });
diff --git a/packages/desktop/src/renderer/src/shared/turn/feed.tsx b/packages/desktop/src/renderer/src/shared/turn/feed.tsx
index cb19eec7..5cc00f1d 100644
--- a/packages/desktop/src/renderer/src/shared/turn/feed.tsx
+++ b/packages/desktop/src/renderer/src/shared/turn/feed.tsx
@@ -18,7 +18,7 @@ export const TurnFeed = memo(() => {
 
   turnIndexesRef.current = turnIndexes;
 
-  const { roomRef, scrollRef, contentRef, positioned, roomVisible, onVirtualRangeChange } = useTurnRoom({
+  const { roomRef, scrollRef, contentRef, positioned, initialEnd, roomVisible, onVirtualRangeChange } = useTurnRoom({
     streaming,
     turnIndex,
     virtualRef,
@@ -37,7 +37,12 @@ export const TurnFeed = memo(() => {
       )}
     >
       <div ref={contentRef} class="mx-auto flex min-h-full max-w-3xl flex-col justify-end px-5">
-        <TurnArticles virtualRef={virtualRef} preserveScrollEnd={!roomVisible} onRangeChange={onVirtualRangeChange} />
+        <TurnArticles
+          initialEnd={initialEnd}
+          virtualRef={virtualRef}
+          preserveScrollEnd={!roomVisible}
+          onRangeChange={onVirtualRangeChange}
+        />
         {roomVisible && <div ref={roomRef} class="shrink-0" aria-hidden="true" />}
       </div>
     </section>
diff --git a/packages/desktop/src/renderer/src/shared/turn/room.ts b/packages/desktop/src/renderer/src/shared/turn/room.ts
index 8433fe99..492d0d17 100644
--- a/packages/desktop/src/renderer/src/shared/turn/room.ts
+++ b/packages/desktop/src/renderer/src/shared/turn/room.ts
@@ -174,6 +174,7 @@ export const useTurnRoom = ({ streaming, turnCount, turnIndex, virtualRef }: Use
     positioned,
     contentRef,
     onVirtualRangeChange,
-    roomVisible: Boolean(roomTurnId)
+    roomVisible: Boolean(roomTurnId),
+    initialEnd: scrollIntent.kind === 'bottom'
   };
 };
diff --git a/packages/desktop/src/renderer/src/shared/workspace/folders.ts b/packages/desktop/src/renderer/src/shared/workspace/folders.ts
index 250a530e..10274305 100644
--- a/packages/desktop/src/renderer/src/shared/workspace/folders.ts
+++ b/packages/desktop/src/renderer/src/shared/workspace/folders.ts
@@ -1,14 +1,8 @@
 import type { WorkspaceFolder } from '@preload/index';
-import { workspaceDisplayName } from '@renderer/shared/workspace/utils';
 import { useCallback, useEffect, useState } from 'preact/hooks';
 
 type WorkspaceFoldersListener = () => void;
 
-interface UseWorkspaceFoldersOptions {
-  active?: boolean;
-  workspacePath: string | undefined;
-}
-
 let stopWorkspaceFolderEvents: (() => void) | undefined;
 let workspaceFoldersCache: WorkspaceFolder[] | undefined;
 let workspaceFoldersRequest: Promise<WorkspaceFolder[]> | undefined;
@@ -17,24 +11,11 @@ let appliedWorkspaceFoldersSeq = 0;
 
 const workspaceFoldersListeners = new Set<WorkspaceFoldersListener>();
 
-const currentWorkspaceFolder = (workspacePath: string): WorkspaceFolder => ({
-  sessionCount: 0,
-  path: workspacePath,
-  modified: Date.now(),
-  name: workspaceDisplayName(workspacePath)
-});
-
-const withCurrentWorkspace = (folders: WorkspaceFolder[], workspacePath: string | undefined) => {
-  if (!workspacePath || folders.some((folder) => folder.path === workspacePath)) return folders;
-  return [currentWorkspaceFolder(workspacePath), ...folders];
-};
-
 const emitWorkspaceFolders = () => {
   for (const listener of workspaceFoldersListeners) listener();
 };
 
-export const cachedWorkspaceFolders = (workspacePath?: string) =>
-  withCurrentWorkspace(workspaceFoldersCache ?? [], workspacePath);
+export const cachedWorkspaceFolders = () => workspaceFoldersCache ?? [];
 
 const applyWorkspaceFolders = (folders: WorkspaceFolder[], seq: number) => {
   if (seq < appliedWorkspaceFoldersSeq) return workspaceFoldersCache ?? folders;
@@ -60,24 +41,14 @@ export const loadWorkspaceFolders = async () => {
   return request;
 };
 
-export const primeWorkspaceFolders = (workspacePath: string | undefined) => {
-  const nextFolders = cachedWorkspaceFolders(workspacePath);
-  if (nextFolders !== workspaceFoldersCache) {
-    workspaceFoldersCache = nextFolders;
-    emitWorkspaceFolders();
-  }
-
-  loadWorkspaceFolders().catch(emitWorkspaceFolders);
-};
-
-const refreshWorkspaceFolders = () => {
+export const primeWorkspaceFolders = () => {
   loadWorkspaceFolders().catch(emitWorkspaceFolders);
 };
 
 const watchWorkspaceFolders = () => {
   if (stopWorkspaceFolderEvents) return;
-  const offRecentSessionsChanged = window.pi.chat.onRecentSessionsChanged(refreshWorkspaceFolders);
-  const offStatusChanged = window.pi.chat.onStatusChanged(refreshWorkspaceFolders);
+  const offRecentSessionsChanged = window.pi.chat.onRecentSessionsChanged(primeWorkspaceFolders);
+  const offStatusChanged = window.pi.chat.onStatusChanged(primeWorkspaceFolders);
   stopWorkspaceFolderEvents = () => {
     offRecentSessionsChanged();
     offStatusChanged();
@@ -100,27 +71,20 @@ const subscribeWorkspaceFolders = (listener: WorkspaceFoldersListener) => {
   };
 };
 
-export const useWorkspaceFolders = ({ active = true, workspacePath }: UseWorkspaceFoldersOptions) => {
-  const [folders, setFolders] = useState(() => cachedWorkspaceFolders(workspacePath));
+export const useWorkspaceFolders = () => {
+  const [folders, setFolders] = useState(cachedWorkspaceFolders);
 
   const syncFolders = useCallback(() => {
-    setFolders(cachedWorkspaceFolders(workspacePath));
-  }, [workspacePath]);
+    setFolders(cachedWorkspaceFolders());
+  }, []);
 
-  const refreshFolders = useCallback(() => {
-    primeWorkspaceFolders(workspacePath);
-  }, [workspacePath]);
-
-  useEffect(() => {
-    if (!active) return;
-    return subscribeWorkspaceFolders(syncFolders);
-  }, [active, syncFolders]);
+  useEffect(() => subscribeWorkspaceFolders(syncFolders), [syncFolders]);
   useEffect(() => {
-    if (active) refreshFolders();
-  }, [active, refreshFolders]);
+    primeWorkspaceFolders();
+  }, []);
 
   return {
-    refreshFolders,
-    folders: withCurrentWorkspace(folders, workspacePath)
+    folders,
+    refreshFolders: primeWorkspaceFolders
   };
 };
diff --git a/packages/desktop/src/renderer/src/shared/workspace/menu.tsx b/packages/desktop/src/renderer/src/shared/workspace/menu.tsx
index 277b7544..d5855c5e 100644
--- a/packages/desktop/src/renderer/src/shared/workspace/menu.tsx
+++ b/packages/desktop/src/renderer/src/shared/workspace/menu.tsx
@@ -1,7 +1,6 @@
 import type { WorkspaceFolder } from '@preload/index';
-import { attentionStatus } from '@renderer/shared/attention-status';
+import { attentionStatus } from '@renderer/shared/attention';
 import { Indicator } from '@renderer/shared/indicator';
-import { canSelectWorkspace } from '@renderer/shared/workspace/select';
 import { FolderIcon } from '@renderer/ui/icons';
 import { AppMenu } from '@renderer/ui/menu';
 import { tw } from '@renderer/utils/tw';
@@ -23,7 +22,6 @@ interface WorkspaceRowProps {
 }
 
 interface WorkspaceMenuProps {
-  workspacePath?: string;
   folders: WorkspaceFolder[];
   onChooseDirectory: () => void;
   onSelect: (path: string) => void;
@@ -46,15 +44,10 @@ const WorkspaceRow = ({ folder, selected, onSelect }: WorkspaceRowProps) => (
   </AppMenu.Item>
 );
 
-export const WorkspaceMenu = ({ folders, onSelect, workspacePath, onChooseDirectory }: WorkspaceMenuProps) => (
+export const WorkspaceMenu = ({ folders, onSelect, onChooseDirectory }: WorkspaceMenuProps) => (
   <div class="flex flex-col gap-1">
     {folders.map((folder) => (
-      <WorkspaceRow
-        key={folder.path}
-        folder={folder}
-        onSelect={onSelect}
-        selected={!canSelectWorkspace(folder.path, workspacePath)}
-      />
+      <WorkspaceRow key={folder.path} folder={folder} onSelect={onSelect} selected={folder.active} />
     ))}
     <AppMenu.Item
       onClick={onChooseDirectory}
diff --git a/packages/desktop/src/renderer/src/shared/workspace/picker.tsx b/packages/desktop/src/renderer/src/shared/workspace/picker.tsx
index 9b061825..0c10fdf0 100644
--- a/packages/desktop/src/renderer/src/shared/workspace/picker.tsx
+++ b/packages/desktop/src/renderer/src/shared/workspace/picker.tsx
@@ -1,4 +1,4 @@
-import { workspaceFoldersAttention } from '@renderer/shared/attention-status';
+import { workspaceFoldersAttention } from '@renderer/shared/attention';
 import { AttentionBadge } from '@renderer/shared/badge';
 import { useWorkspaceFolders } from '@renderer/shared/workspace/folders';
 import { useWorkspace } from '@renderer/shared/workspace/info';
@@ -27,11 +27,8 @@ export const Workspace = memo(
     const [open, setOpen] = useState(false);
     const rootRef = useRef<HTMLDivElement>(null);
     const workspace = useWorkspace(workspacePath);
-    const { folders, refreshFolders } = useWorkspaceFolders({ workspacePath });
-    const { kind: attention, countLabel: visibleAttentionCountLabel } = workspaceFoldersAttention(
-      folders,
-      workspacePath
-    );
+    const { folders, refreshFolders } = useWorkspaceFolders();
+    const { kind: attention, countLabel: visibleAttentionCountLabel } = workspaceFoldersAttention(folders);
 
     const handleOpenChange = (next: boolean) => {
       if (next) playToggleSound();
@@ -112,12 +109,7 @@ export const Workspace = memo(
           <AppMenu.Portal>
             <AppMenu.Positioner side="top" sideOffset={12} anchor={rootRef} className="z-50" collisionPadding={12}>
               <MenuPanel className="w-64" finalFocus={false}>
-                <WorkspaceMenu
-                  folders={folders}
-                  onSelect={onSelectWorkspace}
-                  workspacePath={workspacePath}
-                  onChooseDirectory={onChooseDirectory}
-                />
+                <WorkspaceMenu folders={folders} onSelect={onSelectWorkspace} onChooseDirectory={onChooseDirectory} />
               </MenuPanel>
             </AppMenu.Positioner>
           </AppMenu.Portal>
diff --git a/packages/desktop/src/renderer/src/ui/icons.tsx b/packages/desktop/src/renderer/src/ui/icons.tsx
index 94feed46..98f77e6b 100644
--- a/packages/desktop/src/renderer/src/ui/icons.tsx
+++ b/packages/desktop/src/renderer/src/ui/icons.tsx
@@ -444,6 +444,18 @@ export const SettingsIcon = (props: IconProps) => (
   </svg>
 );
 
+export const UsageIcon = (props: IconProps) => (
+  <svg aria-hidden="true" fill="none" viewBox="0 0 24 24" {...props}>
+    <path
+      d="M10 10L5.5 5.5M12 5.25V2.75C17.1086 2.75 21.25 6.89137 21.25 12C21.25 17.1086 17.1086 21.25 12 21.25C6.89137 21.25 2.75 17.1086 2.75 12C2.75 10.5672 3.07575 9.21057 3.65722 8M14.75 12C14.75 13.5188 13.5188 14.75 12 14.75C10.4812 14.75 9.25 13.5188 9.25 12C9.25 10.4812 10.4812 9.25 12 9.25C13.5188 9.25 14.75 10.4812 14.75 12Z"
+      stroke-width="1.5"
+      stroke="currentColor"
+      stroke-linecap="round"
+      stroke-linejoin="round"
+    />
+  </svg>
+);
+
 export const HistoryIcon = (props: IconProps) => (
   <svg aria-hidden="true" fill="none" viewBox="0 0 24 24" {...props}>
     <path
diff --git a/packages/desktop/src/renderer/src/ui/tooltip.tsx b/packages/desktop/src/renderer/src/ui/tooltip.tsx
index 03af0109..a810da9c 100644
--- a/packages/desktop/src/renderer/src/ui/tooltip.tsx
+++ b/packages/desktop/src/renderer/src/ui/tooltip.tsx
@@ -30,7 +30,7 @@ export const Tooltip = ({
           align={align}
           sideOffset={12}
           collisionPadding={12}
-          className="tooltip-positioner z-50"
+          className="tooltip-positioner z-70"
         >
           <BaseTooltip.Popup className="tooltip-popup pointer-events-none flex items-center gap-2 rounded-full border-0 bg-tooltip px-3 py-1.75 text-xs leading-none font-medium whitespace-nowrap text-zinc-950 opacity-100 shadow-sm transition-[opacity,transform] duration-100 ease-out select-none data-[ending-style]:opacity-0 data-[starting-style]:opacity-0">
             {label}
diff --git a/packages/desktop/src/renderer/src/ui/virtual/geometry.ts b/packages/desktop/src/renderer/src/ui/virtual/geometry.ts
index 3f37860d..e2d0e0a9 100644
--- a/packages/desktop/src/renderer/src/ui/virtual/geometry.ts
+++ b/packages/desktop/src/renderer/src/ui/virtual/geometry.ts
@@ -75,6 +75,9 @@ export const initialVisibleEnd = (cumulative: Float64Array, viewportGuess: numbe
   return last;
 };
 
+export const initialVisibleStart = (cumulative: Float64Array, viewportGuess: number) =>
+  firstVisibleIndex(cumulative, Math.max(0, totalHeight(cumulative) - viewportGuess));
+
 export const visibleRange = (
   cumulative: Float64Array,
   scrollTop: number,
diff --git a/packages/desktop/src/renderer/src/ui/virtual/index.tsx b/packages/desktop/src/renderer/src/ui/virtual/index.tsx
index 2042e7d2..bee65f12 100644
--- a/packages/desktop/src/renderer/src/ui/virtual/index.tsx
+++ b/packages/desktop/src/renderer/src/ui/virtual/index.tsx
@@ -1,15 +1,16 @@
+import type { VisibleRange } from '@renderer/ui/virtual/geometry';
 import {
-  totalHeight,
-  visibleRange,
-  resolveItemHeight,
   cumulativeHeights,
   firstVisibleIndex,
   initialVisibleEnd,
+  initialVisibleStart,
   measuredPrependShift,
+  resolveItemHeight,
+  shouldCompensateMeasuredDelta,
   shouldPreserveScrollEnd,
-  shouldCompensateMeasuredDelta
+  totalHeight,
+  visibleRange
 } from '@renderer/ui/virtual/geometry';
-import type { VisibleRange } from '@renderer/ui/virtual/geometry';
 import { tw } from '@renderer/utils/tw';
 import type { ComponentChildren, RefObject } from 'preact';
 import { Fragment } from 'preact';
@@ -24,6 +25,7 @@ interface VirtualProps<T> {
   gap?: number;
   overscan?: number;
   className?: string;
+  initialEnd?: boolean;
   itemClassName?: string;
   items: ReadonlyArray<T>;
   preserveScrollEnd?: boolean;
@@ -60,14 +62,17 @@ const sameRange = (a: VisibleRange, b: VisibleRange) => a.start === b.start && a
 const useVisibleRange = (
   cumulative: Float64Array,
   overscan: number,
+  initialEnd: boolean,
   containerRef: RefObject<HTMLElement>
 ): VisibleRange => {
   const frameRef = useRef(0);
+  const initialEndRef = useRef(initialEnd);
   const cumulativeRef = useRef(cumulative);
-  const [range, setRange] = useState<VisibleRange>(() => ({
-    start: 0,
-    end: initialVisibleEnd(cumulative, initialViewportGuess)
-  }));
+  const [range, setRange] = useState<VisibleRange>(() =>
+    initialEnd
+      ? { end: cumulative.length - 1, start: initialVisibleStart(cumulative, initialViewportGuess) }
+      : { start: 0, end: initialVisibleEnd(cumulative, initialViewportGuess) }
+  );
 
   cumulativeRef.current = cumulative;
 
@@ -109,6 +114,10 @@ const useVisibleRange = (
   }, [compute, containerRef]);
 
   useLayoutEffect(() => {
+    if (initialEndRef.current) {
+      initialEndRef.current = false;
+      return;
+    }
     compute();
   }, [compute, cumulative]);
 
@@ -145,6 +154,7 @@ export const Virtual = <T,>({
   onRangeChange,
   className = '',
   estimateHeight,
+  initialEnd = false,
   itemClassName = '',
   preserveScrollEnd = false,
   overscan = defaultOverscan
@@ -158,14 +168,14 @@ export const Virtual = <T,>({
   const containerRef = useRef<HTMLDivElement>(null);
   const committedKeysRef = useRef(new Set<string>());
   const itemIndexRef = useRef(new Map<string, number>());
-  const heightCacheRef = useRef(new Map<string, number>());
-  const [heightRevision, setHeightRevision] = useState(0);
   const preserveScrollEndRef = useRef(preserveScrollEnd);
+  const [heightRevision, setHeightRevision] = useState(0);
+  const heightCacheRef = useRef(new Map<string, number>());
   const cumulativeRef = useRef<Float64Array>(cumulativeHeights([]));
 
+  itemsRef.current = items;
   estimateHeightRef.current = estimateHeight;
   preserveScrollEndRef.current = preserveScrollEnd;
-  itemsRef.current = items;
 
   const heights = useMemo(() => {
     const last = items.length - 1;
@@ -181,7 +191,7 @@ export const Virtual = <T,>({
   }, [gap, items, getKey, estimateHeight, heightRevision]);
   const cumulative = useMemo(() => cumulativeHeights(heights), [heights]);
   const total = totalHeight(cumulative);
-  const range = useVisibleRange(cumulative, overscan, containerRef);
+  const range = useVisibleRange(cumulative, overscan, initialEnd, containerRef);
 
   cumulativeRef.current = cumulative;
 
diff --git a/packages/desktop/tests/scenarios/background-notice.test.ts b/packages/desktop/tests/scenarios/background-notice.test.ts
index 5e70a3fb..5c589f96 100644
--- a/packages/desktop/tests/scenarios/background-notice.test.ts
+++ b/packages/desktop/tests/scenarios/background-notice.test.ts
@@ -5,6 +5,21 @@ import { broadcastsByChannel } from '../fakes/window.js';
 import { freshChatService, newWebContents } from '../helpers/chat-service.js';
 
 describe('background notices', () => {
+  it('does not create a notice for the session the user is viewing', async () => {
+    const chat = freshChatService({ lastWorkspace: '/tmp/workspace-a' });
+    const webContents = newWebContents();
+
+    const tab = await chat.createTab('/tmp/workspace-a');
+    const send = chat.send('visible work', webContents);
+    const session = getFakeSession(tab.id);
+    await session?.awaitPromptCall();
+    session?.finishPrompt();
+    await send;
+
+    expect(await chat.getNotices()).toEqual([]);
+    expect(broadcastsByChannel('chat:notice')).toEqual([]);
+  });
+
   it('persists a completed notice when a session finishes while the user is on another workspace', async () => {
     const chat = freshChatService({ lastWorkspace: '/tmp/workspace-a' });
     const webContents = newWebContents();
diff --git a/packages/desktop/tests/scenarios/background-session.test.ts b/packages/desktop/tests/scenarios/background-session.test.ts
index 9a039810..2087ad63 100644
--- a/packages/desktop/tests/scenarios/background-session.test.ts
+++ b/packages/desktop/tests/scenarios/background-session.test.ts
@@ -1,5 +1,6 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { getFakeSession } from '../fakes/agent/index.js';
+import { broadcastsByChannel } from '../fakes/window.js';
 import { freshChatService, newWebContents } from '../helpers/chat-service.js';
 
 describe('background session creation', () => {
@@ -22,6 +23,15 @@ describe('background session creation', () => {
     expect(chat.getTabs().some((tab) => tab.id === summary.id)).toBe(true);
 
     background?.finishPrompt();
+    await vi.waitFor(() => expect(broadcastsByChannel('chat:notice')).toHaveLength(1));
+    expect(broadcastsByChannel('chat:notice')[0]?.args[0]).toMatchObject({
+      tabId: summary.id,
+      payload: { kind: 'completed', sessionId: summary.id }
+    });
+    expect(broadcastsByChannel('chat:recent-sessions-changed').at(-1)?.args[0]).toEqual({
+      workspacePath: summary.workspacePath
+    });
+
     activeSession?.finishPrompt();
     await send;
   });
diff --git a/packages/desktop/tests/scenarios/worktree-binding.test.ts b/packages/desktop/tests/scenarios/worktree-binding.test.ts
index da54db5c..40cee9f8 100644
--- a/packages/desktop/tests/scenarios/worktree-binding.test.ts
+++ b/packages/desktop/tests/scenarios/worktree-binding.test.ts
@@ -1,21 +1,19 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
 import { baseDir } from '@main/application';
-import { managedWorktreeRoot } from '@main/workspace/worktree';
+import { managedWorktreeRoot, repoFolderName, worktreePathFor } from '@main/workspace/worktree';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { FakeSessionManager, getFakeSession } from '../fakes/agent/index.js';
 import { getStorageSnapshot } from '../fakes/storage.js';
 import { freshChatService } from '../helpers/chat-service.js';
 
 const git = vi.hoisted(() => ({
+  addWorktree: vi.fn(),
+  listWorktrees: vi.fn(async () => []),
+  discardWorktree: vi.fn(async () => {}),
   getGitBranch: vi.fn(async () => undefined),
-  gitTopLevel: vi.fn(async () => ''),
-  addWorktree: vi.fn(
-    async (_repoRoot: string, worktreePath: string, _options?: { branch?: string; base?: string }) => ({
-      path: worktreePath,
-      head: '',
-      branch: '',
-      isMain: false,
-      locked: false
-    })
-  )
+  gitMainWorktree: vi.fn(async (_cwd: string) => '')
 }));
 
 vi.mock('@main/git', () => git);
@@ -24,11 +22,20 @@ const worktreeRoot = managedWorktreeRoot(baseDir);
 
 describe('worktree-backed tabs', () => {
   beforeEach(() => {
-    git.gitTopLevel.mockResolvedValue('');
+    git.gitMainWorktree.mockResolvedValue('');
+    git.addWorktree.mockImplementation(
+      async (_repoRoot: string, worktreePath: string, _options?: { branch?: string; base?: string }) => ({
+        head: '',
+        branch: '',
+        isMain: false,
+        locked: false,
+        path: worktreePath
+      })
+    );
   });
 
   it('creates an isolated worktree session under the managed root', async () => {
-    git.gitTopLevel.mockResolvedValue('/repo');
+    git.gitMainWorktree.mockResolvedValue('/repo');
     const chat = freshChatService({ lastWorkspace: '/tmp/workspace-a' });
 
     const tab = await chat.createWorktreeTab('fix the bug');
@@ -40,7 +47,7 @@ describe('worktree-backed tabs', () => {
   });
 
   it('forks the worktree from the requested base branch', async () => {
-    git.gitTopLevel.mockResolvedValue('/repo');
+    git.gitMainWorktree.mockResolvedValue('/repo');
     const chat = freshChatService({ lastWorkspace: '/tmp/workspace-a' });
 
     await chat.createWorktreeTab('fix the bug', 'develop');
@@ -48,17 +55,94 @@ describe('worktree-backed tabs', () => {
     expect(git.addWorktree.mock.calls[0]?.[2]).toMatchObject({ base: 'develop' });
   });
 
-  it('falls back to a normal tab outside a git repository', async () => {
+  it('fails without creating a normal tab outside a git repository', async () => {
     const chat = freshChatService({ lastWorkspace: '/tmp/workspace-a' });
 
-    const tab = await chat.createWorktreeTab('anything');
+    await expect(chat.createWorktreeTab('anything')).rejects.toThrow('/tmp/workspace-a is not a Git repository.');
 
     expect(git.addWorktree).not.toHaveBeenCalled();
-    expect(tab.workspacePath).toBe('/tmp/workspace-a');
+    expect(chat.getTabs()).toEqual([]);
+  });
+
+  it('creates nested agent worktrees under the primary repository folder', async () => {
+    git.gitMainWorktree.mockResolvedValue('/repo');
+    const chat = freshChatService({ lastWorkspace: '/tmp/foreground' });
+    const callerWorktree = worktreePathFor(baseDir, '/repo', 'caller');
+
+    const summary = await chat.startSession({
+      prompt: 'do work',
+      cwd: callerWorktree,
+      environment: { type: 'worktree', branch: 'caller-work' }
+    });
+
+    expect(git.gitMainWorktree).toHaveBeenCalledWith(callerWorktree);
+    expect(git.addWorktree).toHaveBeenCalledWith(
+      '/repo',
+      expect.stringContaining(repoFolderName('/repo')),
+      expect.objectContaining({ branch: expect.stringMatching(/^start\/caller-work-/) })
+    );
+    const session = getFakeSession(summary.id);
+    await session?.awaitPromptCall();
+    session?.finishPrompt();
+  });
+
+  it('does not nest a worktree when the primary repository cannot be resolved', async () => {
+    const callerWorktree = worktreePathFor(baseDir, '/repo', 'caller');
+    git.gitMainWorktree.mockResolvedValue(callerWorktree);
+    const chat = freshChatService({ lastWorkspace: callerWorktree });
+
+    await expect(chat.startSession({ prompt: 'do work', environment: { type: 'worktree' } })).rejects.toThrow(
+      `Could not resolve the primary Git repository for ${callerWorktree}.`
+    );
+
+    expect(git.addWorktree).not.toHaveBeenCalled();
+    expect(chat.getTabs()).toEqual([]);
+  });
+
+  it('does not start a session when worktree creation fails', async () => {
+    git.gitMainWorktree.mockResolvedValue('/repo');
+    git.addWorktree.mockRejectedValue(new Error('fatal: invalid reference'));
+    const chat = freshChatService({ lastWorkspace: '/tmp/workspace-a' });
+
+    await expect(
+      chat.startSession({ prompt: 'do work', environment: { type: 'worktree', base: 'missing' } })
+    ).rejects.toThrow('fatal: invalid reference');
+
+    expect(chat.getTabs()).toEqual([]);
+  });
+
+  it('discards the worktree when session construction fails', async () => {
+    git.gitMainWorktree.mockResolvedValue('/repo');
+    const chat = freshChatService({ lastWorkspace: '/tmp/workspace-a', models: [] });
+
+    await expect(chat.createWorktreeTab('broken-session')).rejects.toThrow('No configured models found.');
+
+    expect(git.discardWorktree).toHaveBeenCalledWith(
+      '/repo',
+      expect.any(String),
+      expect.stringMatching(/^start\/broken-session-/)
+    );
+    expect(chat.getTabs()).toEqual([]);
+  });
+
+  it('discards a background worktree when session construction fails', async () => {
+    git.gitMainWorktree.mockResolvedValue('/repo');
+    const chat = freshChatService({ lastWorkspace: '/tmp/workspace-a', models: [] });
+
+    await expect(
+      chat.startSession({ prompt: 'do work', environment: { type: 'worktree', branch: 'broken-agent' } })
+    ).rejects.toThrow('No configured models found.');
+
+    expect(git.discardWorktree).toHaveBeenCalledWith(
+      '/repo',
+      expect.any(String),
+      expect.stringMatching(/^start\/broken-agent-/)
+    );
+    expect(chat.getTabs()).toEqual([]);
   });
 
   it('keeps the worktree on disk when its tab is closed', async () => {
-    git.gitTopLevel.mockResolvedValue('/repo');
+    git.gitMainWorktree.mockResolvedValue('/repo');
     const chat = freshChatService({ lastWorkspace: '/tmp/workspace-a' });
 
     const tab = await chat.createWorktreeTab('keep me');
@@ -66,4 +150,36 @@ describe('worktree-backed tabs', () => {
 
     expect(tab.workspacePath.startsWith(worktreeRoot)).toBe(true);
   });
+
+  it('groups an unresolved managed worktree session under its known repository', async () => {
+    const repoRoot = mkdtempSync(path.join(tmpdir(), 'start-worktree-root-'));
+    try {
+      const chat = freshChatService({ lastWorkspace: repoRoot });
+      const stored = FakeSessionManager.create(worktreePathFor(baseDir, repoRoot, 'orphan'));
+      stored.appendEntry({ type: 'message' });
+
+      expect(
+        (await chat.getWorkspaceFolders()).map((folder) => ({ path: folder.path, active: folder.active }))
+      ).toEqual([{ path: repoRoot, active: true }]);
+      expect(git.listWorktrees).not.toHaveBeenCalled();
+    } finally {
+      rmSync(repoRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('caches the primary repository resolved for a managed worktree', async () => {
+    const repoRoot = mkdtempSync(path.join(tmpdir(), 'start-worktree-root-'));
+    try {
+      const worktree = worktreePathFor(baseDir, repoRoot, 'cached');
+      git.gitMainWorktree.mockResolvedValue(repoRoot);
+      const chat = freshChatService({ lastWorkspace: worktree });
+
+      await chat.getWorkspaceFolders();
+      await chat.getWorkspaceFolders();
+
+      expect(git.gitMainWorktree).toHaveBeenCalledTimes(1);
+    } finally {
+      rmSync(repoRoot, { recursive: true, force: true });
+    }
+  });
 });
diff --git a/packages/desktop/tests/units/attention-status.test.ts b/packages/desktop/tests/units/attention.test.ts
similarity index 76%
rename from packages/desktop/tests/units/attention-status.test.ts
rename to packages/desktop/tests/units/attention.test.ts
index 53515b32..f0d4ea79 100644
--- a/packages/desktop/tests/units/attention-status.test.ts
+++ b/packages/desktop/tests/units/attention.test.ts
@@ -5,10 +5,11 @@ import {
   attentionStatusCount,
   sessionAttentionStatus,
   workspaceFoldersAttention
-} from '@renderer/shared/attention-status';
+} from '@renderer/shared/attention';
 
-const folder = (path: string, status?: WorkspaceFolder['status']): WorkspaceFolder => ({
+const folder = (path: string, status?: WorkspaceFolder['status'], active = false): WorkspaceFolder => ({
   path,
+  active,
   name: path,
   modified: 0,
   sessionCount: 0,
@@ -43,19 +44,28 @@ describe('attention status', () => {
 
   it('summarizes folder attention while excluding the active workspace', () => {
     const folders = [
-      folder('/active', 'generating'),
+      folder('/active', 'generating', true),
       folder('/other', 'completed'),
       folder('/failing', 'failed'),
       folder('/idle')
     ];
 
-    expect(workspaceFoldersAttention(folders, '/active')).toEqual({ kind: 'failed', countLabel: '2' });
+    expect(workspaceFoldersAttention(folders)).toEqual({ kind: 'failed', countLabel: '2' });
   });
 
   it('reports no attention when only the active workspace is busy', () => {
-    expect(workspaceFoldersAttention([folder('/active', 'generating')], '/active')).toEqual({
+    expect(workspaceFoldersAttention([folder('/active', 'generating', true)])).toEqual({
       kind: '',
       countLabel: '0'
     });
   });
+
+  it('excludes the canonical active repository for a worktree session', () => {
+    const folders = [folder('/repo', 'generating', true), folder('/other', 'completed')];
+
+    expect(workspaceFoldersAttention(folders)).toEqual({
+      kind: 'completed',
+      countLabel: '1'
+    });
+  });
 });
diff --git a/packages/desktop/tests/units/git-worktree-failure.test.ts b/packages/desktop/tests/units/git-worktree-failure.test.ts
new file mode 100644
index 00000000..735483ce
--- /dev/null
+++ b/packages/desktop/tests/units/git-worktree-failure.test.ts
@@ -0,0 +1,115 @@
+import type { ChildProcess } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const childProcessMocks = vi.hoisted(() =>
+  import('../fakes/exec.js').then((exec) => ({ execFile: exec.createExecFileMock() }))
+);
+
+vi.mock('node:child_process', () => childProcessMocks);
+
+const { execFile: execFileMock } = await childProcessMocks;
+const { addWorktree, gitMainWorktree } = await import('@main/git');
+
+const branch = 'start/partial-failure';
+const worktreePath = '/tmp/start-partial-worktree';
+
+const mockGit = (branchExists: boolean) => {
+  execFileMock.mockImplementation(
+    (
+      _command: string,
+      args: string[],
+      _options: object,
+      callback: (error: Error | null, stdout: string, stderr: string) => void
+    ) => {
+      if (args[0] === 'for-each-ref') {
+        callback(null, branchExists ? `refs/heads/${branch}\n` : '', '');
+      } else if (args[0] === 'worktree' && args[1] === 'add') {
+        callback(new Error('checkout failed'), '', 'checkout failed');
+      } else {
+        callback(null, '', '');
+      }
+      return new EventEmitter() as ChildProcess;
+    }
+  );
+};
+
+describe('addWorktree failure cleanup', () => {
+  beforeEach(() => {
+    execFileMock.mockReset();
+  });
+
+  it('deletes a generated branch after a partial creation failure', async () => {
+    mockGit(false);
+
+    await expect(addWorktree('/repo', worktreePath, { branch })).rejects.toThrow('checkout failed');
+
+    expect(execFileMock).toHaveBeenCalledWith(
+      'git',
+      ['worktree', 'add', '--quiet', '-b', branch, worktreePath],
+      expect.objectContaining({ timeout: 60_000 }),
+      expect.any(Function)
+    );
+    expect(execFileMock).toHaveBeenCalledWith(
+      'git',
+      ['branch', '-D', branch],
+      expect.any(Object),
+      expect.any(Function)
+    );
+    expect(
+      execFileMock.mock.calls.filter((call) => call[1]?.[0] === 'worktree' && call[1]?.[1] === 'prune')
+    ).toHaveLength(1);
+  });
+
+  it('preserves a branch that existed before creation', async () => {
+    mockGit(true);
+
+    await expect(addWorktree('/repo', worktreePath, { branch })).rejects.toThrow('checkout failed');
+
+    expect(execFileMock.mock.calls.some((call) => call[1]?.[0] === 'branch' && call[1]?.[1] === '-D')).toBe(false);
+  });
+});
+
+describe('gitMainWorktree', () => {
+  beforeEach(() => {
+    execFileMock.mockReset();
+  });
+
+  it('resolves the primary repository from a linked worktree', async () => {
+    execFileMock.mockImplementation(
+      (
+        _command: string,
+        args: string[],
+        _options: object,
+        callback: (error: Error | null, stdout: string, stderr: string) => void
+      ) => {
+        const stdout =
+          args[0] === 'rev-parse'
+            ? '/repo/worktrees/current\n'
+            : 'worktree /repo\0HEAD abc\0branch refs/heads/main\0\0worktree /repo/worktrees/current\0HEAD def\0branch refs/heads/start/current\0\0';
+        callback(null, stdout, '');
+        return new EventEmitter() as ChildProcess;
+      }
+    );
+
+    await expect(gitMainWorktree('/repo/worktrees/current')).resolves.toBe('/repo');
+    expect(execFileMock.mock.calls.some((call) => call[1]?.[0] === 'rev-parse')).toBe(false);
+  });
+
+  it('falls back to the Git top level when worktree listing fails', async () => {
+    execFileMock.mockImplementation(
+      (
+        _command: string,
+        args: string[],
+        _options: object,
+        callback: (error: Error | null, stdout: string, stderr: string) => void
+      ) => {
+        if (args[0] === 'worktree') callback(new Error('worktree list failed'), '', 'worktree list failed');
+        else callback(null, '/repo\n', '');
+        return new EventEmitter() as ChildProcess;
+      }
+    );
+
+    await expect(gitMainWorktree('/repo/worktrees/current')).resolves.toBe('/repo');
+  });
+});
diff --git a/packages/desktop/tests/units/menu.test.ts b/packages/desktop/tests/units/menu.test.ts
index 16d1cd72..52e23d59 100644
--- a/packages/desktop/tests/units/menu.test.ts
+++ b/packages/desktop/tests/units/menu.test.ts
@@ -1,4 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ProviderUsage } from '@main/usage/types';
 import { applicationMenuTemplate, lastTray, resetFakeMenus, type FakeMenuItem } from '../fakes/electron.js';
 
 vi.mock('@main/application', () => ({
@@ -9,15 +10,21 @@ vi.mock('@main/application', () => ({
   trayIconPath: '/tray.png'
 }));
 
-const menuActions = (onShowSettings = vi.fn()) => ({
+const menuActions = (
+  onShowSettings = vi.fn(),
+  onShowProviders = vi.fn(),
+  providerUsage: ProviderUsage[] | null = null
+) => ({
+  providerUsage,
   onShowSettings,
+  onShowProviders,
   recentSessions: [],
-  composerShortcut: 'Control+Space',
   onNewSession: vi.fn(),
   onQuickAccess: vi.fn(),
   onShowShortcuts: vi.fn(),
   onCheckForUpdates: vi.fn(),
-  onOpenRecentSession: vi.fn()
+  onOpenRecentSession: vi.fn(),
+  composerShortcut: 'Control+Space'
 });
 
 const itemWithLabel = (items: FakeMenuItem[], label: string) => {
@@ -48,15 +55,26 @@ describe('menus', () => {
 
   it('opens settings from the tray menu without forwarding Electron click arguments', async () => {
     const onShowSettings = vi.fn();
+    const onShowProviders = vi.fn();
     const { installStatusItem } = await import('@main/menu');
 
-    installStatusItem(menuActions(onShowSettings));
+    installStatusItem(menuActions(onShowSettings, onShowProviders, [{ id: 'openai', remainingPercent: 52 }]));
 
-    const settings = itemWithLabel(lastTray()?.contextMenu ?? [], 'Settings');
+    const items = lastTray()?.contextMenu ?? [];
+    const settings = itemWithLabel(items, 'Settings');
     if (!settings.click) throw new Error('Expected Settings tray item click handler.');
 
     settings.click({ label: 'Settings' }, { id: 'window' }, { triggeredByAccelerator: true });
 
     expect(onShowSettings).toHaveBeenCalledWith();
+    expect(itemWithLabel(items, 'Usage').enabled).toBe(false);
+    const openAi = itemWithLabel(items, 'OpenAI');
+    expect(openAi).toMatchObject({ sublabel: '52% remaining' });
+    expect(openAi.enabled).not.toBe(false);
+    expect(itemWithLabel(items, 'Anthropic')).toMatchObject({ sublabel: 'Unavailable' });
+
+    openAi.click?.();
+
+    expect(onShowProviders).toHaveBeenCalledWith();
   });
 });
diff --git a/packages/desktop/tests/units/provider-usage.test.ts b/packages/desktop/tests/units/provider-usage.test.ts
new file mode 100644
index 00000000..04860ab4
--- /dev/null
+++ b/packages/desktop/tests/units/provider-usage.test.ts
@@ -0,0 +1,124 @@
+import { ProviderUsageService } from '@main/usage/index';
+import { fetchProviderUsage, parseProviderUsage } from '@main/usage/providers';
+
+vi.mock('@main/utils/logger', () => ({ logger: { error: vi.fn() } }));
+
+const openAiResponse = () =>
+  new Response(
+    JSON.stringify({
+      rate_limit: {
+        primary_window: { reset_at: 2_000_000_000, used_percent: 48 }
+      }
+    }),
+    { status: 200 }
+  );
+
+describe('provider usage', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('uses the most constrained OpenAI window and its provider reset', () => {
+    expect(
+      parseProviderUsage('openai', {
+        rate_limit: {
+          primary_window: {
+            used_percent: 42,
+            reset_at: 2_000_000_000
+          },
+          secondary_window: {
+            used_percent: 81,
+            reset_at: 2_000_086_400
+          }
+        }
+      })
+    ).toEqual({
+      id: 'openai',
+      remainingPercent: 19,
+      resetAt: 2_000_086_400_000
+    });
+  });
+
+  it('uses the most constrained Anthropic window and parses its reset', () => {
+    expect(
+      parseProviderUsage('anthropic', {
+        five_hour: { resets_at: '2033-05-18T03:33:20.000Z', utilization: 62 },
+        seven_day: { resets_at: '2033-05-19T03:33:20.000Z', utilization: 24 }
+      })
+    ).toEqual({
+      id: 'anthropic',
+      remainingPercent: 38,
+      resetAt: 2_000_000_000_000
+    });
+  });
+
+  it('rejects an invalid provider response', () => {
+    expect(() => parseProviderUsage('openai', { rate_limit: {} })).toThrow(
+      'OpenAI did not return a supported usage window.'
+    );
+  });
+
+  it('sends the OpenAI OAuth account header without exposing refresh credentials', async () => {
+    const fetchMock = vi.fn().mockImplementation(async () => openAiResponse());
+    vi.stubGlobal('fetch', fetchMock);
+
+    await fetchProviderUsage('openai', { accountId: 'account-1', token: 'access-token' });
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      'https://chatgpt.com/backend-api/wham/usage',
+      expect.objectContaining({
+        headers: {
+          Authorization: 'Bearer access-token',
+          'ChatGPT-Account-Id': 'account-1'
+        }
+      })
+    );
+  });
+
+  it('skips fresh requests and unchanged menu updates', async () => {
+    const fetchMock = vi.fn().mockImplementation(async () => openAiResponse());
+    const onChange = vi.fn();
+    vi.stubGlobal('fetch', fetchMock);
+    const service = new ProviderUsageService({
+      onChange,
+      prepareCredentials: () => {},
+      getCredential: async (provider) =>
+        provider === 'openai' ? { accountId: 'account-1', token: 'access-token' } : null
+    });
+
+    await service.refresh();
+    await service.refresh();
+    await service.refreshIfStale();
+
+    expect(service.getUsage()).toEqual([
+      {
+        id: 'openai',
+        remainingPercent: 52,
+        resetAt: 2_000_000_000_000
+      }
+    ]);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    expect(onChange).toHaveBeenCalledTimes(1);
+  });
+
+  it('clears stale usage after a refresh failure', async () => {
+    const fetchMock = vi
+      .fn()
+      .mockImplementationOnce(async () => openAiResponse())
+      .mockRejectedValueOnce(new Error('network unavailable'));
+    const onChange = vi.fn();
+    vi.stubGlobal('fetch', fetchMock);
+    const service = new ProviderUsageService({
+      onChange,
+      prepareCredentials: () => {},
+      getCredential: async (provider) =>
+        provider === 'openai' ? { accountId: 'account-1', token: 'access-token' } : null
+    });
+
+    await service.refresh();
+    await service.refresh();
+
+    expect(service.getUsage()).toEqual([]);
+    expect(onChange).toHaveBeenCalledTimes(2);
+  });
+});
diff --git a/packages/desktop/tests/units/sessions-tool.test.ts b/packages/desktop/tests/units/sessions-tool.test.ts
index 30250b88..7c687357 100644
--- a/packages/desktop/tests/units/sessions-tool.test.ts
+++ b/packages/desktop/tests/units/sessions-tool.test.ts
@@ -1,10 +1,10 @@
 import {
-  type SessionController,
-  type SessionSummary,
   runCreateSession,
   runListSessions,
   runReadSession,
-  runSendMessage
+  runSendMessage,
+  type SessionController,
+  type SessionSummary
 } from '@main/providers/tools/sessions';
 import { describe, expect, it, vi } from 'vitest';
 
@@ -52,10 +52,14 @@ describe('create_session', () => {
     expect(result.content[0]?.text).toContain('non-empty prompt');
   });
 
-  it('reports the fallback when isolation is not honored', async () => {
-    const ctrl = controller({ create: async () => summary({ isolated: false, workspacePath: '/repo' }) });
+  it('reports creation failure without starting a fallback session', async () => {
+    const ctrl = controller({
+      create: async () => {
+        throw new Error('fatal: invalid reference');
+      }
+    });
     const result = await runCreateSession(ctrl, { prompt: 'do x', environment: { type: 'worktree' } });
-    expect(result.content[0]?.text).toContain('Could not isolate a worktree');
+    expect(result.content[0]?.text).toBe('Could not create worktree session: fatal: invalid reference');
   });
 });
 
diff --git a/packages/desktop/tests/units/settings-usage.test.ts b/packages/desktop/tests/units/settings-usage.test.ts
new file mode 100644
index 00000000..3946ac06
--- /dev/null
+++ b/packages/desktop/tests/units/settings-usage.test.ts
@@ -0,0 +1,20 @@
+import { usageLabel } from '@renderer/shared/settings/usage';
+
+describe('provider usage labels', () => {
+  const now = 2_000_000_000_000;
+
+  it('formats short reset delays compactly', () => {
+    expect(usageLabel({ id: 'openai', remainingPercent: 93, resetAt: now + 5 * 3_600_000 }, now)).toBe(
+      '93% remaining / resets in 5h'
+    );
+  });
+
+  it('formats long and elapsed reset delays', () => {
+    expect(usageLabel({ id: 'anthropic', remainingPercent: 99, resetAt: now + 3 * 86_400_000 }, now)).toBe(
+      '99% remaining / resets in 3d'
+    );
+    expect(usageLabel({ id: 'anthropic', remainingPercent: 99, resetAt: now }, now)).toBe(
+      '99% remaining / resets soon'
+    );
+  });
+});
diff --git a/packages/desktop/tests/units/virtual-geometry.test.ts b/packages/desktop/tests/units/virtual-geometry.test.ts
index c0d39764..384a6312 100644
--- a/packages/desktop/tests/units/virtual-geometry.test.ts
+++ b/packages/desktop/tests/units/virtual-geometry.test.ts
@@ -1,14 +1,15 @@
 import {
-  totalHeight,
-  visibleRange,
-  resolveItemHeight,
-  lastVisibleIndex,
   cumulativeHeights,
   firstVisibleIndex,
   initialVisibleEnd,
+  initialVisibleStart,
+  lastVisibleIndex,
   measuredPrependShift,
+  resolveItemHeight,
+  shouldCompensateMeasuredDelta,
   shouldPreserveScrollEnd,
-  shouldCompensateMeasuredDelta
+  totalHeight,
+  visibleRange
 } from '@renderer/ui/virtual/geometry';
 import { describe, expect, it } from 'vitest';
 
@@ -99,6 +100,16 @@ describe('initialVisibleEnd', () => {
   });
 });
 
+describe('initialVisibleStart', () => {
+  it('starts near the end when estimates exceed the viewport guess', () => {
+    expect(initialVisibleStart(cumulativeHeights([100, 100, 100, 100]), 150)).toBe(2);
+  });
+
+  it('starts at zero when estimates fit within the viewport guess', () => {
+    expect(initialVisibleStart(cumulativeHeights([40, 50, 60]), 500)).toBe(0);
+  });
+});
+
 describe('visibleRange', () => {
   const cumulative = cumulativeHeights([100, 100, 100, 100, 100]);
 
diff --git a/packages/desktop/tests/units/workspace-folders.test.ts b/packages/desktop/tests/units/workspace-folders.test.ts
new file mode 100644
index 00000000..86dfb553
--- /dev/null
+++ b/packages/desktop/tests/units/workspace-folders.test.ts
@@ -0,0 +1,8 @@
+import { cachedWorkspaceFolders } from '@renderer/shared/workspace/folders';
+import { describe, expect, it } from 'vitest';
+
+describe('workspace folder cache', () => {
+  it('stays empty until canonical folders arrive from the main process', () => {
+    expect(cachedWorkspaceFolders()).toEqual([]);
+  });
+});
diff --git a/packages/desktop/tests/units/workspace-menu.test.ts b/packages/desktop/tests/units/workspace-menu.test.ts
index 23dae14a..ae173ed1 100644
--- a/packages/desktop/tests/units/workspace-menu.test.ts
+++ b/packages/desktop/tests/units/workspace-menu.test.ts
@@ -3,10 +3,10 @@ import { describe, expect, it } from 'vitest';
 
 describe('workspace menu', () => {
   it('does not select the current workspace', () => {
-    expect(canSelectWorkspace('/Users/studio/project', '/Users/studio/project')).toBe(false);
+    expect(canSelectWorkspace('/Users/example/project', '/Users/example/project')).toBe(false);
   });
 
   it('selects a different workspace', () => {
-    expect(canSelectWorkspace('/Users/studio/other', '/Users/studio/project')).toBe(true);
+    expect(canSelectWorkspace('/Users/example/other', '/Users/example/project')).toBe(true);
   });
 });
diff --git a/packages/desktop/tests/units/workspace/worktree.test.ts b/packages/desktop/tests/units/workspace/worktree.test.ts
index 56c626c2..e965d95e 100644
--- a/packages/desktop/tests/units/workspace/worktree.test.ts
+++ b/packages/desktop/tests/units/workspace/worktree.test.ts
@@ -1,5 +1,6 @@
 import {
   isManagedWorktree,
+  managedWorktreeRepoFolder,
   managedWorktreeRoot,
   repoFolderName,
   repoKey,
@@ -53,6 +54,17 @@ describe('worktreePathFor', () => {
   });
 });
 
+describe('managedWorktreeRepoFolder', () => {
+  it('returns the repository folder encoded in a managed worktree path', () => {
+    const path = worktreePathFor('/data', '/a/repo', 'feature');
+    expect(managedWorktreeRepoFolder('/data', path)).toBe(repoFolderName('/a/repo'));
+  });
+
+  it('rejects paths outside the managed root', () => {
+    expect(managedWorktreeRepoFolder('/data', '/somewhere/else')).toBe('');
+  });
+});
+
 describe('isManagedWorktree', () => {
   it('accepts paths inside the managed root', () => {
     expect(isManagedWorktree('/data', worktreePathFor('/data', '/a/repo', 'feature'))).toBe(true);
diff --git a/packages/web/package.json b/packages/web/package.json
index 488c1eac..28f8e866 100644
--- a/packages/web/package.json
+++ b/packages/web/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@start/web",
   "private": true,
-  "version": "0.1.0-alpha.34",
+  "version": "0.1.0-alpha.35",
   "license": "MIT",
   "description": "your coding assistant",
   "type": "module",