subconscious-cli 4.0.13 → 4.0.15

package/README.md

@@ -7,6 +7,7 @@ Log in to Subconscious, then run coding agents against the Subconscious gateway.
 ```bash
 npm install -g subconscious-cli
 subc login
+subc sc
 subc claude
 ```
 
@@ -21,7 +22,7 @@ never block the requested command. Set `SUBC_DISABLE_UPDATE_CHECK=1` to suppress
 the check in offline automation.
 
 Login creates both the saved credential and a ready-to-use `default` profile,
-so Claude Code, Codex, OpenCode, and DeepSeek Harness can launch immediately.
+so Subconscious Code, Claude Code, Codex, OpenCode, and DeepSeek Harness can launch immediately.
 Persistent editor and Pi integrations are installed per agent:
 
 ```bash
@@ -52,6 +53,7 @@ profile; they do not authenticate, install, configure, or launch anything:
 
 ```bash
 subc claude help
+subc sc help
 subc codex help
 subc cursor help
 subc config help
@@ -66,6 +68,7 @@ gateway environment applied for that process. Arguments pass through as usual:
 
 ```bash
 subc claude --continue
+subc sc -- -p "fix the tests"
 subc codex exec "write a test"
 subc opencode
 subc pi
@@ -78,6 +81,7 @@ The packaged integrations live in `cli/bin/runbook`.
 
 | Command | Behavior |
 | --- | --- |
+| `subc sc` | Launch Subconscious Code with the active gateway, key, model, and DLR transport |
 | `subc claude` | Launch Claude Code with the runbook environment, context limits, subagent limits, and OTEL usage reporting |
 | `subc codex` | Launch Codex with the runbook provider, temporary model catalog, and surgically merged compaction hooks |
 | `subc opencode` | Launch OpenCode with the runbook provider, client header, and context/output limits |
@@ -86,11 +90,16 @@ The packaged integrations live in `cli/bin/runbook`.
 | `subc pi` | Refresh the Pi provider from the live catalog, then launch |
 | `subc dsh` | Launch the DeepSeek Harness Web UI with a temporary provider populated from the live catalog |
 
-If Claude Code, Codex, OpenCode, or DeepSeek Harness is missing, an interactive terminal offers
+If Subconscious Code, Claude Code, Codex, OpenCode, or DeepSeek Harness is missing, an interactive terminal offers
 to install it before launching. Pi refreshes its Subconscious provider on every
 `subc pi` launch while preserving all other providers in `models.json`; its
 executable must already be installed.
 
+`subc sc install` downloads and checksum-verifies the latest static Linux release
+from `subconscious-systems/subconscious-code`. The upstream release currently
+publishes x86_64 and ARM64 Linux assets. On macOS, the installer uses Cargo to
+build the tagged release until Darwin assets are published.
+
 `subc codex` disables Codex apps and plugin tools for that launch by default so
 requests remain below the gateway's 128-tool limit. Core coding tools remain
 available. Use `subc codex --external-tools` to opt back in when targeting a
@@ -145,7 +154,7 @@ rewritten. Run a one-shot task with `subc dsh headless "PROMPT"`.
 ```
 
 The file is mode `600` and contains the shared gateway URL, API key, model,
-optional per-agent key overrides, and all Claude/Codex/OpenCode/Pi/Copilot/
+optional per-agent key overrides, and all Subconscious Code/Claude/Codex/OpenCode/Pi/Copilot/
 DeepSeek Harness context and output settings used by the packaged runbook scripts.
 
 ```bash
@@ -153,8 +162,9 @@ subc config                         # list every profile and its file path
 subc -p staging config create      # create a profile with default settings
 subc -p staging config              # print that path and env file
 subc -p staging config --model subconscious/glm-5.2
+subc -p staging config --model UNSET
 subc -p staging config --subagent-model subconscious/deepseek-v4-flash-marathon
-subc -p staging config --subagent-model follow-default
+subc -p staging config --subagent-model UNSET
 subc config --gateway-url https://gateway.example
 subc config path
 subc config edit                    # open the selected profile in $VISUAL, $EDITOR, vim, or nano
@@ -170,9 +180,12 @@ Subconscious-injected defaults; resolved login identity (`GATEWAY_URL`,
 In scripts and CI, keep using `subc config --gateway-url`, `--api-key`,
 `--model`, and `--subagent-model`.
 
+Use `UNSET` to clear the profile default so launches use the first model in
+the live catalog (gateway priority order).
+
 The subagent setting controls `CLAUDE_CODE_SUBAGENT_MODEL` for Claude Code.
-Use `follow-default` to clear the override so subagents automatically follow
-the profile's default model.
+Use `UNSET` to clear the override so subagents automatically follow the
+profile's default model.
 
 Each agent section can hold its own API key. An agent-specific key takes
 precedence over the shared profile key and can be used on its own, so profiles
@@ -224,11 +237,15 @@ list. The selected profile model is listed first only while the gateway still
 advertises it.
 OpenCode rebuilds its isolated runtime provider on every `subc opencode` launch,
 so models left in older OpenCode configuration files do not leak into the list.
-If a saved profile default has been removed, launches use the first live model;
-an explicit `--model` or `SUBCONSCIOUS_MODEL` override is always preserved.
+If a saved profile default is UNSET or has been removed, launches use the first
+live model; an explicit `--model` or `SUBCONSCIOUS_MODEL` override is always
+preserved.
 Claude Code exposes four native Opus/Sonnet/Haiku/Fable picker slots plus one
-custom model option, so the CLI maps the first five models into those slots; any other
-model can still be selected with `subc claude --model MODEL`. Cursor requires adding
+custom model option. The CLI remaps those aliases to the live catalog, then
+replaces the built-in `/model` lineup (`modelPicker.replaceBuiltInOptions`) and
+allowlists only those models (`availableModels`) so Anthropic Fable and
+ungranted slugs do not appear. Any other model can still be selected with
+`subc claude --model MODEL`. Cursor requires adding
 the printed model IDs in its OpenAI API Key Override settings. Use the printed
 `/v1` Base URL in Cursor Settings; the profile itself stores the gateway origin
 so correlation hooks can post to `/v1/agent-hooks`.

package/bin/agents.js

@@ -20,8 +20,16 @@ import readline from 'node:readline';
 import { fileURLToPath } from 'node:url';
 import { c } from './colors.js';
 import { getApiKey } from './auth.js';
-import { profileSettingsForAgent, resolvedProfileValues } from './profiles.js';
+import {
+  isUnsetSetting,
+  profileSettingsForAgent,
+  resolvedModelSetting,
+  resolvedProfileValues,
+} from './profiles.js';
 import { isLiveModelSource, PUBLIC_CATALOG_FALLBACK_MESSAGE, resolveModelCatalog } from './models.js';
+import { compareVersions } from './update-check.js';
+
+export const MIN_CLAUDE_CODE_VERSION = '2.1.242';
 
 // --- Registry (single source of truth, generated copy shipped in the package).
 const registry = JSON.parse(
@@ -156,6 +164,17 @@ export function parseAgentAction(agent, argv = []) {
 }
 
 const AGENT_HELP = {
+  'subconscious-code': {
+    usage: 'subc [-p NAME] sc [help|install] [Subconscious Code arguments...]',
+    behavior:
+      'Launches the native Subconscious coding agent with the selected profile gateway, credential, and model.',
+    options: [
+      ['help', 'Show this help'],
+      ['install', 'Install the latest Linux release, or build from source on macOS'],
+      ['--model MODEL', 'Override the profile model for this launch'],
+      ['ARGS...', 'Pass arguments directly to Subconscious Code'],
+    ],
+  },
   'claude-code': {
     usage: 'subc [-p NAME] claude [help|status|uninstall] [Claude arguments...]',
     behavior:
@@ -258,6 +277,12 @@ function displayProfileValue(setting, value, values) {
     if (value) return '(set)';
     return setting.key !== 'API_KEY' && values.API_KEY ? '(shared key)' : '(not set)';
   }
+  if (
+    !value &&
+    (setting.key === 'MODEL' || setting.key === 'CLAUDE_CODE_SUBAGENT_MODEL')
+  ) {
+    return 'UNSET';
+  }
   return value || '(auto)';
 }
 
@@ -295,9 +320,10 @@ export function printAgentHelp(agent, profile) {
   );
   const actions = agentSetupActions(agent);
   if (actions.includes('install')) {
-    console.log(
-      `  Install the persistent integration with ${c.cyan}subc ${command} install${c.reset}.`,
-    );
+    const installDescription = agent.runbook?.binaryInstallScript
+      ? 'Install the agent binary with'
+      : 'Install the persistent integration with';
+    console.log(`  ${installDescription} ${c.cyan}subc ${command} install${c.reset}.`);
   }
   if (actions.includes('uninstall')) {
     console.log(
@@ -325,28 +351,40 @@ function buildContext(apiKey, model, profile) {
 /**
  * Pull a `--model <value>` / `--model=<value>` flag out of the passthrough
  * args (so it sets the Subconscious model rather than reaching the agent).
- * Falls back to SUBCONSCIOUS_MODEL, then the registry default.
+ * Falls back to SUBCONSCIOUS_MODEL, then the profile MODEL. UNSET or a blank
+ * profile model means "use the first live catalog entry" (gateway priority).
  */
-function extractModel(argv, profile) {
-  const environmentModel = process.env.SUBCONSCIOUS_MODEL?.trim();
-  const profileModel = profile?.values?.MODEL?.trim();
-  let model = environmentModel || profileModel || DEFAULTS.model;
-  let modelSource = environmentModel ? 'environment' : profileModel ? 'profile' : 'default';
+export function extractModel(argv, profile) {
+  const environmentModel = resolvedModelSetting(process.env.SUBCONSCIOUS_MODEL);
+  const profileModel = resolvedModelSetting(profile?.values?.MODEL);
+  let model = environmentModel || profileModel || '';
+  let modelSource = environmentModel ? 'environment' : profileModel ? 'profile' : 'catalog';
   const rest = [];
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === '--model') {
       const v = argv[i + 1];
       if (v && !v.startsWith('-')) {
-        model = v;
-        modelSource = 'command';
+        if (isUnsetSetting(v)) {
+          model = '';
+          modelSource = 'catalog';
+        } else {
+          model = v;
+          modelSource = 'command';
+        }
         i++;
       }
       continue;
     }
     if (a.startsWith('--model=')) {
-      model = a.slice('--model='.length);
-      modelSource = 'command';
+      const v = a.slice('--model='.length);
+      if (isUnsetSetting(v)) {
+        model = '';
+        modelSource = 'catalog';
+      } else {
+        model = v;
+        modelSource = 'command';
+      }
       continue;
     }
     rest.push(a);
@@ -371,6 +409,7 @@ function candidateBinDirs() {
     if (home) dirs.push(path.join(home, '.local', 'bin'));
   } else {
     dirs.push(path.join(home, '.local', 'bin'));
+    dirs.push(path.join(home, '.cargo', 'bin'));
     dirs.push('/opt/homebrew/bin');
     dirs.push('/usr/local/bin');
   }
@@ -445,10 +484,25 @@ function askYesNo(question) {
   });
 }
 
-/** Run the agent's install command (may contain `&&`, so shell:true). */
-function runInstaller(install) {
+function waitForEnter(prompt) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(prompt, () => {
+      rl.close();
+      resolve();
+    });
+  });
+}
+
+/** Run the agent's packaged binary installer, or its shell install command. */
+function runInstaller(agent, install = agent.install, usePackagedScript = true) {
   return new Promise((resolve) => {
-    const child = spawn(install, { shell: true, stdio: 'inherit' });
+    const installScript = usePackagedScript && agent.runbook?.binaryInstallScript;
+    const child = installScript
+      ? spawn('bash', [runbookScriptPath(agent, installScript), 'install'], {
+          stdio: 'inherit',
+        })
+      : spawn(install, { shell: true, stdio: 'inherit' });
     child.on('error', () => resolve(false));
     child.on('exit', (code) => resolve(code === 0));
   });
@@ -508,14 +562,14 @@ async function ensureInstalled(agent) {
   }
 
   console.error(`\n  ${c.dim}Running ${c.reset}${c.cyan}${agent.install}${c.reset}\n`);
-  let installed = await runInstaller(agent.install);
+  let installed = await runInstaller(agent);
 
   // Primary failed and a fallback exists — try it once.
   if (!installed && agent.installFallback) {
     console.error(
       `\n  ${c.dim}That didn't work. Trying the fallback: ${c.reset}${c.cyan}${agent.installFallback}${c.reset}\n`,
     );
-    installed = await runInstaller(agent.installFallback);
+    installed = await runInstaller(agent, agent.installFallback, false);
   }
 
   if (!installed) {
@@ -536,6 +590,51 @@ async function ensureInstalled(agent) {
   process.exit(0);
 }
 
+export function parseClaudeVersion(text) {
+  const match = String(text ?? '').match(/v?(\d+\.\d+\.\d+)/);
+  return match?.[1] ?? null;
+}
+
+export function claudeVersionNeedsUpgrade(installed, minimum = MIN_CLAUDE_CODE_VERSION) {
+  return Boolean(installed && minimum && compareVersions(installed, minimum) < 0);
+}
+
+export function readClaudeVersion(bin, binDir, options = {}) {
+  const execFile = options.execFileSync || execFileSync;
+  try {
+    const stdout = execFile(bin, ['--version'], {
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env, PATH: augmentPath([binDir, ...candidateBinDirs()].filter(Boolean)) },
+      timeout: options.timeoutMs ?? 3000,
+    });
+    return parseClaudeVersion(typeof stdout === 'string' ? stdout : stdout?.toString?.());
+  } catch {
+    return null;
+  }
+}
+
+async function ensureClaudeCompatible(agent, binDir) {
+  if (agent.id !== 'claude-code') return;
+  const version = readClaudeVersion(agent.bin, binDir);
+  if (!claudeVersionNeedsUpgrade(version)) return;
+
+  console.error(
+    `\n  Minimum supported Claude Code version is ${MIN_CLAUDE_CODE_VERSION}. Your version is ${version}. Upgrade to get the best experience.\n`,
+  );
+  console.error(`  Upgrade it with:`);
+  console.error(`    ${c.cyan}${agent.install}${c.reset}`);
+  if (agent.installFallback) {
+    console.error(`  or`);
+    console.error(`    ${c.cyan}${agent.installFallback}${c.reset}`);
+  }
+  console.error('');
+  if (process.stdin.isTTY === true && process.stdout.isTTY === true) {
+    await waitForEnter(`  ${c.dim}Press Enter to continue.${c.reset} `);
+    console.error('');
+  }
+}
+
 /** Resolve and validate a script inside the packaged runbook directory. */
 function runbookScriptPath(agent, relativeScript = agent.runbook.script) {
   const script = path.resolve(RUNBOOK_DIR, relativeScript);
@@ -639,21 +738,48 @@ const CLAUDE_MODEL_PICKER_KEYS = [
   'ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION',
 ];
 
+const CLAUDE_MODEL_PICKER_ID_KEYS = [
+  'ANTHROPIC_DEFAULT_OPUS_MODEL',
+  'ANTHROPIC_DEFAULT_SONNET_MODEL',
+  'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+  'ANTHROPIC_DEFAULT_FABLE_MODEL',
+  'ANTHROPIC_CUSTOM_MODEL_OPTION',
+];
+
+function uniqueCatalogModels(models, fallbackModel) {
+  const unique = [];
+  for (const model of models) {
+    if (model && !unique.includes(model)) unique.push(model);
+  }
+  if (unique.length === 0 && fallbackModel) unique.push(fallbackModel);
+  return unique;
+}
+
+export function claudePickerSettings(models, fallbackModel) {
+  const unique = uniqueCatalogModels(models, fallbackModel);
+  return {
+    availableModels: unique,
+    modelPicker: {
+      replaceBuiltInOptions: true,
+      options: unique.map((model) => ({
+        model,
+        label: model,
+        description: `Subconscious model ${model}`,
+      })),
+    },
+  };
+}
+
 function claudeModelPickerEnv(agent, ctx, models) {
   if (agent.id !== 'claude-code') return {};
-  const configured = substitute(agent.env || {}, ctx);
-  const configuredModels = [
-    configured.ANTHROPIC_DEFAULT_OPUS_MODEL,
-    configured.ANTHROPIC_DEFAULT_SONNET_MODEL,
-    configured.ANTHROPIC_DEFAULT_HAIKU_MODEL,
-    configured.ANTHROPIC_DEFAULT_FABLE_MODEL,
-    configured.ANTHROPIC_CUSTOM_MODEL_OPTION,
-  ];
-  const pickerModels = [];
-  for (const model of [...models, ...configuredModels]) {
-    if (model && !pickerModels.includes(model)) pickerModels.push(model);
-  }
-  while (pickerModels.length < 3) pickerModels.push(pickerModels.at(-1) || ctx.model);
+  // Only the live catalog belongs in Claude's picker. Packaged registry slots
+  // (Haiku → DeepSeek, etc.) must not be unioned back in — that advertised
+  // models the key cannot call.
+  //
+  // Pad through Fable so the built-in `fable` alias cannot resolve to Anthropic
+  // Fable 5. The /model menu itself is replaced via claudePickerSettings.
+  const pickerModels = uniqueCatalogModels(models, ctx.model);
+  while (pickerModels.length < 4) pickerModels.push(pickerModels.at(-1) || ctx.model);
 
   const roles = ['OPUS', 'SONNET', 'HAIKU', 'FABLE'];
   const env = {};
@@ -676,6 +802,27 @@ function claudeModelPickerEnv(agent, ctx, models) {
   );
 }
 
+function applyClaudePickerCatalog(env, picker, models) {
+  if (Object.keys(picker).length === 0) return env;
+  const allowed = new Set(models);
+
+  for (const key of CLAUDE_MODEL_PICKER_KEYS) {
+    if (!picker[key]) {
+      delete env[key];
+    }
+  }
+
+  for (const key of CLAUDE_MODEL_PICKER_ID_KEYS) {
+    if (!picker[key] || !env[key] || allowed.has(env[key])) continue;
+    env[key] = picker[key];
+    const nameKey = `${key}_NAME`;
+    const descriptionKey = `${key}_DESCRIPTION`;
+    if (picker[nameKey]) env[nameKey] = picker[nameKey];
+    if (picker[descriptionKey]) env[descriptionKey] = picker[descriptionKey];
+  }
+  return env;
+}
+
 export function runbookEnv(
   apiKey,
   model,
@@ -687,18 +834,29 @@ export function runbookEnv(
   const ctx = buildContext(apiKey, model, profile);
   const extraDirs = [binDir, ...candidateBinDirs()].filter(Boolean);
   const specificApiKey = agentApiKeySetting(agent)?.key;
-  return {
-    ...claudeModelPickerEnv(agent, ctx, models),
-    ...(profile?.values || {}),
-    ...process.env,
-    GATEWAY_URL: ctx.baseUrl,
-    API_KEY: apiKey,
-    ...(specificApiKey ? { [specificApiKey]: apiKey } : {}),
-    MODEL: model,
-    SUBCONSCIOUS_MODELS: models.join('\n'),
-    SUBC_ENV_FILE: os.devNull,
-    PATH: augmentPath(extraDirs),
-  };
+  const picker = claudeModelPickerEnv(agent, ctx, models);
+  return applyClaudePickerCatalog(
+    {
+      ...picker,
+      ...(profile?.values || {}),
+      ...process.env,
+      GATEWAY_URL: ctx.baseUrl,
+      API_KEY: apiKey,
+      ...(specificApiKey ? { [specificApiKey]: apiKey } : {}),
+      MODEL: model,
+      SUBCONSCIOUS_MODELS: models.join('\n'),
+      ...(agent.id === 'claude-code'
+        ? {
+            SUBC_CLAUDE_SETTINGS: JSON.stringify(claudePickerSettings(models, model)),
+            CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: '0',
+          }
+        : {}),
+      SUBC_ENV_FILE: os.devNull,
+      PATH: augmentPath(extraDirs),
+    },
+    picker,
+    models,
+  );
 }
 
 async function resolvedModelsForLaunch(profile, apiKey, selectedModel) {
@@ -721,16 +879,20 @@ async function resolvedModelsForLaunch(profile, apiKey, selectedModel) {
 }
 
 export function selectLaunchModel(requestedModel, modelSource, catalog) {
+  const first = catalog.models[0] || requestedModel || DEFAULTS.model;
+  if (modelSource === 'catalog' || !requestedModel) {
+    return first;
+  }
   const useLiveDefault =
     isLiveModelSource(catalog.source) &&
     catalog.models.length > 0 &&
     !catalog.models.includes(requestedModel) &&
     (modelSource === 'profile' || modelSource === 'default');
-  return useLiveDefault ? catalog.models[0] : requestedModel;
+  return useLiveDefault ? first : requestedModel;
 }
 
 async function runRunbookSetup(agent, argv, profile, relativeScript = agent.runbook.script) {
-  if (isSetupWithoutAuth(argv)) {
+  if (isSetupWithoutAuth(argv) || agent.runbook?.setupNeedsAuth === false) {
     return spawnRunbook(agent, argv, {
       ...(profile?.values || {}),
       ...process.env,
@@ -743,7 +905,7 @@ async function runRunbookSetup(agent, argv, profile, relativeScript = agent.runb
   if (!apiKey) return 1;
   const catalog = await resolvedModelsForLaunch(profile, apiKey, requestedModel);
   const model = selectLaunchModel(requestedModel, modelSource, catalog);
-  if (model !== requestedModel) {
+  if (requestedModel && model !== requestedModel) {
     console.error(
       `  ${c.yellow}Configured model ${requestedModel} is not in the live catalog; using ${model}.${c.reset}\n`,
     );
@@ -810,9 +972,10 @@ export async function runAgent(agent, argv, options = {}) {
   if (!apiKey) return 1;
 
   const binDir = await ensureInstalled(agent);
+  await ensureClaudeCompatible(agent, binDir);
   const catalog = await resolvedModelsForLaunch(profile, apiKey, requestedModel);
   const model = selectLaunchModel(requestedModel, modelSource, catalog);
-  if (model !== requestedModel) {
+  if (requestedModel && model !== requestedModel) {
     console.error(
       `  ${c.yellow}Configured model ${requestedModel} is not in the live catalog; using ${model}.${c.reset}\n`,
     );

package/bin/cli.js

@@ -34,6 +34,7 @@ import {
   loadProfile,
   modelsCommand,
   printConfigHelp,
+  resolvedModelSetting,
   RUNBOOK_DEFAULTS,
   SUPPORTED_MODELS as PACKAGED_MODELS,
   updateUrlCommand,
@@ -74,7 +75,7 @@ function printHelp() {
 ${agents}
 
   ${c.bold}Options${c.reset}
-    ${c.dim}--model <id>${c.reset}   Model to use (default subconscious/glm-5.2)
+    ${c.dim}--model <id>${c.reset}   Model to use (profile MODEL, or first live catalog model if UNSET)
     ${c.dim}-p, --profile${c.reset}  Select a profile (default: default)
     ${c.dim}-h, --help${c.reset}     Show this help
     ${c.dim}-v, --version${c.reset}  Show version
@@ -154,7 +155,8 @@ Usage:
   subc models
   subc models help
 
-List available Subconscious models.
+List available Subconscious models. The default is the profile MODEL,
+or the first live catalog model if MODEL is UNSET.
 `,
 };
 
@@ -309,10 +311,9 @@ async function main() {
     }
     const profile = await loadProfile(profileName);
     const auth = await getApiKey(profile);
-    const selectedModel =
-      process.env.SUBCONSCIOUS_MODEL?.trim() ||
-      profile.values.MODEL?.trim() ||
-      RUNBOOK_DEFAULTS.MODEL;
+    const selectedModel = resolvedModelSetting(
+      process.env.SUBCONSCIOUS_MODEL || profile.values.MODEL,
+    );
     const baseUrl =
       process.env.SUBCONSCIOUS_BASE_URL?.trim() ||
       profile.values.GATEWAY_URL?.trim() ||

package/bin/profiles.js

@@ -38,6 +38,7 @@ export const RUNBOOK_DEFAULTS = {
   GATEWAY_URL: registry.defaults.baseUrl,
   API_KEY: '',
   MODEL: registry.defaults.model,
+  SC_API_KEY: '',
   CLAUDE_CODE_SUBAGENT_MODEL: '',
   CLAUDE_GATEWAY_URL: '',
   CLAUDE_CODE_API_KEY: '',
@@ -84,14 +85,21 @@ const SETTINGS = {
   MODEL: {
     key: 'MODEL',
     label: 'Default model',
-    description: 'Initial model used by coding-agent launches and setup.',
+    description:
+      'Initial model used by coding-agent launches and setup. UNSET uses the first live catalog model.',
     type: 'choice',
     choices: SUPPORTED_MODELS,
   },
+  SC_API_KEY: {
+    key: 'SC_API_KEY',
+    label: 'Subconscious Code API key',
+    description: 'Subconscious Code credential override; blank uses API_KEY.',
+    type: 'secret',
+  },
   CLAUDE_CODE_SUBAGENT_MODEL: {
     key: 'CLAUDE_CODE_SUBAGENT_MODEL',
     label: 'Subagent model',
-    description: 'Model used by Claude Code subagents; blank follows the default model.',
+    description: 'Model used by Claude Code subagents. UNSET follows the default model.',
     type: 'choice',
     choices: SUPPORTED_MODELS,
   },
@@ -273,6 +281,7 @@ const SETTINGS = {
 };
 
 const AGENT_SETTING_KEYS = {
+  'subconscious-code': ['SC_API_KEY'],
   'claude-code': [
     'CLAUDE_GATEWAY_URL',
     'CLAUDE_CODE_API_KEY',
@@ -340,11 +349,12 @@ function profileTemplate() {
 
 GATEWAY_URL={GATEWAY_URL}
 API_KEY={API_KEY}
-# Available models:
+# Available models (MODEL=UNSET uses the first live catalog model):
 ${modelComments}
 MODEL={MODEL}
 
 # Optional per-agent keys. Leave blank to use API_KEY above.
+SC_API_KEY={SC_API_KEY}
 CLAUDE_CODE_API_KEY={CLAUDE_CODE_API_KEY}
 CODEX_API_KEY={CODEX_API_KEY}
 OPENCODE_API_KEY={OPENCODE_API_KEY}
@@ -356,7 +366,7 @@ DEEPSEEK_HARNESS_API_KEY={DEEPSEEK_HARNESS_API_KEY}
 # Claude Code
 # Leave CLAUDE_GATEWAY_URL blank to use GATEWAY_URL above.
 CLAUDE_GATEWAY_URL={CLAUDE_GATEWAY_URL}
-# Leave blank to use MODEL above for Claude Code subagents.
+# CLAUDE_CODE_SUBAGENT_MODEL=UNSET follows MODEL above.
 CLAUDE_CODE_SUBAGENT_MODEL={CLAUDE_CODE_SUBAGENT_MODEL}
 CLAUDE_CODE_AUTO_COMPACT_WINDOW={CLAUDE_CODE_AUTO_COMPACT_WINDOW}
 CLAUDE_CODE_MAX_CONTEXT_TOKENS={CLAUDE_CODE_MAX_CONTEXT_TOKENS}
@@ -600,6 +610,16 @@ async function printProfile(profile) {
   console.log();
 }
 
+export function isUnsetSetting(value) {
+  const normalized = String(value ?? '').trim().toUpperCase();
+  return normalized === 'UNSET' || normalized === 'FOLLOW-GATEWAY' || normalized === 'FOLLOW-DEFAULT';
+}
+
+export function resolvedModelSetting(value) {
+  const trimmed = String(value ?? '').trim();
+  return isUnsetSetting(trimmed) ? '' : trimmed;
+}
+
 export function validateSettingValue(setting, value) {
   if (!value) {
     if (setting.required) return `${setting.label} cannot be blank`;
@@ -691,8 +711,9 @@ Usage:
   subc config edit [vim|nano]
   subc -p NAME config edit [vim|nano]
   subc config [show|path|list|create|delete]
-              [--gateway-url URL] [--api-key KEY] [--model MODEL]
-              [--subagent-model MODEL|follow-default]
+              [--gateway-url URL] [--api-key KEY]
+              [--model MODEL|UNSET]
+              [--subagent-model MODEL|UNSET]
 
   subc config                      List every profile and its file path
   subc -p NAME config              Print that profile's path and env file
@@ -702,6 +723,9 @@ Usage:
   subc config path                 Print the selected profile path
   subc -p NAME config create       Create a new profile with default settings
   subc -p NAME config delete       Delete a non-default profile
+
+  --model UNSET                    Clear MODEL so launches use the first live catalog model
+  --subagent-model UNSET           Clear the Claude subagent override so it follows MODEL
 `);
 }
 
@@ -745,7 +769,8 @@ export async function configCommand(argv, profileName = DEFAULT_PROFILE, options
         '--model': 'MODEL',
         '--subagent-model': 'CLAUDE_CODE_SUBAGENT_MODEL',
       }[arg];
-      updates[key] = arg === '--subagent-model' && value === 'follow-default' ? '' : value;
+      updates[key] =
+        (arg === '--model' || arg === '--subagent-model') && isUnsetSetting(value) ? '' : value;
     } else if (action === 'edit' && ALLOWED_EDITORS.has(arg)) {
       if (editor) throw new Error('Specify only one editor (vim or nano)');
       editor = arg;
@@ -813,7 +838,7 @@ export async function configCommand(argv, profileName = DEFAULT_PROFILE, options
 }
 
 export function modelsCommand(models = SUPPORTED_MODELS, options = {}) {
-  const selectedModel = options.selectedModel || registry.defaults.model;
+  const selectedModel = options.selectedModel || models[0] || registry.defaults.model;
   console.log(`\n  ${c.bold}Available models${c.reset}\n`);
   for (const model of models) {
     const suffix = model === selectedModel ? ` ${c.dim}(default)${c.reset}` : '';

package/bin/registry.generated.json

@@ -13,6 +13,49 @@
     "platformUrl": "https://subconscious.dev/platform"
   },
   "agents": [
+    {
+      "id": "subconscious-code",
+      "command": "sc",
+      "name": "Subconscious Code",
+      "aliases": [
+        "subconscious-code"
+      ],
+      "description": "Launch the native Subconscious coding agent with the active profile, gateway, and model.",
+      "framework": "Subconscious Code",
+      "language": "rust",
+      "category": "coding-agent",
+      "tags": [
+        "local",
+        "cli",
+        "agents"
+      ],
+      "protocol": "openai",
+      "homepage": "https://github.com/subconscious-systems/subconscious-code",
+      "bin": "sc",
+      "install": {
+        "darwin": "cargo install --locked --git https://github.com/subconscious-systems/subconscious-code --bin sc rc-cli",
+        "linux": "subc sc install",
+        "fallback": "cargo install --locked --git https://github.com/subconscious-systems/subconscious-code --bin sc rc-cli"
+      },
+      "runbook": {
+        "mode": "launch",
+        "script": "subconscious-code/run.sh",
+        "setupScript": "subconscious-code/install.sh",
+        "binaryInstallScript": "subconscious-code/install.sh",
+        "setupActions": [
+          "install"
+        ],
+        "setupNeedsAuth": false
+      },
+      "launch": "sc",
+      "env": {
+        "SC_BASE_URL": "{baseUrlV1}",
+        "SC_DLR_URL": "{baseUrl}",
+        "SC_DLR_ENABLED": "true",
+        "SC_API_KEY": "{apiKey}",
+        "SC_MODEL": "{model}"
+      }
+    },
     {
       "id": "claude-code",
       "command": "claude",

package/bin/runbook/README.md

@@ -1,7 +1,7 @@
 # Coding-agent integrations
 
 These scripts are part of `subc`. They launch or surgically install Claude Code,
-Codex, OpenCode, DeepSeek Harness, Cursor, Copilot, and Pi against the
+Subconscious Code, Codex, OpenCode, DeepSeek Harness, Cursor, Copilot, and Pi against the
 Subconscious gateway.
 
 `subc` reads `~/.subconscious/profiles/<name>.env` and injects those values into
@@ -10,6 +10,7 @@ directly, `SUBC_ENV_FILE` (or `cli/bin/runbook/.env`) can supply the same keys.
 
 Included integrations:
 
+- `subconscious-code/install.sh` and `run.sh`
 - `claude-code/install.sh` and `run.sh`
 - `codex/install.sh`, `run.sh`, `hook.sh`, `hooks.json`, and `hooks-lib.sh`
 - `opencode/install.sh`, `run.sh`, and `subconscious-compaction.ts`

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

@@ -62,9 +62,6 @@ DEFAULT_COMPACT_WINDOW="1000000"
 DEFAULT_MAX_CONTEXT_TOKENS="3000000"
 DEFAULT_MAX_CONCURRENT_SUBAGENTS="4"
 DEFAULT_MAX_SUBAGENT_SPAWN_DEPTH="1"
-DEFAULT_OPUS_MODEL="subconscious/glm-5.2"
-DEFAULT_SONNET_MODEL="subconscious/tim-qwen3.6-27b"
-DEFAULT_HAIKU_MODEL="subconscious/deepseek-v4-flash-marathon"
 
 GATEWAY_URL="${GATEWAY_URL:-}"
 API_KEY="${CLAUDE_CODE_API_KEY:-${API_KEY:-}}"
@@ -73,15 +70,55 @@ COMPACT_WINDOW="${CLAUDE_CODE_AUTO_COMPACT_WINDOW:-${COMPACT_WINDOW:-$DEFAULT_CO
 MAX_CONTEXT_TOKENS="${CLAUDE_CODE_MAX_CONTEXT_TOKENS:-${MAX_CONTEXT_TOKENS:-$DEFAULT_MAX_CONTEXT_TOKENS}}"
 MAX_CONCURRENT_SUBAGENTS="${MAX_CONCURRENT_SUBAGENTS:-$DEFAULT_MAX_CONCURRENT_SUBAGENTS}"
 MAX_SUBAGENT_SPAWN_DEPTH="${MAX_SUBAGENT_SPAWN_DEPTH:-$DEFAULT_MAX_SUBAGENT_SPAWN_DEPTH}"
+
+PICKER_MODELS=()
+if [[ -n "${SUBCONSCIOUS_MODELS:-}" ]]; then
+  while IFS= read -r picker_model; do
+    [[ -n "$picker_model" ]] && PICKER_MODELS+=("$picker_model")
+  done <<< "$SUBCONSCIOUS_MODELS"
+fi
+
+picker_model_at() {
+  local index="$1"
+  local count="${#PICKER_MODELS[@]}"
+  if [[ "$count" -eq 0 ]]; then
+    printf '%s' "$MODEL"
+    return
+  fi
+  if [[ "$index" -ge "$count" ]]; then
+    index=$((count - 1))
+  fi
+  printf '%s' "${PICKER_MODELS[$index]}"
+}
+
+in_picker_catalog() {
+  local candidate="$1" existing
+  [[ -z "$candidate" ]] && return 1
+  [[ "${#PICKER_MODELS[@]}" -eq 0 ]] && return 0
+  for existing in "${PICKER_MODELS[@]}"; do
+    [[ "$existing" == "$candidate" ]] && return 0
+  done
+  return 1
+}
+
+if [[ "${#PICKER_MODELS[@]}" -gt 0 ]]; then
+  in_picker_catalog "${ANTHROPIC_DEFAULT_OPUS_MODEL:-}" || ANTHROPIC_DEFAULT_OPUS_MODEL=""
+  in_picker_catalog "${ANTHROPIC_DEFAULT_SONNET_MODEL:-}" || ANTHROPIC_DEFAULT_SONNET_MODEL=""
+  in_picker_catalog "${ANTHROPIC_DEFAULT_HAIKU_MODEL:-}" || ANTHROPIC_DEFAULT_HAIKU_MODEL=""
+fi
+
+DEFAULT_OPUS_MODEL="$(picker_model_at 0)"
+DEFAULT_SONNET_MODEL="$(picker_model_at 1)"
+DEFAULT_HAIKU_MODEL="$(picker_model_at 2)"
 OPUS_MODEL="${ANTHROPIC_DEFAULT_OPUS_MODEL:-$DEFAULT_OPUS_MODEL}"
 OPUS_MODEL_NAME="${ANTHROPIC_DEFAULT_OPUS_MODEL_NAME:-$OPUS_MODEL}"
-OPUS_MODEL_DESCRIPTION="${ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION:-Subconscious default model}"
+OPUS_MODEL_DESCRIPTION="${ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION:-Subconscious model ${OPUS_MODEL}}"
 SONNET_MODEL="${ANTHROPIC_DEFAULT_SONNET_MODEL:-$DEFAULT_SONNET_MODEL}"
 SONNET_MODEL_NAME="${ANTHROPIC_DEFAULT_SONNET_MODEL_NAME:-$SONNET_MODEL}"
-SONNET_MODEL_DESCRIPTION="${ANTHROPIC_DEFAULT_SONNET_MODEL_DESCRIPTION:-Subconscious TIM Qwen 3.6 27B}"
+SONNET_MODEL_DESCRIPTION="${ANTHROPIC_DEFAULT_SONNET_MODEL_DESCRIPTION:-Subconscious model ${SONNET_MODEL}}"
 HAIKU_MODEL="${ANTHROPIC_DEFAULT_HAIKU_MODEL:-$DEFAULT_HAIKU_MODEL}"
 HAIKU_MODEL_NAME="${ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME:-$HAIKU_MODEL}"
-HAIKU_MODEL_DESCRIPTION="${ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION:-Subconscious DeepSeek V4 Flash Marathon}"
+HAIKU_MODEL_DESCRIPTION="${ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION:-Subconscious model ${HAIKU_MODEL}}"
 COMMAND="install"
 
 usage() {

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

@@ -30,9 +30,6 @@ DEFAULT_COMPACT_WINDOW="1000000"
 DEFAULT_MAX_CONTEXT_TOKENS="3000000"
 DEFAULT_MAX_CONCURRENT_SUBAGENTS="4"
 DEFAULT_MAX_SUBAGENT_SPAWN_DEPTH="1"
-DEFAULT_OPUS_MODEL="subconscious/glm-5.2"
-DEFAULT_SONNET_MODEL="subconscious/tim-qwen3.6-27b"
-DEFAULT_HAIKU_MODEL="subconscious/deepseek-v4-flash-marathon"
 
 GATEWAY_URL="${GATEWAY_URL:-}"
 API_KEY="${CLAUDE_CODE_API_KEY:-${API_KEY:-}}"
@@ -41,15 +38,94 @@ COMPACT_WINDOW="${CLAUDE_CODE_AUTO_COMPACT_WINDOW:-${COMPACT_WINDOW:-$DEFAULT_CO
 MAX_CONTEXT_TOKENS="${CLAUDE_CODE_MAX_CONTEXT_TOKENS:-${MAX_CONTEXT_TOKENS:-$DEFAULT_MAX_CONTEXT_TOKENS}}"
 MAX_CONCURRENT_SUBAGENTS="${MAX_CONCURRENT_SUBAGENTS:-$DEFAULT_MAX_CONCURRENT_SUBAGENTS}"
 MAX_SUBAGENT_SPAWN_DEPTH="${MAX_SUBAGENT_SPAWN_DEPTH:-$DEFAULT_MAX_SUBAGENT_SPAWN_DEPTH}"
+
+# Claude's Opus/Sonnet/Haiku/Fable/custom slots must follow the live catalog
+# (SUBCONSCIOUS_MODELS). Packaged DeepSeek/GLM defaults are not a capability.
+PICKER_MODELS=()
+if [[ -n "${SUBCONSCIOUS_MODELS:-}" ]]; then
+  while IFS= read -r picker_model; do
+    [[ -n "$picker_model" ]] && PICKER_MODELS+=("$picker_model")
+  done <<< "$SUBCONSCIOUS_MODELS"
+fi
+
+picker_model_at() {
+  local index="$1"
+  local count="${#PICKER_MODELS[@]}"
+  if [[ "$count" -eq 0 ]]; then
+    printf '%s' "$MODEL"
+    return
+  fi
+  if [[ "$index" -ge "$count" ]]; then
+    index=$((count - 1))
+  fi
+  printf '%s' "${PICKER_MODELS[$index]}"
+}
+
+in_picker_catalog() {
+  local candidate="$1" existing
+  [[ -z "$candidate" ]] && return 1
+  [[ "${#PICKER_MODELS[@]}" -eq 0 ]] && return 0
+  for existing in "${PICKER_MODELS[@]}"; do
+    [[ "$existing" == "$candidate" ]] && return 0
+  done
+  return 1
+}
+
+if [[ "${#PICKER_MODELS[@]}" -gt 0 ]]; then
+  in_picker_catalog "${ANTHROPIC_DEFAULT_OPUS_MODEL:-}" || ANTHROPIC_DEFAULT_OPUS_MODEL=""
+  in_picker_catalog "${ANTHROPIC_DEFAULT_SONNET_MODEL:-}" || ANTHROPIC_DEFAULT_SONNET_MODEL=""
+  in_picker_catalog "${ANTHROPIC_DEFAULT_HAIKU_MODEL:-}" || ANTHROPIC_DEFAULT_HAIKU_MODEL=""
+  in_picker_catalog "${ANTHROPIC_DEFAULT_FABLE_MODEL:-}" || unset ANTHROPIC_DEFAULT_FABLE_MODEL ANTHROPIC_DEFAULT_FABLE_MODEL_NAME ANTHROPIC_DEFAULT_FABLE_MODEL_DESCRIPTION
+  if [[ "${#PICKER_MODELS[@]}" -lt 5 ]] || ! in_picker_catalog "${ANTHROPIC_CUSTOM_MODEL_OPTION:-}"; then
+    unset ANTHROPIC_CUSTOM_MODEL_OPTION ANTHROPIC_CUSTOM_MODEL_OPTION_NAME ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION
+  fi
+fi
+
+DEFAULT_OPUS_MODEL="$(picker_model_at 0)"
+DEFAULT_SONNET_MODEL="$(picker_model_at 1)"
+DEFAULT_HAIKU_MODEL="$(picker_model_at 2)"
+DEFAULT_FABLE_MODEL="$(picker_model_at 3)"
 OPUS_MODEL="${ANTHROPIC_DEFAULT_OPUS_MODEL:-$DEFAULT_OPUS_MODEL}"
 OPUS_MODEL_NAME="${ANTHROPIC_DEFAULT_OPUS_MODEL_NAME:-$OPUS_MODEL}"
-OPUS_MODEL_DESCRIPTION="${ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION:-Subconscious default model}"
+OPUS_MODEL_DESCRIPTION="${ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION:-Subconscious model ${OPUS_MODEL}}"
 SONNET_MODEL="${ANTHROPIC_DEFAULT_SONNET_MODEL:-$DEFAULT_SONNET_MODEL}"
 SONNET_MODEL_NAME="${ANTHROPIC_DEFAULT_SONNET_MODEL_NAME:-$SONNET_MODEL}"
-SONNET_MODEL_DESCRIPTION="${ANTHROPIC_DEFAULT_SONNET_MODEL_DESCRIPTION:-Subconscious TIM Qwen 3.6 27B}"
+SONNET_MODEL_DESCRIPTION="${ANTHROPIC_DEFAULT_SONNET_MODEL_DESCRIPTION:-Subconscious model ${SONNET_MODEL}}"
 HAIKU_MODEL="${ANTHROPIC_DEFAULT_HAIKU_MODEL:-$DEFAULT_HAIKU_MODEL}"
 HAIKU_MODEL_NAME="${ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME:-$HAIKU_MODEL}"
-HAIKU_MODEL_DESCRIPTION="${ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION:-Subconscious DeepSeek V4 Flash Marathon}"
+HAIKU_MODEL_DESCRIPTION="${ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION:-Subconscious model ${HAIKU_MODEL}}"
+FABLE_MODEL="${ANTHROPIC_DEFAULT_FABLE_MODEL:-$DEFAULT_FABLE_MODEL}"
+FABLE_MODEL_NAME="${ANTHROPIC_DEFAULT_FABLE_MODEL_NAME:-$FABLE_MODEL}"
+FABLE_MODEL_DESCRIPTION="${ANTHROPIC_DEFAULT_FABLE_MODEL_DESCRIPTION:-Subconscious model ${FABLE_MODEL}}"
+
+# Model IDs are already restricted to [-A-Za-z0-9._:/+], so they are JSON-safe.
+build_claude_picker_settings() {
+  local ids=() model_id first options allowlist
+  if [[ "${#PICKER_MODELS[@]}" -gt 0 ]]; then
+    ids=("${PICKER_MODELS[@]}")
+  else
+    ids=("$MODEL")
+  fi
+  options=""
+  allowlist=""
+  first=1
+  for model_id in "${ids[@]}"; do
+    [[ -n "$model_id" ]] || continue
+    if [[ "$first" -eq 1 ]]; then
+      first=0
+    else
+      options="${options},"
+      allowlist="${allowlist},"
+    fi
+    options="${options}{\"model\":\"${model_id}\",\"label\":\"${model_id}\",\"description\":\"Subconscious model ${model_id}\"}"
+    allowlist="${allowlist}\"${model_id}\""
+  done
+  printf '{"availableModels":[%s],"modelPicker":{"replaceBuiltInOptions":true,"options":[%s]}}' "$allowlist" "$options"
+}
+
+if [[ -z "${SUBC_CLAUDE_SETTINGS:-}" ]]; then
+  SUBC_CLAUDE_SETTINGS="$(build_claude_picker_settings)"
+fi
 
 usage() {
   cat <<'EOF'
@@ -136,6 +212,10 @@ export ANTHROPIC_DEFAULT_SONNET_MODEL_DESCRIPTION="${ANTHROPIC_DEFAULT_SONNET_MO
 export ANTHROPIC_DEFAULT_HAIKU_MODEL="${ANTHROPIC_DEFAULT_HAIKU_MODEL:-$HAIKU_MODEL}"
 export ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME="${ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME:-$HAIKU_MODEL_NAME}"
 export ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION="${ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION:-$HAIKU_MODEL_DESCRIPTION}"
+export ANTHROPIC_DEFAULT_FABLE_MODEL="${ANTHROPIC_DEFAULT_FABLE_MODEL:-$FABLE_MODEL}"
+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}"
 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}"
@@ -164,4 +244,6 @@ if [[ "${BASH_SOURCE[0]:-$0}" != "${0}" ]]; then
 fi
 
 # If executed, launch claude with any passed-through args.
-exec claude ${PASSTHRU[@]+"${PASSTHRU[@]}"}
+# --settings is additional JSON: it replaces the built-in Fable/Opus lineup
+# with the live catalog and allowlists only those models.
+exec claude --settings "${SUBC_CLAUDE_SETTINGS}" ${PASSTHRU[@]+"${PASSTHRU[@]}"}

package/bin/runbook/subconscious-code/install.sh

@@ -0,0 +1,147 @@
+#!/usr/bin/env bash
+# Install Subconscious Code. Tagged releases currently contain static Linux
+# binaries; macOS builds from the tagged source until Darwin assets are added.
+
+set -euo pipefail
+
+REPOSITORY="subconscious-systems/subconscious-code"
+REPOSITORY_URL="https://github.com/${REPOSITORY}"
+INSTALL_DIR="${SC_INSTALL_DIR:-${HOME}/.local/bin}"
+
+usage() {
+  cat <<'EOF'
+Usage: subc sc install
+
+Install the latest Subconscious Code release. Linux downloads and verifies the
+published static binary. macOS builds the release from source with Cargo.
+EOF
+}
+
+case "${1:-install}" in
+  install) ;;
+  help|-h|--help)
+    usage
+    exit 0
+    ;;
+  *)
+    echo "error: unsupported Subconscious Code setup action: $1" >&2
+    usage >&2
+    exit 2
+    ;;
+esac
+
+release_tag() {
+  if [[ -n "${SC_CODE_VERSION:-}" ]]; then
+    printf '%s\n' "${SC_CODE_VERSION#v}"
+    return
+  fi
+  if command -v gh >/dev/null 2>&1; then
+    local tag
+    tag="$(gh release view --repo "$REPOSITORY" --json tagName --jq '.tagName' 2>/dev/null || true)"
+    if [[ -n "$tag" ]]; then
+      printf '%s\n' "${tag#v}"
+      return
+    fi
+  fi
+  if command -v curl >/dev/null 2>&1; then
+    local tag
+    tag="$(curl -fsSL "https://api.github.com/repos/${REPOSITORY}/releases/latest" 2>/dev/null \
+      | sed -n 's/.*"tag_name"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' \
+      | head -n 1 || true)"
+    if [[ -n "$tag" ]]; then
+      printf '%s\n' "${tag#v}"
+      return
+    fi
+  fi
+  return 1
+}
+
+install_from_source() {
+  if ! command -v cargo >/dev/null 2>&1; then
+    echo "error: macOS installation currently requires Cargo (Rust 1.89 or newer)" >&2
+    echo "Install Rust from https://rustup.rs, then run: subc sc install" >&2
+    exit 1
+  fi
+
+  local version="${1:-}"
+  local args=(install --locked --git "$REPOSITORY_URL" --bin sc)
+  if [[ -n "$version" ]]; then
+    args+=(--tag "v${version}")
+    echo "Building Subconscious Code v${version} from source..."
+  else
+    echo "No published release is visible yet; building Subconscious Code from the default branch..."
+  fi
+  args+=(rc-cli)
+  CARGO_NET_GIT_FETCH_WITH_CLI=true cargo "${args[@]}"
+}
+
+platform="$(uname -s)"
+version="$(release_tag || true)"
+
+if [[ "$platform" == "Darwin" ]]; then
+  install_from_source "$version"
+  exit 0
+fi
+
+if [[ "$platform" != "Linux" ]]; then
+  echo "error: Subconscious Code automatic installation supports Linux and macOS" >&2
+  exit 1
+fi
+
+if [[ -z "$version" ]]; then
+  echo "error: no published Subconscious Code release is available yet" >&2
+  echo "The release may still be building. Retry subc sc install after it finishes." >&2
+  exit 1
+fi
+
+case "$(uname -m)" in
+  x86_64|amd64) target="x86_64-unknown-linux-musl" ;;
+  aarch64|arm64) target="aarch64-unknown-linux-musl" ;;
+  *)
+    echo "error: unsupported Linux architecture: $(uname -m)" >&2
+    exit 1
+    ;;
+esac
+
+asset="sc-${target}.tar.gz"
+checksum="${asset}.sha256"
+work_dir="$(mktemp -d "${TMPDIR:-/tmp}/subc-sc-install.XXXXXX")"
+cleanup() {
+  rm -f "$work_dir/$asset" "$work_dir/$checksum" "$work_dir/sc"
+  rmdir "$work_dir" 2>/dev/null || true
+}
+trap cleanup EXIT HUP INT TERM
+
+echo "Downloading Subconscious Code v${version} for ${target}..."
+if command -v gh >/dev/null 2>&1 \
+  && gh release view "v${version}" --repo "$REPOSITORY" >/dev/null 2>&1; then
+  gh release download "v${version}" --repo "$REPOSITORY" \
+    --pattern "$asset" --pattern "$checksum" --dir "$work_dir"
+else
+  command -v curl >/dev/null 2>&1 || {
+    echo "error: curl is required to download Subconscious Code" >&2
+    exit 1
+  }
+  release_url="${REPOSITORY_URL}/releases/download/v${version}"
+  curl -fL "${release_url}/${asset}" -o "$work_dir/$asset"
+  curl -fL "${release_url}/${checksum}" -o "$work_dir/$checksum"
+fi
+
+if command -v sha256sum >/dev/null 2>&1; then
+  (cd "$work_dir" && sha256sum --check "$checksum")
+elif command -v shasum >/dev/null 2>&1; then
+  expected="$(awk '{print $1}' "$work_dir/$checksum")"
+  actual="$(shasum -a 256 "$work_dir/$asset" | awk '{print $1}')"
+  [[ "$actual" == "$expected" ]] || {
+    echo "error: Subconscious Code checksum verification failed" >&2
+    exit 1
+  }
+else
+  echo "error: sha256sum or shasum is required to verify the download" >&2
+  exit 1
+fi
+
+tar -xzf "$work_dir/$asset" -C "$work_dir" sc
+mkdir -p "$INSTALL_DIR"
+install -m 0755 "$work_dir/sc" "$INSTALL_DIR/sc"
+echo "Installed Subconscious Code v${version} to $INSTALL_DIR/sc"

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

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+# Launch Subconscious Code without changing ~/.sc or project settings.
+
+set -euo pipefail
+
+GATEWAY_URL="${GATEWAY_URL:-}"
+API_KEY="${SC_API_KEY:-${API_KEY:-}}"
+MODEL="${MODEL:-subconscious/glm-5.2}"
+
+if [[ -z "$GATEWAY_URL" || -z "$API_KEY" ]]; then
+  echo "error: GATEWAY_URL and API_KEY are required to launch Subconscious Code" >&2
+  exit 1
+fi
+
+export SC_API_KEY="$API_KEY"
+export SC_BASE_URL="${GATEWAY_URL%/}/v1"
+export SC_DLR_URL="${GATEWAY_URL%/}"
+export SC_DLR_ENABLED=true
+export SC_MODEL="$MODEL"
+
+exec sc "$@"

package/bin/tui.js

@@ -11,6 +11,7 @@ import {
   DEFAULT_PROFILE,
   listProfiles,
   loadProfile,
+  resolvedModelSetting,
   RUNBOOK_DEFAULTS,
   SUPPORTED_MODELS as PACKAGED_MODELS,
 } from './profiles.js';
@@ -70,15 +71,11 @@ export async function resolveTuiExecutable(options = {}) {
 }
 
 function selectedModelFor(profile) {
-  return (
-    process.env.SUBCONSCIOUS_MODEL?.trim() ||
-    profile.values.MODEL?.trim() ||
-    RUNBOOK_DEFAULTS.MODEL
-  );
+  return resolvedModelSetting(process.env.SUBCONSCIOUS_MODEL || profile.values.MODEL);
 }
 
 function subagentModelFor(profile) {
-  return profile.values.CLAUDE_CODE_SUBAGENT_MODEL?.trim() || '';
+  return resolvedModelSetting(profile.values.CLAUDE_CODE_SUBAGENT_MODEL);
 }
 
 function gatewayFor(profile) {
@@ -117,14 +114,15 @@ export async function createTuiState(profileName = DEFAULT_PROFILE, options = {}
   );
 
   const auth = await getApiKey(activeProfile);
-  const selectedModel = selectedModelFor(activeProfile);
+  const requestedModel = selectedModelFor(activeProfile);
   const gatewayUrl = gatewayFor(activeProfile);
   const catalog = await resolveModelCatalog({
     baseUrl: gatewayUrl,
     apiKey: auth?.key,
-    selectedModel,
+    selectedModel: requestedModel,
     fallbackModels: PACKAGED_MODELS,
   });
+  const selectedModel = requestedModel;
 
   return {
     version: await packageVersion(),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "subconscious-cli",
-  "version": "4.0.13",
-  "description": "CLI for Subconscious — run Claude Code, Codex, OpenCode, DeepSeek Harness, Cursor, Copilot, and Pi",
+  "version": "4.0.15",
+  "description": "CLI for Subconscious — run Subconscious Code, Claude Code, Codex, OpenCode, DeepSeek Harness, Cursor, Copilot, and Pi",
   "bin": {
     "subc": "bin/cli.js"
   },
@@ -33,6 +33,7 @@
     "authentication",
     "profiles",
     "coding-agent",
+    "subconscious-code",
     "claude-code",
     "opencode",
     "codex",