From b6335144e4e1be49ba14a0e65919a905bb1e75a8 Mon Sep 17 00:00:00 2001
From: deymosh <232244450+deymosh@users.noreply.github.com>
Date: Thu, 8 Oct 2026 19:59:48 +0200
Subject: [PATCH 1/5] feat: /compact, /undo, /redo and /share in OpenCode
 sessions
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

These commands are run by OpenCode's terminal itself, so its server does
not list them: typed on the phone they reached the model as plain text.
The driver now runs them through the server's API — summarize, revert and
unrevert, share and unshare — lists them in the command menu, and reports
each outcome as a status line. Undo takes back the last turn not yet
undone, and the line says the transcript keeps it until the next message;
a command a project defines under the same name still wins.

Co-Authored-By: Claude Code <noreply@anthropic.com>
---
 .../opencode/__tests__/opencodeDriver.test.ts |  21 ++-
 .../__tests__/opencodeSessionCommands.test.ts |  81 +++++++++++
 .../src/drivers/opencode/adapter.ts           |   9 ++
 .../agent-host/src/drivers/opencode/driver.ts |  27 +++-
 .../src/drivers/opencode/sessionCommands.ts   | 134 ++++++++++++++++++
 5 files changed, 268 insertions(+), 4 deletions(-)
 create mode 100644 packages/agent-host/src/drivers/opencode/__tests__/opencodeSessionCommands.test.ts
 create mode 100644 packages/agent-host/src/drivers/opencode/sessionCommands.ts

diff --git a/packages/agent-host/src/drivers/opencode/__tests__/opencodeDriver.test.ts b/packages/agent-host/src/drivers/opencode/__tests__/opencodeDriver.test.ts
index cddf7cc2..8df769ca 100644
--- a/packages/agent-host/src/drivers/opencode/__tests__/opencodeDriver.test.ts
+++ b/packages/agent-host/src/drivers/opencode/__tests__/opencodeDriver.test.ts
@@ -533,16 +533,18 @@ describe('OpenCode slash commands', () => {
     return client as FakeClient & { session: { command: ReturnType<typeof vi.fn>; promptAsync: ReturnType<typeof vi.fn> } };
   };
 
-  it('lists its commands with their argument placeholders as hints', async () => {
+  it('lists its commands with their argument placeholders as hints, then the ones the driver runs', async () => {
     const client = withCommands(clientWith([]));
     const ctx = recordingContext();
     const session = OpenCodeDriver.withClient(client).startSession({ sessionId: 's1', agent: 'opencode', cwd: '/tmp', model: 'a/b', resume: 'x' }, ctx);
     (client.session.get as ReturnType<typeof vi.fn>).mockResolvedValue({ data: { id: 'ses_1' }, error: undefined });
-    expect(await session.listCommands!()).toEqual([
+    const commands = await session.listCommands!();
+    expect(commands.slice(0, 3)).toEqual([
       { name: 'init', description: 'create/update AGENTS.md' },
       { name: 'review', description: 'review changes', argumentHint: '<arguments>' },
       { name: 'fix', argumentHint: '<arg1> <arg2>' },
     ]);
+    expect(commands.slice(3).map((c) => c.name)).toEqual(['compact', 'undo', 'redo', 'share', 'unshare']);
     await session.end();
   });
 
@@ -562,6 +564,21 @@ describe('OpenCode slash commands', () => {
     expect(client.session.promptAsync.mock.calls.map((c) => c[0].parts[0].text).sort()).toEqual(['/etc/hosts is broken', '/unknown thing']);
     await session.end();
   });
+
+  it('runs a typed /undo itself, never as a prompt, and reports the outcome', async () => {
+    const client = withCommands(clientWith([]));
+    const ctx = recordingContext();
+    const session = OpenCodeDriver.withClient(client).startSession({ sessionId: 's1', agent: 'opencode', cwd: '/tmp', resume: 'x' }, ctx);
+    (client.session.get as ReturnType<typeof vi.fn>).mockResolvedValue({ data: { id: 'ses_1' }, error: undefined });
+    Object.assign(client.session, {
+      messages: vi.fn().mockResolvedValue({ data: [{ info: { id: 'm1', role: 'user' }, parts: [{ type: 'text', text: 'fix it' }] }] }),
+      revert: vi.fn().mockResolvedValue({ data: {} }),
+    });
+    session.prompt('/undo');
+    await ctx.waitFor(() => ctx.entries().some((e) => e.entryType === 'status' && e.text.startsWith('Undid "fix it"')));
+    expect(client.session.promptAsync).not.toHaveBeenCalled();
+    await session.end();
+  });
 });
 
 describe('OpenCode model checks', () => {
diff --git a/packages/agent-host/src/drivers/opencode/__tests__/opencodeSessionCommands.test.ts b/packages/agent-host/src/drivers/opencode/__tests__/opencodeSessionCommands.test.ts
new file mode 100644
index 00000000..faa8f1e0
--- /dev/null
+++ b/packages/agent-host/src/drivers/opencode/__tests__/opencodeSessionCommands.test.ts
@@ -0,0 +1,81 @@
+/**
+ * The commands OpenCode's terminal runs itself (compact, undo, redo,
+ * share), run through its server API.
+ */
+import { describe, expect, it, vi } from 'vitest';
+import type { OpencodeClient } from '@opencode-ai/sdk/v2/client';
+import { SESSION_COMMANDS, sessionCommand, sessionSlashCommands, type SessionCommandContext } from '../sessionCommands';
+
+const user = (id: string, text: string) => ({ info: { id, role: 'user' }, parts: [{ type: 'text', text }] });
+const assistant = (id: string) => ({ info: { id, role: 'assistant' }, parts: [{ type: 'text', text: 'done' }] });
+
+function context(revert?: string) {
+  const session = {
+    messages: vi.fn().mockResolvedValue({ data: [user('m1', 'add a test'), assistant('m2'), user('m3', 'now rename it\nplease'), assistant('m4')] }),
+    get: vi.fn().mockResolvedValue({ data: { id: 'ses_1', ...(revert ? { revert: { messageID: revert } } : {}) } }),
+    revert: vi.fn().mockResolvedValue({ data: {} }),
+    unrevert: vi.fn().mockResolvedValue({ data: {} }),
+    summarize: vi.fn().mockResolvedValue({ data: true }),
+    share: vi.fn().mockResolvedValue({ data: { share: { url: 'https://opncd.ai/s/abc' } } }),
+    unshare: vi.fn().mockResolvedValue({ data: {} }),
+  };
+  const lines: string[] = [];
+  const ctx: SessionCommandContext = {
+    client: { session } as unknown as OpencodeClient,
+    sessionID: 'ses_1',
+    directory: '/w',
+    model: { providerID: 'ccr', modelID: 'm' },
+    status: (text) => lines.push(text),
+  };
+  return { ctx, session, lines };
+}
+
+const run = (name: string, ctx: SessionCommandContext) => SESSION_COMMANDS.find((c) => c.name === name)!.run(ctx);
+
+describe('the built-in session commands', () => {
+  it('undo takes back the last turn not yet undone', async () => {
+    const { ctx, session, lines } = context();
+    await run('undo', ctx);
+    expect(session.revert).toHaveBeenCalledWith({ sessionID: 'ses_1', directory: '/w', messageID: 'm3' });
+    expect(lines.at(-1)).toMatch(/^Undid "now rename it" and the file changes/);
+
+    const again = context('m3');
+    await run('undo', again.ctx);
+    expect(again.session.revert).toHaveBeenCalledWith({ sessionID: 'ses_1', directory: '/w', messageID: 'm1' });
+
+    const none = context('m1');
+    await run('undo', none.ctx);
+    expect(none.session.revert).not.toHaveBeenCalled();
+    expect(none.lines).toEqual(['Nothing to undo.']);
+  });
+
+  it('redo brings undone turns back, and says so when there are none', async () => {
+    const undone = context('m3');
+    await run('redo', undone.ctx);
+    expect(undone.session.unrevert).toHaveBeenCalled();
+    const none = context();
+    await run('redo', none.ctx);
+    expect(none.session.unrevert).not.toHaveBeenCalled();
+    expect(none.lines).toEqual(['Nothing to redo.']);
+  });
+
+  it("compact summarizes on the session's model; share names the link", async () => {
+    const { ctx, session, lines } = context();
+    await run('compact', ctx);
+    expect(session.summarize).toHaveBeenCalledWith({ sessionID: 'ses_1', directory: '/w', providerID: 'ccr', modelID: 'm' });
+    await run('share', ctx);
+    expect(lines.at(-1)).toContain('https://opncd.ai/s/abc');
+  });
+
+  it('a failed call is an error naming what failed', async () => {
+    const { ctx, session } = context();
+    session.revert.mockResolvedValue({ error: { data: { message: 'session is busy' } } });
+    await expect(run('undo', ctx)).rejects.toThrow('OpenCode could not undo the last turn: {"message":"session is busy"}');
+  });
+
+  it("gives way to a command of the server's with the same name", () => {
+    expect(sessionCommand('undo', new Set())?.name).toBe('undo');
+    expect(sessionCommand('undo', new Set(['undo']))).toBeUndefined();
+    expect(sessionSlashCommands(new Set(['share'])).map((c) => c.name)).toEqual(['compact', 'undo', 'redo', 'unshare']);
+  });
+});
diff --git a/packages/agent-host/src/drivers/opencode/adapter.ts b/packages/agent-host/src/drivers/opencode/adapter.ts
index b7b086d8..76258fb9 100644
--- a/packages/agent-host/src/drivers/opencode/adapter.ts
+++ b/packages/agent-host/src/drivers/opencode/adapter.ts
@@ -60,6 +60,12 @@ export interface OpenCodeError {
   content: string;
 }
 
+/** A line about the session, not from the model (a command's outcome). */
+export interface OpenCodeStatus {
+  type: 'status';
+  text: string;
+}
+
 /** The session to resume no longer exists server-side and a fresh one was
  *  created instead — the model does not remember earlier turns, which the
  *  user must not learn only through a silent id change. */
@@ -102,6 +108,7 @@ export type OpenCodeEvent =
   | OpenCodeIdle
   | OpenCodePart
   | OpenCodeError
+  | OpenCodeStatus
   | OpenCodeResumeLost
   | OpenCodeDiff
   | OpenCodeQuestion
@@ -122,6 +129,8 @@ export function opencodeEventToEntries(event: OpenCodeEvent, ctx: TranslateConte
       return parsePart(event, ctx);
     case 'error':
       return [{ entryType: 'error', text: event.content, timestamp: ts }];
+    case 'status':
+      return [{ entryType: 'status', text: event.text, timestamp: ts }];
     case 'resume-lost':
       return [{
         entryType: 'notice',
diff --git a/packages/agent-host/src/drivers/opencode/driver.ts b/packages/agent-host/src/drivers/opencode/driver.ts
index 6be47498..4095e4e0 100644
--- a/packages/agent-host/src/drivers/opencode/driver.ts
+++ b/packages/agent-host/src/drivers/opencode/driver.ts
@@ -52,6 +52,7 @@ import type {
   Subagent,
   UsageData,
 } from '../../sdk/types';
+import { SESSION_COMMANDS, sessionCommand, sessionSlashCommands } from './sessionCommands';
 import { opencodeEventToEntries, toolCallDiffs, type OpenCodeEvent } from './adapter';
 import { OpenCodeMcp, openCodeSessionMcp, toggleOpenCodeMcp } from './mcp';
 import { OpenCodePlugins } from './plugins';
@@ -841,10 +842,16 @@ export class OpenCodeSession implements DriverSession {
     const command = parseSlashCommand(text);
     this.ready
       .then(async ({ client, session }) => {
-        if (command && (await this.knownCommands(client)).has(command.name)) {
+        const listed = command ? await this.knownCommands(client) : new Set<string>();
+        if (command && listed.has(command.name)) {
           this.runCommand(client, session.id, command.name, command.args);
           return;
         }
+        const builtin = command && sessionCommand(command.name, listed);
+        if (builtin) {
+          this.runSessionCommand(client, session.id, builtin);
+          return;
+        }
         const { error } = await client.session.promptAsync({
           sessionID: session.id,
           directory: this.cwd,
@@ -859,6 +866,20 @@ export class OpenCodeSession implements DriverSession {
       });
   }
 
+  /** One of the commands OpenCode's terminal runs itself; its outcome is a
+   *  status line, its failure an error entry. */
+  private runSessionCommand(client: OpencodeClient, sessionID: string, command: (typeof SESSION_COMMANDS)[number]): void {
+    command
+      .run({
+        client,
+        sessionID,
+        directory: this.cwd,
+        ...(this.model ? { model: this.model } : {}),
+        status: (text) => this.deliver({ type: 'status', text }),
+      })
+      .catch((err) => this.deliver({ type: 'error', content: err instanceof Error ? err.message : String(err) }));
+  }
+
   /** The OpenCode agent a prompt names: the plan agent in the plan mode,
    *  none (OpenCode's default) otherwise. */
   private agentField(): { agent?: string } {
@@ -897,9 +918,11 @@ export class OpenCodeSession implements DriverSession {
     return this.commandNames;
   }
 
+  /** The server's commands, then the ones the driver runs itself. */
   async listCommands(): Promise<SlashCommand[]> {
     const { client } = await this.ready;
-    return toSlashCommands(await this.fetchCommands(client));
+    const commands = await this.fetchCommands(client);
+    return [...toSlashCommands(commands), ...sessionSlashCommands(new Set(commands.map((c) => c.name)))];
   }
 
   async mcpStatus(): Promise<SessionMcpState> {
diff --git a/packages/agent-host/src/drivers/opencode/sessionCommands.ts b/packages/agent-host/src/drivers/opencode/sessionCommands.ts
new file mode 100644
index 00000000..acc598d5
--- /dev/null
+++ b/packages/agent-host/src/drivers/opencode/sessionCommands.ts
@@ -0,0 +1,134 @@
+/**
+ * Commands OpenCode's terminal runs itself and its server does not list:
+ * compacting the conversation, undoing and redoing turns, sharing it. Each
+ * runs through the server's API, and its outcome is a status line in the
+ * transcript (the transcript keeps what an undo took back; the line says
+ * so). A command the server lists under the same name — a project's own —
+ * is the one that runs.
+ */
+import type { OpencodeClient } from '@opencode-ai/sdk/v2/client';
+import { slashCommand } from '../../sdk/commands';
+import type { SlashCommand } from '../../sdk/types';
+
+/** What a command works on and how it reports back. */
+export interface SessionCommandContext {
+  client: OpencodeClient;
+  sessionID: string;
+  directory: string;
+  /** The model the session's prompts name, if one was chosen. */
+  model?: { providerID: string; modelID: string };
+  status(text: string): void;
+}
+
+interface SessionCommand {
+  name: string;
+  description: string;
+  run(ctx: SessionCommandContext): Promise<void>;
+}
+
+/** A failed call's reason, for the error entry. */
+function failure(what: string, error: unknown): Error {
+  const detail = typeof error === 'object' && error !== null && 'data' in error ? (error as { data: unknown }).data : error;
+  return new Error(`OpenCode could not ${what}: ${JSON.stringify(detail)}`);
+}
+
+/** The first line of a prompt, short enough to name it in a status line. */
+function gist(text: string): string {
+  const line = text.trim().split('\n')[0] ?? '';
+  return line.length > 60 ? `${line.slice(0, 57)}…` : line;
+}
+
+/** The user turns of a session, oldest first, with their text. */
+async function userTurns(ctx: SessionCommandContext): Promise<Array<{ id: string; text: string }>> {
+  const { data, error } = await ctx.client.session.messages({ sessionID: ctx.sessionID, directory: ctx.directory });
+  if (error || !data) throw failure('read the conversation', error);
+  return data
+    .filter((m) => m.info.role === 'user')
+    .map((m) => ({
+      id: m.info.id,
+      text: m.parts.flatMap((p) => (p.type === 'text' && !p.synthetic ? [p.text] : [])).join('\n'),
+    }));
+}
+
+async function revertPoint(ctx: SessionCommandContext): Promise<string | undefined> {
+  const { data, error } = await ctx.client.session.get({ sessionID: ctx.sessionID, directory: ctx.directory });
+  if (error || !data) throw failure('read the session', error);
+  return data.revert?.messageID;
+}
+
+export const SESSION_COMMANDS: SessionCommand[] = [
+  {
+    name: 'compact',
+    description: 'Summarize the conversation so far, to free up context',
+    async run(ctx) {
+      ctx.status('Compacting the conversation…');
+      const { error } = await ctx.client.session.summarize({
+        sessionID: ctx.sessionID,
+        directory: ctx.directory,
+        ...(ctx.model ?? {}),
+      });
+      if (error) throw failure('compact the conversation', error);
+      ctx.status('Compacted: OpenCode continues from a summary of the conversation.');
+    },
+  },
+  {
+    name: 'undo',
+    description: 'Take back the last turn and the file changes it made',
+    async run(ctx) {
+      const [turns, point] = await Promise.all([userTurns(ctx), revertPoint(ctx)]);
+      // Turns from the revert point on are already undone.
+      const live = point ? turns.slice(0, Math.max(0, turns.findIndex((t) => t.id === point))) : turns;
+      const last = live.at(-1);
+      if (!last) {
+        ctx.status('Nothing to undo.');
+        return;
+      }
+      const { error } = await ctx.client.session.revert({ sessionID: ctx.sessionID, directory: ctx.directory, messageID: last.id });
+      if (error) throw failure('undo the last turn', error);
+      ctx.status(
+        `Undid "${gist(last.text)}" and the file changes it made. OpenCode forgets it with your next message; /redo brings it back before then.`,
+      );
+    },
+  },
+  {
+    name: 'redo',
+    description: 'Bring back the turns /undo took back',
+    async run(ctx) {
+      if (!(await revertPoint(ctx))) {
+        ctx.status('Nothing to redo.');
+        return;
+      }
+      const { error } = await ctx.client.session.unrevert({ sessionID: ctx.sessionID, directory: ctx.directory });
+      if (error) throw failure('redo', error);
+      ctx.status('Brought back the undone turns and their file changes.');
+    },
+  },
+  {
+    name: 'share',
+    description: 'Publish the conversation at a link anyone can open',
+    async run(ctx) {
+      const { data, error } = await ctx.client.session.share({ sessionID: ctx.sessionID, directory: ctx.directory });
+      if (error || !data) throw failure('share the conversation', error);
+      ctx.status(data.share?.url ? `Shared at ${data.share.url} — anyone with the link can read it. /unshare stops it.` : 'Shared.');
+    },
+  },
+  {
+    name: 'unshare',
+    description: 'Stop sharing the conversation',
+    async run(ctx) {
+      const { error } = await ctx.client.session.unshare({ sessionID: ctx.sessionID, directory: ctx.directory });
+      if (error) throw failure('stop sharing the conversation', error);
+      ctx.status('The conversation is no longer shared.');
+    },
+  },
+];
+
+/** The built-in command named `name`, unless the server lists one so named. */
+export function sessionCommand(name: string, listed: ReadonlySet<string>): SessionCommand | undefined {
+  return listed.has(name) ? undefined : SESSION_COMMANDS.find((c) => c.name === name);
+}
+
+/** The built-ins for the command menu, beside the `listed` ones. */
+export function sessionSlashCommands(listed: ReadonlySet<string>): SlashCommand[] {
+  return SESSION_COMMANDS.filter((c) => !listed.has(c.name)).map((c) => slashCommand(c.name, c.description));
+}

From 90a8657ee95bfbeec9e77c88043b2757c31332aa Mon Sep 17 00:00:00 2001
From: deymosh <232244450+deymosh@users.noreply.github.com>
Date: Thu, 8 Oct 2026 20:05:13 +0200
Subject: [PATCH 2/5] feat: OpenCode names its sessions

The driver created every OpenCode session titled with the bridge's session
id, which stops OpenCode from naming it after its first message. Sessions
are now created untitled, and the title OpenCode gives one reaches the
bridge in the session's info (a new `title` field): it wins over the
title the bridge takes from the first message and over the session-meta
topic it asks the agent for, which still sets the project.

Co-Authored-By: Claude Code <noreply@anthropic.com>
---
 crates/agent-protocol/src/messages.rs         |  5 +++
 crates/bridge-core/src/engine/host.rs         | 35 ++++++++++++-------
 crates/bridge-core/src/session.rs             |  4 +++
 crates/bridge-core/tests/cards.rs             |  2 +-
 crates/bridge-core/tests/sessions.rs          | 27 +++++++++++++-
 docs/PROTOCOL.md                              |  2 +-
 .../opencode/__tests__/opencodeDriver.test.ts | 17 +++++++++
 .../agent-host/src/drivers/opencode/driver.ts | 32 ++++++++++++++---
 packages/agent-host/src/generated/protocol.ts | 28 ++++++++++-----
 9 files changed, 125 insertions(+), 27 deletions(-)

diff --git a/crates/agent-protocol/src/messages.rs b/crates/agent-protocol/src/messages.rs
index 6f26d665..e442ebd8 100644
--- a/crates/agent-protocol/src/messages.rs
+++ b/crates/agent-protocol/src/messages.rs
@@ -195,6 +195,11 @@ pub enum SessionEvent {
         /// plan approval switched it).
         #[serde(default, skip_serializing_if = "Option::is_none")]
         mode: Option<String>,
+        /// The agent named the session itself (OpenCode titles a session
+        /// after its first message). It wins over the title the bridge takes
+        /// from that message and over the topic it asks the agent for.
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        title: Option<String>,
         #[serde(default, skip_serializing_if = "Option::is_none")]
         #[specta(type = Option<specta_typescript::Number>)]
         context_window: Option<u64>,
diff --git a/crates/bridge-core/src/engine/host.rs b/crates/bridge-core/src/engine/host.rs
index 3e39d5d7..45999158 100644
--- a/crates/bridge-core/src/engine/host.rs
+++ b/crates/bridge-core/src/engine/host.rs
@@ -64,6 +64,16 @@ pub(crate) enum HostCall {
     DeleteConversation(ConversationDelete),
 }
 
+/// The facts a `SessionEvent::Info` changed; absent = unchanged.
+struct InfoUpdate {
+    native_session_id: Option<String>,
+    model: Option<String>,
+    mode: Option<String>,
+    title: Option<String>,
+    context_window: Option<u64>,
+    context_percentage: Option<f64>,
+}
+
 /// A conversation of a deleted session, for its agent to delete.
 #[derive(Debug, Clone)]
 pub(crate) struct ConversationDelete {
@@ -503,8 +513,9 @@ impl Engine {
         }
         match event {
             SessionEvent::Ready {} => self.on_ready(session_id),
-            SessionEvent::Info { native_session_id, model, mode, context_window, context_percentage } => {
-                self.on_info(session_id, native_session_id, model, mode, context_window, context_percentage);
+            SessionEvent::Info { native_session_id, model, mode, title, context_window, context_percentage } => {
+                let info = InfoUpdate { native_session_id, model, mode, title, context_window, context_percentage };
+                self.on_info(session_id, info);
             }
             SessionEvent::Entries { entries } => self.on_entries(session_id, entries),
             SessionEvent::Turn { state } => {
@@ -542,16 +553,15 @@ impl Engine {
         self.publish_all(BridgeToPhone::SessionReady(SessionReadyMsg { pending_id: session_id.to_string(), session: info }));
     }
 
-    fn on_info(
-        &mut self,
-        session_id: &str,
-        native_session_id: Option<String>,
-        model: Option<String>,
-        mode: Option<String>,
-        context_window: Option<u64>,
-        context_percentage: Option<f64>,
-    ) {
+    fn on_info(&mut self, session_id: &str, info: InfoUpdate) {
+        let InfoUpdate { native_session_id, model, mode, title, context_window, context_percentage } = info;
         let Some(session) = self.sessions.get_mut(session_id) else { return };
+        let title = title.and_then(|t| title_from(&t));
+        if title.is_some() {
+            if let Some(run) = session.run.as_mut() {
+                run.agent_titled = true;
+            }
+        }
         let rec = &mut session.rec;
         let mut changed = false;
         let mut set = |field: &mut Option<String>, value: Option<String>| {
@@ -562,6 +572,7 @@ impl Engine {
         };
         set(&mut rec.native_session_id, native_session_id);
         set(&mut rec.model, model);
+        set(&mut rec.title, title);
         let mode_changed = mode.is_some() && rec.mode != mode;
         set(&mut rec.mode, mode.clone());
         if context_window.is_some_and(|w| w > 0) && rec.context_window != context_window {
@@ -606,7 +617,7 @@ impl Engine {
                         *text = stripped;
                         if let Some(meta) = meta.filter(|_| !run.summarized) {
                             run.summarized = true;
-                            if let Some(topic) = meta.topic {
+                            if let Some(topic) = meta.topic.filter(|_| !run.agent_titled) {
                                 session.rec.title = Some(topic);
                             }
                             if let Some(project) = meta.project {
diff --git a/crates/bridge-core/src/session.rs b/crates/bridge-core/src/session.rs
index 5a788127..734ed8be 100644
--- a/crates/bridge-core/src/session.rs
+++ b/crates/bridge-core/src/session.rs
@@ -71,6 +71,9 @@ pub(crate) struct Runner {
     pub meta_requested: bool,
     /// The session-meta tag has been read once; later ones are only stripped.
     pub summarized: bool,
+    /// The agent named the session itself: a session-meta topic no longer
+    /// renames it.
+    pub agent_titled: bool,
     /// git HEAD when the session started; a different HEAD later = a commit.
     pub base_head: Option<String>,
 }
@@ -89,6 +92,7 @@ impl Runner {
             authored: VecDeque::new(),
             meta_requested: titled,
             summarized: titled,
+            agent_titled: false,
             base_head: None,
         }
     }
diff --git a/crates/bridge-core/tests/cards.rs b/crates/bridge-core/tests/cards.rs
index e6836f9a..82705036 100644
--- a/crates/bridge-core/tests/cards.rs
+++ b/crates/bridge-core/tests/cards.rs
@@ -178,7 +178,7 @@ fn a_plan_answer_and_the_agents_mode_switch_reach_the_phone() {
     );
     assert_eq!(resolved(&rig.messages()), ["YOLO"]);
 
-    rig.host_event(&s, SessionEvent::Info { native_session_id: None, model: None, mode: Some("yolo".into()), context_window: None, context_percentage: None });
+    rig.host_event(&s, SessionEvent::Info { native_session_id: None, model: None, mode: Some("yolo".into()), title: None, context_window: None, context_percentage: None });
     let msgs = rig.messages();
     assert!(msgs.iter().any(|m| matches!(m, BridgeToPhone::OptionConfirmed(o) if o.value == "yolo")));
     assert_eq!(last_heartbeat(&msgs).sessions[0].mode.as_deref(), Some("yolo"));
diff --git a/crates/bridge-core/tests/sessions.rs b/crates/bridge-core/tests/sessions.rs
index b0c13a89..31f289b8 100644
--- a/crates/bridge-core/tests/sessions.rs
+++ b/crates/bridge-core/tests/sessions.rs
@@ -198,6 +198,7 @@ fn a_session_started_on_the_default_model_is_listed_with_it() {
         native_session_id: None,
         model: Some("m-default".into()),
         mode: None,
+        title: None,
         context_window: None,
         context_percentage: None,
     });
@@ -291,6 +292,30 @@ fn the_meta_tag_titles_the_session_once_and_is_always_stripped() {
     assert!(heartbeats(&msgs).iter().all(|h| h.sessions[0].title.as_deref() == Some("Fix login")));
 }
 
+#[test]
+fn a_title_the_agent_gives_wins_over_the_meta_topic() {
+    let mut rig = Rig::new();
+    rig.host_up();
+    let s = rig.ready_session("alpha");
+    let info = |title: &str| SessionEvent::Info {
+        native_session_id: None,
+        model: None,
+        mode: None,
+        title: Some(title.into()),
+        context_window: None,
+        context_percentage: None,
+    };
+    rig.host_event(&s, info("Fix the login redirect"));
+    rig.say(&s, "Done.\n<!-- session-meta: {\"topic\": \"Fix login\", \"project\": \"web\"} -->");
+    let hb = last_heartbeat(&rig.messages());
+    assert_eq!((hb.sessions[0].title.as_deref(), hb.sessions[0].project.as_str()), (Some("Fix the login redirect"), "web"));
+    // A later title from the agent still renames it; a blank one does not.
+    rig.host_event(&s, info("Fix the OAuth login redirect"));
+    rig.host_event(&s, info("  "));
+    let hb = last_heartbeat(&rig.messages());
+    assert_eq!(hb.sessions[0].title.as_deref(), Some("Fix the OAuth login redirect"));
+}
+
 #[test]
 fn input_to_an_unknown_session_is_no_session_and_to_an_ended_one_error() {
     let mut rig = Rig::new();
@@ -319,7 +344,7 @@ fn turn_events_drive_the_listed_state() {
 fn info_native(rig: &mut Rig, s: &str, id: &str) {
     rig.host_event(
         s,
-        SessionEvent::Info { native_session_id: Some(id.into()), model: None, mode: None, context_window: None, context_percentage: None },
+        SessionEvent::Info { native_session_id: Some(id.into()), model: None, mode: None, title: None, context_window: None, context_percentage: None },
     );
 }
 
diff --git a/docs/PROTOCOL.md b/docs/PROTOCOL.md
index b3615802..2d90538d 100644
--- a/docs/PROTOCOL.md
+++ b/docs/PROTOCOL.md
@@ -538,7 +538,7 @@ Session events are notifications: `session-event {sessionId, event}` with
 | Event | Meaning |
 |---|---|
 | `ready` | The agent accepts prompts (once per `start-session`). |
-| `info` | Changed facts only: `nativeSessionId` (the resume target), `model`, `mode`, `contextWindow`, `contextPercentage`. |
+| `info` | Changed facts only: `nativeSessionId` (the resume target), `model`, `mode`, `title` (the agent named the session; wins over the bridge's title from the first message and the session-meta topic), `contextWindow`, `contextPercentage`. |
 | `entries` | Transcript entries, in order (the bridge assigns seqs). |
 | `turn` | `running` / `idle`. |
 | `ended` | The session is gone: no `error` = a normal end; `resumeLost` = the conversation to resume no longer exists. The host forgets the session. |
diff --git a/packages/agent-host/src/drivers/opencode/__tests__/opencodeDriver.test.ts b/packages/agent-host/src/drivers/opencode/__tests__/opencodeDriver.test.ts
index 8df769ca..ed44c091 100644
--- a/packages/agent-host/src/drivers/opencode/__tests__/opencodeDriver.test.ts
+++ b/packages/agent-host/src/drivers/opencode/__tests__/opencodeDriver.test.ts
@@ -45,6 +45,23 @@ function start(client: FakeClient, overrides: Partial<StartSession> = {}, handle
   return ctx;
 }
 
+describe('OpenCode session titles', () => {
+  const updated = (title: string, sessionID = 'ses_1') => ({ type: 'session.updated', properties: { sessionID, info: { id: sessionID, title } } });
+
+  it('creates a session untitled, then reports the title OpenCode gives it, each new one once', async () => {
+    const client = clientWith([
+      updated('New session - 2026-10-08T10:00:00.000Z'),
+      updated('Fix the login redirect'),
+      updated('Fix the login redirect'),
+      updated('Other session', 'ses_other'),
+    ]);
+    const ctx = start(client);
+    await ctx.ended();
+    expect(client.session.create).toHaveBeenCalledWith({ directory: '/tmp' });
+    expect(ctx.events.filter((e) => e.type === 'info' && 'title' in e)).toEqual([{ type: 'info', title: 'Fix the login redirect' }]);
+  });
+});
+
 describe('OpenCode conversation delete', () => {
   const deleting = (result: unknown) => {
     const client = clientWith([]) as FakeClient & { session: { delete: ReturnType<typeof vi.fn> } };
diff --git a/packages/agent-host/src/drivers/opencode/driver.ts b/packages/agent-host/src/drivers/opencode/driver.ts
index 4095e4e0..c845d80e 100644
--- a/packages/agent-host/src/drivers/opencode/driver.ts
+++ b/packages/agent-host/src/drivers/opencode/driver.ts
@@ -204,6 +204,14 @@ export function pickDefaultModel(
 
 /** Why OpenCode cannot run `model`: none of its providers offers it. When
  *  the model list could not be fetched, nothing is refused. */
+/** The name OpenCode gives a session it has not titled yet
+ *  ("New session - <ISO time>"; "Child session - …" for a sub-agent's). */
+const PLACEHOLDER_TITLE = /^(New|Child) session - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+
+export function isPlaceholderTitle(title: string): boolean {
+  return PLACEHOLDER_TITLE.test(title);
+}
+
 export function unsupportedModelReason(model: string, models: ModelEntry[]): string | undefined {
   if (models.length === 0 || models.some((m) => m.id === model)) return undefined;
   return `OpenCode does not offer the model '${model}' — none of its configured providers serves it; choose one from its model list.`;
@@ -296,6 +304,8 @@ export class OpenCodeSession implements DriverSession {
   private readonly translate = newTranslateContext();
   private ended = false;
   private mode: string;
+  /** The title last reported for the session. */
+  private title: string | undefined;
   private model?: { providerID: string; modelID: string };
 
   /** messageID -> role, seeded from message.updated events, so a later
@@ -412,6 +422,7 @@ export class OpenCodeSession implements DriverSession {
       if (resumeLost) this.deliver({ type: 'resume-lost' });
       if (!this.ended) {
         this.ctx.emit({ type: 'info', nativeSessionId: session.id, ...(model ? { model } : {}), mode: this.mode });
+        this.reportTitle(session.title);
         this.deliver({ type: 'started', ...(model ? { model } : {}) });
         this.ctx.emit({ type: 'ready' });
       }
@@ -448,13 +459,14 @@ export class OpenCodeSession implements DriverSession {
         `[opencode] resume ${params.resume} not found server-side ` +
           `(${error ? JSON.stringify(error) : 'no session returned'}) — starting a fresh session instead`,
       );
-      return { session: await this.createSessionRemote(client, params), resumeLost: true };
+      return { session: await this.createSessionRemote(client), resumeLost: true };
     }
-    return { session: await this.createSessionRemote(client, params), resumeLost: false };
+    return { session: await this.createSessionRemote(client), resumeLost: false };
   }
 
-  private async createSessionRemote(client: OpencodeClient, params: StartSession): Promise<Session> {
-    const { data, error } = await client.session.create({ directory: this.cwd, title: params.sessionId });
+  /** Created untitled, so OpenCode names it after its first message. */
+  private async createSessionRemote(client: OpencodeClient): Promise<Session> {
+    const { data, error } = await client.session.create({ directory: this.cwd });
     if (error || !data) {
       throw new Error(`OpenCode session.create failed: ${JSON.stringify(error ?? 'no session returned')}`);
     }
@@ -522,6 +534,10 @@ export class OpenCodeSession implements DriverSession {
           if (!this.ended) this.ctx.emit({ type: 'turn', state: status === 'busy' ? 'running' : 'idle' });
           break;
         }
+        case 'session.updated': {
+          if (event.properties.sessionID === sessionId) this.reportTitle(event.properties.info.title);
+          break;
+        }
         case 'session.diff': {
           if (event.properties.sessionID !== sessionId) continue;
           const files = this.changedDiffs(event.properties.diff);
@@ -880,6 +896,14 @@ export class OpenCodeSession implements DriverSession {
       .catch((err) => this.deliver({ type: 'error', content: err instanceof Error ? err.message : String(err) }));
   }
 
+  /** The title OpenCode gave the session, once it has one of its own
+   *  (not the timestamp a new session starts with) — each new one once. */
+  private reportTitle(title: string | undefined): void {
+    if (!title || isPlaceholderTitle(title) || title === this.title || this.ended) return;
+    this.title = title;
+    this.ctx.emit({ type: 'info', title });
+  }
+
   /** The OpenCode agent a prompt names: the plan agent in the plan mode,
    *  none (OpenCode's default) otherwise. */
   private agentField(): { agent?: string } {
diff --git a/packages/agent-host/src/generated/protocol.ts b/packages/agent-host/src/generated/protocol.ts
index 65517ca0..84c075c4 100644
--- a/packages/agent-host/src/generated/protocol.ts
+++ b/packages/agent-host/src/generated/protocol.ts
@@ -1327,7 +1327,7 @@ export type SessionEvent = SessionEvent_Serialize | SessionEvent_Deserialize;
  */
 export type SessionEvent_Deserialize = 
 /**  The agent came up and accepts prompts. Sent once per `start-session`. */
-({ type: "ready" }) & { contextPercentage?: never; contextWindow?: never; entries?: never; error?: never; mode?: never; model?: never; nativeSessionId?: never; resumeLost?: never; state?: never } | 
+({ type: "ready" }) & { contextPercentage?: never; contextWindow?: never; entries?: never; error?: never; mode?: never; model?: never; nativeSessionId?: never; resumeLost?: never; state?: never; title?: never } | 
 /**  Session facts changed. Only the fields that changed are set. */
 ({ type: "info"; 
 /**  The agent's own conversation id — the `resume` target. */
@@ -1338,11 +1338,17 @@ model?: string | null;
  *  The agent changed its own mode (e.g. it entered plan mode, or a
  *  plan approval switched it).
  */
-mode?: string | null; contextWindow?: number | null; 
+mode?: string | null; 
+/**
+ *  The agent named the session itself (OpenCode titles a session
+ *  after its first message). It wins over the title the bridge takes
+ *  from that message and over the topic it asks the agent for.
+ */
+title?: string | null; contextWindow?: number | null; 
 /**  0–100. */
 contextPercentage?: number | null }) & { entries?: never; error?: never; resumeLost?: never; state?: never } | 
 /**  Transcript entries, in order. The bridge assigns their seqs. */
-({ type: "entries"; entries: OutputEntry_Deserialize[] }) & { contextPercentage?: never; contextWindow?: never; error?: never; mode?: never; model?: never; nativeSessionId?: never; resumeLost?: never; state?: never } | ({ type: "turn"; state: TurnState }) & { contextPercentage?: never; contextWindow?: never; entries?: never; error?: never; mode?: never; model?: never; nativeSessionId?: never; resumeLost?: never } | 
+({ type: "entries"; entries: OutputEntry_Deserialize[] }) & { contextPercentage?: never; contextWindow?: never; error?: never; mode?: never; model?: never; nativeSessionId?: never; resumeLost?: never; state?: never; title?: never } | ({ type: "turn"; state: TurnState }) & { contextPercentage?: never; contextWindow?: never; entries?: never; error?: never; mode?: never; model?: never; nativeSessionId?: never; resumeLost?: never; title?: never } | 
 /**
  *  The session is gone. Absent `error` = it ended normally. The host
  *  forgets the session after sending this.
@@ -1352,7 +1358,7 @@ contextPercentage?: number | null }) & { entries?: never; error?: never; resumeL
  *  The agent could not find the `resume` conversation, so continuing
  *  it is impossible; a new start must be fresh.
  */
-resumeLost?: boolean }) & { contextPercentage?: never; contextWindow?: never; entries?: never; mode?: never; model?: never; nativeSessionId?: never; state?: never };
+resumeLost?: boolean }) & { contextPercentage?: never; contextWindow?: never; entries?: never; mode?: never; model?: never; nativeSessionId?: never; state?: never; title?: never };
 
 /**
  *  Something a running session reports. The host translates its agent's own
@@ -1360,7 +1366,7 @@ resumeLost?: boolean }) & { contextPercentage?: never; contextWindow?: never; en
  */
 export type SessionEvent_Serialize = 
 /**  The agent came up and accepts prompts. Sent once per `start-session`. */
-({ type: "ready" }) & { contextPercentage?: never; contextWindow?: never; entries?: never; error?: never; mode?: never; model?: never; nativeSessionId?: never; resumeLost?: never; state?: never } | 
+({ type: "ready" }) & { contextPercentage?: never; contextWindow?: never; entries?: never; error?: never; mode?: never; model?: never; nativeSessionId?: never; resumeLost?: never; state?: never; title?: never } | 
 /**  Session facts changed. Only the fields that changed are set. */
 ({ type: "info"; 
 /**  The agent's own conversation id — the `resume` target. */
@@ -1371,11 +1377,17 @@ model?: string | null;
  *  The agent changed its own mode (e.g. it entered plan mode, or a
  *  plan approval switched it).
  */
-mode?: string | null; contextWindow?: number | null; 
+mode?: string | null; 
+/**
+ *  The agent named the session itself (OpenCode titles a session
+ *  after its first message). It wins over the title the bridge takes
+ *  from that message and over the topic it asks the agent for.
+ */
+title?: string | null; contextWindow?: number | null; 
 /**  0–100. */
 contextPercentage?: number | null }) & { entries?: never; error?: never; resumeLost?: never; state?: never } | 
 /**  Transcript entries, in order. The bridge assigns their seqs. */
-({ type: "entries"; entries: OutputEntry_Serialize[] }) & { contextPercentage?: never; contextWindow?: never; error?: never; mode?: never; model?: never; nativeSessionId?: never; resumeLost?: never; state?: never } | ({ type: "turn"; state: TurnState }) & { contextPercentage?: never; contextWindow?: never; entries?: never; error?: never; mode?: never; model?: never; nativeSessionId?: never; resumeLost?: never } | 
+({ type: "entries"; entries: OutputEntry_Serialize[] }) & { contextPercentage?: never; contextWindow?: never; error?: never; mode?: never; model?: never; nativeSessionId?: never; resumeLost?: never; state?: never; title?: never } | ({ type: "turn"; state: TurnState }) & { contextPercentage?: never; contextWindow?: never; entries?: never; error?: never; mode?: never; model?: never; nativeSessionId?: never; resumeLost?: never; title?: never } | 
 /**
  *  The session is gone. Absent `error` = it ended normally. The host
  *  forgets the session after sending this.
@@ -1385,7 +1397,7 @@ contextPercentage?: number | null }) & { entries?: never; error?: never; resumeL
  *  The agent could not find the `resume` conversation, so continuing
  *  it is impossible; a new start must be fresh.
  */
-resumeLost?: boolean }) & { contextPercentage?: never; contextWindow?: never; entries?: never; mode?: never; model?: never; nativeSessionId?: never; state?: never };
+resumeLost?: boolean }) & { contextPercentage?: never; contextWindow?: never; entries?: never; mode?: never; model?: never; nativeSessionId?: never; state?: never; title?: never };
 
 /**  One MCP server of a running session. */
 export type SessionMcpServer = SessionMcpServer_Serialize | SessionMcpServer_Deserialize;

From 7a86aaa91877e9727b1df3418d98bfdaa552a390 Mon Sep 17 00:00:00 2001
From: deymosh <232244450+deymosh@users.noreply.github.com>
Date: Thu, 8 Oct 2026 20:12:36 +0200
Subject: [PATCH 3/5] feat: the session's cost and its model's name in the
 controls bar

OpenCode reports what a session has cost, as it prices its models, so its
catalog entry now says it has usage: the cost, with no subscription
windows. The controls bar shows a session's cost as a pill whenever the
agent reports one above zero (Claude Code's too, which was never shown),
and the phone asks for usage again each time a turn ends, so the figure
follows the session.

The model chip ran every id through the Claude tag table, which passes
anything else through whole: an OpenCode or gateway session read
"ccr/OpenCode Go/deepseek-v4.1-flash". It now shows the name the agent's
model list (or a provider profile's) gives the model, as the picker does;
the session screen asks for that list on open.

Co-Authored-By: Claude Code <noreply@anthropic.com>
---
 .../codedeck/plus/ui/session/SessionScreen.kt |  74 ++++++++++++++++--
 .../codedeck/plus/ui/DesignSnapshotTest.kt    |  12 +++
 .../plus/ui/session/ModelLabelTest.kt         |  13 +++
 .../ui/session/SessionChromeSnapshotTest.kt   |   2 +-
 .../plus/ui/session/SessionCostTest.kt        |  17 ++++
 ...SnapshotTest_session_controls_opencode.png | Bin 0 -> 12785 bytes
 .../opencode/__tests__/opencodeDriver.test.ts |  15 ++++
 .../agent-host/src/drivers/opencode/driver.ts |  14 +++-
 8 files changed, 134 insertions(+), 13 deletions(-)
 create mode 100644 apps/android/app/src/test/java/com/codedeck/plus/ui/session/SessionCostTest.kt
 create mode 100644 apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignSnapshotTest_session_controls_opencode.png

diff --git a/apps/android/app/src/main/java/com/codedeck/plus/ui/session/SessionScreen.kt b/apps/android/app/src/main/java/com/codedeck/plus/ui/session/SessionScreen.kt
index 801f7c07..7943a73b 100644
--- a/apps/android/app/src/main/java/com/codedeck/plus/ui/session/SessionScreen.kt
+++ b/apps/android/app/src/main/java/com/codedeck/plus/ui/session/SessionScreen.kt
@@ -98,6 +98,7 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.runInterruptible
 import kotlinx.coroutines.withTimeoutOrNull
 import uniffi.client_ffi.UniffiIntent
+import uniffi.client_ffi.UniffiModelEntry
 import uniffi.client_ffi.UniffiOptionChoice
 import uniffi.client_ffi.UniffiSessionMcp
 import uniffi.client_ffi.UniffiTranscriptDelta
@@ -495,13 +496,21 @@ fun SessionScreen(
         inputFocus.requestFocus()
     }
 
-    // Refresh the subscription-usage snapshot on open: the bridge only
-    // publishes usage when asked. An agent whose catalog entry says it has
-    // no usage is not asked (it would publish nothing); until the catalog
-    // is known the effect waits, and fires once it says yes.
+    // Refresh the usage snapshot on open and whenever a turn ends (the
+    // session's cost grows with each): the bridge only publishes usage when
+    // asked. An agent whose catalog entry says it has no usage is not asked
+    // (it would publish nothing); until the catalog is known the effect
+    // waits, and fires once it says yes.
+    // The agent's model list names the session's model in the controls bar.
+    LaunchedEffect(machine, agent?.id, agent?.supportsModels) {
+        val id = agent?.id
+        if (id != null && agent.supportsModels) core.dispatch(UniffiIntent.RequestModels(machine = machine, agent = id))
+    }
+
     val supportsUsage = agent?.supportsUsage == true
-    LaunchedEffect(machine, sessionId, supportsUsage) {
-        if (supportsUsage) core.dispatch(UniffiIntent.RequestUsage(machine = machine, sessionId = sessionId))
+    val turnRunning = session?.state == "running"
+    LaunchedEffect(machine, sessionId, supportsUsage, turnRunning) {
+        if (supportsUsage && !turnRunning) core.dispatch(UniffiIntent.RequestUsage(machine = machine, sessionId = sessionId))
     }
 
     // Slash commands: the menu opens while the draft is a bare `/name` (not
@@ -671,6 +680,11 @@ fun SessionScreen(
             modeLabel = modeLabel?.takeIf { modes.size >= 2 },
             modePending = modeCycle.pending != null,
             model = session?.model,
+            modelName = listedModelName(
+                session?.model,
+                listOfNotNull(machineSummary?.models?.firstOrNull { it.agent == session?.agent }?.models) +
+                    machineSummary?.providerProfiles.orEmpty().filter { it.agent == session?.agent }.map { it.models },
+            ),
             contextPercentage = session?.contextPercentage,
             contextWindow = session?.contextWindow?.toLong(),
             onEffortSelect = { level ->
@@ -855,6 +869,8 @@ internal fun SessionControlsBar(
     /** `null` hides the MCP pill (no servers, or an agent without MCP). */
     mcp: UniffiSessionMcp? = null,
     onMcpTap: () -> Unit = {},
+    /** The model list's name for [model] ([listedModelName]); null shows its tag. */
+    modelName: String? = null,
 ) {
     Row(
         Modifier
@@ -865,7 +881,7 @@ internal fun SessionControlsBar(
         horizontalArrangement = Arrangement.spacedBy(Tokens.Space2),
     ) {
         if (model != null) {
-            ModelContextChip(model = model, contextPercentage = contextPercentage, contextWindow = contextWindow)
+            ModelContextChip(model = model, modelName = modelName, contextPercentage = contextPercentage, contextWindow = contextWindow)
         }
         if (modeLabel != null) {
             ModeButton(modeLabel, modePending, onModeTap)
@@ -876,6 +892,9 @@ internal fun SessionControlsBar(
         if (mcp != null) {
             McpChip(mcp, onMcpTap)
         }
+        // What the session has cost so far: the agent's figure, shown whether
+        // or not the subscription windows are.
+        usage?.sessionCostUsd?.let(::sessionCost)?.let { CostPill(it) }
         val badges = usageBadges(usage, System.currentTimeMillis())
         if (showUsageBadge && badges.isNotEmpty()) {
             UsageBox(usage, badges)
@@ -916,6 +935,31 @@ internal fun SendFailedBar(text: String, failedCount: Int, onRetry: () -> Unit)
     }
 }
 
+/** A session's cost as a pill: "$0.42", "<$0.01" below a cent; nothing for
+ *  a free (or unpriced) session. */
+internal fun sessionCost(usd: Double): String? = when {
+    !usd.isFinite() || usd <= 0.0 -> null
+    usd < 0.01 -> "<$0.01"
+    usd < 100.0 -> "$" + String.format(java.util.Locale.ROOT, "%.2f", usd)
+    else -> "$" + String.format(java.util.Locale.ROOT, "%.0f", usd)
+}
+
+@Composable
+private fun CostPill(cost: String) {
+    Text(
+        cost,
+        color = Tokens.TextMuted,
+        fontSize = Tokens.TextXs,
+        fontWeight = FontWeight.Bold,
+        maxLines = 1,
+        modifier = Modifier
+            .clip(RoundedCornerShape(Tokens.RadiusPill))
+            .background(Tokens.SurfaceHover)
+            .padding(horizontal = ControlPadH, vertical = ControlPadV)
+            .semantics { contentDescription = "Session cost $cost" },
+    )
+}
+
 /** Effort dropdown over the agent's advertised levels: shows the current
  *  level ("effort…" until the bridge reports one), opens the list on tap. The
  *  placeholder carries the muted "effort…" trigger for the not-yet-reported
@@ -1078,6 +1122,18 @@ internal fun modelLabel(id: String?): String {
     return base.replace(Regex("^claude-"), "").replace(Regex("-\\d{8}$"), "")
 }
 
+/**
+ * The name a model list gives the session's model [id] — its agent's list,
+ * or a provider profile's — for a model [MODEL_TAGS] has no compact tag
+ * for: an OpenCode or gateway id such as `ccr/OpenCode Go/deepseek-v4.1-flash`
+ * reads as `deepseek-v4.1-flash`, as in the model picker. Null when the tag
+ * table knows it, or no list names it.
+ */
+internal fun listedModelName(id: String?, lists: List<List<UniffiModelEntry>>): String? {
+    if (id.isNullOrEmpty() || MODEL_TAGS.any { (modelId) -> modelId == stripContextMarker(id) }) return null
+    return lists.firstNotNullOfOrNull { list -> list.firstOrNull { it.id == id }?.label?.takeIf { it.isNotBlank() } }
+}
+
 /** Widest the model tag in [ModelContextChip] gets before it marquees. */
 private val MODEL_TAG_MAX_WIDTH = 160.dp
 
@@ -1109,13 +1165,15 @@ private val MODEL_TAG_MAX_WIDTH = 160.dp
 @Composable
 private fun ModelContextChip(
     model: String,
+    /** The model list's name for it ([listedModelName]), when it has one. */
+    modelName: String?,
     contextPercentage: Double?,
     contextWindow: Long?,
 ) {
     Layout(
         content = {
             Text(
-                modelLabel(model),
+                modelName ?: modelLabel(model),
                 color = Tokens.Accent,
                 fontWeight = FontWeight.Bold,
                 fontSize = Tokens.TextXs,
diff --git a/apps/android/app/src/test/java/com/codedeck/plus/ui/DesignSnapshotTest.kt b/apps/android/app/src/test/java/com/codedeck/plus/ui/DesignSnapshotTest.kt
index 812a10b2..7fe766dd 100644
--- a/apps/android/app/src/test/java/com/codedeck/plus/ui/DesignSnapshotTest.kt
+++ b/apps/android/app/src/test/java/com/codedeck/plus/ui/DesignSnapshotTest.kt
@@ -35,6 +35,7 @@ import com.codedeck.plus.ui.transcript.DisplayEntry
 import com.codedeck.plus.ui.screens.AccountPage
 import com.codedeck.plus.ui.screens.BackupPage
 import com.codedeck.plus.ui.screens.RestoreContent
+import uniffi.client_ffi.UniffiUsageData
 import uniffi.client_ffi.UniffiBackupStatus
 import uniffi.client_ffi.UniffiBackupView
 import com.codedeck.plus.ui.screens.SettingsHub
@@ -93,6 +94,16 @@ private val pages: Map<String, @Composable () -> Unit> = linkedMapOf(
             )
         }
     },
+    "session_controls_opencode" to {
+        Column(Modifier.background(Tokens.Bg)) {
+            SessionControlsBar(
+                effort = null, efforts = emptyList(), modeLabel = "Plan", modePending = false, model = "home-gateway/OpenCode Go/deepseek-v4.1-flash",
+                contextPercentage = 18.0, contextWindow = 1_000_000, onEffortSelect = {}, onModeTap = {}, showUsageBadge = true,
+                usage = UniffiUsageData(available = true, plan = null, windows = emptyList(), sessionCostUsd = 0.0371, fetchedAt = "2026-10-08T10:00:00Z"),
+                modelName = "deepseek-v4.1-flash",
+            )
+        }
+    },
     "session_commands" to {
         Column(Modifier.background(Tokens.Bg)) {
             SessionTopBar(title = "Fix the flaky reconnect test", workspace = "/home/me/code/codedeck-plus", sessionState = "idle", onBack = {})
@@ -276,6 +287,7 @@ class DesignSnapshotTest {
     @Test fun home() = paparazzi.page("home")
     @Test fun home_nothing_paired() = paparazzi.page("home_nothing_paired")
     @Test fun session() = paparazzi.page("session")
+    @Test fun session_controls_opencode() = paparazzi.page("session_controls_opencode")
     @Test fun session_commands() = paparazzi.page("session_commands")
     @Test fun transcript() = paparazzi.page("transcript")
     @Test fun transcript_plan() = paparazzi.page("transcript_plan")
diff --git a/apps/android/app/src/test/java/com/codedeck/plus/ui/session/ModelLabelTest.kt b/apps/android/app/src/test/java/com/codedeck/plus/ui/session/ModelLabelTest.kt
index ca4596d0..f480e15d 100644
--- a/apps/android/app/src/test/java/com/codedeck/plus/ui/session/ModelLabelTest.kt
+++ b/apps/android/app/src/test/java/com/codedeck/plus/ui/session/ModelLabelTest.kt
@@ -1,7 +1,9 @@
 package com.codedeck.plus.ui.session
 
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
 import org.junit.Test
+import uniffi.client_ffi.UniffiModelEntry
 
 /** Port of `apps/mobile/src/ui/__tests__/modelLabel.test.ts` — the same
  *  cases, asserting the Kotlin port of `modelLabel` (SessionScreen.kt) keeps
@@ -45,4 +47,15 @@ class ModelLabelTest {
         assertEquals("?", modelLabel(null))
         assertEquals("?", modelLabel(""))
     }
+
+    @Test
+    fun aListedModelReadsByItsListName() {
+        val opencode = listOf(UniffiModelEntry("ccr/OpenCode Go/deepseek-v4.1-flash", "deepseek-v4.1-flash", "CCR · OpenCode Go", null))
+        val profile = listOf(UniffiModelEntry("kimi-k3", "Kimi K3", "Moonshot", null))
+        assertEquals("deepseek-v4.1-flash", listedModelName("ccr/OpenCode Go/deepseek-v4.1-flash", listOf(opencode, profile)))
+        assertEquals("Kimi K3", listedModelName("kimi-k3", listOf(opencode, profile)))
+        // Claude's compact tags stay; an unlisted model has no name.
+        assertNull(listedModelName("claude-opus-5", listOf(listOf(UniffiModelEntry("claude-opus-5", "Opus 5", null, null)))))
+        assertNull(listedModelName("unlisted/model", listOf(opencode)))
+    }
 }
diff --git a/apps/android/app/src/test/java/com/codedeck/plus/ui/session/SessionChromeSnapshotTest.kt b/apps/android/app/src/test/java/com/codedeck/plus/ui/session/SessionChromeSnapshotTest.kt
index b651d8b5..39e502b4 100644
--- a/apps/android/app/src/test/java/com/codedeck/plus/ui/session/SessionChromeSnapshotTest.kt
+++ b/apps/android/app/src/test/java/com/codedeck/plus/ui/session/SessionChromeSnapshotTest.kt
@@ -74,7 +74,7 @@ class SessionChromeSnapshotTest {
                                     UniffiUsageWindow(label = "5h", utilization = 61.0, resetsAt = null),
                                     UniffiUsageWindow(label = "7d", utilization = 23.0, resetsAt = null),
                                 ),
-                                sessionCostUsd = null,
+                                sessionCostUsd = 0.42,
                                 fetchedAt = "2026-09-23T10:00:00Z",
                             ),
                         )
diff --git a/apps/android/app/src/test/java/com/codedeck/plus/ui/session/SessionCostTest.kt b/apps/android/app/src/test/java/com/codedeck/plus/ui/session/SessionCostTest.kt
new file mode 100644
index 00000000..7ee1e8e4
--- /dev/null
+++ b/apps/android/app/src/test/java/com/codedeck/plus/ui/session/SessionCostTest.kt
@@ -0,0 +1,17 @@
+package com.codedeck.plus.ui.session
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class SessionCostTest {
+    @Test
+    fun a_cost_reads_in_dollars_and_a_free_session_shows_none() {
+        assertEquals("$0.42", sessionCost(0.4213))
+        assertEquals("<$0.01", sessionCost(0.004))
+        assertEquals("$12.30", sessionCost(12.3))
+        assertEquals("$140", sessionCost(139.6))
+        assertNull(sessionCost(0.0))
+        assertNull(sessionCost(Double.NaN))
+    }
+}
diff --git a/apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignSnapshotTest_session_controls_opencode.png b/apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignSnapshotTest_session_controls_opencode.png
new file mode 100644
index 0000000000000000000000000000000000000000..6200265e5fee8b9b399e2ad6396b26340bc373d1
GIT binary patch
literal 12785
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

literal 0
HcmV?d00001

diff --git a/packages/agent-host/src/drivers/opencode/__tests__/opencodeDriver.test.ts b/packages/agent-host/src/drivers/opencode/__tests__/opencodeDriver.test.ts
index ed44c091..5941dfab 100644
--- a/packages/agent-host/src/drivers/opencode/__tests__/opencodeDriver.test.ts
+++ b/packages/agent-host/src/drivers/opencode/__tests__/opencodeDriver.test.ts
@@ -62,6 +62,21 @@ describe('OpenCode session titles', () => {
   });
 });
 
+describe('OpenCode usage', () => {
+  it("is the session's cost, none for a free session", async () => {
+    const client = clientWith([]);
+    const ctx = recordingContext();
+    const session = OpenCodeDriver.withClient(client).startSession({ sessionId: 's1', agent: 'opencode', cwd: '/tmp' }, ctx);
+    await ctx.waitFor((e) => e.type === 'ready');
+    (client.session.get as ReturnType<typeof vi.fn>).mockResolvedValue({ data: { id: 'ses_1', cost: 0.0371 } });
+    expect(await session.getUsage!()).toMatchObject({ available: true, windows: [], sessionCostUsd: 0.0371 });
+    (client.session.get as ReturnType<typeof vi.fn>).mockResolvedValue({ data: { id: 'ses_1', cost: 0 } });
+    expect(await session.getUsage!()).not.toHaveProperty('sessionCostUsd');
+    expect(OpenCodeDriver.withClient(client).info().supports?.usage).toBe(true);
+    await session.end();
+  });
+});
+
 describe('OpenCode conversation delete', () => {
   const deleting = (result: unknown) => {
     const client = clientWith([]) as FakeClient & { session: { delete: ReturnType<typeof vi.fn> } };
diff --git a/packages/agent-host/src/drivers/opencode/driver.ts b/packages/agent-host/src/drivers/opencode/driver.ts
index c845d80e..e733c238 100644
--- a/packages/agent-host/src/drivers/opencode/driver.ts
+++ b/packages/agent-host/src/drivers/opencode/driver.ts
@@ -1000,8 +1000,14 @@ export class OpenCodeSession implements DriverSession {
     if (error) throw new Error(`OpenCode could not stop the task: ${JSON.stringify(error)}`);
   }
 
+  /** What the session has cost so far, as OpenCode prices its models (no
+   *  subscription windows: OpenCode has none to report). A free or
+   *  unpriced model's session reports no cost. */
   async getUsage(): Promise<UsageData | null> {
-    return null;
+    const { client, session } = await this.ready;
+    const { data, error } = await client.session.get({ sessionID: session.id, directory: this.cwd });
+    if (error || !data) return null;
+    return { available: true, windows: [], ...(data.cost ? { sessionCostUsd: data.cost } : {}), fetchedAt: new Date().toISOString() };
   }
 
   async end(): Promise<void> {
@@ -1229,11 +1235,11 @@ export class OpenCodeDriver implements Driver {
       modes: OPENCODE_MODES,
       efforts: [],
       defaultMode: DEFAULT_MODE,
-      // No subscription usage. Provider profiles add models to the server
-      // this driver starts; sessions are never bound to one.
+      // Usage is the session's cost. Provider profiles add models to the
+      // server this driver starts; sessions are never bound to one.
       supports: {
         models: true,
-        usage: false,
+        usage: true,
         providers: false,
         providerModels: this.manages,
         gsd: true,

From 282c205ec07b8583d6d9557302a9fdef3e728db2 Mon Sep 17 00:00:00 2001
From: deymosh <232244450+deymosh@users.noreply.github.com>
Date: Thu, 8 Oct 2026 20:20:02 +0200
Subject: [PATCH 4/5] feat: OpenCode's catalog places each provider profile

OpenCode ships the models.dev catalog of providers and models, and its
server lists it with the base URL each provider is served at. A profile
is now placed by it:

- an endpoint the catalog knows (DeepSeek's API, OpenRouter's) signs in
  to that provider, as /connect would: the catalog's models, prices and
  limits under the name the user gave the profile, plus any model the
  endpoint lists that the catalog lacks. One OpenCode already uses with
  a key of its own is left out rather than replaced;
- any other endpoint stays a provider of its own, its models filled in
  from the catalog where it knows them (a routed "OpenCode Go/..." model
  is OpenCode Go's): limits, tool calls, image input and reasoning, which
  gives it OpenCode's reasoning levels. Prices are not copied, a
  gateway's being its own.

Checked on 1.18.32: a gateway model filled in so is offered the low,
medium, high and max levels and image input, with its real limits.

Co-Authored-By: Claude Code <noreply@anthropic.com>
---
 docs/AGENT-CANDIDATES.md                      |   7 +-
 .../__tests__/opencodeProviders.test.ts       | 158 +++++++++++---
 .../src/drivers/opencode/catalog.ts           | 123 +++++++++++
 .../agent-host/src/drivers/opencode/driver.ts |  58 ++---
 .../src/drivers/opencode/providers.ts         | 199 +++++++++++-------
 5 files changed, 407 insertions(+), 138 deletions(-)
 create mode 100644 packages/agent-host/src/drivers/opencode/catalog.ts

diff --git a/docs/AGENT-CANDIDATES.md b/docs/AGENT-CANDIDATES.md
index 232529a2..d6eb8f84 100644
--- a/docs/AGENT-CANDIDATES.md
+++ b/docs/AGENT-CANDIDATES.md
@@ -105,7 +105,12 @@ offer no tool that only works on its vendor's API. OpenCode meets all
 three: its web search is offered only on its own provider (checked on
 1.18.32), its web fetch is local, and a provider profile adds the
 endpoint's models to its list beside OpenCode Zen's free ones — read from
-the endpoint, never typed by hand. The server the bridge starts sets
+the endpoint, never typed by hand. OpenCode's own catalog (models.dev)
+places each profile: an endpoint it knows (DeepSeek's, OpenRouter's) signs
+in to that provider as `/connect` would; a gateway's models are filled in
+from the catalog — limits, tool calls, image input, and with reasoning
+OpenCode's own reasoning levels — but never its prices, a gateway's being
+its own. The server the bridge starts sets
 `OPENCODE_ENABLE_EXA`, so that web search (Exa's keyless endpoint, behind
 OpenCode's `websearch` permission) is offered to every model, not only to
 OpenCode's own providers'. Codex is out (its client speaks only the
diff --git a/packages/agent-host/src/drivers/opencode/__tests__/opencodeProviders.test.ts b/packages/agent-host/src/drivers/opencode/__tests__/opencodeProviders.test.ts
index eb66505e..1f9d46ee 100644
--- a/packages/agent-host/src/drivers/opencode/__tests__/opencodeProviders.test.ts
+++ b/packages/agent-host/src/drivers/opencode/__tests__/opencodeProviders.test.ts
@@ -1,11 +1,13 @@
 /**
- * Provider profiles as OpenCode providers: the config the server starts
- * with, the password guarding it, and the restart a changed list takes.
+ * Provider profiles as OpenCode providers: where OpenCode's catalog places
+ * each, the config the server starts with, the password guarding it, and
+ * the restart a changed list takes.
  */
 import { describe, expect, it, vi } from 'vitest';
-import type { OpencodeClient } from '@opencode-ai/sdk/v2/client';
+import type { Model, OpencodeClient, Provider } from '@opencode-ai/sdk/v2/client';
 import { OpenCodeDriver } from '../driver';
-import { admitProfiles, profileModelGroup, profileProviderId, providersConfig, serverSetup } from '../providers';
+import { type Catalog, EMPTY_CATALOG } from '../catalog';
+import { placeProfiles, profileModelGroup, profileProviderId, providersConfig, servedBy, serverSetup } from '../providers';
 import type { StartOpenCodeServerOptions } from '../server';
 import type { ProviderBinding } from '../../../sdk/types';
 
@@ -19,9 +21,91 @@ const router = (over: Partial<ProviderBinding> = {}): ProviderBinding => ({
   ...over,
 });
 
+/** A catalog provider, as OpenCode's server lists it. */
+function catalogProvider(id: string, name: string, url: string, models: Record<string, Partial<Model>> = {}): Provider {
+  return {
+    id,
+    name,
+    source: 'api',
+    env: [],
+    options: {},
+    models: Object.fromEntries(
+      Object.entries(models).map(([mid, m]) => [mid, { id: mid, providerID: id, api: { id: mid, url, npm: '@ai-sdk/openai-compatible' }, name: mid, ...m } as Model]),
+    ),
+  } as Provider;
+}
+
+const reasoningModel: Partial<Model> = {
+  name: 'DeepSeek V4.1 Flash',
+  family: 'deepseek',
+  capabilities: {
+    temperature: true, reasoning: true, attachment: true, toolcall: true,
+    input: { text: true, audio: false, image: true, video: false, pdf: false },
+    output: { text: true, audio: false, image: false, video: false, pdf: false },
+    interleaved: { field: 'reasoning_content' },
+  },
+  cost: { input: 0.15, output: 0.6, cache: { read: 0.003, write: 0 } },
+  limit: { context: 1_000_000, output: 393_216 },
+};
+
+const catalog: Catalog = {
+  providers: new Map([
+    ['deepseek', catalogProvider('deepseek', 'DeepSeek', 'https://api.deepseek.com', { 'deepseek-flash': reasoningModel })],
+    ['opencode-go', catalogProvider('opencode-go', 'OpenCode Go', 'https://opencode.ai/zen/go/v1', { 'deepseek-v4.1-flash': reasoningModel })],
+    ['openrouter', catalogProvider('openrouter', 'OpenRouter', 'https://openrouter.ai/api/v1', { 'deepseek/deepseek-chat': {} })],
+    ['opencode', catalogProvider('opencode', 'OpenCode Zen', 'https://opencode.ai/zen/v1')],
+  ]),
+  connected: new Set(['opencode', 'deepseek']),
+};
+
+const providerOf = (config: Record<string, unknown>, id: string) => (config.provider as Record<string, Record<string, unknown>>)[id]!;
+
+describe('placing profiles', () => {
+  it('names a profile of its own as the user named it', () => {
+    expect(profileProviderId(router({ label: 'CCR' }))).toBe('ccr');
+    expect(profileProviderId(router({ label: 'OpenCode Go (OpenAI)' }))).toBe('opencode-go-openai');
+    expect(profileProviderId(router({ label: 'Café / LAN' }))).toBe('cafe-lan');
+    expect(profileProviderId(router({ label: '★', id: 'p-7' }))).toBe('p-7');
+  });
+
+  it("signs in to a provider OpenCode knows by its endpoint, unless OpenCode already uses it", () => {
+    const openrouter = router({ id: 'or', label: 'My OpenRouter', baseUrl: 'https://openrouter.ai/api' });
+    const deepseek = router({ id: 'ds', label: 'DeepSeek API', baseUrl: 'https://api.deepseek.com/v1' });
+    const { placed, refused } = placeProfiles([openrouter, deepseek], catalog);
+    expect(placed.map((p) => [p.profile.id, p.providerId, p.known?.id])).toEqual([['or', 'openrouter', 'openrouter']]);
+    expect(refused).toEqual([{ id: 'ds', reason: 'OpenCode already uses DeepSeek with a key of its own; this profile would replace it.' }]);
+  });
+
+  it("leaves out a name one of OpenCode's providers, or an earlier profile, already has", () => {
+    const ccr = router({ id: 'a', label: 'CCR' });
+    const again = router({ id: 'b', label: 'ccr' });
+    const named = router({ id: 'c', label: 'DeepSeek' });
+    const { placed, refused } = placeProfiles([ccr, again, named], catalog);
+    expect(placed.map((p) => p.providerId)).toEqual(['ccr']);
+    expect(refused).toEqual([
+      { id: 'b', reason: "The provider profile 'CCR' already goes by 'ccr' in OpenCode. Give this one another name." },
+      { id: 'c', reason: "OpenCode already has a provider called 'deepseek'. Give this profile another name." },
+    ]);
+  });
+
+  it('never takes what profiles already made of the running server for OpenCode\'s own', () => {
+    // The running server lists the profile's provider, and the catalog one
+    // it signed in to as connected.
+    const running: Catalog = {
+      providers: new Map([...catalog.providers, ['ccr', catalogProvider('ccr', 'CCR', 'http://192.168.1.2:3458/v1', { m: {} })]]),
+      connected: new Set([...catalog.connected, 'ccr', 'openrouter']),
+    };
+    const served = servedBy(placeProfiles([router({ label: 'CCR' }), router({ id: 'or', label: 'OR', baseUrl: 'https://openrouter.ai/api' })], catalog).placed);
+    const again = placeProfiles([router({ label: 'CCR' }), router({ id: 'or', label: 'OR', baseUrl: 'https://openrouter.ai/api' })], running, served);
+    expect(again.refused).toEqual([]);
+    expect(again.placed.map((p) => p.providerId)).toEqual(['ccr', 'openrouter']);
+  });
+});
+
 describe('providersConfig', () => {
-  it("adds each profile as a provider of its own, beside the operator's, with the token left to the environment", () => {
-    const config = providersConfig([router()], { provider: { mine: { npm: 'x' } }, theme: 'dark' });
+  it("adds a profile of its own beside the operator's providers, with the token left to the environment", () => {
+    const { placed } = placeProfiles([router()], catalog);
+    const config = providersConfig(placed, catalog, { provider: { mine: { npm: 'x' } }, theme: 'dark' });
     expect(config).toEqual({
       theme: 'dark',
       provider: {
@@ -37,37 +121,43 @@ describe('providersConfig', () => {
     expect(JSON.stringify(config)).not.toContain('tok-secret');
   });
 
-  it('names a routed model without its upstream, which its group shows, and gives OpenCode a known context window', () => {
-    const routed = router({ models: [{ id: 'OpenCode Go/deepseek-v4.1-flash', provider: 'OpenCode Go', contextWindow: 1_000_000 }] });
-    const provider = (providersConfig([routed]).provider as Record<string, { models: Record<string, unknown> }>)['home-router']!;
-    expect(provider.models).toEqual({
-      'OpenCode Go/deepseek-v4.1-flash': { name: 'deepseek-v4.1-flash', limit: { context: 1_000_000, output: 0 } },
+  it("fills a gateway's routed model in from the catalog, without its price", () => {
+    const routed = router({ label: 'CCR', models: [{ id: 'OpenCode Go/deepseek-v4.1-flash', provider: 'OpenCode Go' }] });
+    const { placed } = placeProfiles([routed], catalog);
+    expect(providerOf(providersConfig(placed, catalog), 'ccr').models).toEqual({
+      'OpenCode Go/deepseek-v4.1-flash': {
+        name: 'deepseek-v4.1-flash',
+        family: 'deepseek',
+        limit: { context: 1_000_000, output: 393_216 },
+        reasoning: true,
+        tool_call: true,
+        temperature: true,
+        attachment: true,
+        modalities: { input: ['text', 'image'], output: ['text'] },
+      },
     });
     expect(profileModelGroup('CCR', routed.models[0])).toBe('CCR · OpenCode Go');
     expect(profileModelGroup('CCR', { id: 'kimi-k3' })).toBe('CCR');
   });
 
-  it('names each provider as the user named the profile', () => {
-    expect(profileProviderId(router({ label: 'CCR' }))).toBe('ccr');
-    expect(profileProviderId(router({ label: 'OpenCode Go (OpenAI)' }))).toBe('opencode-go-openai');
-    expect(profileProviderId(router({ label: 'Café / LAN' }))).toBe('cafe-lan');
-    expect(profileProviderId(router({ label: '★', id: 'p-7' }))).toBe('p-7');
+  it("keeps the endpoint's own context window over the catalog's", () => {
+    const routed = router({ label: 'CCR', models: [{ id: 'OpenCode Go/deepseek-v4.1-flash', provider: 'OpenCode Go', contextWindow: 128_000 }] });
+    const config = providersConfig(placeProfiles([routed], catalog).placed, catalog);
+    expect((providerOf(config, 'ccr').models as Record<string, { limit: unknown }>)['OpenCode Go/deepseek-v4.1-flash']!.limit).toEqual({ context: 128_000, output: 393_216 });
   });
 
-  it("leaves out a profile whose name one of OpenCode's providers, or an earlier profile, already has", () => {
-    const ccr = router({ id: 'a', label: 'CCR' });
-    const again = router({ id: 'b', label: 'ccr' });
-    const deepseek = router({ id: 'c', label: 'DeepSeek' });
-    const { admitted, refused } = admitProfiles([ccr, again, deepseek], new Set(['deepseek', 'opencode']));
-    expect(admitted.map((p) => p.id)).toEqual(['a']);
-    expect(refused).toEqual([
-      { id: 'b', reason: "The provider profile 'CCR' already goes by 'ccr' in OpenCode. Give this one another name." },
-      { id: 'c', reason: "OpenCode already has a provider called 'deepseek'. Give this profile another name." },
-    ]);
+  it("signs a known provider in by its key alone, adding only the endpoint's models the catalog lacks", () => {
+    const openrouter = router({ id: 'or', label: 'My OpenRouter', baseUrl: 'https://openrouter.ai/api', models: [{ id: 'deepseek/deepseek-chat' }, { id: 'new/model', label: 'New' }] });
+    const config = providersConfig(placeProfiles([openrouter], catalog).placed, catalog);
+    expect(providerOf(config, 'openrouter')).toEqual({
+      name: 'My OpenRouter',
+      options: { apiKey: '{env:CODEDECK_PROVIDER_KEY_0}' },
+      models: { 'new/model': { name: 'New' } },
+    });
   });
 
   it('does not restrict the providers OpenCode already has', () => {
-    const config = providersConfig([router()]);
+    const config = providersConfig(placeProfiles([router()], catalog).placed, catalog);
     expect(config).not.toHaveProperty('enabled_providers');
     expect(config).not.toHaveProperty('disabled_providers');
     expect(config).not.toHaveProperty('model');
@@ -75,23 +165,25 @@ describe('providersConfig', () => {
 });
 
 describe('serverSetup', () => {
+  const placedOf = (...profiles: ProviderBinding[]) => placeProfiles(profiles, EMPTY_CATALOG).placed;
+
   it('passes the tokens in the environment and guards the server with a password of its own', () => {
-    const a = serverSetup([router(), router({ id: 'or', label: 'My OpenRouter', authToken: 'tok-2' })], {});
+    const a = serverSetup(placedOf(router(), router({ id: 'or', label: 'My OpenRouter', authToken: 'tok-2' })), EMPTY_CATALOG, {});
     expect(a.env.CODEDECK_PROVIDER_KEY_0).toBe('tok-secret');
     expect(a.env.CODEDECK_PROVIDER_KEY_1).toBe('tok-2');
     expect(JSON.parse(a.env.OPENCODE_CONFIG_CONTENT!).provider).toHaveProperty('my-openrouter');
     const password = a.env.OPENCODE_SERVER_PASSWORD!;
     expect(password).toMatch(/^[0-9a-f]{48}$/);
     expect(a.headers.authorization).toBe(`Basic ${Buffer.from(`opencode:${password}`).toString('base64')}`);
-    expect(serverSetup([], {}).env.OPENCODE_SERVER_PASSWORD).not.toBe(password);
+    expect(serverSetup([], EMPTY_CATALOG, {}).env.OPENCODE_SERVER_PASSWORD).not.toBe(password);
     // Web search for every model, not only OpenCode's own providers'.
-    expect(serverSetup([], {}).env.OPENCODE_ENABLE_EXA).toBe('1');
+    expect(serverSetup([], EMPTY_CATALOG, {}).env.OPENCODE_ENABLE_EXA).toBe('1');
     // No profiles: the operator's config stands as it is.
-    expect(serverSetup([], { OPENCODE_CONFIG_CONTENT: '{"theme":"x"}' }).env).not.toHaveProperty('OPENCODE_CONFIG_CONTENT');
+    expect(serverSetup([], EMPTY_CATALOG, { OPENCODE_CONFIG_CONTENT: '{"theme":"x"}' }).env).not.toHaveProperty('OPENCODE_CONFIG_CONTENT');
   });
 
   it("keeps the operator's own environment config underneath", () => {
-    const { env } = serverSetup([router()], { OPENCODE_CONFIG_CONTENT: '{"provider":{"mine":{"npm":"x"}}}' });
+    const { env } = serverSetup(placedOf(router()), EMPTY_CATALOG, { OPENCODE_CONFIG_CONTENT: '{"provider":{"mine":{"npm":"x"}}}' });
     expect(Object.keys(JSON.parse(env.OPENCODE_CONFIG_CONTENT!).provider)).toEqual(['mine', 'home-router']);
   });
 });
@@ -189,7 +281,7 @@ describe('an OpenCode driver given provider profiles', () => {
         return { url: `http://127.0.0.1:${4100 + starts.length}`, pid: starts.length, exited: new Promise(() => {}), close: async () => {} };
       },
       // The running server lists what it has, the profiles it was given too.
-      connect: () => ({ provider: { list: async () => ({ data: { all: ids.map((id) => ({ id })), default: {}, connected: [] } }) } }) as unknown as OpencodeClient,
+      connect: () => ({ provider: { list: async () => ({ data: { all: ids.map((id) => ({ id, name: id, models: {} })), default: {}, connected: [] } }) } }) as unknown as OpencodeClient,
     });
     expect(await driver.setProviders([router({ label: 'DeepSeek' })])).toEqual([
       { id: 'router', reason: "OpenCode already has a provider called 'deepseek'. Give this profile another name." },
diff --git a/packages/agent-host/src/drivers/opencode/catalog.ts b/packages/agent-host/src/drivers/opencode/catalog.ts
new file mode 100644
index 00000000..a0e64cdd
--- /dev/null
+++ b/packages/agent-host/src/drivers/opencode/catalog.ts
@@ -0,0 +1,123 @@
+/**
+ * OpenCode's catalog of providers and their models — models.dev, which
+ * OpenCode ships and keeps current, plus what the operator configured — as
+ * its server lists it (`GET /provider`). A provider profile learns two
+ * things from it:
+ *
+ *  - whether its endpoint is a provider OpenCode already knows (DeepSeek,
+ *    OpenRouter, Moonshot…), by the base URL the catalog records for it;
+ *    such a profile signs in to that provider, the way `/connect` would,
+ *    and gets the catalog's models, prices and limits whole;
+ *  - what its models are, when the endpoint is a gateway: a routed
+ *    `OpenCode Go/deepseek-v4.1-flash` is the catalog's OpenCode Go model,
+ *    whose context and output limits, reasoning (and with it OpenCode's
+ *    reasoning levels), tool calls and image input the gateway's model list
+ *    never says. Prices are left out: a gateway's are its own (a
+ *    subscription, a local model, a markup), not the upstream's list price.
+ */
+import type { Model, Provider } from '@opencode-ai/sdk/v2/client';
+import type { ProviderModel } from '../../sdk/types';
+
+/** `name` as an OpenCode provider id: lower case, each run of anything but
+ *  letters and digits one `-` (a `/` would split its model ids). */
+export function providerIdOf(name: string): string {
+  return name
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+export interface Catalog {
+  /** Every provider OpenCode knows, by id. */
+  providers: ReadonlyMap<string, Provider>;
+  /** Those it can already use: configured, signed in to, or given a key in
+   *  its environment. */
+  connected: ReadonlySet<string>;
+}
+
+export const EMPTY_CATALOG: Catalog = { providers: new Map(), connected: new Set() };
+
+/** A base URL as endpoints are compared: lower case, without a trailing
+ *  slash or `/v1` (both spellings are common for one endpoint). */
+export function endpointKey(url: string): string {
+  return url.trim().toLowerCase().replace(/\/+$/, '').replace(/\/v1$/, '');
+}
+
+/** The base URLs a catalog provider is served at. */
+function providerEndpoints(provider: Provider): string[] {
+  const urls = Object.values(provider.models).map((m) => m.api?.url);
+  const configured = (provider.options as { baseURL?: unknown } | undefined)?.baseURL;
+  if (typeof configured === 'string') urls.push(configured);
+  return [...new Set(urls.filter((u): u is string => typeof u === 'string' && u.trim() !== '').map(endpointKey))];
+}
+
+/** The catalog provider served at `baseUrl`, leaving out the `skip` ids
+ *  (the providers profiles themselves became). */
+export function knownProviderAt(catalog: Catalog, baseUrl: string, skip: ReadonlySet<string>): Provider | undefined {
+  const key = endpointKey(baseUrl);
+  for (const provider of catalog.providers.values()) {
+    if (!skip.has(provider.id) && providerEndpoints(provider).includes(key)) return provider;
+  }
+  return undefined;
+}
+
+/** The catalog's record of a profile model: under the provider a gateway
+ *  routes it to when the endpoint names one (by name or id), else under the
+ *  first provider that lists its id. */
+export function catalogModel(catalog: Catalog, model: ProviderModel, skip: ReadonlySet<string>): Model | undefined {
+  const upstream = model.provider?.trim();
+  if (upstream) {
+    const bare = model.id.startsWith(`${upstream}/`) ? model.id.slice(upstream.length + 1) : model.id;
+    const wanted = upstream.toLowerCase();
+    const slug = providerIdOf(upstream);
+    for (const provider of catalog.providers.values()) {
+      if (skip.has(provider.id)) continue;
+      if (provider.name.toLowerCase() === wanted || provider.id === slug) {
+        const found = provider.models[bare];
+        if (found) return found;
+      }
+    }
+  }
+  for (const provider of catalog.providers.values()) {
+    if (skip.has(provider.id)) continue;
+    const found = provider.models[model.id];
+    if (found) return found;
+  }
+  return undefined;
+}
+
+type Modality = 'text' | 'audio' | 'image' | 'video' | 'pdf';
+
+function modalities(flags: Record<Modality, boolean>): Modality[] {
+  return (Object.keys(flags) as Modality[]).filter((k) => flags[k]);
+}
+
+/**
+ * A profile model as OpenCode's config holds it: named without the upstream
+ * provider its group already shows, with what the catalog knows of it
+ * (`known`) — never its prices. The endpoint's own context window wins over
+ * the catalog's; without any, the limits stay unset, OpenCode's "unknown".
+ */
+export function profileModelConfig(model: ProviderModel, known: Model | undefined): Record<string, unknown> {
+  const name =
+    model.label ??
+    (model.provider && model.id.startsWith(`${model.provider}/`) ? model.id.slice(model.provider.length + 1) : undefined) ??
+    known?.name;
+  const context = model.contextWindow || known?.limit.context || 0;
+  return {
+    ...(name ? { name } : {}),
+    ...(context > 0 ? { limit: { context, output: known?.limit.output ?? 0 } } : {}),
+    ...(known
+      ? {
+          ...(known.family ? { family: known.family } : {}),
+          reasoning: known.capabilities.reasoning,
+          tool_call: known.capabilities.toolcall,
+          temperature: known.capabilities.temperature,
+          attachment: known.capabilities.attachment,
+          modalities: { input: modalities(known.capabilities.input), output: modalities(known.capabilities.output) },
+        }
+      : {}),
+  };
+}
diff --git a/packages/agent-host/src/drivers/opencode/driver.ts b/packages/agent-host/src/drivers/opencode/driver.ts
index e733c238..47046cff 100644
--- a/packages/agent-host/src/drivers/opencode/driver.ts
+++ b/packages/agent-host/src/drivers/opencode/driver.ts
@@ -56,7 +56,8 @@ import { SESSION_COMMANDS, sessionCommand, sessionSlashCommands } from './sessio
 import { opencodeEventToEntries, toolCallDiffs, type OpenCodeEvent } from './adapter';
 import { OpenCodeMcp, openCodeSessionMcp, toggleOpenCodeMcp } from './mcp';
 import { OpenCodePlugins } from './plugins';
-import { admitProfiles, profileModelGroup, profileProviderId, providersFingerprint, serverSetup } from './providers';
+import { type Catalog, EMPTY_CATALOG } from './catalog';
+import { NOTHING_SERVED, type Placement, placeProfiles, profileModelGroup, providersFingerprint, type Served, servedBy, serverSetup } from './providers';
 import {
   resolveOpenCodePath,
   startOpenCodeServer,
@@ -1065,12 +1066,14 @@ export class OpenCodeDriver implements Driver {
    *  session. */
   private installs = false;
   private stopped = false;
-  /** The provider profiles the server should have, and those the running
-   *  one was started with. */
-  private providers: ProviderBinding[] = [];
+  /** Where the provider profiles go among the server's providers, and the
+   *  catalog that placed them (it fills in their models). */
+  private placed: Placement[] = [];
+  private catalog: Catalog = EMPTY_CATALOG;
+  /** The placements the running server was started with: their
+   *  fingerprint, and the providers they made. */
   private served = providersFingerprint([]);
-  /** The provider ids the running server has from profiles. */
-  private servedIds = new Set<string>();
+  private serving: Served = NOTHING_SERVED;
   /** Provider changes are applied one at a time, in order. */
   private applying: Promise<void> = Promise.resolve();
   readonly plugins: PluginManager = new OpenCodePlugins(() => this.client());
@@ -1132,8 +1135,8 @@ export class OpenCodeDriver implements Driver {
   /** Start `opencode serve` with the provider profiles it should have, and
    *  connect to it. */
   private async startServer(bin: string): Promise<OpencodeClient> {
-    const profiles = this.providers;
-    const setup = serverSetup(profiles, process.env);
+    const placed = this.placed;
+    const setup = serverSetup(placed, this.catalog, process.env);
     const start = this.options.startServer ?? startOpenCodeServer;
     let server: OpenCodeServerHandle;
     try {
@@ -1150,9 +1153,9 @@ export class OpenCodeDriver implements Driver {
       throw new Error('the agent host is shutting down');
     }
     this.server = server;
-    this.served = providersFingerprint(profiles);
-    this.servedIds = new Set(profiles.map(profileProviderId));
-    const added = profiles.length > 0 ? `, with ${profiles.length} provider profile(s)` : '';
+    this.served = providersFingerprint(placed);
+    this.serving = servedBy(placed);
+    const added = placed.length > 0 ? `, with ${placed.length} provider profile(s)` : '';
     this.options.log(`[opencode] started ${server.url} (pid ${server.pid ?? '?'})${added}`);
     return this.connect({ baseUrl: server.url, headers: setup.headers });
   }
@@ -1178,8 +1181,9 @@ export class OpenCodeDriver implements Driver {
     );
   }
 
-  /** The provider profiles to add to OpenCode's own providers; those whose
-   *  name one of its providers already has are left out. The server reads
+  /** The provider profiles to add to OpenCode's own providers, placed by
+   *  its catalog (providers.ts); one that would shadow a provider OpenCode
+   *  has is left out, with the reason. The server reads
    *  its config only when it starts, so a changed list restarts it:
    *  sessions on the old one end with an error and the bridge resumes them
    *  on the new one. */
@@ -1197,13 +1201,15 @@ export class OpenCodeDriver implements Driver {
 
   private async applyProviders(providers: ProviderBinding[]): Promise<RefusedProvider[]> {
     // A server still being installed or started is waited for: it may have
-    // read an older list, and it says which names are taken.
+    // read an older list, and its catalog places the profiles.
     await this.clientPromise?.catch(() => {});
     // A profile the bridge would not let a session use is not added either.
     const usable = providers.filter((p) => isValidProviderBaseUrl(p.baseUrl) && p.authToken !== '' && p.models.length > 0);
-    const { admitted, refused } = admitProfiles(usable, await this.ownProviderIds());
-    this.providers = admitted;
-    if (this.stopped || !this.server || !this.bin || providersFingerprint(this.providers) === this.served) return refused;
+    const catalog = await this.readCatalog();
+    const { placed, refused } = placeProfiles(usable, catalog, this.serving);
+    this.placed = placed;
+    this.catalog = catalog;
+    if (this.stopped || !this.server || !this.bin || providersFingerprint(placed) === this.served) return refused;
     this.options.log('[opencode] restarting the server: its provider profiles changed');
     const old = this.server;
     this.server = null;
@@ -1212,19 +1218,19 @@ export class OpenCodeDriver implements Driver {
     return refused;
   }
 
-  /** The provider ids OpenCode has of its own — built in, configured by
-   *  the operator, signed in to — without the profiles this driver added.
-   *  Empty when the server cannot say (nothing is refused then). */
-  private async ownProviderIds(): Promise<Set<string>> {
+  /** The running server's catalog (catalog.ts). Empty when it cannot say:
+   *  every profile is then a provider of its own, nothing refused or
+   *  filled in. */
+  private async readCatalog(): Promise<Catalog> {
     try {
       const client = await this.clientPromise;
-      if (!client) return new Set();
+      if (!client) return EMPTY_CATALOG;
       const { data, error } = await client.provider.list();
       if (error || !data) throw new Error(JSON.stringify(error ?? 'no provider list'));
-      return new Set(data.all.map((p) => p.id).filter((id) => !this.servedIds.has(id)));
+      return { providers: new Map(data.all.map((p) => [p.id, p])), connected: new Set(data.connected) };
     } catch (err) {
-      this.options.log(`[opencode] could not list its providers, so profile names are not checked: ${err instanceof Error ? err.message : String(err)}`);
-      return new Set();
+      this.options.log(`[opencode] could not read its provider catalog, so profiles are not checked against it: ${err instanceof Error ? err.message : String(err)}`);
+      return EMPTY_CATALOG;
     }
   }
 
@@ -1290,7 +1296,7 @@ export class OpenCodeDriver implements Driver {
       if (error || !data) return { models: [] };
       const models: ModelEntry[] = [];
       const contextLimits: Record<string, number> = {};
-      const profiles = new Map(this.providers.map((p) => [profileProviderId(p), p]));
+      const profiles = new Map(this.placed.map((p) => [p.providerId, p.profile]));
       for (const provider of data.providers) {
         const profile = profiles.get(provider.id);
         for (const model of Object.values(provider.models)) {
diff --git a/packages/agent-host/src/drivers/opencode/providers.ts b/packages/agent-host/src/drivers/opencode/providers.ts
index 82a3214a..d9498106 100644
--- a/packages/agent-host/src/drivers/opencode/providers.ts
+++ b/packages/agent-host/src/drivers/opencode/providers.ts
@@ -2,72 +2,111 @@
  * Provider profiles as OpenCode providers.
  *
  * A profile adds a provider to OpenCode — beside OpenCode Zen and whatever
- * the operator configured, which all stay: an OpenAI-compatible endpoint,
- * its token and its models. OpenCode takes a custom provider only from its
- * config, so the profiles reach the server this driver starts as config
- * handed over in its environment, on top of the operator's files (which are
- * never written):
+ * the operator configured, which all stay. OpenCode takes a provider only
+ * from its config, so the profiles reach the server this driver starts as
+ * config handed over in its environment, on top of the operator's files
+ * (which are never written). Each profile is placed one of two ways, by
+ * what OpenCode's catalog knows (catalog.ts):
  *
- *  - each profile is a provider named as the user named the profile, its
- *    id that name in lower case (`CCR` is `ccr`, its models `ccr/<model>`);
- *    a profile whose id one of OpenCode's own providers already has, or an
- *    earlier profile, is left out with the reason rather than shadow it;
- *  - each token sits in the server's environment only, referenced from the
- *    config, never in a file;
- *  - the server answers only with a password made for it, since its API
- *    reads its config — the tokens included — back to anyone on loopback
- *    who asks.
+ *  - an endpoint the catalog knows (DeepSeek's API, OpenRouter's…) signs in
+ *    to that provider, as `/connect` would: the catalog's models, prices
+ *    and limits, under the name the user gave the profile, plus any model
+ *    the endpoint lists that the catalog does not;
+ *  - any other endpoint (a gateway, a local server) is an OpenAI-compatible
+ *    provider of its own, its id the profile's name in lower case (`CCR` is
+ *    `ccr`, its models `ccr/<model>`), its models what the endpoint listed,
+ *    each filled in from the catalog where it knows the model.
+ *
+ * A profile is left out, with the reason, rather than shadow a provider
+ * OpenCode already has: one it is already signed in to, or one whose id the
+ * profile's name would take, or another profile's. Each token sits in the
+ * server's environment only, referenced from the config; the server answers
+ * only with a password made for it, since its API reads its config — the
+ * tokens included — back to anyone on loopback who asks.
  *
  * The server reads its config when it starts, so a changed profile list
  * means a new server (see the driver).
  */
 import { createHash, randomBytes } from 'node:crypto';
+import type { Provider } from '@opencode-ai/sdk/v2/client';
 import { providerApiRoot } from '../../sdk/providerModels';
 import type { ProviderBinding, ProviderModel, RefusedProvider } from '../../sdk/types';
+import { type Catalog, catalogModel, EMPTY_CATALOG, knownProviderAt, profileModelConfig, providerIdOf } from './catalog';
 
 /** The user name OpenCode's server expects with its password. */
 const SERVER_USERNAME = 'opencode';
 
-/** `name` as an OpenCode provider id: lower case, each run of anything but
- *  letters and digits one `-` (a `/` would split its model ids). */
-function providerIdOf(name: string): string {
-  return name
-    .normalize('NFKD')
-    .replace(/[\u0300-\u036f]/g, '')
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '');
+/** Where a profile sits among OpenCode's providers. */
+export interface Placement {
+  profile: ProviderBinding;
+  /** Its OpenCode provider id: the catalog's for a provider OpenCode knows,
+   *  else its name's. */
+  providerId: string;
+  /** The catalog provider it signs in to, when OpenCode knows its endpoint. */
+  known?: Provider;
+}
+
+/** What profiles already are in a running server, so they are not taken
+ *  for OpenCode's own providers. */
+export interface Served {
+  /** Every provider id profiles took. */
+  ids: ReadonlySet<string>;
+  /** Those that are a profile's own provider, not one of the catalog's. */
+  own: ReadonlySet<string>;
 }
 
-/** The OpenCode provider id of a profile: its name's, or its id's when the
- *  name has no letter or digit. */
+export const NOTHING_SERVED: Served = { ids: new Set(), own: new Set() };
+
+/** The provider id a profile of its own takes: its name's, or its id's
+ *  when the name has no letter or digit. */
 export function profileProviderId(profile: ProviderBinding): string {
   return providerIdOf(profile.label) || providerIdOf(profile.id) || 'provider';
 }
 
-/** Which of `profiles` OpenCode can take, in order: one whose provider id
- *  is `taken` by a provider OpenCode already has, or by an earlier profile,
- *  is refused with the reason. */
-export function admitProfiles(
+/**
+ * Where each of `profiles` goes, in order, against what OpenCode has
+ * (`catalog`) and what earlier profiles took (`served`, not OpenCode's own);
+ * a profile that would shadow a provider is refused with the reason.
+ */
+export function placeProfiles(
   profiles: ProviderBinding[],
-  taken: ReadonlySet<string>,
-): { admitted: ProviderBinding[]; refused: RefusedProvider[] } {
-  const admitted: ProviderBinding[] = [];
+  catalog: Catalog,
+  served: Served = NOTHING_SERVED,
+): { placed: Placement[]; refused: RefusedProvider[] } {
+  const placed: Placement[] = [];
   const refused: RefusedProvider[] = [];
-  const used = new Map<string, ProviderBinding>();
+  const taken = new Map<string, ProviderBinding>();
   for (const profile of profiles) {
-    const id = profileProviderId(profile);
-    const earlier = used.get(id);
-    if (taken.has(id)) {
-      refused.push({ id: profile.id, reason: `OpenCode already has a provider called '${id}'. Give this profile another name.` });
-    } else if (earlier) {
-      refused.push({ id: profile.id, reason: `The provider profile '${earlier.label}' already goes by '${id}' in OpenCode. Give this one another name.` });
-    } else {
-      used.set(id, profile);
-      admitted.push(profile);
+    const known = knownProviderAt(catalog, profile.baseUrl, served.own);
+    const providerId = known?.id ?? profileProviderId(profile);
+    const earlier = taken.get(providerId);
+    const theirs = !served.ids.has(providerId);
+    let reason: string | undefined;
+    if (earlier) {
+      reason = known
+        ? `The provider profile '${earlier.label}' already signs OpenCode in to ${known.name}.`
+        : `The provider profile '${earlier.label}' already goes by '${providerId}' in OpenCode. Give this one another name.`;
+    } else if (known && theirs && catalog.connected.has(providerId)) {
+      reason = `OpenCode already uses ${known.name} with a key of its own; this profile would replace it.`;
+    } else if (!known && theirs && catalog.providers.has(providerId)) {
+      reason = `OpenCode already has a provider called '${providerId}'. Give this profile another name.`;
+    }
+    if (reason) {
+      refused.push({ id: profile.id, reason });
+      continue;
     }
+    taken.set(providerId, profile);
+    placed.push({ profile, providerId, ...(known ? { known } : {}) });
   }
-  return { admitted, refused };
+  return { placed, refused };
+}
+
+/** What `placed` makes of a running server's providers. */
+export function servedBy(placed: Placement[]): Served {
+  return {
+    ids: new Set(placed.map((p) => p.providerId)),
+    own: new Set(placed.filter((p) => !p.known).map((p) => p.providerId)),
+  };
 }
 
 /** The variable profile `index`'s token reaches the server in. */
@@ -75,52 +114,56 @@ function tokenVariable(index: number): string {
   return `CODEDECK_PROVIDER_KEY_${index}`;
 }
 
-/** The provider entries for `profiles`, on top of `base` (an operator's own
+/** One placed profile's provider entry. */
+function providerEntry(placement: Placement, index: number, catalog: Catalog, served: Served): Record<string, unknown> {
+  const { profile, known } = placement;
+  const apiKey = `{env:${tokenVariable(index)}}`;
+  if (known) {
+    // The catalog's models stand; the endpoint's others join them.
+    const extra = profile.models.filter((m) => !known.models[m.id]);
+    return {
+      name: profile.label || known.name,
+      options: { apiKey },
+      ...(extra.length > 0 ? { models: Object.fromEntries(extra.map((m) => [m.id, profileModelConfig(m, undefined)])) } : {}),
+    };
+  }
+  return {
+    npm: '@ai-sdk/openai-compatible',
+    name: profile.label || profile.id,
+    options: { baseURL: providerApiRoot(profile.baseUrl), apiKey },
+    models: Object.fromEntries(profile.models.map((m) => [m.id, profileModelConfig(m, catalogModel(catalog, m, served.own))])),
+  };
+}
+
+/** The provider entries for `placed`, on top of `base` (an operator's own
  *  `OPENCODE_CONFIG_CONTENT`, whose providers stay). */
-export function providersConfig(profiles: ProviderBinding[], base: Record<string, unknown> = {}): Record<string, unknown> {
+export function providersConfig(
+  placed: Placement[],
+  catalog: Catalog = EMPTY_CATALOG,
+  base: Record<string, unknown> = {},
+): Record<string, unknown> {
   const own = (base.provider ?? {}) as Record<string, unknown>;
-  const added = Object.fromEntries(
-    profiles.map((profile, index) => [
-      profileProviderId(profile),
-      {
-        npm: '@ai-sdk/openai-compatible',
-        name: profile.label || profile.id,
-        options: { baseURL: providerApiRoot(profile.baseUrl), apiKey: `{env:${tokenVariable(index)}}` },
-        models: Object.fromEntries(profile.models.map((m) => [m.id, modelConfig(m)])),
-      },
-    ]),
-  );
+  const served = servedBy(placed);
+  const added = Object.fromEntries(placed.map((p, index) => [p.providerId, providerEntry(p, index, catalog, served)]));
   return { ...base, provider: { ...own, ...added } };
 }
 
-/** A profile model as OpenCode's config holds it: named without the
- *  upstream provider its group already shows. A known context window
- *  lets OpenCode compact before the model overflows; the output size is
- *  never listed by endpoints, so it stays 0, OpenCode's own "unknown". */
-function modelConfig(model: ProviderModel): Record<string, unknown> {
-  const name = model.label ?? (model.provider && model.id.startsWith(`${model.provider}/`) ? model.id.slice(model.provider.length + 1) : undefined);
-  return {
-    ...(name ? { name } : {}),
-    ...(model.contextWindow ? { limit: { context: model.contextWindow, output: 0 } } : {}),
-  };
-}
-
 /** The group a profile model is listed under: the profile, and the
  *  provider a gateway routes the model to when the endpoint names one. */
 export function profileModelGroup(profile: string, model: ProviderModel | undefined): string {
   return model?.provider ? `${profile} · ${model.provider}` : profile;
 }
 
-/** What the server is started with to serve `profiles`, and how its client
- *  signs in. */
+/** What the server is started with to serve the profiles, and how its
+ *  client signs in. */
 export interface ServerSetup {
   env: Record<string, string>;
   headers: Record<string, string>;
 }
 
-/** The environment and credentials of a server for `profiles` — and, for
+/** The environment and credentials of a server for `placed` — and, for
  *  every model, web search. `baseEnv` is the host's own environment. */
-export function serverSetup(profiles: ProviderBinding[], baseEnv: NodeJS.ProcessEnv): ServerSetup {
+export function serverSetup(placed: Placement[], catalog: Catalog, baseEnv: NodeJS.ProcessEnv): ServerSetup {
   const password = randomBytes(24).toString('hex');
   const env: Record<string, string> = {
     OPENCODE_SERVER_USERNAME: SERVER_USERNAME,
@@ -130,9 +173,9 @@ export function serverSetup(profiles: ProviderBinding[], baseEnv: NodeJS.Process
     // still behind the `websearch` permission).
     OPENCODE_ENABLE_EXA: '1',
   };
-  if (profiles.length > 0) {
-    env.OPENCODE_CONFIG_CONTENT = JSON.stringify(providersConfig(profiles, operatorConfig(baseEnv)));
-    profiles.forEach((profile, index) => {
+  if (placed.length > 0) {
+    env.OPENCODE_CONFIG_CONTENT = JSON.stringify(providersConfig(placed, catalog, operatorConfig(baseEnv)));
+    placed.forEach(({ profile }, index) => {
       env[tokenVariable(index)] = profile.authToken;
     });
   }
@@ -152,9 +195,9 @@ function operatorConfig(baseEnv: NodeJS.ProcessEnv): Record<string, unknown> {
   }
 }
 
-/** What makes two profile lists need different servers: everything their
+/** What makes two placements need different servers: everything their
  *  config is built from. Hashed, so the tokens are not kept around in it. */
-export function providersFingerprint(profiles: ProviderBinding[]): string {
-  const parts = profiles.map((p) => [p.id, p.label, p.baseUrl, p.authToken, p.models]);
+export function providersFingerprint(placed: Placement[]): string {
+  const parts = placed.map(({ profile: p, providerId }) => [providerId, p.id, p.label, p.baseUrl, p.authToken, p.models]);
   return createHash('sha256').update(JSON.stringify(parts)).digest('hex');
 }

From 10899696d26eb58cfa078b5dacbac75c35a6ac37 Mon Sep 17 00:00:00 2001
From: deymosh <232244450+deymosh@users.noreply.github.com>
Date: Thu, 8 Oct 2026 20:29:53 +0200
Subject: [PATCH 5/5] feat: reasoning levels for each OpenCode model
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

OpenCode gives a model reasoning levels ("variants": low, high, max…)
that differ from model to model, so the agent-wide effort list could not
hold them and OpenCode sessions had no effort control at all. A model
entry now carries its own levels (`efforts`, with a corpus fixture); an
agent that lists no levels of its own has them per model, and the bridge
leaves checking one to the agent. The OpenCode driver lists each model's
variants with its default first, checks a chosen level against the
session's model, drops it when the model changes to one without it, and
asks for it on every prompt and command. The phone offers the session
model's levels in the controls bar and the new-session form.

Co-Authored-By: Claude Code <noreply@anthropic.com>
---
 .../plus/ui/screens/NewSessionScreen.kt       |  17 ++++-
 .../codedeck/plus/ui/session/SessionScreen.kt |   6 +-
 .../main/java/uniffi/client_ffi/client_ffi.kt |  11 ++-
 .../com/codedeck/plus/ui/DesignFixtures.kt    |  30 +++++---
 .../codedeck/plus/ui/DesignSnapshotTest.kt    |   4 ++
 .../ui/components/ModelPickerOptionsTest.kt   |   6 +-
 .../plus/ui/session/ModelLabelTest.kt         |   6 +-
 ...nFullPageSnapshotTest_settings_machine.png | Bin 50098 -> 51024 bytes
 ...esignSnapshotTest_new_session_opencode.png | Bin 0 -> 47974 bytes
 crates/bridge-core/src/catalog.rs             |   5 +-
 crates/bridge-core/tests/cards.rs             |   8 ++-
 crates/client-core/src/stores/machines.rs     |   4 +-
 crates/client-ffi/src/views.rs                |  12 +++-
 crates/client-runtime/src/dispatch.rs         |   2 +-
 crates/protocol/fixtures/corpus.json          |   1 +
 crates/protocol/src/events.rs                 |   9 ++-
 docs/PROTOCOL.md                              |   7 +-
 .../opencode/__tests__/opencodeDriver.test.ts |  68 +++++++++++++++++-
 .../agent-host/src/drivers/opencode/driver.ts |  52 ++++++++++++--
 packages/agent-host/src/generated/protocol.ts |  12 ++++
 20 files changed, 223 insertions(+), 37 deletions(-)
 create mode 100644 apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignSnapshotTest_new_session_opencode.png

diff --git a/apps/android/app/src/main/java/com/codedeck/plus/ui/screens/NewSessionScreen.kt b/apps/android/app/src/main/java/com/codedeck/plus/ui/screens/NewSessionScreen.kt
index b2bdd07a..da2f9e33 100644
--- a/apps/android/app/src/main/java/com/codedeck/plus/ui/screens/NewSessionScreen.kt
+++ b/apps/android/app/src/main/java/com/codedeck/plus/ui/screens/NewSessionScreen.kt
@@ -328,8 +328,23 @@ internal fun NewSessionBody(
             }
 
             // --- Effort ---
+            // An agent whose levels differ by model lists none of its own:
+            // the chosen model's (or its default model's) are offered, its
+            // own default among them.
+            val chosenModel = modelOptions.firstOrNull { it.id == model.ifEmpty { agentModels?.defaultModel.orEmpty() } }
+            val modelEfforts = chosenModel?.efforts.orEmpty()
             val efforts = agent?.efforts.orEmpty()
-            if (efforts.isNotEmpty()) {
+            if (modelEfforts.isNotEmpty()) {
+                if (shown++ > 0) Divider()
+                ValueRow("Effort") {
+                    SelectField(
+                        options = modelEfforts.map { PickerOption(it.id, it.label) },
+                        // A level the model lacks reads as its default.
+                        selected = effort.takeIf { pick -> modelEfforts.any { it.id == pick } } ?: modelEfforts.first().id,
+                        onSelect = { effort = it },
+                    )
+                }
+            } else if (efforts.isNotEmpty()) {
                 if (shown++ > 0) Divider()
                 ValueRow("Effort") {
                     SelectField(
diff --git a/apps/android/app/src/main/java/com/codedeck/plus/ui/session/SessionScreen.kt b/apps/android/app/src/main/java/com/codedeck/plus/ui/session/SessionScreen.kt
index 7943a73b..6de1d218 100644
--- a/apps/android/app/src/main/java/com/codedeck/plus/ui/session/SessionScreen.kt
+++ b/apps/android/app/src/main/java/com/codedeck/plus/ui/session/SessionScreen.kt
@@ -675,7 +675,11 @@ fun SessionScreen(
 
         SessionControlsBar(
             effort = session?.effort,
-            efforts = agent?.efforts.orEmpty(),
+            // The session model's own levels, for an agent whose levels
+            // differ by model; else the agent's.
+            efforts = machineSummary?.models?.firstOrNull { it.agent == session?.agent }?.models
+                ?.firstOrNull { it.id == session?.model }?.efforts?.takeIf { it.isNotEmpty() }
+                ?: agent?.efforts.orEmpty(),
             // The button shows only when the agent has modes to switch between.
             modeLabel = modeLabel?.takeIf { modes.size >= 2 },
             modePending = modeCycle.pending != null,
diff --git a/apps/android/app/src/main/java/uniffi/client_ffi/client_ffi.kt b/apps/android/app/src/main/java/uniffi/client_ffi/client_ffi.kt
index a5ac35d5..1ebaa56f 100644
--- a/apps/android/app/src/main/java/uniffi/client_ffi/client_ffi.kt
+++ b/apps/android/app/src/main/java/uniffi/client_ffi/client_ffi.kt
@@ -6119,6 +6119,12 @@ data class UniffiModelEntry (
      * How many tokens the model takes in, when known.
      */
     var `contextWindow`: kotlin.UInt?
+    , 
+    /**
+     * The model's own reasoning levels, for an agent whose levels differ by
+     * model; empty: the agent's.
+     */
+    var `efforts`: List<UniffiOptionChoice>
     
 ){
     
@@ -6139,6 +6145,7 @@ public object FfiConverterTypeUniffiModelEntry: FfiConverterRustBuffer<UniffiMod
             FfiConverterOptionalString.read(buf),
             FfiConverterOptionalString.read(buf),
             FfiConverterOptionalUInt.read(buf),
+            FfiConverterSequenceTypeUniffiOptionChoice.read(buf),
         )
     }
 
@@ -6146,7 +6153,8 @@ public object FfiConverterTypeUniffiModelEntry: FfiConverterRustBuffer<UniffiMod
             FfiConverterString.allocationSize(value.`id`) +
             FfiConverterOptionalString.allocationSize(value.`label`) +
             FfiConverterOptionalString.allocationSize(value.`provider`) +
-            FfiConverterOptionalUInt.allocationSize(value.`contextWindow`)
+            FfiConverterOptionalUInt.allocationSize(value.`contextWindow`) +
+            FfiConverterSequenceTypeUniffiOptionChoice.allocationSize(value.`efforts`)
     )
 
     override fun write(value: UniffiModelEntry, buf: ByteBuffer) {
@@ -6154,6 +6162,7 @@ public object FfiConverterTypeUniffiModelEntry: FfiConverterRustBuffer<UniffiMod
             FfiConverterOptionalString.write(value.`label`, buf)
             FfiConverterOptionalString.write(value.`provider`, buf)
             FfiConverterOptionalUInt.write(value.`contextWindow`, buf)
+            FfiConverterSequenceTypeUniffiOptionChoice.write(value.`efforts`, buf)
     }
 }
 
diff --git a/apps/android/app/src/test/java/com/codedeck/plus/ui/DesignFixtures.kt b/apps/android/app/src/test/java/com/codedeck/plus/ui/DesignFixtures.kt
index 44101adf..d0b85160 100644
--- a/apps/android/app/src/test/java/com/codedeck/plus/ui/DesignFixtures.kt
+++ b/apps/android/app/src/test/java/com/codedeck/plus/ui/DesignFixtures.kt
@@ -92,21 +92,21 @@ internal object DesignFixtures {
         UniffiProviderProfileInfo(
             id = "home-gateway", agent = "opencode", label = "Home gateway", baseUrl = "http://192.168.1.2:3458",
             models = listOf(
-                UniffiModelEntry("OpenCode Go/deepseek-v4.1-flash", "deepseek-v4.1-flash", "Home gateway · OpenCode Go", 1_000_000u),
-                UniffiModelEntry("Z.ai/glm-5.3-flash", "glm-5.3-flash", "Home gateway · Z.ai", 200_000u),
-                UniffiModelEntry("qwen3.8-coder", null, "Home gateway", null),
+                UniffiModelEntry("OpenCode Go/deepseek-v4.1-flash", "deepseek-v4.1-flash", "Home gateway · OpenCode Go", 1_000_000u, emptyList()),
+                UniffiModelEntry("Z.ai/glm-5.3-flash", "glm-5.3-flash", "Home gateway · Z.ai", 200_000u, emptyList()),
+                UniffiModelEntry("qwen3.8-coder", null, "Home gateway", null, emptyList()),
             ),
             modelsFromProvider = true, defaultModel = "OpenCode Go/deepseek-v4.1-flash", hasToken = true, error = null,
         ),
         UniffiProviderProfileInfo(
             id = "openrouter", agent = "opencode", label = "OpenRouter", baseUrl = "https://openrouter.ai/api",
-            models = (1..42).map { UniffiModelEntry("vendor/model-$it", "model-$it", "OpenRouter · vendor", null) },
+            models = (1..42).map { UniffiModelEntry("vendor/model-$it", "model-$it", "OpenRouter · vendor", null, emptyList()) },
             modelsFromProvider = true, defaultModel = null, hasToken = false,
             error = "OpenCode already has a provider called 'openrouter'. Give this profile another name.",
         ),
         UniffiProviderProfileInfo(
             id = "kimi-k3", agent = "", label = "Kimi K3", baseUrl = "https://api.moonshot.ai/anthropic",
-            models = listOf(UniffiModelEntry("kimi-k3", "Kimi K3", "Kimi K3", null)),
+            models = listOf(UniffiModelEntry("kimi-k3", "Kimi K3", "Kimi K3", null, emptyList())),
             modelsFromProvider = false, defaultModel = "kimi-k3", hasToken = true, error = null,
         ),
     )
@@ -188,13 +188,25 @@ internal object DesignFixtures {
         models = listOf(UniffiAgentModels(
             "claude-code",
             listOf(
-                UniffiModelEntry("opus", "Opus", "Anthropic", null),
-                UniffiModelEntry("fable", "Fable", "Anthropic", null),
-                UniffiModelEntry("OpenCode Go/glm-5.3-flash", "glm-5.3-flash", "OpenCode Go", null),
-                UniffiModelEntry("Z.ai/glm-5.3-flash", "glm-5.3-flash", "Z.ai", null),
+                UniffiModelEntry("opus", "Opus", "Anthropic", null, emptyList()),
+                UniffiModelEntry("fable", "Fable", "Anthropic", null, emptyList()),
+                UniffiModelEntry("OpenCode Go/glm-5.3-flash", "glm-5.3-flash", "OpenCode Go", null, emptyList()),
+                UniffiModelEntry("Z.ai/glm-5.3-flash", "glm-5.3-flash", "Z.ai", null, emptyList()),
             ),
             "opus",
             null,
+        ), UniffiAgentModels(
+            "opencode",
+            listOf(
+                UniffiModelEntry(
+                    "home-gateway/OpenCode Go/deepseek-v4.1-flash", "deepseek-v4.1-flash", "Home gateway · OpenCode Go", null,
+                    listOf("default" to "Default", "low" to "Low", "medium" to "Medium", "high" to "High", "max" to "Max")
+                        .map { (id, label) -> UniffiOptionChoice(id, label, null) },
+                ),
+                UniffiModelEntry("opencode/big-pickle", "Big Pickle", "OpenCode Zen", null, emptyList()),
+            ),
+            "home-gateway/OpenCode Go/deepseek-v4.1-flash",
+            null,
         )),
         providerProfiles = providerProfiles, plugins = listOf(claudePlugins, opencodePlugins), mcp = listOf(claudeMcp),
         directAdvertised = listOf("wss://192.168.1.20:7447"), directPinned = true,
diff --git a/apps/android/app/src/test/java/com/codedeck/plus/ui/DesignSnapshotTest.kt b/apps/android/app/src/test/java/com/codedeck/plus/ui/DesignSnapshotTest.kt
index 7fe766dd..ac56338c 100644
--- a/apps/android/app/src/test/java/com/codedeck/plus/ui/DesignSnapshotTest.kt
+++ b/apps/android/app/src/test/java/com/codedeck/plus/ui/DesignSnapshotTest.kt
@@ -167,6 +167,9 @@ private val pages: Map<String, @Composable () -> Unit> = linkedMapOf(
     "new_session" to {
         NewSessionBody(machine = workstation, events = MutableSharedFlow<CoreEvent>(), dispatch = {}, onClose = {}, onCreated = {})
     },
+    "new_session_opencode" to {
+        NewSessionBody(machine = workstation.copy(defaultAgent = "opencode"), events = MutableSharedFlow<CoreEvent>(), dispatch = {}, onClose = {}, onCreated = {})
+    },
     "pairing" to {
         CompositionLocalProvider(LocalActivityResultRegistryOwner provides DesignFixtures.noResults) {
             PairingBody(
@@ -294,6 +297,7 @@ class DesignSnapshotTest {
     @Test fun transcript_cards() = paparazzi.page("transcript_cards")
     @Test fun transcript_long() = paparazzi.page("transcript_long")
     @Test fun new_session() = paparazzi.page("new_session")
+    @Test fun new_session_opencode() = paparazzi.page("new_session_opencode")
     @Test fun pairing() = paparazzi.page("pairing")
     @Test fun settings() = paparazzi.page("settings")
     @Test fun plugins() = paparazzi.page("plugins")
diff --git a/apps/android/app/src/test/java/com/codedeck/plus/ui/components/ModelPickerOptionsTest.kt b/apps/android/app/src/test/java/com/codedeck/plus/ui/components/ModelPickerOptionsTest.kt
index 63bb178f..400a01ef 100644
--- a/apps/android/app/src/test/java/com/codedeck/plus/ui/components/ModelPickerOptionsTest.kt
+++ b/apps/android/app/src/test/java/com/codedeck/plus/ui/components/ModelPickerOptionsTest.kt
@@ -9,9 +9,9 @@ class ModelPickerOptionsTest {
     fun `models are grouped by provider, in the order providers first appear`() {
         val options = modelPickerOptions(
             listOf(
-                UniffiModelEntry("OpenCode Go/glm-5.3-flash", "glm-5.3-flash", "OpenCode Go", null),
-                UniffiModelEntry("Z.ai/glm-5.3-flash", "glm-5.3-flash", "Z.ai", null),
-                UniffiModelEntry("OpenCode Go/minimax-m3", null, "OpenCode Go", null),
+                UniffiModelEntry("OpenCode Go/glm-5.3-flash", "glm-5.3-flash", "OpenCode Go", null, emptyList()),
+                UniffiModelEntry("Z.ai/glm-5.3-flash", "glm-5.3-flash", "Z.ai", null, emptyList()),
+                UniffiModelEntry("OpenCode Go/minimax-m3", null, "OpenCode Go", null, emptyList()),
             ),
         )
         assertEquals(
diff --git a/apps/android/app/src/test/java/com/codedeck/plus/ui/session/ModelLabelTest.kt b/apps/android/app/src/test/java/com/codedeck/plus/ui/session/ModelLabelTest.kt
index f480e15d..323422ea 100644
--- a/apps/android/app/src/test/java/com/codedeck/plus/ui/session/ModelLabelTest.kt
+++ b/apps/android/app/src/test/java/com/codedeck/plus/ui/session/ModelLabelTest.kt
@@ -50,12 +50,12 @@ class ModelLabelTest {
 
     @Test
     fun aListedModelReadsByItsListName() {
-        val opencode = listOf(UniffiModelEntry("ccr/OpenCode Go/deepseek-v4.1-flash", "deepseek-v4.1-flash", "CCR · OpenCode Go", null))
-        val profile = listOf(UniffiModelEntry("kimi-k3", "Kimi K3", "Moonshot", null))
+        val opencode = listOf(UniffiModelEntry("ccr/OpenCode Go/deepseek-v4.1-flash", "deepseek-v4.1-flash", "CCR · OpenCode Go", null, emptyList()))
+        val profile = listOf(UniffiModelEntry("kimi-k3", "Kimi K3", "Moonshot", null, emptyList()))
         assertEquals("deepseek-v4.1-flash", listedModelName("ccr/OpenCode Go/deepseek-v4.1-flash", listOf(opencode, profile)))
         assertEquals("Kimi K3", listedModelName("kimi-k3", listOf(opencode, profile)))
         // Claude's compact tags stay; an unlisted model has no name.
-        assertNull(listedModelName("claude-opus-5", listOf(listOf(UniffiModelEntry("claude-opus-5", "Opus 5", null, null)))))
+        assertNull(listedModelName("claude-opus-5", listOf(listOf(UniffiModelEntry("claude-opus-5", "Opus 5", null, null, emptyList())))))
         assertNull(listedModelName("unlisted/model", listOf(opencode)))
     }
 }
diff --git a/apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignFullPageSnapshotTest_settings_machine.png b/apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignFullPageSnapshotTest_settings_machine.png
index 352c8fb1aeb12cd3674d46c8319ae0633ac86051..e4c350cf66dbcd732363ecc8a03e9a5e82133ecb 100644
GIT binary patch
literal 51024
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

literal 50098
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

diff --git a/apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignSnapshotTest_new_session_opencode.png b/apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignSnapshotTest_new_session_opencode.png
new file mode 100644
index 0000000000000000000000000000000000000000..e410cf70d136a0c48958247df3410664b6e7827e
GIT binary patch
literal 47974
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
R*dsz1P!1X~<Vrm9_%C`v(VqYS

literal 0
HcmV?d00001

diff --git a/crates/bridge-core/src/catalog.rs b/crates/bridge-core/src/catalog.rs
index 52fce9fe..c345c62b 100644
--- a/crates/bridge-core/src/catalog.rs
+++ b/crates/bridge-core/src/catalog.rs
@@ -69,6 +69,9 @@ pub(crate) fn is_mode(agent: &AgentInfo, mode: &str) -> bool {
     agent.modes.iter().any(|m| m.id == mode)
 }
 
+/// Whether `effort` may be asked of `agent`: one of its levels, or — for an
+/// agent that lists none of its own, its levels differing by model
+/// (`ModelEntry.efforts`) — any, which the agent itself checks.
 pub(crate) fn is_effort(agent: &AgentInfo, effort: &str) -> bool {
-    agent.efforts.iter().any(|e| e.id == effort)
+    agent.efforts.is_empty() || agent.efforts.iter().any(|e| e.id == effort)
 }
diff --git a/crates/bridge-core/tests/cards.rs b/crates/bridge-core/tests/cards.rs
index 82705036..cbc5c74c 100644
--- a/crates/bridge-core/tests/cards.rs
+++ b/crates/bridge-core/tests/cards.rs
@@ -300,8 +300,12 @@ fn set_option_is_checked_against_the_catalog_then_confirmed() {
     rig.host_reply(&id, HostMessage::Error { message: "no".into() });
     assert_eq!(confirmed(&mut rig), ["low"], "a refused change confirms the effort in force");
 
+    // Beta lists no levels of its own: its levels are per model, so the
+    // agent judges one — and its refusal confirms nothing new.
     let b = rig.ready_session("beta");
-    assert_eq!(set_option(&mut rig, &b, "effort", "low"), None, "beta has no efforts");
+    let id = set_option(&mut rig, &b, "effort", "max").expect("left to the agent");
+    rig.host_reply(&id, HostMessage::Error { message: "not a level of this model".into() });
+    assert!(!confirmed(&mut rig).contains(&"max".to_string()));
 }
 
 #[test]
@@ -499,7 +503,7 @@ fn models_are_listed_or_the_phone_is_told_why_not() {
     rig.host_up();
     rig.send(json!({"type":"models-request","agent":"alpha"}));
     let (id, _) = rig.host_request(|m| matches!(m, BridgeMessage::ListModels { .. }));
-    rig.host_reply(&id, HostMessage::Models { models: vec![protocol::events::ModelEntry { id: "m1".into(), label: None, provider: None }], default_model: Some("m1".into()) });
+    rig.host_reply(&id, HostMessage::Models { models: vec![protocol::events::ModelEntry { id: "m1".into(), ..Default::default() }], default_model: Some("m1".into()) });
     let msgs = rig.messages();
     assert!(msgs.iter().any(|m| matches!(m, BridgeToPhone::Models(x) if x.models.len() == 1 && x.error.is_none() && x.default_model.as_deref() == Some("m1"))));
 
diff --git a/crates/client-core/src/stores/machines.rs b/crates/client-core/src/stores/machines.rs
index 8a45bedc..43de3e5e 100644
--- a/crates/client-core/src/stores/machines.rs
+++ b/crates/client-core/src/stores/machines.rs
@@ -1367,7 +1367,7 @@ mod tests {
                 .map(|id| ModelEntry {
                     id: (*id).to_string(),
                     label: Some(id.to_uppercase()),
-                    provider: None,
+                    ..Default::default()
                 })
                 .collect(),
             default_model: default.map(str::to_string),
@@ -1607,7 +1607,7 @@ mod tests {
             "pk",
             &ModelsMsg {
                 agent: "opencode".into(),
-                models: vec![ModelEntry { id: "gpt".into(), label: None, provider: None }],
+                models: vec![ModelEntry { id: "gpt".into(), ..Default::default() }],
                 default_model: None,
                 error: None,
             },
diff --git a/crates/client-ffi/src/views.rs b/crates/client-ffi/src/views.rs
index 255c5f03..f0e671e2 100644
--- a/crates/client-ffi/src/views.rs
+++ b/crates/client-ffi/src/views.rs
@@ -330,12 +330,21 @@ pub struct UniffiModelEntry {
     pub provider: Option<String>,
     /// How many tokens the model takes in, when known.
     pub context_window: Option<u32>,
+    /// The model's own reasoning levels, for an agent whose levels differ by
+    /// model; empty: the agent's.
+    pub efforts: Vec<UniffiOptionChoice>,
 }
 
 fn to_uniffi_model_entries(models: &[protocol::events::ModelEntry]) -> Vec<UniffiModelEntry> {
     models
         .iter()
-        .map(|m| UniffiModelEntry { id: m.id.clone(), label: m.label.clone(), provider: m.provider.clone(), context_window: None })
+        .map(|m| UniffiModelEntry {
+            id: m.id.clone(),
+            label: m.label.clone(),
+            provider: m.provider.clone(),
+            context_window: None,
+            efforts: m.efforts.iter().map(to_uniffi_option_choice).collect(),
+        })
         .collect()
 }
 
@@ -356,6 +365,7 @@ fn to_uniffi_profile_model(profile: &str, m: &protocol::common::ProviderModel) -
             None => profile.to_string(),
         }),
         context_window: m.context_window,
+        efforts: Vec::new(),
     }
 }
 
diff --git a/crates/client-runtime/src/dispatch.rs b/crates/client-runtime/src/dispatch.rs
index a88508d4..6839dc77 100644
--- a/crates/client-runtime/src/dispatch.rs
+++ b/crates/client-runtime/src/dispatch.rs
@@ -1310,7 +1310,7 @@ mod tests {
                     models: vec![protocol::events::ModelEntry {
                         id: "sonnet".into(),
                         label: Some("Sonnet".into()),
-                        provider: None,
+                        ..Default::default()
                     }],
                     default_model: Some("sonnet".into()),
                     error: None,
diff --git a/crates/protocol/fixtures/corpus.json b/crates/protocol/fixtures/corpus.json
index 5438f6eb..a6c74f3b 100644
--- a/crates/protocol/fixtures/corpus.json
+++ b/crates/protocol/fixtures/corpus.json
@@ -129,6 +129,7 @@
       { "type": "usage", "sessionId": "s", "usage": { "available": false, "fetchedAt": "t" } },
       { "type": "gsd-state", "sessionId": "s", "gsd": { "installed": true, "available": true, "hasGit": true, "situation": "x", "summary": "y", "milestone": null, "currentPhase": "2", "totalPhases": 5, "percent": 40.0, "phases": [{ "number": "1", "name": "plan", "diskStatus": "ok", "plans": 2, "summaries": 1, "recentlyTouched": true, "action": null, "command": null, "planCount": 2, "needsYou": null }], "actions": [{ "id": "a", "label": "go", "command": "gsd go", "recommended": true }], "recommended": "a", "paused": false, "blockers": [], "verifyFailed": false, "execution": { "phase": "2", "plansTotal": 3, "plansDone": 1, "currentPlan": "p2", "tasksDone": 4, "tasksTotal": null, "lastTask": "t" } } },
       { "type": "models", "agent": "claude-code", "models": [{ "id": "m1", "label": "M1" }, { "id": "m2" }, { "id": "Z.ai/glm-5.3-flash", "label": "glm-5.3-flash", "provider": "Z.ai" }], "defaultModel": "m1" },
+      { "type": "models", "agent": "opencode", "models": [{ "id": "ccr/OpenCode Go/deepseek-v4.1-flash", "label": "deepseek-v4.1-flash", "provider": "CCR · OpenCode Go", "efforts": [{ "id": "default", "label": "Default" }, { "id": "high", "label": "High" }, { "id": "max", "label": "Max" }] }], "defaultModel": "ccr/OpenCode Go/deepseek-v4.1-flash" },
       { "type": "models", "agent": "opencode", "models": [], "error": "sdk offline" },
       { "type": "commands", "sessionId": "s", "commands": [{ "name": "compact", "description": "Clear history but keep a summary", "argumentHint": "<instructions>" }, { "name": "commit-commands:commit" }] },
       { "type": "commands", "sessionId": "s", "commands": [], "error": "The session is not running." },
diff --git a/crates/protocol/src/events.rs b/crates/protocol/src/events.rs
index 80ba44e5..b7d0bedc 100644
--- a/crates/protocol/src/events.rs
+++ b/crates/protocol/src/events.rs
@@ -5,7 +5,7 @@ use serde::{Deserialize, Serialize};
 
 use super::capabilities::BridgeHostKind;
 use super::common::{
-    AgentDescriptor, AvailablePlugin, CredentialStatus, GsdState, InstalledPlugin, McpAction, McpServerInfo, OutputEntry,
+    AgentDescriptor, AvailablePlugin, CredentialStatus, GsdState, InstalledPlugin, McpAction, McpServerInfo, OptionChoice, OutputEntry,
     SessionMcpServer,
     PluginAction, PluginMarketplace, ProviderProfileInfo, RemoteSessionInfo, SessionOption,
     UsageData,
@@ -208,7 +208,7 @@ pub struct GsdStateMsg {
     pub gsd: GsdState,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, specta::Type)]
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize, specta::Type)]
 pub struct ModelEntry {
     pub id: String,
     #[serde(default, skip_serializing_if = "Option::is_none")]
@@ -217,6 +217,11 @@ pub struct ModelEntry {
     /// says: the same model can be offered by more than one provider.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub provider: Option<String>,
+    /// The reasoning levels of this model, for an agent whose levels differ
+    /// by model (its catalog entry lists none of its own). Empty: the
+    /// agent's own levels, if any.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub efforts: Vec<OptionChoice>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, specta::Type)]
diff --git a/docs/PROTOCOL.md b/docs/PROTOCOL.md
index 2d90538d..1a017f62 100644
--- a/docs/PROTOCOL.md
+++ b/docs/PROTOCOL.md
@@ -269,9 +269,12 @@ wrong provider).
 ### `models`
 
 `models-request {agent}` → `models {agent, models[], defaultModel?, error?}`.
-Each model is `{id, label?, provider?}`: `provider` names who serves it (an
+Each model is `{id, label?, provider?, efforts?}`: `provider` names who serves it (an
 OpenCode provider, a router's channel such as `OpenCode Go`), since the same
-model can be offered by more than one. An empty list always comes with an `error` saying why, so the phone can tell
+model can be offered by more than one. `efforts` are the model's own
+reasoning levels, from an agent whose levels differ by model: its catalog
+entry lists no `efforts`, the phone offers the session model's instead, and
+the bridge leaves checking a level to the agent. An empty list always comes with an `error` saying why, so the phone can tell
 "no answer yet" from a lost message. Models are correlated by the machine that
 sent them (the event author), never by a payload field.
 
diff --git a/packages/agent-host/src/drivers/opencode/__tests__/opencodeDriver.test.ts b/packages/agent-host/src/drivers/opencode/__tests__/opencodeDriver.test.ts
index 5941dfab..d0218688 100644
--- a/packages/agent-host/src/drivers/opencode/__tests__/opencodeDriver.test.ts
+++ b/packages/agent-host/src/drivers/opencode/__tests__/opencodeDriver.test.ts
@@ -5,7 +5,7 @@
  */
 import { describe, it, expect, vi } from 'vitest';
 import type { Event, OpencodeClient, Provider, Session } from '@opencode-ai/sdk/v2/client';
-import { OpenCodeDriver, pickDefaultModel, toQuestionAnswers } from '../driver';
+import { OpenCodeDriver, reasoningLevels, pickDefaultModel, toQuestionAnswers } from '../driver';
 import type { StartSession } from '../../../sdk/types';
 import { recordingContext, type Handlers } from '../../../sdk/__tests__/context';
 
@@ -409,7 +409,7 @@ describe('OpenCode resume', () => {
 });
 
 describe('OpenCode options', () => {
-  it('accepts its modes and provider/model ids, refuses effort', async () => {
+  it('accepts its modes and provider/model ids', async () => {
     const ctx = recordingContext();
     const session = OpenCodeDriver.withClient(clientWith([])).startSession({ sessionId: 's1', agent: 'opencode', cwd: '/tmp' }, ctx);
     await session.setOption('mode', 'default');
@@ -417,7 +417,69 @@ describe('OpenCode options', () => {
     await session.setOption('model', 'anthropic/claude-sonnet-5');
     await expect(session.setOption('mode', 'acceptEdits')).rejects.toThrow(/no mode/);
     await expect(session.setOption('model', 'sonnet')).rejects.toThrow(/provider\/model/);
-    await expect(session.setOption('effort', 'high')).rejects.toThrow(/no effort/);
+    await session.end();
+  });
+});
+
+describe('OpenCode reasoning levels', () => {
+  const catalog = {
+    providers: vi.fn().mockResolvedValue({
+      data: {
+        providers: [{
+          id: 'ccr', name: 'CCR',
+          models: {
+            'OpenCode Go/deepseek-v4.1-flash': { id: 'OpenCode Go/deepseek-v4.1-flash', name: 'deepseek-v4.1-flash', variants: { low: {}, high: {}, max: {} }, cost: { input: 0, output: 0 }, status: 'active' },
+            plain: { id: 'plain', name: 'plain', variants: {}, cost: { input: 0, output: 0 }, status: 'active' },
+          },
+        }],
+        default: {},
+      },
+      error: undefined,
+    }),
+    get: vi.fn().mockResolvedValue({ data: {}, error: undefined }),
+  };
+
+  it("are the model's own, default first", () => {
+    expect(reasoningLevels({ low: {}, xhigh: {}, max: {} })).toEqual([
+      { id: 'default', label: 'Default' },
+      { id: 'low', label: 'Low' },
+      { id: 'xhigh', label: 'Extra high' },
+      { id: 'max', label: 'Max' },
+    ]);
+    expect(reasoningLevels({})).toEqual([]);
+    expect(reasoningLevels(undefined)).toEqual([]);
+  });
+
+  it('are listed with each model, asked of it on every prompt, and checked against it', async () => {
+    const client = Object.assign(clientWith([]), { config: catalog });
+    const promptAsync = vi.fn().mockResolvedValue({ data: undefined, error: undefined });
+    (client.session as unknown as { promptAsync: unknown }).promptAsync = promptAsync;
+    const driver = OpenCodeDriver.withClient(client);
+    const listed = (await driver.listModels()).models;
+    expect(listed.find((m) => m.id === 'ccr/OpenCode Go/deepseek-v4.1-flash')?.efforts?.map((e) => e.id)).toEqual(['default', 'low', 'high', 'max']);
+    expect(listed.find((m) => m.id === 'ccr/plain')).not.toHaveProperty('efforts');
+
+    const ctx = recordingContext();
+    const session = driver.startSession({ sessionId: 's1', agent: 'opencode', cwd: '/tmp', model: 'ccr/OpenCode Go/deepseek-v4.1-flash' }, ctx);
+    await ctx.waitFor((e) => e.type === 'ready');
+    await session.setOption('effort', 'max');
+    session.prompt('think hard');
+    await expect.poll(() => promptAsync.mock.calls.length).toBe(1);
+    expect(promptAsync.mock.calls[0]![0].variant).toBe('max');
+    await expect(session.setOption('effort', 'ultra')).rejects.toThrow(/not a reasoning level/);
+
+    // A model without levels drops the level, and refuses one.
+    await session.setOption('model', 'ccr/plain');
+    session.prompt('quick');
+    await expect.poll(() => promptAsync.mock.calls.length).toBe(2);
+    expect(promptAsync.mock.calls[1]![0]).not.toHaveProperty('variant');
+    await expect(session.setOption('effort', 'high')).rejects.toThrow(/has no reasoning levels/);
+
+    await session.setOption('model', 'ccr/OpenCode Go/deepseek-v4.1-flash');
+    await session.setOption('effort', 'default');
+    session.prompt('as usual');
+    await expect.poll(() => promptAsync.mock.calls.length).toBe(3);
+    expect(promptAsync.mock.calls[2]![0]).not.toHaveProperty('variant');
     await session.end();
   });
 });
diff --git a/packages/agent-host/src/drivers/opencode/driver.ts b/packages/agent-host/src/drivers/opencode/driver.ts
index 47046cff..12531a25 100644
--- a/packages/agent-host/src/drivers/opencode/driver.ts
+++ b/packages/agent-host/src/drivers/opencode/driver.ts
@@ -42,6 +42,7 @@ import { newTranslateContext } from '../../sdk/transcript';
 import type {
   AgentInfo,
   ModelEntry,
+  OptionChoice,
   PermissionOption,
   ProviderBinding,
   QuestionSpec,
@@ -205,6 +206,22 @@ export function pickDefaultModel(
 
 /** Why OpenCode cannot run `model`: none of its providers offers it. When
  *  the model list could not be fetched, nothing is refused. */
+/** The variant OpenCode reads as "none": the model's own settings. */
+const DEFAULT_VARIANT = 'default';
+
+/** How a variant reads in the effort picker. */
+const VARIANT_LABELS: Record<string, string> = { xhigh: 'Extra high', none: 'None' };
+
+/** A model's reasoning levels, from its OpenCode variants (`low`, `high`,
+ *  `max`…, set by OpenCode from what the model is): its default first. A
+ *  model without variants has none. */
+export function reasoningLevels(variants: Record<string, unknown> | undefined): OptionChoice[] {
+  const ids = Object.keys(variants ?? {}).filter((id) => id !== DEFAULT_VARIANT);
+  if (ids.length === 0) return [];
+  const label = (id: string) => VARIANT_LABELS[id] ?? id.charAt(0).toUpperCase() + id.slice(1);
+  return [{ id: DEFAULT_VARIANT, label: 'Default' }, ...ids.map((id) => ({ id, label: label(id) }))];
+}
+
 /** The name OpenCode gives a session it has not titled yet
  *  ("New session - <ISO time>"; "Child session - …" for a sub-agent's). */
 const PLACEHOLDER_TITLE = /^(New|Child) session - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
@@ -308,6 +325,9 @@ export class OpenCodeSession implements DriverSession {
   /** The title last reported for the session. */
   private title: string | undefined;
   private model?: { providerID: string; modelID: string };
+  /** The reasoning level ("variant") prompts ask of the model; none = the
+   *  model's default. */
+  private variant: string | undefined;
 
   /** messageID -> role, seeded from message.updated events, so a later
    *  message.part.updated for the same messageID can be tagged — Part itself
@@ -373,6 +393,9 @@ export class OpenCodeSession implements DriverSession {
     this.mode = params.mode ?? DEFAULT_MODE;
     this.catalog = options.catalog ?? (async () => ({ models: [] }));
     this.model = splitModelId(params.model ?? undefined);
+    // A level the model lacks is ignored by OpenCode: the session starts on
+    // the model's default rather than failing.
+    this.variant = params.effort && params.effort !== DEFAULT_VARIANT ? params.effort : undefined;
     this.ready = this.init(clientPromise, params);
     // init() reports its own failure as `ended`; nothing else awaits this
     // rejection except prompt/interrupt, which catch it themselves.
@@ -875,6 +898,7 @@ export class OpenCodeSession implements DriverSession {
           parts: [{ type: 'text', text }],
           ...(this.model ? { model: this.model } : {}),
           ...this.agentField(),
+          ...this.variantField(),
         });
         if (error) this.deliver({ type: 'error', content: `OpenCode prompt failed: ${JSON.stringify(error)}` });
       })
@@ -918,7 +942,7 @@ export class OpenCodeSession implements DriverSession {
   private runCommand(client: OpencodeClient, sessionID: string, name: string, args: string): void {
     const model = this.model ? `${this.model.providerID}/${this.model.modelID}` : undefined;
     client.session
-      .command({ sessionID, directory: this.cwd, command: name, arguments: args, ...(model ? { model } : {}), ...this.agentField() })
+      .command({ sessionID, directory: this.cwd, command: name, arguments: args, ...(model ? { model } : {}), ...this.agentField(), ...this.variantField() })
       .then(({ error }) => {
         if (error) this.deliver({ type: 'error', content: `OpenCode /${name} failed: ${JSON.stringify(error)}` });
       })
@@ -970,16 +994,33 @@ export class OpenCodeSession implements DriverSession {
         // Model selection is per prompt in OpenCode; the next prompt uses it.
         const split = splitModelId(value);
         if (!split) throw new Error(`'${value}' is not an OpenCode provider/model id`);
-        const refused = unsupportedModelReason(value, (await this.catalog()).models);
+        const models = (await this.catalog()).models;
+        const refused = unsupportedModelReason(value, models);
         if (refused) throw new Error(refused);
         this.model = split;
+        // A level the new model lacks would be ignored; drop it.
+        if (this.variant && !models.find((m) => m.id === value)?.efforts?.some((e) => e.id === this.variant)) this.variant = undefined;
+        return;
+      }
+      case 'effort': {
+        // Levels are the model's own (its OpenCode variants).
+        const { models, defaultModel } = await this.catalog();
+        const id = this.model ? `${this.model.providerID}/${this.model.modelID}` : defaultModel;
+        const levels = models.find((m) => m.id === id)?.efforts ?? [];
+        if (!levels.some((e) => e.id === value)) {
+          throw new Error(levels.length > 0 ? `'${value}' is not a reasoning level of ${id}` : `${id ?? 'This model'} has no reasoning levels`);
+        }
+        this.variant = value === DEFAULT_VARIANT ? undefined : value;
         return;
       }
-      case 'effort':
-        throw new Error('OpenCode has no effort levels');
     }
   }
 
+  /** The reasoning level a prompt or command asks for, if any. */
+  private variantField(): { variant?: string } {
+    return this.variant ? { variant: this.variant } : {};
+  }
+
   async interrupt(): Promise<void> {
     try {
       const { client, session } = await this.ready;
@@ -1303,7 +1344,8 @@ export class OpenCodeDriver implements Driver {
           const id = `${provider.id}/${model.id}`;
           const name = provider.name || provider.id;
           const group = profile ? profileModelGroup(name, profile.models.find((m) => m.id === model.id)) : name;
-          models.push({ id, label: model.name, provider: group });
+          const efforts = reasoningLevels(model.variants);
+          models.push({ id, label: model.name, provider: group, ...(efforts.length > 0 ? { efforts } : {}) });
           const window = model.limit?.context ?? 0;
           if (window > 0) contextLimits[id] = window;
         }
diff --git a/packages/agent-host/src/generated/protocol.ts b/packages/agent-host/src/generated/protocol.ts
index 84c075c4..663ea62d 100644
--- a/packages/agent-host/src/generated/protocol.ts
+++ b/packages/agent-host/src/generated/protocol.ts
@@ -981,6 +981,12 @@ export type ModelEntry_Deserialize = {
 	 *  says: the same model can be offered by more than one provider.
 	 */
 	provider?: string | null,
+	/**
+	 *  The reasoning levels of this model, for an agent whose levels differ
+	 *  by model (its catalog entry lists none of its own). Empty: the
+	 *  agent's own levels, if any.
+	 */
+	efforts?: OptionChoice_Deserialize[],
 };
 
 export type ModelEntry_Serialize = {
@@ -991,6 +997,12 @@ export type ModelEntry_Serialize = {
 	 *  says: the same model can be offered by more than one provider.
 	 */
 	provider?: string | null,
+	/**
+	 *  The reasoning levels of this model, for an agent whose levels differ
+	 *  by model (its catalog entry lists none of its own). Empty: the
+	 *  agent's own levels, if any.
+	 */
+	efforts?: OptionChoice_Serialize[],
 };
 
 /**  Session lifecycle notices a client shows as a marker line. */