@posthog/wizard 2.52.1 → 2.54.0

package/dist/pi-CfdqOKDI.js

@@ -0,0 +1,611 @@
+import { a as getLogFilePath, f as getUI, ft as WIZARD_USER_AGENT, ht as VERSION, s as logToFile, ut as WIZARD_REMARK_EVENT_NAME } from "./debug-CbgLkSCY.js";
+import { n as analytics } from "./analytics-D7hsukY7.js";
+import { M as GATEWAY_PROVIDER, N as buildGatewayProvider, f as AgentOutputSignals, h as assembleCommandments, m as REMARK_INSTRUCTION, p as AgentSignals } from "./agent-interface-CLvG6Rk9.js";
+import fs from "fs";
+import path from "path";
+//#region src/lib/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`
+* (dev/test builds only); returns a no-op instance when disabled so the
+* wire-in points stay a no-op with zero overhead.
+*
+* The wizard's LLM calls happen inside subprocesses we don't own (the
+* claude-agent-sdk CLI on the anthropic path, pi's own runtime on pi), so we
+* can't wrap the client with `posthog-node`'s `wrapAnthropic`. Instead, each
+* harness surfaces assistant turns on the way back — the SDK message stream
+* on anthropic, `agentSession.subscribe(message_end)` on pi — and this module
+* composes an `$ai_generation` event from either shape.
+*
+* For the Conversation tab in AIO to render anything, each generation needs
+* `$ai_input` (the messages the model saw when it produced this turn). The
+* initial prompt is passed to the SDK subprocess and never echoed back on
+* the stream, so callers must hand it to `setInitialPrompt` before the run
+* starts. From there we track user/assistant turns as they flow through the
+* stream, snapshotting the running conversation into each generation's
+* `$ai_input` and firing `$ai_input_state` / `$ai_output_state` on the
+* terminal `$ai_trace` event.
+*
+* POSTs are fire-and-forget: failures are debug-logged and never surfaced to
+* the main agent flow. Losing an AIO event must never break a run.
+*/
+const noop = (_) => void 0;
+const NOOP = {
+	setInitialPrompt: noop,
+	captureFromAnthropicSDKMessage: noop,
+	captureFromPiMessageEndEvent: noop
+};
+function createAioCapture(args) {
+	if (!args.enabled || !args.projectApiKey || !args.apiHost) return NOOP;
+	const { projectApiKey, apiHost, runTags } = args;
+	const distinctId = `wizard-cli-${VERSION}`;
+	const captureUrl = `${apiHost.replace(/\/$/, "")}/capture/`;
+	const runStartAt = Date.now();
+	let prevTurnAt = runStartAt;
+	let traceEnded = false;
+	let initialPrompt;
+	let conversation = [];
+	let lastAssistantContent;
+	const postEvent = (event, properties) => {
+		const body = {
+			api_key: projectApiKey,
+			event,
+			distinct_id: distinctId,
+			properties: {
+				$ai_trace_id: runTags.run_id ?? "",
+				...runTags,
+				...properties
+			},
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		fetch(captureUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		}).then((res) => {
+			if (!res.ok) logToFile(`[aio-capture] POST failed status=${res.status}`);
+		}).catch((err) => {
+			logToFile(`[aio-capture] POST error: ${err instanceof Error ? err.message : String(err)}`);
+		});
+	};
+	const postGeneration = (turn) => {
+		postEvent("$ai_generation", {
+			$ai_provider: turn.provider,
+			$ai_model: turn.model,
+			$ai_input: turn.input,
+			$ai_output_choices: turn.outputChoices,
+			$ai_input_tokens: turn.inputTokens ?? 0,
+			$ai_output_tokens: turn.outputTokens ?? 0,
+			$ai_cache_read_input_tokens: turn.cacheReadTokens ?? 0,
+			$ai_cache_creation_input_tokens: turn.cacheCreationTokens ?? 0,
+			$ai_latency: turn.latencyMs / 1e3,
+			$ai_generation_id: turn.generationId ?? "",
+			$ai_is_error: turn.isError
+		});
+	};
+	const sendTraceEnd = (opts) => {
+		if (traceEnded) return;
+		traceEnded = true;
+		postEvent("$ai_trace", {
+			$ai_span_name: runTags.program_id ?? "wizard-run",
+			$ai_latency: (Date.now() - runStartAt) / 1e3,
+			$ai_is_error: opts.isError,
+			$ai_input_state: initialPrompt ? [{
+				role: "user",
+				content: [{
+					type: "text",
+					text: initialPrompt
+				}]
+			}] : [],
+			$ai_output_state: lastAssistantContent ?? []
+		});
+	};
+	const anthropicAssistantTurn = (msg) => {
+		const m = msg;
+		if (m?.type !== "assistant" || !m.message) return null;
+		const now = Date.now();
+		const latencyMs = now - prevTurnAt;
+		prevTurnAt = now;
+		return {
+			provider: "anthropic",
+			model: m.message.model ?? "unknown",
+			input: [...conversation],
+			outputChoices: Array.isArray(m.message.content) ? m.message.content : [],
+			inputTokens: m.message.usage?.input_tokens,
+			outputTokens: m.message.usage?.output_tokens,
+			cacheReadTokens: m.message.usage?.cache_read_input_tokens,
+			cacheCreationTokens: m.message.usage?.cache_creation_input_tokens,
+			latencyMs,
+			generationId: m.message.id,
+			isError: false
+		};
+	};
+	const piAssistantTurn = (event) => {
+		const e = event;
+		if (e?.type !== "message_end" || e.message?.role !== "assistant") return null;
+		const now = Date.now();
+		const latencyMs = now - prevTurnAt;
+		prevTurnAt = now;
+		return {
+			provider: "anthropic",
+			model: e.message.model ?? "unknown",
+			input: [...conversation],
+			outputChoices: Array.isArray(e.message.content) ? e.message.content : [],
+			inputTokens: e.message.usage?.input_tokens,
+			outputTokens: e.message.usage?.output_tokens,
+			cacheReadTokens: e.message.usage?.cache_read_input_tokens,
+			cacheCreationTokens: e.message.usage?.cache_creation_input_tokens,
+			latencyMs,
+			generationId: e.message.id,
+			isError: false
+		};
+	};
+	return {
+		setInitialPrompt(prompt) {
+			initialPrompt = prompt;
+			conversation = [{
+				role: "user",
+				content: [{
+					type: "text",
+					text: prompt
+				}]
+			}];
+			lastAssistantContent = void 0;
+		},
+		captureFromAnthropicSDKMessage(msg) {
+			try {
+				const m = msg;
+				if (m?.type === "user" && m.message) conversation.push({
+					role: "user",
+					content: m.message.content ?? []
+				});
+				const turn = anthropicAssistantTurn(msg);
+				if (turn) {
+					postGeneration(turn);
+					conversation.push({
+						role: "assistant",
+						content: turn.outputChoices
+					});
+					lastAssistantContent = turn.outputChoices;
+				}
+				if (m?.type === "result") sendTraceEnd({ isError: !!m.is_error });
+			} catch (err) {
+				logToFile(`[aio-capture] anthropic compose failed: ${err instanceof Error ? err.message : String(err)}`);
+			}
+		},
+		captureFromPiMessageEndEvent(event) {
+			try {
+				const e = event;
+				if (e?.type === "message_end" && e.message?.role === "user" && e.message) conversation.push({
+					role: "user",
+					content: e.message.content ?? []
+				});
+				const turn = piAssistantTurn(event);
+				if (turn) {
+					postGeneration(turn);
+					conversation.push({
+						role: "assistant",
+						content: turn.outputChoices
+					});
+					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)}`);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/lib/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";
+	if (args.openTasks) return "WIZARD_INCOMPLETE_TASKS";
+}
+//#endregion
+//#region src/lib/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
+* `wizard-orchestrator`. It owns the agent loop and model transport; prompt
+* assembly, error routing, and the outro stay in `linear.ts`, shared with the
+* `anthropic` control.
+*
+* Transport: the gateway is registered as an `anthropic-messages` provider
+* (same protocol the claude-agent-sdk path uses), bearer auth, Bedrock-fallback
+* + wizard metadata/flag headers, model id matched to `anthropic` for a clean
+* A/B. Security parity (canUseTool + YARA) and skills/MCP discovery are
+* follow-ups (#525, #524 skills) — v1 uses pi's built-in coding tools.
+*/
+/** Injects the MCP server `instructions` pi-mcp-adapter drops (project env, skill steer, tool domains) into the system prompt, falling back to a bootstrap-derived project block when the warm-connect captured none. */
+function piMcpContext(boot, instructions) {
+	if (instructions) return [
+		"",
+		"## PostHog MCP server",
+		instructions
+	].join("\n");
+	return [
+		"",
+		"## PostHog project",
+		"Your `posthog_exec` calls run against this project:",
+		`- Project: ${boot.project?.name ? `${boot.project.name} (id ${boot.credentials.projectId})` : `id ${boot.credentials.projectId}`}`,
+		`- Host: ${boot.credentials.host.apiHost}`,
+		`- Region: ${boot.credentials.host.region}`
+	].join("\n");
+}
+/**
+* The ONLY environment variables pi's tool subprocesses (bash → npm/pip/…) are
+* allowed to see. Everything else — every secret (POSTHOG_PERSONAL_API_KEY,
+* ANTHROPIC_*, AWS_*), every ambient credential, the parent process's whole env
+* — is dropped before a child is spawned. pi's own gateway auth is programmatic
+* (the access token never lives in env), so a minimal env costs the agent
+* nothing while closing the leak that exposed the key before. Kept to what a
+* package manager genuinely needs to run.
+*/
+const ALLOWED_SUBPROCESS_ENV_KEYS = [
+	"PATH",
+	"HOME",
+	"SHELL",
+	"USER",
+	"LOGNAME",
+	"TMPDIR",
+	"TMP",
+	"TEMP",
+	"TERM",
+	"LANG",
+	"LC_ALL",
+	"LC_CTYPE",
+	"NODE_EXTRA_CA_CERTS",
+	"SSL_CERT_FILE",
+	"SSL_CERT_DIR",
+	"HTTP_PROXY",
+	"HTTPS_PROXY",
+	"NO_PROXY",
+	"http_proxy",
+	"https_proxy",
+	"no_proxy"
+];
+/** A fresh subprocess env holding only the allowlisted keys present in process.env. */
+function buildScrubbedEnv() {
+	const env = {};
+	for (const key of ALLOWED_SUBPROCESS_ENV_KEYS) {
+		const value = process.env[key];
+		if (value !== void 0) env[key] = value;
+	}
+	return env;
+}
+/**
+* Tag a tool with an execution mode (mutates + returns it). Read-only tools are
+* `parallel` so a single turn that batches independent reads/searches runs them
+* at once; mutating/install tools are `sequential` so a batch never races writes
+* or concurrent installs. pi-agent-core runs a batch in parallel only when no
+* tool in it is `sequential`.
+*/
+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) {
+	const content = message?.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 "";
+}
+/**
+* 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)]];
+	for (const [marker, apply] of markers) {
+		const idx = textBlock.indexOf(marker);
+		if (idx === -1) continue;
+		const url = textBlock.slice(idx + marker.length).trim().split(/\s/)[0];
+		if (url) apply(url);
+	}
+}
+/**
+* The text of the last `[STATUS] …` line in a block, if any. Last wins so the
+* spinner shows the most recent action when a turn prints several.
+*/
+function lastStatusLine(textBlock) {
+	let status;
+	for (const line of textBlock.split("\n")) {
+		const idx = line.indexOf(AgentSignals.STATUS);
+		if (idx !== -1) status = line.slice(idx + AgentSignals.STATUS.length).trim();
+	}
+	return status || void 0;
+}
+/** Cap on completion-guard re-prompts while tasks remain open (see the run loop). */
+const MAX_CONTINUE_NUDGES = 20;
+/** Nudge re-sent when the agent stops early with tasks still open. */
+const CONTINUE_INSTRUCTION = "You still have open tasks in your list (not all are marked `completed`). Do not stop — pick up the next `in_progress` or `pending` task and keep working until every task is `completed`. Continue now.";
+/** True while any task in the store is not yet `completed`. */
+function hasOpenTasks(store) {
+	for (const t of store.values()) if (t.status !== "completed") return true;
+	return false;
+}
+const piBackend = {
+	name: "pi",
+	async run(inputs) {
+		const { session, boot, prompt, spinner, config, programConfig } = inputs;
+		const modelId = inputs.model;
+		const capture = createAioCapture({
+			enabled: session.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!");
+		spinner.start(config.spinnerMessage ?? "Customizing your PostHog setup...");
+		const startTime = Date.now();
+		const signals = new AgentOutputSignals();
+		let assistantTurns = 0;
+		let toolCalls = 0;
+		const runDurations = () => {
+			const durationMs = Date.now() - startTime;
+			return {
+				duration_ms: durationMs,
+				duration_seconds: Math.round(durationMs / 1e3)
+			};
+		};
+		const captureAborted = () => analytics.wizardCapture("agent aborted", {
+			...runDurations(),
+			model: modelId
+		});
+		try {
+			const { createAgentSession, DefaultResourceLoader, SessionManager, AuthStorage, ModelRegistry, getAgentDir, createLsToolDefinition, createFindToolDefinition, createGrepToolDefinition, createBashToolDefinition, createReadToolDefinition, createEditToolDefinition, createWriteToolDefinition } = await import("@earendil-works/pi-coding-agent");
+			const { provider, caps } = buildGatewayProvider({
+				gatewayUrl: boot.credentials.host.gatewayUrl,
+				accessToken: boot.credentials.accessToken,
+				wizardMetadata: boot.wizardMetadata,
+				wizardFlags: boot.wizardFlags,
+				modelId,
+				effort: inputs.thinkingLevel
+			});
+			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",
+				message: "pi: gateway model could not be resolved"
+			};
+			const askState = { pending: false };
+			const { createSecurityExtension } = await import("./security-BNqgFjYh.js");
+			const security = createSecurityExtension({
+				disallowedTools: programConfig.disallowedTools,
+				getWizardAskPending: () => askState.pending,
+				triageProvider: boot.triageProvider,
+				workingDirectory: session.installDir
+			});
+			const { prewarmYaraScanner } = await import("./yara-hooks--QA2Cwjv.js");
+			prewarmYaraScanner();
+			const extensionFactories = [security.factory];
+			let mcpCleanup;
+			let mcpInstructions;
+			try {
+				const { setupPostHogMcp, fetchInstructions } = await import("./mcp-jKHwa45f.js");
+				const instructionsPromise = fetchInstructions(boot.credentials.host.mcpUrl, boot.credentials.accessToken, WIZARD_USER_AGENT);
+				const mcp = await setupPostHogMcp({
+					mcpUrl: boot.credentials.host.mcpUrl,
+					accessToken: boot.credentials.accessToken,
+					userAgent: WIZARD_USER_AGENT
+				});
+				extensionFactories.push(mcp.extensionFactory);
+				mcpCleanup = mcp.cleanup;
+				mcpInstructions = await instructionsPromise;
+			} catch (err) {
+				logToFile(`[pi] PostHog MCP setup skipped: ${String(err)}`);
+				analytics.wizardCapture("mcp setup failed", {
+					harness: "pi",
+					scope: "run",
+					error: String(err).slice(0, 300)
+				});
+			}
+			const resourceLoader = new DefaultResourceLoader({
+				cwd: session.installDir,
+				agentDir: getAgentDir(),
+				systemPrompt: assembleCommandments({
+					program: programConfig.id,
+					sequence: "linear",
+					harness: "pi",
+					caps: {
+						bash: true,
+						posthogMcp: true
+					}
+				}) + "\n" + piMcpContext(boot, mcpInstructions),
+				noExtensions: true,
+				noSkills: true,
+				noContextFiles: true,
+				noPromptTemplates: true,
+				noThemes: true,
+				extensionFactories
+			});
+			await resourceLoader.reload();
+			const { createWizardPiTools } = await import("./tools-Br8lP29r.js");
+			const { createWizardPiTaskTools } = await import("./tasks-yqJVuTvc.js");
+			const { createDispatchAgentTool } = await import("./subagent-CKNbRtfQ.js");
+			const wizardTaskTools = createWizardPiTaskTools();
+			const scrubbedBash = withMode(createBashToolDefinition(session.installDir, { spawnHook: (ctx) => ({
+				...ctx,
+				env: buildScrubbedEnv()
+			}) }), "sequential");
+			const customTools = [
+				withMode(createReadToolDefinition(session.installDir), "parallel"),
+				withMode(createEditToolDefinition(session.installDir), "sequential"),
+				withMode(createWriteToolDefinition(session.installDir), "sequential"),
+				scrubbedBash,
+				withMode(createLsToolDefinition(session.installDir), "parallel"),
+				withMode(createFindToolDefinition(session.installDir), "parallel"),
+				withMode(createGrepToolDefinition(session.installDir), "parallel"),
+				...createWizardPiTools({
+					workingDirectory: session.installDir,
+					skillsBaseUrl: boot.skillsBaseUrl,
+					triageProvider: boot.triageProvider,
+					detectPackageManager: config.detectPackageManager,
+					askBridge: inputs.askBridge,
+					maxQuestions: config.maxQuestions,
+					onAskPendingChange: (pending) => {
+						askState.pending = pending;
+					},
+					disallowedTools: programConfig.disallowedTools
+				}),
+				...wizardTaskTools.tools,
+				createDispatchAgentTool({
+					model,
+					modelRegistry: registry,
+					cwd: session.installDir,
+					agentDir: getAgentDir(),
+					securityFactory: security.factory,
+					bashTool: scrubbedBash,
+					sdk: {
+						createAgentSession,
+						DefaultResourceLoader,
+						SessionManager
+					}
+				})
+			];
+			const { session: agentSession } = await createAgentSession({
+				model,
+				modelRegistry: registry,
+				thinkingLevel: caps.thinkingLevel,
+				cwd: session.installDir,
+				sessionManager: SessionManager.inMemory(session.installDir),
+				resourceLoader,
+				noTools: "builtin",
+				customTools
+			});
+			await agentSession.bindExtensions({});
+			const unsubscribe = agentSession.subscribe((event) => {
+				capture.captureFromPiMessageEndEvent(event);
+				switch (event.type) {
+					case "message_end": {
+						if (event.message?.role !== "assistant") break;
+						assistantTurns += 1;
+						const assistant = extractText(event.message).trim();
+						if (assistant) {
+							logToFile(`[pi] assistant: ${assistant.slice(0, 1e3)}`);
+							applyOutroMarkers(assistant);
+							const statusText = lastStatusLine(assistant);
+							if (statusText) {
+								getUI().pushStatus(statusText);
+								spinner.message(statusText);
+							}
+							for (const line of assistant.split("\n")) signals.push(line);
+						}
+						break;
+					}
+					case "tool_execution_start": {
+						toolCalls += 1;
+						const args = JSON.stringify(event.args ?? {}).slice(0, 200);
+						logToFile(`[pi] → ${event.toolName} ${args}`);
+						break;
+					}
+					case "tool_execution_end":
+						logToFile(`[pi] ${event.isError ? "✗" : "←"} ${event.toolName}: ${typeof event.result === "string" ? event.result : JSON.stringify(event.result ?? "")}`);
+						break;
+					case "agent_end":
+						logToFile(`[pi] agent_end (willRetry=${String(event.willRetry)})`);
+						break;
+					default: break;
+				}
+			});
+			capture.setInitialPrompt(prompt);
+			try {
+				await agentSession.prompt(prompt);
+				let continueNudges = 0;
+				while (continueNudges < MAX_CONTINUE_NUDGES && !security.state.criticalViolation && hasOpenTasks(wizardTaskTools.store)) {
+					continueNudges += 1;
+					logToFile(`[pi] completion guard: tasks still open, nudge ${continueNudges}/${MAX_CONTINUE_NUDGES}`);
+					await agentSession.prompt(CONTINUE_INSTRUCTION);
+				}
+				if (!security.state.criticalViolation) try {
+					await agentSession.prompt(REMARK_INSTRUCTION);
+				} catch (err) {
+					logToFile(`[pi] remark request failed: ${String(err)}`);
+				}
+			} finally {
+				unsubscribe();
+				mcpCleanup?.();
+			}
+			if (security.state.criticalViolation) {
+				spinner.stop("Security violation detected");
+				logToFile(`[pi] terminated: YARA violation (blocked ${security.state.blockedCount} call(s))`);
+				captureAborted();
+				return { error: "WIZARD_YARA_VIOLATION" };
+			}
+			const openTasks = hasOpenTasks(wizardTaskTools.store);
+			const failure = completionFailure({
+				toolCalls,
+				openTasks
+			});
+			if (failure === "WIZARD_NO_PROGRESS") {
+				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();
+				return { error: 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();
+				return { error: 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);
+			} catch (err) {
+				logToFile(`[pi] .posthog-events.json cleanup skipped: ${String(err)}`);
+			}
+			const stats = agentSession.getSessionStats();
+			analytics.wizardCapture("agent completed", {
+				...runDurations(),
+				model: modelId,
+				num_turns: assistantTurns,
+				input_tokens: stats.tokens.input,
+				output_tokens: stats.tokens.output,
+				cache_creation_input_tokens: stats.tokens.cacheWrite,
+				cache_read_input_tokens: stats.tokens.cacheRead
+			});
+			spinner.stop(config.successMessage ?? "PostHog integration complete");
+			return {};
+		} catch (err) {
+			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}`);
+			captureAborted();
+			const lower = message.toLowerCase();
+			if (lower.includes("rate limit") || lower.includes("429")) return {
+				error: "WIZARD_RATE_LIMIT",
+				message
+			};
+			return {
+				error: "WIZARD_API_ERROR",
+				message
+			};
+		}
+	},
+	async runTask(inputs) {
+		const { runPiTask } = await import("./task-DwzRxORh.js");
+		return runPiTask(inputs);
+	}
+};
+//#endregion
+export { piBackend as a, lastStatusLine as i, buildScrubbedEnv as n, withMode as o, extractText as r, createAioCapture as s, applyOutroMarkers as t };
+
+//# sourceMappingURL=pi-CfdqOKDI.js.map