ccprofiles-core 0.9.0 → 0.10.1

package/dist/adopt.d.ts

@@ -9,8 +9,8 @@ export declare function buildManifest(live: LiveProfile[], platform: Platform, s
  * 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 env) that live
- * state cannot represent — buildManifest resets them to defaults, so without this every
- * snapshot/adopt would silently turn them off.
+ * 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.
@@ -68,9 +72,9 @@ export function buildManifest(live, platform, sharedRoot = join(platform.home, '
  * 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 env) that live
- * state cannot represent — buildManifest resets them to defaults, so without this every
- * snapshot/adopt would silently turn them off.
+ * 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) {
@@ -78,6 +82,9 @@ export async function preserveSecretRefs(newM, oldM, getSecret) {
         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 ?? {})) {

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/handoff.d.ts

@@ -1,5 +1,13 @@
 import type { ProjectSessions, SessionTranscript } from './sessions.js';
-export declare function findLastSessionForCwd(scanned: ProjectSessions[], cwd: string, scope: string, agent: 'claude' | 'codex'): {
+import type { OsKind } from './platform.js';
+/**
+ * Compare two absolute paths the way the OS would. Windows is case-insensitive and mixes
+ * separators freely (`C:\p` / `c:/p` are one path), so a strict === there silently fails to
+ * match a session against its own project. POSIX is case-sensitive — normalizing it would
+ * merge genuinely distinct paths, so it stays exact.
+ */
+export declare function samePath(a: string, b: string, os: OsKind): boolean;
+export declare function findLastSessionForCwd(scanned: ProjectSessions[], cwd: string, scope: string, agent: 'claude' | 'codex', os?: OsKind): {
     scope: string;
     id: string;
 } | null;

package/dist/handoff.js

@@ -1,7 +1,19 @@
-export function findLastSessionForCwd(scanned, cwd, scope, agent) {
+/**
+ * Compare two absolute paths the way the OS would. Windows is case-insensitive and mixes
+ * separators freely (`C:\p` / `c:/p` are one path), so a strict === there silently fails to
+ * match a session against its own project. POSIX is case-sensitive — normalizing it would
+ * merge genuinely distinct paths, so it stays exact.
+ */
+export function samePath(a, b, os) {
+    if (os !== 'win32')
+        return a === b;
+    const norm = (p) => p.replace(/[\\/]+/g, '\\').replace(/(.)\\+$/, '$1').toLowerCase();
+    return norm(a) === norm(b);
+}
+export function findLastSessionForCwd(scanned, cwd, scope, agent, os = 'linux') {
     let newest = null;
     for (const p of scanned) {
-        if (p.project !== cwd || p.scope !== scope || p.agent !== agent)
+        if (!samePath(p.project, cwd, os) || p.scope !== scope || p.agent !== agent)
             continue;
         for (const s of p.sessions)
             if (!newest || s.mtime > newest.mtime)

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/sessions.d.ts

@@ -36,8 +36,18 @@ export declare function sessionScanCacheStats(): {
     hits: number;
     misses: number;
 };
-/** Best-effort decode of Claude Code's project dir name (cwd from a record is preferred). */
+/**
+ * Last resort only — lossy, and unfixably so. Claude Code encodes a project path by replacing
+ * every '/' with '-', so a segment that legitimately contains a hyphen (`/Users/lp-stf00543`)
+ * cannot be told apart from a separator on the way back. Prefer the `cwd` recorded inside the
+ * session file; `headCwd` exists so that stays available even for files we decline to read.
+ */
 export declare function decodeProjectDir(name: string): string;
+/**
+ * First cwd found in a head slice. A slice cut mid-record leaves a partial trailing line, which
+ * simply fails JSON.parse and is skipped — no need to guess which line is incomplete.
+ */
+export declare function headCwd(head: string, pick: (rec: any) => string | undefined): string | null;
 export declare function scanSessions(opts: {
     sharedRoot: string;
     profiles: {

package/dist/sessions.js

@@ -1,4 +1,4 @@
-import { readdir, readFile, stat, lstat } from 'node:fs/promises';
+import { readdir, readFile, stat, lstat, open } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 const SAFE_SESSION_ID = /^[A-Za-z0-9_-]{1,160}$/;
@@ -7,6 +7,8 @@ const claudeSessionCache = new Map();
 const codexSessionCache = new Map();
 /** Per-file cap: a transcript above this size is summarized without reading its content. */
 const MAX_FILE_SCAN_BYTES = 10 * 1024 * 1024;
+// enough to reach the first record carrying cwd, without reading a multi-MB transcript
+const HEAD_SCAN_BYTES = 64 * 1024;
 /** Per-request cap: once this many bytes have been read from disk in one scanSessions() call,
  *  remaining (uncached) files are summarized without reading their content either. */
 const MAX_TOTAL_SCAN_BYTES = 50 * 1024 * 1024;
@@ -17,10 +19,52 @@ let scanCacheMisses = 0;
 export function sessionScanCacheStats() {
     return { hits: scanCacheHits, misses: scanCacheMisses };
 }
-/** Best-effort decode of Claude Code's project dir name (cwd from a record is preferred). */
+/**
+ * Last resort only — lossy, and unfixably so. Claude Code encodes a project path by replacing
+ * every '/' with '-', so a segment that legitimately contains a hyphen (`/Users/lp-stf00543`)
+ * cannot be told apart from a separator on the way back. Prefer the `cwd` recorded inside the
+ * session file; `headCwd` exists so that stays available even for files we decline to read.
+ */
 export function decodeProjectDir(name) {
     return name.replace(/^-/, '/').replace(/-/g, '/');
 }
+/** First `bytes` of a file, for cheap field recovery without reading a multi-MB transcript. */
+async function readHead(file, bytes = HEAD_SCAN_BYTES) {
+    let fh = null;
+    try {
+        fh = await open(file, 'r');
+        const buf = Buffer.alloc(bytes);
+        const { bytesRead } = await fh.read(buf, 0, bytes, 0);
+        return buf.subarray(0, bytesRead).toString('utf8');
+    }
+    catch {
+        return '';
+    }
+    finally {
+        await fh?.close().catch(() => { });
+    }
+}
+/**
+ * First cwd found in a head slice. A slice cut mid-record leaves a partial trailing line, which
+ * simply fails JSON.parse and is skipped — no need to guess which line is incomplete.
+ */
+export function headCwd(head, pick) {
+    for (const line of head.split('\n')) {
+        if (!line.trim())
+            continue;
+        let rec;
+        try {
+            rec = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const v = pick(rec);
+        if (typeof v === 'string' && v)
+            return v;
+    }
+    return null;
+}
 /**
  * Shared mtime+size cache lookup for the two session-file formats. `parseFull` runs only on a
  * cache miss with a fresh read; `makeTruncated` builds a summary-only result when the file is
@@ -43,12 +87,12 @@ async function cachedParse(file, cache, budget, parseFull, makeTruncated) {
     }
     scanCacheMisses++;
     if (st.size > MAX_FILE_SCAN_BYTES) {
-        const result = makeTruncated(st);
+        const result = makeTruncated(st, await readHead(file));
         cache.set(file, { mtimeMs: st.mtimeMs, size: st.size, result });
         return result;
     }
     if (st.size > budget.bytesLeft)
-        return makeTruncated(st); // not cached — budget is per-request
+        return makeTruncated(st, await readHead(file)); // not cached — budget is per-request
     let raw;
     try {
         raw = await readFile(file, 'utf8');
@@ -90,7 +134,7 @@ async function parseClaudeSession(file, budget) {
                 break;
         }
         return { meta: { id, mtime: st.mtimeMs, messageCount: lines.length, firstPrompt, gitBranch, model, sizeBytes: st.size }, cwd };
-    }, st => ({ meta: { id, mtime: st.mtimeMs, messageCount: 0, firstPrompt: null, gitBranch: null, model: null, sizeBytes: st.size, truncated: true }, cwd: null }));
+    }, (st, head) => ({ meta: { id, mtime: st.mtimeMs, messageCount: 0, firstPrompt: null, gitBranch: null, model: null, sizeBytes: st.size, truncated: true }, cwd: headCwd(head, r => r.cwd) }));
 }
 async function scanProjectsDir(projectsDir, scope, budget) {
     if (!existsSync(projectsDir))
@@ -314,7 +358,7 @@ async function parseCodexSession(file, budget) {
         }
         id ??= fallbackId;
         return { meta: { id, mtime: st.mtimeMs, messageCount: messageCount || lines.length, firstPrompt, gitBranch, model, sizeBytes: st.size }, cwd };
-    }, st => ({ meta: { id: fallbackId, mtime: st.mtimeMs, messageCount: 0, firstPrompt: null, gitBranch: null, model: null, sizeBytes: st.size, truncated: true }, cwd: null }));
+    }, (st, head) => ({ meta: { id: fallbackId, mtime: st.mtimeMs, messageCount: 0, firstPrompt: null, gitBranch: null, model: null, sizeBytes: st.size, truncated: true }, cwd: headCwd(head, r => r?.payload?.cwd) }));
 }
 async function codexSessionFiles(dir) {
     let entries;

package/package.json

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