@cjhyy/code-shell-capability-coding 0.8.0

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

@@ -0,0 +1,57 @@
+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,45 @@
+import type { DiscoveredSession, DiscoverOptions, ExternalSessionDiscoveryScope, RecentExternalSession } 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.
+ */
+/** Discover Codex CLI sessions for the coding host. */
+export declare function discoverCodexSessions(cwd: string, codexHome?: string, opts?: DiscoverOptions): DiscoveredSession[];
+/** Discover several cwd buckets in one rollout walk. This matters for the
+ * room list: a CodeShell project and the worktrees delegated from it are one
+ * user-visible scope, while Codex stores all of them in a single global tree. */
+export declare function discoverCodexSessionsForCwds(cwds: readonly string[], codexHome?: string, opts?: DiscoverOptions, accept?: (session: {
+    sessionId: string;
+    cwd: string;
+}) => boolean): 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;
+export declare function countCodexSessionsForCwds(cwds: readonly string[], codexHome?: string): number;
+/** One Codex session discovered globally (no cwd filter), for the Pet
+ *  external-session adapter. `file` is the newest rollout for this thread.
+ *  Alias of the shared shape so codex + claude paths stay isomorphic. */
+export type RecentCodexSession = RecentExternalSession;
+/**
+ * Discover ALL recent codex sessions regardless of cwd. Same bounded-read
+ * strategy as `discoverCodexSessionsForCwds` (stat pass → recency window →
+ * first-line meta), plus per-thread dedup: a resumed thread appends a NEW
+ * rollout file with the same session_meta id, so keep only the newest file
+ * (windowed list is already mtime-descending — first hit wins).
+ */
+export declare function discoverRecentCodexSessions(opts?: DiscoverOptions, codexHome?: string, scope?: ExternalSessionDiscoveryScope): RecentCodexSession[];

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

@@ -0,0 +1,251 @@
+import { readdirSync, statSync, existsSync, openSync, readSync, closeSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { externalSessionCwdEnabled, selectRecentStats } from "./session-discovery.js";
+import { codexUserText } from "./codex-user-text.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.
+ */
+/** Discover Codex CLI sessions for the coding host. */
+export function discoverCodexSessions(cwd, codexHome = join(homedir(), ".codex"), opts = {}) {
+    return discoverCodexSessionsForCwds([cwd], codexHome, opts);
+}
+/** Discover several cwd buckets in one rollout walk. This matters for the
+ * room list: a CodeShell project and the worktrees delegated from it are one
+ * user-visible scope, while Codex stores all of them in a single global tree. */
+export function discoverCodexSessionsForCwds(cwds, codexHome = join(homedir(), ".codex"), opts = {}, accept) {
+    const root = join(codexHome, "sessions");
+    if (!existsSync(root))
+        return [];
+    const cwdSet = new Set(cwds);
+    if (cwdSet.size === 0)
+        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 windowed = selectRecentStats(statAllRollouts(root), {
+        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 || !cwdSet.has(meta.cwd))
+            continue;
+        if (accept && !accept({ sessionId: meta.id, cwd: meta.cwd }))
+            continue;
+        out.push({
+            sessionId: meta.id,
+            cwd: meta.cwd,
+            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")) {
+    return countCodexSessionsForCwds([cwd], codexHome);
+}
+export function countCodexSessionsForCwds(cwds, codexHome = join(homedir(), ".codex")) {
+    const root = join(codexHome, "sessions");
+    if (!existsSync(root))
+        return 0;
+    const cwdSet = new Set(cwds);
+    let n = 0;
+    for (const file of walkRollouts(root)) {
+        let meta;
+        try {
+            meta = readSessionMeta(file);
+        }
+        catch {
+            continue;
+        }
+        if (meta && meta.id && meta.cwd && cwdSet.has(meta.cwd))
+            n++;
+    }
+    return n;
+}
+/**
+ * Discover ALL recent codex sessions regardless of cwd. Same bounded-read
+ * strategy as `discoverCodexSessionsForCwds` (stat pass → recency window →
+ * first-line meta), plus per-thread dedup: a resumed thread appends a NEW
+ * rollout file with the same session_meta id, so keep only the newest file
+ * (windowed list is already mtime-descending — first hit wins).
+ */
+export function discoverRecentCodexSessions(opts = {}, codexHome = join(homedir(), ".codex"), scope) {
+    const root = join(codexHome, "sessions");
+    if (!existsSync(root))
+        return [];
+    const windowed = selectRecentStats(statAllRollouts(root), {
+        sinceMs: opts.sinceMs,
+        now: opts.now,
+    });
+    const limit = opts.limit && opts.limit > 0 ? opts.limit : Infinity;
+    const out = new Map();
+    for (const s of windowed) {
+        if (out.size >= limit)
+            break;
+        let meta;
+        try {
+            // Codex stores every cwd in one date-partitioned tree, so the bounded
+            // first-line session_meta is the earliest possible project boundary.
+            // Apply scope immediately here: a disabled root is never title/content
+            // probed, returned to the adapter, or tailed.
+            meta = readSessionMeta(s.file);
+        }
+        catch {
+            continue;
+        }
+        if (!meta?.id || !meta.cwd || out.has(meta.id) || !externalSessionCwdEnabled(meta.cwd, scope)) {
+            continue;
+        }
+        out.set(meta.id, {
+            sessionId: meta.id,
+            cwd: meta.cwd,
+            file: s.file,
+            lastModified: s.mtimeMs,
+            firstMessage: readFirstUserMessage(s.file),
+        });
+    }
+    return [...out.values()];
+}
+/** Stat every rollout under <root>/sessions, skipping unreadable files. */
+function statAllRollouts(root) {
+    const stats = [];
+    for (const file of walkRollouts(root)) {
+        try {
+            stats.push({ file, mtimeMs: statSync(file).mtimeMs });
+        }
+        catch {
+            continue;
+        }
+    }
+    return stats;
+}
+/** 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}]}}
+ * A user message can contain several parts: host-injected plugin/AGENTS/env
+ * context followed by the actual prompt. `codexUserText` drops the injected
+ * parts without discarding the prompt beside them.
+ *
+ * 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 t = codexUserText(p.content).trim();
+        if (!t)
+            continue;
+        return t.slice(0, 200);
+    }
+    return "";
+}

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

@@ -0,0 +1,39 @@
+import type { HistoryMessage, SessionTailEvent } 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 and host-injected plugin/AGENTS/environment user
+ * parts are skipped, while real input parts beside them remain visible.
+ */
+/** Read recent Codex CLI history for the coding host. */
+export declare function readCodexRecentHistory(cwd: string, threadId: string, limit: number, codexHome?: string): {
+    messages: HistoryMessage[];
+    hasMore: boolean;
+    totalCount: number;
+};
+/** Parse a bounded/raw Codex rollout snapshot. Shared with the desktop tail
+ * follower so its initial history and EOF cursor are atomic. */
+export declare function parseCodexRecentHistory(raw: string, limit: number): {
+    messages: HistoryMessage[];
+    hasMore: boolean;
+    totalCount: number;
+};
+/** Parse one newly-appended Codex rollout JSONL line. `response_item` is the
+ * authoritative rendered stream; parallel `event_msg.agent_message` records
+ * are deliberately ignored to avoid duplicate assistant bubbles. */
+export declare function parseCodexTranscriptLine(line: string): SessionTailEvent[];
+/** Find the rollout file whose `session_meta` matches both `threadId` and `cwd`. */
+export declare function findCodexRolloutFile(codexHome: string, cwd: string, threadId: string): string | undefined;

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

@@ -0,0 +1,249 @@
+import { readdirSync, readFileSync, statSync, existsSync, openSync, readSync, closeSync, } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { codexUserText } from "./codex-user-text.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 and host-injected plugin/AGENTS/environment user
+ * parts are skipped, while real input parts beside them remain visible.
+ */
+/** Read recent Codex CLI history for the coding host. */
+export function readCodexRecentHistory(cwd, threadId, limit, codexHome = join(homedir(), ".codex")) {
+    const empty = { messages: [], hasMore: false, totalCount: 0 };
+    const file = findCodexRolloutFile(codexHome, cwd, threadId);
+    if (!file)
+        return empty;
+    let raw;
+    try {
+        raw = readFileSync(file, "utf-8");
+    }
+    catch {
+        return empty;
+    }
+    return parseCodexRecentHistory(raw, limit);
+}
+/** Parse a bounded/raw Codex rollout snapshot. Shared with the desktop tail
+ * follower so its initial history and EOF cursor are atomic. */
+export function parseCodexRecentHistory(raw, limit) {
+    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 = (p.role === "user" ? codexUserText(p.content) : textOf(p.content)).trim();
+            if (!t)
+                continue;
+            all.push({ role: p.role, text: t });
+        }
+        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 };
+}
+/** Parse one newly-appended Codex rollout JSONL line. `response_item` is the
+ * authoritative rendered stream; parallel `event_msg.agent_message` records
+ * are deliberately ignored to avoid duplicate assistant bubbles. */
+export function parseCodexTranscriptLine(line) {
+    let d;
+    try {
+        d = JSON.parse(line);
+    }
+    catch {
+        return [];
+    }
+    if (d?.type === "event_msg" && d.payload?.type === "task_complete") {
+        return [{ type: "turn_end", reason: "completed" }];
+    }
+    if (d?.type !== "response_item" || !d.payload)
+        return [];
+    const p = d.payload;
+    if (p.type === "message" && (p.role === "user" || p.role === "assistant")) {
+        const text = (p.role === "user" ? codexUserText(p.content) : textOf(p.content)).trim();
+        if (!text)
+            return [];
+        return [{ type: p.role === "user" ? "user" : "assistant", text }];
+    }
+    if (p.type === "function_call" || p.type === "custom_tool_call") {
+        return [
+            {
+                type: "tool",
+                id: typeof p.call_id === "string" ? p.call_id : undefined,
+                name: typeof p.name === "string" ? p.name : "tool",
+                summary: summaryOf(p),
+                args: argsOf(p),
+            },
+        ];
+    }
+    if (p.type === "function_call_output" || p.type === "custom_tool_call_output") {
+        const result = typeof p.output === "string"
+            ? p.output
+            : typeof p.content === "string"
+                ? p.content
+                : JSON.stringify(p.output ?? p.content ?? "");
+        return [
+            {
+                type: "tool_result",
+                id: typeof p.call_id === "string" ? p.call_id : undefined,
+                result: result.slice(0, 4000),
+                isError: Boolean(p.is_error),
+            },
+        ];
+    }
+    return [];
+}
+/** 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`. */
+export function findCodexRolloutFile(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/codex-user-text.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Codex can store host-provided context and the user's actual prompt as
+ * separate `input_text` parts on the SAME user message. Joining every part
+ * makes room titles start with AGENTS/plugin boilerplate; dropping the whole
+ * message when its joined text starts with `<environment_context>` drops the
+ * real prompt too. Keep user-authored parts and discard only known host
+ * context parts.
+ */
+export declare function codexUserText(content: unknown): string;

package/dist/cc-orchestrator/codex-user-text.js

@@ -0,0 +1,25 @@
+/**
+ * Codex can store host-provided context and the user's actual prompt as
+ * separate `input_text` parts on the SAME user message. Joining every part
+ * makes room titles start with AGENTS/plugin boilerplate; dropping the whole
+ * message when its joined text starts with `<environment_context>` drops the
+ * real prompt too. Keep user-authored parts and discard only known host
+ * context parts.
+ */
+export function codexUserText(content) {
+    if (typeof content === "string") {
+        return isInjectedCodexContext(content) ? "" : content;
+    }
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => (typeof part?.text === "string" ? part.text : ""))
+        .filter((text) => text.trim() && !isInjectedCodexContext(text))
+        .join("\n");
+}
+function isInjectedCodexContext(text) {
+    const trimmed = text.trimStart();
+    return (trimmed.startsWith("<environment_context>") ||
+        trimmed.startsWith("<recommended_plugins>") ||
+        /^# AGENTS\.md instructions for\s/.test(trimmed));
+}