subconscious-cli 6.2.0 → 6.3.0

package/README.md

@@ -60,7 +60,6 @@ so OpenCode, Claude Code, Codex, and DeepSeek Harness can launch immediately.
 Persistent editor and Pi integrations are installed per agent:
 
 ```bash
-subc cursor install
 subc copilot install
 subc pi
 subc <agent> uninstall
@@ -90,7 +89,7 @@ profile; they do not authenticate, install, configure, or launch anything:
 subc opencode help
 subc claude help
 subc codex help
-subc cursor help
+subc copilot help
 subc config help
 subc login help
 ```
@@ -127,7 +126,6 @@ subc.cmd claude
 subc codex
 subc opencode
 subc dsh
-subc cursor install
 subc copilot install
 subc pi
 subc config edit notepad
@@ -155,7 +153,7 @@ and the native TUI use Windows paths and processes. Profile editing defaults to
 Notepad, honors `VISUAL`/`EDITOR`, and supports `code`/`code-insiders` with `--wait`.
 The existing profile location remains `%USERPROFILE%\.subconscious`.
 
-Cursor, Copilot, Codex, and Pi setup use native JSON merges and Node hooks. Other
+Copilot, Codex, and Pi setup use native JSON merges and Node hooks. Other
 providers and hooks are preserved; malformed configuration is left unchanged.
 Hook credentials are stored in `subconscious-windows.json` within the agent's
 user directory; treat that file as a secret. Copilot's model provider still uses
@@ -176,9 +174,8 @@ The packaged integrations live in `bin/runbook`.
 | `subc opencode` | Launch OpenCode with the runbook provider, client header, and context/output limits |
 | `subc claude` | Launch Claude Code with the runbook environment, context limits, subagent limits, and OTEL usage reporting |
 | `subc codex` | Launch Codex with the runbook provider, temporary model catalog, and surgically merged compaction hooks |
-| `subc cursor install` | Install/update Cursor conversation and compaction hooks (Cursor desktop app and IDE only — the Cursor CLI is not supported) |
-| `subc copilot install` | Install/update the VS Code custom endpoint and Copilot hooks |
 | `subc pi` | Refresh the Pi provider from the live catalog, then launch |
+| `subc copilot install` | Install/update the VS Code custom endpoint and Copilot hooks |
 | `subc dsh` | Launch the DeepSeek Harness Web UI with a temporary provider populated from the live catalog |
 
 ## Headless runs
@@ -323,8 +320,8 @@ characters. Tool payloads, tool results, system prompts, and hidden reasoning
 are not copied. Source transcripts remain owned by their original harness and
 are never rewritten.
 
-Cursor and GitHub Copilot sessions are not listed because their IDE-owned
-conversation stores do not expose a stable local resume interface. A session
+GitHub Copilot sessions are not listed because its IDE-owned
+conversation store does not expose a stable local resume interface. A session
 whose local transcript is missing remains available for native resume but does
 not offer cross-harness destinations.
 
@@ -346,7 +343,6 @@ Persistent writes are merge/unmerge only. They never replace a user's
 provider list. Remove Subconscious files with the matching uninstall command:
 
 ```bash
-subc cursor uninstall
 subc copilot uninstall
 subc pi uninstall
 subc codex uninstall
@@ -362,14 +358,13 @@ Inspect a persistent integration with `subc <agent> status`. A one-off
 `--api-key` passed to install takes precedence for that command but is not
 saved to the selected profile.
 
-Cursor still requires enabling its OpenAI API Key Override in Cursor Settings.
 Copilot requires entering the custom endpoint key once through VS Code's
 Manage Language Models UI. The install scripts print the relevant next steps.
 Its Custom Endpoint provider uses the Messages API at `/v1/messages` by
 default; rerun `subc copilot install` to migrate an older Chat Completions entry.
 
-The runbook scripts require Bash. Cursor, Copilot, Pi, and Codex hook merge
-also require `jq`; Cursor and Copilot also require `curl`.
+The runbook scripts require Bash. Copilot, Pi, and Codex hook merge
+also require `jq`. Copilot and Codex hooks also require `curl`.
 
 `subc dsh` defaults to the DeepSeek Harness Web UI. It injects an ephemeral
 Cordis overlay containing the active gateway URL, selected model, token limits,
@@ -434,7 +429,7 @@ subc -p staging config \
   --model subconscious/glm-5.3-marathon
 
 subc -p staging claude
-subc -p staging cursor install
+subc -p staging copilot install
 ```
 
 You can also select one with `SUBC_PROFILE=staging`. Explicit shell variables
@@ -468,7 +463,7 @@ export SUBCONSCIOUS_MODEL=subconscious/glm-5.3-marathon
 ```
 
 Every launch and install fetches the same live catalog without caching. Codex,
-OpenCode, Pi, Copilot, Cursor, and DeepSeek Harness receive the complete model
+OpenCode, Pi, Copilot, and DeepSeek Harness receive the complete model
 list. The selected profile model is listed first only while the gateway still
 advertises it.
 OpenCode rebuilds its isolated runtime provider on every `subc opencode` launch,
@@ -481,10 +476,7 @@ custom model option. The CLI remaps those aliases to the live catalog, then
 replaces the built-in `/model` lineup (`modelPicker.replaceBuiltInOptions`) and
 allowlists only those models (`availableModels`) so Anthropic Fable and
 ungranted slugs do not appear. Any other model can still be selected with
-`subc claude --model MODEL`. Cursor requires adding
-the printed model IDs in its OpenAI API Key Override settings. Use the printed
-`/v1` Base URL in Cursor Settings; the profile itself stores the gateway origin
-so correlation hooks can post to `/v1/agent-hooks`.
+`subc claude --model MODEL`.
 
 The default gateway is `https://api.subconscious.dev`. Profiles containing
 the former exact default (`https://api.subconscious.dev`) migrate automatically;

package/bin/agent-launch.js

@@ -1,6 +1,7 @@
+import path from 'node:path';
 import { agentInputs, agentKeyName } from './agent-data.js';
 import { openCodeConfigFromEnv } from './opencode-provider.js';
-import { isUnsetSetting } from './profiles.js';
+import { configDir, isUnsetSetting } from './profiles.js';
 
 // One pass, so a substituted value (a prompt, a settings document) is never
 // scanned again for placeholders.
@@ -8,6 +9,9 @@ const PLACEHOLDER = /\$\{([A-Z_][A-Z0-9_]*)\}(\/)?|\{([A-Za-z][A-Za-z0-9]*)\}/g;
 const present = (value) =>
   value !== undefined && value !== null && value !== '';
 
+// CLAUDE_CODE_ISOLATE values that stop Claude Code config isolation.
+const ISOLATE_OFF = new Set(['off', '0', 'false', 'no']);
+
 function tokensFor(agent, env, extra) {
   const baseUrl = String(env.GATEWAY_URL ?? '').replace(/\/+$/, '');
   const keyName = agentKeyName(agent);
@@ -19,6 +23,26 @@ function tokensFor(agent, env, extra) {
     // Left for the runbook, which writes the file and substitutes its path.
     tempFile: '{tempFile}',
     opencodeConfig: () => JSON.stringify(openCodeConfigFromEnv(env)),
+    // Claude Code config isolation: subc sessions keep their Claude config
+    // (settings, sessions, plugins, credentials) under the subc config dir
+    // instead of ~/.claude, so session state cannot bleed into a plain
+    // `claude` installation. Empty when CLAUDE_CODE_ISOLATE opts out.
+    claudeConfigDir: () => {
+      const setting = String(env.CLAUDE_CODE_ISOLATE ?? '')
+        .trim()
+        .toLowerCase();
+      // Opted out: the user's own folder, as plain `claude` would use it.
+      if (ISOLATE_OFF.has(setting)) {
+        return String(
+          env.SUBC_CLAUDE_CONFIG_SOURCE || env.CLAUDE_CONFIG_DIR || '',
+        ).trim();
+      }
+      const base = String(env.SUBC_CONFIG_DIR ?? '').trim() || configDir();
+      // A relative base would put the config, MCP tokens included, in the
+      // current directory; use ~/.claude unchanged instead.
+      if (!path.isAbsolute(base)) return '';
+      return path.join(base, 'claude-code');
+    },
     ...extra,
   };
 }
@@ -116,15 +140,24 @@ export function resolveInputs(
   return resolved;
 }
 
-/** Set each env entry: the first non-empty override, otherwise its value. */
+/**
+ * Set each env entry: the first non-empty override, otherwise its value.
+ * An entry marked `optional` is unset when its value renders empty, so a
+ * template can drop a variable instead of exporting an empty string.
+ */
 export function resolveAgentEnv(agent, env) {
   const resolved = { ...env };
   for (const entry of agent.env) {
     const override = (entry.override || [])
       .map((name) => resolved[name])
       .find(present);
-    resolved[entry.name] =
-      override !== undefined ? override : render(entry.value, agent, resolved);
+    if (override !== undefined) {
+      resolved[entry.name] = override;
+      continue;
+    }
+    const value = render(entry.value, agent, resolved);
+    if (entry.optional && !present(value)) delete resolved[entry.name];
+    else resolved[entry.name] = value;
   }
   return resolved;
 }

package/bin/agents.js

@@ -19,6 +19,7 @@ import {
 import { launchPlan, resolveInputs } from './agent-launch.js';
 import { planCommand, runCommand, scriptCommand } from './agent-spawn.js';
 import { getApiKey } from './auth.js';
+import { prepareClaudeLaunch } from './claude-config.js';
 import {
   applyClaudePickerCatalog,
   CLAUDE_PICKER_ENV_DESCRIPTION,
@@ -545,5 +546,22 @@ async function launchAgent(agent, argv, profile, headless) {
   // The headless endpoint is the one endpoint for every harness, Claude too.
   const launchEnv = headless ? { ...env, CLAUDE_GATEWAY_URL: '' } : env;
   const plan = launchPlan(agent, { env: launchEnv, ...headlessParts(rest) });
+  if (agent.id === CLAUDE_CODE) {
+    const {
+      warnings,
+      refused,
+      env: sourceEnv,
+    } = prepareClaudeLaunch(agent, plan.env, launchEnv);
+    const color = refused ? c.red : c.yellow;
+    for (const warning of warnings) {
+      console.error(`  ${color}${warning}${c.reset}`);
+    }
+    if (refused) {
+      process.exitCode = 1;
+      return 1;
+    }
+    const prepared = { ...plan, env: { ...plan.env, ...sourceEnv } };
+    return runCommand(planCommand(agent, prepared, binDir));
+  }
   return runCommand(planCommand(agent, plan, binDir));
 }

package/bin/auth.js

@@ -277,7 +277,7 @@ export async function loginCommand(_argv = [], options = {}) {
         }
         console.log(`  ${c.dim}Runbook profile: ${profile.path}${c.reset}`);
         console.log(
-          `  ${c.dim}Launch a terminal agent with ${c.reset}${c.cyan}subc claude${c.reset}${c.dim}, or install editor hooks with ${c.reset}${c.cyan}subc cursor install${c.reset}${c.dim}.${c.reset}`,
+          `  ${c.dim}Launch a terminal agent with ${c.reset}${c.cyan}subc claude${c.reset}${c.dim}, or set up VS Code Copilot with ${c.reset}${c.cyan}subc copilot install${c.reset}${c.dim}.${c.reset}`,
         );
         console.log(
           `  ${c.dim}Pi needs ${c.reset}${c.cyan}subc pi install${c.reset}${c.dim} first. List profiles with ${c.reset}${c.cyan}subc config${c.reset}${c.dim}.${c.reset}`,

package/bin/claude-config-drift.js

@@ -0,0 +1,58 @@
+import { isDeepStrictEqual } from 'node:util';
+
+// Each launch rebuilds the subc copies of settings.json and the MCP servers
+// in .claude.json from the user's own files, so anything a subc session
+// changed in those copies is replaced. These helpers find what a session
+// changed, by comparing the copies with what the last launch wrote, so the
+// launch can save it aside and name it instead of losing it silently.
+
+const isObject = (value) =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+/**
+ * Keys of `current` that a session added or changed since `written`.
+ * Removed keys are ignored: Claude Code drops keys on its own.
+ *
+ * @param {Record<string, unknown>} written what the last launch wrote
+ * @param {Record<string, unknown>} current what the copy holds now
+ * @param {string[]} [ignored] keys subc keeps across launches
+ * @returns {string[]}
+ */
+export function changedKeys(written, current, ignored = []) {
+  if (!isObject(written) || !isObject(current)) return [];
+  return Object.keys(current).filter(
+    (key) =>
+      !ignored.includes(key) && !isDeepStrictEqual(current[key], written[key]),
+  );
+}
+
+/** The MCP servers of a .claude.json: user scope and each project. */
+export function mcpServersOf(state) {
+  const projects = isObject(state?.projects) ? state.projects : {};
+  return {
+    mcpServers: isObject(state?.mcpServers) ? state.mcpServers : {},
+    projects: Object.fromEntries(
+      Object.entries(projects)
+        .filter(([, project]) => isObject(project?.mcpServers))
+        .map(([name, project]) => [name, project.mcpServers]),
+    ),
+  };
+}
+
+/**
+ * MCP server names a session added or changed since `written`, as
+ * `name` for user scope and `name (project)` for a project.
+ *
+ * @param {ReturnType<typeof mcpServersOf>} written
+ * @param {ReturnType<typeof mcpServersOf>} current
+ * @returns {string[]}
+ */
+export function changedMcpServers(written, current) {
+  const changed = changedKeys(written.mcpServers, current.mcpServers);
+  for (const [project, servers] of Object.entries(current.projects)) {
+    for (const name of changedKeys(written.projects[project] ?? {}, servers)) {
+      changed.push(`${name} (${project})`);
+    }
+  }
+  return changed;
+}

package/bin/claude-config-plugins.js

@@ -0,0 +1,103 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
+// Claude Code finds an enabled plugin that installed_plugins.json does not
+// list (a marketplace plugin pinned to a git SHA, for example) by its place
+// in its own cache: <config dir>/plugins/cache/<marketplace>/<plugin>/<version>.
+// The subc config dir never links that cache, so such a plugin, and the MCP
+// servers it ships, would not load. Each missing version is copied once. A
+// copy, unlike a link, cannot carry a cache sweep or orphan marker made in a
+// subc session back into ~/.claude.
+
+// A marketplace or plugin name used as one path segment.
+const SAFE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+
+/** `[plugin, marketplace]` of an enabledPlugins key, or `undefined`. */
+function parsePluginId(id) {
+  const at = id.lastIndexOf('@');
+  if (at <= 0) return undefined;
+  const plugin = id.slice(0, at);
+  const marketplace = id.slice(at + 1);
+  return SAFE_NAME.test(plugin) && SAFE_NAME.test(marketplace)
+    ? [plugin, marketplace]
+    : undefined;
+}
+
+function copyVersion(from, to) {
+  // A copy is renamed into place only when complete, so a launch stopped
+  // half way never leaves a partial plugin that later launches skip.
+  const temp = `${to}.${crypto.randomBytes(6).toString('hex')}.tmp`;
+  try {
+    fs.cpSync(from, temp, { recursive: true, verbatimSymlinks: true });
+    fs.renameSync(temp, to);
+  } finally {
+    fs.rmSync(temp, { recursive: true, force: true });
+  }
+}
+
+/** Whether `base` or any folder from it down through `parts` is a link. */
+function linkOnPath(base, parts) {
+  let current = base;
+  for (const part of ['', ...parts]) {
+    current = part ? path.join(current, part) : current;
+    try {
+      if (fs.lstatSync(current).isSymbolicLink()) return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+function directories(dir) {
+  try {
+    return fs
+      .readdirSync(dir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && SAFE_NAME.test(entry.name))
+      .map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Copy into `dir`'s plugin cache every cached version of each enabled plugin
+ * that the plugin index does not list, unless a copy is already there.
+ *
+ * @param {{ dir: string, source: string, enabledPlugins: unknown,
+ *   indexed: unknown, warnings: string[] }} options
+ */
+export function copyUnindexedPlugins({
+  dir,
+  source,
+  enabledPlugins,
+  indexed,
+  warnings,
+}) {
+  if (!enabledPlugins || typeof enabledPlugins !== 'object') return;
+  const listed =
+    indexed && typeof indexed === 'object' ? Object.keys(indexed) : [];
+  for (const [id, enabled] of Object.entries(enabledPlugins)) {
+    if (enabled !== true || listed.includes(id)) continue;
+    const parsed = parsePluginId(id);
+    if (!parsed) continue;
+    const [plugin, marketplace] = parsed;
+    const from = path.join(source, 'plugins', 'cache', marketplace, plugin);
+    const to = path.join(dir, 'plugins', 'cache', marketplace, plugin);
+    // A link here could carry the copy into the user's own cache.
+    if (linkOnPath(path.join(dir, 'plugins'), ['cache', marketplace, plugin])) {
+      warnings.push(`Skipped plugin ${id} for subc: its cache path is a link.`);
+      continue;
+    }
+    for (const version of directories(from)) {
+      if (fs.existsSync(path.join(to, version))) continue;
+      try {
+        fs.mkdirSync(to, { recursive: true });
+        copyVersion(path.join(from, version), path.join(to, version));
+      } catch (error) {
+        warnings.push(`Could not copy plugin ${id} for subc: ${error.message}`);
+      }
+    }
+  }
+}