@posthog/wizard 2.77.0 → 2.78.0

package/dist/agent-bCZ3i3fh.js

@@ -0,0 +1,3085 @@
+import { t as __exportAll } from "./rolldown-runtime-B_-DWIq7.js";
+import { a as AgentSignals, d as ErrorCodes, i as AGENT_ERROR_CODE, l as WizardError, r as skillErrorCode, t as classifyRunFailure } from "./errors-CQ9kttJD.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-Ch4BDOtD.js";
+import { t as VERSION } from "./version-aXxpgRKx.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-jFI2SaE1.js";
+import "./wizard-session-2w4Ru-Wz.js";
+import { a as ciExcludedTaskTypes, n as analytics } from "./analytics-CHCZ_qUR.js";
+import { d as mcpUrlFor, p as detectNodePackageManagers } from "./setup-utils-CmTCTPkX.js";
+import { n as currentAccessToken } from "./oauth-session-DJ8h6GFa.js";
+import { c as configureGatewayFromCIEnvironment, l as gatewayAuth } from "./gateway-CjoShdLa.js";
+import { a as requireKnownModel, r as isValidModel } from "./models-DDdBJKwT.js";
+import { U as installSkillById, et as fetchSkillMenu, i as runAgent$1, lt as createTriageLLMProvider, nt as LONGER_ASK_TIMEOUT_MS, r as initializeAgent, rt as createWizardAskBridge } from "./agent-interface-BAOIHuXS.js";
+import { a as piBackend, d as createEmitSpinner, f as createProgressCollector, l as createAioCapture, u as createEmitLog } from "./pi-D3h5Ok0i.js";
+import { a as flushScanReport, s as formatYaraAbortMessage } from "./yara-hooks-DCeMDd1o.js";
+import { _ as TaskStatus, d as uncoveredBySink, h as SkipReason, m as QueueStore, p as QUEUE_DIR_NAME, u as dependencyClosure } from "./queue-tools-9OOVx5TE.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-7Pd4CfZO.js";
+import fs, { cpSync, existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "fs";
+import * as path$1 from "path";
+import path from "path";
+import { z } from "zod";
+import { randomUUID } from "crypto";
+//#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`.
+*/
+/**
+* Decide whether the `wizard_ask` overlay should be wired for this run.
+* Disabled in non-interactive modes (CI, signup) — there's no human to
+* answer. Per-program disabling is done by adding WIZARD_ASK_TOOL_NAME to
+* the program's `disallowedTools` so the SDK rejects calls outright.
+* Extracted so the policy can be unit-tested directly.
+*
+* `e2eAsk` is the one escape hatch. The e2e harness runs a `ci`
+* session, but it does have an answerer — the driver loop answers each
+* `wizard_ask` batch from the program's e2e profile. Without the flag the
+* agent-in-the-loop layer (the ask bridge in both sequence arms, and the
+* orchestrator's seeded warehouse task) stays unreachable from a test.
+*
+* Only the e2e TUI host sets the flag, from the `E2E_ASK` env var. No CLI flag
+* populates it, so plain `--ci` and `--signup` runs behave exactly as before.
+*/
+function shouldDisableAsk(flags) {
+	return (flags.ci || flags.signup) && !flags.e2eAsk;
+}
+/** 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)
+	};
+}
+//#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 } = 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
+		});
+		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,
+			allowedTools: runConfig.allowedTools,
+			disallowedTools: runConfig.disallowedTools,
+			modelOverride: model,
+			capture,
+			emit
+		}, runOptions(input));
+		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, {
+			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,
+			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/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 host's `signal` decides the outcome; `runSignal` also ends with the run. */
+async function executeLinear({ config, input, boot, emit, interaction, signal }, 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);
+	emit({
+		kind: "lifecycle",
+		phase: "started"
+	});
+	const ask = 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 = input.flags.benchmark ? createBenchmarkPipeline(emit, spinner, runOptions(input)) : void 0;
+	const prompt = assemblePrompt(run, {
+		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
+	});
+	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
+	});
+	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 (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
+	};
+}
+//#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;
+	const snapshot = () => {
+		try {
+			if (collector) return collector.snapshot();
+		} catch {}
+		return {
+			tasks: [],
+			statusMessages: [],
+			usage: {
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheReadTokens: 0,
+				cacheCreationTokens: 0
+			}
+		};
+	};
+	const flushReport = () => {
+		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;
+		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
+		});
+		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/index.ts
+var agent_exports = /* @__PURE__ */ __exportAll({
+	LONGER_ASK_TIMEOUT_MS: () => LONGER_ASK_TIMEOUT_MS,
+	TASK_OUTCOMES_KEY: () => TASK_OUTCOMES_KEY,
+	configureGatewayFromCIEnvironment: () => configureGatewayFromCIEnvironment,
+	runMcpPromptViaSdk: () => runMcpPromptViaSdk
+});
+/**
+* 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-I2U_X7BC.js")).runMcpPromptViaSdk(args);
+}
+//#endregion
+export { formatCostUsd as a, computeTokenCostUsd as i, runAgent as n, formatTokenCount as o, resolveBinding as r, shouldDisableAsk as s, agent_exports as t };
+
+//# sourceMappingURL=agent-bCZ3i3fh.js.map