pi2dsh 0.12.0 → 0.12.2

package/dist/{runtime-Bh5k4Kjt.mjs → runtime-DsPaznXJ.mjs}

@@ -1,6 +1,6 @@
 
-import { F as AssistantMessageEventStream, a as builtinProviders, h as getSupportedThinkingLevels, i as __setPiAiLlmBridge } from "./pi-ai-Dyg4zyLZ.mjs";
-import { P as generateBranchSummary, Tn as PiCapabilityError, b as Theme, d as ExtensionRunner, w as __setSubagentSessionFactory, wn as CapabilityLedger } from "./pi-coding-agent-Ctw-BhoY.mjs";
+import { F as AssistantMessageEventStream, I as isContextOverflow, a as builtinProviders, h as getSupportedThinkingLevels, i as __setPiAiLlmBridge } from "./pi-ai-Dyg4zyLZ.mjs";
+import { P as generateBranchSummary, Tn as PiCapabilityError, b as Theme, d as ExtensionRunner, w as __setSubagentSessionFactory, wn as CapabilityLedger } from "./pi-coding-agent-CYnmeJEx.mjs";
 import { t as getAgentDir } from "./pi-config-shim-CZ1wFzqM.mjs";
 import { a as resolvePiProviderAuth, n as loginPiProvider, r as providerSupportsOAuth, t as FileCredentialStore } from "./oauth-bridge-CfyImWx4.mjs";
 import { createRequire } from "node:module";
@@ -12,10 +12,18 @@ import { tmpdir } from "node:os";
 import { EventEmitter } from "node:events";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createJiti } from "jiti";
-import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { CONTEXT_WINDOW_EXCEEDED_CODE, EMPTY_RESPONSE_CODE, LlmError, QUOTA_EXCEEDED_CODE, createUserMessage, isContextWindowExceededError, isQuotaExceededError } from "@deepseek-ai/dsh-llm";
 import { renderPrompt } from "@deepseek-ai/dsh-system-prompt";
 import { randomUUID } from "node:crypto";
+import { foldSurface } from "@deepseek-ai/dsh-session";
+import { Compile } from "typebox/compile";
+import { Value } from "typebox/value";
 //#region src/session-bridge.ts
+/** The durable seq behind a projected entry id (`dsh-<seq>`), when it has one. */
+function entrySeq(id) {
+	const match = /^dsh-(\d+)$/.exec(id);
+	return match === null ? void 0 : Number(match[1]);
+}
 function sidecarDir() {
 	return join(getAgentDir(), "session-entries");
 }
@@ -143,6 +151,20 @@ var PiSessionBridge = class {
 	* shape. DSH history is linear, so the projection is a single-branch tree:
 	* every entry's parent is its predecessor.
 	*/
+	/**
+	* The seqs still on the model-visible surface, via DSH's own canonical fold.
+	* @param session - the session to project.
+	* @returns the visible seqs, or undefined when the fold cannot run (a
+	*   projection built from a partial event list, e.g. in a test double) — in
+	*   which case nothing is filtered out rather than everything.
+	*/
+	visibleSeqs(session) {
+		try {
+			return new Set(foldSurface(sessionEvents(session)).nodes);
+		} catch {
+			return;
+		}
+	}
 	projectEntries(session) {
 		this.load(session.id);
 		const merged = [];
@@ -270,7 +292,14 @@ var PiSessionBridge = class {
 				const index = entries.findIndex((entry) => entry.id === fromId);
 				return index === -1 ? [] : entries.slice(0, index + 1);
 			},
-			buildContextEntries: () => entriesOf().filter((entry) => entry.type === "message" || entry.type === "compaction" || entry.type === "branch_summary" || entry.type === "custom_message"),
+			buildContextEntries: () => {
+				const visible = this.visibleSeqs(session);
+				return entriesOf().filter((entry) => {
+					if (entry.type !== "message" && entry.type !== "compaction" && entry.type !== "branch_summary" && entry.type !== "custom_message") return false;
+					const seq = entrySeq(entry.id);
+					return seq === void 0 || visible === void 0 || visible.has(seq);
+				});
+			},
 			getHeader: () => ({
 				type: "session",
 				version: 3,
@@ -332,6 +361,8 @@ var PiBridgedAgentSession = class {
 	#pendingToolCalls = /* @__PURE__ */ new Set();
 	#sessionName = "";
 	#turns = 0;
+	/** Keeps message projections (which await attachment reads) in log order. */
+	#messageProjection = Promise.resolve();
 	#aborted = false;
 	constructor(host, handle, tools) {
 		this.#host = host;
@@ -464,8 +495,9 @@ var PiBridgedAgentSession = class {
 				}
 			});
 		}
-		const message = this.#host.messageFromSessionEvent(event);
-		if (message !== void 0) {
+		this.#messageProjection = this.#messageProjection.then(async () => {
+			const message = await this.#host.messageFromSessionEvent(event);
+			if (message === void 0) return;
 			this.messages.push(message);
 			emit({
 				type: "message_start",
@@ -475,19 +507,21 @@ var PiBridgedAgentSession = class {
 				type: "message_end",
 				message
 			});
-		}
+		});
 		if (type === "turn/end") {
 			this.#turns += 1;
 			this.#streaming = false;
 			this.#pendingToolCalls.clear();
-			emit({
-				type: "turn_end",
-				turnIndex: Number(event.data.turn ?? 1) - 1,
-				message: {
-					role: "assistant",
-					content: []
-				},
-				toolResults: []
+			this.#messageProjection = this.#messageProjection.then(() => {
+				emit({
+					type: "turn_end",
+					turnIndex: Number(event.data.turn ?? 1) - 1,
+					message: {
+						role: "assistant",
+						content: []
+					},
+					toolResults: []
+				});
 			});
 		}
 	}
@@ -541,6 +575,7 @@ var PiBridgedAgentSession = class {
 			}
 		}), "followup");
 		await completed;
+		await this.#messageProjection;
 	}
 	steer(text) {
 		this.#host.piContentToDsh([{
@@ -663,6 +698,184 @@ async function createBridgedAgentSession(host, options) {
 	return { session: new PiBridgedAgentSession(host, handle, tools) };
 }
 //#endregion
+//#region src/compat/vendor/pi-tool-validation.ts
+const validatorCache = /* @__PURE__ */ new WeakMap();
+const TYPEBOX_KIND = Symbol.for("TypeBox.Kind");
+function getSchemaTypes(schema) {
+	if (typeof schema.type === "string") return [schema.type];
+	if (Array.isArray(schema.type)) return schema.type.filter((type) => typeof type === "string");
+	return [];
+}
+function matchesJsonType(value, type) {
+	switch (type) {
+		case "number": return typeof value === "number";
+		case "integer": return typeof value === "number" && Number.isInteger(value);
+		case "boolean": return typeof value === "boolean";
+		case "string": return typeof value === "string";
+		case "null": return value === null;
+		case "array": return Array.isArray(value);
+		case "object": return typeof value === "object" && value !== null && !Array.isArray(value);
+		default: return false;
+	}
+}
+function getSubSchemaValidator(schema) {
+	try {
+		return getValidator(schema);
+	} catch {
+		return;
+	}
+}
+function coercePrimitiveByType(value, type) {
+	switch (type) {
+		case "number":
+			if (value === null) return 0;
+			if (typeof value === "string" && value.trim() !== "") {
+				const parsed = Number(value);
+				if (Number.isFinite(parsed)) return parsed;
+			}
+			if (typeof value === "boolean") return value ? 1 : 0;
+			return value;
+		case "integer":
+			if (value === null) return 0;
+			if (typeof value === "string" && value.trim() !== "") {
+				const parsed = Number(value);
+				if (Number.isInteger(parsed)) return parsed;
+			}
+			if (typeof value === "boolean") return value ? 1 : 0;
+			return value;
+		case "boolean":
+			if (value === null) return false;
+			if (typeof value === "string") {
+				if (value === "true") return true;
+				if (value === "false") return false;
+			}
+			if (typeof value === "number") {
+				if (value === 1) return true;
+				if (value === 0) return false;
+			}
+			return value;
+		case "string":
+			if (value === null) return "";
+			if (typeof value === "number" || typeof value === "boolean") return String(value);
+			return value;
+		case "null":
+			if (value === "" || value === 0 || value === false) return null;
+			return value;
+		default: return value;
+	}
+}
+function applySchemaObjectCoercion(value, schema) {
+	const properties = schema.properties;
+	const definedKeys = new Set(properties ? Object.keys(properties) : []);
+	if (properties) for (const [key, propertySchema] of Object.entries(properties)) {
+		if (!(key in value)) continue;
+		value[key] = coerceWithJsonSchema(value[key], propertySchema);
+	}
+	if (schema.additionalProperties && typeof schema.additionalProperties === "object") for (const [key, propertyValue] of Object.entries(value)) {
+		if (definedKeys.has(key)) continue;
+		value[key] = coerceWithJsonSchema(propertyValue, schema.additionalProperties);
+	}
+}
+function applySchemaArrayCoercion(value, schema) {
+	if (Array.isArray(schema.items)) {
+		for (let index = 0; index < value.length; index++) {
+			const itemSchema = schema.items[index];
+			if (!itemSchema) continue;
+			value[index] = coerceWithJsonSchema(value[index], itemSchema);
+		}
+		return;
+	}
+	if (schema.items && typeof schema.items === "object") for (let index = 0; index < value.length; index++) value[index] = coerceWithJsonSchema(value[index], schema.items);
+}
+function coerceWithUnionSchema(value, schemas) {
+	for (const schema of schemas) if (getSubSchemaValidator(schema)?.Check(value)) return value;
+	for (const schema of schemas) {
+		const coerced = coerceWithJsonSchema(structuredClone(value), schema);
+		if (getSubSchemaValidator(schema)?.Check(coerced)) return coerced;
+	}
+	return value;
+}
+function coerceWithJsonSchema(value, schema) {
+	let nextValue = value;
+	if (Array.isArray(schema.allOf)) for (const nested of schema.allOf) nextValue = coerceWithJsonSchema(nextValue, nested);
+	if (Array.isArray(schema.anyOf)) nextValue = coerceWithUnionSchema(nextValue, schema.anyOf);
+	if (Array.isArray(schema.oneOf)) nextValue = coerceWithUnionSchema(nextValue, schema.oneOf);
+	const schemaTypes = getSchemaTypes(schema);
+	const matchesUnionMember = schemaTypes.length > 1 && schemaTypes.some((schemaType) => matchesJsonType(nextValue, schemaType));
+	if (schemaTypes.length > 0 && !matchesUnionMember) for (const schemaType of schemaTypes) {
+		const candidate = coercePrimitiveByType(nextValue, schemaType);
+		if (candidate !== nextValue) {
+			nextValue = candidate;
+			break;
+		}
+	}
+	if (schemaTypes.includes("object") && typeof nextValue === "object" && nextValue !== null && !Array.isArray(nextValue)) applySchemaObjectCoercion(nextValue, schema);
+	if (schemaTypes.includes("array") && Array.isArray(nextValue)) applySchemaArrayCoercion(nextValue, schema);
+	return nextValue;
+}
+function normalizeOptionalNulls(value, schema) {
+	if (Array.isArray(value)) {
+		if (Array.isArray(schema.items)) for (let index = 0; index < value.length; index++) {
+			const itemSchema = schema.items[index];
+			if (itemSchema) normalizeOptionalNulls(value[index], itemSchema);
+		}
+		else if (schema.items) for (const item of value) normalizeOptionalNulls(item, schema.items);
+		return;
+	}
+	if (typeof value !== "object" || value === null || !schema.properties) return;
+	const object = value;
+	const required = new Set(schema.required ?? []);
+	for (const [key, propertySchema] of Object.entries(schema.properties)) {
+		if (!(key in object)) continue;
+		if (object[key] === null && !required.has(key) && typeof propertySchema.$ref !== "string" && getSubSchemaValidator(propertySchema)?.Check(null) === false) delete object[key];
+		else normalizeOptionalNulls(object[key], propertySchema);
+	}
+}
+function getValidator(schema) {
+	const key = schema;
+	const cached = validatorCache.get(key);
+	if (cached) return cached;
+	const validator = Compile(schema);
+	validatorCache.set(key, validator);
+	return validator;
+}
+function formatValidationPath(error) {
+	if (error.keyword === "required") {
+		const requiredProperty = error.params.requiredProperties?.[0];
+		if (requiredProperty) {
+			const basePath = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
+			return basePath ? `${basePath}.${requiredProperty}` : requiredProperty;
+		}
+	}
+	return error.instancePath.replace(/^\//, "").replace(/\//g, ".") || "root";
+}
+/**
+* Validates tool call arguments against the tool's TypeBox schema
+* @param tool The tool definition with TypeBox schema
+* @param toolCall The tool call from the LLM
+* @returns The validated (and potentially coerced) arguments
+* @throws Error with formatted message if validation fails
+*/
+function validateToolArguments(tool, toolCall) {
+	const args = structuredClone(toolCall.arguments);
+	normalizeOptionalNulls(args, tool.parameters);
+	Value.Convert(tool.parameters, args);
+	const validator = getValidator(tool.parameters);
+	if (!Object.getOwnPropertySymbols(tool.parameters).includes(TYPEBOX_KIND)) {
+		const coerced = coerceWithJsonSchema(args, tool.parameters);
+		if (coerced !== args) {
+			if (typeof args === "object" && args !== null && typeof coerced === "object" && coerced !== null) {
+				for (const key of Object.keys(args)) delete args[key];
+				Object.assign(args, coerced);
+			} else return validator.Check(coerced) ? coerced : args;
+		}
+	}
+	if (validator.Check(args)) return args;
+	const errors = validator.Errors(args).map((error) => `  - ${formatValidationPath(error)}: ${error.message}`).join("\n") || "Unknown validation error";
+	const errorMessage = `Validation failed for tool "${toolCall.name}":\n${errors}\n\nReceived arguments:\n${JSON.stringify(toolCall.arguments, null, 2)}`;
+	throw new Error(errorMessage);
+}
+//#endregion
 //#region src/model-bridge.ts
 function llmOf(ctx) {
 	try {
@@ -736,14 +949,30 @@ var ModelCatalog = class {
 				provider: provider.id
 			}));
 		} catch {}
+		const resolved = /* @__PURE__ */ new Map();
+		await Promise.all(next.map(async (model) => {
+			const exact = await this.#resolveExact(model.provider, model.id);
+			if (exact === void 0) return;
+			if (exact.contextWindow !== void 0) model.contextWindow = exact.contextWindow;
+			if (exact.maxTokens !== void 0) model.maxTokens = exact.maxTokens;
+			model.reasoning = exact.reasoning;
+			resolved.set(`${model.provider}${model.id}`, model);
+		}));
 		this.#models = next;
+		this.#resolved = resolved;
 	}
 	/** Exact-route metadata (context window, reasoning efforts), cached per route. */
 	async resolve(provider, modelId) {
-		if (this.#llm === void 0) return void 0;
 		const key = `${provider}${modelId}`;
 		const cached = this.#resolved.get(key);
 		if (cached !== void 0) return cached;
+		const model = await this.#resolveExact(provider, modelId);
+		if (model !== void 0) this.#resolved.set(key, model);
+		return model;
+	}
+	/** One exact resolve, uncached: the two callers own their own caching. */
+	async #resolveExact(provider, modelId) {
+		if (this.#llm === void 0) return void 0;
 		try {
 			const info = await this.#llm.resolveModelInfo(provider, modelId);
 			const model = piModelFromInfo(info);
@@ -753,7 +982,6 @@ var ModelCatalog = class {
 			if (typeof defaultMaxTokens === "number") model.maxTokens = defaultMaxTokens;
 			const reasoning = info.reasoning;
 			model.reasoning = Array.isArray(reasoning?.efforts) && reasoning.efforts.length > 0;
-			this.#resolved.set(key, model);
 			return model;
 		} catch {
 			return;
@@ -1083,26 +1311,34 @@ function normalizeToolSchemas(tools) {
 	}));
 }
 /** DSH GenerateOptions parts → the Pi request context a provider.stream expects. */
-function dshRequestToPiContext(options) {
+async function dshRequestToPiContext(options, attachments) {
 	const piMessages = [];
+	const toolNamesById = /* @__PURE__ */ new Map();
+	for (const message of Array.isArray(options.messages) ? options.messages : []) {
+		if (message.role !== "assistant") continue;
+		for (const block of Array.isArray(message.content) ? message.content : []) if (block.type === "tool-call" && typeof block.id === "string" && typeof block.name === "string") toolNamesById.set(block.id, block.name);
+	}
 	for (const message of Array.isArray(options.messages) ? options.messages : []) {
 		const content = Array.isArray(message.content) ? message.content : [];
 		const source = message.source;
 		if (message.role === "user" && source?.kind === "tool") {
 			const result = content[0];
+			const toolCallId = String(result?.toolCallId ?? "");
+			const toolName = toolNamesById.get(toolCallId);
 			piMessages.push({
 				role: "toolResult",
-				toolCallId: String(result?.toolCallId ?? ""),
-				content: piContentFromDshBlocks(Array.isArray(result?.content) ? result.content : []),
+				toolCallId,
+				...toolName === void 0 ? {} : { toolName },
+				content: await piContentFromDshBlocks(Array.isArray(result?.content) ? result.content : [], attachments),
 				isError: result?.isError === true
 			});
 		} else if (message.role === "user") piMessages.push({
 			role: "user",
-			content: piContentFromDshBlocks(content)
+			content: await piContentFromDshBlocks(content, attachments)
 		});
 		else if (message.role === "assistant") piMessages.push({
 			role: "assistant",
-			content: piContentFromDshBlocks(content)
+			content: await piContentFromDshBlocks(content, attachments)
 		});
 	}
 	return {
@@ -1111,7 +1347,12 @@ function dshRequestToPiContext(options) {
 		...Array.isArray(options.tools) ? { tools: options.tools } : {}
 	};
 }
-function piContentFromDshBlocks(blocks) {
+/** Whether any block in this content — including inside a tool result — is an image. */
+function blocksContainImage(blocks) {
+	if (!Array.isArray(blocks)) return false;
+	return blocks.some((block) => block?.type === "image" || block?.type === "tool-result" && blocksContainImage(block.content));
+}
+async function piContentFromDshBlocks(blocks, attachments) {
 	const out = [];
 	for (const block of blocks) if (block.type === "text") out.push({
 		type: "text",
@@ -1134,15 +1375,187 @@ function piContentFromDshBlocks(blocks) {
 			name: String(block.name ?? ""),
 			arguments: parsed
 		});
+	} else if (block.type === "image") {
+		if (attachments === void 0) throw new LlmError("pi2dsh: image input requires the durable attachment service", "UNSUPPORTED_CONTENT");
+		const stored = await attachments.readImage(block.attachment);
+		out.push({
+			type: "image",
+			data: Buffer.from(stored.data).toString("base64"),
+			mimeType: String(stored.ref?.mediaType ?? block.attachment?.mediaType ?? "image/png")
+		});
 	}
 	return out;
 }
+/**
+* Classify a failure into the code DSH keys retries and error surfaces off.
+*
+* Mirrored from `classifyPiAiError` in DSH's own pi-ai adapter
+* (`packages/llm/llm-pi-ai/src/stream.ts`). That symbol is private to a
+* package whose published tarball ships only `lib/`, so it cannot be imported
+* — but it must not be diverged from either. `RATE_LIMIT`, `SERVER`,
+* `TIMEOUT` and `TRANSPORT` are four of the five codes in DSH's default
+* retryable set, so a code invented here would make every rate limit, every
+* dropped socket and every timeout a Pi provider ever reports permanently
+* non-retryable — dsh-llm-retry would simply not recognize it. The quota and
+* context-window predicates it defers to are DSH's own, imported above.
+* @param message - the provider's failure text.
+* @returns the harness failure code.
+*/
+function classifyPiFailure(message) {
+	if (/\b(?:401|403)\b/.test(message)) return "AUTH";
+	if (isQuotaExceededError(message)) return QUOTA_EXCEEDED_CODE;
+	if (/\b429\b|rate.?limit/i.test(message)) return "RATE_LIMIT";
+	if (/\b400\b|invalid.?request/i.test(message)) return "INVALID_REQUEST";
+	if (/\b5\d\d\b/.test(message)) return "SERVER";
+	if (/\btime(?:d)?\s*out\b|timeout/i.test(message)) return "TIMEOUT";
+	if (/stream ended (?:before|without)\b/i.test(message)) return "TRANSPORT";
+	if (/\b(?:network|connection|socket|fetch)\b|\bECONN[A-Z]+\b/i.test(message) || /\b(?:other side closed|HTTP2 request did not get a response|WebSocket closed unexpectedly)\b/i.test(message) || /\bterminated\b|premature close/i.test(message)) return "TRANSPORT";
+	return "PI_AI_ERROR";
+}
+/**
+* Pi usage counts → DSH's TokenUsage, mirroring the official adapter's
+* `mapUsage`: Pi reports zeros rather than absence, so the cache fields appear
+* only when non-zero.
+* @param usage - the usage record on a terminal Pi event, if the package sent one.
+* @returns the harness counts.
+*/
+function piUsageToDsh(usage) {
+	const cacheRead = Number(usage?.cacheRead ?? 0);
+	const cacheWrite = Number(usage?.cacheWrite ?? 0);
+	return {
+		inputTokens: Number(usage?.input ?? 0),
+		outputTokens: Number(usage?.output ?? 0),
+		...cacheRead > 0 ? { cacheReadTokens: cacheRead } : {},
+		...cacheWrite > 0 ? { cacheWriteTokens: cacheWrite } : {}
+	};
+}
+/**
+* The assistant message Pi's terminal `error` event carries.
+*
+* Pi delivers failures in-stream as `{ type: 'error', reason, error }` where
+* `error` is an **AssistantMessage**, not an Error — its text lives on
+* `errorMessage`. A package that hands back a bare Error instead is met
+* halfway rather than stringified into "[object Object]".
+* @param error - the event's payload.
+* @param fallbackStopReason - the event's own `reason`, used when the payload states none.
+* @returns a message shape the finish-reason mapping can read.
+*/
+function piErrorPayload(error, fallbackStopReason) {
+	if (error instanceof Error) return {
+		stopReason: fallbackStopReason,
+		errorMessage: error.message
+	};
+	if (typeof error === "object" && error !== null) {
+		const record = error;
+		if (typeof record.stopReason === "string" || typeof record.errorMessage === "string") return {
+			stopReason: fallbackStopReason,
+			...record
+		};
+		return {
+			stopReason: fallbackStopReason,
+			errorMessage: JSON.stringify(error)
+		};
+	}
+	return {
+		stopReason: fallbackStopReason,
+		errorMessage: String(error ?? "pi2dsh: the package reported a stream failure with no detail")
+	};
+}
+/**
+* A terminal Pi assistant message → DSH's finish reason, mirroring the
+* official adapter's `mapStopReason`, including its context-overflow and
+* empty-response detection (the overflow predicate is Pi's own, vendored).
+*
+* One documented deviation: DSH's adapter can trust pi-ai to populate
+* `content`, and reads an empty array as a degenerate empty completion. This
+* bridge takes its events from an arbitrary third-party package, so it also
+* accepts the blocks it actually saw stream past as proof of content. That
+* only ever narrows the error — a stream that produced output is never
+* mislabelled EMPTY_RESPONSE because its terminal event omitted a field.
+* @param message - the assistant message on the `done` or `error` event.
+* @param contextWindow - the model's resolved capacity, for usage-based overflow detection.
+* @param sawContent - whether any content block streamed before the terminal event.
+* @returns the harness finish reason.
+*/
+function piFinishReason(message, contextWindow, sawContent) {
+	const stopReason = String(message?.stopReason ?? "stop");
+	const errorMessage = typeof message?.errorMessage === "string" ? message.errorMessage : void 0;
+	const model = String(message?.model ?? "unknown");
+	const usage = message?.usage;
+	const probe = {
+		stopReason,
+		errorMessage,
+		usage: {
+			input: Number(usage?.input ?? 0),
+			output: Number(usage?.output ?? 0),
+			cacheRead: Number(usage?.cacheRead ?? 0),
+			cacheWrite: Number(usage?.cacheWrite ?? 0)
+		}
+	};
+	if (isContextOverflow(probe, contextWindow) || stopReason === "error" && errorMessage !== void 0 && isContextWindowExceededError(errorMessage)) return {
+		kind: "error",
+		failure: {
+			message: errorMessage ?? `pi2dsh: the package's provider reported context overflow for model "${model}"`,
+			code: CONTEXT_WINDOW_EXCEEDED_CODE
+		}
+	};
+	switch (stopReason) {
+		case "length": return { kind: "max-tokens" };
+		case "toolUse": return { kind: "tool-calls" };
+		case "aborted": return {
+			kind: "aborted",
+			failure: {
+				message: errorMessage ?? "pi2dsh: the package aborted the stream",
+				code: "ABORTED"
+			}
+		};
+		case "error": {
+			const text = errorMessage ?? "pi2dsh: the package reported a stream failure";
+			return {
+				kind: "error",
+				failure: {
+					message: text,
+					code: classifyPiFailure(text)
+				}
+			};
+		}
+		default:
+			if ((Array.isArray(message?.content) ? message.content : []).length === 0 && !sawContent) return {
+				kind: "error",
+				failure: {
+					message: `model "${model}" returned a completed response with no content`,
+					code: EMPTY_RESPONSE_CODE
+				}
+			};
+			return { kind: "stop" };
+	}
+}
+/**
+* The id and name of the tool call an event is opening or extending. Pi states
+* them on the partial message's content at the event's index, never on the
+* event itself.
+* @param event - a `toolcall_start` or `toolcall_delta` event.
+* @param index - the event's content index.
+* @returns the call's identity, or undefined when the partial states none.
+*/
+function partialToolCall(event, index) {
+	const partial = event.partial;
+	const block = (Array.isArray(partial?.content) ? partial.content : [])[index];
+	if (block === void 0 || block.type !== "toolCall") return void 0;
+	const name = typeof block.name === "string" && block.name.length > 0 ? block.name : void 0;
+	return {
+		id: typeof block.id === "string" ? block.id : "",
+		...name === void 0 ? {} : { name }
+	};
+}
 /** A Pi AssistantMessageEventStream → DSH StreamChunk sequence. */
-async function* piEventsToDshChunks(events) {
-	let usage;
+async function* piEventsToDshChunks(events, contextWindow) {
+	const openToolCalls = /* @__PURE__ */ new Map();
+	let sawContent = false;
 	for await (const event of events) {
 		const type = String(event.type ?? "");
 		const index = Number(event.contentIndex ?? 0);
+		if (type === "text_start" || type === "thinking_start" || type === "toolcall_start") sawContent = true;
 		if (type === "text_start") yield {
 			type: "block-start",
 			index,
@@ -1179,18 +1592,24 @@ async function* piEventsToDshChunks(events) {
 				text: String(event.content ?? "")
 			}
 		};
-		else if (type === "toolcall_start") yield {
-			type: "block-start",
-			index,
-			blockType: "tool-call"
-		};
-		else if (type === "toolcall_delta") yield {
-			type: "tool-call-delta",
-			index,
-			id: "",
-			argumentsDelta: String(event.delta ?? "")
-		};
-		else if (type === "toolcall_end") {
+		else if (type === "toolcall_start") {
+			const opened = partialToolCall(event, index);
+			if (opened !== void 0) openToolCalls.set(index, opened);
+			yield {
+				type: "block-start",
+				index,
+				blockType: "tool-call"
+			};
+		} else if (type === "toolcall_delta") {
+			const open = openToolCalls.get(index) ?? partialToolCall(event, index);
+			yield {
+				type: "tool-call-delta",
+				index,
+				id: open?.id ?? "",
+				...open?.name === void 0 ? {} : { name: open.name },
+				argumentsDelta: String(event.delta ?? "")
+			};
+		} else if (type === "toolcall_end") {
 			const call = event.toolCall;
 			yield {
 				type: "block-end",
@@ -1204,61 +1623,34 @@ async function* piEventsToDshChunks(events) {
 			};
 		} else if (type === "done") {
 			const message = event.message;
-			const piUsage = message?.usage;
-			if (piUsage !== void 0) {
-				usage = {
-					inputTokens: Number(piUsage.input ?? 0),
-					outputTokens: Number(piUsage.output ?? 0),
-					...piUsage.cacheRead === void 0 ? {} : { cacheReadTokens: Number(piUsage.cacheRead) },
-					...piUsage.cacheWrite === void 0 ? {} : { cacheWriteTokens: Number(piUsage.cacheWrite) }
-				};
-				yield {
-					type: "usage",
-					usage
-				};
-			}
-			const stop = String(message?.stopReason ?? "stop");
+			yield {
+				type: "usage",
+				usage: piUsageToDsh(message?.usage)
+			};
 			yield {
 				type: "finish",
-				reason: stop === "length" ? { kind: "max-tokens" } : stop === "toolUse" ? { kind: "tool-calls" } : stop === "aborted" ? {
-					kind: "aborted",
-					failure: {
-						message: "aborted by caller",
-						code: "ABORTED"
-					}
-				} : { kind: "stop" }
+				reason: piFinishReason(message, contextWindow, sawContent)
 			};
 			return;
 		} else if (type === "error") {
-			const error = event.error;
+			const message = piErrorPayload(event.error, String(event.reason ?? "error"));
+			yield {
+				type: "usage",
+				usage: piUsageToDsh(message.usage)
+			};
 			yield {
 				type: "finish",
-				reason: {
-					kind: String(event.reason ?? "") === "aborted" ? "aborted" : "error",
-					failure: {
-						message: error instanceof Error ? error.message : String(error ?? "provider stream error"),
-						code: "PI_PROVIDER"
-					}
-				}
+				reason: piFinishReason(message, contextWindow, sawContent)
 			};
 			return;
 		}
 	}
-	yield {
-		type: "finish",
-		reason: {
-			kind: "error",
-			failure: {
-				message: "pi2dsh: Pi provider stream ended without done/error",
-				code: "PI_PROVIDER"
-			}
-		}
-	};
+	throw new LlmError("pi2dsh: the package's provider stream ended without a done or error event", "STREAM_CLOSED");
 }
 //#endregion
 //#region src/provider-adapter.ts
 function providerCarriesTransport(value) {
-	return typeof value?.stream === "function";
+	return typeof value?.streamSimple === "function" || typeof value?.stream === "function";
 }
 function providerModels(provider) {
 	try {
@@ -1280,6 +1672,19 @@ const PI_CARRIED_FIELDS = [
 	"headers"
 ];
 /**
+* Model capabilities DSH asks about by its own names. Shared by the catalog
+* listing and the exact-route resolve deliberately: a capability present in
+* one and absent from the other is how a model silently loses an ability —
+* the host consults the resolve before a request, so a modality declared only
+* in the listing reads as "text only" at the moment it matters.
+* @param model - the Pi model descriptor as its package declared it.
+*/
+function capabilityProjection(model) {
+	if (!Array.isArray(model.input)) return {};
+	const modalities = model.input.filter((entry) => entry === "text" || entry === "image");
+	return modalities.length === 0 ? {} : { inputModalities: modalities };
+}
+/**
 * Pi's reasoning capability, in DSH's shape.
 *
 * The two sides say the same thing differently: Pi carries a `reasoning`
@@ -1316,6 +1721,12 @@ function piCarriedFields(model) {
 * Structural typing carries it through `llm.registerAdapter`.
 */
 function piProviderDshAdapter(providerId, provider, host) {
+	let warnedStop = false;
+	const warnStopUnsupported = () => {
+		if (warnedStop) return;
+		warnedStop = true;
+		host.warn(`[pi2dsh] a request to Pi provider ${JSON.stringify(providerId)} carries stop sequences, which Pi models at no layer — they cannot be forwarded, so the model will not halt on them`);
+	};
 	return {
 		providerInfo: (id) => ({
 			id,
@@ -1324,15 +1735,16 @@ function piProviderDshAdapter(providerId, provider, host) {
 		providerRetryPolicy: () => void 0,
 		listModels: async (id) => providerModels(provider).map((model) => ({
 			...piCarriedFields(model),
+			...capabilityProjection(model),
 			provider: id,
 			id: String(model.id ?? ""),
-			name: String(model.name ?? model.id ?? ""),
-			...Array.isArray(model.input) ? { inputModalities: model.input.filter((m) => m === "text" || m === "image") } : {}
+			name: String(model.name ?? model.id ?? "")
 		})),
 		resolveModel: async (id, modelId) => {
 			const known = providerModels(provider).find((model) => model.id === modelId);
 			return {
 				...known === void 0 ? {} : piCarriedFields(known),
+				...known === void 0 ? {} : capabilityProjection(known),
 				...known === void 0 ? {} : reasoningProjection(known),
 				provider: id,
 				id: modelId,
@@ -1348,7 +1760,14 @@ function piProviderDshAdapter(providerId, provider, host) {
 				id: modelId,
 				provider: providerId
 			};
-			const piContext = dshRequestToPiContext(options);
+			const carriesImage = (Array.isArray(options.messages) ? options.messages : []).some((message) => blocksContainImage(message.content));
+			if (carriesImage) {
+				if (!(Array.isArray(model.input) ? model.input : []).includes("image")) throw new LlmError(`pi2dsh: model "${modelId}" does not declare image input`, "UNSUPPORTED_CONTENT");
+			}
+			const attachments = carriesImage ? host.resolveAttachments?.() : void 0;
+			if (carriesImage && attachments === void 0) throw new LlmError("pi2dsh: image input requires the durable attachment service", "UNSUPPORTED_CONTENT");
+			const piContext = await dshRequestToPiContext(options, attachments);
+			const effort = typeof options.reasoningEffort === "string" ? options.reasoningEffort : void 0;
 			const piOptions = {
 				...auth?.apiKey === void 0 ? {} : { apiKey: auth.apiKey },
 				...auth?.baseUrl === void 0 ? {} : { baseUrl: auth.baseUrl },
@@ -1356,9 +1775,20 @@ function piProviderDshAdapter(providerId, provider, host) {
 				...options.signal instanceof AbortSignal ? { signal: options.signal } : {},
 				...typeof options.maxTokens === "number" ? { maxTokens: options.maxTokens } : {},
 				...typeof options.temperature === "number" ? { temperature: options.temperature } : {},
-				...typeof options.reasoningEffort === "string" ? { reasoningEffort: options.reasoningEffort } : {}
+				...typeof options.sessionId === "string" ? { sessionId: options.sessionId } : {},
+				...effort === void 0 || effort === "off" ? {} : { reasoning: effort }
 			};
-			yield* piEventsToDshChunks(provider.stream(model, piContext, piOptions));
+			const contextWindow = typeof model.contextWindow === "number" ? model.contextWindow : void 0;
+			if (Array.isArray(options.stop) && options.stop.length > 0) warnStopUnsupported();
+			if (typeof provider.streamSimple === "function") {
+				yield* piEventsToDshChunks(provider.streamSimple(model, piContext, piOptions), contextWindow);
+				return;
+			}
+			const { reasoning, ...rest } = piOptions;
+			yield* piEventsToDshChunks(provider.stream(model, piContext, reasoning === void 0 ? rest : {
+				...rest,
+				reasoningEffort: reasoning
+			}), contextWindow);
 		}
 	};
 }
@@ -1772,11 +2202,12 @@ function contextFor(ctx, state, agent, signal, command = false, sessionOverride)
 	const notices = [];
 	const userQuestions = optionalService(ctx, "userQuestions");
 	const ui = {
-		notify(message) {
+		notify(message, type) {
 			const text = String(message);
 			notices.push(text);
 			state.notifications.push(text);
-			logger(ctx).info(`[pi2dsh] ${text}`);
+			const level = type === "warning" || type === "error" ? "warn" : "info";
+			logger(ctx)[level](`[pi2dsh] ${text}`);
 		},
 		select: (title, options) => askOne(ctx, agent, signal, {
 			id: "pi2dsh-select",
@@ -1989,9 +2420,18 @@ function contextFor(ctx, state, agent, signal, command = false, sessionOverride)
 	};
 	const contextCwd = typeof (sessionOverride?.header)?.cwd === "string" ? sessionOverride.header.cwd : cwdOf(agent);
 	const base = {
+		...sessionOverride === void 0 ? {} : {
+			sendMessage: (message, options = {}) => sendPiMessage(ctx, state, message.content, deliveryMode(options), sessionOverride, typeof message.customType === "string" ? message.customType : void 0),
+			sendUserMessage: (content) => sendPiMessage(ctx, state, content, "followup", sessionOverride),
+			appendEntry: (customType, data) => {
+				state.bridge.appendCustomEntry(String(sessionOverride.id ?? ""), customType, data);
+			}
+		},
 		ui,
 		mode: "rpc",
-		hasUI: userQuestions !== void 0,
+		get hasUI() {
+			return humanAnswererAvailable(userQuestions, agent);
+		},
 		cwd: contextCwd,
 		sessionManager: session === void 0 ? state.bridge.readonlySessionManager({
 			id: "pi2dsh-detached",
@@ -1999,7 +2439,7 @@ function contextFor(ctx, state, agent, signal, command = false, sessionOverride)
 		}, contextCwd) : state.bridge.readonlySessionManager(session, contextCwd),
 		modelRegistry,
 		model: agent === void 0 ? void 0 : currentPiModel(state, agent),
-		scopedModels: catalog?.all() ?? [],
+		scopedModels: [],
 		thinkingLevel: thinkingLevelOf(state, agent),
 		isIdle: () => command,
 		isProjectTrusted: () => false,
@@ -2012,7 +2452,7 @@ function contextFor(ctx, state, agent, signal, command = false, sessionOverride)
 				reason: "pi2dsh: aborted by migrated Pi extension"
 			});
 		},
-		hasPendingMessages: () => false,
+		hasPendingMessages: () => agent?.inbox?.hasPending === true,
 		shutdown: () => {
 			capabilityLedgerOf(ctx, state).reportHostDecision({
 				capability: "ctx.shutdown",
@@ -2214,39 +2654,93 @@ async function dispatch(state, eventName, event, eventContext) {
 	for (const handler of state.handlers.get(eventName) ?? []) results.push(await state.agentScope.run(agent, () => handler(event, eventContext)));
 	return results;
 }
-function dshToPiContent(content) {
-	return content.map((block) => {
-		if (block.type === "text") return {
-			type: "text",
-			text: block.text
-		};
-		if (block.type === "reasoning") return {
-			type: "thinking",
-			thinking: block.text
-		};
-		if (block.type === "tool-call") return {
-			type: "toolCall",
-			id: block.id,
-			name: block.name,
-			arguments: block.arguments
-		};
-		return { type: block.type };
+/**
+* What triggered a compaction, in Pi's vocabulary.
+*
+* DSH's durable lifecycle events say two things about the trigger: a manual
+* compaction runs with no open turn (`turn: null`), and one a command drove
+* cites that command. Both are Pi's "manual".
+*
+* The limit, stated rather than papered over: DSH's automatic trigger is
+* `'pressure' | 'context-overflow'` at the call site but is NOT written to the
+* log, so Pi's `threshold` and `overflow` cannot be told apart after the fact.
+* Automatic compactions report `threshold`, the far more common of the two —
+* and `willRetry` stays false for the same reason. A package keying behavior
+* on `overflow` specifically will not see it.
+* @param data - the `compaction/start` or `compaction/summary` event data.
+*/
+function compactionReason(data) {
+	if (data.sourceCommandId !== void 0) return "manual";
+	return data.turn === null ? "manual" : "threshold";
+}
+/**
+* DSH content → the Pi content blocks packages read.
+*
+* Asynchronous because Pi's image block carries the bytes inline while DSH's
+* carries only an attachment reference, and the bytes come from the attachment
+* service. The sync version this replaced projected an image as a bare
+* `{type:'image'}` — a block that announces an image and contains none, which
+* is the exact shape a package cannot tell from a real one.
+* @param ctx - context used to reach the attachment service.
+* @param content - the DSH blocks to project.
+*/
+async function dshToPiContent(ctx, content) {
+	const out = [];
+	for (const block of content) if (block.type === "text") out.push({
+		type: "text",
+		text: block.text
+	});
+	else if (block.type === "reasoning") out.push({
+		type: "thinking",
+		thinking: block.text
+	});
+	else if (block.type === "tool-call") out.push({
+		type: "toolCall",
+		id: block.id,
+		name: block.name,
+		arguments: block.arguments
 	});
+	else if (block.type === "image") {
+		const image = await piImageBlock(ctx, block.attachment);
+		if (image !== void 0) out.push(image);
+	} else out.push({ type: block.type });
+	return out;
+}
+/**
+* One DSH image attachment as Pi's inline image block.
+* @param ctx - context used to reach the attachment service.
+* @param attachment - the durable reference on an image block.
+* @returns the Pi block, or undefined when the bytes cannot be read.
+*/
+async function piImageBlock(ctx, attachment) {
+	if (attachment === void 0 || attachment === null) return void 0;
+	const attachments = optionalService(ctx, "attachments");
+	if (attachments === void 0) return void 0;
+	try {
+		const stored = await attachments.readImage(attachment);
+		return {
+			type: "image",
+			data: Buffer.from(stored.data).toString("base64"),
+			mimeType: String(attachment.mediaType ?? "image/png")
+		};
+	} catch {
+		return;
+	}
 }
-function messageFromSessionEvent(event) {
+async function messageFromSessionEvent(ctx, event) {
 	const type = event.type;
 	const data = event.data;
 	if (typeof data !== "object" || data === null) return void 0;
 	const record = data;
 	if (type === "user/message") return {
 		role: "user",
-		content: dshToPiContent(record.content ?? [])
+		content: await dshToPiContent(ctx, record.content ?? [])
 	};
 	if (type === "assistant/message") {
 		const message = record.message;
 		return {
 			role: "assistant",
-			content: dshToPiContent(message?.content ?? [])
+			content: await dshToPiContent(ctx, message?.content ?? [])
 		};
 	}
 	if (type === "tool/result") {
@@ -2254,7 +2748,7 @@ function messageFromSessionEvent(event) {
 		return {
 			role: "toolResult",
 			toolCallId: tool?.toolCallId,
-			content: dshToPiContent(tool?.content ?? []),
+			content: await dshToPiContent(ctx, tool?.content ?? []),
 			isError: tool?.isError === true
 		};
 	}
@@ -2301,13 +2795,42 @@ function subscribeLifecycle(ctx, state) {
 		const eventContext = contextFor(ctx, state, agent, void 0);
 		const type = event.type;
 		if (type === "turn/start") {
-			const turn = Number(event.data.turn ?? 1);
+			if (session !== void 0) state.piTurnIndex.set(session, 0);
 			dispatch(state, "agent_start", { type: "agent_start" }, eventContext).catch((error) => warn("agent_start", error));
-			dispatch(state, "turn_start", {
-				type: "turn_start",
-				turnIndex: turn - 1,
-				timestamp: event.time ?? Date.now()
-			}, eventContext).catch((error) => warn("turn_start", error));
+		}
+		if (type === "step/start") dispatch(state, "turn_start", {
+			type: "turn_start",
+			turnIndex: state.piTurnIndex.get(session) ?? 0,
+			timestamp: event.time ?? Date.now()
+		}, eventContext).catch((error) => warn("turn_start", error));
+		if (type === "step/end") {
+			const data = event.data;
+			const turn = Number(data.turn ?? 1);
+			const step = Number(data.step ?? 1);
+			const key = session;
+			const index = state.piTurnIndex.get(key) ?? 0;
+			state.piTurnIndex.set(key, index + 1);
+			state.projection = state.projection.then(async () => {
+				const stepEvents = (session.events ?? []).filter((entry) => {
+					const entryData = entry.data;
+					return Number(entryData?.turn ?? -1) === turn && Number(entryData?.step ?? -1) === step;
+				});
+				const toolResults = (await Promise.all(stepEvents.filter((entry) => entry.type === "tool/result").map((entry) => messageFromSessionEvent(ctx, entry)))).filter((message) => message !== void 0);
+				const assistant = stepEvents.findLast((entry) => entry.type === "assistant/message");
+				const message = assistant === void 0 ? {
+					role: "assistant",
+					content: []
+				} : await messageFromSessionEvent(ctx, assistant) ?? {
+					role: "assistant",
+					content: []
+				};
+				await dispatch(state, "turn_end", {
+					type: "turn_end",
+					turnIndex: index,
+					message,
+					toolResults
+				}, eventContext);
+			}).catch((error) => warn("turn_end", error));
 		}
 		if (type === "tool/call") {
 			const data = event.data;
@@ -2358,21 +2881,26 @@ function subscribeLifecycle(ctx, state) {
 			type: "session_before_compact",
 			preparation: { ...event.data },
 			branchEntries: [],
-			reason: "threshold",
+			reason: compactionReason(event.data),
 			willRetry: false
 		}, eventContext).catch((error) => warn("session_before_compact", error));
-		if (type === "compaction/end" || type === "compaction/summary") {
+		if (type === "compaction/summary") {
 			const data = event.data;
+			const shadowed = data.shadowedRange;
+			const usage = data.usage;
 			dispatch(state, "session_compact", {
 				type: "session_compact",
 				compactionEntry: {
 					type: "compaction",
 					id: `dsh-${String(event.seq ?? "")}`,
-					summary: typeof data.summary === "string" ? data.summary : "",
-					...data
+					summary: textBlocks(data.summary).map((block) => block.text).join("\n"),
+					firstKeptEntryId: typeof shadowed?.end === "number" ? `dsh-${shadowed.end + 1}` : "",
+					tokensBefore: Number(data.shadowedTokenCount ?? 0),
+					...usage === void 0 ? {} : { usage },
+					fromHook: false
 				},
 				fromExtension: false,
-				reason: "threshold",
+				reason: compactionReason(data),
 				willRetry: false
 			}, eventContext).catch((error) => warn("session_compact", error));
 		}
@@ -2390,29 +2918,25 @@ function subscribeLifecycle(ctx, state) {
 				state.lastLoggedModels.set(agent, String(model));
 			}
 		}
-		const message = messageFromSessionEvent(event);
-		if (message !== void 0) dispatch(state, "message_start", {
-			type: "message_start",
-			message
-		}, eventContext).then(() => dispatch(state, "message_end", {
-			type: "message_end",
-			message
-		}, eventContext)).catch((error) => warn("message lifecycle", error));
-		if (type === "turn/end") {
-			const data = event.data;
-			dispatch(state, "turn_end", {
-				type: "turn_end",
-				turnIndex: Number(data.turn ?? 1) - 1,
-				message: {
-					role: "assistant",
-					content: []
-				},
-				toolResults: []
-			}, eventContext).then(() => dispatch(state, "agent_end", {
+		state.projection = state.projection.then(async () => {
+			const message = await messageFromSessionEvent(ctx, event);
+			if (message === void 0) return;
+			await dispatch(state, "message_start", {
+				type: "message_start",
+				message
+			}, eventContext);
+			await dispatch(state, "message_end", {
+				type: "message_end",
+				message
+			}, eventContext);
+		}).catch((error) => warn("message lifecycle", error));
+		if (type === "turn/end") state.projection = state.projection.then(async () => {
+			await dispatch(state, "agent_end", {
 				type: "agent_end",
 				messages: []
-			}, eventContext)).then(() => dispatch(state, "agent_settled", { type: "agent_settled" }, eventContext)).catch((error) => warn("turn end lifecycle", error));
-		}
+			}, eventContext);
+			await dispatch(state, "agent_settled", { type: "agent_settled" }, eventContext);
+		}).catch((error) => warn("turn end lifecycle", error));
 	});
 	cordis.on("agent/request", async (payload, next) => {
 		const config = await next();
@@ -2428,19 +2952,6 @@ function subscribeLifecycle(ctx, state) {
 			...thinking === void 0 || thinking === "off" ? {} : { reasoningEffort: thinking }
 		};
 	});
-	cordis.on("tools/result", (exec, result) => {
-		const agent = exec.agent;
-		dispatch(state, "tool_execution_end", {
-			type: "tool_execution_end",
-			toolCallId: exec.callId,
-			toolName: exec.name,
-			result: {
-				content: dshToPiContent(result.content),
-				details: result.meta ?? null
-			},
-			isError: result.isError
-		}, contextFor(ctx, state, agent, exec.signal)).catch((error) => warn("tool_execution_end", error));
-	});
 	cordis.effect(() => async () => {
 		for (const agent of state.activeAgents) if (typeof agent === "object" && agent !== null && !state.disposedAgents.has(agent)) {
 			state.disposedAgents.add(agent);
@@ -2458,6 +2969,7 @@ function subscribeLifecycle(ctx, state) {
 function subscribeInterceptors(ctx, state) {
 	const cordis = ctx;
 	cordis.on("tools/pre-execute", async (exec, next) => {
+		if (isSubagentOrigin(exec.agent)) return next();
 		const input = cloneJson(exec.arguments);
 		const event = {
 			type: "tool_call",
@@ -2473,21 +2985,47 @@ function subscribeInterceptors(ctx, state) {
 				reason: `pi2dsh: a Pi tool_call hook mutated arguments of native DSH tool ${JSON.stringify(exec.name)}; DSH logs arguments before policy, so this mutation cannot be honored`
 			};
 		}
-		for (const result of results) if (typeof result === "object" && result !== null && result.block === true) return {
-			kind: "deny",
-			reason: String(result.reason ?? "blocked by migrated Pi tool_call hook")
+		const agent = exec.agent;
+		const tally = agent === void 0 ? void 0 : state.terminateBatch.get(agent) ?? {
+			calls: 0,
+			terminating: 0
 		};
+		if (tally !== void 0 && agent !== void 0) {
+			tally.calls += 1;
+			state.terminateBatch.set(agent, tally);
+		}
+		for (const result of results) {
+			if (typeof result !== "object" || result === null) continue;
+			const record = result;
+			if (record.block !== true) continue;
+			if (record.terminate === true && tally !== void 0) tally.terminating += 1;
+			return {
+				kind: "deny",
+				reason: String(record.reason ?? "blocked by migrated Pi tool_call hook")
+			};
+		}
 		return next();
 	});
 	cordis.on("tools/post-execute", async (exec, result, next) => {
+		if (isSubagentOrigin(exec.agent)) return next();
 		const downstream = await next();
+		await dispatch(state, "tool_execution_end", {
+			type: "tool_execution_end",
+			toolCallId: exec.callId,
+			toolName: exec.name,
+			result: {
+				content: await dshToPiContent(ctx, result.content),
+				details: result.meta ?? null
+			},
+			isError: result.isError
+		}, contextFor(ctx, state, exec.agent, exec.signal)).catch((error) => logger(ctx).warn(`[pi2dsh] tool_execution_end handler failed: ${String(error)}`));
 		if (downstream.kind === "block") return downstream;
 		const event = {
 			type: "tool_result",
 			toolName: exec.name,
 			toolCallId: exec.callId,
 			input: cloneJson(exec.arguments),
-			content: dshToPiContent(result.content),
+			content: await dshToPiContent(ctx, result.content),
 			details: result.meta ?? null,
 			isError: result.isError,
 			usage: void 0
@@ -2503,57 +3041,37 @@ function subscribeInterceptors(ctx, state) {
 			feedback: content
 		};
 		if (event.isError === false && result.isError) logger(ctx).warn("[pi2dsh] a Pi tool_result hook attempted to recover a DSH error; error recovery was ignored");
-		if (!jsonEqual(event.content, dshToPiContent(result.content))) return {
+		if (!jsonEqual(event.content, await dshToPiContent(ctx, result.content))) return {
 			kind: "accept",
 			content
 		};
 		return downstream;
 	});
+	cordis.on("agent/inbox/claimed", (payload) => {
+		const agent = payload.agent;
+		if (agent === void 0 || isSubagentOrigin(agent)) return;
+		const claimed = state.claimedForStep.get(agent) ?? [];
+		claimed.push({
+			message: payload.message,
+			turn: Number(payload.turn ?? 0)
+		});
+		state.claimedForStep.set(agent, claimed);
+	});
 	cordis.on("agent/pre-step", async (payload, next) => {
-		const decision = await next();
-		if (decision.kind !== "enter" || payload.step !== 1) return decision;
-		if ((state.handlers.get("before_agent_start")?.length ?? 0) === 0) return decision;
 		const agent = payload.agent;
-		if (isSubagentOrigin(agent)) return decision;
+		if (isSubagentOrigin(agent)) return next();
+		const tally = state.terminateBatch.get(agent);
+		state.terminateBatch.delete(agent);
+		if (tally !== void 0 && tally.calls > 0 && tally.calls === tally.terminating) {
+			logger(ctx).info(`[pi2dsh] a Pi tool_call hook terminated the turn: all ${tally.calls} call(s) in the batch were blocked with terminate`);
+			return { kind: "reject" };
+		}
+		const decision = await next();
+		if (decision.kind !== "enter") return decision;
 		const signal = payload.signal;
 		const messages = decision.messages ?? [];
-		const userMessages = messages.filter((message) => (message.source?.kind ?? "user") === "user");
-		const prompt = userMessages.flatMap((message) => textBlocks(message.content)).map((block) => block.text).join("\n");
-		const images = await collectPiImages(ctx, userMessages);
-		state.turnSystemPromptOverrides.delete(agent);
-		const event = {
-			type: "before_agent_start",
-			prompt,
-			...images.length > 0 ? { images } : {},
-			systemPrompt: state.currentSystemPrompt,
-			systemPromptOptions: {}
-		};
-		const results = await dispatch(state, "before_agent_start", event, contextFor(ctx, state, agent, signal));
-		const injected = [];
-		for (const result of results) {
-			if (typeof result !== "object" || result === null) continue;
-			const record = result;
-			if (typeof record.systemPrompt === "string") {
-				state.turnSystemPromptOverrides.set(agent, record.systemPrompt);
-				event.systemPrompt = record.systemPrompt;
-			}
-			const message = record.message;
-			if (message !== void 0) {
-				const content = message.content;
-				const blocks = await piToDshContent(ctx, typeof content === "string" ? [{
-					type: "text",
-					text: content
-				}] : content ?? []);
-				injected.push(createUserMessage({
-					content: blocks,
-					source: {
-						kind: "plugin",
-						plugin: state.messageSource,
-						...typeof message.customType === "string" ? { piCustomType: message.customType } : {}
-					}
-				}));
-			}
-		}
+		const injected = state.pendingInjections.get(agent) ?? [];
+		state.pendingInjections.delete(agent);
 		const stepMessages = injected.length === 0 ? messages : [...messages, ...injected];
 		const transformed = await applyPiContextTransform(ctx, state, agent, signal, stepMessages);
 		if (transformed === stepMessages && injected.length === 0) return decision;
@@ -2562,13 +3080,19 @@ function subscribeInterceptors(ctx, state) {
 			messages: transformed
 		};
 	});
+	const systemPrompt = optionalService(ctx, "systemPrompt");
+	if (systemPrompt !== void 0) ctx.effect(() => systemPrompt.section({
+		name: "pi2dsh:tool-guidance",
+		order: 150,
+		text: () => piToolPromptContribution(ctx, state)
+	}));
 	cordis.on("system-prompt/assemble", async (assembly, assembleContext, next) => {
 		const downstream = await next();
-		if ((state.handlers.get("before_agent_start")?.length ?? 0) === 0) return downstream;
 		const original = renderPrompt(downstream);
 		state.currentSystemPrompt = original;
 		const agent = assembleContext.agent ?? assembleContext.scope;
 		if (agent !== void 0 && !isSubagentOrigin(agent)) {
+			await runBeforeAgentStart(ctx, state, agent, assembleContext.signal, original);
 			const override = state.turnSystemPromptOverrides.get(agent);
 			if (override === void 0) return downstream;
 			state.currentSystemPrompt = override;
@@ -2580,6 +3104,7 @@ function subscribeInterceptors(ctx, state) {
 				}]
 			};
 		}
+		if ((state.handlers.get("before_agent_start")?.length ?? 0) === 0) return downstream;
 		const event = {
 			type: "before_agent_start",
 			prompt: "",
@@ -2602,9 +3127,69 @@ function subscribeInterceptors(ctx, state) {
 		};
 	});
 }
-function piShapeOfPending(message) {
+/**
+* Pi's `before_agent_start`, run inside the assembly of the turn it belongs to.
+*
+* Fires once per user prompt: only when this step's claim opened a NEW turn,
+* matching Pi, where the event follows the user's message rather than every
+* model call. A handler's `systemPrompt` becomes this turn's override (reset
+* at the next turn, exactly as Pi resets to the base prompt) and a returned
+* `message` is held for the step that is about to be entered.
+* @param ctx - context used for attachments and handler dispatch.
+* @param state - runtime state holding claims, overrides, and injections.
+* @param agent - the agent whose assembly this is.
+* @param signal - the turn's control signal, when one exists.
+* @param assembled - the prompt as assembled, before any package override.
+*/
+async function runBeforeAgentStart(ctx, state, agent, signal, assembled) {
+	const claimed = state.claimedForStep.get(agent) ?? [];
+	state.claimedForStep.delete(agent);
+	if (claimed.length === 0) return;
+	const turn = Number(claimed[0]?.turn ?? 0);
+	if (state.promptedTurn.get(agent) === turn) return;
+	state.promptedTurn.set(agent, turn);
+	state.turnSystemPromptOverrides.delete(agent);
+	if ((state.handlers.get("before_agent_start")?.length ?? 0) === 0) return;
+	const userMessages = claimed.map((entry) => entry.message).filter((message) => (message.source?.kind ?? "user") === "user");
+	const prompt = userMessages.flatMap((message) => textBlocks(message.content)).map((block) => block.text).join("\n");
+	const images = await collectPiImages(ctx, userMessages);
+	const event = {
+		type: "before_agent_start",
+		prompt,
+		...images.length > 0 ? { images } : {},
+		systemPrompt: assembled,
+		systemPromptOptions: {}
+	};
+	const results = await dispatch(state, "before_agent_start", event, contextFor(ctx, state, agent, signal));
+	const injected = [];
+	for (const result of results) {
+		if (typeof result !== "object" || result === null) continue;
+		const record = result;
+		if (typeof record.systemPrompt === "string") {
+			state.turnSystemPromptOverrides.set(agent, record.systemPrompt);
+			event.systemPrompt = record.systemPrompt;
+		}
+		const message = record.message;
+		if (message === void 0) continue;
+		const content = message.content;
+		const blocks = await piToDshContent(ctx, typeof content === "string" ? [{
+			type: "text",
+			text: content
+		}] : content ?? []);
+		injected.push(createUserMessage({
+			content: blocks,
+			source: {
+				kind: "plugin",
+				plugin: state.messageSource,
+				...typeof message.customType === "string" ? { piCustomType: message.customType } : {}
+			}
+		}));
+	}
+	if (injected.length > 0) state.pendingInjections.set(agent, injected);
+}
+async function piShapeOfPending(ctx, message) {
 	const source = message.source;
-	const content = dshToPiContent(message.content ?? []);
+	const content = await dshToPiContent(ctx, message.content ?? []);
 	return typeof source?.piCustomType === "string" ? {
 		role: "custom",
 		customType: source.piCustomType,
@@ -2619,7 +3204,7 @@ async function applyPiContextTransform(ctx, state, agent, signal, pending) {
 	const session = agentSession(agent);
 	const history = [];
 	for (const event of session?.events ?? []) {
-		const projected = messageFromSessionEvent(event);
+		const projected = await messageFromSessionEvent(ctx, event);
 		if (projected === void 0) continue;
 		if (event.type === "user/message") {
 			const customType = (event.data?.source)?.piCustomType;
@@ -2634,7 +3219,7 @@ async function applyPiContextTransform(ctx, state, agent, signal, pending) {
 		}
 		history.push(projected);
 	}
-	const projectedPending = pending.map(piShapeOfPending);
+	const projectedPending = await Promise.all(pending.map((message) => piShapeOfPending(ctx, message)));
 	const event = {
 		type: "context",
 		messages: [...history, ...projectedPending]
@@ -2681,7 +3266,7 @@ async function applyPiContextTransform(ctx, state, agent, signal, pending) {
 	return rebuilt;
 }
 async function collectPiImages(ctx, messages) {
-	const attachments = ctx.get("attachments");
+	const attachments = optionalService(ctx, "attachments");
 	if (attachments === void 0) return [];
 	const images = [];
 	for (const message of messages) {
@@ -2905,7 +3490,13 @@ function registerTool(ctx, state, tool) {
 			const mutated = state.argMutations.get(exec);
 			if (mutated !== void 0) state.argMutations.delete(exec);
 			const effective = mutated ?? args;
-			const prepared = live.prepareArguments?.(cloneJson(effective)) ?? effective;
+			const prepared = validateToolArguments({
+				name: live.name,
+				parameters: live.parameters
+			}, {
+				name: live.name,
+				arguments: live.prepareArguments?.(cloneJson(effective)) ?? effective
+			});
 			const agent = exec.agent;
 			const result = await normalizeToolResultForDsh(ctx, await state.agentScope.run(agent, () => live.execute(String(exec.callId), prepared, exec.signal, (update) => {
 				dispatch(state, "tool_execution_update", {
@@ -2943,10 +3534,57 @@ function currentAgent(state) {
 function toolRuntime(ctx, agent) {
 	return (agent?.ctx)?.tools ?? ctx.tools;
 }
+/**
+* The system-prompt text a package's ACTIVE tools contribute.
+*
+* Pi renders `promptSnippet` into its "Available tools" list and
+* `promptGuidelines` into its "Guidelines" bullets. DSH assembles its prompt
+* from ordered sections, so both arrive as one section in DSH's tool-guidance
+* band, headed the way Pi heads them.
+* @param ctx - context used to read which tools are active.
+* @param state - runtime state holding the registered Pi tools.
+* @returns the section text, empty when no active Pi tool contributes any.
+*/
+function piToolPromptContribution(ctx, state) {
+	const active = new Set(getActiveTools(ctx, state));
+	const snippets = [];
+	const guidelines = [];
+	for (const [name, tool] of state.tools) {
+		if (!active.has(name)) continue;
+		const snippet = tool.promptSnippet;
+		if (typeof snippet === "string" && snippet.trim().length > 0) snippets.push(`- ${snippet.trim()}`);
+		const bullets = tool.promptGuidelines;
+		if (!Array.isArray(bullets)) continue;
+		for (const bullet of bullets) if (typeof bullet === "string" && bullet.trim().length > 0) guidelines.push(`- ${bullet.trim()}`);
+	}
+	const parts = [];
+	if (snippets.length > 0) parts.push(`Available tools:\n${snippets.join("\n")}`);
+	if (guidelines.length > 0) parts.push(`Guidelines:\n${guidelines.join("\n")}`);
+	return parts.join("\n\n");
+}
 function getActiveTools(ctx, state) {
 	const agent = currentAgent(state);
 	return toolRuntime(ctx, agent).schemas(agent).map((tool) => tool.name);
 }
+/**
+* Pi's `setActiveTools`, on DSH's restriction seam.
+*
+* Pi walks the requested names and keeps the ones its registry knows —
+* **unknown names are silently skipped**. DSH's `restrict` instead FAILS the
+* whole call on a name it cannot restrict (unknown, scope-local, or a
+* reserved transport name), so passing Pi's list through verbatim turned a
+* routine Pi call into a hard error over one stale name.
+*
+* So the list is narrowed to what DSH says is restrictable before restricting.
+* The one case that cannot be both: a tool that is VISIBLE but not
+* restrictable (a scope's own registration, `run_code` outside native mode)
+* cannot be switched off at all. Silence there would leave a tool running that
+* the package believes it disabled, so it is reported once — the package's
+* call still takes effect for everything else.
+* @param ctx - context used to reach the tool runtime.
+* @param state - runtime state holding the per-agent restriction disposers.
+* @param names - the tool names the package wants active.
+*/
 function setActiveTools(ctx, state, names) {
 	const unique = [...new Set(names)];
 	const agent = currentAgent(state);
@@ -2957,27 +3595,104 @@ function setActiveTools(ctx, state, names) {
 		logger(ctx).warn("[pi2dsh] setActiveTools deferred: the current agent exposes no scoped tools.restrict()");
 		return;
 	}
+	const restrictable = restrictableToolNames(scopedTools, agent);
+	const allow = restrictable === void 0 ? unique : unique.filter((name) => restrictable.has(name));
+	if (restrictable !== void 0) {
+		const unswitchable = [...new Set(scopedTools.schemas(agent).map((schema) => schema.name))].filter((name) => !restrictable.has(name) && !unique.includes(name));
+		if (unswitchable.length > 0) logger(ctx).warn(`[pi2dsh] setActiveTools could not deactivate ${unswitchable.map((name) => JSON.stringify(name)).join(", ")}: DSH does not allow restricting a scope-registered or reserved tool, so it stays available to the model`);
+	}
 	state.toolRestrictions.get(agent)?.();
-	state.toolRestrictions.set(agent, scopedTools.restrict({ allow: unique }));
+	state.toolRestrictions.set(agent, allow.length === 0 ? scopedTools.restrict({ deny: [...restrictable ?? /* @__PURE__ */ new Set()] }) : scopedTools.restrict({ allow }));
+}
+/**
+* The tool names DSH will accept in a restriction for this scope.
+* @param tools - the agent-scoped tool runtime.
+* @param agent - the scope key.
+* @returns the restrictable names, or undefined when this runtime exposes no view.
+*/
+function restrictableToolNames(tools, agent) {
+	const view = tools.view;
+	if (typeof view !== "function") return void 0;
+	try {
+		const names = view.call(tools, agent)?.restrictableNames;
+		return names instanceof Set ? names : void 0;
+	} catch {
+		return;
+	}
 }
 function deliverAgentMessage(agent, message, mode) {
 	const deliver = agent[mode];
 	if (typeof deliver !== "function") throw new Error(`pi2dsh: active DSH agent has no ${mode}() delivery method`);
 	deliver.call(agent, message);
 }
-async function sendPiMessage(ctx, state, content, mode) {
-	const agent = requireAgent(state, mode === "inject" ? "sendMessage" : "sendUserMessage");
+/**
+* Pi's `sendMessage` / `sendUserMessage`, on DSH.
+*
+* Two things this has to get right that a plain `deliverAgentMessage` does not:
+*
+*  - **Durability.** Pi's no-turn `sendMessage` appends to the session and
+*    emits its message events before it returns: on return the message IS in
+*    the conversation. DSH's inject only queues it in the agent's inbox, where
+*    it becomes a `user/message` when the next step claims it — so a turn
+*    cancelled in between dropped it, and a package that had already reported
+*    success was wrong. The no-turn mode now appends to the durable log
+*    itself, which is what Pi's contract promises.
+*  - **Which session.** Inside a `withSession` callback the context is bound to
+*    the REPLACEMENT session, but the live agent is still the one that started
+*    the operation — so routing through the agent wrote into the OLD session.
+*    An override session is written to directly.
+* @param ctx - context used for content conversion.
+* @param state - runtime state (message source, active agent).
+* @param content - the Pi content to deliver.
+* @param mode - inject (no turn), steer, or followup.
+* @param sessionOverride - the replacement session, inside a withSession callback.
+* @param customType - Pi's role:"custom" marker, when the caller sent one.
+*/
+async function sendPiMessage(ctx, state, content, mode, sessionOverride, customType) {
 	const blocks = await piToDshContent(ctx, typeof content === "string" ? [{
 		type: "text",
 		text: content
 	}] : content);
-	deliverAgentMessage(agent, createUserMessage({
+	const message = createUserMessage({
 		content: blocks,
 		source: {
 			kind: "plugin",
-			plugin: state.messageSource
+			plugin: state.messageSource,
+			...customType === void 0 ? {} : { piCustomType: customType }
 		}
-	}), mode);
+	});
+	if (sessionOverride !== void 0) {
+		appendUserMessage(sessionOverride, message);
+		return;
+	}
+	if (mode === "inject") {
+		const session = agentSession(currentAgent(state));
+		if (session === void 0) throw new Error("pi2dsh: sendMessage requires one active DSH agent with a durable session");
+		appendUserMessage(session, message);
+		return;
+	}
+	deliverAgentMessage(requireAgent(state, "sendUserMessage"), message, mode);
+}
+/**
+* Pi's delivery options → this bridge's mode. No options at all means "into
+* the conversation, no turn", which is Pi's own default.
+* @param options - the caller's delivery options.
+*/
+function deliveryMode(options) {
+	if (options.deliverAs === "steer") return "steer";
+	if (options.deliverAs === "followUp" || options.deliverAs === "nextTurn" || options.triggerTurn === true) return "followup";
+	return "inject";
+}
+/**
+* Append one plugin-sourced user message to a session's durable log, which is
+* what makes it part of the conversation before the call returns.
+* @param session - the live DSH session to append to.
+* @param message - the message, already in DSH shape.
+*/
+function appendUserMessage(session, message) {
+	const append = session.append;
+	if (typeof append !== "function") throw new Error("pi2dsh: this session cannot be appended to, so the message could not be delivered durably");
+	append.call(session, "user/message", message, { surfaceOp: "append" });
 }
 function combineExecSignal(options) {
 	const controller = new AbortController();
@@ -3087,6 +3802,51 @@ function registerCommand(ctx, state, command) {
 	}
 	logger(ctx).warn(`[pi2dsh] command /${command.name} was not registered: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
 }
+/**
+* The session's current name: DSH's title when a title service is mounted,
+* this bridge's sidecar otherwise (and as the fallback for a session named
+* before the service was there).
+* @param ctx - the cordis context to resolve the optional service from.
+* @param state - runtime state holding the sidecar.
+* @param session - the live DSH session.
+*/
+function sessionNameOf(ctx, state, session) {
+	const title = optionalService(ctx, "sessionTitle")?.get(session)?.title;
+	return typeof title === "string" && title.length > 0 ? title : state.bridge.getName(session.id);
+}
+/**
+* Whether a human can actually answer a question right now.
+*
+* Two facts decide it, and the old check (`the service is mounted`) saw
+* neither: a headless composition mounts the service and registers NO
+* provider, and a delegated child agent has no human answerer at all — both
+* make every `ctx.ui.select/confirm/input` throw for a package that was told
+* `hasUI: true` and skipped its non-interactive path.
+*
+* The provider is a private field, but its existence is publicly observable:
+* DSH allows exactly one provider per context and refuses a second with
+* `DUPLICATE_PROVIDER`. So registering a probe answers the question — a
+* refusal means a real provider is there, and an acceptance means there was
+* none, which the immediate disposal restores.
+* @param userQuestions - the mounted question service, if any.
+* @param agent - the agent whose turn this context belongs to.
+*/
+function humanAnswererAvailable(userQuestions, agent) {
+	if (userQuestions === void 0) return false;
+	if (isSubagentOrigin(agent)) return false;
+	const service = userQuestions;
+	if (typeof service.registerProvider !== "function") return false;
+	let dispose;
+	try {
+		dispose = service.registerProvider({ ask: async () => {
+			throw new Error("pi2dsh probe provider");
+		} });
+	} catch {
+		return true;
+	}
+	dispose?.();
+	return false;
+}
 function requireSession(state, operation) {
 	const session = agentSession(currentAgent(state));
 	if (session === void 0) throw new Error(`pi2dsh: ${operation} requires one active DSH agent with a durable session`);
@@ -3135,7 +3895,8 @@ function createPiApi(ctx, state) {
 						providerConfig: value,
 						store: oauthStoreOf(state)
 					}),
-					warn: (message) => logger(ctx).warn(message)
+					warn: (message) => logger(ctx).warn(message),
+					resolveAttachments: () => optionalService(ctx, "attachments")
 				}
 			});
 			if (routeDisposer !== void 0) {
@@ -3190,8 +3951,7 @@ function createPiApi(ctx, state) {
 		},
 		sendMessage(message, options = {}) {
 			requireAgent(state, "sendMessage");
-			const mode = options.deliverAs === "steer" ? "steer" : options.deliverAs === "followUp" || options.deliverAs === "nextTurn" || options.triggerTurn === true ? "followup" : "inject";
-			return sendPiMessage(ctx, state, message.content, mode);
+			return sendPiMessage(ctx, state, message.content, deliveryMode(options), void 0, typeof message.customType === "string" ? message.customType : void 0);
 		},
 		sendUserMessage(content, options = {}) {
 			requireAgent(state, "sendUserMessage");
@@ -3203,15 +3963,17 @@ function createPiApi(ctx, state) {
 		},
 		setSessionName(name) {
 			const session = requireSession(state, "setSessionName");
-			state.bridge.setName(session.id, String(name));
+			const titles = optionalService(ctx, "sessionTitle");
+			if (titles !== void 0 && String(name).trim().length > 0) titles.rename(session, String(name));
+			else state.bridge.setName(session.id, String(name));
 			dispatch(state, "session_info_changed", {
 				type: "session_info_changed",
-				name: state.bridge.getName(session.id)
+				name: sessionNameOf(ctx, state, session)
 			}, contextFor(ctx, state, currentAgent(state), void 0)).catch((error) => logger(ctx).warn(`[pi2dsh] session_info_changed handler failed: ${String(error)}`));
 		},
 		getSessionName() {
 			const session = agentSession(currentAgent(state));
-			return session === void 0 ? void 0 : state.bridge.getName(session.id);
+			return session === void 0 ? void 0 : sessionNameOf(ctx, state, session);
 		},
 		setLabel(entryId, label) {
 			const session = requireSession(state, "setLabel");
@@ -3258,11 +4020,12 @@ function createPiApi(ctx, state) {
 				...typeof model?.id === "string" ? { model: model.id } : {}
 			};
 			if (override.model === void 0) return false;
+			const previousModel = currentPiModel(state, agent);
 			state.modelOverrides.set(agent, override);
 			dispatch(state, "model_select", {
 				type: "model_select",
 				model,
-				previousModel: state.modelOverrides.get(agent),
+				previousModel,
 				source: "set"
 			}, contextFor(ctx, state, agent, void 0)).catch((error) => logger(ctx).warn(`[pi2dsh] model_select handler failed: ${String(error)}`));
 			return true;
@@ -3460,6 +4223,12 @@ async function applyPiPackage(ctx, options) {
 		modelOverrides: /* @__PURE__ */ new WeakMap(),
 		thinkingLevels: /* @__PURE__ */ new WeakMap(),
 		turnSystemPromptOverrides: /* @__PURE__ */ new WeakMap(),
+		projection: Promise.resolve(),
+		terminateBatch: /* @__PURE__ */ new WeakMap(),
+		piTurnIndex: /* @__PURE__ */ new WeakMap(),
+		claimedForStep: /* @__PURE__ */ new WeakMap(),
+		promptedTurn: /* @__PURE__ */ new WeakMap(),
+		pendingInjections: /* @__PURE__ */ new WeakMap(),
 		globalThinkingLevel: "off",
 		argMutations: /* @__PURE__ */ new WeakMap(),
 		streamingTexts: /* @__PURE__ */ new Map(),
@@ -3520,7 +4289,7 @@ async function applyPiPackage(ctx, options) {
 		},
 		piContentToDsh: (content) => piToDshContent(ctx, content),
 		deliver: (agent, message, mode) => deliverAgentMessage(agent, message, mode),
-		messageFromSessionEvent,
+		messageFromSessionEvent: (event) => messageFromSessionEvent(ctx, event),
 		messageSource: state.messageSource,
 		packageName: state.packageName
 	}, subagentOptions));
@@ -3556,7 +4325,10 @@ async function applyPiPackage(ctx, options) {
 	logger(ctx).info(`[pi2dsh] loaded ${options.manifest.package.name}: ${state.tools.size} tools, ${state.commands.size} commands, ${options.manifest.skillDirs.length} skill roots${healthSuffix}`);
 }
 const runtimeInternals = {
+	compactionReason,
+	dshToPiContent,
 	expandPrompt,
+	isSubagentOrigin,
 	normalizeToolResult,
 	splitArguments,
 	textBlocks
@@ -3564,4 +4336,4 @@ const runtimeInternals = {
 //#endregion
 export { runtimeInternals as i, normalizeToolSchema as n, registerVisionCompanions as r, applyPiPackage as t };
 
-//# sourceMappingURL=runtime-Bh5k4Kjt.mjs.map
+//# sourceMappingURL=runtime-DsPaznXJ.mjs.map