@nanonets/graft 0.24.0 → 0.25.0

package/dist/trace/codex-meta.js

@@ -0,0 +1,112 @@
+/**
+ * The facts of a Codex rollout file itself (design 4.15, 4.16): where Codex keeps its home, the rollout's first
+ * line (`session_meta`), whether it is an import (P39) or a fork (D133), and whether a receipt names this session's
+ * own rollout (HC6). Split from codex.ts, which reads the lines. Never throws; never waits on a FIFO.
+ */
+import { closeSync, constants, fstatSync, lstatSync, openSync, readFileSync, readSync, realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, isAbsolute, join, resolve, sep } from 'node:path';
+const META_BYTES = 64 * 1024;
+/** CODEX_HOME, else $HOME/.codex. */
+export function codexHome(env = process.env) {
+    return env.CODEX_HOME ? resolve(env.CODEX_HOME) : join(env.HOME || homedir(), '.codex');
+}
+const str = (v) => (typeof v === 'string' && v !== '' ? v : null);
+/** The rollout's first line's session_meta payload, read with one positioned read of at most 64 KB; null otherwise. */
+function metaPayload(rolloutPath) {
+    let fd;
+    try {
+        // Never waits on a FIFO or a device planted where the rollout should be (review): O_NONBLOCK, then a plain file.
+        fd = openSync(rolloutPath, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0));
+    }
+    catch {
+        return null;
+    }
+    try {
+        if (!fstatSync(fd).isFile())
+            return null;
+        const buf = Buffer.alloc(META_BYTES);
+        const n = readSync(fd, buf, 0, META_BYTES, 0);
+        const nl = buf.subarray(0, n).indexOf(0x0a);
+        if (nl < 0)
+            return null;
+        const e = JSON.parse(buf.subarray(0, nl).toString('utf8'));
+        const p = e?.payload;
+        return e?.type === 'session_meta' && p && typeof p === 'object' && !Array.isArray(p) && str(p.id) ? p : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** The rollout's first line, read with one positioned read of at most 64 KB; null when it isn't a session_meta line. */
+export function codexMeta(rolloutPath) {
+    const p = metaPayload(rolloutPath);
+    if (!p)
+        return null;
+    try {
+        const src = p.source;
+        const source = str(src) ?? (src && typeof src === 'object' && !Array.isArray(src) ? Object.keys(src)[0] ?? null : null);
+        const hm = p.history_mode;
+        return {
+            id: p.id, originator: str(p.originator), source, cliVersion: str(p.cli_version), cwd: str(p.cwd),
+            historyMode: hm === 'legacy' || hm === 'paginated' ? hm : null,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * D133, fail closed: a rollout whose session_meta names `forked_from_id` starts with a copy of another session's
+ * lines, and Codex lines carry no id that tells the copy from this session's own. A copied typed line whose words the
+ * person types again would count, and the copied calls with it (review). So a fork is read as nothing, like an import.
+ */
+export function isForkedRollout(rolloutPath) {
+    const f = metaPayload(rolloutPath)?.forked_from_id;
+    return f !== undefined && f !== null && f !== '';
+}
+/** The session id a rollout's file name ends with, or null. */
+const nameSession = (path) => /^rollout-.+-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/.exec(basename(path))?.[1] ?? null;
+/** P39: the rollout is one `external_agent_session_imports.json` lists (by its session id): another host's session. */
+export function isImportedRollout(path, env = process.env) {
+    try {
+        const id = codexMeta(path)?.id ?? nameSession(path);
+        if (!id)
+            return false;
+        const file = join(codexHome(env), 'external_agent_session_imports.json');
+        const st = lstatSync(file);
+        if (!st.isFile() || st.size > 16 * 1024 * 1024)
+            return false;
+        const v = JSON.parse(readFileSync(file, 'utf8'));
+        return Array.isArray(v?.records) && v.records.some((r) => r && typeof r === 'object' && r.imported_thread_id === id);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 4.16, D82's first half for Codex: the receipt names this session's own rollout where Codex keeps it: a regular
+ * file (not a link), under `codexHome(env)/sessions/` through realpath, named `rollout-*-<session>.jsonl`, whose
+ * `session_meta.id` is the session (HC6).
+ */
+export function codexTranscriptOk(r, env = process.env) {
+    try {
+        const p = r.transcriptPath;
+        if (!p || !isAbsolute(p) || !r.session || !lstatSync(p).isFile())
+            return false;
+        if (nameSession(p) !== r.session)
+            return false;
+        const root = realpathSync(join(codexHome(env), 'sessions'));
+        const file = realpathSync(p);
+        if (!file.startsWith(root + sep))
+            return false;
+        return codexMeta(file)?.id === r.session;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=codex-meta.js.map

package/dist/trace/codex-meta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-meta.js","sourceRoot":"","sources":["../../src/trace/codex-meta.ts"],"names":[],"mappings":"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"}

package/dist/trace/codex.d.ts

@@ -0,0 +1,33 @@
+import { type Memo } from './cursor.js';
+import type { EventReadOptions, TraceEvent } from './claude.js';
+import type { SkillSessionState } from './types.js';
+export type { CodexMeta } from './types.js';
+export { codexExitOf } from './codex-exec.js';
+export { codexHome, codexMeta, codexTranscriptOk, isForkedRollout, isImportedRollout } from './codex-meta.js';
+/** R7, D138: the keyed hash (HMAC-SHA256 with ~/.trail/state/typed-key, 16 hex) of a prompt's trimmed text; null with no key. */
+export declare function codexTypedSha(text: string, env?: NodeJS.ProcessEnv, opts?: {
+    create?: boolean;
+}): string | null;
+/** For the prompt hook (c8): the submitted prompt's keyed hash into `st.codex.typedShas`, the last 20. Makes the key. */
+export declare function noteCodexPrompt(st: SkillSessionState, prompt: string, env?: NodeJS.ProcessEnv): void;
+/** P30: a typed line is the person's when the prompt hook recorded its keyed hash in this session. */
+export declare function codexTypedByPerson(text: string, st: SkillSessionState | null | undefined, env?: NodeJS.ProcessEnv): boolean;
+/** The reader's state carried from line to line and saved with the cursor: open calls, running commands, the turn. */
+export type CodexMemo = Memo;
+/**
+ * The events of one parsed rollout line, for a caller that walks lines itself (the save gate's tail, a typed line
+ * at an offset). `memo` carries open calls from line to line: start it as `{}`. A typed event here is only a
+ * candidate: the dialect's `typedByPerson` judges it (P30). Never throws.
+ */
+export declare function codexLineEvents(entry: unknown, memo: CodexMemo, offset?: number, _env?: NodeJS.ProcessEnv): TraceEvent[];
+export interface CodexReadOptions extends EventReadOptions {
+    /** The session state whose `codex.typedShas` decide which typed lines are the person's (P30). None: nothing is typed. */
+    state?: SkillSessionState | null;
+}
+/**
+ * The events a Codex rollout gained since the last call with the same `cursorPath` (1a's cursor: positioned,
+ * 4 MB chunks). `.jsonl` only (P40), never an imported rollout (P39) or a forked one (D133), lines over 2 MB skipped.
+ * Never throws.
+ */
+export declare function readNewCodexEvents(rolloutPath: string, cursorPath: string, opts?: CodexReadOptions): TraceEvent[];
+//# sourceMappingURL=codex.d.ts.map

package/dist/trace/codex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../src/trace/codex.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAgB,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAItD,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAIpD,YAAY,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,iBAAiB,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAyD9G,iIAAiI;AACjI,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,GAAE,MAAM,CAAC,UAAwB,EAAE,IAAI,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,MAAM,GAAG,IAAI,CAGhI;AAED,yHAAyH;AACzH,wBAAgB,eAAe,CAAC,EAAE,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,IAAI,CAMjH;AAED,sGAAsG;AACtG,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,iBAAiB,GAAG,IAAI,GAAG,SAAS,EAAE,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAKxI;AAOD,sHAAsH;AACtH,MAAM,MAAM,SAAS,GAAG,IAAI,CAAC;AAiS7B;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,CAAC,UAAwB,GAAG,UAAU,EAAE,CASrI;AAED,MAAM,WAAW,gBAAiB,SAAQ,gBAAgB;IACxD,yHAAyH;IACzH,KAAK,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAC;CAClC;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,GAAE,gBAAqB,GAAG,UAAU,EAAE,CAqBrH"}

package/dist/trace/codex.js

@@ -0,0 +1,485 @@
+/**
+ * Reading a Codex rollout (design 4.15): `~/.codex/sessions/YYYY/MM/DD/
+ * rollout-<time>-<session>.jsonl`, one `{timestamp, type, payload}` per line,
+ * `session_meta` first. The reader turns its lines into 1a's `TraceEvent`s,
+ * so the fold, runs, checks, compile and credit are host-free from there on.
+ *
+ * Whose words a line holds is not in the line: Codex puts AGENTS.md text,
+ * environment context and hook context in user-role messages too. So a typed
+ * line counts as the person's only when its keyed hash is one the
+ * UserPromptSubmit hook recorded from the prompt the person submitted (P30,
+ * R7); anything else is injected. With no session state, or no key, nothing
+ * is typed.
+ *
+ * A command's exit survives only as text in its output's header (P34): the
+ * header decides, a structured `CommandExecution` exit beats it, and a call
+ * whose exit never shows stays open, which a run's verdict reads as not
+ * passed. Imported rollouts (Claude Code sessions Codex copied in) are never
+ * Codex work (P39); compressed `.jsonl.zst` files are never read (P40).
+ * Never throws.
+ */
+import { createHash, createHmac, randomBytes } from 'node:crypto';
+import { closeSync, lstatSync, openSync, readFileSync, writeSync } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
+import { readAppended } from './cursor.js';
+import { failedText } from './failure.js';
+import { ensurePrivateDir } from './state.js';
+import { trailHome } from '../notes/trail-home.js';
+import { isForkedRollout, isImportedRollout } from './codex-meta.js';
+import { argvCommand, codexExitOf, outputBody, outputText, patchFiles, shellPatchFiles } from './codex-exec.js';
+export { codexExitOf } from './codex-exec.js';
+export { codexHome, codexMeta, codexTranscriptOk, isForkedRollout, isImportedRollout } from './codex-meta.js';
+const MAX_LINE = 2 * 1024 * 1024;
+const MAX_TEXT = 40_000;
+const KEEP_HEAD = 8_000;
+/** A running command's output, joined across write_stdin reads: head and tail kept. */
+const JOIN_KEEP = 8 * 1024;
+const MAX_OPEN = 500;
+const MAX_RUNNING = 50;
+const TYPED_KEEP = 20;
+const str = (v) => (typeof v === 'string' && v !== '' ? v : null);
+/* ----------------------------------------------------------- typed (P30) */
+/**
+ * D138 (3): `~/.trail/state/typed-key`, 32 random bytes as hex, 0600; made only when `create`. Never `~/.trail/key`,
+ * which belongs to another feature. null when missing, a link (the file or the state folder), or odd.
+ */
+function promptKey(env, create) {
+    const dir = join(trailHome(env), 'state');
+    const path = join(dir, 'typed-key');
+    const linked = () => {
+        try {
+            return lstatSync(dir).isSymbolicLink();
+        }
+        catch {
+            return false;
+        }
+    };
+    const read = () => {
+        try {
+            if (linked())
+                return null;
+            if (!lstatSync(path).isFile())
+                return null;
+            const t = readFileSync(path, 'utf8').trim();
+            return /^[0-9a-f]{64}$/.test(t) ? Buffer.from(t, 'hex') : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const have = read();
+    if (have || !create)
+        return have;
+    try {
+        ensurePrivateDir(trailHome(env));
+        ensurePrivateDir(dir);
+        if (linked())
+            return null;
+        const fd = openSync(path, 'wx', 0o600);
+        try {
+            writeSync(fd, `${randomBytes(32).toString('hex')}\n`);
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch {
+        /* another hook made it first, or the home can't be written: read what is there */
+    }
+    return read();
+}
+/** R7, D138: the keyed hash (HMAC-SHA256 with ~/.trail/state/typed-key, 16 hex) of a prompt's trimmed text; null with no key. */
+export function codexTypedSha(text, env = process.env, opts = {}) {
+    const key = promptKey(env, opts.create === true);
+    return key ? createHmac('sha256', key).update(String(text).trim(), 'utf8').digest('hex').slice(0, 16) : null;
+}
+/** For the prompt hook (c8): the submitted prompt's keyed hash into `st.codex.typedShas`, the last 20. Makes the key. */
+export function noteCodexPrompt(st, prompt, env = process.env) {
+    const sha = codexTypedSha(prompt, env, { create: true });
+    if (!sha)
+        return;
+    const cur = st.codex && typeof st.codex === 'object' ? st.codex : { meta: null, typedShas: [] };
+    const shas = Array.isArray(cur.typedShas) ? cur.typedShas.filter((s) => typeof s === 'string') : [];
+    st.codex = { meta: cur.meta ?? null, typedShas: [...shas, sha].slice(-TYPED_KEEP) };
+}
+/** P30: a typed line is the person's when the prompt hook recorded its keyed hash in this session. */
+export function codexTypedByPerson(text, st, env = process.env) {
+    const shas = st?.codex?.typedShas;
+    if (!Array.isArray(shas) || !shas.length || !text.trim())
+        return false;
+    const sha = codexTypedSha(text, env);
+    return sha !== null && shas.includes(sha);
+}
+/** The keys fed to each running session in this read, by memo: in memory only, never in the saved cursor. */
+const KEYS_KEEP = 16 * 1024;
+const fedKeys = new WeakMap();
+function keyed(memo, session, chars) {
+    const all = fedKeys.get(memo) ?? {};
+    fedKeys.set(memo, all);
+    all[session] = `${all[session] ?? ''}${chars}`.slice(-KEYS_KEEP);
+    return all[session];
+}
+function box(memo) {
+    const m = memo;
+    const obj = (v) => v && typeof v === 'object' && !Array.isArray(v);
+    if (!obj(m.calls))
+        m.calls = {};
+    if (!obj(m.running))
+        m.running = {};
+    if (!obj(m.stdin))
+        m.stdin = {};
+    if (!obj(m.exits))
+        m.exits = {};
+    if (!Array.isArray(m.said))
+        m.said = [];
+    return m;
+}
+function trim(rec, max) {
+    const keys = Object.keys(rec);
+    for (const k of keys.slice(0, Math.max(0, keys.length - max)))
+        delete rec[k];
+}
+const clip = (t) => (t.length > MAX_TEXT ? `${t.slice(0, KEEP_HEAD)}\n…\n${t.slice(-(MAX_TEXT - KEEP_HEAD))}` : t);
+const sha8 = (t) => createHash('sha256').update(t).digest('hex').slice(0, 16);
+/** The text parts of a message's content (input_text, output_text, text). */
+function partsText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content.flatMap((p) => (p && typeof p === 'object' && typeof p.text === 'string' ? [p.text] : [])).join('\n');
+}
+function args(v) {
+    if (v && typeof v === 'object' && !Array.isArray(v))
+        return v;
+    if (typeof v !== 'string')
+        return null;
+    try {
+        const o = JSON.parse(v);
+        return o && typeof o === 'object' && !Array.isArray(o) ? o : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** A folder named by a call, against the turn's folder when relative. */
+function folder(dir, m) {
+    const d = str(dir);
+    if (!d)
+        return m.cwd;
+    return isAbsolute(d) ? d : m.cwd ? resolve(m.cwd, d) : undefined;
+}
+/** The shell command a call runs, by tool: exec_command's cmd, shell's vector, shell_command's line, local_shell_call's action. */
+function shellOf(name, a) {
+    if (name === 'exec_command')
+        return str(a.cmd) ? { cmd: a.cmd, dir: a.workdir } : null;
+    if (name === 'shell') {
+        const cmd = argvCommand(a.command);
+        return cmd ? { cmd, dir: a.workdir } : null;
+    }
+    if (name === 'shell_command')
+        return str(a.command) ? { cmd: a.command, dir: a.workdir } : null;
+    return null;
+}
+/** The events one parsed rollout line holds. `offset`: where the line starts in the file. */
+function eventsOf(e, memo, out, offset) {
+    const p = e.payload && typeof e.payload === 'object' && !Array.isArray(e.payload) ? e.payload : null;
+    if (!p)
+        return;
+    const m = box(memo);
+    const at = typeof e.timestamp === 'string' ? e.timestamp : '';
+    const where = offset === undefined ? {} : { offset };
+    const ctx = () => ({ ...(m.cwd ? { cwd: m.cwd } : {}), ...(m.branch ? { branch: m.branch } : {}) });
+    const assistant = (text) => {
+        const t = text.trim();
+        if (!t)
+            return;
+        const h = sha8(t);
+        if (m.said.includes(h))
+            return;
+        m.said = [...m.said, h].slice(-20);
+        out.push({ kind: 'assistant', text: clip(t), at, ...where });
+    };
+    const typed = (text) => {
+        const t = text.trim();
+        if (!t)
+            return;
+        m.said = [];
+        out.push({ kind: 'typed', text: t, at, ...where });
+    };
+    const injected = (text) => {
+        const t = text.trim();
+        if (t)
+            out.push({ kind: 'injected', text: clip(t), at, ...where });
+    };
+    const compaction = () => {
+        if (at && m.compactAt === at)
+            return;
+        m.compactAt = at;
+        out.push({ kind: 'compaction', at, ...where });
+    };
+    const call = (id, name, input, shell, cmd, cwd) => {
+        m.calls[id] = { name, shell, ...(cmd ? { cmd } : {}), ...(m.turn ? { turn: m.turn } : {}) };
+        trim(m.calls, MAX_OPEN);
+        const c = ctx();
+        out.push({ kind: 'tool_call', id, name, input, at, ...where, ...c, ...(cwd ? { cwd } : {}) });
+    };
+    const result = (id, code, text, shell) => {
+        const failed = code !== null && code !== 0;
+        const shown = failed ? `Exit code ${code}\n${text}` : text;
+        const ok = shell ? code === 0 && !failedText(text) : !failed;
+        out.push({ kind: 'tool_result', id, ok, text: clip(shown), at, ...where, isError: failed });
+    };
+    const closeRunning = (key, code, more) => {
+        const r = m.running[key];
+        delete m.running[key];
+        for (const [k, v] of Object.entries(m.stdin))
+            if (v === key)
+                delete m.stdin[k];
+        result(r.id, code, [r.head, r.tail, more].filter(Boolean).join('\n'), true);
+    };
+    const join = (r, text) => {
+        if (r.head.length < JOIN_KEEP) {
+            const room = JOIN_KEEP - r.head.length;
+            r.head += (r.head ? '\n' : '') + text.slice(0, room);
+            text = text.slice(room);
+        }
+        if (text)
+            r.tail = `${r.tail}\n${text}`.slice(-JOIN_KEEP);
+    };
+    if (e.type === 'session_meta') {
+        m.cwd = str(p.cwd) ?? m.cwd;
+        m.branch = str(p.git?.branch) ?? m.branch;
+        return;
+    }
+    if (e.type === 'turn_context') {
+        m.cwd = str(p.cwd) ?? m.cwd;
+        m.branch = str(p.git_branch) ?? m.branch;
+        if (str(p.turn_id))
+            m.turn = p.turn_id;
+        m.said = [];
+        return;
+    }
+    if (e.type === 'compacted')
+        return compaction();
+    if (e.type === 'event_msg') {
+        switch (p.type) {
+            case 'task_started':
+                if (str(p.turn_id))
+                    m.turn = p.turn_id;
+                m.said = [];
+                return;
+            case 'user_message':
+                return typed(typeof p.message === 'string' ? p.message : '');
+            case 'agent_message':
+                return assistant(typeof p.message === 'string' ? p.message : '');
+            case 'context_compacted':
+                return compaction();
+            case 'item_completed': {
+                const it = p.item && typeof p.item === 'object' ? p.item : null;
+                if (!it)
+                    return;
+                if (it.type === 'UserMessage')
+                    return typed(partsText(it.content));
+                if (it.type === 'AgentMessage')
+                    return assistant(partsText(it.content));
+                if (it.type === 'CommandExecution')
+                    return structured(str(it.id), argvCommand(it.command), it.exit_code, typeof it.aggregated_output === 'string' ? it.aggregated_output : '');
+                return;
+            }
+            case 'exec_command_end':
+                return structured(str(p.call_id), argvCommand(p.command), p.exit_code, typeof p.aggregated_output === 'string' ? p.aggregated_output : '');
+            default:
+                return;
+        }
+    }
+    if (e.type !== 'response_item')
+        return;
+    switch (p.type) {
+        case 'message': {
+            const text = partsText(p.content);
+            if (p.role === 'assistant')
+                return assistant(text);
+            return injected(text); // user (AGENTS.md, environment context, the prompt's copy), developer, system
+        }
+        case 'function_call': {
+            const id = str(p.call_id);
+            const name = str(p.name);
+            const a = args(p.arguments);
+            if (!id || !name || !a)
+                return;
+            if (name === 'write_stdin') {
+                const session = a.session_id !== undefined && a.session_id !== null ? String(a.session_id) : null;
+                if (session !== null)
+                    m.stdin[id] = session;
+                trim(m.stdin, MAX_RUNNING);
+                // Keystrokes into a running command (a shell, a REPL) can run anything, so they are a call of their own,
+                // with every key fed to that session so far in this read (a command split over writes is whole), never
+                // kept on disk: a login's password can be among them (review).
+                const chars = typeof a.chars === 'string' ? a.chars : '';
+                if (session !== null && chars)
+                    call(id, 'write_stdin', { session_id: session, chars: keyed(memo, session, chars) }, false);
+                return;
+            }
+            const sh = shellOf(name, a);
+            if (sh)
+                return shellCall(id, sh.cmd, folder(sh.dir, m));
+            if (name === 'apply_patch')
+                return edits(id, a.input ?? a.patch);
+            return call(id, name, a, false);
+        }
+        case 'local_shell_call': {
+            const id = str(p.call_id) ?? str(p.id);
+            const cmd = argvCommand(p.action?.command);
+            if (id && cmd)
+                shellCall(id, cmd, folder(p.action?.working_directory, m));
+            return;
+        }
+        case 'custom_tool_call': {
+            const id = str(p.call_id);
+            const name = str(p.name);
+            if (!id || !name)
+                return;
+            if (name === 'apply_patch')
+                return edits(id, p.input);
+            return call(id, name, { input: p.input }, false);
+        }
+        case 'function_call_output':
+        case 'custom_tool_call_output': {
+            const id = str(p.call_id);
+            if (!id)
+                return;
+            const text = outputText(p.output);
+            const exit = codexExitOf(text);
+            const viaStdin = m.stdin[id];
+            if (viaStdin !== undefined) {
+                delete m.stdin[id];
+                if (m.calls[id]) {
+                    delete m.calls[id];
+                    out.push({ kind: 'tool_result', id, ok: true, text: '', at, ...where, isError: false });
+                }
+                const r = m.running[viaStdin];
+                if (!r)
+                    return;
+                if (exit && 'code' in exit)
+                    return closeRunning(viaStdin, exit.code, outputBody(text));
+                join(r, outputBody(text));
+                return;
+            }
+            const open = m.calls[id];
+            delete m.calls[id];
+            const shell = open ? open.shell : true; // a call never seen (read before this window) is judged as a command
+            const known = m.exits[id];
+            delete m.exits[id];
+            if (shell && exit && 'running' in exit && known === undefined) {
+                const key = String(exit.running);
+                m.running[key] = { id, ...(open?.cmd ? { cmd: open.cmd } : {}), ...(open?.turn ? { turn: open.turn } : {}), head: '', tail: '' };
+                join(m.running[key], outputBody(text));
+                trim(m.running, MAX_RUNNING);
+                return;
+            }
+            const code = known !== undefined ? known : exit && 'code' in exit ? exit.code : null;
+            return result(id, code, outputBody(text), shell);
+        }
+        default:
+            return;
+    }
+    function edits(id, patch) {
+        const files = patchFiles(patch);
+        const list = files.length ? files : [''];
+        list.forEach((f, i) => call(i === 0 ? id : `${id}#${i + 1}`, 'Edit', { file_path: f && m.cwd && !isAbsolute(f) ? resolve(m.cwd, f) : f }, false));
+        for (let i = 2; i <= list.length; i++)
+            delete m.calls[`${id}#${i}`];
+    }
+    /**
+     * A shell call, and when it runs apply_patch (`apply_patch <<'EOF'`, `["apply_patch", patch]`, after a `cd`), which
+     * Codex applies itself, one Edit per file it names as well (review): written through the shell, a patch to
+     * ~/.trail was no edit to the tamper checks.
+     */
+    function shellCall(id, cmd, cwd) {
+        call(id, 'Bash', { command: cmd }, true, cmd, cwd);
+        shellPatchFiles(cmd, cwd ?? m.cwd).forEach((f, i) => {
+            const k = `${id}#patch${i + 1}`;
+            call(k, 'Edit', { file_path: f }, false);
+            delete m.calls[k];
+        });
+    }
+    /** A structured exit: for the open call it names (by id, else by its command on this turn), it decides ok. */
+    function structured(id, cmd, exitCode, aggregated) {
+        if (typeof exitCode !== 'number' || !Number.isInteger(exitCode))
+            return;
+        const runKey = (match) => Object.keys(m.running).find((k) => match(m.running[k]));
+        if (id && m.calls[id]?.shell) {
+            m.exits[id] = exitCode;
+            trim(m.exits, MAX_OPEN);
+            return;
+        }
+        const byId = id ? runKey((r) => r.id === id) : undefined;
+        if (byId !== undefined)
+            return closeRunning(byId, exitCode, aggregated && !m.running[byId].head ? aggregated : '');
+        if (!cmd)
+            return;
+        // By command only when exactly one open call (or running command) on this turn ran it: two `npm test` calls at
+        // once would otherwise give one's exit to the other, a failure read as a pass (review).
+        const same = Object.keys(m.calls).filter((k) => m.calls[k].shell && m.calls[k].cmd === cmd && m.calls[k].turn === m.turn && m.exits[k] === undefined);
+        const byCmd = Object.keys(m.running).filter((k) => m.running[k].cmd === cmd && m.running[k].turn === m.turn);
+        if (same.length + byCmd.length !== 1)
+            return;
+        if (same.length) {
+            m.exits[same[0]] = exitCode;
+            return;
+        }
+        closeRunning(byCmd[0], exitCode, '');
+    }
+}
+/**
+ * The events of one parsed rollout line, for a caller that walks lines itself (the save gate's tail, a typed line
+ * at an offset). `memo` carries open calls from line to line: start it as `{}`. A typed event here is only a
+ * candidate: the dialect's `typedByPerson` judges it (P30). Never throws.
+ */
+export function codexLineEvents(entry, memo, offset, _env = process.env) {
+    const out = [];
+    try {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            return out;
+        eventsOf(entry, memo, out, offset);
+    }
+    catch {
+        /* a line of an unknown shape gives what it gave */
+    }
+    return out;
+}
+/**
+ * The events a Codex rollout gained since the last call with the same `cursorPath` (1a's cursor: positioned,
+ * 4 MB chunks). `.jsonl` only (P40), never an imported rollout (P39) or a forked one (D133), lines over 2 MB skipped.
+ * Never throws.
+ */
+export function readNewCodexEvents(rolloutPath, cursorPath, opts = {}) {
+    const out = [];
+    const env = opts.env ?? process.env;
+    try {
+        if (!rolloutPath.endsWith('.jsonl') || isImportedRollout(rolloutPath, env) || isForkedRollout(rolloutPath))
+            return out;
+        readAppended(rolloutPath, cursorPath, (line, memo, offset) => {
+            if (line.length > MAX_LINE)
+                return;
+            let e;
+            try {
+                e = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            if (!e || typeof e !== 'object' || Array.isArray(e))
+                return;
+            if (opts.onEntry)
+                opts.onEntry(e, memo);
+            eventsOf(e, memo, out, offset);
+        }, opts);
+    }
+    catch {
+        /* fail open */
+    }
+    return out.map((ev) => (ev.kind === 'typed' && !codexTypedByPerson(ev.text, opts.state, env) ? { ...ev, kind: 'injected' } : ev));
+}
+//# sourceMappingURL=codex.js.map