diff --git a/CHANGELOG.md b/CHANGELOG.md
index 169a805..def9767 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,18 @@
 # Changelog
 
+## 1.0.80
+
+- Feat: multi-account Batch 2c-lite — pick the account when launching a new session
+  - `⌥⌘+Enter` on a project opens a small account picker (↑↓ / Enter / Esc, or click) — external terminals (iTerm2/Terminal.app/Ghostty/cmux); a non-default pick launches via explicit `CLAUDE_CONFIG_DIR` + `command claude`, a default-account pick via `env -u CLAUDE_CONFIG_DIR claude`
+  - Plain `⌘+Enter` unchanged: opens instantly under the global default; single-account (or registry-less) setups never see the picker
+  - Search-bar hint shows `⌥⌘+Enter: pick account` only for multi-account setups, and updates live after account changes (no app restart)
+  - Tab completion for `claude <name>`: `claude <TAB>` completes account names (polite: skipped if another completion owns `claude`; other positions keep file completion)
+  - Removed the stray `|` (react-select's default separator) before the search-bar hint
+  - Accounts UI: per-row **Rename**; the first-ever add asks what to name your existing `~/.claude` login (defaults to `main`) instead of assuming `personal`; `default` is now a reserved account name
+  - `codev account rename <old> <new>` (CLI) — labels are renameable; folders never move (credentials are keyed by the folder path)
+  - README gains a Multi-Account section (shell commands, `codev account` CLI, UI map)
+  - Roadmap: 2d (folder→account auto-switch) dropped — one folder legitimately hosts sessions from multiple accounts; cross-account *resume* stays deferred to Batch 3 (copy-fork design)
+
 ## 1.0.79
 
 - Feat: multi-account Batch 2b (part 2) — `codev` command in your shell
diff --git a/README.md b/README.md
index e5fc6d1..746a9a2 100644
--- a/README.md
+++ b/README.md
@@ -41,6 +41,73 @@ For the full same-cwd accuracy matrix (detection + switch by launch method and t
 | cmux | Title match → TTY fallback | CLI new-workspace | Same as iTerm2 (requires cmux v0.63+); requires socket access in cmux Settings (`automation` or `allowAll`) |
 | VS Code | URI handler (session-level) | `open -b` + URI handler | Requires Claude Code VS Code extension v2.1.72+; `[VSCODE]` badge on active sessions; adaptive resume via IDE lock file polling (~0.5s if project already open) |
 
+### Multi-Account Support (Claude Code)
+
+Run multiple Claude Code accounts (e.g. personal + work) on one machine. Each account gets its own config dir (via `CLAUDE_CONFIG_DIR`); the default account stays at `~/.claude` untouched. The Sessions tab aggregates sessions from every account (non-default ones get a purple account badge), and each session always resumes under the account it belongs to.
+
+**Setup** — Settings → Accounts:
+
+1. **Add** an account (e.g. `work`) — writes the registry (`~/.config/codev/accounts.json`) and generates `~/.config/codev/accounts.sh`
+2. **Install** Shell integration — appends one marker-guarded `source` line to `~/.zshrc` (zsh; the generated file is bash-sourceable manually, fish unsupported)
+3. Open a new shell and log in: `claude work`
+
+**Shell commands** (from the generated `accounts.sh`):
+
+| Command | What it does |
+|---------|--------------|
+| `claude` | Launches the **global default** account (configurable, see below) |
+| `claude <name> […]` | Launches that account, full passthrough (e.g. `claude work -r`) |
+| `claude-<name> […]` | Function form of the same (e.g. `claude-work mcp list`) |
+| `claude-whoami` | Which account bare `claude` resolves to here, plus its auth status |
+| `claude-accounts` | Quick list of configured accounts |
+
+Tab completion included (zsh): `claude <TAB>` completes account names; `codev account <TAB>` completes subcommands and labels. (The `claude` completion is registered only when nothing else completes `claude` — if you already have one, account names won't be injected into it.)
+
+The **default account** can be launched three equivalent ways: bare `claude`, `claude <its-name>`, or `claude-<its-name>` (the UI's row shows this).
+
+**`codev account` CLI** (the account manager — same generator the Settings UI uses):
+
+| Command | What it does |
+|---------|--------------|
+| `codev account list` (`ls`) | Accounts + identity; `*` marks the bare-`claude` default |
+| `codev account add <name> [--dir D]` | Register an account (default dir `~/.claude-<name>`) |
+| `codev account default <name>` | Point bare `claude` at an account |
+| `codev account remove <name>` (`rm`) | Unregister; keeps its folder on disk |
+| `codev account rename <old> <new>` | Rename a label — the folder is not moved; also the way to rename the auto-seeded default account (`personal`) |
+| `codev account regenerate` (`regen`) | Rewrite `accounts.sh` from the registry |
+| `codev account show` (`preview`) | Dry-run print of the generated `accounts.sh` |
+| `codev account install` / `uninstall` | Add / remove the `~/.zshrc` source block |
+
+> **Add is just a mapping.** `add <name>` registers *name → config folder* (default `~/.claude-<name>` — that folder **is** the account's `CLAUDE_CONFIG_DIR`). Claude Code itself creates and fills the folder on first login (`claude <name>`). One folder = one account: registering an already-registered folder under a second name is rejected.
+>
+> **Name vs folder.** The name is a mutable label; the folder is fixed at creation. They can diverge (after a rename) and the UI shows `· folder: …` on the row when they do. Folders deliberately never move on rename: Claude Code keys the account's credentials by the config-dir **path**, so moving the folder would orphan the login.
+>
+> **Remove is non-destructive.** It only unregisters that mapping: the account's folder, login, and session history all stay on disk. `codev account add <name>` (or the UI) later reattaches everything — identity and sessions reappear immediately, no re-login needed. **Caveat after a rename:** the folder keeps its *original* suffix (rename never moves folders), so re-attach with the folder-matching name — e.g. an account created as `work`, renamed to `ff`, then removed, re-attaches via `add work` (or any name with `--dir ~/.claude-work`), **not** `add ff`. Likewise, an account originally registered with a custom `--dir` always needs `--dir <original-folder>` again on re-add.
+
+**Common scenarios:**
+
+| You are… | What happens / what to do |
+|----------|---------------------------|
+| An existing Claude Code user opening CodeV for the first time | Accounts tab is **empty** (zero footprint — no registry is created until you act); your `~/.claude` login keeps working as before. When you add a second account, **you name your existing login at the same time** (a field appears; empty = `main`) and both get registered together. |
+| Renaming any account later | The **Rename** button on each row, or `codev account rename <old> <new>`. To pre-name your existing default before adding anything: `codev account add <name> --dir ~/.claude` (registers the default itself; no extra account created). `default` is a reserved name. |
+| Starting fresh: add first, log in later | Add a name (UI or CLI) → it shows "not logged in" → in a new shell, `claude <name>` runs Claude Code's login and creates the folder. |
+| Already running a second account by hand (own shell function + custom folder) | Register it with `codev account add <name> --dir <your-folder>` — **any folder works**; `~/.claude-<name>` is only the default. Identity and sessions attach immediately, no re-login. If your hand-rolled wrapper was named `claude`, retire it (it would fight the generated dispatcher). |
+| Wondering why a name maps to a different folder | Renames change only the name side of the *name → folder* mapping; folders never move (credentials are keyed by the folder path) — the UI shows `· folder: …` on the row when they diverge. |
+
+> Not yet supported: auto-detecting existing config folders for one-click registration, and a warning when `accounts.sh` overrides a hand-rolled `claude()` shell function ([#127](https://github.com/grimmerk/codev/issues/127)); continuing an existing conversation under a *different* account — "copy-fork" — needs transcript-level workarounds first ([#128](https://github.com/grimmerk/codev/issues/128)).
+
+The `codev` command runs the CLI **bundled inside CodeV.app** (`ELECTRON_RUN_AS_NODE`) — no system Node, no sudo, no PATH edits. CodeV refreshes `accounts.sh` on every launch, so moving or renaming the app self-heals. (Not available in MAS builds — sandboxed.)
+
+**In the CodeV UI:**
+
+| Where | What |
+|-------|------|
+| Settings → Accounts | List/add/remove accounts, set the global default, install shell integration |
+| Sessions tab | Sessions from all accounts with account badges; resume uses each session's own account |
+| Projects tab: `⌥⌘+Enter` | Pick the account for a new session (`⌘+Enter` stays instant, under the global default). Account override applies to external terminals (iTerm2, Terminal.app, Ghostty, cmux); VS Code ([#121](https://github.com/grimmerk/codev/issues/121)) and the embedded Term tab ignore it |
+
+**Gotcha:** inside a Claude Code session, `!claude auth status` reports the *global default* (the shell snapshot carries the dispatcher function), not the session's account — use `!command claude auth status` instead. Full design + details: [docs/multi-account-support-design.md](docs/multi-account-support-design.md).
+
 ### Embedded Terminal
 
 CodeV includes a built-in terminal tab (powered by xterm.js + node-pty, same technology as VS Code's integrated terminal). Press `⌃+⌘+T` from anywhere (global shortcut) or `⌘+3` when CodeV is in foreground to open it.
diff --git a/docs/multi-account-support-design.md b/docs/multi-account-support-design.md
index a92f38f..36ab149 100644
--- a/docs/multi-account-support-design.md
+++ b/docs/multi-account-support-design.md
@@ -453,18 +453,41 @@ and **(d)** for CodeV, backed by the same `projectMap` in the registry so both a
     registry + `accounts.sh` from one shared generator (§6.A/B); Vitest + CI added.
   - *2b (UI ✅, branch `feat/accounts-settings-ui`):* Accounts tab in Settings —
     list/add/remove + set-default + shell-integration toggle (§6.D), as IPC wrappers
-    over the shared manager (one generator with the CLI). Rename deferred (labels name
-    dirs; remove+add covers it).
+    over the shared manager (one generator with the CLI). (Rename was deferred here,
+    then shipped in 2c-lite below — CLI + per-row UI.)
   - *2b part 2 (✅, branch `feat/codev-path-binary`):* the `codev` command — a
     `codev()` function in accounts.sh runs the CLI bundled inside CodeV.app via
     `ELECTRON_RUN_AS_NODE` (no system Node; no sudo/PATH edits). The app records its
     real `.app` location in the registry (`appPath`) on every launch and refreshes
     accounts.sh, so app moves and generator updates self-heal. CLI is tsc-compiled
     into `resources/cli` (extraResource) at build time.
-  - *2c:* account picker / per-launch override (§6.G, 4.2).
-  - *2d:* pyenv-style folder auto-switch + terminal-side resume-to-right-account (§6.H).
-  - *2e:* configurable global-default (bare `claude` → chosen account) — last, since it
-    also needs the CLI/UI to manage.
+  - *2c-lite (✅, branch `feat/new-session-account-picker`):* NEW-session account
+    picker — ⌥⌘+Enter on a project opens a picker (⌘+Enter unchanged → global
+    default; single-account setups never see it); launches with explicit
+    `CLAUDE_CONFIG_DIR` + `command claude` (an anchor-account pick uses
+    `env -u CLAUDE_CONFIG_DIR claude` instead — §3.4). Post-review naming UX: per-row UI Rename +
+    `codev account rename` (label-only — folders never move; credentials are keyed by
+    the config-dir path); the first-ever add asks what to name the existing ~/.claude
+    login (defaults to `main` — or `primary` when the new account itself is named
+    `main` — replacing the presumptuous auto-`personal`); `default` is
+    a reserved label (it names the dispatcher-target concept). Cross-account *resume*
+    (the other half of §6.G) stays deferred to Batch 3 as explicit copy-fork — a transcript lives in
+    its own account's projects dir, so "resume under another account" must copy, never
+    link. "This repo always opens under X" belongs to 2d's projectMap.
+  - *2d — ❌ dropped (2026-07-10):* pyenv-style folder auto-switch (§6.H). Rationale:
+    in practice one folder hosts sessions from MULTIPLE accounts (we test exactly this
+    way), so a folder→account default would guess wrong precisely where the account
+    choice matters; stacking a third decision layer (global default → folder default →
+    picker) adds "why did bare claude open work here?" confusion for thin value. The
+    need is covered by 2e (global default) + 2c-lite (explicit per-launch picker).
+    Technically it was feasible (a default, not a constraint — resume always follows
+    the session's own account); dropped on value, not feasibility.
+  - *2e — ✅ shipped with 2a (PR #123, v1.0.77):* configurable global-default —
+    `codev account default <label>` / Settings → Set default routes bare `claude`
+    through the dispatcher `*)` to the chosen account. CodeV bypasses the dispatcher
+    only for *account-explicit* operations (resuming a session under its own account,
+    picker launches) via `command claude` / explicit env; the plain ⌘+Enter new-session
+    path deliberately stays on bare `claude` so the dispatcher's global default applies.
 - **Batch 3 — later:** cross-account symlink reuse of global files
   (CLAUDE.md / skills / commands / plugins / settings, §5).
 
diff --git a/package.json b/package.json
index d7b2758..c13a498 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "CodeV",
   "productName": "CodeV",
-  "version": "1.0.79",
+  "version": "1.0.80",
   "description": "Quick switcher for VS Code, Cursor, and Claude Code sessions",
   "repository": {
     "type": "git",
diff --git a/src/claude-session-utility.ts b/src/claude-session-utility.ts
index 8c351c5..e83349e 100644
--- a/src/claude-session-utility.ts
+++ b/src/claude-session-utility.ts
@@ -8,7 +8,11 @@ import * as path from 'path';
 import * as os from 'os';
 import * as fs from 'fs';
 import { getCurrentIDEBundleId } from './vscode-based-ide-utility';
-import { getScannableAccounts, getProjectsDir } from './accounts';
+import {
+  getScannableAccounts,
+  getProjectsDir,
+  getAccountByLabel,
+} from './accounts';
 
 export interface ClaudeSession {
   sessionId: string;
@@ -1389,6 +1393,7 @@ export const launchNewClaudeSession = (
   projectPath: string,
   terminalApp: string = 'iterm2',
   terminalMode: string = 'tab',
+  accountLabel?: string,
 ): void => {
   if (terminalApp === 'vscode') {
     const { execFile } = require('child_process');
@@ -1411,12 +1416,45 @@ export const launchNewClaudeSession = (
     return;
   }
   if (terminalApp === 'codev') {
+    // Embedded terminal spawns the user's shell; the account override isn't
+    // threaded through it yet (the 2c-lite picker targets external terminals).
+    if (accountLabel) {
+      console.log(
+        '[launchNewClaudeSession] account override ignored for codev terminal:',
+        accountLabel,
+      );
+    }
     if (launchInCodevTerminalCallback) {
       launchInCodevTerminalCallback(projectPath);
     }
     return;
   }
-  runCommandInTerminal(`cd "${projectPath}" && claude`, 'claude', projectPath, terminalApp, terminalMode);
+  // No accountLabel: bare `claude` → the accounts.sh dispatcher → the user's
+  // global default (2e). With an explicit account (2c-lite picker): bypass the
+  // dispatcher via `command claude` + explicit env, like buildResumeCommand.
+  let claudeCmd = 'claude';
+  if (accountLabel) {
+    const account = getAccountByLabel(accountLabel);
+    if (account?.label !== accountLabel) {
+      // Stale/unknown label (e.g. the account was removed after the picker
+      // loaded) — getAccountByLabel falls back to the default account, so
+      // abort instead of silently launching a different identity.
+      console.error(
+        '[launchNewClaudeSession] unknown account label, aborting:',
+        accountLabel,
+      );
+      return;
+    }
+    // Explicit pick of the default account: clear any inherited
+    // CLAUDE_CONFIG_DIR too (matches the generated accounts.sh launchers).
+    claudeCmd = account.configDirEnv
+      ? `CLAUDE_CONFIG_DIR='${account.configDirEnv.replace(/'/g, "'\\''")}' command claude`
+      : 'env -u CLAUDE_CONFIG_DIR claude';
+  }
+  // Pass claudeCmd as the 2nd arg too — Ghostty/cmux build their launch
+  // scripts from it (iTerm2/Terminal.app use fullCommand), so the account
+  // env prefix must be present in both.
+  runCommandInTerminal(`cd "${projectPath}" && ${claudeCmd}`, claudeCmd, projectPath, terminalApp, terminalMode);
 };
 
 /**
diff --git a/src/cli/account-manager.test.ts b/src/cli/account-manager.test.ts
index ea89425..7d1902b 100644
--- a/src/cli/account-manager.test.ts
+++ b/src/cli/account-manager.test.ts
@@ -142,13 +142,24 @@ describe('generateAccountsSh', () => {
     expect(sh).toContain('_codev() {');
     expect(sh).toContain('compdef _codev codev');
     expect(sh).toContain(
-      'compadd list add default remove rm regenerate show install uninstall help',
+      'compadd list add default remove rm rename regenerate show install uninstall help',
     );
-    expect(sh).toContain('default) compadd personal work ;;');
+    expect(sh).toContain('default|rename) compadd personal work ;;');
     // anchor (personal) is not removable
     expect(sh).toContain('remove|rm) compadd work ;;');
   });
 
+  it('completes account labels for `claude <TAB>` without clobbering', () => {
+    // Works even without appPath — the dispatcher exists whenever accounts do.
+    const sh = generateAccountsSh(reg());
+    expect(sh).toContain('_claude_codev_accounts() {');
+    expect(sh).toContain('compadd personal work');
+    // polite registration: only when nothing else completes `claude`
+    expect(sh).toContain('[ -z "${_comps[claude]:-}" ]');
+    // non-label positions keep the default file completion
+    expect(sh).toContain('_files');
+  });
+
   it('uses the recorded appExec so a renamed .app bundle still works', () => {
     const sh = generateAccountsSh(
       reg({
diff --git a/src/cli/account-manager.ts b/src/cli/account-manager.ts
index a335e7d..eca0a8a 100644
--- a/src/cli/account-manager.ts
+++ b/src/cli/account-manager.ts
@@ -54,6 +54,11 @@ const ZSHRC_END = '# <<< codev accounts <<<';
 // Labels become shell function names + case branches, so keep them safe.
 const LABEL_RE = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
 
+// 'default' is reserved: it already names the dispatcher's global-default
+// concept (the `default` badge, `codev account default`) — an account with
+// that name would be permanently confusing.
+const RESERVED_LABELS = new Set(['default']);
+
 export const expandHome = (p: string): string =>
   typeof p === 'string' && p.startsWith('~')
     ? path.join(os.homedir(), p.slice(1))
@@ -331,11 +336,11 @@ export function generateAccountsSh(reg: Registry): string {
     L.push('    compadd account');
     L.push('  elif (( CURRENT == 3 )) && [ "${words[2]}" = "account" ]; then');
     L.push(
-      '    compadd list add default remove rm regenerate show install uninstall help',
+      '    compadd list add default remove rm rename regenerate show install uninstall help',
     );
     L.push('  elif (( CURRENT == 4 )) && [ "${words[2]}" = "account" ]; then');
     L.push('    case "${words[3]}" in');
-    if (allLabels) L.push(`      default) compadd ${allLabels} ;;`);
+    if (allLabels) L.push(`      default|rename) compadd ${allLabels} ;;`);
     if (removable) L.push(`      remove|rm) compadd ${removable} ;;`);
     L.push('    esac');
     L.push('  fi');
@@ -346,6 +351,30 @@ export function generateAccountsSh(reg: Registry): string {
     L.push('  compdef _codev codev');
     L.push('fi');
   }
+  // Account-label completion for the `claude <label>` dispatcher. Registered
+  // only when nothing else completes `claude` (checked via _comps), so an
+  // official Claude Code completion — if one ever ships — wins automatically.
+  // Independent of appPath — the dispatcher exists whenever accounts do.
+  const allLabelsForClaude = accounts.map((a) => a.label).join(' ');
+  if (allLabelsForClaude) {
+    L.push('');
+    L.push('# Complete account names for `claude <TAB>` (labels only; native');
+    L.push('# claude flags/subcommands still work — just not suggested).');
+    L.push('_claude_codev_accounts() {');
+    L.push('  if (( CURRENT == 2 )); then');
+    L.push('    # no label matches the typed prefix -> fall back to files');
+    L.push(`    compadd ${allLabelsForClaude} || _files`);
+    L.push('  else');
+    L.push('    # keep the default file completion for every other position');
+    L.push('    _files');
+    L.push('  fi');
+    L.push('}');
+    L.push(
+      'if [ -n "${ZSH_VERSION:-}" ] && (( ${+functions[compdef]} )) && [ -z "${_comps[claude]:-}" ]; then',
+    );
+    L.push('  compdef _claude_codev_accounts claude');
+    L.push('fi');
+  }
   L.push('');
   return L.join('\n');
 }
@@ -394,7 +423,7 @@ export function regenerate(reg?: Registry): string {
 
 export function addAccount(
   label: string,
-  opts: { dir?: string } = {},
+  opts: { dir?: string; anchorName?: string } = {},
 ): RegistryAccount {
   if (!label) throw new Error('add: <label> is required');
   if (!LABEL_RE.test(label)) {
@@ -402,6 +431,11 @@ export function addAccount(
       `Invalid label "${label}" — use a letter followed by letters/digits/-/_`,
     );
   }
+  if (RESERVED_LABELS.has(label)) {
+    throw new Error(
+      `"${label}" is reserved (it names the bare-claude target) — pick another name`,
+    );
+  }
   const reg = readRegistry();
   if (reg.accounts.some((a) => a.label === label)) {
     throw new Error(`Account "${label}" already exists`);
@@ -410,13 +444,37 @@ export function addAccount(
     opts.dir || path.join(os.homedir(), `.claude-${label}`),
   );
   assertSafeDir(dir);
+  // One folder = one account: a second mapping to the same dir would make
+  // CodeV double-scan its sessions and blur attribution.
+  const dupDir = reg.accounts.find(
+    (a) => path.resolve(expandHome(a.dir)) === path.resolve(dir),
+  );
+  if (dupDir) {
+    throw new Error(
+      `That folder is already registered as "${dupDir.label}" (${dir})`,
+    );
+  }
   const isDefault = isDefaultDir(dir);
   // Fresh registry + adding an EXTRA account: seed the anchor (~/.claude)
   // account first, so the machine's existing default install stays registered
   // and keeps the global default (instead of it silently moving to a
   // brand-new, not-yet-logged-in account).
   if (reg.accounts.length === 0 && !isDefault) {
-    const anchorLabel = label === 'personal' ? 'default' : 'personal';
+    // The anchor's name is the USER'S choice (UI first-add field / CLI
+    // --anchor-name); 'main' is only the neutral prefill — never assume
+    // 'personal' (the machine's first login may well be a company account).
+    const anchorLabel =
+      opts.anchorName || (label === 'main' ? 'primary' : 'main');
+    if (!LABEL_RE.test(anchorLabel) || RESERVED_LABELS.has(anchorLabel)) {
+      throw new Error(
+        `Invalid name "${anchorLabel}" for the existing ~/.claude account`,
+      );
+    }
+    if (anchorLabel === label) {
+      throw new Error(
+        'The new account and your existing (~/.claude) account need different names',
+      );
+    }
     const anchorIdentity = path.join(os.homedir(), '.claude.json');
     reg.accounts.push({
       label: anchorLabel,
@@ -477,6 +535,36 @@ export function removeAccount(label: string): string | undefined {
   return reassignedDefault;
 }
 
+/**
+ * Rename an account's label (the folder is NOT moved — `dir` is stored in the
+ * registry, so extra accounts keep working even when label ≠ folder suffix).
+ * This is also the only way to rename the anchor (~/.claude) account, whose
+ * auto-seeded "personal" label can't be changed via remove+add (the anchor is
+ * protected from removal).
+ */
+export function renameAccount(oldLabel: string, newLabel: string): void {
+  if (!newLabel || !LABEL_RE.test(newLabel)) {
+    throw new Error(
+      `Invalid label "${newLabel}" — use a letter followed by letters/digits/-/_`,
+    );
+  }
+  if (RESERVED_LABELS.has(newLabel)) {
+    throw new Error(
+      `"${newLabel}" is reserved (it names the bare-claude target) — pick another name`,
+    );
+  }
+  const reg = readRegistry();
+  const acct = reg.accounts.find((a) => a.label === oldLabel);
+  if (!acct) throw new Error(`No account "${oldLabel}"`);
+  if (reg.accounts.some((a) => a.label === newLabel)) {
+    throw new Error(`Account "${newLabel}" already exists`);
+  }
+  acct.label = newLabel;
+  if (reg.defaultAccount === oldLabel) reg.defaultAccount = newLabel;
+  writeRegistry(reg);
+  regenerate(reg);
+}
+
 export function setDefault(label: string): void {
   const reg = readRegistry();
   if (!reg.accounts.some((a) => a.label === label)) {
diff --git a/src/cli/codev-account.ts b/src/cli/codev-account.ts
index 515d87c..99802d7 100644
--- a/src/cli/codev-account.ts
+++ b/src/cli/codev-account.ts
@@ -20,9 +20,14 @@ const USAGE = `codev account — manage CodeV multi-account registry
 
 Usage:
   codev account list                 List configured accounts
-  codev account add <label> [--dir D] Register a new account (default dir ~/.claude-<label>)
+  codev account add <label> [--dir D] [--anchor-name N]
+                                     Register a new account (default dir ~/.claude-<label>);
+                                     on the first-ever add, N names your existing
+                                     ~/.claude account (default: main — or primary
+                                     when the new account itself is named main)
   codev account default <label>      Set which account bare \`claude\` resolves to
   codev account remove <label>       Unregister an account (leaves its dir on disk)
+  codev account rename <old> <new>   Rename an account's label (folder is not moved)
   codev account regenerate           Rewrite ~/.config/codev/accounts.sh from the registry
   codev account show                 Print the generated accounts.sh (dry run, writes nothing)
   codev account install              Add the source line to ~/.zshrc (idempotent)
@@ -78,13 +83,26 @@ function main(): number {
 
     case 'add': {
       const dir = getFlag(rest, '--dir');
-      // Skip the token consumed by `--dir` so `add --dir /foo work` still picks
+      const anchorName = getFlag(rest, '--anchor-name');
+      // Skip tokens consumed by flags so `add --dir /foo work` still picks
       // `work` as the label (not `/foo`).
-      const dirIdx = rest.indexOf('--dir');
-      const skipIdx = dirIdx >= 0 ? dirIdx + 1 : -1;
-      const label = rest.find((a, i) => !a.startsWith('-') && i !== skipIdx);
-      const acct = manager.addAccount(label as string, { dir });
+      const skip = new Set<number>();
+      for (const flag of ['--dir', '--anchor-name']) {
+        const i = rest.indexOf(flag);
+        if (i >= 0) skip.add(i + 1);
+      }
+      const label = rest.find((a, i) => !a.startsWith('-') && !skip.has(i));
+      const wasFresh = manager.readRegistry().accounts.length === 0;
+      const acct = manager.addAccount(label as string, { dir, anchorName });
       console.log(`✓ Added "${acct.label}"  (${acct.dir})`);
+      if (wasFresh && !acct.isDefault) {
+        const anchor = manager.listAccounts().find((x) => x.isDefault);
+        if (anchor) {
+          console.log(
+            `  Your existing ~/.claude login is registered as "${anchor.label}" (change: codev account rename ${anchor.label} <new>)`,
+          );
+        }
+      }
       if (!acct.loggedIn) {
         console.log(
           `  Log in with:  claude ${acct.label}   (or claude-${acct.label})`,
@@ -102,6 +120,18 @@ function main(): number {
       return 0;
     }
 
+    case 'rename': {
+      const [oldLabel, newLabel] = rest;
+      manager.renameAccount(oldLabel, newLabel);
+      console.log(`✓ Renamed "${oldLabel}" → "${newLabel}" (folder unchanged)`);
+      // A plain `source ~/.zshrc` adds the new functions but does NOT unset
+      // the old claude-<oldLabel> in the current shell — recommend a new one.
+      console.log(
+        `  → open a NEW shell (sourcing would keep the old claude-${oldLabel} defined here)`,
+      );
+      return 0;
+    }
+
     case 'remove':
     case 'rm': {
       const label = rest[0];
diff --git a/src/electron-api.d.ts b/src/electron-api.d.ts
index 3fa2c34..d379002 100644
--- a/src/electron-api.d.ts
+++ b/src/electron-api.d.ts
@@ -23,12 +23,16 @@ interface IElectronAPI {
     accounts?: CodevAccountInfo[];
     shellInstalled?: boolean;
   }>;
-  addAccount: (label: string) => Promise<{
+  addAccount: (label: string, anchorName?: string) => Promise<{
     ok: boolean;
     error?: string;
     account?: CodevAccountInfo;
   }>;
   removeAccount: (label: string) => Promise<{ ok: boolean; error?: string }>;
+  renameAccount: (
+    oldLabel: string,
+    newLabel: string,
+  ) => Promise<{ ok: boolean; error?: string }>;
   setDefaultAccount: (label: string) => Promise<{ ok: boolean; error?: string }>;
   setAccountsShellHook: (action: 'install' | 'uninstall') => Promise<{
     ok: boolean;
@@ -98,7 +102,7 @@ interface IElectronAPI {
   scanClosedVSCodeSessions: (activeSessionIds: string[]) => Promise<any[]>;
   refreshSessionPreview: (sessions: any[]) => Promise<Record<string, { lastUserMessage: string; lastAssistantMessage: string }>>;
   openClaudeSession: (sessionId: string, projectPath: string, isActive: boolean, activePid?: number, customTitle?: string) => void;
-  launchNewClaudeSession: (projectPath: string) => void;
+  launchNewClaudeSession: (projectPath: string, accountLabel?: string) => void;
   launchNewClaudeSessionInCodev: (projectPath: string) => void;
   copyClaudeSessionCommand: (sessionId: string, projectPath: string) => void;
   loadSessionEnrichment: (sessions: any[]) => Promise<{ titles: Record<string, string>; branches: Record<string, string>; prLinks: Record<string, { prNumber: number; prUrl: string }> }>;
diff --git a/src/main.ts b/src/main.ts
index 243216c..9d71ca9 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -678,9 +678,9 @@ ipcMain.handle('accounts-get', () => {
   }
 });
 
-ipcMain.handle('accounts-add', (_event, label: string) => {
+ipcMain.handle('accounts-add', (_event, label: string, anchorName?: string) => {
   try {
-    const added = accountManager.addAccount(label);
+    const added = accountManager.addAccount(label, { anchorName });
     invalidateAccountsCache();
     // Return the enriched (listed) shape so it matches CodevAccountInfo
     // (isCurrentDefault etc.), not the raw registry entry. The fallback
@@ -713,6 +713,20 @@ ipcMain.handle('accounts-remove', (_event, label: string) => {
   }
 });
 
+ipcMain.handle(
+  'accounts-rename',
+  (_event, oldLabel: string, newLabel: string) => {
+    try {
+      accountManager.renameAccount(oldLabel, newLabel);
+      invalidateAccountsCache();
+      syncAccountsAppPath();
+      return { ok: true };
+    } catch (error) {
+      return { ok: false, error: (error as Error).message };
+    }
+  },
+);
+
 ipcMain.handle('accounts-set-default', (_event, label: string) => {
   try {
     accountManager.setDefault(label);
@@ -2276,14 +2290,14 @@ ipcMain.on('open-claude-session', async (_event, sessionId: string, projectPath:
   openSession(sessionId, projectPath, isActive, activePid, terminalApp, terminalMode, customTitle);
 });
 
-ipcMain.on('launch-new-claude-session', async (_event, projectPath: string) => {
+ipcMain.on('launch-new-claude-session', async (_event, projectPath: string, accountLabel?: string) => {
   if (!existsSync(projectPath)) {
     console.log('[launch-new-claude-session] path does not exist:', projectPath);
     return;
   }
   const terminalApp = ((await settings.get('session-terminal-app')) || 'iterm2') as string;
   const terminalMode = ((await settings.get('session-terminal-mode')) || 'tab') as string;
-  launchNewClaudeSession(projectPath, terminalApp, terminalMode);
+  launchNewClaudeSession(projectPath, terminalApp, terminalMode, accountLabel);
 });
 
 ipcMain.on('launch-new-claude-session-in-codev', (_event, projectPath: string) => {
diff --git a/src/popup.tsx b/src/popup.tsx
index 1cc7365..a481f39 100644
--- a/src/popup.tsx
+++ b/src/popup.tsx
@@ -109,7 +109,19 @@ const PopupDefaultExample = ({
   const [accountsError, setAccountsError] = useState('');
   const [accountsNotice, setAccountsNotice] = useState('');
   const [newAccountLabel, setNewAccountLabel] = useState('');
+  // First-ever add also registers the existing ~/.claude login — the USER
+  // picks its name. Empty means "let the manager decide" ('main', or
+  // 'primary' when the new account itself is named main) so the backend
+  // fallback stays the single source of truth.
+  const [anchorNameInput, setAnchorNameInput] = useState('');
+  const [renamingLabel, setRenamingLabel] = useState<string | null>(null);
+  const [renameInput, setRenameInput] = useState('');
   const [accountsBusy, setAccountsBusy] = useState(false);
+  // Footer example uses a REAL account name (prefer a non-default one) so
+  // nobody reads it as a fixed keyword; the example clause is hidden entirely
+  // when no account is registered (the commands wouldn't exist yet).
+  const exampleAccountLabel =
+    accounts.find((a) => !a.isCurrentDefault)?.label || accounts[0]?.label;
 
   const refreshAccounts = async () => {
     try {
@@ -119,6 +131,9 @@ const PopupDefaultExample = ({
         setAccountsLoaded(true);
         setAccountsShellInstalled(!!r.shellInstalled);
         setAccountsError('');
+        // Tell the surrounding switcher UI (same window) accounts changed,
+        // e.g. so the ⌥⌘+Enter hint updates without an app restart.
+        window.dispatchEvent(new CustomEvent('codev-accounts-changed'));
       } else {
         setAccountsNotice('');
         setAccountsError(r.error || 'Failed to load accounts');
@@ -157,14 +172,27 @@ const PopupDefaultExample = ({
   const handleAddAccount = () => {
     const label = newAccountLabel.trim();
     if (!label) return;
+    const isFirstAdd = accountsLoaded && accounts.length === 0;
+    // Pass undefined when untouched so the manager's fallback applies
+    // ('main', or 'primary' when the new account itself is named main).
+    const anchorName = isFirstAdd
+      ? anchorNameInput.trim() || undefined
+      : undefined;
+    const effectiveAnchor = isFirstAdd
+      ? anchorName || (label === 'main' ? 'primary' : 'main')
+      : undefined;
     runAccountOp(async () => {
-      const r = await window.electronAPI.addAccount(label);
+      const r = await window.electronAPI.addAccount(label, anchorName);
       if (r.ok) {
         setNewAccountLabel('');
+        const dir = r.account?.dir || `~/.claude-${label}`;
+        const anchorNote = effectiveAnchor
+          ? ` Your existing login is registered as "${effectiveAnchor}".`
+          : '';
         setAccountsNotice(
           accountsShellInstalled
-            ? `Added "${label}". Log in with: claude ${label} — then open a new shell (or source ~/.zshrc).`
-            : `Added "${label}". Install Shell integration below, open a new shell, then log in with: claude ${label}.`,
+            ? `Added "${label}" → ${dir}.${anchorNote} Log in with: claude ${label} — then open a new shell (or source ~/.zshrc).`
+            : `Added "${label}" → ${dir}.${anchorNote} Install Shell integration below, open a new shell, then log in with: claude ${label}.`,
         );
         await refreshAccounts();
       } else {
@@ -176,9 +204,15 @@ const PopupDefaultExample = ({
 
   const handleRemoveAccount = (label: string) => {
     runAccountOp(async () => {
+      // Capture the folder before it leaves the list — after a rename the
+      // label no longer matches the folder suffix, so "add the same name
+      // back" would point at the WRONG (empty) folder.
+      const removedDir = accounts.find((a) => a.label === label)?.dir;
       const r = await window.electronAPI.removeAccount(label);
       if (r.ok) {
-        setAccountsNotice(`Removed "${label}" (its folder stays on disk).`);
+        setAccountsNotice(
+          `Removed "${label}" — folder kept${removedDir ? ` (${removedDir})` : ''}, login and sessions intact. Re-attach later by adding a name that matches the folder suffix, or: codev account add <name> --dir <folder>.`,
+        );
         await refreshAccounts();
       } else {
         setAccountsNotice('');
@@ -187,6 +221,26 @@ const PopupDefaultExample = ({
     });
   };
 
+  const handleRenameAccount = (oldLabel: string, newLabel: string) => {
+    if (!newLabel || newLabel === oldLabel) {
+      setRenamingLabel(null);
+      return;
+    }
+    runAccountOp(async () => {
+      const r = await window.electronAPI.renameAccount(oldLabel, newLabel);
+      if (r.ok) {
+        setRenamingLabel(null);
+        setAccountsNotice(
+          `Renamed "${oldLabel}" → "${newLabel}" — folder unchanged; open a new shell for claude ${newLabel}.`,
+        );
+        await refreshAccounts();
+      } else {
+        setAccountsNotice('');
+        setAccountsError(r.error || 'Failed to rename');
+      }
+    });
+  };
+
   const handleSetDefaultAccount = (label: string) => {
     runAccountOp(async () => {
       const r = await window.electronAPI.setDefaultAccount(label);
@@ -775,7 +829,7 @@ const PopupDefaultExample = ({
               }}
             >
               Claude Code (Anthropic) accounts — each launches claude with its
-              own config dir
+              own config dir. Names are renameable labels; folders never move.
             </div>
             {/* Only after a successful load — avoids flashing while the IPC
                 call is in flight and contradicting an error message. */}
@@ -788,13 +842,15 @@ const PopupDefaultExample = ({
                 }}
               >
                 No accounts registered yet — your existing ~/.claude login stays
-                the default. Add a second account below to go multi-account.
+                the default. Add a second account below to go multi-account;
+                your existing login is registered at the same time, with the
+                name you set below.
               </div>
             )}
             {accounts.map((a) => (
               <div key={a.label} style={rowStyle}>
                 <div style={{ display: 'flex', flexDirection: 'column' }}>
-                  <span style={labelStyle}>
+                  <span style={labelStyle} title={`Config dir: ${a.dir}`}>
                     {a.label}
                     {a.isCurrentDefault && (
                       <span style={{ color: THEME.primary, fontSize: '11px', marginLeft: '6px' }}>
@@ -805,36 +861,104 @@ const PopupDefaultExample = ({
                   <span style={{ fontSize: '11px', color: THEME.text.secondary }}>
                     {a.loggedIn
                       ? `${a.email || 'logged in'} — launch: ${
-                          a.isCurrentDefault ? 'claude' : `claude ${a.label}`
+                          a.isCurrentDefault
+                            ? `claude (or claude ${a.label})`
+                            : `claude ${a.label}`
                         }`
                       : `not logged in — log in & launch: claude ${a.label}`}
+                    {/* Name and folder can diverge (rename never moves
+                        folders) — surface the folder when they do. */}
+                    {!a.dir.endsWith(`/.claude-${a.label}`) && (
+                      <span style={{ color: '#777' }}>
+                        {` · folder: ${a.dir.replace(/^\/Users\/[^/]+/, '~')}`}
+                      </span>
+                    )}
                   </span>
                 </div>
                 <div style={{ display: 'flex', gap: '8px', alignItems: 'center' }}>
-                  {!a.isCurrentDefault && (
-                    <button
-                      style={smallButtonStyle}
-                      onClick={() => handleSetDefaultAccount(a.label)}
-                      disabled={accountsBusy}
-                      title="Make bare `claude` resolve to this account"
-                    >
-                      Set default
-                    </button>
-                  )}
-                  {!a.isDefault && (
-                    <button
-                      style={{ ...smallButtonStyle, color: THEME.button.warning }}
-                      onClick={() => handleRemoveAccount(a.label)}
-                      disabled={accountsBusy}
-                      title="Unregister (keeps its folder on disk)"
-                    >
-                      Remove
-                    </button>
+                  {renamingLabel === a.label ? (
+                    <>
+                      <input
+                        value={renameInput}
+                        onChange={(e) => setRenameInput(e.target.value)}
+                        onKeyDown={(e) => {
+                          if (e.key === 'Enter') {
+                            handleRenameAccount(a.label, renameInput.trim());
+                          } else if (e.key === 'Escape') {
+                            setRenamingLabel(null);
+                          }
+                        }}
+                        autoFocus
+                        style={{ ...selectStyle, cursor: 'text', width: '110px' }}
+                      />
+                      <button
+                        style={smallButtonStyle}
+                        onClick={() => handleRenameAccount(a.label, renameInput.trim())}
+                        disabled={accountsBusy}
+                      >
+                        Save
+                      </button>
+                      <button
+                        style={smallButtonStyle}
+                        onClick={() => setRenamingLabel(null)}
+                        disabled={accountsBusy}
+                      >
+                        Cancel
+                      </button>
+                    </>
+                  ) : (
+                    <>
+                      <button
+                        style={smallButtonStyle}
+                        onClick={() => {
+                          setRenamingLabel(a.label);
+                          setRenameInput(a.label);
+                        }}
+                        disabled={accountsBusy}
+                        title="Rename the label — the folder never moves"
+                      >
+                        Rename
+                      </button>
+                      {!a.isCurrentDefault && (
+                        <button
+                          style={smallButtonStyle}
+                          onClick={() => handleSetDefaultAccount(a.label)}
+                          disabled={accountsBusy}
+                          title="Make bare `claude` resolve to this account"
+                        >
+                          Set default
+                        </button>
+                      )}
+                      {!a.isDefault && (
+                        <button
+                          style={{ ...smallButtonStyle, color: THEME.button.warning }}
+                          onClick={() => handleRemoveAccount(a.label)}
+                          disabled={accountsBusy}
+                          title="Unregister only — folder, login & sessions stay on disk; re-add the same name to reattach"
+                        >
+                          Remove
+                        </button>
+                      )}
+                    </>
                   )}
                 </div>
               </div>
             ))}
 
+            {accountsLoaded && accounts.length === 0 && (
+              <div style={rowStyle}>
+                <span style={{ fontSize: '12px', color: THEME.text.secondary }}>
+                  …and your existing ~/.claude login will be named
+                </span>
+                <input
+                  value={anchorNameInput}
+                  onChange={(e) => setAnchorNameInput(e.target.value)}
+                  placeholder="main"
+                  disabled={accountsBusy}
+                  style={{ ...selectStyle, cursor: 'text', width: '110px' }}
+                />
+              </div>
+            )}
             <div style={rowStyle}>
               <input
                 value={newAccountLabel}
@@ -853,6 +977,11 @@ const PopupDefaultExample = ({
                 Add account
               </button>
             </div>
+            <div style={{ padding: '0 16px 4px', fontSize: '10px', color: '#777' }}>
+              Add creates or attaches the folder ~/.claude-&lt;name&gt; — to
+              attach an existing custom folder: codev account add &lt;name&gt;
+              --dir &lt;folder&gt;
+            </div>
 
             <div style={rowStyle}>
               <span style={labelStyle}>Shell integration (~/.zshrc)</span>
@@ -877,8 +1006,11 @@ const PopupDefaultExample = ({
               </div>
             )}
             <div style={{ padding: '4px 16px', fontSize: '11px', color: THEME.text.secondary }}>
-              Registry: ~/.config/codev/accounts.json — each account also has a
-              function form, e.g. claude-work
+              Registry: ~/.config/codev/accounts.json
+              {accounts.length > 0 &&
+                (accountsShellInstalled
+                  ? ` — launch any account above by its name: claude ${exampleAccountLabel} and claude-${exampleAccountLabel} are equivalent`
+                  : ' — install Shell integration above to launch accounts by name from the terminal')}
             </div>
           </div>
           )}
diff --git a/src/preload.ts b/src/preload.ts
index 9a68408..9e3d4a0 100644
--- a/src/preload.ts
+++ b/src/preload.ts
@@ -7,8 +7,11 @@ contextBridge.exposeInMainWorld('electronAPI', {
   getHomeDir: () => ipcRenderer.invoke('get-home-dir'),
   // codev multi-account (Settings → Accounts)
   getAccounts: () => ipcRenderer.invoke('accounts-get'),
-  addAccount: (label: string) => ipcRenderer.invoke('accounts-add', label),
+  addAccount: (label: string, anchorName?: string) =>
+    ipcRenderer.invoke('accounts-add', label, anchorName),
   removeAccount: (label: string) => ipcRenderer.invoke('accounts-remove', label),
+  renameAccount: (oldLabel: string, newLabel: string) =>
+    ipcRenderer.invoke('accounts-rename', oldLabel, newLabel),
   setDefaultAccount: (label: string) =>
     ipcRenderer.invoke('accounts-set-default', label),
   setAccountsShellHook: (action: 'install' | 'uninstall') =>
@@ -71,8 +74,8 @@ contextBridge.exposeInMainWorld('electronAPI', {
   refreshSessionPreview: (sessions: any[]) => ipcRenderer.invoke('refresh-session-preview', sessions),
   openClaudeSession: (sessionId: string, projectPath: string, isActive: boolean, activePid?: number, customTitle?: string) =>
     ipcRenderer.send('open-claude-session', sessionId, projectPath, isActive, activePid, customTitle),
-  launchNewClaudeSession: (projectPath: string) =>
-    ipcRenderer.send('launch-new-claude-session', projectPath),
+  launchNewClaudeSession: (projectPath: string, accountLabel?: string) =>
+    ipcRenderer.send('launch-new-claude-session', projectPath, accountLabel),
   launchNewClaudeSessionInCodev: (projectPath: string) =>
     ipcRenderer.send('launch-new-claude-session-in-codev', projectPath),
   copyClaudeSessionCommand: (sessionId: string, projectPath: string) =>
diff --git a/src/switcher-ui.tsx b/src/switcher-ui.tsx
index a795d93..2b92305 100644
--- a/src/switcher-ui.tsx
+++ b/src/switcher-ui.tsx
@@ -269,7 +269,51 @@ const formatRelativeTime = (timestamp: string): string => {
 let loadTimes = 0;
 function SwitcherApp() {
   const optionPress = useRef(false);
-  const launchClaudeRef = useRef<'external' | 'codev' | null>(null);
+  const launchClaudeRef = useRef<'external' | 'codev' | 'external-pick' | null>(null);
+
+  // 2c-lite: ⌥⌘+Enter — pick the account for a new-session launch.
+  type LaunchAccount = {
+    label: string;
+    email?: string;
+    loggedIn?: boolean;
+    isCurrentDefault: boolean;
+  };
+  const [launchPicker, setLaunchPicker] = useState<{
+    path: string;
+    accounts: LaunchAccount[];
+  } | null>(null);
+  const [launchPickerIndex, setLaunchPickerIndex] = useState(0);
+  // Multi-account? → advertise ⌥⌘+Enter in the search-bar hint (single-account
+  // users see the unchanged short hint — no extra clutter).
+  const [isMultiAccountUI, setIsMultiAccountUI] = useState(false);
+
+  const openAccountPickerForLaunch = async (projectPath: string) => {
+    try {
+      const r = await window.electronAPI.getAccounts();
+      if (!r.ok) {
+        // The user explicitly asked to pick — don't guess an identity when
+        // the account list can't be loaded.
+        console.error('[account-picker] failed to load accounts:', r.error);
+        return;
+      }
+      const accounts = (r.accounts || []) as LaunchAccount[];
+      if (accounts.length <= 1) {
+        // Single account (or no registry): nothing to pick — launch as usual.
+        window.electronAPI.launchNewClaudeSession(projectPath);
+        return;
+      }
+      setLaunchPickerIndex(0);
+      setLaunchPicker({ path: projectPath, accounts });
+    } catch (e) {
+      console.error('[account-picker] failed to load accounts:', e);
+    }
+  };
+
+  const pickLaunchAccount = (account: LaunchAccount) => {
+    if (!launchPicker) return;
+    window.electronAPI.launchNewClaudeSession(launchPicker.path, account.label);
+    setLaunchPicker(null);
+  };
 
   const ref = useRef(null);
   const sessionSearchRef = useRef<HTMLInputElement>(null);
@@ -559,6 +603,22 @@ function SwitcherApp() {
       setMode('terminal');
     });
 
+    // Account count decides whether the ⌥⌘+Enter picker hint is shown.
+    // Re-checked when the embedded Settings popup mutates accounts (same-window
+    // CustomEvent) and on window focus (covers CLI-side changes) — no restart
+    // needed for the hint to switch.
+    const refreshMultiAccountHint = () => {
+      window.electronAPI
+        .getAccounts()
+        .then((r) => {
+          if (r.ok) setIsMultiAccountUI(((r.accounts || []) as unknown[]).length > 1);
+        })
+        .catch(() => {});
+    };
+    refreshMultiAccountHint();
+    window.addEventListener('codev-accounts-changed', refreshMultiAccountHint);
+    window.addEventListener('focus', refreshMultiAccountHint);
+
     // If initial mode is sessions (from URL hash), fetch sessions immediately
     if (initialMode === 'sessions') {
       fetchClaudeSessions();
@@ -1496,7 +1556,13 @@ function SwitcherApp() {
           // Clear on every keypress to prevent stale ref if onChange didn't fire
           launchClaudeRef.current = null;
           if (evt.key === 'Enter' && (evt.metaKey || evt.shiftKey)) {
-            launchClaudeRef.current = evt.shiftKey ? 'codev' : 'external';
+            // ⌥⌘+Enter: choose the account first (multi-account, 2c-lite)
+            launchClaudeRef.current =
+              evt.metaKey && evt.altKey
+                ? 'external-pick'
+                : evt.shiftKey
+                  ? 'codev'
+                  : 'external';
           }
         }}
         onInputChange={(evt) => {
@@ -1507,6 +1573,8 @@ function SwitcherApp() {
           launchClaudeRef.current = null;
           if (launchMode === 'codev') {
             window.electronAPI.launchNewClaudeSessionInCodev(evt.value);
+          } else if (launchMode === 'external-pick') {
+            openAccountPickerForLaunch(evt.value);
           } else if (launchMode === 'external') {
             window.electronAPI.launchNewClaudeSession(evt.value);
           } else {
@@ -1519,9 +1587,17 @@ function SwitcherApp() {
         }}
         // Custom components
         components={{
+          // Hide react-select's default vertical separator ("|" that looks
+          // like a stray cursor before the hint text).
+          IndicatorSeparator: () => null,
           DropdownIndicator: () => (
-            <div style={{ fontSize: '11px', color: '#666', paddingRight: '8px', whiteSpace: 'nowrap' }}>
-              {'\u2318+Enter: New Claude'}
+            <div
+              title="\u2325\u2318+Enter: choose the account first"
+              style={{ fontSize: '11px', color: '#666', paddingRight: '8px', whiteSpace: 'nowrap' }}
+            >
+              {isMultiAccountUI
+                ? '\u2318+Enter: New Claude \u00b7 \u2325\u2318+Enter: pick account'
+                : '\u2318+Enter: New Claude'}
             </div>
           ),
           Option: (props) => OptionUI(props, onDeleteClick, (path: string) => {
@@ -1679,6 +1755,86 @@ function SwitcherApp() {
           }),
         }}
       />
+      {launchPicker && (
+        <div
+          data-settings-panel
+          onClick={() => setLaunchPicker(null)}
+          style={{
+            position: 'fixed',
+            inset: 0,
+            background: 'rgba(0, 0, 0, 0.45)',
+            zIndex: 1000,
+            display: 'flex',
+            alignItems: 'flex-start',
+            justifyContent: 'center',
+          }}
+        >
+          <div
+            onClick={(e) => e.stopPropagation()}
+            onKeyDown={(e) => {
+              e.stopPropagation();
+              if (e.key === 'Escape') {
+                setLaunchPicker(null);
+              } else if (e.key === 'ArrowDown') {
+                e.preventDefault();
+                setLaunchPickerIndex((i) => (i + 1) % launchPicker.accounts.length);
+              } else if (e.key === 'ArrowUp') {
+                e.preventDefault();
+                setLaunchPickerIndex(
+                  (i) => (i - 1 + launchPicker.accounts.length) % launchPicker.accounts.length,
+                );
+              } else if (e.key === 'Enter') {
+                e.preventDefault();
+                pickLaunchAccount(launchPicker.accounts[launchPickerIndex]);
+              }
+            }}
+            tabIndex={0}
+            ref={(el) => el?.focus()}
+            style={{
+              marginTop: '120px',
+              minWidth: '320px',
+              background: '#252526',
+              border: '1px solid #454545',
+              borderRadius: '8px',
+              padding: '8px',
+              boxShadow: '0 8px 24px rgba(0, 0, 0, 0.5)',
+              outline: 'none',
+            }}
+          >
+            <div style={{ fontSize: '11px', color: '#888', padding: '2px 8px 6px' }}>
+              New Claude in {launchPicker.path.split('/').pop()} as… (↑↓ · Enter · Esc)
+            </div>
+            {launchPicker.accounts.map((a, i) => (
+              <div
+                key={a.label}
+                onClick={() => pickLaunchAccount(a)}
+                onMouseEnter={() => setLaunchPickerIndex(i)}
+                style={{
+                  padding: '6px 8px',
+                  borderRadius: '4px',
+                  cursor: 'pointer',
+                  backgroundColor: i === launchPickerIndex ? '#094771' : 'transparent',
+                  display: 'flex',
+                  justifyContent: 'space-between',
+                  gap: '12px',
+                }}
+              >
+                <span style={{ color: '#e9e9e9', fontSize: '13px' }}>
+                  {a.label}
+                  {a.isCurrentDefault && (
+                    <span style={{ color: '#00BCD4', fontSize: '10px', marginLeft: '6px' }}>
+                      default
+                    </span>
+                  )}
+                </span>
+                <span style={{ color: '#888', fontSize: '11px' }}>
+                  {a.loggedIn ? a.email || '' : 'not logged in'}
+                </span>
+              </div>
+            ))}
+          </div>
+        </div>
+      )}
       </div>
       ))}
     </div>