subconscious-cli 6.0.1 → 6.2.0

package/bin/windows/launch.js

@@ -2,256 +2,277 @@
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { modelSupportsVision } from '../model-capabilities.js';
-import { buildOpenCodeConfig } from '../opencode-provider.js';
-import { claudeNativeLaunch } from './claude.js';
+import { agentById, agentKeyName } from '../agent-data.js';
 import {
-  defaults,
-  modelIds,
-  origin,
-  parseOptions,
-  positiveInteger,
-  value,
-  writeJson,
-} from './common.js';
+  launchPlan,
+  resolveAgentEnv,
+  resolveInputs,
+  takeFlags,
+} from '../agent-launch.js';
+import { claudePickerSettings } from '../claude-picker.js';
+import { modelIds, positiveInteger } from '../launch-values.js';
+import { modelSupportsVision } from '../model-capabilities.js';
+import { defaults, origin, value, writeJson } from './common.js';
 
-function connection(env, keyName) {
+const PLANNED = new Set(['claude-code', 'pi', 'opencode']);
+
+// Windows trims a configured gateway to its origin and gives every agent but
+// Claude the gateway and key as SUBCONSCIOUS_*. Claude has always been given
+// the gateway as configured.
+function windowsEnv(id, env) {
+  const model = value(env, 'MODEL', defaults.model);
+  const gateway = value(env, 'GATEWAY_URL', defaults.baseUrl);
+  if (id === 'claude-code')
+    return { ...env, MODEL: model, GATEWAY_URL: gateway };
+  const keyName = agentKeyName(agentById(id));
   return {
-    model: value(env, 'MODEL', defaults.model),
-    base: origin(value(env, 'GATEWAY_URL', defaults.baseUrl)),
-    key: value(env, keyName, value(env, 'API_KEY')),
+    ...env,
+    MODEL: model,
+    GATEWAY_URL: origin(gateway),
+    SUBCONSCIOUS_API_KEY: value(env, keyName, value(env, 'API_KEY')),
+    SUBCONSCIOUS_GATEWAY_URL: origin(gateway),
   };
 }
 
-export async function windowsLaunch(
-  id,
-  argv,
-  env,
-  { tempRoot = os.tmpdir() } = {},
-) {
-  if (id === 'claude-code')
-    return { command: 'claude', ...claudeNativeLaunch(argv, env) };
-  const keyName = {
-    codex: 'CODEX_API_KEY',
-    opencode: 'OPENCODE_API_KEY',
-    pi: 'PI_API_KEY',
-    'subconscious-code': 'SC_API_KEY',
-    'deepseek-harness': 'DEEPSEEK_HARNESS_API_KEY',
-  }[id];
-  const { model, base, key } = connection(env, keyName);
-  const childEnv = {
-    ...env,
-    SUBCONSCIOUS_API_KEY: key,
-    SUBCONSCIOUS_GATEWAY_URL: base,
+function claudeLaunch(agent, argv, env) {
+  const settings =
+    value(env, 'SUBC_CLAUDE_SETTINGS') ||
+    JSON.stringify(claudePickerSettings([env.MODEL], env.MODEL));
+  const plan = launchPlan(agent, {
+    env: { ...env, SUBC_CLAUDE_SETTINGS: settings },
+    args: argv,
+  });
+  if (!plan.env.ANTHROPIC_BASE_URL || !plan.env.ANTHROPIC_AUTH_TOKEN) {
+    throw new Error(
+      'GATEWAY_URL and API_KEY are required to launch Claude Code',
+    );
+  }
+  positiveInteger(plan.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW, 'compact-window');
+  positiveInteger(
+    plan.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS,
+    'max-context-tokens',
+  );
+  return plan;
+}
+
+function plannedLaunch(agent, argv, env) {
+  const plan =
+    agent.id === 'claude-code'
+      ? claudeLaunch(agent, argv, env)
+      : launchPlan(agent, { env, args: argv });
+  return { command: plan.argv[0], args: plan.argv.slice(1), env: plan.env };
+}
+
+function codexCatalog(env, context, maxContext, compact) {
+  return {
+    models: modelIds(env).map((id) => ({
+      slug: id,
+      display_name: id,
+      description: `Subconscious model ${id}`,
+      context_window: context,
+      max_context_window: maxContext,
+      auto_compact_token_limit: compact,
+      effective_context_window_percent: 95,
+      supported_reasoning_levels: [],
+      shell_type: 'shell_command',
+      visibility: 'list',
+      supported_in_api: true,
+      priority: 0,
+      service_tiers: [
+        {
+          id: 'priority',
+          name: 'Priority',
+          description:
+            'Route requests through the configured priority service tier',
+        },
+      ],
+      availability_nux: null,
+      upgrade: null,
+      base_instructions: 'You are Codex, a coding agent.',
+      supports_reasoning_summaries: false,
+      support_verbosity: false,
+      default_verbosity: null,
+      apply_patch_tool_type: 'freeform',
+      truncation_policy: { mode: 'tokens', limit: 10000 },
+      supports_parallel_tool_calls: true,
+      experimental_supported_tools: [],
+      // Codex assumes ['text', 'image'] when the field is missing.
+      input_modalities: modelSupportsVision(id) ? ['text', 'image'] : ['text'],
+    })),
   };
-  if (id === 'subconscious-code') {
-    return {
-      command: 'marathon',
-      args: argv,
-      env: {
-        ...childEnv,
-        SC_API_KEY: key,
-        SC_BASE_URL: `${base}/v1`,
-        SC_DLR_URL: base,
-        SC_DLR_ENABLED: 'true',
-        SC_MODEL: model,
-      },
-    };
+}
+
+// --subagents is Windows-only: it runs a pinned older Codex instead.
+function splitSubagents(argv) {
+  const boundary = argv.indexOf('--');
+  const head = boundary < 0 ? argv : argv.slice(0, boundary);
+  const tail = boundary < 0 ? [] : argv.slice(boundary);
+  for (const arg of head)
+    if (arg.startsWith('--subagents='))
+      throw new Error('--subagents does not take a value');
+  return {
+    subagents: head.includes('--subagents'),
+    words: [...head.filter((arg) => arg !== '--subagents'), ...tail],
+  };
+}
+
+function codexConfig(env, file) {
+  const config = {
+    model: env.MODEL,
+    model_provider: 'subconscious',
+    model_catalog_json: file,
+    model_reasoning_effort: env.CODEX_REASONING_EFFORT,
+    web_search: 'disabled',
+    'model_providers.subconscious.name': 'Subconscious',
+    'model_providers.subconscious.base_url': `${env.GATEWAY_URL}/v1`,
+    'model_providers.subconscious.wire_api': 'responses',
+    'model_providers.subconscious.env_key': 'SUBCONSCIOUS_API_KEY',
+    'model_providers.subconscious.stream_idle_timeout_ms': Number(
+      env.CODEX_STREAM_IDLE_TIMEOUT_MS,
+    ),
+  };
+  if (env.CODEX_EXTERNAL_TOOLS !== 'true') {
+    Object.assign(config, {
+      'features.apps': false,
+      'features.plugins': false,
+      'apps._default.enabled': false,
+    });
   }
-  if (id === 'pi')
-    return {
-      command: 'pi',
-      args: ['--provider', 'subconscious', '--model', model, ...argv],
-      env: childEnv,
-    };
-  if (id === 'opencode') {
-    const context = positiveInteger(
-      value(env, 'OPENCODE_CONTEXT_LIMIT', '5000000'),
-      'OPENCODE_CONTEXT_LIMIT',
-    );
-    const output = positiveInteger(
-      value(env, 'OPENCODE_OUTPUT_LIMIT', '65536'),
-      'OPENCODE_OUTPUT_LIMIT',
-    );
-    childEnv.OPENCODE_CONFIG_CONTENT = JSON.stringify(
-      buildOpenCodeConfig({
-        baseUrl: base,
-        model,
-        modelIds: modelIds(env),
-        context,
-        output,
-      }),
-    );
+  return config;
+}
+
+async function codexLaunch(agent, argv, env, tempRoot) {
+  const { subagents, words } = splitSubagents(argv);
+  // Windows Codex sets no subagent effort, and uses the subagent cap only
+  // with --subagents; otherwise those flags still reach Codex unchanged.
+  const { values, rest } = takeFlags(agent, words, {
+    skip: [
+      'CODEX_SUBAGENT_REASONING_EFFORT',
+      ...(subagents ? [] : ['MAX_CONCURRENT_SUBAGENTS']),
+    ],
+  });
+  const resolved = resolveAgentEnv(agent, resolveInputs(agent, env, values));
+  const context = positiveInteger(
+    resolved.CODEX_CONTEXT_WINDOW,
+    'context-window',
+  );
+  const maxContext = positiveInteger(
+    resolved.CODEX_MAX_CONTEXT_WINDOW,
+    'max-context-window',
+  );
+  const compact = positiveInteger(
+    resolved.CODEX_AUTO_COMPACT_TOKEN_LIMIT,
+    'auto-compact-token-limit',
+  );
+  const catalog = codexCatalog(resolved, context, maxContext, compact);
+  // Validate all flags before creating a temporary directory.
+  positiveInteger(resolved.CODEX_STREAM_IDLE_TIMEOUT_MS, 'stream-idle-timeout');
+  const threads = positiveInteger(
+    resolved.MAX_CONCURRENT_SUBAGENTS,
+    'MAX_CONCURRENT_SUBAGENTS',
+  );
+  const dir = await fs.mkdtemp(path.join(tempRoot, 'subc-codex-'));
+  const cleanup = () => fs.rm(dir, { recursive: true, force: true });
+  try {
+    const file = path.join(dir, 'models.json');
+    await writeJson(file, catalog);
+    const config = codexConfig(resolved, file);
+    if (subagents)
+      Object.assign(config, {
+        'features.multi_agent': true,
+        'agents.max_threads': threads,
+        'agents.max_depth': 1,
+        'agents.interrupt_message': true,
+      });
+    const args = Object.entries(config).flatMap(([k, v]) => [
+      '-c',
+      `${k}=${JSON.stringify(v)}`,
+    ]);
     return {
-      command: 'opencode',
-      args: parseOptions(argv, {}).rest,
-      env: childEnv,
+      command: subagents ? 'npx' : 'codex',
+      args: [
+        ...(subagents ? ['-y', '@openai/codex@0.132.0'] : []),
+        ...args,
+        ...rest,
+      ],
+      env: resolved,
+      cleanup,
     };
+  } catch (error) {
+    await cleanup();
+    throw error;
   }
-  if (id === 'codex') {
-    const { options: opts, rest } = parseOptions(argv, {
-      '--context-window': 1,
-      '--max-context-window': 1,
-      '--auto-compact-token-limit': 1,
-      '--reasoning-effort': 1,
-      '--subagents': true,
-      '--external-tools': true,
-    });
-    const context = positiveInteger(
-      opts['--context-window'] || value(env, 'CODEX_CONTEXT_WINDOW', '5000000'),
-      'context-window',
-    );
-    const maxContext = positiveInteger(
-      opts['--max-context-window'] ||
-        value(env, 'CODEX_MAX_CONTEXT_WINDOW', String(context)),
-      'max-context-window',
-    );
-    const compact = positiveInteger(
-      opts['--auto-compact-token-limit'] ||
-        value(env, 'CODEX_AUTO_COMPACT_TOKEN_LIMIT', '4500000'),
-      'auto-compact-token-limit',
+}
+
+function dshOverlay(env, context, maxTokens) {
+  const models = modelIds(env)
+    .map(
+      (id) =>
+        `          - id: '${id}'\n            name: '${id}'\n${modelSupportsVision(id) ? '            input: [text, image]\n' : ''}            contextWindow: ${context}\n            maxTokens: ${maxTokens}`,
+    )
+    .join('\n');
+  return `- id: llm-pi-ai\n  config:\n    providers:\n      subconscious:\n        apiKeyEnv: SUBCONSCIOUS_API_KEY\n        displayName: Subconscious Gateway\n        api: openai-completions\n        baseURL: !!js process.env.SUBCONSCIOUS_DSH_BASE_URL\n        headers:\n          x-subconscious-client: deepseek-harness\n        compat:\n          supportsDeveloperRole: false\n          maxTokensField: max_tokens\n        defaultContextWindow: ${context}\n        defaultMaxTokens: ${maxTokens}\n        models:\n${models}\n- id: agent-default-model\n  config:\n    provider: subconscious\n    model: '${env.MODEL}'\n`;
+}
+
+async function dshLaunch(agent, argv, env, tempRoot) {
+  const headless = argv[0] === 'headless';
+  const plan = launchPlan(agent, {
+    env,
+    args: headless ? argv.slice(2) : argv,
+    prompt: headless ? argv[1] : undefined,
+  });
+  const context = positiveInteger(
+    plan.env.DEEPSEEK_HARNESS_CONTEXT_WINDOW,
+    'DEEPSEEK_HARNESS_CONTEXT_WINDOW',
+  );
+  const maxTokens = positiveInteger(
+    plan.env.DEEPSEEK_HARNESS_MAX_TOKENS,
+    'DEEPSEEK_HARNESS_MAX_TOKENS',
+  );
+  const text = dshOverlay(plan.env, context, maxTokens);
+  const dir = await fs.mkdtemp(path.join(tempRoot, 'subc-dsh-'));
+  const cleanup = () => fs.rm(dir, { recursive: true, force: true });
+  try {
+    const file = path.join(dir, 'subconscious.cordis.yml');
+    await fs.writeFile(file, text, { mode: 0o600, flag: 'wx' });
+    const argvWithFile = plan.argv.map((word, index) =>
+      index < plan.templateWords ? word.replaceAll('{tempFile}', file) : word,
     );
-    const reasoning =
-      opts['--reasoning-effort'] || value(env, 'CODEX_REASONING_EFFORT', 'max');
-    if (!['none', 'low', 'medium', 'high', 'max'].includes(reasoning))
-      throw new Error(
-        'reasoning-effort must be none, low, medium, high, or max',
-      );
-    const catalog = {
-      models: modelIds(env).map((id) => ({
-        slug: id,
-        display_name: id,
-        description: `Subconscious model ${id}`,
-        context_window: context,
-        max_context_window: maxContext,
-        auto_compact_token_limit: compact,
-        effective_context_window_percent: 95,
-        supported_reasoning_levels: [],
-        shell_type: 'shell_command',
-        visibility: 'list',
-        supported_in_api: true,
-        priority: 0,
-        service_tiers: [
-          {
-            id: 'priority',
-            name: 'Priority',
-            description:
-              'Route requests through the configured priority service tier',
-          },
-        ],
-        availability_nux: null,
-        upgrade: null,
-        base_instructions: 'You are Codex, a coding agent.',
-        supports_reasoning_summaries: false,
-        support_verbosity: false,
-        default_verbosity: null,
-        apply_patch_tool_type: 'freeform',
-        truncation_policy: { mode: 'tokens', limit: 10000 },
-        supports_parallel_tool_calls: true,
-        experimental_supported_tools: [],
-        ...(modelSupportsVision(id)
-          ? { input_modalities: ['text', 'image'] }
-          : {}),
-      })),
+    return {
+      command: argvWithFile[0],
+      args: argvWithFile.slice(1),
+      env: plan.env,
+      ...(plan.input === undefined ? {} : { input: plan.input }),
+      cleanup,
     };
-    // Validate all flags before creating a temporary directory.
-    const threads = positiveInteger(
-      value(env, 'MAX_CONCURRENT_SUBAGENTS', '4'),
-      'MAX_CONCURRENT_SUBAGENTS',
-    );
-    const dir = await fs.mkdtemp(path.join(tempRoot, 'subc-codex-'));
-    const cleanup = () => fs.rm(dir, { recursive: true, force: true });
-    try {
-      const file = path.join(dir, 'models.json');
-      await writeJson(file, catalog);
-      const config = {
-        model,
-        model_provider: 'subconscious',
-        model_catalog_json: file,
-        model_reasoning_effort: reasoning,
-        web_search: 'disabled',
-        'model_providers.subconscious.name': 'Subconscious',
-        'model_providers.subconscious.base_url': `${base}/v1`,
-        'model_providers.subconscious.wire_api': 'responses',
-        'model_providers.subconscious.env_key': 'SUBCONSCIOUS_API_KEY',
-        'model_providers.subconscious.stream_idle_timeout_ms': 300000,
-      };
-      if (
-        !opts['--external-tools'] &&
-        value(env, 'CODEX_EXTERNAL_TOOLS', 'false') !== 'true'
-      ) {
-        Object.assign(config, {
-          'features.apps': false,
-          'features.plugins': false,
-          'apps._default.enabled': false,
-        });
-      }
-      if (opts['--subagents'])
-        Object.assign(config, {
-          'features.multi_agent': true,
-          'agents.max_threads': threads,
-          'agents.max_depth': 1,
-          'agents.interrupt_message': true,
-        });
-      const args = Object.entries(config).flatMap(([k, v]) => [
-        '-c',
-        `${k}=${JSON.stringify(v)}`,
-      ]);
-      return {
-        command: opts['--subagents'] ? 'npx' : 'codex',
-        args: [
-          ...(opts['--subagents'] ? ['-y', '@openai/codex@0.132.0'] : []),
-          ...args,
-          ...rest,
-        ],
-        env: childEnv,
-        cleanup,
-      };
-    } catch (error) {
-      await cleanup();
-      throw error;
-    }
-  }
-  if (id === 'deepseek-harness') {
-    const context = positiveInteger(
-      value(env, 'DEEPSEEK_HARNESS_CONTEXT_WINDOW', '5000000'),
-      'DEEPSEEK_HARNESS_CONTEXT_WINDOW',
-    );
-    const maxTokens = positiveInteger(
-      value(env, 'DEEPSEEK_HARNESS_MAX_TOKENS', '65536'),
-      'DEEPSEEK_HARNESS_MAX_TOKENS',
-    );
-    const models = modelIds(env);
-    const dir = await fs.mkdtemp(path.join(tempRoot, 'subc-dsh-'));
-    const cleanup = () => fs.rm(dir, { recursive: true, force: true });
-    try {
-      const file = path.join(dir, 'subconscious.cordis.yml');
-      const text = `- id: llm-pi-ai\n  config:\n    providers:\n      subconscious:\n        apiKeyEnv: SUBCONSCIOUS_API_KEY\n        displayName: Subconscious Gateway\n        api: openai-completions\n        baseURL: !!js process.env.SUBCONSCIOUS_DSH_BASE_URL\n        headers:\n          x-subconscious-client: deepseek-harness\n        compat:\n          supportsDeveloperRole: false\n          maxTokensField: max_tokens\n        defaultContextWindow: ${context}\n        defaultMaxTokens: ${maxTokens}\n        models:\n${models.map((id) => `          - id: '${id}'\n            name: '${id}'\n${modelSupportsVision(id) ? '            input: [text, image]\n' : ''}            contextWindow: ${context}\n            maxTokens: ${maxTokens}`).join('\n')}\n- id: agent-default-model\n  config:\n    provider: subconscious\n    model: '${model}'\n`;
-      await fs.writeFile(file, text, { mode: 0o600, flag: 'wx' });
-      const mode = ['web', 'headless'].includes(argv[0]) ? argv[0] : 'web';
-      const rest = ['web', 'headless'].includes(argv[0]) ? argv.slice(1) : argv;
-      return {
-        command: 'dsh',
-        args: [
-          ...(mode === 'web' ? ['web'] : ['--profile', 'headless']),
-          '--patch',
-          file,
-          ...rest,
-        ],
-        env: { ...childEnv, SUBCONSCIOUS_DSH_BASE_URL: `${base}/v1` },
-        cleanup,
-      };
-    } catch (error) {
-      await cleanup();
-      throw error;
-    }
+  } catch (error) {
+    await cleanup();
+    throw error;
   }
+}
+
+export async function windowsLaunch(
+  id,
+  argv,
+  env,
+  { tempRoot = os.tmpdir() } = {},
+) {
+  const agent = agentById(id);
+  const launchEnv = windowsEnv(id, env);
+  if (PLANNED.has(id)) return plannedLaunch(agent, argv, launchEnv);
+  if (id === 'codex') return codexLaunch(agent, argv, launchEnv, tempRoot);
+  if (id === 'deepseek-harness')
+    return dshLaunch(agent, argv, launchEnv, tempRoot);
   throw new Error(`No native Windows launcher is available for ${id}`);
 }
 
 export async function executeWindowsLaunch(spec, run) {
   try {
-    return await run(spec.command, spec.args, { env: spec.env });
+    const options =
+      spec.input === undefined
+        ? { env: spec.env }
+        : { env: spec.env, input: spec.input };
+    return await run(spec.command, spec.args, options);
   } finally {
     await spec.cleanup?.();
   }

package/bin/windows/process.js

@@ -207,8 +207,19 @@ export function spawnWindowsSync(command, args, options = {}) {
 }
 
 export function runWindows(command, args, options = {}) {
+  const { input, ...spawnOptions } = options;
   return new Promise((resolve, reject) => {
-    const child = spawnWindows(command, args, { stdio: 'inherit', ...options });
+    const child = spawnWindows(command, args, {
+      stdio: input === undefined ? 'inherit' : ['pipe', 'inherit', 'inherit'],
+      ...spawnOptions,
+    });
+    if (input !== undefined) {
+      // EPIPE means the agent exited without reading; its exit code reports why.
+      child.stdin.on('error', (error) => {
+        if (error.code !== 'EPIPE') reject(error);
+      });
+      child.stdin.end(input);
+    }
     const forward = (signal) => {
       try {
         child.kill(signal);

package/bin/windows/setup.js

@@ -1,6 +1,8 @@
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
+import { agentById } from '../agent-data.js';
+import { resolveInputs } from '../agent-launch.js';
 import { modelSupportsVision } from '../model-capabilities.js';
 import {
   defaults,
@@ -118,10 +120,16 @@ export async function windowsSetup(
   if (id === 'pi')
     Object.assign(schema, { '--context-window': 1, '--max-tokens': 1 });
   const { options } = parseOptions(argv, schema, { strict: true });
-  const env = {
-    ...environment,
-    ...(options['--model'] ? { MODEL: options['--model'] } : {}),
-  };
+  const agent = agentById(id);
+  const env = resolveInputs(
+    agent,
+    {
+      ...environment,
+      ...(options['--model'] ? { MODEL: options['--model'] } : {}),
+    },
+    {},
+    { strict: false },
+  );
   const gatewayUrl = origin(
     options['--gateway-url'] || value(env, 'GATEWAY_URL', defaults.baseUrl),
   );
@@ -179,12 +187,12 @@ export async function windowsSetup(
       if (installing) {
         const context = positiveInteger(
           options['--max-input-tokens'] ||
-            value(env, 'COPILOT_MAX_INPUT_TOKENS', '5000000'),
+            value(env, 'COPILOT_MAX_INPUT_TOKENS'),
           'max-input-tokens',
         );
         const maxTokens = positiveInteger(
           options['--max-output-tokens'] ||
-            value(env, 'COPILOT_MAX_OUTPUT_TOKENS', '65536'),
+            value(env, 'COPILOT_MAX_OUTPUT_TOKENS'),
           'max-output-tokens',
         );
         providers.push({
@@ -262,15 +270,20 @@ export async function windowsSetup(
       'extensions',
       'subconscious-compaction.ts',
     );
+    // Keeps requests at the newest 30 images; same files as the shell runbook.
+    const imageWindow = path.join(
+      dir,
+      'extensions',
+      'subconscious-image-window',
+    );
     const config = path.join(dir, 'subconscious-windows.json');
     if (installing) {
       const context = positiveInteger(
-        options['--context-window'] ||
-          value(env, 'PI_CONTEXT_WINDOW', '5000000'),
+        options['--context-window'] || value(env, 'PI_CONTEXT_WINDOW'),
         'context-window',
       );
       const maxTokens = positiveInteger(
-        options['--max-tokens'] || value(env, 'PI_MAX_TOKENS', '65536'),
+        options['--max-tokens'] || value(env, 'PI_MAX_TOKENS'),
         'max-tokens',
       );
       providers.subconscious = {
@@ -294,10 +307,17 @@ export async function windowsSetup(
         new URL('./pi-compaction.ts', import.meta.url),
         extension,
       );
+      await fs.rm(imageWindow, { recursive: true, force: true });
+      await fs.cp(
+        new URL('../runbook/image-window', import.meta.url),
+        imageWindow,
+        { recursive: true },
+      );
       await writeJson(config, { gatewayUrl, apiKey });
     } else {
       delete providers.subconscious;
       await fs.rm(extension, { force: true });
+      await fs.rm(imageWindow, { recursive: true, force: true });
       await fs.rm(config, { force: true });
     }
     if (installing || (await exists(modelsFile)))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "subconscious-cli",
-  "version": "6.0.1",
+  "version": "6.2.0",
   "description": "CLI for Subconscious — run Subconscious Code, Claude Code, Codex, OpenCode, DeepSeek Harness, Cursor, Copilot, and Pi",
   "bin": {
     "subc": "bin/cli.js"
@@ -9,9 +9,8 @@
     "build:tui": "node scripts/build-tui.js",
     "build:tui:host": "node scripts/build-tui.js --host",
     "test": "node --test",
-    "test:windows": "node --test test/windows.test.js test/models.test.js test/model-capabilities.test.js test/auth.test.js test/tui.test.js test/update-check.test.js test/sessions.test.js test/branding.test.js test/claude-version.test.js test/usage.test.js test/feedback.test.js test/release.test.js test/github-govuln-issue.test.js",
+    "test:windows": "node --test test/windows.test.js test/models.test.js test/model-capabilities.test.js test/auth.test.js test/tui.test.js test/update-check.test.js test/sessions.test.js test/branding.test.js test/claude-version.test.js test/usage.test.js test/feedback.test.js test/release.test.js test/github-govuln-issue.test.js test/harness-manifest.test.js test/agent-files.test.js test/agent-launch.test.js test/agent-install-policy.test.js",
     "test:tui": "go -C tui test ./...",
-    "generate": "node scripts/generate-agents.js",
     "lint": "biome ci .",
     "format": "biome check --write .",
     "typecheck": "tsc --noEmit",
@@ -38,7 +37,6 @@
     "authentication",
     "profiles",
     "coding-agent",
-    "subconscious-code",
     "claude-code",
     "opencode",
     "codex",