@posthog/wizard 2.78.0 → 2.79.1

package/dist/{run-agent-legacy-d7rWlzQR.js → run-agent-legacy-DOlM6DQu.js}

@@ -1,190 +1,31 @@
-import { t as __exportAll } from "./rolldown-runtime-B_-DWIq7.js";
-import { a as AgentSignals, d as ErrorCodes } from "./errors-CQ9kttJD.js";
-import { i as enableDebugLogs, o as initLogFile, s as logToFile } from "./debug-Ch4BDOtD.js";
-import { $ as getSkillsBaseUrl, G as WIZARD_ORCHESTRATOR_FLAG_KEY, W as WIZARD_OAUTH_SCOPES, Z as WIZARD_SELF_DRIVING_USE_PI_HARNESS_FLAG_KEY, b as HAIKU_MODEL, n as AGENTIC_DETECTION_RETRY_TIMEOUT_MS, t as AGENTIC_DETECTION_FIRST_ATTEMPT_TIMEOUT_MS, u as DETECTION_TIMEOUT_MS, w as Integration } from "./constants-jFI2SaE1.js";
+import { at as MAX_ENV_KEY_SET, c as checkAllSettingsConflicts, ct as toPromptSafeRelativePath, d as restoreClaudeSettings, h as markGrantRevoked, l as classifySettingsConflicts, n as buildRunTags, ot as isEnvFileName, s as backupAndFixClaudeSettings, st as parseEnvKeyNames } from "./agent-interface-FkbaBJwz.js";
+import { n as ErrorCodes } from "./emit-BSetXzDV.js";
+import { i as enableDebugLogs, o as initLogFile, s as logToFile } from "./debug-kAHwWGg7.js";
+import { $ as getSkillsBaseUrl, G as WIZARD_ORCHESTRATOR_FLAG_KEY, W as WIZARD_OAUTH_SCOPES, Z as WIZARD_SELF_DRIVING_USE_PI_HARNESS_FLAG_KEY } from "./constants-DHCBSfnx.js";
 import { r as mayReportScanResults } from "./wizard-session-2w4Ru-Wz.js";
-import { n as analytics, r as groupsFromUser } from "./analytics-CHCZ_qUR.js";
-import { a as safeReadFile, i as readProjectFile, o as walkProjectFiles } from "./bounded-fs-Bx9zTe6m.js";
-import { c as refreshAccessToken, l as OAuthError, p as detectNodePackageManagers, s as missingOAuthScopes, t as getOrAskForProjectData } from "./setup-utils-CmTCTPkX.js";
-import { a as getBlockingServiceKeys, i as evaluateWizardReadiness, n as SERVICE_LABELS, r as SIGNUP_WIZARD_READINESS_CONFIG } from "./logging-ui-_TwoMNbG.js";
-import { t as getUI } from "./ui-BBVuTM1v.js";
-import { i as wizardAbort, t as registerCleanup } from "./wizard-abort-BBkiUxfS.js";
-import { n as isNonInteractiveEnvironment } from "./environment-B07Bmxae.js";
-import { i as oauthCredentials, t as configureOAuthSession } from "./oauth-session-DJ8h6GFa.js";
-import { at as MAX_ENV_KEY_SET, c as checkAllSettingsConflicts, ct as toPromptSafeRelativePath, d as restoreClaudeSettings, h as markGrantRevoked, i as runAgent, l as classifySettingsConflicts, n as buildRunTags, ot as isEnvFileName, r as initializeAgent, s as backupAndFixClaudeSettings, st as parseEnvKeyNames } from "./agent-interface-BAOIHuXS.js";
-import { n as runAgent$1, r as resolveBinding } from "./agent-bCZ3i3fh.js";
-import { _ as coerceAuditChecks, a as flushScanReport } from "./yara-hooks-DCeMDd1o.js";
-import { g as TASK_OUTCOMES_KEY } from "./queue-tools-9OOVx5TE.js";
-import { t as FRAMEWORK_REGISTRY } from "./registry-8YG-kuXk.js";
-import { t as startFileWatcher } from "./file-watcher-DWc_bTs6.js";
-import * as semver from "semver";
+import { n as analytics, r as groupsFromUser } from "./analytics-DXK1gc12.js";
+import "./errors-C2domSkK.js";
+import { a as safeReadFile, i as readProjectFile, o as walkProjectFiles } from "./bounded-fs-vAq-T-K7.js";
+import { d as refreshAccessToken, f as OAuthError, r as getOrAskForProjectData, u as missingOAuthScopes } from "./setup-utils-B26Lf2yF.js";
+import { a as getBlockingServiceKeys, i as evaluateWizardReadiness, n as SERVICE_LABELS, r as SIGNUP_WIZARD_READINESS_CONFIG } from "./logging-ui-Dza4D0MK.js";
+import { t as getUI } from "./ui-Q6-RvERF.js";
+import { i as wizardAbort, t as registerCleanup } from "./wizard-abort-BPdv07np.js";
+import { t as isNonInteractiveEnvironment } from "./environment-BATlQxcQ.js";
+import { i as oauthCredentials, t as configureOAuthSession } from "./oauth-session-DYM2Hrl2.js";
+import { n as runAgent, r as resolveBinding } from "./agent-BWFhuLgo.js";
+import { _ as coerceAuditChecks, a as flushScanReport } from "./yara-hooks-BnxejtXK.js";
+import { g as TASK_OUTCOMES_KEY } from "./queue-tools-C8mXOh7e.js";
+import { t as FRAMEWORK_REGISTRY } from "./registry-CD5RQt38.js";
+import { t as startFileWatcher } from "./file-watcher-Brq2nnHV.js";
 import fs, { existsSync, statSync } from "fs";
-import path, { isAbsolute, join, relative, resolve, sep } from "path";
-//#region src/ui/agent-progress.ts
-/**
-* The inverse of the agent's former `getUI()` calls: one event, one
-* `WizardUI` method, synchronous, in emission order. Because each case maps
-* back to exactly the call the agent used to make, the frame and flow goldens
-* hold without regeneration.
-*/
-function createUiReducer(ui) {
-	let spinner;
-	return (event) => {
-		switch (event.kind) {
-			case "lifecycle":
-				if (event.phase === "started") ui.startRun();
-				else ui.outro(event.message);
-				break;
-			case "spinner":
-				(spinner ??= ui.spinner())[event.action](event.message);
-				break;
-			case "log":
-				ui.log[event.level](event.message);
-				break;
-			case "status":
-				ui.pushStatus(event.message);
-				break;
-			case "tasks":
-				ui.syncTodos(event.tasks);
-				break;
-			case "stage":
-				ui.setStage(event.stage);
-				break;
-			case "url":
-				if (event.which === "dashboard") ui.setDashboardUrl(event.url);
-				else ui.setNotebookUrl(event.url);
-				break;
-			case "usage":
-				ui.addTokenUsage(event.delta);
-				break;
-			case "finalCost":
-				ui.setFinalTokenCostUsd(event.usd);
-				break;
-			case "authError":
-				ui.showAuthError(event.detail);
-				break;
-			case "handoff":
-				ui.setHandoffText(event.text);
-				break;
-			case "completion":
-				ui.setOutroData(event.outro);
-				break;
-			default: throw new Error(`Unhandled agent progress: ${JSON.stringify(event)}`);
-		}
-	};
-}
-/** The agent's questions, answered wherever `getUI()` answers them today. */
-function uiInteraction(ui) {
-	return {
-		ask: (question, { signal }) => dismissOnAbort(ui.requestQuestion(question), signal, () => ui.cancelPendingQuestion()),
-		taskNotice: (notice, { signal }) => dismissOnAbort(ui.showTaskNotice(notice), signal, () => ui.cancelTaskNotice())
-	};
-}
-/**
-* Dismiss one open request on abort; a settled one leaves the UI alone. A
-* throw inside an abort listener reaches no caller: Node rethrows it as an
-* uncaught exception, so a broken overlay is logged here instead.
-*/
-function dismissOnAbort(open, signal, dismiss) {
-	const onAbort = () => {
-		try {
-			dismiss();
-		} catch (error) {
-			logToFile("[agent-progress] dismissing an aborted request failed", error);
-		}
-	};
-	if (signal.aborted) onAbort();
-	else signal.addEventListener("abort", onAbort, { once: true });
-	return open.finally(() => signal.removeEventListener("abort", onAbort));
-}
-//#endregion
-//#region src/lib/programs/program-step.ts
-/**
-* Project program steps into the narrower Screen shape the router consumes.
-*
-* Two things happen here:
-*   1. Headless steps (no `screenId`) are filtered out. The router walks
-*      visible screens; gate-only steps like `detect` are store concerns.
-*   2. The step is narrowed to just { id, show, isComplete } — the
-*      router has no business touching gate, onInit, or label.
-*
-* This intentional separation keeps the router focused on one question:
-* "Which screen should be rendered right now?"
-*/
-/**
-* The gated steps the agent runner awaits after `auth` and before `run`, in
-* step order. Empty when a program has no auth step or runs before it.
-*/
-function postAuthGateSteps(steps) {
-	const authIndex = steps.findIndex((s) => s.screenId === "auth");
-	const runIndex = steps.findIndex((s) => s.screenId === "run");
-	if (authIndex === -1 || runIndex <= authIndex) return [];
-	return steps.slice(authIndex + 1, runIndex).filter((s) => s.gate);
-}
-function createProgramSequence(steps) {
-	const entries = steps.filter((step) => step.screenId != null).map((step) => ({
-		id: step.screenId,
-		show: step.show,
-		isComplete: step.isComplete ?? step.gate
-	}));
-	entries.push({
-		id: "exit",
-		show: void 0,
-		isComplete: void 0
-	});
-	return entries;
-}
-//#endregion
-//#region src/lib/programs/authenticate.ts
-async function authenticate(session, programId) {
-	if (session.credentials) return;
-	logToFile("[agent-runner] starting OAuth");
-	const { projectApiKey, host, accessToken, refreshToken, expiresAt, oauthClientId, projectId, roleAtOrganization, user, project, missingScopes } = await getOrAskForProjectData({
-		signup: session.signup,
-		ci: session.ci,
-		apiKey: session.apiKey,
-		projectId: session.projectId,
-		email: session.email,
-		region: session.region,
-		baseUrl: session.baseUrl,
-		localMcp: session.localMcp,
-		programId
-	});
-	session.credentials = {
-		accessToken,
-		refreshToken,
-		expiresAt,
-		oauthClientId,
-		projectApiKey,
-		host,
-		projectId,
-		missingScopes
-	};
-	session.apiProject = project;
-	session.roleAtOrganization = roleAtOrganization;
-	session.apiUser = user;
-	getUI().setCredentials(session.credentials);
-	getUI().setRoleAtOrganization(roleAtOrganization);
-	getUI().setApiUser(user);
-	if (user) analytics.identifyUser(user);
-	analytics.setGroups(groupsFromUser(user, host.apiHost));
-}
+import path, { join } from "path";
+import { randomUUID } from "crypto";
+//#region src/programs/credentials.ts
 /**
 * Grants the token endpoint refuses permanently. A dead grant means the login
 * is gone, not that the network blipped, so only these mark the session.
 */
 const DEAD_GRANT_CODES = new Set(["invalid_grant", "invalid_client"]);
-async function refreshAccessTokenIfNeeded(session) {
-	if (!session.credentials) return;
-	configureOAuthSession(session.credentials, {
-		rotate: (credentials) => rotateCredentials(credentials, session.baseUrl),
-		onRefreshed: (refreshed) => {
-			session.credentials = refreshed;
-			getUI().setAccessToken(refreshed);
-		}
-	});
-	await oauthCredentials();
-}
 async function rotateCredentials(credentials, baseUrl) {
 	if (!credentials.refreshToken) return credentials;
 	try {
@@ -206,492 +47,7 @@ async function rotateCredentials(credentials, baseUrl) {
 	}
 }
 //#endregion
-//#region src/lib/detection/framework.ts
-/**
-* Framework detection — identify which PostHog-supported framework
-* is present in the project directory.
-*
-* Pure function: takes an install dir, returns the detected integration
-* (or undefined). No store mutations, no UI calls.
-*/
-/**
-* Loop through all registered frameworks and return the first one
-* whose `detect()` predicate matches the given directory.
-* Returns undefined if no framework is detected or detection times out.
-*/
-async function detectFramework(installDir) {
-	for (const integration of Object.values(Integration)) {
-		const config = FRAMEWORK_REGISTRY[integration];
-		try {
-			if (await Promise.race([config.detection.detect({ installDir }), new Promise((resolve) => setTimeout(() => resolve(false), 1e4))])) return integration;
-		} catch {}
-	}
-}
-//#endregion
-//#region src/lib/detection/features.ts
-/**
-* Feature discovery — scan project dependencies for known SDK patterns
-* that indicate additional PostHog programs are relevant.
-*
-* Pure function: takes an install dir, returns a set of discovered features.
-* No store mutations, no UI calls.
-*/
-const STRIPE_PACKAGES = new Set(["stripe", "@stripe/stripe-js"]);
-const LLM_PACKAGES = new Set([
-	"openai",
-	"@anthropic-ai/sdk",
-	"ai",
-	"@ai-sdk/openai",
-	"langchain",
-	"@langchain/openai",
-	"@langchain/langgraph",
-	"@google/generative-ai",
-	"@google/genai",
-	"@instructor-ai/instructor",
-	"@mastra/core",
-	"portkey-ai"
-]);
-const PYTHON_LLM_PACKAGES = new Set([
-	"openai",
-	"anthropic",
-	"langchain",
-	"langchain-openai",
-	"langchain-anthropic",
-	"langchain-google-genai",
-	"langgraph",
-	"litellm",
-	"llama-index",
-	"pydantic-ai",
-	"crewai",
-	"instructor",
-	"dspy-ai",
-	"mistralai",
-	"cohere",
-	"google-generativeai",
-	"google-genai",
-	"portkey-ai"
-]);
-function discoverFeatures(installDir) {
-	const features = [];
-	discoverNodeFeatures(installDir, features);
-	discoverPythonFeatures(installDir, features);
-	return features;
-}
-function discoverNodeFeatures(installDir, features) {
-	const packageJsonText = safeRead(installDir, "package.json");
-	if (!packageJsonText) return;
-	let packageJson;
-	try {
-		packageJson = JSON.parse(packageJsonText);
-	} catch {
-		return;
-	}
-	const depNames = Object.keys({
-		...packageJson.dependencies,
-		...packageJson.devDependencies
-	});
-	if (depNames.some((depName) => STRIPE_PACKAGES.has(depName))) features.push("stripe");
-	if (depNames.some((depName) => LLM_PACKAGES.has(depName))) features.push("llm");
-}
-function discoverPythonFeatures(installDir, features) {
-	if (features.includes("llm")) return;
-	const depNames = [];
-	const requirementsTxt = safeRead(installDir, "requirements.txt");
-	if (requirementsTxt) depNames.push(...parseRequirementsTxt(requirementsTxt));
-	const pyprojectToml = safeRead(installDir, "pyproject.toml");
-	if (pyprojectToml) depNames.push(...parsePyprojectToml(pyprojectToml));
-	const pipfile = safeRead(installDir, "Pipfile");
-	if (pipfile) depNames.push(...parsePipfile(pipfile));
-	if (depNames.some((depName) => PYTHON_LLM_PACKAGES.has(depName))) features.push("llm");
-}
-function safeRead(installDir, file) {
-	return readProjectFile(join(installDir, file));
-}
-function normalizePyName(name) {
-	return name.toLowerCase().replace(/_/g, "-");
-}
-function parseRequirementsTxt(content) {
-	return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#") && !line.startsWith("-")).map((line) => line.replace(/\[[^\]]*\]/, "")).map((line) => line.split(/[<>=!~;\s]/)[0]).filter(Boolean).map(normalizePyName);
-}
-function parsePyprojectToml(content) {
-	const depNames = [];
-	for (const arrayMatch of content.matchAll(/dependencies\s*=\s*\[([^\]]*)\]/g)) {
-		const arrayBody = arrayMatch[1];
-		for (const quotedMatch of arrayBody.matchAll(/["']([^"']+)["']/g)) {
-			const name = quotedMatch[1].replace(/\[[^\]]*\]/, "").split(/[<>=!~;\s]/)[0];
-			if (name) depNames.push(normalizePyName(name));
-		}
-	}
-	for (const sectionMatch of content.matchAll(/\[tool\.poetry\.(?:dev-dependencies|dependencies|group\.[^.\]]+\.dependencies)\]([\s\S]*?)(?=\n\[|$)/g)) {
-		const sectionBody = sectionMatch[1];
-		depNames.push(...extractTomlSectionKeys(sectionBody, { skip: ["python"] }));
-	}
-	return depNames;
-}
-function parsePipfile(content) {
-	const depNames = [];
-	for (const sectionMatch of content.matchAll(/\[(packages|dev-packages)\]([\s\S]*?)(?=\n\[|$)/g)) {
-		const sectionBody = sectionMatch[2];
-		depNames.push(...extractTomlSectionKeys(sectionBody));
-	}
-	return depNames;
-}
-function extractTomlSectionKeys(sectionBody, opts = {}) {
-	const skipNames = new Set(opts.skip ?? []);
-	const depNames = [];
-	for (const line of sectionBody.split("\n")) {
-		const trimmed = line.trim();
-		if (!trimmed || trimmed.startsWith("#")) continue;
-		const equalsIndex = trimmed.indexOf("=");
-		if (equalsIndex <= 0) continue;
-		const name = trimmed.slice(0, equalsIndex).trim();
-		if (!/^[a-zA-Z0-9._-]+$/.test(name)) continue;
-		if (skipNames.has(name.toLowerCase())) continue;
-		depNames.push(normalizePyName(name));
-	}
-	return depNames;
-}
-//#endregion
-//#region src/lib/detection/context.ts
-/**
-* Framework context gathering — run gatherContext and version checks
-* for a detected framework.
-*
-* Pure functions: take a framework config and options, return results.
-* No store mutations, no UI calls.
-*/
-/**
-* Run a framework's `gatherContext()` to collect variant-specific
-* metadata (e.g., router type for Next.js, Expo vs bare for React Native).
-*
-* Returns the gathered context, or an empty object on failure/timeout.
-*/
-async function gatherFrameworkContext(config, options) {
-	if (!config.metadata.gatherContext) return {};
-	try {
-		return await Promise.race([config.metadata.gatherContext(options), new Promise((resolve) => setTimeout(() => resolve({}), DETECTION_TIMEOUT_MS))]);
-	} catch {
-		return {};
-	}
-}
-/**
-* Check whether the installed framework version meets the minimum requirement.
-*
-* Returns `{ supported: true }` if the version is fine (or no check is needed).
-* Returns the version details if unsupported.
-*/
-async function checkFrameworkVersion(config, options) {
-	if (!config.detection.minimumVersion || !config.detection.getInstalledVersion) return { supported: true };
-	const version = await config.detection.getInstalledVersion(options);
-	if (!version) return { supported: true };
-	const coerced = semver.coerce(version);
-	if (coerced && semver.lt(coerced, config.detection.minimumVersion)) return { supported: {
-		current: version,
-		minimum: config.detection.minimumVersion,
-		docsUrl: config.metadata.unsupportedVersionDocsUrl ?? config.metadata.docsUrl
-	} };
-	return { supported: true };
-}
-//#endregion
-//#region src/lib/detection/agentic.ts
-/**
-* Agentic project detection.
-*
-* A reusable detection tool that drives a Haiku agent over the repo: it finds
-* project roots, resolves monorepo/workspace markers, reads package manifests,
-* classifies each project against a caller-supplied set of targets, and reports
-* which projects already have a PostHog SDK installed.
-*
-* Product-knowledge-free by design — the caller passes the targets to classify
-* into (e.g. source-map skill variants) and maps the result back. Sits next to
-* the other detection tools (framework, features, package-manager) so it's
-* discoverable. Runs AFTER auth: it uses the same agent loop every program
-* uses, which needs credentials.
-*/
-var AgenticDetectionTimeoutError = class extends Error {
-	constructor(attempt, timeoutMs) {
-		super(`Project scan attempt ${attempt} timed out after ${timeoutMs / 1e3}s`);
-		this.name = "AgenticDetectionTimeoutError";
-	}
-};
-/**
-* Every project-manifest / workspace-marker filename the wizard's frameworks
-* are identified by. One brace-expansion Glob over all of these locates every
-* project root in the repo in a single call, regardless of language.
-*
-* Counterpart: POSTHOG_MANIFESTS in @lib/programs/self-driving/detect (SDK
-* grep); keep the two in sync.
-*/
-const PROJECT_MANIFESTS = [
-	"package.json",
-	"pnpm-workspace.yaml",
-	"turbo.json",
-	"nx.json",
-	"lerna.json",
-	"requirements.txt",
-	"pyproject.toml",
-	"setup.py",
-	"Pipfile",
-	"manage.py",
-	"Gemfile",
-	"composer.json",
-	"pom.xml",
-	"Cargo.toml",
-	"mix.exs",
-	"go.mod",
-	"*.csproj",
-	"Package.swift",
-	"Podfile",
-	"project.yml",
-	"project.pbxproj",
-	"pubspec.yaml",
-	"build.gradle",
-	"build.gradle.kts",
-	"settings.gradle",
-	"settings.gradle.kts",
-	"gradle/libs.versions.toml"
-];
-/** The single brace-expansion glob covering every supported manifest. */
-function manifestGlob() {
-	return `**/{${PROJECT_MANIFESTS.join(",")}}`;
-}
-function buildPrompt(cwd, targets, purpose, recommend) {
-	const targetList = targets.map((t) => `- ${t.id} → ${t.name}`).join("\n");
-	const projectShape = `{"path":string,"framework":string,"matchingTargets":string[],"targetId":string|null,"hasPostHog":boolean,"evidence":string${recommend ? ",\"recommended\":boolean" : ""}}`;
-	return [
-		`You are scanning a code repository to ${purpose}. Be fast and mechanical — do not over-explore. Keep any reasoning to one short sentence, then run the tool calls and output the JSON.`,
-		"",
-		`Working directory: ${cwd}`,
-		"",
-		"A \"project\" is a directory containing one or more of the manifest files below. Find projects by their manifests, NOT by walking directories — never report a directory that has no manifest.",
-		"",
-		"Do exactly this:",
-		`1. Run Glob ONCE with this pattern to find every project manifest in the repo in a single call: "${manifestGlob()}". Discard any result whose path contains node_modules/, dist/, build/, .next/, out/, coverage/, vendor/, .venv/, site-packages/, target/, Pods/, Carthage/, or DerivedData/. Group the remaining results by directory — each directory is one project. Three exceptions to "directory = project": a project.pbxproj lives inside a "<Name>.xcodeproj/" wrapper, so the project root is the PARENT of that .xcodeproj directory; a project.yml at a directory root is an XcodeGen-generated Xcode app rooted at that directory; a gradle/libs.versions.toml is a version catalog belonging to the gradle project rooted at the PARENT of that gradle/ directory (read it alongside the build.gradle when deciding hasPostHog), never its own project.`,
-		"2. Decide repoType: \"monorepo\" if the root package.json has a \"workspaces\" field OR a pnpm-workspace.yaml / turbo.json / nx.json / lerna.json was found at the root, else \"single\".",
-		`3. For EACH project directory, ONE AT A TIME: Read its manifest(s) ONCE, decide the fields below, then IMMEDIATELY — before reading any other project — write that project's verdict as one JSON line of shape ${projectShape}. Never write a verdict from memory of an earlier Read; the manifest you just read is the only source. Decide from its dependency lists:`,
-		"   - the human-readable framework name (e.g. \"Next.js\", \"Django\", \"Rails\"),",
-		"   - matchingTargets: EVERY target id from the list below whose technology appears in THIS manifest, in the priority order of the list. An id belongs here only if you can point at the dependency or setting in the manifest you just read — never carry one over from another project,",
-		"   - targetId: the FIRST entry of matchingTargets (the list is ordered by priority, most specific first). null when matchingTargets is empty,",
-		`   - hasPostHog: true if any dependency is a PostHog SDK. This includes: a name containing "posthog" in any ecosystem (e.g. posthog-js, posthog-node, @posthog/*, posthog for pip/gem/hex, a com.posthog:* gradle/maven coordinate, a PostHog NuGet PackageReference); an SPM package named "PostHog" or a repositoryURL of github.com/PostHog/posthog-ios (in Package.swift or a .pbxproj); or a "pod 'PostHog'" line in a Podfile. Else false.`,
-		"   - evidence: the manifest fact that decided targetId, with the file it came from (e.g. \"rollup in devDependencies of backend/package.json\"). When targetId is null, name the closest fact you saw. One short clause, quoted from the manifest you just read.",
-		"   Do NOT read any file other than these manifests.",
-		...recommend ? ["4. Pick exactly ONE project as recommended — the main user-facing client application. Prefer a frontend web app or a mobile app over backend servers/APIs, libraries, CLIs, tooling, and example/demo/docs apps. If several client apps exist, pick the primary production app; if no client app exists, pick the primary application project."] : [],
-		"",
-		"Target ids (id → name), in priority order — most specific first; if several match a project, keep the one listed earliest:",
-		targetList,
-		"",
-		"Output requirements:",
-		"- After the last verdict line, respond with ONLY a single JSON object assembling the verdict lines you wrote, copied VERBATIM — same path, framework, targetId and evidence per project. No prose, no markdown code fences.",
-		`- Shape: {"repoType":"monorepo"|"single","projects":[${projectShape}]}`,
-		"- \"path\" is the project directory relative to the working directory; use \".\" for the repo root.",
-		"- \"targetId\" MUST be exactly one of the target ids above when it matches; if several match, use the one listed earliest; otherwise null.",
-		"- Include projects whose stack matches no target too (targetId: null).",
-		...recommend ? ["- Exactly one project has \"recommended\": true; every other project has \"recommended\": false."] : [],
-		`- If there are no manifests at all, respond with exactly: ${AgentSignals.ABORT} detection failed`
-	].join("\n");
-}
-/**
-* Build the detection report from the agent's output, or null when it holds
-* no verdicts. Exported for testing.
-*
-* The verdict lines are far more reliable than the model's final assembly
-* (prose, pretty-printing, per-object fences), so every parseable line
-* contributes: objects with a `path` merge by path (last wins), and a
-* one-line assembly's `projects` merge the same way. `repoType` is
-* approximated from the count — it only feeds telemetry and display.
-*/
-function deriveReportJson(text) {
-	const byPath = /* @__PURE__ */ new Map();
-	for (const line of text.split("\n")) {
-		const start = line.indexOf("{");
-		const end = line.lastIndexOf("}");
-		if (start === -1 || end <= start) continue;
-		let parsed;
-		try {
-			parsed = JSON.parse(line.slice(start, end + 1));
-		} catch {
-			continue;
-		}
-		const obj = parsed ?? {};
-		const candidates = Array.isArray(obj.projects) ? obj.projects : [obj];
-		for (const candidate of candidates) {
-			const p = candidate ?? {};
-			if (typeof p.path === "string") byPath.set(p.path, p);
-		}
-	}
-	if (byPath.size === 0) return null;
-	const projects = [...byPath.values()];
-	return {
-		repoType: projects.length > 1 ? "monorepo" : "single",
-		projects
-	};
-}
-/**
-* Clamp an agent-reported project path to a safe repo-relative dir. The path
-* is LLM output: absolute paths or `..` segments could steer later phases
-* (e.g. integrate-run's targetDir) outside the repo, so they clamp to '.'.
-*/
-function coercePath(raw) {
-	if (typeof raw !== "string" || raw.length === 0) return ".";
-	if (isAbsolute(raw) || raw.split(/[\\/]/).includes("..")) return ".";
-	return raw;
-}
-/** Resolve an agent-reported path to an absolute dir clamped to the root — the caller-side counterpart of coercePath. */
-function resolveProjectDir(installDir, rel) {
-	if (typeof rel !== "string" || rel === ".") return installDir;
-	const root = resolve(installDir);
-	const dir = resolve(root, rel);
-	return dir === root || dir.startsWith(root + sep) ? dir : root;
-}
-/**
-* Validate the agent's raw JSON into a report, clamping each targetId to the
-* supplied set and each path to a repo-relative dir. Exported for testing.
-* `recommended` is stripped unless requested; at most one (the first) survives.
-*/
-function coerceAgenticReport(parsed, validTargetIds, options) {
-	const recommend = options?.recommend === true;
-	const rerankIds = options?.rerankIds ?? [];
-	const obj = parsed ?? {};
-	const repoType = obj.repoType === "monorepo" ? "monorepo" : "single";
-	const rawProjects = Array.isArray(obj.projects) ? obj.projects : [];
-	let recommendedSeen = false;
-	return {
-		repoType,
-		projects: rawProjects.map((raw) => {
-			const p = raw ?? {};
-			const pick = typeof p.targetId === "string" && validTargetIds.includes(p.targetId) ? p.targetId : null;
-			const enumerated = Array.isArray(p.matchingTargets) ? validTargetIds.find((id) => p.matchingTargets.includes(id)) ?? null : null;
-			const targetId = pick === null ? enumerated : enumerated !== null && rerankIds.includes(enumerated) && rerankIds.includes(pick) ? enumerated : pick;
-			const recommended = recommend && !recommendedSeen && p.recommended === true;
-			recommendedSeen ||= recommended;
-			return {
-				path: coercePath(p.path),
-				framework: typeof p.framework === "string" ? p.framework : "Unknown",
-				targetId,
-				hasPostHog: p.hasPostHog === true,
-				...recommend ? { recommended } : {}
-			};
-		})
-	};
-}
-function formatToolUse(block) {
-	const name = typeof block?.name === "string" ? block.name : "tool";
-	const input = block?.input ?? {};
-	const detail = input.file_path || input.pattern || input.path || "";
-	return detail ? `${name} ${detail}` : name;
-}
-function sessionToWizardOptions(session) {
-	return {
-		installDir: session.installDir,
-		ci: session.ci,
-		debug: session.debug,
-		benchmark: session.benchmark,
-		yaraReport: session.yaraReport,
-		signup: session.signup,
-		apiKey: session.apiKey,
-		projectId: session.projectId
-	};
-}
-const NOOP_SPINNER = {
-	start: () => void 0,
-	stop: () => void 0,
-	message: () => void 0
-};
-/**
-* Drive the wizard's agent loop on HAIKU_MODEL to scan the repo and return a
-* structured detection report. Reuses the same setup every program uses, so
-* MCP, tools, and credentials are wired identically.
-*/
-async function detectProjectsWithAgent(session, options) {
-	if (!session.credentials) throw new Error("Detection requires authenticated credentials.");
-	const { targets, programId, purpose = "set up a PostHog integration", recommend = false, rerankIds, onEvent } = options;
-	const { accessToken, host } = session.credentials;
-	const cwd = session.installDir;
-	const runOptions = sessionToWizardOptions(session);
-	const wizardMetadata = {
-		...buildRunTags({
-			programId,
-			integration: "agentic-detect",
-			runId: analytics.runId,
-			build: analytics.build
-		}),
-		call_type: "detection"
-	};
-	const prompt = buildPrompt(cwd, targets, purpose, recommend);
-	for (let attempt = 0; attempt < 2; attempt++) {
-		const timeoutMs = attempt === 0 ? AGENTIC_DETECTION_FIRST_ATTEMPT_TIMEOUT_MS : AGENTIC_DETECTION_RETRY_TIMEOUT_MS;
-		const agent = await initializeAgent({
-			emit: createUiReducer(getUI()),
-			workingDirectory: cwd,
-			posthogMcpUrl: host.mcpUrl,
-			posthogApiKey: accessToken,
-			host,
-			detectPackageManager: detectNodePackageManagers,
-			skillsBaseUrl: getSkillsBaseUrl(),
-			programId,
-			integrationLabel: "agentic-detect",
-			wizardMetadata,
-			allowedTools: [
-				"Read",
-				"Grep",
-				"Glob"
-			],
-			modelOverride: HAIKU_MODEL
-		}, runOptions);
-		const MAX_TRANSCRIPT_CHARS = 256 * 1024;
-		const collected = [];
-		let collectedChars = 0;
-		const collect = (text) => {
-			collected.push(text);
-			collectedChars += text.length;
-			while (collectedChars > MAX_TRANSCRIPT_CHARS && collected.length > 1) collectedChars -= collected.shift().length;
-		};
-		let resultText = "";
-		const result = await runAgent(agent, prompt, runOptions, NOOP_SPINNER, {
-			spinnerMessage: "Scanning the repo...",
-			successMessage: "Detection complete",
-			errorMessage: "Detection failed",
-			requestRemark: false,
-			timeoutMs
-		}, {
-			onMessage: (message) => {
-				if (message?.type === "assistant") {
-					for (const block of message.message?.content ?? []) if (block?.type === "text" && typeof block.text === "string") {
-						collect(block.text);
-						const line = block.text.trim();
-						if (line && onEvent) onEvent(line.length > 100 ? `${line.slice(0, 100)}…` : line);
-					} else if (block?.type === "tool_use") onEvent?.(formatToolUse(block));
-				} else if (message?.type === "result" && typeof message.result === "string") resultText = message.result;
-			},
-			finalize: (_resultMessage, _durationMs) => void 0
-		});
-		if (result.kind === "failure" && result.classification === "WIZARD_AGENTIC_DETECTION_TIMEOUT") {
-			if (attempt === 0) {
-				onEvent?.("Project scan timed out; retrying...");
-				continue;
-			}
-			throw new AgenticDetectionTimeoutError(attempt + 1, timeoutMs);
-		}
-		if (result.kind !== "success") {
-			if (result.kind === "decided_failure") throw result.failure.error ?? new Error(result.failure.message);
-			throw result.error ?? new Error(result.message || `Agent error: ${result.classification}`);
-		}
-		const output = `${collected.join("\n")}\n${resultText}`;
-		const derived = deriveReportJson(output);
-		if (derived !== null) return coerceAgenticReport(derived, targets.map((t) => t.id), {
-			recommend,
-			rerankIds
-		});
-		if (output.includes(AgentSignals.ABORT)) return {
-			repoType: "single",
-			projects: []
-		};
-		if (attempt === 0) onEvent?.("Retrying project scan...");
-	}
-	throw new Error("Agent did not return a JSON object after retry");
-}
-//#endregion
-//#region src/lib/warehouse-sources/registry.ts
+//#region src/programs/warehouse-sources/registry.ts
 const CORE_SOURCE_DETECTORS = [
 	{
 		kind: "Postgres",
@@ -3056,16 +2412,689 @@ const OTHER_SOURCE_DETECTORS = [
 			envKeys: [/^DUB_API_KEY$/]
 		}
 	}
-];
-const SOURCE_DETECTORS = [
-	...CORE_SOURCE_DETECTORS,
-	...LLM_SOURCE_DETECTORS,
-	...OTHER_SOURCE_DETECTORS
-];
-/** Kinds from the LLM / AI section above — the only ones that may set `wizard_ai_sdk_detected`. */
-const AI_SOURCE_KINDS = new Set(LLM_SOURCE_DETECTORS.map((detector) => detector.kind));
+];
+const SOURCE_DETECTORS = [
+	...CORE_SOURCE_DETECTORS,
+	...LLM_SOURCE_DETECTORS,
+	...OTHER_SOURCE_DETECTORS
+];
+/** Kinds from the LLM / AI section above — the only ones that may set `wizard_ai_sdk_detected`. */
+const AI_SOURCE_KINDS = new Set(LLM_SOURCE_DETECTORS.map((detector) => detector.kind));
+//#endregion
+//#region src/programs/posthog-integration/ai-sdk-stamp.ts
+function hasAiSdkEvidence(evidence) {
+	return evidence.warehouseSources.some((s) => AI_SOURCE_KINDS.has(s.kind)) || evidence.discoveredFeatures.includes("llm");
+}
+/**
+* Boolean only, on the org, never the list of kinds or any non-AI tool: a
+* decline must not leak even the shape of what local detection saw.
+*/
+function stampAiSdkDetected(evidence) {
+	if (!evidence.mayReportScanResults) return;
+	const organizationId = evidence.apiUser?.organization?.id;
+	if (!organizationId) return;
+	if (!hasAiSdkEvidence(evidence)) return;
+	analytics.groupIdentify("organization", organizationId, { wizard_ai_sdk_detected: true });
+}
+//#endregion
+//#region src/programs/program-store.ts
+const MAX_DIAGNOSTICS = 10;
+var ProgramStore = class {
+	runs = [];
+	diagnostics = [];
+	data;
+	onData;
+	constructor(options = {}) {
+		this.onData = options.onData;
+		this.data = {
+			credentials: null,
+			apiProject: null,
+			apiUser: null,
+			detection: { frameworkContext: {} },
+			binding: null,
+			aiSdkStampReported: options.aiSdkStampReported ?? false
+		};
+	}
+	readData() {
+		return structuredClone(this.data);
+	}
+	setAuthenticated(auth) {
+		Object.assign(this.data, structuredClone(auth));
+		this.emitData();
+	}
+	setFrameworkContext(key, value) {
+		this.data.detection.frameworkContext[key] = structuredClone(value);
+		this.emitData();
+	}
+	setBinding(binding) {
+		this.data.binding = structuredClone(binding);
+		this.emitData();
+	}
+	setAiSdkStampReported() {
+		if (this.data.aiSdkStampReported) return;
+		this.data.aiSdkStampReported = true;
+		this.emitData();
+	}
+	beginRun(runId, observer) {
+		const run = { runId };
+		this.runs.push(run);
+		return {
+			onProgress: (event) => {
+				const source = {
+					runId: run.runId,
+					eventKind: event.kind
+				};
+				if (run.result) {
+					this.recordDiagnostic(source, "progress after finish");
+					return;
+				}
+				if (!observer) return;
+				this.deliver(source, () => observer({
+					kind: "run",
+					runId,
+					event: structuredClone(event)
+				}));
+			},
+			finish: (result) => {
+				run.result = result;
+			}
+		};
+	}
+	settledRuns() {
+		return this.runs.flatMap(({ runId, result }) => result ? [{
+			runId,
+			result
+		}] : []);
+	}
+	readDiagnostics() {
+		return this.diagnostics.map((diagnostic) => ({ ...diagnostic }));
+	}
+	emitData() {
+		const onData = this.onData;
+		if (!onData) return;
+		this.deliver({ eventKind: "data" }, () => onData({
+			kind: "program",
+			data: this.readData()
+		}));
+	}
+	/** Never waits for an observer; a throw or a rejection becomes a diagnostic. */
+	deliver(source, send) {
+		try {
+			const delivery = send();
+			if (delivery && typeof delivery.then === "function") Promise.resolve(delivery).catch((error) => {
+				this.recordDiagnostic(source, error);
+			});
+		} catch (error) {
+			this.recordDiagnostic(source, error);
+		}
+	}
+	recordDiagnostic(source, error) {
+		this.diagnostics.push({
+			...source,
+			message: error instanceof Error ? error.message : String(error)
+		});
+		if (this.diagnostics.length > MAX_DIAGNOSTICS) this.diagnostics.shift();
+	}
+};
+//#endregion
+//#region src/programs/run-program.ts
+/** A caller-owned program invocation. No TUI store or session is required. */
+/** Handed to the caller's capabilities when it supplied no signal. */
+const NEVER_ABORTED = new AbortController().signal;
+const DEFAULT_FLAGS = {
+	ci: false,
+	signup: false,
+	debug: false,
+	e2eAsk: false,
+	localMcp: false,
+	captureAio: false,
+	benchmark: false,
+	yaraReport: false
+};
+/** Fields that carry functions or class instances; everything else is data. */
+const KEPT_BY_REFERENCE = [
+	"credentials",
+	"run",
+	"program",
+	"hooks",
+	"seedTasks"
+];
+/** Copy the caller's input, so a later caller write cannot reach the run or its hooks. */
+function snapshotProgramInput(input) {
+	const data = { ...input };
+	for (const key of KEPT_BY_REFERENCE) delete data[key];
+	return {
+		...input,
+		...structuredClone(data)
+	};
+}
+/** Run an existing program from explicit inputs, with invocation-owned state. */
+async function runProgram(programId, callerInput, options = {}) {
+	const input = snapshotProgramInput(callerInput);
+	const store = new ProgramStore({
+		aiSdkStampReported: input.aiSdkStampReported,
+		onData: options.onProgress
+	});
+	const { installDir, run } = input;
+	const program = input.program ?? {};
+	const artifacts = {};
+	const runId = input.runId ?? randomUUID();
+	const signal = options.signal ?? NEVER_ABORTED;
+	const settle = (outcome, failure) => ({
+		programId,
+		outcome,
+		data: store.readData(),
+		settledRuns: store.settledRuns(),
+		diagnostics: store.readDiagnostics(),
+		artifacts,
+		...failure && { failure }
+	});
+	const fail = (message) => settle("failed", {
+		code: ErrorCodes.InternalUnhandled,
+		message
+	});
+	const abort = (message) => settle("aborted", {
+		code: ErrorCodes.AgentAbort,
+		message
+	});
+	const cancelled = () => abort("Run cancelled by the caller.");
+	if (signal.aborted) return cancelled();
+	analytics.wizardCapture("agent started", {
+		integration: run.integrationLabel,
+		program_id: programId,
+		skill_id: run.skillId ?? null
+	});
+	/** Await a caller capability; a caller abort during the wait wins over its answer. */
+	const park = async (work) => {
+		const value = await work;
+		signal.throwIfAborted();
+		return value;
+	};
+	let credentials = input.credentials;
+	const flags = {
+		...DEFAULT_FLAGS,
+		...input.flags
+	};
+	let flagSnapshot = {
+		flags: { ...input.wizardFlags },
+		payloads: { ...input.wizardFlagPayloads }
+	};
+	try {
+		if (!credentials && options.credentials) credentials = await park(options.credentials.resolve(programId, { signal }));
+		if (!credentials) return fail(`Credentials are required to run ${programId}.`);
+		store.setAuthenticated({
+			credentials: credentials.posthog,
+			apiProject: credentials.project,
+			apiUser: credentials.apiUser
+		});
+		if (credentials.apiUser) analytics.identifyUser(credentials.apiUser);
+		analytics.setGroups(groupsFromUser(credentials.apiUser, credentials.posthog.host.apiHost));
+		if (!store.readData().aiSdkStampReported) {
+			store.setAiSdkStampReported();
+			stampAiSdkDetected({
+				apiUser: credentials.apiUser,
+				discoveredFeatures: input.discoveredFeatures ?? [],
+				warehouseSources: input.warehouseSources ?? [],
+				mayReportScanResults: input.mayReportScanResults ?? false
+			});
+		}
+		if (program.requiresAi !== false && !flags.ci && !flags.signup && credentials.apiUser?.organization?.is_ai_data_processing_approved !== true) {
+			if (!options.awaitAiApproval) return fail("AI processing approval is required before this program can run.");
+			if (!await park(options.awaitAiApproval({
+				programId,
+				signal
+			}))) return abort("AI processing approval declined.");
+		}
+		const gates = program.postAuthGates ?? [];
+		if (gates.length > 0 && options.awaitPostAuthGates) await park(options.awaitPostAuthGates({
+			programId,
+			gates,
+			signal
+		}));
+		if (!input.wizardFlags && options.featureFlags) flagSnapshot = await park(options.featureFlags());
+		const login = credentials;
+		configureOAuthSession(login.posthog, {
+			rotate: (held) => rotateCredentials(held, input.host?.baseUrl),
+			onRefreshed: (refreshed) => store.setAuthenticated({
+				credentials: refreshed,
+				apiProject: login.project,
+				apiUser: login.apiUser
+			})
+		});
+		const posthog = await oauthCredentials() ?? login.posthog;
+		credentials = {
+			...login,
+			posthog
+		};
+		signal.throwIfAborted();
+	} catch (error) {
+		if (signal.aborted) return cancelled();
+		return fail(error instanceof Error ? error.message : String(error));
+	}
+	const wizardFlags = { ...flagSnapshot.flags };
+	const wizardFlagPayloads = { ...flagSnapshot.payloads };
+	const switchboard = {
+		program: programId,
+		composed: input.composed ?? false,
+		flags: wizardFlags,
+		flagPayloads: wizardFlagPayloads,
+		cliHarness: input.overrides?.harness,
+		cliSequence: input.overrides?.sequence,
+		cliModel: input.overrides?.model
+	};
+	const binding = resolveBinding(switchboard);
+	analytics.setTag("sequence", binding.sequence);
+	analytics.setTag("harness", binding.harness);
+	captureSwitchboardDecision(switchboard, binding);
+	store.setBinding(binding);
+	const wizardMetadata = {
+		...buildRunTags({
+			programId,
+			integration: run.integrationLabel,
+			runId: analytics.runId,
+			build: analytics.build,
+			skillId: run.skillId
+		}),
+		SEQUENCE: binding.sequence,
+		HARNESS: binding.harness
+	};
+	artifacts.reportFile = path.resolve(installDir, run.reportFile);
+	const adapter = store.beginRun(runId, options.onProgress);
+	const result = await runAgent({
+		programId,
+		run,
+		composed: input.composed ?? false,
+		binding,
+		switchboard,
+		skillsBaseUrl: getSkillsBaseUrl(),
+		wizardFlags,
+		wizardFlagPayloads,
+		wizardMetadata,
+		allowedTools: program.allowedTools,
+		disallowedTools: program.disallowedTools,
+		agentFlow: program.agentFlow,
+		excludedTaskTypes: program.excludedTaskTypes,
+		seedTasks: input.seedTasks,
+		hooks: input.hooks
+	}, {
+		installDir,
+		credentials: credentials.posthog,
+		project: credentials.project,
+		apiUser: credentials.apiUser,
+		skillId: input.skillId ?? run.skillId ?? run.integrationLabel,
+		integration: input.integration,
+		frameworkDocsUrl: input.frameworkDocsUrl,
+		flags,
+		host: { ...input.host }
+	}, {
+		interaction: options.interaction,
+		onProgress: (event) => adapter.onProgress(event),
+		signal: options.signal
+	});
+	adapter.finish(result);
+	return settle(result.outcome, result.outcome === "success" ? void 0 : result.failure);
+}
+/**
+* One event + one log line per run: what entered the switchboard, which
+* precedence rung decided each axis, and the final pick.
+*/
+function captureSwitchboardDecision(ctx, binding) {
+	const trace = ctx.trace ?? {};
+	const perTaskModel = binding.sequence === "orchestrator" && trace.model === "binding";
+	const model = perTaskModel ? "chosen-per-task" : binding.model;
+	const modelSource = perTaskModel ? "agent-prompts" : trace.model;
+	analytics.wizardCapture("switchboard resolved", {
+		program: ctx.program,
+		flag_self_driving_use_pi_harness: ctx.flags[WIZARD_SELF_DRIVING_USE_PI_HARNESS_FLAG_KEY],
+		flag_self_driving_pi_payload: JSON.stringify(ctx.flagPayloads?.["wizard-self-driving-use-pi-harness"] ?? null),
+		flag_orchestrator: ctx.flags[WIZARD_ORCHESTRATOR_FLAG_KEY],
+		cli_harness: ctx.cliHarness,
+		cli_sequence: ctx.cliSequence,
+		cli_model: ctx.cliModel,
+		harness_source: trace.harness,
+		model_source: modelSource,
+		sequence_source: trace.sequence,
+		harness: binding.harness,
+		model,
+		thinking_level: binding.thinkingLevel,
+		sequence: binding.sequence
+	});
+	logToFile(`[switchboard] decision: program=${ctx.program} in(orchestrator=${ctx.flags["wizard-orchestrator"] ?? "-"}, cli=${ctx.cliHarness ?? "-"}/${ctx.cliSequence ?? "-"}/${ctx.cliModel ?? "-"}) → harness=${binding.harness} (${trace.harness ?? "?"}) model=${model} (${modelSource ?? "?"}) sequence=${binding.sequence} (${trace.sequence ?? "?"})`);
+}
+//#endregion
+//#region src/ui/agent-progress.ts
+/**
+* The inverse of the agent's former `getUI()` calls: one event, one
+* `WizardUI` method, synchronous, in emission order. Because each case maps
+* back to exactly the call the agent used to make, the frame and flow goldens
+* hold without regeneration.
+*/
+function createUiReducer(ui) {
+	let spinner;
+	return (event) => {
+		switch (event.kind) {
+			case "lifecycle":
+				if (event.phase === "started") ui.startRun();
+				else ui.outro(event.message);
+				break;
+			case "spinner":
+				(spinner ??= ui.spinner())[event.action](event.message);
+				break;
+			case "log":
+				ui.log[event.level](event.message);
+				break;
+			case "status":
+				ui.pushStatus(event.message);
+				break;
+			case "tasks":
+				ui.syncTodos(event.tasks);
+				break;
+			case "stage":
+				ui.setStage(event.stage);
+				break;
+			case "url":
+				if (event.which === "dashboard") ui.setDashboardUrl(event.url);
+				else ui.setNotebookUrl(event.url);
+				break;
+			case "usage":
+				ui.addTokenUsage(event.delta);
+				break;
+			case "finalCost":
+				ui.setFinalTokenCostUsd(event.usd);
+				break;
+			case "authError":
+				ui.showAuthError(event.detail);
+				break;
+			case "handoff":
+				ui.setHandoffText(event.text);
+				break;
+			case "completion":
+				ui.setOutroData(event.outro);
+				break;
+			case "activity": break;
+			default: throw new Error(`Unhandled agent progress: ${JSON.stringify(event)}`);
+		}
+	};
+}
+/** The agent's questions, answered wherever `getUI()` answers them today. */
+function uiInteraction(ui) {
+	return {
+		ask: (question, { signal }) => dismissOnAbort(ui.requestQuestion(question), signal, () => ui.cancelPendingQuestion()),
+		taskNotice: (notice, { signal }) => dismissOnAbort(ui.showTaskNotice(notice), signal, () => ui.cancelTaskNotice())
+	};
+}
+/**
+* Dismiss one open request on abort; a settled one leaves the UI alone. A
+* throw inside an abort listener reaches no caller: Node rethrows it as an
+* uncaught exception, so a broken overlay is logged here instead.
+*/
+function dismissOnAbort(open, signal, dismiss) {
+	const onAbort = () => {
+		try {
+			dismiss();
+		} catch (error) {
+			logToFile("[agent-progress] dismissing an aborted request failed", error);
+		}
+	};
+	if (signal.aborted) onAbort();
+	else signal.addEventListener("abort", onAbort, { once: true });
+	return open.finally(() => signal.removeEventListener("abort", onAbort));
+}
+//#endregion
+//#region src/programs/program-step.ts
+/**
+* Project program steps into the narrower Screen shape the router consumes.
+*
+* Two things happen here:
+*   1. Headless steps (no `screenId`) are filtered out. The router walks
+*      visible screens; gate-only steps like `detect` are store concerns.
+*   2. The step is narrowed to just { id, show, isComplete } — the
+*      router has no business touching gate, onInit, or label.
+*
+* This intentional separation keeps the router focused on one question:
+* "Which screen should be rendered right now?"
+*/
+/**
+* The gated steps the agent runner awaits after `auth` and before `run`, in
+* step order. Empty when a program has no auth step or runs before it.
+*/
+function postAuthGateSteps(steps) {
+	const authIndex = steps.findIndex((s) => s.screenId === "auth");
+	const runIndex = steps.findIndex((s) => s.screenId === "run");
+	if (authIndex === -1 || runIndex <= authIndex) return [];
+	return steps.slice(authIndex + 1, runIndex).filter((s) => s.gate);
+}
+function createProgramSequence(steps) {
+	const entries = steps.filter((step) => step.screenId != null).map((step) => ({
+		id: step.screenId,
+		show: step.show,
+		isComplete: step.isComplete ?? step.gate
+	}));
+	entries.push({
+		id: "exit",
+		show: void 0,
+		isComplete: void 0
+	});
+	return entries;
+}
+//#endregion
+//#region src/programs/authenticate.ts
+async function authenticate(session, programId) {
+	if (session.credentials) return;
+	logToFile("[agent-runner] starting OAuth");
+	const { projectApiKey, host, accessToken, refreshToken, expiresAt, oauthClientId, projectId, roleAtOrganization, user, project, missingScopes } = await getOrAskForProjectData({
+		signup: session.signup,
+		ci: session.ci,
+		apiKey: session.apiKey,
+		projectId: session.projectId,
+		email: session.email,
+		region: session.region,
+		baseUrl: session.baseUrl,
+		localMcp: session.localMcp,
+		programId
+	});
+	session.credentials = {
+		accessToken,
+		refreshToken,
+		expiresAt,
+		oauthClientId,
+		projectApiKey,
+		host,
+		projectId,
+		missingScopes
+	};
+	session.apiProject = project;
+	session.roleAtOrganization = roleAtOrganization;
+	session.apiUser = user;
+	getUI().setCredentials(session.credentials);
+	getUI().setRoleAtOrganization(roleAtOrganization);
+	getUI().setApiUser(user);
+	if (user) analytics.identifyUser(user);
+	analytics.setGroups(groupsFromUser(user, host.apiHost));
+}
+//#endregion
+//#region src/programs/audit/types.ts
+/** Single source of truth for status glyph + color across audit views. */
+const AUDIT_SEVERITY_STYLE = {
+	pending: {
+		glyph: "◌",
+		color: "gray"
+	},
+	pass: {
+		glyph: "✔",
+		color: "green"
+	},
+	error: {
+		glyph: "✘",
+		color: "red"
+	},
+	warning: {
+		glyph: "⚠",
+		color: "yellow"
+	},
+	suggestion: {
+		glyph: "•",
+		color: "cyan"
+	}
+};
+const AUDIT_CHECKS_KEY = "auditChecks";
+function getAuditChecks(session) {
+	const raw = session.frameworkContext[AUDIT_CHECKS_KEY];
+	return Array.isArray(raw) ? raw : [];
+}
+//#endregion
+//#region src/programs/audit/ledger-watcher.ts
+/**
+* Mirrors the agent's `.posthog-audit-checks.json` into the session, so the TUI
+* screens and the task stream read one value. `runProgramAgent` owns the
+* lifecycle and removes the file at run end, so every path gets it — including
+* the e2e host, which builds no task stream.
+*/
+const MAX_LEDGER_FILE_BYTES = 256 * 1024;
+function startAuditLedgerWatcher(installDir, file, options = {}) {
+	const target = path.join(installDir, file);
+	logToFile(`[audit-ledger] watching ${target}`);
+	return startFileWatcher(target, (parsed) => getUI().setFrameworkContext(AUDIT_CHECKS_KEY, coerceAuditChecks(parsed)), {
+		ignoreInitialFile: true,
+		maxFileSizeBytes: MAX_LEDGER_FILE_BYTES,
+		...options
+	});
+}
+/** The program declared the ledger, so it removes it, agent `rm` step or not. */
+function removeAuditLedger(installDir, file) {
+	const target = path.join(installDir, file);
+	try {
+		fs.rmSync(target, { force: true });
+	} catch (error) {
+		logToFile(`[audit-ledger] could not remove ${target}: ${String(error)}`);
+	}
+}
+//#endregion
+//#region src/programs/detection/features.ts
+/**
+* Feature discovery — scan project dependencies for known SDK patterns
+* that indicate additional PostHog programs are relevant.
+*
+* Pure function: takes an install dir, returns a set of discovered features.
+* No store mutations, no UI calls.
+*/
+const STRIPE_PACKAGES = new Set(["stripe", "@stripe/stripe-js"]);
+const LLM_PACKAGES = new Set([
+	"openai",
+	"@anthropic-ai/sdk",
+	"ai",
+	"@ai-sdk/openai",
+	"langchain",
+	"@langchain/openai",
+	"@langchain/langgraph",
+	"@google/generative-ai",
+	"@google/genai",
+	"@instructor-ai/instructor",
+	"@mastra/core",
+	"portkey-ai"
+]);
+const PYTHON_LLM_PACKAGES = new Set([
+	"openai",
+	"anthropic",
+	"langchain",
+	"langchain-openai",
+	"langchain-anthropic",
+	"langchain-google-genai",
+	"langgraph",
+	"litellm",
+	"llama-index",
+	"pydantic-ai",
+	"crewai",
+	"instructor",
+	"dspy-ai",
+	"mistralai",
+	"cohere",
+	"google-generativeai",
+	"google-genai",
+	"portkey-ai"
+]);
+function discoverFeatures(installDir) {
+	const features = [];
+	discoverNodeFeatures(installDir, features);
+	discoverPythonFeatures(installDir, features);
+	return features;
+}
+function discoverNodeFeatures(installDir, features) {
+	const packageJsonText = safeRead(installDir, "package.json");
+	if (!packageJsonText) return;
+	let packageJson;
+	try {
+		packageJson = JSON.parse(packageJsonText);
+	} catch {
+		return;
+	}
+	const depNames = Object.keys({
+		...packageJson.dependencies,
+		...packageJson.devDependencies
+	});
+	if (depNames.some((depName) => STRIPE_PACKAGES.has(depName))) features.push("stripe");
+	if (depNames.some((depName) => LLM_PACKAGES.has(depName))) features.push("llm");
+}
+function discoverPythonFeatures(installDir, features) {
+	if (features.includes("llm")) return;
+	const depNames = [];
+	const requirementsTxt = safeRead(installDir, "requirements.txt");
+	if (requirementsTxt) depNames.push(...parseRequirementsTxt(requirementsTxt));
+	const pyprojectToml = safeRead(installDir, "pyproject.toml");
+	if (pyprojectToml) depNames.push(...parsePyprojectToml(pyprojectToml));
+	const pipfile = safeRead(installDir, "Pipfile");
+	if (pipfile) depNames.push(...parsePipfile(pipfile));
+	if (depNames.some((depName) => PYTHON_LLM_PACKAGES.has(depName))) features.push("llm");
+}
+function safeRead(installDir, file) {
+	return readProjectFile(join(installDir, file));
+}
+function normalizePyName(name) {
+	return name.toLowerCase().replace(/_/g, "-");
+}
+function parseRequirementsTxt(content) {
+	return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#") && !line.startsWith("-")).map((line) => line.replace(/\[[^\]]*\]/, "")).map((line) => line.split(/[<>=!~;\s]/)[0]).filter(Boolean).map(normalizePyName);
+}
+function parsePyprojectToml(content) {
+	const depNames = [];
+	for (const arrayMatch of content.matchAll(/dependencies\s*=\s*\[([^\]]*)\]/g)) {
+		const arrayBody = arrayMatch[1];
+		for (const quotedMatch of arrayBody.matchAll(/["']([^"']+)["']/g)) {
+			const name = quotedMatch[1].replace(/\[[^\]]*\]/, "").split(/[<>=!~;\s]/)[0];
+			if (name) depNames.push(normalizePyName(name));
+		}
+	}
+	for (const sectionMatch of content.matchAll(/\[tool\.poetry\.(?:dev-dependencies|dependencies|group\.[^.\]]+\.dependencies)\]([\s\S]*?)(?=\n\[|$)/g)) {
+		const sectionBody = sectionMatch[1];
+		depNames.push(...extractTomlSectionKeys(sectionBody, { skip: ["python"] }));
+	}
+	return depNames;
+}
+function parsePipfile(content) {
+	const depNames = [];
+	for (const sectionMatch of content.matchAll(/\[(packages|dev-packages)\]([\s\S]*?)(?=\n\[|$)/g)) {
+		const sectionBody = sectionMatch[2];
+		depNames.push(...extractTomlSectionKeys(sectionBody));
+	}
+	return depNames;
+}
+function extractTomlSectionKeys(sectionBody, opts = {}) {
+	const skipNames = new Set(opts.skip ?? []);
+	const depNames = [];
+	for (const line of sectionBody.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const equalsIndex = trimmed.indexOf("=");
+		if (equalsIndex <= 0) continue;
+		const name = trimmed.slice(0, equalsIndex).trim();
+		if (!/^[a-zA-Z0-9._-]+$/.test(name)) continue;
+		if (skipNames.has(name.toLowerCase())) continue;
+		depNames.push(normalizePyName(name));
+	}
+	return depNames;
+}
 //#endregion
-//#region src/lib/warehouse-sources/detect.ts
+//#region src/programs/warehouse-sources/detect.ts
 /**
 * Data warehouse source detection.
 *
@@ -3191,7 +3220,7 @@ function parseGemfile(content) {
 	return gems;
 }
 //#endregion
-//#region src/lib/programs/warehouse-source/detect.ts
+//#region src/programs/warehouse-source/detect.ts
 /**
 * Warehouse-source program detection step.
 *
@@ -3267,247 +3296,23 @@ function detectWarehousePrerequisites(session, setFrameworkContext) {
 	setFrameworkContext(DETECTED_WAREHOUSE_SOURCES_KEY, sources);
 }
 //#endregion
-//#region src/lib/programs/shared/package-scanning.ts
-const POSTHOG_SDKS = new Set([
-	"posthog-js",
-	"posthog-node",
-	"posthog-react-native",
-	"posthog-android",
-	"posthog-ios"
-]);
-const STRIPE_SDKS = new Set([
-	"stripe",
-	"@stripe/stripe-js",
-	"@stripe/react-stripe-js"
-]);
-const MAX_PACKAGE_MATCHES = 500;
-/**
-* Find all package.json files under installDir via the shared bounded walk
-* (depth cap, ignored dirs, symlink-loop protection, per-dir entry cap).
-* Returns matches with detected SDKs.
-*/
-function findPackageJsons(installDir, maxDepth = 3) {
-	const matches = [];
-	walkProjectFiles(installDir, (name, fullPath) => {
-		if (name !== "package.json" || matches.length >= MAX_PACKAGE_MATCHES) return;
-		const content = safeReadFile(fullPath);
-		if (content === null) return;
-		try {
-			const pkg = JSON.parse(content);
-			const depNames = [...Object.keys(pkg.dependencies ?? {}), ...Object.keys(pkg.devDependencies ?? {})];
-			const posthogSdks = depNames.filter((d) => POSTHOG_SDKS.has(d));
-			const stripeSdks = depNames.filter((d) => STRIPE_SDKS.has(d));
-			matches.push({
-				path: relative(installDir, fullPath) || "package.json",
-				posthogSdks,
-				stripeSdks
-			});
-		} catch {}
-	}, maxDepth);
-	return matches;
-}
-//#endregion
-//#region src/lib/programs/posthog-integration/detect.ts
-async function detectPostHogIntegration(ctx) {
-	const session = ctx.session;
-	const installDir = session.installDir;
-	const detectedIntegration = await detectFramework(installDir);
-	if (detectedIntegration) {
-		const config = FRAMEWORK_REGISTRY[detectedIntegration];
-		const sessionOptions = {
-			installDir,
-			debug: session.debug,
-			signup: session.signup,
-			ci: session.ci,
-			benchmark: session.benchmark,
-			yaraReport: session.yaraReport
-		};
-		const context = await gatherFrameworkContext(config, sessionOptions);
-		for (const [key, value] of Object.entries(context)) if (!(key in session.frameworkContext)) ctx.setFrameworkContext(key, value);
-		ctx.setFrameworkConfig(detectedIntegration, config);
-		ctx.setSkillId(detectedIntegration);
-		if (!session.detectedFrameworkLabel) ctx.setDetectedFramework(config.metadata.name);
-		const versionResult = await checkFrameworkVersion(config, sessionOptions);
-		if (versionResult.supported !== true) ctx.setUnsupportedVersion(versionResult.supported);
-	}
-	for (const feature of discoverFeatures(installDir)) ctx.addDiscoveredFeature(feature);
-	detectWarehouseSourcesForSuggestion(ctx, installDir);
-	detectExistingPostHog(ctx, installDir);
-	ctx.setDetectionComplete();
-}
-/**
-* How the scan went, for the reporter to read later. Three states, and the
-* absent one carries the most weight:
-*
-*   absent   this program never scanned. Only `posthog-integration` runs the
-*            scan below, but every program's intro screen resolves consent
-*            through the same store method, so the reporter is reached on runs
-*            where no scan ever happened.
-*   'failed' the scan threw. A zero-count row would read as "scanned, found
-*            nothing", which is a different fact.
-*   'ok'     the scan ran. Zero sources is a real result and gets reported.
-*/
-const WAREHOUSE_SCAN_STATE_KEY = "warehouseScanState";
+//#region src/programs/run-agent-legacy.ts
 /**
-* Scan for data warehouse source signals (Postgres, Stripe, Hubspot, …) and,
-* when found, stash them for a `wizard warehouse` suggestion on the outro.
-* Runs unconditionally during `detect`, before the intro screen has asked
-* about sharing. Reporting what this finds is a separate, later concern.
-* See `reportWarehouseSourcesDetected` below.
+* The session-driven agent runner every existing caller uses.
 *
-* Deliberately a suggestion, not an inline agent run: a second credential-
-* collecting agent run before the outro could `process.exit()` on any of its
-* failure paths and cost the user the success outro on a run where PostHog
-* installed fine.
+* `runProgramAgent(programConfig, session)` runs the gates the TUI owns
+* (health, settings), then calls `runProgram` as its caller, backed by the
+* session and `getUI()`: credentials come from `authenticate`, the AI
+* opt-in and post-auth gates park on the UI, every progress event maps back
+* onto `getUI()`, and the invocation's data projects back onto the session.
+* It applies the result — `wizardAbort` with the outcome's terminal status for
+* a decided failure, the terminal analytics event for a finished top-level run.
 *
-* Calls `detectWarehouseSources` (a pure scan) rather than the warehouse
-* program's `detectWarehousePrerequisites`, which writes a `detectError` when
-* it finds nothing — that's right for `wizard warehouse` but here would show a
-* spurious error and trip the CI prerequisites abort. No sources is a no-op.
-*
-* Best-effort: never let a scan failure break the wizard flow.
-*/
-function detectWarehouseSourcesForSuggestion(ctx, installDir) {
-	try {
-		const sources = detectWarehouseSources(installDir);
-		ctx.setFrameworkContext(WAREHOUSE_SCAN_STATE_KEY, "ok");
-		if (sources.length === 0) return;
-		ctx.setFrameworkContext(DETECTED_WAREHOUSE_SOURCES_KEY, sources);
-	} catch (error) {
-		ctx.setFrameworkContext(WAREHOUSE_SCAN_STATE_KEY, "failed");
-		analytics.captureException(error instanceof Error ? error : new Error(String(error)), { step: "detectWarehouseSourcesForSuggestion" });
-	}
-}
-function hasAiSdkEvidence(session, sources) {
-	return sources.some((s) => AI_SOURCE_KINDS.has(s.kind)) || session.discoveredFeatures.includes("llm");
-}
-/**
-* Boolean only, on the org, never the list of kinds or any non-AI tool: a
-* decline must not leak even the shape of what local detection saw.
-*/
-function stampAiSdkDetected(session, sources) {
-	const organizationId = session.apiUser?.organization?.id;
-	if (!organizationId) return;
-	if (!hasAiSdkEvidence(session, sources)) return;
-	analytics.groupIdentify("organization", organizationId, { wizard_ai_sdk_detected: true });
-}
-/**
-* Fires the org stamp once per session, right after `authenticate()` succeeds
-* — never from the consent path, since consent on the intro screen resolves
-* before login and `session.apiUser` is unset there. Called right after
-* `authenticate()` from run-wizard.ts's auth step and from bootstrap.ts,
-* whichever completes it first for a given program; a no-op on every call
-* after that. In the `--ci` path, project-scope.ts authenticates first as a
-* prerequisite (no evidence gathered yet, so nothing would stamp there
-* anyway) and this only ever runs from the later, idempotent bootstrap.ts
-* call — still correctly finding no evidence, since CI skips the detect step.
-*/
-function maybeStampAiSdkDetected(session) {
-	if (session.aiSdkStampReported) return;
-	session.aiSdkStampReported = true;
-	if (!mayReportScanResults(session)) return;
-	stampAiSdkDetected(session, getDetectedWarehouseSources(session));
-}
-/**
-* The single place scan results become telemetry. Called from
-* `WizardStore.completeSetup()`, the point consent becomes final — the privacy
-* panel's choice is reversible until then, so nothing may report earlier.
-* The org stamp is a separate concern: see `maybeStampAiSdkDetected`, which
-* runs post-auth rather than at consent resolution.
+* This is the only file that knows about `getUI()`, the session and
+* `wizardAbort` on the agent's behalf.
 *
-* Returns true when consent has resolved and the caller should latch
-* `warehouseSourcesReported`, which is not the same as "this sent something":
-* a decline, a failed scan, and a program that never scanned all resolve
-* without sending.
-*/
-function reportWarehouseSourcesDetected(session) {
-	if (session.warehouseSourcesReported) return false;
-	if (session.scanConsent === "undecided") return false;
-	if (mayReportScanResults(session)) {
-		const sources = getDetectedWarehouseSources(session);
-		if (session.frameworkContext[WAREHOUSE_SCAN_STATE_KEY] !== "ok") return true;
-		analytics.wizardCapture("warehouse sources detected", {
-			warehouse_source_count: sources.length,
-			warehouse_source_kinds: sources.map((s) => s.kind),
-			warehouse_source_modes: sources.map((s) => s.mode)
-		});
-		if (sources.length > 0) {
-			analytics.setTag("warehouse_source_kinds", sources.map((s) => s.kind).join(","));
-			analytics.setTag("warehouse_source_count", sources.length);
-		}
-	}
-	return true;
-}
-/** Dependency-level signal, not a verified install. A failed scan reports false. */
-function detectExistingPostHog(ctx, installDir) {
-	try {
-		const pkgJsons = findPackageJsons(installDir);
-		ctx.setPosthogSdkDetected(pkgJsons.some((p) => p.posthogSdks.length > 0));
-	} catch (error) {
-		analytics.captureException(error instanceof Error ? error : new Error(String(error)), { step: "detectExistingPosthog" });
-		ctx.setPosthogSdkDetected(false);
-	}
-}
-//#endregion
-//#region src/lib/programs/audit/types.ts
-/** Single source of truth for status glyph + color across audit views. */
-const AUDIT_SEVERITY_STYLE = {
-	pending: {
-		glyph: "◌",
-		color: "gray"
-	},
-	pass: {
-		glyph: "✔",
-		color: "green"
-	},
-	error: {
-		glyph: "✘",
-		color: "red"
-	},
-	warning: {
-		glyph: "⚠",
-		color: "yellow"
-	},
-	suggestion: {
-		glyph: "•",
-		color: "cyan"
-	}
-};
-const AUDIT_CHECKS_KEY = "auditChecks";
-function getAuditChecks(session) {
-	const raw = session.frameworkContext[AUDIT_CHECKS_KEY];
-	return Array.isArray(raw) ? raw : [];
-}
-//#endregion
-//#region src/lib/programs/audit/ledger-watcher.ts
-/**
-* Mirrors the agent's `.posthog-audit-checks.json` into the session, so the TUI
-* screens and the task stream read one value. `runProgramAgent` owns the
-* lifecycle and removes the file at run end, so every path gets it — including
-* the e2e host, which builds no task stream.
+* ⚠️ Temporary adapter. It is removed later in the refactor.
 */
-const MAX_LEDGER_FILE_BYTES = 256 * 1024;
-function startAuditLedgerWatcher(installDir, file, options = {}) {
-	const target = path.join(installDir, file);
-	logToFile(`[audit-ledger] watching ${target}`);
-	return startFileWatcher(target, (parsed) => getUI().setFrameworkContext(AUDIT_CHECKS_KEY, coerceAuditChecks(parsed)), {
-		ignoreInitialFile: true,
-		maxFileSizeBytes: MAX_LEDGER_FILE_BYTES,
-		...options
-	});
-}
-/** The program declared the ledger, so it removes it, agent `rm` step or not. */
-function removeAuditLedger(installDir, file) {
-	const target = path.join(installDir, file);
-	try {
-		fs.rmSync(target, { force: true });
-	} catch (error) {
-		logToFile(`[audit-ledger] could not remove ${target}: ${String(error)}`);
-	}
-}
-//#endregion
-//#region src/lib/programs/run-agent-legacy.ts
-var run_agent_legacy_exports = /* @__PURE__ */ __exportAll({ runProgramAgent: () => runProgramAgent });
 /**
 * Resolve a ProgramConfig's agent run definition and execute the pipeline.
 * Entry point for the runners and for composed run steps.
@@ -3523,98 +3328,45 @@ async function runProgramAgent(programConfig, session, options = {}) {
 	};
 	if (ledger) registerCleanup(releaseLedger);
 	try {
-		await runProgram(session, typeof programConfig.run === "function" ? await programConfig.run(session) : programConfig.run, programConfig, options.composed ?? false);
+		await runSessionProgram(session, typeof programConfig.run === "function" ? await programConfig.run(session, uiRunnerContext()) : programConfig.run, programConfig, options.composed ?? false);
 	} finally {
 		releaseLedger();
 	}
 }
-/**
-* Gates → authenticate → flags → binding → the functional run → apply result.
-* Every step happens in the order it did inside the agent's bootstrap.
-*/
-async function runProgram(session, run, programConfig, composed) {
+/** The runner context each program effect reaches `getUI()` through, read at call time. */
+function uiRunnerContext() {
+	return {
+		getFrameworkContext: (key) => getUI().getFrameworkContext(key),
+		setFrameworkContext: (key, value) => getUI().setFrameworkContext(key, value),
+		log: { warn: (message) => getUI().log.warn(message) }
+	};
+}
+/** Gates → runProgram on the session's behalf → apply result. */
+async function runSessionProgram(session, run, programConfig, composed) {
 	initLogFile();
 	session.skillId = run.skillId ?? run.integrationLabel;
 	logToFile(`[agent-runner] START ${run.integrationLabel} build=${analytics.build}${session.ci ? " (non-interactive)" : ""}`);
 	if (session.debug) enableDebugLogs();
 	await runHealthGate(session, programConfig);
 	await runSettingsGate(session);
-	analytics.wizardCapture("agent started", {
-		integration: run.integrationLabel,
-		program_id: programConfig.id,
-		skill_id: run.skillId ?? null
-	});
-	await authenticate(session, programConfig.id);
-	maybeStampAiSdkDetected(session);
-	logToFile("[agent-runner] checking AI opt-in gate");
-	await getUI().waitForAiOptIn();
-	logToFile("[agent-runner] AI opt-in gate cleared");
-	for (const step of postAuthGateSteps(programConfig.steps)) {
-		logToFile(`[agent-runner] awaiting post-auth gate: ${step.id}`);
-		await getUI().waitForGate(step.id);
-		logToFile(`[agent-runner] post-auth gate cleared: ${step.id}`);
-	}
-	const wizardFlags = await analytics.getAllFlagsForWizard();
-	const wizardFlagPayloads = analytics.getWizardFlagPayloads();
-	const wizardMetadata = buildRunTags({
-		programId: programConfig.id,
-		integration: run.integrationLabel,
-		runId: analytics.runId,
-		build: analytics.build,
-		skillId: run.skillId
-	});
-	await refreshAccessTokenIfNeeded(session);
-	const credentials = session.credentials;
-	const switchboard = {
-		program: programConfig.id,
-		composed,
-		flags: wizardFlags,
-		flagPayloads: wizardFlagPayloads,
-		cliHarness: session.harness,
-		cliSequence: session.sequence,
-		cliModel: session.model
-	};
-	const binding = resolveBinding(switchboard);
-	analytics.setTag("sequence", binding.sequence);
-	analytics.setTag("harness", binding.harness);
-	wizardMetadata.SEQUENCE = binding.sequence;
-	wizardMetadata.HARNESS = binding.harness;
-	captureSwitchboardDecision(switchboard, binding);
 	const ui = getUI();
-	registerCleanup(() => {
-		const report = flushScanReport({ yaraReport: session.yaraReport });
-		if (report) ui.log.info(report);
+	const reduceUi = createUiReducer(ui);
+	const projectData = projectProgramData(ui, session);
+	let capabilityFailure;
+	const keepFailure = (work) => work.catch((error) => {
+		capabilityFailure ??= { error };
+		throw error;
 	});
-	if (binding.sequence === "linear") ui.onEnterScreen("outro", () => restoreClaudeSettings(session.installDir));
 	const framework = session.integration ?? session.skillId ?? void 0;
-	const result = await runAgent$1({
-		programId: programConfig.id,
+	const result = await runProgram(programConfig.id, {
+		installDir: session.installDir,
 		run,
 		composed,
-		binding,
-		switchboard,
-		skillsBaseUrl: getSkillsBaseUrl(),
-		wizardFlags,
-		wizardFlagPayloads,
-		wizardMetadata,
-		allowedTools: programConfig.allowedTools,
-		disallowedTools: programConfig.disallowedTools,
-		agentFlow: programConfig.agentFlow,
-		excludedTaskTypes: programConfig.excludedTaskTypes,
-		seedTasks: programConfig.seedTasks ? () => programConfig.seedTasks(session) : void 0,
-		hooks: {
-			postRun: run.postRun ? (creds) => run.postRun(session, creds) : void 0,
-			buildOutroData: run.buildOutroData ? (creds) => run.buildOutroData(session, creds) ?? void 0 : void 0,
-			buildOutroNextSteps: run.buildOutroNextSteps ? (creds, completed) => run.buildOutroNextSteps(session, creds, completed) : void 0,
-			recordTaskOutcomes: (outcomes) => {
-				session.frameworkContext[TASK_OUTCOMES_KEY] = outcomes;
-			}
-		}
-	}, {
-		installDir: session.installDir,
-		credentials,
-		project: session.apiProject,
-		apiUser: session.apiUser,
+		overrides: {
+			harness: session.harness,
+			sequence: session.sequence,
+			model: session.model
+		},
 		skillId: session.skillId ?? void 0,
 		integration: session.integration,
 		frameworkDocsUrl: framework ? FRAMEWORK_REGISTRY[framework]?.metadata.docsUrl : void 0,
@@ -3634,14 +3386,62 @@ async function runProgram(session, run, programConfig, composed) {
 			email: session.email,
 			projectId: session.projectId,
 			apiKey: session.apiKey
-		}
+		},
+		seedTasks: programConfig.seedTasks ? () => programConfig.seedTasks(session) : void 0,
+		hooks: {
+			postRun: run.postRun ? (creds) => run.postRun(session, creds) : void 0,
+			buildOutroData: run.buildOutroData ? (creds) => run.buildOutroData(session, creds) ?? void 0 : void 0,
+			buildOutroNextSteps: run.buildOutroNextSteps ? (creds, completed) => run.buildOutroNextSteps(session, creds, completed) : void 0,
+			recordTaskOutcomes: (outcomes) => {
+				session.frameworkContext[TASK_OUTCOMES_KEY] = outcomes;
+			}
+		},
+		program: {
+			requiresAi: programConfig.requiresAi,
+			agentFlow: programConfig.agentFlow,
+			allowedTools: programConfig.allowedTools,
+			disallowedTools: programConfig.disallowedTools,
+			excludedTaskTypes: programConfig.excludedTaskTypes,
+			postAuthGates: postAuthGateSteps(programConfig.steps).map((step) => step.id)
+		},
+		aiSdkStampReported: session.aiSdkStampReported,
+		discoveredFeatures: session.discoveredFeatures,
+		warehouseSources: getDetectedWarehouseSources(session),
+		mayReportScanResults: mayReportScanResults(session)
 	}, {
-		onProgress: createUiReducer(ui),
+		credentials: { resolve: () => keepFailure(authenticate(session, programConfig.id).then(() => ({
+			posthog: session.credentials,
+			project: session.apiProject,
+			apiUser: session.apiUser
+		}))) },
+		awaitAiApproval: async () => {
+			logToFile("[agent-runner] checking AI opt-in gate");
+			await ui.waitForAiOptIn();
+			logToFile("[agent-runner] AI opt-in gate cleared");
+			return true;
+		},
+		awaitPostAuthGates: async ({ gates }) => {
+			for (const gate of gates) {
+				logToFile(`[agent-runner] awaiting post-auth gate: ${gate}`);
+				await ui.waitForGate(gate);
+				logToFile(`[agent-runner] post-auth gate cleared: ${gate}`);
+			}
+		},
+		featureFlags: () => keepFailure(loadWizardFlags()),
+		onProgress: (progress) => {
+			if (progress.kind === "run") reduceUi(progress.event);
+			else projectData(progress.data);
+		},
 		interaction: uiInteraction(ui)
 	});
-	if (result.outcome === "crashed") throw result.failure.error;
+	for (const diagnostic of result.diagnostics) {
+		const runLabel = "runId" in diagnostic ? ` run=${diagnostic.runId}` : "";
+		logToFile(`[agent-runner] progress diagnostic (${diagnostic.eventKind}${runLabel}): ${diagnostic.message}`);
+	}
+	if (capabilityFailure) throw capabilityFailure.error;
+	if (result.outcome === "crashed") throw result.failure?.error;
 	if (result.outcome !== "success") {
-		if (result.failure.authErrorDetail) ui.showAuthError(result.failure.authErrorDetail);
+		if (result.failure?.authErrorDetail) ui.showAuthError(result.failure.authErrorDetail);
 		await wizardAbort({
 			...result.failure,
 			status: result.outcome === "aborted" ? "cancelled" : "error"
@@ -3652,6 +3452,34 @@ async function runProgram(session, run, programConfig, composed) {
 		logToFile("[agent-runner] analytics shutdown failed:", error);
 	}
 }
+/** Mirror the invocation's data onto the session and the UI the TUI reads. */
+function projectProgramData(ui, session) {
+	let bindingSeen = false;
+	return (data) => {
+		const current = session.credentials;
+		if (current && data.credentials && data.credentials.accessToken !== current.accessToken) {
+			session.credentials = {
+				...current,
+				accessToken: data.credentials.accessToken,
+				refreshToken: data.credentials.refreshToken,
+				expiresAt: data.credentials.expiresAt
+			};
+			ui.setAccessToken(session.credentials);
+		}
+		if (data.aiSdkStampReported) session.aiSdkStampReported = true;
+		if (!data.binding || bindingSeen) return;
+		bindingSeen = true;
+		registerCleanup(() => {
+			const report = flushScanReport({ yaraReport: session.yaraReport });
+			if (report) ui.log.info(report);
+		});
+		if (data.binding.sequence === "linear") ui.onEnterScreen("outro", () => restoreClaudeSettings(session.installDir));
+	};
+}
+const loadWizardFlags = async () => ({
+	flags: await analytics.getAllFlagsForWizard(),
+	payloads: analytics.getWizardFlagPayloads()
+});
 async function runHealthGate(session, programConfig) {
 	const hasHealthCheckScreen = programConfig.steps.some((s) => s.screenId === "health-check");
 	if (session.readinessResult) logToFile(`[agent-runner] readiness pre-computed by TUI: decision=${session.readinessResult.decision}${session.outageDismissed ? " (outage dismissed by user)" : ""} — skipping re-check`);
@@ -3706,34 +3534,7 @@ async function runSettingsGate(session) {
 		logToFile("[agent-runner] settings override resolved");
 	}
 }
-/**
-* One event + one log line per run: what entered the switchboard, which
-* precedence rung decided each axis, and the final pick.
-*/
-function captureSwitchboardDecision(ctx, binding) {
-	const trace = ctx.trace ?? {};
-	const perTaskModel = binding.sequence === "orchestrator" && trace.model === "binding";
-	const model = perTaskModel ? "chosen-per-task" : binding.model;
-	const modelSource = perTaskModel ? "agent-prompts" : trace.model;
-	analytics.wizardCapture("switchboard resolved", {
-		program: ctx.program,
-		flag_self_driving_use_pi_harness: ctx.flags[WIZARD_SELF_DRIVING_USE_PI_HARNESS_FLAG_KEY],
-		flag_self_driving_pi_payload: JSON.stringify(ctx.flagPayloads?.["wizard-self-driving-use-pi-harness"] ?? null),
-		flag_orchestrator: ctx.flags[WIZARD_ORCHESTRATOR_FLAG_KEY],
-		cli_harness: ctx.cliHarness,
-		cli_sequence: ctx.cliSequence,
-		cli_model: ctx.cliModel,
-		harness_source: trace.harness,
-		model_source: modelSource,
-		sequence_source: trace.sequence,
-		harness: binding.harness,
-		model,
-		thinking_level: binding.thinkingLevel,
-		sequence: binding.sequence
-	});
-	logToFile(`[switchboard] decision: program=${ctx.program} in(orchestrator=${ctx.flags["wizard-orchestrator"] ?? "-"}, cli=${ctx.cliHarness ?? "-"}/${ctx.cliSequence ?? "-"}/${ctx.cliModel ?? "-"}) → harness=${binding.harness} (${trace.harness ?? "?"}) model=${model} (${modelSource ?? "?"}) sequence=${binding.sequence} (${trace.sequence ?? "?"})`);
-}
 //#endregion
-export { createProgramSequence as S, detectProjectsWithAgent as _, getAuditChecks as a, detectFramework as b, reportWarehouseSourcesDetected as c, findPackageJsons as d, WAREHOUSE_ABORT_CASES as f, AgenticDetectionTimeoutError as g, detectWarehouseSources as h, AUDIT_SEVERITY_STYLE as i, POSTHOG_SDKS as l, getDetectedWarehouseSources as m, run_agent_legacy_exports as n, detectPostHogIntegration as o, detectWarehousePrerequisites as p, AUDIT_CHECKS_KEY as r, maybeStampAiSdkDetected as s, runProgramAgent as t, STRIPE_SDKS as u, resolveProjectDir as v, authenticate as x, gatherFrameworkContext as y };
+export { getDetectedWarehouseSources as a, AUDIT_CHECKS_KEY as c, authenticate as d, createProgramSequence as f, detectWarehousePrerequisites as i, AUDIT_SEVERITY_STYLE as l, stampAiSdkDetected as m, DETECTED_WAREHOUSE_SOURCES_KEY as n, detectWarehouseSources as o, createUiReducer as p, WAREHOUSE_ABORT_CASES as r, discoverFeatures as s, runProgramAgent as t, getAuditChecks as u };
 
-//# sourceMappingURL=run-agent-legacy-d7rWlzQR.js.map
+//# sourceMappingURL=run-agent-legacy-DOlM6DQu.js.map