@huseynsnmz/pi-suite 0.2.2 → 0.2.3

package/packages/subscription/src/catalog.ts

@@ -0,0 +1,310 @@
+// Generated by scripts/gen-catalog.mjs from pi's Anthropic catalog. Do not edit.
+export const CATALOG = [
+	{
+		"id": "claude-fable-5",
+		"name": "Claude Fable 5",
+		"reasoning": true,
+		"input": [
+			"text",
+			"image"
+		],
+		"cost": {
+			"input": 10,
+			"output": 50,
+			"cacheRead": 1,
+			"cacheWrite": 12.5
+		},
+		"contextWindow": 1000000,
+		"maxTokens": 128000,
+		"thinkingLevelMap": {
+			"off": null,
+			"xhigh": "xhigh",
+			"max": "max"
+		}
+	},
+	{
+		"id": "claude-fable-5-1",
+		"name": "Claude Fable 5.1",
+		"reasoning": true,
+		"input": [
+			"text",
+			"image"
+		],
+		"cost": {
+			"input": 10,
+			"output": 50,
+			"cacheRead": 0.25,
+			"cacheWrite": 12.5
+		},
+		"contextWindow": 1000000,
+		"maxTokens": 128000,
+		"thinkingLevelMap": {
+			"off": null,
+			"xhigh": "xhigh",
+			"max": "max"
+		}
+	},
+	{
+		"id": "claude-haiku-4-5",
+		"name": "Claude Haiku 4.5 (latest)",
+		"reasoning": true,
+		"input": [
+			"text",
+			"image"
+		],
+		"cost": {
+			"input": 1,
+			"output": 5,
+			"cacheRead": 0.1,
+			"cacheWrite": 1.25
+		},
+		"contextWindow": 200000,
+		"maxTokens": 64000
+	},
+	{
+		"id": "claude-haiku-5-5",
+		"name": "Claude Haiku 5.5",
+		"reasoning": true,
+		"input": [
+			"text",
+			"image"
+		],
+		"cost": {
+			"input": 0.1,
+			"output": 0.5,
+			"cacheRead": 0.01,
+			"cacheWrite": 0.125,
+			"tiers": [
+				{
+					"inputTokensAbove": 100000,
+					"input": 0.5,
+					"output": 2.5,
+					"cacheRead": 0.05,
+					"cacheWrite": 0.625
+				}
+			]
+		},
+		"contextWindow": 1000000,
+		"maxTokens": 128000,
+		"thinkingLevelMap": {
+			"off": null,
+			"minimal": null,
+			"low": "low",
+			"medium": "medium",
+			"high": "high",
+			"xhigh": "xhigh",
+			"max": "max"
+		}
+	},
+	{
+		"id": "claude-opus-4-5",
+		"name": "Claude Opus 4.5 (latest)",
+		"reasoning": true,
+		"input": [
+			"text",
+			"image"
+		],
+		"cost": {
+			"input": 5,
+			"output": 25,
+			"cacheRead": 0.5,
+			"cacheWrite": 6.25
+		},
+		"contextWindow": 200000,
+		"maxTokens": 64000
+	},
+	{
+		"id": "claude-opus-4-6",
+		"name": "Claude Opus 4.6",
+		"reasoning": true,
+		"input": [
+			"text",
+			"image"
+		],
+		"cost": {
+			"input": 5,
+			"output": 25,
+			"cacheRead": 0.5,
+			"cacheWrite": 6.25
+		},
+		"contextWindow": 1000000,
+		"maxTokens": 128000,
+		"thinkingLevelMap": {
+			"max": "max"
+		}
+	},
+	{
+		"id": "claude-opus-4-7",
+		"name": "Claude Opus 4.7",
+		"reasoning": true,
+		"input": [
+			"text",
+			"image"
+		],
+		"cost": {
+			"input": 5,
+			"output": 25,
+			"cacheRead": 0.5,
+			"cacheWrite": 6.25
+		},
+		"contextWindow": 1000000,
+		"maxTokens": 128000,
+		"thinkingLevelMap": {
+			"xhigh": "xhigh",
+			"max": "max"
+		}
+	},
+	{
+		"id": "claude-opus-4-8",
+		"name": "Claude Opus 4.8",
+		"reasoning": true,
+		"input": [
+			"text",
+			"image"
+		],
+		"cost": {
+			"input": 5,
+			"output": 25,
+			"cacheRead": 0.5,
+			"cacheWrite": 6.25
+		},
+		"contextWindow": 1000000,
+		"maxTokens": 128000,
+		"thinkingLevelMap": {
+			"xhigh": "xhigh",
+			"max": "max"
+		}
+	},
+	{
+		"id": "claude-opus-5",
+		"name": "Claude Opus 5",
+		"reasoning": true,
+		"input": [
+			"text",
+			"image"
+		],
+		"cost": {
+			"input": 5,
+			"output": 25,
+			"cacheRead": 0.5,
+			"cacheWrite": 6.25
+		},
+		"contextWindow": 1000000,
+		"maxTokens": 128000,
+		"thinkingLevelMap": {
+			"off": null,
+			"xhigh": "xhigh",
+			"max": "max"
+		}
+	},
+	{
+		"id": "claude-opus-5-5",
+		"name": "Claude Opus 5.5",
+		"reasoning": true,
+		"input": [
+			"text",
+			"image"
+		],
+		"cost": {
+			"input": 4,
+			"output": 20,
+			"cacheRead": 0.2,
+			"cacheWrite": 5
+		},
+		"contextWindow": 1000000,
+		"maxTokens": 128000,
+		"thinkingLevelMap": {
+			"off": null,
+			"minimal": null,
+			"low": "low",
+			"medium": "medium",
+			"high": "high",
+			"xhigh": "xhigh",
+			"max": "max"
+		}
+	},
+	{
+		"id": "claude-sonnet-4-5",
+		"name": "Claude Sonnet 4.5 (latest)",
+		"reasoning": true,
+		"input": [
+			"text",
+			"image"
+		],
+		"cost": {
+			"input": 3,
+			"output": 15,
+			"cacheRead": 0.3,
+			"cacheWrite": 3.75
+		},
+		"contextWindow": 1000000,
+		"maxTokens": 64000
+	},
+	{
+		"id": "claude-sonnet-4-6",
+		"name": "Claude Sonnet 4.6",
+		"reasoning": true,
+		"input": [
+			"text",
+			"image"
+		],
+		"cost": {
+			"input": 3,
+			"output": 15,
+			"cacheRead": 0.3,
+			"cacheWrite": 3.75
+		},
+		"contextWindow": 1000000,
+		"maxTokens": 128000,
+		"thinkingLevelMap": {
+			"max": "max"
+		}
+	},
+	{
+		"id": "claude-sonnet-5",
+		"name": "Claude Sonnet 5",
+		"reasoning": true,
+		"input": [
+			"text",
+			"image"
+		],
+		"cost": {
+			"input": 2,
+			"output": 10,
+			"cacheRead": 0.2,
+			"cacheWrite": 2.5
+		},
+		"contextWindow": 1000000,
+		"maxTokens": 128000,
+		"thinkingLevelMap": {
+			"xhigh": "xhigh",
+			"max": "max"
+		}
+	},
+	{
+		"id": "claude-sonnet-5-5",
+		"name": "Claude Sonnet 5.5",
+		"reasoning": true,
+		"input": [
+			"text",
+			"image"
+		],
+		"cost": {
+			"input": 2,
+			"output": 10,
+			"cacheRead": 0.2,
+			"cacheWrite": 2.5
+		},
+		"contextWindow": 1000000,
+		"maxTokens": 128000,
+		"thinkingLevelMap": {
+			"off": null,
+			"minimal": null,
+			"low": "low",
+			"medium": "medium",
+			"high": "high",
+			"xhigh": "xhigh",
+			"max": "max"
+		}
+	}
+] as const;

package/packages/subscription/src/cc-sessions.ts

@@ -0,0 +1,122 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import { assistantBlocks, type TurnMessage, userTurnBlocks } from "./convert.ts";
+
+function projectsRoot(): string {
+	return join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"), "projects");
+}
+
+/** Claude Code's per-project session directory: the working directory's realpath, sanitized. */
+export function projectDir(cwd: string): string {
+	let real = cwd;
+	try {
+		real = realpathSync(cwd);
+	} catch {}
+	return join(projectsRoot(), real.replace(/[^a-zA-Z0-9]/g, "-"));
+}
+
+/** Path of a session's transcript, wherever Claude Code filed it. */
+export function sessionFile(cwd: string, sessionId: string): string | undefined {
+	const name = `${sessionId}.jsonl`;
+	const direct = join(projectDir(cwd), name);
+	if (existsSync(direct)) return direct;
+	try {
+		for (const dir of readdirSync(projectsRoot())) {
+			const f = join(projectsRoot(), dir, name);
+			if (existsSync(f)) return f;
+		}
+	} catch {}
+	return undefined;
+}
+
+/**
+ * Legacy-anchor fallback: the uuid of the last transcript entry Claude Code wrote for API
+ * message `messageId` (it stores one entry per content block). New anchors capture this uuid
+ * from the SDK stream instead; this scan serves anchors persisted before that was possible.
+ */
+export function findMessageUuid(cwd: string, sessionId: string, messageId: string): string | undefined {
+	const file = sessionFile(cwd, sessionId);
+	if (!file) return undefined;
+	let uuid: string | undefined;
+	for (const line of readFileSync(file, "utf8").split("\n")) {
+		if (!line.includes(messageId)) continue;
+		try {
+			const e = JSON.parse(line);
+			if (e.type === "assistant" && e.message?.id === messageId && !e.isSidechain) uuid = e.uuid;
+		} catch {}
+	}
+	return uuid;
+}
+
+/**
+ * Write a Claude Code transcript for history that never ran through Claude Code (another
+ * provider's turns, a compacted session, a session from before this extension). Returns the
+ * session id and the uuid to resume at. `messages` must end with an assistant message.
+ */
+export function synthesizeSession(cwd: string, model: string, messages: TurnMessage[]): { sessionId: string; at: string } {
+	const sessionId = randomUUID();
+	const lines: string[] = [];
+	let parent: string | null = null;
+	const now = Date.now();
+	const common = { isSidechain: false, userType: "external", entrypoint: "sdk-cli", cwd, sessionId };
+	// Thinking signatures are only needed (and only checked) inside the trailing tool loop;
+	// earlier thinking is dropped by the API anyway.
+	let lastUserText = -1;
+	messages.forEach((m, i) => {
+		if (m.role === "user") lastUserText = i;
+	});
+	let i = 0;
+	let n = 0;
+	while (i < messages.length) {
+		const uuid = randomUUID();
+		const timestamp = new Date(now - (messages.length - i) * 1000).toISOString();
+		const m = messages[i];
+		if (m.role === "assistant") {
+			const keepThinking = i > lastUserText && m.model === model && (m.api === "claude-agent-sdk" || m.api === "anthropic-messages");
+			const content = assistantBlocks(m as AssistantMessage, keepThinking);
+			lines.push(
+				JSON.stringify({
+					parentUuid: parent,
+					...common,
+					type: "assistant",
+					message: {
+						id: `msg_pi_${(n++).toString(36)}_${sessionId.slice(0, 8)}`,
+						type: "message",
+						role: "assistant",
+						model,
+						content: content.length > 0 ? content : [{ type: "text", text: "(empty)" }],
+						stop_reason: content.some((c) => c.type === "tool_use") ? "tool_use" : "end_turn",
+						stop_sequence: null,
+						usage: { input_tokens: 0, output_tokens: 0 },
+					},
+					uuid,
+					timestamp,
+				}),
+			);
+			i++;
+		} else {
+			let j = i;
+			while (j < messages.length && messages[j].role !== "assistant") j++;
+			const content = userTurnBlocks(messages.slice(i, j));
+			lines.push(
+				JSON.stringify({
+					parentUuid: parent,
+					...common,
+					type: "user",
+					message: { role: "user", content: content.length > 0 ? content : [{ type: "text", text: "(empty)" }] },
+					uuid,
+					timestamp,
+				}),
+			);
+			i = j;
+		}
+		parent = uuid;
+	}
+	mkdirSync(projectDir(cwd), { recursive: true });
+	// The whole conversation, so only you can read it, as with Claude Code's own files.
+	writeFileSync(join(projectDir(cwd), `${sessionId}.jsonl`), `${lines.join("\n")}\n`, { mode: 0o600, flag: "wx" });
+	return { sessionId, at: parent! };
+}

package/packages/subscription/src/config.ts

@@ -0,0 +1,34 @@
+import { readSection } from "../../../src/settings.ts";
+
+export interface Config {
+	pathToClaudeCodeExecutable?: string;
+	/** "claude" (default): a pi prompt prefix written for Claude. "pi": pi's default prompt. */
+	promptMode?: "claude" | "pi";
+	maxSessions?: number;
+	idleMinutes?: number;
+}
+
+const intIn = (lo: number, hi: number) => (n: unknown): n is number => Number.isInteger(n) && (n as number) >= lo && (n as number) <= hi;
+const validMaxSessions = intIn(1, 16);
+const validIdleMinutes = intIn(1, 24 * 60);
+
+/** Its settings are all conveniences, so broken ones just mean the defaults. */
+function readSaved(agentDir: string): Record<string, unknown> {
+	try {
+		return readSection(agentDir, "subscription");
+	} catch {
+		return {};
+	}
+}
+
+/** Global only: a repository must not choose which program runs, or how many, or how your prompt is built. */
+export function resolveConfig(where: { agentDir: string; env: Record<string, string | undefined> }): Config {
+	const saved = readSaved(where.agentDir);
+	const path = where.env.PI_CLAUDE_SDK_CLAUDE_PATH ?? saved.pathToClaudeCodeExecutable;
+	return {
+		...(typeof path === "string" && path !== "" ? { pathToClaudeCodeExecutable: path } : {}),
+		...(validMaxSessions(saved.maxSessions) ? { maxSessions: saved.maxSessions } : {}),
+		...(validIdleMinutes(saved.idleMinutes) ? { idleMinutes: saved.idleMinutes } : {}),
+		promptMode: where.env.PI_CLAUDE_SDK_PROMPT === "pi" || (where.env.PI_CLAUDE_SDK_PROMPT === undefined && saved.promptMode === "pi") ? "pi" : "claude",
+	};
+}

package/packages/subscription/src/convert.ts

@@ -0,0 +1,161 @@
+import type {
+	AssistantMessage,
+	ImageContent,
+	Message,
+	SystemMessage,
+	TextContent,
+	Tool,
+	ToolResultMessage,
+	TranscriptContext,
+	UserMessage,
+} from "@earendil-works/pi-ai";
+import { getCurrentTools, getInitialSystemMessage, getSystemMessageText, renderSystemMessageUpdate, toToolDeclaration } from "@earendil-works/pi-ai";
+import { sha, stableStringify } from "./util.ts";
+
+export const MCP_SERVER = "pi";
+export const MCP_PREFIX = `mcp__${MCP_SERVER}__`;
+
+/** A transcript message the provider consumes: everything but the leading system message. */
+export type TurnMessage = UserMessage | AssistantMessage | ToolResultMessage | SystemMessage;
+
+export interface Transcript {
+	/** Leading system prompt text; fixed for the lifetime of a Claude Code session. */
+	systemPrompt: string;
+	/** Tools in effect for this request (after every transcript delta). */
+	tools: Tool[];
+	toolsHash: string;
+	messages: TurnMessage[];
+	/** chain[i] identifies the conversation state after messages[0..i). chain[0] is the prompt alone. */
+	chain: string[];
+}
+
+/**
+ * Prepare pi's transcript for Claude Code. Failed or aborted assistant turns are dropped, as pi's
+ * built-in Anthropic provider does, together with tool results that answer their calls.
+ */
+export function readTranscript(context: TranscriptContext): Transcript {
+	const leading = getInitialSystemMessage(context.messages);
+	const systemPrompt = leading ? getSystemMessageText(leading) : "";
+	const tools = getCurrentTools(context.messages).map(toToolDeclaration);
+	const messages: TurnMessage[] = [];
+	const droppedCalls = new Set<string>();
+	for (const m of context.messages) {
+		if (m === leading) continue;
+		if (m.role === "assistant" && (m.stopReason === "error" || m.stopReason === "aborted")) {
+			for (const c of m.content) if (c.type === "toolCall") droppedCalls.add(c.id);
+			continue;
+		}
+		if (m.role === "toolResult" && droppedCalls.has(m.toolCallId)) continue;
+		messages.push(m as TurnMessage);
+	}
+	const chain = [sha(`prompt\0${systemPrompt}`)];
+	for (const m of messages) chain.push(sha(`${chain[chain.length - 1]}\0${fingerprint(m)}`));
+	return { systemPrompt, tools, toolsHash: sha(stableStringify(tools)), messages, chain };
+}
+
+/** Content identity of a message: what the model sees, without timestamps, usage or ids pi adds. */
+export function fingerprint(m: TurnMessage): string {
+	switch (m.role) {
+		case "user":
+			return stableStringify(["u", normContent(m.content)]);
+		case "toolResult":
+			return stableStringify(["r", m.toolCallId, normContent(m.content), !!m.isError]);
+		case "system":
+			return stableStringify(["s", renderSystemMessageUpdate(m)]);
+		case "assistant":
+			return stableStringify([
+				"a",
+				m.content
+					.filter((c) => !(c.type === "text" && c.text.length === 0))
+					.map((c) =>
+						c.type === "text"
+							? ["t", c.text]
+							: c.type === "thinking"
+								? ["k", c.thinking, c.thinkingSignature ?? "", !!c.redacted]
+								: ["c", c.id, c.name, c.arguments],
+					),
+			]);
+	}
+}
+
+function normContent(content: string | (TextContent | ImageContent)[]): unknown {
+	if (typeof content === "string") return [["t", content]];
+	return content.map((c) => (c.type === "text" ? ["t", c.text] : ["i", c.mimeType, sha(c.data)]));
+}
+
+// ---- pi → Anthropic content -------------------------------------------------------------
+
+const ID_RE = /^[a-zA-Z0-9_-]{1,64}$/;
+/** Anthropic tool_use ids must match ^[a-zA-Z0-9_-]+$; ids from other providers may not. */
+export function toolUseId(id: string): string {
+	return ID_RE.test(id) ? id : `toolu_x${sha(id).slice(0, 24)}`;
+}
+
+export function toImageBlock(c: ImageContent) {
+	return { type: "image" as const, source: { type: "base64" as const, media_type: c.mimeType, data: c.data } };
+}
+
+function userBlocks(content: string | (TextContent | ImageContent)[]): any[] {
+	if (typeof content === "string") return content.length > 0 ? [{ type: "text", text: content }] : [];
+	return content
+		.filter((c) => c.type !== "text" || c.text.length > 0)
+		.map((c) => (c.type === "text" ? { type: "text", text: c.text } : toImageBlock(c)));
+}
+
+export function toolResultBlock(m: ToolResultMessage): any {
+	const content = m.content.map((c) => (c.type === "text" ? { type: "text", text: c.text } : toImageBlock(c)));
+	return {
+		type: "tool_result",
+		tool_use_id: toolUseId(m.toolCallId),
+		content: content.length > 0 ? content : [{ type: "text", text: "(no output)" }],
+		...(m.isError ? { is_error: true } : {}),
+	};
+}
+
+/** A later system message (prompt or section change), delivered as a system reminder in the user turn. */
+export function systemUpdateText(m: SystemMessage): string | undefined {
+	const text = renderSystemMessageUpdate(m).trim();
+	return text ? `<system-reminder>\n${text}\n</system-reminder>` : undefined;
+}
+
+/**
+ * Render consecutive non-assistant messages as one Anthropic user message. Tool results come
+ * first, as the API requires, then reminders and user text in transcript order.
+ */
+export function userTurnBlocks(tail: TurnMessage[]): any[] {
+	const results: any[] = [];
+	const rest: any[] = [];
+	for (const m of tail) {
+		if (m.role === "toolResult") results.push(toolResultBlock(m));
+		else if (m.role === "user") rest.push(...userBlocks(m.content));
+		else if (m.role === "system") {
+			const text = systemUpdateText(m);
+			if (text) rest.push({ type: "text", text });
+		}
+	}
+	return [...results, ...rest];
+}
+
+/** Assistant content for a synthesized Claude Code transcript. */
+export function assistantBlocks(m: AssistantMessage, keepThinking: boolean): any[] {
+	const blocks: any[] = [];
+	for (const c of m.content) {
+		if (c.type === "text") {
+			if (c.text.length > 0) blocks.push({ type: "text", text: c.text });
+		} else if (c.type === "thinking") {
+			if (!keepThinking || !c.thinkingSignature) continue;
+			if (c.redacted) blocks.push({ type: "redacted_thinking", data: c.thinkingSignature });
+			else blocks.push({ type: "thinking", thinking: c.thinking, signature: c.thinkingSignature });
+		} else if (c.type === "toolCall") {
+			blocks.push({ type: "tool_use", id: toolUseId(c.id), name: MCP_PREFIX + c.name, input: c.arguments ?? {} });
+		}
+	}
+	return blocks;
+}
+
+/** Map a tool_use name emitted by Claude back to pi's tool name. */
+export function piToolName(name: string): string {
+	return name.startsWith(MCP_PREFIX) ? name.slice(MCP_PREFIX.length) : name;
+}
+
+export type { Message };

package/packages/subscription/src/index.ts

@@ -0,0 +1,69 @@
+import { appendFileSync } from "node:fs";
+import { type ExtensionAPI, type ExtensionContext, getAgentDir, getDocsPath, getExamplesPath, getReadmePath } from "@earendil-works/pi-coding-agent";
+import { EXTRA_USAGE_NO, EXTRA_USAGE_QUESTION, EXTRA_USAGE_YES } from "./billing.ts";
+import { resolveConfig } from "./config.ts";
+import { anthropicChatModels, claudeModels } from "./models.ts";
+import { applyClaudePrompt } from "./prompt.ts";
+import { API, ClaudeSdkProvider } from "./provider.ts";
+
+export const PROVIDER = "claude-sdk";
+
+/**
+ * pi extension: Claude models through the Claude Agent SDK, authenticated by the local Claude
+ * Code login (Pro/Max subscription). pi keeps its own agent loop, tools, prompt and compaction;
+ * Claude Code is used only as the authenticated model transport.
+ */
+export default function (pi: ExtensionAPI) {
+	const config = resolveConfig({ agentDir: getAgentDir(), env: process.env });
+	const debugPath = process.env.PI_CLAUDE_SDK_DEBUG;
+	let session: ExtensionContext | undefined;
+	const provider = new ClaudeSdkProvider({
+		// With nobody to ask, as in `pi -p` or a subagent, it stops rather than spend your money.
+		confirmExtraUsage: async (_info, signal) => {
+			if (!session?.hasUI) return false;
+			return (await session.ui.select(EXTRA_USAGE_QUESTION, [EXTRA_USAGE_NO, EXTRA_USAGE_YES], { signal })) === EXTRA_USAGE_YES;
+		},
+		pathToClaudeCodeExecutable: config.pathToClaudeCodeExecutable,
+		...(config.maxSessions ? { maxSessions: config.maxSessions } : {}),
+		...(config.idleMinutes ? { idleMs: config.idleMinutes * 60_000 } : {}),
+		debug: debugPath ? (msg) => appendFileSync(debugPath, `${new Date().toISOString()} ${msg}\n`) : undefined,
+	});
+
+	const register = (models = claudeModels()) =>
+		pi.registerProvider(PROVIDER, {
+			name: "Claude (subscription via Agent SDK)",
+			// Claude Code authenticates itself; pi only needs a non-empty key to treat the provider as configured.
+			apiKey: "claude-code-login",
+			api: API as any,
+			baseUrl: "claude-agent-sdk://local",
+			models,
+			streamSimple: provider.streamSimple,
+		});
+	register();
+
+	// Pick up Claude models newer than the bundled snapshot from pi's own catalog.
+	let refreshed = false;
+	pi.on("session_start", (_event, ctx) => {
+		session = ctx;
+		if (refreshed) return;
+		refreshed = true;
+		try {
+			const live = anthropicChatModels(ctx.modelRegistry.getAll());
+			const known = new Set(claudeModels().map((m) => m.id));
+			if (live.some((m) => !/-\d{8}$/.test(m.id) && !known.has(m.id))) register(claudeModels(live));
+		} catch {
+			// The snapshot stays registered.
+		}
+	});
+
+	const docs = { readme: getReadmePath(), docs: getDocsPath(), examples: getExamplesPath() };
+	pi.on("before_agent_start", (event, ctx) => applyClaudePrompt(event, ctx.model, config.promptMode ?? "claude", docs));
+
+	const shutdown = () => provider.shutdown();
+	process.once("exit", shutdown);
+	pi.on("session_shutdown", () => {
+		session = undefined;
+		process.off("exit", shutdown);
+		shutdown();
+	});
+}