@herbertgao/pi-extensions 2026.8.9 → 2026.8.11

package/node_modules/@herbertgao/resume-from/dist/adapters/claude-code/reader.js

@@ -0,0 +1,424 @@
+/**
+ * Reading a Claude Code session into the neutral vocabulary.
+ *
+ * Two rules shape everything here: no result body crosses (FR-24) and no system prompt,
+ * environment value, token or hidden reasoning crosses (FR-28, NG-7). Both are enforced by
+ * what this file builds, not by what a caller does with it.
+ */
+import { readFile, stat } from "node:fs/promises";
+import { asArray, asObject, asString, ENTRY_TYPE_ASSISTANT, ENTRY_TYPE_SUMMARY, ENTRY_TYPE_USER, parseJsonl, resolveActiveEntryPath, toIsoUtc, } from "./entries.js";
+import { listSessionFiles, sessionIdOf } from "./layout.js";
+import { redactSensitiveStructure, redactSensitiveText } from "./redaction.js";
+/** FR-25: every dropped body is marked in text the model can read. */
+export const DROPPED_MARKER = "(content dropped: imported session, may be stale)";
+export const UNREADABLE_TITLE = "(unreadable session file)";
+export const UNTITLED = "(no user message)";
+const MAX_TITLE_CHARS = 80;
+const MAX_ARGUMENT_CHARS = 80;
+const MAX_ARGUMENTS_CHARS = 200;
+/** Claude Code tools that change the repository (FR-26). */
+const MUTATING_TOOLS = new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
+/** Claude Code tools that only look. Everything else is "unknown", including Bash. */
+const READ_ONLY_TOOLS = new Set([
+    "Read",
+    "Grep",
+    "Glob",
+    "LS",
+    "NotebookRead",
+    "WebFetch",
+    "WebSearch",
+    "TodoRead",
+]);
+/** Input keys that name the file a mutating call changed. */
+const PATH_KEYS = ["file_path", "notebook_path", "path", "filePath"];
+function truncate(text, max) {
+    return text.length <= max ? text : `${text.slice(0, max)}…`;
+}
+function oneLine(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+function effectOf(toolName) {
+    if (MUTATING_TOOLS.has(toolName))
+        return "mutating";
+    if (READ_ONLY_TOOLS.has(toolName))
+        return "read-only";
+    return "unknown";
+}
+function renderValue(value) {
+    if (typeof value === "string")
+        return `'${truncate(oneLine(value), MAX_ARGUMENT_CHARS)}'`;
+    if (value === null || typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    return truncate(oneLine(JSON.stringify(value) ?? ""), MAX_ARGUMENT_CHARS);
+}
+/** The redacted source arguments, shortened so one call stays one line. */
+export function renderArguments(input) {
+    const safeInput = redactSensitiveStructure(input);
+    const object = asObject(safeInput);
+    if (object === null)
+        return safeInput === undefined ? "" : renderValue(safeInput);
+    return truncate(Object.values(object).map(renderValue).join(", "), MAX_ARGUMENTS_CHARS);
+}
+/** The text of a tool result, used for its size only. It is never carried (FR-24). */
+function resultBodyText(content) {
+    if (typeof content === "string")
+        return content;
+    const blocks = asArray(content);
+    if (blocks === null)
+        return null;
+    const texts = blocks
+        .map((block) => asString(asObject(block)?.text))
+        .filter((text) => text !== null);
+    return texts.length === 0 ? null : texts.join("\n");
+}
+/** True when the source recorded a result of any shape — text, blocks, or a structured object. */
+function hasResultBody(content) {
+    if (typeof content === "string")
+        return content !== "";
+    if (Array.isArray(content))
+        return content.length > 0;
+    return asObject(content) !== null;
+}
+/** Exactly one line about the outcome (FR-23). */
+function summarizeResult(result) {
+    if (result === undefined)
+        return { text: "no result recorded", bodyDropped: false };
+    if (result.body === null) {
+        // A structured result: its size is unknown, but it existed and it is being dropped (FR-25).
+        if (result.present) {
+            return {
+                text: result.isError ? "error, result dropped" : "result recorded",
+                bodyDropped: true,
+            };
+        }
+        return {
+            text: result.isError ? "error" : "no result recorded",
+            bodyDropped: false,
+        };
+    }
+    const lines = result.body === "" ? 0 : result.body.split("\n").length;
+    const size = `${lines} line${lines === 1 ? "" : "s"}`;
+    return {
+        text: result.isError ? `error, ${size}` : size,
+        bodyDropped: result.body.length > 0,
+    };
+}
+function toolCallRecord(toolName, input, result) {
+    const argumentsText = renderArguments(input);
+    const { text, bodyDropped } = summarizeResult(result);
+    const line = `${toolName}(${argumentsText}) → ${text}`;
+    return {
+        toolName,
+        argumentsText,
+        outcomeLine: redactSensitiveText(bodyDropped ? `${line} ${DROPPED_MARKER}` : line),
+        effect: effectOf(toolName),
+        bodyDropped,
+        // FR-54: false when no tool_result block existed for this call id (broken tail signal).
+        resultRecorded: result !== undefined,
+    };
+}
+/** Tool results, keyed by the id of the call they answer. */
+function collectResults(entries) {
+    const results = new Map();
+    for (const entry of entries) {
+        if (entry.type !== ENTRY_TYPE_USER)
+            continue;
+        const blocks = asArray(asObject(entry.message)?.content);
+        if (blocks === null)
+            continue;
+        for (const raw of blocks) {
+            const block = asObject(raw);
+            if (block === null || block.type !== "tool_result")
+                continue;
+            const id = asString(block.tool_use_id);
+            if (id === null)
+                continue;
+            results.set(id, {
+                body: resultBodyText(block.content),
+                present: hasResultBody(block.content) || asObject(entry.toolUseResult) !== null,
+                isError: block.is_error === true,
+            });
+        }
+    }
+    return results;
+}
+/** The visible text of a message. Tool-result blocks contribute nothing (FR-24). */
+function messageText(content) {
+    if (typeof content === "string")
+        return content;
+    const blocks = asArray(content);
+    if (blocks === null)
+        return "";
+    const texts = [];
+    for (const raw of blocks) {
+        const block = asObject(raw);
+        if (block?.type === "text") {
+            const text = asString(block.text);
+            if (text !== null)
+                texts.push(text);
+        }
+    }
+    return texts.join("\n");
+}
+/**
+ * Claude records slash commands, their stdout, and !-prefixed shell input as user-shaped
+ * carriers. None of it is conversation, so none of it crosses (FR-28) — a carrier kept as a
+ * turn would also become the session title when it is the first user-shaped entry.
+ */
+function isLocalCommandCarrier(content) {
+    const text = messageText(content).trim();
+    return (/(?:^|\n)<local-command-stdout>[\s\S]*<\/local-command-stdout>(?:\n|$)/.test(text) ||
+        /(?:^|\n)<local-command-caveat>[\s\S]*<\/local-command-caveat>(?:\n|$)/.test(text) ||
+        // Tag order varies by Claude Code version: <command-message> may come first.
+        /^<command-(?:name|message|args)>[\s\S]*<\/command-(?:name|message|args)>/.test(text) ||
+        /^<bash-input>[\s\S]*<\/bash-input>(?:\n|$)/.test(text) ||
+        /^<bash-std(?:out|err)>[\s\S]*<\/bash-std(?:out|err)>(?:\n|$)/.test(text));
+}
+function firstLine(text, max) {
+    const line = oneLine(text.split("\n")[0] ?? "");
+    return truncate(line, max);
+}
+/** Read a whole session file into canonical turns. Pure: it takes the text, not a path. */
+export function readSessionText(text) {
+    const parsed = parseJsonl(text);
+    const active = parsed.unreadable === null
+        ? resolveActiveEntryPath(parsed.entries)
+        : { entries: [], unreadable: null };
+    const unreadable = parsed.unreadable ?? active.unreadable;
+    const results = collectResults(active.entries);
+    const turns = [];
+    const changedPaths = [];
+    let skipped = parsed.entries.length - active.entries.length;
+    let repoPath = null;
+    let branch = null;
+    if (unreadable === null) {
+        // Repository ownership is session metadata, not active-branch metadata. Claude can reset the
+        // active chain after changing cwd, but the session still belongs to the directory it started in.
+        for (const entry of parsed.entries) {
+            if (entry.isSidechain === true)
+                continue;
+            repoPath = asString(entry.cwd);
+            if (repoPath !== null)
+                break;
+        }
+    }
+    const push = (turn) => {
+        // FR-28, security: credentials pasted as message text must not cross to a different vendor.
+        // Tool-call turns carry text: "" so the condition is a no-op there (no double-redaction).
+        const text = turn.text.length > 0 ? redactSensitiveText(turn.text) : turn.text;
+        turns.push({ ...turn, text, index: turns.length });
+    };
+    for (const entry of active.entries) {
+        if (branch === null)
+            branch = asString(entry.gitBranch);
+        // A sidechain is a separate sub-conversation, not a turn of this session.
+        if (entry.isSidechain === true) {
+            skipped++;
+            continue;
+        }
+        const timestamp = toIsoUtc(entry.timestamp);
+        if (entry.type === ENTRY_TYPE_USER && entry.isCompactSummary === true) {
+            const summary = messageText(asObject(entry.message)?.content);
+            if (summary.trim() === "") {
+                skipped++;
+            }
+            else {
+                push({
+                    role: "agent",
+                    kind: "summary",
+                    text: summary,
+                    toolCall: null,
+                    timestamp,
+                });
+            }
+            continue;
+        }
+        if (entry.type === ENTRY_TYPE_USER) {
+            // Meta entries carry injected context — environment blocks, command output, reminders.
+            // FR-28 keeps all of it out of the canonical model.
+            if (entry.isMeta === true) {
+                skipped++;
+                continue;
+            }
+            const content = asObject(entry.message)?.content;
+            if (isLocalCommandCarrier(content)) {
+                skipped++;
+                continue;
+            }
+            const text = messageText(content);
+            if (text.trim() === "")
+                continue; // a tool-result carrier; its outcome already crossed
+            push({ role: "user", kind: "message", text, toolCall: null, timestamp });
+            continue;
+        }
+        if (entry.type === ENTRY_TYPE_ASSISTANT) {
+            const content = asObject(entry.message)?.content;
+            if (typeof content === "string") {
+                push({
+                    role: "agent",
+                    kind: "message",
+                    text: content,
+                    toolCall: null,
+                    timestamp,
+                });
+                continue;
+            }
+            const blocks = asArray(content);
+            if (blocks === null) {
+                skipped++;
+                continue;
+            }
+            let pending = [];
+            const flush = () => {
+                if (pending.length === 0)
+                    return;
+                push({
+                    role: "agent",
+                    kind: "message",
+                    text: pending.join("\n"),
+                    toolCall: null,
+                    timestamp,
+                });
+                pending = [];
+            };
+            for (const raw of blocks) {
+                const block = asObject(raw);
+                const type = block?.type;
+                if (block === null) {
+                    skipped++;
+                }
+                else if (type === "text") {
+                    const value = asString(block.text);
+                    if (value !== null)
+                        pending.push(value);
+                }
+                else if (type === "tool_use") {
+                    flush();
+                    const name = asString(block.name) ?? "unknown-tool";
+                    const id = asString(block.id);
+                    const record = toolCallRecord(name, block.input, id === null ? undefined : results.get(id));
+                    if (record.effect === "mutating") {
+                        const input = asObject(block.input);
+                        for (const key of PATH_KEYS) {
+                            const value = asString(input?.[key]);
+                            if (value !== null) {
+                                if (!changedPaths.includes(value))
+                                    changedPaths.push(value);
+                                break;
+                            }
+                        }
+                    }
+                    push({
+                        role: "agent",
+                        kind: "tool-call",
+                        text: "",
+                        toolCall: record,
+                        timestamp,
+                    });
+                }
+                else {
+                    // thinking, redacted_thinking, server tool state: hidden reasoning and vendor state
+                    // never cross (FR-28, NG-8).
+                    skipped++;
+                }
+            }
+            flush();
+            continue;
+        }
+        if (entry.type === ENTRY_TYPE_SUMMARY) {
+            const summary = asString(entry.summary);
+            if (summary !== null) {
+                push({
+                    role: "agent",
+                    kind: "summary",
+                    text: summary,
+                    toolCall: null,
+                    timestamp,
+                });
+                continue;
+            }
+        }
+        // Every other entry type of C-3: system, attachment, file history, mode, and the rest.
+        skipped++;
+    }
+    const firstUser = turns.find((turn) => turn.role === "user" && turn.kind === "message");
+    const stamps = turns
+        .map((turn) => turn.timestamp)
+        .filter((value) => value !== null);
+    return {
+        turns,
+        skipped,
+        unreadable,
+        title: firstUser === undefined ? "" : firstLine(firstUser.text, MAX_TITLE_CHARS),
+        startedAt: stamps[0] ?? null,
+        updatedAt: stamps[stamps.length - 1] ?? null,
+        repoPath,
+        branch,
+        changedPaths,
+    };
+}
+/** One row per session file of the home, newest first (FR-11, FR-14). */
+export async function listSessions(home) {
+    const descriptors = [];
+    // Whole-file read and full parse per file: title, turn count, and updatedAt all require
+    // parsing the entire JSONL (FR-11). Benchmarked at ≈ 5 ms per 2 MB file (warm OS cache);
+    // 200 such files cost ≈ 1 s. Ceiling accepted; revisit if a home with thousands of
+    // large sessions makes the listing noticeably slow to users.
+    for (const file of await listSessionFiles(home)) {
+        let text;
+        let modified;
+        try {
+            text = await readFile(file, "utf8");
+            modified = (await stat(file)).mtime.toISOString();
+        }
+        catch {
+            continue;
+        }
+        const read = readSessionText(text);
+        const broken = read.unreadable !== null;
+        descriptors.push({
+            ref: { agent: "claude-code", home, id: sessionIdOf(file) },
+            title: broken ? UNREADABLE_TITLE : read.title === "" ? UNTITLED : read.title,
+            startedAt: broken ? modified : (read.startedAt ?? modified),
+            updatedAt: broken ? modified : (read.updatedAt ?? modified),
+            turnCount: broken ? 0 : read.turns.length,
+            repoPath: read.repoPath,
+            filePath: file,
+        });
+    }
+    descriptors.sort((a, b) => {
+        if (a.updatedAt !== b.updatedAt)
+            return a.updatedAt < b.updatedAt ? 1 : -1;
+        return a.ref.id < b.ref.id ? -1 : 1;
+    });
+    return descriptors;
+}
+/** One session in the neutral vocabulary. A file cut mid-entry is reported, never guessed at. */
+export async function loadSession(descriptor) {
+    let text;
+    try {
+        text = await readFile(descriptor.filePath, "utf8");
+    }
+    catch (cause) {
+        throw new Error(`cannot read Claude Code session file ${descriptor.filePath}`, { cause });
+    }
+    const read = readSessionText(text);
+    if (read.unreadable !== null) {
+        throw new Error(`unreadable Claude Code session file ${descriptor.filePath}: ${read.unreadable}`);
+    }
+    return {
+        provenance: {
+            ref: descriptor.ref,
+            title: descriptor.title,
+            startedAt: read.startedAt ?? descriptor.startedAt,
+            updatedAt: read.updatedAt ?? descriptor.updatedAt,
+            repo: {
+                // Claude Code records the branch on every entry but never the commit.
+                commit: null,
+                branch: read.branch,
+                changedPaths: read.changedPaths,
+            },
+        },
+        turns: read.turns,
+    };
+}

package/node_modules/@herbertgao/resume-from/dist/adapters/claude-code/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/claude-code/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/claude-code/validation.d.ts

@@ -0,0 +1,4 @@
+import type { SessionId } from "./contract.js";
+import { type RawEntry } from "./entries.js";
+/** Structural facts required for a committed Claude transcript to be resumable by identity. */
+export declare function isStructurallyOpenable(entries: RawEntry[], sessionId: SessionId): boolean;

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

@@ -0,0 +1,39 @@
+import { asArray, asObject, asString, ENTRY_TYPE_ASSISTANT, ENTRY_TYPE_USER, resolveActiveEntryPath, toIsoUtc, } from "./entries.js";
+function hasVisibleContent(content) {
+    return (typeof content === "string" && content.length > 0) || (asArray(content)?.length ?? 0) > 0;
+}
+function isStoredTurn(entry, sessionId) {
+    const expectedRole = entry.type === ENTRY_TYPE_ASSISTANT ? "assistant" : "user";
+    const message = asObject(entry.message);
+    if (asString(entry.uuid) === null ||
+        entry.sessionId !== sessionId ||
+        toIsoUtc(entry.timestamp) === null ||
+        (entry.parentUuid !== null && typeof entry.parentUuid !== "string") ||
+        message?.role !== expectedRole ||
+        !hasVisibleContent(message.content)) {
+        return false;
+    }
+    if (entry.type === ENTRY_TYPE_ASSISTANT) {
+        return asString(message.model) !== null && asObject(message.usage) !== null;
+    }
+    return true;
+}
+/** Structural facts required for a committed Claude transcript to be resumable by identity. */
+export function isStructurallyOpenable(entries, sessionId) {
+    let turnCount = 0;
+    for (const entry of entries) {
+        if (entry.sessionId !== undefined && entry.sessionId !== sessionId)
+            return false;
+        if (entry.type !== ENTRY_TYPE_USER && entry.type !== ENTRY_TYPE_ASSISTANT)
+            continue;
+        turnCount++;
+        if (!isStoredTurn(entry, sessionId))
+            return false;
+    }
+    if (turnCount === 0)
+        return false;
+    const active = resolveActiveEntryPath(entries);
+    if (active.unreadable !== null)
+        return false;
+    return active.entries.some((entry) => entry.type === ENTRY_TYPE_USER || entry.type === ENTRY_TYPE_ASSISTANT);
+}

package/node_modules/@herbertgao/resume-from/dist/adapters/claude-code/writer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Writing a canonical session into a new Claude Code session file.
+ *
+ * C-9 measured that a file holding one `user` entry and one `assistant` entry is listed by the
+ * native resume list and opened by `claude --resume <id>` as native turns. This module writes
+ * exactly those two entry types and nothing else: the other eight types of C-3 are eight more
+ * ways to corrupt an internal application database.
+ *
+ * Nothing here touches the filesystem except to read. `serialize` returns bytes;
+ * `src/import/landing/` creates the files (FR-49, FR-53).
+ */
+import type { CanonicalSession, ProvenanceMarker, SerializedSession, TargetProfile, ValidationDefect } from "./contract.js";
+/** The version C-9 was measured against. Written so the target reads a version it knows. */
+export declare const CLAUDE_CODE_FORMAT_VERSION = "2.1.220";
+/** The model field of an imported turn. No model produced it, and none is claimed. */
+export declare const IMPORTED_MODEL = "imported";
+export declare const USER_TYPE = "external";
+/** Bytes only: the file is created by `src/import/landing/`, never here (FR-49, FR-53). */
+export declare function serialize(session: CanonicalSession, target: TargetProfile, marker: ProvenanceMarker, context: {
+    cwd: string;
+}): SerializedSession;
+/** Every structural defect, not the first (FR-50). Empty means the bytes may be placed. */
+export declare function validate(serialized: SerializedSession): ValidationDefect[];