subconscious-cli 4.0.18 → 4.1.0

package/bin/update-check.js

@@ -1,16 +1,69 @@
 import fs from 'node:fs/promises';
 import { spawn } from 'node:child_process';
+import { spawnWindows } from './windows/process.js';
 import readline from 'node:readline';
 import { fileURLToPath } from 'node:url';
 import { LOGO_ART_SMALL_LINES } from './branding.js';
 import { c, colorEnabled } from './colors.js';
-import { detectInstallCommand } from './upgrade.js';
 
 export const PACKAGE_NAME = 'subconscious-cli';
 export const UPDATE_CHECK_TIMEOUT_MS = 1500;
 const UPDATE_ACTIONS = ['Update now', 'Skip for now'];
 const UPDATE_LOGO = LOGO_ART_SMALL_LINES;
 
+function shellQuote(value) {
+  const text = String(value);
+  return /^[-/@A-Za-z0-9._:]+$/.test(text)
+    ? text
+    : `'${text.replaceAll("'", `'"'"'`)}'`;
+}
+
+export function detectInstallTarget(
+  here = fileURLToPath(import.meta.url),
+  platform = process.platform,
+) {
+  const normalized = here.replace(/\\/g, '/');
+  if (normalized.includes('/.pnpm/') || normalized.includes('/pnpm/global/')) {
+    return {
+      command: 'pnpm',
+      args: ['add', '-g', `${PACKAGE_NAME}@latest`],
+      display: `pnpm add -g ${PACKAGE_NAME}@latest`,
+    };
+  }
+  if (normalized.includes('/.yarn/') || normalized.includes('/yarn/global/')) {
+    return {
+      command: 'yarn',
+      args: ['global', 'add', `${PACKAGE_NAME}@latest`],
+      display: `yarn global add ${PACKAGE_NAME}@latest`,
+    };
+  }
+  if (normalized.includes('/.bun/install/global/')) {
+    return {
+      command: 'bun',
+      args: ['add', '-g', `${PACKAGE_NAME}@latest`],
+      display: `bun add -g ${PACKAGE_NAME}@latest`,
+    };
+  }
+
+  const marker = `/lib/node_modules/${PACKAGE_NAME}/`;
+  let prefix = normalized.includes(marker) ? normalized.slice(0, normalized.indexOf(marker)) : '';
+  if (!prefix && platform === 'win32') {
+    const windowsMarker = `/node_modules/${PACKAGE_NAME}/`;
+    if (normalized.includes(windowsMarker)) {
+      prefix = normalized.slice(0, normalized.indexOf(windowsMarker));
+    }
+  }
+  const args = ['install', '-g'];
+  if (prefix) args.push('--prefix', prefix);
+  args.push(`${PACKAGE_NAME}@latest`);
+  return {
+    command: 'npm',
+    args,
+    display: ['npm', ...args].map(platform === 'win32' ? value => /^[-/@A-Za-z0-9._:]+$/.test(value) ? value : `"${value}"` : shellQuote).join(' '),
+    prefix,
+  };
+}
+
 function parseVersion(version) {
   const match = String(version)
     .trim()
@@ -123,13 +176,8 @@ export function renderUpdateNotice(installedVersion, latestVersion) {
   ].join('\n');
 }
 
-export function resolveInstallCommand(here = fileURLToPath(import.meta.url)) {
-  return detectInstallCommand(here);
-}
-
 export function renderUpdateOptions(selectedIndex = 0, versions = {}) {
-  const installCommand =
-    versions.installCommand || `npm install -g ${PACKAGE_NAME}@latest`;
+  const installCommand = versions.installCommand || detectInstallTarget().display;
   const descriptions = [
     `Runs \`${installCommand}\``,
     versions.installedVersion
@@ -209,12 +257,30 @@ export async function selectUpdateAction(options = {}) {
 }
 
 export async function installLatest(options = {}) {
-  const spawnImpl = options.spawnImpl || spawn;
-  const command = options.command || resolveInstallCommand();
+  const spawnImpl = options.spawnImpl || (process.platform === 'win32' ? spawnWindows : spawn);
+  const target = options.target || detectInstallTarget();
   return new Promise((resolve) => {
-    const child = spawnImpl(command, { shell: true, stdio: 'inherit' });
+    const child = spawnImpl(target.command, target.args, {
+      stdio: 'inherit',
+    });
     child.on('error', () => resolve(false));
-    child.on('exit', (code) => resolve(code === 0));
+    child.on('exit', async (code) => {
+      if (code !== 0) {
+        resolve(false);
+        return;
+      }
+      if (!options.expectedVersion) {
+        resolve(true);
+        return;
+      }
+      try {
+        const readVersion = options.readVersion || currentVersion;
+        const actualVersion = await readVersion();
+        resolve(compareVersions(actualVersion, options.expectedVersion) >= 0);
+      } catch {
+        resolve(false);
+      }
+    });
   });
 }
 
@@ -241,9 +307,13 @@ export async function showUpdateNotice(options = {}) {
       options.interactive ?? (process.stdin.isTTY === true && process.stderr.isTTY === true);
     if (!interactive) return { installedVersion, latestVersion, action: 'skip' };
 
-    const installCommand = options.installCommand || resolveInstallCommand();
     const select = options.select || selectUpdateAction;
-    const action = await select({ installedVersion, latestVersion, installCommand });
+    const installTarget = options.installTarget || detectInstallTarget();
+    const action = await select({
+      installedVersion,
+      latestVersion,
+      installCommand: installTarget.display,
+    });
     if (action === 'cancel') return { installedVersion, latestVersion, action };
     if (action === 'skip') {
       write(`\n  ${c.dim}Skipping update.${c.reset}\n\n`);
@@ -251,8 +321,10 @@ export async function showUpdateNotice(options = {}) {
     }
 
     write(`\n  ${c.cyan}Updating ${PACKAGE_NAME} to ${latestVersion}...${c.reset}\n\n`);
-    const install = options.install || installLatest;
-    const installed = await install();
+    const install =
+      options.install ||
+      ((expectedVersion) => installLatest({ expectedVersion, target: installTarget }));
+    const installed = await install(latestVersion);
     if (installed) {
       write(
         `\n  ${c.green}${c.bold}Update complete.${c.reset} Re-run your subc command.\n\n`,
@@ -260,8 +332,9 @@ export async function showUpdateNotice(options = {}) {
       return { installedVersion, latestVersion, action: 'updated' };
     }
 
-    write(`\n  ${c.red}Update failed.${c.reset} Try it manually:\n\n`);
-    write(`    ${c.cyan}${installCommand}${c.reset}\n\n`);
+    write(`\n  ${c.red}Update failed or the running installation stayed unchanged.${c.reset}\n`);
+    write(`  Try the exact detected install target manually:\n\n`);
+    write(`    ${c.cyan}${installTarget.display}${c.reset}\n\n`);
     return { installedVersion, latestVersion, action: 'failed' };
   } catch {
     // Update discovery must never prevent the requested command from running.

package/bin/upgrade.js

@@ -6,10 +6,12 @@
  */
 
 import { spawn } from 'node:child_process';
+import { runWindows } from './windows/process.js';
 import fs from 'node:fs/promises';
 import readline from 'node:readline';
 import { fileURLToPath } from 'node:url';
 import { c } from './colors.js';
+import { detectInstallTarget } from './update-check.js';
 
 export const PACKAGE_NAME = 'subconscious-cli';
 export const MIN_LOGIN_VERSION = '4.0';
@@ -24,17 +26,7 @@ export function parseUpgradeArgs(argv = []) {
 }
 
 export function detectInstallCommand(here = fileURLToPath(import.meta.url)) {
-  const normalized = here.replace(/\\/g, '/');
-  if (normalized.includes('/.pnpm/') || normalized.includes('/pnpm/global/')) {
-    return `pnpm add -g ${PACKAGE_NAME}@latest`;
-  }
-  if (normalized.includes('/.yarn/') || normalized.includes('/yarn/global/')) {
-    return `yarn global add ${PACKAGE_NAME}@latest`;
-  }
-  if (normalized.includes('/.bun/install/global/')) {
-    return `bun add -g ${PACKAGE_NAME}@latest`;
-  }
-  return `npm install -g ${PACKAGE_NAME}@latest`;
+  return detectInstallTarget(here).display;
 }
 
 export async function currentCliVersion() {
@@ -90,6 +82,10 @@ function askYesNo(question) {
 }
 
 function runInstall(command) {
+  if (process.platform === 'win32') {
+    const target = detectInstallTarget();
+    return runWindows(target.command, target.args).then(code => code === 0, () => false);
+  }
   return new Promise((resolve) => {
     const child = spawn(command, { shell: true, stdio: 'inherit' });
     child.on('error', () => resolve(false));
@@ -132,6 +128,26 @@ export async function installLatest(options = {}) {
     return false;
   }
 
+  if (latest) {
+    try {
+      const readVersion = options.readVersion || currentCliVersion;
+      const installedVersion = await readVersion();
+      if (compareVersions(installedVersion, latest) < 0) {
+        console.error(
+          `\n  ${c.red}Upgrade command completed, but this installation is still ${installedVersion}.${c.reset}`,
+        );
+        console.error(`  Run the exact detected command manually:\n`);
+        console.error(`    ${c.cyan}${command}${c.reset}\n`);
+        return false;
+      }
+    } catch {
+      console.error(`\n  ${c.red}Could not verify the updated CLI installation.${c.reset}`);
+      console.error(`  Run the exact detected command manually:\n`);
+      console.error(`    ${c.cyan}${command}${c.reset}\n`);
+      return false;
+    }
+  }
+
   console.log(`\n  ${c.green}${c.bold}✓ Upgraded.${c.reset} Re-run ${c.cyan}subc login${c.reset} if you were signing in.\n`);
   return true;
 }

package/bin/windows/agents.js

@@ -0,0 +1,87 @@
+import path from 'node:path';
+import os from 'node:os';
+import readline from 'node:readline';
+import { windowsEnv, windowsBinDirs, windowsPath, resolveWindowsExecutable, readWindowsVersion, runWindows } from './process.js';
+import { windowsInstallSpec, installWindowsAgent } from './install.js';
+import { windowsSetup } from './setup.js';
+import { windowsLaunch, executeWindowsLaunch } from './launch.js';
+import { parseOptions } from './common.js';
+
+const askInstall = name => new Promise(resolve => {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  rl.question(`  ${name} isn't installed. Install it now? [Y/n] `, answer => { rl.close(); resolve(['', 'y', 'yes'].includes(answer.trim().toLowerCase())); });
+});
+
+export async function runWindowsAgent(agent, argv, dependencies) {
+  const { profile, parseAgentAction, extractModel, requireApiKey, resolvedModelsForLaunch, selectLaunchModel, runbookEnv } = dependencies;
+  const parsed = parseAgentAction(agent, argv);
+  let args = parsed.action !== 'launch' && parsed.action === argv[0] ? argv.slice(1) : argv;
+  const environment = windowsEnv(profile?.values, process.env);
+  const preferredDirs = agent.runbook?.installDir
+    ? [path.resolve(environment[agent.runbook.installDirEnv] || path.join(os.homedir(), agent.runbook.installDir))] : [];
+  environment.PATH = windowsPath([...preferredDirs, ...(environment.PATH || '').split(';'), ...windowsBinDirs(environment)]);
+  if (agent.id === 'subconscious-code' && parsed.action === 'install') {
+    if (args.length) throw new Error('Usage: subc sc install');
+    return finish(await installWindowsAgent(agent.id, environment));
+  }
+  if (['status', 'uninstall'].includes(parsed.action)) {
+    return finish(await windowsSetup(agent.id, parsed.action, args, environment));
+  }
+
+  // Honor -- after which all arguments belong to the underlying agent.
+  const boundary = args.indexOf('--');
+  const tail = boundary < 0 ? [] : args.slice(boundary);
+  const extracted = extractModel(boundary < 0 ? args : args.slice(0, boundary), profile);
+  args = [...extracted.rest, ...tail];
+  let explicit = {};
+  if (parsed.action === 'install' || agent.id === 'claude-code') {
+    const handled = parseOptions(boundary < 0 ? args : args.slice(0, args.indexOf('--')), { '--api-key': 1, '--gateway-url': 1 });
+    explicit = handled.options;
+  }
+  const key = explicit['--api-key'] || await requireApiKey(profile, agent);
+  if (!key) return finish(1);
+  const catalogProfile = explicit['--gateway-url'] ? { ...profile, values: { ...profile?.values, GATEWAY_URL: explicit['--gateway-url'] } } : profile;
+  const catalog = await resolvedModelsForLaunch(catalogProfile, key, extracted.model);
+  const model = selectLaunchModel(extracted.model, extracted.modelSource, catalog);
+  if (extracted.model && model !== extracted.model) console.error(`Configured model ${extracted.model} is not in the live catalog; using ${model}.`);
+  let executable;
+  if (parsed.action === 'launch') {
+    executable = resolveWindowsExecutable(agent.bin, { env: environment, preferredDirs });
+    if (!executable) {
+      const installer = windowsInstallSpec(agent.id, environment);
+      if (!installer || !process.stdin.isTTY || !process.stdout.isTTY || !await askInstall(agent.name)) {
+        console.error(`${agent.name} isn't installed. ${installer ? `Install it with: ${installer.display}` : 'Install it separately, then rerun subc.'}`);
+        return finish(127);
+      }
+      const installed = await installWindowsAgent(agent.id, environment);
+      if (installed) return finish(installed);
+      executable = resolveWindowsExecutable(agent.bin, { env: environment, preferredDirs });
+      if (!executable) {
+        console.error(`Installed ${agent.name}, but ${agent.bin} was not found. Add its installation directory to PATH or restart your terminal.`);
+        return finish(127);
+      }
+    }
+    if (agent.id === 'claude-code') {
+      const version = dependencies.parseClaudeVersion(readWindowsVersion(executable, environment));
+      if (dependencies.claudeVersionNeedsUpgrade(version)) console.error(`Minimum supported Claude Code version is ${dependencies.minimumClaudeVersion}; installed version is ${version}. Please upgrade Claude Code.`);
+    }
+  }
+  // Reuse profile/catalog semantics, but use Windows path and environment rules.
+  const env = windowsEnv(runbookEnv(key, model, executable && path.dirname(executable), catalogProfile, agent, catalog.models), { PATH: windowsPath(executable ? [path.dirname(executable)] : [], environment.PATH) });
+  if (explicit['--gateway-url']) env.GATEWAY_URL = explicit['--gateway-url'];
+  if (parsed.action === 'install') return finish(await windowsSetup(agent.id, 'install', args, env));
+  if (agent.id === 'pi') await windowsSetup('pi', 'install', [], env);
+  if (agent.id === 'codex') {
+    try { await windowsSetup('codex', 'install', [], env, { log: () => {} }); }
+    catch (error) { console.error(`Could not refresh Codex hooks (launch will continue): ${error.message}`); }
+  }
+  const spec = await windowsLaunch(agent.id, args, env);
+  if (spec.command === agent.bin) spec.command = executable;
+  console.log(`  Launching ${agent.name} on Subconscious (${model})\n`);
+  return finish(await executeWindowsLaunch(spec, runWindows));
+}
+
+function finish(code) {
+  if (code) process.exitCode = code;
+  return code;
+}

package/bin/windows/claude.js

@@ -0,0 +1,71 @@
+// Windows-only equivalent of the existing Claude shell launch.
+import { readFileSync } from 'node:fs';
+import { resolvedModelSetting } from '../profiles.js';
+import { positiveInteger, parseOptions } from './common.js';
+const DEFAULTS = JSON.parse(readFileSync(new URL('../registry.generated.json', import.meta.url), 'utf8')).defaults;
+function claudePickerSettings(models) {
+  return { availableModels: models, modelPicker: { replaceBuiltInOptions: true, options: models.map(model => ({model, label: model, description: 'Subconscious model ' + model})) } };
+}
+
+export function claudeNativeLaunch(argv, environment) {
+  const { options, rest: passthrough } = parseOptions(argv, {
+    '--gateway-url': 1, '--api-key': 1, '--model': 1,
+    '--compact-window': 1, '--max-context-tokens': 1,
+  });
+  const gatewayUrl = options['--gateway-url'] || environment.GATEWAY_URL?.trim() || '';
+  const apiKey = options['--api-key'] || environment.CLAUDE_CODE_API_KEY?.trim() || environment.API_KEY?.trim() || '';
+  const model = options['--model'] || environment.MODEL?.trim() || DEFAULTS.model;
+  const compactWindow = options['--compact-window'] ||
+    environment.CLAUDE_CODE_AUTO_COMPACT_WINDOW?.trim() ||
+    environment.COMPACT_WINDOW?.trim() ||
+    '1000000';
+  const maxContextTokens = options['--max-context-tokens'] ||
+    environment.CLAUDE_CODE_MAX_CONTEXT_TOKENS?.trim() ||
+    environment.MAX_CONTEXT_TOKENS?.trim() ||
+    '3000000';
+
+  if (!gatewayUrl || !apiKey) {
+    throw new Error('GATEWAY_URL and API_KEY are required to launch Claude Code');
+  }
+  positiveInteger(compactWindow, 'compact-window');
+  positiveInteger(maxContextTokens, 'max-context-tokens');
+
+  const effectiveGatewayUrl = environment.CLAUDE_GATEWAY_URL?.trim() || gatewayUrl;
+  const subagentModel = resolvedModelSetting(environment.CLAUDE_CODE_SUBAGENT_MODEL) || model;
+  const settings =
+    environment.SUBC_CLAUDE_SETTINGS?.trim() ||
+    JSON.stringify(claudePickerSettings([model], model));
+  const withoutTrailingSlash = effectiveGatewayUrl.replace(/\/+$/, '');
+  const env = {
+    ...environment,
+    ANTHROPIC_BASE_URL: effectiveGatewayUrl,
+    ANTHROPIC_AUTH_TOKEN: apiKey,
+    ANTHROPIC_MODEL: environment.ANTHROPIC_MODEL?.trim() || model,
+    ANTHROPIC_SMALL_FAST_MODEL: environment.ANTHROPIC_SMALL_FAST_MODEL?.trim() || model,
+    CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY:
+      environment.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY?.trim() || '0',
+    CLAUDE_CODE_SUBAGENT_MODEL: subagentModel,
+    CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS:
+      environment.MAX_CONCURRENT_SUBAGENTS?.trim() || '4',
+    CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH:
+      environment.MAX_SUBAGENT_SPAWN_DEPTH?.trim() || '1',
+    CLAUDE_CODE_AUTO_COMPACT_WINDOW: compactWindow,
+    CLAUDE_CODE_MAX_CONTEXT_TOKENS: maxContextTokens,
+    CLAUDE_CODE_ENABLE_TELEMETRY:
+      environment.CLAUDE_CODE_ENABLE_TELEMETRY?.trim() || '1',
+    CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC:
+      environment.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC?.trim() || '1',
+    ENABLE_CLAUDEAI_MCP_SERVERS: 'false',
+    OTEL_LOGS_EXPORTER: environment.OTEL_LOGS_EXPORTER?.trim() || 'otlp',
+    OTEL_EXPORTER_OTLP_PROTOCOL:
+      environment.OTEL_EXPORTER_OTLP_PROTOCOL?.trim() || 'http/json',
+    OTEL_EXPORTER_OTLP_LOGS_ENDPOINT: `${withoutTrailingSlash}/v1/logs`,
+    OTEL_EXPORTER_OTLP_HEADERS: `x-api-key=${apiKey}`,
+    OTEL_EXPORTER_OTLP_TIMEOUT:
+      environment.OTEL_EXPORTER_OTLP_TIMEOUT?.trim() || '2000',
+    OTEL_LOGS_EXPORT_INTERVAL:
+      environment.OTEL_LOGS_EXPORT_INTERVAL?.trim() || '2000',
+  };
+
+  return { args: ['--settings', settings, ...passthrough], env };
+}

package/bin/windows/common.js

@@ -0,0 +1,58 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+
+export const defaults = JSON.parse(readFileSync(new URL('../registry.generated.json', import.meta.url), 'utf8')).defaults;
+export const value = (env, key, fallback = '') => env[key]?.trim() || fallback;
+export const origin = url => url.replace(/\/+$/, '').replace(/\/v1(?:\/(?:messages|responses|chat\/completions))?$/, '');
+export function positiveInteger(input, name) {
+  if (!/^[1-9][0-9]*$/.test(String(input)) || !Number.isSafeInteger(Number(input))) throw new Error(`${name} must be a positive integer`);
+  return Number(input);
+}
+export function modelIds(env) {
+  const models = [...new Set([value(env, 'MODEL', defaults.model), ...value(env, 'SUBCONSCIOUS_MODELS', defaults.models.join('\n')).split(/\r?\n/)].filter(Boolean))];
+  for (const model of models) if (!/^[-A-Za-z0-9._:/+]+$/.test(model)) throw new Error(`Invalid model id: ${model}`);
+  return models;
+}
+export function parseOptions(argv, schema, { strict = false } = {}) {
+  const options = {}, rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--') {
+      if (strict && i + 1 < argv.length) throw new Error(`Unexpected setup argument: ${argv[i + 1]}`);
+      rest.push(...argv.slice(i + 1)); break;
+    }
+    const [flag, ...equals] = argv[i].split('=');
+    if (!Object.hasOwn(schema, flag)) {
+      if (strict) throw new Error(`Unknown setup option: ${argv[i]}`);
+      rest.push(argv[i]); continue;
+    }
+    if (schema[flag] === true) {
+      if (equals.length) throw new Error(`${flag} does not take a value`);
+      options[flag] = true; continue;
+    }
+    const next = equals.length ? equals.join('=') : argv[++i];
+    if (!next || next.startsWith('--')) throw new Error(`${flag} requires a value`);
+    options[flag] = next;
+  }
+  return { options, rest };
+}
+export async function readJson(file, fallback) {
+  try { return JSON.parse((await fs.readFile(file, 'utf8')).replace(/^\uFEFF/, '')); }
+  catch (error) {
+    if (error.code === 'ENOENT') return fallback;
+    throw new Error(`Cannot read ${file}; leaving it unchanged: ${error.message}`);
+  }
+}
+export function object(value, description) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error(`${description} must be a JSON object; leaving it unchanged`);
+  return value;
+}
+export async function writeJson(file, data) {
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  const temp = `${file}.${randomUUID()}.tmp`;
+  try {
+    await fs.writeFile(temp, JSON.stringify(data, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+    await fs.rename(temp, file);
+  } finally { await fs.rm(temp, { force: true }); }
+}

package/bin/windows/hook.cjs

@@ -0,0 +1,71 @@
+// Standalone Windows hook, copied into the agent's user configuration.
+// Observational only: never block a session, leak credentials, or print payloads.
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { randomUUID, createHash } = require('node:crypto');
+
+async function main() {
+  const [client, configPath] = process.argv.slice(2);
+  let payload = {};
+  const input = await new Promise(resolve => {
+    let text = '';
+    const finish = () => { clearTimeout(timer); process.stdin.pause(); resolve(text); };
+    const timer = setTimeout(finish, 500);
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', chunk => { text += chunk; if (text.length > 4 * 1024 * 1024) finish(); });
+    process.stdin.on('end', finish);
+    process.stdin.on('error', finish);
+  });
+  try { payload = JSON.parse(input); } catch { /* fail open */ }
+  const event = payload?.hook_event_name || '';
+  const response = client === 'cursor'
+    ? (event === 'preCompact' ? {} : { continue: true, permission: 'allow' })
+    : client === 'copilot' ? { continue: true } : {};
+  try {
+    const config = JSON.parse(await fs.readFile(configPath, 'utf8'));
+    const cid = payload?.conversation_id || payload?.session_id;
+    if (!cid || typeof cid !== 'string' || !config.apiKey || !config.gatewayUrl) return;
+    const post = async body => {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 1500);
+      try {
+        const res = await fetch(`${config.gatewayUrl}/v1/agent-hooks`, {
+          method: 'POST', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${config.apiKey}`, 'x-subconscious-client': client },
+          body: JSON.stringify({ conversation_id: cid, hook_event_name: event, ...body }), signal: controller.signal,
+        });
+        await res.body?.cancel();
+      } catch { /* fail open */ } finally { clearTimeout(timer); }
+    };
+    if ((client === 'cursor' && event === 'beforeSubmitPrompt') || (client === 'copilot' && event === 'UserPromptSubmit')) {
+      if (typeof payload.prompt !== 'string' || !payload.prompt) return;
+      const root = payload.workspace_roots?.[0] || payload.cwd;
+      await post({ event: 'conversation_ensure', prompt: payload.prompt, workspace: typeof root === 'string' ? path.win32.basename(root) : undefined });
+    }
+    if (client === 'codex' && ['PreCompact', 'PostCompact'].includes(event)) {
+      const phase = event === 'PreCompact' ? 'start' : 'end';
+      await post({ event: 'conversation_compaction', phase, dedupe_key: `${cid}:${phase}:${payload.turn_id || randomUUID()}`, metadata: { trigger: payload.trigger, turn_id: payload.turn_id } });
+    }
+    if (client === 'cursor' && event === 'preCompact') {
+      const metadata = Object.fromEntries(['trigger', 'context_tokens', 'context_window_size', 'context_usage_percent', 'message_count', 'messages_to_compact', 'is_first_compaction'].filter(k => payload[k] != null).map(k => [k, payload[k]]));
+      await post({ event: 'conversation_compaction', phase: 'point', dedupe_key: `${cid}:${payload.generation_id ?? 'gen'}:${payload.is_first_compaction ?? false}`, metadata });
+    }
+    if (client === 'copilot' && ['PreCompact', 'UserPromptSubmit'].includes(event)) {
+      const pendingDir = path.join(path.dirname(configPath), 'subconscious-compact-pending');
+      const pending = path.join(pendingDir, createHash('sha256').update(cid).digest('hex') + '.json');
+      if (event === 'PreCompact') {
+        const token = randomUUID();
+        await fs.mkdir(pendingDir, { recursive: true });
+        await fs.writeFile(pending, JSON.stringify({ token }), { mode: 0o600 });
+        await post({ event: 'conversation_compaction', phase: 'start', dedupe_key: `${cid}:start:${token}`, metadata: { trigger: payload.trigger || 'auto' } });
+      } else {
+        try {
+          const { token } = JSON.parse(await fs.readFile(pending, 'utf8'));
+          await fs.rm(pending, { force: true });
+          await post({ event: 'conversation_compaction', phase: 'end', dedupe_key: `${cid}:end:${token}` });
+        } catch { /* no pending compaction */ }
+      }
+    }
+  } catch { /* missing/malformed config, I/O and transport errors are nonfatal */ }
+  finally { process.stdout.write(JSON.stringify(response) + '\n'); }
+}
+main().catch(() => { process.stdout.write('{}\n'); }).finally(() => { process.exitCode = 0; });

package/bin/windows/install.js

@@ -0,0 +1,97 @@
+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 repository = 'subconscious-systems/subconscious-code';
+
+function npmInstall(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 command = typeof install === 'object' ? install.win32 : undefined;
+  if (id === 'subconscious-code') return { nativeRelease: true, display: 'subc sc 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 spec = npmInstall(command);
+  if (!spec) throw new Error(`No safe Windows installer is defined for ${id}`);
+  return { ...spec, display: command };
+}
+
+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 names = [`sc-${target}.zip`, `sc-${target}.exe`];
+  const asset = release.assets?.find(asset => names.includes(asset.name));
+  if (!asset) throw new Error(`Subconscious Code ${release.tag_name || 'latest'} has no published native Windows ${arch} binary. The CLI can launch an installed sc.exe, but the upstream release must include a Windows build before subc sc install can install it.`);
+  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 } = {}) {
+  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 release = await response.json();
+  const { asset, checksum } = windowsReleaseAsset(release, arch);
+  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}`);
+    return Buffer.from(await response.arrayBuffer());
+  };
+  log(`Downloading Subconscious Code ${release.tag_name} for Windows ${arch}...`);
+  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');
+  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 destination = path.join(installDir, 'sc.exe');
+  const staging = path.join(installDir, `sc-${randomUUID()}.tmp`);
+  try {
+    const extracted = path.join(dir, 'sc.exe');
+    if (asset.name.endsWith('.zip')) {
+      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 spec = powershellCommand("$ErrorActionPreference = 'Stop'; Add-Type -AssemblyName System.IO.Compression.FileSystem; $z = [IO.Compression.ZipFile]::OpenRead($env:SUBC_ARCHIVE); try { $e = $z.GetEntry('sc.exe'); if ($null -eq $e) { throw 'Archive has no root sc.exe' }; [IO.Compression.ZipFileExtensions]::ExtractToFile($e, $env:SUBC_EXTRACTED, $false) } finally { $z.Dispose() }", { ...env, SUBC_ARCHIVE: archive, SUBC_EXTRACTED: extracted });
+      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');
+    if (magic !== 'MZ') throw new Error('Release is not a Windows executable');
+    await fs.mkdir(installDir, { recursive: true });
+    await fs.copyFile(extracted, staging);
+    await fs.rename(staging, destination);
+    log(`Installed ${destination}. Run subc sc to launch it.`);
+    return 0;
+  } finally {
+    await fs.rm(staging, { force: true });
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+}
+
+export async function installWindowsAgent(id, env, run = runWindows) {
+  const spec = windowsInstallSpec(id, env);
+  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; }
+  if (code && spec.fallback) {
+    console.error('Native installer failed; trying the npm package.');
+    code = await run(spec.fallback.command, spec.fallback.args, { env });
+  }
+  return code;
+}