diff --git a/lat.md/chat-commands.md b/lat.md/chat-commands.md
index 13bb60f40..913a9860a 100644
--- a/lat.md/chat-commands.md
+++ b/lat.md/chat-commands.md
@@ -47,7 +47,7 @@ So `ensureClient` distinguishes two failures: a **genuinely absent** dashboard (
 
 On `message.complete` the desktop reconciles the text streamed via `message.delta` with the turn's `final_response`, because a last-turn-only final would otherwise clobber text streamed before a tool call (#746).
 
-[[src/renderer/src/screens/Chat/dashboardEventAdapter.ts#completeAssistantWithFinalText]] rewrites the last assistant bubble through [[src/renderer/src/screens/Chat/dashboardEventAdapter.ts#mergeStreamedWithFinal]], which compares whitespace-insensitively and: uses the final text when it already contains the streamed text; keeps the streamed text when it contains the final (preserving pre-tool-call content); stitches a re-streamed boundary by dropping the duplicated word-aligned seam (rejecting coincidental mid-word overlaps); replaces a garbled re-stream with the final text when the two converge on a substantial common suffix (a corrupted-prefix delta — e.g. a mangled CJK stream — that ends the same sentence as the clean final, rather than the disjoint pre-tool-call + answer pair); and otherwise concatenates the two with a blank-line separator so segments never run together. On the remote/SSH path deltas are not rendered (`renderAssistantDeltas: false`), so the bubble starts empty and the final text is used verbatim.
+[[src/renderer/src/screens/Chat/dashboardEventAdapter.ts#completeAssistantWithFinalText]] rewrites the last assistant bubble through [[src/renderer/src/screens/Chat/dashboardEventAdapter.ts#mergeStreamedWithFinal]], which compares whitespace-insensitively and: uses the final text when it already contains the streamed text; keeps the streamed text when it contains the final (preserving pre-tool-call content); replaces a **lossy chunk-dropped stream** with the final text when [[src/renderer/src/screens/Chat/lossyText.ts#isLossyChunkCopy]] recognises the streamed content as a chunk-dropped copy of the final (the upstream tagging alternate chunks as `reasoning` leaves the content stream a garbled subset like "! What are we working on?" for "Hey! What are we working on today?"; concatenating stacked the partial above the clean answer in one bubble — the matcher requires contiguous runs of ≥3 chars plus ≥12-char / ≥30%-coverage guards, so a pre-tool-call segment whose characters merely embed as scattered fragments still stacks); stitches a re-streamed boundary by dropping the duplicated word-aligned seam (rejecting coincidental mid-word overlaps); replaces a garbled re-stream with the final text when the two converge on a substantial common suffix (a corrupted-prefix delta — e.g. a mangled CJK stream — that ends the same sentence as the clean final, rather than the disjoint pre-tool-call + answer pair); and otherwise concatenates the two with a blank-line separator so segments never run together. On the remote/SSH path deltas are not rendered (`renderAssistantDeltas: false`), so the bubble starts empty and the final text is used verbatim.
 
 ## Streaming source-of-truth ref
 
@@ -61,6 +61,26 @@ Streamed reasoning and tool calls are folded into compact, collapsible transcrip
 
 [[src/renderer/src/screens/Chat/HistoryRow.tsx#ReasoningRow]] renders the `Thought` / `Thinking…` row and [[src/renderer/src/screens/Chat/HistoryRow.tsx#ToolActivityGroup]] folds a contiguous run of tool calls/results into one row titled by [[src/renderer/src/screens/Chat/HistoryRow.tsx#toolActivityGroupTitle]]. Each row is collapsed by default and borderless (Codex-style): dim at rest, it brightens and reveals an expand chevron beside the title on hover/focus, and clicking toggles the body open. While the turn is still streaming the leading icon is a `Grid` loader (purple for reasoning, blue for tools); once finished it shows the brain/tool glyph.
 
+### Reasoning reconciliation
+
+The live reasoning stream is best-effort — dropped delta chunks leave the streamed row garbled — while state.db holds the canonical text. The DB refresh must collapse the two, or the user sees both stacked in one Thought block.
+
+The observed symptom: a Thought block showing "moon-k3 … ous" (lossy live preview) above "moonshotai/kimi-k3 … nous" (canonical DB row) for the same thought.
+
+Because the garbled text can't match the DB row's text-based reconciliation key, [[src/renderer/src/screens/Chat/sessionHistory.ts#reconcileStreamedWithDb]] ends with [[src/renderer/src/screens/Chat/sessionHistory.ts#dropLossyStreamedReasoning]]: a streamed reasoning row is dropped when [[src/renderer/src/screens/Chat/lossyText.ts#isLossyChunkCopy]] recognises it as a chunk-dropped copy of a DB reasoning row (`db-r-…`) in the **same turn**. A dropped-chunks preview is by construction a concatenation of contiguous runs of the canonical text; the matcher's run (≥3 chars) and length/coverage (≥12 chars, ≥30%) guards separate "same thought, chunks missing" from a genuinely distinct short segment whose characters merely embed as scattered fragments.
+
+#### Lossy live preview collapses into the DB row
+
+A streamed reasoning row recognised as a chunk-dropped copy of the same turn's DB reasoning row disappears from the merge; only the canonical DB text renders. A short thought whose characters embed only as scattered fragments is kept.
+
+#### Distinct live segments survive
+
+A second live reasoning segment that is not a lossy duplicate of any DB row in the turn (multi-segment thinking around tool calls) is kept alongside the reconciled first segment.
+
+#### Turn-scoped matching
+
+The chunk-copy check never crosses turns: a live preview in turn 2 is kept even when its text would match turn 1's canonical reasoning, so repeated questions can't cross-cancel live rows.
+
 ## Bubble hover timestamp
 
 Each user/assistant bubble reveals a relative "time ago" label on row hover, so the transcript stays uncluttered at rest but is still scrutable when a user wants to know _when_ something was said.
diff --git a/lat.md/hermes-account-login.md b/lat.md/hermes-account-login.md
index 738a8a114..30c632bef 100644
--- a/lat.md/hermes-account-login.md
+++ b/lat.md/hermes-account-login.md
@@ -92,6 +92,32 @@ account" card that opens it; once signed in it renders an identity card —
 avatar (or letter fallback), name/email, a "Connected" status line — with a
 Sign out action.
 
+## Auto-provisioned inference key and credits
+
+Signing in should yield model access without hand-copying keys: the desktop auto-issues a Hermes One Inference gateway key from the account and shows the account's AI-credit balance on the Providers card.
+
+[[src/main/hermesone-provision.ts]] is the convenience layer. `ensureHermesOneApiKey` checks the profile's `.env` for `HERMESONE_API_KEY`; when missing, it POSTs the backend's `/api/credits/keys` (bearer device-login token, key named `Hermes Desktop (<hostname>)` so the console list shows its origin) and persists the one-time raw `hs-live-…` key via `setEnvValue`. Setting that env var **is** what "adds the provider": the Hermes One card ([[provider-setup]]) and the active-model picker both key off it, so no store writes are needed. `fetchHermesOneCredits` GETs `/api/credits/balance` for the USD-denominated balance.
+
+It runs from two places, both idempotent: the `hermes-account-login` IPC handler right after a successful device login, and the Providers screen whenever it loads with a signed-in account (covering users who signed in before this feature). Both are **local-mode only** — the key lands in the local profile `.env`, which remote/SSH chat doesn't read, and provisioning there would strand an orphan backend key per visit. The account card renders a credits chip (`$X.XX credits`, Coins icon) next to Connected/Sync-on, backed by the `hermesone-credits` IPC; a `created` result makes the screen re-read env so the Hermes One card appears immediately.
+
+### Issues a key only when missing
+
+An existing `HERMESONE_API_KEY` is always kept — the backend shows a raw key exactly once, so re-issuing would orphan the old one. No backend call happens at all in that case.
+
+### Provisions and persists a fresh key
+
+With a signed-in account and no local key, one authenticated POST issues the key and it is written to the target profile's `.env` under `HERMESONE_API_KEY`.
+
+### Single-flight provisioning
+
+Concurrent ensure calls (post-login hook + Providers screen mount) coalesce into one backend key issue per profile, preventing orphan keys.
+
+The latch is **per profile** — provisioning writes that profile's `.env`, so a global latch would let profile B piggyback on A's run and report `created` without receiving a key.
+
+### Credits for the account card
+
+The balance endpoint is called with the bearer token and returns the numeric USD credit balance; signed-out or malformed responses yield `null` so the chip simply hides.
+
 ## Tests
 
 Unit tests cover the two pieces that can break silently.
diff --git a/lat.md/provider-setup.md b/lat.md/provider-setup.md
index d095194a7..3368dfef3 100644
--- a/lat.md/provider-setup.md
+++ b/lat.md/provider-setup.md
@@ -34,8 +34,16 @@ The screen is organized as two tabs: Providers and Auxiliary Tasks. There is no
 
 The **MODEL** section shows a read-only summary (logo + provider label + model). A **Change** button opens a picker modal with a **provider** picker (a custom `LogoSelect` — the brand logo renders inside the control and each option, which a native `<select>` can't do) and a native **model** dropdown. Confirming sets `modelProvider`/`modelName`/`modelBaseUrl`, which the existing debounced auto-save persists to `config.yaml` via `setModelConfig` (compat providers as `custom` + base_url). The **API key is resolved automatically** at runtime — the picker never asks for it.
 
+That modal (`model-select-modal`) is styled **light-based** (no strokes): the container border, header/footer dividers, and control outlines are dropped in favor of filled controls (`--bg-elevated`, `--bg-hover` on hover/open) — matching the branded config modal's treatment. Crucially it sets `overflow: visible` (the base `.models-modal` clips with `overflow: hidden`), so the `LogoSelect` dropdown — which is absolutely positioned and can extend past the modal — isn't clipped; the menu itself caps at `max-height` and scrolls internally when the provider list is long. Without the override the lower providers were hidden and unreachable.
+
 The provider list (`pickerProviders`) is sourced from the **configured providers** — the same set shown as LLM cards — NOT from which providers happen to have saved models: keyed FieldDef providers (`env[f.key]` set, in FieldDef order so Hermes One leads) plus named custom providers whose `customProviderEnvKey(label)` is set. So a freshly-keyed provider with no models yet still appears.
 
+### Native keys without a setup card still route
+
+Native-provider keys with no `PROVIDERS.setup` card carrying them (or only the OAuth variant, `envKey: ""`) must still resolve to their agent slug, or the picker silently drops them even with a key set — the Nous-missing-from-Change-modal bug.
+
+[[src/renderer/src/constants.ts#providerRouteForEnvKey]] consults an explicit `NATIVE_ENV_KEY_ROUTES` table after the setup/preset lookups: `NOUS_API_KEY → nous`, `GLM_API_KEY → zai`, `KIMI_API_KEY → kimi-coding`, `MINIMAX_API_KEY → minimax`, `MINIMAX_CN_API_KEY → minimax-cn`, `NVIDIA_API_KEY → nvidia`, `OPENCODE_ZEN_API_KEY → opencode-zen`, `OPENCODE_GO_API_KEY → opencode-go`, `HF_TOKEN → huggingface`, and `PERPLEXITY_API_KEY → custom` + its compat base URL. Slugs and env vars mirror hermes-agent's own registry (`plugins/model-providers/*`). A test enforces the invariant that **no** LLM-section FieldDef falls through to the dead `custom` + empty-base-URL fallback (`tests/constants.test.ts`).
+
 The **model** dropdown merges that provider's saved models with live discovery ([[src/renderer/src/hooks/useDiscoveredModels.ts#useDiscoveredModels]]) so a just-configured provider is immediately usable. On confirm, a discovered-only model is persisted via `addModel` first (so its key resolves and it reappears), and compat providers store `custom` + their `OPENAI_COMPATIBLE_BASE_URLS` base URL.
 
 The debounced auto-save keeps a guard from the grid era that still applies: `saveModelConfig` skips persisting a `custom` selection whose `base_url` is empty (writing it would clobber config.yaml with a dead endpoint) — **unless** config.yaml already holds a custom endpoint, tracked by the `persistedCustomUrl` ref (refreshed on load and after each save). In that case the empty value IS persisted, so deliberately clearing a configured custom endpoint doesn't leave the UI (empty) and config.yaml (old URL) disagreeing after navigation/relaunch.
@@ -46,6 +54,20 @@ The `SETTINGS_SECTIONS` "LLM Providers" section no longer renders a static key c
 
 [[src/renderer/src/components/ProviderKeysSection.tsx#ProviderKeysSection]] renders the configured cards + an Add tile; Add opens a searchable picker modal (logo per provider) → a per-provider config modal (key input with show/hide, **Remove provider**). It's a presentation layer over the same `env` state + `handleChange`/`handleBlur`/`handleRemove` handlers in [[src/renderer/src/screens/Providers/Providers.tsx]], so persistence is unchanged (`setEnv`); removing clears the env var.
 
+Card and picker titles show the **plain provider name** ("Hermes One"), not the FieldDef's "… API Key" label — the section is a list of providers, and suffix-stripping the label isn't locale-safe. [[src/renderer/src/constants.ts#providerNameForEnvKey]] derives the display brand from the env key (via `providerRouteForEnvKey` + `displayBrandFromConfig`) and returns its `PROVIDERS.labels` entry, falling back to the FieldDef label for brandless keys; the picker search matches both the name and the full label. A test asserts every LLM-section key resolves to a name (`tests/constants.test.ts`).
+
+### Branded config modal
+
+The per-provider config modal (a keyed brand like Hermes One, not the custom flow) leads with the **provider logo tile + name + a verification pill** in the header, replacing the old key-icon-prefixed title.
+
+The pill's text/tone comes from the same live discovery the models list uses, lifted out of the body: `ProviderModelsManager` takes `showStatus={false}` and reports `{tone,text}` + the saved-model count up via `onStatusChange`/`onModelCountChange`, so there's one discovery hook and no duplicate status line.
+
+The **API key** shows as a masked preview (`maskKeyPreview` — leading scheme segment + last 4, dots between) with **Show** / **Replace** actions and a "used by N models" meta line, rather than a raw always-editable input. `replacingKey` state governs edit vs. preview: a keyed provider opens in preview (Replace swaps to the input), a fresh one opens straight in the input. Closing the modal (Done, ✕, or overlay click) flushes the key through `onBlur` first. The **Models** list drops the separate add row for a **+ Add model ID** pill that swaps to an inline autocomplete input (Enter/blur commits, Escape cancels), and each model chip's id is itself the click target for the definition editor. Only the first `MODELS_COLLAPSED` (10) chips render; the rest collapse behind a **+N more** toggle (`showAllModels`) so a large catalog doesn't flood the modal.
+
+Visually the modal is **stroke-free**: the logo tile, status pill, API-key field, model chips, and the add/more pills are all differentiated by fill/elevation (`--bg-elevated`/`--bg-hover`), not borders — only the header/footer keep a hairline divider for structure. Chip and control fonts are small (11–13px).
+
+The cards and picker are **ordered by display priority**, not the FieldDef declaration order (which groups providers by when they were added, surfacing niche endpoints like AIML API near the top). [[src/renderer/src/constants.ts#providerKeyRank]] ranks each env key: `PROVIDER_KEY_ORDER` front-loads the well-known providers (Hermes One first), unlisted keys keep their FieldDef order in the middle, and `PROVIDER_KEY_DEMOTED` (AIML API) sinks to the end. `ProviderKeysSection` sorts `keyItems` with a **stable** sort on the rank, so both the configured cards and the Add-provider picker share the ordering. A test pins Hermes One first and AIML last.
+
 The section is rendered **standalone, above the credential pool** rather than in the `SETTINGS_SECTIONS.map` position — it's the primary surface for configuring providers and the models the top active-model selector picks from, so it sits before the advanced multi-key pool. The map skips the `constants.sectionLlmProviders` entry (an inline title check returning null); other `SETTINGS_SECTIONS` (non-LLM) still render inline in place, after the pool.
 
 ### Named custom providers
@@ -64,6 +86,55 @@ Sponsor/partner providers (and Hermes One itself) are OpenAI-compatible custom e
 
 To add one, mirror the Hermes One entries: a card in `PROVIDERS.setup` + `PROVIDER_CARDS` + a base URL in `OPENAI_COMPATIBLE_BASE_URLS` ([[src/renderer/src/constants.ts]]), a `URL_KEY_MAP` entry giving it a dedicated `<PARTNER>_API_KEY` in [[src/shared/url-key-map.ts]], and a `detectBrand` rule + logo in [[src/renderer/src/components/common/BrandLogo.tsx]].
 
+## Agent config sync for named providers
+
+Named OpenAI-compatible providers sync both ways between the desktop and the agent's config.yaml — a CLI-added provider appears in the desktop UI, and a desktop-added one is visible to `hermes model` / `--provider <slug>`.
+
+The agent reads two user-config shapes (`hermes-agent/hermes_cli/providers.py`): the `providers:` dict (`{slug: {name, base_url, key_env, transport}}`, resolved by `resolve_user_provider`) and the legacy `custom_providers:` list. [[src/main/agent-config-providers.ts]] is the bridge: it parses and text-edits those blocks with offset/line splicing (like `config.ts`), so user comments and unrelated keys survive round-trips.
+
+The agent's config scaffold writes an inline empty dict (`providers: {}`), which the line-based block parser can't index — the upsert rewrites that line into block form instead of appending (a second `providers:` key would make the YAML ambiguous; this miss silently disabled the Hermes One mirror on real configs). Any other unparseable flow-dict form is left untouched rather than risking a duplicate key.
+
+Sync is read-repair plus write-mirroring, all in the main process — the renderer needed no changes:
+
+- **Import (terminal → desktop)**: every [[src/main/providers-store.ts#listCustomProviders]] read first runs the import — each config.yaml `providers:` entry is upserted into `providers.json` (skipping hosts that own a dedicated brand card), and a terminal `key_env`'s value is aliased additively to the derived `CUSTOM_PROVIDER_<NAME>_KEY` so the desktop key field and the runtime's label-derived lookup resolve unchanged. Similarly [[src/main/models.ts#syncAgentConfigModels]] merges `custom_providers:` model entries into `models.json` on every [[src/main/models.ts#listModels]] call (not just first seed), deduped by provider + model id + base URL, tagging rows with `providerLabel` so cards group correctly.
+- **Mirror (desktop → terminal)**: [[src/main/providers-store.ts#upsertCustomProvider]] upserts a matching `providers:` entry (`name`/`base_url`/`key_env: CUSTOM_PROVIDER_<NAME>_KEY`) via [[src/main/agent-config-providers.ts#upsertAgentUserProvider]] — matching an existing entry by `key_env` then slug, and patching field values in place so a terminal user's extra fields (e.g. `transport:`) survive. [[src/main/providers-store.ts#removeCustomProvider]] removes the entry from **both** config.yaml shapes so the next read can't re-import a deleted provider.
+
+Config.yaml is effectively the shared source of truth: desktop edits land there, and imports copy it back into the desktop stores. All writes are best-effort (an unwritable config.yaml never breaks the desktop store) and idempotent (unchanged content is never rewritten).
+
+### Parses the agent's providers dict
+
+`listAgentUserProviders` reads `providers:` entries with the same `base_url`/`api`/`url` alias precedence and `key_env` handling as the agent's `resolve_user_provider`, scoped by indentation so nested maps can't shadow the identity fields.
+
+### Desktop saves mirror into config.yaml
+
+`upsertAgentUserProvider` appends a `providers:` block (creating config.yaml or the block when missing) and round-trips through the parser; unrelated top-level keys are untouched.
+
+### Store upserts propagate to the agent config
+
+A desktop `upsertCustomProvider` leaves a terminal-visible `providers:` entry carrying the provider's derived `CUSTOM_PROVIDER_<NAME>_KEY` as `key_env`.
+
+### Terminal-added providers import on read
+
+A config.yaml `providers:` entry surfaces as a desktop provider card/record on the next list read, with its custom `key_env` value aliased additively into the derived env var; entries pointing at dedicated-brand hosts (e.g. Groq) are skipped.
+
+### Model library merges custom_providers on every read
+
+`custom_providers:` entries added from the terminal **after** the library was first seeded appear via `listModels`, exactly once (idempotent dedup), with their API key persisted under the derived env var.
+
+### Desktop deletion cleans the agent config
+
+Removing a provider in the desktop also deletes its `providers:` entry, so it stays deleted instead of re-importing on the next read.
+
+### Legacy custom_providers removal
+
+`removeAgentCustomProviderEntry` drops a `custom_providers:` list item by display name while leaving sibling items and following top-level blocks intact.
+
+### First-party brands mirror as user providers
+
+A keyed Hermes One is mirrored into config.yaml as `providers: hermesone:` ([[src/main/agent-config-providers.ts#mirrorFirstPartyAgentProviders]], run on every model-library / provider-list read) — without creating a custom card, since the brand owns a dedicated key card.
+
+This exists because desktop models on `inference.hermesone.org` are saved as bare `custom` + base URL, and the agent resolves `/model … --provider custom` against the **session's current** base URL — a session sitting on another provider (e.g. Nous) would send the Hermes One model to the wrong endpoint (the hermesone-swift → Nous-proxy 404). The named entry gives the switch a slug that always carries the right URL and `HERMESONE_API_KEY`; the dashboard transport's [[src/renderer/src/screens/Chat/hooks/useDashboardChatTransport.ts#resolveDashboardProviderForModel]] correspondingly matches **any** gateway provider row by base URL (named user providers included, not just `custom:*` rows) before ever falling back to bare `custom`.
+
 ## Models live under each provider (OpenCode-style)
 
 A provider's config modal manages the models it serves — the **only** place models are added/edited, since there is no standalone Models screen. The provider→models hierarchy lives in one place instead of a separate flat list.
diff --git a/lat.md/sidebar-navigation.md b/lat.md/sidebar-navigation.md
index 2940c11e6..518091eff 100644
--- a/lat.md/sidebar-navigation.md
+++ b/lat.md/sidebar-navigation.md
@@ -38,6 +38,8 @@ Each sidebar session row exposes a ChatGPT-style options menu — Pin, Rename, M
 
 Transitions are `motion/react`-driven (the same library as [[src/renderer/src/components/modal/AppModal.tsx#AppModal]]): the whole menu fades/scales/blurs from its top-left anchor on open, and an internal `open` flag plays the exit before the parent unmounts it (`AnimatePresence onExitComplete` → `onClose`). Switching between the main and project pages cross-slides them (direction-aware) inside a `.sidebar-session-menu-body` wrapper whose `layout` prop animates the height difference; the wrapper clips the sliding pages. Viewport clamping measures the offset box, not `getBoundingClientRect`, so an in-flight scale/height animation doesn't skew positioning.
 
+The menu is styled light-based and stroke-free (`.sidebar-session-menu`): no 1px border — depth comes from the shared frosted material (`--bg-secondary` at 97% + `backdrop-filter` blur), a top inset highlight, and layered ambient shadow. Dividers are a soft `--text-primary` 7% hairline rather than a hard `--border-bright` line. In the "Move to project" page each row carries a `Folder` icon and the current location gets an `.active-project` accent-subtle fill (not an outline).
+
 Each action calls an existing desktop API with an optimistic local update and rollback on failure: Rename → `updateSessionTitle` (inline `.sidebar-recent-session-rename` input), Move → [[src/main/session-context-folder-store.ts#setSessionContextFolder]] then a `hermes-session-context-folder-changed` event so other surfaces re-group, Delete → a confirmation dialog (portal overlay) then [[src/main/sessions.ts#deleteSessionRows|deleteSession]]. Deleting the open chat calls `onSessionDeleted`, which [[src/renderer/src/screens/Layout/Layout.tsx#Layout]] uses to drop to a fresh New Chat.
 
 Pinned rows are a desktop-only affordance: their ids live in `localStorage` (`hermes.sidebar.pinnedSessions`), and pinned sessions are pulled out of the normal grouping into a collapsible **Pinned** section at the top of the list.
@@ -52,7 +54,9 @@ The modal in [[src/renderer/src/screens/Layout/Layout.tsx#Layout]] renders [[src
 
 The footer profile control keeps the selected shell profile aligned with the visible chat run, while preserving older conversations under their original profiles.
 
-[[src/renderer/src/screens/Layout/ProfileSwitcher.tsx#ProfileSwitcher]] is two affordances, not a popover: the chip (avatar + name) opens the **current** profile's edit modal via `openProfile` ([[src/renderer/src/components/profile/ProfileModalContext.ts]]), and a dedicated switch button opens a **modal** listing every profile (active one checked) — picking one calls `setActiveProfile` and `onSwitch`, and a "Manage profiles" row jumps to the Agents screen. Collapsed, the lone avatar opens the switch modal.
+[[src/renderer/src/screens/Layout/ProfileSwitcher.tsx#ProfileSwitcher]] is two affordances, not a popover: the chip (avatar + name) opens the **current** profile's edit modal via `openProfile` ([[src/renderer/src/components/profile/ProfileModalContext.ts]]), and a dedicated switch button opens a **command-palette-style picker** — picking a profile calls `setActiveProfile` and `onSwitch`, and a "Manage profiles" row jumps to the Agents screen. Collapsed, the lone avatar opens the picker.
+
+The picker is a fixed size (fixed width and height, capped to the viewport), so filtering the list never resizes the panel — the list scrolls or leaves empty space instead. It is styled light-based and stroke-free like the row context menu: the frosted material, a top inset highlight, and layered shadow carry the edge (no outer border), and the search field / list / manage row are separated by soft `--text-primary` 7% hairlines rather than hard `--border` strokes. It has a search field on top that fuzzy-filters by user-facing name, stable id, and model; below it, profiles split into a running group and a **Stopped** group (each row shows a monospace model, a gateway dot — green when running — and a check on the active profile). The active profile floats to the top of its group. It is keyboard-first: **Cmd/Ctrl+P toggles it open from anywhere** (P is unbound in the app menu, so the renderer keydown reliably fires; `preventDefault` suppresses the browser print dialog), the search field auto-focuses, ↑/↓ move a highlight across the flattened running+stopped order, and Enter selects. The `mod` symbol (`⌘` on macOS via `window.electron.process.platform`, else `Ctrl`) is shown both in the search-field hint and the switch button's tooltip.
 
 That switch persists the selected profile through main-process profile switching, then [[src/renderer/src/screens/Layout/Layout.tsx#Layout]] applies [[src/renderer/src/screens/Layout/chatRuns.ts#selectProfileRunTransition]] before rendering Chat. If the active chat is blank, it is re-homed to the selected profile; if it already belongs to another profile, the shell activates an existing blank run for the selected profile or creates a fresh one. This prevents the footer, Settings, recent sessions, and chat transport from disagreeing about which agent is active.
 
diff --git a/src/main/agent-config-providers.test.ts b/src/main/agent-config-providers.test.ts
new file mode 100644
index 000000000..3368e1f4d
--- /dev/null
+++ b/src/main/agent-config-providers.test.ts
@@ -0,0 +1,330 @@
+// @vitest-environment node
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const mockState = vi.hoisted(() => ({ hermesHome: "" }));
+
+vi.mock("./installer", () => ({
+  get HERMES_HOME() {
+    return mockState.hermesHome;
+  },
+}));
+
+describe("agent-config providers (config.yaml bridge)", () => {
+  beforeEach(() => {
+    mockState.hermesHome = mkdtempSync(join(tmpdir(), "hermes-agent-cfg-"));
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    rmSync(mockState.hermesHome, { recursive: true, force: true });
+  });
+
+  async function mod(): Promise<typeof import("./agent-config-providers")> {
+    return import("./agent-config-providers");
+  }
+
+  function configPath(): string {
+    return join(mockState.hermesHome, "config.yaml");
+  }
+
+  function writeConfig(content: string): void {
+    writeFileSync(configPath(), content);
+  }
+
+  function readConfig(): string {
+    return readFileSync(configPath(), "utf-8");
+  }
+
+  // @lat: [[provider-setup#Provider setup#Agent config sync for named providers#Parses the agent's providers dict]]
+  it("parses providers: entries with base_url aliases and key_env", async () => {
+    writeConfig(
+      [
+        "model:",
+        '  provider: "custom"',
+        "providers:",
+        "  faab-ai:",
+        '    name: "Faab AI"',
+        '    base_url: "https://faab.ai/v1"',
+        '    key_env: "FAAB_KEY"',
+        "  terse:",
+        '    api: "https://terse.example/v1"',
+        "gateway:",
+        "  port: 9910",
+        "",
+      ].join("\n"),
+    );
+    const m = await mod();
+    expect(m.listAgentUserProviders("default")).toEqual([
+      {
+        slug: "faab-ai",
+        name: "Faab AI",
+        baseUrl: "https://faab.ai/v1",
+        keyEnv: "FAAB_KEY",
+      },
+      {
+        slug: "terse",
+        name: "terse",
+        baseUrl: "https://terse.example/v1",
+        keyEnv: "",
+      },
+    ]);
+  });
+
+  it("returns empty for a missing file or absent block", async () => {
+    const m = await mod();
+    expect(m.listAgentUserProviders("default")).toEqual([]);
+    writeConfig("model:\n  provider: nous\n");
+    expect(m.listAgentUserProviders("default")).toEqual([]);
+  });
+
+  // @lat: [[provider-setup#Provider setup#Agent config sync for named providers#Desktop saves mirror into config.yaml]]
+  it("appends a providers: block to an existing config", async () => {
+    writeConfig("model:\n  provider: nous\n");
+    const m = await mod();
+    m.upsertAgentUserProvider("default", {
+      name: "Faab AI",
+      baseUrl: "https://faab.ai/v1",
+      keyEnv: "CUSTOM_PROVIDER_FAAB_AI_KEY",
+    });
+    expect(readConfig()).toBe(
+      [
+        "model:",
+        "  provider: nous",
+        "providers:",
+        "  faab-ai:",
+        '    name: "Faab AI"',
+        '    base_url: "https://faab.ai/v1"',
+        '    key_env: "CUSTOM_PROVIDER_FAAB_AI_KEY"',
+        "",
+      ].join("\n"),
+    );
+    expect(m.listAgentUserProviders("default")).toEqual([
+      {
+        slug: "faab-ai",
+        name: "Faab AI",
+        baseUrl: "https://faab.ai/v1",
+        keyEnv: "CUSTOM_PROVIDER_FAAB_AI_KEY",
+      },
+    ]);
+  });
+
+  // The agent's config scaffold writes `providers: {}` (inline empty dict).
+  // The upsert must rewrite that line into block form — this exact miss made
+  // the Hermes One mirror a silent no-op on real configs (appending would
+  // have produced a duplicate `providers:` key instead).
+  it("rewrites an inline empty providers dict into block form", async () => {
+    writeConfig(
+      [
+        "model:",
+        "  provider: nous",
+        "providers: {}",
+        "fallback_providers: []",
+        "",
+      ].join("\n"),
+    );
+    const m = await mod();
+    m.upsertAgentUserProvider("default", {
+      name: "Hermes One",
+      slug: "hermesone",
+      baseUrl: "https://inference.hermesone.org/v1",
+      keyEnv: "HERMESONE_API_KEY",
+    });
+    const content = readConfig();
+    // Exactly one providers key, now in block form, siblings untouched.
+    expect(content.match(/^providers[^\S\r\n]*:/gm)).toHaveLength(1);
+    expect(content).toContain("fallback_providers: []");
+    expect(m.listAgentUserProviders("default")).toEqual([
+      {
+        slug: "hermesone",
+        name: "Hermes One",
+        baseUrl: "https://inference.hermesone.org/v1",
+        keyEnv: "HERMESONE_API_KEY",
+      },
+    ]);
+  });
+
+  it("never appends a duplicate key over an unparseable flow dict", async () => {
+    const before = [
+      'providers: { keep: { base_url: "https://keep.example/v1" } }',
+      "",
+    ].join("\n");
+    writeConfig(before);
+    const m = await mod();
+    m.upsertAgentUserProvider("default", {
+      name: "Hermes One",
+      baseUrl: "https://inference.hermesone.org/v1",
+      keyEnv: "HERMESONE_API_KEY",
+    });
+    expect(readConfig()).toBe(before);
+  });
+
+  it("creates config.yaml when missing", async () => {
+    const m = await mod();
+    m.upsertAgentUserProvider("default", {
+      name: "Faab AI",
+      baseUrl: "https://faab.ai/v1",
+      keyEnv: "CUSTOM_PROVIDER_FAAB_AI_KEY",
+    });
+    expect(existsSync(configPath())).toBe(true);
+    expect(m.listAgentUserProviders("default")).toHaveLength(1);
+  });
+
+  it("updates an existing entry in place, preserving extra fields", async () => {
+    writeConfig(
+      [
+        "providers:",
+        "  faab-ai:",
+        '    name: "Faab AI"',
+        '    base_url: "https://old.faab.ai/v1"',
+        '    transport: "anthropic_messages"',
+        '    key_env: "CUSTOM_PROVIDER_FAAB_AI_KEY"',
+        "gateway:",
+        "  port: 9910",
+        "",
+      ].join("\n"),
+    );
+    const m = await mod();
+    m.upsertAgentUserProvider("default", {
+      name: "Faab AI",
+      baseUrl: "https://new.faab.ai/v1",
+      keyEnv: "CUSTOM_PROVIDER_FAAB_AI_KEY",
+    });
+    const content = readConfig();
+    expect(content).toContain('base_url: "https://new.faab.ai/v1"');
+    // A terminal user's extra field survives the desktop update.
+    expect(content).toContain('transport: "anthropic_messages"');
+    expect(content).toContain("gateway:");
+    expect(m.listAgentUserProviders("default")).toHaveLength(1);
+  });
+
+  it("matches an existing terminal entry by key_env even when slugs differ", async () => {
+    writeConfig(
+      [
+        "providers:",
+        "  myfaab:",
+        '    name: "Faab"',
+        '    base_url: "https://faab.ai/v1"',
+        '    key_env: "SHARED_KEY"',
+        "",
+      ].join("\n"),
+    );
+    const m = await mod();
+    m.upsertAgentUserProvider("default", {
+      name: "Faab AI",
+      baseUrl: "https://faab.ai/v2",
+      keyEnv: "SHARED_KEY",
+    });
+    const list = m.listAgentUserProviders("default");
+    // Updated in place under the original slug — no duplicate entry.
+    expect(list).toHaveLength(1);
+    expect(list[0]).toMatchObject({
+      slug: "myfaab",
+      name: "Faab AI",
+      baseUrl: "https://faab.ai/v2",
+    });
+  });
+
+  it("escapes quotes and backslashes in provider values (valid YAML)", async () => {
+    // Review regression: unescaped user input inside double-quoted YAML could
+    // produce an unparseable config.yaml. The writer escapes, the reader
+    // unescapes — the name round-trips exactly.
+    const name = 'My "Fast" \\ Provider';
+    const m = await mod();
+    m.upsertAgentUserProvider("default", {
+      name,
+      baseUrl: "https://fast.example/v1",
+      keyEnv: "FAST_KEY",
+    });
+    expect(readConfig()).toContain('name: "My \\"Fast\\" \\\\ Provider"');
+    const list = m.listAgentUserProviders("default");
+    expect(list).toHaveLength(1);
+    expect(list[0].name).toBe(name);
+    // Idempotency survives the escaping: re-upserting is still a no-op.
+    const before = readConfig();
+    m.upsertAgentUserProvider("default", {
+      name,
+      baseUrl: "https://fast.example/v1",
+      keyEnv: "FAST_KEY",
+    });
+    expect(readConfig()).toBe(before);
+  });
+
+  it("is a no-op re-upserting identical values (no file rewrite)", async () => {
+    const m = await mod();
+    m.upsertAgentUserProvider("default", {
+      name: "Faab AI",
+      baseUrl: "https://faab.ai/v1",
+      keyEnv: "K",
+    });
+    const before = readConfig();
+    m.upsertAgentUserProvider("default", {
+      name: "Faab AI",
+      baseUrl: "https://faab.ai/v1",
+      keyEnv: "K",
+    });
+    expect(readConfig()).toBe(before);
+  });
+
+  it("removes an entry and leaves siblings intact", async () => {
+    writeConfig(
+      [
+        "providers:",
+        "  faab-ai:",
+        '    name: "Faab AI"',
+        '    base_url: "https://faab.ai/v1"',
+        "  other:",
+        '    base_url: "https://other.example/v1"',
+        "gateway:",
+        "  port: 9910",
+        "",
+      ].join("\n"),
+    );
+    const m = await mod();
+    m.removeAgentUserProvider("default", { name: "Faab AI" });
+    const content = readConfig();
+    expect(content).not.toContain("faab-ai");
+    expect(content).toContain("other:");
+    expect(content).toContain("gateway:");
+    expect(m.listAgentUserProviders("default")).toHaveLength(1);
+  });
+
+  // @lat: [[provider-setup#Provider setup#Agent config sync for named providers#Legacy custom_providers removal]]
+  it("removes a legacy custom_providers list item by name", async () => {
+    writeConfig(
+      [
+        "custom_providers:",
+        '  - name: "Keep Me"',
+        '    base_url: "https://keep.example/v1"',
+        '    model: "keep-1"',
+        '  - name: "Drop Me"',
+        '    base_url: "https://drop.example/v1"',
+        '    model: "drop-1"',
+        "gateway:",
+        "  port: 9910",
+        "",
+      ].join("\n"),
+    );
+    const m = await mod();
+    m.removeAgentCustomProviderEntry("default", "Drop Me");
+    const content = readConfig();
+    expect(content).toContain("Keep Me");
+    expect(content).not.toContain("Drop Me");
+    expect(content).not.toContain("drop.example");
+    expect(content).toContain("gateway:");
+  });
+
+  it("slugifies display names the way the agent expects", async () => {
+    const m = await mod();
+    expect(m.slugifyProviderName("Faab AI")).toBe("faab-ai");
+    expect(m.slugifyProviderName("  My_Provider 2!  ")).toBe("my-provider-2");
+  });
+});
diff --git a/src/main/agent-config-providers.ts b/src/main/agent-config-providers.ts
new file mode 100644
index 000000000..69fcd42fd
--- /dev/null
+++ b/src/main/agent-config-providers.ts
@@ -0,0 +1,404 @@
+// @lat: [[provider-setup#Provider setup#Agent config sync for named providers]]
+import { existsSync, readFileSync } from "fs";
+import { profilePaths, safeWriteFile } from "./utils";
+
+/**
+ * Bridge between hermes-agent's config.yaml provider sections and the
+ * desktop's own stores, so providers added from the terminal show up in the
+ * desktop UI and providers added in the desktop are visible to `hermes`.
+ *
+ * The agent reads two user-config shapes (hermes_cli/providers.py):
+ *   - `providers:` — a dict of named endpoints: `{slug: {name, base_url,
+ *     key_env, transport}}`, resolved by `resolve_user_provider`. This is the
+ *     shape the desktop mirrors its named custom providers into.
+ *   - `custom_providers:` — the legacy list (`- name/base_url/model/api_key`),
+ *     already imported into the model library by [[src/main/models.ts]].
+ *
+ * All edits are text-based (offset/line splicing, like config.ts) so user
+ * comments and unrelated keys in config.yaml survive round-trips. In
+ * particular, updating an entry patches individual field values in place —
+ * a terminal user's extra fields (e.g. `transport:`) are never dropped.
+ */
+
+export interface AgentUserProvider {
+  /** The `providers:` dict key — what `--provider <slug>` resolves. */
+  slug: string;
+  /** Display name (`name:`), falling back to the slug. */
+  name: string;
+  /** Endpoint base URL (`base_url:`/`api:`/`url:` — same aliases the agent accepts). */
+  baseUrl: string;
+  /** Env var holding the API key (`key_env:`), empty when unset. */
+  keyEnv: string;
+}
+
+/** Slug used as the config.yaml `providers:` dict key for a display name —
+ *  same normalization the agent applies to custom-provider names. */
+export function slugifyProviderName(name: string): string {
+  return (name || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+function readConfig(profile?: string): { file: string; content: string } {
+  const { configFile } = profilePaths(profile);
+  return {
+    file: configFile,
+    content: existsSync(configFile) ? readFileSync(configFile, "utf-8") : "",
+  };
+}
+
+function stripScalar(raw: string): string {
+  const trimmed = raw.trim();
+  // A double-quoted scalar: unquote and unescape (the inverse of yamlQuote),
+  // and don't apply comment stripping inside the quotes.
+  const dq = trimmed.match(/^"((?:[^"\\]|\\.)*)"/);
+  if (dq) return dq[1].replace(/\\(["\\])/g, "$1");
+  const sq = trimmed.match(/^'((?:[^']|'')*)'/);
+  if (sq) return sq[1].replace(/''/g, "'");
+  return trimmed
+    .replace(/\s+#.*$/, "")
+    .replace(/^["']|["']$/g, "")
+    .trim();
+}
+
+interface FieldSpan {
+  value: string;
+  /** Offsets bracketing the raw value text on the field's line. */
+  valueStart: number;
+  valueEnd: number;
+}
+
+interface ProviderEntrySpan {
+  slug: string;
+  /** Offset of the `<slug>:` line start. */
+  start: number;
+  /** Offset just past the entry's last line (exclusive, incl. newline). */
+  end: number;
+  /** Offset just past the `<slug>:` header line — where a new field goes. */
+  headerEnd: number;
+  /** Indent of this entry's direct fields ("" until a field is seen). */
+  fieldIndent: string;
+  fields: Map<string, FieldSpan>;
+}
+
+interface ProvidersBlock {
+  /** Offset just past the last body line (exclusive) — append point. */
+  bodyEnd: number;
+  /** Indent of provider entries (children of `providers:`). */
+  childIndent: string;
+  entries: ProviderEntrySpan[];
+}
+
+/** Locate the top-level `providers:` block and its entries. Null when the
+ *  file has no such block. Line-based, indentation-scoped: only an entry's
+ *  direct children are recorded as fields, so nested maps (e.g. a `models:`
+ *  sub-dict) can't shadow `name`/`base_url`/`key_env`. */
+function findProvidersBlock(content: string): ProvidersBlock | null {
+  const header = content.match(/^providers[^\S\r\n]*:[^\S\r\n]*(#.*)?\r?\n/m);
+  if (!header || header.index === undefined) return null;
+  if (header.index > 0 && content[header.index - 1] !== "\n") return null;
+
+  const bodyStart = header.index + header[0].length;
+  const lines = content.slice(bodyStart).split(/(?<=\n)/);
+  const entries: ProviderEntrySpan[] = [];
+  let childIndent = "";
+  let offset = bodyStart;
+  let bodyEnd = bodyStart;
+  let current: ProviderEntrySpan | null = null;
+
+  for (const line of lines) {
+    // Lines keep their trailing newline (lookbehind split) so offsets add up;
+    // match against the newline-stripped text since `$` won't cross a `\n`.
+    const text = line.replace(/\r?\n$/, "");
+    const isBlank = /^\s*$/.test(text);
+    if (!isBlank && !/^[ \t]/.test(text)) break; // next top-level key
+    if (!isBlank) {
+      const keyMatch = text.match(/^([ \t]+)([\w.-]+)([^\S\r\n]*:)(.*)$/);
+      if (keyMatch) {
+        const [, ind, key, colon, rest] = keyMatch;
+        if (!childIndent) childIndent = ind;
+        if (ind.length <= childIndent.length) {
+          current = {
+            slug: key,
+            start: offset,
+            end: offset + line.length,
+            headerEnd: offset + line.length,
+            fieldIndent: "",
+            fields: new Map(),
+          };
+          entries.push(current);
+        } else if (current) {
+          if (!current.fieldIndent) current.fieldIndent = ind;
+          if (ind.length === current.fieldIndent.length) {
+            const valueStart =
+              offset +
+              ind.length +
+              key.length +
+              colon.length +
+              (rest.length - rest.trimStart().length);
+            const rawValue = rest.trimStart();
+            current.fields.set(key, {
+              value: stripScalar(rawValue),
+              valueStart,
+              valueEnd: valueStart + rawValue.replace(/\s+$/, "").length,
+            });
+          }
+          current.end = offset + line.length;
+        }
+      } else if (current) {
+        // Non key:value content (e.g. list items) still belongs to the entry.
+        current.end = offset + line.length;
+      }
+      bodyEnd = offset + line.length;
+    }
+    offset += line.length;
+  }
+  return { bodyEnd, childIndent: childIndent || "  ", entries };
+}
+
+/** Parse the `providers:` dict from a profile's config.yaml. */
+export function listAgentUserProviders(profile?: string): AgentUserProvider[] {
+  const { content } = readConfig(profile);
+  if (!content) return [];
+  const block = findProvidersBlock(content);
+  if (!block) return [];
+  return block.entries.map((e) => ({
+    slug: e.slug,
+    name: e.fields.get("name")?.value || e.slug,
+    // Same base-URL aliases resolve_user_provider accepts, same precedence.
+    baseUrl:
+      e.fields.get("api")?.value ||
+      e.fields.get("url")?.value ||
+      e.fields.get("base_url")?.value ||
+      "",
+    keyEnv: e.fields.get("key_env")?.value || "",
+  }));
+}
+
+/** Double-quoted YAML scalar: backslashes and quotes escaped so a provider
+ *  name like `My "Fast" Provider` can't produce an unparseable config.yaml. */
+function yamlQuote(value: string): string {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+function renderEntry(
+  indent: string,
+  input: { slug: string; name: string; baseUrl: string; keyEnv: string },
+): string {
+  const sub = indent + "  ";
+  return (
+    `${indent}${input.slug}:\n` +
+    `${sub}name: ${yamlQuote(input.name)}\n` +
+    `${sub}base_url: ${yamlQuote(input.baseUrl)}\n` +
+    (input.keyEnv ? `${sub}key_env: ${yamlQuote(input.keyEnv)}\n` : "")
+  );
+}
+
+/**
+ * Create or update a `providers:` entry in config.yaml. An existing entry is
+ * matched by `key_env`, then by slug — so a desktop re-save updates the
+ * terminal-visible block in place instead of duplicating it. Updates patch
+ * only the `name`/`base_url`/`key_env` values; other fields are preserved.
+ */
+export function upsertAgentUserProvider(
+  profile: string | undefined,
+  input: { name: string; baseUrl: string; keyEnv: string; slug?: string },
+): void {
+  const name = (input.name || "").trim();
+  const baseUrl = (input.baseUrl || "").trim();
+  const slug = (input.slug || slugifyProviderName(name)).trim();
+  if (!name || !baseUrl || !slug) return;
+
+  const { file, content } = readConfig(profile);
+  const block = findProvidersBlock(content);
+  const entry = { slug, name, baseUrl, keyEnv: input.keyEnv || "" };
+
+  if (!block) {
+    // The agent's config scaffold writes an inline empty dict (`providers: {}`),
+    // which the block parser can't index. Rewrite that line into block form —
+    // appending a second `providers:` key instead would make the YAML
+    // ambiguous (this exact miss silently disabled the Hermes One mirror).
+    const emptyFlow = content.match(
+      /^providers[^\S\r\n]*:[^\S\r\n]*\{[^\S\r\n]*\}[^\S\r\n]*(#.*)?\r?\n?/m,
+    );
+    if (emptyFlow && emptyFlow.index !== undefined) {
+      const replacement = `providers:\n${renderEntry("  ", entry)}`;
+      safeWriteFile(
+        file,
+        content.slice(0, emptyFlow.index) +
+          replacement +
+          content.slice(emptyFlow.index + emptyFlow[0].length),
+      );
+      return;
+    }
+    // Any other unparseable `providers:` form (a non-empty flow dict) — bail
+    // rather than append a duplicate top-level key.
+    if (/^providers[^\S\r\n]*:/m.test(content)) return;
+    const sep = content === "" || content.endsWith("\n") ? "" : "\n";
+    safeWriteFile(
+      file,
+      `${content}${sep}providers:\n${renderEntry("  ", entry)}`,
+    );
+    return;
+  }
+
+  const existing =
+    block.entries.find(
+      (e) => input.keyEnv && e.fields.get("key_env")?.value === input.keyEnv,
+    ) ?? block.entries.find((e) => e.slug === slug);
+
+  if (!existing) {
+    const rendered = renderEntry(block.childIndent, entry);
+    safeWriteFile(
+      file,
+      content.slice(0, block.bodyEnd) + rendered + content.slice(block.bodyEnd),
+    );
+    return;
+  }
+
+  // Patch fields in place, back-to-front so earlier offsets stay valid.
+  // The base-URL aliases (`api`/`url`) are updated under whichever name the
+  // entry already uses; missing fields are inserted after the header line.
+  const urlField = existing.fields.has("api")
+    ? "api"
+    : existing.fields.has("url")
+      ? "url"
+      : "base_url";
+  const wanted: [string, string][] = [
+    ["name", name],
+    [urlField, baseUrl],
+    ...(entry.keyEnv ? [["key_env", entry.keyEnv] as [string, string]] : []),
+  ];
+  const patches: { start: number; end: number; text: string }[] = [];
+  const fieldIndent = existing.fieldIndent || block.childIndent + "  ";
+  for (const [key, value] of wanted) {
+    const span = existing.fields.get(key);
+    if (span) {
+      if (span.value === value) continue;
+      patches.push({
+        start: span.valueStart,
+        end: span.valueEnd,
+        text: yamlQuote(value),
+      });
+    } else {
+      patches.push({
+        start: existing.headerEnd,
+        end: existing.headerEnd,
+        text: `${fieldIndent}${key}: ${yamlQuote(value)}\n`,
+      });
+    }
+  }
+  if (patches.length === 0) return; // nothing changed — don't rewrite the file
+  patches.sort((a, b) => b.start - a.start);
+  let next = content;
+  for (const p of patches) {
+    next = next.slice(0, p.start) + p.text + next.slice(p.end);
+  }
+  safeWriteFile(file, next);
+}
+
+/** Remove a `providers:` entry matched by key_env, or by slug derived from
+ *  the name. No-op when absent. */
+export function removeAgentUserProvider(
+  profile: string | undefined,
+  match: { name: string; keyEnv?: string },
+): void {
+  const { file, content } = readConfig(profile);
+  if (!content) return;
+  const block = findProvidersBlock(content);
+  if (!block) return;
+  const slug = slugifyProviderName(match.name);
+  const existing =
+    block.entries.find(
+      (e) => match.keyEnv && e.fields.get("key_env")?.value === match.keyEnv,
+    ) ?? block.entries.find((e) => e.slug === slug);
+  if (!existing) return;
+  safeWriteFile(
+    file,
+    content.slice(0, existing.start) + content.slice(existing.end),
+  );
+}
+
+// Hermes One's inference endpoint. Mirrored as a first-party user provider so
+// the agent can route it by slug; must match `OPENAI_COMPATIBLE_BASE_URLS`
+// (renderer constants) and the `URL_KEY_MAP` host pattern.
+const HERMESONE_BASE_URL = "https://inference.hermesone.org/v1";
+
+/**
+ * Mirror first-party keyed brands into config.yaml `providers:` so the agent
+ * can route them as *named* providers. Today: Hermes One.
+ *
+ * Without this the gateway has no provider row for `inference.hermesone.org`
+ * — desktop models on that endpoint are saved as bare `custom` + base URL,
+ * and the agent resolves `--provider custom` against **the session's current
+ * base URL**. A session sitting on another provider (e.g. Nous) then sends
+ * the Hermes One model to the wrong endpoint (404, wrong catalog). A
+ * `providers: hermesone:` entry gives the switch a slug that always carries
+ * the right URL and key. Idempotent — the upsert no-ops when unchanged; runs
+ * on every model-library / provider-list read.
+ */
+export function mirrorFirstPartyAgentProviders(profile?: string): void {
+  try {
+    const { envFile } = profilePaths(profile);
+    if (!existsSync(envFile)) return;
+    const env = readFileSync(envFile, "utf-8");
+    const match = env.match(/^\s*HERMESONE_API_KEY\s*=\s*(.+)\s*$/m);
+    if (!match || !match[1].trim()) return;
+    upsertAgentUserProvider(profile, {
+      slug: "hermesone",
+      name: "Hermes One",
+      baseUrl: HERMESONE_BASE_URL,
+      keyEnv: "HERMESONE_API_KEY",
+    });
+  } catch {
+    /* best-effort — chat still works once the entry can be written */
+  }
+}
+
+/**
+ * Remove a legacy `custom_providers:` list item by display name. Needed when
+ * the user deletes a terminal-added provider from the desktop UI — leaving the
+ * list item behind would re-import it on the next read.
+ */
+export function removeAgentCustomProviderEntry(
+  profile: string | undefined,
+  name: string,
+): void {
+  const { file, content } = readConfig(profile);
+  if (!content) return;
+  const header = content.match(
+    /^custom_providers[^\S\r\n]*:[^\S\r\n]*(#.*)?\r?\n/m,
+  );
+  if (!header || header.index === undefined) return;
+  if (header.index > 0 && content[header.index - 1] !== "\n") return;
+
+  const bodyStart = header.index + header[0].length;
+  const lines = content.slice(bodyStart).split(/(?<=\n)/);
+  const target = (name || "").trim();
+  let offset = bodyStart;
+  let itemStart = -1;
+  let itemEnd = -1;
+  let itemMatches = false;
+
+  for (const line of lines) {
+    const text = line.replace(/\r?\n$/, "");
+    const isBlank = /^\s*$/.test(text);
+    if (!isBlank && !/^[ \t]/.test(text)) break; // next top-level key
+    if (/^\s*-\s/.test(text)) {
+      if (itemMatches) break; // matched item fully scanned
+      itemStart = offset;
+      itemEnd = offset + line.length;
+      const nm = text.match(/-\s*name\s*:\s*(.*)$/);
+      itemMatches = !!nm && stripScalar(nm[1]) === target;
+    } else if (itemStart !== -1 && !isBlank) {
+      const nm = text.match(/^\s*name\s*:\s*(.*)$/);
+      if (nm && stripScalar(nm[1]) === target) itemMatches = true;
+      itemEnd = offset + line.length;
+    }
+    offset += line.length;
+  }
+  if (!itemMatches || itemStart === -1) return;
+  safeWriteFile(file, content.slice(0, itemStart) + content.slice(itemEnd));
+}
diff --git a/src/main/hermesone-provision.test.ts b/src/main/hermesone-provision.test.ts
new file mode 100644
index 000000000..6a5a629d8
--- /dev/null
+++ b/src/main/hermesone-provision.test.ts
@@ -0,0 +1,187 @@
+// @vitest-environment node
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// Unit tests for the Hermes One convenience layer: auto-provisioning the
+// HERMESONE_API_KEY from the signed-in account and reading the credit
+// balance. Account store, env store, and fetch are all faked — no real
+// HERMES_HOME or network.
+
+const state = vi.hoisted(() => ({
+  env: {} as Record<string, string>,
+  accountProfile: "default" as string | null,
+  apiUrl: "https://backend.test",
+  token: "session-token" as string | null,
+  envWrites: [] as Array<{ key: string; value: string; profile?: string }>,
+}));
+
+vi.mock("./account-store", () => ({
+  findAccountProfile: () => state.accountProfile,
+  getAccount: () =>
+    state.accountProfile !== null
+      ? { apiUrl: state.apiUrl, user: { id: "u1" } }
+      : null,
+  getAccessToken: () => state.token,
+}));
+
+vi.mock("./hermes-account", () => ({
+  apiHeaders: (json = true) =>
+    json ? { "content-type": "application/json" } : {},
+}));
+
+vi.mock("./config", () => ({
+  readEnv: () => state.env,
+  setEnvValue: (key: string, value: string, profile?: string) => {
+    state.envWrites.push({ key, value, profile });
+    state.env[key] = value;
+  },
+}));
+
+const fetchMock = vi.fn();
+
+async function mod(): Promise<typeof import("./hermesone-provision")> {
+  return import("./hermesone-provision");
+}
+
+describe("hermesone provisioning", () => {
+  beforeEach(() => {
+    state.env = {};
+    state.accountProfile = "default";
+    state.token = "session-token";
+    state.envWrites = [];
+    fetchMock.mockReset();
+    vi.stubGlobal("fetch", fetchMock);
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  // @lat: [[hermes-account-login#Hermes One account login#Auto-provisioned inference key and credits#Issues a key only when missing]]
+  it("keeps an existing HERMESONE_API_KEY without touching the backend", async () => {
+    state.env["HERMESONE_API_KEY"] = "hs-live-already";
+    const m = await mod();
+    expect(await m.ensureHermesOneApiKey("default")).toEqual({
+      status: "exists",
+    });
+    expect(fetchMock).not.toHaveBeenCalled();
+    expect(state.envWrites).toEqual([]);
+  });
+
+  it("reports signed-out (and stays offline) with no account", async () => {
+    state.accountProfile = null;
+    const m = await mod();
+    expect(await m.ensureHermesOneApiKey("default")).toEqual({
+      status: "signed-out",
+    });
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  // @lat: [[hermes-account-login#Hermes One account login#Auto-provisioned inference key and credits#Provisions and persists a fresh key]]
+  it("issues a key from the backend and persists it to the profile env", async () => {
+    fetchMock.mockResolvedValue(
+      new Response(JSON.stringify({ key: "hs-live-fresh" }), { status: 200 }),
+    );
+    const m = await mod();
+    expect(await m.ensureHermesOneApiKey("coder")).toEqual({
+      status: "created",
+    });
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+    expect(url).toBe("https://backend.test/api/credits/keys");
+    expect(init.method).toBe("POST");
+    expect((init.headers as Record<string, string>).authorization).toBe(
+      "Bearer session-token",
+    );
+    // The console key list shows this name so users know its origin.
+    expect(JSON.parse(String(init.body)).name).toMatch(/^Hermes Desktop /);
+
+    expect(state.envWrites).toEqual([
+      { key: "HERMESONE_API_KEY", value: "hs-live-fresh", profile: "coder" },
+    ]);
+  });
+
+  it("surfaces backend failures without writing anything", async () => {
+    fetchMock.mockResolvedValue(new Response("{}", { status: 500 }));
+    const m = await mod();
+    const result = await m.ensureHermesOneApiKey("default");
+    expect(result.status).toBe("error");
+    expect(state.envWrites).toEqual([]);
+  });
+
+  // @lat: [[hermes-account-login#Hermes One account login#Auto-provisioned inference key and credits#Single-flight provisioning]]
+  it("coalesces concurrent ensure calls into one backend key", async () => {
+    let resolveFetch!: (r: Response) => void;
+    fetchMock.mockReturnValue(
+      new Promise<Response>((resolve) => {
+        resolveFetch = resolve;
+      }),
+    );
+    const m = await mod();
+    const a = m.ensureHermesOneApiKey("default");
+    const b = m.ensureHermesOneApiKey("default");
+    resolveFetch(
+      new Response(JSON.stringify({ key: "hs-live-once" }), { status: 200 }),
+    );
+    expect(await a).toEqual({ status: "created" });
+    expect(await b).toEqual({ status: "created" });
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(state.envWrites).toHaveLength(1);
+  });
+
+  it("does not share a flight across profiles — each gets its own key", async () => {
+    // Review regression: a global single-flight latch let profile B piggyback
+    // on profile A's provisioning and report `created` while only A's `.env`
+    // received a key.
+    fetchMock.mockImplementation(
+      async () =>
+        new Response(
+          JSON.stringify({ key: `hs-live-${fetchMock.mock.calls.length}` }),
+          { status: 200 },
+        ),
+    );
+    const m = await mod();
+    const [a, b] = await Promise.all([
+      m.ensureHermesOneApiKey("alpha"),
+      m.ensureHermesOneApiKey("beta"),
+    ]);
+    expect(a).toEqual({ status: "created" });
+    expect(b).toEqual({ status: "created" });
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    expect(state.envWrites.map((w) => w.profile).sort()).toEqual([
+      "alpha",
+      "beta",
+    ]);
+  });
+
+  // @lat: [[hermes-account-login#Hermes One account login#Auto-provisioned inference key and credits#Credits for the account card]]
+  it("fetches the credit balance for the signed-in account", async () => {
+    fetchMock.mockResolvedValue(
+      new Response(JSON.stringify({ balance: 12.5 }), { status: 200 }),
+    );
+    const m = await mod();
+    expect(await m.fetchHermesOneCredits()).toEqual({ balance: 12.5 });
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+    expect(url).toBe("https://backend.test/api/credits/balance?limit=1");
+    expect((init.headers as Record<string, string>).authorization).toBe(
+      "Bearer session-token",
+    );
+  });
+
+  it("returns a null balance when signed out or on bad payloads", async () => {
+    state.accountProfile = null;
+    const m = await mod();
+    expect((await m.fetchHermesOneCredits()).balance).toBe(null);
+
+    state.accountProfile = "default";
+    fetchMock.mockResolvedValue(
+      new Response(JSON.stringify({ balance: "not-a-number" }), {
+        status: 200,
+      }),
+    );
+    vi.resetModules();
+    const m2 = await mod();
+    expect((await m2.fetchHermesOneCredits()).balance).toBe(null);
+  });
+});
diff --git a/src/main/hermesone-provision.ts b/src/main/hermesone-provision.ts
new file mode 100644
index 000000000..498633269
--- /dev/null
+++ b/src/main/hermesone-provision.ts
@@ -0,0 +1,148 @@
+// @lat: [[hermes-account-login#Hermes One account login#Auto-provisioned inference key and credits]]
+import { hostname } from "os";
+import {
+  findAccountProfile,
+  getAccessToken,
+  getAccount,
+} from "./account-store";
+import { apiHeaders } from "./hermes-account";
+import { readEnv, setEnvValue } from "./config";
+
+/**
+ * Convenience layer over the signed-in Hermes One account: users get model
+ * access through Hermes One Inference without hand-copying an API key from the
+ * console. On login (and whenever the Providers screen finds the key missing)
+ * the desktop asks the backend to issue a gateway key and stores it as
+ * `HERMESONE_API_KEY` — which by itself makes the Hermes One provider card and
+ * active-model picker entry appear, since both are keyed off that env var.
+ *
+ * The backend endpoints are session-gated and accept the device-login bearer
+ * token (`hermes-one-backend/server/api/credits/keys.ts` + `balance.get.ts`);
+ * the raw `hs-live-…` key is returned exactly once and never re-readable, so
+ * an existing local key is always kept rather than re-issued.
+ */
+
+export interface EnsureHermesOneKeyResult {
+  status: "created" | "exists" | "signed-out" | "error";
+  error?: string;
+}
+
+export interface HermesOneCreditsResult {
+  /** USD-denominated AI-credit balance (1 credit = $1). */
+  balance: number | null;
+  error?: string;
+}
+
+function accountSession(): { apiUrl: string; token: string } | null {
+  const accountProfile = findAccountProfile();
+  if (accountProfile === null) return null;
+  const account = getAccount(accountProfile);
+  const token = getAccessToken(accountProfile);
+  if (!account || !token) return null;
+  return { apiUrl: account.apiUrl, token };
+}
+
+// Single-flight **per profile**: the post-login hook and the Providers screen
+// can both ask at once; issuing two backend keys for one gap would leave an
+// orphan. Keyed by profile because provisioning writes that profile's `.env` —
+// a global latch would let profile B piggyback on profile A's run and report
+// `created` without ever receiving a key.
+const ensureInFlight = new Map<string, Promise<EnsureHermesOneKeyResult>>();
+
+/**
+ * Make sure the profile has a `HERMESONE_API_KEY`: keep an existing one,
+ * otherwise issue a fresh gateway key from the signed-in account and persist
+ * it to the profile's `.env`.
+ */
+export function ensureHermesOneApiKey(
+  profile?: string,
+): Promise<EnsureHermesOneKeyResult> {
+  const key = profile?.trim() || "default";
+  let flight = ensureInFlight.get(key);
+  if (!flight) {
+    flight = doEnsure(profile).finally(() => {
+      ensureInFlight.delete(key);
+    });
+    ensureInFlight.set(key, flight);
+  }
+  return flight;
+}
+
+async function doEnsure(profile?: string): Promise<EnsureHermesOneKeyResult> {
+  try {
+    const existing = (readEnv(profile)["HERMESONE_API_KEY"] || "").trim();
+    if (existing) return { status: "exists" };
+  } catch {
+    // Unreadable .env — treat as missing and let the write surface an error.
+  }
+
+  const session = accountSession();
+  if (!session) return { status: "signed-out" };
+
+  let res: Response;
+  try {
+    res = await fetch(`${session.apiUrl}/api/credits/keys`, {
+      method: "POST",
+      headers: {
+        ...apiHeaders(),
+        authorization: `Bearer ${session.token}`,
+      },
+      // The console's key list shows this name, so the user can tell where
+      // the key came from.
+      body: JSON.stringify({ name: `Hermes Desktop (${hostname()})` }),
+    });
+  } catch (err) {
+    return {
+      status: "error",
+      error: `Couldn't reach the Hermes One backend: ${(err as Error).message}`,
+    };
+  }
+  if (!res.ok) {
+    return {
+      status: "error",
+      error: `Key provisioning failed (HTTP ${res.status}).`,
+    };
+  }
+
+  const data = (await res.json().catch(() => ({}))) as { key?: unknown };
+  const key = typeof data.key === "string" ? data.key.trim() : "";
+  if (!key) {
+    return { status: "error", error: "Backend returned no key." };
+  }
+
+  try {
+    setEnvValue("HERMESONE_API_KEY", key, profile);
+  } catch (err) {
+    return {
+      status: "error",
+      error: `Couldn't save the key: ${(err as Error).message}`,
+    };
+  }
+  return { status: "created" };
+}
+
+/** The signed-in account's AI-credit balance, for the Providers account card. */
+export async function fetchHermesOneCredits(): Promise<HermesOneCreditsResult> {
+  const session = accountSession();
+  if (!session) return { balance: null, error: "signed-out" };
+
+  try {
+    const res = await fetch(`${session.apiUrl}/api/credits/balance?limit=1`, {
+      headers: {
+        ...apiHeaders(false),
+        authorization: `Bearer ${session.token}`,
+      },
+    });
+    if (!res.ok) {
+      return { balance: null, error: `HTTP ${res.status}` };
+    }
+    const data = (await res.json().catch(() => ({}))) as { balance?: unknown };
+    const balance = Number(data.balance);
+    if (!Number.isFinite(balance)) {
+      return { balance: null, error: "Malformed balance." };
+    }
+    return { balance };
+  } catch (err) {
+    return { balance: null, error: (err as Error).message };
+  }
+}
diff --git a/src/main/ipc/register.ts b/src/main/ipc/register.ts
index 70506ae0f..2b8df4f0a 100644
--- a/src/main/ipc/register.ts
+++ b/src/main/ipc/register.ts
@@ -94,6 +94,10 @@ import {
   detectDeviceCode,
 } from "../hermes-auth";
 import { startDeviceLogin, cancelDeviceLogin } from "../hermes-account";
+import {
+  ensureHermesOneApiKey,
+  fetchHermesOneCredits,
+} from "../hermesone-provision";
 import {
   syncAgents,
   getAgentSyncStatus,
@@ -838,8 +842,8 @@ export function registerIpcHandlers(context: IpcContext): void {
   // Hermes account sign-in — OAuth 2.0 Device Authorization Grant against the
   // Hermes backend. Streams progress to the renderer's modal, opens the browser
   // approval page once the code is issued, and stores the encrypted session.
-  ipcMain.handle("hermes-account-login", (event, profile?: string) =>
-    startDeviceLogin(profile, {
+  ipcMain.handle("hermes-account-login", async (event, profile?: string) => {
+    const result = await startDeviceLogin(profile, {
       onCode: (info) => {
         if (event.sender.isDestroyed()) return;
         // Show the code in the modal, then open the browser to approve it.
@@ -850,8 +854,15 @@ export function registerIpcHandlers(context: IpcContext): void {
         if (event.sender.isDestroyed()) return;
         event.sender.send("hermes-account-login-progress", chunk);
       },
-    }),
-  );
+    });
+    // Convenience auto-provision: a fresh sign-in should yield model access
+    // without hand-adding keys. Best-effort and local-only — the key lands in
+    // the local profile `.env`, which remote/SSH chat doesn't read.
+    if (result.success && getConnectionConfig().mode === "local") {
+      void ensureHermesOneApiKey(profile).catch(() => {});
+    }
+    return result;
+  });
   ipcMain.handle("hermes-account-login-cancel", () => cancelDeviceLogin());
   // The account is device-wide (one Hermes One login for the whole app), but
   // account.json lives under whichever profile was active at sign-in. Resolve
@@ -864,6 +875,19 @@ export function registerIpcHandlers(context: IpcContext): void {
     clearAllAccounts();
     return { success: true };
   });
+  // Auto-provision a Hermes One Inference key from the signed-in account when
+  // the profile has none (idempotent — an existing key is never replaced, the
+  // backend shows the raw key only once). Local mode only: the key is written
+  // to the local profile `.env`, which remote/SSH chat doesn't read — issuing
+  // one there would strand an orphan key on the backend every screen visit.
+  ipcMain.handle("hermesone-ensure-key", (_event, profile?: string) => {
+    if (getConnectionConfig().mode !== "local") {
+      return { status: "error", error: "Local connections only." };
+    }
+    return ensureHermesOneApiKey(profile?.trim() || getActiveProfileNameSync());
+  });
+  // The signed-in account's AI-credit balance, shown on the account card.
+  ipcMain.handle("hermesone-credits", () => fetchHermesOneCredits());
 
   // Cloud agent sync — reconciles local profiles with the signed-in Hermes One
   // account's cloud agents. `agent-sync-updated` tells the renderer to reload
@@ -2406,7 +2430,9 @@ export function registerIpcHandlers(context: IpcContext): void {
         getActiveProfileNameSync(),
       );
     }
-    return listModels();
+    // Pass the active profile so terminal-added `custom_providers:` entries in
+    // that profile's config.yaml are merged into the library on read.
+    return listModels(getActiveProfileNameSync());
   });
   ipcMain.handle(
     "add-model",
diff --git a/src/main/models.ts b/src/main/models.ts
index 4df330b72..81fd30521 100644
--- a/src/main/models.ts
+++ b/src/main/models.ts
@@ -4,6 +4,7 @@ import { randomUUID } from "crypto";
 import { HERMES_HOME } from "./installer";
 import { safeWriteFile, profilePaths } from "./utils";
 import { hostDerivedEnvKeyForUrl } from "./host-derived-env";
+import { mirrorFirstPartyAgentProviders } from "./agent-config-providers";
 import { customProviderEnvKey } from "../shared/url-key-map";
 import DEFAULT_MODELS from "./default-models";
 
@@ -300,19 +301,102 @@ function loadCustomProviders(profile?: string): CustomProviderEntry[] {
   return result;
 }
 
-function seedDefaults(profile?: string): SavedModelRow[] {
-  const models: SavedModelRow[] = DEFAULT_MODELS.map((m) => ({
-    id: randomUUID(),
-    name: m.name,
-    provider: m.provider,
-    model: m.model,
-    baseUrl: m.baseUrl,
-    createdAt: Date.now(),
-  }));
+/** Persist a `custom_providers:` entry's API key into the profile `.env`,
+ *  under both key names the two engine generations resolve. Additive only —
+ *  existing values are never overwritten. */
+function writeCustomProviderEnvKeys(
+  profile: string | undefined,
+  cp: CustomProviderEntry,
+): void {
+  if (!cp.apiKey || cp.apiKey === "no-key-required") return;
   try {
     const { envFile } = profilePaths(profile);
-    const cpModels = loadCustomProviders(profile);
-    for (const cp of cpModels) {
+    let envContent = existsSync(envFile) ? readFileSync(envFile, "utf-8") : "";
+    // Names to persist for this custom-provider key:
+    //   1. CUSTOM_PROVIDER_<NAME>_KEY — the historical desktop
+    //      contract; the runtime spawn in `hermes.ts` reads it
+    //      via the models.json baseUrl match.
+    //   2. <VENDOR>_API_KEY when the URL matches a known vendor
+    //      host (e.g. api.deepseek.com → DEEPSEEK_API_KEY) —
+    //      required for dual-engine compat: upstream-main's
+    //      `_host_derived_api_key()` won't accept the custom-
+    //      prefix form. Old engine (≤ v2026.5.16) doesn't have
+    //      the host-derive resolver and ignores this extra var,
+    //      so writing both is additive and safe.
+    // The gateway path in `hermes.ts:startGateway` ingests ALL
+    // profile env vars at spawn, so the host-derived form has
+    // to live in .env (not just be set at chat-time) for the
+    // long-running gateway flow to work on the new engine.
+    const customPrefixKey = customProviderEnvKey(cp.name);
+    const namesToWrite: string[] = [customPrefixKey];
+    const hostKey = hostDerivedEnvKeyForUrl(cp.baseUrl);
+    // Don't shadow real OPENAI / ANTHROPIC keys via this path —
+    // those belong to a separately-configured provider, not a
+    // custom-provider key. The persistence guard mirrors the
+    // runtime guard in `hermes.ts`.
+    if (
+      hostKey &&
+      hostKey !== "OPENAI_API_KEY" &&
+      hostKey !== "ANTHROPIC_API_KEY" &&
+      hostKey !== customPrefixKey
+    ) {
+      namesToWrite.push(hostKey);
+    }
+    let modified = false;
+    for (const envKey of namesToWrite) {
+      const keyRegex = new RegExp(
+        "^" + envKey.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "=.*$",
+        "m",
+      );
+      if (!keyRegex.test(envContent)) {
+        envContent =
+          envContent.trimEnd() + "\n" + envKey + "=" + cp.apiKey + "\n";
+        modified = true;
+      }
+    }
+    if (modified) {
+      safeWriteFile(envFile, envContent);
+    }
+  } catch {
+    /* best-effort */
+  }
+}
+
+/**
+ * Merge `custom_providers:` entries from the profile's config.yaml into the
+ * model library. Runs on every renderer-facing read (not just first seed), so
+ * a provider the user adds from the terminal appears in the desktop without
+ * wiping models.json. Idempotent: rows are deduped by provider + model id +
+ * base URL (the same key `addModel` uses) and env keys are written only when
+ * absent.
+ */
+export function syncAgentConfigModels(profile?: string): void {
+  // Piggyback on the library read (chat pickers hit this via list-models):
+  // keyed first-party brands must exist as named `providers:` entries so
+  // session model switches route them by slug instead of bare `custom`.
+  mirrorFirstPartyAgentProviders(profile);
+
+  let cpModels: CustomProviderEntry[];
+  try {
+    cpModels = loadCustomProviders(profile);
+  } catch (e) {
+    console.error("Failed to load custom providers:", e);
+    return;
+  }
+  if (cpModels.length === 0) return;
+
+  const norm = (u: string): string =>
+    (u || "").trim().replace(/\/+$/, "").toLowerCase();
+  const models = readModelsRaw();
+  let modified = false;
+  for (const cp of cpModels) {
+    const exists = models.some(
+      (m) =>
+        m.model === cp.model &&
+        m.provider === cp.provider &&
+        norm(m.baseUrl) === norm(cp.baseUrl),
+    );
+    if (!exists) {
       models.push({
         id: randomUUID(),
         name: cp.name,
@@ -320,73 +404,40 @@ function seedDefaults(profile?: string): SavedModelRow[] {
         model: cp.model,
         baseUrl: cp.baseUrl,
         apiMode: cp.apiMode || null,
+        // Group under the provider's name like desktop-added custom models,
+        // so the card union and the runtime's label-derived key lookup agree.
+        providerLabel: cp.name,
         createdAt: Date.now(),
       });
-      if (cp.apiKey && cp.apiKey !== "no-key-required") {
-        try {
-          let envContent = existsSync(envFile)
-            ? readFileSync(envFile, "utf-8")
-            : "";
-          // Names to persist for this custom-provider key:
-          //   1. CUSTOM_PROVIDER_<NAME>_KEY — the historical desktop
-          //      contract; the runtime spawn in `hermes.ts` reads it
-          //      via the models.json baseUrl match.
-          //   2. <VENDOR>_API_KEY when the URL matches a known vendor
-          //      host (e.g. api.deepseek.com → DEEPSEEK_API_KEY) —
-          //      required for dual-engine compat: upstream-main's
-          //      `_host_derived_api_key()` won't accept the custom-
-          //      prefix form. Old engine (≤ v2026.5.16) doesn't have
-          //      the host-derive resolver and ignores this extra var,
-          //      so writing both is additive and safe.
-          // The gateway path in `hermes.ts:startGateway` ingests ALL
-          // profile env vars at spawn, so the host-derived form has
-          // to live in .env (not just be set at chat-time) for the
-          // long-running gateway flow to work on the new engine.
-          const customPrefixKey = customProviderEnvKey(cp.name);
-          const namesToWrite: string[] = [customPrefixKey];
-          const hostKey = hostDerivedEnvKeyForUrl(cp.baseUrl);
-          // Don't shadow real OPENAI / ANTHROPIC keys via this path —
-          // those belong to a separately-configured provider, not a
-          // custom-provider key. The persistence guard mirrors the
-          // runtime guard in `hermes.ts`.
-          if (
-            hostKey &&
-            hostKey !== "OPENAI_API_KEY" &&
-            hostKey !== "ANTHROPIC_API_KEY" &&
-            hostKey !== customPrefixKey
-          ) {
-            namesToWrite.push(hostKey);
-          }
-          let modified = false;
-          for (const envKey of namesToWrite) {
-            const keyRegex = new RegExp(
-              "^" + envKey.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "=.*$",
-              "m",
-            );
-            if (!keyRegex.test(envContent)) {
-              envContent =
-                envContent.trimEnd() + "\n" + envKey + "=" + cp.apiKey + "\n";
-              modified = true;
-            }
-          }
-          if (modified) {
-            safeWriteFile(envFile, envContent);
-          }
-        } catch {
-          /* best-effort */
-        }
-      }
+      modified = true;
     }
-  } catch (e) {
-    console.error("Failed to load custom providers:", e);
+    writeCustomProviderEnvKeys(profile, cp);
   }
+  if (modified) writeModels(models);
+}
+
+function seedDefaults(profile?: string): SavedModelRow[] {
+  const models: SavedModelRow[] = DEFAULT_MODELS.map((m) => ({
+    id: randomUUID(),
+    name: m.name,
+    provider: m.provider,
+    model: m.model,
+    baseUrl: m.baseUrl,
+    createdAt: Date.now(),
+  }));
   writeModels(models);
-  return models;
+  syncAgentConfigModels(profile);
+  return readModelsRaw();
 }
 
-export function listModels(): SavedModel[] {
+export function listModels(profile?: string): SavedModel[] {
   if (!existsSync(MODELS_FILE)) {
-    seedDefaults();
+    seedDefaults(profile);
+  } else {
+    // Pick up providers/models added to config.yaml from the terminal since
+    // the library was first seeded — keeps `hermes` CLI edits and the desktop
+    // library in sync instead of only honoring config.yaml on first run.
+    syncAgentConfigModels(profile);
   }
   // Hoist any legacy per-row context overrides into shared definitions before
   // the merged read. This is the renderer-facing entry point (Providers screen),
diff --git a/src/main/providers-store.test.ts b/src/main/providers-store.test.ts
index 17657f0d8..e9233b4c7 100644
--- a/src/main/providers-store.test.ts
+++ b/src/main/providers-store.test.ts
@@ -1,5 +1,5 @@
 // @vitest-environment node
-import { existsSync, mkdtempSync, rmSync } from "fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "fs";
 import { tmpdir } from "os";
 import { join } from "path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
@@ -104,6 +104,109 @@ describe("providers store", () => {
     expect(s.listCustomProviders("default")).toEqual([]);
   });
 
+  // @lat: [[provider-setup#Provider setup#Agent config sync for named providers#Terminal-added providers import on read]]
+  it("imports terminal-added providers: entries from config.yaml", async () => {
+    const { writeFileSync } = await import("fs");
+    writeFileSync(
+      join(mockState.hermesHome, "config.yaml"),
+      [
+        "providers:",
+        "  faab-ai:",
+        '    name: "Faab AI"',
+        '    base_url: "https://faab.ai/v1"',
+        '    key_env: "MY_FAAB_KEY"',
+        "",
+      ].join("\n"),
+    );
+    writeFileSync(join(mockState.hermesHome, ".env"), "MY_FAAB_KEY=sk-123\n");
+
+    const s = await store();
+    const list = s.listCustomProviders("default");
+    expect(list).toHaveLength(1);
+    expect(list[0]).toMatchObject({
+      name: "Faab AI",
+      baseUrl: "https://faab.ai/v1",
+    });
+    // The terminal entry's key is aliased to the desktop's derived env var so
+    // the key field and the chat runtime's label-derived lookup both resolve.
+    const env = readFileSync(join(mockState.hermesHome, ".env"), "utf-8");
+    expect(env).toContain("CUSTOM_PROVIDER_FAAB_AI_KEY=sk-123");
+    // Original stays — aliasing is additive.
+    expect(env).toContain("MY_FAAB_KEY=sk-123");
+  });
+
+  it("skips config.yaml entries whose host has a dedicated brand card", async () => {
+    const { writeFileSync } = await import("fs");
+    writeFileSync(
+      join(mockState.hermesHome, "config.yaml"),
+      [
+        "providers:",
+        "  my-groq:",
+        '    base_url: "https://api.groq.com/openai/v1"',
+        "",
+      ].join("\n"),
+    );
+    const s = await store();
+    expect(s.listCustomProviders("default")).toEqual([]);
+  });
+
+  // @lat: [[provider-setup#Provider setup#Agent config sync for named providers#Store upserts propagate to the agent config]]
+  it("mirrors desktop upserts into config.yaml's providers: dict", async () => {
+    const s = await store();
+    s.upsertCustomProvider("default", {
+      name: "Faab AI",
+      baseUrl: "https://faab.ai/v1",
+    });
+    const config = readFileSync(
+      join(mockState.hermesHome, "config.yaml"),
+      "utf-8",
+    );
+    expect(config).toContain("faab-ai:");
+    expect(config).toContain('base_url: "https://faab.ai/v1"');
+    expect(config).toContain('key_env: "CUSTOM_PROVIDER_FAAB_AI_KEY"');
+  });
+
+  // @lat: [[provider-setup#Provider setup#Agent config sync for named providers#Desktop deletion cleans the agent config]]
+  it("removes the config.yaml entry on delete so it can't re-import", async () => {
+    const s = await store();
+    s.upsertCustomProvider("default", {
+      name: "Faab AI",
+      baseUrl: "https://faab.ai/v1",
+    });
+    s.removeCustomProvider("default", "Faab AI");
+    expect(s.listCustomProviders("default")).toEqual([]);
+    const config = readFileSync(
+      join(mockState.hermesHome, "config.yaml"),
+      "utf-8",
+    );
+    expect(config).not.toContain("faab-ai");
+  });
+
+  // @lat: [[provider-setup#Provider setup#Agent config sync for named providers#First-party brands mirror as user providers]]
+  it("mirrors a keyed Hermes One into config.yaml providers: without a custom card", async () => {
+    const { writeFileSync } = await import("fs");
+    writeFileSync(
+      join(mockState.hermesHome, ".env"),
+      "HERMESONE_API_KEY=hs-live-abc\n",
+    );
+    const s = await store();
+    // No custom-provider card — Hermes One owns a dedicated brand card.
+    expect(s.listCustomProviders("default")).toEqual([]);
+    const config = readFileSync(
+      join(mockState.hermesHome, "config.yaml"),
+      "utf-8",
+    );
+    expect(config).toContain("hermesone:");
+    expect(config).toContain('base_url: "https://inference.hermesone.org/v1"');
+    expect(config).toContain('key_env: "HERMESONE_API_KEY"');
+  });
+
+  it("does not create a providers: entry without a Hermes One key", async () => {
+    const s = await store();
+    s.listCustomProviders("default");
+    expect(existsSync(join(mockState.hermesHome, "config.yaml"))).toBe(false);
+  });
+
   it("isolates providers per profile", async () => {
     const s = await store();
     s.upsertCustomProvider("default", {
diff --git a/src/main/providers-store.ts b/src/main/providers-store.ts
index de4dcef2f..8ca2b9354 100644
--- a/src/main/providers-store.ts
+++ b/src/main/providers-store.ts
@@ -6,7 +6,19 @@ import {
   type CustomProviderFile,
   type CustomProviderRecord,
 } from "../shared/custom-providers";
-import { customProviderEnvKey } from "../shared/url-key-map";
+import {
+  CUSTOM_API_KEY_ENV,
+  customProviderEnvKey,
+  expectedEnvKeyForUrl,
+} from "../shared/url-key-map";
+import {
+  listAgentUserProviders,
+  mirrorFirstPartyAgentProviders,
+  removeAgentCustomProviderEntry,
+  removeAgentUserProvider,
+  upsertAgentUserProvider,
+} from "./agent-config-providers";
+import { readEnv, setEnvValue } from "./config";
 import { isValidProfileName, profileHome, safeWriteFile } from "./utils";
 
 // Per-profile store of user-configured custom providers. Sits alongside the
@@ -65,20 +77,58 @@ function writeProvidersFile(
   safeWriteFile(providersPath(profile), JSON.stringify(data, null, 2));
 }
 
-/** All custom providers configured for `profile` (empty when none/no file). */
-export function listCustomProviders(profile?: string): CustomProviderRecord[] {
-  const normalized = normalizeProfile(profile);
-  return readProvidersFile(normalized).providers;
-}
-
 /**
- * Create or update a custom provider by identity. Records are keyed by their
- * derived env-key name (`customProviderEnvKey(name)`) — the same anchor the
- * runtime uses to look the API key back up — so a re-save with the same name
- * updates the base URL in place instead of duplicating. Blank name or base URL
- * is a no-op (nothing durable to record yet).
+ * Import providers the user added from the terminal — the `providers:` dict in
+ * the profile's config.yaml — into the desktop's `providers.json`, so they
+ * render as cards and appear in the active-model picker like desktop-added
+ * ones. Runs on every list read; each step is an idempotent no-op once synced.
+ *
+ * Endpoints whose host maps to a first-class brand key (Groq, Hermes One, …)
+ * are skipped — those already surface through their dedicated key cards.
+ *
+ * When a terminal entry keeps its key under a custom `key_env`, the value is
+ * aliased to the desktop's derived `CUSTOM_PROVIDER_<NAME>_KEY` (never the
+ * other way round), so the desktop key field and the chat runtime's
+ * label-derived lookup both resolve without renderer changes — the same
+ * additive dual-write convention `models.ts` uses for vendor-host keys.
  */
-export function upsertCustomProvider(
+function importAgentConfigProviders(profile: string | undefined): void {
+  let agentProviders;
+  try {
+    agentProviders = listAgentUserProviders(profile);
+  } catch {
+    return; // unreadable config.yaml — leave the desktop store as-is
+  }
+  if (agentProviders.length === 0) return;
+
+  let env: Record<string, string> | null = null;
+  for (const ap of agentProviders) {
+    const name = (ap.name || "").trim();
+    const baseUrl = (ap.baseUrl || "").trim();
+    if (!name || !baseUrl) continue;
+    if (expectedEnvKeyForUrl(baseUrl) !== CUSTOM_API_KEY_ENV) continue;
+
+    upsertCustomProviderRecordOnly(profile, { name, baseUrl });
+
+    const derived = customProviderEnvKey(name);
+    if (ap.keyEnv && ap.keyEnv !== derived) {
+      try {
+        env = env ?? readEnv(profile);
+        const value = (env[ap.keyEnv] || "").trim();
+        if (value && !(env[derived] || "").trim()) {
+          setEnvValue(derived, value, profile);
+          env[derived] = value;
+        }
+      } catch {
+        /* best-effort aliasing — key stays reachable via the terminal */
+      }
+    }
+  }
+}
+
+/** Upsert into providers.json only — no config.yaml mirror. Used by the
+ *  import path, where config.yaml is the side that already has the entry. */
+function upsertCustomProviderRecordOnly(
   profile: string | undefined,
   input: { name: string; baseUrl: string },
 ): CustomProviderRecord | null {
@@ -95,6 +145,9 @@ export function upsertCustomProvider(
 
   let record: CustomProviderRecord;
   if (existing) {
+    if (existing.name === name && existing.baseUrl === baseUrl) {
+      return existing; // unchanged — don't rewrite the file on every read
+    }
     // Preserve id/createdAt; refresh the display name + base URL.
     existing.name = name;
     existing.baseUrl = baseUrl;
@@ -107,13 +160,60 @@ export function upsertCustomProvider(
   return record;
 }
 
-/** Remove a custom provider by name (matched via its derived env-key anchor). */
+/** All custom providers configured for `profile` (empty when none/no file).
+ *  Terminal-added providers from the agent's config.yaml are imported first,
+ *  so the returned list covers both origins. */
+export function listCustomProviders(profile?: string): CustomProviderRecord[] {
+  const normalized = normalizeProfile(profile);
+  // Keyed first-party brands (Hermes One) must exist as named `providers:`
+  // entries so gateway model switches can route them by slug.
+  mirrorFirstPartyAgentProviders(normalized);
+  importAgentConfigProviders(normalized);
+  return readProvidersFile(normalized).providers;
+}
+
+/**
+ * Create or update a custom provider by identity. Records are keyed by their
+ * derived env-key name (`customProviderEnvKey(name)`) — the same anchor the
+ * runtime uses to look the API key back up — so a re-save with the same name
+ * updates the base URL in place instead of duplicating. Blank name or base URL
+ * is a no-op (nothing durable to record yet).
+ */
+export function upsertCustomProvider(
+  profile: string | undefined,
+  input: { name: string; baseUrl: string },
+): CustomProviderRecord | null {
+  const normalized = normalizeProfile(profile);
+  const record = upsertCustomProviderRecordOnly(normalized, input);
+  if (record) {
+    // Mirror into the agent's config.yaml `providers:` dict so the terminal
+    // CLI (`hermes model`, `--provider <slug>`) sees the same provider. A
+    // terminal-origin entry is matched by its key_env/slug and patched in
+    // place, so this never duplicates.
+    try {
+      upsertAgentUserProvider(normalized, {
+        name: record.name,
+        baseUrl: record.baseUrl,
+        keyEnv: customProviderEnvKey(record.name),
+      });
+    } catch {
+      /* config.yaml unwritable — the desktop store is still consistent */
+    }
+  }
+  return record;
+}
+
+/** Remove a custom provider by name (matched via its derived env-key anchor).
+ *  Also removes the mirrored/originating entry from the agent's config.yaml
+ *  (both the `providers:` dict and the legacy `custom_providers:` list) so
+ *  the next read doesn't re-import it. */
 export function removeCustomProvider(
   profile: string | undefined,
   name: string,
 ): void {
   const normalized = normalizeProfile(profile);
-  const anchor = customProviderEnvKey((name || "").trim());
+  const trimmed = (name || "").trim();
+  const anchor = customProviderEnvKey(trimmed);
   const data = readProvidersFile(normalized);
   const next = data.providers.filter(
     (p) => customProviderEnvKey(p.name) !== anchor,
@@ -121,4 +221,10 @@ export function removeCustomProvider(
   if (next.length !== data.providers.length) {
     writeProvidersFile(normalized, { version: 1, providers: next });
   }
+  try {
+    removeAgentUserProvider(normalized, { name: trimmed, keyEnv: anchor });
+    removeAgentCustomProviderEntry(normalized, trimmed);
+  } catch {
+    /* best-effort — a stale config.yaml entry re-imports harmlessly */
+  }
 }
diff --git a/src/preload/index.d.ts b/src/preload/index.d.ts
index 9c71b453e..ae5bf4000 100644
--- a/src/preload/index.d.ts
+++ b/src/preload/index.d.ts
@@ -15,8 +15,10 @@ import type { TokenBalancesResponse } from "../shared/tokens";
 import type { CustomProviderRecord } from "../shared/custom-providers";
 import type {
   DeviceCodeInfo,
+  EnsureHermesOneKeyResult,
   HermesAccount,
   HermesAccountUser,
+  HermesOneCreditsResult,
 } from "../shared/account";
 import type { AgentSyncResult, AgentSyncStatus } from "../shared/agent-sync";
 import type {
@@ -274,6 +276,8 @@ interface HermesAPI {
   onAccountLoginProgress: (callback: (chunk: string) => void) => () => void;
   getAccount: (profile?: string) => Promise<HermesAccount | null>;
   accountLogout: (profile?: string) => Promise<{ success: boolean }>;
+  ensureHermesOneKey: (profile?: string) => Promise<EnsureHermesOneKeyResult>;
+  getHermesOneCredits: () => Promise<HermesOneCreditsResult>;
 
   // Cloud agent sync (profiles ↔ signed-in Hermes One account)
   syncAgents: () => Promise<AgentSyncResult>;
diff --git a/src/preload/index.ts b/src/preload/index.ts
index 06e666429..418436e72 100644
--- a/src/preload/index.ts
+++ b/src/preload/index.ts
@@ -22,8 +22,10 @@ import type {
 import type { ChatToolEvent } from "../shared/chat-stream";
 import type {
   DeviceCodeInfo,
+  EnsureHermesOneKeyResult,
   HermesAccount,
   HermesAccountUser,
+  HermesOneCreditsResult,
 } from "../shared/account";
 import type { AgentSyncResult, AgentSyncStatus } from "../shared/agent-sync";
 import type { GpuPreferenceMode, GpuStatus } from "../shared/gpu";
@@ -209,6 +211,13 @@ const hermesAPI = {
     ipcRenderer.invoke("hermes-account-get", profile),
   accountLogout: (profile?: string): Promise<{ success: boolean }> =>
     ipcRenderer.invoke("hermes-account-logout", profile),
+  // Auto-provision a Hermes One Inference key from the signed-in account
+  // (no-op when the profile already has one), and read the account's
+  // AI-credit balance for the Providers account card.
+  ensureHermesOneKey: (profile?: string): Promise<EnsureHermesOneKeyResult> =>
+    ipcRenderer.invoke("hermesone-ensure-key", profile),
+  getHermesOneCredits: (): Promise<HermesOneCreditsResult> =>
+    ipcRenderer.invoke("hermesone-credits"),
 
   // Cloud agent sync (profiles ↔ signed-in Hermes One account)
   syncAgents: (): Promise<AgentSyncResult> =>
diff --git a/src/renderer/src/assets/icons/index.tsx b/src/renderer/src/assets/icons/index.tsx
index 77931f85c..5e7d61c38 100644
--- a/src/renderer/src/assets/icons/index.tsx
+++ b/src/renderer/src/assets/icons/index.tsx
@@ -29,7 +29,8 @@ export {
   Send,
   Settings,
   Signal,
-  Sparkles,
+  Drama,
+  Wand,
   Sun,
   Timer,
   User,
diff --git a/src/renderer/src/assets/main.css b/src/renderer/src/assets/main.css
index 18b64953d..4726e91f8 100644
--- a/src/renderer/src/assets/main.css
+++ b/src/renderer/src/assets/main.css
@@ -2095,11 +2095,17 @@ body:has(.shell-vibrant),
   z-index: 1000;
   display: flex;
   flex-direction: column;
-  padding: 4px;
-  border: 1px solid var(--border-bright);
-  border-radius: var(--radius-md);
-  background: var(--bg-elevated);
-  box-shadow: 0 12px 32px rgba(0, 0, 0, 0.36);
+  padding: 6px;
+  border-radius: var(--radius-lg);
+  /* Light-based, stroke-free: depth from a frosted material, a top inset
+     highlight, and layered ambient shadow — no hard 1px border. */
+  background: color-mix(in srgb, var(--bg-secondary) 97%, transparent);
+  backdrop-filter: blur(30px) saturate(1.5);
+  -webkit-backdrop-filter: blur(30px) saturate(1.5);
+  box-shadow:
+    inset 0 1px 0 rgba(255, 255, 255, 0.06),
+    0 24px 60px -18px rgba(0, 0, 0, 0.55),
+    0 8px 24px -14px rgba(0, 0, 0, 0.4);
   font-family: var(--font-sans);
   /* Open animation scales from the anchored top-left corner. */
   transform-origin: top left;
@@ -2131,9 +2137,9 @@ body:has(.shell-vibrant),
   align-items: center;
   gap: 10px;
   width: 100%;
-  padding: 7px 10px;
+  padding: 8px 10px;
   border: none;
-  border-radius: var(--radius-sm, 6px);
+  border-radius: var(--radius-md);
   background: none;
   color: var(--text-primary);
   cursor: pointer;
@@ -2145,6 +2151,16 @@ body:has(.shell-vibrant),
     color var(--transition);
 }
 
+/* Active "Move to project" location: a soft accent fill, not a stroke. */
+.sidebar-session-menu-item.active-project {
+  background: var(--accent-subtle);
+  color: var(--accent-text);
+}
+
+.sidebar-session-menu-item.active-project svg {
+  color: var(--accent-text);
+}
+
 .sidebar-session-menu-item svg {
   flex-shrink: 0;
   color: var(--text-secondary);
@@ -2177,8 +2193,9 @@ body:has(.shell-vibrant),
 
 .sidebar-session-menu-divider {
   height: 1px;
-  margin: 4px 6px;
-  background: var(--border-bright);
+  margin: 5px 8px;
+  /* Soft hairline instead of a hard stroke. */
+  background: color-mix(in srgb, var(--text-primary) 7%, transparent);
 }
 
 .sidebar-session-menu-back {
@@ -2656,16 +2673,21 @@ body:has(.shell-vibrant),
   animation: profileSwitchOverlayIn 0.14s ease;
 }
 .profile-switch-modal {
-  width: 360px;
+  width: 480px;
   max-width: 100%;
-  max-height: 70vh;
+  /* Fixed size: the panel stays the same dimensions whatever the search
+     filters down to — the list scrolls/leaves empty space rather than the
+     modal resizing. Caps to the viewport on short screens. */
+  height: 560px;
+  max-height: 82vh;
   display: flex;
   flex-direction: column;
-  padding: 8px;
+  overflow: hidden;
+  /* Light-based, stroke-free: no outer border — depth comes from the frosted
+     material, a top inset highlight, and layered ambient shadow. */
   background: color-mix(in srgb, var(--bg-secondary) 97%, transparent);
   backdrop-filter: blur(30px) saturate(1.5);
   -webkit-backdrop-filter: blur(30px) saturate(1.5);
-  border: 0.5px solid var(--border);
   border-radius: var(--radius-lg);
   box-shadow:
     inset 0 1px 0 rgba(255, 255, 255, 0.06),
@@ -2673,19 +2695,60 @@ body:has(.shell-vibrant),
     0 8px 24px -12px rgba(0, 0, 0, 0.45);
   animation: profileSwitchModalIn 0.16s cubic-bezier(0.16, 1, 0.3, 1);
 }
-.profile-switch-title {
-  padding: 8px 10px 8px;
-  font-size: 10px;
-  font-weight: 700;
-  text-transform: uppercase;
-  letter-spacing: 0.05em;
+/* Command-palette search header: icon + filter input + the ⌘P/Ctrl+P hint.
+   Separated from the list by a soft light hairline, not a hard stroke. */
+.profile-switch-search {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 14px 16px;
+  border-bottom: 1px solid color-mix(in srgb, var(--text-primary) 7%, transparent);
+}
+.profile-switch-search-icon {
+  flex-shrink: 0;
+  color: var(--text-muted);
+}
+.profile-switch-search-input {
+  flex: 1;
+  min-width: 0;
+  background: none;
+  border: none;
+  outline: none;
+  color: var(--text-primary);
+  font-size: 15px;
+  font-family: var(--font-sans);
+}
+.profile-switch-search-input::placeholder {
+  color: var(--text-muted);
+}
+.profile-switch-kbd {
+  flex-shrink: 0;
+  font-family: var(--font-mono);
+  font-size: 12px;
   color: var(--text-muted);
 }
 .profile-switch-list {
+  flex: 1;
+  min-height: 0;
   overflow-y: auto;
   display: flex;
   flex-direction: column;
   gap: 2px;
+  padding: 8px;
+}
+.profile-switch-group {
+  padding: 12px 12px 6px;
+  font-size: 10px;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  color: var(--text-muted);
+}
+.profile-switch-empty {
+  padding: 28px 16px;
+  text-align: center;
+  color: var(--text-muted);
+  font-size: 13px;
 }
 @keyframes profileSwitchOverlayIn {
   from {
@@ -2863,11 +2926,12 @@ body:has(.shell-vibrant),
 }
 
 .profile-menu-item {
-  display: flex;
+  display: grid;
+  grid-template-columns: 32px minmax(0, 160px) 1fr auto;
   align-items: center;
-  gap: 10px;
+  gap: 12px;
   width: 100%;
-  padding: 8px 10px;
+  padding: 8px 12px;
   background: none;
   border: none;
   border-radius: var(--radius-md);
@@ -2877,27 +2941,20 @@ body:has(.shell-vibrant),
   transition: background var(--transition);
 }
 
-.profile-menu-item:hover {
+/* Pointer hover and keyboard highlight share one resting tint; the active
+   profile keeps its accent fill and wins when it is also highlighted. */
+.profile-menu-item:hover,
+.profile-menu-item.highlighted {
   background: var(--bg-tertiary);
 }
 
-.profile-menu-item.active {
+.profile-menu-item.active,
+.profile-menu-item.active.highlighted {
   background: var(--accent-subtle);
 }
 
-.profile-menu-info {
-  flex: 1;
-  display: flex;
-  flex-direction: column;
-  gap: 2px;
-  min-width: 0;
-}
-
 .profile-menu-name {
-  display: flex;
-  align-items: center;
-  gap: 6px;
-  font-size: 13px;
+  font-size: 14px;
   font-weight: 600;
   color: var(--text-primary);
   overflow: hidden;
@@ -2911,9 +2968,24 @@ body:has(.shell-vibrant),
   color: var(--text-muted);
 }
 
+.profile-menu-model {
+  font-family: var(--font-mono);
+  font-size: 12.5px;
+  color: var(--text-muted);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.profile-menu-status {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 12px;
+}
+
 .profile-menu-gateway {
   flex-shrink: 0;
-  margin-left: auto;
   width: 8px;
   height: 8px;
   border-radius: 50%;
@@ -2942,14 +3014,12 @@ body:has(.shell-vibrant),
 .profile-menu-manage {
   display: flex;
   align-items: center;
-  gap: 8px;
+  gap: 10px;
   width: 100%;
-  margin-top: 6px;
-  padding: 9px 10px;
+  padding: 13px 16px;
   background: none;
   border: none;
-  border-top: 1px solid var(--border);
-  border-radius: 0 0 var(--radius-md) var(--radius-md);
+  border-top: 1px solid color-mix(in srgb, var(--text-primary) 7%, transparent);
   color: var(--text-secondary);
   font-size: 13px;
   font-weight: 500;
@@ -7447,22 +7517,25 @@ body:has(.shell-vibrant),
   width: 560px;
   border-radius: var(--radius-xl);
 }
+/* Header + footer are separated from the body by hairline dividers (reference),
+   so the three zones read as distinct without heavy chrome. */
 .provider-modal .models-modal-header {
-  padding: 28px 32px 0;
-  border-bottom: none;
+  padding: 18px 22px;
+  border-bottom: 1px solid var(--border);
 }
 .provider-modal .models-modal-body {
-  padding: 24px 32px 8px;
+  padding: 22px;
   gap: 0;
 }
 .provider-modal .models-modal-footer {
-  padding: 20px 32px 24px;
-  margin-top: 8px;
+  padding: 16px 22px;
+  margin-top: 0;
+  border-top: 1px solid var(--border);
 }
-/* Rounder inputs + buttons inside this modal */
+/* Inputs + buttons inside this modal */
 .provider-modal .input {
-  padding: 13px 16px;
-  border-radius: var(--radius-lg);
+  padding: 11px 14px;
+  border-radius: var(--radius-md);
   font-size: 14px;
 }
 .provider-modal .btn {
@@ -7488,15 +7561,132 @@ body:has(.shell-vibrant),
   display: inline-flex;
   align-items: center;
   justify-content: center;
-  width: 48px;
-  height: 48px;
-  border: 1px solid var(--border-bright);
-  border-radius: var(--radius-lg);
+  width: 40px;
+  height: 40px;
+  border: none;
+  border-radius: var(--radius-md);
+  background: var(--bg-elevated);
+  flex-shrink: 0;
+}
+
+/* Redesigned branded config-modal header: logo tile + name + status pill. */
+.provider-modal .provider-modal-header {
+  align-items: center;
+}
+.provider-modal-heading {
+  display: flex;
+  align-items: center;
+  gap: 14px;
+  min-width: 0;
+}
+.provider-modal-name {
+  font-size: 20px;
+  font-weight: 700;
+  color: var(--text-primary);
+  white-space: nowrap;
+  flex-shrink: 0;
+}
+.provider-status-pill {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  flex-shrink: 0;
+  padding: 4px 10px;
+  border-radius: 999px;
+  font-size: 12.5px;
+  font-weight: 600;
+}
+.provider-status-pill-dot {
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  background: currentColor;
+  flex-shrink: 0;
+}
+.provider-status-pill-ok {
+  color: var(--success);
+  background: var(--success-bg);
+}
+.provider-status-pill-loading,
+.provider-status-pill-muted {
+  color: var(--text-muted);
+  background: var(--bg-elevated);
+}
+
+/* Labelled field block (API key). */
+.provider-field-block {
+  display: flex;
+  flex-direction: column;
+  gap: 9px;
+}
+.provider-field-label {
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--text-secondary);
+}
+.provider-field-meta {
+  margin: 1px 0 0;
+  font-size: 12px;
+  color: var(--text-muted);
+}
+
+/* API-key field: masked preview (or input) on the left, Show / Replace on the
+   right, inside one inset control — differentiated by fill only, no stroke. */
+.provider-key-field {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 10px 14px;
+  border: none;
+  border-radius: var(--radius-md);
   background: var(--bg-elevated);
+}
+.provider-key-field:focus-within {
+  background: var(--bg-hover);
+}
+.provider-key-input,
+.provider-key-masked {
+  flex: 1;
+  min-width: 0;
+  font-family: var(--font-mono, monospace);
+  font-size: 13px;
+  color: var(--text-primary);
+  letter-spacing: 0.02em;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.provider-key-input {
+  border: none;
+  background: transparent;
+  padding: 0;
+  outline: none;
+}
+.provider-key-actions {
+  display: flex;
+  align-items: center;
+  gap: 10px;
   flex-shrink: 0;
 }
+.provider-key-sep {
+  color: var(--border-bright);
+  font-size: 13px;
+}
+.provider-link-btn {
+  border: none;
+  background: transparent;
+  padding: 0;
+  cursor: pointer;
+  font-size: 13px;
+  font-weight: 500;
+  color: var(--accent-text);
+}
+.provider-link-btn:hover {
+  color: var(--accent-hover);
+  text-decoration: underline;
+}
 
-/* Key input row: leading icon + input + Show */
+/* Custom-provider modal still uses the old leading-icon key row. */
 .provider-key-row {
   display: flex;
   align-items: center;
@@ -7560,22 +7750,26 @@ body:has(.shell-vibrant),
   inset: 0;
   z-index: 10;
 }
+/* Menu is elevation-based (shadow), no stroke; scrolls internally when the
+   provider list is long. */
 .logo-select-menu {
   position: absolute;
   top: calc(100% + 6px);
   left: 0;
   right: 0;
   z-index: 11;
-  max-height: 260px;
+  max-height: 240px;
   overflow-y: auto;
   padding: 6px;
   display: flex;
   flex-direction: column;
   gap: 2px;
   background: var(--bg-elevated);
-  border: 1px solid var(--border-bright);
+  border: none;
   border-radius: var(--radius-lg);
-  box-shadow: 0 12px 32px rgba(0, 0, 0, 0.4);
+  box-shadow:
+    0 1px 0 rgba(255, 255, 255, 0.05) inset,
+    0 16px 40px -8px rgba(0, 0, 0, 0.55);
 }
 .logo-select-option {
   display: flex;
@@ -7586,7 +7780,7 @@ body:has(.shell-vibrant),
   background: transparent;
   border-radius: var(--radius-md);
   color: var(--text-primary);
-  font-size: 14px;
+  font-size: 13px;
   cursor: pointer;
   text-align: left;
   width: 100%;
@@ -7599,6 +7793,60 @@ body:has(.shell-vibrant),
   font-weight: 600;
 }
 
+/* ===== "Select default model" picker — light-based (no strokes) ===== */
+.models-modal.model-select-modal {
+  width: 560px;
+  border: none;
+  border-radius: var(--radius-xl);
+  /* Let the provider dropdown extend past the modal instead of being clipped
+     (the base .models-modal has overflow:hidden, which hid the lower rows and
+     killed scrolling). The frosted background keeps its rounded shape. */
+  overflow: visible;
+}
+.model-select-modal .models-modal-header,
+.model-select-modal .models-modal-footer {
+  border: none;
+  padding: 20px 24px;
+}
+.model-select-modal .models-modal-body {
+  padding: 8px 24px 20px;
+  gap: 18px;
+}
+.model-select-title {
+  font-size: 20px;
+  font-weight: 700;
+}
+.model-select-modal .settings-field-label {
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--text-secondary);
+  margin-bottom: 9px;
+  display: block;
+}
+/* Provider trigger + model <select>: filled controls, no borders. */
+.model-select-modal .logo-select-trigger,
+.model-select-modal select.input {
+  border: none;
+  background: var(--bg-elevated);
+  border-radius: var(--radius-md);
+  padding: 12px 14px;
+  font-size: 14px;
+}
+.model-select-modal .logo-select.open .logo-select-trigger,
+.model-select-modal .logo-select-trigger:hover,
+.model-select-modal select.input:hover {
+  background: var(--bg-hover);
+}
+/* No focus stroke — the open/hover fill is the affordance. */
+.model-select-modal .logo-select-trigger:focus,
+.model-select-modal .logo-select-trigger:focus-visible,
+.model-select-modal select.input:focus,
+.model-select-modal select.input:focus-visible {
+  border: none;
+  outline: none;
+  box-shadow: none;
+}
+
 /* Custom-provider modal: base URL + key as one connected control (no gap).
    Inner inputs are borderless; a single divider separates the two rows. */
 .provider-key-group {
@@ -7652,20 +7900,20 @@ body:has(.shell-vibrant),
 
 /* Models section */
 .provider-models {
-  margin-top: 28px;
+  margin-top: 22px;
 }
 .provider-models-head {
   display: flex;
   align-items: baseline;
   justify-content: space-between;
   gap: 12px;
-  margin-bottom: 14px;
+  margin-bottom: 12px;
 }
+/* Sentence-case label matching the "API key" field label, not an uppercase
+   micro-heading (reference). */
 .provider-models-title {
   font-size: 13px;
-  font-weight: 700;
-  letter-spacing: 0.06em;
-  text-transform: uppercase;
+  font-weight: 600;
   color: var(--text-secondary);
 }
 .provider-models-hint {
@@ -7678,26 +7926,36 @@ body:has(.shell-vibrant),
   display: flex;
   flex-wrap: wrap;
   gap: 8px;
-  margin-bottom: 14px;
+  margin-bottom: 0;
 }
+/* Chips + add/more pills are differentiated by fill only — no strokes, all
+   "light-based" (elevation). */
 .provider-model-chip {
   display: inline-flex;
   align-items: center;
-  gap: 5px;
+  gap: 6px;
   max-width: 100%;
-  padding: 3px 6px 3px 10px;
-  border: 1px solid var(--border-bright);
-  border-radius: var(--radius-sm);
+  padding: 5px 7px 5px 11px;
+  border: none;
+  border-radius: var(--radius-md);
   background: var(--bg-elevated);
 }
+/* Chip label doubles as an "edit this model" button — reset button chrome. */
 .provider-model-chip-label {
+  border: none;
+  background: transparent;
+  padding: 0;
+  cursor: pointer;
   font-family: var(--font-mono, monospace);
-  font-size: 12px;
+  font-size: 11px;
   color: var(--text-primary);
   overflow: hidden;
   text-overflow: ellipsis;
   white-space: nowrap;
 }
+.provider-model-chip-label:hover {
+  color: var(--accent-text);
+}
 .provider-model-chip-del,
 .provider-model-chip-edit {
   display: inline-flex;
@@ -7717,21 +7975,49 @@ body:has(.shell-vibrant),
   color: var(--text-primary);
 }
 
-/* Add row */
-.provider-models-add {
-  display: flex;
-  align-items: stretch;
-  gap: 10px;
+/* Inline add + "+N more" — filled ghost pills (no dashed stroke) that read as
+   actions via a lighter fill on hover. */
+.provider-model-add-pill,
+.provider-model-more-pill {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 6px 12px 6px 10px;
+  border: none;
+  border-radius: var(--radius-md);
+  background: color-mix(in srgb, var(--bg-elevated) 60%, transparent);
+  color: var(--text-secondary);
+  font-size: 11px;
+  font-weight: 500;
+  cursor: pointer;
+  transition:
+    color 0.15s ease,
+    background 0.15s ease;
 }
-.provider-models-add .input {
-  flex: 1;
-  min-width: 0;
+.provider-model-more-pill {
+  padding: 6px 12px;
+}
+.provider-model-add-pill:hover,
+.provider-model-more-pill:hover {
+  color: var(--text-primary);
+  background: var(--bg-hover);
+}
+.provider-model-chip-input {
+  padding-right: 9px;
 }
-.provider-models-add-btn {
+.provider-model-add-input {
+  border: none;
+  background: transparent;
+  outline: none;
+  padding: 0;
+  min-width: 130px;
+  font-family: var(--font-mono, monospace);
+  font-size: 11px;
+  color: var(--text-primary);
+}
+.provider-model-chip-busy {
+  color: var(--text-muted);
   flex-shrink: 0;
-  gap: 5px;
-  padding-left: 20px;
-  padding-right: 20px;
 }
 
 .oauth-signin-btn {
@@ -14205,6 +14491,13 @@ body:has(.shell-vibrant),
   max-width: none;
 }
 
+/* The search box is a direct modal child (between header and body), so give it
+   the same horizontal inset as the header/body — otherwise it runs edge to edge
+   and reads as un-margined against the padded content. */
+.models-registry-modal .models-search {
+  margin: 4px 20px 16px;
+}
+
 .models-registry-body {
   max-height: 60vh;
   overflow-y: auto;
diff --git a/src/renderer/src/components/ProviderKeysSection.tsx b/src/renderer/src/components/ProviderKeysSection.tsx
index 99c92beb2..7e9d8b70b 100644
--- a/src/renderer/src/components/ProviderKeysSection.tsx
+++ b/src/renderer/src/components/ProviderKeysSection.tsx
@@ -10,7 +10,11 @@ import {
   X,
 } from "lucide-react";
 import type { FieldDef } from "../constants";
-import { providerRouteForEnvKey } from "../constants";
+import {
+  providerKeyRank,
+  providerNameForEnvKey,
+  providerRouteForEnvKey,
+} from "../constants";
 import { useDiscoveredModels } from "../hooks/useDiscoveredModels";
 import {
   CUSTOM_API_KEY_ENV,
@@ -76,6 +80,18 @@ interface Props {
   profile?: string;
 }
 
+// Masked preview of a stored API key: keep the leading scheme segment (up to
+// and including the first hyphen, e.g. `hs-`) and the last 4 chars, dots in
+// between — enough to recognise the key without revealing it.
+function maskKeyPreview(raw: string): string {
+  const k = (raw || "").trim();
+  if (!k) return "";
+  if (k.length <= 8) return "•".repeat(Math.max(k.length, 6));
+  const dash = k.indexOf("-");
+  const prefix = dash > 0 && dash <= 6 ? k.slice(0, dash + 1) : k.slice(0, 2);
+  return `${prefix}${"•".repeat(10)}${k.slice(-4)}`;
+}
+
 // Best-effort display name recovered from an orphaned `CUSTOM_PROVIDER_<X>_KEY`
 // env var (a provider whose key was saved but whose identity record/models were
 // never persisted). It round-trips: `customProviderEnvKey(envKeyToName(k)) === k`,
@@ -94,11 +110,19 @@ const envKeyToName = (envKey: string): string =>
 // `providerRouteForEnvKey`: native providers keep their slug, OpenAI-compatible
 // ones save as `custom` + base URL. Add-input autocompletes off live provider
 // discovery when a key is present.
+interface ProviderKeyStatus {
+  tone: "ok" | "loading" | "muted";
+  text: string;
+}
+
 function ProviderModelsManager({
   envKey,
   apiKey,
   route: routeOverride,
   providerLabel,
+  showStatus = true,
+  onStatusChange,
+  onModelCountChange,
 }: {
   // Anchor: either an LLM-provider env key (route derived) or an explicit route
   // (custom endpoints, where no fixed env key maps to the base URL).
@@ -109,6 +133,14 @@ function ProviderModelsManager({
   // keys their API key (`CUSTOM_PROVIDER_<label>_KEY`) — only set for named
   // custom providers.
   providerLabel?: string;
+  // When false, the inline status line is hidden (the branded config modal
+  // lifts it into the header pill instead). Defaults to true for the custom
+  // modal, which has no header pill.
+  showStatus?: boolean;
+  // Report the derived key-verification status / saved-model count up to the
+  // parent so a header can render them without duplicating the discovery hook.
+  onStatusChange?: (status: ProviderKeyStatus) => void;
+  onModelCountChange?: (count: number) => void;
 }): React.JSX.Element {
   const { t } = useI18n();
   const route = useMemo(
@@ -119,6 +151,13 @@ function ProviderModelsManager({
   const [loading, setLoading] = useState(true);
   const [modelId, setModelId] = useState("");
   const [busy, setBusy] = useState(false);
+  // The add-input is revealed by the "+ Add model ID" pill; hidden by default
+  // so the models row stays compact.
+  const [adding, setAdding] = useState(false);
+  // Only the first N models render by default; the rest collapse behind a
+  // "+N more" toggle so a provider with a long catalog doesn't flood the modal.
+  const [showAllModels, setShowAllModels] = useState(false);
+  const MODELS_COLLAPSED = 10;
   // Per-model definition editor (display name + context window). Keyed by model
   // id, so a change here applies wherever that id is attached.
   const [editing, setEditing] = useState<LibModel | null>(null);
@@ -184,6 +223,7 @@ function ProviderModelsManager({
         providerLabel,
       );
       setModelId("");
+      setAdding(false);
       await reload();
     } finally {
       setBusy(false);
@@ -218,7 +258,7 @@ function ProviderModelsManager({
   // accepted the key and returned a model list, so "verified" is truthful;
   // providers that don't expose /models fall back to a plain "Connected".
   const hasKey = !!apiKey.trim();
-  const status: { tone: "ok" | "loading" | "muted"; text: string } = !hasKey
+  const status: ProviderKeyStatus = !hasKey
     ? { tone: "muted", text: t("providers.keys.status.needsKey") }
     : discovery.status === "loading"
       ? { tone: "loading", text: t("providers.keys.status.verifying") }
@@ -231,16 +271,31 @@ function ProviderModelsManager({
             ? { tone: "muted", text: t("providers.keys.status.failed") }
             : { tone: "ok", text: t("providers.keys.status.connected") };
 
+  // Report status + model count up to the config-modal header (which shows the
+  // verification pill + "used by N models"). Destructure to primitives so the
+  // effect only fires on real changes, not on every object re-creation.
+  const { tone: statusTone, text: statusText } = status;
+  useEffect(() => {
+    onStatusChange?.({ tone: statusTone, text: statusText });
+  }, [statusTone, statusText, onStatusChange]);
+  useEffect(() => {
+    if (!loading) onModelCountChange?.(models.length);
+  }, [models.length, loading, onModelCountChange]);
+
   return (
     <>
-      <div className={`provider-key-status provider-key-status-${status.tone}`}>
-        {status.tone === "loading" ? (
-          <Loader2 size={12} className="spin" aria-hidden />
-        ) : (
-          <span className="provider-key-status-dot" aria-hidden />
-        )}
-        <span>{status.text}</span>
-      </div>
+      {showStatus && (
+        <div
+          className={`provider-key-status provider-key-status-${status.tone}`}
+        >
+          {status.tone === "loading" ? (
+            <Loader2 size={12} className="spin" aria-hidden />
+          ) : (
+            <span className="provider-key-status-dot" aria-hidden />
+          )}
+          <span>{status.text}</span>
+        </div>
+      )}
 
       <div className="provider-models">
         <div className="provider-models-head">
@@ -254,9 +309,9 @@ function ProviderModelsManager({
             <Loader2 size={13} className="spin" /> {t("common.loading")}
           </p>
         ) : (
-          models.length > 0 && (
-            <div className="provider-models-chips">
-              {models.map((m) => (
+          <div className="provider-models-chips">
+            {(showAllModels ? models : models.slice(0, MODELS_COLLAPSED)).map(
+              (m) => (
                 <span
                   key={m.id}
                   className="provider-model-chip"
@@ -266,14 +321,13 @@ function ProviderModelsManager({
                       : m.model
                   }
                 >
-                  <span className="provider-model-chip-label">{m.model}</span>
                   <button
                     type="button"
-                    className="provider-model-chip-edit"
+                    className="provider-model-chip-label"
                     onClick={() => openEditor(m)}
-                    aria-label={t("common.edit")}
+                    title={t("common.edit")}
                   >
-                    <Pencil size={12} />
+                    {m.model}
                   </button>
                   <button
                     type="button"
@@ -284,42 +338,84 @@ function ProviderModelsManager({
                     <X size={13} />
                   </button>
                 </span>
-              ))}
-            </div>
-          )
-        )}
+              ),
+            )}
 
-        <div className="provider-models-add">
-          <input
-            className="input"
-            list={listId}
-            value={modelId}
-            // Model IDs never contain whitespace — strip it as typed/pasted so
-            // "hello there" can't be saved as a bogus model.
-            onChange={(e) => setModelId(e.target.value.replace(/\s+/g, ""))}
-            onKeyDown={(e) => {
-              if (e.key === "Enter") {
-                e.preventDefault();
-                void add();
-              }
-            }}
-            placeholder={t("providers.models.addPlaceholder")}
-          />
-          <datalist id={listId}>
-            {discovery.models.map((mm) => (
-              <option key={mm} value={mm} />
-            ))}
-          </datalist>
-          <button
-            type="button"
-            className="btn btn-secondary provider-models-add-btn"
-            onClick={() => void add()}
-            disabled={busy || !modelId.trim()}
-          >
-            {busy ? <Loader2 size={14} className="spin" /> : <Plus size={14} />}{" "}
-            {t("common.add")}
-          </button>
-        </div>
+            {/* Collapse a long catalog behind a "+N more" toggle. */}
+            {!showAllModels && models.length > MODELS_COLLAPSED && (
+              <button
+                type="button"
+                className="provider-model-more-pill"
+                onClick={() => setShowAllModels(true)}
+              >
+                {t("providers.models.more", {
+                  count: models.length - MODELS_COLLAPSED,
+                })}
+              </button>
+            )}
+            {showAllModels && models.length > MODELS_COLLAPSED && (
+              <button
+                type="button"
+                className="provider-model-more-pill"
+                onClick={() => setShowAllModels(false)}
+              >
+                {t("providers.models.less")}
+              </button>
+            )}
+
+            {adding ? (
+              <span className="provider-model-chip provider-model-chip-input">
+                <input
+                  className="provider-model-add-input"
+                  list={listId}
+                  autoFocus
+                  value={modelId}
+                  // Model IDs never contain whitespace — strip it as typed/
+                  // pasted so "hello there" can't be saved as a bogus model.
+                  onChange={(e) =>
+                    setModelId(e.target.value.replace(/\s+/g, ""))
+                  }
+                  onKeyDown={(e) => {
+                    if (e.key === "Enter") {
+                      e.preventDefault();
+                      void add();
+                    } else if (e.key === "Escape") {
+                      setModelId("");
+                      setAdding(false);
+                    }
+                  }}
+                  onBlur={() => {
+                    // Commit a typed id on blur; otherwise collapse the input.
+                    if (modelId.trim()) void add();
+                    else setAdding(false);
+                  }}
+                  placeholder={t("providers.models.addModelId")}
+                />
+                <datalist id={listId}>
+                  {discovery.models.map((mm) => (
+                    <option key={mm} value={mm} />
+                  ))}
+                </datalist>
+                {busy && (
+                  <Loader2
+                    size={13}
+                    className="spin provider-model-chip-busy"
+                    aria-hidden
+                  />
+                )}
+              </span>
+            ) : (
+              <button
+                type="button"
+                className="provider-model-add-pill"
+                onClick={() => setAdding(true)}
+              >
+                <Plus size={13} aria-hidden />
+                {t("providers.models.addModelId")}
+              </button>
+            )}
+          </div>
+        )}
       </div>
 
       {editing && (
@@ -407,6 +503,13 @@ export function ProviderKeysSection({
   const [pickerOpen, setPickerOpen] = useState(false);
   const [search, setSearch] = useState("");
   const [editing, setEditing] = useState<FieldDef | null>(null);
+  // Branded config modal: whether the API-key field is in edit mode (a fresh
+  // provider with no key, or the user clicked Replace) vs. the masked preview.
+  const [replacingKey, setReplacingKey] = useState(false);
+  // Verification status + saved-model count reported up by the models manager,
+  // shown in the modal header pill and the "used by N models" meta line.
+  const [editStatus, setEditStatus] = useState<ProviderKeyStatus | null>(null);
+  const [editModelCount, setEditModelCount] = useState(0);
   // Custom OpenAI-compatible provider being configured (null = closed).
   // Empty name+baseUrl = a brand-new custom provider.
   const [customEditing, setCustomEditing] = useState<{
@@ -422,9 +525,20 @@ export function ProviderKeysSection({
   >([]);
 
   // The generic "Custom" env key is handled by the dedicated custom flow, not
-  // as a normal key card — drop it from the key-based lists.
+  // as a normal key card — drop it from the key-based lists. Well-known
+  // providers are ordered first (Hermes One leads, AIML last) via a stable
+  // sort on `providerKeyRank`, so the cards + Add-provider picker aren't
+  // ordered by the FieldDef declaration order.
   const keyItems = useMemo(
-    () => items.filter((f) => f.key !== CUSTOM_API_KEY_ENV),
+    () =>
+      items
+        .filter((f) => f.key !== CUSTOM_API_KEY_ENV)
+        .map((f, i) => ({ f, i }))
+        .sort(
+          (a, b) =>
+            providerKeyRank(a.f.key) - providerKeyRank(b.f.key) || a.i - b.i,
+        )
+        .map((x) => x.f),
     [items],
   );
   const isSet = useCallback(
@@ -437,9 +551,17 @@ export function ProviderKeysSection({
   );
   const available = useMemo(() => {
     const q = search.trim().toLowerCase();
-    return keyItems.filter(
-      (f) => !isSet(f.key) && (!q || t(f.label).toLowerCase().includes(q)),
-    );
+    // Match both the displayed provider name and the full FieldDef label, so
+    // searching "hermes" or "api key" both work.
+    const matches = (f: FieldDef): boolean => {
+      if (!q) return true;
+      const name = providerNameForEnvKey(f.key);
+      return (
+        (name !== null && t(name).toLowerCase().includes(q)) ||
+        t(f.label).toLowerCase().includes(q)
+      );
+    };
+    return keyItems.filter((f) => !isSet(f.key) && matches(f));
   }, [keyItems, isSet, search, t]);
 
   // Load configured custom providers: the authoritative `providers.json` records
@@ -508,9 +630,19 @@ export function ProviderKeysSection({
 
   function openConfig(field: FieldDef): void {
     setPickerOpen(false);
+    // Start in preview mode when a key already exists; in edit mode otherwise.
+    setReplacingKey(!isSet(field.key));
+    setEditStatus(null);
+    setEditModelCount(0);
     setEditing(field);
   }
 
+  function closeConfig(): void {
+    if (editing) void onBlur(editing.key);
+    setEditing(null);
+    setReplacingKey(false);
+  }
+
   function openCustom(name: string, baseUrl: string): void {
     setPickerOpen(false);
     setCustomEditing({ name, baseUrl });
@@ -559,7 +691,9 @@ export function ProviderKeysSection({
             <BrandLogo provider={field.key} size={22} />
             <span className="provider-config-card-body">
               <span className="provider-config-card-title">
-                {t(field.label)}
+                {/* A list of providers, so just the name — the "API Key"
+                    suffix of the FieldDef label is noise here. */}
+                {t(providerNameForEnvKey(field.key) ?? field.label)}
               </span>
               <span className="provider-config-card-sub">
                 {visibleKeys.has(field.key)
@@ -650,7 +784,7 @@ export function ProviderKeysSection({
                     <BrandLogo provider={field.key} size={22} />
                     <span className="provider-picker-item-body">
                       <span className="provider-picker-item-title">
-                        {t(field.label)}
+                        {t(providerNameForEnvKey(field.key) ?? field.label)}
                       </span>
                       <span className="provider-picker-item-hint">
                         {t(field.hint)}
@@ -681,84 +815,143 @@ export function ProviderKeysSection({
       )}
 
       {/* Config: enter / edit / remove a provider's key */}
-      {editing && (
-        <div className="models-modal-overlay" onClick={() => setEditing(null)}>
-          <div
-            className="models-modal provider-modal"
-            onClick={(e) => e.stopPropagation()}
-          >
-            <div className="models-modal-header">
-              <h2 className="models-modal-title provider-modal-title">
-                <span className="provider-modal-logo">
-                  <BrandLogo provider={editing.key} size={22} />
-                </span>
-                {t(editing.label)}
-                {savedKey === editing.key && (
-                  <span className="settings-saved">{t("common.saved")}</span>
-                )}
-              </h2>
-              <button
-                className="btn-ghost"
-                onClick={() => setEditing(null)}
-                aria-label={t("common.close")}
+      {editing &&
+        (() => {
+          const key = env[editing.key] || "";
+          const hasKey = !!key.trim();
+          const keyVisible = visibleKeys.has(editing.key);
+          // Show the editable input when replacing or when there's no key yet;
+          // otherwise a masked preview with Show / Replace actions.
+          const showInput = replacingKey || !hasKey;
+          const usedByText =
+            editModelCount === 1
+              ? t("providers.keys.usedByModel")
+              : editModelCount > 0
+                ? t("providers.keys.usedByModels", { count: editModelCount })
+                : t("providers.keys.noModelsYet");
+          return (
+            <div className="models-modal-overlay" onClick={closeConfig}>
+              <div
+                className="models-modal provider-modal"
+                onClick={(e) => e.stopPropagation()}
               >
-                <X size={18} />
-              </button>
-            </div>
-            <div className="models-modal-body">
-              <div className="settings-input-row provider-key-row">
-                <KeyRound className="provider-key-icon" size={16} aria-hidden />
-                <input
-                  className="input"
-                  autoFocus
-                  type={
-                    editing.type === "password" && !visibleKeys.has(editing.key)
-                      ? "password"
-                      : "text"
-                  }
-                  value={env[editing.key] || ""}
-                  onChange={(e) => onChange(editing.key, e.target.value)}
-                  onBlur={() => onBlur(editing.key)}
-                  placeholder={t(editing.label)}
-                />
-                {editing.type === "password" && (
+                <div className="models-modal-header provider-modal-header">
+                  <div className="provider-modal-heading">
+                    <span className="provider-modal-logo">
+                      <BrandLogo provider={editing.key} size={24} />
+                    </span>
+                    <span className="provider-modal-name">
+                      {t(providerNameForEnvKey(editing.key) ?? editing.label)}
+                    </span>
+                    {editStatus && (
+                      <span
+                        className={`provider-status-pill provider-status-pill-${editStatus.tone}`}
+                      >
+                        {editStatus.tone === "loading" ? (
+                          <Loader2 size={11} className="spin" aria-hidden />
+                        ) : (
+                          <span
+                            className="provider-status-pill-dot"
+                            aria-hidden
+                          />
+                        )}
+                        {editStatus.text}
+                      </span>
+                    )}
+                  </div>
                   <button
-                    className="btn-ghost settings-toggle-btn"
-                    onClick={() => onToggleVisibility(editing.key)}
+                    className="btn-ghost"
+                    onClick={closeConfig}
+                    aria-label={t("common.close")}
                   >
-                    {visibleKeys.has(editing.key)
-                      ? t("common.hide")
-                      : t("common.show")}
+                    <X size={18} />
                   </button>
-                )}
+                </div>
+
+                <div className="models-modal-body">
+                  <section className="provider-field-block">
+                    <label className="provider-field-label">
+                      {t("providers.keys.apiKeyLabel")}
+                    </label>
+                    <div className="provider-key-field">
+                      {showInput ? (
+                        <input
+                          className="provider-key-input"
+                          autoFocus
+                          type={
+                            editing.type === "password" && !keyVisible
+                              ? "password"
+                              : "text"
+                          }
+                          value={key}
+                          onChange={(e) =>
+                            onChange(editing.key, e.target.value)
+                          }
+                          onBlur={() => onBlur(editing.key)}
+                          placeholder={t(editing.label)}
+                        />
+                      ) : (
+                        <span className="provider-key-masked">
+                          {keyVisible ? key : maskKeyPreview(key)}
+                        </span>
+                      )}
+                      <div className="provider-key-actions">
+                        {editing.type === "password" && (
+                          <button
+                            type="button"
+                            className="provider-link-btn"
+                            onClick={() => onToggleVisibility(editing.key)}
+                          >
+                            {keyVisible
+                              ? t("providers.keys.hide")
+                              : t("providers.keys.show")}
+                          </button>
+                        )}
+                        {hasKey && !showInput && (
+                          <>
+                            <span className="provider-key-sep" aria-hidden>
+                              |
+                            </span>
+                            <button
+                              type="button"
+                              className="provider-link-btn"
+                              onClick={() => setReplacingKey(true)}
+                            >
+                              {t("providers.keys.replace")}
+                            </button>
+                          </>
+                        )}
+                      </div>
+                    </div>
+                    <p className="provider-field-meta">{usedByText}</p>
+                  </section>
+
+                  <ProviderModelsManager
+                    envKey={editing.key}
+                    apiKey={key}
+                    showStatus={false}
+                    onStatusChange={setEditStatus}
+                    onModelCountChange={setEditModelCount}
+                  />
+                </div>
+
+                <div className="models-modal-footer">
+                  {isSet(editing.key) && (
+                    <button
+                      className="btn btn-ghost btn-sm provider-remove-btn"
+                      onClick={() => void removeAndClose(editing)}
+                    >
+                      {t("providers.keys.remove")}
+                    </button>
+                  )}
+                  <button className="btn btn-primary" onClick={closeConfig}>
+                    {t("common.done")}
+                  </button>
+                </div>
               </div>
-              <ProviderModelsManager
-                envKey={editing.key}
-                apiKey={env[editing.key] || ""}
-              />
             </div>
-            <div className="models-modal-footer">
-              {isSet(editing.key) && (
-                <button
-                  className="btn btn-ghost btn-sm provider-remove-btn"
-                  onClick={() => void removeAndClose(editing)}
-                >
-                  {t("providers.keys.remove")}
-                </button>
-              )}
-              <button
-                className="btn btn-primary"
-                onClick={() => {
-                  void onBlur(editing.key);
-                  setEditing(null);
-                }}
-              >
-                {t("common.done")}
-              </button>
-            </div>
-          </div>
-        </div>
-      )}
+          );
+        })()}
 
       {/* Config: a named custom OpenAI-compatible provider (name + base URL + key + models) */}
       {customEditing &&
diff --git a/src/renderer/src/components/profile/ProfileModal.tsx b/src/renderer/src/components/profile/ProfileModal.tsx
index c6fcb5e58..59b6fea43 100644
--- a/src/renderer/src/components/profile/ProfileModal.tsx
+++ b/src/renderer/src/components/profile/ProfileModal.tsx
@@ -8,7 +8,7 @@ import {
   Refresh,
   Settings,
   Signal,
-  Sparkles,
+  Drama,
   Trash,
   User,
   Wallet,
@@ -70,7 +70,7 @@ const PROFILE_SECTIONS: ReadonlyArray<{
   Icon: React.ComponentType<{ size?: number }>;
 }> = [
   { id: "profile", labelKey: "agents.sectionProfile", Icon: User },
-  { id: "persona", labelKey: "agents.sectionPersona", Icon: Sparkles },
+  { id: "persona", labelKey: "agents.sectionPersona", Icon: Drama },
   { id: "agentMemory", labelKey: "agents.sectionAgentMemory", Icon: Database },
   { id: "wallet", labelKey: "agents.sectionWallet", Icon: Wallet },
   { id: "sync", labelKey: "agents.sectionSync", Icon: Refresh },
diff --git a/src/renderer/src/constants.ts b/src/renderer/src/constants.ts
index 63dda1d85..60ba392c4 100644
--- a/src/renderer/src/constants.ts
+++ b/src/renderer/src/constants.ts
@@ -110,6 +110,9 @@ export const PROVIDERS = {
     zai: "Z.ai / GLM",
     alibaba: "Alibaba DashScope",
     minimax: "MiniMax",
+    "minimax-cn": "MiniMax (China)",
+    "opencode-zen": "OpenCode Zen",
+    "opencode-go": "OpenCode Go",
     nous: "constants.nousName",
     lmstudio: "constants.lmstudio",
     atomicchat: "constants.atomicchat",
@@ -522,6 +525,102 @@ export const LOCAL_PRESETS: LocalPreset[] = [
 // keeps the per-provider Models manager saving entries exactly the way the
 // Models screen / Providers tab would. Unknown keys fall back to a bare `custom`
 // route so any provider can still hold models.
+// Native-provider keys that appear as "LLM Providers" FieldDefs but have no
+// `PROVIDERS.setup` card carrying their envKey (the setup card is absent, or —
+// like Nous — is the OAuth variant with `envKey: ""`). Without an explicit
+// route these fell through to the bare `custom` fallback, whose empty base URL
+// made the Providers tab's active-model picker silently drop the provider even
+// with a key set (the "key set but not in the Change modal" bug). Slugs and
+// env vars mirror hermes-agent's own registry (plugins/model-providers/*):
+// e.g. GLM_API_KEY is the `zai` provider, KIMI_API_KEY is `kimi-coding`.
+export const NATIVE_ENV_KEY_ROUTES: Record<
+  string,
+  { provider: string; baseUrl: string }
+> = {
+  NOUS_API_KEY: { provider: "nous", baseUrl: "" },
+  GLM_API_KEY: { provider: "zai", baseUrl: "" },
+  KIMI_API_KEY: { provider: "kimi-coding", baseUrl: "" },
+  MINIMAX_API_KEY: { provider: "minimax", baseUrl: "" },
+  MINIMAX_CN_API_KEY: { provider: "minimax-cn", baseUrl: "" },
+  NVIDIA_API_KEY: { provider: "nvidia", baseUrl: "" },
+  OPENCODE_ZEN_API_KEY: { provider: "opencode-zen", baseUrl: "" },
+  OPENCODE_GO_API_KEY: { provider: "opencode-go", baseUrl: "" },
+  HF_TOKEN: { provider: "huggingface", baseUrl: "" },
+  // Perplexity has no native agent slug — it routes like the compat presets.
+  PERPLEXITY_API_KEY: {
+    provider: "custom",
+    baseUrl: "https://api.perplexity.ai",
+  },
+};
+
+// Display priority for the LLM-provider cards + Add-provider picker. The
+// `SETTINGS_SECTIONS` FieldDef order is grouped by how providers were added
+// over time, which surfaces niche endpoints (e.g. AIML API) above household
+// names. This front-loads the well-known providers — Hermes One first — and
+// anything not listed keeps its FieldDef order after them, ahead of the
+// explicitly demoted keys. Keys are env-var names (a FieldDef's `key`).
+export const PROVIDER_KEY_ORDER: readonly string[] = [
+  "HERMESONE_API_KEY",
+  "OPENAI_API_KEY",
+  "ANTHROPIC_API_KEY",
+  "OPENROUTER_API_KEY",
+  "GOOGLE_API_KEY",
+  "GROQ_API_KEY",
+  "DEEPSEEK_API_KEY",
+  "XAI_API_KEY",
+  "MISTRAL_API_KEY",
+  "NOUS_API_KEY",
+  "TOGETHER_API_KEY",
+  "FIREWORKS_API_KEY",
+  "CEREBRAS_API_KEY",
+  "PERPLEXITY_API_KEY",
+  "GLM_API_KEY",
+  "KIMI_API_KEY",
+  "MINIMAX_API_KEY",
+  "DASHSCOPE_API_KEY",
+  "NVIDIA_API_KEY",
+  "HF_TOKEN",
+  "OLLAMA_API_KEY",
+];
+
+// Keys pushed to the very end of the list regardless of FieldDef order — niche
+// endpoints most users won't reach for. Ordered among themselves by this list.
+export const PROVIDER_KEY_DEMOTED: readonly string[] = ["AIMLAPI_API_KEY"];
+
+/**
+ * Rank an LLM-provider env key for display ordering: prioritized keys first
+ * (in `PROVIDER_KEY_ORDER`), then everything unlisted, then demoted keys last.
+ * Pair with a **stable** sort so unlisted keys keep their FieldDef order.
+ */
+export function providerKeyRank(envKey: string): number {
+  const demoted = PROVIDER_KEY_DEMOTED.indexOf(envKey);
+  if (demoted !== -1) return 20000 + demoted;
+  const ranked = PROVIDER_KEY_ORDER.indexOf(envKey);
+  if (ranked !== -1) return ranked;
+  return 10000; // unlisted — after prioritized, before demoted
+}
+
+/**
+ * The plain provider name for an LLM-provider env key — "Hermes One", not
+ * "Hermes One API Key". The provider cards/picker are a list of providers, so
+ * the "API Key" suffix in every FieldDef label is noise there (and the label
+ * can't be suffix-stripped reliably across locales). Derives the display brand
+ * via the same route mapping the active-model picker uses, then looks up
+ * `PROVIDERS.labels`. Returns the (possibly untranslated) label, or null for
+ * keys with no brand (bare custom fallback) — callers keep the FieldDef label.
+ */
+export function providerNameForEnvKey(envKey: string): string | null {
+  const r = providerRouteForEnvKey(envKey);
+  const brand =
+    r.provider === "custom"
+      ? r.baseUrl
+        ? displayBrandFromConfig("custom", r.baseUrl)
+        : "custom"
+      : r.provider;
+  if (!brand || brand === "custom") return null;
+  return PROVIDERS.labels[brand] ?? null;
+}
+
 export function providerRouteForEnvKey(envKey: string): {
   provider: string;
   baseUrl: string;
@@ -545,6 +644,8 @@ export function providerRouteForEnvKey(envKey: string): {
   }
   const preset = LOCAL_PRESETS.find((p) => p.envKey === envKey);
   if (preset) return { provider: "custom", baseUrl: preset.baseUrl ?? "" };
+  const native = NATIVE_ENV_KEY_ROUTES[envKey];
+  if (native) return { ...native };
   return { provider: "custom", baseUrl: "" };
 }
 
diff --git a/src/renderer/src/screens/Chat/dashboardEventAdapter.test.ts b/src/renderer/src/screens/Chat/dashboardEventAdapter.test.ts
index 965e57e4a..c87bbc4c9 100644
--- a/src/renderer/src/screens/Chat/dashboardEventAdapter.test.ts
+++ b/src/renderer/src/screens/Chat/dashboardEventAdapter.test.ts
@@ -48,6 +48,48 @@ describe("mergeStreamedWithFinal", () => {
     expect(merged).not.toContain("checkIt");
   });
 
+  // Lossy re-assembly: the content stream dropped chunks (e.g. alternate
+  // chunks mis-tagged as `reasoning` upstream), so the streamed bubble is a
+  // garbled subsequence of the final answer. The final must REPLACE it —
+  // concatenating stacked the partial above the clean answer in one bubble.
+  it("replaces a lossy chunk-dropped stream with the final text", () => {
+    expect(
+      mergeStreamedWithFinal(
+        "! What are we working on?",
+        "Hey! What are we working on today?",
+      ),
+    ).toBe("Hey! What are we working on today?");
+  });
+
+  it("replaces a longer garbled stream that interleaves into the final", () => {
+    expect(
+      mergeStreamedWithFinal(
+        "Sat planet from the Sun — ring system made ice and rock particles.",
+        "Saturn is the sixth planet from the Sun — a gas giant famous for its stunning ring system made of ice and rock particles.",
+      ),
+    ).toBe(
+      "Saturn is the sixth planet from the Sun — a gas giant famous for its stunning ring system made of ice and rock particles.",
+    );
+  });
+
+  it("still concatenates a short lead-in even if it is a subsequence", () => {
+    // Guard: a tiny streamed fragment is a subsequence of almost anything;
+    // treat it as the pre-tool-call text it usually is.
+    expect(mergeStreamedWithFinal("On it.", "Onwards — it is done.")).toBe(
+      "On it.\n\nOnwards — it is done.",
+    );
+  });
+
+  it("preserves pre-tool-call text that embeds only as scattered characters", () => {
+    // Review regression: the streamed text is a plain character subsequence
+    // of the final (every char appears in order as 1-char fragments), long
+    // enough to pass the length/coverage guards — but it is NOT a
+    // chunk-dropped copy, so it must stack, not be erased.
+    expect(
+      mergeStreamedWithFinal("abcdefghijkl", "a1b2c3d4e5f6g7h8i9j0k1l2"),
+    ).toBe("abcdefghijkl\n\na1b2c3d4e5f6g7h8i9j0k1l2");
+  });
+
   it("stitches a re-streamed boundary, dropping the duplicated seam", () => {
     // Tail of streamed repeats the head of final at a word boundary.
     expect(mergeStreamedWithFinal("The answer is 4", "answer is 4.")).toBe(
diff --git a/src/renderer/src/screens/Chat/dashboardEventAdapter.ts b/src/renderer/src/screens/Chat/dashboardEventAdapter.ts
index 41b9cfa40..74f0ab4ed 100644
--- a/src/renderer/src/screens/Chat/dashboardEventAdapter.ts
+++ b/src/renderer/src/screens/Chat/dashboardEventAdapter.ts
@@ -1,4 +1,5 @@
 import type { ChatToolEvent } from "../../../../shared/chat-stream";
+import { isLossyChunkCopy } from "./lossyText";
 import type { ActiveTurn, ChatBubbleMessage, ChatMessage } from "./types";
 
 export interface DashboardStreamEvent<T = unknown> {
@@ -460,6 +461,19 @@ export function mergeStreamedWithFinal(
   if (normFinal.includes(normStreamed)) return finalContent;
   if (normStreamed.includes(normFinal)) return streamedContent;
 
+  // Lossy re-assembly: the streamed deltas dropped chunks (e.g. the upstream
+  // tagged alternate chunks as `reasoning`, so the content stream only carried
+  // a subset), leaving the streamed bubble a chunk-dropped copy of the final
+  // text ("! What are we working on?" for "Hey! What are we working on
+  // today?"). Concatenating would stack the garbled partial above the clean
+  // answer — the final text replaces it. The run-based matcher plus its
+  // length/coverage guards keep the pre-tool-call + answer pair (#746,
+  // genuinely different texts) on the concatenate path: unrelated sentences
+  // only embed as scattered fragments, never as contiguous chunk runs.
+  if (isLossyChunkCopy(normStreamed, normFinal)) {
+    return finalContent;
+  }
+
   const overlap = tailHeadOverlap(streamedContent, finalContent);
   if (overlap > 0) return `${streamedContent}${finalContent.slice(overlap)}`;
 
diff --git a/src/renderer/src/screens/Chat/hooks/useDashboardChatTransport.ts b/src/renderer/src/screens/Chat/hooks/useDashboardChatTransport.ts
index 20e26512c..716757b01 100644
--- a/src/renderer/src/screens/Chat/hooks/useDashboardChatTransport.ts
+++ b/src/renderer/src/screens/Chat/hooks/useDashboardChatTransport.ts
@@ -526,8 +526,16 @@ export function resolveDashboardProviderForModel(
   );
 
   if (requestedBaseUrl) {
-    const baseMatches = customProviders.filter(
+    // Match ANY provider row on the requested endpoint — named user providers
+    // from config.yaml `providers:` (e.g. the mirrored `hermesone` entry) as
+    // well as legacy `custom:<name>` rows. Falling through to bare "custom"
+    // is the failure mode this avoids: the agent resolves `--provider custom`
+    // against the session's *current* base URL, so a session sitting on
+    // another provider would send this model to the wrong endpoint (the
+    // hermesone-swift → Nous-proxy 404).
+    const baseMatches = providers.filter(
       (provider) =>
+        !!provider.slug &&
         normalizeBaseUrl(providerBaseUrl(provider)) === requestedBaseUrl,
     );
     return (
diff --git a/src/renderer/src/screens/Chat/lossyText.test.ts b/src/renderer/src/screens/Chat/lossyText.test.ts
new file mode 100644
index 000000000..6f0262dfe
--- /dev/null
+++ b/src/renderer/src/screens/Chat/lossyText.test.ts
@@ -0,0 +1,62 @@
+// @vitest-environment node
+import { describe, expect, it } from "vitest";
+import { isLossyChunkCopy } from "./lossyText";
+
+/**
+ * The chunk-copy matcher backs both stream reconciliations (assistant bubble
+ * merge + reasoning-row dedup). It must accept genuine chunk-dropped copies
+ * and reject unrelated text whose characters merely embed as a scattered
+ * subsequence — the review-flagged false positive that would erase real
+ * pre-tool-call content or a distinct short thought.
+ */
+describe("isLossyChunkCopy", () => {
+  it("accepts real chunk-dropped copies", () => {
+    expect(
+      isLossyChunkCopy(
+        "! What are we working on?",
+        "Hey! What are we working on today?",
+      ),
+    ).toBe(true);
+    expect(
+      isLossyChunkCopy(
+        "Sat planet from the Sun — ring system made ice and rock particles.",
+        "Saturn is the sixth planet from the Sun — a gas giant famous for its stunning ring system made of ice and rock particles.",
+      ),
+    ).toBe(true);
+    expect(
+      isLossyChunkCopy(
+        "I'm running moon-k3 via provider ous.",
+        "I'm running moonshotai/kimi-k3 via provider nous.",
+      ),
+    ).toBe(true);
+  });
+
+  it("rejects a scattered character subsequence (not contiguous runs)", () => {
+    // Every character of the partial appears in order in the full text, but
+    // only as 1-char fragments — a coincidental embedding (what a plain
+    // subsequence test would wrongly accept), not a chunk-dropped copy.
+    expect(isLossyChunkCopy("abcdefghijkl", "a1b2c3d4e5f6g7h8i9j0k1l2")).toBe(
+      false,
+    );
+  });
+
+  it("rejects tiny fragments and low coverage", () => {
+    // Below the minimum length.
+    expect(isLossyChunkCopy("On it.", "Onwards — it is done.")).toBe(false);
+    // A real prefix, but far under 30% of the full text.
+    const long = "x".repeat(200);
+    expect(isLossyChunkCopy("xxxxxxxxxxxx", long)).toBe(false);
+  });
+
+  it("rejects equal or longer partials (nothing was dropped)", () => {
+    expect(isLossyChunkCopy("same text here", "same text here")).toBe(false);
+    expect(isLossyChunkCopy("longer than the full", "short full")).toBe(false);
+  });
+
+  it("allows a short final run (trailing punctuation survives chunking)", () => {
+    // Runs: "Hello there my friend" + trailing "!" (1 char, final run).
+    expect(
+      isLossyChunkCopy("Hello there my friend!", "Hello there my friend, hi!"),
+    ).toBe(true);
+  });
+});
diff --git a/src/renderer/src/screens/Chat/lossyText.ts b/src/renderer/src/screens/Chat/lossyText.ts
new file mode 100644
index 000000000..f46e245ff
--- /dev/null
+++ b/src/renderer/src/screens/Chat/lossyText.ts
@@ -0,0 +1,62 @@
+// @lat: [[chat-commands#Slash command execution#Completion text reconciliation]]
+
+/**
+ * Detect whether `partial` looks like a chunk-dropped copy of `full`.
+ *
+ * A stream assembled with dropped delta chunks is a concatenation of
+ * **contiguous substrings** of the canonical text, in order — e.g.
+ * "! What are we working on?" for "Hey! What are we working on today?", or
+ * "Sat planet from the Sun" for "Saturn is the sixth planet from the Sun".
+ *
+ * A plain character-subsequence test is too loose: unrelated English
+ * sentences often embed as scattered 1–2 character fragments, which would
+ * make a genuine pre-tool-call segment (or a distinct short reasoning
+ * segment) look like a damaged copy and get erased. So the match is greedy
+ * over runs: every matched segment must be at least `minRun` characters
+ * (the last segment may be shorter — a trailing "?" survives chunking), with
+ * arbitrary gaps between runs. On top of the shape test, callers get
+ * coverage guards: the partial must be non-trivial (≥ `minLength`) and cover
+ * a substantial share of the full text (≥ `minCoverage`), so a tiny
+ * fragment can never cancel a long canonical text.
+ *
+ * Inputs are expected to be whitespace-normalized by the caller.
+ */
+export function isLossyChunkCopy(
+  partial: string,
+  full: string,
+  {
+    minRun = 3,
+    minLength = 12,
+    minCoverage = 0.3,
+  }: { minRun?: number; minLength?: number; minCoverage?: number } = {},
+): boolean {
+  if (!partial || !full) return false;
+  if (partial.length < minLength) return false;
+  if (partial.length >= full.length) return false;
+  if (partial.length < minCoverage * full.length) return false;
+
+  let i = 0; // position in partial
+  let j = 0; // position in full
+  while (i < partial.length) {
+    const remaining = partial.length - i;
+    const probeLen = Math.min(minRun, remaining);
+    const probe = partial.slice(i, i + probeLen);
+    const at = full.indexOf(probe, j);
+    if (at < 0) return false;
+    // A short trailing probe (the final run) may be under minRun; any other
+    // run must anchor with at least minRun matching characters.
+    if (probeLen < minRun && remaining > probeLen) return false;
+    // Extend the run as far as the two texts agree.
+    let len = probeLen;
+    while (
+      i + len < partial.length &&
+      at + len < full.length &&
+      partial[i + len] === full[at + len]
+    ) {
+      len++;
+    }
+    i += len;
+    j = at + len;
+  }
+  return true;
+}
diff --git a/src/renderer/src/screens/Chat/sessionHistory.ts b/src/renderer/src/screens/Chat/sessionHistory.ts
index c3656e277..266d236cb 100644
--- a/src/renderer/src/screens/Chat/sessionHistory.ts
+++ b/src/renderer/src/screens/Chat/sessionHistory.ts
@@ -4,6 +4,7 @@ import {
   isBubbleMessage,
   normalizeMessageText,
 } from "./chatMessages";
+import { isLossyChunkCopy } from "./lossyText";
 import type { ActiveTurn, ChatMessage, ChatBubbleMessage } from "./types";
 
 /**
@@ -880,7 +881,73 @@ export function reconcileStreamedWithDb(
   // landing *below* any agent content the gateway streamed after the user
   // answered (the reverse of what the user saw live). Re-anchor each card
   // immediately after the streamed message that preceded it.
-  return repositionClarifyCards(dedupeMessageIds(merged), streamed);
+  return repositionClarifyCards(
+    dropLossyStreamedReasoning(dedupeMessageIds(merged)),
+    streamed,
+  );
+}
+
+const normalizeReasoningText = (text: string): string =>
+  (text || "").replace(/\s+/g, " ").trim();
+
+/**
+ * Drop live-streamed reasoning rows that are lossy previews of a canonical DB
+ * reasoning row in the same turn.
+ *
+ * The live reasoning stream is best-effort: dropped delta chunks leave the
+ * streamed row with garbled text (e.g. "moon-k3 … ous" for
+ * "moonshotai/kimi-k3 … nous"), so its text-based reconciliation key never
+ * matches the DB row and both survive the merge — the user sees the corrupt
+ * partial AND the full thought stacked in one Thought block. A dropped-chunks
+ * preview is, by construction, a concatenation of contiguous runs of the
+ * canonical text — matched by [[isLossyChunkCopy]], whose run/length/coverage
+ * guards separate "same thought, chunks missing" (drop) from a genuinely
+ * distinct short reasoning segment whose characters merely embed as scattered
+ * fragments (keep). Scoped per turn (between user rows) so identical thoughts
+ * in different turns can't cross-cancel, and only a strictly shorter streamed
+ * row is dropped — equal text means the key match already handled it.
+ */
+function dropLossyStreamedReasoning(
+  messages: ReadonlyArray<ChatMessage>,
+): ChatMessage[] {
+  const isReasoning = (
+    m: ChatMessage,
+  ): m is Extract<ChatMessage, { kind: "reasoning" }> =>
+    "kind" in m && m.kind === "reasoning";
+
+  const drop = new Set<string>();
+  let turnStart = 0;
+  const scanTurn = (end: number): void => {
+    const canonical: string[] = [];
+    for (let i = turnStart; i < end; i++) {
+      const m = messages[i];
+      if (isReasoning(m) && m.id.startsWith("db-r-")) {
+        canonical.push(normalizeReasoningText(m.text));
+      }
+    }
+    if (canonical.length === 0) return;
+    for (let i = turnStart; i < end; i++) {
+      const m = messages[i];
+      if (!isReasoning(m) || m.id.startsWith("db-r-")) continue;
+      const text = normalizeReasoningText(m.text);
+      if (!text) continue;
+      if (canonical.some((c) => isLossyChunkCopy(text, c))) {
+        drop.add(m.id);
+      }
+    }
+  };
+
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i];
+    if (isBubbleMessage(m) && m.role === "user") {
+      scanTurn(i);
+      turnStart = i + 1;
+    }
+  }
+  scanTurn(messages.length);
+
+  if (drop.size === 0) return [...messages];
+  return messages.filter((m) => !drop.has(m.id));
 }
 
 /**
diff --git a/src/renderer/src/screens/Chat/slash/SlashCommandIcon.tsx b/src/renderer/src/screens/Chat/slash/SlashCommandIcon.tsx
index 7d6329cfc..22e2c0aa4 100644
--- a/src/renderer/src/screens/Chat/slash/SlashCommandIcon.tsx
+++ b/src/renderer/src/screens/Chat/slash/SlashCommandIcon.tsx
@@ -35,7 +35,7 @@ import {
   Server,
   Settings,
   Share2,
-  Sparkles,
+  Puzzle,
   Target,
   Terminal,
   Undo2,
@@ -118,7 +118,7 @@ const ICON_MAP: Record<string, LucideIcon> = {
   // Info
   help: HelpCircle,
   tools: Wrench,
-  skills: Sparkles,
+  skills: Puzzle,
   "reload-skills": RefreshCw,
   kanban: Columns,
   schedules: Calendar,
@@ -196,7 +196,7 @@ export function SlashCommandIcon({
   const IconComponent: LucideIcon =
     ICON_MAP[cleanName] ??
     (category ? CATEGORY_DEFAULTS[category.toLowerCase()] : undefined) ??
-    Sparkles;
+    Zap;
 
   return <IconComponent size={size} className={className} />;
 }
diff --git a/src/renderer/src/screens/Kanban/Kanban.tsx b/src/renderer/src/screens/Kanban/Kanban.tsx
index b6c628bc7..e5440105b 100644
--- a/src/renderer/src/screens/Kanban/Kanban.tsx
+++ b/src/renderer/src/screens/Kanban/Kanban.tsx
@@ -9,7 +9,7 @@ import {
   Check,
   Ban,
   RotateCcw,
-  Sparkles,
+  Wand,
 } from "../../assets/icons";
 import { useI18n } from "../../components/useI18n";
 
@@ -951,7 +951,7 @@ function Kanban({ profile, visible }: KanbanProps): React.JSX.Element {
                             }}
                             disabled={actionBusy === task.id}
                           >
-                            <Sparkles size={14} />
+                            <Wand size={14} />
                           </button>
                         )}
                         {!isHqActive && task.status === "ready" && (
diff --git a/src/renderer/src/screens/Layout/ProfileSwitcher.tsx b/src/renderer/src/screens/Layout/ProfileSwitcher.tsx
index c09f23a26..c4a0723f0 100644
--- a/src/renderer/src/screens/Layout/ProfileSwitcher.tsx
+++ b/src/renderer/src/screens/Layout/ProfileSwitcher.tsx
@@ -1,5 +1,5 @@
-import { useState, useEffect, useCallback } from "react";
-import { Settings, Users, Check } from "../../assets/icons";
+import { useState, useEffect, useCallback, useRef } from "react";
+import { Settings, Users, Check, Search } from "../../assets/icons";
 import { useI18n } from "../../components/useI18n";
 import ProfileAvatar from "../../components/common/ProfileAvatar";
 import { useProfileModal } from "../../components/profile/ProfileModalContext";
@@ -30,8 +30,10 @@ interface ProfileSwitcherProps {
 /**
  * Sidebar-footer profile control, split into two affordances: the chip (avatar
  * + name) opens the current profile's edit modal, and a dedicated switch button
- * opens a modal to change the active profile. Collapsed, the single avatar opens
- * the switch modal.
+ * opens a command-palette-style picker to change the active profile. Collapsed,
+ * the single avatar opens the picker. The picker also opens from anywhere via
+ * Cmd/Ctrl+P: a fuzzy search field on top, running profiles grouped above a
+ * "Stopped" section, each row showing its model in monospace and a running dot.
  */
 export default function ProfileSwitcher({
   activeProfile,
@@ -43,6 +45,13 @@ export default function ProfileSwitcher({
   const { openProfile } = useProfileModal();
   const [switchOpen, setSwitchOpen] = useState(false);
   const [profiles, setProfiles] = useState<ProfileInfo[]>([]);
+  const [query, setQuery] = useState("");
+  const [highlight, setHighlight] = useState(0);
+  const searchRef = useRef<HTMLInputElement>(null);
+  const listRef = useRef<HTMLDivElement>(null);
+
+  const isMac = window.electron?.process?.platform === "darwin";
+  const mod = isMac ? "⌘" : "Ctrl";
 
   const load = useCallback(() => {
     window.hermesAPI
@@ -58,20 +67,36 @@ export default function ProfileSwitcher({
     load();
   }, [load]);
 
-  // Refresh when the switch modal opens — counts and the gateway dot drift.
-  useEffect(() => {
-    if (switchOpen) load();
-  }, [switchOpen, load]);
-
-  // Escape closes the switch modal.
+  // Cmd/Ctrl+P toggles the picker from anywhere. P is unbound in the app menu,
+  // so the renderer reliably receives it; preventDefault keeps the browser
+  // print dialog from stealing it.
   useEffect(() => {
-    if (!switchOpen) return;
     function onKey(e: KeyboardEvent): void {
-      if (e.key === "Escape") setSwitchOpen(false);
+      if (
+        (e.metaKey || e.ctrlKey) &&
+        !e.altKey &&
+        !e.shiftKey &&
+        (e.key === "p" || e.key === "P")
+      ) {
+        e.preventDefault();
+        setSwitchOpen((v) => !v);
+      }
     }
     document.addEventListener("keydown", onKey);
     return () => document.removeEventListener("keydown", onKey);
-  }, [switchOpen]);
+  }, []);
+
+  // Refresh + reset search/focus each time the picker opens — counts and the
+  // gateway dot drift while it's closed.
+  useEffect(() => {
+    if (!switchOpen) return;
+    load();
+    setQuery("");
+    setHighlight(0);
+    // Focus after the open animation's first frame so the caret lands reliably.
+    const id = requestAnimationFrame(() => searchRef.current?.focus());
+    return () => cancelAnimationFrame(id);
+  }, [switchOpen, load]);
 
   const activeInfo = profiles.find((p) => p.id === activeProfile);
   const hasDefaultFallbackName =
@@ -87,15 +112,96 @@ export default function ProfileSwitcher({
     openProfile(activeProfile, { onChanged: load });
   }
 
-  async function handleSelect(name: string): Promise<void> {
-    setSwitchOpen(false);
-    if (name === activeProfile) return;
-    try {
-      await window.hermesAPI.setActiveProfile(name);
-    } catch {
-      /* still reflect the choice optimistically */
+  const handleSelect = useCallback(
+    async (name: string): Promise<void> => {
+      setSwitchOpen(false);
+      if (name === activeProfile) return;
+      try {
+        await window.hermesAPI.setActiveProfile(name);
+      } catch {
+        /* still reflect the choice optimistically */
+      }
+      onSwitch(name);
+    },
+    [activeProfile, onSwitch],
+  );
+
+  // Fuzzy-ish filter across the user-facing name, the stable id, and the model.
+  const q = query.trim().toLowerCase();
+  const matches = (p: ProfileInfo): boolean =>
+    !q ||
+    p.name.toLowerCase().includes(q) ||
+    p.id.toLowerCase().includes(q) ||
+    (p.model || "").toLowerCase().includes(q);
+  // Active profile floats to the top of its group; the rest keep list order.
+  const byActiveFirst = (a: ProfileInfo, b: ProfileInfo): number =>
+    Number(b.id === activeProfile) - Number(a.id === activeProfile);
+  const filtered = profiles.filter(matches);
+  const running = filtered.filter((p) => p.gatewayRunning).sort(byActiveFirst);
+  const stopped = filtered.filter((p) => !p.gatewayRunning).sort(byActiveFirst);
+  // Flat order drives keyboard navigation across both groups.
+  const flat = [...running, ...stopped];
+
+  // Keep the highlighted row scrolled into view as the selection moves.
+  useEffect(() => {
+    if (!switchOpen) return;
+    listRef.current
+      ?.querySelector(".profile-menu-item.highlighted")
+      ?.scrollIntoView({ block: "nearest" });
+  }, [highlight, switchOpen]);
+
+  function onSearchKey(e: React.KeyboardEvent): void {
+    if (e.key === "ArrowDown") {
+      e.preventDefault();
+      // Clamp to the (possibly empty) filtered list — an empty list keeps 0
+      // rather than drifting to -1.
+      setHighlight((h) => Math.max(0, Math.min(flat.length - 1, h + 1)));
+    } else if (e.key === "ArrowUp") {
+      e.preventDefault();
+      setHighlight((h) => Math.max(0, h - 1));
+    } else if (e.key === "Enter") {
+      e.preventDefault();
+      // No-op when the query matches nothing — `flat[highlight]` is undefined.
+      const target = flat[highlight];
+      if (target) void handleSelect(target.id);
+    } else if (e.key === "Escape") {
+      e.stopPropagation();
+      setSwitchOpen(false);
     }
-    onSwitch(name);
+  }
+
+  function renderRow(p: ProfileInfo, flatIndex: number): React.JSX.Element {
+    const isActive = p.id === activeProfile;
+    return (
+      <button
+        key={p.id}
+        className={`profile-menu-item ${isActive ? "active" : ""} ${
+          flatIndex === highlight ? "highlighted" : ""
+        }`}
+        role="menuitemradio"
+        aria-checked={isActive}
+        onClick={() => void handleSelect(p.id)}
+        onMouseMove={() => setHighlight(flatIndex)}
+      >
+        <ProfileAvatar
+          name={p.id}
+          color={p.color}
+          avatar={p.avatar}
+          size={32}
+        />
+        <span className="profile-menu-name">{p.name}</span>
+        <span className="profile-menu-model">
+          {p.model || t("agents.noModel")}
+        </span>
+        <span className="profile-menu-status">
+          <span
+            className={`profile-menu-gateway ${p.gatewayRunning ? "active" : ""}`}
+            aria-hidden
+          />
+          {isActive && <Check size={16} className="profile-menu-check" />}
+        </span>
+      </button>
+    );
   }
 
   return (
@@ -122,7 +228,7 @@ export default function ProfileSwitcher({
           <button
             className="profile-switch-btn"
             onClick={() => setSwitchOpen(true)}
-            title={t("agents.switchProfile")}
+            title={`${t("agents.switchProfile")} (${mod}P)`}
             aria-label={t("agents.switchProfile")}
           >
             <Users size={16} />
@@ -141,59 +247,46 @@ export default function ProfileSwitcher({
             aria-label={t("agents.switchProfile")}
             onClick={(e) => e.stopPropagation()}
           >
-            <div className="profile-switch-title">
-              {t("agents.switchProfile")}
+            <div className="profile-switch-search">
+              <Search
+                size={16}
+                className="profile-switch-search-icon"
+                aria-hidden
+              />
+              <input
+                ref={searchRef}
+                className="profile-switch-search-input"
+                type="text"
+                value={query}
+                onChange={(e) => {
+                  setQuery(e.target.value);
+                  setHighlight(0);
+                }}
+                onKeyDown={onSearchKey}
+                placeholder={t("agents.switchProfile")}
+                aria-label={t("agents.switchProfile")}
+              />
+              <kbd className="profile-switch-kbd">{mod}P</kbd>
             </div>
-            <div className="profile-switch-list">
-              {profiles.map((p) => {
-                const isActive = p.id === activeProfile;
-                return (
-                  <button
-                    key={p.id}
-                    className={`profile-menu-item ${isActive ? "active" : ""}`}
-                    role="menuitemradio"
-                    aria-checked={isActive}
-                    onClick={() => handleSelect(p.id)}
-                  >
-                    <div className="profile-menu-avatar">
-                      <ProfileAvatar
-                        name={p.id}
-                        color={p.color}
-                        avatar={p.avatar}
-                        size={28}
-                      />
+
+            <div className="profile-switch-list" ref={listRef}>
+              {flat.length === 0 ? (
+                <div className="profile-switch-empty">
+                  {t("agents.noProfilesMatch")}
+                </div>
+              ) : (
+                <>
+                  {running.map((p, i) => renderRow(p, i))}
+                  {stopped.length > 0 && (
+                    <div className="profile-switch-group">
+                      {t("agents.stopped")}
                     </div>
-                    <span className="profile-menu-info">
-                      <span className="profile-menu-name">
-                        {p.name}
-                        {p.isDefault && (
-                          <span className="profile-menu-tag">
-                            {t("agents.defaultTag")}
-                          </span>
-                        )}
-                        {p.id !== p.name && (
-                          <span className="profile-menu-tag">{p.id}</span>
-                        )}
-                        <span
-                          className={`profile-menu-gateway ${
-                            p.gatewayRunning ? "active" : ""
-                          }`}
-                        />
-                      </span>
-                      <span className="profile-menu-meta">
-                        {[
-                          p.model || t("agents.noModel"),
-                          t("agents.skillsCount", { count: p.skillCount }),
-                        ].join(" · ")}
-                      </span>
-                    </span>
-                    {isActive && (
-                      <Check size={16} className="profile-menu-check" />
-                    )}
-                  </button>
-                );
-              })}
+                  )}
+                  {stopped.map((p, i) => renderRow(p, running.length + i))}
+                </>
+              )}
             </div>
+
             <button
               className="profile-menu-manage"
               onClick={() => {
diff --git a/src/renderer/src/screens/Layout/SidebarSessionMenu.tsx b/src/renderer/src/screens/Layout/SidebarSessionMenu.tsx
index ff4d2b927..9687a5ac6 100644
--- a/src/renderer/src/screens/Layout/SidebarSessionMenu.tsx
+++ b/src/renderer/src/screens/Layout/SidebarSessionMenu.tsx
@@ -5,6 +5,7 @@ import { useI18n } from "../../components/useI18n";
 import {
   Check,
   ChevronRight,
+  Folder,
   FolderInput,
   Pencil,
   Pin,
@@ -274,13 +275,16 @@ function SidebarSessionMenu({
                               key={project.path}
                               type="button"
                               role="menuitem"
-                              className="sidebar-session-menu-item"
+                              className={`sidebar-session-menu-item ${
+                                active ? "active-project" : ""
+                              }`}
                               title={project.path}
                               onClick={() => {
                                 if (!active) onMoveToProject(project.path);
                                 requestClose();
                               }}
                             >
+                              <Folder size={15} />
                               <span className="sidebar-session-menu-project-name">
                                 {project.name}
                               </span>
diff --git a/src/renderer/src/screens/Memory/MemoryTabs.tsx b/src/renderer/src/screens/Memory/MemoryTabs.tsx
index 9b3913fa2..766116ad7 100644
--- a/src/renderer/src/screens/Memory/MemoryTabs.tsx
+++ b/src/renderer/src/screens/Memory/MemoryTabs.tsx
@@ -1,4 +1,4 @@
-import { Database, User, Cloud, Sparkles } from "lucide-react";
+import { Database, User, Cloud, Drama } from "lucide-react";
 import { useI18n } from "../../components/useI18n";
 import type { MemoryTab } from "./types";
 
@@ -17,7 +17,7 @@ export function MemoryTabs({
     { id: "entries", icon: Database, label: t("memory.agentMemory") },
     { id: "profile", icon: User, label: t("memory.userProfile") },
     { id: "providers", icon: Cloud, label: t("memory.providersTitle") },
-    { id: "soul", icon: Sparkles, label: t("soul.title") },
+    { id: "soul", icon: Drama, label: t("soul.title") },
   ];
 
   return (
diff --git a/src/renderer/src/screens/Providers/Providers.tsx b/src/renderer/src/screens/Providers/Providers.tsx
index b1cd31823..368b13b26 100644
--- a/src/renderer/src/screens/Providers/Providers.tsx
+++ b/src/renderer/src/screens/Providers/Providers.tsx
@@ -22,6 +22,7 @@ import {
   RefreshCw,
   Eye,
   EyeOff,
+  Coins,
 } from "lucide-react";
 import { customProviderEnvKey } from "../../../../shared/url-key-map";
 import type { HermesAccount } from "../../../../shared/account";
@@ -205,6 +206,8 @@ function Providers({
   // Hermes account (device login). `account` is the signed-in profile or null.
   const [account, setAccount] = useState<HermesAccount | null>(null);
   const [showAccountModal, setShowAccountModal] = useState(false);
+  // AI-credit balance for the account card (null = signed out / unavailable).
+  const [credits, setCredits] = useState<number | null>(null);
   useEffect(() => {
     let cancelled = false;
     void window.hermesAPI.getAccount(profile).then((a) => {
@@ -215,6 +218,37 @@ function Providers({
     };
   }, [profile]);
 
+  // Hermes One convenience layer: with a signed-in account, surface the
+  // credit balance and make sure the profile has an auto-provisioned
+  // HERMESONE_API_KEY (no-op when one exists; the main process guards
+  // remote/SSH modes). A freshly created key means the env just changed
+  // under us — re-read it so the Hermes One card + picker appear now, not
+  // on the next visit.
+  useEffect(() => {
+    let cancelled = false;
+    if (!account) {
+      setCredits(null);
+      return;
+    }
+    void window.hermesAPI
+      .getHermesOneCredits()
+      .then((r) => {
+        if (!cancelled) setCredits(r.balance);
+      })
+      .catch(() => {});
+    void window.hermesAPI
+      .ensureHermesOneKey(profile)
+      .then(async (r) => {
+        if (r.status !== "created" || cancelled) return;
+        const envData = await window.hermesAPI.getEnv(profile);
+        if (!cancelled) setEnv(envData);
+      })
+      .catch(() => {});
+    return () => {
+      cancelled = true;
+    };
+  }, [account, profile]);
+
   // Per-key debounce timers for env auto-save on change. Previously env
   // values were persisted only on input blur, so users who clicked the
   // model dropdown (triggering the model-config auto-save) without first
@@ -700,6 +734,17 @@ function Providers({
                       <RefreshCw size={11} aria-hidden="true" />
                       {t("providers.hermesAccount.syncOn")}
                     </span>
+                    {credits !== null && (
+                      <span
+                        className="hermes-account-chip"
+                        title={t("providers.hermesAccount.creditsTitle")}
+                      >
+                        <Coins size={11} aria-hidden="true" />
+                        {t("providers.hermesAccount.credits", {
+                          amount: credits.toFixed(2),
+                        })}
+                      </span>
+                    )}
                   </span>
                 </span>
                 <button
@@ -1073,11 +1118,11 @@ function Providers({
               onClick={() => setModelPickerOpen(false)}
             >
               <div
-                className="models-modal provider-modal"
+                className="models-modal model-select-modal"
                 onClick={(e) => e.stopPropagation()}
               >
                 <div className="models-modal-header">
-                  <h2 className="models-modal-title provider-modal-title">
+                  <h2 className="models-modal-title model-select-title">
                     {t("providers.model.pickerTitle")}
                   </h2>
                   <button
diff --git a/src/shared/account.ts b/src/shared/account.ts
index de9359cf6..1d795e390 100644
--- a/src/shared/account.ts
+++ b/src/shared/account.ts
@@ -13,6 +13,19 @@ export interface HermesAccount {
   user: HermesAccountUser;
 }
 
+/** Outcome of the auto-provisioned Hermes One Inference key check. */
+export interface EnsureHermesOneKeyResult {
+  status: "created" | "exists" | "signed-out" | "error";
+  error?: string;
+}
+
+/** The signed-in account's AI-credit balance (USD-denominated; null when
+ *  signed out or unavailable). */
+export interface HermesOneCreditsResult {
+  balance: number | null;
+  error?: string;
+}
+
 /** Emitted once the backend issues a device code, so the modal can show it. */
 export interface DeviceCodeInfo {
   userCode: string;
diff --git a/src/shared/i18n/locales/en/agents.ts b/src/shared/i18n/locales/en/agents.ts
index e8e676576..05e1391c8 100644
--- a/src/shared/i18n/locales/en/agents.ts
+++ b/src/shared/i18n/locales/en/agents.ts
@@ -33,6 +33,8 @@ export default {
   local: "Local",
   manageProfiles: "Manage profiles",
   switchProfile: "Switch profile",
+  stopped: "Stopped",
+  noProfilesMatch: "No profiles match",
   defaultTag: "default",
   editAppearance: "Edit profile",
   editAppearanceFor: "Edit {{name}}",
diff --git a/src/shared/i18n/locales/en/providers.ts b/src/shared/i18n/locales/en/providers.ts
index 5080f8b54..71a3546bc 100644
--- a/src/shared/i18n/locales/en/providers.ts
+++ b/src/shared/i18n/locales/en/providers.ts
@@ -14,7 +14,14 @@ export default {
     emptyHint: "No providers configured yet. Add one to get started.",
     searchPlaceholder: "Search providers…",
     allConfigured: "All providers are already configured.",
-    remove: "Remove provider",
+    remove: "Remove provider…",
+    apiKeyLabel: "API key",
+    show: "Show",
+    hide: "Hide",
+    replace: "Replace",
+    usedByModel: "Used by 1 model",
+    usedByModels: "Used by {{count}} models",
+    noModelsYet: "No models added yet",
     custom: {
       title: "Custom provider",
       pickerHint: "Any OpenAI-compatible base URL",
@@ -26,7 +33,7 @@ export default {
     status: {
       needsKey: "Add a key to connect",
       verifying: "Verifying key…",
-      verified: "Connected · key verified",
+      verified: "Key verified",
       connected: "Connected",
       failed: "Couldn't verify key",
     },
@@ -34,6 +41,9 @@ export default {
   models: {
     title: "Models",
     empty: "No models yet.",
+    addModelId: "Add model ID",
+    more: "+{{count}} more",
+    less: "Show less",
     addPlaceholder: "Add another model ID…",
     displayName: "Display name",
     contextWindow: "Context window (tokens)",
@@ -65,6 +75,9 @@ export default {
     signedInAs: "Signed in as",
     connected: "Connected",
     syncOn: "Sync on",
+    credits: "${{amount}} credits",
+    creditsTitle:
+      "AI Credits available on your Hermes One account (1 credit = $1). Top up in the Hermes One console.",
     modalTitle: "Sign in to Hermes One",
     codeHint: "Approve in your browser. Make sure it shows the same code:",
     waitingHint: "Waiting for approval…",
diff --git a/tests/constants.test.ts b/tests/constants.test.ts
index b56c0ae30..52e560093 100644
--- a/tests/constants.test.ts
+++ b/tests/constants.test.ts
@@ -8,6 +8,9 @@ import {
   OPENAI_COMPATIBLE_BASE_URLS,
   DASHSCOPE_ENDPOINTS,
   THEME_OPTIONS,
+  providerKeyRank,
+  providerNameForEnvKey,
+  providerRouteForEnvKey,
 } from "../src/renderer/src/constants";
 
 // ─── PROVIDERS ──────────────────────────────────────────
@@ -248,6 +251,101 @@ describe("LOCAL_PRESETS", () => {
   });
 });
 
+// ─── providerRouteForEnvKey ─────────────────────────────
+
+// @lat: [[provider-setup#Provider setup#Active model is picked from configured providers#Native keys without a setup card still route]]
+describe("providerRouteForEnvKey", () => {
+  // Regression: NOUS_API_KEY (and other native-provider keys whose setup card
+  // is the OAuth variant or absent) fell through to the bare `custom` fallback,
+  // so the Providers tab's Change-model picker dropped them even with a key
+  // set. Each must route to its hermes-agent slug.
+  it("routes native-provider keys to their agent slugs", () => {
+    const native: Record<string, string> = {
+      NOUS_API_KEY: "nous",
+      GLM_API_KEY: "zai",
+      KIMI_API_KEY: "kimi-coding",
+      MINIMAX_API_KEY: "minimax",
+      MINIMAX_CN_API_KEY: "minimax-cn",
+      NVIDIA_API_KEY: "nvidia",
+      OPENCODE_ZEN_API_KEY: "opencode-zen",
+      OPENCODE_GO_API_KEY: "opencode-go",
+      HF_TOKEN: "huggingface",
+    };
+    for (const [envKey, slug] of Object.entries(native)) {
+      expect(providerRouteForEnvKey(envKey)).toEqual({
+        provider: slug,
+        baseUrl: "",
+      });
+    }
+  });
+
+  it("orders Hermes One first and AIML API last among LLM keys", () => {
+    const llm = SETTINGS_SECTIONS.find(
+      (s) => s.title === "constants.sectionLlmProviders",
+    )!;
+    const ordered = llm.items
+      .filter((f) => f.key !== "CUSTOM_API_KEY")
+      .map((f, i) => ({ key: f.key, i }))
+      .sort(
+        (a, b) => providerKeyRank(a.key) - providerKeyRank(b.key) || a.i - b.i,
+      )
+      .map((x) => x.key);
+
+    expect(ordered[0]).toBe("HERMESONE_API_KEY");
+    expect(ordered[ordered.length - 1]).toBe("AIMLAPI_API_KEY");
+    // A well-known provider outranks a niche one it followed in FieldDef order.
+    expect(ordered.indexOf("ANTHROPIC_API_KEY")).toBeLessThan(
+      ordered.indexOf("AIMLAPI_API_KEY"),
+    );
+    expect(ordered.indexOf("OPENAI_API_KEY")).toBeLessThan(
+      ordered.indexOf("OLLAMA_API_KEY"),
+    );
+  });
+
+  it("routes Perplexity as an OpenAI-compatible custom endpoint", () => {
+    expect(providerRouteForEnvKey("PERPLEXITY_API_KEY")).toEqual({
+      provider: "custom",
+      baseUrl: OPENAI_COMPATIBLE_BASE_URLS.perplexity,
+    });
+  });
+
+  // The provider cards/picker show plain provider names ("Hermes One"), not
+  // the FieldDef's "… API Key" label. Every LLM-section key must resolve to a
+  // name so no card falls back to the noisy label.
+  it("resolves a plain provider name for every LLM-provider key", () => {
+    const llm = SETTINGS_SECTIONS.find(
+      (s) => s.title === "constants.sectionLlmProviders",
+    );
+    expect(llm).toBeDefined();
+    for (const f of llm!.items) {
+      if (f.key === "CUSTOM_API_KEY") continue; // generic bucket — no brand
+      expect(
+        providerNameForEnvKey(f.key),
+        `${f.key} has no provider display name`,
+      ).toBeTruthy();
+    }
+  });
+
+  // Every password-type key in the LLM Providers section must resolve to a
+  // usable route: either a native agent slug or `custom` with a non-empty base
+  // URL. A bare `custom` route (empty base URL) is silently dropped by the
+  // active-model picker — exactly the bug that hid Nous Portal.
+  it("leaves no LLM-provider FieldDef on the dead custom fallback", () => {
+    const llm = SETTINGS_SECTIONS.find(
+      (s) => s.title === "constants.sectionLlmProviders",
+    );
+    expect(llm).toBeDefined();
+    for (const f of llm!.items) {
+      if (f.key === "CUSTOM_API_KEY") continue; // the generic bucket, by design
+      const route = providerRouteForEnvKey(f.key);
+      expect(
+        route.provider !== "custom" || route.baseUrl !== "",
+        `${f.key} falls through to the bare custom route`,
+      ).toBe(true);
+    }
+  });
+});
+
 describe("DASHSCOPE_ENDPOINTS", () => {
   it("offers mainland and international DashScope endpoints", () => {
     expect(DASHSCOPE_ENDPOINTS).toEqual([
diff --git a/tests/dashboard-chat-transport.test.ts b/tests/dashboard-chat-transport.test.ts
index 2b2a76a55..af834f008 100644
--- a/tests/dashboard-chat-transport.test.ts
+++ b/tests/dashboard-chat-transport.test.ts
@@ -646,6 +646,38 @@ describe("resolveDashboardProviderForModel", () => {
     ).toBe("custom");
   });
 
+  // Regression: `/model hermesone-swift --provider custom` let the agent bind
+  // "custom" to the session's *current* base URL — a session sitting on Nous
+  // sent the Hermes One model to the Nous proxy (404 "not in our configuration
+  // or OpenRouter catalog"). A named user-provider row on the same endpoint
+  // (the mirrored config.yaml `providers: hermesone:` entry) must win.
+  it("resolves custom rows to a named user provider on the same endpoint", () => {
+    expect(
+      resolveDashboardProviderForModel(
+        "custom",
+        "hermesone-swift",
+        "https://inference.hermesone.org/v1",
+        {
+          provider: "nous",
+          model: "moonshotai/kimi-k3",
+          providers: [
+            {
+              slug: "nous",
+              name: "Nous Portal",
+              models: ["moonshotai/kimi-k3"],
+            },
+            {
+              slug: "hermesone",
+              name: "Hermes One",
+              api_url: "https://inference.hermesone.org/v1/",
+              models: [],
+            },
+          ],
+        },
+      ),
+    ).toBe("hermesone");
+  });
+
   it("resolves Hermes One custom rows to dashboard custom provider slugs by base URL", () => {
     expect(
       resolveDashboardProviderForModel(
diff --git a/tests/models-agent-config-sync.test.ts b/tests/models-agent-config-sync.test.ts
new file mode 100644
index 000000000..1fe62691e
--- /dev/null
+++ b/tests/models-agent-config-sync.test.ts
@@ -0,0 +1,76 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+/**
+ * Terminal ↔ desktop model-library sync: `custom_providers:` entries in
+ * config.yaml must merge into models.json on every renderer-facing read,
+ * not only when the library is first seeded. Previously a provider added
+ * via the hermes CLI after first run never appeared in the desktop.
+ */
+
+let testHome: string;
+
+async function freshModels(): Promise<typeof import("../src/main/models")> {
+  vi.resetModules();
+  vi.stubEnv("HERMES_HOME", testHome);
+  return await import("../src/main/models");
+}
+
+function writeCustomProviders(): void {
+  writeFileSync(
+    join(testHome, "config.yaml"),
+    [
+      "custom_providers:",
+      '  - name: "Faab AI"',
+      '    base_url: "https://faab.ai/v1"',
+      '    model: "faab-large"',
+      '    api_key: "sk-faab"',
+      "",
+    ].join("\n"),
+  );
+}
+
+beforeEach(() => {
+  testHome = mkdtempSync(join(tmpdir(), "hermes-models-sync-"));
+});
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+  rmSync(testHome, { recursive: true, force: true });
+});
+
+// @lat: [[provider-setup#Provider setup#Agent config sync for named providers#Model library merges custom_providers on every read]]
+describe("agent-config model sync", () => {
+  it("merges custom_providers entries added after first seed", async () => {
+    const models = await freshModels();
+    // First read seeds the defaults with no custom providers configured.
+    expect(models.listModels().some((m) => m.model === "faab-large")).toBe(
+      false,
+    );
+
+    // The user then adds a provider from the terminal.
+    writeCustomProviders();
+    const merged = models.listModels();
+    const row = merged.find((m) => m.model === "faab-large");
+    expect(row).toBeDefined();
+    expect(row).toMatchObject({
+      provider: "custom",
+      baseUrl: "https://faab.ai/v1",
+      providerLabel: "Faab AI",
+    });
+    // Its key is persisted under the desktop's derived env var.
+    const env = readFileSync(join(testHome, ".env"), "utf-8");
+    expect(env).toContain("CUSTOM_PROVIDER_FAAB_AI_KEY=sk-faab");
+  });
+
+  it("is idempotent — repeated reads don't duplicate rows", async () => {
+    writeCustomProviders();
+    const models = await freshModels();
+    models.listModels();
+    models.listModels();
+    const rows = models.listModels().filter((m) => m.model === "faab-large");
+    expect(rows).toHaveLength(1);
+  });
+});
diff --git a/tests/reconcile-streamed-with-db.test.ts b/tests/reconcile-streamed-with-db.test.ts
index 4ada74bf9..764e3e05c 100644
--- a/tests/reconcile-streamed-with-db.test.ts
+++ b/tests/reconcile-streamed-with-db.test.ts
@@ -1109,3 +1109,89 @@ describe("reconcileStreamedWithDb", () => {
     expect(merged.filter((m) => m.id === "user-active-image")).toHaveLength(1);
   });
 });
+
+/**
+ * The live reasoning stream is best-effort: dropped delta chunks leave the
+ * streamed row with garbled text whose reconciliation key can't match the
+ * canonical DB reasoning row, so both used to survive the merge — the user
+ * saw the corrupt partial AND the full thought stacked in one Thought block
+ * ("moon-k3 via provider ous" above "moonshotai/kimi-k3 via provider nous").
+ * A dropped-chunks preview is by construction a subsequence of the canonical
+ * text, which separates "same thought, chunks missing" (drop) from a distinct
+ * second reasoning segment (keep).
+ */
+describe("lossy streamed reasoning previews", () => {
+  const CANONICAL = "I'm running moonshotai/kimi-k3 via provider nous.";
+  const LOSSY = "I'm running moon-k3 via provider ous.";
+
+  // @lat: [[chat-commands#Slash command execution#Reasoning & tool activity rows#Reasoning reconciliation#Lossy live preview collapses into the DB row]]
+  it("drops a garbled streamed preview when the DB has the canonical row", () => {
+    const merged = reconcileStreamedWithDb(
+      [
+        STREAMED_USER("what model are you"),
+        STREAMED_REASONING(LOSSY, "r-lossy"),
+      ],
+      [DB_USER("what model are you", 1), DB_REASONING(CANONICAL, 2)],
+    );
+
+    const reasoning = merged.filter(
+      (m) => "kind" in m && m.kind === "reasoning",
+    );
+    expect(reasoning).toHaveLength(1);
+    expect((reasoning[0] as { text: string }).text).toBe(CANONICAL);
+  });
+
+  // @lat: [[chat-commands#Slash command execution#Reasoning & tool activity rows#Reasoning reconciliation#Distinct live segments survive]]
+  it("keeps a live second reasoning segment that is not a lossy duplicate", () => {
+    const SECOND = "Now checking the weather tool output.";
+    const merged = reconcileStreamedWithDb(
+      [
+        STREAMED_USER("hi"),
+        STREAMED_REASONING(CANONICAL, "r-seg-1"),
+        STREAMED_REASONING(SECOND, "r-seg-2"),
+      ],
+      [DB_USER("hi", 1), DB_REASONING(CANONICAL, 2)],
+    );
+
+    const texts = merged
+      .filter((m) => "kind" in m && m.kind === "reasoning")
+      .map((m) => (m as { text: string }).text);
+    expect(texts).toEqual([CANONICAL, SECOND]);
+  });
+
+  it("keeps a short thought that embeds only as scattered characters", () => {
+    // Review regression: a distinct short thought whose characters happen to
+    // appear in order inside the canonical text (as scattered 1-char
+    // fragments) is NOT a lossy preview and must survive the merge.
+    const merged = reconcileStreamedWithDb(
+      [STREAMED_USER("hi"), STREAMED_REASONING("abcdefghijkl", "r-scattered")],
+      [DB_USER("hi", 1), DB_REASONING("a1b2c3d4e5f6g7h8i9j0k1l2", 2)],
+    );
+
+    const texts = merged
+      .filter((m) => "kind" in m && m.kind === "reasoning")
+      .map((m) => (m as { text: string }).text);
+    expect(texts).toContain("abcdefghijkl");
+    expect(texts).toContain("a1b2c3d4e5f6g7h8i9j0k1l2");
+  });
+
+  // @lat: [[chat-commands#Slash command execution#Reasoning & tool activity rows#Reasoning reconciliation#Turn-scoped matching]]
+  it("does not cross-drop against a DB reasoning row from another turn", () => {
+    // Turn 1 is fully reconciled (DB); turn 2's live preview happens to be a
+    // subsequence of turn 1's canonical text but belongs to a different turn,
+    // so it must be kept.
+    const merged = reconcileStreamedWithDb(
+      [
+        STREAMED_USER("first", "u-1"),
+        STREAMED_USER("second", "u-2"),
+        STREAMED_REASONING(LOSSY, "r-turn-2"),
+      ],
+      [DB_USER("first", 1), DB_REASONING(CANONICAL, 2), DB_USER("second", 3)],
+    );
+
+    const texts = merged
+      .filter((m) => "kind" in m && m.kind === "reasoning")
+      .map((m) => (m as { text: string }).text);
+    expect(texts).toEqual([CANONICAL, LOSSY]);
+  });
+});