subconscious-cli 5.0.3 → 6.0.1

package/bin/windows/install.js

@@ -1,26 +1,38 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { createHash, randomUUID } from 'node:crypto';
-import { readFileSync } from 'node:fs';
 import { powershellCommand, runWindows } from './process.js';
 
-const registry = JSON.parse(readFileSync(new URL('../registry.generated.json', import.meta.url), 'utf8'));
+const registry = JSON.parse(
+  readFileSync(new URL('../registry.generated.json', import.meta.url), 'utf8'),
+);
 const repository = 'subconscious-systems/subconscious-code';
 
 function npmInstall(command) {
-  const match = /^npm (?:i|install) -g ([@a-zA-Z0-9/._-]+)$/.exec(command || '');
+  const match = /^npm (?:i|install) -g ([@a-zA-Z0-9/._-]+)$/.exec(
+    command || '',
+  );
   return match ? { command: 'npm', args: ['install', '-g', match[1]] } : null;
 }
 
 export function windowsInstallSpec(id, env = process.env) {
-  const install = registry.agents.find(agent => agent.id === id)?.install;
+  const install = registry.agents.find((agent) => agent.id === id)?.install;
   const command = typeof install === 'object' ? install.win32 : undefined;
-  if (id === 'subconscious-code') return { nativeRelease: true, display: 'subc marathon install' };
+  if (id === 'subconscious-code')
+    return { nativeRelease: true, display: 'subc marathon install' };
   if (!command) return null; // Never fall back to a Linux installer.
   if (id === 'claude-code') {
-    const primary = powershellCommand("$ErrorActionPreference = 'Stop'; Invoke-RestMethod 'https://claude.ai/install.ps1' | Invoke-Expression; if (-not $?) { exit 1 }", env);
-    return { ...primary, display: command, fallback: npmInstall(install.fallback) };
+    const primary = powershellCommand(
+      "$ErrorActionPreference = 'Stop'; Invoke-RestMethod 'https://claude.ai/install.ps1' | Invoke-Expression; if (-not $?) { exit 1 }",
+      env,
+    );
+    return {
+      ...primary,
+      display: command,
+      fallback: npmInstall(install.fallback),
+    };
   }
   const spec = npmInstall(command);
   if (!spec) throw new Error(`No safe Windows installer is defined for ${id}`);
@@ -28,38 +40,97 @@ export function windowsInstallSpec(id, env = process.env) {
 }
 
 export function windowsReleaseAsset(release, arch = process.arch) {
-  const target = { x64: 'x86_64-pc-windows-msvc', arm64: 'aarch64-pc-windows-msvc' }[arch];
-  if (!target) throw new Error(`Subconscious Code does not support Windows architecture ${arch}`);
+  const target = {
+    x64: 'x86_64-pc-windows-msvc',
+    arm64: 'aarch64-pc-windows-msvc',
+  }[arch];
+  if (!target)
+    throw new Error(
+      `Subconscious Code does not support Windows architecture ${arch}`,
+    );
   // Pinned older releases are installed under the new executable name too.
   // Never resolve or overwrite Windows' own sc.exe.
-  const names = [`marathon-${target}.zip`, `marathon-${target}.exe`, `sc-${target}.zip`, `sc-${target}.exe`];
-  const asset = names.map(name => release.assets?.find(asset => asset.name === name)).find(Boolean);
-  if (!asset) throw new Error(`Marathon ${release.tag_name || 'latest'} has no published native Windows ${arch} binary for subc marathon install.`);
-  const checksum = release.assets.find(candidate => candidate.name === `${asset.name}.sha256`);
-  if (!checksum) throw new Error(`The Windows release is missing ${asset.name}.sha256; refusing an unverified installation.`);
+  const names = [
+    `marathon-${target}.zip`,
+    `marathon-${target}.exe`,
+    `sc-${target}.zip`,
+    `sc-${target}.exe`,
+  ];
+  const asset = names
+    .map((name) => release.assets?.find((asset) => asset.name === name))
+    .find(Boolean);
+  if (!asset)
+    throw new Error(
+      `Marathon ${release.tag_name || 'latest'} has no published native Windows ${arch} binary for subc marathon install.`,
+    );
+  const checksum = release.assets.find(
+    (candidate) => candidate.name === `${asset.name}.sha256`,
+  );
+  if (!checksum)
+    throw new Error(
+      `The Windows release is missing ${asset.name}.sha256; refusing an unverified installation.`,
+    );
   return { asset, checksum };
 }
 
-export async function installWindowsSC(env, { fetchImpl = fetch, run = runWindows, home = os.homedir(), arch = process.arch, log = console.log } = {}) {
+export async function installWindowsSC(
+  env,
+  {
+    fetchImpl = fetch,
+    run = runWindows,
+    home = os.homedir(),
+    arch = process.arch,
+    log = console.log,
+  } = {},
+) {
   const version = env.SC_CODE_VERSION?.replace(/^v/, '');
-  const endpoint = version ? `tags/${encodeURIComponent('v' + version)}` : 'latest';
-  const response = await fetchImpl(`https://api.github.com/repos/${repository}/releases/${endpoint}`, { headers: { Accept: 'application/vnd.github+json' }, signal: AbortSignal.timeout(15000) });
-  if (!response.ok) throw new Error(`Could not find a Subconscious Code release (HTTP ${response.status}).`);
+  const endpoint = version
+    ? `tags/${encodeURIComponent(`v${version}`)}`
+    : 'latest';
+  const response = await fetchImpl(
+    `https://api.github.com/repos/${repository}/releases/${endpoint}`,
+    {
+      headers: { Accept: 'application/vnd.github+json' },
+      signal: AbortSignal.timeout(15000),
+    },
+  );
+  if (!response.ok)
+    throw new Error(
+      `Could not find a Subconscious Code release (HTTP ${response.status}).`,
+    );
   const release = await response.json();
   const { asset, checksum } = windowsReleaseAsset(release, arch);
-  const download = async asset => {
+  const download = async (asset) => {
     const url = new URL(asset.browser_download_url);
-    if (url.origin !== 'https://github.com' || !url.pathname.startsWith(`/${repository}/releases/download/`)) throw new Error('Unexpected release download URL');
-    const response = await fetchImpl(url.href, { signal: AbortSignal.timeout(120000) });
-    if (!response.ok) throw new Error(`Download failed (HTTP ${response.status}): ${asset.name}`);
+    if (
+      url.origin !== 'https://github.com' ||
+      !url.pathname.startsWith(`/${repository}/releases/download/`)
+    )
+      throw new Error('Unexpected release download URL');
+    const response = await fetchImpl(url.href, {
+      signal: AbortSignal.timeout(120000),
+    });
+    if (!response.ok)
+      throw new Error(
+        `Download failed (HTTP ${response.status}): ${asset.name}`,
+      );
     return Buffer.from(await response.arrayBuffer());
   };
   log(`Downloading Marathon ${release.tag_name} for Windows ${arch}...`);
-  const [binary, checksumText] = await Promise.all([download(asset), download(checksum)]);
+  const [binary, checksumText] = await Promise.all([
+    download(asset),
+    download(checksum),
+  ]);
   const expected = checksumText.toString('utf8').trim().split(/\s+/)[0];
-  if (!/^[a-f0-9]{64}$/i.test(expected) || createHash('sha256').update(binary).digest('hex') !== expected.toLowerCase()) throw new Error('Subconscious Code checksum verification failed');
+  if (
+    !/^[a-f0-9]{64}$/i.test(expected) ||
+    createHash('sha256').update(binary).digest('hex') !== expected.toLowerCase()
+  )
+    throw new Error('Subconscious Code checksum verification failed');
   const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'subc-sc-install-'));
-  const installDir = path.resolve(env.SC_INSTALL_DIR || path.join(home, '.local', 'bin'));
+  const installDir = path.resolve(
+    env.SC_INSTALL_DIR || path.join(home, '.local', 'bin'),
+  );
   const destination = path.join(installDir, 'marathon.exe');
   const staging = path.join(installDir, `marathon-${randomUUID()}.tmp`);
   try {
@@ -68,11 +139,24 @@ export async function installWindowsSC(env, { fetchImpl = fetch, run = runWindow
       const archive = path.join(dir, 'release.zip');
       await fs.writeFile(archive, binary, { flag: 'wx' });
       // Extract only the exact root executable. No archive-controlled paths.
-      const executable = asset.name.startsWith('marathon-') ? 'marathon.exe' : 'sc.exe';
-      const spec = powershellCommand("$ErrorActionPreference = 'Stop'; Add-Type -AssemblyName System.IO.Compression.FileSystem; $z = [IO.Compression.ZipFile]::OpenRead($env:SUBC_ARCHIVE); try { $e = $z.GetEntry($env:SUBC_EXECUTABLE); if ($null -eq $e) { throw 'Archive has no expected root executable' }; [IO.Compression.ZipFileExtensions]::ExtractToFile($e, $env:SUBC_EXTRACTED, $false) } finally { $z.Dispose() }", { ...env, SUBC_ARCHIVE: archive, SUBC_EXTRACTED: extracted, SUBC_EXECUTABLE: executable });
-      if (await run(spec.command, spec.args, { env: spec.env })) throw new Error('Could not extract the Windows release');
+      const executable = asset.name.startsWith('marathon-')
+        ? 'marathon.exe'
+        : 'sc.exe';
+      const spec = powershellCommand(
+        "$ErrorActionPreference = 'Stop'; Add-Type -AssemblyName System.IO.Compression.FileSystem; $z = [IO.Compression.ZipFile]::OpenRead($env:SUBC_ARCHIVE); try { $e = $z.GetEntry($env:SUBC_EXECUTABLE); if ($null -eq $e) { throw 'Archive has no expected root executable' }; [IO.Compression.ZipFileExtensions]::ExtractToFile($e, $env:SUBC_EXTRACTED, $false) } finally { $z.Dispose() }",
+        {
+          ...env,
+          SUBC_ARCHIVE: archive,
+          SUBC_EXTRACTED: extracted,
+          SUBC_EXECUTABLE: executable,
+        },
+      );
+      if (await run(spec.command, spec.args, { env: spec.env }))
+        throw new Error('Could not extract the Windows release');
     } else await fs.writeFile(extracted, binary, { flag: 'wx' });
-    const magic = (await fs.readFile(extracted)).subarray(0, 2).toString('ascii');
+    const magic = (await fs.readFile(extracted))
+      .subarray(0, 2)
+      .toString('ascii');
     if (magic !== 'MZ') throw new Error('Release is not a Windows executable');
     await fs.mkdir(installDir, { recursive: true });
     await fs.copyFile(extracted, staging);
@@ -90,8 +174,12 @@ export async function installWindowsAgent(id, env, run = runWindows) {
   if (!spec) throw new Error('Install this agent separately, then rerun subc.');
   if (spec.nativeRelease) return installWindowsSC(env, { run });
   let code;
-  try { code = await run(spec.command, spec.args, { env: spec.env || env }); }
-  catch (error) { if (!spec.fallback) throw error; code = 1; }
+  try {
+    code = await run(spec.command, spec.args, { env: spec.env || env });
+  } catch (error) {
+    if (!spec.fallback) throw error;
+    code = 1;
+  }
   if (code && spec.fallback) {
     console.error('Native installer failed; trying the npm package.');
     code = await run(spec.fallback.command, spec.fallback.args, { env });

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);
+      }
     });
   }
 }