@posthog/wizard 2.80.0 → 2.80.1

package/dist/store-D3509G87.js

@@ -1,1030 +0,0 @@
-import { s as logToFile } from "./debug-DyARf5TF.js";
-import "./constants-DO4X70po.js";
-import { t as buildSession } from "./wizard-session-BYw6LzpS.js";
-import { i as sessionProperties, n as analytics } from "./analytics-B6q5PN7a.js";
-import { n as isTaskStatus } from "./task-status-CmrrR7zo.js";
-import { a as getBlockingServiceKeys } from "./logging-ui-p6XKVmTx.js";
-import { o as computeTokenCostUsd } from "./agent-BkBbVuNq.js";
-import { p as appendStatus } from "./pi-B5YTBRDv.js";
-import { a as PROGRAM_REGISTRY, i as isRunFailure, o as Program, ot as reportWarehouseSourcesDetected, u as getProgramConfig } from "./mint-failure-C0HyvEwO.js";
-import { atom, map } from "nanostores";
-//#region src/tui/token-usage.ts
-const EMPTY_TOKEN_USAGE = {
-	inputTokens: 0,
-	outputTokens: 0,
-	cacheReadTokens: 0,
-	cacheCreationTokens: 0,
-	costUsd: 0,
-	costIsFinal: false
-};
-/** Total tokens across all counters in a `TokenUsageSnapshot` — used by
-*  both `TokenCostHud` and `exit-line.ts` to detect "no agent turns yet". */
-function totalTokenCount(usage) {
-	return usage.inputTokens + usage.outputTokens + usage.cacheReadTokens + usage.cacheCreationTokens;
-}
-//#endregion
-//#region src/tui/flow.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?"
-*/
-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/tui/ai-opt-in-gate.ts
-/** Step id — also the ScreenId.AiOptIn enum value in screen-sequences. */
-const AI_OPT_IN_STEP_ID = "ai-opt-in";
-function aiApproved(session) {
-	return !!session.apiUser?.organization?.is_ai_data_processing_approved;
-}
-/**
-* Returns the program's steps with the AI opt-in gate injected after
-* `auth`. Programs with `requiresAi: false` or no auth step pass
-* through unchanged — without auth, `apiUser` would never be populated
-* for evaluation anyway.
-*/
-function withAiOptInGate(config) {
-	if (config.requiresAi === false) return config.steps;
-	const authIdx = config.steps.findIndex((s) => s.id === "auth");
-	if (authIdx === -1) return config.steps;
-	const gateStep = {
-		id: AI_OPT_IN_STEP_ID,
-		label: "AI opt-in check",
-		screenId: AI_OPT_IN_STEP_ID,
-		show: (session) => !session.ci && !session.signup && session.apiUser != null && !aiApproved(session),
-		isComplete: (session) => session.ci || session.signup || aiApproved(session),
-		gate: (session) => session.ci || session.signup || aiApproved(session)
-	};
-	return [
-		...config.steps.slice(0, authIdx + 1),
-		gateStep,
-		...config.steps.slice(authIdx + 1)
-	];
-}
-//#endregion
-//#region src/ui/tui/screen-sequences.ts
-/** Post-run steps a mint-failure handoff continues through; ends on exit. */
-const MINT_HANDOFF_SEQUENCE = [
-	{
-		id: "mcp",
-		isComplete: (s) => s.mcpComplete
-	},
-	{
-		id: "slack-connect",
-		isComplete: (s) => s.slackStepDismissed
-	},
-	{
-		id: "keep-skills",
-		isComplete: (s) => s.skillsComplete
-	},
-	{ id: "exit" }
-];
-/** All program screen sequences keyed by program id. */
-const PROGRAM_SEQUENCES = Object.fromEntries(PROGRAM_REGISTRY.map((c) => [c.id, createProgramSequence(withAiOptInGate(c))]));
-//#endregion
-//#region src/tui/router.ts
-var WizardRouter = class {
-	sequence;
-	programId;
-	overlays = [];
-	constructor(programId = Program.PostHogIntegration) {
-		this.setProgram(programId);
-	}
-	/** Point the router at a different program. */
-	setProgram(programId) {
-		this.programId = programId;
-		this.sequence = PROGRAM_SEQUENCES[programId];
-		this.overlays = [];
-	}
-	/**
-	* Resolve which screen should be active based on session state.
-	* Walks the program sequence, skipping hidden entries and completed entries,
-	* returns the first incomplete screen.
-	*/
-	resolve(session) {
-		const runFailed = isRunFailure(session);
-		if (runFailed && session.mintHandoff === "exit") return "exit";
-		if (runFailed && !session.mintHandoff) return "mint-failure";
-		if (this.overlays.length > 0) return this.overlays[this.overlays.length - 1];
-		const sequence = runFailed ? MINT_HANDOFF_SEQUENCE : this.sequence;
-		for (const entry of sequence) {
-			if (entry.show && !entry.show(session)) continue;
-			if (entry.isComplete && entry.isComplete(session)) continue;
-			if (entry.id === "auth" && session.runPhase === "error" && session.outroData) return "outro";
-			return entry.id;
-		}
-		return sequence[sequence.length - 1].id;
-	}
-	/** The screen that should be rendered right now. */
-	get activeScreen() {
-		if (this.overlays.length > 0) return this.overlays[this.overlays.length - 1];
-		return this.sequence[0].id;
-	}
-	/** The id of the active program. */
-	get activeProgram() {
-		return this.programId;
-	}
-	/** Whether an overlay is currently active. */
-	get hasOverlay() {
-		return this.overlays.length > 0;
-	}
-	/**
-	* Push an overlay that interrupts the current program.
-	* The program resumes when the overlay is dismissed via popOverlay().
-	*/
-	pushOverlay(overlay) {
-		this.overlays.push(overlay);
-	}
-	/**
-	* Dismiss the topmost overlay. The program screen underneath resumes.
-	*/
-	popOverlay() {
-		this.overlays.pop();
-	}
-	/**
-	* Direction hint for screen transitions.
-	*/
-	_lastDirection = null;
-	get lastNavDirection() {
-		return this._lastDirection;
-	}
-	/** @internal — called by store wrapper to track direction */
-	_setDirection(dir) {
-		this._lastDirection = dir;
-	}
-};
-//#endregion
-//#region src/tui/store.ts
-/**
-* WizardStore — Nanostore-backed reactive store for the TUI.
-* React components subscribe via useSyncExternalStore.
-*
-* The active screen is derived from session state — WizardRouter walks
-* the flow and shows the first step whose `isComplete` is still false.
-*
-* Define a step `gate` if your screen needs to await user interactions.
-* bin.ts calls `await store.getGate(stepId)` to pause until the gate
-* predicate becomes true.
-*
-* All session mutations that affect screen resolution go through
-* explicit setters so emitChange() is always called.
-*/
-function captureHealthCheckBlocked(result) {
-	try {
-		const health = result.health;
-		const blockingKeys = getBlockingServiceKeys(health);
-		const attempts = health.skillsOrigin.rawIndicator?.match(/attempts=(\d+)/);
-		const retriesUsed = Math.max(0, attempts ? Number(attempts[1]) - 1 : 0);
-		analytics.wizardCapture("health check blocked", {
-			decision: "skills-origin-down",
-			blocking_keys: blockingKeys,
-			retries_used: retriesUsed
-		});
-	} catch (err) {
-		logToFile(`[health-checks] failed to capture analytics: ${err instanceof Error ? err.message : String(err)}`);
-	}
-}
-var WizardStore = class {
-	$session = map(buildSession({}));
-	$statusMessages = atom([]);
-	$statusExpanded = atom(false);
-	$tasks = atom([]);
-	$eventPlan = atom([]);
-	$handoffText = atom(null);
-	$learnCardBlockIdx = atom(0);
-	$learnCardComplete = atom(false);
-	$version = atom(0);
-	$currentStage = atom(null);
-	$tokenUsage = atom(EMPTY_TOKEN_USAGE);
-	$tokenHudVisible = atom(false);
-	_onTasksChanged = null;
-	/** Last screen seen — used to detect screen transitions for analytics. */
-	_lastScreen = null;
-	/** Hooks run when transitioning onto a screen. */
-	_enterScreenHooks = /* @__PURE__ */ new Map();
-	/** Gate promises derived from program step definitions. */
-	_gates = /* @__PURE__ */ new Map();
-	version = "";
-	/** Navigation router — resolves active screen from session state. */
-	router;
-	/** Blocks agent execution until the settings-override overlay is dismissed. */
-	_resolveSettingsOverride = null;
-	_backupAndFixSettings = null;
-	/** Blocks the run until an optional step's notice is answered. */
-	_resolveTaskNotice = null;
-	/** Blocks OAuth flow until the port-conflict overlay is dismissed. */
-	_resolvePortConflict = null;
-	/** Resolves the OAuth flow with a manually-entered authorization code. */
-	_resolveManualAuthCode = null;
-	/** Resolves the in-flight wizard_ask request. */
-	_noteAskProgress = null;
-	_resolvePendingQuestion = null;
-	constructor(program = Program.PostHogIntegration) {
-		this.router = new WizardRouter(program);
-		this._initFromProgram(program);
-	}
-	/**
-	* Scan program steps for gate predicates and create gate promises.
-	*
-	* Steps are wrapped with withAiOptInGate so the injected ai-opt-in
-	* step's gate registers here — the agent runner awaits it (via
-	* WizardUI.waitForAiOptIn) before any source leaves the machine.
-	* Same wrapper screen-sequences.ts uses, so the gate and its screen
-	* can't drift apart.
-	*/
-	_initFromProgram(program) {
-		const steps = withAiOptInGate(getProgramConfig(program));
-		for (const step of steps) if (step.gate) {
-			let resolve;
-			const promise = new Promise((r) => {
-				resolve = r;
-			});
-			this._gates.set(step.id, {
-				predicate: step.gate,
-				promise,
-				resolve,
-				resolved: false
-			});
-		}
-	}
-	/**
-	* Run the program steps' onInit callbacks. startTUI calls this once
-	* the screens are actually rendering — constructing a store alone
-	* (tests, playground) must not fire init work like the health-check
-	* pre-flight, whose probes belong only to flows that show its screen.
-	*/
-	runInitHooks() {
-		const steps = getProgramConfig(this.router.activeProgram).steps;
-		const getSession = () => this.session;
-		const ctx = {
-			get session() {
-				return getSession();
-			},
-			setReadinessResult: (r) => this.setReadinessResult(r),
-			setFrameworkContext: (k, v) => this.setFrameworkContext(k, v),
-			emitChange: () => this.emitChange()
-		};
-		for (const step of steps) step.onInit?.(ctx);
-	}
-	/**
-	* Run all `onReady` hooks declared by the current flow's steps, in
-	* order. Must be called after `store.session = session` so hooks see
-	* the real installDir. bin.ts calls this generically — it doesn't
-	* need to know which program has which pre-flow work.
-	*/
-	async runReadyHooks() {
-		const steps = getProgramConfig(this.router.activeProgram).steps;
-		const ctx = {
-			session: this.session,
-			setFrameworkContext: (k, v) => this.setFrameworkContext(k, v),
-			setFrameworkConfig: (i, c) => this.setFrameworkConfig(i, c),
-			setDetectedFramework: (l) => this.setDetectedFramework(l),
-			setPosthogSdkDetected: (d) => this.setPosthogSdkDetected(d),
-			setSkillId: (id) => this.setSkillId(id),
-			setUnsupportedVersion: (info) => this.setUnsupportedVersion(info),
-			addDiscoveredFeature: (f) => this.addDiscoveredFeature(f),
-			setDetectionComplete: () => this.setDetectionComplete()
-		};
-		for (const step of steps) if (step.onReady) await step.onReady(ctx);
-	}
-	/**
-	* Get a gate promise by step ID — the primary blocking checkpoint API
-	* for bin.ts. `await store.getGate('...')` parks the caller until the
-	* corresponding program step's gate predicate flips to true (if the
-	* predicate stays false, the caller stays parked indefinitely — the
-	* TUI keeps rendering so the user can resolve whatever is blocking).
-	*
-	* If the program doesn't define a step with this ID, or the step
-	* has no `gate` predicate, this returns an already-resolved promise
-	* so bin.ts flows straight through. This lets programs opt in to
-	* gates on a per-step basis without bin.ts needing to know which
-	* gates exist in which flow.
-	*/
-	getGate(stepId) {
-		return this._gates.get(stepId)?.promise ?? Promise.resolve();
-	}
-	/**
-	* Resolve once `predicate(session)` is true. Unlike a gate, this is created
-	* at the await point and evaluated live against the current session, so it
-	* never latches on a startup value — the orchestrator uses it to wait for a
-	* decision (a project picked, a handoff acknowledged) without the "true while
-	* undecided" trap that latched gate predicates have.
-	*/
-	waitUntil(predicate) {
-		if (predicate(this.session)) return Promise.resolve();
-		return new Promise((resolve) => {
-			const unsub = this.subscribe(() => {
-				if (predicate(this.session)) {
-					unsub();
-					resolve();
-				}
-			});
-		});
-	}
-	/**
-	* Re-evaluate every gate predicate against the current session and
-	* resolve any whose predicate now returns true. Called after every
-	* emitChange(), so gates unblock as soon as the session mutation
-	* that satisfies them lands. Gates only resolve once — a predicate
-	* that goes true → false → true will NOT re-block a caller that
-	* already awaited through.
-	*/
-	_checkGates() {
-		for (const [, gate] of this._gates) if (!gate.resolved && gate.predicate(this.session)) {
-			gate.resolved = true;
-			gate.resolve();
-		}
-	}
-	get session() {
-		return this.$session.get();
-	}
-	set session(value) {
-		this.$session.set(value);
-		this.emitChange();
-	}
-	get statusMessages() {
-		return this.$statusMessages.get();
-	}
-	get tasks() {
-		return this.$tasks.get();
-	}
-	get eventPlan() {
-		return this.$eventPlan.get();
-	}
-	get handoffText() {
-		return this.$handoffText.get();
-	}
-	get currentStage() {
-		return this.$currentStage.get();
-	}
-	/** No-op when the stage hasn't changed, so `startedAt` survives across
-	*  re-renders and tab switches and measures real stage time. */
-	setCurrentStage(stage) {
-		if (this.$currentStage.get()?.stage === stage) return;
-		this.$currentStage.set({
-			stage,
-			startedAt: Date.now()
-		});
-		this.emitChange();
-	}
-	get statusExpanded() {
-		return this.$statusExpanded.get();
-	}
-	toggleStatusExpanded() {
-		this.$statusExpanded.set(!this.$statusExpanded.get());
-		this.emitChange();
-	}
-	setStatusExpanded(expanded) {
-		if (this.$statusExpanded.get() !== expanded) {
-			this.$statusExpanded.set(expanded);
-			this.emitChange();
-		}
-	}
-	/** Sets setupConfirmed, and is the point consent becomes final. */
-	completeSetup() {
-		this.$session.setKey("setupConfirmed", true);
-		this._markWarehouseSourcesReportedIfNeeded();
-		analytics.wizardCapture("setup confirmed", sessionProperties(this.session));
-		this.emitChange();
-	}
-	/**
-	* Sharing is on: either the user turned it back on in the panel, or they
-	* pressed Continue without ever touching it. Both are reversible until
-	* completeSetup() resolves the intro gate and reports.
-	*/
-	grantSharing() {
-		this.$session.setKey("scanConsent", "granted");
-		this.emitChange();
-	}
-	/**
-	* Sharing is off. Suppresses reporting only — local detection still ran and
-	* the results stay in the session, so the outro suggestion and the warehouse
-	* task are unaffected; see `scanConsent` on `WizardSession`.
-	*
-	* Deliberately does not report. The panel's toggle can come back here, so
-	* marking the run reported would strand a user who turns sharing off and
-	* then on again. completeSetup() owns the single report.
-	*/
-	declineSharing() {
-		this.$session.setKey("scanConsent", "declined");
-		this.emitChange();
-	}
-	/**
-	* reportWarehouseSourcesDetected() is the single place scan results turn
-	* into telemetry; this just supplies its idempotency flag via the normal
-	* setter path (never mutate session directly). A no-op once
-	* `warehouseSourcesReported` is set, or for any program that never
-	* populated a warehouse-scan result in the first place.
-	*/
-	_markWarehouseSourcesReportedIfNeeded() {
-		if (reportWarehouseSourcesDetected(this.session)) this.$session.setKey("warehouseSourcesReported", true);
-	}
-	setRunPhase(phase) {
-		this.$session.setKey("runPhase", phase);
-		analytics.setTag("run_phase", phase);
-		this.emitChange();
-	}
-	setCredentials(credentials) {
-		this.$session.setKey("credentials", credentials);
-		if (credentials?.projectId) analytics.setTag("project_id", credentials.projectId);
-		analytics.wizardCapture("auth complete", { project_id: credentials?.projectId });
-		this.emitChange();
-	}
-	/** Post-refresh credential swap. No `auth complete` — see WizardUI. */
-	setAccessToken(credentials) {
-		this.$session.setKey("credentials", credentials);
-		this.emitChange();
-	}
-	setRoleAtOrganization(role) {
-		this.$session.setKey("roleAtOrganization", role);
-		this.emitChange();
-	}
-	setApiUser(user) {
-		this.$session.setKey("apiUser", user);
-		this.emitChange();
-	}
-	setFrameworkConfig(integration, config) {
-		this.$session.setKey("integration", integration);
-		this.$session.setKey("frameworkConfig", config);
-		this.$session.setKey("unsupportedVersion", null);
-		if (integration) analytics.setTag("integration", integration);
-		this.emitChange();
-	}
-	setDetectionComplete() {
-		this.$session.setKey("detectionComplete", true);
-		this.emitChange();
-	}
-	setDetectedFramework(label) {
-		this.$session.setKey("detectedFrameworkLabel", label);
-		analytics.setTag("detected_framework", label);
-		this.emitChange();
-	}
-	setPosthogSdkDetected(detected) {
-		this.$session.setKey("posthogSdkDetected", detected);
-		this.emitChange();
-	}
-	setSpellbook(spellbook) {
-		this.$session.setKey("spellbook", spellbook);
-		this.emitChange();
-	}
-	setMintHandoff(action) {
-		this.cancelPendingQuestion();
-		if (this.session.taskNotice) this.resolveTaskNotice(false);
-		this.$session.setKey("mintHandoff", action);
-		this.emitChange();
-	}
-	setSkillId(skillId) {
-		this.$session.setKey("skillId", skillId);
-		this.emitChange();
-	}
-	setUnsupportedVersion(info) {
-		this.$session.setKey("unsupportedVersion", info);
-		this.emitChange();
-	}
-	setLoginUrl(url) {
-		this.$session.setKey("loginUrl", url);
-		this.emitChange();
-	}
-	setAuthorizeUrl(url) {
-		this.$session.setKey("authorizeUrl", url);
-		this.emitChange();
-	}
-	setReadinessResult(result) {
-		this.$session.setKey("readinessResult", result);
-		if (result && result.decision === "no") captureHealthCheckBlocked(result);
-		this.emitChange();
-	}
-	/** User dismissed the blocking outage screen. Gate resolves via _checkGates(). */
-	dismissOutage() {
-		logToFile("[health-checks] user dismissed outage screen, continuing");
-		this.$session.setKey("outageDismissed", true);
-		this.emitChange();
-	}
-	/**
-	* Push the settings-override overlay and return a promise that blocks
-	* until the user dismisses it via backupAndFixSettingsOverride().
-	*/
-	showSettingsOverride(conflicts, backupAndFix) {
-		const allKeys = conflicts.flatMap((c) => c.keys);
-		this.$session.setKey("settingsOverrideKeys", allKeys);
-		this.$session.setKey("settingsConflicts", conflicts);
-		this._backupAndFixSettings = backupAndFix;
-		if (conflicts.some((c) => !c.writable)) this.pushOverlay("managed-settings");
-		else this.pushOverlay("settings-override");
-		return new Promise((resolve) => {
-			this._resolveSettingsOverride = resolve;
-		});
-	}
-	/**
-	* Push the port-conflict overlay and return a promise that blocks
-	* until the user frees the ports and retries, or exits.
-	*/
-	showPortConflict(processInfo) {
-		this.$session.setKey("portConflictProcess", processInfo);
-		this.pushOverlay("port-conflict");
-		return new Promise((resolve) => {
-			this._resolvePortConflict = resolve;
-		});
-	}
-	/** Dismiss the port-conflict overlay and retry the OAuth port loop. */
-	resolvePortConflict() {
-		this.$session.setKey("portConflictProcess", null);
-		this.popOverlay();
-		this._resolvePortConflict?.();
-		this._resolvePortConflict = null;
-	}
-	/**
-	* Show an optional step's notice and return whether to keep that step.
-	* Asked before the step runs, so nobody is surprised by a prompt mid-run.
-	*/
-	showTaskNotice(notice) {
-		this.$session.setKey("taskNotice", notice);
-		this.pushOverlay("task-notice");
-		return new Promise((resolve) => {
-			this._resolveTaskNotice = resolve;
-		});
-	}
-	/** Dismiss the notice, keeping (`true`) or skipping (`false`) the step. */
-	resolveTaskNotice(keep) {
-		this.$session.setKey("taskNotice", null);
-		this.popOverlay();
-		this._resolveTaskNotice?.(keep);
-		this._resolveTaskNotice = null;
-	}
-	/**
-	* Return a promise that resolves when the user submits a manually-entered
-	* OAuth code via the paste modal. The OAuth flow races this against the
-	* local callback server — see `performOAuthFlow`.
-	*/
-	waitForManualAuthCode() {
-		return new Promise((resolve) => {
-			this._resolveManualAuthCode = resolve;
-		});
-	}
-	/** Open the manual OAuth code-entry overlay over the auth screen. */
-	showManualAuthCode() {
-		this.pushOverlay("manual-auth-code");
-	}
-	/** Dismiss the manual OAuth code overlay without submitting. */
-	dismissManualAuthCode() {
-		this.popOverlay();
-	}
-	/**
-	* Submit a manually-entered authorization code: dismiss the overlay and
-	* resolve the in-flight OAuth flow so it can exchange the code for a token.
-	*/
-	submitManualAuthCode(code) {
-		this.popOverlay();
-		this._resolveManualAuthCode?.(code);
-		this._resolveManualAuthCode = null;
-	}
-	/**
-	* Open the WizardAsk overlay with a set of questions and return a promise
-	* that resolves once the user submits answers (or the request is cancelled).
-	*
-	* Only one request is in flight at a time — calling this while a request
-	* is already pending throws.
-	*/
-	requestQuestion(question, onAnswer) {
-		if (this._resolvePendingQuestion) throw new Error("requestQuestion called while another wizard_ask request is pending");
-		this._noteAskProgress = onAnswer ?? null;
-		this.$session.setKey("pendingQuestion", question);
-		this.pushOverlay("wizard-ask");
-		analytics.wizardCapture("wizard_ask shown", {
-			source: question.source,
-			question_count: question.questions.length,
-			kinds: question.questions.map((q) => q.kind)
-		});
-		return new Promise((resolve) => {
-			this._resolvePendingQuestion = resolve;
-		});
-	}
-	/**
-	* Report that the user answered one question of the in-flight request and
-	* another is coming — the ask bridge's timeout heartbeat.
-	*/
-	noteAskProgress() {
-		this._noteAskProgress?.();
-	}
-	/**
-	* Resolve the in-flight wizard_ask request with the user's answers and
-	* dismiss the overlay. Answers flow back to the agent as the tool result.
-	*/
-	resolvePendingQuestion(answers) {
-		const resolve = this._resolvePendingQuestion;
-		this._resolvePendingQuestion = null;
-		this._noteAskProgress = null;
-		this.$session.setKey("pendingQuestion", null);
-		this.popOverlay();
-		resolve?.(answers);
-	}
-	/**
-	* Cancel the in-flight wizard_ask request — the bridge sends a sentinel
-	* answer ("__cancelled__") so the skill can decide how to handle it.
-	*/
-	cancelPendingQuestion() {
-		const pending = this.session.pendingQuestion;
-		if (!pending) return;
-		const cancelled = {};
-		for (const q of pending.questions) cancelled[q.id] = "__cancelled__";
-		this.resolvePendingQuestion(cancelled);
-	}
-	/**
-	* Back up .claude/settings.json. Dismisses the overlay on success.
-	*/
-	backupAndFixSettingsOverride() {
-		const ok = this._backupAndFixSettings?.() ?? false;
-		if (ok) {
-			this.$session.setKey("settingsOverrideKeys", null);
-			this.$session.setKey("settingsConflicts", null);
-			this.popOverlay();
-			this._resolveSettingsOverride?.();
-			this._resolveSettingsOverride = null;
-			this._backupAndFixSettings = null;
-		}
-		return ok;
-	}
-	/** Push the auth-error overlay (no dismiss — user must exit). */
-	showAuthError(detail) {
-		this.$session.setKey("authErrorDetail", detail ?? null);
-		this.pushOverlay("auth-error");
-	}
-	/** Push the session-timeout overlay (no dismiss — user must exit). */
-	showSessionTimeout() {
-		this.pushOverlay("session-timeout");
-	}
-	addDiscoveredFeature(feature) {
-		if (!this.session.discoveredFeatures.includes(feature)) {
-			this.session.discoveredFeatures.push(feature);
-			this.emitChange();
-		}
-	}
-	setMcpComplete(outcome = "skipped", installedClients = [], featuresSelected, loginCommands = []) {
-		this.$session.setKey("mcpComplete", true);
-		this.$session.setKey("mcpOutcome", outcome);
-		this.$session.setKey("mcpInstalledClients", installedClients);
-		this.$session.setKey("mcpLoginCommands", loginCommands);
-		const featuresPayload = outcome === "installed" && featuresSelected !== void 0 ? { mcp_features_selected: featuresSelected } : {};
-		analytics.wizardCapture("mcp complete", {
-			mcp_outcome: outcome,
-			mcp_installed_clients: installedClients,
-			...featuresPayload,
-			...sessionProperties(this.session)
-		});
-		this.emitChange();
-	}
-	setSkillsComplete(kept) {
-		this.$session.setKey("skillsComplete", true);
-		analytics.wizardCapture("skills complete", {
-			skills_kept: kept,
-			...sessionProperties(this.session)
-		});
-		this.emitChange();
-	}
-	setMcpSuggestedPromptsDismissed() {
-		this.$session.setKey("mcpSuggestedPromptsDismissed", true);
-		this.emitChange();
-	}
-	setSlackStepDismissed() {
-		this.$session.setKey("slackStepDismissed", true);
-		this.emitChange();
-	}
-	setSlackConnected(connected) {
-		this.$session.setKey("slackConnected", connected);
-		this.emitChange();
-	}
-	setGithubConnected(connected) {
-		this.$session.setKey("githubConnected", connected);
-		this.emitChange();
-	}
-	/**
-	* Self-driving GitHub gate declined. Carries the outro the user lands on,
-	* since declining ends the flow before the agent runs and there is no abort
-	* case to render one.
-	*/
-	declineGithub(outroData) {
-		this.$session.setKey("githubDeclined", true);
-		this.$session.setKey("outroData", outroData);
-		this.emitChange();
-	}
-	/**
-	* Self-driving integration-check answer. `true` → integrate the SDK as part
-	* of this run; `false` → PostHog is already set up, go straight to
-	* Self-driving. Resolves `session.integrate` from null.
-	*/
-	setIntegrate(integrate, extra) {
-		this.$session.setKey("integrate", integrate);
-		analytics.wizardCapture("self-driving integration check", {
-			self_driving_integrate: integrate,
-			...extra?.via ? { self_driving_integrate_via: extra.via } : {},
-			...extra?.path ? { self_driving_integrate_path: extra.path } : {},
-			...sessionProperties(this.session)
-		});
-		this.emitChange();
-	}
-	/**
-	* Self-driving "no PostHog account" branch of the integration check. The
-	* project has no SDK, so we always integrate (`integrate = true`); and since
-	* the user has no account, we flip `signup` and record the `email` / `region`
-	* collected on the screen so `authenticate` → `getOrAskForProjectData` takes
-	* the provisioning path (create account + email a login link) instead of
-	* OAuth. The "yes, I have an account" branch uses `setIntegrate(true)` and
-	* leaves `signup` false so auth runs the normal OAuth login.
-	*/
-	chooseProvisionAccount(email, region) {
-		this.$session.setKey("signup", true);
-		this.$session.setKey("email", email);
-		this.$session.setKey("region", region);
-		this.$session.setKey("integrate", true);
-		analytics.wizardCapture("self-driving integration check", {
-			self_driving_integrate: true,
-			self_driving_has_account: false,
-			provision_region: region,
-			...sessionProperties(this.session)
-		});
-		this.emitChange();
-	}
-	/**
-	* Self-driving handoff confirmed — the user acknowledged the post-integration
-	* screen, so the Self-driving run can begin. Gate resolves via _checkGates().
-	*/
-	confirmSelfDrivingHandoff() {
-		this.$session.setKey("selfDrivingHandoffConfirmed", true);
-		this.emitChange();
-	}
-	/**
-	* Mark a composed run step complete (e.g. self-driving's `integrate-run`).
-	* Records the step id so its `isComplete` predicate holds, clears the task
-	* list, and resets run phase to Idle so the next run step starts fresh.
-	*/
-	completeRunStep(stepId) {
-		const done = this.session.completedRuns;
-		if (!done.includes(stepId)) this.$session.setKey("completedRuns", [...done, stepId]);
-		this.$tasks.set([]);
-		this.setRunPhase("idle");
-	}
-	setOutroDismissed(dismissed = true) {
-		this.$session.setKey("outroDismissed", dismissed);
-		this.emitChange();
-	}
-	setOutroData(data) {
-		this.$session.setKey("outroData", data);
-		this.emitChange();
-	}
-	setDashboardUrl(url) {
-		logToFile(`store.setDashboardUrl: ${url}`);
-		this.$session.setKey("dashboardUrl", url);
-		this.emitChange();
-	}
-	setNotebookUrl(url) {
-		logToFile(`store.setNotebookUrl: ${url}`);
-		this.$session.setKey("notebookUrl", url);
-		this.emitChange();
-	}
-	setFrameworkContext(key, value) {
-		const ctx = {
-			...this.$session.get().frameworkContext,
-			[key]: value
-		};
-		this.$session.setKey("frameworkContext", ctx);
-		this.emitChange();
-	}
-	switchProgram(program) {
-		if (program === this.router.activeProgram) return;
-		for (const gate of this._gates.values()) gate.resolve();
-		this._gates.clear();
-		this.router.setProgram(program);
-		this._initFromProgram(program);
-		analytics.setTag("program_id", program);
-		const config = getProgramConfig(program);
-		this.$session.setKey("setupConfirmed", false);
-		this.$session.setKey("programLabel", config.id);
-		this.$session.setKey("skillId", config.skillId ?? null);
-		this.emitChange();
-	}
-	/**
-	* The screen that should be rendered right now.
-	* Derived from session state via the router.
-	*/
-	get currentScreen() {
-		return this.router.resolve(this.session);
-	}
-	/** Direction hint for screen transitions. */
-	get lastNavDirection() {
-		return this.router.lastNavDirection;
-	}
-	getVersion() {
-		return this.$version.get();
-	}
-	/**
-	* Notify React that state has changed.
-	* The router re-resolves the active screen on next render.
-	* Gate predicates are checked and resolved if ready.
-	*/
-	emitChange() {
-		this.router._setDirection("push");
-		this.$version.set(this.$version.get() + 1);
-		this._checkGates();
-		this._detectTransition();
-	}
-	pushOverlay(overlay) {
-		this.router._setDirection("push");
-		this.router.pushOverlay(overlay);
-		this.$version.set(this.$version.get() + 1);
-		this._detectTransition();
-	}
-	popOverlay() {
-		this.router._setDirection("pop");
-		this.router.popOverlay();
-		this.$version.set(this.$version.get() + 1);
-		this._detectTransition();
-	}
-	/**
-	* Register a callback to run when transitioning onto the given screen.
-	* Fires after every transition that lands on this screen.
-	*/
-	onEnterScreen(screen, fn) {
-		const list = this._enterScreenHooks.get(screen) ?? [];
-		list.push(fn);
-		this._enterScreenHooks.set(screen, list);
-	}
-	/**
-	* The program `screen` reports under — its step's `reportsAsProgramId` if it
-	* claims one, else the running program (also the fallback for overlays and
-	* screens with no owning step).
-	*/
-	_programIdForScreen(screen) {
-		const program = this.router.activeProgram;
-		return getProgramConfig(program).steps.find((s) => s.screenId === screen)?.reportsAsProgramId ?? program;
-	}
-	/** The program the visible screen reports under; screens stamp this on their
-	*  own events rather than relying on the run-level `program_id` tag. */
-	get analyticsProgramId() {
-		return this._programIdForScreen(this.router.resolve(this.session));
-	}
-	/**
-	* Detect screen transitions, run enter-screen hooks, and fire analytics.
-	* Called at the end of emitChange/pushOverlay/popOverlay.
-	*/
-	_detectTransition() {
-		const next = this.router.resolve(this.session);
-		const prev = this._lastScreen;
-		if (next !== prev) analytics.setTag("$screen_name", next);
-		if (prev !== null && next !== prev) {
-			const hooks = this._enterScreenHooks.get(next);
-			if (hooks) for (const fn of hooks) fn();
-			analytics.wizardCapture(`screen ${next}`, {
-				from_screen: prev,
-				program_id: this._programIdForScreen(next),
-				...sessionProperties(this.session)
-			});
-		}
-		this._lastScreen = next;
-	}
-	pushStatus(message) {
-		const msgs = this.$statusMessages.get();
-		const next = appendStatus(msgs, message);
-		if (next === msgs) return;
-		this.$statusMessages.set(next);
-		this.emitChange();
-	}
-	get tokenUsage() {
-		return this.$tokenUsage.get();
-	}
-	get tokenHudVisible() {
-		return this.$tokenHudVisible.get();
-	}
-	/** Hidden Ctrl+T shortcut — see ScreenContainer. Not registered as a
-	*  keyboard hint, so it never shows in the hints bar. */
-	toggleTokenHud() {
-		this.$tokenHudVisible.set(!this.$tokenHudVisible.get());
-		this.emitChange();
-	}
-	/**
-	* Accumulate one assistant turn's token usage into the running estimate.
-	* Approximate by design (no dedup for SDK-retried/replayed turns, unlike
-	* the benchmark middleware's TurnCounterPlugin) — it's a live indicator
-	* for a hidden debug HUD, not a billing record, and `setFinalTokenCostUsd`
-	* corrects the total once the run's authoritative cost is known.
-	*/
-	addTokenUsage(delta) {
-		const cur = this.$tokenUsage.get();
-		if (cur.costIsFinal) return;
-		const deltaCostUsd = computeTokenCostUsd(delta);
-		this.$tokenUsage.set({
-			inputTokens: cur.inputTokens + delta.inputTokens,
-			outputTokens: cur.outputTokens + delta.outputTokens,
-			cacheReadTokens: cur.cacheReadTokens + delta.cacheReadTokens,
-			cacheCreationTokens: cur.cacheCreationTokens + delta.cacheCreationTokens,
-			costUsd: cur.costUsd + deltaCostUsd,
-			costIsFinal: false
-		});
-		this.emitChange();
-	}
-	/** Reconcile the running cost estimate to the SDK's authoritative total
-	*  once the agent run completes — same trick the benchmark's
-	*  CostTrackerPlugin.onFinalize uses to correct any per-turn drift. */
-	setFinalTokenCostUsd(costUsd) {
-		const cur = this.$tokenUsage.get();
-		this.$tokenUsage.set({
-			...cur,
-			costUsd,
-			costIsFinal: true
-		});
-		this.emitChange();
-	}
-	setTasks(tasks) {
-		this.$tasks.set(tasks);
-		this.emitChange();
-	}
-	updateTask(index, done) {
-		const tasks = this.$tasks.get();
-		if (tasks[index]) {
-			const updated = [...tasks];
-			updated[index] = {
-				...updated[index],
-				done,
-				status: done ? "completed" : "pending"
-			};
-			this.$tasks.set(updated);
-			this.emitChange();
-		}
-	}
-	setEventPlan(events) {
-		this.$eventPlan.set(events);
-		this.emitChange();
-	}
-	/** No-op on identical text: an emit here means a network push downstream. */
-	setHandoffText(text) {
-		if (this.$handoffText.get() === text) return;
-		logToFile(`store.setHandoffText: ${text.length} chars`);
-		this.$handoffText.set(text);
-		this.emitChange();
-	}
-	get learnCardBlockIdx() {
-		return this.$learnCardBlockIdx.get();
-	}
-	setLearnCardBlockIdx(idx) {
-		this.$learnCardBlockIdx.set(idx);
-	}
-	get learnCardComplete() {
-		return this.$learnCardComplete.get();
-	}
-	setLearnCardComplete() {
-		this.$learnCardComplete.set(true);
-		this.emitChange();
-	}
-	syncTodos(todos) {
-		const incoming = todos.map((t) => {
-			const status = isTaskStatus(t.status) ? t.status : "pending";
-			return {
-				id: t.id,
-				source: t.source,
-				sourceStatus: isTaskStatus(t.status) ? void 0 : t.status,
-				label: t.content,
-				activeForm: t.activeForm,
-				status,
-				done: status === "completed"
-			};
-		});
-		const incomingLabels = new Set(incoming.map((t) => t.label));
-		const sources = new Set(todos.map((t) => t.source));
-		const retained = this.$tasks.get().filter((t) => (t.status === "completed" || t.status === "failed" || t.status === "skipped") && (t.source ? !sources.has(t.source) : !incomingLabels.has(t.label)));
-		this.$tasks.set([...retained, ...incoming]);
-		this.emitChange();
-		this._onTasksChanged?.();
-	}
-	/** Register a listener for task state changes (e.g. task stream push). */
-	set onTasksChanged(fn) {
-		this._onTasksChanged = fn;
-	}
-	subscribe(callback) {
-		return this.$version.listen(() => callback());
-	}
-	getSnapshot() {
-		return this.$version.get();
-	}
-};
-//#endregion
-export { totalTokenCount as n, WizardStore as t };
-
-//# sourceMappingURL=store-D3509G87.js.map