@posthog/wizard 2.77.0 → 2.79.0

package/dist/{pi-mY8I2XkG.js → pi-BtqcLX3y.js}

@@ -1,11 +1,147 @@
-import { o as AgentSignals, s as REMARK_INSTRUCTION } from "./errors-BoJvrdw8.js";
-import { a as getLogFilePath, ht as WIZARD_USER_AGENT, p as getUI, pt as WIZARD_REMARK_EVENT_NAME, s as logToFile, vt as VERSION } from "./debug-B4kzIZPi.js";
-import { n as analytics } from "./analytics-C67F2vee.js";
-import { _ as buildGatewayProvider, g as GATEWAY_PROVIDER, m as assembleCommandments, p as AgentOutputSignals, v as withGatewayRemint } from "./agent-interface-Avtr_5M5.js";
-import { o as gatewayAuth } from "./gateway-session-xPFv6p5c.js";
+import { s as ErrorCodes, t as classifyRunFailure } from "./errors-ddDE6MbA.js";
+import { a as getLogFilePath, s as logToFile } from "./debug-Cj-8vfXY.js";
+import { t as VERSION } from "./version-Cadof0Z_.js";
+import { Q as WIZARD_USER_AGENT, Y as WIZARD_REMARK_EVENT_NAME } from "./constants-CuJfQEcC.js";
+import { n as analytics } from "./analytics-VRYdebXW.js";
+import { n as currentAccessToken } from "./oauth-session-CQTFOk-I.js";
+import { c as REMARK_INSTRUCTION, f as gatewayAuth, o as withGatewayRemint, r as buildGatewayProvider, s as AgentSignals, t as GATEWAY_PROVIDER } from "./gateway-CVU1G0H3.js";
+import { g as assembleCommandments, p as AgentOutputSignals } from "./agent-interface-BXvmAm4c.js";
 import fs from "fs";
 import path from "path";
-//#region src/lib/agent/aio-capture.ts
+function appendStatus(messages, message) {
+	if (messages.length > 0 && messages[messages.length - 1] === message) return messages;
+	return [...messages.slice(-9), message];
+}
+//#endregion
+//#region src/agent/runner/shared/progress-collector.ts
+/**
+* The agent's own record of what it reported.
+*
+* `runAgent` accumulates its final `RunSnapshot` here, independently of any
+* observer, so a missing or throwing `onProgress` never makes the result
+* incomplete. The emitter wraps the caller's callback: it applies the event
+* here first, then hands a copy to the observer, and logs rather than
+* propagates anything the observer throws.
+*/
+function createProgressCollector(onProgress) {
+	const snapshot = {
+		tasks: [],
+		statusMessages: [],
+		usage: {
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheCreationTokens: 0
+		}
+	};
+	const apply = (event) => {
+		switch (event.kind) {
+			case "tasks":
+				snapshot.tasks = event.tasks.map((t) => ({ ...t }));
+				break;
+			case "status":
+				snapshot.statusMessages = appendStatus(snapshot.statusMessages, event.message);
+				break;
+			case "stage":
+				snapshot.stage = event.stage;
+				break;
+			case "url":
+				if (event.which === "dashboard") snapshot.dashboardUrl = event.url;
+				else snapshot.notebookUrl = event.url;
+				break;
+			case "usage":
+				snapshot.usage.inputTokens += event.delta.inputTokens;
+				snapshot.usage.outputTokens += event.delta.outputTokens;
+				snapshot.usage.cacheReadTokens += event.delta.cacheReadTokens;
+				snapshot.usage.cacheCreationTokens += event.delta.cacheCreationTokens;
+				break;
+			case "finalCost":
+				snapshot.finalCostUsd = event.usd;
+				break;
+			case "handoff":
+				snapshot.handoffText = event.text;
+				break;
+			default: break;
+		}
+	};
+	const emit = (event) => {
+		apply(event);
+		if (!onProgress) return;
+		try {
+			const observed = onProgress(structuredClone(event));
+			if (observed && typeof observed.then === "function") Promise.resolve(observed).catch((error) => {
+				try {
+					logToFile(`[agent] progress observer rejected on ${event.kind}:`, error);
+				} catch {}
+			});
+		} catch (error) {
+			try {
+				logToFile(`[agent] progress observer threw on ${event.kind}:`, error instanceof Error ? error.message : error);
+			} catch {}
+		}
+	};
+	return {
+		emit,
+		snapshot: () => ({
+			...snapshot,
+			tasks: snapshot.tasks.map((t) => ({ ...t })),
+			statusMessages: [...snapshot.statusMessages],
+			usage: { ...snapshot.usage }
+		})
+	};
+}
+/** The run spinner as a progress emitter. One per run, like `getUI().spinner()`. */
+function createEmitSpinner(emit) {
+	return {
+		start: (message) => emit({
+			kind: "spinner",
+			action: "start",
+			message
+		}),
+		stop: (message) => emit({
+			kind: "spinner",
+			action: "stop",
+			message
+		}),
+		message: (message) => emit({
+			kind: "spinner",
+			action: "message",
+			message
+		})
+	};
+}
+/** `WizardUI.log` as a progress emitter. */
+function createEmitLog(emit) {
+	return {
+		info: (message) => emit({
+			kind: "log",
+			level: "info",
+			message
+		}),
+		warn: (message) => emit({
+			kind: "log",
+			level: "warn",
+			message
+		}),
+		error: (message) => emit({
+			kind: "log",
+			level: "error",
+			message
+		}),
+		success: (message) => emit({
+			kind: "log",
+			level: "success",
+			message
+		}),
+		step: (message) => emit({
+			kind: "log",
+			level: "step",
+			message
+		})
+	};
+}
+//#endregion
+//#region src/agent/aio-capture.ts
 /**
 * aio-capture — mirror wizard LLM calls into the authenticated project's
 * AI Observability tab as `$ai_generation` events. Gated on `--capture-aio`
@@ -35,7 +171,8 @@ const noop = (_) => void 0;
 const NOOP = {
 	setInitialPrompt: noop,
 	captureFromAnthropicSDKMessage: noop,
-	captureFromPiMessageEndEvent: noop
+	captureFromPiMessageEndEvent: noop,
+	finishPiRun: noop
 };
 function createAioCapture(args) {
 	if (!args.enabled || !args.projectApiKey || !args.apiHost) return NOOP;
@@ -139,7 +276,7 @@ function createAioCapture(args) {
 			cacheCreationTokens: e.message.usage?.cache_creation_input_tokens,
 			latencyMs,
 			generationId: e.message.id,
-			isError: false
+			isError: e.message.stopReason === "error" || e.message.stopReason === "aborted"
 		};
 	};
 	return {
@@ -191,15 +328,17 @@ function createAioCapture(args) {
 					});
 					lastAssistantContent = turn.outputChoices;
 				}
-				if (e?.type === "agent_end" && !e.willRetry) sendTraceEnd({ isError: false });
 			} catch (err) {
 				logToFile(`[aio-capture] pi compose failed: ${err instanceof Error ? err.message : String(err)}`);
 			}
+		},
+		finishPiRun(isError) {
+			sendTraceEnd({ isError });
 		}
 	};
 }
 //#endregion
-//#region src/lib/agent/runner/harness/pi/completion.ts
+//#region src/agent/runner/harness/pi/completion.ts
 /** Which completion guard should fail a pi run, or undefined for a clean finish. */
 function completionFailure(args) {
 	if (args.toolCalls === 0) return "WIZARD_NO_PROGRESS";
@@ -220,7 +359,61 @@ function runErrorType(message) {
 	return "WIZARD_API_ERROR";
 }
 //#endregion
-//#region src/lib/agent/runner/harness/pi/index.ts
+//#region src/agent/runner/harness/pi/cancellation.ts
+/** Bind a host signal to Pi's abort-and-wait-for-idle operation. */
+function bindPiCancellation(signal, session, onAbortError) {
+	let abortPromise;
+	const onAbort = () => {
+		abortPromise ??= Promise.resolve().then(() => session.abort()).catch((error) => {
+			try {
+				onAbortError?.(error);
+			} catch {}
+		});
+	};
+	signal?.addEventListener("abort", onAbort, { once: true });
+	if (signal?.aborted) onAbort();
+	return { async settle() {
+		signal?.removeEventListener("abort", onAbort);
+		await abortPromise;
+	} };
+}
+//#endregion
+//#region src/agent/runner/harness/pi/structured-output.ts
+/** Apply the output contract at the provider boundary on every agent turn. */
+function structuredOutputExtension(schema, api) {
+	return (pi) => {
+		pi.on("before_provider_request", (event) => {
+			const payload = event.payload;
+			const format = {
+				type: "json_schema",
+				schema
+			};
+			switch (api) {
+				case "anthropic-messages": return {
+					...payload,
+					output_config: {
+						...payload.output_config,
+						format
+					}
+				};
+				case "openai-responses": return {
+					...payload,
+					text: {
+						...payload.text,
+						format: {
+							...format,
+							name: "wizard_result",
+							strict: true
+						}
+					}
+				};
+				case "openai-completions": throw new Error("Structured output is not supported on Chat Completions");
+			}
+		});
+	};
+}
+//#endregion
+//#region src/agent/runner/harness/pi/index.ts
 /**
 * The `pi` backend — the challenger. Drives pi.dev's coding agent
 * (`@earendil-works/pi-coding-agent`) against the PostHog LLM gateway, behind
@@ -303,23 +496,39 @@ function withMode(tool, mode) {
 	tool.executionMode = mode;
 	return tool;
 }
-/** Pull plain text out of a pi AgentMessage (content is text/image blocks). */
-function extractText(message) {
+/**
+* The text blocks of a pi AgentMessage (content is text/image blocks). A
+* Responses model can send several message items in one turn, commentary
+* before its answer, and each becomes its own block.
+*/
+function textBlocks(message) {
 	const content = message?.content;
-	if (typeof content === "string") return content;
+	if (typeof content === "string") return [content];
 	if (Array.isArray(content)) return content.filter((c) => {
 		const block = c;
 		return block?.type === "text" && typeof block.text === "string";
-	}).map((c) => c.text).join("");
-	return "";
+	}).map((c) => c.text);
+	return [];
+}
+/** Pull plain text out of a pi AgentMessage. */
+function extractText(message) {
+	return textBlocks(message).join("");
 }
 /**
 * Surface `[DASHBOARD_URL]` / `[NOTEBOOK_URL]` markers the agent prints (after
 * the MCP creates them) into the outro link, mirroring the anthropic path's
 * signal parsing (#9). The marker carries the URL the MCP returned.
 */
-function applyOutroMarkers(textBlock) {
-	const markers = [[AgentSignals.DASHBOARD_URL, (url) => getUI().setDashboardUrl(url)], [AgentSignals.NOTEBOOK_URL, (url) => getUI().setNotebookUrl(url)]];
+function applyOutroMarkers(textBlock, emit) {
+	const markers = [[AgentSignals.DASHBOARD_URL, (url) => emit({
+		kind: "url",
+		which: "dashboard",
+		url
+	})], [AgentSignals.NOTEBOOK_URL, (url) => emit({
+		kind: "url",
+		which: "notebook",
+		url
+	})]];
 	for (const [marker, apply] of markers) {
 		const idx = textBlock.indexOf(marker);
 		if (idx === -1) continue;
@@ -351,21 +560,31 @@ function hasOpenTasks(store) {
 const piBackend = {
 	name: "pi",
 	async run(inputs) {
-		const { session, boot, prompt, spinner, config, programConfig } = inputs;
+		if (inputs.signal?.aborted) return {
+			kind: "abort",
+			classification: "WIZARD_ABORT",
+			message: "Agent run cancelled"
+		};
+		const { config: runConfig, input, boot, emit, prompt, spinner, structured } = inputs;
+		const config = runConfig.run;
 		const modelId = inputs.model;
+		const log = createEmitLog(emit);
 		const capture = createAioCapture({
-			enabled: session.captureAio,
+			enabled: input.flags.captureAio,
 			projectApiKey: boot.credentials.projectApiKey,
 			apiHost: boot.credentials.host.apiHost,
 			runTags: boot.wizardMetadata
 		});
-		getUI().log.step("Initializing Wizard agent...");
-		getUI().log.step(`Verbose logs: ${getLogFilePath()}`);
-		getUI().log.success("Agent initialized. Let's get cooking!");
+		if (!structured) {
+			log.step("Initializing Wizard agent...");
+			log.step(`Verbose logs: ${getLogFilePath()}`);
+			log.success("Agent initialized. Let's get cooking!");
+		}
 		spinner.start(config.spinnerMessage ?? "Customizing your PostHog setup...");
 		const startTime = Date.now();
 		const signals = new AgentOutputSignals();
 		let assistantTurns = 0;
+		let lastAssistantText = "";
 		let toolCalls = 0;
 		const runDurations = () => {
 			const durationMs = Date.now() - startTime;
@@ -379,9 +598,33 @@ const piBackend = {
 			...runDurations(),
 			model: modelId
 		});
+		const timedOutResult = (timeoutMs) => {
+			spinner.stop("Agent run timed out");
+			captureAborted("WIZARD_AGENTIC_DETECTION_TIMEOUT");
+			return {
+				kind: "failure",
+				classification: "WIZARD_AGENTIC_DETECTION_TIMEOUT",
+				message: `Agent run timed out after ${timeoutMs / 1e3}s`
+			};
+		};
+		let mcpCleanup;
+		let aioFailed = true;
+		let cancellation;
+		let timedOut = false;
+		let timeoutAbort;
+		let securityState;
+		const yaraViolationResult = () => {
+			spinner.stop("Security violation detected");
+			logToFile(`[pi] terminated: YARA violation (blocked ${securityState?.blockedCount} call(s))`);
+			captureAborted("WIZARD_YARA_VIOLATION");
+			return {
+				kind: "failure",
+				classification: "WIZARD_YARA_VIOLATION"
+			};
+		};
 		try {
 			const { createAgentSession, DefaultResourceLoader, SessionManager, AuthStorage, ModelRegistry, getAgentDir, createLsToolDefinition, createFindToolDefinition, createGrepToolDefinition, createBashToolDefinition, createReadToolDefinition, createEditToolDefinition, createWriteToolDefinition } = await import("@earendil-works/pi-coding-agent");
-			const refreshAuth = () => gatewayAuth(boot.credentials.host, boot.credentials.accessToken, boot.programId);
+			const refreshAuth = async () => gatewayAuth(boot.credentials.host, await currentAccessToken(boot.credentials), boot.programId);
 			const auth = await refreshAuth();
 			const providerInputs = (current) => ({
 				gatewayUrl: current.gatewayUrl,
@@ -392,34 +635,37 @@ const piBackend = {
 				modelId,
 				effort: inputs.thinkingLevel
 			});
-			const { provider, caps } = buildGatewayProvider(providerInputs(auth));
+			const { provider, caps, api } = buildGatewayProvider(providerInputs(auth));
 			const registry = ModelRegistry.inMemory(AuthStorage.create());
 			registry.registerProvider(GATEWAY_PROVIDER, provider);
 			const model = registry.find(GATEWAY_PROVIDER, modelId);
 			if (!model) return {
-				error: "WIZARD_API_ERROR",
+				kind: "failure",
+				classification: "WIZARD_API_ERROR",
 				message: "pi: gateway model could not be resolved"
 			};
 			const askState = { pending: false };
-			const { createSecurityExtension } = await import("./security-Dw2oFJjP.js");
+			const { createSecurityExtension, READ_ONLY_PI_TOOLS } = await import("./security-lkBwWbrK.js");
 			const security = createSecurityExtension({
-				disallowedTools: programConfig.disallowedTools,
+				readOnly: config.readOnly,
+				disallowedTools: runConfig.disallowedTools,
 				getWizardAskPending: () => askState.pending,
 				triageProvider: boot.triageProvider,
-				workingDirectory: session.installDir
+				workingDirectory: input.installDir
 			});
-			const { prewarmYaraScanner } = await import("./yara-hooks-CFY4pGcW.js");
+			securityState = security.state;
+			const { prewarmYaraScanner } = await import("./yara-hooks-B49RIk5d.js");
 			prewarmYaraScanner();
 			const extensionFactories = [security.factory];
-			let mcpCleanup;
 			let mcpInstructions;
 			let posthogMcp = false;
-			try {
-				const { setupPostHogMcp, fetchInstructions } = await import("./mcp-Cbuw_xss.js");
-				const instructionsPromise = fetchInstructions(boot.credentials.host.mcpUrl, boot.credentials.accessToken, WIZARD_USER_AGENT);
+			if (!config.readOnly) try {
+				const { setupPostHogMcp, fetchInstructions } = await import("./mcp-JcsBBnWv.js");
+				const mcpToken = await currentAccessToken(boot.credentials);
+				const instructionsPromise = fetchInstructions(boot.credentials.host.mcpUrl, mcpToken, WIZARD_USER_AGENT);
 				const mcp = await setupPostHogMcp({
 					mcpUrl: boot.credentials.host.mcpUrl,
-					accessToken: boot.credentials.accessToken,
+					accessToken: mcpToken,
 					userAgent: WIZARD_USER_AGENT
 				});
 				extensionFactories.push(mcp.extensionFactory);
@@ -427,6 +673,10 @@ const piBackend = {
 				mcpInstructions = await instructionsPromise;
 				posthogMcp = true;
 			} catch (err) {
+				try {
+					mcpCleanup?.();
+				} catch {}
+				mcpCleanup = void 0;
 				logToFile(`[pi] PostHog MCP setup skipped: ${String(err)}`);
 				analytics.wizardCapture("mcp setup failed", {
 					harness: "pi",
@@ -434,11 +684,12 @@ const piBackend = {
 					error: String(err).slice(0, 300)
 				});
 			}
+			if (structured) extensionFactories.push(structuredOutputExtension(structured.schema, api));
 			const resourceLoader = new DefaultResourceLoader({
-				cwd: session.installDir,
+				cwd: input.installDir,
 				agentDir: getAgentDir(),
 				systemPrompt: assembleCommandments({
-					program: programConfig.id,
+					program: runConfig.programId,
 					sequence: "linear",
 					harness: "pi",
 					caps: {
@@ -454,39 +705,43 @@ const piBackend = {
 				extensionFactories
 			});
 			await resourceLoader.reload();
-			const { createWizardPiTools } = await import("./tools-Dp6i9k70.js");
-			const { createWizardPiTaskTools } = await import("./tasks-D1c2z1aw.js");
-			const { createDispatchAgentTool } = await import("./subagent-Dz41vV9j.js");
-			const wizardTaskTools = createWizardPiTaskTools();
-			const scrubbedBash = withMode(createBashToolDefinition(session.installDir, { spawnHook: (ctx) => ({
+			const { createWizardPiTools } = await import("./tools-Cc41af5W.js");
+			const { createWizardPiTaskTools } = await import("./tasks-Bbv_lOBG.js");
+			const { createDispatchAgentTool } = await import("./subagent-Bfy0sfhU.js");
+			const wizardTaskTools = createWizardPiTaskTools((tasks) => emit({
+				kind: "tasks",
+				tasks
+			}));
+			const scrubbedBash = withMode(createBashToolDefinition(input.installDir, { spawnHook: (ctx) => ({
 				...ctx,
 				env: buildScrubbedEnv()
 			}) }), "sequential");
 			const customTools = [
-				withMode(createReadToolDefinition(session.installDir), "parallel"),
-				withMode(createEditToolDefinition(session.installDir), "sequential"),
-				withMode(createWriteToolDefinition(session.installDir), "sequential"),
+				withMode(createReadToolDefinition(input.installDir), "parallel"),
+				withMode(createEditToolDefinition(input.installDir), "sequential"),
+				withMode(createWriteToolDefinition(input.installDir), "sequential"),
 				scrubbedBash,
-				withMode(createLsToolDefinition(session.installDir), "parallel"),
-				withMode(createFindToolDefinition(session.installDir), "parallel"),
-				withMode(createGrepToolDefinition(session.installDir), "parallel"),
+				withMode(createLsToolDefinition(input.installDir), "parallel"),
+				withMode(createFindToolDefinition(input.installDir), "parallel"),
+				withMode(createGrepToolDefinition(input.installDir), "parallel"),
 				...createWizardPiTools({
-					workingDirectory: session.installDir,
+					workingDirectory: input.installDir,
 					skillsBaseUrl: boot.skillsBaseUrl,
 					triageProvider: boot.triageProvider,
+					emit,
 					detectPackageManager: config.detectPackageManager,
 					askBridge: inputs.askBridge,
 					maxQuestions: config.maxQuestions,
 					onAskPendingChange: (pending) => {
 						askState.pending = pending;
 					},
-					disallowedTools: programConfig.disallowedTools
+					disallowedTools: runConfig.disallowedTools
 				}),
 				...wizardTaskTools.tools,
 				createDispatchAgentTool({
 					model,
 					modelRegistry: registry,
-					cwd: session.installDir,
+					cwd: input.installDir,
 					agentDir: getAgentDir(),
 					securityFactory: security.factory,
 					bashTool: scrubbedBash,
@@ -496,19 +751,23 @@ const piBackend = {
 						SessionManager
 					}
 				})
-			];
+			].filter((tool) => !config.readOnly || READ_ONLY_PI_TOOLS.has(tool.name));
 			const { session: agentSession } = await createAgentSession({
 				model,
 				modelRegistry: registry,
 				thinkingLevel: caps.thinkingLevel,
-				cwd: session.installDir,
-				sessionManager: SessionManager.inMemory(session.installDir),
+				cwd: input.installDir,
+				sessionManager: SessionManager.inMemory(input.installDir),
 				resourceLoader,
 				noTools: "builtin",
 				customTools
 			});
+			cancellation = bindPiCancellation(inputs.signal, agentSession, (error) => {
+				logToFile(`[pi] abort failed: ${String(error)}`);
+			});
 			await agentSession.bindExtensions({});
 			const turns = withGatewayRemint({
+				signal: inputs.signal,
 				session: agentSession,
 				registry,
 				auth,
@@ -527,13 +786,25 @@ const piBackend = {
 						if (event.message?.role !== "assistant") break;
 						assistantTurns += 1;
 						turns.noteAssistantTurn(event.message);
-						const assistant = extractText(event.message).trim();
+						const blocks = textBlocks(event.message);
+						const assistant = blocks.join("").trim();
+						lastAssistantText = (blocks.at(-1) ?? "").trim();
+						if (structured) inputs.middleware?.onMessage({
+							type: "assistant",
+							message: { content: blocks.map((text) => ({
+								type: "text",
+								text
+							})) }
+						});
 						if (assistant) {
 							logToFile(`[pi] assistant: ${assistant.slice(0, 1e3)}`);
-							applyOutroMarkers(assistant);
+							applyOutroMarkers(assistant, emit);
 							const statusText = lastStatusLine(assistant);
 							if (statusText) {
-								getUI().pushStatus(statusText);
+								emit({
+									kind: "status",
+									message: statusText
+								});
 								spinner.message(statusText);
 							}
 							for (const line of assistant.split("\n")) signals.push(line);
@@ -544,6 +815,14 @@ const piBackend = {
 						toolCalls += 1;
 						const args = JSON.stringify(event.args ?? {}).slice(0, 200);
 						logToFile(`[pi] → ${event.toolName} ${args}`);
+						if (structured) inputs.middleware?.onMessage({
+							type: "assistant",
+							message: { content: [{
+								type: "tool_use",
+								name: event.toolName,
+								input: event.args
+							}] }
+						});
 						break;
 					}
 					case "tool_execution_end":
@@ -556,30 +835,68 @@ const piBackend = {
 				}
 			});
 			capture.setInitialPrompt(prompt);
+			let terminal = turns.terminalFailure();
+			const timeout = structured && setTimeout(() => {
+				timedOut = true;
+				timeoutAbort = agentSession.abort().catch((error) => {
+					logToFile(`[pi] timeout abort failed: ${String(error)}`);
+				});
+			}, structured.timeoutMs);
 			try {
+				if (inputs.signal?.aborted) return {
+					kind: "abort",
+					classification: "WIZARD_ABORT",
+					message: "Agent run cancelled"
+				};
 				await turns.prompt(prompt);
+				terminal = turns.terminalFailure();
 				let continueNudges = 0;
-				while (continueNudges < MAX_CONTINUE_NUDGES && !security.state.criticalViolation && hasOpenTasks(wizardTaskTools.store)) {
+				while (!structured && continueNudges < MAX_CONTINUE_NUDGES && !security.state.criticalViolation && !inputs.signal?.aborted && !terminal && hasOpenTasks(wizardTaskTools.store)) {
 					continueNudges += 1;
 					logToFile(`[pi] completion guard: tasks still open, nudge ${continueNudges}/${MAX_CONTINUE_NUDGES}`);
 					await turns.prompt(CONTINUE_INSTRUCTION);
+					terminal = turns.terminalFailure();
 				}
-				if (!security.state.criticalViolation) try {
+				if (!structured && !security.state.criticalViolation && !terminal && !inputs.signal?.aborted) try {
 					await agentSession.prompt(REMARK_INSTRUCTION);
 				} catch (err) {
 					logToFile(`[pi] remark request failed: ${String(err)}`);
 				}
 			} finally {
-				unsubscribe();
-				mcpCleanup?.();
+				if (timeout) clearTimeout(timeout);
+				try {
+					unsubscribe();
+				} catch {}
 			}
-			if (security.state.criticalViolation) {
-				spinner.stop("Security violation detected");
-				logToFile(`[pi] terminated: YARA violation (blocked ${security.state.blockedCount} call(s))`);
-				captureAborted("WIZARD_YARA_VIOLATION");
-				return { error: "WIZARD_YARA_VIOLATION" };
+			if (inputs.signal?.aborted) return {
+				kind: "abort",
+				classification: "WIZARD_ABORT",
+				message: "Agent run cancelled"
+			};
+			if (timedOut && structured && !security.state.criticalViolation) return timedOutResult(structured.timeoutMs);
+			if (terminal && !security.state.criticalViolation) {
+				spinner.stop(config.errorMessage ?? `${config.integrationLabel} failed`);
+				captureAborted(terminal.classification);
+				if (terminal.status === 401) return {
+					kind: "decided_failure",
+					failure: {
+						code: ErrorCodes.AuthInvalidOrExpired,
+						message: "Authentication failed (401)",
+						detail: { providerMessage: terminal.message }
+					}
+				};
+				return terminal.classification === "WIZARD_ABORT" ? {
+					kind: "abort",
+					classification: "WIZARD_ABORT",
+					message: terminal.message
+				} : {
+					kind: "failure",
+					classification: terminal.classification,
+					message: terminal.message
+				};
 			}
-			const openTasks = hasOpenTasks(wizardTaskTools.store);
+			if (security.state.criticalViolation) return yaraViolationResult();
+			const openTasks = !structured && hasOpenTasks(wizardTaskTools.store);
 			const failure = completionFailure({
 				toolCalls,
 				openTasks
@@ -588,23 +905,30 @@ const piBackend = {
 				spinner.stop("Agent made no changes");
 				logToFile(`[pi] no progress: ${assistantTurns} assistant turn(s), 0 tool calls`);
 				analytics.wizardCapture("agent no progress", { assistant_turns: assistantTurns });
-				captureAborted(failure);
-				return { error: failure };
+				const classification = structured ? "WIZARD_INVALID_STRUCTURED_OUTPUT" : failure;
+				captureAborted(classification);
+				return {
+					kind: "failure",
+					classification
+				};
 			}
 			if (failure === "WIZARD_INCOMPLETE_TASKS") {
 				spinner.stop("Agent stopped before finishing");
 				logToFile("[pi] incomplete: tasks left open");
 				analytics.wizardCapture("agent incomplete tasks", { open_tasks: true });
 				captureAborted(failure);
-				return { error: failure };
+				return {
+					kind: "failure",
+					classification: failure
+				};
 			}
 			const remark = signals.remark();
 			if (remark) analytics.capture(WIZARD_REMARK_EVENT_NAME, { remark });
 			const skillFailure = signals.skillInstallFailure();
 			if (skillFailure !== void 0) analytics.wizardCapture("agent continued without skill", { detail: skillFailure });
 			try {
-				const planFile = path.join(session.installDir, ".posthog-events.json");
-				if (fs.existsSync(planFile)) await fs.promises.rm(planFile);
+				const planFile = path.join(input.installDir, ".posthog-events.json");
+				if (!structured && fs.existsSync(planFile)) await fs.promises.rm(planFile);
 			} catch (err) {
 				logToFile(`[pi] .posthog-events.json cleanup skipped: ${String(err)}`);
 			}
@@ -619,26 +943,65 @@ const piBackend = {
 				cache_read_input_tokens: stats.tokens.cacheRead
 			});
 			spinner.stop(config.successMessage ?? "PostHog integration complete");
-			return {};
+			aioFailed = false;
+			if (!structured) return { kind: "success" };
+			try {
+				return {
+					kind: "success",
+					structuredOutput: JSON.parse(lastAssistantText)
+				};
+			} catch {
+				return { kind: "success" };
+			}
 		} catch (err) {
+			if (inputs.signal?.aborted) return {
+				kind: "abort",
+				classification: "WIZARD_ABORT",
+				message: "Agent run cancelled"
+			};
+			if (securityState?.criticalViolation) return yaraViolationResult();
+			if (timedOut && structured) return timedOutResult(structured.timeoutMs);
 			const message = err instanceof Error ? err.message : String(err);
 			logToFile(`[pi] run error: ${message}`);
 			spinner.stop(config.errorMessage ?? `${config.integrationLabel} failed`);
-			getUI().log.error(`pi backend error: ${message}`);
-			const error = runErrorType(message);
-			captureAborted(error);
+			log.error(`pi backend error: ${message}`);
+			const coded = classifyRunFailure(err);
+			if (coded.coded && err instanceof Error) {
+				captureAborted("WIZARD_API_ERROR");
+				return {
+					kind: "decided_failure",
+					failure: {
+						code: coded.code,
+						message: coded.message,
+						error: err
+					}
+				};
+			}
+			const classification = runErrorType(message);
+			captureAborted(classification);
 			return {
-				error,
-				message
+				kind: "failure",
+				classification,
+				message,
+				error: err instanceof Error ? err : void 0
 			};
+		} finally {
+			await cancellation?.settle();
+			await timeoutAbort;
+			try {
+				mcpCleanup?.();
+			} catch {}
+			try {
+				capture.finishPiRun(aioFailed);
+			} catch {}
 		}
 	},
 	async runTask(inputs) {
-		const { runPiTask } = await import("./task-5-fw_Vw3.js");
+		const { runPiTask } = await import("./task-BOfw7GPc.js");
 		return runPiTask(inputs);
 	}
 };
 //#endregion
-export { piBackend as a, createAioCapture as c, lastStatusLine as i, buildScrubbedEnv as n, withMode as o, extractText as r, runErrorType as s, applyOutroMarkers as t };
+export { piBackend as a, runErrorType as c, createEmitSpinner as d, createProgressCollector as f, lastStatusLine as i, createAioCapture as l, buildScrubbedEnv as n, withMode as o, appendStatus as p, extractText as r, bindPiCancellation as s, applyOutroMarkers as t, createEmitLog as u };
 
-//# sourceMappingURL=pi-mY8I2XkG.js.map
+//# sourceMappingURL=pi-BtqcLX3y.js.map