subconscious-cli 6.0.1 → 6.1.0

package/bin/sessions.js

@@ -2,6 +2,7 @@ import { spawnSync } from 'node:child_process';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
+import { AGENTS, agentById, agentCommandName } from './agent-data.js';
 import { resolveAgent, runAgent } from './agents.js';
 
 import { c } from './colors.js';
@@ -14,15 +15,25 @@ const MAX_INDEX_BYTES = 4 * 1024 * 1024;
 const MAX_HANDOFF_MESSAGES = 24;
 const MAX_HANDOFF_CHARS = 24_000;
 const MAX_MESSAGE_CHARS = 4_000;
-const SESSION_KEY_PATTERN = /^(claude|codex|opencode|pi|sc):[-A-Za-z0-9._]+$/;
-
-export const SESSION_HARNESSES = Object.freeze({
-  claude: { name: 'Claude Code', command: 'claude', portable: true },
-  codex: { name: 'Codex CLI', command: 'codex', portable: true },
-  opencode: { name: 'OpenCode', command: 'opencode', portable: true },
-  pi: { name: 'Pi', command: 'pi', portable: true },
-  sc: { name: 'Marathon', command: 'marathon', portable: false },
-});
+const SESSION_KEY_PATTERN = new RegExp(
+  `^(${AGENTS.filter((agent) => agent.sessions)
+    .map((agent) => agent.sessions.key)
+    .join('|')}):[-A-Za-z0-9._]+$`,
+);
+
+export const SESSION_HARNESSES = Object.freeze(
+  Object.fromEntries(
+    AGENTS.filter((agent) => agent.sessions).map((agent) => [
+      agent.sessions.key,
+      Object.freeze({
+        name: agent.name,
+        command: agentCommandName(agent),
+        portable: agent.sessions.portable,
+        agentId: agent.id,
+      }),
+    ]),
+  ),
+);
 
 function cleanText(value) {
   return String(value || '')
@@ -56,7 +67,10 @@ function parseLines(text) {
   for (const line of text.split('\n')) {
     if (!line.trim()) continue;
     try {
-      records.push(JSON.parse(line));
+      const record = JSON.parse(line);
+      if (record && typeof record === 'object' && !Array.isArray(record)) {
+        records.push(record);
+      }
     } catch {
       // Session writers can leave a partial final line after an interrupted run.
     }
@@ -594,22 +608,38 @@ export function buildHandoffPrompt(session, messages) {
     .join('\n\n');
 }
 
+function sessionLaunch(harness) {
+  return agentById(SESSION_HARNESSES[harness]?.agentId)?.launch ?? {};
+}
+
+// One pass, so a prompt that mentions a placeholder is passed unchanged.
+function fillWords(words, values) {
+  return words.map((word) =>
+    word.replace(/\{(sessionId|sessionFile|prompt)\}/g, (_, name) =>
+      String(values[name]),
+    ),
+  );
+}
+
 export function nativeResumeArgs(session) {
-  if (session.harness === 'claude') return ['--resume', session.id];
-  if (session.harness === 'codex') return ['resume', session.id];
-  if (session.harness === 'opencode') return ['--session', session.id];
-  if (session.harness === 'pi')
-    return ['--session', session.sourcePath || session.id];
-  if (session.harness === 'sc') return ['--resume', session.sourcePath];
-  throw new Error(`Native resume is not supported for ${session.harnessName}.`);
+  const { resume } = sessionLaunch(session.harness);
+  if (!resume)
+    throw new Error(
+      `Native resume is not supported for ${session.harnessName}.`,
+    );
+  return fillWords(resume, {
+    sessionId: session.id,
+    sessionFile: session.sourcePath || session.id,
+  });
 }
 
 export function handoffLaunchArgs(targetHarness, prompt) {
-  if (targetHarness === 'opencode') return ['--prompt', prompt];
-  if (['claude', 'codex', 'pi'].includes(targetHarness)) return [prompt];
-  throw new Error(
-    `${SESSION_HARNESSES[targetHarness]?.name || targetHarness} cannot start an interactive handoff yet.`,
-  );
+  const { handoff } = sessionLaunch(targetHarness);
+  if (!handoff)
+    throw new Error(
+      `${SESSION_HARNESSES[targetHarness]?.name || targetHarness} cannot start an interactive handoff yet.`,
+    );
+  return fillWords(handoff, { prompt });
 }
 
 function sessionByKey(sessions, key) {

package/bin/tui.js

@@ -422,6 +422,19 @@ function spawnAndWait(command, args, options = {}) {
 }
 
 export async function runTui(options = {}) {
+  for (;;) {
+    const result = await runTuiOnce(options);
+    if (result?.args?.length !== 2 || result.args[0] !== '-p') return result;
+    options = {
+      ...options,
+      profileName: result.args[1],
+      profile: undefined,
+      state: undefined,
+    };
+  }
+}
+
+async function runTuiOnce(options) {
   const executable = await resolveTuiExecutable(options);
   if (!executable) return null;
 

package/bin/update-check.js

@@ -86,6 +86,10 @@ function parseVersion(version) {
   };
 }
 
+export function isVersion(version) {
+  return parseVersion(version) !== null;
+}
+
 function comparePrerelease(a, b) {
   if (!a.length && !b.length) return 0;
   if (!a.length) return 1;
@@ -102,7 +106,7 @@ function comparePrerelease(a, b) {
       return Math.sign(aNumber - bNumber);
     if (aNumber !== null) return -1;
     if (bNumber !== null) return 1;
-    return a[index].localeCompare(b[index]);
+    return a[index] < b[index] ? -1 : 1;
   }
   return 0;
 }

package/bin/upgrade.js

@@ -10,7 +10,11 @@ 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';
+import {
+  compareVersions,
+  detectInstallTarget,
+  isVersion,
+} from './update-check.js';
 import { runWindows } from './windows/process.js';
 
 export const PACKAGE_NAME = 'subconscious-cli';
@@ -38,23 +42,6 @@ export async function currentCliVersion() {
   return pkg.version;
 }
 
-export function compareVersions(a, b) {
-  const pa = String(a)
-    .split('.')
-    .map((part) => Number.parseInt(part, 10) || 0);
-  const pb = String(b)
-    .split('.')
-    .map((part) => Number.parseInt(part, 10) || 0);
-  const n = Math.max(pa.length, pb.length);
-  for (let i = 0; i < n; i++) {
-    const da = pa[i] || 0;
-    const db = pb[i] || 0;
-    if (da > db) return 1;
-    if (da < db) return -1;
-  }
-  return 0;
-}
-
 export async function fetchLatestVersion(fetchImpl = fetch) {
   const res = await fetchImpl(
     `https://registry.npmjs.org/${PACKAGE_NAME}/latest`,
@@ -121,13 +108,17 @@ export async function installLatest(options = {}) {
 
   let latest;
   try {
-    latest = await fetchLatest();
+    const version = await fetchLatest();
+    if (!isVersion(version)) {
+      throw new Error(`npm returned an invalid version (${version}).`);
+    }
+    latest = version;
   } catch (error) {
     console.error(`  ${c.yellow}${error.message}${c.reset}`);
     console.error(`  ${c.dim}Installing @latest anyway.${c.reset}\n`);
   }
 
-  if (latest && compareVersions(current, latest) >= 0) {
+  if (latest && isVersion(current) && compareVersions(current, latest) >= 0) {
     console.log(
       `\n  ${c.green}Already up to date${c.reset} ${c.dim}(${current}).${c.reset}\n`,
     );
@@ -153,18 +144,12 @@ export async function installLatest(options = {}) {
   }
 
   if (latest) {
+    const readVersion = options.readVersion || currentCliVersion;
+    let installedVersion;
     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 {
+      installedVersion = await readVersion();
+    } catch {}
+    if (!isVersion(installedVersion)) {
       console.error(
         `\n  ${c.red}Could not verify the updated CLI installation.${c.reset}`,
       );
@@ -172,6 +157,14 @@ export async function installLatest(options = {}) {
       console.error(`    ${c.cyan}${command}${c.reset}\n`);
       return false;
     }
+    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;
+    }
   }
 
   console.log(

package/bin/usage.js

@@ -9,19 +9,30 @@ import { printLoginUpgradeWarning } from './upgrade.js';
 
 export const USAGE_API_PATH = '/api/v1/usage';
 
-export function formatTokens(value) {
+// Largest first: [size, suffix].
+const TOKEN_UNITS = [
+  [1_000_000_000, 'B'],
+  [1_000_000, 'M'],
+  [1_000, 'K'],
+];
+
+export function formatTokens(value, { sigFigs = 3 } = {}) {
   const n = Number(value);
+
   if (!Number.isFinite(n) || n < 0) return '0';
-  if (n >= 1_000_000_000) {
-    const scaled = n / 1_000_000_000;
-    return `${scaled.toFixed(n % 1_000_000_000 ? 1 : 0)}B`;
-  }
-  if (n >= 1_000_000) {
-    const scaled = n / 1_000_000;
-    return `${scaled.toFixed(n % 1_000_000 ? 1 : 0)}M`;
+
+  let index = TOKEN_UNITS.findIndex(([size]) => n >= size);
+  if (index === -1) return n.toLocaleString('en-US');
+
+  // Number() also turns toPrecision's exponent form ("1.00e+3") back into 1000.
+
+  let scaled = Number((n / TOKEN_UNITS[index][0]).toPrecision(sigFigs));
+  // Rounding can reach the next unit: 999_500 is 1M, not 1000K.
+  if (scaled >= 1_000 && index > 0) {
+    index -= 1;
+    scaled = Number((n / TOKEN_UNITS[index][0]).toPrecision(sigFigs));
   }
-  if (n >= 1_000) return `${Math.round(n / 1_000)}K`;
-  return n.toLocaleString('en-US');
+  return `${scaled}${TOKEN_UNITS[index][1]}`;
 }
 
 export function formatCurrency(value) {

package/bin/windows/agents.js

@@ -1,6 +1,8 @@
 import os from 'node:os';
 import path from 'node:path';
 import readline from 'node:readline';
+import { agentBinary, agentInstallDirs } from '../agent-data.js';
+import { separatorIndex } from '../headless-args.js';
 import { parseOptions } from './common.js';
 import { installWindowsAgent, windowsInstallSpec } from './install.js';
 import { executeWindowsLaunch, windowsLaunch } from './launch.js';
@@ -41,18 +43,12 @@ export async function runWindowsAgent(agent, argv, dependencies) {
   } = dependencies;
   const parsed = parseAgentAction(agent, argv);
   let args =
-    parsed.action !== 'launch' && parsed.action === argv[0]
+    !['launch', 'headless'].includes(parsed.action) && 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),
-        ),
-      ]
-    : [];
+  const preferredDirs = agentInstallDirs(agent, environment, os.homedir());
+  const bin = agentBinary(agent);
   environment.PATH = windowsPath([
     ...preferredDirs,
     ...(environment.PATH || '').split(';'),
@@ -69,7 +65,7 @@ export async function runWindowsAgent(agent, argv, dependencies) {
   }
 
   // Honor -- after which all arguments belong to the underlying agent.
-  const boundary = args.indexOf('--');
+  const boundary = separatorIndex(args);
   const tail = boundary < 0 ? [] : args.slice(boundary);
   const extracted = extractModel(
     boundary < 0 ? args : args.slice(0, boundary),
@@ -79,7 +75,7 @@ export async function runWindowsAgent(agent, argv, dependencies) {
   let explicit = {};
   if (parsed.action === 'install' || agent.id === 'claude-code') {
     const handled = parseOptions(
-      boundary < 0 ? args : args.slice(0, args.indexOf('--')),
+      boundary < 0 ? args : args.slice(0, boundary),
       { '--api-key': 1, '--gateway-url': 1 },
     );
     explicit = handled.options;
@@ -106,9 +102,10 @@ export async function runWindowsAgent(agent, argv, dependencies) {
     console.error(
       `Configured model ${extracted.model} is not in the live catalog; using ${model}.`,
     );
+  const headless = dependencies.headless ?? parsed.action === 'headless';
   let executable;
-  if (parsed.action === 'launch') {
-    executable = resolveWindowsExecutable(agent.bin, {
+  if (parsed.action === 'launch' || headless) {
+    executable = resolveWindowsExecutable(bin, {
       env: environment,
       preferredDirs,
     });
@@ -116,6 +113,7 @@ export async function runWindowsAgent(agent, argv, dependencies) {
       const installer = windowsInstallSpec(agent.id, environment);
       if (
         !installer ||
+        headless ||
         !process.stdin.isTTY ||
         !process.stdout.isTTY ||
         !(await askInstall(agent.name))
@@ -127,13 +125,13 @@ export async function runWindowsAgent(agent, argv, dependencies) {
       }
       const installed = await installWindowsAgent(agent.id, environment);
       if (installed) return finish(installed);
-      executable = resolveWindowsExecutable(agent.bin, {
+      executable = resolveWindowsExecutable(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.`,
+          `Installed ${agent.name}, but ${bin} was not found. Add its installation directory to PATH or restart your terminal.`,
         );
         return finish(127);
       }
@@ -179,8 +177,11 @@ export async function runWindowsAgent(agent, argv, dependencies) {
     }
   }
   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`);
+  if (spec.command === bin) spec.command = executable;
+  // Headless stdout belongs to the agent alone.
+  (headless ? console.error : console.log)(
+    `  Launching ${agent.name} on Subconscious (${model})\n`,
+  );
   return finish(await executeWindowsLaunch(spec, runWindows));
 }
 

package/bin/windows/common.js

@@ -1,40 +1,14 @@
 import { randomUUID } from 'node:crypto';
-import { readFileSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
-export const defaults = JSON.parse(
-  readFileSync(new URL('../registry.generated.json', import.meta.url), 'utf8'),
-).defaults;
+export { DEFAULTS as defaults } from '../agent-data.js';
+export { modelIds, positiveInteger } from '../launch-values.js';
 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 = [];

package/bin/windows/install.js

@@ -1,14 +1,12 @@
 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 { agentById, installCommands } from '../agent-data.js';
 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';
+const marathon = agentById('subconscious-code').install;
+const repository = marathon.repository;
 
 function npmInstall(command) {
   const match = /^npm (?:i|install) -g ([@a-zA-Z0-9/._-]+)$/.exec(
@@ -18,8 +16,8 @@ function npmInstall(command) {
 }
 
 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;
+  const install = installCommands(agentById(id)) || {};
+  const command = install.win32;
   if (id === 'subconscious-code')
     return { nativeRelease: true, display: 'subc marathon install' };
   if (!command) return null; // Never fall back to a Linux installer.
@@ -40,22 +38,18 @@ 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];
+  const target = marathon.windows_targets.find((triple) =>
+    triple.startsWith({ x64: 'x86_64-', arm64: 'aarch64-' }[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 names = marathon.windows_assets.map((name) =>
+    name.replaceAll('{target}', target),
+  );
   const asset = names
     .map((name) => release.assets?.find((asset) => asset.name === name))
     .find(Boolean);