feat(models): numbered OpenCode credential selection, labels, migration

Adopt the numbered OPENCODE_API_KEY_N scheme in the model picker and
concurrency surfaces.

- model-select: numeric sort of opencode-<n> keys (#2 before #10); friendly
  OpenCode #N labels (raw opencode-N/<model> value still selected/persisted);
  migrateLegacyModelName rewrites opencode/<model> -> opencode-1/<model>.
- ModelSelector: renders friendly key labels; surfaces a disappeared saved
  credential as UNAVAILABLE (disabled option + notice) without silently
  switching to another model.
- app store: DEFAULT_MODEL -> opencode-1/...; catalogs no longer auto-fallback
  the active model when the selected credential is absent; boot restore
  migrates persisted legacy opencode/<model> tab models idempotently.
- concurrency: providerLabel renders opencode-<n> as OpenCode #<n> in the
  limit rows and Add dropdown (raw provider id preserved on the wire).
- Tests: parsing/sorting/labels/migration, unavailable-state selector behavior,
  no-silent-fallback, and concurrency provider label; fixtures updated to the
  numbered scheme.

Verification: bun install, bun run typecheck (0 errors), bun run test
(1179 passed), bun run check (clean, exit 0), bun run build (vite OK).

5 files changed, 181 insertions, 9 deletions

diff --git a/src/features/chat/index.ts b/src/features/chat/index.ts
index 2f98a0e..8cf776b 100644
--- a/src/features/chat/index.ts
+++ b/src/features/chat/index.ts
@@ -6,7 +6,13 @@ export type {
 } from "../../core/chunks";
 export { groupRenderedChunks, resolveImageUrl, viewProviderRetry } from "../../core/chunks";
 export type { TurnMetricsEntry } from "../../core/metrics";
-export { isVisionModel } from "./model-select";
+export {
+  isNumberedOpenCode,
+  isVisionModel,
+  migrateLegacyModelName,
+  modelKeyLabel,
+  openCodeNumber,
+} from "./model-select";
 export type { ChatTransport, HistorySync, HistoryWindow, MetricsSync } from "./ports";
 export type {
   EffortOption,
diff --git a/src/features/chat/model-select.test.ts b/src/features/chat/model-select.test.ts
index 6d3081d..33c1a16 100644
--- a/src/features/chat/model-select.test.ts
+++ b/src/features/chat/model-select.test.ts
@@ -2,8 +2,11 @@ import { describe, expect, it } from "vitest";
 import {
   isVisionModel,
   joinModelName,
+  migrateLegacyModelName,
+  modelKeyLabel,
   modelKeys,
   modelsForKey,
+  openCodeNumber,
   splitModelName,
 } from "./model-select";
 
@@ -47,11 +50,64 @@ describe("modelKeys", () => {
     ).toEqual(["openai", "anthropic", "google"]);
   });
 
+  it("sorts numbered OpenCode keys numerically (#2 before #10)", () => {
+    expect(
+      modelKeys(["opencode-10/models", "opencode-2/models", "opencode-1/models", "openai/gpt-4"]),
+    ).toEqual(["opencode-1", "opencode-2", "opencode-10", "openai"]);
+  });
+
   it("is empty for no models", () => {
     expect(modelKeys([])).toEqual([]);
   });
 });
 
+describe("openCodeNumber", () => {
+  it("parses a numbered OpenCode key", () => {
+    expect(openCodeNumber("opencode-1")).toBe(1);
+    expect(openCodeNumber("opencode-10")).toBe(10);
+  });
+
+  it("returns null for non-openCode / malformed keys", () => {
+    expect(openCodeNumber("umans")).toBeNull();
+    expect(openCodeNumber("opencode")).toBeNull();
+    expect(openCodeNumber("opencode-0")).toBeNull();
+    expect(openCodeNumber("opencode-01")).toBeNull();
+  });
+});
+
+describe("modelKeyLabel", () => {
+  it("labels a numbered OpenCode key as OpenCode #N", () => {
+    expect(modelKeyLabel("opencode-2")).toBe("OpenCode #2");
+    expect(modelKeyLabel("opencode-10")).toBe("OpenCode #10");
+  });
+
+  it("leaves non-OpenCode keys unchanged", () => {
+    expect(modelKeyLabel("umans")).toBe("umans");
+  });
+});
+
+describe("migrateLegacyModelName", () => {
+  it("rewrites opencode/<model> to opencode-1/<model>", () => {
+    expect(migrateLegacyModelName("opencode/deepseek-v4-flash")).toBe(
+      "opencode-1/deepseek-v4-flash",
+    );
+    expect(migrateLegacyModelName("opencode/nested/model")).toBe("opencode-1/nested/model");
+  });
+
+  it("leaves already-numbered and other-provider names unchanged", () => {
+    expect(migrateLegacyModelName("opencode-1/deepseek-v4-flash")).toBe(
+      "opencode-1/deepseek-v4-flash",
+    );
+    expect(migrateLegacyModelName("umans/umans-glm-5.2")).toBe("umans/umans-glm-5.2");
+    expect(migrateLegacyModelName("opencode-2/x")).toBe("opencode-2/x");
+  });
+
+  it("is idempotent", () => {
+    const once = migrateLegacyModelName("opencode/deepseek-v4-flash");
+    expect(migrateLegacyModelName(once)).toBe(once);
+  });
+});
+
 describe("modelsForKey", () => {
   it("returns the model suffixes under a key, in order", () => {
     const models = ["openai/gpt-4", "anthropic/claude-3", "openai/gpt-4o"];
diff --git a/src/features/chat/model-select.ts b/src/features/chat/model-select.ts
index 602e0ef..5da6e7b 100644
--- a/src/features/chat/model-select.ts
+++ b/src/features/chat/model-select.ts
@@ -29,15 +29,61 @@ export function joinModelName(key: string, model: string): string {
 /** Distinct keys across all models, in first-seen order. */
 export function modelKeys(models: readonly string[]): string[] {
   const seen = new Set<string>();
-  const out: string[] = [];
+  const openCodeKeys: Array<{ key: string; n: number }> = [];
+  const otherKeys: string[] = [];
   for (const full of models) {
     const { key } = splitModelName(full);
-    if (!seen.has(key)) {
-      seen.add(key);
-      out.push(key);
-    }
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const n = openCodeNumber(key);
+    if (n !== null) openCodeKeys.push({ key, n });
+    else otherKeys.push(key);
   }
-  return out;
+  // Numbered OpenCode credentials sort NUMERICALLY (#2 before #10), placed
+  // before other providers (the primary credential in this app). Others keep
+  // first-seen order.
+  openCodeKeys.sort((a, b) => a.n - b.n);
+  return [...openCodeKeys.map((e) => e.key), ...otherKeys];
+}
+
+/**
+ * The stable numeric identity of a numbered OpenCode provider id/key
+ * (`opencode-1` → 1, `opencode-10` → 10), or `null` when the id is not a
+ * numbered OpenCode key. Numbers are canonical positive integers with no
+ * leading zeros.
+ */
+export function openCodeNumber(key: string): number | null {
+  const m = /^opencode-([1-9][0-9]*)$/.exec(key);
+  return m === null ? null : Number(m[1]);
+}
+
+/** True iff `id` is a numbered OpenCode provider/key (`opencode-<n>`). */
+export function isNumberedOpenCode(id: string): boolean {
+  return openCodeNumber(id) !== null;
+}
+
+/**
+ * A friendly human label for a model key/provider id: `opencode-<n>` →
+ * "OpenCode #<n>"; any other id is returned unchanged. The RAW id is still what
+ * gets selected/persisted — this only affects display.
+ */
+export function modelKeyLabel(key: string): string {
+  const n = openCodeNumber(key);
+  return n === null ? key : `OpenCode #${n}`;
+}
+
+/**
+ * Migration helper: rewrite a legacy `opencode/<model>` full model name to the
+ * numbered `opencode-1/<model>` namespace. Returns the input unchanged for
+ * anything that is not `opencode/`-prefixed (already-numbered names, other
+ * providers). Idempotent. This is the FE-side persisted-state migration; the
+ * backend performs its own equivalent on its own store.
+ */
+export function migrateLegacyModelName(full: string): string {
+  const legacyPrefix = "opencode/";
+  if (!full.startsWith(legacyPrefix)) return full;
+  const model = full.slice(legacyPrefix.length);
+  return model.length === 0 ? full : `opencode-1/${model}`;
 }
 
 /** The model suffixes available under a given key, in order. */
diff --git a/src/features/chat/ui.test.ts b/src/features/chat/ui.test.ts
index f4006f7..aa43e04 100644
--- a/src/features/chat/ui.test.ts
+++ b/src/features/chat/ui.test.ts
@@ -1089,6 +1089,43 @@ describe("ModelSelector", () => {
     });
     expect(screen.getByText(/auto-described/i)).toBeInTheDocument();
   });
+
+  it("labels numbered OpenCode keys as OpenCode #N and sorts them numerically", () => {
+    const models = ["opencode-10/m1", "opencode-2/m2", "opencode-1/m3"];
+    const onSelect = vi.fn();
+    render(ModelSelector, {
+      props: { models, selected: "opencode-2/m2", onSelect },
+    });
+
+    const keySelect = screen.getByRole("combobox", { name: "Key selector" });
+    const options = within(keySelect).getAllByRole("option");
+    // Numeric order: #1 < #2 < #10, and values stay RAW (opencode-N).
+    expect(options.map((o) => (o as HTMLOptionElement).value)).toEqual([
+      "opencode-1",
+      "opencode-2",
+      "opencode-10",
+    ]);
+    expect(options[0]?.textContent).toContain("OpenCode #1");
+    expect(options[1]?.textContent).toContain("OpenCode #2");
+    expect(options[2]?.textContent).toContain("OpenCode #10");
+  });
+
+  it("shows a disappeared saved credential as unavailable without silently falling back", () => {
+    // Saved selection references opencode-5, but the catalog no longer has it.
+    const models = ["opencode-1/deepseek-v4-flash"];
+    const onSelect = vi.fn();
+    render(ModelSelector, {
+      props: { models, selected: "opencode-5/deepseek-v4-flash", onSelect },
+    });
+
+    // The unavailable key is surfaced as an explicit (disabled) option + notice.
+    const keySelect = screen.getByRole("combobox", { name: "Key selector" });
+    const unavailable = within(keySelect).getByText(/OpenCode #5 \(unavailable\)/i);
+    expect(unavailable).toBeInTheDocument();
+    expect(screen.getByText(/Selected model .* unavailable/)).toBeInTheDocument();
+    // No silent switch is attempted.
+    expect(onSelect).not.toHaveBeenCalled();
+  });
 });
 
 describe("ReasoningEffortSelector", () => {
diff --git a/src/features/chat/ui/ModelSelector.svelte b/src/features/chat/ui/ModelSelector.svelte
index 11b9feb..1d06848 100644
--- a/src/features/chat/ui/ModelSelector.svelte
+++ b/src/features/chat/ui/ModelSelector.svelte
@@ -1,6 +1,13 @@
 <script lang="ts">
   import type { ModelMetadata } from "@dispatch/transport-contract";
-  import { isVisionModel, joinModelName, modelKeys, modelsForKey, splitModelName } from "../model-select";
+  import {
+    isVisionModel,
+    joinModelName,
+    modelKeyLabel,
+    modelKeys,
+    modelsForKey,
+    splitModelName,
+  } from "../model-select";
 
   let {
     models,
@@ -27,8 +34,17 @@
   // Whether the currently-selected full model name is vision-capable.
   const selectedVision = $derived(isVisionModel(modelInfo, selected));
 
+  // Whether the currently-selected full name is PRESENT in the catalog. When a
+  // saved credential/model disappears, we show it as unavailable rather than
+  // silently switching to something else.
+  const selectedUnavailable = $derived(selected !== "" && !models.includes(selected));
+  // The key part is itself missing from the catalog (e.g. a whole numbered
+  // OpenCode credential was removed).
+  const keyUnavailable = $derived(selected !== "" && !keys.includes(current.key));
+
   // Switching key jumps to the first model available under it.
   function selectKey(key: string): void {
+    if (key === current.key) return;
     const first = modelsForKey(models, key)[0] ?? "";
     onSelect(joinModelName(key, first));
   }
@@ -50,8 +66,11 @@
     onchange={(e) => selectKey(e.currentTarget.value)}
     aria-label="Key selector"
   >
+    {#if keyUnavailable}
+      <option value={current.key} disabled>{modelKeyLabel(current.key)} (unavailable)</option>
+    {/if}
     {#each keys as key (key)}
-      <option value={key}>{key}</option>
+      <option value={key}>{modelKeyLabel(key)}</option>
     {/each}
   </select>
   <select
@@ -65,7 +84,15 @@
         {model}{#if isVisionModel(modelInfo, fullNameFor(model))} · vision{/if}
       </option>
     {/each}
+    {#if selectedUnavailable && !keyUnavailable}
+      <option value={current.model} disabled>{current.model} (unavailable)</option>
+    {/if}
   </select>
+  {#if selectedUnavailable}
+    <div class="text-xs text-warning" role="status">
+      Selected model “{selected}” is unavailable — choose another credential.
+    </div>
+  {/if}
   {#if selectedVision}
     <div class="flex items-center gap-1 text-xs text-base-content/60">
       <svg