@herbertgao/pi-extensions 2026.8.8 → 2026.8.10

package/node_modules/pi-web-access/CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.24.2] - 2026-08-22
+
+### Highlights
+- `auto` search now uses Codex-backed OpenAI search when Pi is running a Codex model.
+- Non-Codex sessions still prefer Exa first, so zero-config search keeps its fast keyless path.
+- Gemini Web browser-cookie access is more reliable on Windows Chrome and Edge profiles.
+
+### Changed
+- Prefer Codex-backed OpenAI search in `auto` mode when the active Pi model is `openai-codex`; otherwise prefer Exa before OpenAI.
+
+### Fixed
+- Fixed Windows Gemini Web browser-cookie extraction when Chromium cookie expiry values are too large for JavaScript numbers or PowerShell DPAPI key unprotect needs encoded command transport. Thanks to [@laixuanthoi](https://github.com/laixuanthoi) for issue #290.
+
 ## [0.24.1] - 2026-08-21
 
 ### Added

package/node_modules/pi-web-access/README.md

@@ -18,7 +18,7 @@
 
 **Video Understanding** — Point it at a YouTube video or local screen recording and ask questions about what's on screen. Full transcripts, visual descriptions, and frame extraction at exact timestamps.
 
-**Smart Fallbacks** — Every capability has a fallback chain. Search tries configured SearXNG first for local/private search, then OpenAI when suitable and available, Exa, Brave, Parallel, TinyFish, Search1API, Searchinfinity, Querit, Tavily, Firecrawl, Jina, SERPdive, Kagi, Bocha, Ollama, Perplexity, Gemini API, and Gemini Web when browser cookies are enabled. With no SearXNG configured, the existing zero-config order is unchanged. YouTube tries Gemini Web when enabled, then API, then Perplexity. Blocked pages try configured self-hosted Firecrawl first. Third-party hosted page fetchers require explicit `fetchRouting.allowRemoteHostedProviders` opt-in for remote HTTP(S) targets.
+**Smart Fallbacks** — Every capability has a fallback chain. Search tries configured SearXNG first for local/private search. When the active Pi model is `openai-codex`, it then tries Codex-backed OpenAI search. Otherwise it tries Exa before OpenAI, then Brave, Parallel, TinyFish, Search1API, Searchinfinity, Querit, Tavily, Firecrawl, Jina, SERPdive, Kagi, Bocha, Ollama, Perplexity, Gemini API, and Gemini Web when browser cookies are enabled. YouTube tries Gemini Web when enabled, then API, then Perplexity. Blocked pages try configured self-hosted Firecrawl first. Third-party hosted page fetchers require explicit `fetchRouting.allowRemoteHostedProviders` opt-in for remote HTTP(S) targets.
 
 **GitHub Cloning** — GitHub URLs are cloned locally instead of scraped. The agent gets real file contents and a local path to explore, not rendered HTML.
 
@@ -46,7 +46,7 @@ Works immediately with no API keys — Exa MCP provides zero-config search. If P
 }
 ```
 
-In `auto` mode (default), `web_search` tries a configured SearXNG endpoint first for local/private search, then OpenAI when suitable and available, Exa (direct API if keyed, MCP if not), Brave, Parallel, TinyFish, Search1API, Searchinfinity, Querit, Tavily, Firecrawl, Jina, SERPdive, Perplexity, Gemini API, and Gemini Web when browser-cookie access is enabled. With no SearXNG configured, the existing zero-config order is unchanged. Exa handles search; curator summary drafts are generated separately by the configured Pi summary model, defaulting to Claude Haiku, Codex Luna, Codex Terra, Gemini 3.6 Flash, GPT-5 mini, then DeepSeek V4 Flash when available. Slow summary drafts fall back to a deterministic result summary after a bounded deadline.
+In `auto` mode (default), `web_search` tries a configured SearXNG endpoint first for local/private search. When the active Pi model is `openai-codex`, it then tries Codex-backed OpenAI search. Otherwise it tries Exa (direct API if keyed, MCP if not) before OpenAI, then Brave, Parallel, TinyFish, Search1API, Searchinfinity, Querit, Tavily, Firecrawl, Jina, SERPdive, Perplexity, Gemini API, and Gemini Web when browser-cookie access is enabled. Exa handles search; curator summary drafts are generated separately by the configured Pi summary model, defaulting to Claude Haiku, Codex Luna, Codex Terra, Gemini 3.6 Flash, GPT-5 mini, then DeepSeek V4 Flash when available. Slow summary drafts fall back to a deterministic result summary after a bounded deadline.
 
 If your OpenAI key belongs to a third-party Responses-compatible gateway, set `openaiResponsesUrl` to that gateway's full Responses endpoint. The default remains `https://api.openai.com/v1/responses`.
 

package/node_modules/pi-web-access/chrome-cookies.ts

@@ -375,8 +375,9 @@ async function readWindowsEncryptionKey(config: BrowserConfig, home: string): Pr
 
 function unprotectWindowsData(protectedData: Buffer): Promise<Buffer | null> {
 	return new Promise((resolve) => {
-		const script = "$data=[Convert]::FromBase64String($args[0]);$clear=[Security.Cryptography.ProtectedData]::Unprotect($data,$null,[Security.Cryptography.DataProtectionScope]::CurrentUser);[Console]::Write([Convert]::ToBase64String($clear))";
-		execFile("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script, protectedData.toString("base64")], { timeout: 5000, maxBuffer: 1024 * 1024 }, (err, stdout) => {
+		const script = "Add-Type -AssemblyName System.Security;$data=[Convert]::FromBase64String($env:PIWA_PROTECTED);$clear=[System.Security.Cryptography.ProtectedData]::Unprotect($data,$null,[System.Security.Cryptography.DataProtectionScope]::CurrentUser);[Console]::Write([Convert]::ToBase64String($clear))";
+		const encoded = Buffer.from(script, "utf16le").toString("base64");
+		execFile("powershell.exe", ["-NoProfile", "-NonInteractive", "-EncodedCommand", encoded], { timeout: 5000, maxBuffer: 1024 * 1024, env: { ...process.env, PIWA_PROTECTED: protectedData.toString("base64") } }, (err, stdout) => {
 			if (err) { resolve(null); return; }
 			try {
 				resolve(Buffer.from(stdout.trim(), "base64"));
@@ -509,10 +510,10 @@ async function queryCookieRows(dbPath: string, hosts: string[], names: Iterable<
 	const columns = await readCookieColumns(dbPath);
 	if (columns.status === "failure") return columns;
 	const pathExpr = columns.columns.has("path") ? "path" : "'/' AS path";
-	const expiresExpr = columns.columns.has("expires_utc") ? "expires_utc" : "0 AS expires_utc";
-	const expiryFilter = filterExpired && columns.columns.has("expires_utc") ? ` AND (expires_utc = 0 OR expires_utc > ${chromeExpiryNowMicros()})` : "";
+	const expiresExpr = columns.columns.has("expires_utc") ? chromeExpiryMillisExpr() : "0";
+	const expiryFilter = filterExpired && columns.columns.has("expires_utc") ? ` AND (${expiresExpr} = 0 OR ${expiresExpr} > ${chromeExpiryNowMillis()})` : "";
 	const partitionFilter = filterExpired ? unpartitionedCookieFilter(columns.columns) : "";
-	return runSqliteQuery(dbPath, `SELECT name, value, host_key, ${pathExpr}, ${expiresExpr}, hex(encrypted_value) AS encrypted_value_hex FROM cookies WHERE ${buildCookieWhere(hosts, names ?? undefined)}${expiryFilter}${partitionFilter} ORDER BY length(path) DESC, expires_utc ASC`);
+	return runSqliteQuery(dbPath, `SELECT name, value, host_key, ${pathExpr}, ${expiresExpr} AS expires_utc, hex(encrypted_value) AS encrypted_value_hex FROM cookies WHERE ${buildCookieWhere(hosts, names ?? undefined)}${expiryFilter}${partitionFilter} ORDER BY length(path) DESC, ${expiresExpr} ASC`);
 }
 
 async function readCookieColumns(dbPath: string): Promise<{ status: "success"; columns: Set<string> } | { status: "failure"; failure: SqliteFailure }> {
@@ -521,8 +522,12 @@ async function readCookieColumns(dbPath: string): Promise<{ status: "success"; c
 	return { status: "success", columns: new Set(result.rows.map(row => typeof row.name === "string" ? row.name : "")) };
 }
 
-function chromeExpiryNowMicros(): number {
-	return (Date.now() + 11644473600000) * 1000;
+function chromeExpiryMillisExpr(): string {
+	return "CASE WHEN expires_utc = 0 THEN 0 ELSE CAST(expires_utc / 1000 AS INTEGER) + CASE WHEN expires_utc % 1000 = 0 THEN 0 ELSE 1 END END";
+}
+
+function chromeExpiryNowMillis(): number {
+	return Date.now() + 11644473600000;
 }
 
 function unpartitionedCookieFilter(columns: Set<string>): string {

package/node_modules/pi-web-access/gemini-search.ts

@@ -216,6 +216,24 @@ function shouldTryOpenAIInAuto(options: SearchOptions): boolean {
 	return true;
 }
 
+function isOpenAICodexSelected(ctx?: ExtensionContext): boolean {
+	return ctx?.model?.provider === "openai-codex";
+}
+
+async function tryOpenAIInAuto(query: string, options: FullSearchOptions, fallbackErrors: string[]): Promise<AttributedSearchResponse | null> {
+	if (!shouldTryOpenAIInAuto(options)) return null;
+	try {
+		if (await isOpenAISearchAvailable(options.extensionContext)) {
+			const result = await searchWithOpenAI(query, options, options.extensionContext);
+			return { ...result, provider: "openai" };
+		}
+	} catch (err) {
+		if (isAbortError(err)) throw err;
+		fallbackErrors.push(`OpenAI: ${errorMessage(err)}`);
+	}
+	return null;
+}
+
 async function searchWithGemini(
 	query: string,
 	options: SearchOptions,
@@ -524,16 +542,11 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 		}
 	}
 
-	if (shouldTryOpenAIInAuto(options)) {
-		try {
-			if (await isOpenAISearchAvailable(options.extensionContext)) {
-				const result = await searchWithOpenAI(query, options, options.extensionContext);
-				return { ...result, provider: "openai" };
-			}
-		} catch (err) {
-			if (isAbortError(err)) throw err;
-			fallbackErrors.push(`OpenAI: ${errorMessage(err)}`);
-		}
+	let triedOpenAI = false;
+	if (!options.extensionContext || isOpenAICodexSelected(options.extensionContext)) {
+		triedOpenAI = true;
+		const result = await tryOpenAIInAuto(query, options, fallbackErrors);
+		if (result) return result;
 	}
 
 	if (isExaAvailable()) {
@@ -546,6 +559,11 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 		}
 	}
 
+	if (!triedOpenAI) {
+		const result = await tryOpenAIInAuto(query, options, fallbackErrors);
+		if (result) return result;
+	}
+
 	if (isBraveAvailable()) {
 		try {
 			const result = await searchWithBrave(query, options);

package/node_modules/pi-web-access/index.ts

@@ -152,7 +152,7 @@ interface WebSearchConfig {
 	};
 }
 
-interface ProviderAvailability {
+export interface ProviderAvailability {
 	all: boolean;
 	openai: boolean;
 	brave: boolean;
@@ -184,7 +184,7 @@ interface ProviderAvailability {
 
 type WebSearchWorkflow = "none" | "summary-review" | "auto-summary";
 type CuratorWorkflow = "summary-review";
-type CuratorProvider = Exclude<SearchProvider, "auto">;
+export type CuratorProvider = Exclude<SearchProvider, "auto">;
 type SummaryWorkflow = "summary-review" | "auto-summary";
 
 interface CuratorBootstrap {
@@ -420,13 +420,16 @@ async function getProviderAvailability(ctx: ExtensionContext): Promise<ProviderA
 	};
 }
 
-function shouldPreferOpenAI(options?: Pick<PendingCurate, "numResults" | "recencyFilter">): boolean {
-	if (!options) return true;
-	if (options.recencyFilter) return false;
-	if (typeof options.numResults === "number" && Number.isFinite(options.numResults) && Math.floor(options.numResults) !== 5) {
+function shouldUseOpenAICodexDefault(ctx?: Pick<ExtensionContext, "model">): boolean {
+	return ctx?.model?.provider === "openai-codex";
+}
+
+function shouldPreferOpenAI(options: Pick<PendingCurate, "numResults" | "recencyFilter"> | undefined, preferOpenAICodexDefault: boolean): boolean {
+	if (options?.recencyFilter) return false;
+	if (typeof options?.numResults === "number" && Number.isFinite(options.numResults) && Math.floor(options.numResults) !== 5) {
 		return false;
 	}
-	return true;
+	return preferOpenAICodexDefault;
 }
 
 async function loadCuratorBootstrap(
@@ -439,15 +442,25 @@ async function loadCuratorBootstrap(
 	if (Array.isArray(provider)) availableProviders.all = true;
 	return {
 		availableProviders,
-		defaultProvider: resolveProvider(provider, availableProviders, options),
+		defaultProvider: resolveCuratorDefaultProvider(provider, availableProviders, ctx, options),
 		timeoutSeconds: getCuratorTimeoutSeconds(),
 	};
 }
 
+export function resolveCuratorDefaultProvider(
+	provider: SearchProviderSelection,
+	available: ProviderAvailability,
+	ctx?: Pick<ExtensionContext, "model">,
+	options?: Pick<PendingCurate, "numResults" | "recencyFilter">,
+): CuratorProvider {
+	return resolveProvider(provider, available, options, shouldUseOpenAICodexDefault(ctx));
+}
+
 function firstAvailableProvider(available: ProviderAvailability, preferOpenAI: boolean, fallback: ResolvedSearchProvider): ResolvedSearchProvider {
 	if (available.searxng) return "searxng";
 	if (preferOpenAI && available.openai) return "openai";
 	if (available.exa) return "exa";
+	if (available.openai) return "openai";
 	if (available.brave) return "brave";
 	if (available.parallel) return "parallel";
 	if (available.tinyfish) return "tinyfish";
@@ -470,9 +483,10 @@ function resolveProvider(
 	provider: SearchProviderSelection,
 	available: ProviderAvailability,
 	options?: Pick<PendingCurate, "numResults" | "recencyFilter">,
+	preferOpenAICodexDefault = false,
 ): CuratorProvider {
 	if (Array.isArray(provider)) return "all";
-	const preferOpenAI = shouldPreferOpenAI(options);
+	const preferOpenAI = shouldPreferOpenAI(options, preferOpenAICodexDefault);
 
 	if (provider === "auto") {
 		const routing = getConfiguredSearchRouting();
@@ -1660,7 +1674,7 @@ export default function (pi: ExtensionAPI) {
 		name: toolNames.webSearch,
 		label: "Web Search",
 		description:
-			`Search the web using OpenAI, Brave, Parallel, Parallel MCP, TinyFish, Search1API, Searchinfinity, Querit, Tavily, Firecrawl, Jina, SERPdive, Kagi, Bocha, Ollama, SearXNG, DuckDuckGo, Exa, Perplexity, Gemini, AnySearch, Valyu, xAI, Bright Data, SerpBase, or Serper. Pass a provider array to search only those providers simultaneously, or use provider "all" to search every eligible provider except Parallel MCP, DuckDuckGo, AnySearch, Valyu, xAI, Bright Data, SerpBase, and Serper. Returns an AI-synthesized answer with source citations. OpenAI search uses a Codex subscription or OpenAI API key; xAI search uses a SuperGrok/X Premium subscription or xAI API key. Parallel MCP, DuckDuckGo, AnySearch, Valyu, xAI, Bright Data, SerpBase, and Serper are available only when explicitly selected. For comprehensive research, prefer queries (plural) with 2-4 varied angles over a single query — each query gets its own synthesized answer, so varying phrasing and scope gives much broader coverage. When includeContent is true, full page content is fetched in the background. Searches auto-open the interactive browser curator and stream results live; set workflow to "none" to skip curation or "auto-summary" for a model-generated summary without the browser curator. The configured provider is used when provider is omitted or set to auto; omit provider unless explicitly overriding it. Without a configured provider, auto-selects OpenAI when suitable and available, then Exa, Brave, Parallel, TinyFish, Search1API, Searchinfinity, Querit, Tavily, Firecrawl, Jina, SERPdive, Kagi, Bocha, Ollama, Perplexity, Gemini API, or Gemini Web. When SearXNG is configured, it is preferred first for local/private search.`,
+			`Search the web using OpenAI, Brave, Parallel, Parallel MCP, TinyFish, Search1API, Searchinfinity, Querit, Tavily, Firecrawl, Jina, SERPdive, Kagi, Bocha, Ollama, SearXNG, DuckDuckGo, Exa, Perplexity, Gemini, AnySearch, Valyu, xAI, Bright Data, SerpBase, or Serper. Pass a provider array to search only those providers simultaneously, or use provider "all" to search every eligible provider except Parallel MCP, DuckDuckGo, AnySearch, Valyu, xAI, Bright Data, SerpBase, and Serper. Returns an AI-synthesized answer with source citations. OpenAI search uses a Codex subscription or OpenAI API key; xAI search uses a SuperGrok/X Premium subscription or xAI API key. Parallel MCP, DuckDuckGo, AnySearch, Valyu, xAI, Bright Data, SerpBase, and Serper are available only when explicitly selected. For comprehensive research, prefer queries (plural) with 2-4 varied angles over a single query — each query gets its own synthesized answer, so varying phrasing and scope gives much broader coverage. When includeContent is true, full page content is fetched in the background. Searches auto-open the interactive browser curator and stream results live; set workflow to "none" to skip curation or "auto-summary" for a model-generated summary without the browser curator. The configured provider is used when provider is omitted or set to auto; omit provider unless explicitly overriding it. Without a configured provider, SearXNG is preferred first for local/private search. When the active Pi model is openai-codex, Codex-backed OpenAI search is preferred next. Otherwise Exa is preferred before OpenAI, then Brave, Parallel, TinyFish, Search1API, Searchinfinity, Querit, Tavily, Firecrawl, Jina, SERPdive, Kagi, Bocha, Ollama, Perplexity, Gemini API, or Gemini Web.`,
 		promptSnippet:
 			"Use for web research questions. Prefer {queries:[...]} with 2-4 varied angles over a single query for broader coverage. Omit provider unless explicitly overriding the configured default.",
 		parameters: Type.Object({

package/node_modules/pi-web-access/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-web-access",
-  "version": "0.24.1",
+  "version": "0.24.2",
   "description": "Web search, URL fetching, GitHub repo cloning, PDF extraction, YouTube video understanding, and local video analysis for Pi coding agent. Supports OpenAI, Brave, Parallel, TinyFish, Search1API, Searchinfinity, Querit, Tavily, Firecrawl, Jina, SERPdive, Kagi, Ollama, AnySearch, Bright Data SERP, SerpBase, SearXNG, Exa, Perplexity, and Gemini.",
   "type": "module",
   "scripts": {

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;