@cjhyy/code-shell-core 0.5.0-rc.1 → 0.6.0-rc.1

package/dist/cc-orchestrator/agent-adapter.js

@@ -0,0 +1,133 @@
+/**
+ * Soft cost-guard appended to a driven CC's system prompt. Workflow fans out a
+ * fleet of agents and is the main token sink; we ask CC to surface intent and
+ * get a go-ahead before running one, so a human can intervene (rooms) and the
+ * model stays cost-aware even where Workflow isn't hard-disabled. Shared so the
+ * room's resident process can reuse the exact same wording.
+ */
+export const CC_COST_GUARD_PROMPT = "Cost guard: before invoking the Workflow tool (which fans out many agents and " +
+    "burns a lot of tokens), first state in one short message what workflow you intend " +
+    "to run and why, and ask for a go-ahead — do NOT launch a Workflow unprompted. A " +
+    "single Task sub-agent is fine without asking.";
+export const claudeAdapter = {
+    kind: "claude",
+    buildArgs(opts) {
+        // -p (print/headless) + stream-json REQUIRES --verbose (verified).
+        const args = ["-p", opts.prompt, "--output-format", "stream-json", "--verbose"];
+        if (opts.resumeSessionId)
+            args.push("--resume", opts.resumeSessionId);
+        // Hard-disallow Workflow: driving CC unattended (esp. bypassPermissions),
+        // CC's Workflow tool fans out a FLEET of agents — the real token-burn culprit
+        // (user: "自动了 2 个 workflow token 就烧没了"). A single Task (one sub-agent)
+        // is cheap, so it stays ALLOWED. (We earlier disallowed Task by mistake;
+        // Workflow is the one that fans out.) Disabling outright is cleaner than an
+        // approval round-trip this path doesn't have.
+        args.push("--disallowedTools", "Workflow");
+        // Soft constraint (belt-and-suspenders + carries to rooms where Workflow is
+        // allowed): ask CC to check in before expensive multi-agent work.
+        args.push("--append-system-prompt", CC_COST_GUARD_PROMPT);
+        args.push("--permission-mode", opts.permissionMode);
+        return args;
+    },
+    parseResult(lines) {
+        let sessionId = "";
+        let finalText = "";
+        let isError = false;
+        for (const line of lines) {
+            const t = line.trim();
+            if (!t)
+                continue;
+            let d;
+            try {
+                d = JSON.parse(t);
+            }
+            catch {
+                continue;
+            }
+            if (typeof d.session_id === "string" && !sessionId)
+                sessionId = d.session_id;
+            if (d.type === "result") {
+                if (typeof d.session_id === "string")
+                    sessionId = d.session_id;
+                if (typeof d.result === "string")
+                    finalText = d.result;
+                isError = Boolean(d.is_error);
+            }
+        }
+        return { sessionId, finalText, isError };
+    },
+};
+/**
+ * Drives the OpenAI Codex CLI via `codex exec`. Mirrors claudeAdapter but for
+ * codex's different surface:
+ *  - prompt is fed over STDIN (argv ends with a bare `-`), not argv → promptViaStdin
+ *  - permission is a spawn-time SANDBOX choice, not a per-tool approval loop:
+ *      default        → --sandbox read-only      (codex can read, not write)
+ *      acceptEdits    → --sandbox workspace-write (codex can write the workspace)
+ *      bypassPermissions → --dangerously-bypass-approvals-and-sandbox (full auto)
+ *    (Matches the only model codex supports — same choice the `wand` tool makes;
+ *    codex has no `--permission-prompt-tool stdio` equivalent.)
+ *  - JSONL event shape differs: session id is `thread.started`.thread_id, the
+ *    final answer is the last `item.completed` of item.type "agent_message", and
+ *    failure is `turn.failed` / `error` events (no `is_error` flag).
+ */
+export const codexAdapter = {
+    kind: "codex",
+    promptViaStdin: true,
+    buildArgs(opts) {
+        const args = ["exec", "--json", "--color", "never", "--skip-git-repo-check"];
+        if (opts.permissionMode === "bypassPermissions") {
+            args.push("--dangerously-bypass-approvals-and-sandbox");
+        }
+        else {
+            args.push("--sandbox", opts.permissionMode === "acceptEdits" ? "workspace-write" : "read-only");
+        }
+        // `resume <thread_id>` continues a prior codex session; the trailing `-`
+        // tells codex exec to read the prompt from stdin (we feed it there).
+        if (opts.resumeSessionId)
+            args.push("resume", opts.resumeSessionId, "-");
+        else
+            args.push("-");
+        return args;
+    },
+    parseResult(lines) {
+        let sessionId = "";
+        let finalText = "";
+        let isError = false;
+        const errorBits = [];
+        for (const line of lines) {
+            const t = line.trim();
+            if (!t)
+                continue;
+            let d;
+            try {
+                d = JSON.parse(t);
+            }
+            catch {
+                continue;
+            }
+            if (d.type === "thread.started" && typeof d.thread_id === "string")
+                sessionId = d.thread_id;
+            else if (d.type === "item.completed" && d.item?.type === "agent_message" && typeof d.item.text === "string") {
+                finalText = d.item.text; // keep the LAST agent_message
+            }
+            else if (d.type === "turn.failed") {
+                isError = true;
+                const msg = d.error?.message ?? d.error ?? "turn failed";
+                if (typeof msg === "string")
+                    errorBits.push(msg);
+            }
+            else if (d.type === "error") {
+                isError = true;
+                const msg = d.message ?? d.error?.message ?? d.error ?? "error";
+                if (typeof msg === "string")
+                    errorBits.push(msg);
+            }
+        }
+        // On failure, surface the error text as finalText (so the caller/notification
+        // shows *why*), preferring it over any partial agent_message.
+        if (isError && errorBits.length)
+            finalText = errorBits.join("\n");
+        return { sessionId, finalText, isError };
+    },
+};

package/dist/cc-orchestrator/cc-capability.d.ts

@@ -0,0 +1,19 @@
+export interface CCAvailability {
+    available: boolean;
+    command: string;
+    version?: string;
+    reason?: "not-found" | "not-executable";
+}
+/** macOS GUI-launched Electron has a minimal PATH (no Homebrew). Prepend common
+ *  CLI dirs so `claude` resolves. Mirrors resident-agent.ts's fix. */
+export declare function pathWithCommonBins(env?: NodeJS.ProcessEnv): string;
+export type ProbeRunner = (command: string) => Promise<{
+    ok: boolean;
+    stdout: string;
+}>;
+/** Probe a CLI's availability. Injectable runner for tests. */
+export declare function probeCli(command: string, runner?: ProbeRunner): Promise<CCAvailability>;
+/** Cached probe; pass force=true to re-detect (user installed CLI mid-session). */
+export declare function probeClaudeCli(force?: boolean): Promise<CCAvailability>;
+/** Cached probe for the OpenAI Codex CLI; force=true re-detects. */
+export declare function probeCodexCli(force?: boolean): Promise<CCAvailability>;

package/dist/cc-orchestrator/cc-capability.js

@@ -0,0 +1,53 @@
+import { spawn } from "node:child_process";
+import { delimiter } from "node:path";
+/** macOS GUI-launched Electron has a minimal PATH (no Homebrew). Prepend common
+ *  CLI dirs so `claude` resolves. Mirrors resident-agent.ts's fix. */
+export function pathWithCommonBins(env = process.env) {
+    const extra = ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"];
+    const current = (env.PATH ?? "").split(delimiter).filter(Boolean);
+    const merged = [];
+    for (const dir of [...extra, ...current])
+        if (!merged.includes(dir))
+            merged.push(dir);
+    return merged.join(delimiter);
+}
+/** Default runner: `<command> --version` with PATH fix. */
+const defaultRunner = (command) => new Promise((resolve, reject) => {
+    const child = spawn(command, ["--version"], {
+        env: { ...process.env, PATH: pathWithCommonBins() },
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    child.stdout?.on("data", (c) => (stdout += String(c)));
+    child.on("error", reject);
+    child.on("exit", (code) => resolve({ ok: code === 0, stdout }));
+});
+/** Probe a CLI's availability. Injectable runner for tests. */
+export async function probeCli(command, runner = defaultRunner) {
+    try {
+        const { ok, stdout } = await runner(command);
+        if (!ok)
+            return { available: false, command, reason: "not-executable" };
+        return { available: true, command, version: stdout.trim() || undefined };
+    }
+    catch (err) {
+        const code = err.code;
+        return { available: false, command, reason: code === "ENOENT" ? "not-found" : "not-executable" };
+    }
+}
+let cached;
+/** Cached probe; pass force=true to re-detect (user installed CLI mid-session). */
+export async function probeClaudeCli(force = false) {
+    if (cached && !force)
+        return cached;
+    cached = await probeCli("claude");
+    return cached;
+}
+let cachedCodex;
+/** Cached probe for the OpenAI Codex CLI; force=true re-detects. */
+export async function probeCodexCli(force = false) {
+    if (cachedCodex && !force)
+        return cachedCodex;
+    cachedCodex = await probeCli("codex");
+    return cachedCodex;
+}

package/dist/cc-orchestrator/codex-session-discovery.d.ts

@@ -0,0 +1,24 @@
+import type { DiscoveredSession, DiscoverOptions } from "./session-discovery.js";
+/**
+ * Discover codex CLI sessions for a given `cwd`, mirroring the claude-side
+ * `discoverSessions` but for codex's storage layout, which is fundamentally
+ * different:
+ *
+ *   ~/.codex/sessions/YYYY/MM/DD/rollout-<ts>-<uuid>.jsonl
+ *
+ * Unlike claude (one dir per project), codex stores rollouts by DATE, not by
+ * cwd. The cwd lives INSIDE the file: the first line is a `session_meta` event
+ * whose `payload` carries `{ id, cwd, timestamp }` (`id` is the thread id we
+ * resume by). So discovery means: walk every rollout file, read just its first
+ * line to learn its cwd, and keep the ones matching the requested project.
+ *
+ * Codex rollout files can be large, so we deliberately AVOID `readFileSync` on
+ * the whole file (the claude version reads the whole file because claude
+ * sessions are small). We read the first line for the meta, and — only for a
+ * matching file — read a bounded prefix to find the first real user message for
+ * the title. Returns the same `DiscoveredSession` shape so the UI is CLI-blind.
+ */
+export declare function discoverCodexSessions(cwd: string, codexHome?: string, opts?: DiscoverOptions): DiscoveredSession[];
+/** Count codex sessions for `cwd` (reads first-line meta of every rollout; no
+ *  window). Used so the UI knows whether a bounded list left older ones hidden. */
+export declare function countCodexSessions(cwd: string, codexHome?: string): number;

package/dist/cc-orchestrator/codex-session-discovery.js

@@ -0,0 +1,191 @@
+import { readdirSync, statSync, existsSync, openSync, readSync, closeSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { selectRecentStats } from "./session-discovery.js";
+/**
+ * Discover codex CLI sessions for a given `cwd`, mirroring the claude-side
+ * `discoverSessions` but for codex's storage layout, which is fundamentally
+ * different:
+ *
+ *   ~/.codex/sessions/YYYY/MM/DD/rollout-<ts>-<uuid>.jsonl
+ *
+ * Unlike claude (one dir per project), codex stores rollouts by DATE, not by
+ * cwd. The cwd lives INSIDE the file: the first line is a `session_meta` event
+ * whose `payload` carries `{ id, cwd, timestamp }` (`id` is the thread id we
+ * resume by). So discovery means: walk every rollout file, read just its first
+ * line to learn its cwd, and keep the ones matching the requested project.
+ *
+ * Codex rollout files can be large, so we deliberately AVOID `readFileSync` on
+ * the whole file (the claude version reads the whole file because claude
+ * sessions are small). We read the first line for the meta, and — only for a
+ * matching file — read a bounded prefix to find the first real user message for
+ * the title. Returns the same `DiscoveredSession` shape so the UI is CLI-blind.
+ */
+export function discoverCodexSessions(cwd, codexHome = join(homedir(), ".codex"), opts = {}) {
+    const root = join(codexHome, "sessions");
+    if (!existsSync(root))
+        return [];
+    // Cheap pass: stat every rollout (no read). Apply the recency window here so
+    // the meta read (first line) only runs on in-window files. The limit can't be
+    // applied yet — we don't know which files match `cwd` until we read the meta,
+    // so we'd otherwise drop matching-but-not-yet-seen sessions.
+    const stats = [];
+    for (const file of walkRollouts(root)) {
+        let st;
+        try {
+            st = statSync(file);
+        }
+        catch {
+            continue;
+        }
+        stats.push({ file, mtimeMs: st.mtimeMs });
+    }
+    const windowed = selectRecentStats(stats, { sinceMs: opts.sinceMs, now: opts.now });
+    const limit = opts.limit && opts.limit > 0 ? opts.limit : Infinity;
+    const out = [];
+    for (const s of windowed) {
+        if (out.length >= limit)
+            break;
+        let meta;
+        try {
+            meta = readSessionMeta(s.file);
+        }
+        catch {
+            continue;
+        }
+        if (!meta || !meta.id || meta.cwd !== cwd)
+            continue;
+        out.push({
+            sessionId: meta.id,
+            firstMessage: readFirstUserMessage(s.file),
+            lastModified: s.mtimeMs,
+            messageCount: 0, // not tracked for codex (would need a full scan); UI shows time + title.
+        });
+    }
+    return out;
+}
+/** Count codex sessions for `cwd` (reads first-line meta of every rollout; no
+ *  window). Used so the UI knows whether a bounded list left older ones hidden. */
+export function countCodexSessions(cwd, codexHome = join(homedir(), ".codex")) {
+    const root = join(codexHome, "sessions");
+    if (!existsSync(root))
+        return 0;
+    let n = 0;
+    for (const file of walkRollouts(root)) {
+        let meta;
+        try {
+            meta = readSessionMeta(file);
+        }
+        catch {
+            continue;
+        }
+        if (meta && meta.id && meta.cwd === cwd)
+            n++;
+    }
+    return n;
+}
+/** Recursively yield every `rollout-*.jsonl` file under `root`. */
+function* walkRollouts(root) {
+    let entries;
+    try {
+        entries = readdirSync(root);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        const full = join(root, name);
+        let st;
+        try {
+            st = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (st.isDirectory()) {
+            yield* walkRollouts(full);
+        }
+        else if (name.startsWith("rollout-") && name.endsWith(".jsonl")) {
+            yield full;
+        }
+    }
+}
+/** Read just the first line of a file (bounded), without loading the whole file. */
+function readFirstLine(file, maxBytes = 1 << 16) {
+    const fd = openSync(file, "r");
+    try {
+        const buf = Buffer.alloc(maxBytes);
+        const n = readSync(fd, buf, 0, maxBytes, 0);
+        const text = buf.toString("utf-8", 0, n);
+        const nl = text.indexOf("\n");
+        return nl === -1 ? text : text.slice(0, nl);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** Parse the first-line `session_meta` event → `{ id, cwd }`. */
+function readSessionMeta(file) {
+    const first = readFirstLine(file).trim();
+    if (!first)
+        return undefined;
+    const d = JSON.parse(first);
+    if (d.type !== "session_meta" || !d.payload)
+        return undefined;
+    return { id: d.payload.id, cwd: d.payload.cwd };
+}
+/**
+ * Find the first *real* user message text for the session title. Codex user
+ * messages look like:
+ *   {type:"response_item", payload:{type:"message", role:"user",
+ *      content:[{type:"input_text", text}]}}
+ * The very first user message is usually an `<environment_context>` injection
+ * (analogous to claude's `<local-command-caveat>`); skip those wrappers.
+ *
+ * Reads a bounded prefix of the file rather than the whole thing.
+ */
+function readFirstUserMessage(file, maxBytes = 1 << 20) {
+    let chunk;
+    try {
+        const fd = openSync(file, "r");
+        try {
+            const buf = Buffer.alloc(maxBytes);
+            const n = readSync(fd, buf, 0, maxBytes, 0);
+            chunk = buf.toString("utf-8", 0, n);
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch {
+        return "";
+    }
+    for (const line of chunk.split("\n")) {
+        if (!line.trim())
+            continue;
+        let d;
+        try {
+            d = JSON.parse(line);
+        }
+        catch {
+            // Truncated last line of the bounded read — stop scanning.
+            break;
+        }
+        const p = d?.payload;
+        if (d?.type !== "response_item" || p?.type !== "message" || p?.role !== "user")
+            continue;
+        const content = p.content;
+        const text = Array.isArray(content)
+            ? content.map((c) => (typeof c?.text === "string" ? c.text : "")).join("")
+            : typeof content === "string"
+                ? content
+                : "";
+        const t = text.trim();
+        if (!t)
+            continue;
+        if (t.startsWith("<environment_context>"))
+            continue;
+        return t.slice(0, 200);
+    }
+    return "";
+}

package/dist/cc-orchestrator/codex-session-history.d.ts

@@ -0,0 +1,25 @@
+import type { HistoryMessage } from "./session-history.js";
+/**
+ * Read the last `limit` user/assistant messages from a codex CLI session,
+ * returning the SAME shape as the claude-side `readRecentHistory` so the room
+ * UI stays CLI-blind.
+ *
+ * Codex storage differs from claude fundamentally (see `codex-session-discovery`):
+ * rollouts live under `~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl`, keyed by
+ * DATE not cwd, with the thread id inside the file's `session_meta` first line.
+ * So we first locate the rollout file whose `session_meta` matches both
+ * `threadId` and `cwd`, then parse its event stream:
+ *
+ *   - {type:"response_item", payload:{type:"message", role:"user"|"assistant",
+ *        content:[{type:"input_text"|"output_text", text}]}}  → message text
+ *   - {type:"response_item", payload:{type:"function_call", name, arguments}}   → tool
+ *   - {type:"response_item", payload:{type:"custom_tool_call", name, input}}    → tool
+ *
+ * `developer`-role messages (environment/system injections) and the leading
+ * `<environment_context>` user wrapper are skipped, mirroring discovery.
+ */
+export declare function readCodexRecentHistory(cwd: string, threadId: string, limit: number, codexHome?: string): {
+    messages: HistoryMessage[];
+    hasMore: boolean;
+    totalCount: number;
+};

package/dist/cc-orchestrator/codex-session-history.js

@@ -0,0 +1,187 @@
+import { readdirSync, readFileSync, statSync, existsSync, openSync, readSync, closeSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+/**
+ * Read the last `limit` user/assistant messages from a codex CLI session,
+ * returning the SAME shape as the claude-side `readRecentHistory` so the room
+ * UI stays CLI-blind.
+ *
+ * Codex storage differs from claude fundamentally (see `codex-session-discovery`):
+ * rollouts live under `~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl`, keyed by
+ * DATE not cwd, with the thread id inside the file's `session_meta` first line.
+ * So we first locate the rollout file whose `session_meta` matches both
+ * `threadId` and `cwd`, then parse its event stream:
+ *
+ *   - {type:"response_item", payload:{type:"message", role:"user"|"assistant",
+ *        content:[{type:"input_text"|"output_text", text}]}}  → message text
+ *   - {type:"response_item", payload:{type:"function_call", name, arguments}}   → tool
+ *   - {type:"response_item", payload:{type:"custom_tool_call", name, input}}    → tool
+ *
+ * `developer`-role messages (environment/system injections) and the leading
+ * `<environment_context>` user wrapper are skipped, mirroring discovery.
+ */
+export function readCodexRecentHistory(cwd, threadId, limit, codexHome = join(homedir(), ".codex")) {
+    const empty = { messages: [], hasMore: false, totalCount: 0 };
+    const file = findRolloutFile(codexHome, cwd, threadId);
+    if (!file)
+        return empty;
+    let raw;
+    try {
+        raw = readFileSync(file, "utf-8");
+    }
+    catch {
+        return empty;
+    }
+    const all = [];
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        let d;
+        try {
+            d = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (d?.type !== "response_item")
+            continue;
+        const p = d.payload;
+        if (!p)
+            continue;
+        if (p.type === "message" && (p.role === "user" || p.role === "assistant")) {
+            const t = textOf(p.content).trim();
+            if (!t || t.startsWith("<environment_context>"))
+                continue;
+            all.push({ role: p.role, text: t.slice(0, 4000) });
+        }
+        else if (p.type === "function_call" || p.type === "custom_tool_call") {
+            const tool = { name: typeof p.name === "string" ? p.name : "tool", summary: summaryOf(p), args: argsOf(p) };
+            const last = all[all.length - 1];
+            // Attach the tool to the preceding assistant turn; otherwise start one.
+            if (last && last.role === "assistant") {
+                (last.tools ??= []).push(tool);
+            }
+            else {
+                all.push({ role: "assistant", text: "", tools: [tool] });
+            }
+        }
+    }
+    const lim = limit > 0 ? limit : 20;
+    const start = Math.max(0, all.length - lim);
+    return { messages: all.slice(start), hasMore: start > 0, totalCount: all.length };
+}
+/** Join the text of codex content parts (`input_text`/`output_text`). */
+function textOf(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content))
+        return content.map((c) => (typeof c?.text === "string" ? c.text : "")).join("");
+    return "";
+}
+/** Build a short summary for a codex tool event from its arguments/input. */
+function summaryOf(payload) {
+    // function_call carries `arguments` as a JSON string; custom_tool_call carries `input` as a string.
+    if (typeof payload.arguments === "string") {
+        try {
+            const a = JSON.parse(payload.arguments);
+            const s = a?.cmd ?? a?.command ?? a?.file_path ?? a?.path ?? a?.workdir ?? "";
+            if (s)
+                return String(s).slice(0, 120);
+        }
+        catch {
+            /* fall through to raw */
+        }
+        return payload.arguments.slice(0, 120);
+    }
+    if (typeof payload.input === "string")
+        return payload.input.slice(0, 120);
+    return "";
+}
+/**
+ * Build the FULL structured tool args for a codex tool event so a replayed tool
+ * card can show the real parameters (not just the lossy one-field summary).
+ * `function_call.arguments` is a JSON string → parse it; `custom_tool_call.input`
+ * is a raw string → keep it under `{input}`. Returns undefined when neither is
+ * present or the JSON is malformed.
+ */
+function argsOf(payload) {
+    if (typeof payload.arguments === "string") {
+        try {
+            const a = JSON.parse(payload.arguments);
+            if (a && typeof a === "object")
+                return a;
+        }
+        catch {
+            /* malformed JSON → fall through */
+        }
+        return { arguments: payload.arguments };
+    }
+    if (typeof payload.input === "string")
+        return { input: payload.input };
+    return undefined;
+}
+/** Find the rollout file whose `session_meta` matches both `threadId` and `cwd`. */
+function findRolloutFile(codexHome, cwd, threadId) {
+    const root = join(codexHome, "sessions");
+    if (!existsSync(root))
+        return undefined;
+    for (const file of walkRollouts(root)) {
+        let meta;
+        try {
+            meta = readSessionMeta(file);
+        }
+        catch {
+            continue;
+        }
+        if (meta && meta.id === threadId && meta.cwd === cwd)
+            return file;
+    }
+    return undefined;
+}
+/** Recursively yield every `rollout-*.jsonl` file under `root`. */
+function* walkRollouts(root) {
+    let entries;
+    try {
+        entries = readdirSync(root);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        const full = join(root, name);
+        let st;
+        try {
+            st = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (st.isDirectory()) {
+            yield* walkRollouts(full);
+        }
+        else if (name.startsWith("rollout-") && name.endsWith(".jsonl")) {
+            yield full;
+        }
+    }
+}
+/** Parse the first-line `session_meta` event → `{ id, cwd }`, reading a bounded prefix. */
+function readSessionMeta(file, maxBytes = 1 << 16) {
+    const fd = openSync(file, "r");
+    let text;
+    try {
+        const buf = Buffer.alloc(maxBytes);
+        const n = readSync(fd, buf, 0, maxBytes, 0);
+        text = buf.toString("utf-8", 0, n);
+    }
+    finally {
+        closeSync(fd);
+    }
+    const nl = text.indexOf("\n");
+    const first = (nl === -1 ? text : text.slice(0, nl)).trim();
+    if (!first)
+        return undefined;
+    const d = JSON.parse(first);
+    if (d.type !== "session_meta" || !d.payload)
+        return undefined;
+    return { id: d.payload.id, cwd: d.payload.cwd };
+}

package/dist/cc-orchestrator/external-agent-changes.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Parse claude transcript JSONL text → deduped list of changed file paths.
+ * Each line is `{ message: { content: [{ type:"tool_use", name, input }] } }`.
+ * Exported for direct unit testing without a transcript file on disk.
+ */
+export declare function extractChangedFilesFromClaudeLines(text: string): string[];
+/** Locate `<claudeHome>/projects/<encodeCwd(cwd)>/<sid>.jsonl` and extract changes. */
+export declare function readClaudeChangedFiles(cwd: string, sessionId: string, claudeHome?: string): string[];
+/**
+ * Parse codex rollout JSONL text → changed file paths. Codex tool calls are
+ * `{type:"response_item", payload:{type:"function_call", name, arguments}}` or
+ * `{...custom_tool_call, input}`. apply_patch carries the patch text; write/edit
+ * carry a file path in arguments. Exported for unit testing.
+ */
+export declare function extractChangedFilesFromCodexLines(text: string): string[];
+/** Locate a codex rollout by threadId+cwd under `<codexHome>/sessions` and extract changes. */
+export declare function readCodexChangedFiles(cwd: string, threadId: string, codexHome?: string): string[];
+/** Dispatch by CLI. Unknown cli → []. Never throws. */
+export declare function readExternalChangedFiles(cli: string, cwd: string, sessionId: string): string[];