ccprofiles-core 0.8.1 → 0.10.0

package/dist/adopt.d.ts

@@ -8,5 +8,9 @@ export declare function buildManifest(live: LiveProfile[], platform: Platform, s
  * re-leak a previously migrated token as plaintext. For each profile that existed before,
  * if the old manifest had a secret:// ref whose resolved value matches the newly-discovered
  * plaintext value, restore the ref instead of the plaintext.
+ *
+ * Also carries forward declared-only fields (skipPermissions, launcher name, launcher env)
+ * that live state cannot represent — buildManifest resets them to defaults, so without this
+ * every snapshot/adopt would silently turn them off.
  */
 export declare function preserveSecretRefs(newM: Manifest, oldM: Manifest, getSecret: (name: string) => Promise<string | null>): Promise<void>;

package/dist/adopt.js

@@ -59,7 +59,11 @@ export function buildManifest(live, platform, sharedRoot = join(platform.home, '
                 .map(([k]) => k).sort(),
         };
     });
-    return { version: 1, hub, profiles, mcpServers, marketplaces };
+    // Whichever profile already has a statusline wins; ~/.claude first, since that is where a
+    // `ccstatusline`-style installer writes when run without CLAUDE_CONFIG_DIR set.
+    const statusLine = (live.find(lp => lp.dirName === '.claude' && lp.statusLine) ?? live.find(lp => lp.statusLine))
+        ?.statusLine;
+    return { version: 1, hub, profiles, mcpServers, marketplaces, ...(statusLine ? { statusLine } : {}) };
 }
 /**
  * Re-migrate secret refs after a snapshot/adopt rebuilds the manifest from live state.
@@ -67,12 +71,22 @@ export function buildManifest(live, platform, sharedRoot = join(platform.home, '
  * re-leak a previously migrated token as plaintext. For each profile that existed before,
  * if the old manifest had a secret:// ref whose resolved value matches the newly-discovered
  * plaintext value, restore the ref instead of the plaintext.
+ *
+ * Also carries forward declared-only fields (skipPermissions, launcher name, launcher env)
+ * that live state cannot represent — buildManifest resets them to defaults, so without this
+ * every snapshot/adopt would silently turn them off.
  */
 export async function preserveSecretRefs(newM, oldM, getSecret) {
     for (const pr of newM.profiles) {
         const old = oldM.profiles.find(p => p.name === pr.name);
         if (!old)
             continue;
+        pr.skipPermissions = old.skipPermissions;
+        // buildManifest derives `cl-<dirname>`, which silently renames a hand-picked alias
+        // (cl-plb -> cl-data-plb) and makes the next apply rewrite the user's rc block.
+        pr.launcher = old.launcher;
+        if (Object.keys(pr.env).length === 0)
+            pr.env = old.env;
         for (const [k, v] of Object.entries(old.settingsEnv ?? {})) {
             if (!v.startsWith('secret://'))
                 continue;

package/dist/apply.d.ts

@@ -21,6 +21,10 @@ export type ApplyAction = {
     kind: 'set-settings-env';
     settingsPath: string;
     env: Record<string, string>;
+} | {
+    kind: 'set-status-line';
+    settingsPath: string;
+    statusLine: Record<string, unknown>;
 } | {
     kind: 'share-session-dir';
     from: string;

package/dist/apply.js

@@ -1,4 +1,4 @@
-import { cp, lstat, mkdir, readFile, rm, symlink, unlink } from 'node:fs/promises';
+import { cp, lstat, mkdir, readFile, rm, stat, symlink, unlink } from 'node:fs/promises';
 import { existsSync, readFileSync } from 'node:fs';
 import { join, dirname, posix as posixPath, win32 as win32Path } from 'node:path';
 import { renderPath } from './platform.js';
@@ -128,6 +128,14 @@ export function planApply(m, live, p, resolvedSettingsEnv, sharedRoot = join(p.h
                 actions.push({ kind: 'set-settings-env', settingsPath: join(dir, 'settings.json'), env: desired });
             }
         }
+        // Same normalization as the mcp check — comparing raw JSON would re-emit this action on
+        // every apply whenever key order differed, which is the unfixable-drift-loop shape.
+        if (agent === 'claude' && m.statusLine) {
+            const currentSl = lp?.statusLine ?? null;
+            if (!currentSl || JSON.stringify(sortKeys(currentSl)) !== JSON.stringify(sortKeys(m.statusLine))) {
+                actions.push({ kind: 'set-status-line', settingsPath: join(dir, 'settings.json'), statusLine: m.statusLine });
+            }
+        }
     }
     const block = renderRcBlock(m, p);
     let rcCurrent = '';
@@ -146,7 +154,8 @@ export async function executeApply(actions, opts) {
     const touched = actions.flatMap(a => a.kind === 'set-mcp-servers' ? [a.configPath]
         : a.kind === 'rc-block' ? [a.rcFile]
             : a.kind === 'set-settings-env' ? [a.settingsPath]
-                : []);
+                : a.kind === 'set-status-line' ? [a.settingsPath]
+                    : []);
     let backupDir = touched.length ? await backupFiles(touched, opts.backupRoot, opts.stamp) : null;
     for (const a of actions) {
         if (a.kind === 'create-profile-dir') {
@@ -222,6 +231,29 @@ export async function executeApply(actions, opts) {
             // Resolved secret:// refs land here as plaintext env values — keep it 0600.
             await atomicWrite(a.settingsPath, JSON.stringify(cfg, null, 2), { mode: 0o600 });
         }
+        else if (a.kind === 'set-status-line') {
+            let cfg = {};
+            try {
+                cfg = JSON.parse(await readFile(a.settingsPath, 'utf8'));
+            }
+            catch (e) {
+                if (e.code !== 'ENOENT') {
+                    await backupFiles([a.settingsPath], opts.backupRoot, opts.stamp);
+                    throw new Error(`refusing to overwrite unreadable ${a.settingsPath} — back it up and fix it, then re-apply (${e.message})`);
+                }
+                // ENOENT: genuinely new file, cfg stays {}
+            }
+            cfg.statusLine = a.statusLine;
+            // Preserve the existing mode. set-settings-env may have just written this same file at
+            // 0600 because it holds resolved secrets; atomicWrite's 0644 default would widen it.
+            let mode = 0o644;
+            try {
+                mode = (await stat(a.settingsPath)).mode & 0o777;
+            }
+            catch { /* new file: 0644 */ }
+            await mkdir(dirname(a.settingsPath), { recursive: true });
+            await atomicWrite(a.settingsPath, JSON.stringify(cfg, null, 2), { mode });
+        }
         else if (a.kind === 'share-session-dir') {
             await mkdir(a.to, { recursive: true });
             let st = null;
@@ -263,6 +295,7 @@ function describe(a) {
         case 'link': return `link ${a.from} -> ${a.to}`;
         case 'rc-block': return `update managed block in ${a.rcFile}`;
         case 'set-settings-env': return `set settings env (${Object.keys(a.env).length}) in ${a.settingsPath}`;
+        case 'set-status-line': return `set statusLine in ${a.settingsPath}`;
         case 'share-session-dir': return `share ${a.from} -> ${a.to}`;
         case 'unshare-session-dir': return `unshare ${a.from} (seed from ${a.to})`;
     }

package/dist/delegate.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Run another profile's agent headlessly as a subagent of the current session.
+ *
+ * `handoff` moves you to another profile interactively; this keeps you where you are and
+ * calls the other profile for one scoped task, returning its output. That is the only way
+ * to reach a different provider from inside a session: ANTHROPIC_BASE_URL / _AUTH_TOKEN are
+ * process-wide, and a native subagent's `model` is validated against the *current* provider,
+ * so a Claude session cannot dispatch a native subagent onto Kimi, GLM, or Codex.
+ */
+/** Env that pins a session to one account/provider. Must never survive into a delegate. */
+export declare const PROVIDER_ENV_KEYS: readonly ["CLAUDE_CONFIG_DIR", "CODEX_HOME", "ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_BASE_URL", "ANTHROPIC_MODEL", "ANTHROPIC_SMALL_FAST_MODEL", "ANTHROPIC_DEFAULT_OPUS_MODEL", "ANTHROPIC_DEFAULT_SONNET_MODEL", "ANTHROPIC_DEFAULT_HAIKU_MODEL"];
+export interface DelegateLaunch {
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+    cwd: string;
+}
+/**
+ * Parent env minus every provider pin, plus the target's own.
+ *
+ * Without the strip, delegating from a gateway profile (kimi/z/mimo, which export
+ * ANTHROPIC_BASE_URL) to a Claude profile would leave the gateway's base URL in place: the
+ * target would authenticate as the Claude profile but send its traffic to the gateway. The
+ * delegate would appear to work while silently running on the wrong model.
+ */
+export declare function delegateEnv(parentEnv: Record<string, string | undefined>, homeVar: 'CLAUDE_CONFIG_DIR' | 'CODEX_HOME', targetDir: string, targetEnv: Record<string, string>): Record<string, string>;
+export declare function buildDelegateLaunch(opts: {
+    targetAgent: 'claude' | 'codex';
+    targetDir: string;
+    targetEnv: Record<string, string>;
+    skipPermissions: boolean;
+    prompt: string;
+    cwd: string;
+    model?: string | null;
+    json?: boolean;
+    parentEnv?: Record<string, string | undefined>;
+}): DelegateLaunch;

package/dist/delegate.js

@@ -0,0 +1,65 @@
+/**
+ * Run another profile's agent headlessly as a subagent of the current session.
+ *
+ * `handoff` moves you to another profile interactively; this keeps you where you are and
+ * calls the other profile for one scoped task, returning its output. That is the only way
+ * to reach a different provider from inside a session: ANTHROPIC_BASE_URL / _AUTH_TOKEN are
+ * process-wide, and a native subagent's `model` is validated against the *current* provider,
+ * so a Claude session cannot dispatch a native subagent onto Kimi, GLM, or Codex.
+ */
+/** Env that pins a session to one account/provider. Must never survive into a delegate. */
+export const PROVIDER_ENV_KEYS = [
+    'CLAUDE_CONFIG_DIR',
+    'CODEX_HOME',
+    'ANTHROPIC_API_KEY',
+    'ANTHROPIC_AUTH_TOKEN',
+    'ANTHROPIC_BASE_URL',
+    'ANTHROPIC_MODEL',
+    'ANTHROPIC_SMALL_FAST_MODEL',
+    'ANTHROPIC_DEFAULT_OPUS_MODEL',
+    'ANTHROPIC_DEFAULT_SONNET_MODEL',
+    'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+];
+/**
+ * Parent env minus every provider pin, plus the target's own.
+ *
+ * Without the strip, delegating from a gateway profile (kimi/z/mimo, which export
+ * ANTHROPIC_BASE_URL) to a Claude profile would leave the gateway's base URL in place: the
+ * target would authenticate as the Claude profile but send its traffic to the gateway. The
+ * delegate would appear to work while silently running on the wrong model.
+ */
+export function delegateEnv(parentEnv, homeVar, targetDir, targetEnv) {
+    const out = {};
+    for (const [k, v] of Object.entries(parentEnv)) {
+        if (v === undefined)
+            continue;
+        if (PROVIDER_ENV_KEYS.includes(k))
+            continue;
+        out[k] = v;
+    }
+    out[homeVar] = targetDir;
+    return { ...out, ...targetEnv };
+}
+export function buildDelegateLaunch(opts) {
+    const codex = opts.targetAgent === 'codex';
+    const homeVar = codex ? 'CODEX_HOME' : 'CLAUDE_CONFIG_DIR';
+    const args = codex ? ['exec'] : ['-p'];
+    if (opts.model)
+        args.push(codex ? '-m' : '--model', opts.model);
+    // codex exec has no --output-format; the caller is told rather than silently given text
+    if (opts.json && !codex)
+        args.push('--output-format', 'json');
+    if (opts.skipPermissions) {
+        args.push(codex ? '--dangerously-bypass-approvals-and-sandbox' : '--dangerously-skip-permissions');
+    }
+    // codex resolves its workspace from --cd, not the spawn cwd
+    if (codex)
+        args.push('-C', opts.cwd);
+    args.push(opts.prompt);
+    return {
+        command: codex ? 'codex' : 'claude',
+        args,
+        env: delegateEnv(opts.parentEnv ?? {}, homeVar, opts.targetDir, opts.targetEnv),
+        cwd: opts.cwd,
+    };
+}

package/dist/discovery.d.ts

@@ -9,6 +9,9 @@ export interface LiveProfile {
     mcpServers: Record<string, McpServerDef>;
     links: Record<string, string>;
     settingsEnv: Record<string, string>;
+    /** settings.json `statusLine`, verbatim. Claude Code reads it from the profile's own
+     *  settings.json, so configuring it once in ~/.claude leaves every other profile bare. */
+    statusLine?: unknown;
     enabledPlugins: Record<string, boolean>;
     /** Plugin ids actually installed (keys of plugins/installed_plugins.json) — the ground truth
      *  for "present". enabledPlugins alone can be stale: an enabled-but-never-installed entry

package/dist/discovery.js

@@ -98,6 +98,7 @@ export async function discoverProfiles(home) {
         }
         const settingsEnv = {};
         const enabledPlugins = {};
+        let statusLine;
         if (agent === 'claude')
             try {
                 const s = JSON.parse(await readFile(join(dir, 'settings.json'), 'utf8'));
@@ -109,6 +110,8 @@ export async function discoverProfiles(home) {
                     for (const [k, v] of Object.entries(s.enabledPlugins))
                         if (typeof v === 'boolean')
                             enabledPlugins[k] = v;
+                if (s && typeof s.statusLine === 'object' && s.statusLine !== null)
+                    statusLine = s.statusLine;
             }
             catch { /* no settings.json */ }
         const marketplaces = {};
@@ -144,6 +147,7 @@ export async function discoverProfiles(home) {
             mcpServers: agent === 'claude' ? cfg?.mcpServers ?? {} : await readCodexMcpServers(configPath),
             links,
             settingsEnv,
+            statusLine,
             enabledPlugins,
             installedPlugins,
             installedPluginVersions,

package/dist/index.d.ts

@@ -16,5 +16,6 @@ export * from './syncclient.js';
 export * from './bundle.js';
 export * from './sessions.js';
 export * from './handoff.js';
+export * from './delegate.js';
 export * from './plugins.js';
 export * from './provider.js';

package/dist/index.js

@@ -16,5 +16,6 @@ export * from './syncclient.js';
 export * from './bundle.js';
 export * from './sessions.js';
 export * from './handoff.js';
+export * from './delegate.js';
 export * from './plugins.js';
 export * from './provider.js';

package/dist/manifest.d.ts

@@ -160,6 +160,11 @@ declare const ManifestSchema: z.ZodObject<{
     }, {
         source: string;
     }>>>;
+    /** One settings.json `statusLine` block mirrored into every claude profile. Claude Code
+     *  reads it per-CLAUDE_CONFIG_DIR, so without this a statusline configured in one profile
+     *  is simply absent in the others. Shared, not per-profile: the point is that every
+     *  profile gets the same line (it renders per-profile data at runtime). */
+    statusLine: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
     version: 1;
     hub: string | null;
@@ -187,6 +192,7 @@ declare const ManifestSchema: z.ZodObject<{
     marketplaces: Record<string, {
         source: string;
     }>;
+    statusLine?: Record<string, unknown> | undefined;
 }, {
     version: 1;
     hub: string | null;
@@ -214,6 +220,7 @@ declare const ManifestSchema: z.ZodObject<{
     marketplaces?: Record<string, {
         source: string;
     }> | undefined;
+    statusLine?: Record<string, unknown> | undefined;
 }>;
 export type McpServerDef = z.infer<typeof McpServerSchema>;
 export type ProfileDecl = z.infer<typeof ProfileSchema>;

package/dist/manifest.js

@@ -36,6 +36,11 @@ const ManifestSchema = z.object({
     profiles: z.array(ProfileSchema),
     mcpServers: z.record(McpServerSchema),
     marketplaces: z.record(MarketplaceSchema).default({}),
+    /** One settings.json `statusLine` block mirrored into every claude profile. Claude Code
+     *  reads it per-CLAUDE_CONFIG_DIR, so without this a statusline configured in one profile
+     *  is simply absent in the others. Shared, not per-profile: the point is that every
+     *  profile gets the same line (it renders per-profile data at runtime). */
+    statusLine: z.record(z.unknown()).optional(),
 });
 // identifiers that get interpolated into shell launcher code must be injection-safe
 // leading '-' is forbidden (but internal '-' still allowed) so a value can never be parsed as a

package/dist/plugins.d.ts

@@ -50,5 +50,29 @@ export declare function reconcileProfilePlugins(opts: {
     /** ids drifting across profiles — update them here so every profile lands on the same latest. */
     updateIds?: string[];
 }): Promise<string[]>;
+/**
+ * Existing claude-mem cache dirs under a profile (`plugins/cache/<owner>/claude-mem`, any owner).
+ * Disk is the ground truth on purpose: a PROJECT-scope claude-mem install is invisible to
+ * installed_plugins.json's user-scope view (discovery's installedPlugins misses it), yet it still
+ * leaks the same way — `.claude-staffinc` was exactly this case on 2026-07-23. Gating the prune on
+ * install bookkeeping would skip the one profile that needed it most.
+ */
+export declare function claudeMemCacheDirs(configDir: string): Promise<string[]>;
+/**
+ * Keep only the highest-semver version dir under `cacheDir`, delete the rest. Returns removed names.
+ *
+ * Why this is the real fix for the claude-mem leak: the plugin's session-init hook resolves which
+ * worker to launch with `ls -dt <cache>/[0-9]*` — the newest dir by MTIME — and ignores the pinned
+ * version in installed_plugins.json entirely. So a leftover OLD version dir with a fresher mtime is
+ * launched instead of the pinned latest, reviving the shared-`~/.claude-mem`-worker fight even when
+ * every profile's pin is already correct. On 2026-07-23 this ran `.claude-data-plb` (pinned 13.12.1)
+ * up to 187 procs / 20GB swap, all from a stale 13.11.0 dir. Version *parity* (planPluginVersionDrift
+ * + `clp fix`) is necessary but not sufficient; the ambiguity only goes away when one dir remains.
+ *
+ * "Keep highest semver" == keep the intended active version, because `claude plugin update` only ever
+ * moves to the marketplace's latest — there is no way to pin an older one. Non-numeric dirs
+ * (git-sha/"unknown" caches of versionless plugins) are left untouched.
+ */
+export declare function pruneStaleVersionDirs(cacheDir: string): Promise<string[]>;
 /** If a profile's plugins/ is a legacy symlink into the old shared pool, restore it to a real dir. */
 export declare function restoreLegacyPluginSymlink(pluginsDir: string): Promise<boolean>;

package/dist/plugins.js

@@ -1,5 +1,6 @@
-import { cp, lstat, mkdir, readlink, unlink } from 'node:fs/promises';
+import { cp, lstat, mkdir, readdir, readlink, rm, unlink } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
+import { join } from 'node:path';
 export function marketplaceOf(id) {
     const at = id.lastIndexOf('@');
     return at > 0 ? id.slice(at + 1) : null;
@@ -72,6 +73,76 @@ export async function reconcileProfilePlugins(opts) {
     }
     return log;
 }
+/**
+ * Existing claude-mem cache dirs under a profile (`plugins/cache/<owner>/claude-mem`, any owner).
+ * Disk is the ground truth on purpose: a PROJECT-scope claude-mem install is invisible to
+ * installed_plugins.json's user-scope view (discovery's installedPlugins misses it), yet it still
+ * leaks the same way — `.claude-staffinc` was exactly this case on 2026-07-23. Gating the prune on
+ * install bookkeeping would skip the one profile that needed it most.
+ */
+export async function claudeMemCacheDirs(configDir) {
+    const cacheRoot = join(configDir, 'plugins', 'cache');
+    let owners;
+    try {
+        owners = await readdir(cacheRoot);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const owner of owners) {
+        const d = join(cacheRoot, owner, 'claude-mem');
+        if (existsSync(d))
+            out.push(d);
+    }
+    return out;
+}
+/** Compare dotted numeric version names ("13.9.2" < "13.11.0"). Missing parts count as 0. */
+function compareVersionDir(a, b) {
+    const pa = a.split('.'), pb = b.split('.');
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const x = Number(pa[i] ?? 0), y = Number(pb[i] ?? 0);
+        if (x !== y)
+            return x - y;
+    }
+    return 0;
+}
+/**
+ * Keep only the highest-semver version dir under `cacheDir`, delete the rest. Returns removed names.
+ *
+ * Why this is the real fix for the claude-mem leak: the plugin's session-init hook resolves which
+ * worker to launch with `ls -dt <cache>/[0-9]*` — the newest dir by MTIME — and ignores the pinned
+ * version in installed_plugins.json entirely. So a leftover OLD version dir with a fresher mtime is
+ * launched instead of the pinned latest, reviving the shared-`~/.claude-mem`-worker fight even when
+ * every profile's pin is already correct. On 2026-07-23 this ran `.claude-data-plb` (pinned 13.12.1)
+ * up to 187 procs / 20GB swap, all from a stale 13.11.0 dir. Version *parity* (planPluginVersionDrift
+ * + `clp fix`) is necessary but not sufficient; the ambiguity only goes away when one dir remains.
+ *
+ * "Keep highest semver" == keep the intended active version, because `claude plugin update` only ever
+ * moves to the marketplace's latest — there is no way to pin an older one. Non-numeric dirs
+ * (git-sha/"unknown" caches of versionless plugins) are left untouched.
+ */
+export async function pruneStaleVersionDirs(cacheDir) {
+    let names;
+    try {
+        names = await readdir(cacheDir);
+    }
+    catch {
+        return [];
+    }
+    const versions = names.filter(n => /^\d/.test(n)).sort(compareVersionDir);
+    if (versions.length <= 1)
+        return [];
+    const keep = versions[versions.length - 1];
+    const removed = [];
+    for (const v of versions) {
+        if (v === keep)
+            continue;
+        await rm(join(cacheDir, v), { recursive: true, force: true });
+        removed.push(v);
+    }
+    return removed;
+}
 /** If a profile's plugins/ is a legacy symlink into the old shared pool, restore it to a real dir. */
 export async function restoreLegacyPluginSymlink(pluginsDir) {
     let st = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccprofiles-core",
-  "version": "0.8.1",
+  "version": "0.10.0",
   "description": "Core library for ccprofiles — discovery, manifest, secrets, apply, and LAN sync for Claude Code multi-account setups",
   "type": "module",
   "main": "./dist/index.js",