@herbertgao/pi-extensions 2026.8.14 → 2026.9.0

package/node_modules/@narumitw/pi-caffeinate/src/dbus-inhibit.ts

@@ -0,0 +1,153 @@
+import type { Message, MessageBus } from "dbus-native";
+
+export const SCREENSAVER_BUS_NAME = "org.freedesktop.ScreenSaver";
+export const SCREENSAVER_INTERFACE = "org.freedesktop.ScreenSaver";
+export const INHIBIT_REASON = "Pi agent is running";
+
+const INHIBIT_APPLICATION_NAME = "pi-caffeinate";
+const SCREENSAVER_OBJECT_PATHS = ["/org/freedesktop/ScreenSaver", "/ScreenSaver"];
+const DBUS_CALL_TIMEOUT_MS = 2_000;
+
+type DbusFailureHandler = (error: Error) => void;
+
+export interface DbusScreenSaverClient {
+	setFailureHandler(handler: DbusFailureHandler | undefined): void;
+	inhibit(reason: string, signal?: AbortSignal): Promise<void>;
+	uninhibit(): Promise<void>;
+	close(): Promise<void>;
+}
+
+export type DbusScreenSaverFactory = () => Promise<DbusScreenSaverClient>;
+
+export async function defaultDbusScreenSaverFactory(): Promise<DbusScreenSaverClient> {
+	const { sessionBus } = await import("dbus-native");
+	return new NativeScreenSaverClient(sessionBus());
+}
+
+class NativeScreenSaverClient implements DbusScreenSaverClient {
+	private cookie?: number;
+	private objectPath?: string;
+	private failureHandler?: DbusFailureHandler;
+	private pendingFailure?: Error;
+	private lastConnectionError?: Error;
+	private closing = false;
+
+	private readonly handleConnectionError = (error: unknown) => {
+		this.lastConnectionError = toError(error, "D-Bus session connection failed");
+		if (this.cookie !== undefined) this.reportFailure(this.lastConnectionError);
+	};
+
+	private readonly handleConnectionClose = (error?: unknown) => {
+		if (this.closing || this.cookie === undefined) return;
+		this.reportFailure(
+			toError(error, this.lastConnectionError?.message ?? "D-Bus session connection closed"),
+		);
+	};
+
+	constructor(private readonly bus: MessageBus) {
+		this.bus.connection.on("error", this.handleConnectionError);
+		this.bus.connection.on("close", this.handleConnectionClose);
+	}
+
+	setFailureHandler(handler: DbusFailureHandler | undefined): void {
+		this.failureHandler = handler;
+		if (!handler || !this.pendingFailure) return;
+		const failure = this.pendingFailure;
+		this.pendingFailure = undefined;
+		handler(failure);
+	}
+
+	async inhibit(reason: string, signal?: AbortSignal): Promise<void> {
+		let lastError: unknown;
+		for (const objectPath of SCREENSAVER_OBJECT_PATHS) {
+			if (signal?.aborted) throw abortReason(signal);
+			try {
+				this.cookie = await invoke<number>(
+					this.bus,
+					{
+						destination: SCREENSAVER_BUS_NAME,
+						path: objectPath,
+						interface: SCREENSAVER_INTERFACE,
+						member: "Inhibit",
+						signature: "ss",
+						body: [INHIBIT_APPLICATION_NAME, reason],
+					},
+					signal,
+				);
+				this.objectPath = objectPath;
+				return;
+			} catch (error) {
+				if (signal?.aborted) throw abortReason(signal);
+				lastError = error;
+			}
+		}
+		throw new Error(`D-Bus idle inhibit failed: ${formatError(lastError)}`, {
+			cause: lastError,
+		});
+	}
+
+	async uninhibit(): Promise<void> {
+		if (this.cookie === undefined || !this.objectPath) return;
+		const cookie = this.cookie;
+		this.cookie = undefined;
+		const objectPath = this.objectPath;
+		this.objectPath = undefined;
+		await invoke<void>(this.bus, {
+			destination: SCREENSAVER_BUS_NAME,
+			path: objectPath,
+			interface: SCREENSAVER_INTERFACE,
+			member: "UnInhibit",
+			signature: "u",
+			body: [cookie],
+		});
+	}
+
+	async close(): Promise<void> {
+		this.closing = true;
+		this.cookie = undefined;
+		this.objectPath = undefined;
+		this.failureHandler = undefined;
+		try {
+			await this.bus.close();
+		} finally {
+			this.bus.connection.off("error", this.handleConnectionError);
+			this.bus.connection.off("close", this.handleConnectionClose);
+		}
+	}
+
+	private reportFailure(error: Error): void {
+		if (this.cookie === undefined) return;
+		this.cookie = undefined;
+		this.objectPath = undefined;
+		if (this.failureHandler) this.failureHandler(error);
+		else this.pendingFailure = error;
+	}
+}
+
+function invoke<TResult>(
+	bus: MessageBus,
+	message: Message,
+	signal?: AbortSignal,
+): Promise<TResult> {
+	return new Promise<TResult>((resolve, reject) => {
+		bus.invoke(message, { signal, timeout: DBUS_CALL_TIMEOUT_MS }, (error, ...values) => {
+			if (error) reject(error);
+			else resolve(values[0] as TResult);
+		});
+	});
+}
+
+function abortReason(signal: AbortSignal): unknown {
+	return signal.reason ?? new DOMException("D-Bus idle inhibit cancelled", "AbortError");
+}
+
+function toError(error: unknown, fallback: string): Error {
+	return error instanceof Error ? error : new Error(fallback);
+}
+
+function formatError(error: unknown) {
+	if (error instanceof Error) {
+		return error.name === "Error" ? error.message : `${error.name}: ${error.message}`;
+	}
+	return String(error);
+}

package/node_modules/@narumitw/pi-caffeinate/src/index.ts

@@ -0,0 +1 @@
+export { default } from "./caffeinate.js";

package/node_modules/@narumitw/pi-caffeinate/src/inhibitor-process.ts

@@ -0,0 +1,43 @@
+import { type ChildProcess, spawn } from "node:child_process";
+import process from "node:process";
+import type { InhibitorCommand } from "./inhibitors.js";
+
+export function startInhibitorProcess(
+	command: InhibitorCommand,
+	onError: (error: Error) => void,
+	onUnexpectedExit: (description: string) => void,
+): ChildProcess {
+	const child = spawn(command.command, command.args, {
+		detached: false,
+		stdio: [command.releaseOnStdinClose ? "pipe" : "ignore", "pipe", "pipe"],
+	});
+	child.once("error", onError);
+	child.once("exit", (code, signal) => onUnexpectedExit(formatExit(code, signal)));
+	return child;
+}
+
+export function stopInhibitorProcess(child: ChildProcess, command: InhibitorCommand | undefined) {
+	child.removeAllListeners("exit");
+	child.removeAllListeners("error");
+	if (child.killed) return;
+
+	if (command?.releaseOnStdinClose && child.stdin && !child.stdin.destroyed) {
+		child.stdin.end();
+		if (child.exitCode === null && child.signalCode === null) {
+			const killTimer = setTimeout(() => {
+				if (child.exitCode === null && child.signalCode === null && !child.killed) child.kill();
+			}, 2000);
+			killTimer.unref();
+			child.once("exit", () => clearTimeout(killTimer));
+		}
+	} else if (process.platform === "win32") {
+		child.kill();
+	} else {
+		child.kill("SIGTERM");
+	}
+}
+
+function formatExit(code: number | null, signal: NodeJS.Signals | null) {
+	if (signal) return `signal ${signal}`;
+	return `code ${code ?? "unknown"}`;
+}

package/node_modules/@narumitw/pi-caffeinate/src/inhibitors.ts

@@ -0,0 +1,167 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import type { CaffeinateMode } from "./settings.js";
+
+export interface InhibitorCommand {
+	command: string;
+	args: string[];
+	description: string;
+	releaseOnStdinClose?: boolean;
+	custom?: boolean;
+	/** Display mode also needs D-Bus because logind idle inhibition misses some compositors. */
+	addDbusIdleInhibit?: boolean;
+}
+
+export function getInhibitorCommand(mode: CaffeinateMode): InhibitorCommand | undefined {
+	const customCommand = process.env.PI_CAFFEINATE_COMMAND?.trim();
+	if (customCommand) {
+		const [command, ...args] = splitCommand(customCommand);
+		if (command) return { command, args, description: `custom command (${command})`, custom: true };
+	}
+	if (process.platform === "darwin") {
+		return parentBoundUnixCommand(
+			"caffeinate",
+			macCaffeinateArgs(mode),
+			caffeinateDescription(mode),
+		);
+	}
+	if (process.platform === "linux") {
+		if (isWsl() && commandExists("powershell.exe")) {
+			return windowsPowerInhibitorCommand("powershell.exe", mode);
+		}
+		if (commandExists("systemd-inhibit")) {
+			const what = mode === "display" ? "idle:sleep" : "sleep";
+			return parentBoundUnixCommand(
+				"systemd-inhibit",
+				[
+					`--what=${what}`,
+					"--who=pi-caffeinate",
+					"--why=Pi agent is running",
+					"--mode=block",
+					"sleep",
+					"infinity",
+				],
+				`systemd-inhibit (${formatMode(mode)})`,
+				mode === "display",
+			);
+		}
+		if (commandExists("caffeinate")) {
+			return parentBoundUnixCommand(
+				"caffeinate",
+				macCaffeinateArgs(mode),
+				caffeinateDescription(mode),
+				mode === "display",
+			);
+		}
+	}
+	if (process.platform === "win32") return windowsPowerInhibitorCommand("powershell.exe", mode);
+	return undefined;
+}
+
+function macCaffeinateArgs(mode: CaffeinateMode) {
+	return mode === "sleep" ? ["-ims"] : ["-dimsu"];
+}
+
+function caffeinateDescription(mode: CaffeinateMode) {
+	return `caffeinate (${formatMode(mode)})`;
+}
+
+function parentBoundUnixCommand(
+	command: string,
+	args: string[],
+	description: string,
+	addDbusIdleInhibit = false,
+): InhibitorCommand {
+	return {
+		command: "sh",
+		args: [
+			"-c",
+			unixParentBoundScript(),
+			"pi-caffeinate-watch",
+			String(process.pid),
+			command,
+			...args,
+		],
+		description,
+		...(addDbusIdleInhibit ? { addDbusIdleInhibit: true } : {}),
+	};
+}
+
+function unixParentBoundScript() {
+	return `parent=$1; shift; "$@" & child=$!; ( while kill -0 "$parent" 2>/dev/null; do sleep 5; done; kill "$child" 2>/dev/null ) & watcher=$!; cleanup() { kill "$watcher" 2>/dev/null; kill "$child" 2>/dev/null; wait "$child" 2>/dev/null; }; trap 'cleanup; exit 0' INT TERM HUP EXIT; wait "$child"; status=$?; kill "$watcher" 2>/dev/null; trap - EXIT; exit "$status"`;
+}
+
+function commandExists(command: string) {
+	const searchPath = process.env.PATH ?? "";
+	const extensions = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+	for (const directory of searchPath.split(process.platform === "win32" ? ";" : ":")) {
+		if (!directory) continue;
+		for (const extension of extensions) {
+			if (existsSync(path.join(directory, `${command}${extension}`))) return true;
+		}
+	}
+	return false;
+}
+
+export function splitCommand(input: string) {
+	const parts: string[] = [];
+	let current = "";
+	let quote: '"' | "'" | undefined;
+	let escaping = false;
+	for (const char of input) {
+		if (escaping) {
+			current += char;
+			escaping = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaping = true;
+			continue;
+		}
+		if ((char === '"' || char === "'") && !quote) {
+			quote = char;
+			continue;
+		}
+		if (char === quote) {
+			quote = undefined;
+			continue;
+		}
+		if (/\s/.test(char) && !quote) {
+			if (current) {
+				parts.push(current);
+				current = "";
+			}
+			continue;
+		}
+		current += char;
+	}
+	if (current) parts.push(current);
+	return parts;
+}
+
+function windowsPowerInhibitorCommand(command: string, mode: CaffeinateMode): InhibitorCommand {
+	return {
+		command,
+		args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", windowsInhibitorScript(mode)],
+		description: `PowerShell SetThreadExecutionState (${formatMode(mode)})`,
+		releaseOnStdinClose: true,
+	};
+}
+
+export function windowsInhibitorScript(mode: CaffeinateMode) {
+	const flags = mode === "sleep" ? "0x80000001" : "0x80000003";
+	return `$ErrorActionPreference = 'Stop'; Add-Type -Namespace Native -Name Power -MemberDefinition '[DllImport("kernel32.dll")] public static extern uint SetThreadExecutionState(uint esFlags);'; $flags = [uint32]'${flags}'; $release = [uint32]'0x80000000'; $stdin = [Console]::OpenStandardInput(); $buffer = New-Object byte[] 1; $readTask = $stdin.ReadAsync($buffer, 0, 1); try { while ($true) { [Native.Power]::SetThreadExecutionState($flags) | Out-Null; if ($readTask.Wait(30000)) { break } } } finally { [Native.Power]::SetThreadExecutionState($release) | Out-Null }`;
+}
+
+function isWsl() {
+	try {
+		return existsSync("/proc/sys/fs/binfmt_misc/WSLInterop");
+	} catch {
+		return false;
+	}
+}
+
+export function formatMode(mode: CaffeinateMode) {
+	return mode === "sleep" ? "system-awake" : "display-awake";
+}

package/node_modules/@narumitw/pi-caffeinate/src/settings.ts

@@ -0,0 +1,202 @@
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { access, lstat, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import process from "node:process";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+const NEW_SETTINGS_FILE = "pi-caffeinate.json";
+const LEGACY_SETTINGS_FILE = "pi-caffeinate-settings.json";
+
+export type CaffeinateMode = "sleep" | "display";
+
+export interface CaffeinateSettings {
+	mode: CaffeinateMode;
+	quiet: boolean;
+	updatedAt: number;
+}
+
+export interface SettingsFileOperations {
+	write(path: string, data: string): Promise<void>;
+	rename(source: string, destination: string): Promise<void>;
+}
+
+const DEFAULT_FILE_OPERATIONS: SettingsFileOperations = {
+	write: (path, data) => writeFile(path, data, "utf8").then(() => undefined),
+	rename,
+};
+
+export type SettingsLoadResult =
+	| { kind: "missing"; notice?: string }
+	| { kind: "invalid"; reason: string; notice?: string }
+	| { kind: "loaded"; settings: CaffeinateSettings; notice?: string };
+
+export async function loadSettings(): Promise<SettingsLoadResult> {
+	await settingsSaveQueue;
+	const newPath = settingsFilePath();
+	const newSettings = await readSettingsFile(newPath);
+	if (newSettings.kind !== "missing") return withLegacyIgnoredNotice(newSettings);
+
+	const legacyPath = legacySettingsFilePath();
+	const legacySettings = await readSettingsFile(legacyPath);
+	const concurrentlyCreatedSettings = await readSettingsFile(newPath);
+	if (concurrentlyCreatedSettings.kind !== "missing") {
+		return withLegacyIgnoredNotice(concurrentlyCreatedSettings);
+	}
+	if (legacySettings.kind === "missing") return { kind: "missing" };
+	if (legacySettings.kind === "invalid") return legacySettings;
+
+	return {
+		...legacySettings,
+		notice: `Using legacy ${LEGACY_SETTINGS_FILE}; rename it to ${NEW_SETTINGS_FILE}. Future saves write ${NEW_SETTINGS_FILE} without modifying the legacy file.`,
+	};
+}
+
+interface SettingsDocumentResult {
+	result: SettingsLoadResult;
+	document?: Record<string, unknown>;
+}
+
+async function readSettingsDocument(filePath: string): Promise<SettingsDocumentResult> {
+	let text: string;
+	try {
+		text = await readFile(filePath, "utf8");
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return { result: { kind: "missing" } };
+		return { result: { kind: "invalid", reason: `${filePath}: ${formatError(error)}` } };
+	}
+	try {
+		const document = JSON.parse(text) as unknown;
+		const settings = normalizeCaffeinateSettings(document);
+		if (settings) {
+			return {
+				result: { kind: "loaded", settings },
+				document: { ...(document as Record<string, unknown>) },
+			};
+		}
+		return {
+			result: {
+				kind: "invalid",
+				reason: `${filePath}: expected { "mode": "sleep" | "display", optional "quiet": boolean }`,
+			},
+		};
+	} catch (error) {
+		return { result: { kind: "invalid", reason: `${filePath}: ${formatError(error)}` } };
+	}
+}
+
+async function readSettingsFile(filePath: string): Promise<SettingsLoadResult> {
+	return (await readSettingsDocument(filePath)).result;
+}
+
+async function withLegacyIgnoredNotice(settings: SettingsLoadResult): Promise<SettingsLoadResult> {
+	if (!(await fileExists(legacySettingsFilePath()))) return settings;
+	return {
+		...settings,
+		notice: `pi-caffeinate legacy settings ignored: ${legacySettingsFilePath()} exists, but ${settingsFilePath()} takes precedence. Delete ${LEGACY_SETTINGS_FILE} after confirming your settings.`,
+	};
+}
+
+async function fileExists(filePath: string) {
+	try {
+		await access(filePath, constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function pathEntryExists(filePath: string) {
+	try {
+		await lstat(filePath);
+		return true;
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+
+export function normalizeCaffeinateSettings(value: unknown): CaffeinateSettings | undefined {
+	if (!value || typeof value !== "object") return undefined;
+	const settings = value as { mode?: unknown; quiet?: unknown; updatedAt?: unknown };
+	if (!isCaffeinateMode(settings.mode)) return undefined;
+	if (settings.quiet !== undefined && typeof settings.quiet !== "boolean") return undefined;
+	if (settings.updatedAt !== undefined && typeof settings.updatedAt !== "number") return undefined;
+	return {
+		mode: settings.mode,
+		quiet: settings.quiet ?? false,
+		updatedAt: settings.updatedAt ?? 0,
+	};
+}
+
+function isCaffeinateMode(value: unknown): value is CaffeinateMode {
+	return value === "sleep" || value === "display";
+}
+
+let settingsSaveQueue: Promise<unknown> = Promise.resolve();
+
+export function saveSettings(
+	settings: Omit<CaffeinateSettings, "quiet"> & { quiet?: boolean },
+	operations: Partial<SettingsFileOperations> = {},
+): Promise<CaffeinateSettings> {
+	const operation = settingsSaveQueue.then(() => saveSettingsNow(settings, operations));
+	settingsSaveQueue = operation.catch(() => undefined);
+	return operation;
+}
+
+async function saveSettingsNow(
+	settings: Omit<CaffeinateSettings, "quiet"> & { quiet?: boolean },
+	operations: Partial<SettingsFileOperations>,
+): Promise<CaffeinateSettings> {
+	const filePath = settingsFilePath();
+	let current = await readSettingsDocument(filePath);
+	const replaceCanonical = current.result.kind !== "missing";
+	if (!replaceCanonical) current = await readSettingsDocument(legacySettingsFilePath());
+	if (current.result.kind === "invalid") {
+		throw new Error(`Cannot save pi-caffeinate settings until you repair ${current.result.reason}`);
+	}
+	const document = current.document ?? {};
+	const quiet =
+		settings.quiet ?? (current.result.kind === "loaded" ? current.result.settings.quiet : false);
+	const nextSettings = { mode: settings.mode, quiet, updatedAt: settings.updatedAt };
+	const nextDocument = {
+		...document,
+		...nextSettings,
+	};
+	await mkdir(dirname(filePath), { recursive: true });
+	const tempFile = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+	try {
+		await (operations.write ?? DEFAULT_FILE_OPERATIONS.write)(
+			tempFile,
+			`${JSON.stringify(nextDocument, null, 2)}\n`,
+		);
+		if (!replaceCanonical && (await pathEntryExists(filePath))) {
+			throw new Error(`${NEW_SETTINGS_FILE} was created concurrently; reopen settings and retry.`);
+		}
+		await (operations.rename ?? DEFAULT_FILE_OPERATIONS.rename)(tempFile, filePath);
+		return nextSettings;
+	} catch (error) {
+		await rm(tempFile, { force: true }).catch(() => undefined);
+		throw error;
+	}
+}
+
+export function settingsFilePath() {
+	return join(agentDir(), NEW_SETTINGS_FILE);
+}
+
+function legacySettingsFilePath() {
+	return join(agentDir(), LEGACY_SETTINGS_FILE);
+}
+
+function agentDir() {
+	return getAgentDir();
+}
+
+function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+	return error instanceof Error && "code" in error;
+}
+
+function formatError(error: unknown) {
+	return error instanceof Error ? error.message : String(error);
+}

package/node_modules/@tifan/pi-handoff/README.md

@@ -1,6 +1,6 @@
 # @tifan/pi-handoff
 
-Start a fresh pi session from a handoff document, and query past sessions for context, decisions, or code changes.
+Start a new pi session from a handoff document. The new session can use the `session_query` tool to look up decisions, files, and next steps from earlier sessions.
 
 ## Install
 
@@ -10,33 +10,59 @@ pi install npm:@tifan/pi-handoff
 
 ## Requirements
 
-Matt Pocock's [`handoff` skill](https://github.com/mattpocock/skills/blob/main/skills/productivity/handoff/SKILL.md) is required:
+Install Matt Pocock's `handoff` skill:
 
 ```bash
 npx skills add https://github.com/mattpocock/skills --global --skill handoff
 ```
 
-## How it works
-
-Submit a prompt containing a standalone `-handoff` marker to generate a handoff document from the current session and automatically start a clean session from it. The marker can appear anywhere in the prompt. The handoff is written under the OS temp directory.
-
-The new session name uses the current session name when available. Otherwise, it uses the next-session focus, sanitized to lowercase, hyphen-separated text under 60 characters.
-
-The handoff includes the previous session path when available, so the next agent can use `session_query` if the handoff omits a detail.
-
 ## Usage
 
+Add a standalone `-handoff` marker to a prompt:
+
 ```text
 fix the auth flow -handoff
 ```
 
-The standalone `-handoff` marker is consumed before the prompt reaches the agent. The text before and after it becomes the next-session focus. A prompt containing only `-handoff` continues the current work.
+The marker is consumed before the prompt reaches the agent.
+
+- Text around the marker becomes the next-session focus.
+- The focus is used in the handoff document.
+- A handoff document is written under the OS temp directory.
+- A new session starts automatically from the document.
+- When Pi runs inside Herdr, the handoff opens in a new tab without changing focus. The current parent session stays available in its original tab.
+- The handoff session keeps the parent-session link and selected provider/model when available.
+- Outside Herdr, the current session is replaced.
+
+A prompt containing only `-handoff` continues the current work.
+
+## Session naming
+
+`pi-handoff` imports the shared naming code from `@tifan/pi-rename`. Installing pi-handoff installs this dependency automatically, but it does not enable pi-rename's commands.
+
+Handoff uses the same naming logic as `/rename`:
+
+- Uses the first user message and up to three latest user messages.
+- Reads the model from `$PI_CODING_AGENT_DIR/extensions/pi-rename.json`.
+- Uses `openai-codex/gpt-5.6-luna` when no config exists.
+- Produces a name such as `[handoff] fix-auth-callback`.
+- Keeps the generated base name under 30 characters before adding the prefix.
+- Falls back to the latest user message if the naming model is unavailable.
+- Uses `[handoff] handoff-session` when no usable user text exists.
+
+The handoff artifact filename uses the unprefixed base name. If you run `/rename` in the new session, it replaces the complete name and can remove the `[handoff]` prefix.
+
+Install `@tifan/pi-rename` separately only if you want its `/rename` and `/rename config` commands.
 
 ## `session_query`
 
-`session_query`: Answer a question about a previous pi session, given the full path to its `.jsonl` file and the question to ask. It uses the configured `openai-codex/gpt-5.6-luna` model, which must be available and authenticated.
+`session_query` answers questions about a previous pi session:
+
+- Reads the previous `.jsonl` session file.
+- Uses the `openai-codex/gpt-5.6-luna` model.
+- Requires that model to be available and authenticated.
 
-Pi provides session loading and compaction-aware context reconstruction, but not semantic questions about an arbitrary previous session. `session_query` supplies that model-powered query layer.
+Pi provides session loading and compaction-aware context reconstruction. `session_query` provides semantic answers about the previous session.
 
 ## Release notes
 

package/node_modules/@tifan/pi-handoff/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tifan/pi-handoff",
-  "version": "2.0.1",
+  "version": "2.2.1",
   "description": "Transfer pi session context to a new session and query past sessions.",
   "keywords": [
     "handoff",
@@ -29,7 +29,7 @@
     "provenance": true
   },
   "dependencies": {
-    "@tifan/pi-rename": "^0.5.0"
+    "@tifan/pi-rename": "^0.6.0"
   },
   "engines": {
     "node": ">=20"