@herbertgao/pi-extensions 2026.8.9 → 2026.8.10

package/README.md

@@ -8,6 +8,8 @@ Aggregate installer for HerbertGao-maintained Pi extensions and pinned upstream
 pi install npm:@herbertgao/pi-extensions
 ```
 
+Requires Node.js 24 or newer.
+
 The package bundles 11 active `@herbertgao/*` child packages, including `@herbertgao/pi-cc-extensions`, plus the following upstream packages under their original names:
 
 - `@dietrichgebert/ponytail@4.9.0`
@@ -19,6 +21,7 @@ The package bundles 11 active `@herbertgao/*` child packages, including `@herber
 - `pi-lens@4.1.1`
 - `pi-web-access@0.24.2`
 - `remote-pi@0.7.0`
+- `resume-from@0.2.0`
 - `@czottmann/pi-automode@1.12.0`
 
 Pi loads their extensions and skills through `node_modules/` paths inside one package root. The upstream companions are pinned and bundled, not forked or renamed.

package/node_modules/resume-from/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alexei Led
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/resume-from/README.md

@@ -0,0 +1,161 @@
+# resume-from
+
+[![Release](https://github.com/alexei-led/resume-from/actions/workflows/release.yml/badge.svg)](https://github.com/alexei-led/resume-from/actions/workflows/release.yml)
+[![npm](https://img.shields.io/npm/v/resume-from)](https://www.npmjs.com/package/resume-from)
+
+![A source coding-agent session is normalized, filtered, previewed, and written as a new native session while the source remains unchanged.](assets/resume-from-card.svg)
+
+Continue an AI coding session in another terminal agent or another profile of the same agent.
+
+`resume-from` converts saved sessions between **Pi**, **Claude Code**, and **Codex**. Use it when you want a different model, provider, tool harness, or account without rebuilding the task context by hand.
+
+## Why this exists
+
+Coding agents save conversations in different locations and vendor-specific formats. A Codex thread is not a Pi session. A Claude Code session cannot be opened directly by Codex.
+
+You can ask the next agent to read another tool's raw session file, but then the model must understand that format and decide which internal data is safe or useful. `resume-from` performs that conversion before the target agent starts:
+
+1. Find sessions for the current Git repository.
+2. Parse the source agent's format into a common conversation model.
+3. Remove tool-result bodies and vendor-only state.
+4. Fit the useful history to the target context budget.
+5. Show exactly what will be imported.
+6. After confirmation, write a new session in the target agent's native format.
+
+The source session is never changed.
+
+## Use it when
+
+- **You want another model or provider.** Start the target agent with the model you want, then import the session.
+- **You want another harness.** Keep the task context while changing terminal UI, tools, permissions, extensions, or agent behavior.
+- **You hit a rate or usage limit.** Continue through another installed agent or account instead of waiting or reconstructing the task.
+- **You need another profile.** Move between work, personal, or team homes, including two profiles of the same agent.
+- **The current context is too large.** Import a budgeted history into a fresh native session.
+- **You want an independent handoff.** Create a target-side copy for continued work or review while preserving the original session.
+
+`resume-from` moves conversation context. It does not copy the repository or migrate a running process. The target agent must have access to the same working tree.
+
+## Supported transfers
+
+Every source-to-target direction is supported, including transfers within the same agent:
+
+| Source \ Target | Pi  | Claude Code | Codex |
+| --------------- | :-: | :---------: | :---: |
+| **Pi**          |  ✓  |      ✓      |   ✓   |
+| **Claude Code** |  ✓  |      ✓      |   ✓   |
+| **Codex**       |  ✓  |      ✓      |   ✓   |
+
+The landing behavior depends on the target:
+
+| Target          | After confirmation                                               |
+| --------------- | ---------------------------------------------------------------- |
+| **Pi**          | Writes and opens the imported session in the current Pi process. |
+| **Claude Code** | Writes the session and prints `claude --resume <session-id>`.    |
+| **Codex**       | Writes the thread and prints `codex resume <thread-id>`.         |
+
+## What crosses the boundary
+
+The importer keeps the parts needed to continue the task, subject to the target token budget:
+
+- User prompts and agent replies.
+- Compaction summaries.
+- Tool activity as **non-replayable plain text**: tool name, recorded arguments, and a one-line outcome.
+- Changed-file paths derived from mutating tool activity.
+- Source provenance and a summary of anything dropped.
+
+It excludes:
+
+- Tool-result bodies, which may be large, stale, or sensitive.
+- Replayable tool-call structures.
+- Hidden reasoning, system prompts, environment blocks, API keys, telemetry, and vendor process state.
+
+A dropped result is marked in the imported conversation. The target agent can reread the current file or rerun a command when it needs fresh state.
+
+### Context budget
+
+By default, the imported history may use up to 30% of the target context window. The first request, recent turns, summaries, and changed-file records are pinned. If older unpinned turns must be removed, the preview reports them. If the pinned content alone does not fit, the import stops before writing.
+
+## Install in the destination agent
+
+Install `resume-from` in the agent that will receive the new session.
+
+### Pi
+
+```sh
+pi install npm:resume-from
+```
+
+Restart Pi, then run `/resume-from`.
+
+### Claude Code
+
+```sh
+claude plugin marketplace add alexei-led/resume-from
+claude plugin install resume-from@alexei-led-resume-from
+```
+
+### Codex
+
+```sh
+codex plugin marketplace add alexei-led/resume-from
+codex plugin add resume-from@alexei-led-resume-from
+```
+
+The Codex prompt runs the matching published `resume-from` package through `npx`. Its first use needs npm registry access.
+
+## Run the first transfer
+
+Run the command from the Git repository that owns the source session.
+
+### In Pi
+
+1. Run `/resume-from`.
+2. Select a source session in the native picker.
+3. Read the preview.
+4. Confirm.
+
+Pi opens the imported session with an empty prompt. You decide when to continue.
+
+### In Claude Code or Codex
+
+1. Run `/resume-from` to list matching sessions.
+2. Run `/resume-from <row>` to preview one.
+3. Run the token-bearing `/resume-from <row> --confirm <token>` command printed by the preview.
+4. Run the native resume command printed by the tool.
+
+You can also select an exact session ID or file path. Selection by path does not bypass the current-repository check.
+
+## Safety properties
+
+- **Read-only source:** source homes and session files are not modified.
+- **Explicit write:** cancellation or a blocked preview writes nothing.
+- **Add-only target:** the importer creates target files; it does not replace or delete existing sessions.
+- **Native validation:** the new file is validated and read back before it is reported as openable.
+- **No model call during transfer:** conversion, filtering, budgeting, and writing are deterministic local operations.
+- **Visible provenance:** the imported session identifies its source and states what was dropped without putting that marker in model context. Pi renders it as a transcript entry; Claude Code uses its native metadata entry; Codex prints it in the CLI because no safe durable out-of-context entry is verified.
+
+## Documentation
+
+The user and maintainer documentation is organized in [`docs/`](docs/README.md).
+
+## Development
+
+Development requires Node 24 LTS and pnpm 11.20.0.
+
+```sh
+pnpm install
+pnpm build
+pnpm test
+pnpm typecheck
+pnpm lint
+```
+
+Run the command help after a build:
+
+```sh
+node dist/bin.js --help
+```
+
+## License
+
+MIT.

package/node_modules/resume-from/dist/adapters/claude-code/adapter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The Claude Code adapter: the port of `src/adapters/`, filled in with what this module knows
+ * about Claude Code.
+ */
+import type { AgentAdapter, ClaudeCodeAdapterFactory } from "./contract.js";
+/** Claude Code's context window, used when configuration overrides none (FR-18). */
+export declare const DEFAULT_WINDOW_TOKENS = 200000;
+/** The command the landing hands back, because Claude Code cannot move the user (C-2, FR-45). */
+export declare const HANDOVER_COMMAND = "claude --resume";
+export interface ClaudeCodeAdapterDeps {
+    /**
+     * The repository the import runs in. Claude Code keys a session to a repository, and no
+     * argument of the port names one, so the working directory is the signal.
+     */
+    cwd: string;
+    env: Record<string, string | undefined>;
+    homeDir: string;
+}
+/**
+ * Build the adapter. `deps` exists for the tests of this module: the shipped factory below
+ * passes the real process values.
+ */
+export declare function createClaudeCodeAdapter(deps?: Partial<ClaudeCodeAdapterDeps>): AgentAdapter;
+/** The only export of this module (FR-57). */
+export declare const claudeCodeAdapter: ClaudeCodeAdapterFactory;

package/node_modules/resume-from/dist/adapters/claude-code/adapter.js

@@ -0,0 +1,60 @@
+/**
+ * The Claude Code adapter: the port of `src/adapters/`, filled in with what this module knows
+ * about Claude Code.
+ */
+import { resolveDefaultHome } from "./layout.js";
+import { readBack } from "./readback.js";
+import { listSessions, loadSession } from "./reader.js";
+import { serialize, validate } from "./writer.js";
+/** Claude Code's context window, used when configuration overrides none (FR-18). */
+export const DEFAULT_WINDOW_TOKENS = 200_000;
+/** The command the landing hands back, because Claude Code cannot move the user (C-2, FR-45). */
+export const HANDOVER_COMMAND = "claude --resume";
+/**
+ * Build the adapter. `deps` exists for the tests of this module: the shipped factory below
+ * passes the real process values.
+ */
+export function createClaudeCodeAdapter(deps = {}) {
+    const cwd = deps.cwd ?? process.cwd();
+    const env = deps.env ?? process.env;
+    // Resolved once: capabilities() is pure, synchronous, and equal on every call.
+    const capabilities = Object.freeze({
+        agent: "claude-code",
+        roles: ["source", "target"],
+        selection: "numbered-list",
+        landing: "create-only",
+        provenance: "out-of-context-entry",
+        defaultHome: deps.homeDir === undefined ? resolveDefaultHome(env) : resolveDefaultHome(env, deps.homeDir),
+        defaultWindowTokens: DEFAULT_WINDOW_TOKENS,
+    });
+    return {
+        capabilities() {
+            return capabilities;
+        },
+        listSessions(home) {
+            return listSessions(home);
+        },
+        loadSession(descriptor) {
+            return loadSession(descriptor);
+        },
+        serialize(session, target, marker) {
+            return serialize(session, target, marker, { cwd });
+        },
+        validate(serialized) {
+            return validate(serialized);
+        },
+        readBack(home, sessionId) {
+            return readBack(home, sessionId);
+        },
+        switchTo(_home, sessionId, _runtime) {
+            return Promise.reject(new Error('Claude Code declares landing "create-only": it cannot move the user into a session ' +
+                `(C-2). Run: ${HANDOVER_COMMAND} ${sessionId}`));
+        },
+    };
+}
+/** The only export of this module (FR-57). */
+export const claudeCodeAdapter = {
+    create() {
+        return createClaudeCodeAdapter();
+    },
+};

package/node_modules/resume-from/dist/adapters/claude-code/contract.d.ts

@@ -0,0 +1,8 @@
+import type { AdapterRole, AgentAdapter, AgentCapabilities, AgentRuntime, Bytes, LandingLevel, PendingFile, ProvenanceSupport, SelectionLevel, SerializedSession, StoredSessionFacts, SwitchOutcome, ValidationDefect } from "../contract.js";
+export type { AdapterRole, AgentAdapter, AgentCapabilities, AgentRuntime, Bytes, LandingLevel, PendingFile, ProvenanceSupport, SelectionLevel, SerializedSession, StoredSessionFacts, SwitchOutcome, ValidationDefect, };
+import type { AgentId, CanonicalSession, CanonicalTurn, HomePath, ProvenanceMarker, RepoSnapshot, SessionDescriptor, SessionId, SessionRef, SourceProvenance, TargetProfile, ToolCallRecord, ToolEffect, TurnKind, TurnRole } from "../../session/contract.js";
+export type { AgentId, CanonicalSession, CanonicalTurn, HomePath, ProvenanceMarker, RepoSnapshot, SessionDescriptor, SessionId, SessionRef, SourceProvenance, TargetProfile, ToolCallRecord, ToolEffect, TurnKind, TurnRole, };
+/** Builds the Claude Code adapter. The only export of this module (FR-57). */
+export interface ClaudeCodeAdapterFactory {
+    create(): AgentAdapter;
+}

package/node_modules/resume-from/dist/adapters/claude-code/contract.js

@@ -0,0 +1,4 @@
+// GENERATED from src/adapters/claude-code/module.md — the Public Contract section is the normative home.
+// Declarations only: no behaviour, no defaults. If this file and module.md disagree,
+// the document wins and this file is corrected.
+export {};

package/node_modules/resume-from/dist/adapters/claude-code/entries.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The Claude Code session file: one JSON object per line.
+ *
+ * The store holds ten entry types (C-3). This module reads the few that carry turns and writes
+ * exactly two, `user` and `assistant` (C-9) — fewer types, fewer ways to corrupt the store.
+ */
+export declare const ENTRY_TYPE_USER = "user";
+export declare const ENTRY_TYPE_ASSISTANT = "assistant";
+export declare const ENTRY_TYPE_SUMMARY = "summary";
+/** The only entry types `serialize` writes (C-9). */
+export declare const WRITTEN_ENTRY_TYPES: readonly string[];
+export type RawEntry = Record<string, unknown>;
+export interface JsonlParse {
+    entries: RawEntry[];
+    /** Set when a line is not a complete entry — the file is cut mid-entry. */
+    unreadable: string | null;
+}
+export interface ActiveEntryPath {
+    entries: RawEntry[];
+    unreadable: string | null;
+}
+/** Parse a session file. A line that is not a complete entry makes the whole file unreadable. */
+export declare function parseJsonl(text: string): JsonlParse;
+/** Follow the last non-sidechain UUID record to the root of Claude's active transcript. */
+export declare function resolveActiveEntryPath(entries: RawEntry[]): ActiveEntryPath;
+export declare function asString(value: unknown): string | null;
+export declare function asObject(value: unknown): Record<string, unknown> | null;
+export declare function asArray(value: unknown): unknown[] | null;
+/** ISO-8601 UTC, the vocabulary every timestamp of the canonical model uses. */
+export declare function toIsoUtc(value: unknown): string | null;

package/node_modules/resume-from/dist/adapters/claude-code/entries.js

@@ -0,0 +1,107 @@
+/**
+ * The Claude Code session file: one JSON object per line.
+ *
+ * The store holds ten entry types (C-3). This module reads the few that carry turns and writes
+ * exactly two, `user` and `assistant` (C-9) — fewer types, fewer ways to corrupt the store.
+ */
+export const ENTRY_TYPE_USER = "user";
+export const ENTRY_TYPE_ASSISTANT = "assistant";
+export const ENTRY_TYPE_SUMMARY = "summary";
+/** The only entry types `serialize` writes (C-9). */
+export const WRITTEN_ENTRY_TYPES = [ENTRY_TYPE_USER, ENTRY_TYPE_ASSISTANT];
+/** Parse a session file. A line that is not a complete entry makes the whole file unreadable. */
+export function parseJsonl(text) {
+    const entries = [];
+    const lines = text.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        if (line.trim() === "")
+            continue;
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch {
+            return { entries, unreadable: `line ${i + 1} is not a complete entry` };
+        }
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+            return { entries, unreadable: `line ${i + 1} is not an entry object` };
+        }
+        entries.push(value);
+    }
+    return { entries, unreadable: null };
+}
+/** Follow the last non-sidechain UUID record to the root of Claude's active transcript. */
+export function resolveActiveEntryPath(entries) {
+    const byUuid = new Map();
+    const mainEntries = [];
+    for (const entry of entries) {
+        if (entry.isSidechain === true || entry.uuid === undefined)
+            continue;
+        const uuid = asString(entry.uuid);
+        if (uuid === null)
+            return { entries: [], unreadable: "entry has a malformed uuid" };
+        if (byUuid.has(uuid)) {
+            return { entries: [], unreadable: `duplicate entry uuid ${uuid}` };
+        }
+        if (entry.parentUuid !== null && typeof entry.parentUuid !== "string") {
+            return {
+                entries: [],
+                unreadable: `entry ${uuid} has a malformed parentUuid`,
+            };
+        }
+        byUuid.set(uuid, entry);
+        mainEntries.push(entry);
+    }
+    const leaf = mainEntries[mainEntries.length - 1];
+    if (leaf === undefined)
+        return { entries: [], unreadable: null };
+    const reversed = [];
+    const visited = new Set();
+    let current = leaf;
+    while (current !== undefined) {
+        const uuid = asString(current.uuid);
+        if (uuid === null)
+            return { entries: [], unreadable: "active entry has no uuid" };
+        if (visited.has(uuid)) {
+            return {
+                entries: [],
+                unreadable: `entry graph contains a cycle at ${uuid}`,
+            };
+        }
+        visited.add(uuid);
+        reversed.push(current);
+        if (current.parentUuid === null)
+            break;
+        const parent = byUuid.get(current.parentUuid);
+        if (parent === undefined) {
+            return {
+                entries: [],
+                unreadable: `entry ${uuid} refers to missing parent ${String(current.parentUuid)}`,
+            };
+        }
+        current = parent;
+    }
+    return { entries: reversed.reverse(), unreadable: null };
+}
+export function asString(value) {
+    return typeof value === "string" && value !== "" ? value : null;
+}
+export function asObject(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return null;
+    return value;
+}
+export function asArray(value) {
+    return Array.isArray(value) ? value : null;
+}
+/** ISO-8601 UTC, the vocabulary every timestamp of the canonical model uses. */
+export function toIsoUtc(value) {
+    const text = asString(value);
+    if (text === null)
+        return null;
+    const parsed = Date.parse(text);
+    if (!Number.isFinite(parsed))
+        return null;
+    return new Date(parsed).toISOString();
+}

package/node_modules/resume-from/dist/adapters/claude-code/index.d.ts

@@ -0,0 +1,3 @@
+/** The Claude Code adapter. Building it is the only thing this module offers (FR-57). */
+export { claudeCodeAdapter } from "./adapter.js";
+export type { ClaudeCodeAdapterFactory } from "./contract.js";

package/node_modules/resume-from/dist/adapters/claude-code/index.js

@@ -0,0 +1,2 @@
+/** The Claude Code adapter. Building it is the only thing this module offers (FR-57). */
+export { claudeCodeAdapter } from "./adapter.js";

package/node_modules/resume-from/dist/adapters/claude-code/layout.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Where Claude Code keeps its sessions inside a home.
+ *
+ * A home holds `projects/<encoded repository path>/<session id>.jsonl`. The encoding and the
+ * default home are facts about the installed version, not assumptions: the live boundary test
+ * T-CC-16 lands a real session and compares it with what this file computes.
+ */
+import type { HomePath, SessionId } from "./contract.js";
+/** Session files live one directory per repository, under this directory of the home. */
+export declare const PROJECTS_DIR = "projects";
+export declare const SESSION_FILE_SUFFIX = ".jsonl";
+/** Claude Code reads this before falling back to ~/.claude. It is how `~/.claude-team` is named. */
+export declare const CONFIG_DIR_ENV = "CLAUDE_CONFIG_DIR";
+export declare const DEFAULT_HOME_BASENAME = ".claude";
+/** The home used when the user names none (FR-3). Absolute, resolved. */
+export declare function resolveDefaultHome(env?: Record<string, string | undefined>, userHome?: string): HomePath;
+/**
+ * The project directory name of a repository: the absolute path with every character that is
+ * not a letter or a digit replaced by a dash.
+ */
+export declare function encodeProjectPath(repoPath: string): string;
+export declare function projectsDir(home: HomePath): string;
+export declare function projectDir(home: HomePath, repoPath: string): string;
+export declare function sessionFilePath(home: HomePath, repoPath: string, id: SessionId): string;
+export declare function sessionIdOf(filePath: string): SessionId;
+/** Every session file of a home, across all of its project directories. */
+export declare function listSessionFiles(home: HomePath): Promise<string[]>;
+/** The file of one session id, or null when the home does not hold it. */
+export declare function findSessionFile(home: HomePath, id: SessionId): Promise<string | null>;

package/node_modules/resume-from/dist/adapters/claude-code/layout.js

@@ -0,0 +1,80 @@
+/**
+ * Where Claude Code keeps its sessions inside a home.
+ *
+ * A home holds `projects/<encoded repository path>/<session id>.jsonl`. The encoding and the
+ * default home are facts about the installed version, not assumptions: the live boundary test
+ * T-CC-16 lands a real session and compares it with what this file computes.
+ */
+import { readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+/** Session files live one directory per repository, under this directory of the home. */
+export const PROJECTS_DIR = "projects";
+export const SESSION_FILE_SUFFIX = ".jsonl";
+/** Claude Code reads this before falling back to ~/.claude. It is how `~/.claude-team` is named. */
+export const CONFIG_DIR_ENV = "CLAUDE_CONFIG_DIR";
+export const DEFAULT_HOME_BASENAME = ".claude";
+/** The home used when the user names none (FR-3). Absolute, resolved. */
+export function resolveDefaultHome(env = process.env, userHome = homedir()) {
+    const configured = env[CONFIG_DIR_ENV];
+    if (configured !== undefined && configured !== "" && path.isAbsolute(configured)) {
+        return path.resolve(configured);
+    }
+    return path.join(path.resolve(userHome), DEFAULT_HOME_BASENAME);
+}
+/**
+ * The project directory name of a repository: the absolute path with every character that is
+ * not a letter or a digit replaced by a dash.
+ */
+export function encodeProjectPath(repoPath) {
+    return path.resolve(repoPath).replace(/[^a-zA-Z0-9]/g, "-");
+}
+export function projectsDir(home) {
+    return path.join(home, PROJECTS_DIR);
+}
+export function projectDir(home, repoPath) {
+    return path.join(projectsDir(home), encodeProjectPath(repoPath));
+}
+export function sessionFilePath(home, repoPath, id) {
+    return path.join(projectDir(home, repoPath), `${id}${SESSION_FILE_SUFFIX}`);
+}
+export function sessionIdOf(filePath) {
+    return path.basename(filePath, SESSION_FILE_SUFFIX);
+}
+/** Every session file of a home, across all of its project directories. */
+export async function listSessionFiles(home) {
+    const root = projectsDir(home);
+    let projects;
+    try {
+        projects = (await readdir(root, { withFileTypes: true }))
+            .filter((item) => item.isDirectory())
+            .map((item) => item.name);
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    for (const project of projects) {
+        const dir = path.join(root, project);
+        try {
+            for (const item of await readdir(dir, { withFileTypes: true })) {
+                if (item.isFile() && item.name.endsWith(SESSION_FILE_SUFFIX)) {
+                    files.push(path.join(dir, item.name));
+                }
+            }
+        }
+        catch {
+            // A project directory that cannot be read holds no session this tool can offer.
+        }
+    }
+    return files;
+}
+/** The file of one session id, or null when the home does not hold it. */
+export async function findSessionFile(home, id) {
+    const wanted = `${id}${SESSION_FILE_SUFFIX}`;
+    for (const file of await listSessionFiles(home)) {
+        if (path.basename(file) === wanted)
+            return file;
+    }
+    return null;
+}

package/node_modules/resume-from/dist/adapters/claude-code/readback.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Reading a committed session back.
+ *
+ * C-9's own caution is why this is not optional: a throwaway directory holding one session does
+ * not prove a real store is safe, so the import compares what it wrote with what the store holds
+ * (FR-52) and whether the native resume list can open it (FR-51).
+ */
+import type { HomePath, SessionId, StoredSessionFacts } from "./contract.js";
+export declare function readBack(home: HomePath, sessionId: SessionId): Promise<StoredSessionFacts>;

package/node_modules/resume-from/dist/adapters/claude-code/readback.js

@@ -0,0 +1,39 @@
+/**
+ * Reading a committed session back.
+ *
+ * C-9's own caution is why this is not optional: a throwaway directory holding one session does
+ * not prove a real store is safe, so the import compares what it wrote with what the store holds
+ * (FR-52) and whether the native resume list can open it (FR-51).
+ */
+import { readFile } from "node:fs/promises";
+import { parseJsonl } from "./entries.js";
+import { findSessionFile } from "./layout.js";
+import { readSessionText } from "./reader.js";
+import { isStructurallyOpenable } from "./validation.js";
+export async function readBack(home, sessionId) {
+    const absent = {
+        sessionId,
+        itemCount: 0,
+        openable: false,
+    };
+    const file = await findSessionFile(home, sessionId);
+    if (file === null)
+        return absent;
+    let text;
+    try {
+        text = await readFile(file, "utf8");
+    }
+    catch {
+        return absent;
+    }
+    const { entries, unreadable } = parseJsonl(text);
+    const read = unreadable === null ? readSessionText(text) : null;
+    return {
+        sessionId,
+        itemCount: entries.length,
+        openable: unreadable === null &&
+            read?.unreadable === null &&
+            read.turns.length > 0 &&
+            isStructurallyOpenable(entries, sessionId),
+    };
+}

package/node_modules/resume-from/dist/adapters/claude-code/reader.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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 type { CanonicalSession, CanonicalTurn, HomePath, SessionDescriptor } from "./contract.js";
+/** FR-25: every dropped body is marked in text the model can read. */
+export declare const DROPPED_MARKER = "(content dropped: imported session, may be stale)";
+export declare const UNREADABLE_TITLE = "(unreadable session file)";
+export declare const UNTITLED = "(no user message)";
+export interface SessionReadResult {
+    turns: CanonicalTurn[];
+    /**
+     * Entries this adapter does not read: the other entry types of C-3, hidden reasoning, and
+     * everything FR-28 excludes. `AgentAdapter` has no field for this count, so it is reported
+     * here and asserted by T-CC-15.
+     */
+    skipped: number;
+    /** Set when the file is cut mid-entry. Then the session is not readable at all. */
+    unreadable: string | null;
+    title: string;
+    startedAt: string | null;
+    updatedAt: string | null;
+    repoPath: string | null;
+    branch: string | null;
+    changedPaths: string[];
+}
+/** The redacted source arguments, shortened so one call stays one line. */
+export declare function renderArguments(input: unknown): string;
+/** Read a whole session file into canonical turns. Pure: it takes the text, not a path. */
+export declare function readSessionText(text: string): SessionReadResult;
+/** One row per session file of the home, newest first (FR-11, FR-14). */
+export declare function listSessions(home: HomePath): Promise<SessionDescriptor[]>;
+/** One session in the neutral vocabulary. A file cut mid-entry is reported, never guessed at. */
+export declare function loadSession(descriptor: SessionDescriptor): Promise<CanonicalSession>;