@herbertgao/pi-extensions 2026.8.9 → 2026.8.11

package/node_modules/@herbertgao/resume-from/dist/adapters/codex/readback.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Read-back is mandatory, not an optimisation. Codex stores what it is given without validating
+ * it and drops an item type it does not know without a word (C-6), so the only evidence of what
+ * was stored is what can be read back off disk (FR-52).
+ */
+import type { AgentRuntime, HomePath, SessionId, StoredSessionFacts, SwitchOutcome } from "./contract.js";
+export declare function readBackCodex(home: HomePath, sessionId: SessionId): Promise<StoredSessionFacts>;
+/** Codex declares "create-only" (C-2). The landing hands the command back instead (FR-45). */
+export declare function switchToCodex(home: HomePath, sessionId: SessionId, _runtime: AgentRuntime): Promise<SwitchOutcome>;

package/node_modules/@herbertgao/resume-from/dist/adapters/codex/readback.js

@@ -0,0 +1,47 @@
+/**
+ * Read-back is mandatory, not an optimisation. Codex stores what it is given without validating
+ * it and drops an item type it does not know without a word (C-6), so the only evidence of what
+ * was stored is what can be read back off disk (FR-52).
+ */
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { isNotFoundError, listRolloutFiles, sessionIdFromRolloutFileName, sessionsRoot, } from "./rollout.js";
+import { inspectCodexRollout } from "./validation.js";
+export async function readBackCodex(home, sessionId) {
+    const absent = {
+        sessionId,
+        itemCount: 0,
+        openable: false,
+    };
+    const filePath = await findRollout(sessionsRoot(home), sessionId);
+    if (filePath === null)
+        return absent;
+    let text;
+    try {
+        text = await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return absent;
+        throw error;
+    }
+    const inspection = inspectCodexRollout(text, sessionId);
+    return {
+        sessionId,
+        itemCount: inspection.itemCount,
+        openable: inspection.defects.length === 0,
+    };
+}
+/** Codex declares "create-only" (C-2). The landing hands the command back instead (FR-45). */
+export async function switchToCodex(home, sessionId, _runtime) {
+    throw new Error(`Codex landing is "create-only": this adapter cannot move the user into a session. ` +
+        `Run: CODEX_HOME=${home} codex resume ${sessionId}`);
+}
+/** FR-51 is a fact, not an exception: a thread that is not there reports as not openable. */
+async function findRollout(root, sessionId) {
+    for (const filePath of await listRolloutFiles(root)) {
+        if (sessionIdFromRolloutFileName(basename(filePath)) === sessionId)
+            return filePath;
+    }
+    return null;
+}

package/node_modules/@herbertgao/resume-from/dist/adapters/codex/redaction.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Credential redaction — shared implementation kept in three adapter subfolders.
+ *
+ * Files:
+ *   src/adapters/claude-code/redaction.ts
+ *   src/adapters/codex/redaction.ts
+ *   src/adapters/pi/redaction.ts
+ *
+ * These three files are byte-identical by design. A fix in one MUST be applied to all three.
+ * src/adapters/boundary.test.ts asserts byte equality and will fail if they drift.
+ *
+ * Why not a single shared module: src/adapters/contract.ts is types-only (no behaviour). A
+ * platform service would be imported as behaviour, and T-ROO-7 requires adapter-to-platform
+ * cross-module imports to go through contract.js — which can only export types, not functions.
+ */
+/** Stable replacement used for credentials that must not cross an adapter boundary. */
+export declare const REDACTED_VALUE = "[REDACTED]";
+/**
+ * Redact credentials in JSON-like tool inputs without changing the caller's value.
+ * Adapter-specific parsing stays in each adapter; this function only handles secret values.
+ */
+export declare function redactSensitiveStructure(value: unknown): unknown;
+/** Redact recognizable credentials from shell commands, headers, and unstructured arguments. */
+export declare function redactSensitiveText(text: string): string;
+/** Redact a source-recorded argument string, preserving valid JSON when it is JSON. */
+export declare function redactSensitiveArgumentsText(text: string): string;

package/node_modules/@herbertgao/resume-from/dist/adapters/codex/redaction.js

@@ -0,0 +1,132 @@
+/**
+ * Credential redaction — shared implementation kept in three adapter subfolders.
+ *
+ * Files:
+ *   src/adapters/claude-code/redaction.ts
+ *   src/adapters/codex/redaction.ts
+ *   src/adapters/pi/redaction.ts
+ *
+ * These three files are byte-identical by design. A fix in one MUST be applied to all three.
+ * src/adapters/boundary.test.ts asserts byte equality and will fail if they drift.
+ *
+ * Why not a single shared module: src/adapters/contract.ts is types-only (no behaviour). A
+ * platform service would be imported as behaviour, and T-ROO-7 requires adapter-to-platform
+ * cross-module imports to go through contract.js — which can only export types, not functions.
+ */
+/** Stable replacement used for credentials that must not cross an adapter boundary. */
+export const REDACTED_VALUE = "[REDACTED]";
+const ENVIRONMENT_KEYS = new Set(["env", "environment", "environmentvariables"]);
+const SENSITIVE_KEYS = new Set([
+    "authorization",
+    "clientsecret",
+    "cookie",
+    "credentials",
+    "password",
+    "passwd",
+    "privatekey",
+    "proxyauthorization",
+    "secret",
+    "setcookie",
+    "signingkey",
+    "token",
+]);
+const PRIVATE_KEY_PATTERN = /-----BEGIN ([A-Z0-9 ]*PRIVATE KEY)-----[\s\S]*?-----END \1-----/g;
+const AUTHORIZATION_PATTERN = /(\b(?:authorization|proxy-authorization)\s*:\s*)(?:Bearer|Basic)\s+[^\s,;]+/gi;
+const API_HEADER_PATTERN = /(\b(?:x-api-key|api-key|x-auth-token)\s*:\s*)[^\s,;]+/gi;
+const CREDENTIAL_PATTERN = /\b(?:sk-(?:proj-|svcacct-)?[A-Za-z0-9_-]{12,}|gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}|xox[baprs]-[A-Za-z0-9-]{12,}|AKIA[0-9A-Z]{16}|AIza[0-9A-Za-z_-]{30,})\b/g;
+const ASSIGNMENT_PATTERN = /\b([A-Za-z_][A-Za-z0-9_]*)(\s*=\s*)("[^"\r\n]*"|'[^'\r\n]*'|[^\s;&|]+)/g;
+const FLAG_PATTERN = /(--(?:api[-_]?key|access[-_]?token|auth[-_]?token|token|password|passwd|secret|client[-_]?secret|private[-_]?key))(=|\s+)("[^"\r\n]*"|'[^'\r\n]*'|[^\s;&|]+)/gi;
+const USER_CREDENTIAL_PATTERN = /(^|[\s;&|])(-u|--user)(=|\s+)("[^"\r\n]*"|'[^'\r\n]*'|[^\s;&|]+)/g;
+const URI_USERINFO_PATTERN = /\b([a-z][a-z0-9+.-]*:\/\/)([^\s/:@]+):([^\s/@]+)@/gi;
+// Unquoted value requires a structural delimiter or line/string end following it, OR a digit
+// somewhere in the token (C-RED-1: "token: expired" is plain English and stays, while
+// "password: hunter2 # prod" carries a credential that must not cross even mid-line).
+const JSON_LIKE_PATTERN = /(["']?)([A-Za-z_][A-Za-z0-9_-]*)\1(\s*:\s*)("[^"\r\n]*"|'[^'\r\n]*'|[^\s,;}]+(?=[,;}]|[\r\n]|$)|[^\s,;}]*\d[^\s,;}]*)/g;
+function normalizedKey(key) {
+    return key.toLowerCase().replaceAll(/[^a-z0-9]/g, "");
+}
+function isSensitiveKey(key) {
+    const normalized = normalizedKey(key);
+    return (SENSITIVE_KEYS.has(normalized) ||
+        normalized.endsWith("apikey") ||
+        normalized.endsWith("accesskey") ||
+        normalized.endsWith("password") ||
+        normalized.endsWith("privatekey") ||
+        normalized.endsWith("secret") ||
+        normalized.endsWith("token"));
+}
+function redactEnvironmentValue(value) {
+    if (Array.isArray(value))
+        return value.map(redactEnvironmentValue);
+    if (typeof value === "object" && value !== null) {
+        return Object.fromEntries(Object.keys(value).map((key) => [
+            key,
+            redactEnvironmentValue(value[key]),
+        ]));
+    }
+    return value === undefined ? undefined : REDACTED_VALUE;
+}
+function redactSensitiveArray(values) {
+    const redacted = values.map(redactSensitiveStructure);
+    for (let index = 0; index < values.length - 1; index += 1) {
+        const flag = values[index];
+        if (typeof flag === "string" &&
+            (flag.trim() === "-u" || flag.trim() === "--user") &&
+            typeof values[index + 1] === "string") {
+            redacted[index + 1] = REDACTED_VALUE;
+        }
+    }
+    return redacted;
+}
+/**
+ * Redact credentials in JSON-like tool inputs without changing the caller's value.
+ * Adapter-specific parsing stays in each adapter; this function only handles secret values.
+ */
+export function redactSensitiveStructure(value) {
+    if (typeof value === "string")
+        return redactSensitiveText(value);
+    if (Array.isArray(value))
+        return redactSensitiveArray(value);
+    if (typeof value !== "object" || value === null)
+        return value;
+    const redacted = {};
+    for (const [key, child] of Object.entries(value)) {
+        if (isSensitiveKey(key)) {
+            redacted[key] = REDACTED_VALUE;
+        }
+        else if ((normalizedKey(key) === "user" || normalizedKey(key) === "username") &&
+            typeof child === "string" &&
+            child.includes(":")) {
+            redacted[key] = REDACTED_VALUE;
+        }
+        else if (ENVIRONMENT_KEYS.has(normalizedKey(key))) {
+            redacted[key] = redactEnvironmentValue(child);
+        }
+        else {
+            redacted[key] = redactSensitiveStructure(child);
+        }
+    }
+    return redacted;
+}
+/** Redact recognizable credentials from shell commands, headers, and unstructured arguments. */
+export function redactSensitiveText(text) {
+    return text
+        .replace(PRIVATE_KEY_PATTERN, REDACTED_VALUE)
+        .replace(AUTHORIZATION_PATTERN, `$1${REDACTED_VALUE}`)
+        .replace(API_HEADER_PATTERN, `$1${REDACTED_VALUE}`)
+        .replace(FLAG_PATTERN, `$1$2${REDACTED_VALUE}`)
+        .replace(USER_CREDENTIAL_PATTERN, `$1$2$3${REDACTED_VALUE}`)
+        .replace(URI_USERINFO_PATTERN, `$1$2:${REDACTED_VALUE}@`)
+        .replace(ASSIGNMENT_PATTERN, (match, key, separator) => isSensitiveKey(key) ? `${key}${separator}${REDACTED_VALUE}` : match)
+        .replace(JSON_LIKE_PATTERN, (match, quote, key, separator) => isSensitiveKey(key) ? `${quote}${key}${quote}${separator}${REDACTED_VALUE}` : match)
+        .replace(CREDENTIAL_PATTERN, REDACTED_VALUE);
+}
+/** Redact a source-recorded argument string, preserving valid JSON when it is JSON. */
+export function redactSensitiveArgumentsText(text) {
+    try {
+        return JSON.stringify(redactSensitiveStructure(JSON.parse(text)));
+    }
+    catch {
+        return redactSensitiveText(text);
+    }
+}

package/node_modules/@herbertgao/resume-from/dist/adapters/codex/rollout.d.ts

@@ -0,0 +1,75 @@
+/**
+ * What a Codex rollout file is: where it lives, how it is named, and which entries it holds.
+ *
+ * Every fact here was confirmed against codex-cli 0.146.0 (Constraints: "Facts about Codex are
+ * verified against the installed version, never assumed"). The entry names below are the ones
+ * C-7 and C-8 measured: `event_msg` drives the visible history and the picker preview,
+ * `response_item` drives the model history only.
+ */
+import type { HomePath, SessionId } from "./contract.js";
+/** Codex reads this variable to find its home; so does this adapter (FR-2, FR-3). */
+export declare const CODEX_HOME_ENV = "CODEX_HOME";
+/** The version this module's format knowledge was verified against. */
+export declare const CODEX_CLI_VERSION = "0.146.0";
+/** Recorded in the rollout so a thread imported by this tool is identifiable. */
+export declare const CODEX_ORIGINATOR = "resume-from";
+/** `thread/list`'s default filter keeps interactive sources; "cli" is one of them (C-7). */
+export declare const CODEX_SOURCE_CLI = "cli";
+export declare const CODEX_ENTRY_SESSION_META = "session_meta";
+export declare const CODEX_ENTRY_EVENT_MSG = "event_msg";
+export declare const CODEX_ENTRY_RESPONSE_ITEM = "response_item";
+export declare const CODEX_ENTRY_COMPACTED = "compacted";
+export declare const CODEX_EVENT_USER_MESSAGE = "user_message";
+export declare const CODEX_EVENT_AGENT_MESSAGE = "agent_message";
+export declare const CODEX_ITEM_FUNCTION_CALL = "function_call";
+export declare const CODEX_ITEM_FUNCTION_CALL_OUTPUT = "function_call_output";
+export declare const CODEX_ITEM_CUSTOM_TOOL_CALL = "custom_tool_call";
+export declare const CODEX_ITEM_CUSTOM_TOOL_CALL_OUTPUT = "custom_tool_call_output";
+/**
+ * Top-level entry types codex-cli 0.146.0 writes. An entry outside this set is an entry this
+ * module does not understand: it is skipped and counted, never guessed at (C-6).
+ */
+export declare const KNOWN_ENTRY_TYPES: ReadonlySet<string>;
+/** One JSONL line of a rollout file. */
+export interface RolloutEntry {
+    timestamp: string;
+    type: string;
+    payload: Record<string, unknown>;
+}
+/** The `session_meta` payload, in the fields this module uses. */
+export interface CodexSessionMeta {
+    id: string;
+    timestamp: string | null;
+    cwd: string | null;
+    commit: string | null;
+    branch: string | null;
+}
+/** Always absolute: a HomePath is an absolute path, whatever the environment holds (FR-2). */
+export declare function defaultCodexHome(): HomePath;
+export declare function sessionsRoot(home: HomePath): string;
+/** `<home>/sessions/YYYY/MM/DD/rollout-YYYY-MM-DDTHH-mm-ss-<id>.jsonl`, as Codex lays them out. */
+export declare function rolloutFilePath(home: HomePath, sessionId: SessionId, at: Date): string;
+/** True when the file name is a rollout the picker would consider. */
+export declare function isRolloutFileName(name: string): boolean;
+/** The exact thread id encoded after Codex's fixed timestamp prefix. */
+export declare function sessionIdFromRolloutFileName(name: string): string | null;
+/** Rollouts below one sessions root, without following symlinks or hiding I/O failures. */
+export declare function listRolloutFiles(root: string): Promise<string[]>;
+export declare function parseEntry(line: string): RolloutEntry | null;
+/**
+ * A rollout that cannot be parsed line for line is truncated: Codex writes one whole JSON
+ * object per line, so a line that is not one means the file was cut mid-entry.
+ */
+export declare function parseRolloutText(text: string): {
+    entries: RolloutEntry[];
+    truncated: boolean;
+};
+export declare function stringifyRollout(entries: RolloutEntry[]): string;
+export declare function payloadType(entry: RolloutEntry): string;
+/** The entries Codex renders as history, and the only ones this module writes (C-7, C-8). */
+export declare function isMessageEvent(entry: RolloutEntry): boolean;
+export declare function messageTextOf(entry: RolloutEntry): string;
+export declare function readSessionMeta(entry: RolloutEntry): CodexSessionMeta | null;
+export declare function isNotFoundError(error: unknown): boolean;
+/** ISO-8601 UTC, or null when the source recorded nothing usable. */
+export declare function toIsoUtc(value: string | null): string | null;

package/node_modules/@herbertgao/resume-from/dist/adapters/codex/rollout.js

@@ -0,0 +1,185 @@
+/**
+ * What a Codex rollout file is: where it lives, how it is named, and which entries it holds.
+ *
+ * Every fact here was confirmed against codex-cli 0.146.0 (Constraints: "Facts about Codex are
+ * verified against the installed version, never assumed"). The entry names below are the ones
+ * C-7 and C-8 measured: `event_msg` drives the visible history and the picker preview,
+ * `response_item` drives the model history only.
+ */
+import { lstat, readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+/** Codex reads this variable to find its home; so does this adapter (FR-2, FR-3). */
+export const CODEX_HOME_ENV = "CODEX_HOME";
+/** The version this module's format knowledge was verified against. */
+export const CODEX_CLI_VERSION = "0.146.0";
+/** Recorded in the rollout so a thread imported by this tool is identifiable. */
+export const CODEX_ORIGINATOR = "resume-from";
+/** `thread/list`'s default filter keeps interactive sources; "cli" is one of them (C-7). */
+export const CODEX_SOURCE_CLI = "cli";
+export const CODEX_ENTRY_SESSION_META = "session_meta";
+export const CODEX_ENTRY_EVENT_MSG = "event_msg";
+export const CODEX_ENTRY_RESPONSE_ITEM = "response_item";
+export const CODEX_ENTRY_COMPACTED = "compacted";
+export const CODEX_EVENT_USER_MESSAGE = "user_message";
+export const CODEX_EVENT_AGENT_MESSAGE = "agent_message";
+export const CODEX_ITEM_FUNCTION_CALL = "function_call";
+export const CODEX_ITEM_FUNCTION_CALL_OUTPUT = "function_call_output";
+export const CODEX_ITEM_CUSTOM_TOOL_CALL = "custom_tool_call";
+export const CODEX_ITEM_CUSTOM_TOOL_CALL_OUTPUT = "custom_tool_call_output";
+/**
+ * Top-level entry types codex-cli 0.146.0 writes. An entry outside this set is an entry this
+ * module does not understand: it is skipped and counted, never guessed at (C-6).
+ */
+export const KNOWN_ENTRY_TYPES = new Set([
+    CODEX_ENTRY_SESSION_META,
+    CODEX_ENTRY_EVENT_MSG,
+    CODEX_ENTRY_RESPONSE_ITEM,
+    "turn_context",
+    "world_state",
+    CODEX_ENTRY_COMPACTED,
+    "inter_agent_communication_metadata",
+]);
+/** Always absolute: a HomePath is an absolute path, whatever the environment holds (FR-2). */
+export function defaultCodexHome() {
+    const configured = process.env[CODEX_HOME_ENV];
+    return configured !== undefined && configured !== ""
+        ? resolve(configured)
+        : join(homedir(), ".codex");
+}
+export function sessionsRoot(home) {
+    return join(home, "sessions");
+}
+/** `<home>/sessions/YYYY/MM/DD/rollout-YYYY-MM-DDTHH-mm-ss-<id>.jsonl`, as Codex lays them out. */
+export function rolloutFilePath(home, sessionId, at) {
+    const iso = at.toISOString();
+    const [date = "", time = ""] = iso.slice(0, 19).split("T");
+    const [year = "", month = "", day = ""] = date.split("-");
+    const stamp = `${date}T${time.replaceAll(":", "-")}`;
+    return join(sessionsRoot(home), year, month, day, `rollout-${stamp}-${sessionId}.jsonl`);
+}
+/** True when the file name is a rollout the picker would consider. */
+export function isRolloutFileName(name) {
+    return name.startsWith("rollout-") && name.endsWith(".jsonl");
+}
+/** The exact thread id encoded after Codex's fixed timestamp prefix. */
+export function sessionIdFromRolloutFileName(name) {
+    const match = /^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-(.+)\.jsonl$/.exec(name);
+    return match?.[1] ?? null;
+}
+/** Rollouts below one sessions root, without following symlinks or hiding I/O failures. */
+export async function listRolloutFiles(root) {
+    const rootInfo = await lstat(root).catch((error) => {
+        if (isNotFoundError(error))
+            return null;
+        throw error;
+    });
+    if (rootInfo === null)
+        return [];
+    if (rootInfo.isSymbolicLink())
+        return [];
+    if (!rootInfo.isDirectory())
+        throw new Error(`Codex sessions root is not a directory: ${root}`);
+    const found = [];
+    const walk = async (directory) => {
+        for (const entry of (await readdir(directory, { withFileTypes: true })).sort((left, right) => left.name.localeCompare(right.name))) {
+            const full = join(directory, entry.name);
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory())
+                await walk(full);
+            else if (entry.isFile() && isRolloutFileName(entry.name))
+                found.push(full);
+        }
+    };
+    await walk(root);
+    return found;
+}
+export function parseEntry(line) {
+    let value;
+    try {
+        value = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    if (typeof value !== "object" || value === null)
+        return null;
+    const record = value;
+    if (typeof record.type !== "string")
+        return null;
+    const payload = record.payload;
+    return {
+        timestamp: typeof record.timestamp === "string" ? record.timestamp : "",
+        type: record.type,
+        payload: typeof payload === "object" && payload !== null ? payload : {},
+    };
+}
+/**
+ * A rollout that cannot be parsed line for line is truncated: Codex writes one whole JSON
+ * object per line, so a line that is not one means the file was cut mid-entry.
+ */
+export function parseRolloutText(text) {
+    const entries = [];
+    let truncated = false;
+    for (const line of text.split("\n")) {
+        if (line.trim() === "")
+            continue;
+        const entry = parseEntry(line);
+        if (entry === null)
+            truncated = true;
+        else
+            entries.push(entry);
+    }
+    return { entries, truncated };
+}
+export function stringifyRollout(entries) {
+    return entries.map((entry) => `${JSON.stringify(entry)}\n`).join("");
+}
+export function payloadType(entry) {
+    const type = entry.payload.type;
+    return typeof type === "string" ? type : "";
+}
+/** The entries Codex renders as history, and the only ones this module writes (C-7, C-8). */
+export function isMessageEvent(entry) {
+    if (entry.type !== CODEX_ENTRY_EVENT_MSG)
+        return false;
+    const type = payloadType(entry);
+    return type === CODEX_EVENT_USER_MESSAGE || type === CODEX_EVENT_AGENT_MESSAGE;
+}
+export function messageTextOf(entry) {
+    const message = entry.payload.message;
+    return typeof message === "string" ? message : "";
+}
+export function readSessionMeta(entry) {
+    if (entry.type !== CODEX_ENTRY_SESSION_META)
+        return null;
+    const id = entry.payload.id ?? entry.payload.session_id;
+    if (typeof id !== "string" || id === "")
+        return null;
+    const git = entry.payload.git;
+    const gitRecord = typeof git === "object" && git !== null ? git : {};
+    return {
+        id,
+        timestamp: stringOrNull(entry.payload.timestamp) ?? stringOrNull(entry.timestamp),
+        cwd: stringOrNull(entry.payload.cwd),
+        commit: stringOrNull(gitRecord.commit_hash),
+        branch: stringOrNull(gitRecord.branch),
+    };
+}
+function stringOrNull(value) {
+    return typeof value === "string" && value !== "" ? value : null;
+}
+export function isNotFoundError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ENOENT");
+}
+/** ISO-8601 UTC, or null when the source recorded nothing usable. */
+export function toIsoUtc(value) {
+    if (value === null)
+        return null;
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? null : new Date(parsed).toISOString();
+}

package/node_modules/@herbertgao/resume-from/dist/adapters/codex/validation.d.ts

@@ -0,0 +1,7 @@
+import type { ValidationDefect } from "./contract.js";
+export interface CodexRolloutInspection {
+    itemCount: number;
+    defects: ValidationDefect[];
+}
+/** The single file-level check used both before placement and during read-back. */
+export declare function inspectCodexRollout(text: string, expectedSessionId: string): CodexRolloutInspection;

package/node_modules/@herbertgao/resume-from/dist/adapters/codex/validation.js

@@ -0,0 +1,78 @@
+import { isAbsolute } from "node:path";
+import { CODEX_ENTRY_RESPONSE_ITEM, CODEX_ENTRY_SESSION_META, CODEX_EVENT_USER_MESSAGE, isMessageEvent, messageTextOf, parseRolloutText, payloadType, readSessionMeta, } from "./rollout.js";
+/** The single file-level check used both before placement and during read-back. */
+export function inspectCodexRollout(text, expectedSessionId) {
+    const defects = [];
+    const { entries, truncated } = parseRolloutText(text);
+    if (truncated) {
+        defects.push({
+            path: "files/0/bytes",
+            message: "a rollout line is not one whole JSON object",
+        });
+    }
+    const metadataEntries = entries.filter((entry) => entry.type === CODEX_ENTRY_SESSION_META);
+    const metaEntry = entries[0];
+    if (metaEntry === undefined || metaEntry.type !== CODEX_ENTRY_SESSION_META) {
+        defects.push({
+            path: "items/0",
+            message: "the first entry must be session metadata, or the picker cannot list the thread",
+        });
+    }
+    else {
+        const meta = readSessionMeta(metaEntry);
+        if (meta === null ||
+            meta.id !== expectedSessionId ||
+            metaEntry.payload.id !== expectedSessionId ||
+            metaEntry.payload.session_id !== expectedSessionId) {
+            defects.push({
+                path: "items/0/payload/id",
+                message: "session metadata names a different session",
+            });
+        }
+        if (meta === null || meta.cwd === null || !isAbsolute(meta.cwd)) {
+            defects.push({
+                path: "items/0/payload/cwd",
+                message: "session metadata needs an absolute cwd",
+            });
+        }
+        for (const field of ["originator", "cli_version"]) {
+            if (typeof metaEntry.payload[field] !== "string" || metaEntry.payload[field] === "") {
+                defects.push({
+                    path: `items/0/payload/${field}`,
+                    message: `session metadata needs ${field}`,
+                });
+            }
+        }
+        if (Number.isNaN(Date.parse(String(metaEntry.payload.timestamp)))) {
+            defects.push({
+                path: "items/0/payload/timestamp",
+                message: "session metadata needs an ISO timestamp",
+            });
+        }
+    }
+    if (metadataEntries.length !== 1) {
+        defects.push({
+            path: "items",
+            message: `a rollout needs exactly one session metadata entry, not ${metadataEntries.length}`,
+        });
+    }
+    const firstUser = entries.find((entry) => payloadType(entry) === CODEX_EVENT_USER_MESSAGE && isMessageEvent(entry));
+    if (firstUser === undefined || messageTextOf(firstUser).trim() === "") {
+        defects.push({
+            path: "items",
+            message: "no non-empty user_message entry, so the preview would be empty and thread/list would not show the thread",
+        });
+    }
+    for (const [index, entry] of entries.entries()) {
+        if (entry.type === CODEX_ENTRY_RESPONSE_ITEM) {
+            defects.push({
+                path: `items/${index}`,
+                message: "response_item entries fill the model history only — C-7 measured that as invisible",
+            });
+        }
+    }
+    return {
+        itemCount: entries.filter(isMessageEvent).length,
+        defects,
+    };
+}

package/node_modules/@herbertgao/resume-from/dist/adapters/codex/write.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The target role: a canonical session becomes a new Codex thread file.
+ *
+ * C-7 measured what does not work: the injection API writes `response_item` entries, and the
+ * resulting thread is absent from `thread/list` and shows zero turns on resume. C-8 measured what
+ * does: a file with session metadata and one `event_msg` entry per turn is listed, previewed and
+ * resumed with native turns. This module writes that file, and never calls that API.
+ */
+import type { CanonicalSession, ProvenanceMarker, SerializedSession, TargetProfile, ValidationDefect } from "./contract.js";
+export type { CodexSerializeDeps } from "./contract.js";
+import type { CodexSerializeDeps } from "./contract.js";
+export declare function serializeCodex(session: CanonicalSession, target: TargetProfile, marker: ProvenanceMarker, deps: CodexSerializeDeps): SerializedSession;
+/**
+ * FR-50, read against C-7's symptoms: a thread without metadata or without a non-empty first
+ * user message is invisible to the picker, and a `response_item` entry is the shape C-8 replaced.
+ */
+export declare function validateCodex(serialized: SerializedSession): ValidationDefect[];