@posthog/wizard 2.77.0 → 2.78.0

package/dist/{pi-mY8I2XkG.js → pi-D3h5Ok0i.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 { a as AgentSignals, d as ErrorCodes, o as REMARK_INSTRUCTION, t as classifyRunFailure } from "./errors-CQ9kttJD.js";
+import { a as getLogFilePath, s as logToFile } from "./debug-Ch4BDOtD.js";
+import { t as VERSION } from "./version-aXxpgRKx.js";
+import { Q as WIZARD_USER_AGENT, Y as WIZARD_REMARK_EVENT_NAME } from "./constants-jFI2SaE1.js";
+import { n as analytics } from "./analytics-CHCZ_qUR.js";
+import { n as currentAccessToken } from "./oauth-session-DJ8h6GFa.js";
+import { l as gatewayAuth, o as withGatewayRemint, r as buildGatewayProvider, t as GATEWAY_PROVIDER } from "./gateway-CjoShdLa.js";
+import { g as assembleCommandments, p as AgentOutputSignals } from "./agent-interface-BAOIHuXS.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,26 @@ 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/index.ts
 /**
 * The `pi` backend — the challenger. Drives pi.dev's coding agent
 * (`@earendil-works/pi-coding-agent`) against the PostHog LLM gateway, behind
@@ -318,8 +476,16 @@ function extractText(message) {
 * 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,17 +517,24 @@ 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 } = 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!");
+		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();
@@ -379,9 +552,12 @@ const piBackend = {
 			...runDurations(),
 			model: modelId
 		});
+		let mcpCleanup;
+		let aioFailed = true;
+		let cancellation;
 		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,
@@ -397,29 +573,30 @@ const piBackend = {
 			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 } = await import("./security-Cg_4a7vB.js");
 			const security = createSecurityExtension({
-				disallowedTools: programConfig.disallowedTools,
+				disallowedTools: runConfig.disallowedTools,
 				getWizardAskPending: () => askState.pending,
 				triageProvider: boot.triageProvider,
-				workingDirectory: session.installDir
+				workingDirectory: input.installDir
 			});
-			const { prewarmYaraScanner } = await import("./yara-hooks-CFY4pGcW.js");
+			const { prewarmYaraScanner } = await import("./yara-hooks-DSGuCU9A.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);
+				const { setupPostHogMcp, fetchInstructions } = await import("./mcp-DAgaoGk5.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 +604,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",
@@ -435,10 +616,10 @@ const piBackend = {
 				});
 			}
 			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 +635,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-Dyfh9aCD.js");
+			const { createWizardPiTaskTools } = await import("./tasks-Bbv_lOBG.js");
+			const { createDispatchAgentTool } = await import("./subagent-BofIDK-O.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,
@@ -501,14 +686,18 @@ const piBackend = {
 				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,
@@ -530,10 +719,13 @@ const piBackend = {
 						const assistant = extractText(event.message).trim();
 						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);
@@ -556,28 +748,66 @@ const piBackend = {
 				}
 			});
 			capture.setInitialPrompt(prompt);
+			let terminal = turns.terminalFailure();
 			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 (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 (!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?.();
+				try {
+					unsubscribe();
+				} catch {}
+			}
+			if (inputs.signal?.aborted) return {
+				kind: "abort",
+				classification: "WIZARD_ABORT",
+				message: "Agent run cancelled"
+			};
+			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
+				};
 			}
 			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" };
+				return {
+					kind: "failure",
+					classification: "WIZARD_YARA_VIOLATION"
+				};
 			}
 			const openTasks = hasOpenTasks(wizardTaskTools.store);
 			const failure = completionFailure({
@@ -589,21 +819,27 @@ const piBackend = {
 				logToFile(`[pi] no progress: ${assistantTurns} assistant turn(s), 0 tool calls`);
 				analytics.wizardCapture("agent no progress", { assistant_turns: assistantTurns });
 				captureAborted(failure);
-				return { error: failure };
+				return {
+					kind: "failure",
+					classification: failure
+				};
 			}
 			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");
+				const planFile = path.join(input.installDir, ".posthog-events.json");
 				if (fs.existsSync(planFile)) await fs.promises.rm(planFile);
 			} catch (err) {
 				logToFile(`[pi] .posthog-events.json cleanup skipped: ${String(err)}`);
@@ -619,26 +855,54 @@ const piBackend = {
 				cache_read_input_tokens: stats.tokens.cacheRead
 			});
 			spinner.stop(config.successMessage ?? "PostHog integration complete");
-			return {};
+			aioFailed = false;
+			return { kind: "success" };
 		} catch (err) {
+			if (inputs.signal?.aborted) return {
+				kind: "abort",
+				classification: "WIZARD_ABORT",
+				message: "Agent run cancelled"
+			};
 			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();
+			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-r9t1UhQP.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-D3h5Ok0i.js.map