diff --git a/packages/ui/src/apps/MobileSessionsSheet.tsx b/packages/ui/src/apps/MobileSessionsSheet.tsx
index c10b4540..a2fe76e3 100644
--- a/packages/ui/src/apps/MobileSessionsSheet.tsx
+++ b/packages/ui/src/apps/MobileSessionsSheet.tsx
@@ -362,6 +362,15 @@ const SessionRenameForm: React.FC<{
   const { t } = useI18n();
   const [value, setValue] = React.useState(initialTitle);
 
+  // Opens with the whole title selected, so the first keystroke replaces it.
+  // Stable ref callback: an inline one would re-run on every render and
+  // re-select the text mid-edit.
+  const focusRenameInput = React.useCallback((node: HTMLInputElement | null) => {
+    if (!node) return;
+    node.focus();
+    node.select();
+  }, []);
+
   const commit = () => {
     const next = value.trim();
     if (!next || next === initialTitle.trim()) {
@@ -385,7 +394,7 @@ const SessionRenameForm: React.FC<{
       }}
     >
       <input
-        autoFocus
+        ref={focusRenameInput}
         value={value}
         onChange={(event) => setValue(event.target.value)}
         onKeyDown={(event) => {
diff --git a/packages/ui/src/components/chat/ModelControls.tsx b/packages/ui/src/components/chat/ModelControls.tsx
index d09b0004..697d0e7f 100644
--- a/packages/ui/src/components/chat/ModelControls.tsx
+++ b/packages/ui/src/components/chat/ModelControls.tsx
@@ -326,7 +326,13 @@ export const ModelControls: React.FC<ModelControlsProps> = ({
     const currentModelId = useConfigStore((state) => state.currentModelId);
     const effectiveCurrentVariant = useConfigStore((state) => state.currentVariant);
     const currentVariantSelection = useConfigStore((state) => state.currentVariantSelection);
-    const currentVariant = currentVariantSelection.override ?? undefined;
+    // What the picker shows is what the next send carries: an explicit choice
+    // when there is one, "Default" when "Default" was picked, and otherwise the
+    // inherited effort — showing "Default" while an inherited effort is in
+    // force is how a switch away from it looks like it did not stick.
+    const currentVariant = currentVariantSelection.override === null
+        ? undefined
+        : currentVariantSelection.override ?? effectiveCurrentVariant;
     const currentAgentName = useConfigStore((state) => state.currentAgentName);
     const settingsDefaultVariant = useConfigStore((state) => state.settingsDefaultVariant);
     const settingsDefaultAgent = useConfigStore((state) => state.settingsDefaultAgent);
@@ -719,7 +725,14 @@ export const ModelControls: React.FC<ModelControlsProps> = ({
         return candidates.find((candidate) => candidate !== undefined && variantOptions.includes(candidate));
     }, [agents, currentAgentName, currentModelId, currentProviderId, currentSessionId, currentVariantSelection, effectiveCurrentVariant, getModelVariantOptions, settingsDefaultVariant, uiAgentName]);
 
-    const resolveModelVariantSelection = React.useCallback((providerId: string, modelId: string) => {
+    /**
+     * The session's recorded choice for this model, in the selection store's
+     * three states: an effort name, `null` for an explicit "Default", and
+     * `undefined` for no choice at all. Collapsing `null` into `undefined` here
+     * would hand a real "Default" back to the callers as "nothing chosen", and
+     * they would re-record it as a choice on the next write.
+     */
+    const resolveModelVariantSelection = React.useCallback((providerId: string, modelId: string): string | null | undefined => {
         const variantOptions = getModelVariantOptions(providerId, modelId);
         if (variantOptions.length === 0) {
             return undefined;
@@ -728,6 +741,10 @@ export const ModelControls: React.FC<ModelControlsProps> = ({
         const effectiveAgentName = uiAgentName || currentAgentName;
         if (currentSessionId && effectiveAgentName) {
             const savedVariant = getAgentModelVariantForSession(currentSessionId, effectiveAgentName, providerId, modelId);
+            // An explicit "Default" is a choice: it stops the fallbacks below.
+            if (savedVariant === null) {
+                return null;
+            }
             if (savedVariant && variantOptions.includes(savedVariant)) {
                 return savedVariant;
             }
@@ -760,7 +777,16 @@ export const ModelControls: React.FC<ModelControlsProps> = ({
         return liveConfigAgentName || currentAgentName;
     }, [currentAgentName, currentSessionId]);
 
-    const commitVariantSelectionForModel = React.useCallback((providerId: string, modelId: string, variant: string | undefined, agentNameOverride?: string | null) => {
+    /**
+     * Records `variant` as this session's effort for the model, in the same
+     * three states the selection store defines: an effort name, `null` for an
+     * explicit "Default", `undefined` for no choice so the inherited effort
+     * applies. Callers decide which one they mean — the picker turns its own
+     * "Default" into `null`, while restore paths pass `undefined` through when
+     * they found nothing, because "the history carries no effort" is not the
+     * user having chosen "Default".
+     */
+    const commitVariantSelectionForModel = React.useCallback((providerId: string, modelId: string, variant: string | null | undefined, agentNameOverride?: string | null) => {
         const variantOptions = getModelVariantOptions(providerId, modelId);
         if (variantOptions.length === 0) {
             manualVariantSelectionRef.current = false;
@@ -770,10 +796,10 @@ export const ModelControls: React.FC<ModelControlsProps> = ({
 
         manualVariantSelectionRef.current = true;
         setCurrentVariantOverride(
-            variant ?? null,
+            variant,
             resolveInheritedVariantForModel(providerId, modelId, agentNameOverride),
         );
-        addRecentEffort(providerId, modelId, variant);
+        addRecentEffort(providerId, modelId, variant ?? undefined);
 
         const effectiveAgentName = agentNameOverride ?? resolveLiveAgentName();
         if (currentSessionId && effectiveAgentName) {
@@ -790,7 +816,7 @@ export const ModelControls: React.FC<ModelControlsProps> = ({
         setCurrentVariantOverride,
     ]);
 
-    const applyModelSelectionWithVariant = React.useCallback((providerId: string, modelId: string, variant: string | undefined, agentNameOverride?: string | null) => {
+    const applyModelSelectionWithVariant = React.useCallback((providerId: string, modelId: string, variant: string | null | undefined, agentNameOverride?: string | null) => {
         const effectiveAgentName = agentNameOverride ?? resolveLiveAgentName() ?? undefined;
         const result = tryApplyModelSelection(providerId, modelId, effectiveAgentName);
         if (result !== 'applied') {
@@ -852,25 +878,34 @@ export const ModelControls: React.FC<ModelControlsProps> = ({
             && getModelVariantOptions(latestLoadedUserChoice.providerID, latestLoadedUserChoice.modelID).includes(latestLoadedUserChoice.variant)
             ? latestLoadedUserChoice.variant
             : undefined;
+        const restoreAgentName = latestLoadedUserChoice.agent || currentAgentName || undefined;
+        // A message carrying no effort is not evidence that the user has none:
+        // a send under an explicit "Default" carries none either, and the echo
+        // of that very send arrives here. Keep what the session already
+        // recorded, and let a concrete historical effort replace it.
+        const restoredVariant = historicalVariant ?? (currentSessionId && restoreAgentName
+            ? getAgentModelVariantForSession(
+                currentSessionId,
+                restoreAgentName,
+                latestLoadedUserChoice.providerID,
+                latestLoadedUserChoice.modelID,
+            )
+            : undefined);
         const applyResult = applyModelSelectionWithVariant(
             latestLoadedUserChoice.providerID,
             latestLoadedUserChoice.modelID,
-            historicalVariant,
-            latestLoadedUserChoice.agent || currentAgentName || undefined,
+            restoredVariant,
+            restoreAgentName,
         );
         if (applyResult !== 'applied') {
             return;
         }
 
+        // The effort is not written again here: `applyModelSelectionWithVariant`
+        // above already recorded `historicalVariant` for this same agent and
+        // model, and a second write can only disagree with the first.
         if (latestLoadedUserChoice.agent) {
             saveSessionAgentSelection(currentSessionId, latestLoadedUserChoice.agent);
-            saveAgentModelVariantForSession(
-                currentSessionId,
-                latestLoadedUserChoice.agent,
-                latestLoadedUserChoice.providerID,
-                latestLoadedUserChoice.modelID,
-                historicalVariant,
-            );
         }
         saveSessionModelSelection(currentSessionId, latestLoadedUserChoice.providerID, latestLoadedUserChoice.modelID);
         latestLoadedUserChoiceRestoreRef.current = restoreKey;
@@ -884,11 +919,11 @@ export const ModelControls: React.FC<ModelControlsProps> = ({
         latestLoadedUserChoice,
         setAgent,
         applyModelSelectionWithVariant,
+        getAgentModelVariantForSession,
         getModelVariantOptions,
         getSessionModelSelection,
         resolveModelVariantSelection,
         saveSessionAgentSelection,
-        saveAgentModelVariantForSession,
         saveSessionModelSelection,
     ]);
 
@@ -1113,11 +1148,10 @@ export const ModelControls: React.FC<ModelControlsProps> = ({
             return;
         }
 
+        // The chosen effort does not exist on this model: drop the choice and
+        // inherit, rather than pin an explicit "Default" the user never picked.
         if (currentVariant && !availableVariants.includes(currentVariant)) {
-            setCurrentVariantOverride(
-                null,
-                resolveInheritedVariantForModel(currentProviderId, currentModelId),
-            );
+            setCurrentVariant(resolveInheritedVariantForModel(currentProviderId, currentModelId));
             return;
         }
 
@@ -1143,7 +1177,8 @@ export const ModelControls: React.FC<ModelControlsProps> = ({
         const inheritedVariant = resolveInheritedVariantForModel(currentProviderId, currentModelId);
         if (savedVariant && availableVariants.includes(savedVariant)) {
             setCurrentVariantOverride(savedVariant, inheritedVariant);
-        } else if (currentVariantSelection.override === null) {
+        } else if (savedVariant === null || currentVariantSelection.override === null) {
+            // "Default" was picked for this session, or is picked right now.
             setCurrentVariantOverride(null, inheritedVariant);
         } else {
             setCurrentVariant(inheritedVariant);
@@ -1172,7 +1207,9 @@ export const ModelControls: React.FC<ModelControlsProps> = ({
 
     const handleVariantSelect = React.useCallback((variant: string | undefined) => {
         if (currentProviderId && currentModelId) {
-            commitVariantSelectionForModel(currentProviderId, currentModelId, variant);
+            // Picked in the effort menu, so no effort means the user picked
+            // "Default" — a choice, recorded as `null`.
+            commitVariantSelectionForModel(currentProviderId, currentModelId, variant ?? null);
         }
     }, [commitVariantSelectionForModel, currentModelId, currentProviderId]);
 
@@ -1234,8 +1271,10 @@ export const ModelControls: React.FC<ModelControlsProps> = ({
     ) => {
         try {
             const effectiveAgentName = options?.agentName ?? resolveLiveAgentName() ?? undefined;
+            // `applyVariant` is only set when the user adjusted the effort in
+            // the model picker, so no effort means an explicit "Default".
             const result = options?.applyVariant
-                ? applyModelSelectionWithVariant(providerId, modelId, options.variant, effectiveAgentName)
+                ? applyModelSelectionWithVariant(providerId, modelId, options.variant ?? null, effectiveAgentName)
                 : tryApplyModelSelection(providerId, modelId, effectiveAgentName);
             if (result !== 'applied') {
                 if (result === 'provider-missing') {
@@ -1592,8 +1631,10 @@ export const ModelControls: React.FC<ModelControlsProps> = ({
             }
         }
 
-        const handleMobileModelApply = (providerId: string, modelId: string, variant: string | undefined) => {
-            const result = applyModelSelectionWithVariant(providerId, modelId, variant);
+        const handleMobileModelApply = (providerId: string, modelId: string, variant: string | null | undefined) => {
+            // Chosen in the mobile model sheet, and the row already showed this
+            // effort: no effort there means the user is applying "Default".
+            const result = applyModelSelectionWithVariant(providerId, modelId, variant ?? null);
             if (result !== 'applied') {
                 if (result === 'provider-missing') {
                     console.error('[ModelControls] Provider not available for selection:', providerId);
@@ -1630,7 +1671,8 @@ export const ModelControls: React.FC<ModelControlsProps> = ({
             const variantOptions = getModelVariantOptions(providerId, modelId);
             const hasVariants = variantOptions.length > 0;
             const resolvedVariant = resolveModelVariantSelection(providerId, modelId);
-            const variantLabel = hasVariants ? formatEffortLabel(resolvedVariant) : null;
+            // Both an explicit "Default" and no choice at all read as "Default".
+            const variantLabel = hasVariants ? formatEffortLabel(resolvedVariant ?? undefined) : null;
             const isExpanded = expandedMobileModelKey === rowKey;
             const inlineVariantOptions = [undefined, ...variantOptions].slice(0, MAX_INLINE_MOBILE_VARIANT_OPTIONS);
             const hasVariantOverflow = inlineVariantOptions.length < variantOptions.length + 1;
@@ -1935,7 +1977,8 @@ export const ModelControls: React.FC<ModelControlsProps> = ({
         };
 
         const handleSelect = (variant: string | undefined) => {
-            const result = applyModelSelectionWithVariant(targetProviderId, targetModelId, variant);
+            // Chosen in the mobile effort panel: no effort means "Default".
+            const result = applyModelSelectionWithVariant(targetProviderId, targetModelId, variant ?? null);
             if (result !== 'applied') {
                 return;
             }
diff --git a/packages/ui/src/components/chat/ModelControls.variant.behavior.test.tsx b/packages/ui/src/components/chat/ModelControls.variant.behavior.test.tsx
new file mode 100644
index 00000000..a9fec6dd
--- /dev/null
+++ b/packages/ui/src/components/chat/ModelControls.variant.behavior.test.tsx
@@ -0,0 +1,406 @@
+import React, { act } from 'react';
+import { beforeEach, describe, expect, mock, test } from 'bun:test';
+import { createRoot } from 'react-dom/client';
+import { Window } from 'happy-dom';
+import { create } from 'zustand';
+
+/**
+ * Restoring a session must not invent an effort choice.
+ *
+ * The selection store keeps three states for a session's effort: an effort
+ * name, `null` for an explicit "Default", and `undefined` for no choice at all.
+ * Only the picker may write `null`. When a restore path writes it instead, the
+ * session latches onto "Default" — `null` outranks the agent and settings
+ * defaults by design — and the concrete effort the session's own history
+ * carries can never come back. These tests pin who writes what.
+ */
+
+type VariantChoice = string | null | undefined;
+
+type UserModelChoice = {
+  id: string;
+  agent?: string;
+  providerID: string;
+  modelID: string;
+  variant?: string;
+};
+
+const PROVIDER_ID = 'openai';
+const MODEL_ID = 'gpt-5.5';
+const AGENT = 'build';
+const SESSION_ID = 'ses_restore';
+
+const model = {
+  id: MODEL_ID,
+  name: MODEL_ID,
+  providerID: PROVIDER_ID,
+  variants: { low: {}, high: {} },
+};
+const provider = { id: PROVIDER_ID, name: PROVIDER_ID, models: [model] };
+const agent = { name: AGENT, mode: 'primary' as const };
+
+let latestUserChoice: UserModelChoice | null = null;
+let forcePreserveManualOverride: boolean | null = null;
+
+/** Every effort written for the session, in order, including `undefined`. */
+const variantWrites: VariantChoice[] = [];
+/** Every `(override, inherited)` pair pushed into the config store. */
+const overrideWrites: Array<{ override: VariantChoice; inherited: string | undefined }> = [];
+
+type ConfigState = {
+  providers: typeof provider[];
+  agents: typeof agent[];
+  modelsMetadata: Record<string, never>;
+  currentProviderId: string;
+  currentModelId: string;
+  currentVariant: string | undefined;
+  currentVariantSelection: { override: VariantChoice; inherited: string | undefined };
+  currentAgentName: string | undefined;
+  settingsDefaultVariant: string | undefined;
+  settingsDefaultAgent: string | undefined;
+  selectionSource: 'auto' | 'manual';
+  setProvider: (providerId: string) => void;
+  setSelectedProvider: (providerId: string) => void;
+  setModel: (modelId: string) => void;
+  setAgent: (agentName: string) => void;
+  setCurrentVariant: (variant: string | undefined) => void;
+  setCurrentVariantOverride: (override: VariantChoice, inherited: string | undefined) => void;
+  getCurrentProvider: () => typeof provider;
+  getCurrentAgent: () => typeof agent;
+  getVisibleAgents: () => typeof agent[];
+  getCurrentModelVariants: () => string[];
+  getModelMetadata: () => undefined;
+};
+
+const useConfigStore = create<ConfigState>((set) => ({
+  providers: [provider],
+  agents: [agent],
+  modelsMetadata: {},
+  currentProviderId: PROVIDER_ID,
+  currentModelId: MODEL_ID,
+  currentVariant: undefined,
+  currentVariantSelection: { override: undefined, inherited: undefined },
+  currentAgentName: AGENT,
+  settingsDefaultVariant: undefined,
+  settingsDefaultAgent: undefined,
+  selectionSource: 'auto',
+  setProvider: (providerId) => set({ currentProviderId: providerId }),
+  setSelectedProvider: () => undefined,
+  setModel: (modelId) => set({ currentModelId: modelId }),
+  setAgent: (agentName) => set({ currentAgentName: agentName }),
+  // Mirrors the real store, including its no-op guard: without that guard an
+  // unchanged write returns a fresh state object every render and the
+  // component's variant effects never settle.
+  setCurrentVariant: (variant) => {
+    useConfigStore.getState().setCurrentVariantOverride(undefined, variant);
+  },
+  setCurrentVariantOverride: (override, inherited) => {
+    set((state) => {
+      const currentVariant = override === null ? undefined : override ?? inherited;
+      if (
+        state.currentVariant === currentVariant
+        && state.currentVariantSelection.override === override
+        && state.currentVariantSelection.inherited === inherited
+      ) {
+        return state;
+      }
+      overrideWrites.push({ override, inherited });
+      return { currentVariant, currentVariantSelection: { override, inherited } };
+    });
+  },
+  getCurrentProvider: () => provider,
+  getCurrentAgent: () => agent,
+  getVisibleAgents: () => [agent],
+  getCurrentModelVariants: () => Object.keys(model.variants),
+  getModelMetadata: () => undefined,
+}));
+
+type SelectionState = {
+  savedVariant: VariantChoice;
+  sessionAgentSelections: Map<string, string>;
+  getSessionModelSelection: () => { providerId: string; modelId: string } | null;
+  getSessionAgentSelection: () => string | null;
+  getAgentModelForSession: () => { providerId: string; modelId: string } | null;
+  getAgentModelVariantForSession: () => VariantChoice;
+  saveSessionModelSelection: () => void;
+  saveSessionAgentSelection: () => void;
+  saveAgentModelForSession: () => void;
+  saveAgentModelVariantForSession: (
+    sessionId: string,
+    agentName: string,
+    providerId: string,
+    modelId: string,
+    variant: VariantChoice,
+  ) => void;
+};
+
+const useSelectionStore = create<SelectionState>((set, get) => ({
+  savedVariant: undefined,
+  sessionAgentSelections: new Map([[SESSION_ID, AGENT]]),
+  getSessionModelSelection: () => ({ providerId: PROVIDER_ID, modelId: MODEL_ID }),
+  getSessionAgentSelection: () => AGENT,
+  getAgentModelForSession: () => ({ providerId: PROVIDER_ID, modelId: MODEL_ID }),
+  getAgentModelVariantForSession: () => get().savedVariant,
+  saveSessionModelSelection: () => undefined,
+  saveSessionAgentSelection: () => undefined,
+  saveAgentModelForSession: () => undefined,
+  saveAgentModelVariantForSession: (_sessionId, _agentName, _providerId, _modelId, variant) => {
+    variantWrites.push(variant);
+    set({ savedVariant: variant });
+  },
+}));
+
+const useSessionUIStore = create(() => ({
+  currentSessionId: SESSION_ID,
+  getDirectoryForSession: () => '/workspace/project',
+}));
+
+const useUIStore = create(() => ({
+  isMobile: false,
+  isModelSelectorOpen: false,
+  hiddenModels: [],
+  providerOrder: [],
+  shortcutOverrides: {},
+  isFavoriteModel: () => false,
+  toggleFavoriteModel: () => undefined,
+  reorderFavoriteModel: () => undefined,
+  setProviderOrder: () => undefined,
+  setModelSelectorOpen: () => undefined,
+  setSettingsDialogOpen: () => undefined,
+  setSettingsPage: () => undefined,
+  addRecentAgent: () => undefined,
+  addRecentModel: () => undefined,
+  addRecentEffort: () => undefined,
+}));
+
+const passthrough = ({ children }: React.PropsWithChildren) => <div>{children}</div>;
+
+// Captured by value before the module is replaced: reading it back off the
+// namespace afterwards would resolve to the replacement and recurse.
+const { shouldPreserveManualModelOverride: realShouldPreserveManualModelOverride } =
+  await import('@/lib/messages/userModelChoice');
+
+mock.module('@/lib/messages/userModelChoice', () => ({
+  findLatestUserModelChoice: () => latestUserChoice,
+  // The real guard, unless a test opts out: whether it fires decides which
+  // restore branch runs, and the branch that erased a recorded Default is the
+  // one it declines to protect.
+  shouldPreserveManualModelOverride: (args: Parameters<typeof realShouldPreserveManualModelOverride>[0]) => (
+    forcePreserveManualOverride ?? realShouldPreserveManualModelOverride(args)
+  ),
+}));
+
+mock.module('@/stores/useConfigStore', () => ({ useConfigStore }));
+mock.module('@/sync/selection-store', () => ({ useSelectionStore }));
+mock.module('@/sync/session-ui-store', () => ({ useSessionUIStore }));
+mock.module('@/stores/useUIStore', () => ({ useUIStore }));
+mock.module('@/stores/contextStore', () => ({
+  useContextStore: <T,>(selector: (state: { hasHydrated: boolean }) => T): T => selector({ hasHydrated: true }),
+}));
+
+mock.module('@/sync/sync-context', () => ({
+  useSessionMessages: () => [],
+  useSessionRenderable: () => true,
+}));
+mock.module('@/sync/use-sync', () => ({ useSync: () => ({ sessions: [] }) }));
+mock.module('@/sync/sync-refs', () => ({ getSyncParts: () => [] }));
+
+mock.module('@/components/ui/dropdown-menu', () => ({
+  DropdownMenu: passthrough,
+  DropdownMenuContent: passthrough,
+  DropdownMenuItem: passthrough,
+  DropdownMenuLabel: passthrough,
+  DropdownMenuSeparator: () => null,
+  DropdownMenuTrigger: passthrough,
+}));
+mock.module('@/components/ui/input', () => ({
+  Input: (props: React.InputHTMLAttributes<HTMLInputElement>) => <input {...props} />,
+}));
+mock.module('@/components/ui/MobileOverlayPanel', () => ({ MobileOverlayPanel: passthrough }));
+mock.module('@/components/ui/ProviderLogo', () => ({ ProviderLogo: () => null }));
+mock.module('@/components/ui/ScrollableOverlay', () => ({ ScrollableOverlay: passthrough }));
+mock.module('@/components/ui/tooltip', () => ({
+  Tooltip: passthrough,
+  TooltipContent: passthrough,
+  TooltipTrigger: passthrough,
+}));
+mock.module('@/components/icon/Icon', () => ({ Icon: () => null }));
+mock.module('@/components/model-picker/ModelPickerList', () => ({ ModelPickerList: () => null }));
+mock.module('@/hooks/useRuntimeAPIs', () => ({ useIsVSCodeRuntime: () => false }));
+mock.module('@/hooks/useModelLists', () => ({ useModelLists: () => ({ favoriteModels: [], recentModels: [] }) }));
+mock.module('@/hooks/useIsTextTruncated', () => ({ useIsTextTruncated: () => false }));
+mock.module('@/hooks/useOpenCodeReadiness', () => ({
+  useOpenCodeReadiness: () => ({ isReady: true, isUnavailable: false }),
+}));
+mock.module('@/lib/device', () => ({ useDeviceInfo: () => ({ isTouch: false }) }));
+mock.module('@/lib/desktop', () => ({ isDesktopShell: () => false }));
+mock.module('@/lib/startupTrace', () => ({ markStartupTrace: () => undefined }));
+
+const { ModelControls } = await import('./ModelControls');
+const { I18nProvider } = await import('@/lib/i18n');
+
+const DOM_GLOBAL_NAMES = [
+  'window',
+  'document',
+  'navigator',
+  'Node',
+  'Element',
+  'HTMLElement',
+  'HTMLIFrameElement',
+  'localStorage',
+  'requestAnimationFrame',
+  'cancelAnimationFrame',
+  'IS_REACT_ACT_ENVIRONMENT',
+] as const;
+
+const frameTimers = new Map<number, ReturnType<Window['setTimeout']>>();
+let nextFrameHandle = 1;
+
+const installDom = () => {
+  const happyWindow = new Window({ url: 'http://localhost' });
+  const previous = DOM_GLOBAL_NAMES.map(
+    (name) => [name, Object.getOwnPropertyDescriptor(globalThis, name)] as const,
+  );
+  const values = {
+    window: happyWindow,
+    document: happyWindow.document,
+    navigator: happyWindow.navigator,
+    Node: happyWindow.Node,
+    Element: happyWindow.Element,
+    HTMLElement: happyWindow.HTMLElement,
+    HTMLIFrameElement: happyWindow.HTMLIFrameElement,
+    localStorage: happyWindow.localStorage,
+    // The component focuses the composer through rAF on several paths.
+    requestAnimationFrame: (callback: FrameRequestCallback) => {
+      const handle = nextFrameHandle++;
+      frameTimers.set(handle, happyWindow.setTimeout(() => {
+        frameTimers.delete(handle);
+        callback(0);
+      }, 0));
+      return handle;
+    },
+    cancelAnimationFrame: (handle: number) => {
+      const timer = frameTimers.get(handle);
+      if (timer === undefined) return;
+      frameTimers.delete(handle);
+      happyWindow.clearTimeout(timer);
+    },
+    IS_REACT_ACT_ENVIRONMENT: true,
+  };
+  for (const name of DOM_GLOBAL_NAMES) {
+    Object.defineProperty(globalThis, name, { value: values[name], configurable: true, writable: true });
+  }
+
+  const container = document.createElement('div');
+  document.body.appendChild(container);
+  return {
+    container,
+    restore: () => {
+      for (const [name, descriptor] of previous) {
+        if (descriptor) Object.defineProperty(globalThis, name, descriptor);
+        else Reflect.deleteProperty(globalThis, name);
+      }
+    },
+  };
+};
+
+const renderModelControls = async () => {
+  const dom = installDom();
+  const root = createRoot(dom.container);
+  await act(async () => root.render(
+    <I18nProvider>
+      <ModelControls />
+    </I18nProvider>,
+  ));
+  return {
+    dom,
+    cleanup: async () => {
+      await act(async () => root.unmount());
+      dom.restore();
+    },
+  };
+};
+
+describe('ModelControls effort restore', () => {
+  beforeEach(() => {
+    variantWrites.length = 0;
+    overrideWrites.length = 0;
+    latestUserChoice = null;
+    forcePreserveManualOverride = null;
+    useSelectionStore.setState({ savedVariant: undefined });
+    useConfigStore.setState({
+      currentProviderId: PROVIDER_ID,
+      currentModelId: MODEL_ID,
+      currentAgentName: AGENT,
+      currentVariant: undefined,
+      currentVariantSelection: { override: undefined, inherited: undefined },
+      settingsDefaultVariant: undefined,
+      selectionSource: 'auto',
+    });
+  });
+
+  test('restores the concrete effort the session history carries', async () => {
+    latestUserChoice = { id: 'msg-1', agent: AGENT, providerID: PROVIDER_ID, modelID: MODEL_ID, variant: 'low' };
+
+    const { cleanup } = await renderModelControls();
+    try {
+      expect(variantWrites).toContain('low');
+      expect(variantWrites).not.toContain(null);
+      expect(useSelectionStore.getState().savedVariant).toBe('low');
+      expect(useConfigStore.getState().currentVariantSelection.override).toBe('low');
+    } finally {
+      await cleanup();
+    }
+  });
+
+  test('history without an effort records no choice instead of an explicit Default', async () => {
+    latestUserChoice = { id: 'msg-2', agent: AGENT, providerID: PROVIDER_ID, modelID: MODEL_ID };
+
+    const { cleanup } = await renderModelControls();
+    try {
+      expect(variantWrites).not.toContain(null);
+      expect(useSelectionStore.getState().savedVariant).toBe(undefined);
+      expect(useConfigStore.getState().currentVariantSelection.override).toBe(undefined);
+    } finally {
+      await cleanup();
+    }
+  });
+
+  test('the echo of a Default send does not erase the recorded Default', async () => {
+    // The reported repro. The send under "Default" carried no effort, so the
+    // message it echoes back carries none either, and its model matches the one
+    // the send saved — which is exactly when the manual-override guard declines
+    // to protect the selection and the history branch runs.
+    latestUserChoice = { id: 'msg-echo', agent: AGENT, providerID: PROVIDER_ID, modelID: MODEL_ID };
+    useSelectionStore.setState({ savedVariant: null });
+    useConfigStore.setState({
+      selectionSource: 'manual',
+      settingsDefaultVariant: 'low',
+      currentVariantSelection: { override: null, inherited: 'low' },
+    });
+
+    const { cleanup } = await renderModelControls();
+    try {
+      expect(useSelectionStore.getState().savedVariant).toBeNull();
+      expect(useConfigStore.getState().currentVariantSelection.override).toBeNull();
+      expect(useConfigStore.getState().currentVariant).toBe(undefined);
+    } finally {
+      await cleanup();
+    }
+  });
+
+  test('a preserved manual override keeps a recorded explicit Default', async () => {
+    latestUserChoice = { id: 'msg-3', agent: AGENT, providerID: PROVIDER_ID, modelID: MODEL_ID, variant: 'high' };
+    forcePreserveManualOverride = true;
+    useSelectionStore.setState({ savedVariant: null });
+    useConfigStore.setState({ selectionSource: 'manual' });
+
+    const { cleanup } = await renderModelControls();
+    try {
+      expect(useSelectionStore.getState().savedVariant).toBeNull();
+      expect(useConfigStore.getState().currentVariantSelection.override).toBeNull();
+    } finally {
+      await cleanup();
+    }
+  });
+});
diff --git a/packages/ui/src/components/chat/composer/state/useDraftTarget.ts b/packages/ui/src/components/chat/composer/state/useDraftTarget.ts
index cd774c29..e4c2b916 100644
--- a/packages/ui/src/components/chat/composer/state/useDraftTarget.ts
+++ b/packages/ui/src/components/chat/composer/state/useDraftTarget.ts
@@ -17,6 +17,7 @@
 import React from 'react';
 
 import { useRuntimeAPIs } from '@/hooks/useRuntimeAPIs';
+import { useWorktreeBootstrapPending } from '@/hooks/useWorktreeBootstrapPending';
 import { formatDirectoryName } from '@/lib/utils';
 import { useGitBranches, useGitStore, useIsGitRepo } from '@/stores/useGitStore';
 import { useProjectsStore } from '@/stores/useProjectsStore';
@@ -191,6 +192,14 @@ export function useDraftTarget(enabled: boolean) {
         [newSessionDraft?.bootstrapPendingDirectory, newSessionDraft?.directoryOverride, selectedDraftProjectPath],
     );
 
+    // The draft's own pending flags clear once the directory exists, which is
+    // before setup commands and the initial git reset finish; the bootstrap
+    // state covers that remaining window (and creations the draft never knew
+    // about, such as the New Worktree dialog), so the probe never reads the
+    // transient bootstrap files as the branch being dirty.
+    const selectedDraftDirectoryBootstrapPending = useWorktreeBootstrapPending(selectedDraftDirectory);
+    const draftDirectoryNeedsFreshStatusRef = React.useRef<string | null>(null);
+
     React.useEffect(() => {
         if (
             !enabled
@@ -198,15 +207,26 @@ export function useDraftTarget(enabled: boolean) {
             || selectedDraftProject?.kind === 'chat'
             || newSessionDraft?.pendingWorktreeRequestId
             || newSessionDraft?.bootstrapPendingDirectory
+            || selectedDraftDirectoryBootstrapPending
         ) {
+            if (selectedDraftDirectoryBootstrapPending && selectedDraftDirectory) {
+                draftDirectoryNeedsFreshStatusRef.current = selectedDraftDirectory;
+            }
             setDirtyDraftDirectory(null);
             return;
         }
 
         let cancelled = false;
         setDirtyDraftDirectory(null);
-        getGitStatus(selectedDraftDirectory, { mode: 'light' })
+        const needsFreshStatus = draftDirectoryNeedsFreshStatusRef.current === selectedDraftDirectory;
+        const statusRequest = needsFreshStatus
+            ? getGitStatus(selectedDraftDirectory, { mode: 'light', fresh: true })
+            : getGitStatus(selectedDraftDirectory, { mode: 'light' });
+        statusRequest
             .then((status) => {
+                if (!cancelled && needsFreshStatus && draftDirectoryNeedsFreshStatusRef.current === selectedDraftDirectory) {
+                    draftDirectoryNeedsFreshStatusRef.current = null;
+                }
                 if (!cancelled && (status.files?.length ?? 0) > 0) {
                     setDirtyDraftDirectory(selectedDraftDirectory);
                 }
@@ -218,7 +238,7 @@ export function useDraftTarget(enabled: boolean) {
         return () => {
             cancelled = true;
         };
-    }, [enabled, newSessionDraft?.bootstrapPendingDirectory, newSessionDraft?.pendingWorktreeRequestId, selectedDraftDirectory, selectedDraftProject?.kind]);
+    }, [enabled, newSessionDraft?.bootstrapPendingDirectory, newSessionDraft?.pendingWorktreeRequestId, selectedDraftDirectory, selectedDraftDirectoryBootstrapPending, selectedDraftProject?.kind]);
 
     const shouldKeepMissingSelectedDraftDirectory = React.useMemo(() => {
         const pendingDirectory = normalizePath(newSessionDraft?.bootstrapPendingDirectory ?? null);
diff --git a/packages/ui/src/components/chat/message/MessageBody.tsx b/packages/ui/src/components/chat/message/MessageBody.tsx
index b7f69f5e..3d066526 100644
--- a/packages/ui/src/components/chat/message/MessageBody.tsx
+++ b/packages/ui/src/components/chat/message/MessageBody.tsx
@@ -56,6 +56,7 @@ import { isEmbeddedSessionChat } from '@/components/layout/contextPanelEmbeddedC
 import { useProviderLogo } from '@/hooks/useProviderLogo';
 import { getAgentColor } from '@/lib/agentColors';
 import { isCapacitorMobileApp } from '@/apps/mobileNativeChrome';
+import { WorktreeRequiresGitRepositoryError } from '@/lib/worktrees/worktreeCreate';
 
 
 const CONTAIN_LAYOUT_STYLE = { contain: 'layout' as const, transform: 'translateZ(0)' };
@@ -1331,17 +1332,14 @@ const AssistantMessageBody = React.memo(({
     const effectiveStreamPhase: StreamPhase = hasStopFinish ? 'completed' : streamPhase;
 
     const availableWorktreesByProject = useSessionUIStore((state) => state.availableWorktreesByProject);
-    const currentProjectRef = React.useMemo(() => {
-        if (!canUseProjectPlanActions) {
-            return null;
-        }
-
+    const sessionProjectRef = React.useMemo(() => {
         const directory = effectiveDirectory
             ?? (currentSessionId ? getDirectoryForSession(currentSessionId) : null)
             ?? '';
         const resolved = resolveProjectForSessionDirectory(projects, availableWorktreesByProject, directory);
         return resolved ? { id: resolved.id, path: resolved.path } : null;
-    }, [availableWorktreesByProject, canUseProjectPlanActions, currentSessionId, effectiveDirectory, getDirectoryForSession, projects]);
+    }, [availableWorktreesByProject, currentSessionId, effectiveDirectory, getDirectoryForSession, projects]);
+    const currentProjectRef = canUseProjectPlanActions ? sessionProjectRef : null;
 
     const isActiveTool = React.useCallback((toolPart: ToolPartType): boolean => {
         const state = (toolPart as Record<string, unknown>).state as Record<string, unknown> | undefined ?? {};
@@ -1377,28 +1375,48 @@ const AssistantMessageBody = React.memo(({
         (event: React.MouseEvent<HTMLButtonElement>) => {
             event.stopPropagation();
             event.preventDefault();
-            if (!createSessionFromAssistantMessage || !assistantPlanText.trim()) {
+            if (!assistantPlanText.trim()) {
                 return;
             }
             setIsForkDialogOpen(true);
         },
-        [createSessionFromAssistantMessage, assistantPlanText]
+        [assistantPlanText]
     );
 
     const handleConfirmFork = React.useCallback(
         async (execution: ForkSessionExecution) => {
-            if (!createSessionFromAssistantMessage) {
-                return;
-            }
             setIsForkSubmitting(true);
             try {
-                await createSessionFromAssistantMessage(messageId, execution);
+                if (!sessionId) {
+                    throw new Error('Source session is unavailable');
+                }
+                const sourceDirectory = effectiveDirectory ?? getDirectoryForSession(sessionId);
+                if (!sourceDirectory) {
+                    throw new Error('Source session directory is unavailable');
+                }
+                await createSessionFromAssistantMessage({
+                    sessionId,
+                    directory: sourceDirectory,
+                    text: assistantPlanText,
+                }, execution);
                 setIsForkDialogOpen(false);
+            } catch (error) {
+                console.error('Failed to start a session from an assistant message:', error);
+                if (error instanceof WorktreeRequiresGitRepositoryError) {
+                    toast.error(t('rightSidebar.contextNotesTodo.toast.worktreeRequiresGitRepo'));
+                    return;
+                }
+
+                const description = error instanceof Error ? error.message : undefined;
+                toast.error(
+                    t('rightSidebar.contextNotesTodo.toast.createSessionFailed'),
+                    description ? { description } : undefined
+                );
             } finally {
                 setIsForkSubmitting(false);
             }
         },
-        [createSessionFromAssistantMessage, messageId]
+        [assistantPlanText, createSessionFromAssistantMessage, effectiveDirectory, getDirectoryForSession, sessionId, t]
     );
 
     const handleForkMultiRunClick = React.useCallback(
@@ -2136,6 +2154,8 @@ const AssistantMessageBody = React.memo(({
                      open={isForkDialogOpen}
                      onOpenChange={setIsForkDialogOpen}
                      projectDirectory={effectiveDirectory ?? null}
+                     sourceSessionId={sessionId ?? null}
+                     worktreeProjectDirectory={sessionProjectRef?.path ?? null}
                      submitting={isForkSubmitting}
                      onConfirm={handleConfirmFork}
                  />
diff --git a/packages/ui/src/components/chat/message/parts/ToolPart.tsx b/packages/ui/src/components/chat/message/parts/ToolPart.tsx
index adf49da3..29425e2e 100644
--- a/packages/ui/src/components/chat/message/parts/ToolPart.tsx
+++ b/packages/ui/src/components/chat/message/parts/ToolPart.tsx
@@ -14,7 +14,6 @@ import { useEffectiveDirectory } from '@/hooks/useEffectiveDirectory';
 import { useSessionUIStore } from '@/sync/session-ui-store';
 import { useSessionMessageRecords, useEnsureSessionMessages } from '@/sync/sync-context';
 import { useUIStore } from '@/stores/useUIStore';
-import { sessionEvents } from '@/lib/sessionEvents';
 import { ScrollShadow } from '@/components/ui/ScrollShadow';
 import { Button } from '@/components/ui/button';
 import { toast } from '@/components/ui';
@@ -57,7 +56,6 @@ import {
     extractFirstChangedLineFromDiff,
     getDiffPatchEntries,
     getFirstChangedLineFromMetadata,
-    getMutatedToolPaths,
     getPatchText,
     getPrimaryDiffFromMetadata,
     getPrimaryToolPath,
@@ -108,14 +106,6 @@ const normalizeToolName = (toolName: string | undefined | null): string => {
     return trimmed;
 };
 
-const GIT_REFRESH_MUTATING_TOOLS = new Set([
-    'bash',
-    'edit',
-    'write',
-    'apply_patch',
-    'patch',
-]);
-
 const formatDuration = (start: number, end?: number, now: number = Date.now()) => {
     const duration = Math.max(0, (end ?? now) - start);
     const seconds = duration / 1000;
@@ -1699,19 +1689,16 @@ const ToolPartContent: React.FC<ToolPartProps> = ({
 
     const status = state?.status as string | undefined;
     const isFinalized = status === 'completed' || status === 'error' || status === 'aborted' || status === 'failed' || status === 'timeout' || status === 'cancelled';
-    const isSuccessfullyFinalized = status === 'completed';
     const isError = status === 'error' || status === 'failed';
 
     const [activeLatched, setActiveLatched] = React.useState<boolean>(!isFinalized);
     const previousPartIdRef = React.useRef<string | undefined>(part.id);
-    const observedActiveGitToolRef = React.useRef(!isFinalized);
 
     React.useEffect(() => {
         if (previousPartIdRef.current === part.id) {
             return;
         }
         previousPartIdRef.current = part.id;
-        observedActiveGitToolRef.current = !isFinalized;
         // Reset latch only when tool identity changes.
         setActiveLatched(!isFinalized);
     }, [isFinalized, part.id]);
@@ -1722,36 +1709,6 @@ const ToolPartContent: React.FC<ToolPartProps> = ({
         }
     }, [isFinalized]);
 
-    React.useEffect(() => {
-        if (!isFinalized) {
-            observedActiveGitToolRef.current = true;
-            return;
-        }
-
-        // Historical completed tools can remount when the timeline changes.
-        // Refresh only for a tool whose active state this instance observed.
-        const finalizedAfterObservedActive = observedActiveGitToolRef.current;
-        if (!finalizedAfterObservedActive) {
-            return;
-        }
-
-        if (!isSuccessfullyFinalized || !GIT_REFRESH_MUTATING_TOOLS.has(normalizedPartTool)) {
-            observedActiveGitToolRef.current = false;
-            return;
-        }
-        if (!currentDirectory) {
-            return;
-        }
-
-        observedActiveGitToolRef.current = false;
-        const paths = getMutatedToolPaths(normalizedPartTool, input, metadata)
-            .map((path) => getRelativePath(path, currentDirectory));
-        sessionEvents.requestGitRefresh({
-            directory: currentDirectory,
-            ...(paths.length > 0 ? { paths } : {}),
-        });
-    }, [currentDirectory, input, isFinalized, isSuccessfullyFinalized, metadata, normalizedPartTool]);
-
     const expandedContentRef = React.useRef<HTMLDivElement>(null);
 
     React.useLayoutEffect(() => {
diff --git a/packages/ui/src/components/chat/message/parts/toolDiffUtils.test.ts b/packages/ui/src/components/chat/message/parts/toolDiffUtils.test.ts
index b40456c0..e0352fed 100644
--- a/packages/ui/src/components/chat/message/parts/toolDiffUtils.test.ts
+++ b/packages/ui/src/components/chat/message/parts/toolDiffUtils.test.ts
@@ -5,7 +5,6 @@ import {
     getApplyPatchFilePath,
     getDiffPatchEntries,
     getFirstChangedLineFromMetadata,
-    getMutatedToolPaths,
     getPrimaryDiffFromMetadata,
     getPrimaryToolPath,
     getRenderablePatchInfo,
@@ -57,28 +56,6 @@ describe('toolDiffUtils', () => {
         })).toBe('/workspace/project/src/second.ts');
     });
 
-    test('lists every apply_patch mutation path, including both sides of a move', () => {
-        expect(getMutatedToolPaths('apply_patch', undefined, {
-            files: [
-                { filePath: '/workspace/project/src/deleted.ts', type: 'delete' },
-                {
-                    filePath: '/workspace/project/src/old.ts',
-                    movePath: '/workspace/project/src/new.ts',
-                    type: 'move',
-                },
-            ],
-        })).toEqual([
-            '/workspace/project/src/deleted.ts',
-            '/workspace/project/src/new.ts',
-            '/workspace/project/src/old.ts',
-        ]);
-    });
-
-    test('does not invent paths for bash or task tools', () => {
-        expect(getMutatedToolPaths('bash', { command: 'date' }, undefined)).toEqual([]);
-        expect(getMutatedToolPaths('task', { description: 'inspect' }, undefined)).toEqual([]);
-    });
-
     test('selects the move patch and line from the same non-deleted file', () => {
         const deletedPatch = '@@ -3 +3 @@\n-old\n+deleted';
         const movedPatch = '@@ -42 +42 @@\n-before\n+after';
diff --git a/packages/ui/src/components/chat/message/parts/toolDiffUtils.ts b/packages/ui/src/components/chat/message/parts/toolDiffUtils.ts
index 0818130e..cfe1796e 100644
--- a/packages/ui/src/components/chat/message/parts/toolDiffUtils.ts
+++ b/packages/ui/src/components/chat/message/parts/toolDiffUtils.ts
@@ -200,29 +200,6 @@ export const getPrimaryToolPath = (
     return null;
 };
 
-export const getMutatedToolPaths = (
-    toolName: string,
-    input: Record<string, unknown> | undefined,
-    metadata: Record<string, unknown> | undefined,
-): string[] => {
-    if (toolName === 'apply_patch') {
-        const files = Array.isArray(metadata?.files) ? metadata.files : [];
-        const paths = new Set<string>();
-        for (const file of files) {
-            if (!isRecord(file)) continue;
-            const filePath = getApplyPatchFilePath(file);
-            if (filePath) paths.add(filePath);
-            if (file.type === 'move' && typeof file.filePath === 'string') {
-                paths.add(file.filePath);
-            }
-        }
-        return [...paths];
-    }
-
-    const primaryPath = getPrimaryToolPath(toolName, input, metadata);
-    return primaryPath ? [primaryPath] : [];
-};
-
 const supportsDiffMetadata = (toolName: string): boolean => (
     toolName === 'edit' || toolName === 'multiedit' || toolName === 'apply_patch'
 );
diff --git a/packages/ui/src/components/chat/work-status/DOCUMENTATION.md b/packages/ui/src/components/chat/work-status/DOCUMENTATION.md
index d96a6b6d..1c43a17f 100644
--- a/packages/ui/src/components/chat/work-status/DOCUMENTATION.md
+++ b/packages/ui/src/components/chat/work-status/DOCUMENTATION.md
@@ -179,6 +179,13 @@ including edits the user made by hand and excluding session edits that are
 already committed. If a session-authored count is ever needed, it has to come
 from aggregating message summaries, not from `Session.summary`.
 
+One exception: while the directory is a worktree whose creation has not
+finished (`useWorktreeBootstrapPending`), the working tree transiently holds
+bootstrap files that the initial git reset is about to remove. Those are not
+changes on the branch, so the panel neither fetches status nor renders the
+changed-files row until the bootstrap settles, then forces one status fetch so
+the row reflects the reset tree rather than a mid-creation snapshot.
+
 ## Section order
 
 Ordering is by durability, not category:
diff --git a/packages/ui/src/components/chat/work-status/WorkStatusPrimaryGroup.tsx b/packages/ui/src/components/chat/work-status/WorkStatusPrimaryGroup.tsx
index fc0cada6..412f1f3c 100644
--- a/packages/ui/src/components/chat/work-status/WorkStatusPrimaryGroup.tsx
+++ b/packages/ui/src/components/chat/work-status/WorkStatusPrimaryGroup.tsx
@@ -3,6 +3,7 @@ import { useI18n } from '@/lib/i18n';
 import { useGitStore } from '@/stores/useGitStore';
 import { useRuntimeAPIs } from '@/hooks/useRuntimeAPIs';
 import { useNestedGitDirectory } from '@/hooks/useNestedGitDirectory';
+import { useWorktreeBootstrapPending } from '@/hooks/useWorktreeBootstrapPending';
 import { runBackgroundNetworkTask } from '@/lib/background-network';
 import { useFreshestPrVisualSummaryForBranch } from '@/stores/useGitHubPrStatusStore';
 import { useSessionMessages } from '@/sync/sync-context';
@@ -67,12 +68,45 @@ export const WorkStatusPrimaryGroup: React.FC<Props> = ({ sessionId, directory,
     ),
   );
 
+  // A worktree that is still being created transiently looks dirty until its
+  // setup commands and initial git reset finish. Those files are not changes
+  // on the branch, so the changed-files readout stays hidden while the
+  // bootstrap runs — and stays hidden until one fresh status fetch completes
+  // afterwards, because the shared cache may still hold a snapshot captured
+  // mid-creation (refresh hints fire while setup commands touch files) and
+  // lifting the gate onto it would flash the transient state.
+  const worktreeCreationPending = useWorktreeBootstrapPending(gitDirectory);
+  const [postBootstrapRefreshDirectory, setPostBootstrapRefreshDirectory] = React.useState<string | null>(null);
+  const awaitingPostBootstrapStatus = postBootstrapRefreshDirectory !== null
+    && postBootstrapRefreshDirectory === gitDirectory;
+
   // Warm the shared git cache through the background-network gate so the panel
   // never competes with the chat's own bootstrap traffic for sockets.
   React.useEffect(() => {
     if (!showRepository || !gitDirectory || !git) return;
+    if (worktreeCreationPending) {
+      setPostBootstrapRefreshDirectory(gitDirectory);
+      return;
+    }
+    if (awaitingPostBootstrapStatus) {
+      let cancelled = false;
+      void runBackgroundNetworkTask(() => fetchStatus(gitDirectory, git, {
+        force: true,
+        silent: true,
+        throwOnError: true,
+      }))
+        .then(() => {
+          if (!cancelled) {
+            setPostBootstrapRefreshDirectory((current) => (current === gitDirectory ? null : current));
+          }
+        })
+        .catch(() => undefined);
+      return () => {
+        cancelled = true;
+      };
+    }
     void runBackgroundNetworkTask(() => ensureStatus(gitDirectory, git));
-  }, [gitDirectory, git, ensureStatus, showRepository]);
+  }, [gitDirectory, git, ensureStatus, fetchStatus, showRepository, worktreeCreationPending, awaitingPostBootstrapStatus]);
 
   // Own the live invalidation for the repository readout. The desktop
   // composer's changed-files row no longer renders, so this panel must not
@@ -175,6 +209,7 @@ export const WorkStatusPrimaryGroup: React.FC<Props> = ({ sessionId, directory,
   // event is reset to an empty array too, and carries real content only on
   // revert. Git status is the one authoritative, already-cached answer.
   const changed = React.useMemo(() => {
+    if (worktreeCreationPending || awaitingPostBootstrapStatus) return null;
     const files = gitStatus?.files ?? [];
     if (files.length === 0) return null;
     const stats = gitStatus?.diffStats;
@@ -187,7 +222,7 @@ export const WorkStatusPrimaryGroup: React.FC<Props> = ({ sessionId, directory,
       }
     }
     return { files: files.length, additions, deletions, hasStats: Boolean(stats) };
-  }, [gitStatus?.files, gitStatus?.diffStats]);
+  }, [gitStatus?.files, gitStatus?.diffStats, worktreeCreationPending, awaitingPostBootstrapStatus]);
 
   const attentionReason = gitStatus?.attentionReason
     ?? (gitStatus?.rebaseInProgress ? 'rebase' : null)
diff --git a/packages/ui/src/components/layout/Header.tsx b/packages/ui/src/components/layout/Header.tsx
index e89c2ec1..408f1236 100644
--- a/packages/ui/src/components/layout/Header.tsx
+++ b/packages/ui/src/components/layout/Header.tsx
@@ -783,6 +783,15 @@ export const Header: React.FC = () => {
   const beginHeaderSessionRenameRef = React.useRef(beginHeaderSessionRename);
   beginHeaderSessionRenameRef.current = beginHeaderSessionRename;
 
+  // The rename field opens with the whole title selected, so the first
+  // keystroke replaces it. Stable ref callback: an inline one would re-run on
+  // every render and re-select the text mid-edit.
+  const focusHeaderRenameInput = React.useCallback((node: HTMLInputElement | null) => {
+    if (!node) return;
+    node.focus();
+    node.select();
+  }, []);
+
   React.useEffect(() => {
     setIsHeaderSessionMenuOpen(false);
     setPendingHeaderRetentionAction(null);
@@ -1422,9 +1431,9 @@ export const Header: React.FC = () => {
                   }}
                 >
                   <input
+                    ref={focusHeaderRenameInput}
                     value={headerSessionTitleDraft}
                     onChange={(event) => setHeaderSessionTitleDraft(event.target.value)}
-                    autoFocus
                     onKeyDown={(event) => {
                       event.stopPropagation();
                       if (event.key === 'Escape') {
@@ -1579,9 +1588,9 @@ export const Header: React.FC = () => {
                   }}
                 >
                   <input
+                    ref={focusHeaderRenameInput}
                     value={headerSessionTitleDraft}
                     onChange={(event) => setHeaderSessionTitleDraft(event.target.value)}
-                    autoFocus
                     onKeyDown={(event) => {
                       event.stopPropagation();
                       if (event.key === 'Escape') {
diff --git a/packages/ui/src/components/session/ForkSessionDialog.tsx b/packages/ui/src/components/session/ForkSessionDialog.tsx
index b16ab0da..b15a4dab 100644
--- a/packages/ui/src/components/session/ForkSessionDialog.tsx
+++ b/packages/ui/src/components/session/ForkSessionDialog.tsx
@@ -17,6 +17,9 @@ import { isPrimaryMode } from '@/components/chat/mobileControlsUtils';
 import { EXECUTION_FORK_DEFAULT_INSTRUCTIONS, EXECUTION_FORK_GOAL_INSTRUCTIONS } from '@/lib/messages/executionMeta';
 import { useI18n } from '@/lib/i18n';
 import { isVSCodeRuntime } from '@/lib/desktop';
+import { useRuntimeAPIs } from '@/hooks/useRuntimeAPIs';
+import { useGitStore, useIsGitRepo } from '@/stores/useGitStore';
+import { useSessionUIStore } from '@/sync/session-ui-store';
 
 export type ForkSessionExecution = {
   providerID: string;
@@ -32,13 +35,22 @@ type ForkSessionDialogProps = {
   open: boolean;
   onOpenChange: (open: boolean) => void;
   projectDirectory: string | null;
+  sourceSessionId: string | null;
+  worktreeProjectDirectory: string | null;
   submitting?: boolean;
   onConfirm: (execution: ForkSessionExecution) => Promise<void> | void;
 };
 
 export function ForkSessionDialog(props: ForkSessionDialogProps) {
   const { t } = useI18n();
-  const { open, onOpenChange, projectDirectory, submitting = false, onConfirm } = props;
+  const { open, onOpenChange, projectDirectory, sourceSessionId, worktreeProjectDirectory, submitting = false, onConfirm } = props;
+  const metadataProjectDirectory = useSessionUIStore((state) => (
+    sourceSessionId ? state.worktreeMetadata.get(sourceSessionId)?.projectDirectory ?? null : null
+  ));
+  const resolvedWorktreeProjectDirectory = metadataProjectDirectory ?? worktreeProjectDirectory;
+  const git = useRuntimeAPIs().git;
+  const isGitRepository = useIsGitRepo(resolvedWorktreeProjectDirectory);
+  const ensureGitStatus = useGitStore((state) => state.ensureStatus);
 
   const loadProviders = useConfigStore((state) => state.loadProviders);
   const loadConfigAgents = useConfigStore((state) => state.loadAgents);
@@ -56,7 +68,7 @@ export function ForkSessionDialog(props: ForkSessionDialogProps) {
   const [instructions, setInstructions] = React.useState(EXECUTION_FORK_DEFAULT_INSTRUCTIONS);
   const [createWorktree, setCreateWorktree] = React.useState(false);
   const [runAsGoal, setRunAsGoal] = React.useState(false);
-  const showCreateWorktree = React.useMemo(() => !isVSCodeRuntime(), []);
+  const showCreateWorktree = !isVSCodeRuntime() && isGitRepository === true;
   // The goal loop lives in the web server; VS Code only renders goal state.
   const showRunAsGoal = React.useMemo(() => !isVSCodeRuntime(), []);
 
@@ -79,6 +91,11 @@ export function ForkSessionDialog(props: ForkSessionDialogProps) {
     void loadAgentsStoreAgents();
   }, [open, loadProviders, loadConfigAgents, loadAgentsStoreAgents, projectDirectory]);
 
+  React.useEffect(() => {
+    if (!open || !resolvedWorktreeProjectDirectory || !git) return;
+    void ensureGitStatus(resolvedWorktreeProjectDirectory, git);
+  }, [ensureGitStatus, git, open, resolvedWorktreeProjectDirectory]);
+
   // Reset only when the dialog transitions to open. Reading the store snapshot
   // here (instead of subscribing) avoids clobbering in-progress user edits when
   // the config store refreshes in the background while the dialog is open.
diff --git a/packages/ui/src/components/session/GitHubIntegrationDialog.tsx b/packages/ui/src/components/session/GitHubIntegrationDialog.tsx
index 966ff6ea..03bf5a3a 100644
--- a/packages/ui/src/components/session/GitHubIntegrationDialog.tsx
+++ b/packages/ui/src/components/session/GitHubIntegrationDialog.tsx
@@ -29,14 +29,14 @@ import { useI18n } from '@/lib/i18n';
 
 type GitHubTab = 'issues' | 'prs';
 
+export type GitHubWorktreeSelection =
+  | { type: 'issue'; item: GitHubIssue; includeDiff?: boolean }
+  | { type: 'pr'; item: GitHubPullRequestSummary; includeDiff?: boolean };
+
 interface GitHubIntegrationDialogProps {
   open: boolean;
   onOpenChange: (open: boolean) => void;
-  onSelect: (result: {
-    type: 'issue' | 'pr';
-    item: GitHubIssue | GitHubPullRequestSummary;
-    includeDiff?: boolean;
-  } | null) => void;
+  onSelect: (result: GitHubWorktreeSelection | null) => void;
 }
 
 interface ValidationResult {
diff --git a/packages/ui/src/components/session/NewWorktreeDialog.behavior.test.tsx b/packages/ui/src/components/session/NewWorktreeDialog.behavior.test.tsx
new file mode 100644
index 00000000..a638032b
--- /dev/null
+++ b/packages/ui/src/components/session/NewWorktreeDialog.behavior.test.tsx
@@ -0,0 +1,215 @@
+import React, { act } from 'react';
+import { describe, expect, mock, test } from 'bun:test';
+import { createRoot } from 'react-dom/client';
+import { Window } from 'happy-dom';
+import { create } from 'zustand';
+
+type GitHubSelection = {
+  type: 'issue';
+  item: { number: number; title: string };
+};
+
+type WorktreeState = {
+  availableWorktreesByProject: Map<string, Array<{ name: string }>>;
+};
+
+const project = { id: 'project-a', path: '/workspace/project-a' };
+const useWorktreeStore = create<WorktreeState>(() => ({
+  availableWorktreesByProject: new Map(),
+}));
+let selectGitHubItem: ((selection: GitHubSelection) => void) | null = null;
+
+const projectStoreState = { getActiveProject: () => project };
+const githubAuthState = { status: { connected: true }, hasChecked: true };
+const linearAuthState = { status: null, hasChecked: true };
+const uiState = { isMobile: false };
+const gitState = { fetchBranches: async () => undefined };
+
+const selectProjectState = <T,>(selector: (state: typeof projectStoreState) => T): T => selector(projectStoreState);
+const selectGitHubAuthState = <T,>(selector: (state: typeof githubAuthState) => T): T => selector(githubAuthState);
+const selectLinearAuthState = <T,>(selector: (state: typeof linearAuthState) => T): T => selector(linearAuthState);
+const selectUIState = <T,>(selector: (state: typeof uiState) => T): T => selector(uiState);
+const selectGitState = <T,>(selector: (state: typeof gitState) => T): T => selector(gitState);
+
+const passthrough = ({ children }: React.PropsWithChildren) => <div>{children}</div>;
+
+mock.module('@/components/ui/dialog', () => ({
+  Dialog: ({ children, open }: React.PropsWithChildren<{ open: boolean }>) => open ? <>{children}</> : null,
+  DialogContent: passthrough,
+  DialogHeader: passthrough,
+  DialogTitle: passthrough,
+  DialogFooter: passthrough,
+}));
+
+mock.module('@/components/ui/input', () => ({
+  Input: (props: React.InputHTMLAttributes<HTMLInputElement>) => <input {...props} />,
+}));
+
+mock.module('@/components/ui/button', () => ({
+  Button: ({ children, ...props }: React.ButtonHTMLAttributes<HTMLButtonElement>) => (
+    <button {...props}>{children}</button>
+  ),
+}));
+
+mock.module('@/components/ui', () => ({
+  toast: { error: () => undefined, success: () => undefined },
+}));
+
+mock.module('@/components/ui/dropdown-menu', () => ({
+  DropdownMenu: passthrough,
+  DropdownMenuContent: passthrough,
+  DropdownMenuTrigger: passthrough,
+}));
+
+mock.module('@/components/ui/command', () => ({
+  Command: passthrough,
+  CommandEmpty: passthrough,
+  CommandGroup: passthrough,
+  CommandInput: () => null,
+  CommandItem: passthrough,
+  CommandList: passthrough,
+  CommandSeparator: () => null,
+}));
+
+mock.module('@/components/ui/sortable-tabs-strip', () => ({ SortableTabsStrip: () => null }));
+mock.module('@/components/ui/MobileOverlayPanel', () => ({ MobileOverlayPanel: passthrough }));
+mock.module('@/components/icon/Icon', () => ({ Icon: () => null }));
+mock.module('@/components/ui/dropdown-trigger', () => ({ dropdownTriggerVariants: () => '' }));
+mock.module('@/lib/utils', () => ({ cn: (...values: Array<string | false | null | undefined>) => values.filter(Boolean).join(' ') }));
+
+mock.module('@/stores/useProjectsStore', () => ({
+  useProjectsStore: selectProjectState,
+}));
+mock.module('@/stores/useGitHubAuthStore', () => ({
+  useGitHubAuthStore: selectGitHubAuthState,
+}));
+mock.module('@/stores/useLinearAuthStore', () => ({
+  useLinearAuthStore: selectLinearAuthState,
+}));
+mock.module('@/stores/useUIStore', () => ({
+  useUIStore: selectUIState,
+}));
+mock.module('@/sync/session-ui-store', () => ({
+  materializeOpenDraftSession: async () => null,
+  useSessionUIStore: useWorktreeStore,
+}));
+mock.module('@/sync/session-actions', () => ({
+  createSession: async () => null,
+  updateSessionTitle: async () => undefined,
+}));
+mock.module('@/hooks/useRuntimeAPIs', () => ({
+  useRuntimeAPIs: () => ({ github: {}, git: null, linear: null }),
+}));
+mock.module('@/stores/useGitStore', () => ({
+  useGitBranches: () => ({ all: ['main'] }),
+  useGitLoadingBranches: () => false,
+  useGitStore: selectGitState,
+}));
+mock.module('@/lib/worktrees/worktreeManager', () => ({
+  validateWorktreeCreate: async () => ({ ok: true, errors: [] }),
+}));
+mock.module('@/lib/worktrees/worktreeCreate', () => ({ createWorktreeWithDefaults: async () => null }));
+mock.module('@/lib/worktrees/worktreeBootstrap', () => ({ waitForWorktreeBootstrap: async () => undefined }));
+mock.module('@/lib/openchamberConfig', () => ({
+  getWorktreeSetupCommands: async () => [],
+  getWorktreeSetupWaitEnabled: async () => false,
+}));
+mock.module('@/lib/worktrees/worktreeStatus', () => ({ getRootBranch: async () => 'main' }));
+mock.module('@/lib/git/branchNameGenerator', () => ({ generateBranchSlug: () => 'draft-name' }));
+
+mock.module('./GitHubIntegrationDialog', () => ({
+  GitHubIntegrationDialog: ({ onSelect }: { onSelect: (selection: GitHubSelection) => void }) => {
+    selectGitHubItem = onSelect;
+    return null;
+  },
+}));
+mock.module('./LinearIssuePickerDialog', () => ({ LinearIssuePickerDialog: () => null }));
+
+const { NewWorktreeDialog } = await import('./NewWorktreeDialog');
+const { I18nProvider } = await import('@/lib/i18n');
+
+const DOM_GLOBAL_NAMES = [
+  'window',
+  'document',
+  'navigator',
+  'Node',
+  'Element',
+  'HTMLElement',
+  'HTMLIFrameElement',
+  'localStorage',
+  'IS_REACT_ACT_ENVIRONMENT',
+] as const;
+
+const installDom = () => {
+  const happyWindow = new Window({ url: 'http://localhost' });
+  const previous = DOM_GLOBAL_NAMES.map(
+    (name) => [name, Object.getOwnPropertyDescriptor(globalThis, name)] as const,
+  );
+  const values = {
+    window: happyWindow,
+    document: happyWindow.document,
+    navigator: happyWindow.navigator,
+    Node: happyWindow.Node,
+    Element: happyWindow.Element,
+    HTMLElement: happyWindow.HTMLElement,
+    HTMLIFrameElement: happyWindow.HTMLIFrameElement,
+    localStorage: happyWindow.localStorage,
+    IS_REACT_ACT_ENVIRONMENT: true,
+  };
+  for (const name of DOM_GLOBAL_NAMES) {
+    Object.defineProperty(globalThis, name, { value: values[name], configurable: true, writable: true });
+  }
+
+  const container = document.createElement('div');
+  document.body.appendChild(container);
+  return {
+    container,
+    restore: () => {
+      for (const [name, descriptor] of previous) {
+        if (descriptor) Object.defineProperty(globalThis, name, descriptor);
+        else Reflect.deleteProperty(globalThis, name);
+      }
+    },
+  };
+};
+
+describe('NewWorktreeDialog behavior', () => {
+  test('preserves selected issue values when available worktree names change', async () => {
+    const dom = installDom();
+    const root = createRoot(dom.container);
+    useWorktreeStore.setState({ availableWorktreesByProject: new Map() });
+
+    try {
+      await act(async () => root.render(
+        <I18nProvider>
+          <NewWorktreeDialog open onOpenChange={() => undefined} />
+        </I18nProvider>,
+      ));
+      if (!selectGitHubItem) throw new Error('Expected GitHub selection handler');
+
+      await act(async () => selectGitHubItem?.({
+        type: 'issue',
+        item: { number: 42, title: 'Keep the selected issue' },
+      }));
+
+      const [branchInput, worktreeInput] = dom.container.querySelectorAll<HTMLInputElement>('input');
+      expect(branchInput?.value).toBe('issue-42-draft-name');
+      expect(worktreeInput?.value).toBe('issue-42-draft-name');
+      expect(dom.container.textContent).toContain('Keep the selected issue');
+
+      await act(async () => useWorktreeStore.setState({
+        availableWorktreesByProject: new Map([
+          [project.path, [{ name: 'newly-created-worktree' }]],
+        ]),
+      }));
+
+      expect(branchInput?.value).toBe('issue-42-draft-name');
+      expect(worktreeInput?.value).toBe('issue-42-draft-name');
+      expect(dom.container.textContent).toContain('Keep the selected issue');
+    } finally {
+      await act(async () => root.unmount());
+      selectGitHubItem = null;
+      dom.restore();
+    }
+  });
+});
diff --git a/packages/ui/src/components/session/NewWorktreeDialog.tsx b/packages/ui/src/components/session/NewWorktreeDialog.tsx
index f427e827..425e9281 100644
--- a/packages/ui/src/components/session/NewWorktreeDialog.tsx
+++ b/packages/ui/src/components/session/NewWorktreeDialog.tsx
@@ -51,7 +51,7 @@ import {
 } from '@/lib/worktrees/worktreeSourceBranchPreference';
 import { useRuntimeAPIs } from '@/hooks/useRuntimeAPIs';
 import { useGitBranches, useGitStore, useGitLoadingBranches } from '@/stores/useGitStore';
-import { GitHubIntegrationDialog } from './GitHubIntegrationDialog';
+import { GitHubIntegrationDialog, type GitHubWorktreeSelection } from './GitHubIntegrationDialog';
 import { LinearIssuePickerDialog } from './LinearIssuePickerDialog';
 import { SortableTabsStrip } from '@/components/ui/sortable-tabs-strip';
 import { MobileOverlayPanel } from '@/components/ui/MobileOverlayPanel';
@@ -65,7 +65,7 @@ import type {
   LinearIssue,
   LinearIssueComment,
 } from '@/lib/api/types';
-import type { ProjectRef } from '@/lib/worktrees/worktreeManager';
+import type { CreateWorktreeArgs, ProjectRef } from '@/lib/worktrees/worktreeManager';
 import { useI18n } from '@/lib/i18n';
 
 type Mode = 'new-branch' | 'existing-branch';
@@ -456,6 +456,7 @@ export function NewWorktreeDialog({
   // Creation state
   const [isCreating, setIsCreating] = React.useState(false);
   const [validationAbortController, setValidationAbortController] = React.useState<AbortController | null>(null);
+  const initializedForCurrentOpen = React.useRef(false);
 
   const resolveDefaultAgentName = React.useCallback((): string | undefined => {
     const configState = useConfigStore.getState();
@@ -493,9 +494,7 @@ export function NewWorktreeDialog({
       : undefined;
 
     const provider = configState.providers.find((p) => p.id === providerID);
-    const model = provider?.models.find((m: Record<string, unknown>) => (m as { id?: string }).id === modelID) as
-      | { variants?: Record<string, unknown> }
-      | undefined;
+    const model = provider?.models.find((m) => m.id === modelID);
     const variants = model?.variants;
     if (!variants) return settingsDefaultVariant || currentVariant || undefined;
     if (settingsDefaultVariant && Object.prototype.hasOwnProperty.call(variants, settingsDefaultVariant)) return settingsDefaultVariant;
@@ -763,7 +762,12 @@ export function NewWorktreeDialog({
   // Reset state on each open. Resetting on close would empty the form during
   // the close animation, causing visible flicker.
   React.useLayoutEffect(() => {
-    if (!open) return;
+    if (!open) {
+      initializedForCurrentOpen.current = false;
+      return;
+    }
+    if (initializedForCurrentOpen.current) return;
+    initializedForCurrentOpen.current = true;
 
     setMode('new-branch');
     setExistingBranchState({
@@ -840,14 +844,15 @@ export function NewWorktreeDialog({
       if (normalizedBranch && normalizedWorktree) {
         const linkedPr = mode === 'new-branch' ? newBranchState.linkedPr : null;
         const prConfig = linkedPr ? resolvePrWorktreeConfig(linkedPr, localBranches, remoteBranches) : null;
-        const result = await validateWorktreeCreate(projectRef, {
+        const validateArgs: CreateWorktreeArgs = {
           mode: mode === 'existing-branch' || prConfig ? 'existing' : 'new',
           branchName: normalizedBranch,
           worktreeName: normalizedWorktree,
           existingBranch: prConfig?.existingBranch ?? (mode === 'existing-branch' ? normalizedBranch : undefined),
-          ...(prConfig?.ensureRemoteName ? { ensureRemoteName: prConfig.ensureRemoteName } : {}),
-          ...(prConfig?.ensureRemoteUrl ? { ensureRemoteUrl: prConfig.ensureRemoteUrl } : {}),
-        });
+        };
+        if (prConfig?.ensureRemoteName) validateArgs.ensureRemoteName = prConfig.ensureRemoteName;
+        if (prConfig?.ensureRemoteUrl) validateArgs.ensureRemoteUrl = prConfig.ensureRemoteUrl;
+        const result = await validateWorktreeCreate(projectRef, validateArgs);
         
         if (abortController.signal.aborted) return;
         
@@ -961,13 +966,13 @@ export function NewWorktreeDialog({
       const sourceBranch = newBranchState.sourceBranch;
 
       let sourceLabel = '';
-      const args = (() => {
+      const args: CreateWorktreeArgs = (() => {
         if (linkedPr) {
           const prConfig = resolvePrWorktreeConfig(linkedPr, localBranches, remoteBranches);
           sourceLabel = prConfig.sourceLabel;
-          return {
+          const prArgs: CreateWorktreeArgs = {
             preferredName: normalizedBranch || normalizedWorktree,
-            mode: 'existing' as const,
+            mode: 'existing',
             branchName: normalizedBranch,
             worktreeName: normalizedWorktree,
             existingBranch: prConfig.existingBranch,
@@ -976,22 +981,24 @@ export function NewWorktreeDialog({
             upstreamRemote: prConfig.upstreamRemote,
             upstreamBranch: prConfig.upstreamBranch,
             returnAfterDirectoryCreated: true,
-            ...(prConfig.ensureRemoteName ? { ensureRemoteName: prConfig.ensureRemoteName } : {}),
-            ...(prConfig.ensureRemoteUrl ? { ensureRemoteUrl: prConfig.ensureRemoteUrl } : {}),
           };
+          if (prConfig.ensureRemoteName) prArgs.ensureRemoteName = prConfig.ensureRemoteName;
+          if (prConfig.ensureRemoteUrl) prArgs.ensureRemoteUrl = prConfig.ensureRemoteUrl;
+          return prArgs;
         }
 
         sourceLabel = mode === 'new-branch' ? sourceBranch : '';
-        return {
+        const baseArgs: CreateWorktreeArgs = {
           preferredName: normalizedBranch || normalizedWorktree,
-          mode: mode === 'existing-branch' ? 'existing' as const : 'new' as const,
+          mode: mode === 'existing-branch' ? 'existing' : 'new',
           branchName: mode === 'existing-branch' ? undefined : normalizedBranch,
           worktreeName: normalizedWorktree,
           existingBranch: mode === 'existing-branch' ? normalizedBranch : undefined,
           setupCommands,
           returnAfterDirectoryCreated: true,
-          ...(sourceBranch && mode === 'new-branch' ? { startRef: sourceBranch } : {}),
         };
+        if (sourceBranch && mode === 'new-branch') baseArgs.startRef = sourceBranch;
+        return baseArgs;
       })();
 
       const metadata = await createWorktreeWithDefaults(projectRef, args);
@@ -1084,11 +1091,7 @@ export function NewWorktreeDialog({
   };
 
   // Handle GitHub selection
-  const handleGitHubSelect = (result: {
-    type: 'issue' | 'pr';
-    item: GitHubIssue | GitHubPullRequestSummary;
-    includeDiff?: boolean;
-  } | null) => {
+  const handleGitHubSelect = (result: GitHubWorktreeSelection | null) => {
     if (!result) {
       setNewBranchState(prev => ({
         ...prev,
@@ -1102,7 +1105,7 @@ export function NewWorktreeDialog({
     }
 
     if (result.type === 'issue') {
-      const issue = result.item as GitHubIssue;
+      const issue = result.item;
       const newBranchName = `issue-${issue.number}-${generateBranchSlug()}`;
       setNewBranchState(prev => ({
         ...prev,
@@ -1115,7 +1118,7 @@ export function NewWorktreeDialog({
         isSyncingWorktreeName: true,
       }));
     } else if (result.type === 'pr') {
-      const pr = result.item as GitHubPullRequestSummary;
+      const pr = result.item;
       setNewBranchState(prev => ({
         ...prev,
         linkedPr: pr,
@@ -1261,7 +1264,11 @@ export function NewWorktreeDialog({
                 { id: 'existing-branch', label: t('session.newWorktree.mode.existingBranch'), icon: <Icon name="git-repository" className="h-3.5 w-3.5" /> },
               ]}
               activeId={mode}
-              onSelect={(id) => handleModeChange(id as Mode)}
+              onSelect={(id) => {
+                if (id === 'new-branch' || id === 'existing-branch') {
+                  handleModeChange(id);
+                }
+              }}
               variant="active-pill"
               layoutMode="fit"
               className="w-full"
@@ -1767,7 +1774,11 @@ export function NewWorktreeDialog({
                       { id: 'existing-branch', label: t('session.newWorktree.mode.existingBranch'), icon: <Icon name="git-repository" className="h-3.5 w-3.5" /> },
                     ]}
                     activeId={mode}
-                    onSelect={(id) => handleModeChange(id as Mode)}
+                    onSelect={(id) => {
+                if (id === 'new-branch' || id === 'existing-branch') {
+                  handleModeChange(id);
+                }
+              }}
                     variant="active-pill"
                     layoutMode="fit"
                     className="w-full"
diff --git a/packages/ui/src/components/session/sidebar/sessions/SessionNodeItem.tsx b/packages/ui/src/components/session/sidebar/sessions/SessionNodeItem.tsx
index 1ff494a6..2d4e1200 100644
--- a/packages/ui/src/components/session/sidebar/sessions/SessionNodeItem.tsx
+++ b/packages/ui/src/components/session/sidebar/sessions/SessionNodeItem.tsx
@@ -347,6 +347,8 @@ function SessionNodeItemComponent(props: SessionNodeItemProps): React.ReactNode
   const renameDraftRef = React.useRef(renameDraft);
   renameDraftRef.current = renameDraft;
   const renameTargetRef = React.useRef<string | null>(null);
+  const pendingRenameSelectRef = React.useRef(false);
+  const renameInputRef = React.useRef<HTMLInputElement>(null);
   const formRef = React.useRef<HTMLFormElement>(null);
 
   const session = node.session;
@@ -633,9 +635,24 @@ function SessionNodeItemComponent(props: SessionNodeItemProps): React.ReactNode
     }
     if (renameTargetRef.current === session.id) return;
     renameTargetRef.current = session.id;
+    pendingRenameSelectRef.current = true;
     setRenameDraft(editTitle);
   }, [editingId, editTitle, session.id]);
 
+  // Entering rename mode selects the whole title, so the first keystroke
+  // replaces it instead of appending to it. The selection waits for the commit
+  // that actually renders `editTitle`: the draft state above is seeded when the
+  // row mounts, so on a session whose title changed since then the input still
+  // holds the old text during the commit that opens the form.
+  React.useLayoutEffect(() => {
+    if (editingId !== session.id || !pendingRenameSelectRef.current) return;
+    const input = renameInputRef.current;
+    if (!input || input.value !== editTitle) return;
+    pendingRenameSelectRef.current = false;
+    input.focus();
+    input.select();
+  }, [editingId, editTitle, renameDraft, session.id]);
+
   if (editingId === session.id) {
     return (
       <div
@@ -656,6 +673,7 @@ function SessionNodeItemComponent(props: SessionNodeItemProps): React.ReactNode
             }}
           >
             <input
+              ref={renameInputRef}
               value={renameDraft}
               onChange={(event) => setRenameDraft(event.target.value)}
               className="flex-1 min-w-0 bg-transparent typography-ui-label outline-none placeholder:text-muted-foreground"
diff --git a/packages/ui/src/components/views/GitView.tsx b/packages/ui/src/components/views/GitView.tsx
index 7ff07e05..d5ba4cb2 100644
--- a/packages/ui/src/components/views/GitView.tsx
+++ b/packages/ui/src/components/views/GitView.tsx
@@ -20,6 +20,7 @@ import {
   useGitLoadingLog,
 } from '@/stores/useGitStore';
 import { useNestedGitDirectory } from '@/hooks/useNestedGitDirectory';
+import { useWorktreeBootstrapPending } from '@/hooks/useWorktreeBootstrapPending';
 import { NestedRepoResolutionStates } from './git/NestedRepoResolutionStates';
 import { ScrollableOverlay } from '@/components/ui/ScrollableOverlay';
 import { ScrollShadow } from '@/components/ui/ScrollShadow';
@@ -203,8 +204,14 @@ export const GitView: React.FC<GitViewProps> = ({ isActive }) => {
   const { t } = useI18n();
   const { git } = useRuntimeAPIs();
   const currentDirectory = useEffectiveDirectory();
-  const [worktreeBootstrapStatus, setWorktreeBootstrapStatus] = React.useState<'pending' | 'ready' | 'failed' | null>(null);
-  const [isWaitingForGitRefreshAfterBootstrap, setIsWaitingForGitRefreshAfterBootstrap] = React.useState(false);
+  const [worktreeBootstrapSnapshot, setWorktreeBootstrapSnapshot] = React.useState<{
+    directory: string;
+    status: 'pending' | 'ready' | 'failed' | null;
+  } | null>(null);
+  const [postBootstrapRefresh, setPostBootstrapRefresh] = React.useState<{
+    directory: string;
+    status: 'refreshing' | 'failed';
+  } | null>(null);
   const currentSessionId = useSessionUIStore((s) => s.currentSessionId);
   const newSessionDraft = useSessionUIStore((s) => s.newSessionDraft);
   const setDraftBootstrapPendingDirectory = useSessionUIStore((s) => s.setDraftBootstrapPendingDirectory);
@@ -285,7 +292,6 @@ export const GitView: React.FC<GitViewProps> = ({ isActive }) => {
   const isLogLoading = useGitLoadingLog(gitDirectory ?? null);
   const {
     setActiveDirectory,
-    fetchAll,
     ensureAll,
     fetchStatus,
     fetchBranches,
@@ -301,7 +307,6 @@ export const GitView: React.FC<GitViewProps> = ({ isActive }) => {
     selectNestedRepo,
   } = useGitStore(useShallow((state) => ({
     setActiveDirectory: state.setActiveDirectory,
-    fetchAll: state.fetchAll,
     ensureAll: state.ensureAll,
     fetchStatus: state.fetchStatus,
     fetchBranches: state.fetchBranches,
@@ -329,7 +334,6 @@ export const GitView: React.FC<GitViewProps> = ({ isActive }) => {
   });
   const navigateToDiff = useUIStore((state) => state.navigateToDiff);
 
-  const previousBootstrapStatusRef = React.useRef<'pending' | 'ready' | 'failed' | null>(null);
   const gitReconcileTimeoutRef = React.useRef<number | null>(null);
   const gitMutationFlushTimeoutRef = React.useRef<number | null>(null);
   const flushQueuedGitMutationsRef = React.useRef<(() => void) | null>(null);
@@ -438,11 +442,13 @@ export const GitView: React.FC<GitViewProps> = ({ isActive }) => {
   React.useEffect(() => {
     if (!isActive) return;
     if (!currentDirectory) {
-      setWorktreeBootstrapStatus(null);
-      setIsWaitingForGitRefreshAfterBootstrap(false);
+      setWorktreeBootstrapSnapshot(null);
       return;
     }
 
+    const bootstrapDirectory = normalizePath(currentDirectory) ?? currentDirectory;
+    setWorktreeBootstrapSnapshot({ directory: bootstrapDirectory, status: null });
+
     let cancelled = false;
     let timeoutId: number | null = null;
 
@@ -452,7 +458,7 @@ export const GitView: React.FC<GitViewProps> = ({ isActive }) => {
         if (cancelled) {
           return;
         }
-        setWorktreeBootstrapStatus(next.status);
+        setWorktreeBootstrapSnapshot({ directory: bootstrapDirectory, status: next.status });
         if (next.status === 'pending') {
           timeoutId = window.setTimeout(() => {
             void poll();
@@ -460,7 +466,7 @@ export const GitView: React.FC<GitViewProps> = ({ isActive }) => {
         }
       } catch {
         if (!cancelled) {
-          setWorktreeBootstrapStatus(null);
+          setWorktreeBootstrapSnapshot({ directory: bootstrapDirectory, status: null });
         }
       }
     };
@@ -475,37 +481,84 @@ export const GitView: React.FC<GitViewProps> = ({ isActive }) => {
     };
   }, [isActive, currentDirectory]);
 
-  React.useEffect(() => {
-    const previous = previousBootstrapStatusRef.current;
-    previousBootstrapStatusRef.current = worktreeBootstrapStatus;
-
-    if (!currentDirectory || !git) {
-      return;
-    }
-
-    if (previous === 'pending' && worktreeBootstrapStatus === 'ready') {
-      setIsWaitingForGitRefreshAfterBootstrap(true);
-      void fetchAll(currentDirectory, git).finally(() => {
-        window.setTimeout(() => {
-          setIsWaitingForGitRefreshAfterBootstrap(false);
-        }, 1200);
-      });
-    }
-
-    if (worktreeBootstrapStatus === 'failed') {
-      setDraftBootstrapPendingDirectory(null);
-      setIsWaitingForGitRefreshAfterBootstrap(false);
-    }
-  }, [currentDirectory, fetchAll, git, setDraftBootstrapPendingDirectory, worktreeBootstrapStatus]);
-
   const normalizedDraftBootstrapPendingDirectory = normalizePath(newSessionDraft?.bootstrapPendingDirectory ?? null);
   const isDraftBootstrapPendingForCurrentDirectory = Boolean(
     currentDirectory && normalizedDraftBootstrapPendingDirectory && normalizedDraftBootstrapPendingDirectory === normalizePath(currentDirectory)
   );
+  const sharedWorktreeBootstrapPending = useWorktreeBootstrapPending(currentDirectory ?? null);
+  const normalizedCurrentBootstrapDirectory = normalizePath(currentDirectory);
+  const observedWorktreeBootstrapStatus = worktreeBootstrapSnapshot?.directory === normalizedCurrentBootstrapDirectory
+    ? worktreeBootstrapSnapshot.status
+    : null;
   const isPendingWorktreeSetup = Boolean(
-    currentDirectory && (worktreeBootstrapStatus === 'pending' || isDraftBootstrapPendingForCurrentDirectory)
+    currentDirectory
+      && (
+        sharedWorktreeBootstrapPending
+        || observedWorktreeBootstrapStatus === 'pending'
+        || (isDraftBootstrapPendingForCurrentDirectory && newSessionDraft?.pendingWorktreeRequestId)
+      )
   );
-  const shouldHideNotGitState = isPendingWorktreeSetup || isWaitingForGitRefreshAfterBootstrap;
+  const isPostBootstrapRefreshForCurrentDirectory = Boolean(
+    normalizedCurrentBootstrapDirectory
+      && postBootstrapRefresh?.directory === normalizedCurrentBootstrapDirectory
+  );
+
+  React.useEffect(() => {
+    if (!normalizedCurrentBootstrapDirectory) return;
+
+    if (observedWorktreeBootstrapStatus === 'failed') {
+      setDraftBootstrapPendingDirectory(null);
+      setPostBootstrapRefresh((current) => (
+        current?.directory === normalizedCurrentBootstrapDirectory ? null : current
+      ));
+      return;
+    }
+
+    if (isPendingWorktreeSetup) {
+      setPostBootstrapRefresh((current) => (
+        current?.directory === normalizedCurrentBootstrapDirectory && current.status === 'refreshing'
+          ? current
+          : { directory: normalizedCurrentBootstrapDirectory, status: 'refreshing' }
+      ));
+      return;
+    }
+
+    if (
+      postBootstrapRefresh?.directory !== normalizedCurrentBootstrapDirectory
+      || postBootstrapRefresh.status !== 'refreshing'
+      || !gitDirectory
+      || !git
+    ) {
+      return;
+    }
+
+    let cancelled = false;
+    void fetchStatus(gitDirectory, git, {
+      force: true,
+      silent: true,
+      throwOnError: true,
+    }).then(() => {
+      if (cancelled) return;
+      setPostBootstrapRefresh((current) => (
+        current?.directory === normalizedCurrentBootstrapDirectory ? null : current
+      ));
+    }).catch(() => {
+      if (cancelled) return;
+      setPostBootstrapRefresh((current) => (
+        current?.directory === normalizedCurrentBootstrapDirectory
+          ? { ...current, status: 'failed' }
+          : current
+      ));
+    });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [fetchStatus, git, gitDirectory, isPendingWorktreeSetup, normalizedCurrentBootstrapDirectory, observedWorktreeBootstrapStatus, postBootstrapRefresh, setDraftBootstrapPendingDirectory]);
+
+  const shouldHideGitState = isPendingWorktreeSetup || isPostBootstrapRefreshForCurrentDirectory;
+  const postBootstrapRefreshFailed = isPostBootstrapRefreshForCurrentDirectory
+    && postBootstrapRefresh?.status === 'failed';
 
   const initialSnapshot = React.useMemo(() => {
     if (!gitDirectory) return null;
@@ -2336,6 +2389,42 @@ export const GitView: React.FC<GitViewProps> = ({ isActive }) => {
     );
   }
 
+  if (shouldHideGitState) {
+    return (
+      <div className="flex h-full flex-col items-center justify-center px-4 text-center">
+        {!postBootstrapRefreshFailed ? (
+          <Icon name="loader-4" className="mb-3 size-6 animate-spin text-muted-foreground" />
+        ) : null}
+        <p className="typography-ui-label font-semibold text-foreground">
+          {postBootstrapRefreshFailed
+            ? t('gitView.toast.refreshRepositoryFailed')
+            : t('gitView.empty.worktreeSetupInProgress')}
+        </p>
+        {!postBootstrapRefreshFailed ? (
+          <p className="typography-meta mt-1 text-muted-foreground">
+            {t('gitView.empty.worktreeSetupDescription')}
+          </p>
+        ) : (
+          <Button
+            type="button"
+            variant="outline"
+            size="sm"
+            className="mt-3"
+            onClick={() => {
+              if (!normalizedCurrentBootstrapDirectory) return;
+              setPostBootstrapRefresh({
+                directory: normalizedCurrentBootstrapDirectory,
+                status: 'refreshing',
+              });
+            }}
+          >
+            {t('gitView.empty.retryDiscovery')}
+          </Button>
+        )}
+      </div>
+    );
+  }
+
   if (isGitRepo === null || (isGitRepo === true && !status)) {
     return (
       <div className="flex h-full items-center justify-center">
@@ -2348,20 +2437,6 @@ export const GitView: React.FC<GitViewProps> = ({ isActive }) => {
   }
 
   if (isGitRepo === false) {
-    if (shouldHideNotGitState) {
-      return (
-        <div className="flex h-full flex-col items-center justify-center px-4 text-center">
-          <Icon name="loader-4" className="mb-3 size-6 animate-spin text-muted-foreground" />
-          <p className="typography-ui-label font-semibold text-foreground">
-            {t('gitView.empty.worktreeSetupInProgress')}
-          </p>
-          <p className="typography-meta mt-1 text-muted-foreground">
-            {t('gitView.empty.worktreeSetupDescription')}
-          </p>
-        </div>
-      );
-    }
-
     // Nested repository discovery states (discovering, failed, unsupported,
     // none found, or settling on the auto-selected repository).
     return (
diff --git a/packages/ui/src/hooks/useQueuedMessageAutoSend.ts b/packages/ui/src/hooks/useQueuedMessageAutoSend.ts
index 87bee797..623aaa8e 100644
--- a/packages/ui/src/hooks/useQueuedMessageAutoSend.ts
+++ b/packages/ui/src/hooks/useQueuedMessageAutoSend.ts
@@ -148,11 +148,18 @@ const resolveSessionSendConfig = (sessionId: string) => {
     ?? config.currentModelId
     ?? selection.lastUsedProvider?.modelID;
 
-  const variant =
+  // A recorded `null` is an explicit "Default": it stops the lookup and sends
+  // no effort, instead of falling through to the persisted copy.
+  const savedVariant =
     selectedAgent && providerID && modelID
-      ? (selection.getAgentModelVariantForSession(sessionId, selectedAgent, providerID, modelID)
-        ?? context.getAgentModelVariantForSession(sessionId, selectedAgent, providerID, modelID))
+      ? (() => {
+        const live = selection.getAgentModelVariantForSession(sessionId, selectedAgent, providerID, modelID);
+        return live !== undefined
+          ? live
+          : context.getAgentModelVariantForSession(sessionId, selectedAgent, providerID, modelID);
+      })()
       : undefined;
+  const variant = savedVariant ?? undefined;
 
   return {
     providerID,
diff --git a/packages/ui/src/hooks/useWorktreeBootstrapPending.ts b/packages/ui/src/hooks/useWorktreeBootstrapPending.ts
new file mode 100644
index 00000000..1108d84d
--- /dev/null
+++ b/packages/ui/src/hooks/useWorktreeBootstrapPending.ts
@@ -0,0 +1,18 @@
+import React from 'react';
+
+import { getWorktreeBootstrapState, subscribeWorktreeBootstrapState } from '@/lib/worktrees/worktreeBootstrap';
+
+/**
+ * Whether `directory` is a worktree whose creation has not finished yet: the
+ * directory exists, but setup commands and the initial git reset are still
+ * running. Until that completes the working tree transiently looks dirty, so
+ * surfaces that report uncommitted changes consult this and show nothing
+ * instead of presenting bootstrap noise as real changes on the branch.
+ */
+export const useWorktreeBootstrapPending = (directory: string | null): boolean => {
+  const getSnapshot = React.useCallback(
+    () => (directory ? getWorktreeBootstrapState(directory)?.status === 'pending' : false),
+    [directory],
+  );
+  return React.useSyncExternalStore(subscribeWorktreeBootstrapState, getSnapshot, getSnapshot);
+};
diff --git a/packages/ui/src/lib/api/types.ts b/packages/ui/src/lib/api/types.ts
index 4cceb29f..5578727d 100644
--- a/packages/ui/src/lib/api/types.ts
+++ b/packages/ui/src/lib/api/types.ts
@@ -495,7 +495,7 @@ interface GitWorktreeAPI {
 
 export interface GitAPI {
   checkIsGitRepository(directory: string): Promise<boolean>;
-  getGitStatus(directory: string, options?: { mode?: 'light' }): Promise<GitStatus>;
+  getGitStatus(directory: string, options?: { mode?: 'light'; fresh?: boolean }): Promise<GitStatus>;
   getGitDiff(directory: string, options: GetGitDiffOptions): Promise<GitDiffResponse>;
   getGitFileDiff(directory: string, options: GetGitFileDiffOptions): Promise<GitFileDiffResponse>;
   getGitRangeDiff?(directory: string, options: GetGitRangeDiffOptions): Promise<GitDiffResponse>;
diff --git a/packages/ui/src/lib/gitApi.ts b/packages/ui/src/lib/gitApi.ts
index 1d0e325a..1522154f 100644
--- a/packages/ui/src/lib/gitApi.ts
+++ b/packages/ui/src/lib/gitApi.ts
@@ -84,7 +84,7 @@ export async function checkIsGitRepository(directory: string): Promise<boolean>
   return gitHttp.checkIsGitRepository(directory);
 }
 
-export async function getGitStatus(directory: string, options?: { mode?: 'light' }): Promise<import('./api/types').GitStatus> {
+export async function getGitStatus(directory: string, options?: { mode?: 'light'; fresh?: boolean }): Promise<import('./api/types').GitStatus> {
   const runtime = getRuntimeGit();
   if (runtime) return runtime.getGitStatus(directory, options);
   return gitHttp.getGitStatus(directory, options);
diff --git a/packages/ui/src/lib/gitApiHttp.test.ts b/packages/ui/src/lib/gitApiHttp.test.ts
index bc2e2c49..1067481d 100644
--- a/packages/ui/src/lib/gitApiHttp.test.ts
+++ b/packages/ui/src/lib/gitApiHttp.test.ts
@@ -29,6 +29,7 @@ import {
   unstageGitFiles,
 } from './gitApiHttp';
 import type { GitStatus } from './api/types';
+import { sessionEvents } from './sessionEvents';
 
 type FetchCall = {
   input: RequestInfo | URL;
@@ -141,6 +142,28 @@ describe('gitApiHttp index mutations', () => {
 });
 
 describe('gitApiHttp status cache', () => {
+  test('a Git refresh hint invalidates the cached status before listeners fetch', async () => {
+    installWindowMock();
+    let statusRequestCount = 0;
+    globalThis.fetch = async () => {
+      statusRequestCount += 1;
+      return jsonResponse(statusPayload({ behind: statusRequestCount }));
+    };
+
+    try {
+      const directory = '/repo-cache-tool-mutation';
+      const first = await getGitStatus(directory);
+      sessionEvents.requestGitRefresh({ directory });
+      const afterMutation = await getGitStatus(directory);
+
+      expect(first.behind).toBe(1);
+      expect(afterMutation.behind).toBe(2);
+      expect(statusRequestCount).toBe(2);
+    } finally {
+      restoreMocks();
+    }
+  });
+
   test('invalidates cached status after fetch', async () => {
     installWindowMock();
     const calls: FetchCall[] = [];
@@ -188,6 +211,58 @@ describe('gitApiHttp status cache', () => {
       restoreMocks();
     }
   });
+
+  test('fresh status bypasses an unexpired cached snapshot', async () => {
+    installWindowMock();
+    let statusRequestCount = 0;
+    globalThis.fetch = (async () => {
+      statusRequestCount += 1;
+      return jsonResponse(statusPayload({ behind: statusRequestCount }));
+    }) as typeof fetch;
+
+    try {
+      const directory = '/repo-cache-fresh';
+      const first = await getGitStatus(directory);
+      const cached = await getGitStatus(directory);
+      const fresh = await getGitStatus(directory, { fresh: true });
+
+      expect(first.behind).toBe(1);
+      expect(cached.behind).toBe(1);
+      expect(fresh.behind).toBe(2);
+      expect(statusRequestCount).toBe(2);
+    } finally {
+      restoreMocks();
+    }
+  });
+
+  test('fresh status cannot be replaced in cache by an older in-flight response', async () => {
+    installWindowMock();
+    const statusResolvers: Array<(response: Response) => void> = [];
+    // SAFETY: the mock accepts the same arguments as fetch and always returns
+    // a pending Response promise controlled by this test.
+    globalThis.fetch = (async () => new Promise<Response>((resolve) => {
+      statusResolvers.push(resolve);
+    })) as typeof fetch;
+
+    try {
+      const directory = '/repo-cache-fresh-race';
+      const older = getGitStatus(directory);
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      const fresh = getGitStatus(directory, { fresh: true });
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      expect(statusResolvers).toHaveLength(2);
+      statusResolvers[1](jsonResponse(statusPayload({ current: 'fresh' })));
+      statusResolvers[0](jsonResponse(statusPayload({ current: 'stale' })));
+
+      expect((await fresh).current).toBe('fresh');
+      expect((await older).current).toBe('stale');
+      expect((await getGitStatus(directory)).current).toBe('fresh');
+      expect(statusResolvers).toHaveLength(2);
+    } finally {
+      restoreMocks();
+    }
+  });
 });
 
 const statusPayload = (overrides: Partial<GitStatus> = {}): GitStatus => ({
diff --git a/packages/ui/src/lib/gitApiHttp.ts b/packages/ui/src/lib/gitApiHttp.ts
index 197eb7cf..7eda4da4 100644
--- a/packages/ui/src/lib/gitApiHttp.ts
+++ b/packages/ui/src/lib/gitApiHttp.ts
@@ -40,7 +40,7 @@ import { normalizePath } from './pathNormalization';
 import { runtimeFetch } from './runtime-fetch';
 import { getRuntimeUrlResolver } from './runtime-url';
 import { getRuntimeKey } from './runtime-switch';
-import { notifyGitStatusInvalidated } from './gitStatusInvalidation';
+import { notifyGitStatusInvalidated, subscribeGitStatusInvalidations } from './gitStatusInvalidation';
 
 const API_BASE = '/api/git';
 const GIT_STATUS_CACHE_TTL_MS = 1200;
@@ -60,8 +60,7 @@ const getStatusCacheKey = (runtimeKey: string, directory: string, mode?: 'light'
 const getStatusCacheVersion = (runtimeKey: string, directory: string): number =>
   gitStatusCacheVersions.get(getDirectoryCacheKey(runtimeKey, directory)) ?? 0;
 
-const invalidateGitStatusCache = (directory: string): void => {
-  const runtimeKey = getRuntimeKey();
+const clearGitStatusCache = (runtimeKey: string, directory: string): void => {
   const key = getDirectoryCacheKey(runtimeKey, directory);
   gitStatusCacheVersions.set(key, getStatusCacheVersion(runtimeKey, directory) + 1);
   for (const mode of [undefined, 'light'] as const) {
@@ -69,6 +68,13 @@ const invalidateGitStatusCache = (directory: string): void => {
     gitStatusCache.delete(statusKey);
     gitStatusInFlight.delete(statusKey);
   }
+};
+
+subscribeGitStatusInvalidations((directory) => {
+  clearGitStatusCache(getRuntimeKey(), directory);
+});
+
+const invalidateGitStatusCache = (directory: string): void => {
   notifyGitStatusInvalidated(directory);
 };
 
@@ -162,9 +168,14 @@ export async function listGitDirectories(root: string): Promise<string[]> {
     .filter((path): path is string => path !== null);
 }
 
-export async function getGitStatus(directory: string, options?: { mode?: 'light' }): Promise<GitStatus> {
+export async function getGitStatus(directory: string, options?: { mode?: 'light'; fresh?: boolean }): Promise<GitStatus> {
   const mode = options?.mode;
   const runtimeKey = getRuntimeKey();
+  if (options?.fresh) {
+    // A forced read must cross the transport cache boundary too. Advancing the
+    // version also prevents an older in-flight response from repopulating it.
+    clearGitStatusCache(runtimeKey, directory);
+  }
   const key = getStatusCacheKey(runtimeKey, directory, mode);
   const now = Date.now();
   const cached = gitStatusCache.get(key);
diff --git a/packages/ui/src/lib/gitStatusInvalidation.ts b/packages/ui/src/lib/gitStatusInvalidation.ts
index 9e337365..effc8254 100644
--- a/packages/ui/src/lib/gitStatusInvalidation.ts
+++ b/packages/ui/src/lib/gitStatusInvalidation.ts
@@ -1,18 +1,18 @@
 /**
  * Minimal notification channel for git status invalidation.
  *
- * Every successful status-affecting git mutation must call
+ * Every confirmed status-affecting mutation must call
  * `notifyGitStatusInvalidated`. `useGitStore` subscribes and bumps its
  * per-directory status mutation revision so an immediate refresh cannot join an
  * in-flight status request admitted before the mutation, and a stale response
- * cannot commit over newer authoritative state.
+ * cannot commit over newer authoritative state. The HTTP adapter also subscribes
+ * and clears its short-lived status cache.
  *
  * Runtime parity: this is about the store's in-flight status request, not about
- * adapter caching, so it applies to every runtime. The HTTP adapter in
- * `gitApiHttp.ts` emits it where it clears its own cache; runtime adapters (the
- * VS Code bridge) have no cache of their own, so the dispatch layer in
- * `gitApi.ts` emits it for them after a successful runtime mutation. Either
- * path announces a mutation exactly once.
+ * adapter caching, so it applies to every runtime. HTTP mutations emit from
+ * `gitApiHttp.ts`; runtime adapters such as the VS Code bridge emit from the
+ * dispatch layer in `gitApi.ts`. Tool and editor mutations emit through the
+ * shared Git refresh hint. Each path announces a mutation exactly once.
  */
 
 type GitStatusInvalidationListener = (directory: string) => void;
diff --git a/packages/ui/src/lib/sessionEvents.ts b/packages/ui/src/lib/sessionEvents.ts
index 331383b6..07eba0f1 100644
--- a/packages/ui/src/lib/sessionEvents.ts
+++ b/packages/ui/src/lib/sessionEvents.ts
@@ -1,4 +1,6 @@
 import type { Session } from '@opencode-ai/sdk/v2';
+import type { Part } from '@opencode-ai/sdk/v2/client';
+import { notifyGitStatusInvalidated } from '@/lib/gitStatusInvalidation';
 import type { WorktreeMetadata } from '@/types/worktree';
 
 export type SessionDeleteRequest = {
@@ -24,6 +26,12 @@ const deleteListeners = new Set<DeleteListener>();
 const createListeners = new Set<CreateListener>();
 const directoryListeners = new Set<DirectoryListener>();
 const gitRefreshListeners = new Set<GitRefreshListener>();
+const gitMutatingTools = new Set(['bash', 'edit', 'write', 'apply_patch', 'patch']);
+
+const normalizeToolName = (tool: string): string => {
+  const parts = tool.trim().toLowerCase().split('.').filter(Boolean);
+  return parts[parts.length - 1] ?? '';
+};
 
 export const sessionEvents = {
   onDeleteRequest(listener: DeleteListener) {
@@ -67,6 +75,19 @@ export const sessionEvents = {
     if (!hint.directory.trim()) {
       return;
     }
+    notifyGitStatusInvalidated(hint.directory);
     gitRefreshListeners.forEach((listener) => listener(hint));
   },
+  requestGitRefreshForToolTransition(directory: string, previousPart: Part | undefined, nextPart: Part) {
+    if (nextPart.type !== 'tool' || nextPart.state.status !== 'completed') {
+      return;
+    }
+    if (previousPart?.type === 'tool' && previousPart.state.status === 'completed') {
+      return;
+    }
+    if (!gitMutatingTools.has(normalizeToolName(nextPart.tool))) {
+      return;
+    }
+    sessionEvents.requestGitRefresh({ directory });
+  },
 };
diff --git a/packages/ui/src/lib/worktrees/worktreeBootstrap.test.ts b/packages/ui/src/lib/worktrees/worktreeBootstrap.test.ts
index 89204a80..d94eb417 100644
--- a/packages/ui/src/lib/worktrees/worktreeBootstrap.test.ts
+++ b/packages/ui/src/lib/worktrees/worktreeBootstrap.test.ts
@@ -51,6 +51,7 @@ const {
   markWorktreeBootstrapPending,
   setWorktreeBootstrapState,
   startWorktreeBootstrapWatcher,
+  subscribeWorktreeBootstrapState,
   waitForWorktreeBootstrap,
   waitForWorktreeGitReady,
 } = await import('./worktreeBootstrap');
@@ -246,3 +247,39 @@ describe('worktreeBootstrap.waitForWorktreeBootstrap', () => {
     clearWorktreeBootstrapState('/repo-wt');
   });
 });
+
+describe('worktreeBootstrap subscription', () => {
+  beforeEach(() => {
+    clearWorktreeBootstrapState('/repo-wt');
+  });
+
+  test('notifies subscribers as a directory enters and leaves bootstrap', () => {
+    const pendingSnapshots: boolean[] = [];
+    const unsubscribe = subscribeWorktreeBootstrapState(() => {
+      pendingSnapshots.push(getWorktreeBootstrapState('/repo-wt')?.status === 'pending');
+    });
+
+    try {
+      markWorktreeBootstrapPending('/repo-wt');
+      setWorktreeBootstrapState('/repo-wt', { status: 'ready', error: null, updatedAt: 2 });
+      clearWorktreeBootstrapState('/repo-wt');
+    } finally {
+      unsubscribe();
+    }
+
+    expect(pendingSnapshots).toEqual([true, false, false]);
+  });
+
+  test('stops notifying after unsubscribe', () => {
+    let notifications = 0;
+    const unsubscribe = subscribeWorktreeBootstrapState(() => {
+      notifications += 1;
+    });
+
+    markWorktreeBootstrapPending('/repo-wt');
+    unsubscribe();
+    clearWorktreeBootstrapState('/repo-wt');
+
+    expect(notifications).toBe(1);
+  });
+});
diff --git a/packages/ui/src/lib/worktrees/worktreeBootstrap.ts b/packages/ui/src/lib/worktrees/worktreeBootstrap.ts
index 9b047a70..52b649ef 100644
--- a/packages/ui/src/lib/worktrees/worktreeBootstrap.ts
+++ b/packages/ui/src/lib/worktrees/worktreeBootstrap.ts
@@ -24,6 +24,23 @@ const watchers = new Map<string, { cancelled: boolean; lifecycleVersion: number
 const getKey = (directory: string): string => normalizePath(directory);
 const getWaiterKey = (key: string, target: WorktreeBootstrapTarget): string => `${key}\n${target}`;
 
+// UI surfaces subscribe to know when a directory enters or leaves bootstrap,
+// so a half-created worktree's transient files are never shown as changes.
+const bootstrapListeners = new Set<() => void>();
+
+const notifyBootstrapListeners = (): void => {
+  for (const listener of bootstrapListeners) {
+    listener();
+  }
+};
+
+export const subscribeWorktreeBootstrapState = (listener: () => void): (() => void) => {
+  bootstrapListeners.add(listener);
+  return () => {
+    bootstrapListeners.delete(listener);
+  };
+};
+
 const startLifecycle = (key: string): void => {
   const watcher = watchers.get(key);
   if (watcher) {
@@ -72,6 +89,7 @@ const storePolledState = (
   }
 
   state.set(key, next);
+  notifyBootstrapListeners();
   return next;
 };
 
@@ -98,6 +116,7 @@ export const markWorktreeBootstrapPending = (directory: string): void => {
     error: null,
     updatedAt: Date.now(),
   });
+  notifyBootstrapListeners();
 };
 
 export const clearWorktreeBootstrapState = (directory: string): void => {
@@ -108,6 +127,7 @@ export const clearWorktreeBootstrapState = (directory: string): void => {
   startLifecycle(key);
   state.delete(key);
   lifecycleVersions.delete(key);
+  notifyBootstrapListeners();
 };
 
 export const setWorktreeBootstrapState = (directory: string, next: WorktreeBootstrapState): void => {
@@ -117,6 +137,7 @@ export const setWorktreeBootstrapState = (directory: string, next: WorktreeBoots
   }
   startLifecycle(key);
   state.set(key, next);
+  notifyBootstrapListeners();
 };
 
 export const getWorktreeBootstrapState = (directory: string): WorktreeBootstrapState | null => {
diff --git a/packages/ui/src/lib/worktrees/worktreeCreate.test.ts b/packages/ui/src/lib/worktrees/worktreeCreate.test.ts
index 642e10db..ba792b48 100644
--- a/packages/ui/src/lib/worktrees/worktreeCreate.test.ts
+++ b/packages/ui/src/lib/worktrees/worktreeCreate.test.ts
@@ -15,9 +15,11 @@ let gitStatus: {
   behind: number;
 } | null = null;
 let branchTracking: MockBranchTracking = {};
+let isGitRepository = true;
 const createdPayloads: CreateWorktreeArgs[] = [];
 
 mock.module('@/lib/gitApi', () => ({
+  checkIsGitRepository: () => Promise.resolve(isGitRepository),
   getGitStatus: () => (gitStatus ? Promise.resolve(gitStatus) : Promise.reject(new Error('no status'))),
   getGitBranches: () => Promise.resolve({
     all: [],
@@ -52,7 +54,11 @@ mock.module('@/lib/worktrees/worktreeManager', () => ({
   },
 }));
 
-const { createWorktreeWithDefaults, withWorktreeRemoteStartRef } = await import('./worktreeCreate');
+const {
+  createWorktreeWithDefaults,
+  withWorktreeRemoteStartRef,
+  WorktreeRequiresGitRepositoryError,
+} = await import('./worktreeCreate');
 
 const baseArgs = (overrides: CreateWorktreeArgs = {}): CreateWorktreeArgs => ({
   preferredName: 'openchamber/feature',
@@ -168,9 +174,17 @@ describe('createWorktreeWithDefaults remote source integration', () => {
     projectRoot = '/repo';
     gitStatus = { current: 'main', tracking: 'origin/main', ahead: 0, behind: 0 };
     branchTracking = { main: 'origin/main' };
+    isGitRepository = true;
     createdPayloads.length = 0;
   });
 
+  test('rejects a non-Git project before asking the runtime to create a worktree', async () => {
+    isGitRepository = false;
+
+    await expect(createWorktreeWithDefaults(project, baseArgs())).rejects.toThrow(WorktreeRequiresGitRepositoryError);
+    expect(createdPayloads).toHaveLength(0);
+  });
+
   test('sets the new branch\'s own upstream when using the tracked remote source', async () => {
     gitStatus = { current: 'main', tracking: 'origin/main', ahead: 0, behind: 15 };
 
diff --git a/packages/ui/src/lib/worktrees/worktreeCreate.ts b/packages/ui/src/lib/worktrees/worktreeCreate.ts
index 52890f8f..da3c017d 100644
--- a/packages/ui/src/lib/worktrees/worktreeCreate.ts
+++ b/packages/ui/src/lib/worktrees/worktreeCreate.ts
@@ -1,8 +1,15 @@
-import { getGitBranches, getGitStatus } from '@/lib/gitApi';
+import { checkIsGitRepository, getGitBranches, getGitStatus } from '@/lib/gitApi';
 import type { CreateWorktreeArgs, ProjectRef } from '@/lib/worktrees/worktreeManager';
 import { createWorktree } from '@/lib/worktrees/worktreeManager';
 import { getRootBranch, resolveProjectRoot } from '@/lib/worktrees/worktreeStatus';
 
+export class WorktreeRequiresGitRepositoryError extends Error {
+  constructor() {
+    super('Worktree creation requires a Git repository');
+    this.name = 'WorktreeRequiresGitRepositoryError';
+  }
+}
+
 const parseTrackingRef = (tracking: string | null | undefined): { remote: string; branch: string } | null => {
   const value = String(tracking || '').trim().replace(/^remotes\//, '');
   if (!value) {
@@ -162,6 +169,10 @@ export const createWorktreeWithDefaults = async (
   args: CreateWorktreeArgs,
   options?: { resolvedRootTrackingRemote?: string | null }
 ) => {
+  const isGitRepository = await checkIsGitRepository(project.path);
+  if (!isGitRepository) {
+    throw new WorktreeRequiresGitRepositoryError();
+  }
   const remoteArgs = await withWorktreeRemoteStartRef(project, args);
   const resolvedArgs = await withWorktreeUpstreamDefaults(project.path, remoteArgs, options);
   return createWorktree(project, resolvedArgs);
diff --git a/packages/ui/src/lib/worktrees/worktreeManager.test.ts b/packages/ui/src/lib/worktrees/worktreeManager.test.ts
index 109fac8b..dc7bec50 100644
--- a/packages/ui/src/lib/worktrees/worktreeManager.test.ts
+++ b/packages/ui/src/lib/worktrees/worktreeManager.test.ts
@@ -118,6 +118,7 @@ const {
   getLatestWorktreeMetadata,
   listProjectWorktrees,
   partitionWorktreesByRegisteredProject,
+  removeProjectWorktree,
   validateWorktreeCreate,
   worktreeMapsEqual,
 } = await import('./worktreeManager');
@@ -389,6 +390,44 @@ describe('worktreeManager list invalidation', () => {
     expect(metadata.worktreeStatus).toBe('pending');
     expect(getLatestWorktreeMetadata(metadata).worktreeStatus).toBe('ready');
   });
+
+  test('removes a worktree from sidebar topology owned by another registered checkout', async () => {
+    const removed: WorktreeMetadata = {
+      path: '/worktrees/removed',
+      projectDirectory: '/repo',
+      branch: 'removed',
+      label: 'removed',
+    };
+    const sibling: WorktreeMetadata = {
+      path: '/worktrees/sibling',
+      projectDirectory: '/repo',
+      branch: 'sibling',
+      label: 'sibling',
+    };
+    const unrelatedEntries: WorktreeMetadata[] = [{
+      path: '/other/worktree',
+      projectDirectory: '/other',
+      branch: 'other',
+      label: 'other',
+    }];
+    sessionState.availableWorktreesByProject = new Map([
+      ['/worktrees/configured', [removed, sibling]],
+      ['/other', unrelatedEntries],
+    ]);
+    sessionState.availableWorktrees = [removed, sibling, ...unrelatedEntries];
+    sessionState.worktreeMetadata = new Map([
+      ['removed-session', removed],
+      ['sibling-session', sibling],
+    ]);
+
+    await removeProjectWorktree({ id: 'path:/repo', path: '/repo' }, removed);
+
+    expect(sessionState.availableWorktreesByProject.get('/worktrees/configured')).toEqual([sibling]);
+    expect(sessionState.availableWorktreesByProject.get('/other')).toBe(unrelatedEntries);
+    expect(sessionState.availableWorktrees).toEqual([sibling, ...unrelatedEntries]);
+    expect(sessionState.worktreeMetadata.has('removed-session')).toBe(false);
+    expect(sessionState.worktreeMetadata.get('sibling-session')).toBe(sibling);
+  });
 });
 
 describe('worktreeMapsEqual', () => {
diff --git a/packages/ui/src/lib/worktrees/worktreeManager.ts b/packages/ui/src/lib/worktrees/worktreeManager.ts
index b14de347..0fd1953b 100644
--- a/packages/ui/src/lib/worktrees/worktreeManager.ts
+++ b/packages/ui/src/lib/worktrees/worktreeManager.ts
@@ -606,14 +606,16 @@ export async function removeProjectWorktree(project: ProjectRef, worktree: Workt
 
   // Update sidebar store so removed worktree disappears immediately
   const normalizedWorktreePath = normalizePath(worktree.path);
-  const sidebarProjectKey = projectDirectory;
   const currentByProject = useSessionUIStore.getState().availableWorktreesByProject;
   const updatedByProject = new Map(currentByProject);
-  const projectWorktrees = updatedByProject.get(sidebarProjectKey) ?? [];
-  updatedByProject.set(
-    sidebarProjectKey,
-    projectWorktrees.filter((w) => normalizePath(w.path) !== normalizedWorktreePath),
-  );
+  for (const [projectKey, projectWorktrees] of currentByProject) {
+    const remainingWorktrees = projectWorktrees.filter(
+      (candidate) => normalizePath(candidate.path) !== normalizedWorktreePath,
+    );
+    if (remainingWorktrees.length !== projectWorktrees.length) {
+      updatedByProject.set(projectKey, remainingWorktrees);
+    }
+  }
 
   // Clean up worktreeMetadata for sessions in the removed worktree
   const currentMetadata = useSessionUIStore.getState().worktreeMetadata;
diff --git a/packages/ui/src/stores/DOCUMENTATION.md b/packages/ui/src/stores/DOCUMENTATION.md
index 38a08cd3..a910e279 100644
--- a/packages/ui/src/stores/DOCUMENTATION.md
+++ b/packages/ui/src/stores/DOCUMENTATION.md
@@ -156,7 +156,8 @@ Important properties:
 - status, branches, log, identity, repository probes, and prefetch diffs commit through runtime and per-channel generations
 - status mutations advance a revision so older refreshes cannot undo optimistic or confirmed index changes
 - a successful status-affecting git mutation also advances that revision: the HTTP adapter's cache invalidation notifies the store through `lib/gitStatusInvalidation.ts` (the VS Code bridge adapter has no client-side status cache, so it emits nothing today)
-- `fetchAll({ force: true })` forces the status fetch as well as the log refresh
+- `fetchStatus({ force: true })` and `fetchAll({ force: true })` cross both the store and runtime transport caches; a forced reconciliation must reach the active runtime rather than reuse an unexpired browser status snapshot
+- status requests do not start while a managed worktree bootstrap is pending, and a response admitted before bootstrap began is discarded if it completes after the directory enters `pending`; the `--no-checkout` population window is not user working-tree state
 - branch persistence is versioned, bounded, runtime-scoped, and claims the ambiguous legacy cache once
 - diff data has per-directory and aggregate count/UTF-8-byte limits; oversized single entries are rejected
 
@@ -220,11 +221,29 @@ Each of them therefore keeps two things:
   tracks the **active** project only.
 
 Thinking variants keep the effective value in `currentVariant` so existing send
-paths capture a stable configuration. The transient `currentVariantSelection`
-distinguishes automatic initialization from a picker or shortcut choosing an
-explicit override or `Default`; returning to `Default` restores its inherited
-effective value. Only explicit overrides are stored in the per-session
-selection store.
+paths capture a stable configuration. `currentVariantSelection` says where that
+value came from: a string is an effort chosen in the picker or by the shortcut,
+`null` is an explicit `Default`, and `undefined` is automatic initialization,
+which lets the inherited default apply.
+
+`Default` sends no effort at all. It cannot resolve back to the inherited
+default: the settings default would take effect again, and the next assistant
+reply echoes that effort back as an explicit choice, so the picker jumps off
+`Default` one message after the user chose it. For the same reason the
+per-session selection store records an explicit `Default` (as `null`) instead of
+clearing the entry — a cleared entry is indistinguishable from never having
+chosen, and the settings default wins again on the next agent or session switch.
+
+Only a place where the user chose may write `null`. Restore paths — message
+history, a preserved manual override — pass their own "found nothing" through
+as `undefined`, because a session whose history carries no effort is not a
+session where `Default` was picked. A restore that manufactures `null` latches
+the session onto `Default`: `null` outranks the agent and settings defaults by
+design, so the concrete effort it displaced can never come back.
+
+Every write of `currentVariant` writes `currentVariantSelection` with it. They
+are one selection; updating only the effective value leaves the picker showing
+one effort while sends carry another.
 
 Every loader and mutation takes an explicit directory; omitting it means the
 active project, which is what non-Settings callers pass. A load for another
@@ -317,9 +336,11 @@ Do not raise limits casually.
 Expected model:
 
 - `GitView` / `DiffView` ensure current-directory Git state when visible
+- the Git view gates its status-derived content and actions while a managed worktree bootstrap is pending, then keeps the gate closed until one forced fresh status read succeeds; refresh failure exposes retry without revealing the cached bootstrap snapshot
 - explicit Git actions refresh status/branches/log as needed
 - every status-affecting git mutation invalidates the HTTP adapter's status cache on its success path (failed mutations invalidate nothing), so the follow-up refresh is authoritative instead of the pre-mutation cache entry
-- a mounted file-mutating tool issues a one-shot Git refresh hint when it transitions from active to successfully finalized; remounting historical completed tools does not replay the hint
+- the sync event handler issues one Git refresh hint when a live file-mutating tool first reaches `completed`; this does not depend on `ToolPart` mounting, and duplicate terminal events do not replay the hint
+- every Git refresh hint invalidates the store request generation and the HTTP status cache before visible consumers request status, so they share one post-mutation read instead of accepting a cached or pre-mutation response
 - a successful dirty save from the in-app file editor issues a path-scoped Git refresh hint; clean autosave checks remain no-ops
 - refresh hints with authoritative file paths invalidate only those cached and currently rendered diffs before status refresh; pathless tools request status reconciliation without broadly remounting DiffView
 - targeted diff remounts preserve the user's current file-section anchor and intra-file offset before paint instead of resetting the stacked view to the top
diff --git a/packages/ui/src/stores/contextStore.ts b/packages/ui/src/stores/contextStore.ts
index ad824f15..7ee4d7c0 100644
--- a/packages/ui/src/stores/contextStore.ts
+++ b/packages/ui/src/stores/contextStore.ts
@@ -24,8 +24,10 @@ interface ContextState {
 
     sessionAgentModelSelections: Map<string, Map<string, { providerId: string; modelId: string }>>;
 
-    // sessionId → agentName → "providerId/modelId" → variant
-    sessionAgentModelVariantSelections: Map<string, Map<string, Map<string, string>>>;
+    // sessionId → agentName → "providerId/modelId" → variant, where `null` is
+    // an explicit "Default" (send no effort) and a missing entry means the
+    // inherited default applies.
+    sessionAgentModelVariantSelections: Map<string, Map<string, Map<string, string | null>>>;
  
     currentAgentContext: Map<string, string>;
 
@@ -45,8 +47,8 @@ interface ContextActions {
     saveAgentModelForSession: (sessionId: string, agentName: string, providerId: string, modelId: string) => void;
     getAgentModelForSession: (sessionId: string, agentName: string) => { providerId: string; modelId: string } | null;
 
-    saveAgentModelVariantForSession: (sessionId: string, agentName: string, providerId: string, modelId: string, variant: string | undefined) => void;
-    getAgentModelVariantForSession: (sessionId: string, agentName: string, providerId: string, modelId: string) => string | undefined;
+    saveAgentModelVariantForSession: (sessionId: string, agentName: string, providerId: string, modelId: string, variant: string | null | undefined) => void;
+    getAgentModelVariantForSession: (sessionId: string, agentName: string, providerId: string, modelId: string) => string | null | undefined;
 
 
     getContextUsage: (sessionId: string, contextLimit: number, outputLimit: number, messages: Map<string, { info: any; parts: any[] }[]>) => ContextUsage | null;
@@ -145,7 +147,7 @@ export const useContextStore = create<ContextStore>()(
                     return agentMap.get(agentName) || null;
                 },
 
-                saveAgentModelVariantForSession: (sessionId: string, agentName: string, providerId: string, modelId: string, variant: string | undefined) => {
+                saveAgentModelVariantForSession: (sessionId: string, agentName: string, providerId: string, modelId: string, variant: string | null | undefined) => {
                     set((state) => {
                         const newSelections = new Map(state.sessionAgentModelVariantSelections);
 
diff --git a/packages/ui/src/stores/useConfigStore.test.ts b/packages/ui/src/stores/useConfigStore.test.ts
index 5ac465ff..2039ae52 100644
--- a/packages/ui/src/stores/useConfigStore.test.ts
+++ b/packages/ui/src/stores/useConfigStore.test.ts
@@ -544,7 +544,8 @@ describe('useConfigStore provider persistence', () => {
 
     useConfigStore.getState().setCurrentVariantOverride('max', 'high');
     expect(useConfigStore.getState().cycleCurrentVariant()).toBe(undefined);
-    expect(useConfigStore.getState().currentVariant).toBe('high');
+    // Default is a choice to send no effort, not a way back to the inherited one.
+    expect(useConfigStore.getState().currentVariant).toBe(undefined);
     expect(useConfigStore.getState().currentVariantSelection).toEqual({ override: null, inherited: 'high' });
   });
 
@@ -562,7 +563,7 @@ describe('useConfigStore provider persistence', () => {
     expect(useConfigStore.getState().currentVariantSelection.override).toBe('high');
     expect(useConfigStore.getState().cycleCurrentVariant()).toBe(undefined);
     expect(useConfigStore.getState().currentVariantSelection.override).toBeNull();
-    expect(useConfigStore.getState().currentVariant).toBe('high');
+    expect(useConfigStore.getState().currentVariant).toBe(undefined);
   });
 
   test('an unavailable explicit variant cycles back to Default', () => {
@@ -576,7 +577,7 @@ describe('useConfigStore provider persistence', () => {
     });
 
     expect(useConfigStore.getState().cycleCurrentVariant()).toBe(undefined);
-    expect(useConfigStore.getState().currentVariant).toBe('low');
+    expect(useConfigStore.getState().currentVariant).toBe(undefined);
     expect(useConfigStore.getState().currentVariantSelection.override).toBeNull();
   });
 
@@ -608,6 +609,73 @@ describe('useConfigStore provider persistence', () => {
     expect(useConfigStore.getState().currentVariant).toBe('medium');
   });
 
+  test('an explicit Default effort sends no variant instead of the settings default', () => {
+    useConfigStore.setState({
+      activeDirectoryKey: DIRECTORY,
+      providers: [provider('openai', 'gpt-5.5', { low: {}, high: {} })],
+      currentProviderId: 'openai',
+      currentModelId: 'gpt-5.5',
+      currentVariant: 'low',
+      currentVariantSelection: { override: 'low', inherited: 'low' },
+      settingsDefaultVariant: 'low',
+      directoryScoped: {},
+    });
+
+    useConfigStore.getState().setCurrentVariantOverride(null, 'low');
+
+    expect(useConfigStore.getState().currentVariant).toBe(undefined);
+    expect(useConfigStore.getState().currentVariantSelection).toEqual({ override: null, inherited: 'low' });
+  });
+
+  test('setAgent keeps a session Default effort instead of restoring the settings default', () => {
+    const sessionId = 'ses_agent_default_effort';
+    useSessionUIStore.setState({ currentSessionId: sessionId });
+    useSelectionStore.getState().saveAgentModelForSession(sessionId, 'plan', 'openai', 'gpt-5.5');
+    useSelectionStore.getState().saveAgentModelVariantForSession(sessionId, 'plan', 'openai', 'gpt-5.5', null);
+    useConfigStore.setState({
+      activeDirectoryKey: DIRECTORY,
+      providers: [provider('openai', 'gpt-5.5', { low: {}, high: {} })],
+      agents: [testAgent('plan')],
+      settingsDefaultVariant: 'low',
+      currentProviderId: 'openai',
+      currentModelId: 'gpt-5.5',
+      currentVariant: 'low',
+      currentVariantSelection: { override: undefined, inherited: 'low' },
+      directoryScoped: {},
+    });
+
+    useConfigStore.getState().setAgent('plan');
+
+    const state = useConfigStore.getState();
+    expect(state.currentVariant).toBe(undefined);
+    expect(state.currentVariantSelection).toEqual({ override: null, inherited: 'low' });
+    expect(state.directoryScoped[DIRECTORY]?.currentVariant).toBe(undefined);
+  });
+
+  test('setAgent reports the same effort through currentVariant and the picker selection', () => {
+    const sessionId = 'ses_agent_effort_in_sync';
+    useSessionUIStore.setState({ currentSessionId: sessionId });
+    useSelectionStore.getState().saveAgentModelForSession(sessionId, 'plan', 'openai', 'gpt-5.5');
+    useSelectionStore.getState().saveAgentModelVariantForSession(sessionId, 'plan', 'openai', 'gpt-5.5', 'high');
+    useConfigStore.setState({
+      activeDirectoryKey: DIRECTORY,
+      providers: [provider('openai', 'gpt-5.5', { low: {}, high: {} })],
+      agents: [testAgent('plan')],
+      settingsDefaultVariant: 'low',
+      currentProviderId: 'openai',
+      currentModelId: 'gpt-5.5',
+      currentVariant: 'low',
+      currentVariantSelection: { override: 'low', inherited: 'low' },
+      directoryScoped: {},
+    });
+
+    useConfigStore.getState().setAgent('plan');
+
+    const state = useConfigStore.getState();
+    expect(state.currentVariant).toBe('high');
+    expect(state.currentVariantSelection).toEqual({ override: 'high', inherited: 'low' });
+  });
+
   test('setAgent applies settings default variant for a saved session agent model', () => {
     const sessionId = 'ses_existing_agent_model_default_variant';
     useSessionUIStore.setState({ currentSessionId: sessionId });
diff --git a/packages/ui/src/stores/useConfigStore.ts b/packages/ui/src/stores/useConfigStore.ts
index 66f1487e..aef723b1 100644
--- a/packages/ui/src/stores/useConfigStore.ts
+++ b/packages/ui/src/stores/useConfigStore.ts
@@ -904,11 +904,28 @@ interface DirectoryScopedConfig {
     selectionSource?: "auto" | "manual";
 }
 
+/**
+ * The thinking-effort selection, split into what the user picked and what
+ * applies when they picked nothing:
+ *
+ * - `override: string`    an effort chosen in the picker
+ * - `override: null`      "Default" chosen in the picker — send no effort
+ * - `override: undefined` nothing chosen — the inherited default applies
+ *
+ * `null` and `undefined` are not interchangeable: collapsing them makes the
+ * "Default" entry unpickable, because the settings default silently takes
+ * effect again and the next assistant reply echoes it back as an explicit
+ * choice.
+ */
 type CurrentVariantSelection = {
     override: string | null | undefined;
     inherited: string | undefined;
 };
 
+const resolveVariantFromSelection = (selection: CurrentVariantSelection): string | undefined => (
+    selection.override === null ? undefined : selection.override ?? selection.inherited
+);
+
 /**
  * Lift the active directory's cached provider/agent snapshot into the top-level
  * fields the pickers read (`providers`, `agents`, selections), so a cold start
@@ -1902,7 +1919,7 @@ export const useConfigStore = create<ConfigStore>()(
 
                 setCurrentVariantOverride: (override, inherited) => {
                     set((state) => {
-                        const currentVariant = override ?? inherited;
+                        const currentVariant = resolveVariantFromSelection({ override, inherited });
                         if (
                             state.currentVariant === currentVariant
                             && state.currentVariantSelection.override === override
@@ -2527,8 +2544,27 @@ export const useConfigStore = create<ConfigStore>()(
                     if (agentName) {
                         const { currentSessionId } = useSessionUIStore.getState();
 
-                        const applyResolvedModelSelection = (providerId: string, modelId: string, variant?: string) => {
+                        // Writes the effort alongside the model, because the two are one
+                        // selection: leaving `currentVariantSelection` behind would let the
+                        // picker show one effort while sends carry another.
+                        const applyResolvedModelSelection = (
+                            providerId: string,
+                            modelId: string,
+                            variantSelection: CurrentVariantSelection,
+                        ) => {
                             set((state) => {
+                                const variant = resolveVariantFromSelection(variantSelection);
+                                if (
+                                    state.currentProviderId === providerId
+                                    && state.currentModelId === modelId
+                                    && state.currentVariant === variant
+                                    && state.currentVariantSelection.override === variantSelection.override
+                                    && state.currentVariantSelection.inherited === variantSelection.inherited
+                                    && state.selectionSource === "manual"
+                                ) {
+                                    return state;
+                                }
+
                                 const directoryKey = state.activeDirectoryKey;
                                 const baseSnapshot: DirectoryScopedConfig = state.directoryScoped[directoryKey] ?? {
                                     providers: state.providers,
@@ -2554,6 +2590,7 @@ export const useConfigStore = create<ConfigStore>()(
                                     currentProviderId: providerId,
                                     currentModelId: modelId,
                                     currentVariant: variant,
+                                    currentVariantSelection: variantSelection,
                                     selectionSource: "manual",
                                     directoryScoped: {
                                         ...state.directoryScoped,
@@ -2563,16 +2600,24 @@ export const useConfigStore = create<ConfigStore>()(
                             });
                         };
 
-                        const resolveVariantForModel = (
+                        const resolveVariantSelectionForModel = (
                             providerId: string,
                             modelId: string,
                             agentVariant?: string,
-                        ): string | undefined => {
+                        ): CurrentVariantSelection => {
                             const model = providers
                                 .find((provider) => provider.id === providerId)
                                 ?.models.find((candidate) => candidate.id === modelId) as { variants?: Record<string, unknown> } | undefined;
                             const variants = model?.variants;
-                            if (!variants) return undefined;
+                            if (!variants) return { override: undefined, inherited: undefined };
+
+                            const isAvailable = (candidate: string | null | undefined): candidate is string => (
+                                candidate !== null
+                                && candidate !== undefined
+                                && Object.prototype.hasOwnProperty.call(variants, candidate)
+                            );
+
+                            const inherited = [agentVariant, settingsDefaultVariant].find(isAvailable);
 
                             const savedVariant = currentSessionId
                                 ? useSelectionStore.getState().getAgentModelVariantForSession(
@@ -2582,14 +2627,23 @@ export const useConfigStore = create<ConfigStore>()(
                                     modelId,
                                 )
                                 : undefined;
-
-                            for (const candidate of [savedVariant, agentVariant, settingsDefaultVariant]) {
-                                if (candidate && Object.prototype.hasOwnProperty.call(variants, candidate)) {
-                                    return candidate;
-                                }
+                            // `null` is this session's explicit "Default"; it outranks
+                            // the agent and settings defaults just like a named effort.
+                            if (savedVariant === null || isAvailable(savedVariant)) {
+                                return { override: savedVariant, inherited };
                             }
 
-                            return undefined;
+                            // While drafting there is no session record to read the choice
+                            // back from, and switching agent is not a change of effort:
+                            // keep the picker's choice for this same model, "Default"
+                            // (an explicit `null`) included.
+                            const liveSelection = get().currentVariantSelection;
+                            const sameModel = get().currentProviderId === providerId && get().currentModelId === modelId;
+                            if (!currentSessionId && sameModel && (liveSelection.override === null || isAvailable(liveSelection.override))) {
+                                return { override: liveSelection.override, inherited };
+                            }
+
+                            return { override: undefined, inherited };
                         };
 
                         const agent = agents.find((candidate) => candidate.name === agentName);
@@ -2601,14 +2655,11 @@ export const useConfigStore = create<ConfigStore>()(
                         if (currentSessionId) {
                             const existingAgentModel = useSelectionStore.getState().getAgentModelForSession(currentSessionId, agentName);
                             if (existingAgentModel && hasProviderModel(providers, existingAgentModel.providerId, existingAgentModel.modelId)) {
-                                const resolvedVariant = resolveVariantForModel(existingAgentModel.providerId, existingAgentModel.modelId, agent?.variant);
-                                if (
-                                    currentProviderId !== existingAgentModel.providerId
-                                    || currentModelId !== existingAgentModel.modelId
-                                    || get().currentVariant !== resolvedVariant
-                                ) {
-                                    applyResolvedModelSelection(existingAgentModel.providerId, existingAgentModel.modelId, resolvedVariant);
-                                }
+                                applyResolvedModelSelection(
+                                    existingAgentModel.providerId,
+                                    existingAgentModel.modelId,
+                                    resolveVariantSelectionForModel(existingAgentModel.providerId, existingAgentModel.modelId, agent?.variant),
+                                );
                                 return;
                             }
                         }
@@ -2621,7 +2672,7 @@ export const useConfigStore = create<ConfigStore>()(
                             const agentModel = agentProvider?.models.find((model) => model.id === modelID);
 
                             if (agentModel) {
-                                applyResolvedModelSelection(providerID, modelID, resolveVariantForModel(providerID, modelID, agent?.variant));
+                                applyResolvedModelSelection(providerID, modelID, resolveVariantSelectionForModel(providerID, modelID, agent?.variant));
                                 return;
                             }
                         }
@@ -2653,7 +2704,7 @@ export const useConfigStore = create<ConfigStore>()(
                             if (parsed) {
                                 const settingsProvider = providers.find((p) => p.id === parsed.providerId);
                                 if (settingsProvider?.models.some((m) => m.id === parsed.modelId)) {
-                                    applyResolvedModelSelection(parsed.providerId, parsed.modelId, resolveVariantForModel(parsed.providerId, parsed.modelId, agent?.variant));
+                                    applyResolvedModelSelection(parsed.providerId, parsed.modelId, resolveVariantSelectionForModel(parsed.providerId, parsed.modelId, agent?.variant));
                                     return;
                                 }
                             }
diff --git a/packages/ui/src/stores/useGitStore.test.ts b/packages/ui/src/stores/useGitStore.test.ts
index e96445b9..9ba64150 100644
--- a/packages/ui/src/stores/useGitStore.test.ts
+++ b/packages/ui/src/stores/useGitStore.test.ts
@@ -3,6 +3,7 @@ import type { GitStatus } from '@/lib/api/types';
 import { useGitStore } from './useGitStore';
 import { getRuntimeKey } from '@/lib/runtime-switch';
 import { notifyGitStatusInvalidated } from '@/lib/gitStatusInvalidation';
+import { clearWorktreeBootstrapState, markWorktreeBootstrapPending } from '@/lib/worktrees/worktreeBootstrap';
 
 // The real transport has no server in tests and fails as a generic error.
 // Tests that exercise other failure modes swap this implementation; the
@@ -86,6 +87,7 @@ const createGitApi = (getGitStatus: GitAPI['getGitStatus']): GitAPI => ({
 
 describe('useGitStore', () => {
   beforeEach(() => {
+    clearWorktreeBootstrapState('/repo');
     useGitStore.getState().resetForRuntimeSwitch(getRuntimeKey());
   });
 
@@ -198,8 +200,10 @@ describe('useGitStore', () => {
     setDirectoryStatus(createStatus());
     const requests: Deferred<GitStatus>[] = [];
     let statusCalls = 0;
-    const git = createGitApi(() => {
+    const statusOptions: Array<{ mode?: 'light'; fresh?: boolean } | undefined> = [];
+    const git = createGitApi((_directory, options) => {
       statusCalls += 1;
+      statusOptions.push(options);
       const request = createDeferred<GitStatus>();
       requests.push(request);
       return request.promise;
@@ -212,6 +216,7 @@ describe('useGitStore', () => {
     const all = useGitStore.getState().fetchAll('/repo', git, { force: true });
     await Promise.resolve();
     expect(statusCalls).toBe(2);
+    expect(statusOptions).toEqual([undefined, { fresh: true }]);
 
     requests[1].resolve({ ...createStatus(), current: 'feature' });
     requests[0].resolve(createStatus());
@@ -220,6 +225,56 @@ describe('useGitStore', () => {
     expect(useGitStore.getState().getDirectoryState('/repo')?.status?.current).toBe('feature');
   });
 
+  test('does not request status while worktree bootstrap is pending', async () => {
+    setDirectoryStatus(createStatus());
+    let statusCalls = 0;
+    const git = createGitApi(async () => {
+      statusCalls += 1;
+      return createStatus(undefined, [{ path: 'bootstrap.ts', index: 'D', working_dir: ' ' }]);
+    });
+
+    markWorktreeBootstrapPending('/repo');
+    const changed = await useGitStore.getState().fetchStatus('/repo', git, { force: true });
+
+    expect(changed).toBe(false);
+    expect(statusCalls).toBe(0);
+    expect(useGitStore.getState().getDirectoryState('/repo')?.status?.files).toEqual([]);
+  });
+
+  test('does not publish a status response after bootstrap becomes pending', async () => {
+    setDirectoryStatus(createStatus());
+    const request = createDeferred<GitStatus>();
+    const git = createGitApi(() => request.promise);
+
+    const loading = useGitStore.getState().fetchStatus('/repo', git, { silent: true });
+    await Promise.resolve();
+    markWorktreeBootstrapPending('/repo');
+    request.resolve(createStatus(undefined, [{ path: 'bootstrap.ts', index: 'D', working_dir: ' ' }]));
+
+    expect(await loading).toBe(false);
+    expect(useGitStore.getState().getDirectoryState('/repo')?.status?.files).toEqual([]);
+  });
+
+  test('can propagate a forced status failure to a reconciliation owner', async () => {
+    setDirectoryStatus(createStatus());
+    const git = createGitApi(async () => {
+      throw new Error('offline');
+    });
+    const originalConsoleError = console.error;
+    console.error = () => undefined;
+
+    try {
+      await expect(useGitStore.getState().fetchStatus('/repo', git, {
+        force: true,
+        silent: true,
+        throwOnError: true,
+      })).rejects.toThrow('offline');
+      expect(useGitStore.getState().getDirectoryState('/repo')?.status?.files).toEqual([]);
+    } finally {
+      console.error = originalConsoleError;
+    }
+  });
+
   test('does not let an older status fetch undo an optimistic mutation', async () => {
     const initial = createStatus(undefined, [{ path: 'src/index.ts', index: ' ', working_dir: 'M' }]);
     setDirectoryStatus(initial);
diff --git a/packages/ui/src/stores/useGitStore.ts b/packages/ui/src/stores/useGitStore.ts
index 341a77a6..a91795e3 100644
--- a/packages/ui/src/stores/useGitStore.ts
+++ b/packages/ui/src/stores/useGitStore.ts
@@ -11,6 +11,7 @@ import { getDeferredSafeStorage } from '@/stores/utils/safeStorage';
 import { getRuntimeKey } from '@/lib/runtime-switch';
 import { GitDirectoriesUnsupportedError, listGitDirectories } from '@/lib/gitApiHttp';
 import { subscribeGitStatusInvalidations } from '@/lib/gitStatusInvalidation';
+import { getWorktreeBootstrapState } from '@/lib/worktrees/worktreeBootstrap';
 
 const LOG_STALE_THRESHOLD = 10000;
 const REPO_CHECK_STALE_THRESHOLD = 60_000;
@@ -28,6 +29,7 @@ const DIFF_CACHE_MAX_ENTRIES = 30;
 const DIFF_CACHE_MAX_TOTAL_SIZE_BYTES = 20 * 1024 * 1024; // 20MB
 const DIFF_CACHE_MAX_GLOBAL_ENTRIES = 200;
 type GitStatusFetchMode = 'full' | 'light';
+type GitStatusRequestOptions = { mode?: 'light'; fresh?: boolean };
 
 // Discovery outcome for a root that is not itself a git repository. The three
 // states are mutually exclusive: a repository list (possibly empty), a failed
@@ -64,7 +66,7 @@ interface GitStore {
   setActiveDirectory: (directory: string | null) => void;
   getDirectoryState: (directory: string) => DirectoryGitState | null;
 
-  fetchStatus: (directory: string, git: GitAPI, options?: { silent?: boolean; mode?: 'light'; force?: boolean }) => Promise<boolean>;
+  fetchStatus: (directory: string, git: GitAPI, options?: { silent?: boolean; mode?: 'light'; force?: boolean; throwOnError?: boolean }) => Promise<boolean>;
   fetchBranches: (directory: string, git: GitAPI) => Promise<void>;
   fetchLog: (directory: string, git: GitAPI, maxCount?: number) => Promise<void>;
   fetchIdentity: (directory: string, git: GitAPI) => Promise<void>;
@@ -115,7 +117,7 @@ interface GitFileDiffResponse {
 
 interface GitAPI {
   checkIsGitRepository: (directory: string) => Promise<boolean>;
-  getGitStatus: (directory: string, options?: { mode?: 'light' }) => Promise<GitStatus>;
+  getGitStatus: (directory: string, options?: GitStatusRequestOptions) => Promise<GitStatus>;
   getGitBranches: (directory: string) => Promise<GitBranch>;
   getGitLog: (directory: string, options?: { maxCount?: number }) => Promise<GitLogResponse>;
   getCurrentGitIdentity: (directory: string) => Promise<GitIdentitySummary | null>;
@@ -692,6 +694,9 @@ export const useGitStore = create<GitStore>()(
       },
 
       fetchStatus: async (directory, git, options = {}) => {
+        if (getWorktreeBootstrapState(directory)?.status === 'pending') {
+          return false;
+        }
         const statusFetchMode: GitStatusFetchMode = options.mode ?? 'full';
         const runtimeKey = getRuntimeKey();
         const statusFetchKey = getStatusFetchKey(runtimeKey, directory, statusFetchMode);
@@ -757,8 +762,17 @@ export const useGitStore = create<GitStore>()(
               return false;
             }
 
-            const newStatus = await git.getGitStatus(directory, options.mode ? { mode: options.mode } : undefined);
+            let statusOptions: GitStatusRequestOptions | undefined;
+            if (options.mode || options.force) {
+              statusOptions = {};
+              if (options.mode) statusOptions.mode = options.mode;
+              if (options.force) statusOptions.fresh = true;
+            }
+            const newStatus = await git.getGitStatus(directory, statusOptions);
             if (!isRequestCurrent(token, directory)) return false;
+            // A request admitted before worktree creation must not publish a
+            // transient --no-checkout/reset snapshot after bootstrap begins.
+            if (getWorktreeBootstrapState(directory)?.status === 'pending') return false;
 
             const latestState = get().directories.get(directory) ?? createEmptyDirectoryState();
             if (hasStatusChanged(latestState.status, newStatus)) {
@@ -830,6 +844,9 @@ export const useGitStore = create<GitStore>()(
             }
           } catch (error) {
             console.error('Failed to fetch git status:', error);
+            if (options.throwOnError) {
+              throw error;
+            }
           } finally {
             if (!silent && isRequestCurrent(token, directory)) {
               const newDirectories = new Map(get().directories);
diff --git a/packages/ui/src/sync/DOCUMENTATION.md b/packages/ui/src/sync/DOCUMENTATION.md
index 4eb87ab4..95b9359c 100644
--- a/packages/ui/src/sync/DOCUMENTATION.md
+++ b/packages/ui/src/sync/DOCUMENTATION.md
@@ -290,6 +290,7 @@ Rules:
 8. A prompt send that fails **after** the request left the client is ambiguous, never a definite failure: the server may already be answering it. Transports tag those errors (`markAmbiguousTransportFailure` in `@/lib/relay/transport-error`; the relay tunnel tags every stream that dies with a request in flight), and `isAmbiguousSendFailure` reads the tag before falling back to status/text heuristics. An ambiguous failure waits for the connection to return, refetches recent messages, and confirms the optimistic message in place instead of rolling it back — rolling it back lets the message queue re-send a prompt the engine is already running, producing two independent AI responses for one user message.
 9. `SessionLiveActivity` has three answers and `unknown` is never `idle`. `getSessionLiveActivity` reports `active` when any child store or the global session-status index holds a non-idle status, `idle` only when a child store actually covers the session's directory, and `unknown` otherwise — child stores are evicted for background directories, and the global index keeps only non-idle entries, so absence of a status is not proof of idleness. Callers that gate a destructive action (worktree moves) must refuse on `unknown`.
 10. Revert and unrevert cascade through known descendant sessions before mutating the parent. Revert uses the first descendant user message at or after the parent's target timestamp, including equal timestamps because message IDs do not define chronology. A descendant failure is logged and does not block its siblings or the parent. The parent runs last so its shared-directory file snapshot remains authoritative. A busy descendant is aborted before it is reverted, like the parent, so nothing keeps writing past the revert boundary. Redo clears the revert marker on every descendant, including markers the user set on a subagent independently of the parent undo.
+11. Starting a session from an assistant answer carries the source session ID, rendered directory, and answer text into the action. It must not rediscover that context from the globally active child store or the OpenCode client's fallback directory: the visible session may belong to an existing worktree while the active provider directory points elsewhere. New isolated worktrees resolve their registered parent project from that captured directory, preferring recorded worktree metadata when available. The dialog offers creation only after the project root is confirmed as a Git repository, and the creation boundary repeats that check so stale or bypassed UI state cannot run Git commands against a non-repository directory; failures leave the dialog open and visible.
 
 Examples of global-store updates performed in `session-actions.ts`:
 
@@ -371,6 +372,14 @@ The global sessions store persists and hydrates one bounded, runtime-scoped star
 
 VS Code intentionally has no managed Chats mode. It neither reads nor writes the managed Chats startup cache, regular drafts continue to target the open workspace, and the global session store rejects managed chat sessions from both snapshots and live upserts before any VS Code surface can consume them. Sidebar and switcher filters repeat that exclusion defensively.
 
+### Remembering the last draft target
+
+`session-ui-store.ts` persists the side of the composer's target selector the user last worked on under `oc.chatInput.lastDraftTarget`, so a plain new session reopens there instead of always landing on Chat. The record holds a project id, a directory, and `target`, which is `"chat"`, `"project"`, or `null`.
+
+`null` is what a record written before `target` existed reads as, and it leaves the Chat default in place rather than guessing a side from the directory. A recorded project that no longer exists falls back to Chat the same way. Only a picker choice writes `"chat"` or `"project"`.
+
+A session's own directory is not a target choice. "New session in the current directory" forwards the current session's directory even when that session is a managed chat, and a chat scratch directory names no project, so those overrides resolve to a chat draft. Treating one as an explicit project target is how a plus pressed inside a chat opened a project draft.
+
 When creating a draft in `handleDirectoryEvent`, **only clone the state fields the event will mutate**. Never spread all fields eagerly.
 
 ```typescript
diff --git a/packages/ui/src/sync/__tests__/issue-2039.test.ts b/packages/ui/src/sync/__tests__/issue-2039.test.ts
index b6fe2b09..39c658ac 100644
--- a/packages/ui/src/sync/__tests__/issue-2039.test.ts
+++ b/packages/ui/src/sync/__tests__/issue-2039.test.ts
@@ -6,6 +6,8 @@ const createSessionCalls: Array<{ title?: string; directory: string | null; pare
 const permissionAutoAcceptCalls: Array<[string, boolean]> = []
 const savedVariantCalls: Array<string | undefined> = []
 let configVariantOverride: string | null | undefined
+let projects: Array<{ id: string; path: string; label: string }> = []
+const createdWorktreeProjects: Array<{ id: string; path: string }> = []
 // Sync's session→directory index. `createSession` writes it, and directory
 // resolution reads it as the authoritative source, so the mock has to keep one.
 const sessionDirectoryRegistry = new Map<string, string>()
@@ -111,7 +113,7 @@ mock.module("@/stores/useConfigStore", () => ({
 mock.module("@/stores/useProjectsStore", () => ({
   useProjectsStore: {
     getState: () => ({
-      projects: [],
+      projects,
       activeProjectId: null,
       getActiveProject: () => null,
     }),
@@ -127,6 +129,12 @@ mock.module("@/stores/useDirectoryStore", () => ({
   },
 }))
 
+mock.module("@/stores/useSessionGoalArmStore", () => ({
+  useSessionGoalArmStore: {
+    getState: () => ({ setArmed: () => undefined }),
+  },
+}))
+
 mock.module("@/stores/useGlobalSessionsStore", () => ({
   useGlobalSessionsStore: {
     getState: () => ({
@@ -304,6 +312,33 @@ mock.module("../session-actions", () => ({
   abortCurrentOperation: mock(async () => undefined),
 }))
 
+mock.module("@/lib/git/branchNameGenerator", () => ({
+  generateBranchName: () => "generated-branch",
+}))
+
+mock.module("@/lib/openchamberConfig", () => ({
+  getWorktreeSetupCommands: async () => [],
+  getWorktreeSetupWaitEnabled: async () => false,
+}))
+
+mock.module("@/lib/worktrees/worktreeBootstrap", () => ({
+  waitForWorktreeBootstrap: async () => undefined,
+}))
+
+mock.module("@/lib/worktrees/worktreeCreate", () => ({
+  createWorktreeWithDefaults: async (project: { id: string; path: string }) => {
+    createdWorktreeProjects.push(project)
+    return {
+      source: "sdk",
+      name: "generated-branch",
+      path: "/worktrees/generated-branch",
+      projectDirectory: project.path,
+      branch: "generated-branch",
+      label: "generated-branch",
+    }
+  },
+}))
+
 const { materializeOpenDraftSession, useSessionUIStore } = await import("../session-ui-store")
 
 describe("issue 2039 draft auto-accept", () => {
@@ -500,3 +535,94 @@ describe("issue 2039 draft auto-accept", () => {
     expect(useSessionUIStore.getState().getDirectoryForSession(sessionId)).toBe("/canonical/worktree")
   })
 })
+
+describe("assistant answer worktree routing", () => {
+  test("reports session creation failure instead of completing silently", async () => {
+    const state = useSessionUIStore.getState()
+    const createFromAssistantMessage = state.createSessionFromAssistantMessage
+    const originalCreateSession = state.createSession
+
+    useSessionUIStore.setState({
+      createSession: async () => null,
+    })
+
+    try {
+      await expect(createFromAssistantMessage({
+        sessionId: "source-session",
+        directory: "/repo",
+        text: "Implement the plan",
+      }, {
+        providerID: "provider",
+        modelID: "model",
+        variant: "",
+        agent: "build",
+        instructions: "Follow the answer",
+      })).rejects.toThrow("Failed to create session")
+    } finally {
+      useSessionUIStore.setState({ createSession: originalCreateSession })
+    }
+  })
+
+  test("creates a sibling worktree from the captured source worktree directory", async () => {
+    projects = [
+      { id: "project", path: "/repo", label: "Repo" },
+      { id: "source-worktree", path: "/worktrees/source", label: "Source worktree" },
+    ]
+    createdWorktreeProjects.length = 0
+    const sourceWorktree = {
+      path: "/worktrees/source",
+      projectDirectory: "/repo",
+      branch: "source",
+      label: "source",
+    }
+    const state = useSessionUIStore.getState()
+    const createFromAssistantMessage = state.createSessionFromAssistantMessage
+    const originalCreateSession = state.createSession
+    const originalSendMessage = state.sendMessage
+    const originalWorktreeMetadata = state.worktreeMetadata
+    let createdDirectory: string | null | undefined
+
+    useSessionUIStore.setState({
+      availableWorktreesByProject: new Map([["/repo", [sourceWorktree]]]),
+      worktreeMetadata: new Map([["source-session", sourceWorktree]]),
+      createSession: async (_title, directory) => {
+        createdDirectory = directory
+        return {
+          id: "created-session",
+          slug: "created-session",
+          projectID: "project",
+          directory: directory ?? "",
+          title: "Created session",
+          version: "1",
+          time: { created: 1, updated: 1 },
+        }
+      },
+      sendMessage: async () => undefined,
+    })
+
+    try {
+      await createFromAssistantMessage({
+        sessionId: "source-session",
+        directory: "/worktrees/source",
+        text: "Implement the plan",
+      }, {
+        providerID: "provider",
+        modelID: "model",
+        variant: "",
+        agent: "build",
+        instructions: "Follow the answer",
+        createWorktree: true,
+      })
+    } finally {
+      useSessionUIStore.setState({
+        createSession: originalCreateSession,
+        sendMessage: originalSendMessage,
+        worktreeMetadata: originalWorktreeMetadata,
+      })
+      projects = []
+    }
+
+    expect(createdWorktreeProjects).toEqual([{ id: "project", path: "/repo" }])
+    expect(createdDirectory).toBe("/worktrees/generated-branch")
+  })
+})
diff --git a/packages/ui/src/sync/__tests__/session-switch-resync.test.ts b/packages/ui/src/sync/__tests__/session-switch-resync.test.ts
index b3874a0d..c03bfbe5 100644
--- a/packages/ui/src/sync/__tests__/session-switch-resync.test.ts
+++ b/packages/ui/src/sync/__tests__/session-switch-resync.test.ts
@@ -67,6 +67,7 @@ mock.module("@/components/ui", () => ({
 import { INITIAL_STATE, type State } from "../types"
 import { ChildStoreManager, type DirectoryStore } from "../child-store"
 import { getRuntimeKey } from "@/lib/runtime-switch"
+import { sessionEvents } from "@/lib/sessionEvents"
 const {
   createEventRoutingIndex,
   handleEvent,
@@ -340,4 +341,40 @@ describe("resyncBlockingRequestsForDirectory", () => {
     unsubscribe()
     childStores.disposeAll()
   })
+
+  test("refreshes Git once when a live mutating tool completes between renders", () => {
+    const childStores = new ChildStoreManager()
+    childStores.ensureChild("/repo", { bootstrap: false })
+    const routingIndex = createEventRoutingIndex()
+    const refreshes: Array<{ directory: string; paths?: string[] }> = []
+    const unsubscribe = sessionEvents.onGitRefreshHint((hint) => refreshes.push(hint))
+    // SAFETY: this fixture supplies the SDK event discriminator and the tool
+    // part identity, tool name, and state fields consumed by the reducer.
+    const toolEvent = (tool: string, status: "pending" | "completed" | "error") => ({
+      type: "message.part.updated",
+      properties: {
+        part: {
+          id: "prt_tool",
+          messageID: "msg_assistant",
+          sessionID: "ses_a",
+          type: "tool",
+          tool,
+          state: { status, input: {}, metadata: {} },
+        },
+      },
+    }) as Event
+
+    try {
+      handleEvent("/repo", toolEvent("apply_patch", "pending"), childStores, routingIndex, getRuntimeKey())
+      handleEvent("/repo", toolEvent("apply_patch", "completed"), childStores, routingIndex, getRuntimeKey())
+      handleEvent("/repo", toolEvent("apply_patch", "completed"), childStores, routingIndex, getRuntimeKey())
+      handleEvent("/repo", toolEvent("read", "completed"), childStores, routingIndex, getRuntimeKey())
+      handleEvent("/repo", toolEvent("edit", "error"), childStores, routingIndex, getRuntimeKey())
+
+      expect(refreshes).toEqual([{ directory: "/repo" }])
+    } finally {
+      unsubscribe()
+      childStores.disposeAll()
+    }
+  })
 })
diff --git a/packages/ui/src/sync/__tests__/sync-context-session-events.test.ts b/packages/ui/src/sync/__tests__/sync-context-session-events.test.ts
index d846e868..5a42c6c5 100644
--- a/packages/ui/src/sync/__tests__/sync-context-session-events.test.ts
+++ b/packages/ui/src/sync/__tests__/sync-context-session-events.test.ts
@@ -45,7 +45,15 @@ mock.module("@/lib/runtime-switch", () => ({
     return () => undefined
   },
 }))
-import { applySessionEventsToGlobalSessions, applySessionEventToGlobalSessions } from "../session-event-router"
+import {
+  applySessionEventsToGlobalSessions,
+  applySessionEventToGlobalSessions,
+} from "../session-event-router"
+import {
+  registerBulkArchiveEchoes,
+  releaseBulkArchiveEchoes,
+  shouldConsumeBulkArchiveEcho,
+} from "../bulk-archive-echo"
 
 const buildSession = (title: string, time: Session["time"]): Session => ({
   id: "ses_1",
@@ -146,4 +154,35 @@ describe("applySessionEventToGlobalSessions", () => {
     expect(mutationCalls).toBe(1)
     expect(upsertedSessions).toHaveLength(1_000)
   })
+
+  test("consumes only the matching bulk archive echo", () => {
+    registerBulkArchiveEchoes(runtimeKey, [{ id: "ses_1", archivedAt: 20 }], 100)
+
+    expect(shouldConsumeBulkArchiveEcho(buildEvent(buildSession("Initial", {
+      created: 1,
+      updated: 20,
+      archived: 20,
+    })), runtimeKey, 101)).toBe(true)
+    expect(shouldConsumeBulkArchiveEcho(buildEvent(buildSession("Initial", {
+      created: 1,
+      updated: 21,
+      archived: 21,
+    })), runtimeKey, 101)).toBe(false)
+    expect(shouldConsumeBulkArchiveEcho(buildEvent(buildSession("Initial", {
+      created: 1,
+      updated: 20,
+      archived: 20,
+    })), "runtime-b", 101)).toBe(false)
+  })
+
+  test("does not consume an expired or released bulk archive echo", () => {
+    registerBulkArchiveEchoes(runtimeKey, [{ id: "ses_1", archivedAt: 20 }], 100)
+    const event = buildEvent(buildSession("Initial", { created: 1, updated: 20, archived: 20 }))
+
+    expect(shouldConsumeBulkArchiveEcho(event, runtimeKey, 30_101)).toBe(false)
+
+    registerBulkArchiveEchoes(runtimeKey, [{ id: "ses_1", archivedAt: 20 }], 100)
+    releaseBulkArchiveEchoes(runtimeKey, ["ses_1"])
+    expect(shouldConsumeBulkArchiveEcho(event, runtimeKey, 101)).toBe(false)
+  })
 })
diff --git a/packages/ui/src/sync/bulk-archive-echo.ts b/packages/ui/src/sync/bulk-archive-echo.ts
new file mode 100644
index 00000000..0e9f469e
--- /dev/null
+++ b/packages/ui/src/sync/bulk-archive-echo.ts
@@ -0,0 +1,49 @@
+import type { Event } from "@opencode-ai/sdk/v2/client"
+import { subscribeRuntimeEndpointWillChange } from "@/lib/runtime-switch"
+
+const BULK_ARCHIVE_ECHO_TTL_MS = 30_000
+const pendingEchoes = new Map<string, Map<string, { archivedAt: number; expiresAt: number }>>()
+
+subscribeRuntimeEndpointWillChange(() => pendingEchoes.clear())
+
+export const registerBulkArchiveEchoes = (
+  runtimeKey: string,
+  sessions: Iterable<{ id: string; archivedAt: number }>,
+  now = Date.now(),
+): void => {
+  let runtimeEchoes = pendingEchoes.get(runtimeKey)
+  if (!runtimeEchoes) {
+    runtimeEchoes = new Map()
+    pendingEchoes.set(runtimeKey, runtimeEchoes)
+  }
+  for (const session of sessions) {
+    runtimeEchoes.set(session.id, {
+      archivedAt: session.archivedAt,
+      expiresAt: now + BULK_ARCHIVE_ECHO_TTL_MS,
+    })
+  }
+}
+
+export const releaseBulkArchiveEchoes = (runtimeKey: string, sessionIds: Iterable<string>): void => {
+  const runtimeEchoes = pendingEchoes.get(runtimeKey)
+  if (!runtimeEchoes) return
+  for (const sessionId of sessionIds) runtimeEchoes.delete(sessionId)
+  if (runtimeEchoes.size === 0) pendingEchoes.delete(runtimeKey)
+}
+
+export const shouldConsumeBulkArchiveEcho = (
+  event: Event,
+  runtimeKey: string,
+  now = Date.now(),
+): boolean => {
+  if (event.type !== "session.updated") return false
+  const runtimeEchoes = pendingEchoes.get(runtimeKey)
+  const expected = runtimeEchoes?.get(event.properties.info.id)
+  if (!expected) return false
+  if (expected.expiresAt < now) {
+    runtimeEchoes?.delete(event.properties.info.id)
+    if (runtimeEchoes?.size === 0) pendingEchoes.delete(runtimeKey)
+    return false
+  }
+  return event.properties.info.time.archived === expected.archivedAt
+}
diff --git a/packages/ui/src/sync/persist-cache.test.ts b/packages/ui/src/sync/persist-cache.test.ts
index 2afc3889..95427e33 100644
--- a/packages/ui/src/sync/persist-cache.test.ts
+++ b/packages/ui/src/sync/persist-cache.test.ts
@@ -92,6 +92,16 @@ describe("persisted directory sessions", () => {
     expect(readManagedChatSessions()).toEqual([])
   })
 
+  test("coalesces a continuing burst into one trailing session write", async () => {
+    persistSessions(directory, [session(1, 1)])
+    await new Promise((resolve) => setTimeout(resolve, 30))
+    persistSessions(directory, [session(1, 2)])
+    await waitForPersistence()
+
+    expect(storage.writes).toBe(1)
+    expect(readDirCache(directory).sessions?.[0]?.time.updated).toBe(2)
+  })
+
   test("keeps the 50 most recently updated sessions across restart reads", async () => {
     const sessions = Array.from({ length: 60 }, (_, updated) => session(59 - updated, updated))
 
diff --git a/packages/ui/src/sync/persist-cache.ts b/packages/ui/src/sync/persist-cache.ts
index 51d3e580..f2a43af5 100644
--- a/packages/ui/src/sync/persist-cache.ts
+++ b/packages/ui/src/sync/persist-cache.ts
@@ -177,7 +177,7 @@ function scheduleSessionCacheWrite(directory: string, sessions: Session[]): void
     if (pending.runtimeKey !== runtimeKey) pendingSessionWrites.delete(pendingKey)
   }
   pendingSessionWrites.set(key, { runtimeKey, key, legacyKey: legacyCacheKey(directory, "sessions"), sessions })
-  if (pendingSessionWriteTimer !== undefined) return
+  if (pendingSessionWriteTimer !== undefined) clearTimeout(pendingSessionWriteTimer)
   pendingSessionWriteTimer = setTimeout(flushPendingSessionWrites, SESSION_PERSIST_DEBOUNCE_MS)
 }
 
diff --git a/packages/ui/src/sync/selection-store.ts b/packages/ui/src/sync/selection-store.ts
index a8c1cb21..6762ef05 100644
--- a/packages/ui/src/sync/selection-store.ts
+++ b/packages/ui/src/sync/selection-store.ts
@@ -29,16 +29,21 @@ export type SelectionState = {
   getSessionAgentSelection: (sessionId: string) => string | null
   saveAgentModelForSession: (sessionId: string, agentName: string, providerId: string, modelId: string) => void
   getAgentModelForSession: (sessionId: string, agentName: string) => { providerId: string; modelId: string } | null
-  saveAgentModelVariantForSession: (sessionId: string, agentName: string, providerId: string, modelId: string, variant: string | undefined) => void
-  getAgentModelVariantForSession: (sessionId: string, agentName: string, providerId: string, modelId: string) => string | undefined
+  /**
+   * `variant` is the effort chosen for this agent/model in this session:
+   * a name, `null` for an explicit "Default" (send no effort), or `undefined`
+   * to forget the choice so the inherited default applies again.
+   */
+  saveAgentModelVariantForSession: (sessionId: string, agentName: string, providerId: string, modelId: string, variant: string | null | undefined) => void
+  getAgentModelVariantForSession: (sessionId: string, agentName: string, providerId: string, modelId: string) => string | null | undefined
 }
 
 const isPersistedSelectionState = (state: unknown): state is PersistedSelectionState => (
   typeof state === "object" && state !== null
 )
 
-// In-memory variant storage (not persisted)
-const agentModelVariantSelections = new Map<string, Map<string, Map<string, string>>>()
+// In-memory variant storage (not persisted). `null` is an explicit "Default".
+const agentModelVariantSelections = new Map<string, Map<string, Map<string, string | null>>>()
 
 // Maximum number of sessions to persist to local storage to prevent unbounded growth
 const MAX_PERSISTED_SESSIONS = 150
@@ -91,20 +96,21 @@ export const useSelectionStore = create<SelectionState>()(
 
       saveAgentModelVariantForSession: (sessionId, agentName, providerId, modelId, variant) => {
         const key = `${providerId}/${modelId}`
+        const clears = variant === undefined
         let agentMap = agentModelVariantSelections.get(sessionId)
-        if (!agentMap && variant) {
+        if (!agentMap && !clears) {
           agentMap = new Map()
           agentModelVariantSelections.set(sessionId, agentMap)
         }
         if (!agentMap) return
         let modelMap = agentMap.get(agentName)
-        if (!modelMap && variant) {
+        if (!modelMap && !clears) {
           modelMap = new Map()
           agentMap.set(agentName, modelMap)
         }
         if (!modelMap) return
 
-        if (!variant) {
+        if (clears) {
           modelMap.delete(key)
           if (modelMap.size === 0) {
             agentMap.delete(agentName)
diff --git a/packages/ui/src/sync/session-actions.test.ts b/packages/ui/src/sync/session-actions.test.ts
index d4611074..01e703a1 100644
--- a/packages/ui/src/sync/session-actions.test.ts
+++ b/packages/ui/src/sync/session-actions.test.ts
@@ -21,7 +21,16 @@ let sessionDeleteError: unknown | null = null
 let beforeSessionUpdateResolve: ((sessionId: string) => void) | null = null
 let beforeSessionDeleteResolve: ((sessionId: string) => void) | null = null
 const globalUpsertedSessions: unknown[] = []
+const globalUpsertedSessionBatches: Session[][] = []
 const globalRemovedSessionIds: string[] = []
+// Sessions this client is holding. `archiveSessions` reads them to decide which
+// sessions can be archived by the server in one batch.
+let globalActiveSessions: Session[] = []
+const archiveBatchRequests: Array<{ directory: string; ids: string[] }> = []
+let archiveBatchResponse: { status: number; body: unknown } = {
+  status: 404,
+  body: { error: 'not found' },
+}
 const deletedCleanupIdentities: Array<{ runtimeKey: string; directory: string; sessionId: string }> = []
 const movedSessionDirectories: Array<{ sessionID: string; directory: string }> = []
 
@@ -243,11 +252,15 @@ mock.module("@/stores/useGlobalSessionsStore", () => ({
   },
   useGlobalSessionsStore: {
     getState: () => ({
-      activeSessions: [],
+      activeSessions: globalActiveSessions,
       archivedSessions: [],
       upsertSession: (session: unknown) => {
         globalUpsertedSessions.push(session)
       },
+      upsertSessions: (sessions: Session[]) => {
+        globalUpsertedSessionBatches.push(sessions)
+        globalUpsertedSessions.push(...sessions)
+      },
       removeSessions: (ids: Iterable<string>) => {
         globalRemovedSessionIds.push(...ids)
       },
@@ -255,6 +268,18 @@ mock.module("@/stores/useGlobalSessionsStore", () => ({
   },
 }))
 
+mock.module("@/lib/runtime-fetch", () => ({
+  runtimeFetch: async (path: string, init?: { body?: string }) => {
+    const payload = JSON.parse(String(init?.body ?? "{}"))
+    archiveBatchRequests.push({ directory: payload.directory, ids: payload.ids })
+    void path
+    return new Response(JSON.stringify(archiveBatchResponse.body), {
+      status: archiveBatchResponse.status,
+      headers: { "content-type": "application/json" },
+    })
+  },
+}))
+
 mock.module("./session-deletion-cleanup", () => ({
   cleanupPersistedSessionState: (identity: { runtimeKey: string; directory: string; sessionId: string }) => {
     deletedCleanupIdentities.push(identity)
@@ -396,6 +421,10 @@ describe("confirmed session removal", () => {
     sessionUpdateResult = {}
     beforeSessionUpdateResolve = null
     beforeSessionDeleteResolve = null
+    globalUpsertedSessionBatches.length = 0
+    globalActiveSessions = []
+    archiveBatchRequests.length = 0
+    archiveBatchResponse = { status: 404, body: { error: 'not found' } }
   })
 
   test("does not remove live or persisted state when delete fails", async () => {
@@ -636,6 +665,161 @@ describe("confirmed session removal", () => {
   })
 })
 
+describe("archiving a batch through the server", () => {
+  const liveSession = (id: string, metadata?: Record<string, unknown>): Session => ({
+    id,
+    directory: "/test/project",
+    time: { created: 1 },
+    ...(metadata ? { metadata } : {}),
+  } as unknown as Session)
+
+  const archivedSession = (id: string): Session => ({
+    id,
+    directory: "/test/project",
+    time: { created: 1, archived: 2 },
+  } as unknown as Session)
+
+  beforeEach(() => {
+    replyCalls.length = 0
+    globalUpsertedSessions.length = 0
+    globalUpsertedSessionBatches.length = 0
+    globalActiveSessions = []
+    archiveBatchRequests.length = 0
+    archiveBatchResponse = { status: 404, body: { error: "not found" } }
+    sessionUpdateResult = {}
+    beforeSessionUpdateResolve = null
+  })
+
+  test("archives held sessions in one request and reconciles the stores once", async () => {
+    globalActiveSessions = [liveSession("session-a"), liveSession("session-b")]
+    archiveBatchResponse = {
+      status: 200,
+      body: { archived: [archivedSession("session-a"), archivedSession("session-b")], failedIds: [] },
+    }
+    const source = createStore({}, { session: [liveSession("session-a"), liveSession("session-b")] })
+    const { archiveSessions, setActionRefs } = await import("./session-actions")
+    setActionRefs(mockSdk as unknown as OpencodeClient, createChildStores([["/test/project", source]]), () => "/test/project")
+
+    const result = await archiveSessions(["session-a", "session-b"])
+
+    expect(result).toEqual({ archivedIds: ["session-a", "session-b"], failedIds: [] })
+    expect(archiveBatchRequests).toEqual([{ directory: "/test/project", ids: ["session-a", "session-b"] }])
+    // The point of the batch: no per-session SDK call, and one store write for
+    // the whole set instead of one per session.
+    expect(replyCalls.filter((call) => call.method === "session.update")).toEqual([])
+    expect(globalUpsertedSessionBatches).toHaveLength(1)
+    expect(source.getState().session).toEqual([])
+    expect(source.getState().sessionRevision).toBe(1)
+  })
+
+  test("batches sessions held only by the live directory store", async () => {
+    archiveBatchResponse = {
+      status: 200,
+      body: { archived: [archivedSession("session-a")], failedIds: [] },
+    }
+    const source = createStore({}, { session: [liveSession("session-a")] })
+    const { archiveSessions, setActionRefs } = await import("./session-actions")
+    setActionRefs(mockSdk as unknown as OpencodeClient, createChildStores([["/test/project", source]]), () => "/test/project")
+
+    const result = await archiveSessions(["session-a"])
+
+    expect(result).toEqual({ archivedIds: ["session-a"], failedIds: [] })
+    expect(archiveBatchRequests).toEqual([{ directory: "/test/project", ids: ["session-a"] }])
+    expect(replyCalls.filter((call) => call.method === "session.update")).toEqual([])
+  })
+
+  test("reports the sessions the server could not archive without losing the rest", async () => {
+    globalActiveSessions = [liveSession("session-a"), liveSession("session-b")]
+    archiveBatchResponse = {
+      status: 200,
+      body: { archived: [archivedSession("session-a")], failedIds: ["session-b"] },
+    }
+    const source = createStore({}, { session: [liveSession("session-a"), liveSession("session-b")] })
+    const { archiveSessions, setActionRefs } = await import("./session-actions")
+    setActionRefs(mockSdk as unknown as OpencodeClient, createChildStores([["/test/project", source]]), () => "/test/project")
+
+    const result = await archiveSessions(["session-a", "session-b"])
+
+    expect(result).toEqual({ archivedIds: ["session-a"], failedIds: ["session-b"] })
+    expect(source.getState().session.map((item) => item.id)).toEqual(["session-b"])
+  })
+
+  test("falls back to archiving one by one when the runtime does not serve the route", async () => {
+    globalActiveSessions = [liveSession("session-a"), liveSession("session-b")]
+    archiveBatchResponse = { status: 501, body: { error: "not supported in VS Code" } }
+    sessionUpdateResult = { data: archivedSession("session-a") }
+    const source = createStore({}, { session: [liveSession("session-a"), liveSession("session-b")] })
+    const { archiveSessions, setActionRefs } = await import("./session-actions")
+    setActionRefs(mockSdk as unknown as OpencodeClient, createChildStores([["/test/project", source]]), () => "/test/project")
+
+    const result = await archiveSessions(["session-a", "session-b"])
+
+    expect(result).toEqual({ archivedIds: ["session-a", "session-b"], failedIds: [] })
+    expect(replyCalls.filter((call) => call.method === "session.update").map((call) => call.params.sessionID))
+      .toEqual(["session-a", "session-b"])
+    expect(source.getState().session).toEqual([])
+  })
+
+  test("treats a malformed batch answer as unavailable instead of as an empty success", async () => {
+    globalActiveSessions = [liveSession("session-a")]
+    archiveBatchResponse = { status: 200, body: { archived: [{ title: "no id" }], failedIds: [] } }
+    sessionUpdateResult = { data: archivedSession("session-a") }
+    const source = createStore({}, { session: [liveSession("session-a")] })
+    const { archiveSessions, setActionRefs } = await import("./session-actions")
+    setActionRefs(mockSdk as unknown as OpencodeClient, createChildStores([["/test/project", source]]), () => "/test/project")
+
+    const result = await archiveSessions(["session-a"])
+
+    expect(result).toEqual({ archivedIds: ["session-a"], failedIds: [] })
+    expect(replyCalls.filter((call) => call.method === "session.update").map((call) => call.params.sessionID))
+      .toEqual(["session-a"])
+  })
+
+  test("keeps review and btw sessions on the per-session path", async () => {
+    const review = liveSession("session-review", { openchamber: { kind: "review", originalSessionID: "session-parent" } })
+    const parentWithFork = liveSession("session-parent", { openchamber: { btwSessionID: "session-fork" } })
+    globalActiveSessions = [liveSession("session-plain"), review, parentWithFork]
+    archiveBatchResponse = {
+      status: 200,
+      body: { archived: [archivedSession("session-plain")], failedIds: [] },
+    }
+    sessionUpdateResult = { data: archivedSession("session-review") }
+    const source = createStore({}, { session: [liveSession("session-plain"), review, parentWithFork] })
+    const { archiveSessions, setActionRefs } = await import("./session-actions")
+    setActionRefs(mockSdk as unknown as OpencodeClient, createChildStores([["/test/project", source]]), () => "/test/project")
+
+    await archiveSessions(["session-plain", "session-review", "session-parent"])
+
+    // Unlinking a partner rewrites another session's metadata, so those two
+    // never travel in the batch.
+    expect(archiveBatchRequests).toEqual([{ directory: "/test/project", ids: ["session-plain"] }])
+    expect(replyCalls.filter((call) => call.method === "session.update").map((call) => call.params.sessionID))
+      .toEqual(["session-review", "session-parent"])
+  })
+
+  test("does not reconcile a batch answered after a runtime switch", async () => {
+    globalActiveSessions = [liveSession("session-a")]
+    archiveBatchResponse = {
+      status: 200,
+      body: { archived: [archivedSession("session-a")], failedIds: [] },
+    }
+    const source = createStore({}, { session: [liveSession("session-a")] })
+    const { getRuntimeKey, switchRuntimeEndpoint } = await import("../lib/runtime-switch")
+    switchRuntimeEndpoint({ apiBaseUrl: "http://archive-bulk-a.test", runtimeKey: "archive-bulk-a" })
+    const capturedRuntimeKey = getRuntimeKey()
+    const { archiveSessions, setActionRefs } = await import("./session-actions")
+    setActionRefs(mockSdk as unknown as OpencodeClient, createChildStores([["/test/project", source]]), () => "/test/project")
+
+    const pending = archiveSessions(["session-a"], { expectedRuntimeKey: capturedRuntimeKey })
+    switchRuntimeEndpoint({ apiBaseUrl: "http://archive-bulk-b.test", runtimeKey: "archive-bulk-b" })
+    const result = await pending
+
+    expect(result).toEqual({ archivedIds: [], failedIds: ["session-a"] })
+    expect(source.getState().session.map((item) => item.id)).toEqual(["session-a"])
+    expect(globalUpsertedSessionBatches).toEqual([])
+  })
+})
+
 describe("session restore (unarchive)", () => {
   beforeEach(() => {
     replyCalls.length = 0
diff --git a/packages/ui/src/sync/session-actions.ts b/packages/ui/src/sync/session-actions.ts
index c208e0cc..85ddbd37 100644
--- a/packages/ui/src/sync/session-actions.ts
+++ b/packages/ui/src/sync/session-actions.ts
@@ -33,6 +33,8 @@ import { getBtwOriginalSessionID, getBtwSessionID, isBtwSession, withoutBtwSessi
 import { withLinkedIssue, type LinkedIssue } from "@/lib/linkedIssues"
 import { getImperativeSessionMessageLoader } from "./session-message-loader"
 import { cleanupPersistedSessionState } from "./session-deletion-cleanup"
+import { requestSessionArchiveBatch } from "./session-archive-batch"
+import { registerBulkArchiveEchoes, releaseBulkArchiveEchoes } from "./bulk-archive-echo"
 import { getRuntimeKey } from "@/lib/runtime-switch"
 import { markAmbiguousTransportFailure } from "@/lib/relay/transport-error"
 import { getErrorStatus, isAmbiguousSendFailure } from "./send-failure-classification"
@@ -75,20 +77,29 @@ let _optimisticAdd: ((input: OptimisticAddInput) => void) | null = null
 let _optimisticRemove: ((input: OptimisticRemoveInput) => void) | null = null
 let _optimisticConfirm: ((input: OptimisticConfirmInput) => void) | null = null
 
-function sessionMutationPatch(
+/**
+ * Revision patch for one or more sessions changing in the same store write.
+ *
+ * A batch bumps the revision once, because it is one state change: consumers
+ * compare revisions to decide whether their view of the list is stale, and a
+ * batch leaves them stale exactly once rather than once per session.
+ */
+function sessionsMutationPatch(
   state: ReturnType<DirectoryStoreApi["getState"]>,
-  sessionId: string,
+  sessionIds: Iterable<string>,
   deleted: boolean,
 ) {
   const revision = (state.sessionRevision ?? 0) + 1
   const sessionEventRevision = { ...(state.sessionEventRevision ?? {}) }
   const sessionDeletedRevision = { ...(state.sessionDeletedRevision ?? {}) }
-  if (deleted) {
-    sessionDeletedRevision[sessionId] = revision
-    delete sessionEventRevision[sessionId]
-  } else {
-    sessionEventRevision[sessionId] = revision
-    delete sessionDeletedRevision[sessionId]
+  for (const sessionId of sessionIds) {
+    if (deleted) {
+      sessionDeletedRevision[sessionId] = revision
+      delete sessionEventRevision[sessionId]
+    } else {
+      sessionEventRevision[sessionId] = revision
+      delete sessionDeletedRevision[sessionId]
+    }
   }
   return {
     sessionListSource: "live" as const,
@@ -98,6 +109,14 @@ function sessionMutationPatch(
   }
 }
 
+function sessionMutationPatch(
+  state: ReturnType<DirectoryStoreApi["getState"]>,
+  sessionId: string,
+  deleted: boolean,
+) {
+  return sessionsMutationPatch(state, [sessionId], deleted)
+}
+
 function invalidateSessionLoads(sessionId: string, directories: Iterable<string | null | undefined>): void {
   const loader = getImperativeSessionMessageLoader()
   if (!loader) return
@@ -1039,6 +1058,50 @@ function removeSessionFromLiveStores(sessionId: string, preferredDirectory?: str
   return snapshots
 }
 
+/**
+ * Remove a batch of server-confirmed sessions from every live child store.
+ *
+ * Each affected store is written once for the whole batch. Removing the
+ * sessions one at a time notified every subscriber — and therefore re-rendered
+ * the sidebar — once per session, which is what made archiving a worktree's
+ * sessions block the main thread for seconds.
+ */
+function removeSessionsFromLiveStores(sessionIds: Iterable<string>, preferredDirectory?: string): SessionListSnapshot[] {
+  const ids = new Set(sessionIds)
+  if (!_childStores || ids.size === 0) return []
+
+  const snapshots: SessionListSnapshot[] = []
+  const visited = new Set<string>()
+  const candidates: Array<[string, DirectoryStoreApi]> = []
+
+  if (preferredDirectory) {
+    const preferredStore = _childStores.children.get(preferredDirectory)
+    if (preferredStore) {
+      candidates.push([preferredDirectory, preferredStore])
+      visited.add(preferredDirectory)
+    }
+  }
+
+  for (const entry of _childStores.children.entries()) {
+    if (visited.has(entry[0])) continue
+    candidates.push(entry)
+  }
+
+  for (const [directory, store] of candidates) {
+    const current = store.getState()
+    const removed = current.session.filter((session) => ids.has(session.id)).map((session) => session.id)
+    if (removed.length === 0) continue
+
+    snapshots.push({ directory })
+    store.setState({
+      session: current.session.filter((session) => !ids.has(session.id)),
+      ...sessionsMutationPatch(current, removed, true),
+    })
+  }
+
+  return snapshots
+}
+
 function cleanupSessionWorktreeMetadata(sessionId: string): void {
   useSessionUIStore.getState().setWorktreeMetadata(sessionId, null)
 }
@@ -1252,7 +1315,14 @@ export type ArchiveSessionsOptions = {
 }
 
 /**
- * Archive several sessions sequentially, preserving partial results.
+ * Archive several sessions, preserving partial results.
+ *
+ * Sessions that carry no review or btw link are archived by their directory's
+ * server in one request, and the whole answer is reconciled with a single store
+ * write. The remainder — review sessions, btw forks, sessions with an active
+ * btw fork, and any session this client does not hold — keep the per-session
+ * path, because unlinking a partner is UI-owned work that reads and rewrites
+ * another session's metadata.
  *
  * One failed session never blocks or erases the others: it is reported in
  * `failedIds` while the remaining IDs are still attempted. When
@@ -1269,10 +1339,55 @@ export async function archiveSessions(
   const archivedIds: string[] = []
   const failedIds: string[] = []
   const expectedRuntimeKey = options?.expectedRuntimeKey ?? getRuntimeKey()
+  if (ids.length === 0) return { archivedIds, failedIds }
 
-  for (const [index, id] of ids.entries()) {
+  const plan = planArchiveBatches(ids)
+
+  for (const [directory, batchIds] of plan.batchesByDirectory) {
     if (isStaleRuntime(expectedRuntimeKey)) {
-      failedIds.push(...ids.slice(index))
+      failedIds.push(...batchIds)
+      continue
+    }
+
+    const archivedAt = Date.now()
+    registerBulkArchiveEchoes(
+      expectedRuntimeKey,
+      batchIds.map((id) => ({ id, archivedAt })),
+    )
+    const result = await requestSessionArchiveBatch(directory, batchIds, archivedAt)
+    if (isStaleRuntime(expectedRuntimeKey)) {
+      failedIds.push(...batchIds)
+      continue
+    }
+
+    if (result.outcome === "archived") {
+      releaseBulkArchiveEchoes(expectedRuntimeKey, batchIds)
+      registerBulkArchiveEchoes(
+        expectedRuntimeKey,
+        result.archived.flatMap((session) => (
+          session.time?.archived === undefined
+            ? []
+            : [{ id: session.id, archivedAt: session.time.archived }]
+        )),
+      )
+      commitArchivedSessions(result.archived, directory)
+      archivedIds.push(...result.archived.map((session) => session.id))
+      failedIds.push(...result.failedIds)
+      continue
+    }
+
+    // The runtime does not serve the batch route, or its answer could not be
+    // trusted. Archiving each session individually is slower but reaches the
+    // same state, and re-archiving a session the server already archived writes
+    // the same field again.
+    console.warn("[session-actions] archive batch unavailable, archiving one by one", result.reason)
+    releaseBulkArchiveEchoes(expectedRuntimeKey, batchIds)
+    plan.individualIds.push(...batchIds)
+  }
+
+  for (const [index, id] of plan.individualIds.entries()) {
+    if (isStaleRuntime(expectedRuntimeKey)) {
+      failedIds.push(...plan.individualIds.slice(index))
       break
     }
     if (await archiveSession(id, expectedRuntimeKey)) archivedIds.push(id)
@@ -1282,6 +1397,82 @@ export async function archiveSessions(
   return { archivedIds, failedIds }
 }
 
+/**
+ * A session whose archive also has to rewrite another session's metadata.
+ *
+ * Review sessions and btw forks point at a parent that must be unlinked, and a
+ * parent with an active btw fork has to delete that fork. Those are
+ * read-modify-write pairs on a second session, so they stay on the per-session
+ * path instead of the server batch.
+ */
+function hasLinkedSessionCleanup(session: Session): boolean {
+  return isReviewSession(session) || isBtwSession(session) || Boolean(getBtwSessionID(session))
+}
+
+/**
+ * Split the requested IDs into per-directory server batches and the sessions
+ * that must be archived individually.
+ *
+ * Link classification reads this client's session records rather than
+ * refetching each session: those records are kept current by the same
+ * `session.updated` events that publish a link created anywhere else, so a
+ * fetch per session would buy no authority the store does not already have.
+ * A session this client does not hold is classified as individual, which
+ * restores the per-session fetch for exactly the cases where the store has
+ * nothing to say.
+ */
+function planArchiveBatches(ids: string[]) {
+  const global = useGlobalSessionsStore.getState()
+  const knownSessions = new Map<string, Session>()
+  for (const session of [...global.activeSessions, ...global.archivedSessions]) {
+    knownSessions.set(session.id, session)
+  }
+  for (const store of _childStores?.children.values() ?? []) {
+    for (const session of store.getState().session) knownSessions.set(session.id, session)
+  }
+
+  const batchesByDirectory = new Map<string, string[]>()
+  const individualIds: string[] = []
+
+  for (const id of ids) {
+    const session = knownSessions.get(id)
+    const directory = session
+      ? resolveGlobalSessionDirectory(session) ?? getSessionDirectory(id)
+      : undefined
+    if (!session || !directory || hasLinkedSessionCleanup(session)) {
+      individualIds.push(id)
+      continue
+    }
+    const batch = batchesByDirectory.get(directory)
+    if (batch) batch.push(id)
+    else batchesByDirectory.set(directory, [id])
+  }
+
+  return { batchesByDirectory, individualIds }
+}
+
+/**
+ * Reconcile a server-confirmed archive batch with one write per store.
+ *
+ * This mirrors what `archiveSession` does for a single session — drop it from
+ * the live directory stores, invalidate its cached messages, move it to the
+ * archived bucket, and clear it if it was open — with the per-session store
+ * notifications collapsed into one.
+ */
+function commitArchivedSessions(sessions: Session[], directory: string): void {
+  if (sessions.length === 0) return
+
+  const ids = sessions.map((session) => session.id)
+  const snapshots = removeSessionsFromLiveStores(ids, directory)
+  const directories = [...snapshots.map((snapshot) => snapshot.directory), directory]
+  for (const id of ids) invalidateSessionLoads(id, directories)
+
+  useGlobalSessionsStore.getState().upsertSessions(sessions)
+
+  const ui = useSessionUIStore.getState()
+  if (ui.currentSessionId && ids.includes(ui.currentSessionId)) ui.setCurrentSession(null)
+}
+
 /**
  * Sentinel written to `time.archived` when restoring a session.
  *
diff --git a/packages/ui/src/sync/session-archive-batch.ts b/packages/ui/src/sync/session-archive-batch.ts
new file mode 100644
index 00000000..7774a43e
--- /dev/null
+++ b/packages/ui/src/sync/session-archive-batch.ts
@@ -0,0 +1,77 @@
+/**
+ * Server-side archive batch.
+ *
+ * Archiving the sessions linked to a worktree one request at a time is what
+ * made removing a worktree with many sessions take tens of seconds: every
+ * session cost its own round trip and its own store reconciliation. This asks
+ * the OpenChamber server to archive the whole batch next to OpenCode, so the
+ * browser spends one request and reconciles once.
+ *
+ * The route is an OpenChamber capability, not an OpenCode one. Runtimes that do
+ * not serve it (the VS Code webview has no server process) answer with a stable
+ * unsupported status, and callers fall back to archiving session by session.
+ */
+
+import type { Session } from '@opencode-ai/sdk/v2/client';
+import { z } from 'zod';
+
+import { runtimeFetch } from '@/lib/runtime-fetch';
+
+/**
+ * The route answers with sessions OpenCode itself returned from
+ * `session.update`. Only the identity this layer routes on is asserted here;
+ * every other field is carried through to the stores exactly as the server
+ * sent it, the same as for any other session response.
+ */
+const archiveResponseSchema = z.object({
+  archived: z.array(z.looseObject({ id: z.string().min(1) })),
+  failedIds: z.array(z.string().min(1)),
+});
+
+export type SessionArchiveBatchResult =
+  | { outcome: 'archived'; archived: Session[]; failedIds: string[] }
+  | { outcome: 'unavailable'; reason: string };
+
+export async function requestSessionArchiveBatch(
+  directory: string,
+  ids: string[],
+  archivedAt: number,
+): Promise<SessionArchiveBatchResult> {
+  let response: Response;
+  try {
+    response = await runtimeFetch('/api/openchamber/sessions/archive', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ directory, ids, archivedAt }),
+    });
+  } catch (error) {
+    return { outcome: 'unavailable', reason: error instanceof Error ? error.message : 'archive request failed' };
+  }
+
+  if (!response.ok) {
+    return { outcome: 'unavailable', reason: `archive request failed with ${response.status}` };
+  }
+
+  let body: unknown;
+  try {
+    body = await response.json();
+  } catch (error) {
+    return { outcome: 'unavailable', reason: error instanceof Error ? error.message : 'archive response was not JSON' };
+  }
+
+  const parsed = archiveResponseSchema.safeParse(body);
+  if (!parsed.success) {
+    // A body this layer cannot read is reported as unavailable rather than as
+    // an empty success, so a caller never mistakes "the response made no
+    // sense" for "nothing needed archiving" and drops the sessions.
+    return { outcome: 'unavailable', reason: `malformed archive response: ${parsed.error.issues[0]?.message ?? 'unknown shape'}` };
+  }
+
+  return {
+    outcome: 'archived',
+    // SAFETY: the schema guarantees the non-empty string `id` this layer keys
+    // on; the remaining fields are the server's own session payload.
+    archived: parsed.data.archived as Session[],
+    failedIds: parsed.data.failedIds,
+  };
+}
diff --git a/packages/ui/src/sync/session-ui-store.test.js b/packages/ui/src/sync/session-ui-store.test.js
index bff2e2f2..4dcb50a8 100644
--- a/packages/ui/src/sync/session-ui-store.test.js
+++ b/packages/ui/src/sync/session-ui-store.test.js
@@ -8,8 +8,10 @@ import { setActionRefs, setOptimisticRefs } from './session-actions';
 import { useSkillsStore } from '@/stores/useSkillsStore';
 import { useCommandsStore } from '@/stores/useCommandsStore';
 import { useConfigStore } from '@/stores/useConfigStore';
+import { useSelectionStore } from './selection-store';
 import { getRuntimeKey } from '@/lib/runtime-switch';
 import { getDeferredSafeStorage } from '@/stores/utils/safeStorage';
+import { CHAT_DRAFT_PROJECT_ID } from '@/lib/chatDirectories';
 import { useSessionDisplayStore } from '@/stores/useSessionDisplayStore';
 
 /**
@@ -398,7 +400,10 @@ describe('openNewSessionDraft project binding', () => {
   const projectA = { id: 'proj-a', path: '/projects/alpha', label: 'Alpha' };
   const projectB = { id: 'proj-b', path: '/projects/beta', label: 'Beta' };
 
+  const DRAFT_TARGET_KEY = 'oc.chatInput.lastDraftTarget';
+
   beforeEach(() => {
+    getDeferredSafeStorage().removeItem(DRAFT_TARGET_KEY);
     useSessionUIStore.setState({
       currentSessionId: null,
       currentSessionDirectory: null,
@@ -412,6 +417,10 @@ describe('openNewSessionDraft project binding', () => {
     useDirectoryStore.getState().setDirectory(projectB.path, { showOverlay: false });
   });
 
+  afterEach(() => {
+    getDeferredSafeStorage().removeItem(DRAFT_TARGET_KEY);
+  });
+
   test('defaults an implicit draft to Chat when active project differs', () => {
     useSessionUIStore.getState().openNewSessionDraft();
     const draft = useSessionUIStore.getState().newSessionDraft;
@@ -449,6 +458,82 @@ describe('openNewSessionDraft project binding', () => {
     expect(draft.open).toBe(true);
     expect(draft.selectedProjectId).toBe(projectB.id);
   });
+
+  test('reopens an implicit draft on the project the target selector was last set to', () => {
+    useSessionUIStore.getState().openNewSessionDraft({ selectedProjectId: projectB.id });
+    useSessionUIStore.getState().closeNewSessionDraft();
+    // A chat session leaves its managed scratch directory current; the project
+    // to reopen on can only come from the recorded target.
+    useDirectoryStore.getState().setDirectory(
+      '/Users/tester/.config/openchamber/chats/ses_chat',
+      { showOverlay: false },
+    );
+
+    useSessionUIStore.getState().openNewSessionDraft();
+    const draft = useSessionUIStore.getState().newSessionDraft;
+
+    expect(draft.target).toBe('project');
+    expect(draft.selectedProjectId).toBe(projectB.id);
+    expect(draft.directoryOverride).toBe(projectB.path);
+  });
+
+  test('setNewSessionDraftTarget records Chat, so the next implicit draft opens on Chat', () => {
+    useSessionUIStore.getState().openNewSessionDraft({ selectedProjectId: projectB.id });
+    useSessionUIStore.getState().setNewSessionDraftTarget({ projectId: CHAT_DRAFT_PROJECT_ID });
+    useSessionUIStore.getState().closeNewSessionDraft();
+
+    useSessionUIStore.getState().openNewSessionDraft();
+
+    expect(useSessionUIStore.getState().newSessionDraft.target).toBe('chat');
+  });
+
+  test('keeps the Chat default for a record written before the target was stored', () => {
+    getDeferredSafeStorage().setItem(
+      DRAFT_TARGET_KEY,
+      JSON.stringify({ projectId: projectB.id, directory: projectB.path }),
+    );
+
+    useSessionUIStore.getState().openNewSessionDraft();
+
+    expect(useSessionUIStore.getState().newSessionDraft.target).toBe('chat');
+  });
+
+  test('a chat scratch directory forwarded as override opens a chat draft', () => {
+    // "New session in the current directory" callers forward the current
+    // session's directory even when that session is a chat; its scratch
+    // directory names no project.
+    useSessionUIStore.getState().openNewSessionDraft({
+      directoryOverride: '/Users/tester/.config/openchamber/chats/ses_chat',
+    });
+    const draft = useSessionUIStore.getState().newSessionDraft;
+
+    expect(draft.target).toBe('chat');
+    expect(draft.directoryOverride).toBeNull();
+  });
+
+  test('a chat scratch override opens Chat even when the recorded target is a project', () => {
+    getDeferredSafeStorage().setItem(
+      DRAFT_TARGET_KEY,
+      JSON.stringify({ projectId: projectB.id, directory: projectB.path, target: 'project' }),
+    );
+
+    useSessionUIStore.getState().openNewSessionDraft({
+      directoryOverride: '/Users/tester/.config/openchamber/chats/ses_chat',
+    });
+
+    expect(useSessionUIStore.getState().newSessionDraft.target).toBe('chat');
+  });
+
+  test('falls back to Chat when the last project target no longer exists', () => {
+    getDeferredSafeStorage().setItem(
+      DRAFT_TARGET_KEY,
+      JSON.stringify({ projectId: 'proj-removed', directory: '/projects/removed', target: 'project' }),
+    );
+
+    useSessionUIStore.getState().openNewSessionDraft();
+
+    expect(useSessionUIStore.getState().newSessionDraft.target).toBe('chat');
+  });
 });
 
 describe('createSession draft lifecycle', () => {
@@ -962,3 +1047,84 @@ describe('deleteSessions option forwarding', () => {
     expect(deleteSessionCalls).toEqual([]);
   });
 });
+
+describe('sendMessage effort record', () => {
+  let originalSendMessage;
+
+  const SESSION = 'session-effort';
+  const PROVIDER = 'provider-a';
+  const MODEL = 'model-a';
+  const AGENT = 'build';
+
+  const readRecord = () => useSelectionStore
+    .getState()
+    .getAgentModelVariantForSession(SESSION, AGENT, PROVIDER, MODEL);
+
+  beforeEach(() => {
+    const childStore = {
+      getState: () => ({ session: [], message: {}, part: {}, session_status: {} }),
+      setState: () => {},
+    };
+    const childStores = {
+      children: new Map(),
+      ensureChild: () => childStore,
+      getChild: () => childStore,
+    };
+    setActionRefs(opencodeClient, childStores, () => '/current/project');
+    setOptimisticRefs(() => {}, () => {});
+    useConfigStore.setState({
+      isConnected: true,
+      currentProviderId: PROVIDER,
+      currentModelId: MODEL,
+      currentAgentName: AGENT,
+      currentVariant: undefined,
+      currentVariantSelection: { override: undefined, inherited: undefined },
+    });
+    useSessionUIStore.setState({
+      currentSessionId: SESSION,
+      currentSessionDirectory: '/current/project',
+      newSessionDraft: { open: false, directoryOverride: null, parentID: null },
+    });
+    originalSendMessage = opencodeClient.sendMessage;
+    opencodeClient.sendMessage = async () => 'msg';
+  });
+
+  afterEach(() => {
+    opencodeClient.sendMessage = originalSendMessage;
+    useSelectionStore.getState().saveAgentModelVariantForSession(SESSION, AGENT, PROVIDER, MODEL, undefined);
+  });
+
+  const send = (variant) => useSessionUIStore.getState().sendMessage(
+    'hello', PROVIDER, MODEL, AGENT, undefined, undefined, undefined, variant, 'normal',
+  );
+
+  test('keeps an explicit Default across the send that follows it', async () => {
+    // What the picker leaves behind: `null` recorded, and a send that carries
+    // no effort because "Default" means exactly that.
+    useSelectionStore.getState().saveAgentModelVariantForSession(SESSION, AGENT, PROVIDER, MODEL, null);
+    useConfigStore.setState({ currentVariantSelection: { override: null, inherited: 'high' } });
+
+    await send(undefined);
+
+    expect(readRecord()).toBeNull();
+  });
+
+  test('records the effort a send carries', async () => {
+    useConfigStore.setState({ currentVariantSelection: { override: 'high', inherited: 'high' } });
+
+    await send('high');
+
+    expect(readRecord()).toBe('high');
+  });
+
+  test('records no choice when the live selection inherits its effort', async () => {
+    useConfigStore.setState({
+      currentVariant: 'high',
+      currentVariantSelection: { override: undefined, inherited: 'high' },
+    });
+
+    await send('high');
+
+    expect(readRecord()).toBe(undefined);
+  });
+});
diff --git a/packages/ui/src/sync/session-ui-store.ts b/packages/ui/src/sync/session-ui-store.ts
index 74fbac64..1f0414f6 100644
--- a/packages/ui/src/sync/session-ui-store.ts
+++ b/packages/ui/src/sync/session-ui-store.ts
@@ -14,7 +14,7 @@
 
 import type { ContextPartMetadata } from "@/lib/messages/contextParts"
 import { create } from "zustand"
-import type { Session, Part, Message, TextPart } from "@opencode-ai/sdk/v2/client"
+import type { Session, Part, TextPart } from "@opencode-ai/sdk/v2/client"
 import type { AttachedFile, SessionContextUsage, SessionWorktreeAttachment } from "@/stores/types/sessionTypes"
 import type { WorktreeMetadata } from "@/types/worktree"
 import { opencodeClient } from "@/lib/opencode/client"
@@ -31,9 +31,8 @@ import { useSkillsStore } from "@/stores/useSkillsStore"
 import { getDeferredSafeStorage } from "@/stores/utils/safeStorage"
 import { markPendingUserSendAnimation } from "@/lib/userSendAnimation"
 import { normalizePath } from "@/lib/pathNormalization"
-import { CHAT_DRAFT_PROJECT_ID, createChatDirectory, deleteChatDirectory, getChatsRootFromDirectory, warmChatsRootDirectory } from "@/lib/chatDirectories"
+import { CHAT_DRAFT_PROJECT_ID, createChatDirectory, deleteChatDirectory, getChatsRootFromDirectory, isChatDirectoryPath, warmChatsRootDirectory } from "@/lib/chatDirectories"
 import { isVSCodeRuntime } from "@/lib/desktop"
-import { flattenAssistantTextParts } from "@/lib/messages/messageText"
 import { composeForkSessionMessage } from "@/lib/messages/executionMeta"
 import { findLatestUserModelChoice } from "@/lib/messages/userModelChoice"
 import { waitForPendingDraftWorktreeRequest } from "@/lib/worktrees/pendingDraftWorktree"
@@ -252,6 +251,12 @@ type AssistantMessageSessionExecution = {
   runAsGoal?: boolean
 }
 
+type AssistantMessageSessionSource = {
+  sessionId: string
+  directory: string
+  text: string
+}
+
 function notifyMessageSent(sessionId: string): void {
   runtimeFetch(`/api/sessions/${sessionId}/message-sent`, { method: "POST" })
     .catch(() => { /* ignore */ })
@@ -261,6 +266,8 @@ function notifyMessageSent(sessionId: string): void {
 // Types
 // ---------------------------------------------------------------------------
 
+type NewSessionDraftTarget = "chat" | "project"
+
 export type NewSessionDraftState = {
   draftId: number
   open: boolean
@@ -276,7 +283,7 @@ export type NewSessionDraftState = {
   syntheticParts?: SyntheticContextPart[]
   targetFolderId?: string
   projectContextPins?: { notes: string[]; plans: string[] }
-  target: "chat" | "project"
+  target: NewSessionDraftTarget
   preparedChatDirectory?: string | null
 }
 
@@ -383,7 +390,7 @@ export type SessionUIState = {
   forkFromMessage: (sessionId: string, messageId: string) => Promise<void>
   handleSlashUndo: (sessionId: string) => Promise<void>
   handleSlashRedo: (sessionId: string, options?: { fullUnrevert?: boolean }) => Promise<void>
-  createSessionFromAssistantMessage: (sourceMessageId: string, execution: AssistantMessageSessionExecution) => Promise<void>
+  createSessionFromAssistantMessage: (source: AssistantMessageSessionSource, execution: AssistantMessageSessionExecution) => Promise<void>
 
   // Data access helpers (read from sync)
   getSessionsByDirectory: (directory: string) => Session[]
@@ -418,16 +425,25 @@ const resolveDirectoryKey = (session: Session): string | null => {
 const safeStorage = getDeferredSafeStorage()
 const DRAFT_TARGET_STORAGE_KEY = "oc.chatInput.lastDraftTarget"
 
-type PersistedDraftTarget = { projectId: string | null; directory: string | null }
+// `target` records which side of the composer's target selector the user last
+// worked on, so a plain "new session" reopens there instead of always landing
+// on Chat. Records written before this field existed carry no kind — they stay
+// `null` and leave the Chat default in place rather than guessing one.
+type PersistedDraftTarget = {
+  projectId: string | null
+  directory: string | null
+  target: NewSessionDraftTarget | null
+}
 
 const readPersistedDraftTarget = (): PersistedDraftTarget | null => {
   try {
     const raw = safeStorage.getItem(DRAFT_TARGET_STORAGE_KEY)
     if (!raw) return null
-    const parsed = JSON.parse(raw) as { projectId?: unknown; directory?: unknown }
+    const parsed = JSON.parse(raw) as { projectId?: unknown; directory?: unknown; target?: unknown }
     return {
       projectId: typeof parsed?.projectId === "string" ? parsed.projectId : null,
       directory: normalizePath(typeof parsed?.directory === "string" ? parsed.directory : null),
+      target: parsed?.target === "chat" || parsed?.target === "project" ? parsed.target : null,
     }
   } catch {
     return null
@@ -723,7 +739,7 @@ const recoverStaleDraftDirectory = async (openedDraft: NewSessionDraftState): Pr
   }
   useSessionUIStore.setState({ newSessionDraft: nextDraft })
   writeRuntimeSessionMemory(runtimeMemoryKey(), { draft: nextDraft })
-  persistDraftTarget({ projectId: nextDraft.selectedProjectId ?? null, directory: recovered })
+  persistDraftTarget({ projectId: nextDraft.selectedProjectId ?? null, directory: recovered, target: nextDraft.target })
   void activateConfigForDirectory(recovered)
 }
 
@@ -769,6 +785,29 @@ const createSessionWithDraftLifecycle = async (
   }
 }
 
+/**
+ * The effort a send should record for its session.
+ *
+ * A send carries `undefined` both when no effort was ever chosen and when the
+ * user explicitly picked "Default", so the sent value alone cannot tell the two
+ * apart, and recording it raw clears a real "Default". The live selection can
+ * tell them apart, because its `override` keeps `null` for "Default" — but only
+ * while it still describes the agent and model being sent to. Otherwise the
+ * send's own value is all there is to go on.
+ */
+const resolveVariantToRecord = (
+  agentName: string | undefined,
+  providerID: string,
+  modelID: string,
+  sentVariant: string | undefined,
+): string | null | undefined => {
+  const config = useConfigStore.getState()
+  const describesThisSend = config.currentProviderId === providerID
+    && config.currentModelId === modelID
+    && config.currentAgentName === agentName
+  return describesThisSend ? config.currentVariantSelection.override : sentVariant
+}
+
 export async function materializeOpenDraftSession(selection: {
   providerID: string
   modelID: string
@@ -831,6 +870,7 @@ export async function materializeOpenDraftSession(selection: {
   persistDraftTarget({
     projectId: draftProjectId,
     directory: createdDirectory,
+    target: draft.target,
   })
 
   const draftSyntheticParts = draft.syntheticParts
@@ -840,11 +880,12 @@ export async function materializeOpenDraftSession(selection: {
   })
 
   const effectiveDraftAgent = trimmedAgent ?? configState.currentAgentName
-  const variantOverride = configState.currentProviderId === selection.providerID
-    && configState.currentModelId === selection.modelID
-    && configState.currentAgentName === effectiveDraftAgent
-    ? configState.currentVariantSelection.override ?? undefined
-    : selection.variant
+  const variantOverride = resolveVariantToRecord(
+    effectiveDraftAgent,
+    selection.providerID,
+    selection.modelID,
+    selection.variant,
+  )
 
   useSelectionStore.getState().saveSessionModelSelection(created.id, selection.providerID, selection.modelID)
 
@@ -1103,17 +1144,43 @@ export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
     const currentDirectory = normalizePath(useDirectoryStore.getState().currentDirectory ?? null)
     const persistedTarget = readPersistedDraftTarget()
 
-    const explicitDirectory = options?.directoryOverride !== undefined
+    // Callers that forward "the current session's directory" forward it for
+    // chat sessions too, and a chat session's scratch directory names no
+    // project. Treating it as an explicit project target would force a project
+    // draft rooted in scratch; it is a request for another chat.
+    const rawExplicitDirectory = options?.directoryOverride !== undefined
       ? normalizePath(options.directoryOverride)
       : null
+    const explicitDirectoryIsChat = rawExplicitDirectory !== null && isChatDirectoryPath(rawExplicitDirectory)
+    const explicitDirectory = explicitDirectoryIsChat ? null : rawExplicitDirectory
+    const persistedProjectById = persistedTarget?.projectId
+      ? projects.find((p) => p.id === persistedTarget.projectId) ?? null
+      : null
+    const persistedProjectByDir = resolveDraftProjectForDirectory(projects, availableWorktreesByProject, persistedTarget?.directory ?? null)
+    const currentDirProject = resolveDraftProjectForDirectory(projects, availableWorktreesByProject, currentDirectory)
+    const persistedProject = persistedProjectById ?? persistedProjectByDir
+
+    // Nothing explicit was asked for: reopen on the side the user last worked
+    // on. Only a recorded project target that still resolves to an existing
+    // project beats Chat — a project removed since must not open a draft
+    // pointing at a directory that is no longer registered.
+    const restoresProjectTarget = !isVSCodeRuntime()
+      && !options?.target
+      && options?.directoryOverride === undefined
+      && options?.selectedProjectId === undefined
+      && persistedTarget?.target === "project"
+      && persistedProject !== null
+
     let target = isVSCodeRuntime() ? "project" : options?.target
     if (!target) {
-      const hasExplicitProjectTarget = options?.directoryOverride !== undefined
+      const hasExplicitProjectTarget = (options?.directoryOverride !== undefined && !explicitDirectoryIsChat)
         || (options?.selectedProjectId !== undefined && options.selectedProjectId !== CHAT_DRAFT_PROJECT_ID)
         || isVSCodeRuntime()
-      target = options?.selectedProjectId === CHAT_DRAFT_PROJECT_ID || !hasExplicitProjectTarget
+      target = options?.selectedProjectId === CHAT_DRAFT_PROJECT_ID
         ? "chat"
-        : "project"
+        : hasExplicitProjectTarget || restoresProjectTarget
+          ? "project"
+          : "chat"
     }
     const explicitProject = target === "project" && options?.selectedProjectId
       ? projects.find((p) => p.id === options.selectedProjectId) ?? null
@@ -1126,24 +1193,23 @@ export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
       return projects[0] ?? null
     })()
 
-    const persistedProjectById = persistedTarget?.projectId
-      ? projects.find((p) => p.id === persistedTarget.projectId) ?? null
-      : null
-    const persistedProjectByDir = resolveDraftProjectForDirectory(projects, availableWorktreesByProject, persistedTarget?.directory ?? null)
-    const currentDirProject = resolveDraftProjectForDirectory(projects, availableWorktreesByProject, currentDirectory)
-
     const selectedProject = target === "chat" ? null : (() => {
       if (explicitProject) return explicitProject
       if (explicitDirectory !== null) return inferredProjectFromDir
-      if (currentDirectory) return currentDirProject
-      return persistedProjectByDir ?? persistedProjectById ?? fallbackProject
+      // A chat session leaves a managed scratch directory behind as the current
+      // one; it owns no project, so it must not decide this draft's project —
+      // the recorded target below knows which project the user last chose.
+      if (currentDirectory && !isChatDirectoryPath(currentDirectory)) return currentDirProject
+      return persistedProject ?? fallbackProject
     })()
 
     const directory = target === "chat" ? null : (() => {
       if (explicitDirectory !== null) return explicitDirectory
       if (explicitProject) return normalizePath(explicitProject.path ?? null)
-      if (currentDirectory) return currentDirectory
-      if (persistedTarget?.directory) return persistedTarget.directory
+      // A chat session's directory is a managed scratch folder, never a
+      // project: letting it through would open a project draft rooted in it.
+      if (currentDirectory && !isChatDirectoryPath(currentDirectory)) return currentDirectory
+      if (persistedTarget?.directory && !isChatDirectoryPath(persistedTarget.directory)) return persistedTarget.directory
       return normalizePath(selectedProject?.path ?? null)
     })()
 
@@ -1151,7 +1217,7 @@ export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
       warmChatsRootDirectory()
     }
 
-    persistDraftTarget({ projectId: selectedProject?.id ?? null, directory })
+    persistDraftTarget({ projectId: selectedProject?.id ?? null, directory, target })
 
     const nextDraft: NewSessionDraftState = {
       draftId: nextDraftId++,
@@ -1305,6 +1371,15 @@ export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
         },
       }
     })
+    // Picking a side of the target selector is the choice the next plain "new
+    // session" reopens on, so it is recorded here too — not only when a draft
+    // is opened or a session is created from one.
+    const chosenDraft = get().newSessionDraft
+    persistDraftTarget({
+      projectId: chosenDraft.target === "chat" ? null : chosenDraft.selectedProjectId ?? null,
+      directory: chosenDraft.directoryOverride ?? null,
+      target: chosenDraft.target,
+    })
     void activateConfigForDirectory(nextDirectory)
 
     if (nextDirectory && nextDirectory !== useDirectoryStore.getState().currentDirectory) {
@@ -1667,7 +1742,13 @@ export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
     if (targetSessionId && effectiveAgent) {
       useSelectionStore.getState().saveSessionAgentSelection(targetSessionId, effectiveAgent)
       useSelectionStore.getState().saveAgentModelForSession(targetSessionId, effectiveAgent, providerID, modelID)
-      useSelectionStore.getState().saveAgentModelVariantForSession(targetSessionId, effectiveAgent, providerID, modelID, variant)
+      useSelectionStore.getState().saveAgentModelVariantForSession(
+        targetSessionId,
+        effectiveAgent,
+        providerID,
+        modelID,
+        resolveVariantToRecord(effectiveAgent, providerID, modelID, variant),
+      )
     }
 
     if (targetSessionId) {
@@ -1901,47 +1982,26 @@ export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
   },
 
   // ---------------------------------------------------------------------------
-  // createSessionFromAssistantMessage — reads from sync
+  // createSessionFromAssistantMessage — uses the rendered source context
   // ---------------------------------------------------------------------------
-  createSessionFromAssistantMessage: async (sourceMessageId, execution) => {
-    if (!sourceMessageId) return
+  createSessionFromAssistantMessage: async (source, execution) => {
+    if (!source.sessionId) return
     if (!execution?.instructions?.trim()) return
-
-    // Find which session this message belongs to by scanning sync state
-    const state = getDirectoryState()
-    if (!state) return
-
-    let sourceSessionId: string | undefined
-    let sourceMessage: Message | undefined
-
-    for (const [sid, msgs] of Object.entries(state.message ?? {})) {
-      const found = msgs.find((m) => m.id === sourceMessageId)
-      if (found) {
-        sourceSessionId = sid
-        sourceMessage = found
-        break
-      }
-    }
-
-    if (!sourceMessage || sourceMessage.role !== "assistant") return
-
-    const sourceParts = getSyncParts(sourceMessageId)
-    const assistantPlanText = flattenAssistantTextParts(sourceParts)
+    const assistantPlanText = source.text
     if (!assistantPlanText.trim()) return
 
-    const directory = resolveSessionDirectory(
-      sourceSessionId ?? null,
-      (sid) => get().worktreeMetadata.get(sid),
-    )
-    const sourceWorktreeMetadata = sourceSessionId ? get().worktreeMetadata.get(sourceSessionId) : undefined
+    const sourceDirectory = normalizePath(source.directory)
+    if (!sourceDirectory) {
+      throw new Error("Source session directory is unavailable")
+    }
+    const sourceWorktreeMetadata = get().worktreeMetadata.get(source.sessionId)
 
-    const pID = execution.providerID || useSelectionStore.getState().lastUsedProvider?.providerID
-    const mID = execution.modelID || useSelectionStore.getState().lastUsedProvider?.modelID
+    const providerID = execution.providerID || useSelectionStore.getState().lastUsedProvider?.providerID
+    const modelID = execution.modelID || useSelectionStore.getState().lastUsedProvider?.modelID
 
-    if (!pID || !mID) return
+    if (!providerID || !modelID) return
 
-    const sourceDirectory = normalizePath(directory ?? opencodeClient.getDirectory() ?? null)
-    let sessionDirectory = sourceDirectory
+    let sessionDirectory: string | null = sourceDirectory
     let createdWorktree: WorktreeMetadata | null = null
     let createdWorktreeProject: { id: string; path: string } | null = null
 
@@ -1950,11 +2010,11 @@ export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
       const project = resolveProjectForSessionDirectory(
         projects,
         get().availableWorktreesByProject,
-        sourceDirectory,
+        sourceWorktreeMetadata?.projectDirectory ?? null,
       ) ?? resolveProjectForSessionDirectory(
         projects,
         get().availableWorktreesByProject,
-        sourceWorktreeMetadata?.projectDirectory ?? null,
+        sourceDirectory,
       )
       if (!project?.path) {
         throw new Error("Project is not registered in OpenChamber")
@@ -1985,13 +2045,13 @@ export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
       }
     }
 
-    const session = await get().createSession(undefined, sessionDirectory || null, null)
+    const session = await get().createSession(undefined, sessionDirectory, null)
     if (!session) {
       if (createdWorktree && createdWorktreeProject) {
         const { removeProjectWorktree } = await import("@/lib/worktrees/worktreeManager")
         await removeProjectWorktree(createdWorktreeProject, createdWorktree, { deleteLocalBranch: true }).catch(() => undefined)
       }
-      return
+      throw new Error("Failed to create session")
     }
 
     if (createdWorktree) {
@@ -2011,8 +2071,8 @@ export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
 
     await get().sendMessage(
       composeForkSessionMessage(execution.instructions, assistantPlanText),
-      pID,
-      mID,
+      providerID,
+      modelID,
       execution.agent || undefined,
       undefined,
       undefined,
diff --git a/packages/ui/src/sync/sync-context.tsx b/packages/ui/src/sync/sync-context.tsx
index 246d44c7..53f61bab 100644
--- a/packages/ui/src/sync/sync-context.tsx
+++ b/packages/ui/src/sync/sync-context.tsx
@@ -38,7 +38,11 @@ import { setSyncRefs, getAllSyncSessions } from "./sync-refs"
 import { useSessionUIStore } from "./session-ui-store"
 import { stripSessionDiffSnapshots } from "./sanitize"
 import { upsertSessionRecord } from "./session-records"
-import { applySessionEventToGlobalSessions, applySessionEventsToGlobalSessions } from "./session-event-router"
+import {
+  applySessionEventToGlobalSessions,
+  applySessionEventsToGlobalSessions,
+} from "./session-event-router"
+import { shouldConsumeBulkArchiveEcho } from "./bulk-archive-echo"
 import { syncDebug } from "./debug"
 import { getReconnectCandidateSessionIds, mergeBootstrapSessions } from "./reconnect-recovery"
 import { messagesBefore } from "./message-ordering"
@@ -79,6 +83,7 @@ import { getRuntimeKey } from "@/lib/runtime-switch"
 import { getRegisteredRuntimeAPIs } from "@/contexts/runtimeAPIRegistry"
 import { isFilesystemError } from "@/lib/api/files-errors"
 import { formatMessage, useI18nStore } from "@/lib/i18n"
+import { sessionEvents } from "@/lib/sessionEvents"
 import { listGlobalSessionPages } from "@/stores/globalSessions"
 import { areRequestArraysReferentiallyEqual, collectScopedBlockingRequests } from "./scoped-blocking-requests"
 import { EMPTY_USER_MESSAGE_HISTORY_SNAPSHOT, buildUserMessageHistorySnapshot, type UserMessageHistorySnapshot } from "./user-message-history"
@@ -1592,6 +1597,8 @@ export function handleEvent(
     return
   }
 
+  if (shouldConsumeBulkArchiveEcho(payload, expectedRuntimeKey)) return
+
   const directory = resolveDirectoryFromRoutingIndex(routingIndex, rawDirectory, payload, childStores, batch)
 
   if (payload.type === "session.deleted" && expectedRuntimeKey === getRuntimeKey()) {
@@ -1824,6 +1831,10 @@ export function handleEvent(
   // type will mutate. This preserves reference identity for untouched slices
   // so Zustand selectors skip re-renders for unrelated subscribers.
   const current = getDirectoryEventState(store, batch)
+  const updatedPart = payload.type === "message.part.updated" ? payload.properties.part : undefined
+  const previousPart = updatedPart && "messageID" in updatedPart
+    ? current.part[updatedPart.messageID]?.find((part) => part.id === updatedPart.id)
+    : undefined
   const draft: State = { ...current }
   const clonedFields = batch?.clonedFields.get(store) ?? new Set<keyof State>()
   const newlyClonedFields: Array<keyof State> = []
@@ -1900,6 +1911,10 @@ export function handleEvent(
   const reducerChanged = typeof reducerResult === "boolean" ? reducerResult : reducerResult.changed
   const materializationResult = typeof reducerResult === "boolean" ? undefined : reducerResult.materialization
 
+  if (reducerChanged && updatedPart) {
+    sessionEvents.requestGitRefreshForToolTransition(resolvedDirectory, previousPart, updatedPart)
+  }
+
   if (reducerChanged) {
     countSyncPerformance("reducerChangedEvents")
     const eventSessionID = getSessionIdFromPayload(payload) ?? undefined
diff --git a/packages/vscode/webview/api/git.ts b/packages/vscode/webview/api/git.ts
index 7ed75e21..94de428f 100644
--- a/packages/vscode/webview/api/git.ts
+++ b/packages/vscode/webview/api/git.ts
@@ -69,7 +69,7 @@ export const createVSCodeGitAPI = (): GitAPI => ({
     return sendBridgeMessage<boolean>('api:git/check', { directory });
   },
 
-  getGitStatus: async (directory: string, options?: { mode?: 'light' }): Promise<GitStatus> => {
+  getGitStatus: async (directory: string, options?: { mode?: 'light'; fresh?: boolean }): Promise<GitStatus> => {
     return sendBridgeMessage<GitStatus>('api:git/status', { directory, mode: options?.mode });
   },
 
diff --git a/packages/vscode/webview/main.tsx b/packages/vscode/webview/main.tsx
index 03e8b1d1..4a4bc409 100644
--- a/packages/vscode/webview/main.tsx
+++ b/packages/vscode/webview/main.tsx
@@ -384,6 +384,14 @@ const handleLocalApiRequest = async (input: RequestInfo | URL, url: URL, init: R
     return unsupportedWebRouteResponse('Remote tunnel settings');
   }
 
+  // Archiving a batch of sessions server-side needs an OpenChamber server
+  // process; the extension host has none. Answering explicitly keeps the
+  // shared UI on its per-session archive path instead of leaving the request
+  // to the generic proxy.
+  if (normalizedPathname === '/api/openchamber/sessions/archive') {
+    return unsupportedWebRouteResponse('Server-side session archiving');
+  }
+
   if (/^\/api\/projects\/[^/]+\/scheduled-tasks(?:\/[^/]+)?$/.test(normalizedPathname)) {
     return unsupportedWebRouteResponse('Scheduled tasks');
   }
diff --git a/packages/web/server/lib/openchamber-sessions/routes.js b/packages/web/server/lib/openchamber-sessions/routes.js
index 6c58b333..b9b768e0 100644
--- a/packages/web/server/lib/openchamber-sessions/routes.js
+++ b/packages/web/server/lib/openchamber-sessions/routes.js
@@ -253,6 +253,40 @@ const latestCompletedAssistantMessageID = async ({ client, sessionID, directory
   return asNonEmptyString(latest?.id);
 };
 
+/**
+ * Upper bound on one archive batch.
+ *
+ * The batch is applied one session at a time against OpenCode, so an unbounded
+ * list would hold a request open for as long as the list is large. Callers with
+ * more sessions than this send several batches and keep their own partial
+ * results.
+ */
+const MAX_ARCHIVE_BATCH = 500;
+
+const parseArchiveRequest = (payload) => {
+  const rawIds = payload?.ids;
+  if (!Array.isArray(rawIds) || rawIds.length === 0) {
+    return { ok: false, error: 'ids must be a non-empty array of session ids' };
+  }
+  if (rawIds.length > MAX_ARCHIVE_BATCH) {
+    return { ok: false, error: `ids must contain at most ${MAX_ARCHIVE_BATCH} session ids` };
+  }
+
+  const ids = [];
+  for (const value of rawIds) {
+    const id = asNonEmptyString(value);
+    if (!id) return { ok: false, error: 'ids must contain non-empty session ids' };
+    ids.push(id);
+  }
+
+  const archivedAt = payload?.archivedAt;
+  if (archivedAt !== undefined && (!Number.isSafeInteger(archivedAt) || archivedAt <= 0)) {
+    return { ok: false, error: 'archivedAt must be a positive integer timestamp' };
+  }
+
+  return { ok: true, ids, archivedAt: archivedAt ?? Date.now() };
+};
+
 const resolveRequestedDirectory = async ({ payload, readSettingsFromDiskMigrated, sanitizeProjects, validateDirectoryPath }) => {
   const projectID = asNonEmptyString(payload?.projectId) || asNonEmptyString(payload?.projectID);
   if (projectID) {
@@ -579,6 +613,64 @@ export const createOpenChamberSessionService = (dependencies) => {
     return { model, agent, variant, promptDispatched: true, dispatchedAsCommand: Boolean(resolvedCommand) };
   };
 
+  /**
+   * Archive a batch of sessions in one request.
+   *
+   * The UI archives every session linked to a worktree before removing it.
+   * Doing that from the browser costs one request per session plus a store
+   * reconciliation between each of them, which is what made deleting a
+   * worktree with many sessions take tens of seconds. Here the batch stays on
+   * the server, next to OpenCode, and the client reconciles once.
+   *
+   * Sessions are updated one at a time on purpose: they are archived against a
+   * single OpenCode instance, and a fan-out of concurrent writes would trade a
+   * UI stall for server event-loop starvation. One failed session never stops
+   * the batch — it is reported in `failedIds` while the rest still archive, so
+   * callers keep the partial-failure behaviour they already show.
+   */
+  const archive = async (payload = {}) => {
+    const parsed = parseArchiveRequest(payload);
+    if (!parsed.ok) {
+      throw new OpenChamberControlError(parsed.error, 400);
+    }
+
+    const resolvedDirectory = await resolveRequestedDirectory({
+      payload,
+      readSettingsFromDiskMigrated,
+      sanitizeProjects,
+      validateDirectoryPath,
+    });
+    if (!resolvedDirectory.ok) {
+      throw new OpenChamberControlError(resolvedDirectory.error, resolvedDirectory.status || 400);
+    }
+
+    if (typeof waitForOpenCodeReady === 'function') await waitForOpenCodeReady(10_000, 250);
+
+    const directory = resolvedDirectory.directory;
+    const baseUrl = buildOpenCodeUrl('/', '').replace(/\/$/, '');
+    const client = createOpencodeClient({ baseUrl, headers: getOpenCodeAuthHeaders() });
+
+    const archived = [];
+    const failedIds = [];
+    for (const sessionID of parsed.ids) {
+      try {
+        const response = await client.session.update({
+          sessionID,
+          directory,
+          time: { archived: parsed.archivedAt },
+        });
+        const session = response?.data;
+        if (session?.id) archived.push(session);
+        else failedIds.push(sessionID);
+      } catch (error) {
+        console.warn('[OpenChamberSessions] failed to archive session', sessionID, error);
+        failedIds.push(sessionID);
+      }
+    }
+
+    return { directory, archived, failedIds };
+  };
+
   const create = async (payload = {}) => {
     const title = asNonEmptyString(payload.title);
     const prompt = asNonEmptyString(payload.prompt);
@@ -813,6 +905,7 @@ export const createOpenChamberSessionService = (dependencies) => {
 
   return {
     create,
+    archive,
     send: (sessionID, payload) => runExisting('send', sessionID, payload),
     fork: (sessionID, payload) => runExisting('fork', sessionID, payload),
   };
@@ -843,6 +936,15 @@ export const registerOpenChamberSessionRoutes = (app, dependencies) => {
     }
   });
 
+  app.post('/api/openchamber/sessions/archive', express.json({ limit: '1mb' }), async (req, res) => {
+    try {
+      return res.json(await service.archive(req.body && typeof req.body === 'object' ? req.body : {}));
+    } catch (error) {
+      console.error('[OpenChamberSessions] failed to archive sessions:', error);
+      return sendServiceError(res, error, 'Failed to archive sessions');
+    }
+  });
+
   app.post(
     '/api/openchamber/sessions/:sessionId/send',
     express.json({ limit: '1mb' }),
diff --git a/packages/web/server/lib/openchamber-sessions/routes.test.js b/packages/web/server/lib/openchamber-sessions/routes.test.js
index c95fd6e2..6a60ce73 100644
--- a/packages/web/server/lib/openchamber-sessions/routes.test.js
+++ b/packages/web/server/lib/openchamber-sessions/routes.test.js
@@ -17,6 +17,7 @@ const getWorktreeBootstrapStatusMock = vi.fn(async () => ({
 const sessionCreateMock = vi.fn(async () => ({ data: { id: 'ses_123' } }));
 const sessionForkMock = vi.fn(async () => ({ data: { id: 'ses_fork', title: 'Forked session' } }));
 const sessionMessagesMock = vi.fn(async () => ({ data: [] }));
+const sessionUpdateMock = vi.fn(async ({ sessionID }) => ({ data: { id: sessionID, time: { archived: 1 } } }));
 
 let existingSessionMessages = [];
 let dispatchedUserMessageSeq = 0;
@@ -78,6 +79,7 @@ vi.mock('@opencode-ai/sdk/v2', () => ({
       fork: sessionForkMock,
       messages: sessionMessagesMock,
       command: sessionCommandMock,
+      update: sessionUpdateMock,
     },
     command: {
       list: commandListMock,
@@ -132,6 +134,92 @@ describe('openchamber session routes', () => {
     sessionCommandMock.mockResolvedValue({ data: {} });
     commandListMock.mockReset();
     commandListMock.mockResolvedValue({ data: [] });
+    sessionUpdateMock.mockReset();
+    sessionUpdateMock.mockImplementation(async ({ sessionID }) => ({ data: { id: sessionID, time: { archived: 1 } } }));
+  });
+
+  describe('archiving a batch of sessions', () => {
+    it('archives every id against the resolved directory and returns the archived sessions', async () => {
+      const { app } = createApp();
+      const response = await request(app)
+        .post('/api/openchamber/sessions/archive')
+        .send({ directory: '/repo/app', ids: ['ses_a', 'ses_b'], archivedAt: 1700 })
+        .expect(200);
+
+      expect(response.body.directory).toBe('/repo/app');
+      expect(response.body.archived.map((session) => session.id)).toEqual(['ses_a', 'ses_b']);
+      expect(response.body.failedIds).toEqual([]);
+      expect(sessionUpdateMock).toHaveBeenCalledTimes(2);
+      expect(sessionUpdateMock).toHaveBeenCalledWith({
+        sessionID: 'ses_a',
+        directory: '/repo/app',
+        time: { archived: 1700 },
+      });
+    });
+
+    it('keeps archiving after a failed session and reports it as failed', async () => {
+      sessionUpdateMock.mockImplementation(async ({ sessionID }) => {
+        if (sessionID === 'ses_b') throw new Error('session.update failed');
+        return { data: { id: sessionID } };
+      });
+
+      const { app } = createApp();
+      const response = await request(app)
+        .post('/api/openchamber/sessions/archive')
+        .send({ directory: '/repo/app', ids: ['ses_a', 'ses_b', 'ses_c'] })
+        .expect(200);
+
+      expect(response.body.archived.map((session) => session.id)).toEqual(['ses_a', 'ses_c']);
+      expect(response.body.failedIds).toEqual(['ses_b']);
+    });
+
+    it('reports a session the server did not confirm as failed instead of archived', async () => {
+      sessionUpdateMock.mockImplementation(async ({ sessionID }) => (
+        sessionID === 'ses_b' ? { data: null } : { data: { id: sessionID } }
+      ));
+
+      const { app } = createApp();
+      const response = await request(app)
+        .post('/api/openchamber/sessions/archive')
+        .send({ directory: '/repo/app', ids: ['ses_a', 'ses_b'] })
+        .expect(200);
+
+      expect(response.body.archived.map((session) => session.id)).toEqual(['ses_a']);
+      expect(response.body.failedIds).toEqual(['ses_b']);
+    });
+
+    it('rejects an empty batch, an oversized batch, and non-string ids', async () => {
+      const { app } = createApp();
+
+      await request(app).post('/api/openchamber/sessions/archive').send({ directory: '/repo/app', ids: [] }).expect(400);
+      await request(app)
+        .post('/api/openchamber/sessions/archive')
+        .send({ directory: '/repo/app', ids: Array.from({ length: 501 }, (_, index) => `ses_${index}`) })
+        .expect(400);
+      await request(app)
+        .post('/api/openchamber/sessions/archive')
+        .send({ directory: '/repo/app', ids: ['ses_a', ''] })
+        .expect(400);
+      await request(app)
+        .post('/api/openchamber/sessions/archive')
+        .send({ directory: '/repo/app', ids: ['ses_a'], archivedAt: -1 })
+        .expect(400);
+
+      expect(sessionUpdateMock).not.toHaveBeenCalled();
+    });
+
+    it('rejects a directory the runtime does not accept', async () => {
+      const { app } = createApp({
+        validateDirectoryPath: async () => ({ ok: false, error: 'Invalid directory' }),
+      });
+
+      await request(app)
+        .post('/api/openchamber/sessions/archive')
+        .send({ directory: '/elsewhere', ids: ['ses_a'] })
+        .expect(400);
+
+      expect(sessionUpdateMock).not.toHaveBeenCalled();
+    });
   });
 
   it('creates a session for a directory', async () => {