@posthog/wizard 2.24.1 → 2.25.0

package/dist/{agent-runner-CBbkS0Ro.js → agent-runner-L_-kJ3y3.js}

@@ -1,13 +1,583 @@
-import { Q as getSkillsBaseUrl, _ as SIGNUP_WIZARD_READINESS_CONFIG, a as getLogFilePath, c as WIZARD_BENCHMARK_FILE, g as SERVICE_LABELS, i as enableDebugLogs, l as WIZARD_LOG_FILE, o as initLogFile, p as getUI, s as logToFile, t as configureLogFile, tt as runtimeEnv, v as evaluateWizardReadiness, y as getBlockingServiceKeys } from "./debug-DxA_f5QT.js";
-import { n as groupsFromUser, t as analytics } from "./analytics-CUr82BDl.js";
-import { t as getOrAskForProjectData } from "./setup-utils-0U-_Md2G.js";
-import { n as getCloudUrlFromRegion } from "./urls-C8aJWvgh.js";
-import { i as wizardAbort, n as registerCleanup, t as WizardError } from "./wizard-abort-C6gRLxUE.js";
-import { a as backupAndFixClaudeSettings, c as restoreClaudeSettings, d as writeScanReport, h as installSkillById, i as runAgent$1, l as AgentSignals, n as buildWizardMetadata, o as checkAllSettingsConflicts, r as initializeAgent, u as formatScanReport } from "./agent-interface-D1vtN6Wn.js";
-import { r as detectNodePackageManagers } from "./package-manager-BWUS4CP0.js";
-import fs from "fs";
+import { $ as getSkillsBaseUrl, _ as SIGNUP_WIZARD_READINESS_CONFIG, a as getLogFilePath, c as WIZARD_BENCHMARK_FILE, g as SERVICE_LABELS, i as enableDebugLogs, l as WIZARD_LOG_FILE, nt as runtimeEnv, o as initLogFile, p as getUI, s as logToFile, t as configureLogFile, v as evaluateWizardReadiness, y as getBlockingServiceKeys } from "./debug-BwC7UkGH.js";
+import { i as ciExcludedTaskTypes, n as groupsFromUser, t as analytics } from "./analytics-CDOujOSQ.js";
+import { t as getOrAskForProjectData } from "./setup-utils-D87CyNkw.js";
+import { n as getCloudUrlFromRegion } from "./urls-vkJ5c0ix.js";
+import { i as wizardAbort, n as registerCleanup, t as WizardError } from "./wizard-abort-CLGgMAEe.js";
+import { n as isNonInteractiveEnvironment } from "./environment-DQPoj9sU.js";
+import { _ as QUEUE_DIR_NAME, a as runAgent$1, d as formatScanReport, f as writeScanReport, g as installSkillById, h as fetchSkillMenu, i as isOrchestratorEnabled, l as restoreClaudeSettings, n as buildWizardMetadata, o as backupAndFixClaudeSettings, r as initializeAgent, s as checkAllSettingsConflicts, u as AgentSignals, v as QueueStore, y as TaskStatus } from "./agent-interface-BsuUUPle.js";
+import { r as detectNodePackageManagers } from "./package-manager-CB4c2euf.js";
+import fs, { existsSync, rmSync } from "fs";
+import * as path$1 from "path";
 import path from "path";
 import { randomUUID } from "crypto";
+//#region src/lib/programs/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.
+*/
+const DEFAULT_DRAIN_OPTIONS = { maxStarts: 200 };
+async function runOne(store, runTask, task) {
+	store.start(task.id);
+	try {
+		await runTask(task);
+	} catch (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
+		});
+	}
+	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;
+	for (;;) {
+		for (const task of store.nextRunnable()) {
+			if (++starts > opts.maxStarts) break;
+			const p = runOne(store, runTask, task).finally(() => running.delete(task.id));
+			running.set(task.id, p);
+		}
+		if (running.size === 0) break;
+		await Promise.race(running.values());
+	}
+}
+//#endregion
+//#region src/lib/programs/orchestrator/run-metrics.ts
+var RunMetrics = class {
+	firstStartMs;
+	lastStartMs;
+	firstCompleteMs;
+	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);
+	}
+	/**
+	* 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
+		};
+	}
+	/** 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/lib/agent/agent-prompt-loader.ts
+function projectContext(ctx) {
+	return `You have access to the PostHog MCP server and the wizard tools.
+
+Project context:
+- PostHog Project ID: ${ctx.projectId}
+- PostHog public token: ${ctx.projectApiKey}
+- PostHog Host: ${ctx.host}`;
+}
+/** Points the agent at the framework's reference integration to learn patterns from. */
+function exampleReference(ctx) {
+	if (!ctx.examplePath) return null;
+	return `A reference PostHog integration for this framework is at \`${ctx.examplePath}\`. It shows the target implementation pattern. Reference its patterns and conventions, adapting them to this codebase.`;
+}
+/** The framework's rules ship with the reference skill; every task follows them. */
+function commandmentsReference(ctx) {
+	if (!ctx.commandmentsPath) return null;
+	return `Framework rules for this integration are at \`${ctx.commandmentsPath}\`. Read them before you edit and follow them.`;
+}
+const TASK_BASICS = `You are one isolated task in a larger PostHog workflow, run as a fresh agent with no memory of the other tasks beyond the context you are given. Do only your task, then report exactly once by calling complete_task with a structured handoff: what your goal was, what you did, and what the next agent should know. When you are given context from previous steps, trust it — those agents already did their work, so do not re-verify or re-read what their handoffs tell you. Build on it and move fast. Read a file before you edit it, so your own changes do not duplicate what is already there. Work only inside this project's own directory: never read, list, or search (find, ls, grep, glob) outside it — not the OS, not other projects, not global package caches. If your task seems to need something outside this directory, it does not — skip that part and say so in your handoff rather than hunting across the filesystem. If your task does not apply to this project — there is genuinely nothing for it to do — report it with status \`skipped\` and say why, rather than marking it done.`;
+const SEED_BASICS = `You are the orchestrator. Plan the work and seed the queue with enqueue_task — each call returns an id you can pass as a dependency to a later task. Give each task a short label for the UI — the action in a few words, not file names, class names, or other specifics. You are not a task yourself: do not call complete_task and do not edit the project.`;
+/**
+* Points the agent at its installed task instructions (the HOW). They live under
+* the wizard's run dir, not `.claude/skills/`, so the SDK does not auto-load
+* them — the prompt has to name them.
+*/
+function skillReference(paths) {
+	if (paths.length === 0) return null;
+	return `Your task instructions are at ${paths.map((p) => `\`${p}\``).join(", ")}. Read them before you start and follow them. They are wizard scaffolding, not part of the project.`;
+}
+/** A task agent's full prompt: injected basics, then the authored intent. */
+function assembleTaskPrompt(ctx, body, skillPaths = []) {
+	return [
+		projectContext(ctx),
+		exampleReference(ctx),
+		commandmentsReference(ctx),
+		skillReference(skillPaths),
+		TASK_BASICS,
+		body
+	].filter(Boolean).join("\n\n");
+}
+/** The seed agent's full prompt: injected basics, then the authored intent. */
+function assembleSeedPrompt(ctx, body) {
+	return [
+		projectContext(ctx),
+		SEED_BASICS,
+		body
+	].join("\n\n");
+}
+/** Used when neither the enqueue call nor the prompt frontmatter names a model. */
+const DEFAULT_TASK_MODEL = "claude-sonnet-4-6";
+/** Orchestrator tools are MCP tools under the `posthog-wizard` server. Frontmatter
+*  names them short (e.g. `enqueue_task`); the SDK gates on the full name. */
+const ORCHESTRATOR_TOOL_PREFIX = "mcp__posthog-wizard__";
+const ORCHESTRATOR_TOOLS = new Set([
+	"enqueue_task",
+	"complete_task",
+	"read_handoffs"
+]);
+/** The registry for one flow's prompts. Pure; the loader feeds it the fetched set. */
+function buildRegistry(prompts, flow, opts) {
+	const excluded = new Set(opts?.exclude ?? []);
+	const inFlow = prompts.filter((p) => p.flow === flow && !excluded.has(p.type));
+	const byType = new Map(inFlow.map((p) => [p.type, p]));
+	return {
+		types: inFlow.filter((p) => !p.seed).map((p) => p.type),
+		seed: inFlow.find((p) => p.seed),
+		get: (type) => byType.get(type)
+	};
+}
+/** A native tool passes through; an orchestrator tool gets its MCP-qualified name. */
+function expandToolName(name) {
+	return ORCHESTRATOR_TOOLS.has(name) ? `${ORCHESTRATOR_TOOL_PREFIX}${name}` : name;
+}
+/** A prompt's allow/disallow lists with orchestrator tool names MCP-qualified. */
+function agentRunTools(prompt) {
+	return {
+		allowedTools: prompt.allowedTools.map(expandToolName),
+		disallowedTools: prompt.disallowedTools.map(expandToolName)
+	};
+}
+function toStringArray(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((v) => typeof v === "string");
+}
+/**
+* Parse the leading `---` frontmatter block and the markdown body. The
+* frontmatter is a small, known schema (scalars and inline `[a, b]` arrays), so
+* a tiny parser covers it without a YAML dependency. Inline `# comments` after a
+* value are stripped. `fallbackType` is the menu id, used when the body omits
+* `type:`.
+*/
+function parseAgentPrompt(text, fallbackType) {
+	const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+	const frontmatter = match ? match[1] : "";
+	const body = (match ? match[2] : text).trim();
+	const fields = {};
+	for (const rawLine of frontmatter.split(/\r?\n/)) {
+		const line = rawLine.replace(/\s+#.*$/, "").trim();
+		if (!line || line.startsWith("#")) continue;
+		const kv = line.match(/^([\w-]+):\s*(.*)$/);
+		if (!kv) continue;
+		const [, key, raw] = kv;
+		if (raw.startsWith("[") && raw.endsWith("]")) fields[key] = raw.slice(1, -1).split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+		else fields[key] = raw.replace(/^['"]|['"]$/g, "");
+	}
+	const model = typeof fields.model === "string" ? fields.model : void 0;
+	return {
+		type: typeof fields.type === "string" ? fields.type : fallbackType,
+		label: typeof fields.label === "string" ? fields.label : void 0,
+		flow: typeof fields.flow === "string" ? fields.flow : void 0,
+		seed: fields.seed === "true",
+		model,
+		skills: toStringArray(fields.skills),
+		allowedTools: toStringArray(fields.allowedTools),
+		disallowedTools: toStringArray(fields.disallowedTools),
+		dependsOn: toStringArray(fields.dependsOn),
+		body
+	};
+}
+async function fetchText(url) {
+	const res = await fetch(url);
+	if (!res.ok) throw new Error(`Fetch ${url} failed: ${res.status} ${res.statusText}`);
+	return res.text();
+}
+/**
+* Fetch the agent menu and every agent prompt it lists, parse them, and build
+* the registry for one flow. Throws if the menu cannot be fetched — the
+* orchestrator cannot run without its prompts.
+*/
+async function loadAgentRegistry(skillsBaseUrl, flow, opts) {
+	const menuRaw = await fetchText(`${skillsBaseUrl}/agent-menu.json`);
+	const menu = JSON.parse(menuRaw);
+	return buildRegistry(await Promise.all((menu.agents ?? []).map(async (entry) => {
+		return parseAgentPrompt(await fetchText(entry.downloadUrl), entry.id);
+	})), flow, opts);
+}
+/**
+* Render a task's own inputs into a section, so a fanned-out task (e.g. one
+* `capture` per event) sees the specific thing it owns. Empty when there are none.
+*/
+function renderInputs(task) {
+	const entries = Object.entries(task.inputs ?? {});
+	if (entries.length === 0) return "";
+	return `## Your task input\n\n${entries.map(([k, v]) => `- ${k}: ${formatInputValue(v)}`).join("\n")}`;
+}
+function formatInputValue(value) {
+	if (typeof value === "string") return value;
+	return JSON.stringify(value);
+}
+/**
+* The ids of every task `task` transitively depends on — the full upstream
+* chain, not just direct dependencies — ordered roots-first, each once. A `seen`
+* set dedupes diamonds and guards against cycles.
+*/
+function ancestorIds(task, store) {
+	const seen = /* @__PURE__ */ new Set();
+	const ordered = [];
+	const visit = (id) => {
+		if (seen.has(id)) return;
+		seen.add(id);
+		const t = store.get(id);
+		if (!t) return;
+		for (const dep of t.dependsOn) visit(dep);
+		ordered.push(id);
+	};
+	for (const dep of task.dependsOn) visit(dep);
+	return ordered;
+}
+/**
+* Render the handoffs of every step `task` transitively depends on into a context
+* section, so a fresh agent sees the whole upstream chain — not just its direct
+* dependencies. Reliability over token economy: a step must never have to
+* re-discover what any ancestor already established just because an intermediate
+* handoff happened to omit it. Empty when there are no completed ancestors.
+*/
+function renderHandoffContext(task, store) {
+	const lines = [];
+	for (const id of ancestorIds(task, store)) {
+		const dep = store.get(id);
+		const handoff = store.readHandoff(id);
+		if (!dep || !handoff) continue;
+		lines.push(`### ${dep.type}`);
+		lines.push(`- did: ${handoff.did}`);
+		lines.push(`- for you: ${handoff.forNextAgent}`);
+		if (handoff.filesTouched?.length) lines.push(`- files: ${handoff.filesTouched.join(", ")}`);
+		lines.push("");
+	}
+	if (lines.length === 0) return "";
+	return `## Context from previous steps\n\n${lines.join("\n")}`.trim();
+}
+/**
+* Resolve a queued task to its run config: the prompt body (with upstream
+* handoffs appended), the model, and the tool lists with orchestrator tool names
+* MCP-qualified. The model precedence is enqueue override, then prompt, then
+* default. Throws if no prompt is registered for the task's type.
+*/
+function resolveTask(registry, task, store) {
+	const prompt = registry.get(task.type);
+	if (!prompt) throw new Error(`No agent prompt registered for task type "${task.type}"`);
+	const body = [
+		renderInputs(task),
+		prompt.body,
+		renderHandoffContext(task, store)
+	].filter(Boolean).join("\n\n");
+	return {
+		model: taskModel(registry, task),
+		...agentRunTools(prompt),
+		prompt: body,
+		skills: prompt.skills
+	};
+}
+/** The model a task runs on: enqueue override, then prompt frontmatter, then default. */
+function taskModel(registry, task) {
+	return task.model ?? registry.get(task.type)?.model ?? DEFAULT_TASK_MODEL;
+}
+//#endregion
+//#region src/lib/programs/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.
+*/
+function toTodoStatus(status) {
+	switch (status) {
+		case TaskStatus.Running: return "in_progress";
+		case TaskStatus.Done:
+		case TaskStatus.Failed: return "completed";
+		case TaskStatus.Skipped: return "skipped";
+		default: return "pending";
+	}
+}
+function sessionRunOptions(session) {
+	return {
+		installDir: session.installDir,
+		debug: session.debug,
+		default: false,
+		signup: session.signup,
+		localMcp: session.localMcp,
+		ci: session.ci,
+		benchmark: session.benchmark,
+		projectId: session.projectId,
+		apiKey: session.apiKey,
+		yaraReport: session.yaraReport
+	};
+}
+/**
+* The framework reference is the full `integration` skill. `session.skillId` is
+* the bare framework (e.g. `django`), but the skill menu ids it as
+* `integration-<variant>`. Resolve to the menu id: exact `integration-<framework>`
+* (the 1:1 frameworks — django, python, flask, …), else the first granular variant
+* under it (e.g. `integration-nextjs-app-router`). Undefined when none exists.
+*/
+async function resolveReferenceSkillId(skillsBaseUrl, framework) {
+	const menu = await fetchSkillMenu(skillsBaseUrl);
+	if (!menu) return void 0;
+	const ids = Object.values(menu.categories).flat().map((s) => s.id);
+	const exact = `integration-${framework}`;
+	if (ids.includes(exact)) return exact;
+	return ids.find((id) => id.startsWith(`integration-${framework}-`));
+}
+async function runOrchestrator(session, programConfig, boot) {
+	const runId = randomUUID();
+	const options = sessionRunOptions(session);
+	const registry = await loadAgentRegistry(boot.skillsBaseUrl, programConfig.id, { exclude: ciExcludedTaskTypes() });
+	const seedPrompt = registry.seed;
+	if (!seedPrompt) throw new Error(`No seed agent prompt (frontmatter \`seed: true\`) for flow "${programConfig.id}" is available from ${boot.skillsBaseUrl}.`);
+	analytics.setTag("variant", "orchestrator");
+	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(session.installDir, runId, { onTransition: (event, task) => {
+		const base = {
+			type: task.type,
+			model: taskModel(registry, task),
+			attempts: task.attempts
+		};
+		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)
+				});
+				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;
+	const referenceSkillId = session.skillId ? await resolveReferenceSkillId(boot.skillsBaseUrl, session.skillId) : void 0;
+	if (referenceSkillId) {
+		const ref = await installSkillById(referenceSkillId, session.installDir, boot.skillsBaseUrl, path$1.join(QUEUE_DIR_NAME, "reference"));
+		if (ref.kind === "ok") {
+			const example = path$1.join(ref.path, "references", "EXAMPLE.md");
+			if (existsSync(path$1.join(session.installDir, example))) examplePath = example;
+			const commandments = path$1.join(ref.path, "references", "COMMANDMENTS.md");
+			if (existsSync(path$1.join(session.installDir, commandments))) commandmentsPath = commandments;
+		} else logToFile(`[orchestrator] reference unavailable: ${ref.kind} (${referenceSkillId})`);
+	} else if (session.skillId) logToFile(`[orchestrator] no integration skill for framework "${session.skillId}"`);
+	const promptContext = {
+		projectId: boot.projectId,
+		projectApiKey: boot.projectApiKey,
+		host: boot.host,
+		examplePath,
+		commandmentsPath
+	};
+	logToFile(`[orchestrator] START program=${programConfig.id} dir=${session.installDir} run=${runId}`);
+	analytics.wizardCapture("orchestrator started", { program_id: programConfig.id });
+	getUI().startRun();
+	const labelFor = (t) => t.label ?? registry.get(t.type)?.label ?? t.type;
+	const renderQueue = () => getUI().syncTodos(store.list().map((t) => ({
+		content: labelFor(t),
+		status: toTodoStatus(t.status),
+		activeForm: labelFor(t)
+	})));
+	const agentConfigFor = (currentTaskId) => ({
+		workingDirectory: session.installDir,
+		posthogMcpUrl: boot.mcpUrl,
+		posthogApiKey: boot.accessToken,
+		posthogApiHost: boot.host,
+		detectPackageManager: detectNodePackageManagers,
+		skillsBaseUrl: boot.skillsBaseUrl,
+		wizardFlags: boot.wizardFlags,
+		wizardMetadata: {
+			...boot.wizardMetadata,
+			VARIANT: "orchestrator"
+		},
+		integrationLabel: programConfig.id,
+		orchestrator: {
+			store,
+			validTypes: registry.types,
+			currentTaskId
+		}
+	});
+	const spinner = getUI().spinner();
+	const seedAgent = await initializeAgent(agentConfigFor(), options);
+	const seedResult = await runAgent$1({
+		...seedAgent,
+		model: seedPrompt.model ?? seedAgent.model,
+		...agentRunTools(seedPrompt)
+	}, assembleSeedPrompt(promptContext, seedPrompt.body), options, spinner, {
+		spinnerMessage: "Planning the integration...",
+		successMessage: "Planned the integration",
+		additionalFeatureQueue: [],
+		requestRemark: false,
+		analyticsProperties: { task_type: "seed" }
+	});
+	if (seedResult.error) logToFile(`[orchestrator] seed error: ${seedResult.error} ${seedResult.message ?? ""}`);
+	analytics.wizardCapture("orchestrator seeded", {
+		task_count: store.list().length,
+		types: store.list().map((t) => t.type)
+	});
+	renderQueue();
+	const taskSkillsRoot = path$1.join(QUEUE_DIR_NAME, "skills");
+	let remarkRequested = false;
+	const runTask = async (task) => {
+		renderQueue();
+		try {
+			const resolved = resolveTask(registry, task, store);
+			const agent = await initializeAgent(agentConfigFor(task.id), options);
+			const skillPaths = [];
+			for (const skillId of resolved.skills) {
+				const result = await installSkillById(skillId, session.installDir, boot.skillsBaseUrl, taskSkillsRoot);
+				if (result.kind === "ok") skillPaths.push(path$1.join(result.path, "SKILL.md"));
+				else logToFile(`[orchestrator] skill install failed type=${task.type} skill=${skillId} ${result.kind}`);
+			}
+			const requestRemark = !store.list().some((t) => t.id !== task.id && (t.status === TaskStatus.Pending || t.status === TaskStatus.Running)) && !remarkRequested;
+			if (requestRemark) remarkRequested = true;
+			await runAgent$1({
+				...agent,
+				model: resolved.model,
+				allowedTools: resolved.allowedTools,
+				disallowedTools: resolved.disallowedTools
+			}, assembleTaskPrompt(promptContext, resolved.prompt, skillPaths), options, spinner, {
+				spinnerMessage: "",
+				successMessage: "",
+				additionalFeatureQueue: [],
+				requestRemark,
+				analyticsProperties: {
+					task_type: task.type,
+					task_id: task.id
+				}
+			});
+		} finally {
+			renderQueue();
+		}
+	};
+	try {
+		await drainQueue(store, runTask);
+	} finally {
+		try {
+			rmSync(path$1.join(session.installDir, QUEUE_DIR_NAME), {
+				recursive: true,
+				force: true
+			});
+		} catch (err) {
+			analytics.captureException(err instanceof Error ? err : new Error(String(err)), { step: "orchestrator_cache_cleanup" });
+		}
+	}
+	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.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 buildTask = store.list().find((t) => t.type === "build");
+	const conflict = buildTask ? store.readHandoff(buildTask.id)?.conflict : void 0;
+	const reportFile = existsSync(path$1.join(session.installDir, "posthog-setup-report.md")) ? "posthog-setup-report.md" : store.queuePath;
+	const message = conflict ? "PostHog set up, with one conflict to review." : `PostHog set up: ${summary.done}/${summary.total} steps completed.`;
+	getUI().setOutroData({
+		kind: "success",
+		message,
+		body: conflict ? `⚠ Build conflict: ${conflict}\nFull details are in the report.` : void 0,
+		reportFile,
+		docsUrl: "https://posthog.com/docs/ai-engineering/ai-wizard"
+	});
+	getUI().outro(message);
+	await analytics.shutdown("success");
+}
+//#endregion
 //#region src/lib/middleware/phase-detector.ts
 /** Phase transitions from [STATUS] in assistant text. Keep in sync with program "Status to report" bullets. */
 const PHASES_ORDER = [
@@ -948,12 +1518,25 @@ async function runAgent(programConfig, session) {
 /**
 * Run a program's agent pipeline.
 *
-* This is the single execution path for all programs — both skill-based
-* (revenue analytics) and framework-based (core integration). The
-* `ProgramRun` controls what varies between them; `programConfig` carries
-* the program-level static metadata (tool allow/disallow lists, etc.).
+* Runs the shared bootstrap, then forks on the `wizard-variant` flag. The
+* `orchestrator` variant routes to the experimental task-queue runner; every
+* other variant runs the linear pipeline.
 */
 async function runProgram(session, config, programConfig) {
+	const boot = await bootstrapProgram(session, config, programConfig);
+	if (isOrchestratorEnabled(boot.wizardFlags)) {
+		getUI().log.info("Task-queue orchestrator enabled.");
+		return runOrchestrator(session, programConfig, boot);
+	}
+	return runLinearProgram(session, config, programConfig, boot);
+}
+/**
+* Shared setup for both arms: logging, health check, settings conflicts, OAuth
+* and credentials, then the feature flags, variant metadata, and MCP url. Sets
+* `session.credentials`, role, and user as a side effect. Returns the values the
+* arms still need.
+*/
+async function bootstrapProgram(session, config, programConfig) {
 	initLogFile();
 	session.skillId = config.skillId ?? config.integrationLabel;
 	logToFile(`[agent-runner] START ${config.integrationLabel}`);
@@ -970,7 +1553,7 @@ async function runProgram(session, config, programConfig) {
 			const blockingLabels = getBlockingServiceKeys(readiness.health, readinessConfig).map((k) => `${SERVICE_LABELS[k]} (${readiness.health[k].status})`);
 			logToFile(`[agent-runner] blocked by: ${blockingLabels.join(", ")}`);
 			await getUI().showBlockingOutage(readiness);
-			await wizardAbort({ message: "Cannot start — external services are down:\n" + blockingLabels.map((l) => `  - ${l}`).join("\n") + "\n\nPlease try again later." });
+			if (!isNonInteractiveEnvironment()) await wizardAbort({ message: "Cannot start — external services are down:\n" + blockingLabels.map((l) => `  - ${l}`).join("\n") + "\n\nPlease try again later." });
 		} else if (readiness.decision === "yes_with_warnings") getUI().setReadinessWarnings(readiness);
 	}
 	const settingsConflicts = checkAllSettingsConflicts(session.installDir);
@@ -1012,10 +1595,34 @@ async function runProgram(session, config, programConfig) {
 	getUI().setCredentials(session.credentials);
 	getUI().setRoleAtOrganization(roleAtOrganization);
 	getUI().setApiUser(user);
+	if (user) analytics.identifyUser(user);
 	analytics.setGroups(groupsFromUser(user, host));
 	logToFile("[agent-runner] checking AI opt-in gate");
 	await getUI().waitForAiOptIn();
 	logToFile("[agent-runner] AI opt-in gate cleared");
+	const wizardFlags = await analytics.getAllFlagsForWizard();
+	const wizardMetadata = buildWizardMetadata(wizardFlags);
+	analytics.setTag("variant", wizardMetadata.VARIANT);
+	return {
+		skillsBaseUrl,
+		projectApiKey,
+		host,
+		accessToken,
+		projectId,
+		cloudRegion,
+		mcpUrl: session.localMcp ? "http://localhost:8787/mcp" : runtimeEnv("MCP_URL") || "https://mcp.posthog.com/mcp",
+		wizardFlags,
+		wizardMetadata
+	};
+}
+/**
+* The linear pipeline. Single execution path for all non-orchestrator programs,
+* both skill-based (revenue analytics) and framework-based (core integration).
+* The `ProgramRun` controls what varies between them; `programConfig` carries the
+* program-level static metadata (tool allow/disallow lists, etc.).
+*/
+async function runLinearProgram(session, config, programConfig, boot) {
+	const { skillsBaseUrl, projectApiKey, host, accessToken, projectId, cloudRegion, mcpUrl, wizardFlags, wizardMetadata } = boot;
 	let skillPath;
 	if (config.skillId) {
 		logToFile(`[agent-runner] installing skill ${config.skillId}`);
@@ -1028,9 +1635,6 @@ async function runProgram(session, config, programConfig) {
 		logToFile(`[agent-runner] skill installed at ${skillPath}`);
 	}
 	const spinner = getUI().spinner();
-	const wizardFlags = await analytics.getAllFlagsForWizard();
-	const wizardMetadata = buildWizardMetadata(wizardFlags);
-	const mcpUrl = session.localMcp ? "http://localhost:8787/mcp" : runtimeEnv("MCP_URL") || (cloudRegion === "eu" ? "https://mcp-eu.posthog.com/mcp" : "https://mcp.posthog.com/mcp");
 	const restoreSettings = () => restoreClaudeSettings(session.installDir);
 	getUI().onEnterScreen("outro", restoreSettings);
 	if (session.yaraReport) registerCleanup(() => {
@@ -1046,6 +1650,7 @@ async function runProgram(session, config, programConfig) {
 		showQuestion: (q) => getUI().requestQuestion(q),
 		timeoutMs: config.askTimeoutMs
 	});
+	getUI().log.step("Initializing Claude agent...");
 	const agent = await initializeAgent({
 		workingDirectory: session.installDir,
 		posthogMcpUrl: mcpUrl,
@@ -1063,6 +1668,8 @@ async function runProgram(session, config, programConfig) {
 		disallowedTools: programConfig.disallowedTools,
 		getPendingQuestion: () => session.pendingQuestion
 	}, sessionToOptions(session));
+	getUI().log.step(`Verbose logs: ${getLogFilePath()}`);
+	getUI().log.success("Agent initialized. Let's get cooking!");
 	logToFile("[agent-runner] agent initialized");
 	const middleware = session.benchmark ? createBenchmarkPipeline(spinner, sessionToOptions(session)) : void 0;
 	const prompt = assemblePrompt(config, {
@@ -1195,4 +1802,4 @@ async function abortOnInstallFailure(integrationLabel, result) {
 //#endregion
 export { runAgent };
 
-//# sourceMappingURL=agent-runner-CBbkS0Ro.js.map
+//# sourceMappingURL=agent-runner-L_-kJ3y3.js.map