subconscious-cli 4.1.3 → 4.2.0

package/bin/agents.js

@@ -32,6 +32,15 @@ import { compareVersions } from './update-check.js';
 
 export const MIN_CLAUDE_CODE_VERSION = '2.1.242';
 
+// First Codex that honours `multi_agent_version: "v2"` in the model catalog,
+// found by installing each release and reading what it advertises: 0.142.5 and
+// below offer no subagent namespace at all, 0.143.0 offers `collaboration`.
+//
+// Below this the catalog field is not rejected, it is ignored - the run simply
+// has no subagents and nothing says why. That silence is the reason for a
+// version gate rather than a note in the docs.
+export const MIN_CODEX_VERSION = '0.143.0';
+
 // --- Registry (single source of truth, generated copy shipped in the package).
 const registry = JSON.parse(
   readFileSync(new URL('./registry.generated.json', import.meta.url), 'utf-8'),
@@ -193,10 +202,10 @@ const AGENT_HELP = {
   codex: {
     usage: 'subc [-p NAME] codex [help|install|status|uninstall] [Codex arguments...]',
     behavior:
-      'Launches Codex with a temporary Subconscious provider catalog. Compaction hooks are merged into ~/.codex/hooks.json and removed with subc codex uninstall.',
+      'Launches Codex with a temporary Subconscious provider catalog. Compaction hooks are merged into ~/.codex/hooks.json on first launch and removed with subc codex uninstall; Codex will not run them until you trust them with /hooks once.',
     options: [
       ['help', 'Show this help'],
-      ['install', 'Install only the Subconscious compaction hooks'],
+      ['install', 'Install the Subconscious compaction hooks (then trust with /hooks)'],
       ['status', 'Inspect the installed compaction hooks'],
       ['uninstall', 'Remove only the Subconscious Codex hooks'],
       ['--model MODEL', 'Override the profile model for this launch'],
@@ -205,7 +214,9 @@ const AGENT_HELP = {
       ['--auto-compact-token-limit N', 'Override the automatic compaction threshold'],
       ['--reasoning-effort LEVEL', 'Use none, low, medium, high, or max'],
       ['--external-tools', 'Enable Codex apps/plugins for this launch'],
-      ['--subagents', 'Use the pinned legacy Codex subagent mode'],
+      ['--stream-idle-timeout MS', 'Allow a longer silent think before timing out'],
+      ['--max-subagents N', 'Subagents allowed to run at once (default 4)'],
+      ['--subagent-effort LEVEL', 'Effort for subagents, separate from the parent'],
       ['-- ARGS...', 'Pass remaining arguments to Codex'],
     ],
   },
@@ -625,6 +636,10 @@ export function parseClaudeVersion(text) {
 }
 
 export function claudeVersionNeedsUpgrade(installed, minimum = MIN_CLAUDE_CODE_VERSION) {
+  return versionNeedsUpgrade(installed, minimum);
+}
+
+export function versionNeedsUpgrade(installed, minimum) {
   return Boolean(installed && minimum && compareVersions(installed, minimum) < 0);
 }
 
@@ -649,13 +664,20 @@ export function readClaudeVersion(bin, binDir, options = {}) {
   }
 }
 
+const MINIMUM_VERSIONS = {
+  'claude-code': { minimum: MIN_CLAUDE_CODE_VERSION, label: 'Claude Code' },
+  // Below this, subagents are silently absent rather than broken.
+  codex: { minimum: MIN_CODEX_VERSION, label: 'Codex' },
+};
+
 async function ensureClaudeCompatible(agent, binDir) {
-  if (agent.id !== 'claude-code') return;
+  const requirement = MINIMUM_VERSIONS[agent.id];
+  if (!requirement) return;
   const version = readClaudeVersion(agent.bin, binDir);
-  if (!claudeVersionNeedsUpgrade(version)) return;
+  if (!versionNeedsUpgrade(version, requirement.minimum)) 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`,
+    `\n  Minimum supported ${requirement.label} version is ${requirement.minimum}. Your version is ${version}. Upgrade to get the best experience.\n`,
   );
   console.error(`  Upgrade it with:`);
   console.error(`    ${c.cyan}${agent.install}${c.reset}`);
@@ -884,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/profiles.js

@@ -144,6 +144,28 @@ const SETTINGS = {
     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',
@@ -305,6 +327,9 @@ const AGENT_SETTING_KEYS = {
     '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'],

package/bin/registry.generated.json

@@ -167,7 +167,7 @@
           "uninstall"
         ]
       },
-      "launch": "codex -c model={model} -c model_provider=subconscious -c web_search=disabled -c model_providers.subconscious.name=Subconscious -c model_providers.subconscious.base_url={baseUrlV1} -c model_providers.subconscious.wire_api=responses -c model_providers.subconscious.env_key=SUBCONSCIOUS_API_KEY -c model_providers.subconscious.stream_idle_timeout_ms=300000",
+      "launch": "codex -c model={model} -c model_provider=subconscious -c web_search=disabled -c model_providers.subconscious.name=Subconscious -c model_providers.subconscious.base_url={baseUrlV1} -c model_providers.subconscious.wire_api=responses -c model_providers.subconscious.env_key=SUBCONSCIOUS_API_KEY -c model_providers.subconscious.stream_idle_timeout_ms=900000",
       "env": {
         "SUBCONSCIOUS_API_KEY": "{apiKey}",
         "SUBCONSCIOUS_GATEWAY_URL": "{baseUrl}"

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/codex/hooks-lib.sh

@@ -61,6 +61,30 @@ EOF
   chmod 600 "$HOOKS_ENV_FILE"
 }
 
+# True when our hooks, hook script and env file are all already in place and
+# current, so there is nothing to write.
+#
+# This matters more than it looks. Codex asks the user to trust a hook before
+# it will run one, and it decides what is "new" from what is on disk. Rewriting
+# an identical hook on every single launch meant the trust prompt never went
+# away and the compaction hooks never actually ran - we were re-introducing
+# ourselves as a stranger several times a day.
+codex_hooks_current() {
+  [[ -f "$HOOKS_JSON" ]] || return 1
+  codex_hooks_json_valid || return 1
+  [[ -x "$HOOK_DST" ]] || return 1
+  [[ -f "${HOOK_SRC:-}" ]] || return 1
+  cmp -s "$HOOK_SRC" "$HOOK_DST" || return 1
+  [[ -f "$HOOKS_ENV_FILE" ]] || return 1
+  grep -q "SUBCONSCIOUS_GATEWAY_URL='${GATEWAY_URL%/}'" "$HOOKS_ENV_FILE" || return 1
+  grep -q "SUBCONSCIOUS_API_KEY='${API_KEY}'" "$HOOKS_ENV_FILE" || return 1
+  # Our entry present under both compaction events, and exactly once each.
+  jq -e --arg m "$MARKER" '
+    def ours: [ .[]?.hooks[]? | select((.command // "") | tostring | contains($m)) ] | length;
+    (.hooks.PreCompact | ours) == 1 and (.hooks.PostCompact | ours) == 1
+  ' "$HOOKS_JSON" >/dev/null 2>&1
+}
+
 # codex_ensure_hooks [strict|best-effort]
 codex_ensure_hooks() {
   local mode="${1:-strict}"
@@ -91,12 +115,18 @@ codex_ensure_hooks() {
   if [[ ! -f "$HOOKS_JSON" ]]; then
     printf '%s\n' '{"hooks":{}}' >"$HOOKS_JSON"
   fi
+  if codex_hooks_current; then
+    # Already installed and unchanged. Saying nothing is the point: a message
+    # on every launch trains the user to ignore it, and rewriting the file
+    # would reset the trust they have already granted.
+    return 0
+  fi
   codex_write_hook_script
   codex_write_hooks_env
   codex_strip_hook_entries
   codex_append_hook_groups
-  echo "Merged Subconscious Codex hooks into $HOOKS_JSON"
-  echo "Trust new hooks in Codex with /hooks (or --dangerously-bypass-hook-trust)."
+  echo "Installed Subconscious compaction hooks in $HOOKS_JSON"
+  echo "These do not run until you trust them: type /hooks inside Codex once."
 }
 
 codex_uninstall_hooks() {

package/bin/runbook/codex/install.sh

@@ -33,6 +33,16 @@ Usage:
 
 Merges Subconscious compaction hooks into ~/.codex/hooks.json. Does not write
 config.toml. Launch Codex with subc codex.
+
+The hooks report compaction start and end to the gateway, which is what lets a
+conversation's turns stay correlated across a compaction boundary.
+
+Codex will not run a hook until you trust it. After installing, type /hooks
+inside Codex once and approve them; until then they are present but inert.
+Non-interactive runs have nobody to ask, so `codex exec` can only run them with
+--dangerously-bypass-hook-trust, which is yours to opt into and is never passed
+for you. Fleet installs should ship the hooks through Codex's managed
+(MDM) configuration, which is trusted without prompting.
 EOF
 }