@rivus/runtime 0.16.2

package/dist/pi.js

@@ -0,0 +1,2143 @@
+import { a as requiresToolApproval, l as normalizeAgentInvocation, r as createToolInputDigest$1, s as createInvocationAuthority } from "./chunks/tool-input-digest.js";
+import { _ as createAgentLoopToolExecutionStart, d as createAgentLoopModelExecutionStart, f as createAgentLoopSkillExecutionEnd, g as createAgentLoopToolExecutionEnd, h as createAgentLoopThinkingDelta, l as toEffectAgentLoopInput, m as createAgentLoopTextDelta, o as fromEffectAgentLoop, p as createAgentLoopSkillExecutionStart, s as toCompatibilityAgentLoopInput, u as createAgentLoopModelExecutionEnd, v as createAgentLoopToolExecutionUpdate } from "./chunks/agent-loop.js";
+import { Effect, Stream } from "effect";
+import { createHash, randomUUID } from "node:crypto";
+import { readFile, realpath, stat } from "node:fs/promises";
+import { isAbsolute, join, relative } from "node:path";
+import { writeAtomicTextFile } from "@rivus/platform/persistence";
+import { createSha256Digest } from "@rivus/platform/identity";
+import { Type, Unsafe } from "typebox";
+import { DefaultResourceLoader, ModelRuntime, SessionManager, SettingsManager, createAgentSession, createBashToolDefinition, createReadToolDefinition, defineTool, estimateTokens } from "@earendil-works/pi-coding-agent";
+import { realpathSync, statSync } from "node:fs";
+//#region src/adapters/pi/config/pi-model-overrides.ts
+async function mergePiProviderBaseUrlOverride(options) {
+	await updatePiProviderOverride(options.filePath, options.provider, (providerOverride) => ({
+		...providerOverride,
+		baseUrl: options.baseUrl
+	}));
+}
+/**
+* Persist one complete custom model definition in models.json.
+*
+* Pi composes these definitions with its built-in provider metadata. Keeping the
+* complete definition here is deliberate: a missing SDK catalog entry must be
+* represented by its exact server id, never by a fuzzy or legacy alias.
+*/
+async function mergePiProviderModelDeclaration(options) {
+	await updatePiProviderOverride(options.filePath, options.provider, (providerOverride) => {
+		const models = providerOverride.models;
+		if (models !== void 0 && (!Array.isArray(models) || models.some((model) => !isJsonRecord(model)))) throw new Error(`${options.filePath} providers.${options.provider}.models must be a JSON array of objects`);
+		const existingModels = models ?? [];
+		const existingIndex = existingModels.findIndex((model) => model.id === options.model.id);
+		const nextModels = [...existingModels];
+		if (existingIndex >= 0) nextModels[existingIndex] = {
+			...nextModels[existingIndex],
+			...options.model
+		};
+		else nextModels.push({ ...options.model });
+		return {
+			...providerOverride,
+			models: nextModels
+		};
+	});
+}
+async function updatePiProviderOverride(filePath, provider, update) {
+	const overrides = await readPiModelOverrides(filePath);
+	const providers = readJsonRecord(overrides.providers, filePath, "providers");
+	const providerOverride = readJsonRecord(providers[provider], filePath, `providers.${provider}`);
+	await writePiModelOverrides(filePath, {
+		...overrides,
+		providers: {
+			...providers,
+			[provider]: update(providerOverride)
+		}
+	});
+}
+async function readPiModelOverrides(filePath) {
+	try {
+		return readJsonRecord(JSON.parse(await readFile(filePath, "utf8")), filePath, "root");
+	} catch (error) {
+		if (isFileNotFound(error)) return {};
+		throw error;
+	}
+}
+async function writePiModelOverrides(filePath, overrides) {
+	await writeAtomicTextFile(filePath, `${JSON.stringify(overrides, null, 2)}\n`, {
+		durable: true,
+		mode: 384
+	});
+}
+function readJsonRecord(value, filePath, path) {
+	if (value === void 0) return {};
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${filePath} ${path} must be a JSON object`);
+	return value;
+}
+function isJsonRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFileNotFound(error) {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+//#endregion
+//#region src/adapters/pi/skills/pi-skill-tool.ts
+const PI_SKILL_READER_TOOL_NAME = "rivus_read_skill";
+function createPiSkillRuntime(skills) {
+	if (skills.length === 0) return Object.freeze({ prompt: "" });
+	const skillsById = new Map(skills.map((skill) => [skill.id, skill]));
+	const prompt = [
+		"Granted Skills are versioned instructions loaded on demand.",
+		`Before following a Skill, call ${PI_SKILL_READER_TOOL_NAME} with its exact ID and follow the returned content.`,
+		"Granted Skill catalog:",
+		...skills.map((skill) => `- ${skill.id} | ${skill.title} | v${skill.version} | ${skill.digest}`)
+	].join("\n");
+	const tool = {
+		description: "Read the full versioned instructions for one Skill granted to this Agent Runtime.",
+		execute: async (_callId, input) => {
+			const skillId = readSkillId$1(input);
+			const skill = skillsById.get(skillId);
+			if (!skill) throw new Error(`Skill is not granted: ${skillId}`);
+			const details = {
+				contentLength: skill.content.length,
+				digest: skill.digest,
+				skillId: skill.id,
+				title: skill.title,
+				version: skill.version
+			};
+			return {
+				content: [{
+					text: skill.content,
+					type: "text"
+				}],
+				details
+			};
+		},
+		executionMode: "sequential",
+		label: "Read granted Skill",
+		name: PI_SKILL_READER_TOOL_NAME,
+		parameters: Unsafe({
+			additionalProperties: false,
+			properties: { skillId: {
+				description: "Exact Skill ID from the granted Skill catalog.",
+				type: "string"
+			} },
+			required: ["skillId"],
+			type: "object"
+		}),
+		promptSnippet: `${PI_SKILL_READER_TOOL_NAME}: read one granted Skill by exact ID`
+	};
+	return Object.freeze({
+		prompt,
+		tool
+	});
+}
+function readSkillId$1(input) {
+	if (input === null || typeof input !== "object" || Array.isArray(input) || typeof input.skillId !== "string") throw new Error("Skill reader input requires a string skillId");
+	return input.skillId;
+}
+//#endregion
+//#region src/adapters/pi/execution/pi-session-prompts.ts
+/** One ordinary prompt writer, with ordered native steering while that prompt is streaming. */
+async function runPiSessionPrompts(options) {
+	const { input, handle } = options;
+	const { session } = handle;
+	const prepare = (text) => handle.preparePrompt?.({
+		...input,
+		text
+	}) ?? text;
+	if (!options.supportsSteering) {
+		const text = await prepare(input.text);
+		if (!input.abortSignal.aborted) await session.prompt(text);
+		return;
+	}
+	if (!session.steer || typeof session.isStreaming !== "boolean" || !session.clearQueue) throw new Error("Pi steering requires native steer, isStreaming and clearQueue capabilities");
+	const mailbox = input.steering;
+	const stop = new AbortController();
+	const onAbort = () => stop.abort();
+	input.abortSignal.addEventListener("abort", onAbort, { once: true });
+	if (input.abortSignal.aborted) stop.abort();
+	const close = () => Effect.runPromise(mailbox?.close?.() ?? Effect.succeed([]));
+	const take = () => Effect.runPromise(mailbox?.next() ?? Effect.never, { signal: stop.signal }).then((text) => ({
+		type: "steering",
+		text
+	}), (error) => {
+		if (stop.signal.aborted) return { type: "closed" };
+		throw error;
+	});
+	let prompt = Promise.resolve({ type: "completed" });
+	const startPrompt = (text) => {
+		prompt = session.prompt(text).then(() => ({ type: "completed" }), (error) => ({
+			type: "failed",
+			error
+		}));
+	};
+	const settlePrompt = async () => {
+		const outcome = await prompt;
+		if (outcome.type === "failed") throw outcome.error;
+	};
+	let next;
+	let succeeded = false;
+	try {
+		const text = await prepare(input.text);
+		if (input.abortSignal.aborted) return;
+		startPrompt(text);
+		next = take();
+		while (!input.abortSignal.aborted) {
+			const outcome = await Promise.race([next, prompt]);
+			if (outcome.type === "failed") throw outcome.error;
+			if (outcome.type === "closed") break;
+			if (outcome.type === "completed") {
+				const remaining = await close();
+				stop.abort();
+				const claimed = await next;
+				const accepted = claimed.type === "steering" ? [claimed.text, ...remaining] : remaining;
+				for (const acceptedText of accepted) {
+					const prepared = await prepare(acceptedText);
+					if (input.abortSignal.aborted) return;
+					startPrompt(prepared);
+					await settlePrompt();
+				}
+				succeeded = true;
+				return;
+			}
+			const prepared = await prepare(outcome.text);
+			if (input.abortSignal.aborted) break;
+			if (session.isStreaming) await session.steer(prepared);
+			else {
+				await settlePrompt();
+				if (input.abortSignal.aborted) break;
+				startPrompt(prepared);
+			}
+			next = take();
+		}
+	} finally {
+		input.abortSignal.removeEventListener("abort", onAbort);
+		await close();
+		stop.abort();
+		await next;
+		const cancelledOrFailed = !succeeded || input.abortSignal.aborted;
+		if (cancelledOrFailed) await options.abort();
+		await prompt;
+		if (cancelledOrFailed) session.clearQueue();
+	}
+}
+//#endregion
+//#region src/adapters/pi/execution/pi-agent-loop.ts
+function createPiAgentLoop$1(options) {
+	return {
+		...options.supportsSteering ? { supportsSteering: true } : {},
+		run: (input) => {
+			const stream = Stream.fromAsyncIterable(runPiSession(input, options), (error) => error);
+			if (!options.runBoundary) return stream;
+			return Stream.unwrapScoped(Effect.acquireRelease(options.runBoundary.acquireRun({ signal: input.abortSignal }), (lease) => Effect.sync(lease.release)).pipe(Effect.as(stream)));
+		}
+	};
+}
+function createPiSdkAgentLoop$1(options) {
+	return createPiAgentLoop$1({
+		...options.supportsSteering ? { supportsSteering: true } : {},
+		resolveSession: async () => {
+			const result = await options.createAgentSession(options.sessionOptions);
+			return {
+				dispose: () => result.session.dispose?.(),
+				session: result.session
+			};
+		}
+	});
+}
+async function* runPiSession(input, options) {
+	const queue = createAsyncQueue();
+	let removeAbortListener;
+	let unsubscribe;
+	let dispose;
+	let handleForRun;
+	let activationAttempted = false;
+	let abortCompletion;
+	let failure;
+	let terminalErrorMessage;
+	let done = false;
+	const mappingState = {
+		activeSkillIds: /* @__PURE__ */ new Map(),
+		modelCallCount: 0
+	};
+	const complete = (error) => {
+		failure = error;
+		done = true;
+		queue.wake();
+	};
+	const sessionTask = (async () => {
+		try {
+			const handle = await options.resolveSession(input);
+			handleForRun = handle;
+			dispose = handle.dispose ?? (() => handle.session.dispose?.());
+			activationAttempted = true;
+			await handle.activate?.(input);
+			const abortSession = () => {
+				if (abortCompletion) return abortCompletion;
+				abortCompletion = Promise.resolve(handle.session.abort?.()).then(() => void 0, (error) => {
+					if (!input.abortSignal.aborted) throw error;
+				});
+				return abortCompletion;
+			};
+			const requestAbort = () => {
+				abortSession().then(() => complete(), (error) => complete(error));
+			};
+			input.abortSignal.addEventListener("abort", requestAbort, { once: true });
+			removeAbortListener = () => input.abortSignal.removeEventListener("abort", requestAbort);
+			if (input.abortSignal.aborted) {
+				await abortSession();
+				complete();
+				return;
+			}
+			unsubscribe = handle.session.subscribe((event) => {
+				if (event.type === "message_end") {
+					const message = readAssistantMessage(event.message);
+					if (message) terminalErrorMessage = message.stopReason === "error" ? message.errorMessage ?? "Pi agent failed" : void 0;
+				}
+				const mappedEvents = mapPiEvents(event, input.runId, mappingState, handle.resolveToolName);
+				for (const mapped of mappedEvents) {
+					observeModelContent(options.modelContentObserver, handle.session, event, input.runId, mapped);
+					queue.offer(mapped);
+				}
+			});
+			await runPiSessionPrompts({
+				input,
+				handle,
+				supportsSteering: options.supportsSteering === true,
+				abort: abortSession
+			});
+			complete(input.abortSignal.aborted || terminalErrorMessage === void 0 ? void 0 : new Error(terminalErrorMessage));
+		} catch (error) {
+			complete(input.abortSignal.aborted ? void 0 : error);
+		}
+	})();
+	try {
+		while (!done || queue.hasItems()) {
+			const event = queue.poll();
+			if (event !== void 0) {
+				yield event;
+				continue;
+			}
+			await queue.wait();
+		}
+		if (failure !== void 0) throw failure;
+	} finally {
+		removeAbortListener?.();
+		unsubscribe?.();
+		await Promise.all([sessionTask, ...abortCompletion ? [abortCompletion] : []]);
+		try {
+			if (activationAttempted) await handleForRun?.deactivate?.();
+		} finally {
+			if (options.disposeSessionAfterRun !== false) await dispose?.();
+		}
+	}
+}
+function observeModelContent(observer, session, event, runId, mapped) {
+	if (!observer) return;
+	if (mapped.type === "model_execution_start") {
+		const modelInput = snapshotModelInput(session.state);
+		if (modelInput !== void 0) observer.observeInput({
+			input: modelInput,
+			modelCallId: mapped.modelCallId,
+			runId
+		});
+		return;
+	}
+	if (mapped.type !== "model_execution_end" || event.type !== "message_end") return;
+	const output = snapshotAssistantOutput(event.message);
+	if (output !== void 0) observer.observeOutput({
+		modelCallId: mapped.modelCallId,
+		output,
+		runId
+	});
+}
+function snapshotModelInput(value) {
+	if (!isRecord$4(value)) return void 0;
+	const messages = Array.isArray(value.messages) ? value.messages.map(snapshotMessage).filter(isDefined) : void 0;
+	const systemPrompt = typeof value.systemPrompt === "string" ? value.systemPrompt : void 0;
+	const tools = Array.isArray(value.tools) ? value.tools.map(snapshotTool).filter(isDefined) : void 0;
+	if (!messages && systemPrompt === void 0 && !tools) return void 0;
+	return {
+		...messages ? { messages } : {},
+		...systemPrompt === void 0 ? {} : { systemPrompt },
+		...tools ? { tools } : {}
+	};
+}
+function snapshotAssistantOutput(value) {
+	if (!isRecord$4(value) || value.role !== "assistant") return void 0;
+	return snapshotMessage(value);
+}
+function snapshotMessage(value) {
+	if (!isRecord$4(value) || typeof value.role !== "string") return void 0;
+	const content = sanitizeContent(value.content);
+	return {
+		...content === void 0 ? {} : { content },
+		role: value.role,
+		...typeof value.toolCallId === "string" ? { toolCallId: value.toolCallId } : {},
+		...typeof value.toolName === "string" ? { toolName: value.toolName } : {}
+	};
+}
+function snapshotTool(value) {
+	if (!isRecord$4(value) || typeof value.name !== "string") return void 0;
+	return {
+		...typeof value.description === "string" ? { description: value.description } : {},
+		name: value.name,
+		...value.parameters === void 0 ? {} : { parameters: sanitizeSerializable(value.parameters) }
+	};
+}
+function sanitizeContent(value) {
+	if (!Array.isArray(value)) return sanitizeSerializable(value);
+	return value.filter((item) => !isPrivateThinkingBlock(item)).map(sanitizeSerializable).filter(isDefined);
+}
+function sanitizeSerializable(value) {
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (Array.isArray(value)) return value.map(sanitizeSerializable).filter(isDefined);
+	if (!isRecord$4(value)) return void 0;
+	return Object.fromEntries(Object.entries(value).filter(([, nested]) => typeof nested !== "function" && nested !== void 0).map(([key, nested]) => [key, sanitizeSerializable(nested)]).filter((entry) => entry[1] !== void 0));
+}
+function isPrivateThinkingBlock(value) {
+	return isRecord$4(value) && (value.type === "thinking" || value.type === "redacted_thinking");
+}
+function isDefined(value) {
+	return value !== void 0;
+}
+function mapPiEvents(event, runId, state, resolveToolName) {
+	if (event.type === "tool_execution_start") {
+		const toolEvent = event;
+		if (toolEvent.toolName === "rivus_read_skill") {
+			const skillId = readSkillId(getToolExecutionInput(toolEvent));
+			if (!skillId) return [];
+			state.activeSkillIds.set(toolEvent.toolCallId, skillId);
+			return [createAgentLoopSkillExecutionStart({
+				skillCallId: toolEvent.toolCallId,
+				skillId
+			})];
+		}
+	}
+	if (event.type === "tool_execution_update") {
+		if (event.toolName === "rivus_read_skill") return [];
+	}
+	if (event.type === "tool_execution_end") {
+		const toolEvent = event;
+		if (toolEvent.toolName === "rivus_read_skill") {
+			const details = readSkillDetails(toolEvent.result);
+			const skillId = details?.skillId ?? state.activeSkillIds.get(toolEvent.toolCallId);
+			state.activeSkillIds.delete(toolEvent.toolCallId);
+			if (!skillId) return [];
+			if (toolEvent.isError) return [createAgentLoopSkillExecutionEnd({
+				isError: true,
+				skillCallId: toolEvent.toolCallId,
+				skillId
+			})];
+			if (!details) throw new Error(`Skill reader completed without valid metadata: ${skillId}`);
+			return [createAgentLoopSkillExecutionEnd({
+				contentLength: details.contentLength,
+				digest: details.digest,
+				isError: false,
+				skillCallId: toolEvent.toolCallId,
+				skillId,
+				title: details.title,
+				version: details.version
+			})];
+		}
+	}
+	const mapped = mapPiEvent(event, runId, state, resolveToolName);
+	return mapped ? [mapped] : [];
+}
+function mapPiEvent(event, runId, state, resolveToolName) {
+	switch (event.type) {
+		case "message_start": {
+			const message = readAssistantMessage(event.message);
+			if (!message) return void 0;
+			state.modelCallCount += 1;
+			state.activeModelCallId = `${runId}:model:${state.modelCallCount}`;
+			return createAgentLoopModelExecutionStart({
+				api: message.api,
+				model: message.model,
+				modelCallId: state.activeModelCallId,
+				provider: message.provider
+			});
+		}
+		case "message_update":
+			const assistantEvent = event.assistantMessageEvent;
+			if (typeof assistantEvent.delta !== "string") return;
+			if (assistantEvent.type === "thinking_delta") return createAgentLoopThinkingDelta(assistantEvent.delta);
+			if (assistantEvent.type !== "text_delta") return;
+			return createAgentLoopTextDelta(assistantEvent.delta);
+		case "message_end": {
+			const message = readAssistantMessage(event.message);
+			if (!message) return void 0;
+			if (!state.activeModelCallId) {
+				state.modelCallCount += 1;
+				state.activeModelCallId = `${runId}:model:${state.modelCallCount}`;
+			}
+			const modelCallId = state.activeModelCallId;
+			delete state.activeModelCallId;
+			return createAgentLoopModelExecutionEnd({
+				api: message.api,
+				...message.errorMessage ? { errorMessage: message.errorMessage } : {},
+				model: message.model,
+				modelCallId,
+				provider: message.provider,
+				...message.responseModel ? { responseModel: message.responseModel } : {},
+				stopReason: message.stopReason,
+				usage: {
+					cacheRead: message.usage.cacheRead,
+					cacheWrite: message.usage.cacheWrite,
+					cost: message.usage.cost.total,
+					input: message.usage.input,
+					output: message.usage.output,
+					...message.usage.reasoning === void 0 ? {} : { reasoning: message.usage.reasoning },
+					total: message.usage.totalTokens
+				}
+			});
+		}
+		case "tool_execution_start": {
+			const toolEvent = event;
+			return createAgentLoopToolExecutionStart({
+				input: getToolExecutionInput(toolEvent),
+				toolCallId: toolEvent.toolCallId,
+				toolName: resolveToolName?.(toolEvent.toolName) ?? toolEvent.toolName
+			});
+		}
+		case "tool_execution_update": {
+			const toolEvent = event;
+			return createAgentLoopToolExecutionUpdate({
+				input: getToolExecutionInput(toolEvent),
+				partialResult: toolEvent.partialResult,
+				toolCallId: toolEvent.toolCallId,
+				toolName: resolveToolName?.(toolEvent.toolName) ?? toolEvent.toolName
+			});
+		}
+		case "tool_execution_end": {
+			const toolEvent = event;
+			return createAgentLoopToolExecutionEnd({
+				isError: toolEvent.isError,
+				result: toolEvent.result,
+				toolCallId: toolEvent.toolCallId,
+				toolName: resolveToolName?.(toolEvent.toolName) ?? toolEvent.toolName
+			});
+		}
+		default: return;
+	}
+}
+function readAssistantMessage(value) {
+	if (!isRecord$4(value) || value.role !== "assistant" || !isRecord$4(value.usage) || !isRecord$4(value.usage.cost)) return;
+	if (typeof value.api !== "string" || typeof value.model !== "string" || typeof value.provider !== "string" || typeof value.stopReason !== "string" || typeof value.usage.cacheRead !== "number" || typeof value.usage.cacheWrite !== "number" || typeof value.usage.cost.total !== "number" || typeof value.usage.input !== "number" || typeof value.usage.output !== "number" || typeof value.usage.totalTokens !== "number") return;
+	return value;
+}
+function isRecord$4(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getToolExecutionInput(event) {
+	return Object.hasOwn(event, "args") ? event.args : event.input;
+}
+function readSkillId(value) {
+	return isRecord$4(value) && typeof value.skillId === "string" ? value.skillId : void 0;
+}
+function readSkillDetails(value) {
+	if (!isRecord$4(value) || !isRecord$4(value.details)) return void 0;
+	const details = value.details;
+	if (typeof details.contentLength !== "number" || typeof details.digest !== "string" || typeof details.skillId !== "string" || typeof details.title !== "string" || typeof details.version !== "string") return;
+	return details;
+}
+function createAsyncQueue() {
+	const items = [];
+	let resume;
+	return {
+		hasItems: () => items.length > 0,
+		offer: (item) => {
+			items.push(item);
+			resume?.();
+			resume = void 0;
+		},
+		poll: () => items.shift(),
+		wait: () => new Promise((resolve) => {
+			resume = resolve;
+		}),
+		wake: () => {
+			resume?.();
+			resume = void 0;
+		}
+	};
+}
+//#endregion
+//#region src/adapters/pi/execution/pi-session-registry.ts
+function createPiSessionRegistry$1(options) {
+	const sessions = /* @__PURE__ */ new Map();
+	const resolve = async (input) => {
+		const cached = sessions.get(input.sessionKey);
+		if (cached) return cached;
+		const created = Promise.resolve(options.createSession(input)).catch((error) => {
+			sessions.delete(input.sessionKey);
+			throw error;
+		});
+		sessions.set(input.sessionKey, created);
+		return created;
+	};
+	const dispose = async (sessionKey) => {
+		const session = sessions.get(sessionKey);
+		sessions.delete(sessionKey);
+		if (!session) return;
+		await (await session).dispose?.();
+	};
+	return {
+		dispose,
+		disposeAll: async () => {
+			await Promise.all([...sessions.keys()].map(dispose));
+		},
+		list: async () => Promise.all(sessions.values()),
+		resolve,
+		size: () => sessions.size
+	};
+}
+//#endregion
+//#region src/adapters/pi/model-management/pi-model-call-deadline.ts
+var PiModelCallDeadlineExceeded = class extends Error {
+	name = "PiModelCallDeadlineExceeded";
+};
+/** Race a provider or SDK promise against the Run deadline without retaining a late result. */
+async function awaitPiModelCall(promise, options = {}) {
+	const completion = Promise.resolve(promise);
+	const signal = options.signal;
+	if (!signal) return completion;
+	let settled = false;
+	const observed = completion.then((value) => {
+		settled = true;
+		return value;
+	}, (error) => {
+		settled = true;
+		throw error;
+	});
+	let removeAbortListener;
+	const aborted = new Promise((_resolve, reject) => {
+		const handleAbort = () => {
+			if (settled) return;
+			options.onAbort?.();
+			reject(options.isDeadlineExceeded?.() ? new PiModelCallDeadlineExceeded(options.deadlineMessage ?? "Pi model call deadline elapsed") : signal.reason instanceof Error ? signal.reason : new Error(options.abortMessage ?? "Pi model call aborted"));
+		};
+		if (options.isDeadlineExceeded?.() || signal.aborted) handleAbort();
+		else {
+			signal.addEventListener("abort", handleAbort, { once: true });
+			removeAbortListener = () => signal.removeEventListener("abort", handleAbort);
+		}
+	});
+	try {
+		const value = await Promise.race([observed, aborted]);
+		if (options.isDeadlineExceeded?.()) throw new PiModelCallDeadlineExceeded(options.deadlineMessage ?? "Pi model call deadline elapsed");
+		return value;
+	} finally {
+		removeAbortListener?.();
+		if (!settled) observed.catch(() => void 0);
+	}
+}
+//#endregion
+//#region src/adapters/pi/model-management/pi-model-probe.ts
+const PI_MODEL_PROBE_TOOL_NAME = "rivus_model_management_probe";
+const PI_MODEL_PROBE_TOOL_RESULT = "RIVUS_MODEL_PROBE_TOOL_OK";
+const PI_MODEL_PROBE_FOLLOWUP_RESULT = "RIVUS_MODEL_PROBE_FOLLOWUP_OK";
+const probeToolParameters = Type.Object({ probe: Type.String() });
+var PiModelProbeError = class extends Error {
+	name = "PiModelProbeError";
+	code;
+	outcome;
+	constructor(message, outcome, options, code = "model_change_probe_failed") {
+		super(message, options);
+		this.code = code;
+		this.outcome = outcome;
+	}
+};
+/**
+* Exercise a candidate through the same Pi model runtime used by business runs.
+* The probe builds an in-memory synthetic context, performs an actual streamed
+* tool call, feeds the real fixed tool result into a second streamed request, and
+* then sends a separate follow-up request. It never loads a persisted transcript
+* or exposes business tools.
+*/
+function probePiModel(options) {
+	return Effect.gen(function* () {
+		const context = {
+			messages: [{
+				content: "This is an isolated compatibility probe. Call the fixed probe Tool exactly once, then repeat the exact Tool result in your response.",
+				role: "user",
+				timestamp: Date.now()
+			}],
+			systemPrompt: "You are running an isolated model compatibility probe. You must call the rivus_model_management_probe Tool exactly once with a short probe value. After receiving its result, repeat its exact result text in your response. Do not call any other Tool.",
+			tools: [{
+				description: "A fixed no-side-effect probe Tool used only for model compatibility checks.",
+				name: PI_MODEL_PROBE_TOOL_NAME,
+				parameters: probeToolParameters
+			}]
+		};
+		const transcript = [];
+		const initial = yield* streamProbeTurn(options, context, "initial");
+		transcript.push(initial.turn);
+		const toolCall = findSingleProbeToolCall(initial.message);
+		if (!toolCall) return yield* Effect.fail(new PiModelProbeError("candidate did not request the fixed probe Tool in its first streamed response", "known"));
+		if (typeof toolCall.arguments.probe !== "string" || toolCall.arguments.probe.length === 0) return yield* Effect.fail(new PiModelProbeError("candidate supplied invalid arguments to the fixed probe Tool", "known"));
+		const toolResult = {
+			content: [{
+				text: `${PI_MODEL_PROBE_TOOL_RESULT}:${randomUUID()}`,
+				type: "text"
+			}],
+			details: { probe: true },
+			isError: false,
+			role: "toolResult",
+			timestamp: Date.now(),
+			toolCallId: toolCall.id,
+			toolName: PI_MODEL_PROBE_TOOL_NAME
+		};
+		context.messages.push(initial.message, toolResult);
+		const toolResultText = toolResult.content[0].text;
+		const afterTool = yield* streamProbeTurn(options, context, "tool-result");
+		transcript.push({
+			...afterTool.turn,
+			toolResult: {
+				content: toolResultText,
+				toolCallId: toolCall.id,
+				toolName: PI_MODEL_PROBE_TOOL_NAME
+			}
+		});
+		if (!readText(afterTool.message).includes(toolResultText)) return yield* Effect.fail(new PiModelProbeError("candidate did not consume the fixed probe Tool result in its next streamed response", "known"));
+		if (findToolCalls(afterTool.message).length > 0) return yield* Effect.fail(new PiModelProbeError("candidate requested an additional Tool during the probe", "known"));
+		context.messages.push(afterTool.message, {
+			content: "Follow up after the Tool roundtrip. Reply with RIVUS_MODEL_PROBE_FOLLOWUP_OK.",
+			role: "user",
+			timestamp: Date.now()
+		});
+		const followup = yield* streamProbeTurn(options, context, "follow-up");
+		transcript.push(followup.turn);
+		if (findToolCalls(followup.message).length > 0) return yield* Effect.fail(new PiModelProbeError("candidate requested a Tool during the probe follow-up", "known"));
+		const followupText = readText(followup.message);
+		if (!followupText.includes("RIVUS_MODEL_PROBE_FOLLOWUP_OK")) return yield* Effect.fail(new PiModelProbeError("candidate did not produce the fixed probe follow-up response", "known"));
+		const assistantThinkingBlocks = transcript.reduce((count, turn) => count + turn.assistant.content.filter((content) => isRecord$3(content) && content.type === "thinking").length, 0);
+		const outputTokens = transcript.reduce((sum, turn) => sum + readOutputTokens(turn.assistant.usage), 0);
+		return Object.freeze({
+			assistantThinkingBlocks,
+			followupText,
+			model: Object.freeze({
+				id: options.model.id,
+				provider: options.model.provider
+			}),
+			outputTokens,
+			passed: true,
+			thinkingLevel: options.thinkingLevel,
+			toolResultText,
+			toolCallId: toolCall.id,
+			toolName: PI_MODEL_PROBE_TOOL_NAME,
+			transcript: Object.freeze(transcript)
+		});
+	});
+}
+function streamProbeTurn(options, context, kind) {
+	return streamPaidProbeCall({
+		budget: options.budget,
+		context,
+		description: `Pi model probe ${kind}`,
+		kind: "validation",
+		model: options.model,
+		modelRuntime: options.modelRuntime,
+		...options.signal ? { signal: options.signal } : {},
+		thinkingLevel: options.thinkingLevel,
+		validate: (message) => assertProbeStopReason(message, kind)
+	}).pipe(Effect.map(({ message, reservation }) => ({
+		message,
+		turn: {
+			assistant: snapshotAssistant(message),
+			kind,
+			reservationId: reservation.id
+		}
+	})));
+}
+/** Run one bounded, synthetic request for activation/recovery canaries. */
+function runPiModelCanary(options) {
+	return streamPaidProbeCall({
+		budget: options.budget,
+		context: {
+			messages: [{
+				content: "Reply with the exact text RIVUS_MODEL_CANARY_OK.",
+				role: "user",
+				timestamp: Date.now()
+			}],
+			systemPrompt: "This is an isolated model canary. Reply with RIVUS_MODEL_CANARY_OK and do not call tools."
+		},
+		description: `Pi model ${options.kind} canary`,
+		kind: options.kind,
+		model: options.model,
+		modelRuntime: options.modelRuntime,
+		...options.signal ? { signal: options.signal } : {},
+		thinkingLevel: options.thinkingLevel,
+		validate: (message) => {
+			assertCanaryStopReason(message);
+			if (!readText(message).includes("RIVUS_MODEL_CANARY_OK")) throw new PiModelProbeError("model canary did not produce the fixed response", "known");
+		}
+	}).pipe(Effect.map(({ message, outputTokens }) => Object.freeze({
+		assistant: snapshotAssistant(message),
+		outputTokens
+	})));
+}
+function streamPaidProbeCall(options) {
+	return Effect.gen(function* () {
+		const reservation = yield* options.budget.reservePaidCall({ kind: options.kind });
+		const callSignal = yield* Effect.sync(() => createPaidCallSignal(options.signal, options.budget.deadlineAt));
+		let settled = false;
+		const settle = (input) => options.budget.settlePaidCall({
+			...input,
+			reservation
+		}).pipe(Effect.tap(() => Effect.sync(() => {
+			settled = true;
+		})));
+		return yield* Effect.gen(function* () {
+			if (callSignal.expired) {
+				yield* settle({
+					outcome: "known",
+					outputTokens: 0
+				});
+				return yield* Effect.fail(new PiModelProbeError("model change deadline elapsed before the provider request", "known", void 0, "model_change_deadline_exceeded"));
+			}
+			const message = yield* Effect.tryPromise({
+				try: async () => {
+					const stream = options.modelRuntime.streamSimple(options.model, options.context, {
+						signal: callSignal.signal,
+						maxTokens: reservation.maxOutputTokens,
+						maxRetries: 0,
+						maxRetryDelayMs: 0,
+						...options.thinkingLevel === "off" ? {} : { reasoning: options.thinkingLevel }
+					});
+					return await awaitPiModelCall((async () => {
+						for await (const _event of stream) callSignal.signal.throwIfAborted();
+						callSignal.signal.throwIfAborted();
+						return await stream.result();
+					})(), {
+						abortMessage: "model probe aborted",
+						deadlineMessage: "model change deadline elapsed during provider streaming",
+						isDeadlineExceeded: callSignal.isDeadlineExceeded,
+						signal: callSignal.signal
+					});
+				},
+				catch: (error) => error
+			}).pipe(Effect.catchAll((error) => {
+				const deadlineExceeded = callSignal.isDeadlineExceeded() || error instanceof PiModelCallDeadlineExceeded;
+				const probeError = new PiModelProbeError(deadlineExceeded ? `${options.description} stream exceeded the model change deadline` : `${options.description} stream failed: ${error instanceof Error ? error.message : String(error)}`, "unknown", { cause: error }, deadlineExceeded ? "model_change_deadline_exceeded" : "model_change_probe_failed");
+				return settle({
+					outcome: "unknown",
+					outputTokens: reservation.maxOutputTokens
+				}).pipe(Effect.zipRight(Effect.fail(probeError)));
+			}));
+			const outputTokens = readOutputTokens(message.usage);
+			yield* settle({
+				outcome: "known",
+				outputTokens
+			});
+			yield* Effect.try({
+				try: () => options.validate(message),
+				catch: (error) => error
+			});
+			return {
+				message,
+				outputTokens,
+				reservation
+			};
+		}).pipe(Effect.ensuring(Effect.uninterruptible(Effect.suspend(() => settled ? Effect.void : settle({
+			outcome: "unknown",
+			outputTokens: reservation.maxOutputTokens
+		})).pipe(Effect.orDie))), Effect.ensuring(Effect.sync(callSignal.dispose)));
+	});
+}
+function createPaidCallSignal(parent, deadlineAt) {
+	const controller = new AbortController();
+	const deadlineMs = Date.parse(deadlineAt);
+	const remainingMs = deadlineMs - Date.now();
+	let deadlineExceeded = !Number.isFinite(deadlineMs) || remainingMs <= 0;
+	let timer;
+	const onParentAbort = () => controller.abort(parent?.reason);
+	if (parent) if (parent.aborted) controller.abort(parent.reason);
+	else parent.addEventListener("abort", onParentAbort, { once: true });
+	if (remainingMs > 0 && !controller.signal.aborted) timer = setTimeout(() => {
+		deadlineExceeded = true;
+		controller.abort(/* @__PURE__ */ new Error("model change deadline elapsed"));
+	}, Math.min(remainingMs, 2147483647));
+	return {
+		expired: deadlineExceeded,
+		isDeadlineExceeded: () => deadlineExceeded || Number.isFinite(deadlineMs) && Date.now() >= deadlineMs,
+		signal: controller.signal,
+		dispose: () => {
+			if (timer) clearTimeout(timer);
+			parent?.removeEventListener("abort", onParentAbort);
+			if (!controller.signal.aborted) controller.abort(/* @__PURE__ */ new Error("model probe cancelled"));
+		}
+	};
+}
+function assertProbeStopReason(message, kind) {
+	if (message.stopReason === "error" || message.stopReason === "aborted") throw new PiModelProbeError(`candidate streamed an ${message.stopReason} response: ${message.errorMessage ?? "unknown provider error"}`, "known");
+	if (message.stopReason === "length" || message.stopReason === "deferred") throw new PiModelProbeError(`candidate response was truncated or deferred during ${kind}`, "known");
+	if (kind !== "initial" && message.stopReason !== "stop") throw new PiModelProbeError(`candidate used unsupported stop reason ${message.stopReason} during ${kind}`, "known");
+}
+function assertCanaryStopReason(message) {
+	if (message.stopReason === "error" || message.stopReason === "aborted") throw new PiModelProbeError(`model canary streamed an ${message.stopReason} response: ${message.errorMessage ?? "unknown provider error"}`, "known");
+	if (message.stopReason === "length" || message.stopReason === "deferred" || message.stopReason !== "stop") throw new PiModelProbeError(`model canary used unsupported stop reason ${message.stopReason}`, "known");
+}
+function findSingleProbeToolCall(message) {
+	const calls = findToolCalls(message);
+	if (calls.length !== 1 || calls[0]?.name !== "rivus_model_management_probe") return void 0;
+	const call = calls[0];
+	return {
+		arguments: call.arguments,
+		id: call.id
+	};
+}
+function findToolCalls(message) {
+	return message.content.flatMap((content) => {
+		if (!isRecord$3(content) || content.type !== "toolCall") return [];
+		return [{
+			arguments: isRecord$3(content.arguments) ? content.arguments : {},
+			id: typeof content.id === "string" ? content.id : "",
+			name: typeof content.name === "string" ? content.name : ""
+		}];
+	});
+}
+function readText(message) {
+	return message.content.filter((content) => isRecord$3(content) && content.type === "text" && typeof content.text === "string").map((content) => content.text).join("");
+}
+function snapshotAssistant(message) {
+	return Object.freeze({
+		content: Object.freeze(message.content.map((content) => cloneSerializable(content))),
+		model: message.model,
+		provider: message.provider,
+		stopReason: message.stopReason,
+		usage: Object.freeze(cloneSerializable(message.usage))
+	});
+}
+function readOutputTokens(usage) {
+	if (isRecord$3(usage) && typeof usage.output === "number" && Number.isSafeInteger(usage.output) && usage.output >= 0) return usage.output;
+	return 0;
+}
+function cloneSerializable(value) {
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (Array.isArray(value)) return value.map(cloneSerializable);
+	if (!isRecord$3(value)) return void 0;
+	return Object.fromEntries(Object.entries(value).filter(([, nested]) => typeof nested !== "function" && nested !== void 0).map(([key, nested]) => [key, cloneSerializable(nested)]));
+}
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/adapters/pi/model-management/pi-model-resolution.ts
+var PiModelResolutionError = class extends Error {
+	name = "PiModelResolutionError";
+	code;
+	resolutionCode;
+	constructor(resolutionCode, message) {
+		super(message);
+		this.code = resolutionCode === "provider-unknown" ? "model_change_provider_unsupported" : "model_change_target_unsupported";
+		this.resolutionCode = resolutionCode;
+	}
+};
+/**
+* Resolve one exact provider/model pair from the installed Pi model runtime.
+*
+* Model aliases and fuzzy matches are intentionally excluded here. Natural-language
+* interpretation belongs to the application/Agent; the activation boundary must bind
+* to the exact model that the SDK can actually construct.
+*/
+function resolvePiModel(options) {
+	const provider = options.target.provider.trim();
+	const modelId = options.target.model.trim();
+	if (!provider || !modelId || provider.includes("/") || modelId.includes("\n")) throw new PiModelResolutionError("invalid-reference", "Pi model target must contain a provider and model id without a provider separator in either component");
+	if (options.modelRuntime.getModels(provider).length === 0) {
+		if (!options.modelRuntime.getProvider(provider)) throw new PiModelResolutionError("provider-unknown", `Pi provider is not installed: ${provider}`);
+		throw new PiModelResolutionError("model-unknown", `Pi provider ${provider} has no known model metadata; configure a declarative model before activation`);
+	}
+	const model = options.modelRuntime.getModel(provider, modelId);
+	if (!model) throw new PiModelResolutionError("model-unknown", `Pi model ${provider}/${modelId} is not present in the installed model catalog`);
+	return model;
+}
+/**
+* Ensure metadata for an exact model id that is absent from the installed SDK
+* catalog, then recompose the provider from models.json. Phase 1 only ships the
+* verified DeepSeek declaration required by the management contract; all other
+* unknown ids fail closed and must be supplied by a future explicit catalog path.
+*/
+async function ensurePiModel(options) {
+	try {
+		return resolvePiModel(options);
+	} catch (error) {
+		if (!(error instanceof PiModelResolutionError) || error.resolutionCode !== "model-unknown") throw error;
+	}
+	const definition = knownPiDeclarativeModel(options.modelRuntime, options.target);
+	if (!definition) throw new PiModelResolutionError("model-unknown", `Pi model ${options.target.provider}/${options.target.model} is not present in the installed model catalog and has no approved declarative metadata`);
+	await mergePiProviderModelDeclaration({
+		filePath: options.modelsPath,
+		model: definition,
+		provider: options.target.provider
+	});
+	const refreshError = (await refreshPiModelCatalog(options.modelRuntime, {
+		allowNetwork: false,
+		provider: options.target.provider,
+		...options.signal ? { signal: options.signal } : {}
+	})).errors.get(options.target.provider);
+	if (refreshError) throw new PiModelResolutionError("model-unknown", `Pi provider ${options.target.provider} could not load declarative model metadata: ${refreshError.message}`);
+	return resolvePiModel(options);
+}
+function resolvePiModelBinding(options) {
+	const model = resolvePiModel(options);
+	return Object.freeze({
+		binding: Object.freeze({
+			bindingRevision: options.bindingRevision,
+			model: model.id,
+			provider: model.provider
+		}),
+		model
+	});
+}
+/** Refresh installed SDK metadata, retaining the SDK's persisted declarative catalog. */
+async function refreshPiModelCatalog(modelRuntime, options = {}) {
+	const providers = options.provider === void 0 ? void 0 : [options.provider];
+	const result = await modelRuntime.refresh({
+		allowNetwork: options.allowNetwork ?? false,
+		...providers ? { providers } : {},
+		...options.signal ? { signal: options.signal } : {}
+	});
+	const refreshedProviders = providers ?? modelRuntime.getRegisteredProviderIds();
+	return Object.freeze({
+		errors: result.errors,
+		refreshedProviders: Object.freeze([...refreshedProviders])
+	});
+}
+function samePiProvider(left, right) {
+	return left.provider.trim() === right.provider.trim();
+}
+function knownPiDeclarativeModel(modelRuntime, target) {
+	if (target.provider !== "deepseek" || target.model !== "deepseek-flash") return void 0;
+	const source = modelRuntime.getModel("deepseek", "deepseek-v4-flash");
+	if (!source) return void 0;
+	return {
+		api: source.api,
+		baseUrl: source.baseUrl,
+		...source.compat ? { compat: source.compat } : {},
+		contextWindow: 1e6,
+		cost: {
+			cacheRead: .006,
+			cacheWrite: 0,
+			input: .3,
+			output: 1.2
+		},
+		id: target.model,
+		input: ["text", "image"],
+		maxTokens: 384e3,
+		name: "DeepSeek V4.1 Flash",
+		reasoning: true,
+		...source.samplingParams ? { samplingParams: source.samplingParams } : {},
+		...source.thinkingLevelMap ? { thinkingLevelMap: source.thinkingLevelMap } : {}
+	};
+}
+//#endregion
+//#region src/adapters/pi/model-management/pi-history-compatibility.ts
+var PiHistoryCompatibilityError = class extends Error {
+	name = "PiHistoryCompatibilityError";
+	code = "model_change_history_incompatible";
+	messageIndex;
+	constructor(message, messageIndex) {
+		super(message);
+		this.messageIndex = messageIndex;
+	}
+};
+/**
+* Check the structural parts of a persisted Pi transcript that providers need for
+* the next request. The transcript is never returned or copied; only counts are
+* exposed for diagnostics. This deliberately rejects orphaned tool calls/results
+* instead of deleting or rewriting history during a model change.
+*/
+function inspectPiSessionHistory(sessionManager) {
+	const context = sessionManager.buildSessionContext();
+	const pendingToolCalls = /* @__PURE__ */ new Map();
+	let assistantThinkingBlocks = 0;
+	let assistantToolCalls = 0;
+	let imageBlocks = 0;
+	let toolResults = 0;
+	for (const [messageIndex, message] of context.messages.entries()) {
+		if (!isRecord$2(message) || typeof message.role !== "string") throw new PiHistoryCompatibilityError("Pi session history contains a malformed message", messageIndex);
+		if (message.role === "assistant") {
+			const content = message.content;
+			if (!Array.isArray(content)) throw new PiHistoryCompatibilityError("Pi assistant history message content must be an array", messageIndex);
+			for (const block of content) {
+				if (!isRecord$2(block) || typeof block.type !== "string") throw new PiHistoryCompatibilityError("Pi assistant history contains a malformed content block", messageIndex);
+				if (block.type === "thinking") {
+					if (typeof block.thinking !== "string") throw new PiHistoryCompatibilityError("Pi assistant thinking content is malformed", messageIndex);
+					assistantThinkingBlocks += 1;
+					continue;
+				}
+				if (block.type === "toolCall") {
+					if (typeof block.id !== "string" || !block.id || typeof block.name !== "string" || !block.name) throw new PiHistoryCompatibilityError("Pi assistant tool call is malformed", messageIndex);
+					if (!isRecord$2(block.arguments)) throw new PiHistoryCompatibilityError("Pi assistant tool call arguments are malformed", messageIndex);
+					pendingToolCalls.set(block.id, block.name);
+					assistantToolCalls += 1;
+					continue;
+				}
+				if (block.type === "text") {
+					if (typeof block.text !== "string") throw new PiHistoryCompatibilityError("Pi assistant text content is malformed", messageIndex);
+					continue;
+				}
+				if (block.type === "image") {
+					if (typeof block.data !== "string" || typeof block.mimeType !== "string") throw new PiHistoryCompatibilityError("Pi assistant image content is malformed", messageIndex);
+					imageBlocks += 1;
+					continue;
+				}
+				throw new PiHistoryCompatibilityError(`Pi assistant content type is unsupported: ${String(block.type)}`, messageIndex);
+			}
+			continue;
+		}
+		if (message.role === "toolResult") {
+			const content = message.content;
+			if (!Array.isArray(content)) throw new PiHistoryCompatibilityError("Pi tool result content must be an array", messageIndex);
+			if (typeof message.toolCallId !== "string" || !pendingToolCalls.has(message.toolCallId)) throw new PiHistoryCompatibilityError("Pi tool result has no preceding assistant tool call", messageIndex);
+			if (typeof message.toolName !== "string" || !message.toolName) throw new PiHistoryCompatibilityError("Pi tool result is missing its tool name", messageIndex);
+			if (pendingToolCalls.get(message.toolCallId) !== message.toolName) throw new PiHistoryCompatibilityError("Pi tool result tool name does not match its assistant tool call", messageIndex);
+			imageBlocks += countImageBlocks(content);
+			validatePlainContent(content, messageIndex, "tool result");
+			pendingToolCalls.delete(message.toolCallId);
+			toolResults += 1;
+			continue;
+		}
+		if (message.role === "user") {
+			if (typeof message.content !== "string") {
+				if (!Array.isArray(message.content)) throw new PiHistoryCompatibilityError("Pi user history content must be text or an array", messageIndex);
+				imageBlocks += countImageBlocks(message.content);
+				validatePlainContent(message.content, messageIndex, "user");
+			}
+			continue;
+		}
+		if (message.role === "custom") {
+			if (typeof message.customType !== "string" || typeof message.display !== "boolean") throw new PiHistoryCompatibilityError("Pi custom history message metadata is malformed", messageIndex);
+			if (typeof message.content === "string") continue;
+			if (!Array.isArray(message.content)) throw new PiHistoryCompatibilityError("Pi custom history content must be text or an array", messageIndex);
+			imageBlocks += countImageBlocks(message.content);
+			validatePlainContent(message.content, messageIndex, "custom");
+			continue;
+		}
+		if (message.role === "bashExecution") {
+			if (typeof message.command !== "string" || typeof message.output !== "string" || typeof message.cancelled !== "boolean" || typeof message.truncated !== "boolean" || message.exitCode !== void 0 && message.exitCode !== null && typeof message.exitCode !== "number" || message.fullOutputPath !== void 0 && typeof message.fullOutputPath !== "string" || message.excludeFromContext !== void 0 && typeof message.excludeFromContext !== "boolean") throw new PiHistoryCompatibilityError("Pi bash history message is malformed", messageIndex);
+			continue;
+		}
+		if (message.role === "branchSummary") {
+			if (typeof message.summary !== "string" || typeof message.fromId !== "string") throw new PiHistoryCompatibilityError("Pi branch summary history message is malformed", messageIndex);
+			continue;
+		}
+		if (message.role === "compactionSummary") {
+			if (typeof message.summary !== "string" || typeof message.tokensBefore !== "number" || !Number.isFinite(message.tokensBefore) || message.tokensBefore < 0) throw new PiHistoryCompatibilityError("Pi compaction summary history message is malformed", messageIndex);
+			continue;
+		}
+		throw new PiHistoryCompatibilityError(`Pi history role is unsupported: ${String(message.role)}`, messageIndex);
+	}
+	if (pendingToolCalls.size > 0) throw new PiHistoryCompatibilityError("Pi session history contains an assistant tool call without a result", context.messages.length);
+	return Object.freeze({
+		assistantThinkingBlocks,
+		assistantToolCalls,
+		compatible: true,
+		imageBlocks,
+		messageCount: context.messages.length,
+		toolResults
+	});
+}
+function countImageBlocks(content) {
+	return content.filter((block) => isRecord$2(block) && block.type === "image").length;
+}
+function assertPiSessionHistoryCompatible(sessionManager) {
+	return inspectPiSessionHistory(sessionManager);
+}
+function validatePlainContent(content, messageIndex, role) {
+	for (const block of content) {
+		if (!isRecord$2(block) || typeof block.type !== "string") throw new PiHistoryCompatibilityError(`Pi ${role} history contains a malformed content block`, messageIndex);
+		if (block.type === "text") {
+			if (typeof block.text !== "string") throw new PiHistoryCompatibilityError(`Pi ${role} text content is malformed`, messageIndex);
+			continue;
+		}
+		if (block.type === "image") {
+			if (typeof block.data !== "string" || typeof block.mimeType !== "string") throw new PiHistoryCompatibilityError(`Pi ${role} image content is malformed`, messageIndex);
+			continue;
+		}
+		throw new PiHistoryCompatibilityError(`Pi ${role} content type is unsupported: ${block.type}`, messageIndex);
+	}
+}
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/adapters/pi/model-management/pi-model-runtime.ts
+var PiModelRuntimeMutationUnknownError = class extends Error {
+	name = "PiModelRuntimeMutationUnknownError";
+	outcome = "unknown";
+	constructor(message, options) {
+		super(message, options);
+	}
+};
+var PiModelTargetCompatibilityError = class extends Error {
+	name = "PiModelTargetCompatibilityError";
+	code = "model_change_target_unsupported";
+};
+/**
+* Adapter around Pi's live AgentSession instances.
+*
+* The application owns the safe Run boundary. Once that boundary is held, this
+* adapter waits for every cached session, validates its persisted context, and
+* calls AgentSession.setModel so the session manager and conversation history
+* survive the switch. Disposing cached sessions would silently create a new
+* transcript on the next Run and is therefore intentionally unsupported here.
+*/
+function createPiModelRuntime(options) {
+	const registries = new Set(options.sessionRegistries ?? []);
+	const unsettledMutations = /* @__PURE__ */ new Set();
+	let active = options.initial;
+	let selectionInitializationStarted = options.initial !== void 0;
+	const resolveCandidate = async (context, operation) => {
+		assertOperationActive(operation);
+		const model = options.modelRuntime.getModel(context.target.provider, context.target.model);
+		const resolved = model ? model : options.modelCatalogPath ? await ensurePiModel({
+			modelRuntime: options.modelRuntime,
+			modelsPath: options.modelCatalogPath,
+			target: context.target,
+			...operation?.signal ? { signal: operation.signal } : {}
+		}) : resolvePiModel({
+			modelRuntime: options.modelRuntime,
+			target: context.target
+		});
+		assertOperationActive(operation);
+		return Object.freeze({
+			binding: Object.freeze({
+				bindingRevision: context.bindingRevision,
+				model: resolved.id,
+				provider: resolved.provider
+			}),
+			model: resolved
+		});
+	};
+	const listSessions = async () => {
+		const handles = await Promise.all([...registries].map((registry) => registry.list()));
+		const unique = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const handle of handles.flat()) {
+			if (seen.has(handle)) continue;
+			seen.add(handle);
+			unique.push(handle);
+		}
+		return unique;
+	};
+	const waitForIdleAndCheckHistory = async (model, operation) => {
+		assertOperationActive(operation);
+		const sessions = await listSessions();
+		let abortPromise;
+		const abortSessions = () => {
+			if (abortPromise) return abortPromise;
+			abortPromise = Promise.all(sessions.map((handle) => Promise.resolve().then(() => handle.session.abort?.()))).then(() => void 0);
+			return abortPromise;
+		};
+		const onAbort = () => {
+			abortSessions();
+		};
+		const signal = operation?.signal;
+		if (signal) signal.addEventListener("abort", onAbort, { once: true });
+		try {
+			if (signal?.aborted) abortSessions();
+			await awaitPiModelCall(Promise.all(sessions.map((handle) => Promise.resolve().then(() => handle.session.waitForIdle?.()))), {
+				onAbort: abortSessions,
+				...signal ? { signal } : {}
+			});
+			assertOperationActive(operation);
+			for (const handle of sessions) {
+				assertOperationActive(operation);
+				const manager = handle.session.sessionManager;
+				if (!manager) continue;
+				const context = manager.buildSessionContext();
+				const history = assertPiSessionHistoryCompatible(manager);
+				if (model) {
+					if (history.imageBlocks > 0 && !model.input.includes("image")) throw new PiModelTargetCompatibilityError(`Pi model ${model.provider}/${model.id} does not support ${history.imageBlocks} image history block(s)`);
+					if (hasTextInput(context.messages) && !model.input.includes("text")) throw new PiModelTargetCompatibilityError(`Pi model ${model.provider}/${model.id} does not support text history input`);
+					const estimatedTokens = context.messages.reduce((total, message) => total + estimateTokens(message), 0);
+					if (!Number.isFinite(model.contextWindow) || estimatedTokens > model.contextWindow) throw new PiModelTargetCompatibilityError(`Pi model ${model.provider}/${model.id} context window ${model.contextWindow} is smaller than the estimated ${estimatedTokens}-token session history`);
+				}
+			}
+			assertOperationActive(operation);
+		} finally {
+			if (signal) signal.removeEventListener("abort", onAbort);
+			if (abortPromise) abortPromise.catch(() => void 0);
+		}
+		return sessions;
+	};
+	const setSessionsModel = async (sessions, model, thinkingLevel, operation) => {
+		assertNoUnsettledMutations();
+		for (const handle of sessions) {
+			assertOperationActive(operation);
+			if (!handle.session.setModel) throw new Error("Pi session does not expose live setModel; refusing to discard its history");
+			await awaitModelMutation(Promise.resolve().then(() => {
+				assertOperationActive(operation);
+				return handle.session.setModel(model);
+			}), operation);
+			assertOperationActive(operation);
+			handle.session.setThinkingLevel?.(thinkingLevel);
+			assertOperationActive(operation);
+			await awaitModelMutation(Promise.resolve().then(() => {
+				assertOperationActive(operation);
+				return handle.refreshResources?.();
+			}), operation);
+			assertOperationActive(operation);
+			await awaitModelMutation(Promise.resolve().then(() => {
+				assertOperationActive(operation);
+				return handle.session.reload?.();
+			}), operation);
+			assertOperationActive(operation);
+		}
+	};
+	const trackUnsettledMutation = (promise) => {
+		const tracked = promise.then(() => void 0, () => void 0);
+		unsettledMutations.add(tracked);
+		tracked.then(() => unsettledMutations.delete(tracked), () => unsettledMutations.delete(tracked));
+	};
+	const awaitModelMutation = async (promise, operation) => {
+		let timedOut = false;
+		const completion = Promise.resolve(promise);
+		try {
+			if (!operation?.signal) return completion;
+			return await awaitPiModelCall(completion, {
+				onAbort: () => {
+					timedOut = true;
+					trackUnsettledMutation(completion);
+				},
+				signal: operation.signal
+			});
+		} catch (error) {
+			if (timedOut) throw new PiModelRuntimeMutationUnknownError("Pi model session mutation did not settle before the model change deadline", { cause: error });
+			throw error;
+		}
+	};
+	const assertNoUnsettledMutations = () => {
+		if (unsettledMutations.size > 0) throw new PiModelRuntimeMutationUnknownError("A previous Pi model session mutation is still settling; refusing a concurrent mutation");
+	};
+	const createProbeBudget = (budget) => {
+		const settlements = /* @__PURE__ */ new Map();
+		return {
+			deadlineAt: budget.deadlineAt,
+			reservePaidCall: ({ kind, maxOutputTokens }) => budget.reservePaidCall({
+				kind,
+				...maxOutputTokens === void 0 ? {} : { maxOutputTokens }
+			}).pipe(Effect.tap((result) => Effect.sync(() => settlements.set(result.reservation.id, result.settle))), Effect.map((result) => result.reservation)),
+			settlePaidCall: ({ outcome, outputTokens, reservation }) => Effect.suspend(() => {
+				const settle = settlements.get(reservation.id);
+				if (!settle) return Effect.fail(/* @__PURE__ */ new Error(`Pi probe attempted to settle unknown budget reservation: ${reservation.id}`));
+				return settle({
+					outcome,
+					outputTokens
+				}).pipe(Effect.tap(() => Effect.sync(() => settlements.delete(reservation.id))), Effect.asVoid);
+			})
+		};
+	};
+	const runCanary = (kind, model, budget, operation) => runPiModelCanary({
+		budget: createProbeBudget(budget),
+		kind,
+		model,
+		modelRuntime: options.modelRuntime,
+		signal: operation.signal,
+		thinkingLevel: currentThinkingLevel()
+	});
+	return {
+		activate: (input) => Effect.gen(function* () {
+			const operation = yield* Effect.sync(() => createOperationSignal(input.budget.deadlineAt));
+			return yield* Effect.gen(function* () {
+				yield* Effect.try({
+					try: assertNoUnsettledMutations,
+					catch: (error) => error
+				});
+				const candidate = yield* Effect.tryPromise({
+					try: () => resolveCandidate(input.context, operation),
+					catch: (error) => error
+				});
+				if (!sameTarget(candidate.binding, input.validation.model)) return yield* Effect.fail(/* @__PURE__ */ new Error("Pi activation candidate does not match validated model"));
+				const canary = yield* runCanary("activation", candidate.model, input.budget, operation);
+				const sessions = yield* Effect.tryPromise({
+					try: () => waitForIdleAndCheckHistory(candidate.model, operation),
+					catch: (error) => error
+				});
+				if (input.beforeApply) yield* input.beforeApply();
+				yield* Effect.tryPromise({
+					try: () => setSessionsModel(sessions, candidate.model, currentThinkingLevel(), operation),
+					catch: (error) => error
+				});
+				active = {
+					binding: candidate.binding,
+					model: candidate.model,
+					thinkingLevel: currentThinkingLevel()
+				};
+				return Object.freeze({
+					evidence: Object.freeze({
+						canary: canary.assistant,
+						kind: "pi-model-activation-canary-v1",
+						model: candidate.binding,
+						sessionCount: sessions.length
+					}),
+					outputTokens: canary.outputTokens,
+					switched: true
+				});
+			}).pipe(Effect.ensuring(Effect.sync(operation.dispose)));
+		}),
+		current: () => Effect.succeed(active?.binding),
+		drain: (context) => Effect.gen(function* () {
+			const operation = yield* Effect.sync(() => createOperationSignal(context.deadlineAt));
+			yield* Effect.tryPromise({
+				try: async () => {
+					try {
+						const candidate = await resolveCandidate(context, operation);
+						await waitForIdleAndCheckHistory(candidate.model, operation);
+					} finally {
+						operation.dispose();
+					}
+				},
+				catch: (error) => error
+			});
+		}),
+		refreshModelCatalog: (input = {}) => Effect.tryPromise({
+			try: async () => {
+				const operation = createOperationSignal(input.deadlineAt, input.signal);
+				try {
+					assertOperationActive({
+						...input.deadlineAt === void 0 ? {} : { deadlineAt: input.deadlineAt },
+						signal: operation.signal
+					});
+					const result = await options.modelRuntime.refresh({
+						allowNetwork: input.allowNetwork ?? false,
+						...input.provider ? { providers: [input.provider] } : {},
+						signal: operation.signal
+					});
+					if (result.errors.size > 0) throw new Error([...result.errors.entries()].map(([provider, error]) => `${provider}: ${error.message}`).join("; "));
+					assertOperationActive({
+						...input.deadlineAt === void 0 ? {} : { deadlineAt: input.deadlineAt },
+						signal: operation.signal
+					});
+				} finally {
+					operation.dispose();
+				}
+			},
+			catch: (error) => error
+		}),
+		registerSessionRegistry: (registry) => {
+			registries.add(registry);
+			return () => registries.delete(registry);
+		},
+		initializeSelection: (input) => Effect.tryPromise({
+			try: async () => {
+				if (selectionInitializationStarted || active !== void 0) throw new Error("Pi model runtime selection has already been initialized");
+				if (registries.size > 0) throw new Error("Pi model runtime selection must be initialized before any Pi session registry is attached");
+				selectionInitializationStarted = true;
+				try {
+					const context = {
+						baseline: input.binding,
+						bindingRevision: input.binding.bindingRevision,
+						target: input.binding
+					};
+					const candidate = await resolveCandidate(context);
+					active = {
+						binding: candidate.binding,
+						model: candidate.model,
+						thinkingLevel: input.thinkingLevel
+					};
+				} catch (error) {
+					selectionInitializationStarted = false;
+					throw error;
+				}
+			},
+			catch: (error) => error
+		}),
+		getSessionOptions: () => Object.freeze({
+			...active?.model ? { model: active.model } : {},
+			...active?.thinkingLevel ? { thinkingLevel: active.thinkingLevel } : {}
+		}),
+		releasePrevious: (input) => Effect.try({
+			try: () => {
+				assertBeforeDeadline(input.deadlineAt);
+			},
+			catch: (error) => error
+		}),
+		restore: (input) => Effect.gen(function* () {
+			const baselineContext = {
+				...input.context,
+				target: input.context.baseline
+			};
+			const operation = yield* Effect.sync(() => createOperationSignal(input.budget.deadlineAt));
+			return yield* Effect.gen(function* () {
+				yield* Effect.try({
+					try: assertNoUnsettledMutations,
+					catch: (error) => error
+				});
+				const baseline = yield* Effect.tryPromise({
+					try: () => resolveCandidate(baselineContext, operation),
+					catch: (error) => error
+				});
+				const canary = yield* runCanary("restore", baseline.model, input.budget, operation);
+				const sessions = yield* Effect.tryPromise({
+					try: () => waitForIdleAndCheckHistory(baseline.model, operation),
+					catch: (error) => error
+				});
+				yield* Effect.tryPromise({
+					try: () => setSessionsModel(sessions, baseline.model, currentThinkingLevel(), operation),
+					catch: (error) => error
+				});
+				active = {
+					binding: baseline.binding,
+					model: baseline.model,
+					thinkingLevel: currentThinkingLevel()
+				};
+				return Object.freeze({
+					evidence: Object.freeze({
+						canary: canary.assistant,
+						kind: "pi-model-restore-canary-v1",
+						model: baseline.binding,
+						reason: input.reason,
+						sessionCount: sessions.length
+					}),
+					restored: true
+				});
+			}).pipe(Effect.ensuring(Effect.sync(operation.dispose)));
+		}),
+		validate: (input) => Effect.gen(function* () {
+			const operation = yield* Effect.sync(() => createOperationSignal(input.budget.deadlineAt));
+			return yield* Effect.gen(function* () {
+				const candidate = yield* Effect.tryPromise({
+					try: () => resolveCandidate(input.context, operation),
+					catch: (error) => error
+				});
+				const probe = yield* probePiModel({
+					budget: createProbeBudget(input.budget),
+					model: candidate.model,
+					modelRuntime: options.modelRuntime,
+					signal: operation.signal,
+					thinkingLevel: currentThinkingLevel()
+				});
+				return Object.freeze({
+					evidence: Object.freeze({
+						assistantThinkingBlocks: probe.assistantThinkingBlocks,
+						followupText: probe.followupText,
+						kind: "pi-model-probe-v1",
+						model: probe.model,
+						outputTokens: probe.outputTokens,
+						toolCallId: probe.toolCallId,
+						toolName: probe.toolName,
+						transcript: probe.transcript,
+						toolRoundtrip: true
+					}),
+					model: candidate.binding,
+					outputTokens: probe.outputTokens,
+					passed: true
+				});
+			}).pipe(Effect.ensuring(Effect.sync(operation.dispose)));
+		})
+	};
+	function currentThinkingLevel() {
+		return active?.thinkingLevel ?? "medium";
+	}
+}
+function sameTarget(left, right) {
+	return left.bindingRevision === right.bindingRevision && left.provider === right.provider && left.model === right.model;
+}
+function hasTextInput(messages) {
+	return messages.some((message) => {
+		if (!isRecord$1(message) || typeof message.role !== "string") return false;
+		if (message.role === "user" || message.role === "custom" || message.role === "toolResult") return hasTextContent(message.content);
+		if (message.role === "assistant") return Array.isArray(message.content) ? message.content.some((block) => isRecord$1(block) && (block.type === "text" && typeof block.text === "string" || block.type === "thinking" || block.type === "toolCall")) : false;
+		return message.role === "bashExecution" || message.role === "branchSummary" || message.role === "compactionSummary";
+	});
+}
+function hasTextContent(content) {
+	if (typeof content === "string") return content.length > 0;
+	return Array.isArray(content) && content.some((block) => isRecord$1(block) && block.type === "text" && typeof block.text === "string");
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function createOperationSignal(deadlineAt, parent) {
+	const controller = new AbortController();
+	let timer;
+	const onParentAbort = () => controller.abort(parent?.reason);
+	if (parent) if (parent.aborted) onParentAbort();
+	else parent.addEventListener("abort", onParentAbort, { once: true });
+	if (deadlineAt !== void 0) {
+		const remaining = Date.parse(deadlineAt) - Date.now();
+		if (!Number.isFinite(remaining) || remaining <= 0) controller.abort(/* @__PURE__ */ new Error("Pi model management deadline elapsed"));
+		else timer = setTimeout(() => controller.abort(/* @__PURE__ */ new Error("Pi model management deadline elapsed")), remaining);
+	}
+	return {
+		signal: controller.signal,
+		dispose: () => {
+			if (timer) clearTimeout(timer);
+			if (parent) parent.removeEventListener("abort", onParentAbort);
+			if (!controller.signal.aborted) controller.abort(/* @__PURE__ */ new Error("Pi model operation disposed"));
+		}
+	};
+}
+function assertBeforeDeadline(deadlineAt) {
+	if (deadlineAt === void 0) return;
+	const deadline = Date.parse(deadlineAt);
+	if (!Number.isFinite(deadline) || Date.now() >= deadline) throw new Error("Pi model management deadline elapsed");
+}
+function assertOperationActive(operation) {
+	assertBeforeDeadline(operation?.deadlineAt);
+	if (operation?.signal?.aborted) {
+		const reason = operation.signal.reason;
+		throw reason instanceof Error ? reason : /* @__PURE__ */ new Error("Pi model operation aborted");
+	}
+}
+//#endregion
+//#region src/adapters/pi/skills/pi-skill-catalog.ts
+var InvalidPiSkillCatalog = class extends Error {
+	name = "InvalidPiSkillCatalog";
+};
+function validatePiSkillCatalog(input) {
+	const fatal = input.diagnostics.find(({ type }) => type === "error" || type === "collision");
+	if (fatal) throw new InvalidPiSkillCatalog(`Pi Skill discovery failed: ${fatal.message}${fatal.path ? ` (${fatal.path})` : ""}`);
+	const names = /* @__PURE__ */ new Set();
+	for (const { name } of input.skills) {
+		validateSkillName(name);
+		if (names.has(name)) throw new InvalidPiSkillCatalog(`Pi Skill discovery contains duplicate name: ${name}`);
+		names.add(name);
+	}
+	return names;
+}
+function validateSkillName(name) {
+	if (typeof name !== "string" || name.length === 0 || name.length > 64 || !/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/.test(name) || name.includes("--")) throw new InvalidPiSkillCatalog(`Pi Skill discovery contains unsafe name: ${String(name)}`);
+}
+function validatePiSkillCommand(text, skillNames) {
+	if (!text.startsWith("/skill:")) return;
+	const name = text.slice(7).split(/\s/, 1)[0];
+	if (!skillNames.has(name)) throw new InvalidPiSkillCatalog(`Unknown Pi Skill: ${name}`);
+}
+//#endregion
+//#region src/adapters/pi/skills/pi-skill-sources.ts
+var InvalidPiSkillSource = class extends Error {
+	name = "InvalidPiSkillSource";
+};
+async function resolvePiSkillSources(options) {
+	const roots = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const path of [join(options.agentDir, "skills"), join(options.homeDirectory, ".agents", "skills")]) {
+		const canonical = await optionalDirectory(path);
+		if (canonical) appendUnique(roots, seen, canonical);
+	}
+	for (const path of options.projectSkillPaths ?? []) appendUnique(roots, seen, await requiredSkillSource(path));
+	return Object.freeze(roots);
+}
+async function optionalDirectory(path) {
+	let canonical;
+	try {
+		canonical = await realpath(path);
+	} catch (error) {
+		if (isMissingPath(error)) return void 0;
+		throw new InvalidPiSkillSource(`failed to resolve optional user Skill directory: ${path}`, { cause: error });
+	}
+	if (!(await stat(canonical)).isDirectory()) throw new InvalidPiSkillSource(`user Skill source must be a directory: ${path}`);
+	return canonical;
+}
+async function requiredSkillSource(path) {
+	try {
+		const canonical = await realpath(path);
+		const metadata = await stat(canonical);
+		if (!metadata.isDirectory() && !metadata.isFile()) throw new InvalidPiSkillSource(`Project Space Skill source must be a file or directory: ${path}`);
+		return canonical;
+	} catch (error) {
+		if (error instanceof InvalidPiSkillSource) throw error;
+		throw new InvalidPiSkillSource(`required Project Space Skill source is unavailable: ${path}`, { cause: error });
+	}
+}
+function appendUnique(roots, seen, path) {
+	if (seen.has(path)) return;
+	seen.add(path);
+	roots.push(path);
+}
+function isMissingPath(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+//#endregion
+//#region src/adapters/pi/runtime/pi-session-resources.ts
+const PI_BEHAVIOR_SETTING_KEYS = Object.freeze([
+	"lastChangelogVersion",
+	"defaultProvider",
+	"defaultModel",
+	"defaultThinkingLevel",
+	"transport",
+	"steeringMode",
+	"followUpMode",
+	"theme",
+	"compaction",
+	"branchSummary",
+	"retry",
+	"hideThinkingBlock",
+	"showCacheMissNotices",
+	"externalEditor",
+	"shellPath",
+	"quietStartup",
+	"shellCommandPrefix",
+	"collapseChangelog",
+	"enableSkillCommands",
+	"terminal",
+	"images",
+	"enabledModels",
+	"doubleEscapeAction",
+	"treeFilterMode",
+	"thinkingBudgets",
+	"editorPaddingX",
+	"outputPad",
+	"autocompleteMaxVisible",
+	"showHardwareCursor",
+	"markdown",
+	"warnings",
+	"httpProxy",
+	"httpIdleTimeoutMs",
+	"websocketConnectTimeoutMs"
+]);
+async function createPiSessionResources(options) {
+	const settingsManager = createSanitizedSettingsManager(options.cwd, options.agentDir, options.settingsOverrides);
+	const commandPrefix = settingsManager.getShellCommandPrefix();
+	const shellPath = settingsManager.getShellPath();
+	const bashToolOptions = commandPrefix === void 0 && shellPath === void 0 ? void 0 : Object.freeze({
+		...commandPrefix === void 0 ? {} : { commandPrefix },
+		...shellPath === void 0 ? {} : { shellPath }
+	});
+	let skillPaths = await resolveSkillPaths(options);
+	let currentResourceLoader = createResourceLoader(options, settingsManager, skillPaths);
+	await currentResourceLoader.reload();
+	let skillNames = validatePiSkillCatalog(currentResourceLoader.getSkills());
+	const resourceLoader = createResourceLoaderFacade(() => currentResourceLoader, settingsManager);
+	return {
+		...bashToolOptions === void 0 ? {} : { bashToolOptions },
+		get skillNames() {
+			return skillNames;
+		},
+		get skillPaths() {
+			return skillPaths;
+		},
+		refresh: async () => {
+			const nextSkillPaths = await resolveSkillPaths(options);
+			const nextResourceLoader = createResourceLoader(options, settingsManager, nextSkillPaths);
+			await nextResourceLoader.reload();
+			const nextSkillNames = validatePiSkillCatalog(nextResourceLoader.getSkills());
+			skillPaths = nextSkillPaths;
+			currentResourceLoader = nextResourceLoader;
+			skillNames = nextSkillNames;
+		},
+		withSessionOptions: (sessionOptions) => Object.freeze({
+			...sessionOptions,
+			agentDir: options.agentDir,
+			cwd: options.cwd,
+			resourceLoader,
+			settingsManager
+		})
+	};
+}
+function createResourceLoaderFacade(getCurrent, settingsManager) {
+	return {
+		extendResources: (paths) => getCurrent().extendResources(paths),
+		getAgentsFiles: () => getCurrent().getAgentsFiles(),
+		getAppendSystemPrompt: () => getCurrent().getAppendSystemPrompt(),
+		getAppendSystemPromptSources: () => getCurrent().getAppendSystemPromptSources(),
+		getExtensions: () => getCurrent().getExtensions(),
+		getPrompts: () => getCurrent().getPrompts(),
+		getSkills: () => getCurrent().getSkills(),
+		getSystemPrompt: () => getCurrent().getSystemPrompt(),
+		getSystemPromptSource: () => getCurrent().getSystemPromptSource(),
+		getThemes: () => getCurrent().getThemes(),
+		reload: (reloadOptions) => getCurrent().reload(reloadOptions),
+		settingsManager
+	};
+}
+async function resolveSkillPaths(options) {
+	return resolvePiSkillSources({
+		agentDir: options.agentDir,
+		homeDirectory: options.homeDirectory,
+		...options.projectSkillPaths ? { projectSkillPaths: options.projectSkillPaths } : {}
+	});
+}
+function createResourceLoader(options, settingsManager, skillPaths) {
+	return new DefaultResourceLoader({
+		agentDir: options.agentDir,
+		additionalSkillPaths: [...skillPaths],
+		...options.appendSystemPromptOverride ? { appendSystemPromptOverride: options.appendSystemPromptOverride } : {},
+		cwd: options.cwd,
+		noContextFiles: true,
+		noExtensions: true,
+		noPromptTemplates: true,
+		noSkills: true,
+		noThemes: true,
+		settingsManager,
+		...options.systemPromptOverride ? { systemPromptOverride: options.systemPromptOverride } : {}
+	});
+}
+function createSanitizedSettingsManager(cwd, agentDir, settingsOverrides) {
+	const fileSettings = SettingsManager.create(cwd, agentDir, { projectTrusted: false }).getGlobalSettings();
+	const behaviorSettings = Object.fromEntries(PI_BEHAVIOR_SETTING_KEYS.flatMap((key) => fileSettings[key] === void 0 ? [] : [[key, fileSettings[key]]]));
+	for (const key of PI_BEHAVIOR_SETTING_KEYS) if (settingsOverrides?.[key] !== void 0) behaviorSettings[key] = settingsOverrides[key];
+	return SettingsManager.inMemory(behaviorSettings, { projectTrusted: false });
+}
+//#endregion
+//#region src/adapters/pi/runtime/pi-assembly.ts
+async function createPiAssembly(options) {
+	const nativeModelRuntime = await ModelRuntime.create({
+		allowModelNetwork: options.allowModelNetwork ?? false,
+		...options.authPath ? { authPath: options.authPath } : {},
+		...options.modelsPath !== void 0 ? { modelsPath: options.modelsPath } : {}
+	});
+	const settingsManager = SettingsManager.create(options.cwd, options.agentDir, { projectTrusted: false });
+	const createResources = () => createPiSessionResources({
+		cwd: options.cwd,
+		agentDir: options.agentDir,
+		homeDirectory: options.homeDirectory,
+		...options.settingsOverrides ? { settingsOverrides: options.settingsOverrides } : {},
+		...options.resourceOptions
+	});
+	return {
+		modelRuntime: nativeModelRuntime,
+		createSessionResources: createResources,
+		createSession: async (sessionOptions = {}) => {
+			const { model, sessionCwd, sessionDirectory, thinkingLevel, resources, ...restOptions } = sessionOptions;
+			const activeResources = resources ?? await createResources();
+			const effectiveThinkingLevel = thinkingLevel ?? options.defaultThinkingLevel;
+			const nativeSessionManager = sessionDirectory ? SessionManager.create(sessionCwd ?? options.cwd, sessionDirectory) : void 0;
+			const sessionResult = await createAgentSession(activeResources.withSessionOptions({
+				modelRuntime: nativeModelRuntime,
+				...restOptions.noTools === void 0 ? {} : { noTools: restOptions.noTools },
+				...restOptions.tools === void 0 ? {} : { tools: [...restOptions.tools] },
+				...restOptions.excludeTools === void 0 ? {} : { excludeTools: [...restOptions.excludeTools] },
+				...restOptions.customTools === void 0 ? {} : { customTools: [...restOptions.customTools] },
+				...restOptions.scopedModels === void 0 ? {} : { scopedModels: restOptions.scopedModels.map(({ model: scopedModel, thinkingLevel: scopedThinkingLevel }) => ({
+					model: scopedModel,
+					...scopedThinkingLevel === void 0 ? {} : { thinkingLevel: scopedThinkingLevel }
+				})) },
+				...model ? { model } : {},
+				...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {},
+				...nativeSessionManager ? { sessionManager: nativeSessionManager } : {}
+			}));
+			return {
+				...sessionResult,
+				session: sessionResult.session,
+				dispose: () => sessionResult.session.dispose(),
+				refreshResources: () => activeResources.refresh()
+			};
+		},
+		resolveThinkingLevel: (provider, modelId) => {
+			return (provider !== void 0 && modelId !== void 0 ? settingsManager.getModelThinkingLevel(provider, modelId) : void 0) ?? settingsManager.getDefaultThinkingLevel();
+		},
+		dispose: async () => {}
+	};
+}
+//#endregion
+//#region src/adapters/pi/skills/pi-skill-read-tool.ts
+var ProjectSkillReadDenied = class extends Error {
+	name = "ProjectSkillReadDenied";
+};
+function createPiSkillReadTool(options) {
+	if (options.skillPaths.length === 0) throw new ProjectSkillReadDenied("Pi Skill read requires a trusted Skill source");
+	const allowedSources = options.skillPaths.map((source) => {
+		const path = realpathSync(source);
+		return Object.freeze({
+			directory: statSync(path).isDirectory(),
+			path
+		});
+	});
+	return createReadToolDefinition(options.cwd, { operations: {
+		access: async (absolutePath) => {
+			await stat(await authorize(absolutePath, allowedSources));
+		},
+		readFile: async (absolutePath) => readFile(await authorize(absolutePath, allowedSources))
+	} });
+}
+const createPiProjectSkillReadTool = createPiSkillReadTool;
+function createPiSkillReadTools(options) {
+	if (options.skillPaths.length === 0 || options.runtimeToolIds.includes("read")) return [];
+	return [createPiSkillReadTool(options)];
+}
+async function authorize(path, sources) {
+	const candidate = await realpath(path);
+	for (const source of sources) {
+		if (!source.directory) {
+			if (candidate === source.path) return candidate;
+			continue;
+		}
+		const relation = relative(source.path, candidate);
+		if (relation === "" || !relation.startsWith("..") && !isAbsolute(relation)) return candidate;
+	}
+	throw new ProjectSkillReadDenied("read is restricted to the bound Pi Skill sources");
+}
+//#endregion
+//#region src/adapters/pi/skills/project-skill-catalog.ts
+var InvalidProjectSkillCatalog = class extends Error {
+	name = "InvalidProjectSkillCatalog";
+};
+function validateProjectSkillCatalog(input) {
+	const diagnostic = input.diagnostics.find(({ type }) => type === "error" || type === "collision");
+	if (diagnostic) throw new InvalidProjectSkillCatalog(`Project Skill discovery failed: ${diagnostic.message}${diagnostic.path ? ` (${diagnostic.path})` : ""}`);
+	return new Set(input.skills.map(({ name }) => name));
+}
+function validateProjectSkillCommand(text, skillNames) {
+	if (!text.startsWith("/skill:")) return;
+	const name = text.slice(7).split(/\s/, 1)[0];
+	if (!skillNames.has(name)) throw new InvalidProjectSkillCatalog(`Unknown or ungranted Project Skill: ${name}`);
+}
+//#endregion
+//#region src/adapters/pi/tool-execution/pi-bash-tool.ts
+const DEFAULT_TIMEOUT_SECONDS = 120;
+/** Keep Pi's native execution, rendering and abort cleanup with a bounded default. */
+function createPiBashTool(cwd, options) {
+	const { commandPrefix, shellPath, spawnHook } = options ?? {};
+	const tool = createBashToolDefinition(cwd, {
+		...commandPrefix === void 0 ? {} : { commandPrefix },
+		...shellPath === void 0 ? {} : { shellPath },
+		...spawnHook === void 0 ? {} : { spawnHook }
+	});
+	return defineTool({
+		...tool,
+		description: `${tool.description} Defaults to ${DEFAULT_TIMEOUT_SECONDS} seconds when timeout is omitted; set an explicit positive timeout for longer commands.`,
+		parameters: {
+			...tool.parameters,
+			properties: {
+				...tool.parameters.properties,
+				timeout: {
+					...tool.parameters.properties.timeout,
+					description: `Timeout in seconds (optional, defaults to ${DEFAULT_TIMEOUT_SECONDS})`
+				}
+			}
+		},
+		execute: (id, args, signal, onUpdate, context) => tool.execute(id, {
+			...args,
+			timeout: args.timeout === void 0 ? DEFAULT_TIMEOUT_SECONDS : args.timeout
+		}, signal, onUpdate, context)
+	});
+}
+//#endregion
+//#region src/adapters/pi/tool-execution/pi-tool-proxy.ts
+function createPiToolProxyDefinitions$1(options) {
+	const names = /* @__PURE__ */ new Set();
+	return options.tools.map((tool) => {
+		const name = toPiToolName(tool.id);
+		if (names.has(name)) throw new Error(`Pi tool name collision: ${name}`);
+		names.add(name);
+		return {
+			description: tool.description,
+			execute: async (callId, input, signal) => {
+				const activeInput = options.getActiveInput();
+				const origin = activeInput?.invocation;
+				if (!activeInput || !origin) throw new Error(`tool ${tool.id} requires an active agent run with a trusted invocation`);
+				const invocation = normalizeAgentInvocation(origin);
+				if (!invocation.tenantKey) throw new Error(`tool ${tool.id} requires a trusted tenant identity`);
+				throwIfAborted(signal ?? activeInput.abortSignal);
+				const inputDigest = createToolInputDigest(input);
+				const operationId = createBoundId("operation", {
+					agentId: options.agentId,
+					inputDigest,
+					instanceId: options.instanceId,
+					sourceMessageId: invocation.sourceMessageId,
+					toolId: tool.id,
+					toolVersion: tool.version
+				});
+				const approvalId = createBoundId("approval", {
+					callId,
+					operationId,
+					runId: activeInput.runId
+				});
+				if (requiresToolApproval(tool.risk)) {
+					if (invocation.allowedActorOpenIds.length === 0) throw new Error(`tool ${tool.id} requires at least one trusted approval actor`);
+					await options.approvals.requestApproval({
+						agentId: options.agentId,
+						allowedActorOpenIds: invocation.allowedActorOpenIds,
+						approvalId,
+						callId,
+						endpointId: invocation.endpointId,
+						inputDigest,
+						instanceId: options.instanceId,
+						operationId,
+						risk: tool.risk,
+						runId: activeInput.runId,
+						sessionKey: activeInput.sessionKey,
+						signal: signal ?? activeInput.abortSignal,
+						sourceMessageId: invocation.sourceMessageId,
+						tenantKey: invocation.tenantKey,
+						toolId: tool.id,
+						toolVersion: tool.version
+					});
+					throwIfAborted(signal ?? activeInput.abortSignal);
+				}
+				const result = await options.broker.execute({
+					authority: createInvocationAuthority({
+						agentId: options.agentId,
+						allowedActorOpenIds: invocation.allowedActorOpenIds,
+						...invocation.conversationId ? { conversationId: invocation.conversationId } : {},
+						endpointId: invocation.endpointId,
+						instanceId: options.instanceId,
+						...invocation.memory ? { memory: {
+							...invocation.memory,
+							scopes: options.memoryScopes ?? []
+						} } : {},
+						runId: activeInput.runId,
+						sessionKey: activeInput.sessionKey,
+						sourceMessageId: invocation.sourceMessageId,
+						tenantKey: invocation.tenantKey,
+						toolGrantSet: options.toolGrantSet
+					}),
+					callId,
+					input,
+					operationId,
+					...requiresToolApproval(tool.risk) ? { approvalId } : {},
+					toolId: tool.id,
+					version: tool.version
+				});
+				return {
+					content: [{
+						text: stringifyToolResult(result),
+						type: "text"
+					}],
+					details: result
+				};
+			},
+			executionMode: "sequential",
+			label: tool.id,
+			name,
+			parameters: Unsafe(tool.inputSchema),
+			promptSnippet: `${name}: ${tool.description}`
+		};
+	});
+}
+function createToolInputDigest(input) {
+	return createToolInputDigest$1(input, createSha256Digest);
+}
+function createPiToolNameResolver$1(tools) {
+	const toolIdsByPiName = new Map(tools.map((tool) => [toPiToolName(tool.id), tool.id]));
+	return (toolName) => toolIdsByPiName.get(toolName) ?? toolName;
+}
+function toPiToolName(toolId) {
+	return `rivus_${toolId.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+}
+function createBoundId(kind, binding) {
+	return `${kind}:${createHash("sha256").update(JSON.stringify(binding)).digest("hex")}`;
+}
+function throwIfAborted(signal) {
+	if (signal.aborted) throw signal.reason ?? /* @__PURE__ */ new Error("tool execution was aborted");
+}
+function stringifyToolResult(result) {
+	if (typeof result === "string") return result;
+	return JSON.stringify(result ?? null);
+}
+//#endregion
+//#region src/adapters/pi/tool-execution/pi-session-tools.ts
+function resolvePiSessionToolNames(runtimeToolIds, customTools) {
+	const names = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const name of [...runtimeToolIds, ...customTools.map(({ name }) => name)]) {
+		if (seen.has(name)) throw new Error(`Pi Session Tool name collision: ${name}`);
+		seen.add(name);
+		names.push(name);
+	}
+	return Object.freeze(names);
+}
+//#endregion
+//#region src/adapters/pi/tool-execution/pi-managed-run-binding.ts
+function createPiManagedRunBinding(options) {
+	let current;
+	const deactivate = () => {
+		if (!current) return;
+		current.cleanup();
+		current = void 0;
+	};
+	const activate = (run) => {
+		deactivate();
+		current = options.provider(run);
+	};
+	const spawnHook = (spawn) => {
+		if (!current) return spawn;
+		return current.spawnHook(spawn);
+	};
+	const tool = createPiBashTool(options.cwd, {
+		...options.bashToolOptions,
+		spawnHook
+	});
+	return Object.freeze({
+		activate,
+		deactivate,
+		tool
+	});
+}
+//#endregion
+//#region src/adapters/compatibility/agent-execution/pi/pi-agent-loop.ts
+function createPiAgentLoop(options) {
+	return fromEffectAgentLoop(createPiAgentLoop$1({
+		...options.supportsSteering ? { supportsSteering: true } : {},
+		...options.disposeSessionAfterRun === void 0 ? {} : { disposeSessionAfterRun: options.disposeSessionAfterRun },
+		...options.modelContentObserver ? { modelContentObserver: options.modelContentObserver } : {},
+		...options.runBoundary ? { runBoundary: options.runBoundary } : {},
+		resolveSession: async (input) => toEffectPiAgentSessionHandle(await options.resolveSession(toCompatibilityAgentLoopInput(input)))
+	}));
+}
+function createPiSdkAgentLoop(options) {
+	return fromEffectAgentLoop(createPiSdkAgentLoop$1(options));
+}
+function toEffectPiAgentSessionHandle(handle) {
+	return {
+		...handle.activate ? { activate: (input) => handle.activate(toCompatibilityAgentLoopInput(input)) } : {},
+		...handle.dispose ? { dispose: handle.dispose } : {},
+		...handle.deactivate ? { deactivate: handle.deactivate } : {},
+		...handle.preparePrompt ? { preparePrompt: (input) => handle.preparePrompt(toCompatibilityAgentLoopInput(input)) } : {},
+		...handle.resolveToolName ? { resolveToolName: handle.resolveToolName } : {},
+		...handle.refreshResources ? { refreshResources: handle.refreshResources } : {},
+		session: handle.session
+	};
+}
+function fromEffectPiAgentSessionHandle(handle) {
+	return {
+		...handle.activate ? { activate: (input) => handle.activate(toEffectAgentLoopInput(input)) } : {},
+		...handle.dispose ? { dispose: handle.dispose } : {},
+		...handle.deactivate ? { deactivate: handle.deactivate } : {},
+		...handle.preparePrompt ? { preparePrompt: (input) => handle.preparePrompt(toEffectAgentLoopInput(input)) } : {},
+		...handle.resolveToolName ? { resolveToolName: handle.resolveToolName } : {},
+		...handle.refreshResources ? { refreshResources: handle.refreshResources } : {},
+		session: handle.session
+	};
+}
+//#endregion
+//#region src/adapters/compatibility/agent-execution/pi/pi-session-registry.ts
+function createPiSessionRegistry(options) {
+	const compatibilityHandles = /* @__PURE__ */ new WeakMap();
+	const registry = createPiSessionRegistry$1({ createSession: async (input) => {
+		const handle = await options.createSession(toCompatibilityAgentLoopInput(input));
+		const effectHandle = toEffectPiAgentSessionHandle(handle);
+		compatibilityHandles.set(effectHandle, handle);
+		return effectHandle;
+	} });
+	return {
+		dispose: (sessionKey) => registry.dispose(sessionKey),
+		disposeAll: () => registry.disposeAll(),
+		list: async () => (await registry.list()).map((effectHandle) => {
+			const cached = compatibilityHandles.get(effectHandle);
+			if (cached) return cached;
+			const handle = fromEffectPiAgentSessionHandle(effectHandle);
+			compatibilityHandles.set(effectHandle, handle);
+			return handle;
+		}),
+		resolve: async (input) => {
+			const effectHandle = await registry.resolve(toEffectAgentLoopInput(input));
+			const cached = compatibilityHandles.get(effectHandle);
+			if (cached) return cached;
+			const handle = fromEffectPiAgentSessionHandle(effectHandle);
+			compatibilityHandles.set(effectHandle, handle);
+			return handle;
+		},
+		size: () => registry.size()
+	};
+}
+//#endregion
+//#region src/adapters/compatibility/agent-execution/pi/pi-tool-proxy.ts
+function createPiToolProxyDefinitions(options) {
+	return createPiToolProxyDefinitions$1({
+		...options,
+		getActiveInput: () => {
+			const input = options.getActiveInput();
+			return input ? toEffectAgentLoopInput(input) : void 0;
+		}
+	});
+}
+function createPiToolNameResolver(tools) {
+	return createPiToolNameResolver$1(tools);
+}
+//#endregion
+export { InvalidPiSkillCatalog, InvalidPiSkillSource, InvalidProjectSkillCatalog, PI_MODEL_PROBE_FOLLOWUP_RESULT, PI_MODEL_PROBE_TOOL_NAME, PI_MODEL_PROBE_TOOL_RESULT, PI_SKILL_READER_TOOL_NAME, PiHistoryCompatibilityError, PiModelProbeError, PiModelResolutionError, PiModelRuntimeMutationUnknownError, PiModelTargetCompatibilityError, ProjectSkillReadDenied, assertPiSessionHistoryCompatible, createPiAgentLoop as createLegacyPiAgentLoop, createPiSdkAgentLoop as createLegacyPiSdkAgentLoop, createPiSessionRegistry as createLegacyPiSessionRegistry, createPiToolNameResolver as createLegacyPiToolNameResolver, createPiToolProxyDefinitions as createLegacyPiToolProxyDefinitions, createPiAgentLoop$1 as createPiAgentLoop, createPiAssembly, createPiBashTool, createPiManagedRunBinding, createPiModelRuntime, createPiProjectSkillReadTool, createPiSdkAgentLoop$1 as createPiSdkAgentLoop, createPiSessionRegistry$1 as createPiSessionRegistry, createPiSessionResources, createPiSkillReadTool, createPiSkillReadTools, createPiSkillRuntime, createPiToolNameResolver$1 as createPiToolNameResolver, createPiToolProxyDefinitions$1 as createPiToolProxyDefinitions, ensurePiModel, fromEffectPiAgentSessionHandle as fromEffectLegacyPiAgentSessionHandle, inspectPiSessionHistory, mergePiProviderBaseUrlOverride, mergePiProviderModelDeclaration, probePiModel, refreshPiModelCatalog, resolvePiModel, resolvePiModelBinding, resolvePiSessionToolNames, resolvePiSkillSources, runPiModelCanary, runPiSessionPrompts, samePiProvider, toEffectPiAgentSessionHandle as toEffectLegacyPiAgentSessionHandle, validatePiSkillCatalog, validatePiSkillCommand, validateProjectSkillCatalog, validateProjectSkillCommand };