diff --git a/.prettierignore b/.prettierignore
index d8a963a2..b05bda30 100644
--- a/.prettierignore
+++ b/.prettierignore
@@ -6,6 +6,8 @@ node_modules/
 .worktrees/
 .claude/
 .letta/
+.planning/
+CLAUDE.md
 package-lock.json
 *.AppImage
 *.deb
diff --git a/electron/ipc/channels.ts b/electron/ipc/channels.ts
index cac6fb6f..b46e07a8 100644
--- a/electron/ipc/channels.ts
+++ b/electron/ipc/channels.ts
@@ -30,6 +30,7 @@ export enum IPC {
   RebaseTask = 'rebase_task',
   GetMainBranch = 'get_main_branch',
   GetCurrentBranch = 'get_current_branch',
+  CheckoutBranch = 'checkout_branch',
   GetBranches = 'get_branches',
   CheckIsGitRepo = 'check_is_git_repo',
   CommitAll = 'commit_all',
diff --git a/electron/ipc/git.test.ts b/electron/ipc/git.test.ts
new file mode 100644
index 00000000..634b372a
--- /dev/null
+++ b/electron/ipc/git.test.ts
@@ -0,0 +1,118 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { promisify } from 'util';
+
+vi.mock('child_process', () => {
+  const mockExecFile = vi.fn();
+  // Attach custom promisify handler so promisify(execFile) resolves with
+  // { stdout, stderr } rather than just the first callback argument.
+  (mockExecFile as unknown as Record<symbol, unknown>)[promisify.custom] = (
+    file: unknown,
+    args: unknown,
+    opts: unknown,
+  ): Promise<{ stdout: string; stderr: string }> =>
+    new Promise((resolve, reject) => {
+      mockExecFile(file, args, opts, (err: Error | null, stdout: string, stderr: string) => {
+        if (err) reject(err);
+        else resolve({ stdout, stderr });
+      });
+    });
+
+  return {
+    execFile: mockExecFile,
+    spawn: vi.fn(() => ({
+      stdout: { on: vi.fn() },
+      stderr: { on: vi.fn() },
+      on: vi.fn(),
+    })),
+  };
+});
+
+import { execFile } from 'child_process';
+import {
+  getAllFileDiffsFromBranch,
+  getChangedFilesFromBranch,
+  getFileDiffFromBranch,
+} from './git.js';
+
+type ExecFileCallback = (err: Error | null, stdout: string, stderr: string) => void;
+type MockHandler = (args: string[], cb: ExecFileCallback) => void;
+
+/** Configure the mocked execFile — double cast avoids execFile's 12 overloads */
+function setupMock(calls: string[][], handler: MockHandler): void {
+  const impl = (_cmd: string, args: string[], _opts: unknown, cb: ExecFileCallback) => {
+    calls.push(args);
+    handler(args, cb);
+  };
+  vi.mocked(execFile).mockImplementation(impl as unknown as typeof execFile);
+}
+
+describe('baseBranch fallback to detectMainBranch', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('getAllFileDiffsFromBranch', () => {
+    it('falls back to detected main branch when baseBranch is undefined', async () => {
+      const calls: string[][] = [];
+      setupMock(calls, (argsArr, cb) => {
+        const isDiff = argsArr[0] === 'diff';
+        cb(isDiff ? null : new Error('no remote'), '', '');
+      });
+
+      await getAllFileDiffsFromBranch('/repo', 'feature', undefined);
+
+      const diffCall = calls.find((a) => a[0] === 'diff');
+      expect(diffCall).toBeDefined();
+      const refSpec = diffCall?.[2] ?? '';
+      expect(refSpec).toMatch(/^main\.\.\./);
+    });
+
+    it("uses the provided baseBranch when it is 'develop'", async () => {
+      const calls: string[][] = [];
+      setupMock(calls, (_argsArr, cb) => {
+        cb(null, '', '');
+      });
+
+      await getAllFileDiffsFromBranch('/repo', 'feature', 'develop');
+
+      const diffCall = calls.find((a) => a[0] === 'diff');
+      expect(diffCall).toBeDefined();
+      const refSpec = diffCall?.[2] ?? '';
+      expect(refSpec).toBe('develop...feature');
+      const detectionCalls = calls.filter((a) =>
+        ['symbolic-ref', 'rev-parse', 'config', 'remote'].includes(a[0]),
+      );
+      expect(detectionCalls).toHaveLength(0);
+    });
+  });
+
+  describe('getChangedFilesFromBranch', () => {
+    it("uses 'develop' directly when baseBranch is 'develop'", async () => {
+      const calls: string[][] = [];
+      setupMock(calls, (_argsArr, cb) => {
+        cb(null, '', '');
+      });
+
+      await getChangedFilesFromBranch('/repo', 'feature', 'develop');
+
+      const diffCall = calls.find((a) => a[0] === 'diff');
+      const tripleRef = diffCall?.find((arg) => arg.includes('...')) ?? '';
+      expect(tripleRef).toBe('develop...feature');
+    });
+  });
+
+  describe('getFileDiffFromBranch', () => {
+    it("uses 'develop' directly when baseBranch is 'develop'", async () => {
+      const calls: string[][] = [];
+      setupMock(calls, (_argsArr, cb) => {
+        cb(null, '', '');
+      });
+
+      await getFileDiffFromBranch('/repo', 'feature', 'src/foo.ts', 'develop');
+
+      const diffCall = calls.find((a) => a[0] === 'diff');
+      const tripleRef = diffCall?.find((arg) => arg.includes('...')) ?? '';
+      expect(tripleRef).toBe('develop...feature');
+    });
+  });
+});
diff --git a/electron/ipc/git.ts b/electron/ipc/git.ts
index 289508ab..7407bc17 100644
--- a/electron/ipc/git.ts
+++ b/electron/ipc/git.ts
@@ -192,79 +192,30 @@ async function getCurrentBranchName(repoRoot: string): Promise<string> {
   return stdout.trim();
 }
 
-/**
- * Resolve a branch name to whichever ref is further ahead for comparisons:
- * local branch or its remote-tracking counterpart.  Using the most advanced
- * ref prevents diffs from showing files already present on the other side.
- * Falls back to the bare name when no remote ref exists (local-only repos).
- *
- * Note: for merge-base computation, use detectMergeBase() directly — it
- * compares both local and remote merge-bases to pick the closest one.
- */
-async function resolveComparisonRef(repoRoot: string, branch: string): Promise<string> {
-  if (branch.includes('/')) return branch;
-  if (!(await remoteTrackingRefExists(repoRoot, branch))) return branch;
-
-  const remote = `origin/${branch}`;
-  try {
-    const { stdout } = await exec('git', ['rev-list', '--count', `${branch}..${remote}`], {
-      cwd: repoRoot,
-    });
-    const originAhead = parseInt(stdout.trim(), 10) || 0;
-    return originAhead > 0 ? remote : branch;
-  } catch {
-    return branch;
-  }
-}
-
 async function detectMergeBase(
   repoRoot: string,
   head?: string,
   baseBranch?: string,
 ): Promise<string> {
-  const branch = baseBranch ?? (await detectMainBranch(repoRoot));
-  const headRef = head ?? 'HEAD';
-  const key = `${cacheKey(repoRoot)}:${branch}`;
+  const mainBranch = baseBranch ?? (await detectMainBranch(repoRoot));
+  const key = `${cacheKey(repoRoot)}:${mainBranch}`;
   const cached = mergeBaseCache.get(key);
   if (cached) {
     if (cached.expiresAt > Date.now()) return cached.value;
     mergeBaseCache.delete(key);
   }
 
-  // When a remote-tracking ref exists, compute merge-base against both the
-  // local branch and origin/<branch>, then pick whichever is closer to HEAD.
-  // This avoids showing extra files when local and remote have diverged.
-  const refs = [branch];
-  if (!branch.includes('/') && (await remoteTrackingRefExists(repoRoot, branch))) {
-    refs.push(`origin/${branch}`);
-  }
-
-  let best: string | null = null;
-  for (const ref of refs) {
-    try {
-      const { stdout } = await exec('git', ['merge-base', ref, headRef], { cwd: repoRoot });
-      const mb = stdout.trim();
-      if (!mb) continue;
-      if (!best) {
-        best = mb;
-        continue;
-      }
-      if (mb === best) continue;
-      // Two different merge-bases: pick the descendant (closer to HEAD).
-      // `--is-ancestor A B` succeeds when A is reachable from B.
-      const aIsAncestor = await exec('git', ['merge-base', '--is-ancestor', best, mb], {
-        cwd: repoRoot,
-      }).then(
-        () => true,
-        () => false,
-      );
-      if (aIsAncestor) best = mb;
-    } catch {
-      /* ref may not resolve — skip */
-    }
+  let result: string;
+  try {
+    const { stdout } = await exec('git', ['merge-base', mainBranch, head ?? 'HEAD'], {
+      cwd: repoRoot,
+    });
+    const hash = stdout.trim();
+    result = hash || mainBranch;
+  } catch {
+    result = mainBranch;
   }
 
-  const result = best || branch;
   mergeBaseCache.set(key, { value: result, expiresAt: Date.now() + MERGE_BASE_TTL });
   return result;
 }
@@ -533,6 +484,10 @@ export async function getCurrentBranch(projectRoot: string): Promise<string> {
   return getCurrentBranchName(projectRoot);
 }
 
+export async function checkoutBranch(projectRoot: string, branchName: string): Promise<void> {
+  await exec('git', ['checkout', branchName], { cwd: projectRoot });
+}
+
 export async function getBranches(projectRoot: string): Promise<string[]> {
   const { stdout } = await exec('git', ['branch', '--list', '--format=%(refname:short)'], {
     cwd: projectRoot,
@@ -722,10 +677,7 @@ export async function getAllFileDiffsFromBranch(
   branchName: string,
   baseBranch?: string,
 ): Promise<string> {
-  const mainBranch = await resolveComparisonRef(
-    projectRoot,
-    baseBranch ?? (await detectMainBranch(projectRoot)),
-  );
+  const mainBranch = baseBranch ?? (await detectMainBranch(projectRoot));
   try {
     const { stdout } = await exec('git', ['diff', '-U3', `${mainBranch}...${branchName}`], {
       cwd: projectRoot,
@@ -873,10 +825,7 @@ export async function getWorktreeStatus(
   });
   const hasUncommittedChanges = statusOut.trim().length > 0;
 
-  const mainBranch = await resolveComparisonRef(
-    worktreePath,
-    baseBranch ?? (await detectMainBranch(worktreePath).catch(() => 'HEAD')),
-  );
+  const mainBranch = baseBranch ?? (await detectMainBranch(worktreePath).catch(() => 'HEAD'));
   let hasCommittedChanges = false;
   try {
     const { stdout: logOut } = await exec('git', ['log', `${mainBranch}..HEAD`, '--oneline'], {
@@ -909,10 +858,7 @@ export async function checkMergeStatus(
   worktreePath: string,
   baseBranch?: string,
 ): Promise<{ main_ahead_count: number; conflicting_files: string[] }> {
-  const mainBranch = await resolveComparisonRef(
-    worktreePath,
-    baseBranch ?? (await detectMainBranch(worktreePath)),
-  );
+  const mainBranch = baseBranch ?? (await detectMainBranch(worktreePath));
 
   let mainAheadCount = 0;
   try {
@@ -953,10 +899,9 @@ export async function mergeTask(
 
   return withWorktreeLock(lockKey, async () => {
     const mainBranch = baseBranch ?? (await detectMainBranch(projectRoot));
-    const comparisonRef = await resolveComparisonRef(projectRoot, mainBranch);
     const { linesAdded, linesRemoved } = await computeBranchDiffStats(
       projectRoot,
-      comparisonRef,
+      mainBranch,
       branchName,
     );
 
@@ -971,7 +916,7 @@ export async function mergeTask(
 
     const originalBranch = await getCurrentBranchName(projectRoot).catch(() => null);
 
-    // Checkout main (bare branch name, not remote-tracking ref)
+    // Checkout main
     await exec('git', ['checkout', mainBranch], { cwd: projectRoot });
 
     const restoreBranch = async () => {
@@ -1029,10 +974,7 @@ export async function mergeTask(
 }
 
 export async function getBranchLog(worktreePath: string, baseBranch?: string): Promise<string> {
-  const mainBranch = await resolveComparisonRef(
-    worktreePath,
-    baseBranch ?? (await detectMainBranch(worktreePath).catch(() => 'HEAD')),
-  );
+  const mainBranch = baseBranch ?? (await detectMainBranch(worktreePath).catch(() => 'HEAD'));
   try {
     const { stdout } = await exec(
       'git',
@@ -1053,10 +995,7 @@ export async function getChangedFilesFromBranch(
   branchName: string,
   baseBranch?: string,
 ): Promise<ChangedFile[]> {
-  const mainBranch = await resolveComparisonRef(
-    projectRoot,
-    baseBranch ?? (await detectMainBranch(projectRoot)),
-  );
+  const mainBranch = baseBranch ?? (await detectMainBranch(projectRoot));
 
   let diffStr = '';
   try {
@@ -1095,10 +1034,7 @@ export async function getFileDiffFromBranch(
   filePath: string,
   baseBranch?: string,
 ): Promise<FileDiffResult> {
-  const mainBranch = await resolveComparisonRef(
-    projectRoot,
-    baseBranch ?? (await detectMainBranch(projectRoot)),
-  );
+  const mainBranch = baseBranch ?? (await detectMainBranch(projectRoot));
 
   let diff = '';
   try {
diff --git a/electron/ipc/register.ts b/electron/ipc/register.ts
index c57ada2a..dc54d2e6 100644
--- a/electron/ipc/register.ts
+++ b/electron/ipc/register.ts
@@ -45,6 +45,7 @@ import {
   removeWorktree,
   isGitRepo,
   getBranches,
+  checkoutBranch,
 } from './git.js';
 import { createTask, deleteTask } from './tasks.js';
 import { listAgents } from './agents.js';
@@ -327,6 +328,11 @@ export function registerAllHandlers(win: BrowserWindow): void {
     validatePath(args.projectRoot, 'projectRoot');
     return getCurrentBranch(args.projectRoot);
   });
+  ipcMain.handle(IPC.CheckoutBranch, (_e, args) => {
+    validatePath(args.projectRoot, 'projectRoot');
+    validateBranchName(args.branchName, 'branchName');
+    return checkoutBranch(args.projectRoot, args.branchName);
+  });
   ipcMain.handle(IPC.CheckIsGitRepo, (_e, args) => {
     validatePath(args.path, 'path');
     return isGitRepo(args.path);
diff --git a/electron/preload.cjs b/electron/preload.cjs
index 59890e73..9371171e 100644
--- a/electron/preload.cjs
+++ b/electron/preload.cjs
@@ -35,6 +35,7 @@ const ALLOWED_CHANNELS = new Set([
   'rebase_task',
   'get_main_branch',
   'get_current_branch',
+  'checkout_branch',
   'get_branches',
   'check_is_git_repo',
   // Persistence
diff --git a/package-lock.json b/package-lock.json
index e3c6168d..bacd2cf4 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "parallel-code",
-  "version": "1.2.0",
+  "version": "1.1.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "parallel-code",
-      "version": "1.2.0",
+      "version": "1.1.1",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.12.0-beta.195",
diff --git a/src/components/AgentSelector.tsx b/src/components/AgentSelector.tsx
index 41b4d2b2..71331561 100644
--- a/src/components/AgentSelector.tsx
+++ b/src/components/AgentSelector.tsx
@@ -9,31 +9,7 @@ interface AgentSelectorProps {
   onSelect: (agent: AgentDef) => void;
 }
 
-/**
- * Roving-tabindex agent picker.
- * Only the selected agent is in the Tab order; Arrow keys move between agents.
- */
 export function AgentSelector(props: AgentSelectorProps) {
-  const btnRefs: HTMLButtonElement[] = [];
-
-  function handleKeyDown(e: KeyboardEvent, idx: number) {
-    const agents = props.agents;
-    let nextIdx: number | null = null;
-
-    if (e.key === 'ArrowRight' || e.key === 'ArrowDown') {
-      e.preventDefault();
-      nextIdx = (idx + 1) % agents.length;
-    } else if (e.key === 'ArrowLeft' || e.key === 'ArrowUp') {
-      e.preventDefault();
-      nextIdx = (idx - 1 + agents.length) % agents.length;
-    }
-
-    if (nextIdx !== null) {
-      props.onSelect(agents[nextIdx]);
-      btnRefs[nextIdx]?.focus();
-    }
-  }
-
   return (
     <div data-nav-field="agent" style={{ display: 'flex', 'flex-direction': 'column', gap: '8px' }}>
       <label
@@ -46,20 +22,15 @@ export function AgentSelector(props: AgentSelectorProps) {
       >
         Agent
       </label>
-      <div role="radiogroup" style={{ display: 'flex', 'flex-wrap': 'wrap', gap: '8px' }}>
+      <div style={{ display: 'flex', 'flex-wrap': 'wrap', gap: '8px' }}>
         <For each={props.agents}>
-          {(agent, i) => {
+          {(agent) => {
             const isSelected = () => props.selectedAgent?.id === agent.id;
             return (
               <button
-                ref={(el) => (btnRefs[i()] = el)}
                 type="button"
-                role="radio"
-                aria-checked={isSelected()}
-                tabIndex={isSelected() ? 0 : -1}
                 class={`agent-btn ${isSelected() ? 'selected' : ''}`}
                 onClick={() => props.onSelect(agent)}
-                onKeyDown={(e) => handleKeyDown(e, i())}
                 style={{
                   flex: '0 1 auto',
                   'min-width': '70px',
diff --git a/src/components/NewTaskDialog.tsx b/src/components/NewTaskDialog.tsx
index 1d5fa8e7..506d4f55 100644
--- a/src/components/NewTaskDialog.tsx
+++ b/src/components/NewTaskDialog.tsx
@@ -16,6 +16,7 @@ import {
   setPrefillPrompt,
   setDockerAvailable,
   setDockerImage,
+  showNotification,
 } from '../store/store';
 import type { GitIsolationMode } from '../store/types';
 import { toBranchName, sanitizeBranchPrefix } from '../lib/branch-name';
@@ -46,6 +47,7 @@ export function NewTaskDialog(props: NewTaskDialogProps) {
   const [gitIsolation, setGitIsolation] = createSignal<GitIsolationMode>('worktree');
   const [baseBranch, setBaseBranch] = createSignal('');
   const [branches, setBranches] = createSignal<string[]>([]);
+  const [branchesLoading, setBranchesLoading] = createSignal(false);
   const [skipPermissions, setSkipPermissions] = createSignal(false);
   const [dockerMode, setDockerMode] = createSignal(false);
   const [dockerImageReady, setDockerImageReady] = createSignal<boolean | null>(null); // null = unknown
@@ -58,7 +60,7 @@ export function NewTaskDialog(props: NewTaskDialogProps) {
   let buildOutputRef!: HTMLPreElement;
 
   const focusableSelector =
-    'textarea:not(:disabled):not([tabindex="-1"]), input:not(:disabled):not([tabindex="-1"]), select:not(:disabled):not([tabindex="-1"]), button:not(:disabled):not([tabindex="-1"]), [tabindex]:not([tabindex="-1"])';
+    'textarea:not(:disabled), input:not(:disabled), select:not(:disabled), button:not(:disabled), [tabindex]:not([tabindex="-1"])';
 
   function navigateDialogFields(direction: 'up' | 'down'): void {
     if (!formRef) return;
@@ -110,16 +112,11 @@ export function NewTaskDialog(props: NewTaskDialogProps) {
     if (!props.open) return;
 
     // Reset signals for a fresh dialog
-    // selectedProjectId must be reset to null so the branch-fetching effect
-    // re-triggers even when the same project is selected again on reopen.
-    setSelectedProjectId(null);
     setPrompt('');
     setName('');
     setError('');
     setLoading(false);
     setGitIsolation('worktree');
-    setBaseBranch('');
-    setBranches([]);
     setSkipPermissions(false);
     setDockerMode(false);
     setDockerImageReady(null);
@@ -220,34 +217,55 @@ export function NewTaskDialog(props: NewTaskDialogProps) {
     setBranchPrefix(pid ? getProjectBranchPrefix(pid) : 'task');
   });
 
-  // Fetch branches and set default base branch when project changes
+  // Fetch branches on every dialog open and on project change (D-02 merged effect)
   createEffect(() => {
+    // D-02, D-03: All reactive reads synchronous before any async code
+    const open = props.open;
     const pid = selectedProjectId();
     const projectPath = pid ? getProjectPath(pid) : undefined;
     let cancelled = false;
 
-    if (!projectPath) {
+    if (!open || !projectPath) {
       setBranches([]);
       setBaseBranch('');
+      setBranchesLoading(false);
+      // D-03: onCleanup registered synchronously even on early return
+      onCleanup(() => {
+        cancelled = true;
+      });
       return;
     }
 
-    void (async () => {
+    // D-01: Clear list and show spinner immediately on every open
+    setBranches([]);
+    setBranchesLoading(true);
+
+    const doFetch = async () => {
+      const [branchList, mainBranch] = await Promise.all([
+        invoke<string[]>(IPC.GetBranches, { projectRoot: projectPath }),
+        invoke<string>(IPC.GetMainBranch, { projectRoot: projectPath }),
+      ]);
+      if (cancelled) return;
+      // Set both in same synchronous sequence — avoids SolidJS #2241 select value race
+      setBranches(branchList);
+      const proj = pid ? getProject(pid) : undefined;
+      setBaseBranch(proj?.defaultBaseBranch ?? mainBranch);
+      setBranchesLoading(false);
+    };
+
+    void doFetch().catch(async () => {
+      // D-04: Retry once silently
+      if (cancelled) return;
       try {
-        const [branchList, mainBranch] = await Promise.all([
-          invoke<string[]>(IPC.GetBranches, { projectRoot: projectPath }),
-          invoke<string>(IPC.GetMainBranch, { projectRoot: projectPath }),
-        ]);
+        await doFetch();
+      } catch (err) {
         if (cancelled) return;
-        setBranches(branchList);
-        const proj = pid ? getProject(pid) : undefined;
-        setBaseBranch(proj?.defaultBaseBranch ?? mainBranch);
-      } catch {
-        if (cancelled) return;
-        setBranches([]);
+        setBranchesLoading(false);
+        showNotification(`Failed to load branches: ${String(err)}`);
       }
-    })();
+    });
 
+    // D-03: onCleanup MUST be synchronous in effect body, not inside the IIFE
     onCleanup(() => {
       cancelled = true;
     });
@@ -402,10 +420,17 @@ export function NewTaskDialog(props: NewTaskDialogProps) {
           projectRoot: projectPath,
         });
         if (currentBranch !== baseBranch()) {
-          setError(
-            `Repository is on branch "${currentBranch}", not "${baseBranch()}". Please checkout ${baseBranch()} first.`,
-          );
-          return;
+          try {
+            await invoke(IPC.CheckoutBranch, {
+              projectRoot: projectPath,
+              branchName: baseBranch(),
+            });
+          } catch (err) {
+            setError(
+              `Cannot switch to "${baseBranch()}": ${err instanceof Error ? err.message : String(err)}`,
+            );
+            return;
+          }
         }
       }
 
@@ -439,7 +464,7 @@ export function NewTaskDialog(props: NewTaskDialogProps) {
     <Dialog
       open={props.open}
       onClose={props.onClose}
-      width={store.availableAgents.length > 8 ? '580px' : '500px'}
+      width={store.availableAgents.length > 8 ? '540px' : '420px'}
       panelStyle={{ gap: '20px' }}
     >
       <form
@@ -630,11 +655,20 @@ export function NewTaskDialog(props: NewTaskDialogProps) {
         >
           <label style={sectionLabelStyle}>
             {gitIsolation() === 'worktree' ? 'Base branch' : 'Branch'}
+            <Show when={branchesLoading()}>
+              {' '}
+              <span
+                class="inline-spinner"
+                aria-hidden="true"
+                style={{ 'vertical-align': 'middle' }}
+              />
+            </Show>
           </label>
           <select
             class="input-field"
             value={baseBranch()}
             onChange={(e) => setBaseBranch(e.currentTarget.value)}
+            disabled={branchesLoading()}
             style={{
               background: theme.bgInput,
               border: `1px solid ${theme.border}`,
@@ -644,6 +678,7 @@ export function NewTaskDialog(props: NewTaskDialogProps) {
               'font-size': '13px',
               'font-family': "'JetBrains Mono', monospace",
               outline: 'none',
+              opacity: branchesLoading() ? '0.5' : '1',
             }}
           >
             <For each={branches()}>{(b) => <option value={b}>{b}</option>}</For>
diff --git a/src/components/SegmentedButtons.tsx b/src/components/SegmentedButtons.tsx
index 615a558f..68743009 100644
--- a/src/components/SegmentedButtons.tsx
+++ b/src/components/SegmentedButtons.tsx
@@ -13,59 +13,17 @@ interface SegmentedButtonsProps<T extends string> {
   onChange: (value: T) => void;
 }
 
-/**
- * Roving-tabindex segmented button group.
- * Only the active option is in the Tab order; Arrow keys move between options.
- */
 export function SegmentedButtons<T extends string>(props: SegmentedButtonsProps<T>) {
-  const btnRefs: HTMLButtonElement[] = [];
-
-  function handleKeyDown(e: KeyboardEvent, idx: number) {
-    const opts = props.options;
-    let nextIdx: number | null = null;
-
-    if (e.key === 'ArrowRight' || e.key === 'ArrowDown') {
-      e.preventDefault();
-      // Find next non-disabled option
-      for (let i = 1; i <= opts.length; i++) {
-        const candidate = (idx + i) % opts.length;
-        if (!opts[candidate].disabled) {
-          nextIdx = candidate;
-          break;
-        }
-      }
-    } else if (e.key === 'ArrowLeft' || e.key === 'ArrowUp') {
-      e.preventDefault();
-      for (let i = 1; i <= opts.length; i++) {
-        const candidate = (idx - i + opts.length) % opts.length;
-        if (!opts[candidate].disabled) {
-          nextIdx = candidate;
-          break;
-        }
-      }
-    }
-
-    if (nextIdx !== null) {
-      props.onChange(opts[nextIdx].value);
-      btnRefs[nextIdx]?.focus();
-    }
-  }
-
   return (
-    <div role="radiogroup" style={{ display: 'flex', gap: '4px' }}>
+    <div style={{ display: 'flex', gap: '4px' }}>
       <For each={props.options}>
-        {(opt, i) => {
+        {(opt) => {
           const isActive = () => props.value === opt.value;
           return (
             <button
-              ref={(el) => (btnRefs[i()] = el)}
               type="button"
-              role="radio"
-              aria-checked={isActive()}
               disabled={opt.disabled}
-              tabIndex={isActive() ? 0 : -1}
               onClick={() => !opt.disabled && props.onChange(opt.value)}
-              onKeyDown={(e) => handleKeyDown(e, i())}
               style={{
                 flex: '1',
                 padding: '6px 12px',
diff --git a/src/components/TaskNotesPanel.tsx b/src/components/TaskNotesPanel.tsx
index 7a3f1d45..83ab2292 100644
--- a/src/components/TaskNotesPanel.tsx
+++ b/src/components/TaskNotesPanel.tsx
@@ -260,7 +260,6 @@ export function TaskNotesPanel(props: TaskNotesPanelProps) {
                 <div style={{ flex: '1', overflow: 'hidden' }}>
                   <ChangedFilesList
                     worktreePath={props.task.worktreePath}
-                    baseBranch={props.task.baseBranch}
                     isActive={props.isActive}
                     onFileClick={(file) => props.onDiffFileClick(file.path)}
                     ref={(el) => (changedFilesRef = el)}
diff --git a/src/components/TerminalView.tsx b/src/components/TerminalView.tsx
index 24f98980..3b169058 100644
--- a/src/components/TerminalView.tsx
+++ b/src/components/TerminalView.tsx
@@ -148,7 +148,7 @@ export function TerminalView(props: TerminalViewProps) {
     });
 
     fitAddon.fit();
-    registerTerminal(agentId, containerRef, fitAddon, term);
+    registerTerminal(agentId, containerRef, fitAddon);
 
     if (props.autoFocus) {
       term.focus();
diff --git a/src/lib/focus-trap.ts b/src/lib/focus-trap.ts
index a86b8e38..5935eab9 100644
--- a/src/lib/focus-trap.ts
+++ b/src/lib/focus-trap.ts
@@ -1,7 +1,7 @@
 import { createEffect, onCleanup } from 'solid-js';
 
 const FOCUSABLE =
-  'button:not([disabled]):not([tabindex="-1"]), [href]:not([tabindex="-1"]), input:not([disabled]):not([tabindex="-1"]), select:not([disabled]):not([tabindex="-1"]), textarea:not([disabled]):not([tabindex="-1"]), [tabindex]:not([tabindex="-1"])';
+  'button:not([disabled]), [href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])';
 
 /**
  * Traps Tab / Shift+Tab focus cycling within a container element
diff --git a/src/lib/terminalFitManager.ts b/src/lib/terminalFitManager.ts
index 95cd6bb9..3ad58790 100644
--- a/src/lib/terminalFitManager.ts
+++ b/src/lib/terminalFitManager.ts
@@ -1,10 +1,8 @@
 import type { FitAddon } from '@xterm/addon-fit';
-import type { Terminal } from '@xterm/xterm';
 
 interface TerminalEntry {
   container: HTMLElement;
   fitAddon: FitAddon;
-  term: Terminal;
   dirty: boolean;
 }
 
@@ -43,20 +41,8 @@ function flush() {
     if (!entry.dirty) continue;
     entry.dirty = false;
 
-    // xterm.js scroll position workaround (xtermjs/xterm.js#5096):
-    // fit() → resize() → Viewport._sync() can reset scrollTop to 0 when
-    // it encounters a transient dimension mismatch. Save the viewport
-    // scroll position before fitting and restore it if clobbered.
-    const buf = entry.term.buffer.active;
-    const wasScrolledUp = buf.viewportY < buf.baseY;
-    const savedViewportY = buf.viewportY;
-
     entry.fitAddon.fit();
 
-    if (wasScrolledUp && buf.viewportY !== savedViewportY) {
-      entry.term.scrollToLine(Math.min(savedViewportY, buf.baseY));
-    }
-
     didWork = true;
   }
   // Only update throttle timestamp when we actually fitted something —
@@ -87,13 +73,8 @@ function scheduleFlush() {
   }, THROTTLE_MS);
 }
 
-export function registerTerminal(
-  id: string,
-  container: HTMLElement,
-  fitAddon: FitAddon,
-  term: Terminal,
-): void {
-  entries.set(id, { container, fitAddon, term, dirty: false });
+export function registerTerminal(id: string, container: HTMLElement, fitAddon: FitAddon): void {
+  entries.set(id, { container, fitAddon, dirty: false });
   resizeObserver.observe(container);
   intersectionObserver.observe(container);
 }
diff --git a/src/store/persistence.ts b/src/store/persistence.ts
index a4597624..6aed0253 100644
--- a/src/store/persistence.ts
+++ b/src/store/persistence.ts
@@ -367,7 +367,7 @@ export async function loadState(): Promise<void> {
           notes: pt.notes,
           lastPrompt: pt.lastPrompt,
           gitIsolation: legacy.gitIsolation ?? (legacy.directMode ? 'direct' : 'worktree'),
-          baseBranch: legacy.baseBranch,
+          baseBranch: legacy.baseBranch || undefined,
           skipPermissions: pt.skipPermissions === true,
           dockerMode: pt.dockerMode === true ? true : undefined,
           dockerImage: typeof pt.dockerImage === 'string' ? pt.dockerImage : undefined,
@@ -429,7 +429,7 @@ export async function loadState(): Promise<void> {
           lastPrompt: pt.lastPrompt,
           gitIsolation:
             legacyCollapsed.gitIsolation ?? (legacyCollapsed.directMode ? 'direct' : 'worktree'),
-          baseBranch: legacyCollapsed.baseBranch,
+          baseBranch: legacyCollapsed.baseBranch || undefined,
           skipPermissions: pt.skipPermissions === true,
           dockerMode: pt.dockerMode === true ? true : undefined,
           dockerImage: typeof pt.dockerImage === 'string' ? pt.dockerImage : undefined,
diff --git a/src/store/tasks.ts b/src/store/tasks.ts
index df72010a..aeb3bb22 100644
--- a/src/store/tasks.ts
+++ b/src/store/tasks.ts
@@ -114,7 +114,7 @@ export async function createTask(opts: CreateTaskOptions): Promise<string> {
       projectRoot,
       symlinkDirs,
       branchPrefix,
-      baseBranch,
+      baseBranch: baseBranch || undefined,
     });
     taskId = result.id;
     branchName = result.branch_name;
@@ -134,7 +134,7 @@ export async function createTask(opts: CreateTaskOptions): Promise<string> {
     name,
     projectId,
     gitIsolation,
-    baseBranch,
+    baseBranch: baseBranch || undefined,
     branchName,
     worktreePath,
     agentIds: [agentId],