@vantran-se/openchamber-web 2.0.3 → 2.0.5

package/server/lib/opencode/v2-install.test.js

@@ -63,7 +63,7 @@ chmod 755 ${quote(binary)}
   });
 
   describe('on Windows', () => {
-    const TARBALL = 'https://registry.npmjs.org/@opencode/cli-windows-x64-baseline/-/cli-windows-x64-baseline-2.0.15.tgz';
+    const tarballOf = (name) => `https://registry.npmjs.org/@opencode/${name}/-/${name}-2.0.15.tgz`;
     let exe;
     const integrityOf = (bytes) => `sha512-${createHash('sha512').update(bytes).digest('base64')}`;
     // The platform package keeps its binary at package/bin/opencode.exe. Here it is a
@@ -77,14 +77,17 @@ chmod 755 ${quote(binary)}
       await fs.rm(root, { recursive: true, force: true });
       return bytes;
     };
-    const runWindows = (archive, integrity = integrityOf(archive)) => installOpenCodeV2({
+    const PACKAGE_BY_ARCH = { x64: 'cli-windows-x64-baseline', arm64: 'cli-windows-arm64' };
+    const runWindows = (archive, integrity = integrityOf(archive), arch = 'x64') => installOpenCodeV2({
       homeDirectory,
       platform: 'win32',
+      arch,
       tarCommand: 'tar',
       fetchImpl: async (url) => {
+        const name = PACKAGE_BY_ARCH[arch];
         if (url.endsWith('/@opencode%2Fcli/latest')) return Response.json({ version: '2.0.15' });
-        if (url.endsWith('/@opencode%2Fcli-windows-x64-baseline/2.0.15')) return Response.json({ dist: { tarball: TARBALL, integrity } });
-        if (url === TARBALL) return new Response(archive);
+        if (url.endsWith(`/@opencode%2F${name}/2.0.15`)) return Response.json({ dist: { tarball: tarballOf(name), integrity } });
+        if (url === tarballOf(name)) return new Response(archive);
         return new Response(null, { status: 404 });
       },
     });
@@ -101,6 +104,12 @@ chmod 755 ${quote(binary)}
       await expect(fs.stat(path.join(path.dirname(exe), '.openchamber-install'))).rejects.toMatchObject({ code: 'ENOENT' });
     });
 
+    it('installs the native arm64 package on Windows ARM64', async () => {
+      const archive = await pack('2.0.15');
+      expect(await runWindows(archive, integrityOf(archive), 'arm64')).toBe(exe);
+      expect(await readOpenCodeCliVersion({ binary: exe, args: [] })).toBe('2.0.15');
+    });
+
     it('rejects a package that does not match its published integrity before touching the binary', async () => {
       const archive = await pack('2.0.15');
       await expect(runWindows(archive, integrityOf(Buffer.from('other')))).rejects.toThrow('integrity');

package/server/lib/opencode/watcher.js

@@ -47,13 +47,15 @@ export const createOpenCodeWatcherRuntime = (deps) => {
     const signal = abortController.signal;
 
     if (globalEventHub) {
+      // The events of isolated spaces feed this watcher too, so live status, unread marks and
+      // notifications work for a space's sessions as for the host's.
       unsubscribeEvent = globalEventHub.subscribeEvent((event) => {
         const payload = unwrapGlobalEventPayload(event.payload);
         if (!payload || typeof payload !== 'object') {
           return;
         }
         emitTranslated(payload);
-      });
+      }, { spaces: true });
       unsubscribeStatus = globalEventHub.subscribeStatus((status) => {
         if (signal.aborted) {
           return;

package/server/lib/opencode/watcher.test.js

@@ -3,6 +3,21 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
 import { createGlobalMessageStreamHub } from '../event-stream/global-hub.js';
 import { createOpenCodeWatcherRuntime } from './watcher.js';
 
+async function waitForAssertion(assertion) {
+  const deadline = Date.now() + 1000;
+  let lastError;
+  while (Date.now() < deadline) {
+    try {
+      assertion();
+      return;
+    } catch (error) {
+      lastError = error;
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+  }
+  throw lastError;
+}
+
 function createSseResponse({ blocks = [], signal, holdOpen = false }) {
   const encoder = new TextEncoder();
   let index = 0;
@@ -189,6 +204,45 @@ describe('createOpenCodeWatcherRuntime', () => {
     });
   });
 
+  it('keeps its shared subscription across a hub rebind', async () => {
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    let generation = 0;
+    const payloads = [];
+    const globalEventHub = createGlobalMessageStreamHub({
+      buildOpenCodeUrl: () => `http://127.0.0.1:${generation === 0 ? 4096 : 5096}/api/event`,
+      getOpenCodeAuthHeaders: () => ({ Authorization: generation === 0 ? 'Basic first' : 'Basic second' }),
+      upstreamReconnectDelayMs: 60_000,
+      fetchImpl: async (_url, options) => createSseResponse({
+        signal: options.signal,
+        holdOpen: true,
+        blocks: [generation === 0
+          ? 'data: {"id":"evt-1","type":"server.connected","data":{}}\n\n'
+          : 'data: {"id":"evt-2","type":"session.renamed","location":{"directory":"/tmp/project"},"data":{"sessionID":"ses_1","title":"Recovered"}}\n\n'],
+      }),
+    });
+    const watcher = createOpenCodeWatcherRuntime({
+      waitForOpenCodePort: async () => {},
+      buildOpenCodeUrl: () => '',
+      getOpenCodeAuthHeaders: () => ({}),
+      globalEventHub,
+      onPayload: (payload) => payloads.push(payload),
+    });
+
+    try {
+      await watcher.start();
+      await waitForAssertion(() => expect(payloads.map((payload) => payload.type)).toContain('server.connected'));
+      generation = 1;
+      globalEventHub.rebind();
+      await waitForAssertion(() => expect(payloads).toContainEqual(expect.objectContaining({
+        type: 'session.updated',
+        properties: expect.objectContaining({ sessionID: 'ses_1' }),
+      })));
+    } finally {
+      watcher.stop();
+      globalEventHub.stop();
+    }
+  });
+
   it('does not stop a shared global event hub when the watcher stops', async () => {
     const events = new Set();
     const statuses = new Set();

package/server/lib/opencode/websearch-config.js

@@ -9,7 +9,7 @@ import {
   readConfigLayers,
   writeConfig,
 } from './shared.js';
-import { findWebSearchProjectOverride, writeWebSearchSelection } from './config-v2.js';
+import { findWebSearchProjectOverride, writeWarmingEnabled, writeWebSearchSelection } from './config-v2.js';
 
 /**
  * Writes the `websearch` choice into the config OpenCode reads last among the
@@ -26,6 +26,18 @@ export function setWebSearchSelection(selection) {
   return { path: target.path, changed };
 }
 
+/**
+ * Turns session warming on or off in the same file the web search choice goes
+ * to; OpenCode watches it, so the change applies without a restart.
+ */
+export function setWarmingEnabled(enabled) {
+  const layers = readConfigLayers(null);
+  const target = getJsonWriteTarget(layers, AGENT_SCOPE.USER);
+  const changed = writeWarmingEnabled(target.config, enabled);
+  if (changed) writeConfig(target.config, target.path);
+  return { path: target.path, changed };
+}
+
 /**
  * Where the effective `websearch` value for `directory` comes from, as far as
  * a Settings write is concerned: `projectPath` is the project config that

package/server/lib/quota/providers/kimi.js

@@ -12,7 +12,7 @@ import {
 
 export const providerId = 'kimi-for-coding';
 export const providerName = 'Kimi for Coding';
-const aliases = ['kimi-for-coding', 'kimi'];
+const aliases = ['kimi-for-coding', 'kimi', 'kimi-code-plan-global'];
 
 // Kimi's weekly `usage` block reports `used`; its rate-limit `limits[].detail`
 // blocks report `remaining` instead. Neither field is guaranteed present, so

package/server/lib/realtime-proxy.js

@@ -10,10 +10,14 @@ const isAllowedSsePath = (pathname) => {
     || pathname === '/api/notifications/stream';
 };
 
+// The same three sockets of an isolated space, under `/api/spaces/<id>/`, matched by shape.
+const SPACE_WS_PATH = /^\/api\/spaces\/[0-9a-f]{12}\/(?:terminal\/ws|event\/ws|global\/event\/ws)$/;
+
 const isAllowedWebSocketPath = (pathname) => {
   return pathname === '/api/event/ws'
     || pathname === '/api/global/event/ws'
-    || pathname === '/api/terminal/ws';
+    || pathname === '/api/terminal/ws'
+    || SPACE_WS_PATH.test(pathname);
 };
 
 const normalizeBaseUrl = (value) => {

package/server/lib/realtime-proxy.test.js

@@ -228,6 +228,35 @@ describe('realtime proxy', () => {
     }
   });
 
+  it('proxies the sockets of an isolated space by path shape, and refuses another path under the prefix', async () => {
+    const seen = [];
+    const upstreamServer = http.createServer();
+    const upstreamWs = new WebSocketServer({ server: upstreamServer });
+    upstreamWs.on('connection', (socket, request) => {
+      seen.push(request.url);
+      socket.send('ready');
+    });
+    const upstreamOrigin = await listen(upstreamServer);
+    const { origin, runtime } = await startProxyServer({ apiBaseUrl: upstreamOrigin });
+    const attempt = (path) => new Promise((resolve, reject) => {
+      const client = new WebSocket(buildRealtimeProxyWsUrl(origin, `${upstreamOrigin.replace(/^http:/, 'ws:')}${path}`), { headers: { Origin: 'openchamber-ui://app' } });
+      client.once('message', (data) => { client.close(); resolve({ message: data.toString() }); });
+      client.once('close', (code) => resolve({ code }));
+      client.once('error', reject);
+    });
+
+    try {
+      expect(await attempt('/api/spaces/a1b2c3d4e5f6/terminal/ws')).toEqual({ message: 'ready' });
+      expect(await attempt('/api/spaces/a1b2c3d4e5f6/event/ws?directory=%2Fspaces%2Fa1b2c3d4e5f6%2Frepo')).toEqual({ message: 'ready' });
+      expect(await attempt('/api/spaces/a1b2c3d4e5f6/dictation/ws')).toEqual({ code: 1008 });
+      expect(await attempt('/api/spaces/A1B2C3D4E5F6/terminal/ws')).toEqual({ code: 1008 });
+      expect(seen).toEqual(['/api/spaces/a1b2c3d4e5f6/terminal/ws', '/api/spaces/a1b2c3d4e5f6/event/ws?directory=%2Fspaces%2Fa1b2c3d4e5f6%2Frepo']);
+      upstreamWs.close();
+    } finally {
+      runtime.stop();
+    }
+  });
+
   it('allows first passwordless WebSocket proxy upgrade without an existing cookie', async () => {
     const upstreamServer = http.createServer();
     const upstreamWs = new WebSocketServer({ server: upstreamServer });

package/server/lib/relay/tunnel-host.js

@@ -37,7 +37,10 @@ const ALLOWED_WS_PATHS = new Set([
 // Extension surfaces carry the extension id in the path, so they are matched
 // by shape rather than listed.
 const GUEST_SURFACE_WS_PATH = /^\/api\/guests\/[a-z][a-z0-9-]*\/surface\/ws$/;
-export const isAllowedRelayWebSocketPath = (pathname) => ALLOWED_WS_PATHS.has(pathname) || GUEST_SURFACE_WS_PATH.test(pathname);
+// The sockets of an isolated space carry the space id in the path: the same four sockets,
+// under `/api/spaces/<id>/`, matched by shape.
+const SPACE_WS_PATH = /^\/api\/spaces\/[0-9a-f]{12}\/(?:terminal\/ws|dev-tunnel|event\/ws|global\/event\/ws)$/;
+export const isAllowedRelayWebSocketPath = (pathname) => ALLOWED_WS_PATHS.has(pathname) || GUEST_SURFACE_WS_PATH.test(pathname) || SPACE_WS_PATH.test(pathname);
 
 // Hop-by-hop headers stripped from tunneled requests; `host` is set by fetch
 // to the loopback origin. content-length is dropped too because the body is

package/server/lib/relay/tunnel-host.test.js

@@ -153,6 +153,17 @@ describe('relay host WebSocket allowlist', () => {
     expect(isAllowedRelayWebSocketPath('/api/database/ws')).toBe(false);
   });
 
+  test('allows the sockets of an isolated space by path shape only', () => {
+    for (const socket of ['terminal/ws', 'dev-tunnel', 'event/ws', 'global/event/ws']) {
+      expect(isAllowedRelayWebSocketPath(`/api/spaces/a1b2c3d4e5f6/${socket}`)).toBe(true);
+    }
+    expect(isAllowedRelayWebSocketPath('/api/spaces/a1b2c3d4e5f6/dictation/ws')).toBe(false);
+    expect(isAllowedRelayWebSocketPath('/api/spaces/A1B2C3D4E5F6/terminal/ws')).toBe(false);
+    expect(isAllowedRelayWebSocketPath('/api/spaces/a1b2c3d4e5f/terminal/ws')).toBe(false);
+    expect(isAllowedRelayWebSocketPath('/api/spaces/a1b2c3d4e5f6/terminal/ws/x')).toBe(false);
+    expect(isAllowedRelayWebSocketPath('/api/spaces//terminal/ws')).toBe(false);
+  });
+
   test('allows an extension surface socket by path shape only', () => {
     expect(isAllowedRelayWebSocketPath('/api/guests/server-chrome/surface/ws')).toBe(true);
     expect(isAllowedRelayWebSocketPath('/api/guests/Server/surface/ws')).toBe(false);

package/server/lib/session-assist/DOCUMENTATION.md

@@ -121,13 +121,25 @@ before work and before writing. With both off there are no reads, model calls,
 or writes. With one on, the shared recent context is still available, but only
 that field is requested. An empty suggestion does not erase a valid recap.
 
-Clients render an assist only while its `forMessageID` is the last message and
-the session is idle. A new message invalidates it without clearing writes.
-
-- `packages/ui/src/lib/sessionAssistMetadata.ts` parses the payload.
-- `packages/ui/src/hooks/useSessionAssist.ts` owns freshness/settings gating.
+Freshness has one rule, `getCurrentSessionAssist` in
+`packages/ui/src/lib/sessionAssistMetadata.ts`, computed from the session
+record alone so the chat and the sidebar row always agree: the payload is
+current while `generatedAt >= session.time.idle` and the session is not
+reverted. OpenCode moves `time.idle` at every turn end, succeeded or failed.
+Do not compare `forMessageID` with the last loaded message: in v2 the newest
+record is the turn's `idle` marker or a switch record, never the answer.
+When a session turns busy, the runtime also deletes the assist it wrote
+(`persistSessionAssist(id, dir, null)`), so stored state goes stale only for
+payloads written by an earlier process; the `time.idle` rule retires those.
+
+- `packages/ui/src/lib/sessionAssistMetadata.ts` parses the payload and owns freshness.
+- `packages/ui/src/hooks/useSessionAssist.ts` adds live-status and settings gating.
 - `SessionRecapSpacer` shows the reminder in the reserved gap under the reply.
 - `SessionSuggestionChip` fills the composer; it never sends automatically.
+- Sidebar rows (`SessionNodeItem`, both Projects and Timeline) mark a session
+  whose suggestion is still open with a small icon and the suggestion as its
+  title, using the same freshness rule (`getOpenSessionSuggestion`). The marker hides while a turn runs, on the open session, and
+  when `sessionSuggestionEnabled` is off.
 
 Web, Electron, hosted mobile, and Capacitor use the server watcher. VS Code's
 extension-only runtime does not generate assists; shared UI can render payloads

package/server/lib/session-assist/runtime.js

@@ -1,5 +1,6 @@
 // Background session assistance. Only live idle events arm generation; there
-// is no backfill. Clients hide results whose forMessageID is no longer current.
+// is no backfill. A new turn deletes the assist this process wrote; clients
+// retire any other payload older than the session's `time.idle`.
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
@@ -99,6 +100,8 @@ export const createSessionAssistRuntime = ({
   const timers = new Map();
   const inflight = new Map();
   const ready = new Map();
+  // Sessions holding an assist this process wrote, keyed to their directory.
+  const persisted = new Map();
   let stopped = false;
 
   const clearTimer = (sessionId) => {
@@ -115,6 +118,16 @@ export const createSessionAssistRuntime = ({
     inflight.get(sessionId)?.controller.abort();
   };
 
+  // A new turn makes the stored recap and suggestion describe an older turn:
+  // delete them so "has a suggestion" in metadata means the same everywhere.
+  const retireStored = (sessionId, directory) => {
+    if (!persisted.has(sessionId)) return;
+    const storedDirectory = persisted.get(sessionId);
+    persisted.delete(sessionId);
+    Promise.resolve(persistSessionAssist(sessionId, directory || storedDirectory, null))
+      .catch(() => console.warn('[session-assist] failed to retire a stale assist'));
+  };
+
   const generateAssist = async (sessionId, directory, signal) => {
     const targets = getTargets();
     if (!targets.recap && !targets.suggestion) return;
@@ -206,6 +219,7 @@ export const createSessionAssistRuntime = ({
       forMessageID: last.id,
       generatedAt: Date.now(),
     });
+    persisted.set(sessionId, directory);
   };
 
   const startGeneration = (sessionId, directory, armedAt) => {
@@ -254,7 +268,10 @@ export const createSessionAssistRuntime = ({
     const status = extractSessionStatus(payload);
     if (status) {
       if (status.type === 'idle') armTimer(status.sessionId, status.directory || directoryHint);
-      else invalidate(status.sessionId);
+      else {
+        invalidate(status.sessionId);
+        retireStored(status.sessionId, status.directory || directoryHint);
+      }
       return;
     }
     const userMessage = extractUserMessage(payload);

package/server/lib/session-assist/runtime.test.js

@@ -153,6 +153,14 @@ describe('session assist runtime', () => {
     expect(persistSessionAssist.mock.calls[0][2]).toMatchObject({ recap: 'Did the thing.', suggestion: 'Verify it.', forMessageID: 'msg_a' });
     // The pre-write re-check must see past the idle marker as well.
     expect(listLimits.at(-1)).toBeGreaterThan(2);
+
+    // A new turn deletes the stored assist, once.
+    const busy = { type: 'session.status', properties: { sessionID: 'ses_1', status: { type: 'busy' } } };
+    runtime.processPayload(busy);
+    runtime.processPayload(busy);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(persistSessionAssist).toHaveBeenCalledTimes(2);
+    expect(persistSessionAssist.mock.calls[1][2]).toBeNull();
     vi.unstubAllGlobals();
   });
 

package/server/lib/session-goal/DOCUMENTATION.md

@@ -70,6 +70,17 @@ before touching the filesystem). Rationale: metadata rides every
   objective fitting, inline fallback, metadata creation, and the synthetic
   first-turn reminder shared by scheduled tasks and CLI-created sessions.
 
+- Forks: OpenCode copies the source metadata into a fork, goal included.
+  The UI fork paths (`forkAfterMessage`, `forkFromMessage`, `/fork`) then copy
+  the objective file to the fork's id, or inline the text when that write
+  fails (`packages/ui/src/lib/sessionForkInheritance.ts`). The copy re-reads
+  the fork's goal id first and is skipped when the user armed a new goal on
+  the fork meanwhile. Forks made through `POST /api/openchamber/sessions/:id/fork`
+  (CLI, scheduled tasks) get the same repair server-side before the prompt is
+  dispatched (`openchamber-sessions/fork-inheritance.js`); UI forks call
+  OpenCode directly, so both implementations exist. `/btw` forks drop the goal
+  with the rest of the inherited namespace.
+
 ## Flow
 
 1. `createSessionGoalRuntime` subscribes to the global SSE hub (same pattern

package/server/lib/small-model/DOCUMENTATION.md

@@ -81,12 +81,10 @@ Four things are decided here, in order:
 5. Otherwise `GET /api/model/default` — `source: 'default'`. This is
    OpenCode's default chat model, not a small one; it is the last resort.
 
-Claude Code is refused unconditionally (`422`,
-`code: 'small-model-provider-unsupported'`). A plugin can publish an
-OpenAI-compatible endpoint for it, but that endpoint is a façade over the
-Claude Agent SDK, which spawns the Claude Code CLI per request and spends the
-user's Claude subscription rate limit. An available endpoint does not lift the
-refusal — the cost is the reason, not the transport.
+Claude Code (`claude-code`, from the opencode-claude plugin) is a provider
+like any other: its generate path runs a clean one-shot turn with no tools and
+no session, so `claude-code/haiku` (family `claude-haiku`) is picked in the
+normal family order.
 
 ## Prompt shape
 
@@ -120,10 +118,13 @@ model they got. The resolved value comes back as `outputTokens`.
 longer wanted. The timeout covers generation, retry waits and structured-output
 retries together.
 
-OpenCode 2 can reject an explicit model before its cold catalog finishes loading.
-An `InvalidRequestError` whose message exactly names the selected model as
-`Model unavailable: provider/model` gets one retry after 500 ms, with the same
-model and prompt. Cancellation also stops the wait. Other errors are not retried.
+OpenCode 2 can reject an explicit model before its cold catalog finishes loading;
+plugin-provided models (Claude Code) stay unavailable for 20-40 s after OpenCode
+starts because plugins for the global location load lazily. An
+`InvalidRequestError` whose message exactly names the selected model as
+`Model unavailable: provider/model` is retried with exponential backoff (0.5, 1,
+2, 4, 8, 16 s, ~31 s in total), with the same model and prompt. The rejection
+precedes provider dispatch, so retries cost no tokens. Cancellation also stops the wait. Other errors are not retried.
 If the model remains unavailable, the route returns 503 with
 `code: 'small-model-unavailable'` and the model-specific reason. Commit and PR
 generation own their error toast and suppress the shared request toast.

package/server/lib/small-model/index.js

@@ -11,16 +11,20 @@ import {
   listProviderInfos,
 } from './client.js';
 
-// Never a small model, whatever the transport looks like. A plugin can publish
-// an OpenAI-compatible endpoint for Claude Code, but it is a façade over the
-// Claude Agent SDK, which spawns the Claude Code CLI per request and spends
-// the user's Claude subscription rate limit. Paying that for a session title
-// or a summary is the wrong trade, so the refusal is unconditional rather than
-// conditional on an endpoint existing.
-const CLAUDE_CODE_PROVIDER = 'claude-code';
-
 const DEFAULT_TIMEOUT_MS = 60_000;
 
+// Waits between retries of `Model unavailable`, ~31 s in total. Right after
+// OpenCode starts, plugin-provided models (claude-code) stay unavailable for
+// 20-40 s while plugins for the global location load lazily. The rejection
+// precedes provider dispatch, so a retry costs no tokens.
+const UNAVAILABLE_RETRY_DELAYS_MS = [500, 1_000, 2_000, 4_000, 8_000, 16_000];
+let unavailableRetryDelaysMs = UNAVAILABLE_RETRY_DELAYS_MS;
+
+/** Test hook: replace the backoff schedule; no argument restores the default. */
+export const setUnavailableRetryDelaysForTest = (delays = UNAVAILABLE_RETRY_DELAYS_MS) => {
+  unavailableRetryDelaysMs = delays;
+};
+
 const OPENCHAMBER_SETTINGS_FILE = path.join(
   process.env.OPENCHAMBER_DATA_DIR
     ? path.resolve(process.env.OPENCHAMBER_DATA_DIR)
@@ -151,7 +155,6 @@ export const pickSmallModelAnywhere = (models) => pickSmallModel(models, () => t
 const pickSmallModel = (models, accept) => {
   const candidates = models
     .filter((model) => model && accept(model)
-      && model.providerID !== CLAUDE_CODE_PROVIDER
       && model.enabled !== false
       && (model.status === undefined || model.status === 'active')
       && (model.capabilities?.input ?? ['text']).some((item) => String(item).startsWith('text'))
@@ -260,13 +263,6 @@ export async function generateSmallModelText({ prompt, system, maxOutputTokens,
     );
   }
 
-  if (resolved.providerID === CLAUDE_CODE_PROVIDER) {
-    throw Object.assign(
-      new Error('Claude Code cannot be used for background small-model actions. Choose another Small Model in Settings → Sessions.'),
-      { statusCode: 422, code: 'small-model-provider-unsupported' },
-    );
-  }
-
   // A caller that must stay on its session's provider is only overruled by an
   // explicit user choice (the settings override or a request model).
   if (restrictToPreferredProvider
@@ -302,7 +298,6 @@ export async function generateSmallModelText({ prompt, system, maxOutputTokens,
 
   const generationOptions = requestOptions({ timeoutMs, signal });
   const unavailableMessage = `Model unavailable: ${resolved.providerID}/${resolved.modelID}`;
-  let retriedUnavailable = false;
   const send = async () => {
     const result = await client.generate.text(
       { prompt: fullPrompt, model: { id: resolved.modelID, providerID: resolved.providerID } },
@@ -312,21 +307,22 @@ export async function generateSmallModelText({ prompt, system, maxOutputTokens,
   };
 
   const sendWithCatalogRetry = async () => {
-    try {
-      return await send();
-    } catch (error) {
-      if (error?._tag !== 'InvalidRequestError' || error.message !== unavailableMessage) throw error;
-      // OpenCode 2 can resolve a cold catalog before its models arrive.
-      // This rejection precedes provider dispatch; other failures must not retry.
-      if (!retriedUnavailable) {
-        retriedUnavailable = true;
-        await delay(500, undefined, { signal: generationOptions.signal });
-        return sendWithCatalogRetry();
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        return await send();
+      } catch (error) {
+        if (error?._tag !== 'InvalidRequestError' || error.message !== unavailableMessage) throw error;
+        // OpenCode 2 can resolve a cold catalog before its models arrive.
+        // This rejection precedes provider dispatch; other failures must not retry.
+        if (attempt < unavailableRetryDelaysMs.length) {
+          await delay(unavailableRetryDelaysMs[attempt], undefined, { signal: generationOptions.signal });
+          continue;
+        }
+        throw Object.assign(new Error(unavailableMessage), {
+          statusCode: 503,
+          code: 'small-model-unavailable',
+        });
       }
-      throw Object.assign(new Error(unavailableMessage), {
-        statusCode: 503,
-        code: 'small-model-unavailable',
-      });
     }
   };
 
@@ -386,7 +382,6 @@ export async function listAuthenticatedProviders() {
       if (typeof provider?.id === 'string' && enabled.has(provider.id)) ids.add(provider.id);
     }
     for (const id of enabled) ids.add(id);
-    ids.delete(CLAUDE_CODE_PROVIDER);
     return Array.from(ids);
   } catch {
     return [];

package/server/lib/small-model/index.test.js

@@ -3,14 +3,14 @@ import { registerSmallModelRoutes } from './routes.js';
 import http from 'node:http';
 import os from 'os';
 import path from 'path';
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
 
 // The settings override is read straight from disk, so without this the suite
 // would resolve whatever small model the developer running it has configured.
 const TEMP_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'small-model-settings-'));
 process.env.OPENCHAMBER_DATA_DIR = TEMP_DATA_DIR;
 
-const { generateSmallModelText, describeSmallModel, listAuthenticatedProviders } = await import('./index.js');
+const { generateSmallModelText, describeSmallModel, listAuthenticatedProviders, setUnavailableRetryDelaysForTest } = await import('./index.js');
 const { configureOpenCodeRuntimeProviders, resetOpenCodeRuntimeProviders } = await import('./client.js');
 
 // A real OpenCode stub over HTTP. The module talks to OpenCode through
@@ -103,7 +103,10 @@ describe('generateSmallModelText', () => {
   const unavailable = { _tag: 'InvalidRequestError', message: 'Model unavailable: zai-coding-plan/glm-5.3-flash' };
   const options = { prompt: 'write a commit', model: 'zai-coding-plan/glm-5.3-flash' };
 
-  it('retries a cold catalog once with the same model and prompt', async () => {
+  beforeEach(() => setUnavailableRetryDelaysForTest([1, 1, 1]));
+  afterEach(() => setUnavailableRetryDelaysForTest());
+
+  it('retries a cold catalog with the same model and prompt', async () => {
     state.generateErrors = [unavailable];
     const result = await generateSmallModelText(options);
     expect(result.text).toBe('generated');
@@ -112,12 +115,19 @@ describe('generateSmallModelText', () => {
     expect(calls[0].body).toEqual(calls[1].body);
   });
 
-  it('reports persistent model unavailability after one retry', async () => {
-    state.generateErrors = [unavailable, unavailable];
+  it('keeps backing off while the plugin model loads', async () => {
+    state.generateErrors = [unavailable, unavailable, unavailable];
+    const result = await generateSmallModelText(options);
+    expect(result.text).toBe('generated');
+    expect(state.requests.filter((entry) => entry.path === '/api/experimental/generate')).toHaveLength(4);
+  });
+
+  it('reports persistent model unavailability once the backoff runs out', async () => {
+    state.generateErrors = [unavailable, unavailable, unavailable, unavailable];
     await expect(generateSmallModelText(options)).rejects.toMatchObject({
       message: unavailable.message, statusCode: 503, code: 'small-model-unavailable',
     });
-    expect(state.requests.filter((entry) => entry.path === '/api/experimental/generate')).toHaveLength(2);
+    expect(state.requests.filter((entry) => entry.path === '/api/experimental/generate')).toHaveLength(4);
   });
 
   it('does not retry other invalid requests', async () => {
@@ -133,6 +143,7 @@ describe('generateSmallModelText', () => {
   });
 
   it('cancels without sending the retry', async () => {
+    setUnavailableRetryDelaysForTest();
     const controller = new AbortController();
     state.generateErrors = [unavailable];
     const pending = generateSmallModelText({ ...options, signal: controller.signal });
@@ -146,6 +157,7 @@ describe('generateSmallModelText', () => {
   });
 
   it('honors the timeout during the retry delay', async () => {
+    setUnavailableRetryDelaysForTest();
     state.generateErrors = [unavailable];
     await expect(generateSmallModelText({ ...options, timeoutMs: 100 })).rejects.toThrow();
     expect(state.requests.filter((entry) => entry.path === '/api/experimental/generate')).toHaveLength(1);
@@ -182,11 +194,11 @@ describe('generateSmallModelText', () => {
     expect(lastGenerate().body.model).toEqual({ id: 'gpt-5.6-luna', providerID: 'openai' });
   });
 
-  it('refuses Claude Code before any request reaches the model', async () => {
-    await expect(generateSmallModelText({ prompt: 'hi', model: 'claude-code/haiku', directory: '/proj' }))
-      .rejects.toMatchObject({ statusCode: 422, code: 'small-model-provider-unsupported' });
+  it('sends an explicit Claude Code model like any other', async () => {
+    const result = await generateSmallModelText({ prompt: 'hi', model: 'claude-code/haiku', directory: '/proj' });
 
-    expect(lastGenerate()).toBeUndefined();
+    expect(result).toMatchObject({ providerID: 'claude-code', modelID: 'haiku', source: 'request' });
+    expect(lastGenerate().body.model).toEqual({ id: 'haiku', providerID: 'claude-code' });
   });
 
   it('stays on the session provider when the caller forbids switching', async () => {
@@ -276,14 +288,12 @@ describe('generateSmallModelText', () => {
     expect(result).toMatchObject({ providerID: 'my-proxy', modelID: 'gemini-3.6-flash', source: 'session-provider-small' });
   });
 
-  it('never picks Claude Code as the small model of any provider', async () => {
+  it('picks Claude Code haiku as the small model like any other provider', async () => {
     state.models = [MODEL({ id: 'haiku', modelID: 'haiku', providerID: 'claude-code', family: 'claude-haiku' })];
 
     const result = await generateSmallModelText({ prompt: 'hi', directory: '/proj' });
 
-    // Only Claude Code has a small family here, so the scan yields nothing
-    // and OpenCode's default (the fixture's anthropic haiku) is used.
-    expect(result).toMatchObject({ providerID: 'anthropic', modelID: 'claude-haiku-4-5', source: 'default' });
+    expect(result).toMatchObject({ providerID: 'claude-code', modelID: 'haiku', source: 'small' });
   });
 
   it('ignores a disabled small model and falls back to the session model', async () => {
@@ -487,10 +497,10 @@ describe('listAuthenticatedProviders', () => {
     expect(await listAuthenticatedProviders()).toEqual(['anthropic']);
   });
 
-  it('never offers Claude Code', async () => {
+  it('offers Claude Code', async () => {
     state.models = [MODEL(), MODEL({ id: 'sonnet', modelID: 'sonnet', providerID: 'claude-code' })];
 
-    expect(await listAuthenticatedProviders()).not.toContain('claude-code');
+    expect(await listAuthenticatedProviders()).toContain('claude-code');
   });
 
   it('answers an empty list when OpenCode is not reachable', async () => {
@@ -510,6 +520,7 @@ describe('small model failure response', () => {
     }, {
       getSmallModelService: async () => ({ generateSmallModelText }),
     });
+    setUnavailableRetryDelaysForTest([1]);
     state.generateErrors = [
       { _tag: 'InvalidRequestError', message: 'Model unavailable: zai-coding-plan/glm-5.3-flash' },
       { _tag: 'InvalidRequestError', message: 'Model unavailable: zai-coding-plan/glm-5.3-flash' },
@@ -526,5 +537,6 @@ describe('small model failure response', () => {
       error: 'Model unavailable: zai-coding-plan/glm-5.3-flash',
       code: 'small-model-unavailable',
     });
+    setUnavailableRetryDelaysForTest();
   });
 });