catence 0.2.0-beta.8 → 0.2.0

package/scripts/discover-opencode-go.mjs

@@ -1,12 +1,11 @@
+#!/usr/bin/env node
 // Discover OpenCode Go models and emit Catence Console profiles for them.
 //
-// OpenCode Go serves its catalog through three APIs: most models speak the
-// OpenAI Chat Completions API, Grok and GPT-5.6 Luna speak the OpenAI
-// Responses API, and MiniMax and Qwen speak the Anthropic Messages API. The
+// Thin CLI wrapper around the runtime's src/core/runtime/opencode-go.ts
+// module, which owns the "live discovery + trusted metadata" logic: the
 // public `GET /models` endpoint returns only model ids, not which API each
-// model needs, so routing comes from the trusted table below and is intersected
-// with the live list (the same "live discovery + trusted metadata" approach
-// OpenClaw uses).
+// model needs, so routing comes from a trusted table intersected with the
+// live list (the same approach OpenClaw uses).
 //
 // Usage:
 //   node scripts/discover-opencode-go.mjs [--base-url <url>] [--write <config.json>] [--set-default]
@@ -17,62 +16,19 @@
 //   --set-default      With --write, set console.defaultProfile to opencode-go even when one already exists.
 
 import process from 'node:process';
-import { readFile, writeFile } from 'node:fs/promises';
 
-const DEFAULT_BASE_URL = 'https://opencode.ai/zen/go/v1';
-const API_KEY_ENV = 'OPENCODE_GO_API_KEY';
-const API_BASE_ENV = 'OPENCODE_GO_API_BASE';
-const MESSAGES_BASE_ENV = 'OPENCODE_GO_MESSAGES_API_BASE';
-
-// LiteLLM appends a fixed suffix to the profile base URL per provider, so the
-// three APIs need different prefixes and two base URLs:
-//   openai/<id>             -> {base}/chat/completions
-//   openai/responses/<id>   -> {base}/responses
-//   anthropic/<id>          -> {base minus /v1}/v1/messages
-const RESPONSES_MODELS = new Set(['grok-4.5', 'gpt-5.6-luna']);
-const MESSAGES_MODELS = new Set([
-  'minimax-m2.5',
-  'minimax-m2.7',
-  'minimax-m3',
-  'qwen3.5-plus',
-  'qwen3.6-plus',
-  'qwen3.7-plus',
-  'qwen3.7-max',
-  'qwen3.8-max',
-]);
-
-const BRAND_NAMES = new Map([
-  ['deepseek', 'DeepSeek'],
-  ['glm', 'GLM'],
-  ['gpt', 'GPT'],
-  ['grok', 'Grok'],
-  ['hy3', 'Hy3'],
-  ['kimi', 'Kimi'],
-  ['mimo', 'MiMo'],
-  ['minimax', 'MiniMax'],
-  ['qwen', 'Qwen'],
-]);
-
-function classify(id) {
-  if (RESPONSES_MODELS.has(id)) return { route: 'responses', guessed: false };
-  if (MESSAGES_MODELS.has(id)) return { route: 'messages', guessed: false };
-  if (/^(grok-|gpt-)/.test(id)) return { route: 'responses', guessed: true };
-  if (/^(minimax-|qwen)/.test(id)) return { route: 'messages', guessed: true };
-  return { route: 'chat', guessed: false };
+let runtime;
+try {
+  runtime = await import(new URL('../dist/core/runtime/opencode-go.js', import.meta.url).href);
+} catch (error) {
+  if (error?.code !== 'ERR_MODULE_NOT_FOUND') throw error;
+  process.stderr.write(
+    'The discovery module is not built yet. Run `npm run build` in the catence checkout first, or use an installed `catence` package.\n',
+  );
+  process.exit(1);
 }
 
-function modelReference(id, route) {
-  if (route === 'responses') return `openai/responses/${id}`;
-  if (route === 'messages') return `anthropic/${id}`;
-  return `openai/${id}`;
-}
-
-function labelFor(id) {
-  return id
-    .split('-')
-    .map((segment) => BRAND_NAMES.get(segment) ?? segment.charAt(0).toUpperCase() + segment.slice(1))
-    .join(' ');
-}
+const { OPENCODE_GO_API_BASE_ENV, OPENCODE_GO_API_KEY_ENV, OPENCODE_GO_MESSAGES_API_BASE_ENV } = runtime;
 
 function usage() {
   process.stderr.write(
@@ -82,7 +38,7 @@ function usage() {
 
 async function main() {
   const args = process.argv.slice(2);
-  let baseUrl = DEFAULT_BASE_URL;
+  let baseUrl = runtime.OPENCODE_GO_DEFAULT_BASE_URL;
   let writePath = null;
   let setDefault = false;
   for (let i = 0; i < args.length; i += 1) {
@@ -108,100 +64,36 @@ async function main() {
   if (!baseUrl.endsWith('/v1')) {
     process.stderr.write(`Warning: --base-url ${baseUrl} does not end in /v1; chat and responses URLs may be wrong.\n`);
   }
-  const modelsUrl = `${baseUrl.replace(/\/$/, '')}/models`;
   const messagesBase = baseUrl.replace(/\/v1\/?$/, '');
 
-  let response;
-  try {
-    response = await fetch(modelsUrl, { headers: { accept: 'application/json' } });
-  } catch (error) {
-    throw new Error(`Could not reach ${modelsUrl}: ${error.message}`);
-  }
-  if (!response.ok) {
-    throw new Error(`GET ${modelsUrl} returned HTTP ${response.status}.`);
-  }
-  const payload = await response.json();
-  const ids = (payload.data ?? []).map((entry) => entry.id).filter((id) => typeof id === 'string' && id);
-
-  const groups = { chat: [], responses: [], messages: [] };
-  const guessed = [];
-  for (const id of ids) {
-    const { route, guessed: wasGuessed } = classify(id);
-    if (!(route in groups)) continue;
-    groups[route].push(id);
-    if (wasGuessed) guessed.push(`${id} -> ${route}`);
-  }
-  for (const route of Object.keys(groups)) groups[route].sort();
-
-  const chatProfileModels = {};
-  for (const id of groups.chat) {
-    chatProfileModels[id] = { label: labelFor(id), model: modelReference(id, 'chat') };
-  }
-  for (const id of groups.responses) {
-    chatProfileModels[id] = { label: labelFor(id), model: modelReference(id, 'responses') };
-  }
-  const messagesProfileModels = {};
-  for (const id of groups.messages) {
-    messagesProfileModels[id] = { label: labelFor(id), model: modelReference(id, 'messages') };
-  }
-
-  const chatDefault = groups.chat[0] ?? groups.responses[0];
-  const profiles = {};
-  profiles['opencode-go'] = {
-    label: 'OpenCode Go',
-    ...(chatDefault ? { defaultModel: chatDefault } : {}),
-    models: chatProfileModels,
-    apiKeyEnv: API_KEY_ENV,
-    apiBaseEnv: API_BASE_ENV,
-  };
-  if (messagesProfileModels && groups.messages.length) {
-    profiles['opencode-go-messages'] = {
-      label: 'OpenCode Go (Anthropic)',
-      defaultModel: groups.messages[0],
-      models: messagesProfileModels,
-      apiKeyEnv: API_KEY_ENV,
-      apiBaseEnv: MESSAGES_BASE_ENV,
-    };
-  }
-
-  const consoleSection = { defaultProfile: 'opencode-go', profiles };
-
-  if (guessed.length) {
-    process.stderr.write('Routed by prefix heuristic (verify before use):\n');
-    for (const line of guessed) process.stderr.write(`  ${line}\n`);
-  }
-  process.stderr.write(
-    `Discovered ${ids.length} models (${groups.chat.length} chat, ${groups.responses.length} responses, ${groups.messages.length} messages).\n`,
-  );
-
   if (writePath) {
-    let root = {};
-    try {
-      root = JSON.parse(await readFile(writePath, 'utf8'));
-    } catch (error) {
-      if (error.code !== 'ENOENT') throw new Error(`Could not read ${writePath}: ${error.message}`);
+    const result = await runtime.mergeOpenCodeGoConsoleProfiles({ configPath: writePath, baseUrl, setDefault });
+    if (result.guessedRoutes.length) {
+      process.stderr.write('Routed by prefix heuristic (verify before use):\n');
+      for (const line of result.guessedRoutes) process.stderr.write(`  ${line}\n`);
     }
-    if (typeof root !== 'object' || root === null || Array.isArray(root)) {
-      throw new Error(`${writePath} must contain a JSON object.`);
-    }
-    const existingConsole = typeof root.console === 'object' && root.console !== null ? root.console : {};
-    const mergedProfiles = { ...(existingConsole.profiles ?? {}), ...profiles };
-    const defaultProfile =
-      existingConsole.defaultProfile && !setDefault ? existingConsole.defaultProfile : 'opencode-go';
-    root.console = { ...existingConsole, defaultProfile, profiles: mergedProfiles };
-    await writeFile(writePath, `${JSON.stringify(root, null, 2)}\n`);
-    process.stderr.write(`Merged profiles into ${writePath} (defaultProfile: ${defaultProfile}).\n`);
+    process.stderr.write(
+      `Merged ${result.counts.chat} chat, ${result.counts.responses} responses, and ${result.counts.messages} messages models into ${result.configPath}` +
+        ` as ${result.mergedProfileIds.join(' + ')} (defaultProfile: ${result.defaultProfile}).\n`,
+    );
     return;
   }
 
+  const ids = await runtime.fetchOpenCodeGoModelIds(baseUrl);
+  const built = runtime.buildOpenCodeGoConsoleProfiles(ids, baseUrl);
+  if (built.guessedRoutes.length) {
+    process.stderr.write('Routed by prefix heuristic (verify before use):\n');
+    for (const line of built.guessedRoutes) process.stderr.write(`  ${line}\n`);
+  }
   process.stderr.write(
-    `Export the key and base URLs, then add the JSON below under "console" in config.json:\n` +
-      `  export ${API_KEY_ENV}='sk-…'\n` +
-      `  export ${API_BASE_ENV}='${baseUrl}'\n` +
-      `  export ${MESSAGES_BASE_ENV}='${messagesBase}'\n` +
+    `Discovered ${ids.length} models (${built.counts.chat} chat, ${built.counts.responses} responses, ${built.counts.messages} messages).\n` +
+      `Export the key and base URLs, then add the JSON below under "console" in config.json:\n` +
+      `  export ${OPENCODE_GO_API_KEY_ENV}='sk-…'\n` +
+      `  export ${OPENCODE_GO_API_BASE_ENV}='${baseUrl}'\n` +
+      `  export ${OPENCODE_GO_MESSAGES_API_BASE_ENV}='${messagesBase}'\n` +
       `(or rerun with --write ~/.catence/config.json to merge into an existing config.)\n`,
   );
-  process.stdout.write(`${JSON.stringify(consoleSection, null, 2)}\n`);
+  process.stdout.write(`${JSON.stringify({ defaultProfile: built.defaultProfile, profiles: built.profiles }, null, 2)}\n`);
 }
 
 await main().catch((error) => {

package/uv.lock

@@ -47,7 +47,7 @@ dev = [
 requires-dist = [
     { name = "duckdb", specifier = ">=1.4.0" },
     { name = "fitdecode", specifier = ">=0.10.0" },
-    { name = "garminconnect", git = "https://github.com/rifusaki/python-garminconnect.git?rev=732bf14602bce2ca22cb569ba6583c3229bf904d" },
+    { name = "garminconnect", git = "https://github.com/rifusaki/python-garminconnect.git?rev=cd4e3d9ef81a93681950138e08f57af226fd5735" },
     { name = "polars", specifier = ">=1.0.0" },
     { name = "pyarrow", specifier = ">=18.0.0" },
     { name = "pydantic", specifier = ">=2.0.0" },
@@ -318,8 +318,8 @@ wheels = [
 
 [[package]]
 name = "garminconnect"
-version = "0.3.8"
-source = { git = "https://github.com/rifusaki/python-garminconnect.git?rev=732bf14602bce2ca22cb569ba6583c3229bf904d#732bf14602bce2ca22cb569ba6583c3229bf904d" }
+version = "0.3.12"
+source = { git = "https://github.com/rifusaki/python-garminconnect.git?rev=cd4e3d9ef81a93681950138e08f57af226fd5735#cd4e3d9ef81a93681950138e08f57af226fd5735" }
 dependencies = [
     { name = "curl-cffi" },
     { name = "requests" },

package/docs/deployment.md

@@ -1,338 +0,0 @@
-# Deploying Catence Console
-
-Catence Console is a password-protected local web chat that starts a matching
-Catence runtime on loopback. There are two supported ways to run it: **locally**
-(npm package + Python Console on your machine) or **in Docker** (one container
-built from the public registries). Both paths end with the same Console, data
-directory layout, model configuration, and credentials model.
-
-Everything below assumes a recent beta or stable release; channels are
-explained in the [beta release notes](../README.md#beta-releases).
-
-## Prerequisites
-
-- Node.js 22+ and Python 3.12+ with [uv](https://docs.astral.sh/uv/)
-  (local path), or Docker Engine with the `docker compose` plugin (Docker path).
-- Provider credentials for the athletes you choose to sync (Garmin,
-  Intervals.icu, Strava).
-- One model-provider key (OpenAI, Anthropic, OpenCode Go, Azure, or any
-  OpenAI-compatible endpoint).
-
-## What gets stored where
-
-| What | Where | Example |
-| --- | --- | --- |
-| Catalog + athlete stores | data home | `~/.catence/` or `/data` in Docker |
-| Model profiles (no secrets) | `config.json` in the data home | `console.profiles` |
-| Provider credentials | per-athlete secret file, mode 0600 | `catence-data secret set` |
-| API keys | process environment only | `.env` in Docker, shell exports locally |
-| Chat history + preferences | data home | `console/chat-history.sqlite3` |
-
-Credentials never land in `config.json`; profiles reference environment
-variable *names* (`apiKeyEnv`, `apiBaseEnv`, `apiVersionEnv`). See
-[`llm-providers.md`](llm-providers.md) for the profile reference and
-[`config.example.json`](../config.example.json) for a complete example.
-
----
-
-## Path A — Local deployment
-
-### 1. Install the runtime and the Console
-
-```sh
-npm install --global catence@beta          # or catence@latest for stable
-uv tool install catence-console            # persistent `catence-console` command
-# alternative to the last line: uvx catence-console@<version> serve (ephemeral)
-```
-
-`catence-console serve` launches a matching Catence runtime automatically: it
-uses a globally installed `catence` if present, otherwise `npx catence@<pinned>`.
-
-### 2. Create the catalog and first athlete
-
-```sh
-catence-data setup --athlete alex --label "Alex"
-```
-
-This creates `~/.catence/` (or `$CATENCE_HOME`). It also tolerates a directory
-that already holds only Console artifacts (`config.json`, `console/`).
-
-### 3. Store provider credentials (stdin only, never shell history)
-
-Garmin (`email`, `password`), Intervals.icu (`apiKey`, `athleteId`), and Strava
-(`clientId`, `clientSecret`):
-
-```sh
-# Garmin
-printf %s 'alex@example.com' | catence-data --athlete alex secret set --provider garmin --field email --value-stdin
-printf %s 'your-garmin-password' | catence-data --athlete alex secret set --provider garmin --field password --value-stdin
-# Intervals.icu
-printf %s 'intervals-api-key' | catence-data --athlete alex secret set --provider intervals --field apiKey --value-stdin
-printf %s '12345' | catence-data --athlete alex secret set --provider intervals --field athleteId --value-stdin
-# Strava (create an API application at https://www.strava.com/settings/api)
-printf %s 'strava-client-id' | catence-data --athlete alex secret set --provider strava --field clientId --value-stdin
-printf %s 'strava-client-secret' | catence-data --athlete alex secret set --provider strava --field clientSecret --value-stdin
-```
-
-Set only the providers you actually sync; `secret set` accepts each field
-independently.
-
-### 4. Sync data and build retrieval context
-
-```sh
-catence-data --athlete alex sync --provider all
-catence-data --athlete alex build-retrieval-index
-```
-
-### 5. Configure the model
-
-On the first chat, the Console wizard asks for a provider and model and writes
-a starter profile. To start from the documented profiles instead, copy the
-`console` section from [`config.example.json`](../config.example.json) into
-`~/.catence/config.json`. To add OpenCode Go models, run the
-[model discovery script](#model-discovery-opencode-go) below.
-
-### 6. Set the model credentials and Console login
-
-```sh
-export OPENAI_API_KEY='…'                        # or ANTHROPIC_API_KEY / OPENCODE_GO_API_KEY …
-export CATENCE_CONSOLE_USERNAME='coach'
-export CATENCE_CONSOLE_PASSWORD_HASH="$(catence-console auth hash-password)"
-export CHAINLIT_AUTH_SECRET="$(openssl rand -hex 32)"
-```
-
-### 7. Start the Console
-
-```sh
-catence-console serve
-# open http://127.0.0.1:8000
-```
-
-The Model dropdown in the settings panel lists every profile's deployments.
-Preflight with:
-
-```sh
-catence-console doctor
-```
-
----
-
-## Path B — Docker deployment
-
-### 1. Deploy with the script
-
-```sh
-curl -fsSL https://raw.githubusercontent.com/rifusaki/catence/beta/scripts/deploy-console.sh | bash -s beta
-# or from a checkout: ./scripts/deploy-console.sh beta
-# use `stable` instead of `beta` for the stable channel
-```
-
-The script resolves the newest matching versions from npm and PyPI, writes a
-self-contained `catence-deploy/` project (Dockerfile, docker-compose.yml, and
-`.env` with placeholders), builds the image, **seeds a starter
-`/data/config.json`** into the data volume, and starts the stack — or, when
-secrets are missing, prints the remaining steps and exits.
-
-### 2. Fill in `catence-deploy/.env`
-
-```sh
-CATENCE_CONSOLE_USERNAME=coach
-CATENCE_CONSOLE_PASSWORD_HASH='…'      # generate: ./catence-deploy/hash-password.sh
-CHAINLIT_AUTH_SECRET='…'               # generate: openssl rand -hex 32
-OPENAI_API_KEY='…'                     # or ANTHROPIC_API_KEY / OPENCODE_GO_API_KEY …
-OPENAI_API_BASE=''                     # only for OpenAI-compatible endpoints
-OPENCODE_GO_API_KEY='…'                # the OpenCode Go base URLs are pre-filled below
-OPENCODE_GO_API_BASE='https://opencode.ai/zen/go/v1'
-OPENCODE_GO_MESSAGES_API_BASE='https://opencode.ai/zen/go'
-```
-
-Then start the stack (or re-run the script, which re-reads the saved `.env`):
-
-```sh
-docker compose -f catence-deploy/docker-compose.yml --env-file catence-deploy/.env up -d
-```
-
-### 3. Initialize an athlete store
-
-The data volume already contains a seeded `config.json`, so `setup` accepts
-it. Run through the container:
-
-```sh
-docker compose -f catence-deploy/docker-compose.yml --env-file catence-deploy/.env run --rm \
-  --entrypoint catence-data console setup --athlete alex --label "Alex"
-```
-
-### 4. Store provider credentials
-
-Garmin (`email`, `password`), Intervals.icu (`apiKey`, `athleteId`), and Strava
-(`clientId`, `clientSecret`), one `printf` per field:
-
-```sh
-# Garmin
-printf %s 'alex@example.com' | docker compose -f catence-deploy/docker-compose.yml --env-file catence-deploy/.env run --rm -T \
-  --entrypoint catence-data console --athlete alex secret set \
-  --provider garmin --field email --value-stdin
-printf %s 'your-garmin-password' | docker compose -f catence-deploy/docker-compose.yml --env-file catence-deploy/.env run --rm -T \
-  --entrypoint catence-data console --athlete alex secret set \
-  --provider garmin --field password --value-stdin
-# Intervals.icu
-printf %s 'intervals-api-key' | docker compose -f catence-deploy/docker-compose.yml --env-file catence-deploy/.env run --rm -T \
-  --entrypoint catence-data console --athlete alex secret set \
-  --provider intervals --field apiKey --value-stdin
-printf %s '12345' | docker compose -f catence-deploy/docker-compose.yml --env-file catence-deploy/.env run --rm -T \
-  --entrypoint catence-data console --athlete alex secret set \
-  --provider intervals --field athleteId --value-stdin
-# Strava (create an API application at https://www.strava.com/settings/api)
-printf %s 'strava-client-id' | docker compose -f catence-deploy/docker-compose.yml --env-file catence-deploy/.env run --rm -T \
-  --entrypoint catence-data console --athlete alex secret set \
-  --provider strava --field clientId --value-stdin
-printf %s 'strava-client-secret' | docker compose -f catence-deploy/docker-compose.yml --env-file catence-deploy/.env run --rm -T \
-  --entrypoint catence-data console --athlete alex secret set \
-  --provider strava --field clientSecret --value-stdin
-```
-
-Set only the providers you actually sync. Use the same `--entrypoint
-catence-data` pattern for `sync`, `backfill`, and `auth strava`.
-
-### 5. Configure the model
-
-The seeded `config.json` already offers OpenAI, OpenAI-compatible, and
-Anthropic starter profiles, so the settings panel works before the first chat.
-Edit `/data/config.json` inside the volume:
-
-```sh
-docker compose -f catence-deploy/docker-compose.yml --env-file catence-deploy/.env run --rm \
-  --entrypoint sh console -c 'cat > /data/config.json'   # paste JSON, then Ctrl-D
-```
-
-With `--home <dir>` (bind mount), edit `<dir>/config.json` on the host
-instead. To add OpenCode Go models, see [model discovery](#model-discovery-opencode-go).
-
-### 6. Verify with doctor
-
-`catence-console doctor` checks each profile's environment variables and the
-local Catence runtime. The deploy scaffold includes a helper for it:
-
-```sh
-./catence-deploy/doctor.sh
-```
-
-The helper runs the doctor *inside the running container* with `exec` — the
-container's own loopback holds the live MCP server at `127.0.0.1:8787`, and the
-provider keys from `.env` are already in its environment. (A `docker compose
-run` container has a separate loopback and would report the runtime as
-unreachable.) The equivalent long form is:
-
-```sh
-docker compose -f catence-deploy/docker-compose.yml --env-file catence-deploy/.env exec console \
-  /opt/catence-console/bin/catence-console doctor --home /data --mcp-url http://127.0.0.1:8787/mcp
-```
-
-Expect `"ready": true` once the model key is set; missing keys show up per
-profile without ever printing their values.
-
-### 7. Sync, backfill, and inspect athlete data
-
-The deploy scaffold includes a helper that runs `catence-data` *inside the
-running container* with `exec`, so the athlete's provider secrets from the
-data volume are already available:
-
-```sh
-./catence-deploy/sync.sh --athlete alex sync                  # incremental sync, all providers
-./catence-deploy/sync.sh --athlete alex backfill 2026-01-01   # full backfill from a date
-./catence-deploy/sync.sh --athlete alex status                # coverage and errors
-./catence-deploy/sync.sh athletes                             # list athlete IDs
-```
-
-`sync` defaults to `--provider all`; extra flags pass through, for example
-`./catence-deploy/sync.sh --athlete alex sync --refresh` or
-`./catence-deploy/sync.sh --athlete alex backfill 2026-01-01 --provider garmin`.
-Set a default athlete with `export CATENCE_ATHLETE=alex` to drop the
-`--athlete` argument. The equivalent long form is:
-
-```sh
-docker compose -f catence-deploy/docker-compose.yml --env-file catence-deploy/.env exec console \
-  catence-data sync --athlete alex --provider all --home /data
-```
-
-### 8. Expose the Console safely
-
-Keep the Console port bound to `127.0.0.1` (the default) and front it with a
-Cloudflare Tunnel or reverse proxy at HTTPS. Never expose Catence's MCP port
-8787 — it stays loopback-only inside the container. For remote MCP checks use
-SSH port forwarding (`ssh -L 8787:127.0.0.1:8787 server`).
-
----
-
-## Model discovery (OpenCode Go)
-
-OpenCode Go publishes an OpenAI-compatible API at
-`https://opencode.ai/zen/go/v1`; its model list is public. The discovery
-script fetches it and merges two ready-made profiles into `config.json`:
-`opencode-go` (chat + responses models, base `…/zen/go/v1`) and
-`opencode-go-messages` (messages models, base `…/zen/go`). Existing profiles,
-limits, and `defaultProfile` are preserved unless `--set-default` is passed.
-
-```sh
-# Local (from a checkout)
-npm run discover:opencode-go -- --write ~/.catence/config.json
-
-# Docker (the script ships inside the npm package in the image)
-docker compose -f catence-deploy/docker-compose.yml --env-file catence-deploy/.env run --rm \
-  --entrypoint node console \
-  /usr/local/lib/node_modules/catence/scripts/discover-opencode-go.mjs --write /data/config.json
-```
-
-Then set the credentials and verify. The generated `.env` already contains
-`OPENCODE_GO_API_BASE` and `OPENCODE_GO_MESSAGES_API_BASE`, so on Docker only
-the key is missing:
-
-```sh
-export OPENCODE_GO_API_KEY='…'                      # any non-empty value passes the key check
-catence-console doctor
-```
-
-The `openai/responses/…` models (for example `grok-4.5`) go through LiteLLM's
-responses bridge and are the least battle-tested path; smoke-test one chat turn
-before relying on them.
-
----
-
-## Updating
-
-From `catence-data update`-capable releases (0.2.0-beta.3 and later), the
-runtime updates both components on the tracked channel — beta installs follow
-the npm `beta` tag and matching PyPI prereleases:
-
-```sh
-catence-data update --check      # report only; exit 1 when updates are pending
-catence-data update              # npm runtime + uv tool catence-console upgrade
-catence-data update --channel stable   # move off a beta onto the stable channel
-```
-
-Older betas (for example a beta 2 install) predate the command; upgrade them
-manually once:
-
-```sh
-npm install --global catence@beta
-uv tool install --upgrade catence-console
-```
-
-Docker deployments: re-run `deploy-console.sh beta` (or `stable`); it
-re-resolves the newest versions from the registries and rebuilds. The data
-volume and your `config.json` are preserved.
-
-## Troubleshooting
-
-- **"No Catence config exists"** — should not happen after a seeded deploy or
-  wizard run; ensure `/data/config.json` (Docker) or `~/.catence/config.json`
-  exists and contains a `console` section.
-- **"Refusing to initialize"** — the data home contains unrelated files; the
-  error lists them. Console artifacts (`config.json`, `console/`, and Chainlit's
-  `.files/`, `.chainlit/`, `public/`) are allowed; anything else blocks `setup`.
-- **Settings panel has no Model dropdown** — the Console loads profiles from
-  `config.json`; write one via the wizard, a manual copy, or the discovery
-  script.
-- **Profile not ready** — `catence-console doctor` lists the missing
-  environment variables; set them in `.env` (Docker) or the shell (local) and
-  restart the Console.