fix(core): import credentials from previous channel database

packages/core/src/database/migration.gen.ts

@@ -42,5 +42,6 @@ export const migrations = (
     import("./migration/20260622202450_simplify_session_input"),
     import("./migration/20260804233008_loose_psylocke"),
     import("./migration/20260805200742_import_legacy_credentials"),
+    import("./migration/20260806200000_import_next_credentials"),
   ])
 ).map((module) => module.default) satisfies DatabaseMigration.Migration[]

packages/core/src/database/migration/20260806200000_import_next_credentials.ts

@@ -0,0 +1,89 @@
+import path from "node:path"
+import { existsSync } from "node:fs"
+import { sql } from "drizzle-orm"
+import { Effect, Option, Schema } from "effect"
+import { Credential } from "@opencode-ai/schema/credential"
+import { Global } from "@opencode-ai/util/global"
+import type { DatabaseMigration } from "../migration"
+
+const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
+const decodeValue = Schema.decodeUnknownOption(Credential.Value)
+
+export default {
+  id: "20260806200000_import_next_credentials",
+  up(tx) {
+    return importNextCredentials(tx, path.join(Global.Path.data, "opencode-next.db"))
+  },
+} satisfies DatabaseMigration.Migration
+
+/**
+ * The next channel stored credentials in its own `opencode-next.db` before the
+ * channel databases were consolidated into `opencode.db`. The legacy import
+ * only reads V1 `auth.json`, so a credential that existed only in the previous
+ * channel database was silently dropped. Copy those rows over, keeping any
+ * credential the target database already has for the same integration.
+ */
+export function importNextCredentials(tx: Parameters<DatabaseMigration.Migration["up"]>[0], sourcePath: string) {
+  return Effect.gen(function* () {
+    if (!existsSync(sourcePath)) return
+    for (const row of yield* readSourceCredentials(sourcePath)) {
+      const integrationID = typeof row.integration_id === "string" && row.integration_id.length ? row.integration_id : undefined
+      if (!integrationID) continue
+      if (typeof row.value !== "string") continue
+      const json = Option.getOrUndefined(decodeJson(row.value))
+      if (json === undefined || Option.isNone(decodeValue(json))) continue
+      if (yield* tx.get(sql`SELECT id FROM credential WHERE integration_id = ${integrationID}`)) continue
+      const now = Date.now()
+      yield* tx.run(sql`
+        INSERT OR IGNORE INTO credential (
+          id, integration_id, label, value, connector_id, method_id, active, time_created, time_updated
+        ) VALUES (
+          ${typeof row.id === "string" && row.id.length ? row.id : Credential.ID.create()},
+          ${integrationID},
+          ${typeof row.label === "string" && row.label.length ? row.label : "default"},
+          ${row.value},
+          ${typeof row.connector_id === "string" ? row.connector_id : null},
+          ${typeof row.method_id === "string" ? row.method_id : null},
+          ${typeof row.active === "number" ? row.active : null},
+          ${typeof row.time_created === "number" ? row.time_created : now},
+          ${typeof row.time_updated === "number" ? row.time_updated : now}
+        )
+      `)
+    }
+  })
+}
+
+type SourceRow = Record<string, unknown>
+
+// An unreadable or incompatible source database skips the import instead of
+// failing the migration and blocking startup; the source is never modified.
+function readSourceCredentials(sourcePath: string) {
+  return Effect.scoped(
+    Effect.gen(function* () {
+      const sqlite = yield* Effect.promise(() => import("bun:sqlite"))
+      const source = yield* Effect.acquireRelease(
+        Effect.try({
+          try: () => new sqlite.Database(sourcePath, { readonly: true, strict: true }),
+          catch: (error) => error,
+        }),
+        (database) => Effect.sync(() => database.close()),
+      )
+      return yield* Effect.try({
+        try: () => {
+          const table = source
+            .query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'credential'")
+            .get()
+          if (!table) return [] as SourceRow[]
+          return source.query<SourceRow, []>("SELECT * FROM credential").all()
+        },
+        catch: (error) => error,
+      })
+    }),
+  ).pipe(
+    Effect.catch((error) =>
+      Effect.logWarning("Skipped incompatible opencode-next.db credentials", { path: sourcePath, error }).pipe(
+        Effect.as([] as SourceRow[]),
+      ),
+    ),
+  )
+}

packages/core/test/database-migration.test.ts

@@ -12,6 +12,7 @@ import { Database } from "@opencode-ai/core/database/database"
 import { tmpdir } from "./fixture/tmpdir"
 import type { SqlClient } from "effect/unstable/sql/SqlClient"
 import { importLegacyCredentials } from "@opencode-ai/core/database/migration/20260805200742_import_legacy_credentials"
+import { importNextCredentials } from "@opencode-ai/core/database/migration/20260806200000_import_next_credentials"
 
 const run = <A, E>(effect: Effect.Effect<A, E, SqlClient>) =>
   Effect.runPromise(
@@ -164,6 +165,75 @@ describe("DatabaseMigration", () => {
     expect(await Bun.file(source).text()).toBe(content)
   })
 
+  test("imports previous channel database credentials without replacing existing integrations", async () => {
+    await using tmp = await tmpdir()
+    const source = path.join(tmp.path, "opencode-next.db")
+    const { Database: Sqlite } = await import("bun:sqlite")
+    const sourceDb = new Sqlite(source, { strict: true })
+    sourceDb.run(`
+      CREATE TABLE credential (
+        id text PRIMARY KEY, integration_id text, label text NOT NULL, value text NOT NULL,
+        connector_id text, method_id text, active integer, time_created integer NOT NULL, time_updated integer NOT NULL
+      )
+    `)
+    const insert = sourceDb.prepare(
+      "INSERT INTO credential (id, integration_id, label, value, connector_id, method_id, active, time_created, time_updated) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+    )
+    insert.run("cred_next_opencode", "opencode", "anomaly", JSON.stringify({ type: "key", key: "zen-key" }), null, "console", null, 100, 200)
+    insert.run(
+      "cred_next_anthropic",
+      "anthropic",
+      "default",
+      JSON.stringify({ type: "oauth", methodID: "oauth", refresh: "next-refresh", access: "next-access", expires: 456 }),
+      null,
+      null,
+      null,
+      100,
+      200,
+    )
+    insert.run("cred_next_invalid", "invalid", "default", "not-json", null, null, null, 100, 200)
+    sourceDb.close()
+
+    await run(
+      Effect.gen(function* () {
+        const db = yield* makeDb
+        yield* DatabaseMigration.apply(db)
+        const now = Date.now()
+        yield* db.run(sql`
+          INSERT INTO credential (id, integration_id, label, value, time_created, time_updated)
+          VALUES ('existing', 'anthropic', 'Existing', ${JSON.stringify({ type: "key", key: "current-key" })}, ${now}, ${now})
+        `)
+
+        yield* db.transaction((tx) => importNextCredentials(tx, source))
+        // A second run is a no-op because the integration now has a credential.
+        yield* db.transaction((tx) => importNextCredentials(tx, source))
+        // A missing source database is a no-op.
+        yield* db.transaction((tx) => importNextCredentials(tx, path.join(tmp.path, "missing.db")))
+
+        expect(
+          yield* db.all(sql`SELECT id, integration_id, label, value, method_id, time_created FROM credential ORDER BY integration_id`),
+        ).toEqual([
+          {
+            id: "existing",
+            integration_id: "anthropic",
+            label: "Existing",
+            value: JSON.stringify({ type: "key", key: "current-key" }),
+            method_id: null,
+            time_created: now,
+          },
+          {
+            id: "cred_next_opencode",
+            integration_id: "opencode",
+            label: "anomaly",
+            value: JSON.stringify({ type: "key", key: "zen-key" }),
+            method_id: "console",
+            time_created: 100,
+          },
+        ])
+      }),
+    )
+  })
+
   test("rolls back a failed migration without recording it", async () => {
     await run(
       Effect.gen(function* () {

packages/tui/src/component/dialog-integration.tsx

@@ -6,6 +6,7 @@ import type {
   IntegrationOauthConnectOutput,
   IntegrationOAuthMethod,
 } from "@opencode-ai/client"
+import open from "open"
 import { createMemo, createSignal, onCleanup, onMount, Show } from "solid-js"
 import { useClipboard } from "../context/clipboard"
 import { useData } from "../context/data"
@@ -445,6 +446,19 @@ function OAuthAuto(props: {
   Keymap.createLayer(() => ({
     mode: "modal",
     commands: [
+      {
+        bind: "o",
+        title: "Open authorization URL",
+        group: "Dialog",
+        run: () => {
+          open(props.attempt.url).catch(() =>
+            toast.show({
+              message: "Could not open the browser. Copy the URL and continue manually.",
+              variant: "error",
+            }),
+          )
+        },
+      },
       {
         bind: "c",
         title: "Copy authorization details",
@@ -502,6 +516,7 @@ function OAuthAuto(props: {
       instructions={props.attempt.instructions}
       message="Waiting for authorization..."
       copy
+      open
     />
   )
 }
@@ -559,7 +574,14 @@ function OAuthCode(props: {
   )
 }
 
-function OAuthView(props: { title: string; url?: string; instructions?: string; message: string; copy?: boolean }) {
+function OAuthView(props: {
+  title: string
+  url?: string
+  instructions?: string
+  message: string
+  copy?: boolean
+  open?: boolean
+}) {
   const dialog = useDialog()
   const theme = useTheme("elevated")
   return (
@@ -583,11 +605,18 @@ function OAuthView(props: { title: string; url?: string; instructions?: string;
         )}
       </Show>
       <text fg={theme.text.subdued}>{props.message}</text>
-      <Show when={props.copy}>
-        <text fg={theme.text.default}>
-          c <span style={{ fg: theme.text.subdued }}>copy</span>
-        </text>
-      </Show>
+      <box flexDirection="row" gap={2}>
+        <Show when={props.open}>
+          <text fg={theme.text.default}>
+            o <span style={{ fg: theme.text.subdued }}>open</span>
+          </text>
+        </Show>
+        <Show when={props.copy}>
+          <text fg={theme.text.default}>
+            c <span style={{ fg: theme.text.subdued }}>copy</span>
+          </text>
+        </Show>
+      </box>
     </box>
   )
 }

packages/tui/src/component/dialog-model.tsx

@@ -8,21 +8,17 @@ import * as fuzzysort from "fuzzysort"
 import { useConnected } from "./use-connected"
 import { useData } from "../context/data"
 import { modelPreferenceKey } from "../model-preference"
-import { useLocation } from "../context/location"
 
 export function DialogModel(props: { providerID?: string }) {
   const local = useLocal()
   const data = useData()
   const dialog = useDialog()
-  const location = useLocation()
   const [query, setQuery] = createSignal("")
   const favoritePriority = new Set(local.model.favorite().map(modelPreferenceKey))
 
   const connected = useConnected()
-  const providers = createMemo(
-    () => new Map((data.location.provider.list(location.ref) ?? []).map((item) => [item.id, item])),
-  )
-  const models = createMemo(() => data.location.model.list(location.ref) ?? [])
+  const providers = createMemo(() => new Map((data.location.provider.list() ?? []).map((item) => [item.id, item])))
+  const models = createMemo(() => data.location.model.list() ?? [])
 
   const showExtra = createMemo(() => connected() && !props.providerID)
 

packages/tui/src/component/prompt/index.tsx

@@ -327,6 +327,10 @@ export function Prompt(props: PromptProps) {
     if (!session) return
     const agent = session.agent && local.agent.list().find((agent) => agent.id === session.agent)
     if (agent && !args.agent) local.agent.set(agent.id)
+    if (session.model) {
+      local.model.set({ providerID: session.model.providerID, modelID: session.model.id })
+      local.model.variant.set(session.model.variant)
+    }
     syncedSessionID = sessionID
   })
 
@@ -939,25 +943,6 @@ export function Prompt(props: PromptProps) {
       await slash.command.run(slash.input)
       return true
     }
-    const inputText = expandTrackedPastedText(
-      store.prompt.text,
-      input.extmarks.getAllForTypeId(promptPartTypeId).flatMap((extmark) => {
-        const ref = store.extmarkToPart.get(extmark.id)
-        if (ref?.type !== "pasted") return []
-        const part = store.prompt.pasted[ref.index]
-        if (!part) return []
-        return [{ start: extmark.start, end: extmark.end, text: part.text }]
-      }),
-    )
-    const slashHead = parseSlashHead(inputText, /\s/)
-    const isSkill =
-      slashHead !== undefined &&
-      (data.location.skill.list(currentLocation.ref) ?? []).some(
-        (skill) => skill.slash === true && skill.id === slashHead.name,
-      )
-    const isCommand =
-      slashHead !== undefined &&
-      (data.location.command.list(currentLocation.ref) ?? []).some((command) => command.name === slashHead.name)
     const agent = local.agent.current()
     if (!agent) return false
     const selectedModel = local.model.current()
@@ -965,15 +950,6 @@ export function Prompt(props: PromptProps) {
       void promptModelWarning()
       return false
     }
-    const usesModel = !props.sessionID || (store.mode !== "shell" && !isSkill)
-    if (usesModel && !local.model.available(selectedModel)) {
-      toast.show({
-        title: "Model unavailable",
-        message: `${selectedModel.providerID}/${selectedModel.modelID} is not available in this session's location`,
-        variant: "warning",
-      })
-      return false
-    }
 
     const variant = local.model.variant.current()
     let sessionID = props.sessionID
@@ -1014,6 +990,17 @@ export function Prompt(props: PromptProps) {
       session = created
     }
 
+    const inputText = expandTrackedPastedText(
+      store.prompt.text,
+      input.extmarks.getAllForTypeId(promptPartTypeId).flatMap((extmark) => {
+        const ref = store.extmarkToPart.get(extmark.id)
+        if (ref?.type !== "pasted") return []
+        const part = store.prompt.pasted[ref.index]
+        if (!part) return []
+        return [{ start: extmark.start, end: extmark.end, text: part.text }]
+      }),
+    )
+
     // Capture mode before it gets reset
     const currentMode = store.mode
     const editorSelection = editorContext()
@@ -1026,30 +1013,43 @@ export function Prompt(props: PromptProps) {
         command: inputText,
       })
       setStore("mode", "normal")
-    } else if (slashHead && isCommand) {
+    } else if (
+      inputText.startsWith("/") &&
+      (data.location.command.list(currentLocation.current) ?? []).some(
+        (command) => command.name === inputText.split("\n")[0].split(" ")[0].slice(1),
+      )
+    ) {
       move.startSubmit()
-      const model = { providerID: selectedModel.providerID, id: selectedModel.modelID, variant }
-      const cancelCommit = local.model.expectCommit(sessionID, model)
+      // Parse command from first line, preserve multi-line content in arguments
+      const firstLineEnd = inputText.indexOf("\n")
+      const firstLine = firstLineEnd === -1 ? inputText : inputText.slice(0, firstLineEnd)
+      const [command, ...firstLineArgs] = firstLine.split(" ")
+      const restOfInput = firstLineEnd === -1 ? "" : inputText.slice(firstLineEnd + 1)
+      const args = firstLineArgs.join(" ") + (restOfInput ? "\n" + restOfInput : "")
 
       void client.api.session
         .command({
           sessionID,
-          command: slashHead.name,
-          arguments: slashHead.arguments,
+          command: command.slice(1),
+          arguments: args,
           agent: agent.id,
-          model,
+          model: { providerID: selectedModel.providerID, id: selectedModel.modelID, variant },
           files: store.prompt.files,
           agents: store.prompt.agents,
         })
         .catch((error) => {
-          cancelCommit()
           toast.show({ title: "Failed to run command", message: errorMessage(error), variant: "error" })
         })
-    } else if (isSkill) {
+    } else if (
+      inputText.startsWith("/") &&
+      (data.location.skill.list(currentLocation.current) ?? []).some(
+        (skill) => skill.slash === true && skill.id === inputText.split("\n")[0].split(" ")[0].slice(1),
+      )
+    ) {
       move.startSubmit()
       void client.api.session.skill({
         sessionID,
-        skill: slashHead!.name,
+        skill: inputText.split("\n")[0].split(" ")[0].slice(1),
       })
     } else {
       move.startSubmit()
@@ -1065,11 +1065,9 @@ export function Prompt(props: PromptProps) {
         session.model.id !== selectedModel.modelID ||
         (session.model.variant ?? "default") !== (variant ?? "default")
       ) {
-        const model = { providerID: selectedModel.providerID, id: selectedModel.modelID, variant }
-        const cancelCommit = local.model.expectCommit(sessionID, model)
-        await client.api.session.switchModel({ sessionID, model }).catch((error) => {
-          cancelCommit()
-          throw error
+        await client.api.session.switchModel({
+          sessionID,
+          model: { providerID: selectedModel.providerID, id: selectedModel.modelID, variant },
         })
       }
       if (session?.revert) {
@@ -1322,7 +1320,10 @@ export function Prompt(props: PromptProps) {
       return `Ask anything... "${list()[store.placeholder % list().length]}"`
     })()
     if (!value) return undefined
-    const width = dimensions().width < 44 ? dimensions().width - 5 : Math.min(75, dimensions().width - 4) - 5
+    const width =
+      dimensions().width < 44
+        ? dimensions().width - 5
+        : Math.min(75, dimensions().width - 4) - 5
     return Locale.takeWidth(value, Math.max(1, width)).trimEnd()
   })
   const locationLabel = createMemo(() => {

packages/tui/src/context/local.tsx

@@ -1,7 +1,7 @@
 import { createStore } from "solid-js/store"
 import { dedupeWith } from "effect/Array"
 import { createSimpleContext } from "./helper"
-import { batch, createMemo, onCleanup } from "solid-js"
+import { batch, createMemo } from "solid-js"
 import { useEvent } from "./event"
 import path from "path"
 import { useTuiPaths } from "./runtime"
@@ -22,7 +22,6 @@ import { useToast } from "../ui/toast"
 import { useRoute } from "./route"
 import { useData } from "./data"
 import { usePermission } from "./permission"
-import { useLocation } from "./location"
 
 export function parseModel(model: string) {
   const [providerID, ...rest] = model.split("/")
@@ -58,29 +57,26 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
     const args = useArgs()
     const event = useEvent()
     const permission = usePermission()
-    const location = useLocation()
-
-    const models = () => data.location.model.list(location.ref)
-    const providers = () => data.location.provider.list(location.ref)
 
     function isModelValid(model: ModelPreferenceModel) {
-      return !!models()?.some((item) => item.providerID === model.providerID && item.id === model.modelID)
+      return !!data.location.model
+        .list()
+        ?.some((item) => item.providerID === model.providerID && item.id === model.modelID)
     }
 
     function getFirstValidModel(...modelFns: (() => ModelPreferenceModel | undefined)[]) {
       for (const modelFn of modelFns) {
         const model = modelFn()
-        if (model && isModelValid(model)) return model
+        if (!model) continue
+        if (isModelValid(model)) return model
       }
     }
 
     function createAgent() {
       const agents = createMemo(() =>
-        (data.location.agent.list(location.ref) ?? []).filter((agent) => agent.mode !== "subagent" && !agent.hidden),
-      )
-      const visibleAgents = createMemo(() =>
-        (data.location.agent.list(location.ref) ?? []).filter((agent) => !agent.hidden),
+        (data.location.agent.list() ?? []).filter((agent) => agent.mode !== "subagent" && !agent.hidden),
       )
+      const visibleAgents = createMemo(() => (data.location.agent.list() ?? []).filter((agent) => !agent.hidden))
       const [agentStore, setAgentStore] = createStore({
         current: undefined as string | undefined,
       })
@@ -132,26 +128,20 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
     const agent = createAgent()
 
     function createModel() {
-      type Selection = ModelPreferenceModel & { variant?: string }
       const [modelStore, setModelStore] = createStore<
         ModelPreference & {
           ready: boolean
-          defaults: Record<string, ModelPreferenceModel | undefined>
-          drafts: Record<string, Selection | undefined>
+          model: Record<string, ModelPreferenceModel>
         }
       >({
         ready: false,
-        defaults: {},
-        drafts: {},
+        model: {},
         recent: [],
         favorite: [],
         variant: {},
       })
 
       const repository = createModelPreferenceRepository(path.join(paths.state, "model.json"))
-      const pendingCommits = new Map<string, string>()
-      const commitKey = (value: ModelPreferenceModel & { variant?: string }) =>
-        `${modelPreferenceKey(value)}:${normalizeModelVariant(value.variant) ?? "default"}`
       const state = {
         pending: false,
       }
@@ -201,7 +191,7 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
           }
         }
 
-        const model = models()?.[0]
+        const model = data.location.model.list()?.[0]
         if (!model) return undefined
         return {
           providerID: model.providerID,
@@ -210,109 +200,21 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
       })
 
       const currentModel = createMemo(() => {
-        const sessionID = route.data.type === "session" ? route.data.sessionID : undefined
-        if (sessionID) return modelStore.drafts[sessionID] ?? durableSelection(sessionID)
         const a = agent.current()
-        const fallback = getFirstValidModel(
-          () => a && modelStore.defaults[agentModelKey(a.id)],
-          () => a?.model && { providerID: a.model.providerID, modelID: a.model.id },
-          fallbackModel,
+        return (
+          getFirstValidModel(
+            () => a && modelStore.model[a.id],
+            () => a?.model && { providerID: a.model.providerID, modelID: a.model.id },
+            fallbackModel,
+          ) ?? undefined
         )
-        return fallback
       })
 
-      function agentModelKey(agentID: string) {
-        const ref = location.ref ?? data.location.default()
-        return `agent:${JSON.stringify([ref.directory, ref.workspaceID])}:${agentID}`
-      }
-
-      function durableSelection(sessionID: string): Selection | undefined {
-        const model = data.session.get(sessionID)?.model
-        if (!model) return
-        return {
-          providerID: model.providerID,
-          modelID: model.id,
-          variant: normalizeModelVariant(model.variant),
-        }
-      }
-
-      function setDraft(sessionID: string, selection: Selection) {
-        const durable = durableSelection(sessionID)
-        setModelStore(
-          "drafts",
-          sessionID,
-          durable && commitKey(durable) === commitKey(selection) ? undefined : selection,
-        )
-      }
-
-      function select(model: ModelPreferenceModel) {
-        if (route.data.type === "session") {
-          const sessionID = route.data.sessionID
-          const current = modelStore.drafts[sessionID] ?? durableSelection(sessionID)
-          const preferred = normalizeModelVariant(
-            current?.providerID === model.providerID && current.modelID === model.modelID
-              ? current.variant
-              : modelStore.variant[modelPreferenceKey(model)],
-          )
-          const info = models()?.find((item) => item.providerID === model.providerID && item.id === model.modelID)
-          const variant = preferred && info?.variants?.some((item) => item.id === preferred) ? preferred : undefined
-          setDraft(sessionID, { ...model, variant })
-          return true
-        }
-        const current = agent.current()
-        if (!current) return false
-        setModelStore("defaults", agentModelKey(current.id), model)
-        return true
-      }
-
-      onCleanup(
-        event.on("session.model.selected", (evt) => {
-          const expected = pendingCommits.get(evt.data.sessionID)
-          if (!expected) return
-          pendingCommits.delete(evt.data.sessionID)
-          const committed = commitKey({
-            providerID: evt.data.model.providerID,
-            modelID: evt.data.model.id,
-            variant: evt.data.model.variant,
-          })
-          if (committed !== expected) return
-          const draft = modelStore.drafts[evt.data.sessionID]
-          if (draft && commitKey(draft) === committed) setModelStore("drafts", evt.data.sessionID, undefined)
-        }),
-      )
-
-      onCleanup(
-        event.on("session.deleted", (evt) => {
-          pendingCommits.delete(evt.data.sessionID)
-          setModelStore("drafts", evt.data.sessionID, undefined)
-        }),
-      )
-
       return {
         current: currentModel,
-        available(model = currentModel()) {
-          return model ? isModelValid(model) : false
-        },
-        expectCommit(
-          sessionID: string,
-          value: {
-            providerID: string
-            id: string
-            variant?: string
-          },
-        ) {
-          const committed = commitKey({ providerID: value.providerID, modelID: value.id, variant: value.variant })
-          pendingCommits.set(sessionID, committed)
-          return () => {
-            if (pendingCommits.get(sessionID) === committed) pendingCommits.delete(sessionID)
-          }
-        },
         get ready() {
           return modelStore.ready
         },
-        get catalogReady() {
-          return models() !== undefined
-        },
         recent() {
           return modelStore.recent
         },
@@ -328,25 +230,30 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
               reasoning: false,
             }
           }
-          const provider = providers()?.find((item) => item.id === value.providerID)
-          const info = models()?.find((item) => item.providerID === value.providerID && item.id === value.modelID)
+          const provider = data.location.provider.list()?.find((item) => item.id === value.providerID)
+          const info = data.location.model
+            .list()
+            ?.find((item) => item.providerID === value.providerID && item.id === value.modelID)
           return {
             provider: provider?.name ?? value.providerID,
-            model: info?.name ?? `${value.modelID} (unavailable)`,
+            model: info?.name ?? value.modelID,
             reasoning: (info?.variants?.length ?? 0) !== 0,
           }
         }),
         cycle(direction: 1 | -1) {
           const current = currentModel()
           if (!current) return
-          const recent = recentModels(current, modelStore.recent).filter(isModelValid)
+          const recent = modelStore.recent
           const index = recent.findIndex((x) => x.providerID === current.providerID && x.modelID === current.modelID)
-          let next = index === -1 ? (direction === 1 ? 0 : recent.length - 1) : index + direction
+          if (index === -1) return
+          let next = index + direction
           if (next < 0) next = recent.length - 1
           if (next >= recent.length) next = 0
           const val = recent[next]
           if (!val) return
-          select({ ...val })
+          const a = agent.current()
+          if (!a) return
+          setModelStore("model", a.id, { ...val })
         },
         cycleFavorite(direction: 1 | -1) {
           const favorites = modelStore.favorite.filter((item) => isModelValid(item))
@@ -372,14 +279,18 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
           }
           const next = favorites[index]
           if (!next) return
-          if (!select({ ...next })) return
+          const a = agent.current()
+          if (!a) return
+          setModelStore("model", a.id, { ...next })
           setModelStore("recent", recentModels(next, modelStore.recent))
           save()
         },
         set(model: { providerID: string; modelID: string }, options?: { recent?: boolean }) {
           batch(() => {
             if (!isModelValid(model)) return
-            if (!select(model)) return
+            const a = agent.current()
+            if (!a) return
+            setModelStore("model", a.id, model)
             if (options?.recent) {
               setModelStore("recent", recentModels(model, modelStore.recent))
               save()
@@ -406,10 +317,6 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
           selected() {
             const m = currentModel()
             if (!m) return undefined
-            if (route.data.type === "session") {
-              const selection = modelStore.drafts[route.data.sessionID] ?? durableSelection(route.data.sessionID)
-              if (selection?.providerID === m.providerID && selection.modelID === m.modelID) return selection.variant
-            }
             return normalizeModelVariant(modelStore.variant[modelPreferenceKey(m)])
           },
           current() {
@@ -420,16 +327,14 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
           list() {
             const m = currentModel()
             if (!m) return []
-            const info = models()?.find((item) => item.providerID === m.providerID && item.id === m.modelID)
+            const info = data.location.model
+              .list()
+              ?.find((item) => item.providerID === m.providerID && item.id === m.modelID)
             return info?.variants?.map((variant) => variant.id) ?? []
           },
           set(value: string | undefined) {
             const m = currentModel()
             if (!m) return
-            if (route.data.type === "session") {
-              setDraft(route.data.sessionID, { ...m, variant: normalizeModelVariant(value) })
-              return
-            }
             setModelStore("variant", modelPreferenceKey(m), normalizeModelVariant(value))
             save()
           },

packages/tui/src/routes/session/index.tsx

@@ -361,7 +361,7 @@ export function Session() {
 
   createEffect(() => {
     const current = prompt()
-    if (sent || !current || !synced() || !local.model.ready || !local.model.catalogReady) return
+    if (sent || !current || !synced() || !local.model.ready) return
     if (!local.agent.current() || !local.model.current()) return
     if (!args.prompt || route.prompt?.text !== args.prompt || current.current.text !== args.prompt) return
     sent = true

packages/tui/src/ui/link.tsx

@@ -28,7 +28,7 @@ export function Link(props: LinkProps) {
         open(props.href).catch(() => {})
       }}
     >
-      {displayText}
+      <a href={props.href}>{displayText}</a>
     </text>
   )
 }