subconscious-cli 6.0.0 → 6.0.1

package/bin/windows/launch.js

@@ -2,10 +2,18 @@
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { claudeNativeLaunch } from './claude.js';
-import { buildOpenCodeConfig } from '../opencode-provider.js';
 import { modelSupportsVision } from '../model-capabilities.js';
-import { defaults, value, origin, modelIds, positiveInteger, parseOptions, writeJson } from './common.js';
+import { buildOpenCodeConfig } from '../opencode-provider.js';
+import { claudeNativeLaunch } from './claude.js';
+import {
+  defaults,
+  modelIds,
+  origin,
+  parseOptions,
+  positiveInteger,
+  value,
+  writeJson,
+} from './common.js';
 
 function connection(env, keyName) {
   return {
@@ -15,82 +23,236 @@ function connection(env, keyName) {
   };
 }
 
-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];
+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 };
+  const childEnv = {
+    ...env,
+    SUBCONSCIOUS_API_KEY: key,
+    SUBCONSCIOUS_GATEWAY_URL: base,
+  };
   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 } };
+    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,
+      },
+    };
   }
-  if (id === 'pi') return { command: 'pi', args: ['--provider', 'subconscious', '--model', model, ...argv], env: childEnv };
+  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');
+    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 }),
+      buildOpenCodeConfig({
+        baseUrl: base,
+        model,
+        modelIds: modelIds(env),
+        context,
+        output,
+      }),
     );
-    return { command: 'opencode', args: parseOptions(argv, {}).rest, env: childEnv };
+    return {
+      command: 'opencode',
+      args: parseOptions(argv, {}).rest,
+      env: childEnv,
+    };
   }
   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');
-    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'] } : {}),
-    })) };
+    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',
+    );
+    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'] }
+          : {}),
+      })),
+    };
     // Validate all flags before creating a temporary directory.
-    const threads = positiveInteger(value(env, 'MAX_CONCURRENT_SUBAGENTS', '4'), 'MAX_CONCURRENT_SUBAGENTS');
+    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,
+        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['--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 (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 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`;
+      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; }
+      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;
+    }
   }
   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 }); }
-  finally { await spec.cleanup?.(); }
+  try {
+    return await run(spec.command, spec.args, { env: spec.env });
+  } finally {
+    await spec.cleanup?.();
+  }
 }

package/bin/windows/pi-compaction.ts

@@ -1,29 +1,84 @@
 // Windows-only Pi extension. Loaded config is relative to this installed file.
-import { readFileSync } from 'node:fs';
+
 import { randomUUID } from 'node:crypto';
-import { fileURLToPath } from 'node:url';
+import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+type PiCompactEvent = {
+  reason?: unknown;
+  preparation?: { tokensBefore?: unknown };
+  fromExtension?: unknown;
+};
+
+type PiContext = {
+  sessionManager?: { getSessionId?: () => string | undefined };
+};
+
+type WindowsPiConfig = {
+  gatewayUrl?: string;
+  apiKey?: string;
+};
 
-export default function (pi: { on: (event: string, handler: (...args: any[]) => any) => void }) {
-  for (const [eventName, phase] of [['session_before_compact', 'start'], ['session_compact', 'end']]) {
-    pi.on(eventName, async (event: any, ctx: any) => {
+export default function (pi: {
+  on: (
+    event: string,
+    handler: (event: PiCompactEvent, ctx: PiContext) => Promise<void>,
+  ) => void;
+}) {
+  for (const [eventName, phase] of [
+    ['session_before_compact', 'start'],
+    ['session_compact', 'end'],
+  ] as const) {
+    pi.on(eventName, async (event, ctx) => {
       const session = ctx?.sessionManager?.getSessionId?.();
       if (!session) return;
       const controller = new AbortController();
       const timer = setTimeout(() => controller.abort(), 1500);
       try {
-        const config = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'subconscious-windows.json'), 'utf8'));
+        const config = JSON.parse(
+          readFileSync(
+            join(
+              dirname(fileURLToPath(import.meta.url)),
+              '..',
+              'subconscious-windows.json',
+            ),
+            'utf8',
+          ),
+        ) as WindowsPiConfig;
         const url = process.env.SUBCONSCIOUS_GATEWAY_URL || config.gatewayUrl;
         const key = process.env.SUBCONSCIOUS_API_KEY || config.apiKey;
         if (!url || !key) return;
-        const response = await fetch(`${url.replace(/\/+$/, '')}/v1/agent-hooks`, {
-          method: 'POST', headers: { 'content-type': 'application/json', authorization: `Bearer ${key}`, 'x-subconscious-client': 'pi' },
-          body: JSON.stringify({ event: 'conversation_compaction', conversation_id: session, phase, hook_event_name: eventName, dedupe_key: `${session}:${phase}:${randomUUID()}`, metadata: { reason: event?.reason, tokens_before: event?.preparation?.tokensBefore, from_extension: event?.fromExtension } }),
-          signal: controller.signal,
-        });
+        const response = await fetch(
+          `${url.replace(/\/+$/, '')}/v1/agent-hooks`,
+          {
+            method: 'POST',
+            headers: {
+              'content-type': 'application/json',
+              authorization: `Bearer ${key}`,
+              'x-subconscious-client': 'pi',
+            },
+            body: JSON.stringify({
+              event: 'conversation_compaction',
+              conversation_id: session,
+              phase,
+              hook_event_name: eventName,
+              dedupe_key: `${session}:${phase}:${randomUUID()}`,
+              metadata: {
+                reason: event?.reason,
+                tokens_before: event?.preparation?.tokensBefore,
+                from_extension: event?.fromExtension,
+              },
+            }),
+            signal: controller.signal,
+          },
+        );
         await response.body?.cancel();
-      } catch { /* observational: never cancel or replace compaction */ }
-      finally { clearTimeout(timer); }
+      } catch {
+        /* observational: never cancel or replace compaction */
+      } finally {
+        clearTimeout(timer);
+      }
     });
   }
 }