@posthog/wizard 2.9.1 → 2.10.1

package/dist/agent-runner-D_eXxXPp.js

@@ -0,0 +1,1114 @@
+import { a as getLogFilePath, c as getUI, f as runtimeEnv, i as enableDebugLogs, o as initLogFile, s as logToFile, t as configureLogFile } from "./debug-CyJ_3dTP.js";
+import { n as analytics, w as getSkillsBaseUrl } from "./analytics-Bu1XKP2S.js";
+import { a as getCloudUrlFromRegion, t as getOrAskForProjectData } from "./setup-utils-Dymympue.js";
+import { n as registerCleanup, r as wizardAbort, t as WizardError } from "./wizard-abort-BPf5l506.js";
+import { a as backupAndFixClaudeSettings, c as initializeAgent, d as formatScanReport, f as writeScanReport, h as installSkillById, i as AgentSignals, l as restoreClaudeSettings, n as evaluateWizardReadiness, o as buildWizardMetadata, s as checkAllSettingsConflicts, u as runAgent$1 } from "./readiness-BPPVNQum.js";
+import { r as detectNodePackageManagers } from "./package-manager-BTZ75a-a.js";
+import fs, { existsSync } from "fs";
+import path, { join } from "path";
+//#region src/lib/middleware/phase-detector.ts
+/** Phase transitions from [STATUS] in assistant text. Keep in sync with workflow "Status to report" bullets. */
+const PHASES_ORDER = [
+	"1.0-begin",
+	"1.1-edit",
+	"1.2-revise",
+	"1.3-conclude"
+];
+const STATUS_PHRASES_BY_PHASE = {
+	"1.0-begin": [
+		"Checking project structure",
+		"Verifying PostHog dependencies",
+		"Generating events based on project"
+	],
+	"1.1-edit": ["Inserting PostHog capture code"],
+	"1.2-revise": [
+		"Finding and correcting errors",
+		"Report details of any errors you fix",
+		"Linting, building and prettying"
+	],
+	"1.3-conclude": ["Configured dashboard", "Created setup report"]
+};
+var PhaseDetector = class {
+	currentPhase = "setup";
+	detect(message) {
+		if (message.type !== "assistant") return null;
+		const nextPhase = this.getNextPhase();
+		if (nextPhase === null) return null;
+		const content = message.message?.content;
+		if (!Array.isArray(content)) return null;
+		for (const block of content) {
+			if (block.type !== "text" || typeof block.text !== "string") continue;
+			if (!block.text.includes("[STATUS]")) continue;
+			const phrases = STATUS_PHRASES_BY_PHASE[nextPhase];
+			for (const phrase of phrases) if (block.text.includes(phrase)) {
+				this.currentPhase = nextPhase;
+				return nextPhase;
+			}
+		}
+		return null;
+	}
+	getNextPhase() {
+		if (this.currentPhase === "setup") return "1.0-begin";
+		const i = PHASES_ORDER.indexOf(this.currentPhase);
+		if (i < 0 || i >= PHASES_ORDER.length - 1) return null;
+		return PHASES_ORDER[i + 1];
+	}
+	reset() {
+		this.currentPhase = "setup";
+	}
+};
+//#endregion
+//#region src/lib/middleware/pipeline.ts
+/**
+* Middleware pipeline orchestrator.
+*
+* Implements the same { onMessage, finalize } interface that runAgent() expects,
+* while internally dispatching to an ordered list of middleware plugins.
+*/
+var MiddlewarePipeline = class {
+	middlewares;
+	store = /* @__PURE__ */ new Map();
+	phaseDetector;
+	autoDetectPhases;
+	_currentPhase = "setup";
+	_currentPhaseFreshContext = true;
+	constructor(middlewares, opts) {
+		this.middlewares = middlewares;
+		this.phaseDetector = opts?.phaseDetector ?? new PhaseDetector();
+		this.autoDetectPhases = opts?.autoDetectPhases ?? true;
+		const ctx = this.createContext();
+		for (const mw of this.middlewares) mw.onInit?.(ctx);
+	}
+	/** Feed an SDK message through all middleware (satisfies tracker.onMessage) */
+	onMessage(message) {
+		if (this.autoDetectPhases) {
+			const newPhase = this.phaseDetector.detect(message);
+			if (newPhase && newPhase !== this._currentPhase) this.transitionPhase(newPhase, false);
+		}
+		const ctx = this.createContext();
+		const storeHandle = this.createStore();
+		for (const mw of this.middlewares) mw.onMessage?.(message, ctx, storeHandle);
+	}
+	/** Finalize the run (satisfies tracker.finalize) */
+	finalize(resultMessage, totalDurationMs) {
+		const ctx = this.createContext();
+		const storeHandle = this.createStore();
+		let result;
+		for (const mw of this.middlewares) {
+			const r = mw.onFinalize?.(resultMessage, totalDurationMs, ctx, storeHandle);
+			if (r !== void 0) result = r;
+		}
+		return result;
+	}
+	/** Explicit phase start (for phased runner support) */
+	startPhase(name, freshContext) {
+		this.transitionPhase(name, freshContext);
+	}
+	transitionPhase(newPhase, freshContext) {
+		const oldPhase = this._currentPhase;
+		this._currentPhase = newPhase;
+		this._currentPhaseFreshContext = freshContext;
+		const ctx = this.createContext();
+		const storeHandle = this.createStore();
+		for (const mw of this.middlewares) mw.onPhaseTransition?.(oldPhase, newPhase, ctx, storeHandle);
+	}
+	createContext() {
+		return {
+			currentPhase: this._currentPhase,
+			currentPhaseFreshContext: this._currentPhaseFreshContext,
+			get: (key) => this.store.get(key)
+		};
+	}
+	createStore() {
+		return { set: (key, value) => this.store.set(key, value) };
+	}
+};
+//#endregion
+//#region src/lib/middleware/config.ts
+/**
+* Benchmark configuration loader.
+*
+* Loads .benchmark-config.json from the working directory with sensible defaults.
+* All fields are optional — missing fields fall back to defaults.
+*/
+const DEFAULT_CONFIG = {
+	plugins: {
+		tokens: true,
+		cache: true,
+		turns: true,
+		compactions: true,
+		contextSize: true,
+		cost: true,
+		duration: true,
+		summary: true,
+		jsonWriter: true
+	},
+	output: {
+		benchmarkPath: "/tmp/posthog-wizard-benchmark.json",
+		benchmarkEnabled: true,
+		logPath: "/tmp/posthog-wizard.log",
+		logEnabled: true,
+		suppressWizardLogs: false
+	}
+};
+function loadBenchmarkConfig(installDir) {
+	const configPath = runtimeEnv("POSTHOG_WIZARD_BENCHMARK_CONFIG") ?? path.join(installDir, ".benchmark-config.json");
+	try {
+		const raw = fs.readFileSync(configPath, "utf-8");
+		const parsed = JSON.parse(raw);
+		const config = {
+			plugins: {
+				...DEFAULT_CONFIG.plugins,
+				...parsed.plugins
+			},
+			output: {
+				...DEFAULT_CONFIG.output,
+				...parsed.output
+			}
+		};
+		const benchFile = runtimeEnv("POSTHOG_WIZARD_BENCHMARK_FILE");
+		if (benchFile) config.output.benchmarkPath = benchFile;
+		const logDir = runtimeEnv("POSTHOG_WIZARD_LOG_DIR");
+		if (logDir) config.output.logPath = path.join(logDir, "posthog-wizard.log");
+		if (!config.output.benchmarkEnabled) config.plugins.jsonWriter = false;
+		logToFile(`${AgentSignals.BENCHMARK} Loaded config from ${configPath}`);
+		return config;
+	} catch {
+		const config = structuredClone(DEFAULT_CONFIG);
+		const benchFile2 = runtimeEnv("POSTHOG_WIZARD_BENCHMARK_FILE");
+		if (benchFile2) config.output.benchmarkPath = benchFile2;
+		const logDir2 = runtimeEnv("POSTHOG_WIZARD_LOG_DIR");
+		if (logDir2) config.output.logPath = path.join(logDir2, "posthog-wizard.log");
+		return config;
+	}
+}
+//#endregion
+//#region src/lib/middleware/benchmarks/turn-counter.ts
+var TurnCounterPlugin = class {
+	name = "turns";
+	lastMessageId = null;
+	phaseTurns = 0;
+	totalTurns = 0;
+	isDuplicate = false;
+	phaseSnapshots = [];
+	currentPhase = "setup";
+	onMessage(message, _ctx, store) {
+		if (message.type !== "assistant") {
+			this.isDuplicate = false;
+			store.set("turns", this.getData());
+			return;
+		}
+		const msgId = message.message?.id;
+		this.isDuplicate = msgId != null && msgId === this.lastMessageId;
+		if (msgId) this.lastMessageId = msgId;
+		if (!this.isDuplicate) {
+			this.phaseTurns++;
+			this.totalTurns++;
+		}
+		store.set("turns", this.getData());
+	}
+	onPhaseTransition(fromPhase, _toPhase, _ctx, store) {
+		this.phaseSnapshots.push({
+			phase: fromPhase,
+			turns: this.phaseTurns
+		});
+		this.currentPhase = _toPhase;
+		this.phaseTurns = 0;
+		this.lastMessageId = null;
+		store.set("turns", this.getData());
+	}
+	onFinalize(_resultMessage, _totalDurationMs, _ctx, store) {
+		this.phaseSnapshots.push({
+			phase: this.currentPhase,
+			turns: this.phaseTurns
+		});
+		store.set("turns", this.getData());
+	}
+	getData() {
+		return {
+			isDuplicate: this.isDuplicate,
+			phaseTurns: this.phaseTurns,
+			totalTurns: this.totalTurns,
+			phaseSnapshots: [...this.phaseSnapshots]
+		};
+	}
+};
+//#endregion
+//#region src/lib/middleware/benchmarks/token-tracker.ts
+var TokenTrackerPlugin = class {
+	name = "tokens";
+	phaseInput = 0;
+	phaseOutput = 0;
+	totalInput = 0;
+	totalOutput = 0;
+	lastUsage = null;
+	phaseSnapshots = [];
+	currentPhase = "setup";
+	phaseMessagesWithUsage = 0;
+	onMessage(message, ctx, store) {
+		if (message.type !== "assistant") return;
+		if (ctx.get("turns")?.isDuplicate) return;
+		const usage = message.message?.usage;
+		if (usage) {
+			const input = Number(usage.input_tokens ?? 0) + Number(usage.cache_read_input_tokens ?? 0) + Number(usage.cache_creation_input_tokens ?? 0);
+			const output = Number(usage.output_tokens ?? 0);
+			this.phaseInput += input;
+			this.phaseOutput += output;
+			this.totalInput += input;
+			this.totalOutput += output;
+			this.lastUsage = usage;
+			this.phaseMessagesWithUsage += 1;
+		}
+		store.set("tokens", this.getData());
+	}
+	onPhaseTransition(fromPhase, toPhase, _ctx, store) {
+		this.phaseSnapshots.push({
+			phase: fromPhase,
+			inputTokens: this.phaseInput,
+			outputTokens: this.phaseOutput,
+			messagesWithUsage: this.phaseMessagesWithUsage
+		});
+		this.currentPhase = toPhase;
+		this.phaseInput = 0;
+		this.phaseOutput = 0;
+		this.phaseMessagesWithUsage = 0;
+		store.set("tokens", this.getData());
+	}
+	onFinalize(_resultMessage, _totalDurationMs, _ctx, store) {
+		this.phaseSnapshots.push({
+			phase: this.currentPhase,
+			inputTokens: this.phaseInput,
+			outputTokens: this.phaseOutput,
+			messagesWithUsage: this.phaseMessagesWithUsage
+		});
+		store.set("tokens", this.getData());
+	}
+	getData() {
+		return {
+			phaseInput: this.phaseInput,
+			phaseOutput: this.phaseOutput,
+			totalInput: this.totalInput,
+			totalOutput: this.totalOutput,
+			lastUsage: this.lastUsage,
+			phaseSnapshots: [...this.phaseSnapshots]
+		};
+	}
+};
+//#endregion
+//#region src/lib/middleware/benchmarks/cache-tracker.ts
+var CacheTrackerPlugin = class {
+	name = "cache";
+	phaseRead = 0;
+	phaseCreation = 0;
+	phaseCreation5m = 0;
+	phaseCreation1h = 0;
+	totalRead = 0;
+	totalCreation = 0;
+	totalCreation5m = 0;
+	totalCreation1h = 0;
+	phaseSnapshots = [];
+	currentPhase = "setup";
+	onMessage(message, ctx, store) {
+		if (message.type !== "assistant") return;
+		if (ctx.get("turns")?.isDuplicate) return;
+		const usage = message.message?.usage;
+		if (usage) {
+			const read = Number(usage.cache_read_input_tokens ?? 0);
+			const creation = Number(usage.cache_creation_input_tokens ?? 0);
+			const cc = usage.cache_creation;
+			const creation5m = Number(cc?.ephemeral_5m_input_tokens ?? 0);
+			const creation1h = Number(cc?.ephemeral_1h_input_tokens ?? 0);
+			this.phaseRead += read;
+			this.phaseCreation += creation;
+			this.phaseCreation5m += creation5m;
+			this.phaseCreation1h += creation1h;
+			this.totalRead += read;
+			this.totalCreation += creation;
+		}
+		store.set("cache", this.getData());
+	}
+	onPhaseTransition(fromPhase, toPhase, _ctx, store) {
+		this.phaseSnapshots.push({
+			phase: fromPhase,
+			cacheReadTokens: this.phaseRead,
+			cacheCreationTokens: this.phaseCreation,
+			cacheCreation5m: this.phaseCreation5m,
+			cacheCreation1h: this.phaseCreation1h
+		});
+		this.currentPhase = toPhase;
+		this.phaseRead = 0;
+		this.phaseCreation = 0;
+		this.phaseCreation5m = 0;
+		this.phaseCreation1h = 0;
+		store.set("cache", this.getData());
+	}
+	onFinalize(_resultMessage, _totalDurationMs, _ctx, store) {
+		this.phaseSnapshots.push({
+			phase: this.currentPhase,
+			cacheReadTokens: this.phaseRead,
+			cacheCreationTokens: this.phaseCreation,
+			cacheCreation5m: this.phaseCreation5m,
+			cacheCreation1h: this.phaseCreation1h
+		});
+		store.set("cache", this.getData());
+	}
+	getData() {
+		return {
+			phaseRead: this.phaseRead,
+			phaseCreation: this.phaseCreation,
+			totalRead: this.totalRead,
+			totalCreation: this.totalCreation,
+			totalCreation5m: this.totalCreation5m,
+			totalCreation1h: this.totalCreation1h,
+			phaseSnapshots: [...this.phaseSnapshots]
+		};
+	}
+};
+//#endregion
+//#region src/lib/middleware/benchmarks/compaction-tracker.ts
+var CompactionTrackerPlugin = class {
+	name = "compactions";
+	phaseCompactions = 0;
+	phasePreTokens = [];
+	totalCompactions = 0;
+	phaseSnapshots = [];
+	currentPhase = "setup";
+	onMessage(message, ctx, store) {
+		if (message.type !== "system" || message.subtype !== "compact_boundary") return;
+		const preTokens = message.compact_metadata?.pre_tokens ?? 0;
+		const trigger = message.compact_metadata?.trigger ?? "unknown";
+		this.phaseCompactions++;
+		this.totalCompactions++;
+		this.phasePreTokens.push(preTokens);
+		logToFile(`${AgentSignals.BENCHMARK} [COMPACTION] Context compacted during "${ctx.currentPhase}" (trigger: ${trigger}, pre_tokens: ${preTokens})`);
+		store.set("compactions", this.getData());
+	}
+	onPhaseTransition(fromPhase, toPhase, _ctx, store) {
+		this.phaseSnapshots.push({
+			phase: fromPhase,
+			compactions: this.phaseCompactions,
+			preTokens: [...this.phasePreTokens]
+		});
+		this.currentPhase = toPhase;
+		this.phaseCompactions = 0;
+		this.phasePreTokens = [];
+		store.set("compactions", this.getData());
+	}
+	onFinalize(_resultMessage, _totalDurationMs, _ctx, store) {
+		this.phaseSnapshots.push({
+			phase: this.currentPhase,
+			compactions: this.phaseCompactions,
+			preTokens: [...this.phasePreTokens]
+		});
+		store.set("compactions", this.getData());
+	}
+	getData() {
+		return {
+			phaseCompactions: this.phaseCompactions,
+			phasePreTokens: [...this.phasePreTokens],
+			totalCompactions: this.totalCompactions,
+			phaseSnapshots: [...this.phaseSnapshots]
+		};
+	}
+};
+//#endregion
+//#region src/lib/middleware/benchmarks/context-size-tracker.ts
+var ContextSizeTrackerPlugin = class {
+	name = "contextSize";
+	phaseSnapshots = [];
+	lastContextTokensOut;
+	onPhaseTransition(fromPhase, _toPhase, ctx, store) {
+		const tokens = ctx.get("tokens");
+		const contextTokensOut = this.computeContextTokensOut(tokens?.lastUsage);
+		this.phaseSnapshots.push({
+			phase: fromPhase,
+			contextTokensIn: ctx.currentPhaseFreshContext ? void 0 : this.lastContextTokensOut,
+			contextTokensOut,
+			freshContext: ctx.currentPhaseFreshContext
+		});
+		this.lastContextTokensOut = contextTokensOut;
+		store.set("contextSize", this.getData());
+	}
+	onFinalize(_resultMessage, _totalDurationMs, ctx, store) {
+		const tokens = ctx.get("tokens");
+		const contextTokensOut = this.computeContextTokensOut(tokens?.lastUsage);
+		this.phaseSnapshots.push({
+			phase: ctx.currentPhase,
+			contextTokensIn: ctx.currentPhaseFreshContext ? void 0 : this.lastContextTokensOut,
+			contextTokensOut,
+			freshContext: ctx.currentPhaseFreshContext
+		});
+		store.set("contextSize", this.getData());
+	}
+	computeContextTokensOut(usage) {
+		if (!usage) return void 0;
+		return Number(usage.input_tokens ?? 0) + Number(usage.cache_read_input_tokens ?? 0) + Number(usage.cache_creation_input_tokens ?? 0);
+	}
+	getData() {
+		return { phaseSnapshots: [...this.phaseSnapshots] };
+	}
+};
+//#endregion
+//#region src/lib/middleware/benchmarks/cost-tracker.ts
+/** Claude Sonnet 4.6 pricing (USD per 1M tokens) */
+const PRICE_PER_MTOK = {
+	input: 3,
+	output: 15,
+	cacheRead: .3,
+	cacheCreation5m: 3.75,
+	cacheCreation1h: 6
+};
+function computeCost(inputTokens, outputTokens, cacheReadTokens, cacheCreation5m, cacheCreation1h, cacheCreationFallback) {
+	const hasBreakdown = cacheCreation5m > 0 || cacheCreation1h > 0;
+	return inputTokens * (PRICE_PER_MTOK.input / 1e6) + outputTokens * (PRICE_PER_MTOK.output / 1e6) + cacheReadTokens * (PRICE_PER_MTOK.cacheRead / 1e6) + (hasBreakdown ? cacheCreation5m * (PRICE_PER_MTOK.cacheCreation5m / 1e6) + cacheCreation1h * (PRICE_PER_MTOK.cacheCreation1h / 1e6) : cacheCreationFallback * (PRICE_PER_MTOK.cacheCreation5m / 1e6));
+}
+var CostTrackerPlugin = class {
+	name = "cost";
+	phaseCosts = [];
+	totalCost = 0;
+	onPhaseTransition(fromPhase, _toPhase, ctx, store) {
+		const tokens = ctx.get("tokens");
+		const cache = ctx.get("cache");
+		const tokenSnap = tokens?.phaseSnapshots.at(-1);
+		const cacheSnap = cache?.phaseSnapshots.at(-1);
+		const totalIn = tokenSnap?.inputTokens ?? 0;
+		const read = cacheSnap?.cacheReadTokens ?? 0;
+		const creation = cacheSnap?.cacheCreationTokens ?? 0;
+		const c5m = cacheSnap?.cacheCreation5m ?? 0;
+		const c1h = cacheSnap?.cacheCreation1h ?? 0;
+		const phaseCost = computeCost(Math.max(0, totalIn - read - creation), tokenSnap?.outputTokens ?? 0, read, c5m, c1h, creation);
+		this.phaseCosts.push({
+			phase: fromPhase,
+			cost: phaseCost
+		});
+		this.totalCost += phaseCost;
+		store.set("cost", this.getData());
+	}
+	onFinalize(resultMessage, _totalDurationMs, ctx, store) {
+		const tokens = ctx.get("tokens");
+		const cache = ctx.get("cache");
+		const tokenSnap = tokens?.phaseSnapshots.at(-1);
+		const cacheSnap = cache?.phaseSnapshots.at(-1);
+		const totalIn = tokenSnap?.inputTokens ?? 0;
+		const read = cacheSnap?.cacheReadTokens ?? 0;
+		const creation = cacheSnap?.cacheCreationTokens ?? 0;
+		const c5m = cacheSnap?.cacheCreation5m ?? 0;
+		const c1h = cacheSnap?.cacheCreation1h ?? 0;
+		const lastPhaseCost = computeCost(Math.max(0, totalIn - read - creation), tokenSnap?.outputTokens ?? 0, read, c5m, c1h, creation);
+		this.phaseCosts.push({
+			phase: ctx.currentPhase,
+			cost: lastPhaseCost
+		});
+		this.totalCost += lastPhaseCost;
+		const sdkTotal = Number(resultMessage?.usage?.total_cost_usd ?? 0) || Number(resultMessage?.total_cost_usd ?? 0);
+		if (sdkTotal > 0 && this.totalCost > 0) {
+			const scale = sdkTotal / this.totalCost;
+			this.phaseCosts = this.phaseCosts.map((p) => ({
+				phase: p.phase,
+				cost: p.cost * scale
+			}));
+			this.totalCost = sdkTotal;
+		}
+		store.set("cost", this.getData());
+	}
+	getData() {
+		return {
+			totalCost: this.totalCost,
+			phaseCosts: [...this.phaseCosts]
+		};
+	}
+};
+//#endregion
+//#region src/lib/middleware/benchmarks/duration-tracker.ts
+var DurationTrackerPlugin = class {
+	name = "duration";
+	phaseStartTime = Date.now();
+	phaseSnapshots = [];
+	onPhaseTransition(fromPhase, _toPhase, _ctx, store) {
+		const now = Date.now();
+		this.phaseSnapshots.push({
+			phase: fromPhase,
+			startTime: this.phaseStartTime,
+			endTime: now,
+			durationMs: now - this.phaseStartTime
+		});
+		this.phaseStartTime = now;
+		store.set("duration", {
+			phaseSnapshots: [...this.phaseSnapshots],
+			totalDurationMs: 0
+		});
+	}
+	onFinalize(_resultMessage, totalDurationMs, ctx, store) {
+		const now = Date.now();
+		this.phaseSnapshots.push({
+			phase: ctx.currentPhase,
+			startTime: this.phaseStartTime,
+			endTime: now,
+			durationMs: now - this.phaseStartTime
+		});
+		store.set("duration", {
+			phaseSnapshots: [...this.phaseSnapshots],
+			totalDurationMs
+		});
+	}
+};
+//#endregion
+//#region src/lib/middleware/benchmarks/summary.ts
+function fmtDuration(ms) {
+	const s = Math.round(ms / 1e3);
+	const m = Math.floor(s / 60);
+	return m > 0 ? `${m}m ${s % 60}s` : `${s}s`;
+}
+function fmtTok(n) {
+	if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+	if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+	return n.toLocaleString();
+}
+function fmtCost(usd) {
+	if (usd > 0 && usd < .01) return `$${usd.toFixed(4)}`;
+	return `$${usd.toFixed(2)}`;
+}
+function printPhase(s) {
+	const baseIn = Math.max(0, s.inputTokens - s.cacheRead - s.cacheCreation5m - s.cacheCreation1h);
+	return [
+		`${s.phase}: ${fmtDuration(s.durationMs)}, ${s.turns} turns, cost: ${fmtCost(s.cost)}`,
+		`  in: ${fmtTok(baseIn)}, out: ${fmtTok(s.outputTokens)}, cache_read: ${fmtTok(s.cacheRead)}, cache_5m: ${fmtTok(s.cacheCreation5m)}, cache_1h: ${fmtTok(s.cacheCreation1h)}`,
+		s.compactions > 0 ? `  ${s.compactions} compaction(s)` : null,
+		s.contextOut !== void 0 ? `  ctx_out: ${fmtTok(s.contextOut)}` : null
+	].filter(Boolean).join("\n");
+}
+function getPhaseStats(i, ctx) {
+	const dur = ctx.get("duration")?.phaseSnapshots[i];
+	if (!dur) return null;
+	const tokens = ctx.get("tokens");
+	const turns = ctx.get("turns");
+	const cost = ctx.get("cost");
+	const compactions = ctx.get("compactions");
+	const contextSize = ctx.get("contextSize");
+	const cache = ctx.get("cache");
+	return {
+		phase: dur.phase,
+		durationMs: dur.durationMs,
+		turns: turns?.phaseSnapshots[i]?.turns ?? 0,
+		inputTokens: tokens?.phaseSnapshots[i]?.inputTokens ?? 0,
+		outputTokens: tokens?.phaseSnapshots[i]?.outputTokens ?? 0,
+		cacheRead: cache?.phaseSnapshots[i]?.cacheReadTokens ?? 0,
+		cacheCreation5m: cache?.phaseSnapshots[i]?.cacheCreation5m ?? 0,
+		cacheCreation1h: cache?.phaseSnapshots[i]?.cacheCreation1h ?? 0,
+		cost: cost?.phaseCosts[i]?.cost ?? 0,
+		compactions: compactions?.phaseSnapshots[i]?.compactions ?? 0,
+		contextOut: contextSize?.phaseSnapshots[i]?.contextTokensOut
+	};
+}
+var SummaryPlugin = class {
+	name = "summary";
+	spinner;
+	constructor(spinner) {
+		this.spinner = spinner;
+	}
+	onPhaseTransition(fromPhase, toPhase, ctx, _store) {
+		const stats = getPhaseStats((ctx.get("duration")?.phaseSnapshots.length ?? 1) - 1, ctx);
+		if (stats) this.spinner.stop(`${AgentSignals.BENCHMARK} ${printPhase(stats)}`);
+		else this.spinner.stop(`${AgentSignals.BENCHMARK} ${fromPhase}`);
+		getUI().log.info(`${AgentSignals.BENCHMARK} Starting phase: ${toPhase}`);
+		this.spinner.start(`Integrating PostHog (${toPhase})...`);
+	}
+	onFinalize(_resultMessage, totalDurationMs, ctx, _store) {
+		const duration = ctx.get("duration");
+		const cost = ctx.get("cost");
+		const tokens = ctx.get("tokens");
+		const cache = ctx.get("cache");
+		const phaseCount = duration?.phaseSnapshots.length ?? 0;
+		const totalCost = cost?.totalCost ?? 0;
+		getUI().log.info("");
+		getUI().log.info(`◇ ${AgentSignals.BENCHMARK} ${phaseCount} phases in ${fmtDuration(totalDurationMs)}, cost: ${fmtCost(totalCost)}`);
+		getUI().log.info(`  total in: ${fmtTok(tokens?.totalInput ?? 0)}, out: ${fmtTok(tokens?.totalOutput ?? 0)}, cache_read: ${fmtTok(cache?.totalRead ?? 0)}, cache_5m: ${fmtTok(cache?.totalCreation5m ?? 0)}, cache_1h: ${fmtTok(cache?.totalCreation1h ?? 0)}`);
+		getUI().log.info("");
+		getUI().log.info(`● ${AgentSignals.BENCHMARK} Summary by phase:`);
+		if (duration?.phaseSnapshots) for (let i = 0; i < duration.phaseSnapshots.length; i++) {
+			const stats = getPhaseStats(i, ctx);
+			if (stats) getUI().log.info(printPhase(stats));
+		}
+		getUI().log.info("");
+	}
+};
+//#endregion
+//#region src/lib/middleware/benchmarks/json-writer.ts
+/**
+* JSON file output plugin.
+*
+* Assembles the BenchmarkData structure from all upstream plugin data
+* and writes it to a JSON file. Returns the BenchmarkData for backward compat.
+*/
+/**
+* Sum token usage across all models from the SDK's modelUsage field.
+*/
+function sumModelUsage(modelUsage) {
+	let input_tokens = 0;
+	let output_tokens = 0;
+	let cache_creation_input_tokens = 0;
+	let cache_read_input_tokens = 0;
+	for (const model of Object.values(modelUsage)) {
+		input_tokens += model.inputTokens ?? 0;
+		output_tokens += model.outputTokens ?? 0;
+		cache_creation_input_tokens += model.cacheCreationInputTokens ?? 0;
+		cache_read_input_tokens += model.cacheReadInputTokens ?? 0;
+	}
+	return {
+		input_tokens,
+		output_tokens,
+		cache_creation_input_tokens,
+		cache_read_input_tokens
+	};
+}
+var JsonWriterPlugin = class {
+	name = "jsonWriter";
+	outputPath;
+	constructor(outputPath) {
+		this.outputPath = outputPath;
+	}
+	onFinalize(resultMessage, totalDurationMs, ctx, _store) {
+		const tokens = ctx.get("tokens");
+		const cache = ctx.get("cache");
+		const turns = ctx.get("turns");
+		const cost = ctx.get("cost");
+		const duration = ctx.get("duration");
+		const compactions = ctx.get("compactions");
+		const contextSize = ctx.get("contextSize");
+		const aggregateUsage = sumModelUsage(resultMessage?.modelUsage ?? {});
+		const phaseCount = duration?.phaseSnapshots.length ?? 0;
+		const steps = [];
+		for (let i = 0; i < phaseCount; i++) {
+			const dur = duration.phaseSnapshots[i];
+			const tokenSnap = tokens?.phaseSnapshots[i];
+			const cacheSnap = cache?.phaseSnapshots[i];
+			const turnSnap = turns?.phaseSnapshots[i];
+			const costSnap = cost?.phaseCosts[i];
+			const compSnap = compactions?.phaseSnapshots[i];
+			const ctxSnap = contextSize?.phaseSnapshots[i];
+			const step = {
+				name: dur.phase,
+				usage: {
+					input_tokens: tokenSnap?.inputTokens ?? 0,
+					output_tokens: tokenSnap?.outputTokens ?? 0,
+					cache_creation_input_tokens: cacheSnap?.cacheCreationTokens ?? 0,
+					cache_read_input_tokens: cacheSnap?.cacheReadTokens ?? 0,
+					...(cacheSnap?.cacheCreation5m ?? 0) + (cacheSnap?.cacheCreation1h ?? 0) > 0 && { cache_creation: {
+						ephemeral_5m_input_tokens: cacheSnap?.cacheCreation5m ?? 0,
+						ephemeral_1h_input_tokens: cacheSnap?.cacheCreation1h ?? 0
+					} }
+				},
+				modelUsage: {},
+				totalCostUsd: costSnap?.cost ?? 0,
+				durationMs: dur.durationMs,
+				durationApiMs: 0,
+				numTurns: turnSnap?.turns ?? 0,
+				...ctxSnap?.contextTokensIn !== void 0 && { contextTokensIn: ctxSnap.contextTokensIn },
+				...ctxSnap?.contextTokensOut !== void 0 && { contextTokensOut: ctxSnap.contextTokensOut },
+				...compSnap && compSnap.compactions > 0 ? {
+					compactions: compSnap.compactions,
+					compactionPreTokens: compSnap.preTokens
+				} : {}
+			};
+			steps.push(step);
+		}
+		const totalTurns = turns?.totalTurns ?? 0;
+		const totalCost = cost?.totalCost ?? 0;
+		const totalCompactions = compactions?.totalCompactions ?? 0;
+		const fromModelUsage = aggregateUsage.input_tokens + aggregateUsage.cache_read_input_tokens + aggregateUsage.cache_creation_input_tokens;
+		const inputTokens = fromModelUsage > 0 ? fromModelUsage : (tokens?.totalInput ?? 0) + (cache?.totalRead ?? 0) + (cache?.totalCreation ?? 0);
+		const outputTokens = aggregateUsage.output_tokens > 0 ? aggregateUsage.output_tokens : tokens?.totalOutput ?? 0;
+		const benchmark = {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			steps,
+			totals: {
+				totalCostUsd: totalCost,
+				durationMs: totalDurationMs,
+				inputTokens,
+				outputTokens,
+				numTurns: resultMessage?.num_turns ?? totalTurns,
+				totalCompactions,
+				totalCacheReadTokens: cache?.totalRead ?? 0,
+				totalCacheCreation5mTokens: cache?.totalCreation5m ?? 0,
+				totalCacheCreation1hTokens: cache?.totalCreation1h ?? 0
+			}
+		};
+		this.writeBenchmarkData(benchmark);
+		return benchmark;
+	}
+	writeBenchmarkData(data) {
+		try {
+			fs.writeFileSync(this.outputPath, JSON.stringify(data, null, 2));
+			logToFile(`Benchmark data written to ${this.outputPath}`);
+			getUI().log.info(`● ${AgentSignals.BENCHMARK} Results written to ${this.outputPath}`);
+		} catch (error) {
+			logToFile("Failed to write benchmark data:", error);
+		}
+	}
+};
+//#endregion
+//#region src/lib/middleware/benchmarks/index.ts
+const PLUGIN_REGISTRY = {
+	turns: () => new TurnCounterPlugin(),
+	tokens: () => new TokenTrackerPlugin(),
+	cache: () => new CacheTrackerPlugin(),
+	compactions: () => new CompactionTrackerPlugin(),
+	contextSize: () => new ContextSizeTrackerPlugin(),
+	cost: () => new CostTrackerPlugin(),
+	duration: () => new DurationTrackerPlugin(),
+	summary: (opts) => new SummaryPlugin(opts.spinner),
+	jsonWriter: (opts) => new JsonWriterPlugin(opts.outputPath)
+};
+/**
+* Execution order — data producers before consumers:
+* turns (dedup) -> tokens -> cache -> compactions -> contextSize -> cost -> duration -> summary -> jsonWriter
+*/
+const PLUGIN_ORDER = [
+	"turns",
+	"tokens",
+	"cache",
+	"compactions",
+	"contextSize",
+	"cost",
+	"duration",
+	"summary",
+	"jsonWriter"
+];
+function createPluginsFromConfig(config, opts) {
+	const resolvedOpts = {
+		...opts,
+		outputPath: opts.outputPath ?? config.output.benchmarkPath
+	};
+	const effectivePlugins = { ...config.plugins };
+	if (config.output.suppressWizardLogs) effectivePlugins.summary = false;
+	return PLUGIN_ORDER.filter((name) => effectivePlugins[name] !== false).map((name) => PLUGIN_REGISTRY[name]).filter(Boolean).map((factory) => factory(resolvedOpts));
+}
+//#endregion
+//#region src/lib/middleware/benchmark.ts
+/**
+* Benchmark tracking for wizard runs.
+*
+* Usage:
+*   const pipeline = createBenchmarkPipeline(spinner, options);
+*   pipeline.onMessage(message);
+*   pipeline.finalize(resultMessage, durationMs);
+*/
+/**
+* Create a middleware pipeline configured for benchmarking.
+* Loads .benchmark-config.json from the install dir, falls back to defaults.
+*/
+function createBenchmarkPipeline(spinner, options, configOverride) {
+	const config = configOverride ?? loadBenchmarkConfig(options.installDir);
+	configureLogFile({
+		path: config.output.logPath,
+		enabled: config.output.logEnabled
+	});
+	const plugins = createPluginsFromConfig(config, {
+		spinner,
+		phased: false,
+		outputPath: config.output.benchmarkPath
+	});
+	if (!config.output.suppressWizardLogs) {
+		getUI().log.info(`${AgentSignals.BENCHMARK} Verbose logs: ${getLogFilePath()}`);
+		getUI().log.info(`${AgentSignals.BENCHMARK} Benchmark data will be written to: ${config.output.benchmarkPath}`);
+	}
+	logToFile(`${AgentSignals.BENCHMARK} Tracking enabled, starting with setup phase`);
+	return new MiddlewarePipeline(plugins, {
+		phaseDetector: new PhaseDetector(),
+		autoDetectPhases: true
+	});
+}
+//#endregion
+//#region src/lib/agent/agent-prompt.ts
+function defaultProjectPrompt(ctx) {
+	return `You have access to the PostHog MCP server.
+
+Project context:
+- PostHog Project ID: ${ctx.projectId}
+- PostHog public token: ${ctx.projectApiKey}
+- PostHog Host: ${ctx.host}`;
+}
+function skillPrompt(skillPath, reportFile) {
+	return `A PostHog skill has been installed at ${skillPath}/. Read ${skillPath}/SKILL.md and follow its instructions completely.
+
+After completing the skill workflow, write a brief markdown report to ./${reportFile} summarizing:
+- What changes were made to the project
+- Which files were modified or created
+- Any manual steps the user should take next
+
+Important: You must read a file immediately before attempting to write it, even if you have previously read it; failure to do so will cause a tool failure.`;
+}
+/**
+* Assemble the final agent prompt from the workflow's run config.
+*/
+function assemblePrompt(runDef, ctx) {
+	const parts = [];
+	parts.push(defaultProjectPrompt(ctx));
+	if (runDef.customPrompt) parts.push(runDef.customPrompt(ctx));
+	if (ctx.skillPath) parts.push(skillPrompt(ctx.skillPath, runDef.reportFile));
+	return parts.join("\n\n");
+}
+//#endregion
+//#region src/lib/agent/agent-runner.ts
+/**
+* Unified workflow runner.
+*
+* Single configurable pipeline for all workflows. Each workflow
+* provides a WorkflowRun (via the `run` field on WorkflowConfig)
+* that controls:
+*   - Whether a skill is pre-installed or discovered at runtime
+*   - How the agent prompt is built
+*   - What MCP servers and package manager detector to use
+*   - What happens after the agent completes
+*
+* The pipeline itself is fixed:
+*   init → health check → settings → OAuth → [skill install] →
+*   agent init → prompt → run → errors → [postRun] → outro
+*/
+function sessionToOptions(session) {
+	return {
+		installDir: session.installDir,
+		debug: session.debug,
+		forceInstall: session.forceInstall,
+		default: false,
+		signup: session.signup,
+		localMcp: session.localMcp,
+		ci: session.ci,
+		menu: session.menu,
+		benchmark: session.benchmark,
+		projectId: session.projectId,
+		apiKey: session.apiKey,
+		yaraReport: session.yaraReport
+	};
+}
+/**
+* Resolve a WorkflowConfig's agent run definition and execute the pipeline.
+* Entry point for bin.ts — handles buildRunConfig, bootstrap, and (future) run field.
+*/
+async function runAgent(workflowConfig, session) {
+	if (!workflowConfig.run) throw new Error(`Workflow "${workflowConfig.flowKey}" has no run configuration.`);
+	await runWorkflow(session, typeof workflowConfig.run === "function" ? await workflowConfig.run(session) : workflowConfig.run);
+}
+/**
+* Run a workflow's agent pipeline.
+*
+* This is the single execution path for all workflows — both skill-based
+* (revenue analytics) and framework-based (core integration). The
+* `WorkflowRun` controls what varies between them.
+*/
+async function runWorkflow(session, config) {
+	initLogFile();
+	logToFile(`[agent-runner] START ${config.integrationLabel}`);
+	if (session.debug) enableDebugLogs();
+	const skillsBaseUrl = getSkillsBaseUrl(session.localMcp);
+	if (!session.readinessResult) {
+		logToFile("[agent-runner] evaluating wizard readiness");
+		const readiness = await evaluateWizardReadiness();
+		logToFile(`[agent-runner] readiness=${readiness.decision}`);
+		if (readiness.decision === "no") await getUI().showBlockingOutage(readiness);
+		else if (readiness.decision === "yes_with_warnings") getUI().setReadinessWarnings(readiness);
+	}
+	const settingsConflicts = checkAllSettingsConflicts(session.installDir);
+	logToFile(`[agent-runner] settings conflicts: ${settingsConflicts.length > 0 ? settingsConflicts.map((c) => `${c.source}(${c.keys.join(",")})`).join("; ") : "none"}`);
+	if (settingsConflicts.length > 0) {
+		for (const conflict of settingsConflicts) {
+			const level = conflict.source === "managed" ? "org" : conflict.source;
+			analytics.wizardCapture("settings conflict detected", {
+				level,
+				keys: conflict.keys
+			});
+		}
+		await getUI().showSettingsOverride(settingsConflicts, () => backupAndFixClaudeSettings(session.installDir));
+		logToFile("[agent-runner] settings override resolved");
+	}
+	analytics.wizardCapture("agent started", {
+		integration: config.integrationLabel,
+		workflow: config.integrationLabel,
+		skill_id: config.skillId ?? null
+	});
+	logToFile("[agent-runner] starting OAuth");
+	const { projectApiKey, host, accessToken, projectId, cloudRegion } = await getOrAskForProjectData({
+		signup: session.signup,
+		ci: session.ci,
+		apiKey: session.apiKey,
+		projectId: session.projectId,
+		email: session.email,
+		region: session.region
+	});
+	session.credentials = {
+		accessToken,
+		projectApiKey,
+		host,
+		projectId
+	};
+	getUI().setCredentials(session.credentials);
+	let skillPath;
+	if (config.skillId) {
+		logToFile(`[agent-runner] installing skill ${config.skillId}`);
+		const installResult = await installSkillById(config.skillId, session.installDir, skillsBaseUrl);
+		if (installResult.kind !== "ok") {
+			await abortOnInstallFailure(config.integrationLabel, installResult);
+			return;
+		}
+		skillPath = installResult.path;
+		logToFile(`[agent-runner] skill installed at ${skillPath}`);
+	}
+	const spinner = getUI().spinner();
+	const wizardFlags = await analytics.getAllFlagsForWizard();
+	const wizardMetadata = buildWizardMetadata(wizardFlags);
+	const mcpUrl = session.localMcp ? "http://localhost:8787/mcp" : runtimeEnv("MCP_URL") || (cloudRegion === "eu" ? "https://mcp-eu.posthog.com/mcp" : "https://mcp.posthog.com/mcp");
+	const restoreSettings = () => restoreClaudeSettings(session.installDir);
+	getUI().onEnterScreen("outro", restoreSettings);
+	if (session.yaraReport) registerCleanup(() => {
+		const reportPath = writeScanReport();
+		if (reportPath) {
+			const summary = formatScanReport();
+			getUI().log.info(`YARA scan report: ${reportPath}${summary ?? ""}`);
+		}
+	});
+	getUI().startRun();
+	const agent = await initializeAgent({
+		workingDirectory: session.installDir,
+		posthogMcpUrl: mcpUrl,
+		posthogApiKey: accessToken,
+		posthogApiHost: host,
+		additionalMcpServers: config.additionalMcpServers,
+		detectPackageManager: config.detectPackageManager ?? detectNodePackageManagers,
+		skillsBaseUrl,
+		wizardFlags,
+		wizardMetadata
+	}, sessionToOptions(session));
+	const middleware = session.benchmark ? createBenchmarkPipeline(spinner, sessionToOptions(session)) : void 0;
+	const agentResult = await runAgent$1(agent, assemblePrompt(config, {
+		projectId,
+		projectApiKey,
+		host,
+		skillPath
+	}), sessionToOptions(session), spinner, {
+		estimatedDurationMinutes: config.estimatedDurationMinutes,
+		spinnerMessage: config.spinnerMessage,
+		successMessage: config.successMessage,
+		errorMessage: config.errorMessage ?? `${config.integrationLabel} failed`,
+		additionalFeatureQueue: config.additionalFeatureQueue ?? [],
+		abortCases: config.abortCases
+	}, middleware);
+	if (agentResult.error === "WIZARD_ABORT") {
+		const reason = agentResult.message ?? "";
+		const matched = config.abortCases?.find((c) => c.match.test(reason));
+		const outroData = matched ? {
+			kind: "error",
+			message: matched.message,
+			body: matched.body,
+			docsUrl: matched.docsUrl
+		} : {
+			kind: "error",
+			message: `${config.integrationLabel} aborted`,
+			body: reason || "The agent aborted the workflow.",
+			docsUrl: config.docsUrl
+		};
+		analytics.wizardCapture("agent aborted", {
+			integration: config.integrationLabel,
+			reason,
+			matched: matched?.message ?? null
+		});
+		await wizardAbort({
+			outroData,
+			error: new WizardError(`Agent aborted: ${reason}`, {
+				integration: config.integrationLabel,
+				error_type: "WIZARD_ABORT",
+				reason
+			})
+		});
+	}
+	if (agentResult.error === "WIZARD_MCP_MISSING") await wizardAbort({
+		message: `Could not access the PostHog MCP server
+
+The wizard was unable to connect to the PostHog MCP server.
+This could be due to a network issue or a configuration problem.
+
+Please try again, or check the documentation:\n${config.docsUrl}`,
+		error: new WizardError("Agent could not access PostHog MCP server", {
+			integration: config.integrationLabel,
+			error_type: "WIZARD_MCP_MISSING",
+			signal: AgentSignals.ERROR_MCP_MISSING
+		})
+	});
+	if (agentResult.error === "WIZARD_RESOURCE_MISSING") await wizardAbort({
+		message: `Could not access the setup resource
+
+This may indicate a version mismatch or a temporary service issue.
+
+Please try again, or check the documentation:\n${config.docsUrl}`,
+		error: new WizardError("Agent could not access setup resource", {
+			integration: config.integrationLabel,
+			error_type: "WIZARD_RESOURCE_MISSING",
+			signal: AgentSignals.ERROR_RESOURCE_MISSING
+		})
+	});
+	if (agentResult.error === "WIZARD_YARA_VIOLATION") await wizardAbort({
+		message: "Security violation detected.\nPlease report this to: wizard@posthog.com",
+		error: new WizardError("YARA scanner terminated session", {
+			integration: config.integrationLabel,
+			error_type: "WIZARD_YARA_VIOLATION"
+		})
+	});
+	if (agentResult.error === "WIZARD_RATE_LIMIT" || agentResult.error === "WIZARD_API_ERROR") {
+		analytics.wizardCapture("agent api error", {
+			integration: config.integrationLabel,
+			error_type: agentResult.error,
+			error_message: agentResult.message
+		});
+		await wizardAbort({
+			message: `API Error\n\n${agentResult.message || "Unknown error"}\n\nPlease report this to: wizard@posthog.com`,
+			error: new WizardError(`API error: ${agentResult.message}`, {
+				integration: config.integrationLabel,
+				error_type: agentResult.error
+			})
+		});
+	}
+	if (config.postRun) await config.postRun(session, {
+		accessToken,
+		projectApiKey,
+		host,
+		projectId
+	});
+	if (config.buildOutroData) session.outroData = config.buildOutroData(session, {
+		accessToken,
+		projectApiKey,
+		host,
+		projectId
+	}, cloudRegion);
+	else {
+		const continueUrl = session.signup ? `${getCloudUrlFromRegion(cloudRegion)}/products?source=wizard` : void 0;
+		const reportExists = existsSync(join(session.installDir, config.reportFile));
+		session.outroData = {
+			kind: "success",
+			message: config.successMessage,
+			reportFile: reportExists ? config.reportFile : void 0,
+			docsUrl: config.docsUrl,
+			continueUrl
+		};
+	}
+	getUI().outro(config.successMessage);
+	await analytics.shutdown("success");
+}
+async function abortOnInstallFailure(integrationLabel, result) {
+	if (result.kind === "ok") return;
+	await wizardAbort({
+		message: (() => {
+			switch (result.kind) {
+				case "menu-fetch-failed": return "Could not fetch the skill menu from context-mill.\nCheck your network connection and try again.";
+				case "skill-not-found": return `Could not find the "${result.skillId}" skill in the context-mill menu.\nPlease try again later.`;
+				case "download-failed": return `Failed to install skill: ${result.message}\nPlease try again.`;
+			}
+		})(),
+		error: new WizardError(`Skill install failed: ${result.kind}`, {
+			integration: integrationLabel,
+			error_type: result.kind
+		})
+	});
+}
+//#endregion
+export { runAgent };
+
+//# sourceMappingURL=agent-runner-D_eXxXPp.js.map