subconscious-cli 4.1.4 → 4.2.0

package/bin/agents.js

@@ -906,6 +906,7 @@ export function runbookEnv(
         ? {
             SUBC_CLAUDE_SETTINGS: JSON.stringify(claudePickerSettings(models, model)),
             CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: '0',
+            CLAUDE_CODE_AUTO_MODE_SERVER: '0',
           }
         : {}),
       SUBC_ENV_FILE: os.devNull,

package/bin/cli.js

@@ -280,10 +280,20 @@ async function main() {
     return;
   }
 
-  const update = await showUpdateNotice();
-  if (update?.action === 'updated' || update?.action === 'cancel') return;
+  const launchTui =
+    !command &&
+    process.stdin.isTTY === true &&
+    process.stdout.isTTY === true &&
+    process.env.TERM !== 'dumb';
+
+  // The TUI opens immediately and surfaces catalog, session, and upgrade
+  // status itself. Keep the blocking npm prompt for explicit commands.
+  if (!launchTui) {
+    const update = await showUpdateNotice();
+    if (update?.action === 'updated' || update?.action === 'cancel') return;
+  }
 
-  if (!command && process.stdin.isTTY === true && process.stdout.isTTY === true && process.env.TERM !== 'dumb') {
+  if (launchTui) {
     const selection = await runTui({ profileName });
     if (!selection?.args?.length) return;
     if (selection.baseUrl?.trim()) {

package/bin/models.js

@@ -18,6 +18,27 @@ export function isLiveModelSource(source) {
   return source === 'available' || source === 'public';
 }
 
+export function isAbortError(error) {
+  return error?.name === 'AbortError' || error?.code === 'ABORT_ERR';
+}
+
+function linkAbortSignal(controller, signal) {
+  if (!signal) return () => {};
+  if (signal.aborted) {
+    controller.abort();
+    return () => {};
+  }
+  const onAbort = () => controller.abort();
+  signal.addEventListener('abort', onAbort, { once: true });
+  return () => signal.removeEventListener('abort', onAbort);
+}
+
+function abortError(message) {
+  const error = new Error(message);
+  error.name = 'AbortError';
+  return error;
+}
+
 export function normalizeModelIds(modelIds = [], selectedModel) {
   const models = [];
   const seen = new Set();
@@ -53,6 +74,7 @@ export async function fetchGatewayModels({
   path = PUBLIC_MODELS_PATH,
   fetchImpl = globalThis.fetch,
   timeoutMs = DEFAULT_MODEL_FETCH_TIMEOUT_MS,
+  signal,
 }) {
   if (typeof fetchImpl !== 'function') {
     throw new Error('This Node.js version does not support fetch');
@@ -71,14 +93,26 @@ export async function fetchGatewayModels({
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
   timeout.unref?.();
+  const unlink = linkAbortSignal(controller, signal);
 
   try {
-    const response = await fetchImpl(endpoint, {
-      method: 'GET',
-      headers,
-      cache: 'no-store',
-      signal: controller.signal,
+    if (signal?.aborted) throw abortError('Model discovery was cancelled');
+    const aborted = new Promise((_, reject) => {
+      const fail = () => {
+        if (signal?.aborted) reject(abortError('Model discovery was cancelled'));
+        else reject(new Error(`Model discovery timed out after ${timeoutMs}ms`));
+      };
+      controller.signal.addEventListener('abort', fail, { once: true });
     });
+    const response = await Promise.race([
+      fetchImpl(endpoint, {
+        method: 'GET',
+        headers,
+        cache: 'no-store',
+        signal: controller.signal,
+      }),
+      aborted,
+    ]);
 
     if (!response.ok) {
       throw new Error(`Model discovery returned HTTP ${response.status}`);
@@ -91,21 +125,24 @@ export async function fetchGatewayModels({
 
     return normalizeModelIds(payload.data.map((model) => model?.id));
   } catch (error) {
+    if (signal?.aborted) throw abortError('Model discovery was cancelled');
     if (controller.signal.aborted) {
       throw new Error(`Model discovery timed out after ${timeoutMs}ms`);
     }
     throw error;
   } finally {
+    unlink();
     clearTimeout(timeout);
   }
 }
 
-async function fetchPublicModels({ baseUrl, fetchImpl, timeoutMs }) {
+async function fetchPublicModels({ baseUrl, fetchImpl, timeoutMs, signal }) {
   const models = await fetchGatewayModels({
     baseUrl,
     path: PUBLIC_MODELS_PATH,
     fetchImpl,
     timeoutMs,
+    signal,
   });
   if (!models.length) throw new Error('Model discovery returned no usable model IDs');
   return models;
@@ -134,6 +171,7 @@ export async function resolveModelCatalog({
   fallbackModels = [],
   fetchImpl = globalThis.fetch,
   timeoutMs = DEFAULT_MODEL_FETCH_TIMEOUT_MS,
+  signal,
 }) {
   const key = apiKey?.trim() || '';
 
@@ -145,22 +183,26 @@ export async function resolveModelCatalog({
         path: AVAILABLE_MODELS_PATH,
         fetchImpl,
         timeoutMs,
+        signal,
       });
       return liveCatalog(discovered, selectedModel, 'available');
     } catch (availableError) {
+      if (isAbortError(availableError) || signal?.aborted) throw availableError;
       try {
-        const discovered = await fetchPublicModels({ baseUrl, fetchImpl, timeoutMs });
+        const discovered = await fetchPublicModels({ baseUrl, fetchImpl, timeoutMs, signal });
         return liveCatalog(discovered, selectedModel, 'public');
-      } catch {
+      } catch (publicError) {
+        if (isAbortError(publicError) || signal?.aborted) throw publicError;
         return packagedCatalog(selectedModel, fallbackModels, availableError);
       }
     }
   }
 
   try {
-    const discovered = await fetchPublicModels({ baseUrl, fetchImpl, timeoutMs });
+    const discovered = await fetchPublicModels({ baseUrl, fetchImpl, timeoutMs, signal });
     return liveCatalog(discovered, selectedModel, 'public');
   } catch (error) {
+    if (isAbortError(error) || signal?.aborted) throw error;
     return packagedCatalog(selectedModel, fallbackModels, error);
   }
 }

package/bin/opencode-provider.js

@@ -0,0 +1,61 @@
+import { modelSupportsVision } from './model-capabilities.js';
+
+export const OPENCODE_PROVIDER_ID = 'subconscious';
+export const OPENCODE_PROVIDER_NAME = 'Subconscious Gateway';
+
+const ACRONYMS = new Set(['gpt', 'oss', 'api', 'gguf', 'ggml', 'nomic', 'vl', 'it', 'mlx']);
+
+function formatToken(token) {
+  const lower = token.toLowerCase();
+  if (ACRONYMS.has(lower)) return token.toUpperCase();
+  if (/^\d+[bkmg]$/i.test(token)) return token.toUpperCase();
+  if (/^q\d+$/i.test(token)) return token.toUpperCase();
+  if (/^\d+\.\d+/.test(token)) return token;
+  if (/^[a-z]\d+[a-z]$/i.test(token) || /^\d+[a-z]$/i.test(token)) return token.toUpperCase();
+  return token.charAt(0).toUpperCase() + token.slice(1).toLowerCase();
+}
+
+/** Drop the subconscious/ prefix, then capitalize each dash-separated token. */
+export function opencodeModelDisplayName(modelId) {
+  const text = String(modelId ?? '').trim();
+  const slug = text.startsWith('subconscious/') ? text.slice('subconscious/'.length) : text;
+  return slug.split(/[-_]/).filter(Boolean).map(formatToken).join(' ');
+}
+
+export function buildOpenCodeModels(modelIds, { context, output }) {
+  return Object.fromEntries(
+    modelIds.map((id) => [
+      id,
+      {
+        name: opencodeModelDisplayName(id),
+        tools: true,
+        limit: { context, output },
+        ...(modelSupportsVision(id)
+          ? { attachment: true, modalities: { input: ['text', 'image'], output: ['text'] } }
+          : {}),
+      },
+    ]),
+  );
+}
+
+export function buildOpenCodeConfig({ baseUrl, model, modelIds, context, output }) {
+  return {
+    $schema: 'https://opencode.ai/config.json',
+    disabled_providers: ['subconscious-cli'],
+    provider: {
+      [OPENCODE_PROVIDER_ID]: {
+        npm: '@ai-sdk/openai-compatible',
+        name: OPENCODE_PROVIDER_NAME,
+        whitelist: [...modelIds],
+        options: {
+          baseURL: `${baseUrl}/v1`,
+          apiKey: '{env:SUBCONSCIOUS_API_KEY}',
+          headers: { 'x-subconscious-client': 'opencode' },
+          modelsDiscovery: { enabled: false },
+        },
+        models: buildOpenCodeModels(modelIds, { context, output }),
+      },
+    },
+    model: `${OPENCODE_PROVIDER_ID}/${model}`,
+  };
+}

package/bin/runbook/claude-code/run.sh

@@ -216,6 +216,11 @@ export ANTHROPIC_DEFAULT_FABLE_MODEL="${ANTHROPIC_DEFAULT_FABLE_MODEL:-$FABLE_MO
 export ANTHROPIC_DEFAULT_FABLE_MODEL_NAME="${ANTHROPIC_DEFAULT_FABLE_MODEL_NAME:-$FABLE_MODEL_NAME}"
 export ANTHROPIC_DEFAULT_FABLE_MODEL_DESCRIPTION="${ANTHROPIC_DEFAULT_FABLE_MODEL_DESCRIPTION:-$FABLE_MODEL_DESCRIPTION}"
 export CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY="${CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY:-0}"
+# Gateway upstreams can't perform Anthropic's server-side auto mode classifier
+# checks; opting out avoids the "isn't eligible for no-charge classifier
+# requests" fallback and keeps classifier requests billed locally.
+# https://code.claude.com/docs/en/auto-mode-classifier-billing
+export CLAUDE_CODE_AUTO_MODE_SERVER="${CLAUDE_CODE_AUTO_MODE_SERVER:-0}"
 export CLAUDE_CODE_SUBAGENT_MODEL="${CLAUDE_CODE_SUBAGENT_MODEL:-$MODEL}"
 export CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS="${MAX_CONCURRENT_SUBAGENTS}"
 export CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH="${MAX_SUBAGENT_SPAWN_DEPTH}"

package/bin/runbook/opencode/install.sh

@@ -55,6 +55,7 @@ set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/../model-capabilities.generated.sh"
+source "${SCRIPT_DIR}/provider.sh"
 
 # Load shared env from SUBC_ENV_FILE, or a sibling .env / env.example.
 SHARED_ENV="${SUBC_ENV_FILE:-${SCRIPT_DIR}/../.env}"
@@ -147,19 +148,7 @@ while IFS= read -r model_id; do
   add_supported_model "$model_id"
 done <<< "${SUBCONSCIOUS_MODELS:-$DEFAULT_SUBCONSCIOUS_MODELS}"
 
-MODELS_JSON=""
-for model_id in "${SUPPORTED_MODELS[@]}"; do
-  vision_fields=""
-  if subc_model_supports_vision "$model_id"; then
-    vision_fields=',"attachment":true,"modalities":{"input":["text","image"],"output":["text"]}'
-  fi
-  model_json="\"${model_id}\":{\"name\":\"${model_id}\",\"tools\":true,\"limit\":{\"context\":${CONTEXT_LIMIT},\"output\":${OUTPUT_LIMIT}}${vision_fields}}"
-  if [[ -n "$MODELS_JSON" ]]; then
-    MODELS_JSON="${MODELS_JSON},${model_json}"
-  else
-    MODELS_JSON="$model_json"
-  fi
-done
+subc_opencode_build_models_json
 
 OPENCODE_DIR="${HOME}/.opencode"
 OPENCODE_CONFIG="${OPENCODE_DIR}/opencode.json"
@@ -186,34 +175,21 @@ require_cmds() {
 write_config() {
   mkdir -p "$OPENCODE_DIR"
   local base_url="${GATEWAY_URL%/}/v1"
-  local provider
-  provider=$(cat <<EOF
-{
-  "npm": "@ai-sdk/openai-compatible",
-  "name": "Subconscious Gateway",
-  "options": {
-    "baseURL": "${base_url}",
-    "apiKey": "{env:SUBCONSCIOUS_API_KEY}",
-    "headers": {
-      "x-subconscious-client": "opencode"
-    }
-  },
-  "models": {${MODELS_JSON}}
-}
-EOF
-)
+  local provider selected_model
+  provider="$(subc_opencode_build_provider_json "$base_url")"
+  selected_model="${SUBC_OPENCODE_PROVIDER_ID}/${MODEL}"
   if [[ -f "$OPENCODE_CONFIG" ]]; then
     local tmp
     tmp="$(mktemp)"
-    jq --argjson provider "$provider" --arg model "subconscious/${MODEL}" '
+    jq --argjson provider "$provider" --arg model "$selected_model" --arg provider_id "$SUBC_OPENCODE_PROVIDER_ID" '
       .provider = (.provider // {})
-      | .provider.subconscious = $provider
+      | .provider[$provider_id] = $provider
       | .model = $model
     ' "$OPENCODE_CONFIG" >"$tmp"
     mv "$tmp" "$OPENCODE_CONFIG"
   else
-    jq -n --argjson provider "$provider" --arg model "subconscious/${MODEL}" \
-      '{ "$schema": "https://opencode.ai/config.json", provider: {subconscious: $provider}, model: $model }' \
+    jq -n --argjson provider "$provider" --arg model "$selected_model" --arg provider_id "$SUBC_OPENCODE_PROVIDER_ID" \
+      '{ "$schema": "https://opencode.ai/config.json", provider: {($provider_id): $provider}, model: $model }' \
       >"$OPENCODE_CONFIG"
   fi
   local env_file="${OPENCODE_DIR}/subconscious.env"
@@ -240,7 +216,7 @@ uninstall_config() {
     local tmp
     tmp="$(mktemp)"
     jq '
-      del(.provider.subconscious)
+      del(.provider.subconscious, .provider["subconscious-cli"])
       | if ((.model // "") | tostring | startswith("subconscious/")) then del(.model) else . end
     ' "$OPENCODE_CONFIG" >"$tmp"
     mv "$tmp" "$OPENCODE_CONFIG"

package/bin/runbook/opencode/provider.sh

@@ -0,0 +1,93 @@
+#!/usr/bin/env bash
+# Shared OpenCode provider metadata for subc launch and install paths.
+
+# OpenCode groups /models entries by provider.name. Keep this stable and human
+# readable.
+SUBC_OPENCODE_PROVIDER_ID="subconscious"
+SUBC_OPENCODE_PROVIDER_NAME="Subconscious Gateway"
+
+subc_opencode_model_display_name() {
+  local slug="${1:-}"
+  slug="${slug#subconscious/}"
+  echo "$slug" | awk -F '[-_]' '
+    function format_token(token, lower) {
+      lower = tolower(token)
+      if (lower ~ /^(gpt|oss|api|gguf|ggml|nomic|vl|it|mlx)$/) return toupper(token)
+      if (token ~ /^[0-9]+[bBkKmMgG]$/) return toupper(token)
+      if (token ~ /^[qQ][0-9]+$/) return toupper(token)
+      if (token ~ /^[0-9]+\.[0-9]+/) return token
+      if (token ~ /^[A-Za-z][0-9]+[A-Za-z]$/ || token ~ /^[0-9]+[A-Za-z]$/) return toupper(token)
+      return toupper(substr(token, 1, 1)) tolower(substr(token, 2))
+    }
+    {
+      out = ""
+      for (i = 1; i <= NF; i++) {
+        if ($i == "") continue
+        out = out (out == "" ? "" : " ") format_token($i)
+      }
+      print out
+    }
+  '
+}
+
+subc_opencode_build_whitelist_json() {
+  local model_id
+  WHITELIST_JSON=""
+  for model_id in "${SUPPORTED_MODELS[@]}"; do
+    if [[ -n "$WHITELIST_JSON" ]]; then
+      WHITELIST_JSON="${WHITELIST_JSON},\"${model_id}\""
+    else
+      WHITELIST_JSON="\"${model_id}\""
+    fi
+  done
+  WHITELIST_JSON="[${WHITELIST_JSON}]"
+}
+
+subc_opencode_build_models_json() {
+  local model_id display_name vision_fields model_json
+  MODELS_JSON=""
+  for model_id in "${SUPPORTED_MODELS[@]}"; do
+    display_name="$(subc_opencode_model_display_name "$model_id")"
+    vision_fields=""
+    if subc_model_supports_vision "$model_id"; then
+      vision_fields=',"attachment":true,"modalities":{"input":["text","image"],"output":["text"]}'
+    fi
+    model_json="\"${model_id}\":{\"name\":\"${display_name}\",\"tools\":true,\"limit\":{\"context\":${CONTEXT_LIMIT},\"output\":${OUTPUT_LIMIT}}${vision_fields}}"
+    if [[ -n "$MODELS_JSON" ]]; then
+      MODELS_JSON="${MODELS_JSON},${model_json}"
+    else
+      MODELS_JSON="$model_json"
+    fi
+  done
+  subc_opencode_build_whitelist_json
+}
+
+subc_opencode_build_config_json() {
+  local base_url="${1:?base url required}"
+  local model="${2:?model required}"
+  cat <<EOF
+{"\$schema":"https://opencode.ai/config.json","disabled_providers":["subconscious-cli"],"provider":{"${SUBC_OPENCODE_PROVIDER_ID}":{"npm":"@ai-sdk/openai-compatible","name":"${SUBC_OPENCODE_PROVIDER_NAME}","whitelist":${WHITELIST_JSON},"options":{"baseURL":"${base_url}","apiKey":"{env:SUBCONSCIOUS_API_KEY}","headers":{"x-subconscious-client":"opencode"},"modelsDiscovery":{"enabled":false}},"models":{${MODELS_JSON}}}},"model":"${SUBC_OPENCODE_PROVIDER_ID}/${model}"}
+EOF
+}
+
+subc_opencode_build_provider_json() {
+  local base_url="${1:?base url required}"
+  cat <<EOF
+{
+  "npm": "@ai-sdk/openai-compatible",
+  "name": "${SUBC_OPENCODE_PROVIDER_NAME}",
+  "whitelist": ${WHITELIST_JSON},
+  "options": {
+    "baseURL": "${base_url}",
+    "apiKey": "{env:SUBCONSCIOUS_API_KEY}",
+    "headers": {
+      "x-subconscious-client": "opencode"
+    },
+    "modelsDiscovery": {
+      "enabled": false
+    }
+  },
+  "models": {${MODELS_JSON}}
+}
+EOF
+}

package/bin/runbook/opencode/run.sh

@@ -19,6 +19,7 @@ set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/../model-capabilities.generated.sh"
+source "${SCRIPT_DIR}/provider.sh"
 
 # Load shared env from SUBC_ENV_FILE, or a sibling .env / env.example.
 SHARED_ENV="${SUBC_ENV_FILE:-${SCRIPT_DIR}/../.env}"
@@ -58,19 +59,7 @@ while IFS= read -r model_id; do
   add_supported_model "$model_id"
 done <<< "${SUBCONSCIOUS_MODELS:-$DEFAULT_SUBCONSCIOUS_MODELS}"
 
-MODELS_JSON=""
-for model_id in "${SUPPORTED_MODELS[@]}"; do
-  vision_fields=""
-  if subc_model_supports_vision "$model_id"; then
-    vision_fields=',"attachment":true,"modalities":{"input":["text","image"],"output":["text"]}'
-  fi
-  model_json="\"${model_id}\":{\"name\":\"${model_id}\",\"tools\":true,\"limit\":{\"context\":${CONTEXT_LIMIT},\"output\":${OUTPUT_LIMIT}}${vision_fields}}"
-  if [[ -n "$MODELS_JSON" ]]; then
-    MODELS_JSON="${MODELS_JSON},${model_json}"
-  else
-    MODELS_JSON="$model_json"
-  fi
-done
+subc_opencode_build_models_json
 
 if [[ -z "$GATEWAY_URL" || -z "$API_KEY" ]]; then
   echo "error: GATEWAY_URL and API_KEY must be set in ../.env" >&2
@@ -96,15 +85,11 @@ if [[ "${BASH_SOURCE[0]:-$0}" == "${0}" ]]; then
 fi
 
 BASE_URL="${GATEWAY_URL%/}/v1"
-RUNTIME_PROVIDER_ID="subconscious-cli"
 
 export SUBCONSCIOUS_API_KEY="$API_KEY"
 # Compaction reporting needs the plugin on disk; this launch path writes nothing.
 export SUBCONSCIOUS_GATEWAY_URL="${GATEWAY_URL%/}"
-export OPENCODE_CONFIG_CONTENT=$(cat <<EOF
-{"\$schema":"https://opencode.ai/config.json","disabled_providers":["subconscious"],"provider":{"${RUNTIME_PROVIDER_ID}":{"npm":"@ai-sdk/openai-compatible","name":"Subconscious Gateway","options":{"baseURL":"${BASE_URL}","apiKey":"{env:SUBCONSCIOUS_API_KEY}","headers":{"x-subconscious-client":"opencode"}},"models":{${MODELS_JSON}}}},"model":"${RUNTIME_PROVIDER_ID}/${MODEL}"}
-EOF
-)
+export OPENCODE_CONFIG_CONTENT="$(subc_opencode_build_config_json "$BASE_URL" "$MODEL")"
 
 # If sourced, just export env and return.
 if [[ "${BASH_SOURCE[0]:-$0}" != "${0}" ]]; then

package/bin/tui.js

@@ -6,8 +6,9 @@ import { fileURLToPath } from 'node:url';
 
 import { agentList } from './agents.js';
 import { DEFAULT_PLATFORM_URL, getApiKey, getPlatformUrl } from './auth.js';
-import { resolveModelCatalog } from './models.js';
+import { isAbortError, normalizeModelIds, resolveModelCatalog } from './models.js';
 import { discoverSessions, SESSION_HARNESSES } from './sessions.js';
+import { compareVersions, fetchLatestVersion } from './update-check.js';
 import {
   DEFAULT_PROFILE,
   listProfiles,
@@ -47,27 +48,43 @@ async function pathExists(file) {
   }
 }
 
+export async function tuiSourceIsNewerThan(binary, sourceFile = path.join(TUI_SOURCE_DIR, 'cmd/subc-tui/main.go')) {
+  try {
+    const [binaryStat, sourceStat] = await Promise.all([fs.stat(binary), fs.stat(sourceFile)]);
+    return sourceStat.mtimeMs > binaryStat.mtimeMs;
+  } catch {
+    return false;
+  }
+}
+
+function sourceTuiCommand() {
+  return {
+    command: 'go',
+    args: ['run', './cmd/subc-tui'],
+    cwd: TUI_SOURCE_DIR,
+  };
+}
+
 export async function resolveTuiExecutable(options = {}) {
   const override = options.binary || process.env.SUBC_TUI_BIN?.trim();
-  if (override) return { command: override, args: [], cwd: undefined };
+  if (override) {
+    return { command: override, args: options.binaryArgs || [], cwd: undefined };
+  }
 
+  const hasSource = await pathExists(path.join(TUI_SOURCE_DIR, 'go.mod'));
   const target = nativeTargetName(options.platform, options.arch);
   if (target) {
     const packaged = path.join(BIN_DIR, 'native', target);
-    if (await pathExists(packaged)) {
+    // Source checkouts keep a cached host binary for speed. If TUI source is
+    // newer, that cache is stale (for example it will reject --updates).
+    if (await pathExists(packaged) && !(hasSource && (await tuiSourceIsNewerThan(packaged)))) {
       return { command: packaged, args: [], cwd: undefined };
     }
   }
 
   // Source checkouts can run the TUI without committing native build output.
   // Published packages always contain a prebuilt platform binary.
-  if (await pathExists(path.join(TUI_SOURCE_DIR, 'go.mod'))) {
-    return {
-      command: 'go',
-      args: ['run', './cmd/subc-tui'],
-      cwd: TUI_SOURCE_DIR,
-    };
-  }
+  if (hasSource) return sourceTuiCommand();
   return null;
 }
 
@@ -98,7 +115,71 @@ async function packageVersion() {
   return pkg.version;
 }
 
-export async function createTuiState(profileName = DEFAULT_PROFILE, options = {}) {
+function serializeSessions(sessions = []) {
+  return sessions.map((session) => ({
+    key: session.key,
+    harness: session.harness,
+    harnessName: session.harnessName,
+    title: session.title,
+    cwd: session.cwd,
+    updatedAt: session.updatedAt,
+    model: session.model,
+    portable: session.portable,
+  }));
+}
+
+function sessionHarnessList() {
+  return Object.entries(SESSION_HARNESSES).map(([id, harness]) => ({
+    id,
+    name: harness.name,
+    portable: harness.portable,
+  }));
+}
+
+function agentMenuItems() {
+  return agentList().map((agent) => ({
+    command: agent.alias,
+    name: agent.name,
+    action: agent.action,
+    description: agent.description,
+    launch: agent.launch,
+  }));
+}
+
+const ATOMIC_REPLACE_CODES = new Set(['EEXIST', 'EPERM', 'EACCES', 'EBUSY']);
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function replaceFile(tmp, file) {
+  try {
+    await fs.rename(tmp, file);
+  } catch (error) {
+    if (!ATOMIC_REPLACE_CODES.has(error.code)) throw error;
+    // Windows rejects a rename over a file another process still has open.
+    await fs.rm(file, { force: true });
+    await fs.rename(tmp, file);
+  }
+}
+
+export async function writeAtomicJson(file, value) {
+  const payload = `${JSON.stringify(value)}\n`;
+  for (let attempt = 0; attempt < 8; attempt++) {
+    const tmp = `${file}.${process.pid}.${Math.random().toString(16).slice(2)}.tmp`;
+    try {
+      await fs.writeFile(tmp, payload, { mode: 0o600 });
+      await replaceFile(tmp, file);
+      return;
+    } catch (error) {
+      await fs.rm(tmp, { force: true }).catch(() => {});
+      if (!ATOMIC_REPLACE_CODES.has(error.code) || attempt === 7) throw error;
+      await delay(20 * (attempt + 1));
+    }
+  }
+}
+
+export async function createLocalTuiState(profileName = DEFAULT_PROFILE, options = {}) {
   const activeProfile = options.profile || (await loadProfile(profileName));
   const names = [...new Set([profileName, ...(await listProfiles())])].sort((a, b) => {
     if (a === profileName) return -1;
@@ -118,26 +199,17 @@ export async function createTuiState(profileName = DEFAULT_PROFILE, options = {}
     }),
   );
 
-  const auth = await getApiKey(activeProfile);
   const requestedModel = selectedModelFor(activeProfile);
   const gatewayUrl = gatewayFor(activeProfile);
   const platformUrl = platformFor(activeProfile);
-  const catalog = await resolveModelCatalog({
-    baseUrl: gatewayUrl,
-    apiKey: auth?.key,
-    selectedModel: requestedModel,
-    fallbackModels: PACKAGED_MODELS,
-  });
-  const selectedModel = requestedModel;
-  const sessions = await discoverSessions({ max: options.maxSessions || 500 });
 
   return {
     version: await packageVersion(),
     activeProfile: profileName,
     profilePath: activeProfile.path,
     profiles,
-    models: catalog.models,
-    selectedModel,
+    models: normalizeModelIds([requestedModel, ...PACKAGED_MODELS], requestedModel),
+    selectedModel: requestedModel,
     subagentModel: subagentModelFor(activeProfile),
     gatewayUrl,
     savedGatewayUrl:
@@ -148,39 +220,138 @@ export async function createTuiState(profileName = DEFAULT_PROFILE, options = {}
     savedPlatformUrl:
       activeProfile.values.PLATFORM_URL?.trim().replace(/\/+$/, '') || DEFAULT_PLATFORM_URL,
     platformOverridden: Boolean(process.env.SUBCONSCIOUS_URL?.trim()),
-    modelError: catalog.error?.message || '',
-    modelSource: catalog.source,
-    sessions: sessions.map((session) => ({
-      key: session.key,
-      harness: session.harness,
-      harnessName: session.harnessName,
-      title: session.title,
-      cwd: session.cwd,
-      updatedAt: session.updatedAt,
-      model: session.model,
-      portable: session.portable,
-    })),
-    sessionHarnesses: Object.entries(SESSION_HARNESSES).map(([id, harness]) => ({
-      id,
-      name: harness.name,
-      portable: harness.portable,
-    })),
-    agents: agentList().map((agent) => ({
-      command: agent.alias,
-      name: agent.name,
-      action: agent.action,
-      description: agent.description,
-      launch: agent.launch,
-    })),
+    modelError: '',
+    modelSource: 'packaged',
+    modelsLoading: true,
+    sessionsLoading: true,
+    sessions: [],
+    sessionHarnesses: sessionHarnessList(),
+    agents: agentMenuItems(),
+    updateAvailable: false,
+    latestVersion: '',
   };
 }
 
+function whenAborted(signal) {
+  return new Promise((_, reject) => {
+    const fail = () => {
+      const error = new Error('cancelled');
+      error.name = 'AbortError';
+      reject(error);
+    };
+    if (signal.aborted) {
+      fail();
+      return;
+    }
+    signal.addEventListener('abort', fail, { once: true });
+  });
+}
+
+async function raceAbort(signal, promise) {
+  if (!signal) return promise;
+  return Promise.race([promise, whenAborted(signal)]);
+}
+
+export async function loadRemoteTuiUpdates(state, options = {}) {
+  const signal = options.signal;
+  const writePatch = options.writePatch || (async () => {});
+  const resolveCatalog = options.resolveCatalog || resolveModelCatalog;
+  const discover = options.discoverSessions || discoverSessions;
+  const fetchLatest = options.fetchLatestVersion || fetchLatestVersion;
+  const readApiKey = options.getApiKey || getApiKey;
+  const updateDisabled =
+    options.disableUpdateCheck ?? process.env.SUBC_DISABLE_UPDATE_CHECK?.trim() === '1';
+
+  const tasks = [
+    (async () => {
+      const profile = options.profile || (await loadProfile(state.activeProfile));
+      if (signal?.aborted) return;
+      const auth = await readApiKey(profile);
+      if (signal?.aborted) return;
+      const catalog = await resolveCatalog({
+        baseUrl: state.gatewayUrl,
+        apiKey: auth?.key,
+        selectedModel: state.selectedModel,
+        fallbackModels: PACKAGED_MODELS,
+        fetchImpl: options.fetchImpl,
+        timeoutMs: options.timeoutMs,
+        signal,
+      });
+      if (signal?.aborted) return;
+      await writePatch({
+        models: catalog.models,
+        modelError: catalog.error?.message || '',
+        modelSource: catalog.source,
+        modelsLoading: false,
+      });
+    })(),
+    (async () => {
+      const sessions = await raceAbort(
+        signal,
+        discover({
+          max: options.maxSessions || 500,
+          home: options.home,
+          roots: options.roots,
+          indexes: options.indexes,
+          execute: options.execute,
+          signal,
+        }),
+      );
+      if (signal?.aborted) return;
+      await writePatch({
+        sessions: serializeSessions(sessions),
+        sessionsLoading: false,
+      });
+    })(),
+  ];
+
+  if (!updateDisabled) {
+    tasks.push(
+      (async () => {
+        try {
+          const latest = await fetchLatest({
+            fetchImpl: options.updateFetchImpl || options.fetchImpl,
+            timeoutMs: options.updateTimeoutMs,
+            signal,
+          });
+          if (signal?.aborted || !latest) return;
+          if (compareVersions(latest, state.version) > 0) {
+            await writePatch({ updateAvailable: true, latestVersion: latest });
+          }
+        } catch (error) {
+          if (isAbortError(error) || signal?.aborted) return;
+        }
+      })(),
+    );
+  }
+
+  const results = await Promise.allSettled(tasks);
+  for (const result of results) {
+    if (result.status !== 'rejected') continue;
+    if (isAbortError(result.reason) || signal?.aborted) continue;
+    throw result.reason;
+  }
+}
+
+export async function createTuiState(profileName = DEFAULT_PROFILE, options = {}) {
+  const state = await createLocalTuiState(profileName, options);
+  let next = { ...state };
+  await loadRemoteTuiUpdates(state, {
+    ...options,
+    writePatch: async (partial) => {
+      next = { ...next, ...partial };
+    },
+  });
+  return next;
+}
+
 function spawnAndWait(command, args, options = {}) {
+  const spawnImpl = options.spawn || spawn;
   return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
+    const child = spawnImpl(command, args, {
       cwd: options.cwd,
       env: process.env,
-      stdio: 'inherit',
+      stdio: options.stdio ?? 'inherit',
     });
     child.once('error', reject);
     child.once('exit', (code, signal) => {
@@ -197,10 +368,28 @@ export async function runTui(options = {}) {
   const executable = await resolveTuiExecutable(options);
   if (!executable) return null;
 
-  const state = options.state || (await createTuiState(options.profileName, options));
+  const providedState = options.state;
+  const state = providedState || (await createLocalTuiState(options.profileName, options));
   const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'subc-tui-'));
   const statePath = path.join(tempDir, 'state.json');
   const resultPath = path.join(tempDir, 'result.json');
+  const updatesPath = path.join(tempDir, 'updates.json');
+  const controller = new AbortController();
+
+  let patch = {};
+  const writePatch = async (partial) => {
+    if (controller.signal.aborted) return;
+    patch = { ...patch, ...partial };
+    try {
+      await writeAtomicJson(updatesPath, patch);
+    } catch {
+      // The TUI may have already exited and removed the working directory.
+    }
+  };
+
+  const remote = providedState
+    ? Promise.resolve()
+    : loadRemoteTuiUpdates(state, { ...options, signal: controller.signal, writePatch });
 
   try {
     // This state intentionally contains only display data. API keys are used
@@ -208,9 +397,11 @@ export async function runTui(options = {}) {
     await fs.writeFile(statePath, `${JSON.stringify(state)}\n`, { mode: 0o600 });
     const code = await spawnAndWait(
       executable.command,
-      [...executable.args, '--state', statePath, '--result', resultPath],
-      { cwd: executable.cwd },
+      [...executable.args, '--state', statePath, '--result', resultPath, '--updates', updatesPath],
+      { cwd: executable.cwd, spawn: options.spawn, stdio: options.stdio },
     );
+    controller.abort();
+    await remote.catch(() => {});
     if (code !== 0) throw new Error(`Subconscious TUI exited with status ${code}`);
 
     try {
@@ -220,7 +411,12 @@ export async function runTui(options = {}) {
       if (error.code === 'ENOENT') return null;
       throw error;
     }
+  } catch (error) {
+    controller.abort();
+    await remote.catch(() => {});
+    throw error;
   } finally {
+    controller.abort();
     await fs.rm(tempDir, { recursive: true, force: true });
   }
 }

package/bin/update-check.js

@@ -116,27 +116,48 @@ export async function currentVersion() {
 export async function fetchLatestVersion(options = {}) {
   const fetchImpl = options.fetchImpl || globalThis.fetch;
   const timeoutMs = options.timeoutMs ?? UPDATE_CHECK_TIMEOUT_MS;
+  const signal = options.signal;
   if (typeof fetchImpl !== 'function') throw new Error('fetch is unavailable');
 
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
   timeout.unref?.();
+  const onAbort = () => controller.abort();
+  if (signal?.aborted) {
+    const error = new Error('Update check was cancelled');
+    error.name = 'AbortError';
+    clearTimeout(timeout);
+    throw error;
+  }
+  signal?.addEventListener('abort', onAbort, { once: true });
 
   try {
-    const response = await fetchImpl(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
-      headers: {
-        Accept: 'application/json',
-        'Cache-Control': 'no-cache, no-store',
-        Pragma: 'no-cache',
-      },
-      cache: 'no-store',
-      signal: controller.signal,
+    const aborted = new Promise((_, reject) => {
+      const fail = () => {
+        const error = new Error(signal?.aborted ? 'Update check was cancelled' : 'Update check timed out');
+        error.name = 'AbortError';
+        reject(error);
+      };
+      controller.signal.addEventListener('abort', fail, { once: true });
     });
+    const response = await Promise.race([
+      fetchImpl(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+        headers: {
+          Accept: 'application/json',
+          'Cache-Control': 'no-cache, no-store',
+          Pragma: 'no-cache',
+        },
+        cache: 'no-store',
+        signal: controller.signal,
+      }),
+      aborted,
+    ]);
     if (!response.ok) throw new Error(`npm returned HTTP ${response.status}`);
     const payload = await response.json();
     if (!parseVersion(payload?.version)) throw new Error('npm returned an invalid version');
     return payload.version;
   } finally {
+    signal?.removeEventListener('abort', onAbort);
     clearTimeout(timeout);
   }
 }

package/bin/usage.js

@@ -56,6 +56,33 @@ export function renderProgressBar(percentage, width = 20) {
   return `${color}${'█'.repeat(filled)}${c.dim}${'░'.repeat(empty)}${c.reset}`;
 }
 
+/**
+ * Whole percent. Never rounds up to 100 while allowance remains — a meter
+ * that reads 100% claims the day is spent.
+ */
+export function formatAllowancePercent(percent) {
+  const n = Number(percent);
+  if (!Number.isFinite(n) || n <= 0) return '0%';
+  const whole = Math.round(n);
+  if (n >= 100) return '100%';
+  if (whole >= 100) return '99%';
+  return `${whole}%`;
+}
+
+/** New percent payloads, or the pre-basis token shape (consumed / amount). */
+export function describeDailyAllowance(allowance) {
+  if (!allowance || typeof allowance !== 'object') return null;
+  if (allowance.basis === 'unavailable') return { kind: 'unavailable' };
+  if (allowance.basis === 'credit' || allowance.basis === 'tokens') {
+    return { kind: allowance.basis, percent: Number(allowance.percent) || 0 };
+  }
+
+  const consumed = Number(allowance.consumed) || 0;
+  const amount = Number(allowance.amount) || 0;
+  if (amount <= 0) return null;
+  return { kind: 'tokens', percent: (consumed / amount) * 100 };
+}
+
 export function formatUsageDisplay(data) {
   const lines = [];
   lines.push(`\n  ${c.bold}Subconscious Usage${c.reset}\n`);
@@ -81,24 +108,29 @@ export function formatUsageDisplay(data) {
     lines.push('');
     lines.push(`  ${c.dim}Daily allowance${c.reset}`);
     lines.push(`  ${c.green}Unlimited${c.reset} ${c.dim}(comp)${c.reset}`);
-  } else if (allowance && allowance.amount > 0) {
-    const consumed = Number(allowance.consumed) || 0;
-    const amount = Number(allowance.amount) || 0;
-    const remaining = Number(allowance.remaining) || 0;
-    const pct = amount > 0 ? Math.min((consumed / amount) * 100, 100) : 0;
-    const overage = Math.max(0, consumed - amount);
-
-    lines.push('');
-    lines.push(`  ${c.dim}Daily allowance${c.reset}`);
-    lines.push(
-      `  ${renderProgressBar(pct)}  ${formatTokens(consumed)} / ${formatTokens(amount)} tokens`,
-    );
-    const resetNote = allowance.resetAt
-      ? `${formatTokens(remaining)} remaining · resets midnight UTC`
-      : `${formatTokens(remaining)} remaining`;
-    lines.push(`  ${c.dim}${resetNote}${c.reset}`);
-    if (overage > 0) {
-      lines.push(`  ${c.yellow}+${formatTokens(overage)} over daily allowance${c.reset}`);
+  } else {
+    const described = describeDailyAllowance(allowance);
+    if (described) {
+      lines.push('');
+      lines.push(`  ${c.dim}Daily allowance${c.reset}`);
+      if (described.kind === 'unavailable') {
+        lines.push(`  ${c.dim}Daily credit unavailable${c.reset}`);
+        lines.push(
+          `  ${c.dim}Today's credit usage could not be read just now. Your plan and access are unaffected, and the figure returns on its own.${c.reset}`,
+        );
+      } else {
+        const label =
+          described.kind === 'credit' ? 'of daily credit used' : 'of daily tokens used';
+        lines.push(
+          `  ${renderProgressBar(described.percent)}  ${formatAllowancePercent(described.percent)} ${label}`,
+        );
+        lines.push(`  ${c.dim}Resets midnight UTC${c.reset}`);
+        if (described.kind === 'credit' && described.percent >= 100) {
+          lines.push(
+            `  ${c.yellow}Past today's allowance - further usage bills from your balance.${c.reset}`,
+          );
+        }
+      }
     }
   }
 
@@ -221,7 +253,7 @@ Usage:
   subc usage --json
   subc usage help
 
-Show billing mode, daily token allowance, credit balance, and per-model usage
+Show billing mode, daily allowance, credit balance, and per-model usage
 for the authenticated organization.
 
   --json   Print the raw platform JSON response

package/bin/windows/launch.js

@@ -3,6 +3,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { claudeNativeLaunch } from './claude.js';
+import { buildOpenCodeConfig } from '../opencode-provider.js';
 import { modelSupportsVision } from '../model-capabilities.js';
 import { defaults, value, origin, modelIds, positiveInteger, parseOptions, writeJson } from './common.js';
 
@@ -26,16 +27,9 @@ export async function windowsLaunch(id, argv, env, { tempRoot = os.tmpdir() } =
   if (id === 'opencode') {
     const context = positiveInteger(value(env, 'OPENCODE_CONTEXT_LIMIT', '5000000'), 'OPENCODE_CONTEXT_LIMIT');
     const output = positiveInteger(value(env, 'OPENCODE_OUTPUT_LIMIT', '65536'), 'OPENCODE_OUTPUT_LIMIT');
-    const models = Object.fromEntries(modelIds(env).map(id => [id, {
-      name: id, tools: true, limit: { context, output },
-      ...(modelSupportsVision(id) ? { attachment: true, modalities: { input: ['text', 'image'], output: ['text'] } } : {}),
-    }]));
-    childEnv.OPENCODE_CONFIG_CONTENT = JSON.stringify({
-      $schema: 'https://opencode.ai/config.json', disabled_providers: ['subconscious'],
-      provider: { 'subconscious-cli': { npm: '@ai-sdk/openai-compatible', name: 'Subconscious Gateway', options: {
-        baseURL: `${base}/v1`, apiKey: '{env:SUBCONSCIOUS_API_KEY}', headers: { 'x-subconscious-client': 'opencode' },
-      }, models } }, model: `subconscious-cli/${model}`,
-    });
+    childEnv.OPENCODE_CONFIG_CONTENT = JSON.stringify(
+      buildOpenCodeConfig({ baseUrl: base, model, modelIds: modelIds(env), context, output }),
+    );
     return { command: 'opencode', args: parseOptions(argv, {}).rest, env: childEnv };
   }
   if (id === 'codex') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "subconscious-cli",
-  "version": "4.1.4",
+  "version": "4.2.0",
   "description": "CLI for Subconscious — run Subconscious Code, Claude Code, Codex, OpenCode, DeepSeek Harness, Cursor, Copilot, and Pi",
   "bin": {
     "subc": "bin/cli.js"