@posthog/wizard 2.80.0 → 2.81.0

package/dist/agent-BkBbVuNq.js

@@ -1,3189 +0,0 @@
-import { U as installSkillById, ct as LONGER_ASK_TIMEOUT_MS, et as fetchSkillMenu, i as runAgent$1, lt as shouldDisableAsk, nt as createWizardAskBridge, r as initializeAgent, ut as createTriageLLMProvider } from "./agent-interface-CzyCmp7q.js";
-import { n as ErrorCodes } from "./emit-BSetXzDV.js";
-import { a as getLogFilePath, h as RUN_SURFACE, l as WIZARD_BENCHMARK_FILE, s as logToFile, t as configureLogFile, u as WIZARD_LOG_FILE, v as runtimeEnv } from "./debug-DyARf5TF.js";
-import { t as VERSION } from "./version-5_ydHkM6.js";
-import { B as WIZARD_CONTACT_EMAIL, G as WIZARD_ORCHESTRATOR_FLAG_KEY, J as WIZARD_PROVISIONING_SCOPES, K as WIZARD_ORCHESTRATOR_OVERRIDE_FLAG_KEY, L as SONNET_5_MODEL, R as Sequence, S as Harness, W as WIZARD_OAUTH_SCOPES, Z as WIZARD_SELF_DRIVING_USE_PI_HARNESS_FLAG_KEY, _ as GPT5_6_LUNA_MODEL, b as HAIKU_MODEL, l as DEFAULT_AGENT_MODEL, q as WIZARD_ORCHESTRATOR_SEEDED_TASKS_FLAG_KEY, v as GPT5_6_SOL_MODEL, y as GPT5_6_TERRA_MODEL } from "./constants-DO4X70po.js";
-import "./wizard-session-BYw6LzpS.js";
-import { a as ciExcludedTaskTypes, n as analytics } from "./analytics-B6q5PN7a.js";
-import { a as WizardError, r as skillErrorCode, t as classifyRunFailure } from "./errors-C2domSkK.js";
-import { s as detectNodePackageManagers } from "./setup-utils-ChXXTi1m.js";
-import { n as currentAccessToken } from "./oauth-session-D-RfcVmr.js";
-import { f as gatewayAuth, s as AgentSignals } from "./gateway-BmjYUSua.js";
-import { a as requireKnownModel, o as triageModelFor, r as isValidModel } from "./models-Dba8ITeo.js";
-import { n as mcpUrlFor } from "./host-resolution-DVSb7kXb.js";
-import { a as piBackend, d as createEmitSpinner, f as createProgressCollector, l as createAioCapture, u as createEmitLog } from "./pi-B5YTBRDv.js";
-import { a as flushScanReport, s as formatYaraAbortMessage } from "./yara-hooks-C3L6lBij.js";
-import { _ as TaskStatus, d as uncoveredBySink, h as SkipReason, m as QueueStore, p as QUEUE_DIR_NAME, u as dependencyClosure } from "./queue-tools-knnPQP0e.js";
-import { a as assembleTaskPrompt, d as taskModelSpec, i as assembleSeedPrompt, n as agentRunTools, o as loadAgentRegistry, s as promptModelFor, t as ASK_TOOL, u as resolveTask } from "./agent-prompt-loader-4wMxlYSX.js";
-import fs, { cpSync, existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "fs";
-import * as path$1 from "path";
-import path from "path";
-import { randomUUID } from "crypto";
-import { z } from "zod";
-//#region src/agent/runner/shared/bootstrap.ts
-/**
-* Shared preparation for the runner pipeline.
-*
-* Runs before the fork into the linear or orchestrator arm: logging targets,
-* the gateway mint and the scan-triage classifier built on it. Everything the
-* caller must decide first — health gates, settings conflicts, authentication,
-* the AI opt-in gate, post-auth gates, feature flags, run tags, token refresh —
-* arrives already resolved in `RunConfig` and `RunInput`.
-*/
-/** The option bag the agent interface and the middleware read. */
-function runOptions(input) {
-	return {
-		installDir: input.installDir,
-		debug: input.flags.debug,
-		signup: input.flags.signup,
-		ci: input.flags.ci,
-		benchmark: input.flags.benchmark,
-		projectId: input.host.projectId,
-		apiKey: input.host.apiKey,
-		yaraReport: input.flags.yaraReport
-	};
-}
-/**
-* Shared setup for both arms: logging targets, then the gateway mint and the
-* triage classifier. Throws when the mint is refused, so the run fails before
-* any agent starts — the caller maps that the way it maps any unexpected error.
-*/
-async function prepareRun(config, input) {
-	const { skillsBaseUrl } = config;
-	logToFile(`[agent-runner] targets build=${VERSION} skills=${skillsBaseUrl} mcp=${mcpUrlFor(input.flags.localMcp)} posthog=${input.host.baseUrl ?? "region-resolved"}`);
-	const { credentials } = input;
-	const { wizardFlags, wizardFlagPayloads, wizardMetadata, programId } = config;
-	const currentGatewayAuth = () => currentAccessToken(credentials).then((token) => gatewayAuth(credentials.host, token, programId));
-	await currentGatewayAuth();
-	return {
-		skillsBaseUrl,
-		credentials,
-		programId,
-		wizardFlags,
-		wizardFlagPayloads,
-		wizardMetadata,
-		project: input.project,
-		triageProvider: createTriageLLMProvider(async () => {
-			const auth = await currentGatewayAuth();
-			return {
-				baseURL: auth.gatewayUrl,
-				authToken: auth.token,
-				teamId: auth.teamId,
-				wizardMetadata: {
-					...wizardMetadata,
-					call_type: "yara-triage"
-				},
-				wizardFlags
-			};
-		}, config.binding.harness)
-	};
-}
-const ACTIVITY_LINE_CHARS = 100;
-function createTranscriptTail(emit) {
-	const collected = [];
-	let collectedChars = 0;
-	let resultText = "";
-	const collect = (text) => {
-		collected.push(text);
-		collectedChars += text.length;
-		while (collectedChars > 262144 && collected.length > 1) collectedChars -= collected.shift()?.length ?? 0;
-	};
-	const activity = (line) => emit({
-		kind: "activity",
-		line
-	});
-	return {
-		onMessage(message) {
-			if (message?.type === "assistant") {
-				const content = message.message?.content;
-				if (!Array.isArray(content)) return;
-				for (const block of content) if (block?.type === "text" && typeof block.text === "string") {
-					collect(block.text);
-					const line = block.text.trim();
-					if (line) activity(line.length > ACTIVITY_LINE_CHARS ? `${line.slice(0, ACTIVITY_LINE_CHARS)}…` : line);
-				} else if (block?.type === "tool_use") activity(formatToolUse(block));
-			} else if (message?.type === "result" && typeof message.result === "string") resultText = message.result;
-		},
-		finalize: () => void 0,
-		text: () => `${collected.join("\n")}\n${resultText}`
-	};
-}
-/** Put the tail in front of any other middleware, so both see every message. */
-function withTranscript(middleware, transcript) {
-	if (!transcript) return middleware;
-	if (!middleware) return transcript;
-	return {
-		onMessage(message) {
-			transcript.onMessage(message);
-			middleware.onMessage(message);
-		},
-		finalize(resultMessage, totalDurationMs) {
-			transcript.finalize(resultMessage, totalDurationMs);
-			return middleware.finalize(resultMessage, totalDurationMs);
-		}
-	};
-}
-function formatToolUse(block) {
-	const name = typeof block?.name === "string" ? block.name : "tool";
-	const input = block?.input ?? {};
-	const detail = input.file_path || input.pattern || input.path || "";
-	return detail ? `${name} ${detail}` : name;
-}
-//#endregion
-//#region src/agent/runner/harness/anthropic/index.ts
-const anthropicBackend = {
-	name: "anthropic",
-	async run(inputs) {
-		const { config: runConfig, input, boot, emit, prompt, spinner, askBridge, middleware, model, structured } = inputs;
-		const config = runConfig.run;
-		const { skillsBaseUrl, credentials, wizardFlags, wizardMetadata } = boot;
-		const { accessToken, host, projectApiKey } = credentials;
-		const log = createEmitLog(emit);
-		const capture = createAioCapture({
-			enabled: input.flags.captureAio,
-			projectApiKey,
-			apiHost: host.apiHost,
-			runTags: wizardMetadata
-		});
-		if (!structured) log.step("Initializing Claude agent...");
-		const agent = await initializeAgent({
-			workingDirectory: input.installDir,
-			posthogMcpUrl: host.mcpUrl,
-			posthogApiKey: accessToken,
-			currentPosthogApiKey: () => currentAccessToken(credentials),
-			host,
-			additionalMcpServers: config.additionalMcpServers,
-			detectPackageManager: config.detectPackageManager ?? detectNodePackageManagers,
-			skillsBaseUrl,
-			wizardFlags,
-			wizardMetadata,
-			programId: boot.programId,
-			integrationLabel: config.integrationLabel,
-			askBridge,
-			getPendingQuestion: askBridge?.getPendingQuestion,
-			askMaxQuestions: config.maxQuestions,
-			readOnly: config.readOnly,
-			allowedTools: runConfig.allowedTools,
-			disallowedTools: runConfig.disallowedTools,
-			modelOverride: model,
-			outputFormat: structured && {
-				type: "json_schema",
-				schema: structured.schema
-			},
-			capture,
-			emit
-		}, runOptions(input));
-		if (!structured) {
-			log.step(`Verbose logs: ${getLogFilePath()}`);
-			log.success("Agent initialized. Let's get cooking!");
-		}
-		logToFile("[agent-runner] agent initialized");
-		return runAgent$1({
-			...agent,
-			signal: inputs.signal
-		}, prompt, runOptions(input), spinner, {
-			timeoutMs: structured?.timeoutMs,
-			estimatedDurationMinutes: config.estimatedDurationMinutes,
-			spinnerMessage: config.spinnerMessage,
-			successMessage: config.successMessage,
-			errorMessage: config.errorMessage ?? `${config.integrationLabel} failed`,
-			abortCases: config.abortCases,
-			emitStepEvents: config.trackStepProgress ?? false,
-			resolveStepKey: config.resolveStepKey,
-			requestRemark: structured ? false : config.requestRemark,
-			triageProvider: boot.triageProvider
-		}, middleware);
-	},
-	async runTask(inputs) {
-		const { config, input, boot, emit, prompt, spinner, model, allowedTools, disallowedTools, askBridge, orchestrator, spinnerMessage, successMessage, errorMessage, requestRemark, analyticsProperties } = inputs;
-		const options = runOptions(input);
-		const capture = createAioCapture({
-			enabled: input.flags.captureAio,
-			projectApiKey: boot.credentials.projectApiKey,
-			apiHost: boot.credentials.host.apiHost,
-			runTags: boot.wizardMetadata
-		});
-		return runAgent$1({
-			...await initializeAgent({
-				workingDirectory: input.installDir,
-				posthogMcpUrl: boot.credentials.host.mcpUrl,
-				posthogApiKey: boot.credentials.accessToken,
-				currentPosthogApiKey: () => currentAccessToken(boot.credentials),
-				host: boot.credentials.host,
-				detectPackageManager: detectNodePackageManagers,
-				skillsBaseUrl: boot.skillsBaseUrl,
-				programId: boot.programId,
-				wizardFlags: boot.wizardFlags,
-				wizardMetadata: boot.wizardMetadata,
-				integrationLabel: config.programId,
-				askBridge,
-				getPendingQuestion: askBridge?.getPendingQuestion,
-				orchestrator,
-				capture,
-				emit
-			}, options),
-			model,
-			allowedTools,
-			disallowedTools,
-			signal: inputs.signal
-		}, prompt, options, spinner, {
-			spinnerMessage,
-			successMessage,
-			errorMessage,
-			requestRemark,
-			analyticsProperties
-		});
-	}
-};
-//#endregion
-//#region src/agent/runner/switchboard/flags/orchestrator.ts
-/** Orchestrator gate: wizard-orchestrator on/off. On routes the declared programs to the orchestrator on pi; every model/effort comes from prompt frontmatter. */
-const ORCHESTRATOR_SEQUENCE_ROUTE = {
-	programs: ["posthog-integration"],
-	flag: WIZARD_ORCHESTRATOR_FLAG_KEY,
-	sequence: "orchestrator"
-};
-/** Same flag, harness axis: the orchestrator drives tasks through pi. */
-const ORCHESTRATOR_HARNESS_ROUTE = {
-	program: "posthog-integration",
-	flags: {
-		useFlag: WIZARD_ORCHESTRATOR_FLAG_KEY,
-		harness: "pi"
-	}
-};
-/** Same programs, per-stage overrides: the variant payload (`{stage: {model?, effort?}}`) outranks prompt frontmatter for the stages it names. */
-const ORCHESTRATOR_STAGE_OVERRIDES = {
-	programs: ORCHESTRATOR_SEQUENCE_ROUTE.programs,
-	flag: WIZARD_ORCHESTRATOR_OVERRIDE_FLAG_KEY
-};
-/**
-* Kill switch for the runner-seeded task mechanism (the optional warehouse
-* step). Off or unset, the orchestrator queues nothing itself and the run is
-* identical to a project with no detected sources.
-*/
-function areSeededTasksEnabled(flags = {}) {
-	return flags[WIZARD_ORCHESTRATOR_SEEDED_TASKS_FLAG_KEY] === "true";
-}
-/** Raw flag read — for telemetry/log lines only, never for routing. */
-function isOrchestratorEnabled(flags = {}) {
-	return flags[ORCHESTRATOR_SEQUENCE_ROUTE.flag] === "true";
-}
-//#endregion
-//#region src/agent/runner/switchboard/flags/self-driving.ts
-/**
-* Self-driving pi experiment.
-*
-* Flag:   wizard-self-driving-use-pi-harness (bool; payload `{model, effort?,
-*         harness?, sequence?}`)
-* Routes: ONLY `self-driving` — any axis the payload pins. A missing or
-*         invalid payload keeps the non-flagged binding default.
-*/
-const SELF_DRIVING_EXPERIMENT = {
-	program: "self-driving",
-	flags: { useFlag: WIZARD_SELF_DRIVING_USE_PI_HARNESS_FLAG_KEY }
-};
-//#endregion
-//#region src/agent/runner/switchboard/flags/schemes.ts
-/**
-* Flag config schemes — the shapes a PostHog flag set can take to route a
-* program to the pi harness, plus the shared vocabulary and the per-config
-* resolution. Experiment modules in this folder declare *which* flags they
-* use; this module owns *how* a config resolves to a route.
-*/
-/** Model variant key → gateway id. A key the gateway no longer mints is dropped
-* rather than re-aimed: the payload then fails validation and the binding
-* default stands, which is visible in the log instead of silently rerouting. */
-const MODEL_FLAG_VARIANTS = {
-	"gpt-5-6-luna": GPT5_6_LUNA_MODEL,
-	"gpt-5-6-terra": GPT5_6_TERRA_MODEL,
-	"gpt-5-6-sol": GPT5_6_SOL_MODEL,
-	"sonnet-5": SONNET_5_MODEL
-};
-/** Valid effort variants; anything else leaves the model's table default. */
-const EFFORT_FLAG_VARIANTS = [
-	"minimal",
-	"low",
-	"medium",
-	"high",
-	"xhigh"
-];
-/** Variant key validated against the shared vocabulary, transformed to its gateway id. */
-const modelVariantSchema = z.string().refine((key) => key in MODEL_FLAG_VARIANTS).transform((key) => MODEL_FLAG_VARIANTS[key]);
-/** `{model, effort?, harness?, sequence?}` payload shape; extra keys tolerated for forward compat. */
-const payloadConfigFlagSchema = z.object({
-	model: modelVariantSchema,
-	effort: z.enum(EFFORT_FLAG_VARIANTS).optional(),
-	harness: z.nativeEnum(Harness).optional(),
-	sequence: z.nativeEnum(Sequence).optional()
-});
-/**
-* PostHog serves a variant's payload as a JSON string, e.g. the
-* wizard-orchestrator-override `terra-review` variant arrives as
-* `'{"review":{"model":"gpt-5-6-terra","effort":"medium"}}'`; local CI
-* overrides inject the same payloads as already-parsed objects. Coerce both
-* to the value; anything unparseable is undefined.
-*/
-function coerceJson(raw) {
-	if (typeof raw !== "string") return raw;
-	try {
-		return JSON.parse(raw);
-	} catch {
-		return;
-	}
-}
-/** Per-stage overrides keyed by stage; a whole-payload parse failure fails closed to frontmatter everywhere. */
-const stageOverridesSchema = z.record(z.object({
-	model: modelVariantSchema.optional(),
-	effort: z.enum(EFFORT_FLAG_VARIANTS).optional()
-}));
-/** Validate a stage-override payload (object or JSON string); undefined on any unexpected shape. */
-function stageOverridesFromPayload(raw) {
-	const parsed = stageOverridesSchema.safeParse(coerceJson(raw));
-	return parsed.success ? parsed.data : void 0;
-}
-/** Validate a payload (object or JSON string) into a route; undefined on any unexpected shape. */
-function parseFlagPayload(raw) {
-	const parsed = payloadConfigFlagSchema.safeParse(coerceJson(raw));
-	if (!parsed.success) return void 0;
-	return {
-		model: parsed.data.model,
-		thinkingLevel: parsed.data.effort,
-		harness: parsed.data.harness,
-		sequence: parsed.data.sequence
-	};
-}
-/**
-* Resolve one config against the flag snapshot, or undefined when it doesn't
-* validly route: use flag off, or a payload that fails validation — the
-* caller then keeps the non-flagged binding default.
-*/
-function routeFromConfigFlag(cfg, flags, flagPayloads) {
-	if (flags[cfg.useFlag] !== "true") return void 0;
-	if (cfg.harness) return { harness: cfg.harness };
-	const route = parseFlagPayload(flagPayloads?.[cfg.useFlag]);
-	if (!route) logToFile(`[switchboard] ${cfg.useFlag} on but payload missing/invalid — keeping the non-flagged default`);
-	return route;
-}
-//#endregion
-//#region src/agent/runner/switchboard/flags/index.ts
-/**
-* Switchboard flags, one module per experiment. Every experiment declares its
-* own scope — which program(s) its flags route — so the flag→program mapping
-* is readable per file, never implied. `schemes.ts` owns the shared config
-* shapes and resolution.
-*/
-/** Every experiment on each axis. An experiment routes ONLY by being listed here, and only for the programs it declares. */
-const HARNESS_EXPERIMENTS = [ORCHESTRATOR_HARNESS_ROUTE, SELF_DRIVING_EXPERIMENT];
-const SEQUENCE_EXPERIMENTS = [ORCHESTRATOR_SEQUENCE_ROUTE];
-/** The flag-driven route for a program, or undefined when no experiment covers it or its flags don't validly route. */
-function resolveFlagRoute(program, flags, flagPayloads) {
-	const experiment = HARNESS_EXPERIMENTS.find((e) => e.program === program);
-	return experiment && routeFromConfigFlag(experiment.flags, flags, flagPayloads);
-}
-/** The flag-driven sequence for a program, or undefined when no sequence experiment covers it with its flag on. Surface/build scoping is the flag's own job (see `flagPersonProperties`). */
-function resolveFlagSequence(program, flags) {
-	return SEQUENCE_EXPERIMENTS.find((e) => e.programs.includes(program) && flags[e.flag] === "true")?.sequence;
-}
-/** The per-stage overrides for a program's run, or undefined (prompt frontmatter stays). Applied once, where the agent prompts are loaded. */
-function resolveStageOverrides(program, flags, flagPayloads) {
-	if (RUN_SURFACE === "cloud") return void 0;
-	const exp = ORCHESTRATOR_STAGE_OVERRIDES;
-	if (!exp.programs.includes(program)) return void 0;
-	const variant = flags[exp.flag];
-	if (!variant || variant === "false") return void 0;
-	const overrides = stageOverridesFromPayload(flagPayloads?.[exp.flag]);
-	if (!overrides) logToFile(`[switchboard] ${exp.flag}=${variant} but payload missing/invalid — keeping frontmatter`);
-	return overrides;
-}
-//#endregion
-//#region src/agent/runner/switchboard/harness.ts
-/**
-* Harness axis: registry, middleware, resolver. Mirrors `sequence.ts`.
-*/
-const HARNESS_OPTIONS = {
-	["anthropic"]: anthropicBackend,
-	["pi"]: piBackend
-};
-function getHarness(name) {
-	const harness = HARNESS_OPTIONS[name];
-	if (!harness) throw new Error(`No harness registered for '${name}'.`);
-	return harness;
-}
-/**
-* PostHog-flag routing to pi (see `./flags`). No valid route — flag off, no
-* config, or an invalid payload — keeps the non-flagged binding default.
-*/
-const flagRunnerOverride = (ctx, next) => {
-	const pick = next();
-	const route = resolveFlagRoute(ctx.program, ctx.flags, ctx.flagPayloads);
-	if (!route) return pick;
-	if (ctx.trace) {
-		ctx.trace.harness = "flag";
-		if (route.model) ctx.trace.model = "flag";
-	}
-	return {
-		harness: route.harness ?? "pi",
-		model: route.model ?? pick.model,
-		thinkingLevel: route.thinkingLevel ?? pick.thinkingLevel
-	};
-};
-const HARNESS_MIDDLEWARE = [...[], flagRunnerOverride];
-/**
-* Resolve the harness for a role. Linear callers omit `role`; orchestrator
-* callers pass `'seed'` or `task.type`. `contextMillOverride[role]` overlays.
-*/
-function resolveHarness(ctx, role = "default") {
-	const pick = runChain(HARNESS_MIDDLEWARE, ctx, () => {
-		if (ctx.trace) Object.assign(ctx.trace, {
-			harness: "binding",
-			model: "binding"
-		});
-		const binding = PROGRAM_BINDINGS[ctx.program] ?? DEFAULT_BINDING;
-		return {
-			harness: binding.harness,
-			model: binding.model,
-			thinkingLevel: binding.thinkingLevel,
-			...binding.contextMillOverride?.[role]
-		};
-	});
-	logToFile(`[switchboard] resolved: program=${ctx.program} harness=${pick.harness}${ctx.trace?.harness ? ` (${ctx.trace.harness})` : ""} model=${pick.model}${ctx.trace?.model ? ` (${ctx.trace.model})` : ""}`);
-	return pick;
-}
-//#endregion
-//#region src/agent/middleware/phase-detector.ts
-/** Phase transitions from [STATUS] in assistant text. Keep in sync with program "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/agent/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/agent/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: WIZARD_BENCHMARK_FILE,
-		benchmarkEnabled: true,
-		logPath: WIZARD_LOG_FILE,
-		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/agent/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/agent/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/agent/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/agent/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/agent/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/shared/token-pricing.ts
-/**
-* Shared exact-match USD-per-token pricing by model id, and the cost formula
-* applied to a token usage delta.
-*
-* Single source of truth for both the benchmark's `CostTrackerPlugin`
-* (`@lib/middleware/benchmarks/cost-tracker`) and the live token/cost HUD
-* (`agent-interface.ts`'s per-turn usage accumulation), so the two estimates
-* never drift apart. Both reconcile against the SDK's own authoritative
-* `total_cost_usd` once the run finishes — this table only prices the
-* *live-updating* estimate shown while the agent is still running.
-*
-* Model-aware because a run's model isn't fixed: `AgentConfig.modelOverride`
-* switches specific programs to Haiku (e.g. source-map detection), and the
-* SDK reports a `model` string on every individual assistant turn (subagents
-* dispatched via the Agent tool can run on a different model than the main
-* session).
-*
-* Deliberately matched by *exact* model id, not family name (no
-* `model.includes('opus')`-style fallback): different versions of the same
-* family are priced differently — e.g. Claude Opus 4.5 ($5/$25 per Mtok) is
-* half of Opus 4.1's rate ($15/$75) — so matching on "opus" or "sonnet"
-* alone silently mis-prices a newer/older sibling at the wrong rate. The
-* only normalization applied is stripping a trailing release-date suffix
-* (`stripDateSuffix`), since Anthropic's dated and undated ids for the
-* *same* version always carry the same price (verified for every entry
-* below). Claude Sonnet 5 is the one exception with a *time-dependent*
-* price — see `sonnet5Price` — rather than a fixed table entry.
-*
-* Prices verified against https://models.dev/api.json (Anthropic section)
-* on 2026-07-01 — re-verify there when adding an entry or bumping
-* DEFAULT_AGENT_MODEL/HAIKU_MODEL, since this table isn't fetched live.
-*/
-/**
-* `cacheCreation1h` isn't published by models.dev (it only has one
-* cache-write rate); extrapolated at `input × 2`, the ratio that holds for
-* every model below (mirrors `cacheCreation5m` = `input × 1.25`, `cacheRead`
-* = `input × 0.1` — Anthropic's standard prompt-caching multipliers).
-* Rounded to 6 decimal places to clean up binary float noise from the
-* multiplication (e.g. `3 * 0.1` is `0.30000000000000004`, not `0.3`) — well
-* past cent-level precision at the 1M-token scale these prices are quoted at.
-*/
-function pricingFromInput(input, output) {
-	const round = (n) => Math.round(n * 1e6) / 1e6;
-	return {
-		input,
-		output,
-		cacheRead: round(input * .1),
-		cacheCreation5m: round(input * 1.25),
-		cacheCreation1h: round(input * 2)
-	};
-}
-/**
-* Exact-match price table, keyed by the *undated* model id prefix —
-* `pricePerMtokForModel` strips a dated suffix before falling back to this
-* table, so a dated Anthropic id resolves via its undated entry without
-* needing a duplicate key. Ids the wizard no longer dispatches on stay
-* priced, since a subagent turn or the SDK can still report one (a turn on
-* an id NOT in this table contributes $0 to the live estimate rather than
-* guessing, see `pricePerMtokForModel`).
-*
-* `SONNET_5_MODEL` is intentionally absent: its price is time-dependent
-* (promotional launch discount), so `pricePerMtokForModel` resolves it via
-* `sonnet5Price`. It is also `DEFAULT_AGENT_MODEL`, so the no-model fallback
-* goes through that branch.
-*/
-const PRICE_TABLE = {
-	"claude-sonnet-4-6": pricingFromInput(3, 15),
-	[HAIKU_MODEL]: pricingFromInput(1, 5),
-	"claude-opus-4-5": pricingFromInput(5, 25)
-};
-/**
-* Claude Sonnet 5 launched at a promotional discount through 2026-08-31
-* UTC; from 2026-09-01 it reverts to the same rate as Sonnet 4.6 ($3/$15)
-* — not a coincidence, Anthropic prices it identically to 4.6 once the
-* promo ends. Re-verify against https://models.dev/api.json if this ever
-* looks off, and fold this special case into a flat `PRICE_TABLE` entry at
-* the post-promo rate once the window is well past.
-*/
-const SONNET_5_PROMO_ENDS_UTC = /* @__PURE__ */ new Date("2026-09-01T00:00:00Z");
-function sonnet5Price(now) {
-	return now < SONNET_5_PROMO_ENDS_UTC ? pricingFromInput(2, 10) : pricingFromInput(3, 15);
-}
-/** Strips a trailing 8-digit release-date suffix (e.g. `-20251001`) — never
-*  the version segment, so differently-versioned models are never conflated.
-*  `claude-haiku-4-5-20251001` → `claude-haiku-4-5`; `claude-sonnet-4-6` (no
-*  date suffix) is returned unchanged. */
-function stripDateSuffix(model) {
-	return model.replace(/-\d{8}$/, "");
-}
-/**
-* Exact-match pricing lookup. `undefined` model (a caller with no model
-* context, e.g. the benchmark's `CostTrackerPlugin`) falls back to
-* `DEFAULT_AGENT_MODEL`'s price, the default for interactive runs. A
-* *given* but unrecognized model id returns `undefined` rather than
-* guessing from its family name — seeing `undefined` and skipping that
-* delta is strictly more accurate than the family-fallback this replaced,
-* which silently priced e.g. every Opus turn at Opus 4.1's rate.
-*
-* `now` is injectable (defaults to the real clock) only so
-* `sonnet5Price`'s promo-window check is deterministic in tests — no
-* other entry in this table is time-dependent.
-*/
-function pricePerMtokForModel(model, now = /* @__PURE__ */ new Date()) {
-	const id = model ?? "claude-sonnet-5";
-	const undated = stripDateSuffix(id);
-	if (undated === "claude-sonnet-5") return sonnet5Price(now);
-	return PRICE_TABLE[id] ?? PRICE_TABLE[undated];
-}
-/**
-* Cost in USD for one usage delta, priced at `usage.model`'s exact rates
-* (see `pricePerMtokForModel`) — 0 when `model` is given but not in the
-* table, rather than guessing. `cacheCreation5m`/`cacheCreation1h` come from
-* the SDK's `usage.cache_creation` breakdown, which is only reported on
-* some turns — when both are 0, `cacheCreationTokens` (the plain
-* `cache_creation_input_tokens` total) is priced at the 5m rate instead, so
-* a turn without the breakdown still gets a reasonable estimate rather than
-* being priced at $0.
-*
-* Takes the same shape as `TokenUsageDelta` (`@ui/wizard-ui`) so a caller
-* that already has one — `WizardStore.addTokenUsage` — can pass it straight
-* through instead of re-listing its fields in a fixed positional order.
-*/
-function computeTokenCostUsd(usage) {
-	const price = pricePerMtokForModel(usage.model);
-	if (!price) return 0;
-	const hasBreakdown = usage.cacheCreation5m > 0 || usage.cacheCreation1h > 0;
-	return usage.inputTokens * (price.input / 1e6) + usage.outputTokens * (price.output / 1e6) + usage.cacheReadTokens * (price.cacheRead / 1e6) + (hasBreakdown ? usage.cacheCreation5m * (price.cacheCreation5m / 1e6) + usage.cacheCreation1h * (price.cacheCreation1h / 1e6) : usage.cacheCreationTokens * (price.cacheCreation5m / 1e6));
-}
-/**
-* Shared display formatters for the hidden Ctrl+T HUD (`TokenCostHud`) and
-* the post-exit scrollback line (`exit-line.ts`) — kept here, not in either
-* of those files, since `exit-line.ts` is deliberately free of `ink`/React
-* imports (it must stay a pure, unit-testable function), and importing a
-* named export from a `.tsx` file would pull `ink` into its module graph
-* anyway. This module has no such dependency.
-*/
-function formatTokenCount(n) {
-	if (n >= 1e6) return `${(n / 1e6).toFixed(2)}M`;
-	if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
-	return n.toLocaleString();
-}
-function formatCostUsd(usd) {
-	if (usd > 0 && usd < .01) return `$${usd.toFixed(4)}`;
-	return `$${usd.toFixed(2)}`;
-}
-//#endregion
-//#region src/agent/middleware/benchmarks/cost-tracker.ts
-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 = computeTokenCostUsd({
-			inputTokens: Math.max(0, totalIn - read - creation),
-			outputTokens: tokenSnap?.outputTokens ?? 0,
-			cacheReadTokens: read,
-			cacheCreation5m: c5m,
-			cacheCreation1h: c1h,
-			cacheCreationTokens: 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 = computeTokenCostUsd({
-			inputTokens: Math.max(0, totalIn - read - creation),
-			outputTokens: tokenSnap?.outputTokens ?? 0,
-			cacheReadTokens: read,
-			cacheCreation5m: c5m,
-			cacheCreation1h: c1h,
-			cacheCreationTokens: 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/agent/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/agent/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;
-	info;
-	constructor(spinner, emit) {
-		this.spinner = spinner;
-		this.info = (message) => emit({
-			kind: "log",
-			level: "info",
-			message
-		});
-	}
-	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}`);
-		this.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;
-		this.info("");
-		this.info(`◇ ${AgentSignals.BENCHMARK} ${phaseCount} phases in ${fmtDuration(totalDurationMs)}, cost: ${fmtCost(totalCost)}`);
-		this.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)}`);
-		this.info("");
-		this.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) this.info(printPhase(stats));
-		}
-		this.info("");
-	}
-};
-//#endregion
-//#region src/agent/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;
-	info;
-	constructor(outputPath, emit) {
-		this.outputPath = outputPath;
-		this.info = (message) => emit({
-			kind: "log",
-			level: "info",
-			message
-		});
-	}
-	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}`);
-			this.info(`● ${AgentSignals.BENCHMARK} Results written to ${this.outputPath}`);
-		} catch (error) {
-			logToFile("Failed to write benchmark data:", error);
-		}
-	}
-};
-//#endregion
-//#region src/agent/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, opts.emit),
-	jsonWriter: (opts) => new JsonWriterPlugin(opts.outputPath, opts.emit)
-};
-/**
-* 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/agent/middleware/benchmark.ts
-/**
-* Create a middleware pipeline configured for benchmarking.
-* Loads .benchmark-config.json from the install dir, falls back to defaults.
-*/
-function createBenchmarkPipeline(emit, spinner, options, configOverride) {
-	const config = configOverride ?? loadBenchmarkConfig(options.installDir);
-	const info = (message) => emit({
-		kind: "log",
-		level: "info",
-		message
-	});
-	configureLogFile({
-		path: config.output.logPath,
-		enabled: config.output.logEnabled
-	});
-	const plugins = createPluginsFromConfig(config, {
-		emit,
-		spinner,
-		phased: false,
-		outputPath: config.output.benchmarkPath
-	});
-	if (!config.output.suppressWizardLogs) {
-		info(`${AgentSignals.BENCHMARK} Verbose logs: ${getLogFilePath()}`);
-		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/agent/error-map.ts
-const AGENT_ERROR_CODE = {
-	["WIZARD_AGENTIC_DETECTION_TIMEOUT"]: ErrorCodes.AgenticDetectionTimeout,
-	["WIZARD_MCP_MISSING"]: ErrorCodes.AgentMcpMissing,
-	["WIZARD_RESOURCE_MISSING"]: ErrorCodes.AgentResourceMissing,
-	["WIZARD_RATE_LIMIT"]: ErrorCodes.AgentRateLimit,
-	["WIZARD_API_ERROR"]: ErrorCodes.AgentApiError,
-	["WIZARD_YARA_VIOLATION"]: ErrorCodes.AgentYaraViolation,
-	["WIZARD_ABORT"]: ErrorCodes.AgentAbort,
-	["WIZARD_NO_PROGRESS"]: ErrorCodes.AgentNoProgress,
-	["WIZARD_INVALID_STRUCTURED_OUTPUT"]: ErrorCodes.AgentInvalidStructuredOutput,
-	["WIZARD_INCOMPLETE_TASKS"]: ErrorCodes.AgentIncompleteTasks
-};
-//#endregion
-//#region src/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.apiHost}`;
-}
-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 program'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/agent/runner/shared/errors.ts
-const failed = (failure) => ({
-	outcome: "failed",
-	failure
-});
-/** The failure a skill install error decides. The caller reports and exits. */
-function installFailure(integrationLabel, result) {
-	const code = skillErrorCode(result) ?? ErrorCodes.InternalUnhandled;
-	return {
-		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.`;
-			}
-		})(),
-		code,
-		detail: {
-			integration: integrationLabel,
-			error_type: result.kind,
-			platform: process.platform,
-			...result.kind === "download-failed" ? { error_detail: result.message.slice(0, 500) } : {}
-		}
-	};
-}
-//#endregion
-//#region src/agent/runner/shared/ask.ts
-/**
-* The ask bridge over an injected answerer.
-*
-* `createWizardAskBridge` already owns request ids, the timeout race, the
-* `__cancelled__` sentinel and the analytics; it only ever needed a
-* `showQuestion` that honours each question's own signal. Here that comes from
-* `AgentInteraction` instead of `getUI()`. With no answerer there is no bridge,
-* so `wizard_ask` reports its existing "not available" error rather than
-* hanging on a question nobody can see.
-*/
-function createAskBridge(interaction, options) {
-	const ask = interaction?.ask;
-	if (!ask) return void 0;
-	return createWizardAskBridge({
-		getSource: options.getSource,
-		showQuestion: (question, context) => {
-			options.beforeShow?.();
-			return ask(question, context);
-		},
-		richLinks: options.richLinks,
-		timeoutMs: options.timeoutMs,
-		signal: options.signal
-	});
-}
-//#endregion
-//#region src/agent/runner/sequence/linear.ts
-async function runLinearProgram(context) {
-	const controller = new AbortController();
-	const abortFromHost = () => controller.abort();
-	context.signal?.addEventListener("abort", abortFromHost, { once: true });
-	if (context.signal?.aborted) abortFromHost();
-	try {
-		return await executeLinear(context, controller.signal);
-	} finally {
-		context.signal?.removeEventListener("abort", abortFromHost);
-		controller.abort();
-	}
-}
-/** The caller's `signal` decides the outcome; `runSignal` also ends with the run. */
-async function executeLinear({ config, input, boot, emit, interaction, signal, transcript }, runSignal) {
-	const { run, composed } = config;
-	const { skillsBaseUrl, credentials, project } = boot;
-	const { projectApiKey, host, projectId } = credentials;
-	const aborted = () => ({
-		outcome: "aborted",
-		failure: {
-			code: ErrorCodes.AgentAbort,
-			message: "Agent run cancelled"
-		}
-	});
-	if (signal?.aborted) return aborted();
-	let skillPath;
-	if (run.skillId) {
-		logToFile(`[agent-runner] installing skill ${run.skillId}`);
-		const installResult = await installSkillById(run.skillId, input.installDir, skillsBaseUrl, { triage: boot.triageProvider });
-		if (signal?.aborted) return aborted();
-		if (installResult.kind !== "ok") return failed(installFailure(run.integrationLabel, installResult));
-		skillPath = installResult.path;
-		logToFile(`[agent-runner] skill installed at ${skillPath}`);
-	}
-	const spinner = createEmitSpinner(emit);
-	if (!run.structured) emit({
-		kind: "lifecycle",
-		phase: "started"
-	});
-	const ask = !!run.structured || shouldDisableAsk(input.flags) && process.env.WIZARD_ASK_AUTODRIVE !== "1" ? void 0 : createAskBridge(interaction, {
-		getSource: () => input.skillId ?? run.integrationLabel,
-		richLinks: run.richLinks ?? false,
-		timeoutMs: run.askTimeoutMs,
-		signal: runSignal
-	});
-	const middleware = withTranscript(input.flags.benchmark ? createBenchmarkPipeline(emit, spinner, runOptions(input)) : void 0, transcript);
-	const promptContext = {
-		projectId,
-		projectApiKey,
-		host,
-		skillPath,
-		orgAiDataProcessingApproved: input.apiUser?.organization?.is_ai_data_processing_approved ?? null,
-		teamProductOptIns: project ? {
-			sessionReplay: project.session_recording_opt_in ?? null,
-			exceptionAutocapture: project.autocapture_exceptions_opt_in ?? null,
-			surveys: project.surveys_opt_in ?? null
-		} : null
-	};
-	const prompt = run.prompt ? run.prompt(promptContext) : assemblePrompt(run, promptContext);
-	logToFile(`[agent-runner] prompt assembled (${prompt.length} chars)`);
-	if (signal?.aborted) return aborted();
-	const { harness, model, thinkingLevel } = config.binding;
-	const agentResult = await getHarness(harness).run({
-		config,
-		input,
-		boot,
-		emit,
-		prompt,
-		skillPath,
-		spinner,
-		askBridge: ask,
-		middleware,
-		model,
-		thinkingLevel,
-		signal: runSignal,
-		structured: run.structured
-	});
-	if (signal?.aborted && agentResult.kind === "success") return aborted();
-	if (agentResult.kind === "decided_failure") return failed(agentResult.failure);
-	if (agentResult.kind === "success") {} else if (agentResult.kind !== "abort" && agentResult.kind !== "failure") return agentResult;
-	if (agentResult.kind === "abort") {
-		const reason = agentResult.message ?? "";
-		const matched = run.abortCases?.find((c) => c.match.test(reason));
-		const abortCode = matched?.errorCode ?? ErrorCodes.AgentAbort;
-		const outroData = matched ? {
-			kind: "error",
-			message: matched.message,
-			body: matched.body,
-			docsUrl: matched.docsUrl,
-			errorCode: abortCode,
-			errorDetail: { reason }
-		} : {
-			kind: "error",
-			message: `${run.integrationLabel} aborted`,
-			body: reason || "The agent aborted the program.",
-			docsUrl: run.docsUrl,
-			errorCode: abortCode,
-			errorDetail: { reason }
-		};
-		analytics.wizardCapture("agent aborted", {
-			integration: run.integrationLabel,
-			reason,
-			matched: matched?.message ?? null
-		});
-		return {
-			outcome: signal?.aborted ? "aborted" : "failed",
-			failure: {
-				message: matched?.message ?? `${run.integrationLabel} aborted`,
-				outroData,
-				code: abortCode,
-				error: agentResult.error
-			}
-		};
-	}
-	const classification = agentResult.kind === "failure" ? agentResult.classification : void 0;
-	const failureMessage = agentResult.kind === "failure" ? agentResult.message : void 0;
-	if (classification === "WIZARD_MCP_MISSING") return failed({
-		code: AGENT_ERROR_CODE["WIZARD_MCP_MISSING"],
-		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${run.docsUrl}`,
-		error: agentResult.kind === "failure" ? agentResult.error : void 0
-	});
-	if (classification === "WIZARD_RESOURCE_MISSING") return failed({
-		code: AGENT_ERROR_CODE["WIZARD_RESOURCE_MISSING"],
-		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${run.docsUrl}`,
-		error: agentResult.kind === "failure" ? agentResult.error : void 0
-	});
-	if (classification === "WIZARD_YARA_VIOLATION") return failed({
-		code: AGENT_ERROR_CODE["WIZARD_YARA_VIOLATION"],
-		message: formatYaraAbortMessage(),
-		error: agentResult.kind === "failure" ? agentResult.error : void 0
-	});
-	if (classification === "WIZARD_NO_PROGRESS") {
-		analytics.wizardCapture("agent no progress", {
-			integration: run.integrationLabel,
-			error_type: "WIZARD_NO_PROGRESS"
-		});
-		return failed({
-			code: AGENT_ERROR_CODE["WIZARD_NO_PROGRESS"],
-			message: "The Wizard exited without changing your project. Please contact the PostHog team with wizard@posthog.com about this error.",
-			error: agentResult.kind === "failure" ? agentResult.error : void 0
-		});
-	}
-	if (classification === "WIZARD_INCOMPLETE_TASKS") {
-		analytics.wizardCapture("agent incomplete tasks", {
-			integration: run.integrationLabel,
-			error_type: "WIZARD_INCOMPLETE_TASKS"
-		});
-		return failed({
-			code: AGENT_ERROR_CODE["WIZARD_INCOMPLETE_TASKS"],
-			message: "The Wizard exited without completing its planned tasks. Please contact the PostHog team with wizard@posthog.com about this error.",
-			error: agentResult.kind === "failure" ? agentResult.error : void 0
-		});
-	}
-	if (classification === "WIZARD_RATE_LIMIT" || classification === "WIZARD_API_ERROR") {
-		analytics.wizardCapture("agent api error", {
-			integration: run.integrationLabel,
-			error_type: classification,
-			error_message: failureMessage
-		});
-		return failed({
-			code: AGENT_ERROR_CODE[classification],
-			message: `API Error\n\n${failureMessage || "Unknown error"}\n\nPlease report this to: wizard@posthog.com`,
-			error: agentResult.kind === "failure" ? agentResult.error : void 0
-		});
-	}
-	if (agentResult.kind === "failure") return failed({
-		code: AGENT_ERROR_CODE[agentResult.classification],
-		message: agentResult.message ?? "Agent failed",
-		error: agentResult.error
-	});
-	if (run.structured) return {
-		outcome: "success",
-		structuredOutput: agentResult.structuredOutput
-	};
-	if (config.hooks?.postRun) {
-		await config.hooks.postRun(credentials);
-		if (signal?.aborted) return aborted();
-	}
-	if (composed) return { outcome: "success" };
-	const outroData = config.hooks?.buildOutroData ? config.hooks.buildOutroData(credentials) : {
-		kind: "success",
-		message: run.successMessage,
-		reportFile: run.reportFile,
-		docsUrl: run.docsUrl,
-		continueUrl: input.flags.signup ? `${host.appHost}/products?source=wizard` : void 0
-	};
-	if (outroData) emit({
-		kind: "completion",
-		outro: outroData
-	});
-	emit({
-		kind: "lifecycle",
-		phase: "completed",
-		message: run.successMessage
-	});
-	return {
-		outcome: "success",
-		outro: outroData
-	};
-}
-//#endregion
-//#region src/shared/utils/terminal-bell.ts
-/**
-* Ring the terminal bell (BEL, U+0007).
-*
-* The orchestrator takes consent for the warehouse step at the top of the run
-* and asks for the credentials at the end of it, several autonomous minutes
-* later. The person who agreed is often looking at something else by then. A
-* bell is the one attention signal a terminal in a background tab can still
-* deliver, and it costs a user who is watching nothing.
-*
-* Written to stderr, not stdout: Ink owns stdout and repaints whole frames, so
-* a byte written there can land inside one. Silent when stderr is not a TTY —
-* a pipe or a CI log cannot ring, and the byte would only pollute the capture.
-*/
-function ringTerminalBell() {
-	if (!process.stderr.isTTY) return;
-	try {
-		process.stderr.write("\x07");
-	} catch {}
-}
-//#endregion
-//#region src/agent/runner/sequence/orchestrator/executor.ts
-/**
-* The executor drains the queue. It starts every runnable task (dependencies
-* satisfied) as soon as it becomes runnable — parallelism is decided by the
-* task graph, not by an executor knob. Each task runs through an injected
-* `runTask` function and reports its outcome via `complete_task`; a task that
-* ends without reporting is retried while attempts remain, then failed. A
-* `maxStarts` backstop guarantees termination.
-*
-* The drain loop is independent of how a task actually runs. `runTask` is
-* injected: the real one spins up a fresh agent, the tests use a fake.
-*/
-/**
-* Thrown by a `RunTask` when its harness returned a decided failure that ends
-* the whole run (a 401 the auth screen already reported), not just the task.
-* `drainQueue` lets it through so the sequence can return the failure where
-* the harness used to exit the process.
-*/
-var RunTaskFatal = class extends Error {
-	constructor(failure, outcome = "failed", taskType) {
-		super(failure.message ?? "agent run failed");
-		this.failure = failure;
-		this.outcome = outcome;
-		this.taskType = taskType;
-		this.name = "RunTaskFatal";
-	}
-};
-const DEFAULT_DRAIN_OPTIONS = { maxStarts: 200 };
-async function runOne(store, runTask, task, signal) {
-	if (signal?.aborted) return;
-	store.start(task.id);
-	try {
-		await runTask(task);
-	} catch (error) {
-		if (signal?.aborted) return;
-		if (error instanceof RunTaskFatal) throw error;
-		logToFile(`[executor] runTask threw for ${task.type}:`, error);
-		analytics.captureException(error instanceof Error ? error : new Error(String(error)), {
-			step: "orchestrator_run_task",
-			task_type: task.type
-		});
-	}
-	if (signal?.aborted) return;
-	const after = store.get(task.id);
-	if (!after) return;
-	if (after.status === TaskStatus.Running) {
-		if (after.attempts < after.maxAttempts) store.requeue(task.id);
-		else store.fail(task.id, {
-			type: "no-report",
-			message: "Task ended without calling complete_task."
-		});
-		return;
-	}
-	if (after.status === TaskStatus.Failed && after.attempts < after.maxAttempts) store.requeue(task.id);
-}
-/**
-* Drain the queue to a terminal state. Every runnable task starts the moment
-* its dependencies finish; independent branches run concurrently. Returns when
-* every task is done, failed, or blocked by a failed dependency, or when the
-* start backstop trips.
-*/
-async function drainQueue(store, runTask, opts = DEFAULT_DRAIN_OPTIONS) {
-	const running = /* @__PURE__ */ new Map();
-	let starts = 0;
-	let failure;
-	try {
-		for (;;) {
-			if (opts.signal?.aborted) break;
-			if (failure) throw failure.error;
-			for (const task of store.nextRunnable()) {
-				if (opts.signal?.aborted) break;
-				if (++starts > opts.maxStarts) break;
-				const p = runOne(store, runTask, task, opts.signal).catch((error) => {
-					if (!failure) {
-						failure = { error };
-						try {
-							opts.onFatal?.();
-						} catch (abortError) {
-							try {
-								logToFile("[executor] fatal cancellation failed:", abortError);
-							} catch {}
-						}
-					}
-				}).finally(() => running.delete(task.id));
-				running.set(task.id, p);
-			}
-			if (running.size === 0) break;
-			await Promise.race(running.values());
-		}
-	} finally {
-		await Promise.allSettled(running.values());
-	}
-	if (failure) throw failure.error;
-}
-//#endregion
-//#region src/agent/runner/sequence/orchestrator/run-metrics.ts
-var RunMetrics = class {
-	firstStartMs;
-	lastStartMs;
-	firstCompleteMs;
-	firstAskMs;
-	lastVisibleMs;
-	maxGapMs = 0;
-	constructor(runStartMs) {
-		this.runStartMs = runStartMs;
-	}
-	/** A task started. Returns the per-start-event timing for the start event. */
-	recordStart(nowMs) {
-		const timing = {
-			ms_since_run_start: nowMs - this.runStartMs,
-			gap_since_prev_start_ms: this.lastStartMs === void 0 ? void 0 : nowMs - this.lastStartMs
-		};
-		this.firstStartMs ??= nowMs;
-		this.lastStartMs = nowMs;
-		this.markVisible(nowMs);
-		return timing;
-	}
-	/** A task completed. */
-	recordComplete(nowMs) {
-		this.firstCompleteMs ??= nowMs;
-		this.markVisible(nowMs);
-	}
-	/** A task reached a terminal non-complete state the user sees (skip/fail). */
-	recordTerminal(nowMs) {
-		this.markVisible(nowMs);
-	}
-	/**
-	* A question was put to the user. Only the first matters here, and it is not a
-	* queue transition — waiting on a person is not the silence `max_gap_ms`
-	* measures, so this deliberately does not mark visible progress.
-	*/
-	recordAsk(nowMs) {
-		this.firstAskMs ??= nowMs;
-	}
-	/**
-	* The run-level responsiveness summary. Timings are `undefined` when the
-	* relevant transition never happened (e.g. a run that started no task), so a
-	* no-task run stays distinguishable from a genuine zero.
-	*/
-	summary() {
-		return {
-			time_to_first_task_ms: this.firstStartMs === void 0 ? void 0 : this.firstStartMs - this.runStartMs,
-			time_to_first_completion_ms: this.firstCompleteMs === void 0 ? void 0 : this.firstCompleteMs - this.runStartMs,
-			max_gap_ms: this.lastVisibleMs === void 0 ? void 0 : this.maxGapMs,
-			time_to_first_ask_ms: this.firstAskMs === void 0 ? void 0 : this.firstAskMs - this.runStartMs
-		};
-	}
-	/** requeue is not user-visible, so a retry stall counts as silence here. */
-	markVisible(nowMs) {
-		if (this.lastVisibleMs !== void 0) this.maxGapMs = Math.max(this.maxGapMs, nowMs - this.lastVisibleMs);
-		this.lastVisibleMs = nowMs;
-	}
-};
-//#endregion
-//#region src/agent/runner/sequence/orchestrator/seeded-deps.ts
-/**
-* Resolve a runner-seeded task's dependencies against the planned queue.
-*
-* Two exclusions apply to both the declared and the default path:
-*
-* - **Sinks are never dependencies.** A sink runs last and must depend on the
-*   whole queue, this task included. Depending on it back would invert the edge
-*   and cost the report this task's `reportSection`. Leaving sinks out means a
-*   planner that forgot the sink→seeded edge is still caught by the sink
-*   invariant check rather than silently papered over here.
-* - **Anything already downstream of this task is never a dependency**, which is
-*   what makes the result cycle-free by construction rather than by the queue's
-*   per-edge refusal.
-*/
-function seededDependencies(store, seededTaskId, declaredTypes, sinkTypes) {
-	const eligible = store.list().filter((task) => {
-		if (task.id === seededTaskId) return false;
-		if (sinkTypes.includes(task.type)) return false;
-		return !dependencyClosure(store, [task.id]).has(seededTaskId);
-	});
-	if (declaredTypes.length === 0) return {
-		depIds: eligible.map((t) => t.id),
-		unresolvedTypes: [],
-		declared: false
-	};
-	const depIds = [];
-	const unresolvedTypes = [];
-	for (const type of declaredTypes) {
-		if (!store.list().some((t) => t.type === type)) {
-			unresolvedTypes.push(type);
-			continue;
-		}
-		for (const task of eligible) if (task.type === type && !depIds.includes(task.id)) depIds.push(task.id);
-	}
-	return {
-		depIds,
-		unresolvedTypes,
-		declared: true
-	};
-}
-/**
-* Give every runner-seeded task the dependencies it could not name at enqueue,
-* and report what happened per task.
-*
-* The runner calls this once, after the planner has seeded the queue and before
-* the sink invariant is checked. Kept here rather than inline in the runner so
-* the wiring — which prompt's types feed which task — is testable without
-* standing up a whole run.
-*/
-function deferSeededTasks(store, seededTasks, declaredTypesFor, sinkTypes) {
-	return seededTasks.map((seeded) => {
-		const declaredTypes = [...declaredTypesFor(seeded.type)];
-		const resolved = seededDependencies(store, seeded.id, declaredTypes, sinkTypes);
-		const { added, refused } = store.addDependencies(seeded.id, resolved.depIds);
-		return {
-			type: seeded.type,
-			declaredTypes,
-			declared: resolved.declared,
-			added,
-			refused,
-			unresolvedTypes: resolved.unresolvedTypes
-		};
-	});
-}
-//#endregion
-//#region src/agent/runner/sequence/orchestrator/orchestrator-runner.ts
-/**
-* Experimental task-queue orchestrator runner.
-*
-* Branches from the linear runner when the `wizard-orchestrator` flag is on. An
-* orchestrator agent inspects the repo and seeds an in-memory task queue; an
-* executor drains it, running one fresh agent per task.
-*
-* Both the WHAT (agent prompts: model, goal, success criteria, tools) and the
-* HOW (mini-skills) are markdown served from context-mill — the seed and every
-* task resolve to a prompt fetched at startup into the registry. The wizard side
-* stays product-ignorant: it is the queue, the executor, and the loader.
-*/
-/** Docs page (`django.md`, `nuxt-js-3-6.md`) — steps start with a digit, agent artifacts (`SKILL.md`, `EXAMPLE*`, `COMMANDMENTS.md`) have uppercase. */
-const isDocPage = (name) => name.endsWith(".md") && name === name.toLowerCase() && !/^\d/.test(name);
-/** Copy only the framework docs pages out of the run cache into .claude/skills — the one durable artifact an orchestrator run leaves. Never clobbers an existing install. */
-function promoteReferenceSkill(referenceDir, claudeSkillsDir, referenceSkillId) {
-	const target = path$1.join(claudeSkillsDir, referenceSkillId);
-	const refs = path$1.join(referenceDir, "references");
-	if (!existsSync(refs) || existsSync(target)) return;
-	const docs = readdirSync(refs).filter(isDocPage);
-	if (docs.length === 0) return;
-	mkdirSync(path$1.join(target, "references"), { recursive: true });
-	for (const f of docs) cpSync(path$1.join(refs, f), path$1.join(target, "references", f));
-	writeFileSync(path$1.join(target, ".posthog-wizard"), "");
-}
-/**
-* Remove skills that task agents installed durably mid-run (load_skill):
-* wizard-marked, new this run, and not the framework reference docs.
-* User-authored and pre-existing skills stay.
-*/
-function sweepRunInstalledSkills(claudeSkillsDir, preexistingSkills, referenceSkillId) {
-	if (!existsSync(claudeSkillsDir)) return;
-	for (const id of readdirSync(claudeSkillsDir)) {
-		if (preexistingSkills.has(id) || id === referenceSkillId) continue;
-		if (!existsSync(path$1.join(claudeSkillsDir, id, ".posthog-wizard"))) continue;
-		rmSync(path$1.join(claudeSkillsDir, id), {
-			recursive: true,
-			force: true
-		});
-		logToFile(`[orchestrator] removed run-installed skill ${id}`);
-	}
-}
-function toTodoStatus(status) {
-	switch (status) {
-		case TaskStatus.Running: return "in_progress";
-		case TaskStatus.Done: return "completed";
-		case TaskStatus.Failed: return "failed";
-		case TaskStatus.Skipped: return "skipped";
-		default: return "pending";
-	}
-}
-/**
-* Look up the harness impl for a resolved pick and enforce the `runTask`
-* capability. Pi trips this today with the honest impl-gap error instead of
-* silently downgrading to anthropic.
-*/
-function requireTaskHarness(pick) {
-	const harness = getHarness(pick.harness);
-	if (!harness.runTask) throw new Error(`Harness "${pick.harness}" does not implement runTask; orchestrator mode requires it.`);
-	return harness;
-}
-function terminalResult(result) {
-	switch (result.kind) {
-		case "success": return;
-		case "decided_failure": return {
-			outcome: "failed",
-			failure: result.failure
-		};
-		case "abort": return {
-			outcome: "failed",
-			failure: {
-				code: AGENT_ERROR_CODE[result.classification],
-				message: result.message ?? "Agent aborted",
-				error: result.error
-			}
-		};
-		case "failure": return {
-			outcome: "failed",
-			failure: {
-				code: AGENT_ERROR_CODE[result.classification],
-				message: result.message ?? "Agent failed",
-				error: result.error
-			}
-		};
-	}
-}
-function cancelledRun() {
-	return {
-		outcome: "aborted",
-		failure: {
-			code: ErrorCodes.AgentAbort,
-			message: "Agent run cancelled"
-		}
-	};
-}
-/** Every skill entry the menu knows, across categories. */
-async function fetchSkillMenuEntries(skillsBaseUrl) {
-	const menu = await fetchSkillMenu(skillsBaseUrl);
-	if (!menu) return [];
-	return Object.values(menu.categories).flat();
-}
-/** Menu id for a bare skill id + framework via the menu's declared group/framework/default fields; undefined when nothing matches. */
-function resolveSkillVariantId(entries, skillId, framework) {
-	if (entries.some((e) => e.id === skillId)) return skillId;
-	if (!framework) return void 0;
-	const family = entries.filter((e) => e.group === skillId && e.framework === framework);
-	return (family.find((e) => e.default) ?? family[0])?.id;
-}
-/**
-* The framework reference is the full `integration` skill. `input.skillId` is
-* the bare framework (e.g. `django`), but the skill menu ids it as
-* `integration-<variant>`.
-*/
-function resolveReferenceSkillId(entries, framework) {
-	return resolveSkillVariantId(entries, "integration", framework);
-}
-/**
-* How long an optional step's notice waits for an answer.
-*
-* Much shorter than LONGER_ASK_TIMEOUT_MS, because it is asking for something
-* much smaller: one keypress to accept or decline, not "go mint a restricted
-* Stripe key". It cannot be unbounded either — the notice is a modal, and a run
-* that stops forever behind one nobody is looking at is worse than one that
-* takes the safe answer and carries on.
-*
-* The offer is made at seed time, seconds into the run, so five minutes is a
-* generous allowance for a person who is by then still watching the wizard
-* start. It was not: from 2.63.0 to 2.65.0 the offer was made at the moment the
-* step became runnable — a median seven minutes in, after every coding task —
-* and this timeout became the answer for about a quarter of all runs.
-*/
-const TASK_NOTICE_TIMEOUT_MS = 300 * 1e3;
-/**
-* Offer an optional step, defaulting to declining it if nobody answers.
-*
-* Skip is the right default on a timeout: continuing would send the step on to
-* ask for credentials that the same absent user cannot supply either, burning
-* {@link LONGER_ASK_TIMEOUT_MS} per question before falling back to the same
-* links declining gives immediately.
-*/
-async function offerSeededTask(notice, { timeoutMs = TASK_NOTICE_TIMEOUT_MS, interaction, signal } = {}) {
-	if (signal?.aborted) return {
-		keep: false,
-		timedOut: false
-	};
-	if (!interaction?.taskNotice) return {
-		keep: false,
-		timedOut: false
-	};
-	const { taskNotice } = interaction;
-	const controller = new AbortController();
-	let timer;
-	let timedOut = false;
-	let cancelForAbort;
-	const timeout = new Promise((resolve) => {
-		timer = setTimeout(() => {
-			timedOut = true;
-			resolve(false);
-			controller.abort();
-		}, timeoutMs);
-	});
-	const aborted = new Promise((resolve) => {
-		cancelForAbort = () => {
-			resolve(false);
-			controller.abort();
-		};
-		signal?.addEventListener("abort", cancelForAbort, { once: true });
-	});
-	try {
-		return {
-			keep: await Promise.race([
-				taskNotice(notice, { signal: controller.signal }),
-				timeout,
-				aborted
-			]),
-			timedOut
-		};
-	} finally {
-		if (timer) clearTimeout(timer);
-		if (cancelForAbort) signal?.removeEventListener("abort", cancelForAbort);
-	}
-}
-/**
-* Which runner-seeded task types finished successfully.
-*
-* Handed to the program's `buildOutroNextSteps` so it can drop a next step its
-* own seeded task already carried out. Only `Done` counts: a skipped, declined
-* or failed step left the work undone, and that is exactly when the outro
-* bullet pointing at the app is the one thing the user still needs.
-*/
-function completedSeededTypes(store, seededTasks) {
-	return seededTasks.filter((task) => store.get(task.id)?.status === TaskStatus.Done).map((task) => task.type);
-}
-/** Which skip reason a negative {@link SeededConsent} carries onto the event. */
-function consentSkipReason(consent) {
-	if (consent.errored) return SkipReason.NoticeError;
-	return consent.timedOut ? SkipReason.NoticeTimeout : SkipReason.UserDeclined;
-}
-/**
-* Apply the seed-time answers to the queue, before the drain starts.
-*
-* A declined task is skipped rather than dropped, so the graph the planner saw
-* is the graph that ran — the sink already depends on this task, and
-* `nextRunnable` treats a skipped dependency as satisfied, so the report still
-* runs and can say the step was declined. The decline also stays in the funnel,
-* arriving as a `skipped` event carrying the reason that caused it rather than
-* as a task that silently never existed.
-*
-* It happens here rather than inside `runTask` because the executor marks a
-* task running — and fires `orchestrator task started` — before it hands the
-* task over. A decline applied on the far side of that emitted a start for a
-* task no agent ever ran, so every rate measured against starts counted the
-* declines twice: once in the denominator as a task that began, and again in
-* the numerator as a task that was skipped. Nothing upstream of the drain reads
-* task status, so applying the answers here changes only what the drain sees.
-*
-* Returns how many tasks were skipped, so the caller can redraw once.
-*/
-function skipDeclinedSeededTasks(store, consentByTaskId, labelFor) {
-	let skipped = 0;
-	for (const [taskId, consent] of consentByTaskId) {
-		if (consent.keep) continue;
-		const task = store.get(taskId);
-		if (!task) continue;
-		const reason = consentSkipReason(consent);
-		logToFile(`[orchestrator] runner-seeded ${task.type} skipped: ${reason}`);
-		const declinedByUser = reason === SkipReason.UserDeclined;
-		store.skip(taskId, reason, {
-			goals: labelFor(task),
-			did: declinedByUser ? "Nothing — the user chose to skip this step when offered it." : "Nothing — the step was offered at the start of the run and never accepted.",
-			forNextAgent: declinedByUser ? "This step was offered and declined, so it did no work. Report it as skipped at the user’s request, not as failed." : "This step was offered and never accepted, so it did no work. Report it as not set up, and point the user at how to do it later."
-		});
-		skipped += 1;
-	}
-	return skipped;
-}
-/**
-* Ask for one seeded task's consent, and record how the answer came about.
-*
-* Consent and execution are separate concerns, and this is the consent half.
-* It runs at seed time — seconds into the run, with the user still watching —
-* while `seeded-deps.ts` keeps the work itself at the end of the queue. Asking
-* at the moment of execution instead, as 2.63.0 did, put the question in front
-* of a user who had long since tabbed away.
-*
-* Fails closed. The step this gates goes on to ask for live database and API
-* credentials, so a question that could not be put to the user is never read as
-* a yes.
-*/
-async function askSeededConsent(type, notice, options = {}) {
-	const consent = await offerSeededTask(notice, options).then((answer) => ({
-		...answer,
-		errored: false
-	}), (err) => {
-		logToFile(`[orchestrator] notice failed for ${type}, declining: ${String(err)}`);
-		analytics.captureException(err instanceof Error ? err : new Error(String(err)), { step: "orchestrator_task_notice" });
-		return {
-			keep: false,
-			timedOut: false,
-			errored: true
-		};
-	});
-	analytics.wizardCapture("orchestrator task notice answered", {
-		type,
-		kept: consent.keep,
-		timed_out: consent.timedOut,
-		errored: consent.errored
-	});
-	return consent;
-}
-/** Whether a task's prompt lets it ask the user, and so needs the ask bridge. */
-function canAsk(prompt) {
-	return (prompt?.allowedTools ?? []).includes(ASK_TOOL);
-}
-/** Splits terminal failures into run-failing (required) and reported-only (optional). */
-function drainVerdict(tasks) {
-	const failed = tasks.filter((t) => t.status === TaskStatus.Failed);
-	const pending = tasks.filter((t) => t.status === TaskStatus.Pending);
-	return {
-		requiredFailedTypes: failed.filter((t) => t.optional !== true).map((t) => t.type),
-		optionalFailedTypes: failed.filter((t) => t.optional === true).map((t) => t.type),
-		blocked: pending.length,
-		blockedTypes: pending.map((t) => t.type)
-	};
-}
-/**
-* The one-line "what went wrong" the abort message leads with.
-*
-* Both halves are named. A drain that ends with work still pending used to
-* report only how many steps never ran, which is the least useful fact about
-* them: a user who agreed to connect their data sources and then read that
-* "2 steps never ran" had no way to tell whether that step was one of them.
-*/
-function describeDrainFailure(verdict) {
-	const parts = [];
-	if (verdict.requiredFailedTypes.length > 0) parts.push(`the ${verdict.requiredFailedTypes.join(", ")} step failed`);
-	if (verdict.blockedTypes.length > 0) parts.push(`the ${verdict.blockedTypes.join(", ")} step${verdict.blockedTypes.length === 1 ? "" : "s"} never ran`);
-	return parts.join(", so ");
-}
-/** One `orchestrator task blocked` event per pending task, best effort once the outcome is decided. */
-function reportBlockedTasks(tasks, failedTypes) {
-	for (const task of tasks) {
-		if (task.status !== TaskStatus.Pending) continue;
-		try {
-			analytics.wizardCapture("orchestrator task blocked", {
-				type: task.type,
-				optional: task.optional === true,
-				failed_types: failedTypes.join(",") || "none"
-			});
-		} catch {}
-	}
-}
-/** How many tasks deep in the graph a task sits — 0 when it depends on nothing. */
-function graphDepth(task, byId, memo) {
-	const cached = memo.get(task.id);
-	if (cached !== void 0) return cached;
-	memo.set(task.id, 0);
-	const depth = task.dependsOn.reduce((deepest, id) => {
-		const dep = byId.get(id);
-		return dep ? Math.max(deepest, graphDepth(dep, byId, memo) + 1) : deepest;
-	}, 0);
-	memo.set(task.id, depth);
-	return depth;
-}
-/**
-* The queue in the order the user should read it, which is not the order tasks
-* were queued. Tasks the wizard seeded before the planner ran are queued first
-* but are optional side quests, so they sit at the end of the tier they run in
-* — the list reads as the run unfolds, and the first line is work that actually
-* started. Ordering only; nothing here changes what runs when.
-*/
-function displayOrder(tasks, isOptional) {
-	const byId = new Map(tasks.map((t) => [t.id, t]));
-	const memo = /* @__PURE__ */ new Map();
-	return tasks.map((task, index) => ({
-		task,
-		depth: graphDepth(task, byId, memo),
-		optional: isOptional(task) ? 1 : 0,
-		index
-	})).sort((a, b) => a.depth - b.depth || a.optional - b.optional || a.index - b.index).map((entry) => entry.task);
-}
-/**
-* The run's excluded task types: CI gates plus the program's flag mapping.
-* Exported so a test can pin the flag→exclusion hookup against the real
-* program config — the registry and seed note both read this one list.
-*/
-function effectiveExcludedTaskTypes(source, flags) {
-	return [...ciExcludedTaskTypes(), ...source.excludedTaskTypes?.(flags) ?? []];
-}
-async function runOrchestrator(context) {
-	const controller = new AbortController();
-	const abortFromHost = () => controller.abort();
-	context.signal?.addEventListener("abort", abortFromHost, { once: true });
-	if (context.signal?.aborted) abortFromHost();
-	let cleaned = false;
-	const cleanupQueue = () => {
-		if (cleaned) return;
-		cleaned = true;
-		try {
-			rmSync(path$1.join(context.input.installDir, QUEUE_DIR_NAME), {
-				recursive: true,
-				force: true
-			});
-		} catch (error) {
-			try {
-				analytics.captureException(error instanceof Error ? error : new Error(String(error)), { step: "orchestrator_cache_cleanup" });
-			} catch {}
-		}
-	};
-	try {
-		return await executeOrchestrator({
-			...context,
-			signal: controller.signal
-		}, cleanupQueue, controller);
-	} finally {
-		context.signal?.removeEventListener("abort", abortFromHost);
-		cleanupQueue();
-	}
-}
-async function executeOrchestrator({ config, input, boot, emit, interaction, signal }, cleanupQueue, controller) {
-	if (signal?.aborted) return cancelledRun();
-	const runId = randomUUID();
-	const { run } = config;
-	const programId = config.programId;
-	const switchboardCtx = {
-		...config.switchboard,
-		trace: void 0
-	};
-	const flow = config.agentFlow ?? programId;
-	const registry = await loadAgentRegistry(boot.skillsBaseUrl, flow, {
-		exclude: effectiveExcludedTaskTypes(config, boot.wizardFlags),
-		overrides: resolveStageOverrides(programId, boot.wizardFlags, boot.wizardFlagPayloads)
-	});
-	if (signal?.aborted) return cancelledRun();
-	const seedPrompt = registry.seed;
-	if (!seedPrompt) throw new Error(`No seed agent prompt (frontmatter \`seed: true\`) for flow "${flow}" is available from ${boot.skillsBaseUrl}.`);
-	const taskModels = Object.fromEntries(["seed", ...registry.types].map((type) => {
-		const prompt = type === "seed" ? seedPrompt : registry.get(type);
-		const pick = resolveHarness(switchboardCtx, type);
-		const specModel = prompt && promptModelFor(prompt, pick.harness).model;
-		return [type, isValidModel(specModel) ? specModel : pick.model];
-	}));
-	logToFile(`[orchestrator] task models: ${Object.entries(taskModels).map(([t, m]) => `${t}=${m}`).join(" ")}`);
-	analytics.wizardCapture("orchestrator task models", taskModels);
-	const runStartMs = Date.now();
-	const metrics = new RunMetrics(runStartMs);
-	const durationMs = (t) => t.startedAt && t.finishedAt ? Date.parse(t.finishedAt) - Date.parse(t.startedAt) : void 0;
-	const store = new QueueStore(input.installDir, runId, { onTransition: (event, task) => {
-		const pick = resolveHarness(switchboardCtx, task.type);
-		const specModel = taskModelSpec(registry, task, pick.harness).model;
-		const base = {
-			type: task.type,
-			model: isValidModel(specModel) ? specModel : pick.model,
-			attempts: task.attempts,
-			optional: task.optional === true
-		};
-		switch (event) {
-			case "enqueue":
-				analytics.wizardCapture("orchestrator task enqueued", {
-					type: task.type,
-					enqueued_by: task.enqueuedBy,
-					dynamic: task.enqueuedBy !== "orchestrator"
-				});
-				break;
-			case "start":
-				analytics.wizardCapture("orchestrator task started", {
-					...base,
-					...metrics.recordStart(Date.now())
-				});
-				break;
-			case "complete":
-				metrics.recordComplete(Date.now());
-				analytics.wizardCapture("orchestrator task completed", {
-					...base,
-					duration_ms: durationMs(task)
-				});
-				break;
-			case "skip":
-				metrics.recordTerminal(Date.now());
-				analytics.wizardCapture("orchestrator task skipped", {
-					...base,
-					duration_ms: durationMs(task),
-					reason: task.skipReason,
-					not_needed_reason: task.notNeededReason
-				});
-				break;
-			case "fail":
-				metrics.recordTerminal(Date.now());
-				analytics.wizardCapture("orchestrator task failed", {
-					...base,
-					duration_ms: durationMs(task),
-					error: task.error?.type
-				});
-				break;
-			case "requeue": break;
-		}
-	} });
-	let examplePath;
-	let commandmentsPath;
-	let referenceInstallPath;
-	const menuSkillEntries = await fetchSkillMenuEntries(boot.skillsBaseUrl);
-	if (signal?.aborted) return cancelledRun();
-	const framework = input.integration ?? input.skillId ?? void 0;
-	const referenceSkillId = framework ? resolveReferenceSkillId(menuSkillEntries, framework) : void 0;
-	if (referenceSkillId) {
-		const ref = await installSkillById(referenceSkillId, input.installDir, boot.skillsBaseUrl, {
-			skillsRoot: path$1.join(QUEUE_DIR_NAME, "reference"),
-			triage: boot.triageProvider
-		});
-		if (signal?.aborted) return cancelledRun();
-		if (ref.kind === "ok") {
-			referenceInstallPath = ref.path;
-			const example = path$1.join(ref.path, "references", "EXAMPLE.md");
-			if (existsSync(path$1.join(input.installDir, example))) examplePath = example;
-			const commandments = path$1.join(ref.path, "references", "COMMANDMENTS.md");
-			if (existsSync(path$1.join(input.installDir, commandments))) commandmentsPath = commandments;
-		} else logToFile(`[orchestrator] reference unavailable: ${ref.kind} (${referenceSkillId})`);
-	} else if (framework) logToFile(`[orchestrator] no integration skill for framework "${framework}"`);
-	const missingVariants = [];
-	for (const type of registry.types) for (const skillId of registry.get(type)?.skills ?? []) {
-		if (resolveSkillVariantId(menuSkillEntries, skillId, framework)) continue;
-		missingVariants.push(`${type}/${skillId}`);
-		logToFile(`[orchestrator] no skill variant type=${type} skill=${skillId} framework=${framework ?? "none"}`);
-		analytics.wizardCapture("orchestrator skill variant missing", {
-			task_type: type,
-			skill: skillId,
-			framework
-		});
-	}
-	if (missingVariants.length > 0) {
-		const docsUrl = framework ? input.frameworkDocsUrl : void 0;
-		return failed({
-			code: ErrorCodes.AgentOrchestratorSkillVariantMissing,
-			message: `Setup instructions for this project failed to download.
-Please try again, or contact wizard@posthog.com.
-
-You can also set up with your agent by downloading the skills here:
-  https://github.com/PostHog/context-mill/releases
-or integrate manually here:
-  ${docsUrl ?? "https://posthog.com/docs"}`,
-			error: new WizardError("Orchestrator preflight: skill variant missing", {
-				missing: missingVariants.join(", "),
-				framework
-			}, ErrorCodes.AgentOrchestratorSkillVariantMissing)
-		});
-	}
-	const promptContext = {
-		projectId: boot.credentials.projectId,
-		projectApiKey: boot.credentials.projectApiKey,
-		host: boot.credentials.host,
-		examplePath,
-		commandmentsPath
-	};
-	logToFile(`[orchestrator] START program=${programId} dir=${input.installDir} run=${runId}`);
-	analytics.wizardCapture("orchestrator started", { program_id: programId });
-	emit({
-		kind: "lifecycle",
-		phase: "started"
-	});
-	const labelFor = (t) => t.label ?? registry.get(t.type)?.label ?? t.type;
-	const renderQueue = () => emit({
-		kind: "tasks",
-		tasks: displayOrder(store.list(), (t) => registry.runnerSeededTypes.includes(t.type)).map((t) => ({
-			id: `${runId}:${t.id}`,
-			source: runId,
-			content: labelFor(t),
-			status: toTodoStatus(t.status),
-			activeForm: labelFor(t)
-		}))
-	});
-	const orchestratorCtx = (currentTaskId) => ({
-		store,
-		validTypes: registry.enqueueableTypes,
-		sinkTypes: registry.sinkTypes,
-		runnerSeededTypes: registry.runnerSeededTypes,
-		optionalTypes: registry.optionalTypes,
-		currentTaskId
-	});
-	const seedEntries = areSeededTasksEnabled(boot.wizardFlags) ? config.seedTasks?.() ?? [] : [];
-	const seededTypes = [];
-	const seededTasks = [];
-	const seededConsent = /* @__PURE__ */ new Map();
-	for (const seeded of seedEntries) {
-		if (!registry.runnerSeededTypes.includes(seeded.type)) {
-			logToFile(`[orchestrator] skipping runner-seeded task "${seeded.type}": not a runner-seeded type in this flow`);
-			continue;
-		}
-		const task = store.enqueue({
-			type: seeded.type,
-			label: seeded.label,
-			inputs: seeded.inputs,
-			enqueuedBy: "orchestrator",
-			optional: true
-		});
-		seededTypes.push(seeded.type);
-		seededTasks.push(task);
-		if (seeded.notice) {
-			seededConsent.set(task.id, await askSeededConsent(seeded.type, seeded.notice, {
-				interaction,
-				signal
-			}));
-			if (signal?.aborted) return cancelledRun();
-		}
-		logToFile(`[orchestrator] runner-seeded task ${seeded.type}`);
-	}
-	const askingTypes = seededTasks.filter((task) => seededConsent.get(task.id)?.keep !== false).map((task) => task.type).filter((type) => canAsk(registry.get(type)));
-	analytics.setTag("orchestrator_awaits_user", askingTypes.length > 0);
-	analytics.setTag("orchestrator_runner_seeded_types", seededTypes.join(",") || "none");
-	if (askingTypes.length > 0) analytics.wizardCapture("orchestrator awaits user", {
-		task_types: askingTypes,
-		ask_timeout_ms: LONGER_ASK_TIMEOUT_MS
-	});
-	const askBridge = shouldDisableAsk(input.flags) ? void 0 : createAskBridge(interaction, {
-		signal,
-		getSource: () => input.skillId ?? programId,
-		beforeShow: () => {
-			metrics.recordAsk(Date.now());
-			ringTerminalBell();
-		},
-		richLinks: run.richLinks ?? false,
-		timeoutMs: LONGER_ASK_TIMEOUT_MS
-	});
-	const spinner = createEmitSpinner(emit);
-	const seedPick = resolveHarness(switchboardCtx, "seed");
-	const seedHarness = requireTaskHarness(seedPick);
-	const seedModel = promptModelFor(seedPrompt, seedPick.harness);
-	const seedResult = await seedHarness.runTask({
-		signal,
-		config,
-		input,
-		boot,
-		emit,
-		prompt: assembleSeedPrompt(promptContext, seedPrompt.body, store.list(), registry.excludedTypes),
-		spinner,
-		model: requireKnownModel(seedModel.model, seedPick.model),
-		effort: seedModel.effort,
-		...agentRunTools(seedPrompt),
-		orchestrator: orchestratorCtx(),
-		spinnerMessage: "Planning the integration...",
-		successMessage: "Planned the integration",
-		requestRemark: false,
-		analyticsProperties: {
-			task_type: "seed",
-			harness: seedPick.harness
-		}
-	});
-	if (signal?.aborted) return cancelledRun();
-	const seedTerminal = terminalResult(seedResult);
-	if (seedTerminal) return seedTerminal;
-	analytics.wizardCapture("orchestrator seeded", {
-		task_count: store.list().length,
-		types: store.list().map((t) => t.type)
-	});
-	renderQueue();
-	const deferred = deferSeededTasks(store, seededTasks, (type) => registry.get(type)?.dependsOn ?? [], registry.sinkTypes);
-	for (const entry of deferred) {
-		logToFile(`[orchestrator] deferred runner-seeded ${entry.type}: ${entry.added.length} deps (${entry.declared ? `declared: ${entry.declaredTypes.join(", ")}` : "default"})${entry.refused.length > 0 ? `, ${entry.refused.length} refused` : ""}${entry.unresolvedTypes.length > 0 ? `, unresolved: ${entry.unresolvedTypes.join(", ")}` : ""}`);
-		analytics.wizardCapture("orchestrator seeded task deferred", {
-			type: entry.type,
-			dep_count: entry.added.length,
-			declared: entry.declared,
-			declared_types: entry.declaredTypes,
-			unresolved_types: entry.unresolvedTypes,
-			refused_count: entry.refused.length
-		});
-	}
-	if (deferred.length > 0) renderQueue();
-	for (const seeded of seededTasks) {
-		const dependants = store.list().filter((t) => !registry.sinkTypes.includes(t.type) && t.id !== seeded.id && dependencyClosure(store, [t.id]).has(seeded.id));
-		if (dependants.length === 0) continue;
-		logToFile(`[orchestrator] one-way rule broken: ${dependants.map((t) => t.type).join(", ")} depend on runner-seeded ${seeded.type}`);
-		analytics.wizardCapture("orchestrator seeded task depended on", {
-			type: seeded.type,
-			dependant_types: dependants.map((t) => t.type)
-		});
-	}
-	const unwaited = store.list().filter((t) => registry.sinkTypes.includes(t.type)).flatMap((sink) => uncoveredBySink({
-		store,
-		validTypes: registry.types,
-		sinkTypes: registry.sinkTypes
-	}, {
-		type: sink.type,
-		dependsOn: sink.dependsOn
-	}).filter((t) => t.id !== sink.id));
-	if (unwaited.length > 0) {
-		analytics.wizardCapture("orchestrator sink invariant violated", { uncovered_types: unwaited.map((t) => t.type) });
-		return failed({
-			code: ErrorCodes.AgentOrchestratorSinkInvariant,
-			message: `The wizard could not plan this setup: the final step would have skipped ${unwaited.map((t) => t.type).join(", ")}.\n\nPlease report this to: ${WIZARD_CONTACT_EMAIL}`,
-			error: new WizardError("orchestrator sink does not cover the queue", {
-				uncovered: unwaited.map((t) => `${t.type} (${t.id})`).join(", "),
-				queue_state: JSON.stringify(store.list())
-			}, ErrorCodes.AgentOrchestratorSinkInvariant)
-		});
-	}
-	const taskSkillsRoot = path$1.join(QUEUE_DIR_NAME, "skills");
-	const claudeSkillsDir = path$1.join(input.installDir, ".claude", "skills");
-	const preexistingSkills = new Set(existsSync(claudeSkillsDir) ? readdirSync(claudeSkillsDir) : []);
-	const runTask = async (task) => {
-		if (signal?.aborted) return;
-		renderQueue();
-		try {
-			const resolved = resolveTask(registry, task, store);
-			const skillPaths = [];
-			for (const skillId of resolved.skills) {
-				if (signal?.aborted) return;
-				const variantId = resolveSkillVariantId(menuSkillEntries, skillId, framework);
-				if (!variantId) {
-					logToFile(`[orchestrator] no skill variant type=${task.type} skill=${skillId} framework=${framework ?? "none"}`);
-					continue;
-				}
-				const result = await installSkillById(variantId, input.installDir, boot.skillsBaseUrl, {
-					skillsRoot: taskSkillsRoot,
-					triage: boot.triageProvider
-				});
-				if (signal?.aborted) return;
-				if (result.kind === "ok") skillPaths.push(path$1.join(result.path, "SKILL.md"));
-				else {
-					logToFile(`[orchestrator] skill install failed type=${task.type} skill=${variantId} ${result.kind}`);
-					throw new Error(`Skill "${variantId}" for task "${task.type}" could not be installed (${result.kind}). If this is a permissions error, check that the project directory is writable.`);
-				}
-			}
-			const taskPick = resolveHarness(switchboardCtx, task.type);
-			const taskHarness = requireTaskHarness(taskPick);
-			const taskModel = taskModelSpec(registry, task, taskPick.harness);
-			let taskResult;
-			try {
-				taskResult = await taskHarness.runTask({
-					signal,
-					config,
-					input,
-					boot,
-					emit,
-					prompt: assembleTaskPrompt(promptContext, resolved.prompt, skillPaths),
-					spinner,
-					model: requireKnownModel(taskModel.model, taskPick.model),
-					effort: taskModel.effort,
-					allowedTools: resolved.allowedTools,
-					disallowedTools: resolved.disallowedTools,
-					askBridge: canAsk(registry.get(task.type)) ? askBridge : void 0,
-					orchestrator: orchestratorCtx(task.id),
-					spinnerMessage: "",
-					successMessage: "",
-					requestRemark: false,
-					analyticsProperties: {
-						task_type: task.type,
-						task_id: task.id,
-						harness: taskPick.harness
-					}
-				});
-			} catch (error) {
-				if (signal?.aborted) return;
-				if (error instanceof RunTaskFatal) throw error;
-				const failure = classifyRunFailure(error);
-				throw new RunTaskFatal({
-					code: failure.code,
-					message: failure.message,
-					error: error instanceof Error ? error : void 0
-				}, "failed", task.type);
-			}
-			if (signal?.aborted) return;
-			const terminal = terminalResult(taskResult);
-			if (terminal) throw new RunTaskFatal(terminal.failure, terminal.outcome, task.type);
-		} finally {
-			try {
-				sweepRunInstalledSkills(claudeSkillsDir, preexistingSkills, referenceSkillId);
-			} catch (err) {
-				try {
-					logToFile("[orchestrator] per-task skill sweep failed:", err);
-				} catch {}
-			}
-			try {
-				renderQueue();
-			} catch (err) {
-				try {
-					logToFile("[orchestrator] per-task queue render failed:", err);
-				} catch {}
-			}
-		}
-	};
-	if (skipDeclinedSeededTasks(store, seededConsent, labelFor) > 0) renderQueue();
-	let fatal;
-	try {
-		await drainQueue(store, runTask, {
-			...DEFAULT_DRAIN_OPTIONS,
-			signal,
-			onFatal: () => controller.abort()
-		});
-	} catch (error) {
-		if (!(error instanceof RunTaskFatal)) throw error;
-		fatal = error;
-	} finally {
-		config.hooks?.recordTaskOutcomes?.(store.list().map((t) => ({
-			type: t.type,
-			status: t.status,
-			optional: t.optional === true
-		})));
-		try {
-			if (!signal?.aborted && referenceSkillId && referenceInstallPath) promoteReferenceSkill(path$1.join(input.installDir, referenceInstallPath), claudeSkillsDir, referenceSkillId);
-		} catch (err) {
-			try {
-				analytics.captureException(err instanceof Error ? err : new Error(String(err)), { step: "orchestrator_reference_promote" });
-			} catch {}
-		}
-		cleanupQueue();
-		try {
-			sweepRunInstalledSkills(claudeSkillsDir, preexistingSkills, referenceSkillId);
-		} catch (err) {
-			try {
-				analytics.captureException(err instanceof Error ? err : new Error(String(err)), { step: "orchestrator_skill_sweep" });
-			} catch {}
-		}
-	}
-	if (fatal) {
-		const stoppedBy = drainVerdict(store.list()).requiredFailedTypes;
-		if (fatal.taskType && !stoppedBy.includes(fatal.taskType)) stoppedBy.push(fatal.taskType);
-		reportBlockedTasks(store.list(), stoppedBy);
-		return {
-			outcome: fatal.outcome,
-			failure: fatal.failure
-		};
-	}
-	if (signal?.aborted) return cancelledRun();
-	renderQueue();
-	const summary = store.summary();
-	logToFile(`[orchestrator] DONE done=${summary.done} failed=${summary.failed} total=${summary.total}`);
-	analytics.wizardCapture("orchestrator run finished", {
-		tasks_total: summary.total,
-		tasks_done: summary.done,
-		tasks_failed: summary.failed,
-		tasks_skipped: summary[TaskStatus.Skipped],
-		total_duration_ms: Date.now() - runStartMs,
-		...metrics.summary(),
-		dynamic_enqueue_count: store.list().filter((t) => t.enqueuedBy !== "orchestrator").length,
-		retried_task_count: store.list().filter((t) => t.attempts > 1).length
-	});
-	const reviewTask = store.list().find((t) => t.type === "review");
-	const conflict = reviewTask ? store.readHandoff(reviewTask.id)?.conflict : void 0;
-	const notRequired = summary[TaskStatus.Skipped];
-	const verdict = drainVerdict(store.list());
-	const blocked = verdict.blocked;
-	reportBlockedTasks(store.list(), verdict.requiredFailedTypes);
-	if (verdict.requiredFailedTypes.length > 0 || blocked > 0) {
-		const failedTypes = verdict.requiredFailedTypes.join(", ");
-		const whatFailed = describeDrainFailure(verdict);
-		const missingScopes = (boot.credentials.missingScopes ?? []).filter((scope) => WIZARD_PROVISIONING_SCOPES.some((required) => required === scope) || !WIZARD_OAUTH_SCOPES.some((requested) => requested === scope));
-		const message = missingScopes.length > 0 ? `The wizard could not finish setup: ${whatFailed}, and this run was authorized without the following permission${missingScopes.length === 1 ? "" : "s"}: ${missingScopes.join(", ")}.\n\nPlease try again, approving all permissions on the PostHog authorization screen. If it still fails, report it to: ${WIZARD_CONTACT_EMAIL}` : `The wizard was unable to set up PostHog: ${whatFailed}.\n\nPlease report this to: ${WIZARD_CONTACT_EMAIL}`;
-		return failed({
-			code: ErrorCodes.AgentOrchestratorTasksFailed,
-			message,
-			error: new WizardError("orchestrator drain ended with failed tasks", {
-				tasks_failed: summary.failed,
-				tasks_blocked: blocked,
-				failed_types: failedTypes,
-				missing_oauth_scopes: missingScopes.join(" "),
-				queue_state: JSON.stringify(store.list())
-			}, ErrorCodes.AgentOrchestratorTasksFailed)
-		});
-	}
-	if (summary.total === 0) return failed({
-		code: ErrorCodes.AgentOrchestratorHollowRun,
-		message: `The wizard was unable to set up PostHog: the planning step produced no work, so nothing ran.\n\nPlease try again — and if it happens again, report it to: ${WIZARD_CONTACT_EMAIL}`,
-		error: new WizardError("orchestrator drain produced zero tasks", { queue_state: JSON.stringify(store.list()) }, ErrorCodes.AgentOrchestratorHollowRun)
-	});
-	const optionalFailedCount = verdict.optionalFailedTypes.length;
-	const stepNotes = [notRequired > 0 ? `${notRequired} skipped as not required` : "", optionalFailedCount > 0 ? `${optionalFailedCount} optional step failed` : ""].filter(Boolean);
-	const message = conflict ? "PostHog set up, with one conflict to review." : `PostHog set up: ${summary.done}/${summary.total - notRequired - optionalFailedCount} steps completed${stepNotes.length > 0 ? ` (${stepNotes.join(", ")})` : ""}.`;
-	const outro = {
-		kind: "success",
-		message,
-		body: conflict ? `⚠ Build conflict: ${conflict}\nFull details are in the setup report.` : void 0,
-		docsUrl: "https://posthog.com/docs/ai-engineering/ai-wizard",
-		nextSteps: config.hooks?.buildOutroNextSteps?.(boot.credentials, completedSeededTypes(store, seededTasks))
-	};
-	emit({
-		kind: "completion",
-		outro
-	});
-	emit({
-		kind: "lifecycle",
-		phase: "completed",
-		message
-	});
-	return {
-		outcome: "success",
-		outro
-	};
-}
-//#endregion
-//#region src/agent/runner/switchboard/sequence.ts
-/**
-* Sequence axis: gate helpers, registry, middleware, resolver.
-* Percentage rollouts are PostHog-side — the gate just reads the resolved bool.
-*/
-const SEQUENCE_OPTIONS = {
-	["linear"]: {
-		name: "linear",
-		run: (ctx) => runLinearProgram(ctx)
-	},
-	["orchestrator"]: {
-		name: "orchestrator",
-		run: (ctx) => runOrchestrator(ctx)
-	}
-};
-function getSequence(name) {
-	const sequence = SEQUENCE_OPTIONS[name];
-	if (!sequence) throw new Error(`No sequence registered for '${name}'.`);
-	return sequence;
-}
-/**
-* A composed sub-run (integration inside self-driving) is structurally
-* linear: the orchestrator owns the full run lifecycle (queue, outro) and
-* cannot nest. Sits above every override, including CLI.
-*/
-const composedClampMw = (ctx, next) => {
-	if (!ctx.composed) return next();
-	if (ctx.trace) ctx.trace.sequence = "composed";
-	return "linear";
-};
-/** A program's own flag route may pin the sequence; wins over the global orchestrator flag. Traced as 'payload' to stay distinguishable from sequence experiments ('flag'). */
-const flagRouteSequenceMw = (ctx, next) => {
-	const route = resolveFlagRoute(ctx.program, ctx.flags, ctx.flagPayloads);
-	if (!route?.sequence) return next();
-	if (ctx.trace) ctx.trace.sequence = "payload";
-	return route.sequence;
-};
-/** Sequence experiments (e.g. wizard-orchestrator), each inert outside its declared programs. */
-const sequenceExperimentMw = (ctx, next) => {
-	const sequence = resolveFlagSequence(ctx.program, ctx.flags);
-	if (!sequence) return next();
-	if (ctx.trace) ctx.trace.sequence = "flag";
-	return sequence;
-};
-/**
-* The orchestrator drives harnesses through `runTask`; a harness that has not
-* implemented it clamps the run to linear. A capability check, not a harness
-* identity check — a harness gains orchestrator support by implementing the
-* method, with no switchboard change. Sits below the CLI override so
-* `--sequence orchestrator` still reproduces the hard error in dev builds.
-*/
-const runTaskCapabilityClampMw = (ctx, next) => {
-	const pick = resolveHarness(ctx);
-	if (getHarness(pick.harness).runTask) return next();
-	if (isOrchestratorEnabled(ctx.flags)) logToFile(`[switchboard] wizard-orchestrator ignored: ${pick.harness} has no runTask, clamping to linear`);
-	if (ctx.trace) ctx.trace.sequence = "runtask-clamp";
-	return "linear";
-};
-const SEQUENCE_MIDDLEWARE = [
-	composedClampMw,
-	...[],
-	runTaskCapabilityClampMw,
-	flagRouteSequenceMw,
-	sequenceExperimentMw
-];
-/** CLI wins over `wizard-orchestrator` flag wins over binding default. */
-function resolveSequence(ctx) {
-	const sequence = runChain(SEQUENCE_MIDDLEWARE, ctx, () => {
-		if (ctx.trace) ctx.trace.sequence = "binding";
-		return (PROGRAM_BINDINGS[ctx.program] ?? DEFAULT_BINDING).sequence;
-	});
-	logToFile(`[switchboard] resolved: program=${ctx.program} sequence=${sequence}${ctx.trace?.sequence ? ` (${ctx.trace.sequence})` : ""}`);
-	return sequence;
-}
-//#endregion
-//#region src/agent/runner/switchboard/index.ts
-/**
-* Run a middleware chain over `ctx`. Each middleware receives `next` (which
-* runs the rest of the chain) and can either:
-*   - defer: call `next()` and optionally modify its result (overlay pattern)
-*   - short-circuit: return a value without calling `next()` (skip the rest)
-*
-* **Earlier in the array = higher precedence.** Index 0 runs first and can
-* short-circuit the rest; index 1 only runs if index 0 deferred. So
-* `[cliSequenceMw, orchestratorFeatureFlagMw]` means CLI takes precedence over the
-* flag, not the other way around.
-*
-* `fallback` runs at the end — reached only when every middleware deferred.
-* Typically the map read for the base value.
-*/
-function runChain(chain, ctx, fallback) {
-	function step(index) {
-		if (index >= chain.length) return fallback();
-		const middleware = chain[index];
-		const next = () => step(index + 1);
-		return middleware(ctx, next);
-	}
-	return step(0);
-}
-const DEFAULT_BINDING = {
-	sequence: "linear",
-	harness: "pi",
-	model: GPT5_6_SOL_MODEL,
-	thinkingLevel: "medium"
-};
-/**
-* Per-program routing. Kept in lockstep with `PROGRAM_REGISTRY` by the
-* switchboard test. Anything absent falls back to `DEFAULT_BINDING`.
-*/
-const PROGRAM_BINDINGS = {
-	"posthog-integration": DEFAULT_BINDING,
-	"revenue-analytics-setup": DEFAULT_BINDING,
-	"warehouse-source": DEFAULT_BINDING,
-	"error-tracking-upload-source-maps": {
-		sequence: "linear",
-		harness: "pi",
-		model: GPT5_6_SOL_MODEL,
-		thinkingLevel: "medium"
-	},
-	audit: DEFAULT_BINDING,
-	"events-audit": DEFAULT_BINDING,
-	"posthog-doctor": DEFAULT_BINDING,
-	"web-analytics-doctor": DEFAULT_BINDING,
-	migration: DEFAULT_BINDING,
-	"self-driving": DEFAULT_BINDING,
-	"agent-skill": DEFAULT_BINDING,
-	"mcp-add": DEFAULT_BINDING,
-	"mcp-remove": DEFAULT_BINDING,
-	"mcp-tutorial": DEFAULT_BINDING,
-	"mcp-analytics": DEFAULT_BINDING,
-	metrics: {
-		sequence: "orchestrator",
-		harness: "pi",
-		model: DEFAULT_AGENT_MODEL
-	},
-	"replay-vision": {
-		sequence: "orchestrator",
-		harness: "anthropic",
-		model: DEFAULT_AGENT_MODEL
-	},
-	"error-tracking": {
-		sequence: "orchestrator",
-		harness: "pi",
-		model: DEFAULT_AGENT_MODEL
-	},
-	"ai-observability": {
-		sequence: "linear",
-		harness: "pi",
-		model: GPT5_6_TERRA_MODEL,
-		thinkingLevel: "high"
-	},
-	slack: DEFAULT_BINDING
-};
-/** Compose both axes. Callers needing only one axis use the per-axis resolver. */
-function resolveBinding(ctx, role = "default") {
-	ctx.trace ??= {};
-	const sequence = resolveSequence(ctx);
-	const { harness, model, thinkingLevel } = resolveHarness(ctx, role);
-	return {
-		sequence,
-		harness,
-		model,
-		thinkingLevel
-	};
-}
-/** A scan's two attempts on triage models: the resolved harness, then the SDK as a second provider. */
-function resolveScanBindings(ctx) {
-	const scan = (harness) => ({
-		sequence: "linear",
-		harness,
-		model: triageModelFor(harness)
-	});
-	return [scan(resolveBinding(ctx).harness), scan("anthropic")];
-}
-//#endregion
-//#region src/agent/runner/index.ts
-/**
-* Run a program's agent pipeline.
-*
-* Prepare → dispatch to the sequence the binding names → return its result
-* with the agent's own snapshot of what it reported. Missing observers change
-* nothing; a throwing observer is logged and the run continues.
-*/
-async function runAgent(config, input, options = {}) {
-	let collector;
-	let transcript;
-	const snapshot = () => {
-		try {
-			if (collector) {
-				const collected = collector.snapshot();
-				return transcript ? {
-					...collected,
-					transcriptTail: transcript.text()
-				} : collected;
-			}
-		} catch {}
-		return {
-			tasks: [],
-			statusMessages: [],
-			usage: {
-				inputTokens: 0,
-				outputTokens: 0,
-				cacheReadTokens: 0,
-				cacheCreationTokens: 0
-			}
-		};
-	};
-	const flushReport = () => {
-		if (config.scanReport === "defer") return;
-		try {
-			const report = flushScanReport({ yaraReport: input.flags.yaraReport });
-			if (report) collector?.emit({
-				kind: "log",
-				level: "info",
-				message: report
-			});
-		} catch {}
-	};
-	let result;
-	try {
-		collector = createProgressCollector(options.onProgress);
-		const { emit } = collector;
-		if (config.run.collectTranscript) transcript = createTranscriptTail(emit);
-		const log = (message) => emit({
-			kind: "log",
-			level: "info",
-			message
-		});
-		if (options.signal?.aborted) {
-			flushReport();
-			return {
-				outcome: "aborted",
-				skillId: input.skillId,
-				failure: {
-					code: ErrorCodes.AgentAbort,
-					message: "Agent run cancelled"
-				},
-				snapshot: snapshot()
-			};
-		}
-		const boot = await prepareRun(config, input);
-		if (config.binding.sequence === "orchestrator") log("Task-queue orchestrator enabled.");
-		try {
-			logToFile(`[agent-runner] run program=${config.programId} sequence=${config.binding.sequence} harness=${config.binding.harness} composed=${config.composed}`);
-		} catch {}
-		const sequenceResult = await getSequence(config.binding.sequence).run({
-			config,
-			input,
-			boot,
-			emit,
-			interaction: options.interaction,
-			signal: options.signal,
-			transcript
-		});
-		result = {
-			...options.signal?.aborted && sequenceResult.outcome === "success" ? {
-				outcome: "aborted",
-				failure: {
-					code: ErrorCodes.AgentAbort,
-					message: "Agent run cancelled"
-				}
-			} : sequenceResult,
-			skillId: input.skillId,
-			snapshot: snapshot()
-		};
-	} catch (error) {
-		const original = error instanceof Error ? error : new Error(safeErrorMessage(error));
-		let failure;
-		try {
-			failure = classifyRunFailure(original);
-		} catch {
-			failure = {
-				code: ErrorCodes.InternalUnhandled,
-				message: "Unexpected agent error",
-				coded: false
-			};
-		}
-		try {
-			logToFile("[agent-runner] run failed:", original);
-		} catch {}
-		let abortError = false;
-		try {
-			abortError = original.name === "AbortError";
-		} catch {}
-		if (failure.coded) result = {
-			outcome: "failed",
-			skillId: input?.skillId,
-			failure: {
-				code: failure.code,
-				message: failure.message,
-				error: original
-			},
-			snapshot: snapshot()
-		};
-		else if (options.signal?.aborted && abortError) result = {
-			outcome: "aborted",
-			skillId: input?.skillId,
-			failure: {
-				code: ErrorCodes.AgentAbort,
-				message: "Agent run cancelled"
-			},
-			snapshot: snapshot()
-		};
-		else result = {
-			outcome: "crashed",
-			skillId: input?.skillId,
-			failure: {
-				code: failure.code,
-				message: failure.message,
-				error: original
-			},
-			snapshot: snapshot()
-		};
-	}
-	flushReport();
-	return result;
-}
-function safeErrorMessage(error) {
-	try {
-		return String(error);
-	} catch {
-		return "Unknown thrown value";
-	}
-}
-//#endregion
-//#region src/agent/runner/switchboard/resolve-run.ts
-/**
-* One event + one log line per run: what entered the switchboard, which
-* precedence rung decided each axis, and the final pick.
-*/
-function captureSwitchboardDecision(ctx, binding) {
-	const trace = ctx.trace ?? {};
-	const perTaskModel = binding.sequence === "orchestrator" && trace.model === "binding";
-	const model = perTaskModel ? "chosen-per-task" : binding.model;
-	const modelSource = perTaskModel ? "agent-prompts" : trace.model;
-	analytics.wizardCapture("switchboard resolved", {
-		program: ctx.program,
-		flag_self_driving_use_pi_harness: ctx.flags[WIZARD_SELF_DRIVING_USE_PI_HARNESS_FLAG_KEY],
-		flag_self_driving_pi_payload: JSON.stringify(ctx.flagPayloads?.["wizard-self-driving-use-pi-harness"] ?? null),
-		flag_orchestrator: ctx.flags[WIZARD_ORCHESTRATOR_FLAG_KEY],
-		cli_harness: ctx.cliHarness,
-		cli_sequence: ctx.cliSequence,
-		cli_model: ctx.cliModel,
-		harness_source: trace.harness,
-		model_source: modelSource,
-		sequence_source: trace.sequence,
-		harness: binding.harness,
-		model,
-		thinking_level: binding.thinkingLevel,
-		sequence: binding.sequence
-	});
-	logToFile(`[switchboard] decision: program=${ctx.program} in(orchestrator=${ctx.flags["wizard-orchestrator"] ?? "-"}, cli=${ctx.cliHarness ?? "-"}/${ctx.cliSequence ?? "-"}/${ctx.cliModel ?? "-"}) → harness=${binding.harness} (${trace.harness ?? "?"}) model=${model} (${modelSource ?? "?"}) sequence=${binding.sequence} (${trace.sequence ?? "?"})`);
-}
-//#endregion
-//#region src/agent/index.ts
-/**
-* Leaves in C2. The TUI receives agent data through program state. Until
-* then the suggested-prompts screen streams through this wrapper, which loads
-* the streaming module on first call so the startup chunk does not grow.
-*/
-async function* runMcpPromptViaSdk(args) {
-	yield* (await import("./mcp-prompt-streaming-ljCVoQ9I.js")).runMcpPromptViaSdk(args);
-}
-//#endregion
-export { resolveScanBindings as a, formatTokenCount as c, resolveBinding as i, captureSwitchboardDecision as n, computeTokenCostUsd as o, runAgent as r, formatCostUsd as s, runMcpPromptViaSdk as t };
-
-//# sourceMappingURL=agent-BkBbVuNq.js.map