subconscious-cli 6.0.0 → 6.1.0

package/bin/profiles.js

@@ -6,24 +6,29 @@
  *   ~/.subconscious/profiles/<name>.env
  */
 
-import { spawn, execFileSync } from 'node:child_process';
-import { windowsEditor, runWindows } from './windows/process.js';
+import { execFileSync, spawn } from 'node:child_process';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { readFileSync } from 'node:fs';
 import { c } from './colors.js';
 import { PUBLIC_CATALOG_FALLBACK_MESSAGE } from './models.js';
-
-const registry = JSON.parse(
-  readFileSync(new URL('./registry.generated.json', import.meta.url), 'utf-8'),
-);
+import {
+  profileTemplate,
+  RUNBOOK_DEFAULTS,
+  SUPPORTED_MODELS,
+} from './profile-settings.js';
+
+export {
+  PROFILE_SETTING_GROUPS,
+  profileSettingsForAgent,
+  RUNBOOK_DEFAULTS,
+  resolvedProfileValues,
+  SUPPORTED_MODELS,
+} from './profile-settings.js';
+
+import { runWindows, windowsEditor } from './windows/process.js';
 
 export const DEFAULT_PROFILE = 'default';
-export const SUPPORTED_MODELS =
-  Array.isArray(registry.defaults.models) && registry.defaults.models.length
-    ? registry.defaults.models
-    : [registry.defaults.model];
 const PREVIOUS_DEFAULT_GATEWAYS = new Set([
   'https://api.subconscious.dev',
   'https://api.subconscious.dev/',
@@ -35,407 +40,11 @@ const LEGACY_PROFILES_DIR = CONFIG_OVERRIDE
   ? null
   : path.join(os.homedir(), '.subcon', 'profiles');
 
-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: '',
-  CODEX_API_KEY: '',
-  OPENCODE_API_KEY: '',
-  CURSOR_API_KEY: '',
-  COPILOT_API_KEY: '',
-  PI_API_KEY: '',
-  DEEPSEEK_HARNESS_API_KEY: '',
-  CLAUDE_CODE_AUTO_COMPACT_WINDOW: '1000000',
-  CLAUDE_CODE_MAX_CONTEXT_TOKENS: '3000000',
-  MAX_CONCURRENT_SUBAGENTS: '4',
-  MAX_SUBAGENT_SPAWN_DEPTH: '1',
-  CODEX_CONTEXT_WINDOW: '5000000',
-  CODEX_MAX_CONTEXT_WINDOW: '5000000',
-  CODEX_AUTO_COMPACT_TOKEN_LIMIT: '4500000',
-  CODEX_REASONING_EFFORT: 'max',
-  CODEX_EXTERNAL_TOOLS: 'false',
-  OPENCODE_CONTEXT_LIMIT: '5000000',
-  OPENCODE_OUTPUT_LIMIT: '65536',
-  PI_CONTEXT_WINDOW: '5000000',
-  PI_MAX_TOKENS: '65536',
-  DEEPSEEK_HARNESS_CONTEXT_WINDOW: '5000000',
-  DEEPSEEK_HARNESS_MAX_TOKENS: '65536',
-  COPILOT_MAX_INPUT_TOKENS: '5000000',
-  COPILOT_MAX_OUTPUT_TOKENS: '65536',
-  VSCODE_APP: '',
-};
-
-const SETTINGS = {
-  GATEWAY_URL: {
-    key: 'GATEWAY_URL',
-    label: 'Gateway URL',
-    description: 'Subconscious gateway origin shared by every integration.',
-    type: 'url',
-    required: true,
-  },
-  PLATFORM_URL: {
-    key: 'PLATFORM_URL',
-    label: 'Platform URL',
-    description: 'Subconscious platform origin for login, whoami, and usage.',
-    type: 'url',
-  },
-  API_KEY: {
-    key: 'API_KEY',
-    label: 'Shared API key',
-    description: 'Default credential used when an agent-specific key is blank.',
-    type: 'secret',
-  },
-  MODEL: {
-    key: 'MODEL',
-    label: 'Default model',
-    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. UNSET follows the default model.',
-    type: 'choice',
-    choices: SUPPORTED_MODELS,
-  },
-  CLAUDE_GATEWAY_URL: {
-    key: 'CLAUDE_GATEWAY_URL',
-    label: 'Claude gateway override',
-    description: 'Optional Claude-only gateway origin; blank uses GATEWAY_URL.',
-    type: 'url',
-  },
-  CLAUDE_CODE_API_KEY: {
-    key: 'CLAUDE_CODE_API_KEY',
-    label: 'Claude API key',
-    description: 'Claude-specific credential override; blank uses API_KEY.',
-    type: 'secret',
-  },
-  CLAUDE_CODE_AUTO_COMPACT_WINDOW: {
-    key: 'CLAUDE_CODE_AUTO_COMPACT_WINDOW',
-    label: 'Auto-compact window',
-    description: 'Claude token window before compaction (100000–1000000).',
-    type: 'integer',
-    min: 100000,
-    max: 1000000,
-  },
-  CLAUDE_CODE_MAX_CONTEXT_TOKENS: {
-    key: 'CLAUDE_CODE_MAX_CONTEXT_TOKENS',
-    label: 'Maximum context tokens',
-    description: 'Maximum context advertised to Claude Code.',
-    type: 'integer',
-    min: 1,
-  },
-  MAX_CONCURRENT_SUBAGENTS: {
-    key: 'MAX_CONCURRENT_SUBAGENTS',
-    label: 'Concurrent subagents',
-    description: 'Maximum concurrent Claude/Codex subagent threads.',
-    type: 'integer',
-    min: 1,
-  },
-  CODEX_SUBAGENT_REASONING_EFFORT: {
-    key: 'CODEX_SUBAGENT_REASONING_EFFORT',
-    label: 'Subagent reasoning effort',
-    description:
-      'Effort for Codex subagents, set separately from the parent: a marathon model at max thinks for minutes without emitting a token, and a subagent turn is one uninterrupted think, so inheriting max makes every delegated subtask look like a hang.',
-    type: 'text',
-  },
-  CODEX_MULTI_AGENT_VERSION: {
-    key: 'CODEX_MULTI_AGENT_VERSION',
-    label: 'Codex multi-agent version',
-    description:
-      'Which subagent implementation Codex offers: v2 gives the collaboration tools. Leave empty to turn subagents off entirely.',
-    type: 'text',
-  },
-  CODEX_STREAM_IDLE_TIMEOUT_MS: {
-    key: 'CODEX_STREAM_IDLE_TIMEOUT_MS',
-    label: 'Stream idle timeout (ms)',
-    description:
-      'How long Codex waits on a silent stream before giving up. Needs to exceed the longest think the model will take.',
-    type: 'integer',
-    min: 1,
-  },
-  MAX_SUBAGENT_SPAWN_DEPTH: {
-    key: 'MAX_SUBAGENT_SPAWN_DEPTH',
-    label: 'Subagent spawn depth',
-    description: 'Maximum Claude subagent nesting depth.',
-    type: 'integer',
-    min: 0,
-  },
-  CODEX_API_KEY: {
-    key: 'CODEX_API_KEY',
-    label: 'Codex API key',
-    description: 'Codex-specific credential override; blank uses API_KEY.',
-    type: 'secret',
-  },
-  CODEX_CONTEXT_WINDOW: {
-    key: 'CODEX_CONTEXT_WINDOW',
-    label: 'Context window',
-    description: 'Context window written into the Codex model catalog.',
-    type: 'integer',
-    min: 1,
-  },
-  CODEX_MAX_CONTEXT_WINDOW: {
-    key: 'CODEX_MAX_CONTEXT_WINDOW',
-    label: 'Maximum context window',
-    description: 'Maximum context window written into the Codex catalog.',
-    type: 'integer',
-    min: 1,
-  },
-  CODEX_AUTO_COMPACT_TOKEN_LIMIT: {
-    key: 'CODEX_AUTO_COMPACT_TOKEN_LIMIT',
-    label: 'Auto-compact token limit',
-    description: 'Codex token threshold that triggers automatic compaction.',
-    type: 'integer',
-    min: 1,
-  },
-  CODEX_REASONING_EFFORT: {
-    key: 'CODEX_REASONING_EFFORT',
-    label: 'Reasoning effort',
-    description: 'Default Codex reasoning effort.',
-    type: 'choice',
-    choices: ['none', 'low', 'medium', 'high', 'max'],
-  },
-  CODEX_EXTERNAL_TOOLS: {
-    key: 'CODEX_EXTERNAL_TOOLS',
-    label: 'External tools',
-    description: 'Enable Codex apps/plugins; may exceed the gateway tool limit.',
-    type: 'choice',
-    choices: ['false', 'true'],
-  },
-  OPENCODE_API_KEY: {
-    key: 'OPENCODE_API_KEY',
-    label: 'OpenCode API key',
-    description: 'OpenCode-specific credential override; blank uses API_KEY.',
-    type: 'secret',
-  },
-  OPENCODE_CONTEXT_LIMIT: {
-    key: 'OPENCODE_CONTEXT_LIMIT',
-    label: 'Context limit',
-    description: 'OpenCode provider context limit used for compaction.',
-    type: 'integer',
-    min: 1,
-  },
-  OPENCODE_OUTPUT_LIMIT: {
-    key: 'OPENCODE_OUTPUT_LIMIT',
-    label: 'Output limit',
-    description: 'Maximum output tokens advertised to OpenCode.',
-    type: 'integer',
-    min: 1,
-  },
-  CURSOR_API_KEY: {
-    key: 'CURSOR_API_KEY',
-    label: 'Cursor hook API key',
-    description: 'Cursor hook credential override; blank uses API_KEY.',
-    type: 'secret',
-  },
-  COPILOT_API_KEY: {
-    key: 'COPILOT_API_KEY',
-    label: 'Copilot hook API key',
-    description: 'Copilot hook credential override; blank uses API_KEY.',
-    type: 'secret',
-  },
-  COPILOT_MAX_INPUT_TOKENS: {
-    key: 'COPILOT_MAX_INPUT_TOKENS',
-    label: 'Maximum input tokens',
-    description: 'Input-token capacity advertised to VS Code.',
-    type: 'integer',
-    min: 1,
-  },
-  COPILOT_MAX_OUTPUT_TOKENS: {
-    key: 'COPILOT_MAX_OUTPUT_TOKENS',
-    label: 'Maximum output tokens',
-    description: 'Output-token capacity advertised to VS Code.',
-    type: 'integer',
-    min: 1,
-  },
-  VSCODE_APP: {
-    key: 'VSCODE_APP',
-    label: 'VS Code application',
-    description: 'Optional application override; blank enables auto-detection.',
-    type: 'choice',
-    choices: ['', 'Code', 'Code - Insiders', 'VSCodium'],
-  },
-  PI_API_KEY: {
-    key: 'PI_API_KEY',
-    label: 'Pi API key',
-    description: 'Pi-specific credential override; blank uses API_KEY.',
-    type: 'secret',
-  },
-  PI_CONTEXT_WINDOW: {
-    key: 'PI_CONTEXT_WINDOW',
-    label: 'Context window',
-    description: 'Pi context window used to determine compaction.',
-    type: 'integer',
-    min: 1,
-  },
-  PI_MAX_TOKENS: {
-    key: 'PI_MAX_TOKENS',
-    label: 'Maximum output tokens',
-    description: 'Maximum output tokens advertised to Pi.',
-    type: 'integer',
-    min: 1,
-  },
-  DEEPSEEK_HARNESS_API_KEY: {
-    key: 'DEEPSEEK_HARNESS_API_KEY',
-    label: 'DeepSeek Harness API key',
-    description: 'DeepSeek Harness credential override; blank uses API_KEY.',
-    type: 'secret',
-  },
-  DEEPSEEK_HARNESS_CONTEXT_WINDOW: {
-    key: 'DEEPSEEK_HARNESS_CONTEXT_WINDOW',
-    label: 'Context window',
-    description: 'Context capacity advertised to DeepSeek Harness.',
-    type: 'integer',
-    min: 1,
-  },
-  DEEPSEEK_HARNESS_MAX_TOKENS: {
-    key: 'DEEPSEEK_HARNESS_MAX_TOKENS',
-    label: 'Maximum output tokens',
-    description: 'Output capacity advertised to DeepSeek Harness.',
-    type: 'integer',
-    min: 1,
-  },
-};
-
-const AGENT_SETTING_KEYS = {
-  'subconscious-code': ['SC_API_KEY'],
-  'claude-code': [
-    'CLAUDE_GATEWAY_URL',
-    'CLAUDE_CODE_API_KEY',
-    'CLAUDE_CODE_SUBAGENT_MODEL',
-    'CLAUDE_CODE_AUTO_COMPACT_WINDOW',
-    'CLAUDE_CODE_MAX_CONTEXT_TOKENS',
-    'MAX_CONCURRENT_SUBAGENTS',
-    'MAX_SUBAGENT_SPAWN_DEPTH',
-  ],
-  codex: [
-    'CODEX_API_KEY',
-    'CODEX_CONTEXT_WINDOW',
-    'CODEX_MAX_CONTEXT_WINDOW',
-    'CODEX_AUTO_COMPACT_TOKEN_LIMIT',
-    'CODEX_REASONING_EFFORT',
-    'CODEX_EXTERNAL_TOOLS',
-    'CODEX_STREAM_IDLE_TIMEOUT_MS',
-    'CODEX_MULTI_AGENT_VERSION',
-    'CODEX_SUBAGENT_REASONING_EFFORT',
-    'MAX_CONCURRENT_SUBAGENTS',
-  ],
-  opencode: ['OPENCODE_API_KEY', 'OPENCODE_CONTEXT_LIMIT', 'OPENCODE_OUTPUT_LIMIT'],
-  cursor: ['CURSOR_API_KEY'],
-  copilot: [
-    'COPILOT_API_KEY',
-    'COPILOT_MAX_INPUT_TOKENS',
-    'COPILOT_MAX_OUTPUT_TOKENS',
-    'VSCODE_APP',
-  ],
-  pi: ['PI_API_KEY', 'PI_CONTEXT_WINDOW', 'PI_MAX_TOKENS'],
-  'deepseek-harness': [
-    'DEEPSEEK_HARNESS_API_KEY',
-    'DEEPSEEK_HARNESS_CONTEXT_WINDOW',
-    'DEEPSEEK_HARNESS_MAX_TOKENS',
-  ],
-};
-
-const GROUP_KEYS = [
-  { id: 'shared', label: 'Shared settings', keys: ['GATEWAY_URL', 'API_KEY', 'MODEL'] },
-  ...registry.agents
-    .filter((agent) => agent.cli !== false)
-    .map((agent) => ({
-      id: agent.id,
-      label: agent.name,
-      keys: AGENT_SETTING_KEYS[agent.id] || [],
-    })),
-];
-
-export const PROFILE_SETTING_GROUPS = GROUP_KEYS.map((group) => ({
-  ...group,
-  settings: group.keys.map((key) => SETTINGS[key]),
-}));
-
-export function profileSettingsForAgent(agentId) {
-  const shared = PROFILE_SETTING_GROUPS.find((group) => group.id === 'shared');
-  const agent = PROFILE_SETTING_GROUPS.find((group) => group.id === agentId);
-  return [...(shared?.settings || []), ...(agent?.settings || [])];
-}
-
-export function resolvedProfileValues(profile) {
-  return { ...RUNBOOK_DEFAULTS, ...(profile?.values || {}) };
-}
-
-function profileTemplate() {
-  const modelComments = SUPPORTED_MODELS.map((model) => `#   ${model}`).join('\n');
-  return `# Subconscious coding-agent profile
-# Generated by subc. Extra KEY=value lines are passed through to launches.
-
-GATEWAY_URL={GATEWAY_URL}
-API_KEY={API_KEY}
-# 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}
-CURSOR_API_KEY={CURSOR_API_KEY}
-COPILOT_API_KEY={COPILOT_API_KEY}
-PI_API_KEY={PI_API_KEY}
-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}
-# 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}
-MAX_CONCURRENT_SUBAGENTS={MAX_CONCURRENT_SUBAGENTS}
-MAX_SUBAGENT_SPAWN_DEPTH={MAX_SUBAGENT_SPAWN_DEPTH}
-
-# Codex
-CODEX_CONTEXT_WINDOW={CODEX_CONTEXT_WINDOW}
-CODEX_MAX_CONTEXT_WINDOW={CODEX_MAX_CONTEXT_WINDOW}
-CODEX_AUTO_COMPACT_TOKEN_LIMIT={CODEX_AUTO_COMPACT_TOKEN_LIMIT}
-CODEX_REASONING_EFFORT={CODEX_REASONING_EFFORT}
-CODEX_EXTERNAL_TOOLS={CODEX_EXTERNAL_TOOLS}
-
-# OpenCode
-OPENCODE_CONTEXT_LIMIT={OPENCODE_CONTEXT_LIMIT}
-OPENCODE_OUTPUT_LIMIT={OPENCODE_OUTPUT_LIMIT}
-
-# Pi
-PI_CONTEXT_WINDOW={PI_CONTEXT_WINDOW}
-PI_MAX_TOKENS={PI_MAX_TOKENS}
-
-# DeepSeek Harness
-DEEPSEEK_HARNESS_CONTEXT_WINDOW={DEEPSEEK_HARNESS_CONTEXT_WINDOW}
-DEEPSEEK_HARNESS_MAX_TOKENS={DEEPSEEK_HARNESS_MAX_TOKENS}
-
-# GitHub Copilot
-COPILOT_MAX_INPUT_TOKENS={COPILOT_MAX_INPUT_TOKENS}
-COPILOT_MAX_OUTPUT_TOKENS={COPILOT_MAX_OUTPUT_TOKENS}
-VSCODE_APP={VSCODE_APP}
-
-# Extra KEY=value lines are passed through to launches.
-`;
-}
-
 export function validateProfileName(name) {
   if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(name)) {
-    throw new Error(`Invalid profile name '${name}' (use letters, digits, _ or -)`);
+    throw new Error(
+      `Invalid profile name '${name}' (use letters, digits, _ or -)`,
+    );
   }
   return name;
 }
@@ -462,7 +71,9 @@ export function parseProfile(text) {
   for (const line of text.split('\n')) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith('#')) continue;
-    const match = trimmed.match(/^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+    const match = trimmed.match(
+      /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)=(.*)$/,
+    );
     if (!match) continue;
     values[match[1]] = decodeValue(match[2]);
   }
@@ -478,7 +89,9 @@ function encodeValue(value) {
 }
 
 function renderTemplate(values) {
-  return profileTemplate().replace(/\{([A-Z0-9_]+)\}/g, (_, key) => encodeValue(values[key]));
+  return profileTemplate().replace(/\{([A-Z0-9_]+)\}/g, (_, key) =>
+    encodeValue(values[key]),
+  );
 }
 
 function upsertValues(text, updates) {
@@ -491,7 +104,8 @@ function upsertValues(text, updates) {
     remaining.delete(match[2]);
     return `${match[1]}${match[2]}=${encodeValue(value)}`;
   });
-  for (const [key, value] of remaining) output.push(`${key}=${encodeValue(value)}`);
+  for (const [key, value] of remaining)
+    output.push(`${key}=${encodeValue(value)}`);
   return `${output.join('\n')}\n`;
 }
 
@@ -506,10 +120,12 @@ function migrateCopilotTokenDefaults(text) {
   const values = parseProfile(text);
   const updates = {};
   if (values.COPILOT_MAX_INPUT_TOKENS === '12288') {
-    updates.COPILOT_MAX_INPUT_TOKENS = RUNBOOK_DEFAULTS.COPILOT_MAX_INPUT_TOKENS;
+    updates.COPILOT_MAX_INPUT_TOKENS =
+      RUNBOOK_DEFAULTS.COPILOT_MAX_INPUT_TOKENS;
   }
   if (values.COPILOT_MAX_OUTPUT_TOKENS === '4096') {
-    updates.COPILOT_MAX_OUTPUT_TOKENS = RUNBOOK_DEFAULTS.COPILOT_MAX_OUTPUT_TOKENS;
+    updates.COPILOT_MAX_OUTPUT_TOKENS =
+      RUNBOOK_DEFAULTS.COPILOT_MAX_OUTPUT_TOKENS;
   }
   return Object.keys(updates).length ? upsertValues(text, updates) : text;
 }
@@ -530,7 +146,12 @@ export async function loadProfile(name = DEFAULT_PROFILE) {
     const text = await fs.readFile(file, 'utf-8');
     const migratedText = migrateDefaults(text);
     if (migratedText !== text) await writeProfile(file, migratedText);
-    return { name, path: file, exists: true, values: parseProfile(migratedText) };
+    return {
+      name,
+      path: file,
+      exists: true,
+      values: parseProfile(migratedText),
+    };
   } catch (error) {
     if (error.code !== 'ENOENT') throw error;
   }
@@ -539,7 +160,10 @@ export async function loadProfile(name = DEFAULT_PROFILE) {
   if (LEGACY_PROFILES_DIR) {
     try {
       const text = migrateDefaults(
-        await fs.readFile(path.join(LEGACY_PROFILES_DIR, `${name}.env`), 'utf-8'),
+        await fs.readFile(
+          path.join(LEGACY_PROFILES_DIR, `${name}.env`),
+          'utf-8',
+        ),
       );
       await writeProfile(file, text);
       return { name, path: file, exists: true, values: parseProfile(text) };
@@ -562,7 +186,8 @@ export async function ensureProfile(name = DEFAULT_PROFILE, apiKey) {
         Object.fromEntries(
           Object.entries(values).filter(
             ([key]) =>
-              profile.values[key] === undefined || (key === 'API_KEY' && apiKey !== undefined),
+              profile.values[key] === undefined ||
+              (key === 'API_KEY' && apiKey !== undefined),
           ),
         ),
       )
@@ -586,11 +211,21 @@ export async function clearProfileApiKey(name = DEFAULT_PROFILE) {
   return true;
 }
 
-function isSecretKey(key) {
+// PI_MAX_TOKENS=65536 is a budget, not a credential. Anything else under a
+// *_TOKENS name, such as a key pasted onto the wrong line, stays redacted.
+function isTokenBudget(key, value) {
+  return (
+    /_TOKENS$|_TOKEN_LIMIT$/i.test(key) &&
+    /^\d+$/.test(value) &&
+    Number.isSafeInteger(Number(value))
+  );
+}
+
+function isSecretKey(key, value) {
   const upper = key.toUpperCase();
   return (
     upper.endsWith('API_KEY') ||
-    upper.includes('TOKEN') ||
+    (upper.includes('TOKEN') && !isTokenBudget(key, value)) ||
     upper.includes('SECRET') ||
     upper.includes('PASSWORD') ||
     upper.includes('AUTH')
@@ -598,16 +233,20 @@ function isSecretKey(key) {
 }
 
 function redact(key, value) {
-  if (!isSecretKey(key) || !value) return value;
-  return value.length <= 8 ? '********' : `${value.slice(0, 4)}…${value.slice(-4)}`;
+  if (!value || !isSecretKey(key, value)) return value;
+  return value.length <= 8
+    ? '********'
+    : `${value.slice(0, 4)}…${value.slice(-4)}`;
 }
 
 function redactEnvLine(line) {
-  const match = line.match(/^(\s*(?:export\s+)?)([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+  const match = line.match(
+    /^(\s*(?:export\s+)?)([A-Za-z_][A-Za-z0-9_]*)=(.*)$/,
+  );
   if (!match) return line;
   const [, prefix, key, raw] = match;
   const value = decodeValue(raw);
-  if (!isSecretKey(key) || !value) return line;
+  if (!value || !isSecretKey(key, value)) return line;
   return `${prefix}${key}=${redact(key, value)}`;
 }
 
@@ -633,18 +272,20 @@ async function printProfile(profile) {
   }
   const text = await fs.readFile(profile.path, 'utf-8');
   console.log(
-    text
-      .replace(/\n$/, '')
-      .split('\n')
-      .map(redactEnvLine)
-      .join('\n'),
+    text.replace(/\n$/, '').split('\n').map(redactEnvLine).join('\n'),
   );
   console.log();
 }
 
 export function isUnsetSetting(value) {
-  const normalized = String(value ?? '').trim().toUpperCase();
-  return normalized === 'UNSET' || normalized === 'FOLLOW-GATEWAY' || normalized === 'FOLLOW-DEFAULT';
+  const normalized = String(value ?? '')
+    .trim()
+    .toUpperCase();
+  return (
+    normalized === 'UNSET' ||
+    normalized === 'FOLLOW-GATEWAY' ||
+    normalized === 'FOLLOW-DEFAULT'
+  );
 }
 
 export function resolvedModelSetting(value) {
@@ -684,7 +325,11 @@ export function validateSettingValue(setting, value) {
   return null;
 }
 
-const ALLOWED_EDITORS = new Set(process.platform === 'win32' ? ['notepad', 'code', 'code-insiders', 'vim', 'nano'] : ['vim', 'nano']);
+const ALLOWED_EDITORS = new Set(
+  process.platform === 'win32'
+    ? ['notepad', 'code', 'code-insiders', 'vim', 'nano']
+    : ['vim', 'nano'],
+);
 
 function commandExists(bin) {
   try {
@@ -709,7 +354,9 @@ function resolveEditor(requested) {
   if (fromEnv) return parseEditorCommand(fromEnv);
   if (commandExists('vim')) return { cmd: 'vim', args: [] };
   if (commandExists('nano')) return { cmd: 'nano', args: [] };
-  throw new Error('No editor found. Install vim or nano, or set $VISUAL / $EDITOR.');
+  throw new Error(
+    'No editor found. Install vim or nano, or set $VISUAL / $EDITOR.',
+  );
 }
 
 async function editProfile(profileName, requestedEditor) {
@@ -776,12 +423,18 @@ async function printProfileList(activeName) {
   console.log(`\n  ${c.bold}Profiles${c.reset}`);
   for (const name of profiles) {
     const active = name === activeName ? ` ${c.green}(active)${c.reset}` : '';
-    console.log(`    ${c.cyan}${name}${c.reset}${active}  ${c.dim}${profilePath(name)}${c.reset}`);
+    console.log(
+      `    ${c.cyan}${name}${c.reset}${active}  ${c.dim}${profilePath(name)}${c.reset}`,
+    );
   }
   console.log();
 }
 
-export async function configCommand(argv, profileName = DEFAULT_PROFILE, options = {}) {
+export async function configCommand(
+  argv,
+  profileName = DEFAULT_PROFILE,
+  options = {},
+) {
   let action = 'default';
   let editor;
   const updates = {};
@@ -791,7 +444,17 @@ export async function configCommand(argv, profileName = DEFAULT_PROFILE, options
     if (arg === 'help' || arg === '-h' || arg === '--help') {
       printConfigHelp();
       return;
-    } else if (['show', 'path', 'list', 'create', 'delete', 'edit', 'interactive'].includes(arg)) {
+    } else if (
+      [
+        'show',
+        'path',
+        'list',
+        'create',
+        'delete',
+        'edit',
+        'interactive',
+      ].includes(arg)
+    ) {
       action = arg === 'interactive' ? 'edit' : arg;
     } else if (
       arg === '--gateway-url' ||
@@ -810,12 +473,17 @@ export async function configCommand(argv, profileName = DEFAULT_PROFILE, options
         '--subagent-model': 'CLAUDE_CODE_SUBAGENT_MODEL',
       }[arg];
       updates[key] =
-        (arg === '--model' || arg === '--subagent-model') && isUnsetSetting(value) ? '' : value;
+        (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)');
+      if (editor) throw new Error('Specify only one editor');
       editor = arg;
     } else if (action === 'edit') {
-      throw new Error(`Unknown editor '${arg}' (use vim or nano)`);
+      throw new Error(
+        `Unknown editor '${arg}' (use ${[...ALLOWED_EDITORS].join(', ')})`,
+      );
     } else {
       throw new Error(`Unknown config argument: ${arg}`);
     }
@@ -831,7 +499,12 @@ export async function configCommand(argv, profileName = DEFAULT_PROFILE, options
     return;
   }
 
-  if (action === 'list' || (action === 'default' && !options.profileExplicit && !Object.keys(updates).length)) {
+  if (
+    action === 'list' ||
+    (action === 'default' &&
+      !options.profileExplicit &&
+      !Object.keys(updates).length)
+  ) {
     await printProfileList(profileName);
     return;
   }
@@ -846,7 +519,8 @@ export async function configCommand(argv, profileName = DEFAULT_PROFILE, options
       throw new Error('config create cannot be combined with profile updates');
     }
     const existing = await loadProfile(profileName);
-    if (existing.exists) throw new Error(`Profile '${profileName}' already exists`);
+    if (existing.exists)
+      throw new Error(`Profile '${profileName}' already exists`);
     const profile = await ensureProfile(profileName);
     console.log(`Created profile '${profileName}'.`);
     await printProfile(profile);
@@ -855,7 +529,9 @@ export async function configCommand(argv, profileName = DEFAULT_PROFILE, options
 
   if (action === 'delete') {
     if (profileName === DEFAULT_PROFILE) {
-      throw new Error('Refusing to delete the default profile; use subc logout to clear its key');
+      throw new Error(
+        'Refusing to delete the default profile; use subc logout to clear its key',
+      );
     }
     const profile = await loadProfile(profileName);
     if (!profile.exists) {
@@ -878,10 +554,12 @@ export async function configCommand(argv, profileName = DEFAULT_PROFILE, options
 }
 
 export function modelsCommand(models = SUPPORTED_MODELS, options = {}) {
-  const selectedModel = options.selectedModel || models[0] || registry.defaults.model;
+  const selectedModel =
+    options.selectedModel || models[0] || RUNBOOK_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}` : '';
+    const suffix =
+      model === selectedModel ? ` ${c.dim}(default)${c.reset}` : '';
     console.log(`  ${c.cyan}${model}${c.reset}${suffix}`);
   }
   if (options.source === 'public' && options.hasApiKey) {
@@ -896,7 +574,9 @@ export function modelsCommand(models = SUPPORTED_MODELS, options = {}) {
 }
 
 export function validateOriginUrl(rawUrl, label = 'URL') {
-  const normalized = String(rawUrl ?? '').trim().replace(/\/+$/, '');
+  const normalized = String(rawUrl ?? '')
+    .trim()
+    .replace(/\/+$/, '');
   if (!normalized) {
     throw new Error(`${label} cannot be blank`);
   }
@@ -929,7 +609,9 @@ export async function updateUrlCommand(argv = [], options = {}) {
   const profile = await updateProfile(profileName, { GATEWAY_URL: gatewayUrl });
 
   console.log(`\n  ${c.green}${c.bold}✓ Gateway URL updated.${c.reset}`);
-  console.log(`  ${c.dim}Updated profile automatically: ${profile.path}${c.reset}`);
+  console.log(
+    `  ${c.dim}Updated profile automatically: ${profile.path}${c.reset}`,
+  );
   console.log(`  ${c.dim}URL:     ${gatewayUrl}${c.reset}`);
   if (process.env.SUBCONSCIOUS_BASE_URL?.trim()) {
     console.log(
@@ -937,7 +619,8 @@ export async function updateUrlCommand(argv = [], options = {}) {
     );
   }
   const claudeOverride =
-    process.env.CLAUDE_GATEWAY_URL?.trim() || profile.values.CLAUDE_GATEWAY_URL?.trim();
+    process.env.CLAUDE_GATEWAY_URL?.trim() ||
+    profile.values.CLAUDE_GATEWAY_URL?.trim();
   if (claudeOverride) {
     console.log(
       `  ${c.yellow}CLAUDE_GATEWAY_URL is set, so Claude Code will continue using ${claudeOverride}.${c.reset}`,
@@ -954,10 +637,14 @@ export async function updatePlatformUrlCommand(argv = [], options = {}) {
   const platformUrl = validateOriginUrl(argv[0], 'Platform URL');
 
   const profileName = options.profileName || DEFAULT_PROFILE;
-  const profile = await updateProfile(profileName, { PLATFORM_URL: platformUrl });
+  const profile = await updateProfile(profileName, {
+    PLATFORM_URL: platformUrl,
+  });
 
   console.log(`\n  ${c.green}${c.bold}✓ Platform URL updated.${c.reset}`);
-  console.log(`  ${c.dim}Updated profile automatically: ${profile.path}${c.reset}`);
+  console.log(
+    `  ${c.dim}Updated profile automatically: ${profile.path}${c.reset}`,
+  );
   console.log(`  ${c.dim}URL:     ${platformUrl}${c.reset}`);
   if (process.env.SUBCONSCIOUS_URL?.trim()) {
     console.log(