@event4u/agent-switch 1.0.0

package/dist/share.js

@@ -0,0 +1,257 @@
+/**
+ * Share user-level settings across profiles via links.
+ *
+ * Two link kinds, because Claude Code's settings writer writes atomically
+ * (write-temp + rename), which breaks a symlinked FILE but not a symlinked
+ * DIRECTORY (issue #40857, verified in tests/integration.test.ts):
+ *
+ *   - Directories (`skills/`, `commands/`, `agents/`) — genuinely shared. A
+ *     write inside the linked dir lands in the source. Linked as a symlink on
+ *     POSIX, a junction on win32 (junctions need no elevation).
+ *   - Files (`settings.json`, `keybindings.json`, `CLAUDE.md`) — linked, but
+ *     an in-profile `/config` write forks the file (the rename replaces the
+ *     link with a regular file). `agent-switch share sync` detects a forked link
+ *     from the manifest, pushes the profile's edit back into the source, and
+ *     re-links (last-sync-wins across profiles). On win32, file symlinks need
+ *     Developer Mode/admin, so file links degrade with a message there.
+ *
+ * Account-/instance-scoped items (`.claude.json`, `.credentials.json`,
+ * `plugins/`, `sessions/`, `ide/`, `statsig/`) are deliberately never shared.
+ * History (`projects/`, `history.jsonl`, `plans/`) is a POSIX-only opt-in.
+ * (`plans/` defaults to `<CLAUDE_CONFIG_DIR>/plans/` in Claude Code, so plan-mode
+ * files are otherwise isolated per profile — verified against claude-code 2.1.215.)
+ *
+ * A manifest (.agent-switch-shared.json) records what agent-switch created, so
+ * unshare/sync only ever touch agent-switch-managed links, never user data.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+const BASE_ITEMS = [
+    { name: "settings.json", kind: "file" },
+    { name: "keybindings.json", kind: "file" },
+    { name: "CLAUDE.md", kind: "file" },
+    { name: "skills", kind: "dir" },
+    { name: "commands", kind: "dir" },
+    { name: "agents", kind: "dir" },
+];
+/** Conversation history + plan-mode files; opt-in — shares `claude --resume`
+ *  and the plan store across accounts. `plans/` is a `dir`, so writes inside it
+ *  reach the source (no atomic-rename fork), exactly like `projects/`. */
+const HISTORY_ITEMS = [
+    { name: "projects", kind: "dir" },
+    { name: "history.jsonl", kind: "file" },
+    { name: "plans", kind: "dir" },
+];
+/** Names exported for messaging/tests. */
+export const SHARED_ITEMS = BASE_ITEMS.map((i) => i.name);
+export const HISTORY_ITEM_NAMES = HISTORY_ITEMS.map((i) => i.name);
+const ITEM_KIND = new Map([...BASE_ITEMS, ...HISTORY_ITEMS].map((i) => [i.name, i.kind]));
+const MANIFEST = ".agent-switch-shared.json";
+function readManifest(dir) {
+    try {
+        const data = JSON.parse(fs.readFileSync(path.join(dir, MANIFEST), "utf8"));
+        return Array.isArray(data?.links) ? data.links : [];
+    }
+    catch {
+        return [];
+    }
+}
+function writeManifest(dir, links) {
+    fs.writeFileSync(path.join(dir, MANIFEST), JSON.stringify({ links, tool: "agent-switch" }, null, 2) + "\n", { mode: 0o600 });
+}
+/**
+ * Create a link of the right kind for the platform. Directories use a junction
+ * on win32 (no elevation); files use a native symlink everywhere. Throws on
+ * failure so the caller can degrade (win32 file symlink without Dev Mode).
+ */
+function link(src, dst, kind) {
+    if (kind === "dir") {
+        fs.symlinkSync(src, dst, process.platform === "win32" ? "junction" : "dir");
+    }
+    else {
+        fs.symlinkSync(src, dst, process.platform === "win32" ? "file" : undefined);
+    }
+}
+/** True when the existing symlink already points at src (junction paths on
+ *  win32 may carry a trailing separator / `\\?\` prefix, so compare loosely). */
+function pointsAt(dst, src) {
+    try {
+        const target = fs.readlinkSync(dst).replace(/[\\/]+$/, "");
+        return path.resolve(target) === path.resolve(src);
+    }
+    catch {
+        return false;
+    }
+}
+// Keys that must never propagate across profiles via a shared settings.json:
+// MCP server definitions (which can carry OAuth/device tokens) and any
+// token-/secret-shaped key. `.claude.json` / `.credentials.json` are already
+// excluded from sharing entirely; this closes the one shared surface that is a
+// whole-file symlink with no per-key filtering.
+const SENSITIVE_SETTINGS_KEY = /^(mcpServers$|.*(token|secret|api[_-]?key|credential|oauth).*)/i;
+/** Reason string when a settings.json carries account-scoped keys that must not
+ *  be shared, else null. Malformed JSON is not blocked — the guard targets the
+ *  known sensitive keys, not file validity. Exported for the share guard test. */
+export function settingsSharingRisk(settingsPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object")
+        return null;
+    const hit = Object.keys(parsed).find((k) => SENSITIVE_SETTINGS_KEY.test(k));
+    return hit ? `contains "${hit}" — MCP/token state is account-scoped and never shared` : null;
+}
+/** Link items from sourceDir into targetDir. Returns human-readable actions. */
+export function applySharing(sourceDir, targetDir, withHistory) {
+    const actions = [];
+    const items = withHistory ? [...BASE_ITEMS, ...HISTORY_ITEMS] : [...BASE_ITEMS];
+    const managed = new Set(readManifest(targetDir));
+    fs.mkdirSync(targetDir, { recursive: true, mode: 0o700 });
+    for (const item of items) {
+        const src = path.join(sourceDir, item.name);
+        const dst = path.join(targetDir, item.name);
+        if (!fs.existsSync(src))
+            continue;
+        let st = null;
+        try {
+            st = fs.lstatSync(dst);
+        }
+        catch {
+            /* absent */
+        }
+        if (st?.isSymbolicLink()) {
+            if (pointsAt(dst, src)) {
+                managed.add(item.name);
+                continue; // already correct
+            }
+            if (!managed.has(item.name)) {
+                actions.push(`skipped ${item.name}: foreign symlink present`);
+                continue;
+            }
+            fs.unlinkSync(dst); // ours, retarget
+        }
+        else if (st) {
+            // A regular file/dir sits where a link would go.
+            if (item.kind === "file" && managed.has(item.name)) {
+                // We linked it before; it's now a regular file → an in-profile write
+                // forked it. Don't clobber — `share sync` reconciles it.
+                actions.push(`forked ${item.name}: run 'agent-switch share sync' to re-link`);
+                continue;
+            }
+            actions.push(`skipped ${item.name}: profile has its own copy (remove it to share)`);
+            continue;
+        }
+        if (item.name === "settings.json") {
+            const risk = settingsSharingRisk(src);
+            if (risk) {
+                actions.push(`skipped ${item.name}: ${risk}`);
+                continue;
+            }
+        }
+        try {
+            link(src, dst, item.kind);
+            managed.add(item.name);
+            actions.push(`linked ${item.name}`);
+        }
+        catch (err) {
+            if (process.platform === "win32" && item.kind === "file") {
+                actions.push(`skipped ${item.name}: Windows file symlinks need Developer Mode or admin ` +
+                    `(directories are shared via junction regardless)`);
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    writeManifest(targetDir, [...managed]);
+    return actions;
+}
+/**
+ * Reconcile forked file links: a managed file that is now a regular file was
+ * forked by an in-profile `/config` write. Push its content back into the
+ * shared source (so the edit propagates, last-sync-wins), then re-link. Also
+ * re-creates a managed link that vanished. Directory links do not fork, so an
+ * unexpected directory in place of a link is reported, never clobbered.
+ */
+export function syncSharing(sourceDir, targetDir) {
+    const actions = [];
+    for (const name of readManifest(targetDir)) {
+        const src = path.join(sourceDir, name);
+        const dst = path.join(targetDir, name);
+        const kind = ITEM_KIND.get(name) ?? "file";
+        let st = null;
+        try {
+            st = fs.lstatSync(dst);
+        }
+        catch {
+            /* missing */
+        }
+        if (!st) {
+            if (fs.existsSync(src)) {
+                link(src, dst, kind);
+                actions.push(`relinked ${name} (was missing)`);
+            }
+            continue;
+        }
+        if (st.isSymbolicLink())
+            continue; // intact
+        if (st.isFile()) {
+            // Forked file: propagate the profile's edit to the source, then re-link.
+            if (name === "settings.json") {
+                const risk = settingsSharingRisk(dst);
+                if (risk) {
+                    actions.push(`skipped ${name}: ${risk} — profile edit not pushed to the shared source`);
+                    continue;
+                }
+            }
+            fs.mkdirSync(path.dirname(src), { recursive: true });
+            fs.copyFileSync(dst, src);
+            fs.unlinkSync(dst);
+            link(src, dst, "file");
+            actions.push(`synced ${name} (profile edit pushed to source, re-linked)`);
+        }
+        else {
+            actions.push(`skipped ${name}: unexpected directory where a link was — left untouched`);
+        }
+    }
+    return actions;
+}
+/** Health of each manifest-managed link in a profile, for `doctor`.
+ *  `linked` = intact symlink/junction; `forked` = a /config write replaced it
+ *  with a regular file (run `share sync`); `missing` = the link is gone. */
+export function sharedLinkHealth(targetDir) {
+    return readManifest(targetDir).map((name) => {
+        const dst = path.join(targetDir, name);
+        try {
+            return { name, state: fs.lstatSync(dst).isSymbolicLink() ? "linked" : "forked" };
+        }
+        catch {
+            return { name, state: "missing" };
+        }
+    });
+}
+/** Remove agent-switch-created links only (manifest-guarded). */
+export function removeSharing(targetDir) {
+    const actions = [];
+    for (const name of readManifest(targetDir)) {
+        const dst = path.join(targetDir, name);
+        try {
+            const st = fs.lstatSync(dst);
+            // A symlink (POSIX) or a junction (win32, reported as a symlink by
+            // lstat) is ours to remove; a forked regular file is the user's, leave it.
+            if (st.isSymbolicLink()) {
+                fs.unlinkSync(dst);
+                actions.push(`unlinked ${name}`);
+            }
+        }
+        catch {
+            /* already gone */
+        }
+    }
+    writeManifest(targetDir, []);
+    return actions;
+}

package/dist/shellenv.js

@@ -0,0 +1,116 @@
+/**
+ * Shell integration snippets, per shell — a wrapper for each provider binary
+ * (`claude`, `codex`, `agy`) plus `asw`.
+ *
+ * Each binary wrapper injects that provider's isolation env var from the
+ * resolved profile (`agent-switch dir --provider <id>`: mapping >
+ * active-for-provider > default). The wrapper must call the REAL binary, not
+ * recurse — each shell has its own escape (`command` on POSIX/fish,
+ * `Get-Command -CommandType Application` on PowerShell). cmd.exe has no clean
+ * function-wrapper story, so there is no cmd snippet — `agent-switch run <name>
+ * [--provider p]` is the cmd.exe path.
+ *
+ * `asw` convenience: bare `asw` lists all providers' profiles; `asw <name>`
+ * switches the active Claude profile; `asw <provider> <name>` switches that
+ * provider's.
+ */
+import { allProviders } from "./providers.js";
+export const SHELLS = ["zsh", "bash", "fish", "powershell"];
+/** Resolve the target shell: explicit request wins, else detect from the
+ *  environment / platform. Windows defaults to PowerShell; POSIX reads $SHELL. */
+export function detectShell(requested, env = process.env, platform = process.platform) {
+    if (requested) {
+        const r = requested.toLowerCase();
+        if (r === "pwsh" || r === "powershell")
+            return "powershell";
+        if (SHELLS.includes(r))
+            return r;
+        throw new Error(`unknown shell "${requested}" (choose: ${SHELLS.join(", ")})`);
+    }
+    if (platform === "win32")
+        return "powershell";
+    const sh = env.SHELL ?? "";
+    if (sh.includes("fish"))
+        return "fish";
+    if (sh.includes("bash"))
+        return "bash";
+    if (sh.includes("zsh"))
+        return "zsh";
+    return "zsh"; // sensible POSIX default when $SHELL is unset
+}
+function posixWrapper(binary, envVar, id) {
+    return `${binary}() {
+  local dir
+  dir="$(command agent-switch dir --provider ${id} 2>/dev/null)"
+  if [ -n "$dir" ]; then
+    ${envVar}="$dir" command ${binary} "$@"
+  else
+    command ${binary} "$@"
+  fi
+}`;
+}
+function fishWrapper(binary, envVar, id) {
+    return `function ${binary}
+    set -l dir (command agent-switch dir --provider ${id} 2>/dev/null)
+    if test -n "$dir"
+        ${envVar}=$dir command ${binary} $argv
+    else
+        command ${binary} $argv
+    end
+end`;
+}
+function powershellWrapper(binary, envVar, id) {
+    return `function ${binary} {
+    $exe = Get-Command ${binary} -CommandType Application -ErrorAction SilentlyContinue | Select-Object -First 1
+    if (-not $exe) { Write-Error '${binary} not found on PATH.'; return }
+    $dir = (& agent-switch dir --provider ${id} 2>$null)
+    if ($dir) {
+        $prev = Get-Item -Path Env:\\${envVar} -ErrorAction SilentlyContinue
+        $env:${envVar} = $dir
+        try { & $exe.Source @args } finally { if ($prev) { $env:${envVar} = $prev.Value } else { Remove-Item Env:\\${envVar} -ErrorAction SilentlyContinue } }
+    } else {
+        & $exe.Source @args
+    }
+}`;
+}
+function build(header, wrappers, asw) {
+    return [header, ...wrappers, asw].join("\n");
+}
+export function shellenvScript(shell) {
+    const providers = allProviders();
+    if (shell === "fish") {
+        const header = `# agent-switch shell integration — add to ~/.config/fish/config.fish:  agent-switch shellenv --shell fish | source`;
+        const asw = `# Convenience: "asw" lists all; "asw work" switches claude; "asw codex work" switches a provider
+function asw
+    if test (count $argv) -eq 0
+        command agent-switch list
+    else if contains -- $argv[1] claude codex antigravity
+        command agent-switch use $argv[2] --provider $argv[1]
+    else
+        command agent-switch use $argv
+    end
+end`;
+        return build(header, providers.map((p) => fishWrapper(p.binary, p.envVar, p.id)), asw);
+    }
+    if (shell === "powershell") {
+        const header = `# agent-switch shell integration — add to $PROFILE:  agent-switch shellenv --shell powershell | Out-String | Invoke-Expression`;
+        const asw = `# Convenience: "asw" lists all; "asw work" switches claude; "asw codex work" switches a provider
+function asw {
+    if ($args.Count -eq 0) { command agent-switch list; return }
+    if (@('claude','codex','antigravity') -contains $args[0]) { & agent-switch use $args[1] --provider $args[0] }
+    else { & agent-switch use @args }
+}`;
+        return build(header, providers.map((p) => powershellWrapper(p.binary, p.envVar, p.id)), asw);
+    }
+    // zsh + bash share the POSIX snippet.
+    const header = `# agent-switch shell integration — add to your rc file:  eval "$(agent-switch shellenv)"`;
+    const asw = `# Convenience: "asw" lists all; "asw work" switches claude; "asw codex work" switches a provider
+asw() {
+  if [ $# -eq 0 ]; then command agent-switch list; return; fi
+  case "$1" in
+    claude|codex|antigravity) command agent-switch use "$2" --provider "$1" ;;
+    *) command agent-switch use "$@" ;;
+  esac
+}`;
+    return build(header, providers.map((p) => posixWrapper(p.binary, p.envVar, p.id)), asw);
+}

package/dist/telemetry.js

@@ -0,0 +1,269 @@
+/**
+ * Session telemetry — the SINGLE sanctioned transcript reader (roadmap:
+ * road-to-agent-switch-session-telemetry, Phase 1, decision gate D0).
+ *
+ * Iron rule amendment (D0, verified by scripts/spikes/t1+t2 on claude 2.1.210):
+ * transcripts remain OPAQUE, version-unstable blobs *for transfer* (see
+ * sessions.ts — takeover never parses beyond line 1). READ-ONLY TELEMETRY is
+ * one of the two sanctioned body readers (the other is read-only PREVIEW,
+ * `src/session-preview.ts`, ADR-002); telemetry parsing is permitted here and
+ * ONLY here, under four gates:
+ *   1. version matrix     — SUPPORTED_CLAUDE below; unknown → low confidence.
+ *   2. pre-flight canary   — `preflightClaude`, run by the daemon on start.
+ *   3. degraded mode       — every reader returns null / low confidence rather
+ *                            than throwing; the caller shows staleness, never
+ *                            a crash or a silently-wrong number.
+ *   4. confidence scoring  — malformed-line ratio → high | low.
+ *
+ * Zero deps (node built-ins only). Pure + fixture-tested. Own-session only —
+ * this reads a session's OWN context/token state, never a cross-account view
+ * (the anti-rotation lock).
+ *
+ * Ground truth (scripts/spikes/t1, t3):
+ *   Claude assistant line: { type:"assistant", isSidechain?, sessionId,
+ *     message:{ id, model, stop_reason, usage:{ input_tokens,
+ *     cache_read_input_tokens, cache_creation_input_tokens, output_tokens }}}.
+ *     Context size = last FINALIZED (stop_reason set) MAIN-CHAIN
+ *     (isSidechain !== true) non-synthetic entry's input-side sum; output
+ *     excluded (matches the official statusline used_percentage).
+ *   Codex rollout line: { type:"event_msg", payload:{ type:"token_count",
+ *     info:{ total_token_usage:{ total_tokens, ... }, model_context_window }}}.
+ *     `info` is nullable per event → walk backward to the last non-null one.
+ */
+import * as fs from "node:fs";
+/** Bytes tailed from the end of a transcript. A live context reading only
+ *  needs the newest entries; capping the read keeps the daemon cycle cheap. */
+export const TAIL_CAP = 256 * 1024;
+/** Claude-Code major.minor prefixes the fixtures + spikes were verified on.
+ *  A running version outside this set still works but reads at low confidence
+ *  (the daemon logs a version-drift warning). */
+export const SUPPORTED_CLAUDE = ["2.1"];
+/** Effective context windows by model (transcript JSONL carries no window
+ *  size — only the statusline does, in-band). Unknown model → null (show raw
+ *  tokens, never guess a percentage). User overrides via state.json merge on
+ *  top. Codex needs no table — its rollout carries model_context_window. */
+export const CONTEXT_WINDOWS = {
+    "claude-fable-5": 1_000_000,
+    "claude-opus-4-8": 1_000_000,
+    "claude-opus-4-7": 1_000_000,
+    "claude-opus-4-6": 1_000_000,
+    "claude-sonnet-4-6": 1_000_000,
+    "claude-sonnet-5": 1_000_000,
+    "claude-sonnet-4-5": 200_000,
+    "claude-opus-4-5": 200_000,
+    "claude-opus-4-1": 200_000,
+    "claude-haiku-4-5": 200_000,
+};
+export function contextWindowFor(model, overrides = {}) {
+    if (!model)
+        return null;
+    return overrides[model] ?? CONTEXT_WINDOWS[model] ?? null;
+}
+/** Read the last `cap` bytes of a file as complete lines. When the file is
+ *  larger than the cap, the first (partial) line is dropped. Returns [] on any
+ *  error — degraded mode, never throws. */
+export function tailLines(file, cap = TAIL_CAP) {
+    let fd;
+    try {
+        fd = fs.openSync(file, "r");
+    }
+    catch {
+        return [];
+    }
+    try {
+        const size = fs.fstatSync(fd).size;
+        const start = size > cap ? size - cap : 0;
+        const len = size - start;
+        const buf = Buffer.alloc(len);
+        fs.readSync(fd, buf, 0, len, start);
+        const text = buf.toString("utf8");
+        const lines = text.split("\n");
+        if (start > 0 && lines.length > 0)
+            lines.shift(); // drop the partial first line
+        return lines.filter((l) => l.length > 0);
+    }
+    catch {
+        return [];
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function isVersionSupported(version) {
+    if (!version)
+        return false;
+    return SUPPORTED_CLAUDE.some((p) => version.startsWith(p));
+}
+/**
+ * Claude live context from a transcript. Walks the tail backward to the last
+ * FINALIZED (stop_reason set) MAIN-CHAIN (isSidechain !== true) non-synthetic
+ * assistant entry; sums the input side (input + cache_read + cache_creation),
+ * excludes output — matching the official statusline used_percentage. Subagent
+ * (sidechain) tokens never inflate the parent context reading.
+ *
+ * @param claudeVersion the running `claude --version` string, for the version
+ *   gate; unknown/unsupported → confidence "low" (still returns the number).
+ */
+export function readClaudeContext(file, opts = {}) {
+    const lines = tailLines(file, opts.cap ?? TAIL_CAP);
+    if (lines.length === 0)
+        return null;
+    let parsed = 0;
+    let malformed = 0;
+    let hit = null;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        let o;
+        try {
+            o = JSON.parse(lines[i]);
+            parsed++;
+        }
+        catch {
+            malformed++;
+            continue;
+        }
+        if (hit)
+            continue; // keep counting malformed for confidence, but we have our entry
+        if (o?.type !== "assistant")
+            continue;
+        if (o.isSidechain === true)
+            continue;
+        const m = o.message;
+        if (!m || typeof m !== "object" || !m.usage)
+            continue;
+        if (m.model === "<synthetic>")
+            continue;
+        const sr = m.stop_reason;
+        if (sr === null || sr === undefined)
+            continue; // streaming intermediate
+        const u = m.usage;
+        const inputSide = (u.input_tokens || 0) + (u.cache_read_input_tokens || 0) + (u.cache_creation_input_tokens || 0);
+        hit = { inputSide, model: typeof m.model === "string" ? m.model : null, ts: o.timestamp ?? null };
+    }
+    if (!hit)
+        return null;
+    const total = parsed + malformed;
+    const malformedRatio = total > 0 ? malformed / total : 0;
+    const confidence = malformedRatio > 0.1 || !isVersionSupported(opts.claudeVersion) ? "low" : "high";
+    const windowTokens = contextWindowFor(hit.model, opts.overrides);
+    const pct = windowTokens ? Math.round((hit.inputSide / windowTokens) * 1000) / 10 : null;
+    return {
+        provider: "claude",
+        contextTokens: hit.inputSide,
+        windowTokens,
+        pct,
+        model: hit.model,
+        timestamp: hit.ts,
+        confidence,
+    };
+}
+/**
+ * Codex live context from a rollout file. Walks the tail backward to the last
+ * `event_msg` whose `payload.type === "token_count"` carries a non-null `info`
+ * (short/aborted sessions emit info:null — verified in spikes/t3). Context =
+ * `total_token_usage.total_tokens`; window = in-band `model_context_window`.
+ */
+export function readCodexContext(file, opts = {}) {
+    const lines = tailLines(file, opts.cap ?? TAIL_CAP);
+    if (lines.length === 0)
+        return null;
+    let parsed = 0;
+    let malformed = 0;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        let o;
+        try {
+            o = JSON.parse(lines[i]);
+            parsed++;
+        }
+        catch {
+            malformed++;
+            continue;
+        }
+        const p = o?.payload ?? o;
+        if (p?.type !== "token_count")
+            continue;
+        const info = p.info;
+        if (!info || typeof info !== "object")
+            continue; // info:null — keep walking back
+        const usage = info.total_token_usage || info.last_token_usage;
+        if (!usage || !Number.isFinite(usage.total_tokens))
+            continue;
+        const windowTokens = Number.isFinite(info.model_context_window) ? info.model_context_window : null;
+        const pct = windowTokens ? Math.round((usage.total_tokens / windowTokens) * 1000) / 10 : null;
+        const total = parsed + malformed;
+        const confidence = total > 0 && malformed / total > 0.1 ? "low" : "high";
+        return {
+            provider: "codex",
+            contextTokens: usage.total_tokens,
+            windowTokens,
+            pct,
+            model: null, // codex rollout token_count carries no model id; window is in-band
+            timestamp: typeof o.timestamp === "string" ? o.timestamp : null,
+            confidence,
+        };
+    }
+    return null;
+}
+/** Provider-dispatching reader. */
+export function readContext(provider, file, opts = {}) {
+    return provider === "codex" ? readCodexContext(file, opts) : readClaudeContext(file, opts);
+}
+/** Idle guard for `compact` (Phase 4). A turn is "in flight" when the LAST
+ *  transcript line is a non-finalized assistant entry (`stop_reason` null) — we
+ *  must not type `/compact` into a running turn. Pure; degraded → false (don't
+ *  block on an unreadable file). `nowMs`/`maxAgeMs` bound how recent the
+ *  in-flight entry must be to still count (a stale null entry from a crashed
+ *  turn should not block forever). */
+export function turnInFlight(file, nowMs, maxAgeMs) {
+    const lines = tailLines(file, 64 * 1024);
+    for (let i = lines.length - 1; i >= 0; i--) {
+        let o;
+        try {
+            o = JSON.parse(lines[i]);
+        }
+        catch {
+            continue;
+        }
+        if (o?.type !== "assistant")
+            return false; // newest entry isn't an assistant turn
+        const sr = o.message?.stop_reason;
+        if (sr !== null && sr !== undefined)
+            return false; // finalized → not in flight
+        const ts = typeof o.timestamp === "string" ? Date.parse(o.timestamp) : NaN;
+        if (Number.isNaN(ts))
+            return true; // no timestamp but non-finalized → assume in flight
+        return nowMs - ts <= maxAgeMs; // recent + non-finalized → in flight
+    }
+    return false;
+}
+/** A session's context reading joined from its on-disk transcript. `file` is
+ *  the resolved transcript/rollout path; `provider` selects the reader. Thin
+ *  join so the CLI/daemon can go SessionRow → path → reading in one call. */
+export function sessionContext(sess, opts = {}) {
+    return readContext(sess.provider, sess.file, opts);
+}
+/** Resolve a Claude session's transcript path from its config dir + on-disk
+ *  encoded project dir + session id (the sessions.ts SessionRow shape). Pure
+ *  path join — does not touch the filesystem. */
+export function claudeTranscriptPath(configDir, projectDir, sessionId) {
+    return `${configDir}/projects/${projectDir}/${sessionId}.jsonl`;
+}
+/**
+ * Pre-flight canary (D0 gate 2). Validates that a transcript still parses into
+ * a usable context reading on the running Claude version. The daemon runs this
+ * on start; a failure flips the feature to degraded mode with a loud log line
+ * rather than emitting silently-wrong numbers.
+ */
+export function preflightClaude(file, claudeVersion) {
+    const reading = readClaudeContext(file, { claudeVersion });
+    if (!reading) {
+        return { ok: false, confidence: "low", reason: "no finalized main-chain assistant entry found — format may have drifted" };
+    }
+    if (!isVersionSupported(claudeVersion)) {
+        return {
+            ok: true,
+            confidence: "low",
+            reason: `claude version ${claudeVersion ?? "unknown"} outside tested set [${SUPPORTED_CLAUDE.join(", ")}] — reading at low confidence`,
+        };
+    }
+    return { ok: true, confidence: reading.confidence, reason: "ok" };
+}