@posthog/wizard 2.74.1 → 2.76.0

package/dist/{agent-interface-lCIi_alS.js → agent-interface-CZWRgZMc.js}

@@ -1,12 +1,13 @@
 import { n as __require } from "./rolldown-runtime-B_-DWIq7.js";
-import { c as RESUME_INSTRUCTION, d as ErrorCodes, l as classifyAuthFailure, o as AgentSignals, s as REMARK_INSTRUCTION } from "./errors--OqLxmWR.js";
-import { E as AWS_SKILLS_BASE_URL, O as CONTEXT_MILL_URL, a as getLogFilePath, bt as runtimeEnv, f as getUI, mt as wizardUserAgentForProgram, o as initLogFile, r as debug, s as logToFile, ut as WIZARD_REMARK_EVENT_NAME, y as checkLlmGatewayHealth } from "./debug-GxjVplPx.js";
-import { n as ADDITIONAL_FEATURE_PROMPTS } from "./wizard-session-GdDN_aMS.js";
-import { n as analytics } from "./analytics-CeVMOExk.js";
-import { a as safeReadFile, i as readProjectFile, o as walkProjectFiles } from "./bounded-fs-DmcmFPRq.js";
-import { i as wizardAbort, n as registerCleanup, t as WizardError } from "./wizard-abort-BVmjqUAQ.js";
-import { b as coerceAuditChecks, g as AUDIT_CHECKS_FILE, l as prewarmYaraScanner, n as createPostToolUseYaraHooks, p as scanInstalledSkill, r as createPreToolUseYaraHooks } from "./yara-hooks-qRkdjYiV.js";
-import { S as writeJsonAtomic, b as triageModelFor, c as buildOrchestratorTools, v as modelCapabilities, x as makeMutex } from "./queue-tools-BveMVXQm.js";
+import { c as RESUME_INSTRUCTION, l as classifyAuthFailure, o as AgentSignals, s as REMARK_INSTRUCTION } from "./errors--OqLxmWR.js";
+import { D as AWS_SKILLS_BASE_URL, a as getLogFilePath, dt as WIZARD_REMARK_EVENT_NAME, ht as wizardUserAgentForProgram, k as CONTEXT_MILL_URL, o as initLogFile, p as getUI, r as debug, s as logToFile, xt as runtimeEnv } from "./debug-C5Zz8hmm.js";
+import { n as ADDITIONAL_FEATURE_PROMPTS } from "./wizard-session-FSJCkTcP.js";
+import { n as analytics } from "./analytics-C_RyE8fz.js";
+import { a as safeReadFile, i as readProjectFile, o as walkProjectFiles } from "./bounded-fs-BHLy83N9.js";
+import { i as wizardAbort, n as registerCleanup, t as WizardError } from "./wizard-abort-BCnUgT9z.js";
+import { o as gatewayAuth, r as buildWizardPropertiesBlob, s as isPastRefresh } from "./gateway-session-C3Uqwc4R.js";
+import { b as coerceAuditChecks, g as AUDIT_CHECKS_FILE, l as prewarmYaraScanner, n as createPostToolUseYaraHooks, p as scanInstalledSkill, r as createPreToolUseYaraHooks } from "./yara-hooks-BJWVgTpU.js";
+import { C as writeJsonAtomic, S as makeMutex, l as buildOrchestratorTools, x as triageModelFor, y as modelCapabilities } from "./queue-tools-D09PNS0X.js";
 import { createRequire } from "node:module";
 import * as fs$1 from "fs";
 import fs from "fs";
@@ -191,303 +192,6 @@ function createCustomHeaders() {
 	};
 }
 //#endregion
-//#region src/lib/legacy-gateway.ts
-let enabled = false;
-/** Only the `--ci` runner turns this on. */
-function setLegacyGatewayFallback(on) {
-	enabled = on;
-}
-/** Legacy auth when the fallback is on and the mint cannot serve this credential (401, or 404 without the endpoint). */
-function legacyGatewayAuth(host, accessToken, mintStatus) {
-	if (!enabled || mintStatus !== 401 && mintStatus !== 404) return void 0;
-	return {
-		gatewayUrl: legacyGatewayUrl(host),
-		token: accessToken,
-		legacy: true,
-		refreshAtMs: Number.POSITIVE_INFINITY
-	};
-}
-function legacyGatewayUrl(host) {
-	const { hostname } = new URL(host.apiHost);
-	if (hostname === "host.docker.internal") return "http://host.docker.internal:3308/wizard";
-	if (hostname === "localhost" || hostname === "127.0.0.1") return "http://localhost:3308/wizard";
-	return `https://gateway.${host.region}.posthog.com/wizard`;
-}
-/** The legacy gateway reads per-key metadata and flag headers and needs an explicit Bedrock opt-in. */
-function legacyGatewayHeaders(wizardMetadata, wizardFlags) {
-	const headers = { "x-posthog-use-bedrock-fallback": "true" };
-	for (const [key, value] of Object.entries(wizardMetadata)) headers[key.startsWith("X-POSTHOG-PROPERTY-") ? key : `X-POSTHOG-PROPERTY-${key}`] = value;
-	for (const [flagKey, variant] of Object.entries(wizardFlags)) {
-		if (!flagKey.toLowerCase().startsWith("wizard")) continue;
-		headers[`X-POSTHOG-FLAG-${flagKey.toUpperCase()}`] = variant;
-	}
-	return headers;
-}
-//#endregion
-//#region src/lib/gateway-session.ts
-/**
-* Gateway auth for a wizard run: a `phe_` scoped token the backend mints, with
-* pinned attribution, a spend cap and an expiry.
-*
-* Every mint failure throws, since a silent downgrade would spend uncapped,
-* unattributed money to hide an outage. The CI-only exception lives in
-* legacy-gateway.ts.
-*/
-let cached = null;
-/**
-* Shared so concurrent callers mint once. The orchestrator starts every runnable
-* task at once, and each would otherwise take its own token and its own cap.
-*/
-let inFlight = null;
-/**
-* Adoption floor. The anthropic subprocess holds its credential until a 401
-* forces a re-mint, so a token below this would churn mints.
-*/
-const MIN_USABLE_TTL_MS = 120 * 1e3;
-/** Re-resolve at this fraction of the token's life, leaving a usable remainder. */
-const REFRESH_AT_FRACTION = .8;
-const MINT_TIMEOUT_MS = 2e4;
-/** Longer than any refusal the mint writes; a body past this is not a message. */
-const MAX_REFUSAL_DETAIL_LENGTH = 500;
-/** Outcomes are short snake_case labels; anything longer is not one. */
-const MAX_REFUSAL_OUTCOME_LENGTH = 64;
-/** Resolve this run's gateway auth, minting and re-minting near expiry. */
-async function gatewayAuth(host, accessToken, program) {
-	const key = `${host.apiHost}\n${accessToken}\n${program ?? ""}`;
-	if (cached && cached.key === key && Date.now() < cached.staleAtMs) return cached.auth;
-	if (inFlight && inFlight.key === key) return inFlight.promise;
-	const promise = resolveGatewayAuth(host, accessToken, key, program);
-	inFlight = {
-		key,
-		promise
-	};
-	try {
-		return await promise;
-	} finally {
-		if (inFlight?.promise === promise) inFlight = null;
-	}
-}
-async function resolveGatewayAuth(host, accessToken, key, program) {
-	if (!program) {
-		logToFile("[gateway] run has no program id; failing the run");
-		throw new GatewayMintFailed("this run has no program to attribute its spend to");
-	}
-	let minted;
-	try {
-		minted = await mintGatewayToken(host, accessToken, program);
-	} catch (e) {
-		if (!(e instanceof GatewayMintRefused)) throw e;
-		const legacy = legacyGatewayAuth(host, accessToken, e.status);
-		if (!legacy) throw e;
-		logToFile(`[gateway] mint refused this credential (HTTP ${e.status}); CI run staying on the legacy gateway`);
-		cached = {
-			key,
-			auth: legacy,
-			staleAtMs: legacy.refreshAtMs
-		};
-		return legacy;
-	}
-	if ((await checkLlmGatewayHealth(minted.gatewayUrl)).status !== "healthy") throw new WizardError("The PostHog AI gateway is unavailable. Please try again later.", void 0, ErrorCodes.EnvServiceOutage);
-	const expiresAtMs = Date.parse(minted.expiresAt);
-	const ttlMs = expiresAtMs - Date.now();
-	if (!Number.isFinite(expiresAtMs) || ttlMs < MIN_USABLE_TTL_MS) {
-		logToFile(`[gateway] mint returned a token with ${ttlMs}ms of life; failing the run`);
-		throw new GatewayMintFailed(`the PostHog gateway issued a token with ${ttlMs}ms of life`);
-	}
-	const staleAtMs = Date.now() + ttlMs * REFRESH_AT_FRACTION;
-	logToFile(`[gateway] minted a scoped token: program=${program} team=${minted.teamId ?? "unknown"} ttl=${Math.round(ttlMs / 1e3)}s url=${minted.gatewayUrl}`);
-	const auth = {
-		gatewayUrl: minted.gatewayUrl,
-		token: minted.token,
-		teamId: minted.teamId,
-		refreshAtMs: staleAtMs
-	};
-	cached = {
-		key,
-		auth,
-		staleAtMs
-	};
-	return auth;
-}
-/** Whether a 401 on this bearer may be age (past its refresh instant) rather than a bad credential. */
-function isPastRefresh(auth, now = Date.now()) {
-	return now >= auth.refreshAtMs;
-}
-/**
-* Whether a server-supplied origin may receive a bearer and prompt content:
-* https (loopback excepted), and either a posthog.com host or the one the run
-* authenticated against.
-*/
-function isTrustedGatewayUrl(value, apiHost) {
-	let url;
-	try {
-		url = new URL(value);
-	} catch {
-		return false;
-	}
-	if (url.pathname !== "/" || url.search || url.hash || url.username || url.password) return false;
-	if (url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "host.docker.internal") return true;
-	if (url.protocol !== "https:") return false;
-	if (url.hostname.endsWith(".posthog.com")) return true;
-	try {
-		return url.hostname === new URL(apiHost).hostname;
-	} catch {
-		return false;
-	}
-}
-/**
-* A deliberate refusal from the mint endpoint, as opposed to the mint being
-* unavailable. Thrown so the run stops instead of proceeding without the
-* controls the refusal was enforcing. A WizardError, so the runners print its
-* message as-is and `wizardAbort` resolves its code.
-*/
-var GatewayMintRefused = class extends WizardError {
-	status;
-	/** The backend's refusal outcome (`blocked`, `throttled`, ...), when it sent one. */
-	outcome;
-	constructor(status, message, outcome) {
-		super(message, {
-			status,
-			outcome
-		}, ErrorCodes.GatewayMintRefused);
-		this.name = "GatewayMintRefused";
-		this.status = status;
-		this.outcome = outcome;
-	}
-};
-/**
-* The mint could not produce a usable credential: unreachable, a 5xx, or a
-* response the client cannot use.
-*/
-var GatewayMintFailed = class extends WizardError {
-	constructor(message) {
-		super(message, void 0, ErrorCodes.GatewayMintFailed);
-		this.name = "GatewayMintFailed";
-	}
-};
-/**
-* Whether a mint status means "refused this run" rather than "not available".
-* 429 the daily run limit, 403 revoked project access, 400 a login covering
-* more than one project, 401 a credential the mint does not accept, 404 an
-* instance without the mint endpoint.
-*/
-function isMintRefusal(status) {
-	return status === 400 || status === 401 || status === 403 || status === 404 || status === 429;
-}
-/**
-* The server's own reason for a refusal, when it sent one. DRF answers every
-* refusal as `{"detail": "...", "code": "<outcome>"}`; the blocklist's detail
-* names the contact address, which the fixed messages below cannot. `code` is
-* the backend's own label for the refusal (`outcome` on older backends) and
-* rides the client event.
-*/
-function cleanRefusalText(value) {
-	if (typeof value !== "string") return "";
-	return value.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").trim();
-}
-async function readRefusal(resp) {
-	try {
-		const body = await resp.json();
-		const detail = cleanRefusalText(body?.detail);
-		const outcome = cleanRefusalText(body?.code) || cleanRefusalText(body?.outcome);
-		return {
-			detail: detail.length > 0 && detail.length <= MAX_REFUSAL_DETAIL_LENGTH ? detail : void 0,
-			outcome: outcome.length > 0 && outcome.length <= MAX_REFUSAL_OUTCOME_LENGTH ? outcome : void 0
-		};
-	} catch {
-		return {};
-	}
-}
-function mintRefusalMessage(status, detail) {
-	if (detail) return detail;
-	switch (status) {
-		case 429: return "This wizard program has used its daily run limit. Try again tomorrow.";
-		case 403: return "Your access to this project has changed. Re-authenticate and try again.";
-		case 400: return "Your PostHog login must cover exactly one project. Re-authenticate and try again.";
-		case 401: return "PostHog did not accept this login. Re-authenticate with `npx @posthog/wizard@latest`.";
-		case 404: return "This PostHog instance does not issue gateway tokens. Upgrade with `npx @posthog/wizard@latest` and try again.";
-		default: return "The PostHog gateway refused this run.";
-	}
-}
-async function mintGatewayToken(host, accessToken, program) {
-	try {
-		const resp = await fetch(`${host.apiHost}/api/wizard/gateway_token/`, {
-			method: "POST",
-			headers: {
-				Authorization: `Bearer ${accessToken}`,
-				"Content-Type": "application/json"
-			},
-			body: JSON.stringify({
-				program,
-				reads_refusal_reason: true
-			}),
-			signal: AbortSignal.timeout(MINT_TIMEOUT_MS)
-		});
-		if (!resp.ok) {
-			if (isMintRefusal(resp.status)) {
-				const refusal = await readRefusal(resp);
-				logToFile(`[gateway] mint refused with HTTP ${resp.status} (${refusal.outcome ?? "no outcome"}); failing the run`);
-				analytics.wizardCapture("gateway mint refused", {
-					status: resp.status,
-					outcome: refusal.outcome,
-					program
-				});
-				throw new GatewayMintRefused(resp.status, mintRefusalMessage(resp.status, refusal.detail), refusal.outcome);
-			}
-			logToFile(`[gateway] mint failed with HTTP ${resp.status}; failing the run`);
-			throw new GatewayMintFailed(`the PostHog gateway could not issue a token (HTTP ${resp.status})`);
-		}
-		const body = await resp.json();
-		if (!body.token) {
-			logToFile("[gateway] mint response omitted token; failing the run");
-			throw new GatewayMintFailed("mint response omitted token");
-		}
-		if (!body.expires_at) {
-			logToFile("[gateway] mint response omitted expires_at; failing the run");
-			throw new GatewayMintFailed("mint response omitted expires_at");
-		}
-		if (!body.gateway_url) {
-			logToFile("[gateway] mint response omitted gateway_url; failing the run");
-			throw new GatewayMintFailed("mint response omitted gateway_url");
-		}
-		if (!isTrustedGatewayUrl(body.gateway_url, host.apiHost)) {
-			logToFile("[gateway] mint returned an untrusted gateway url; failing the run");
-			throw new GatewayMintFailed("mint returned an untrusted gateway url");
-		}
-		return {
-			token: body.token,
-			expiresAt: body.expires_at,
-			gatewayUrl: body.gateway_url.replace(/\/+$/, ""),
-			teamId: body.team_id
-		};
-	} catch (e) {
-		if (e instanceof GatewayMintRefused || e instanceof GatewayMintFailed) throw e;
-		logToFile(`[gateway] mint transport failure (${String(e)}); failing the run`);
-		throw new GatewayMintFailed(`could not reach the PostHog gateway (${String(e)})`);
-	}
-}
-/**
-* The v2 run-metadata carrier: one JSON blob for the `X-PostHog-Properties`
-* header. Plain keys only, since the gateway strips `$`-prefixed keys as reserved,
-* so feature-flag variants land as `wizard_flag_<key>` instead of the legacy
-* `$feature/<key>` (dashboards keying on `$feature/wizard-*` read the new key
-* post-cutover).
-*/
-function buildWizardPropertiesBlob(wizardMetadata, wizardFlags, teamId) {
-	const props = { ai_product: "wizard" };
-	if (teamId !== void 0) props.team_id = teamId;
-	for (const [key, value] of Object.entries(wizardMetadata)) props[stripPropertyPrefix(key)] = value;
-	for (const [flagKey, variant] of Object.entries(wizardFlags)) {
-		if (!flagKey.toLowerCase().startsWith("wizard")) continue;
-		props[`wizard_flag_${flagKey.toLowerCase()}`] = variant;
-	}
-	return JSON.stringify(props);
-}
-const LEGACY_PROPERTY_PREFIX = "X-POSTHOG-PROPERTY-";
-function stripPropertyPrefix(key) {
-	return key.toUpperCase().startsWith(LEGACY_PROPERTY_PREFIX) ? key.slice(19).toLowerCase() : key;
-}
-//#endregion
 //#region src/lib/safe-tools.ts
 const LINTING_TOOLS = [
 	"codespell",
@@ -999,6 +703,13 @@ function evaluateBashCommand(rawCommand) {
 */
 /** Sentinel returned for unanswered fields on cancellation or timeout. */
 const CANCELLED_SENTINEL = "__cancelled__";
+/**
+* The longer per-question timeout, for asks that send the user on an errand —
+* open a database console, mint a restricted API key. The default above is
+* sized for a question answerable from memory and expires long before an
+* errand is done.
+*/
+const LONGER_ASK_TIMEOUT_MS = 1200 * 1e3;
 function buildCancelledAnswers(questions) {
 	const out = {};
 	for (const q of questions) out[q.id] = CANCELLED_SENTINEL;
@@ -1021,8 +732,10 @@ function createWizardAskBridge(opts) {
 		};
 		const startedAt = Date.now();
 		let timer;
+		let timedOut = false;
 		const timeoutPromise = new Promise((resolve) => {
 			timer = setTimeout(() => {
+				timedOut = true;
 				opts.cancelQuestion?.();
 				resolve(buildCancelledAnswers(questions));
 			}, timeoutMs);
@@ -1035,7 +748,7 @@ function createWizardAskBridge(opts) {
 				subject,
 				question_count: questions.length,
 				duration_ms: durationMs,
-				timed_out: durationMs >= timeoutMs
+				timed_out: timedOut
 			});
 			else analytics.wizardCapture("wizard_ask answered", {
 				source: pending.source,
@@ -1043,7 +756,10 @@ function createWizardAskBridge(opts) {
 				question_count: questions.length,
 				duration_ms: durationMs
 			});
-			return answers;
+			return {
+				answers,
+				timedOut
+			};
 		} finally {
 			if (timer) clearTimeout(timer);
 		}
@@ -1327,6 +1043,31 @@ function normaliseAskSubject(subject) {
 	return trimmed.slice(0, ASK_SUBJECT_MAX_LENGTH);
 }
 /**
+* The `wizard_ask` `kind` field description, shared by both harness facades so
+* the inferred default cannot drift between them.
+*/
+const WIZARD_ASK_KIND_DESCRIPTION = "'single' = pick one option, 'multi' = pick any, 'text' = free-form single-line answer. Optional: omit it and the kind follows the question — 'single' when you pass options, 'text' when you do not, which is what a credential question wants.";
+/**
+* Fill in the `kind` of every question that arrived without one.
+*
+* The field used to be required, and both harnesses validate a call before this
+* handler sees it — pi against the typebox schema, the MCP SDK against the zod
+* one — so a call that omitted it was rejected upstream and the agent spent a
+* turn recovering from a validation error rather than asking its question.
+* Accepting the omission costs nothing, because `options` already says which
+* kind was meant, and a question carrying none is free text — which is what a
+* credential question wants, and the case an agent is most likely to send bare.
+*
+* Options imply `single`, never `multi`: omitting `kind` expresses no intent to
+* accept more than one answer.
+*/
+function resolveAskQuestionKinds(questions) {
+	return questions.map((q) => ({
+		...q,
+		kind: q.kind ?? (q.options && q.options.length > 0 ? "single" : "text")
+	}));
+}
+/**
 * The `wizard_ask` `sensitive` field description, shared by both harness facades
 * (the zod schema in `./mcp` and the typebox mirror in `harness/pi/tools.ts`) so
 * the secret-handling guidance cannot drift between them — the same discipline
@@ -1355,7 +1096,43 @@ const WIZARD_ASK_SUBJECT_DESCRIPTION = "Short, stable tag naming what this call
 * server in `./mcp` and the pi-native mirror in `harness/pi/tools.ts`) so the
 * batching and cancellation contract reads identically in both harnesses.
 */
-const WIZARD_ASK_TOOL_DESCRIPTION = "Ask the user one or more structured questions and wait for their answers. Use this whenever you would otherwise inline a question in your text output. Batch every question about one subject into a single call (up to 8) rather than asking one at a time, and tag the call with `subject`. Walking a list — one call per data-warehouse source, one call per integration step — is expected and is never blocked, because the batching guard counts consecutive calls per subject. A fully cancelled or timed-out response does NOT count against the per-run cap — treat it as \"the user declined\" and fall back gracefully (e.g. hand over a deep link) without worrying about a wasted call.";
+const WIZARD_ASK_TOOL_DESCRIPTION = "Ask the user one or more structured questions and wait for their answers. Use this whenever you would otherwise inline a question in your text output. Batch every question about one subject into a single call (up to 8) rather than asking one at a time, and tag the call with `subject`. Walking a list — one call per data-warehouse source, one call per integration step — is expected and is never blocked, because the batching guard counts consecutive calls per subject. A fully cancelled or timed-out response does NOT count against the per-run cap, so nothing is wasted. When a field is not collected the result carries a `cancelled` object naming those question ids, whether the user dismissed the prompt or it timed out, and what to do next: read that instead of inspecting the answer values, and fall back gracefully (e.g. hand over a deep link) rather than re-asking.";
+/**
+* Guidance returned with a `wizard_ask` result when the user dismissed the
+* prompt. Shared by both harness facades, like the descriptions above.
+*
+* Deliberately says nothing about how the caller reports its own outcome:
+* `wizard_ask` serves programs with no task queue as well as the orchestrator's
+* seeded ones, so the note covers the ask and only the ask.
+*/
+const ASK_CANCELLED_NOTE = "The user dismissed this prompt, so none of these fields were collected. Read it as a decline for this subject: do not re-ask the same questions. Fall back to a route that needs no answer from them (for example, hand them a link to finish it themselves) and carry on with the rest of your work. Asking about a different subject is still fine.";
+/**
+* Guidance returned with a `wizard_ask` result when the prompt timed out.
+*
+* A timeout is not one decline: it says nobody is reading the terminal, and
+* every later prompt in the run will end the same way after the same wait.
+* Naming that is the difference between falling back once and stopping the run
+* behind one unattended prompt per remaining item.
+*/
+const ASK_TIMED_OUT_NOTE = "This prompt timed out with no answer, so the user is most likely away from the terminal. Read it as a decline, and expect any further prompt in this run to time out the same way after the same wait: stop asking and finish without them — hand over links for everything still outstanding — rather than opening another prompt.";
+/**
+* Describe an ask's cancelled fields, or `undefined` when every question was
+* answered. `timedOut` comes from the ask bridge — it is the only thing that
+* tells a dismissed prompt from an unattended one.
+*/
+function describeAskCancellation(answers, timedOut) {
+	const questionIds = Object.entries(answers).filter(([, value]) => value === CANCELLED_SENTINEL).map(([id]) => id);
+	if (questionIds.length === 0) return void 0;
+	return timedOut ? {
+		reason: "timed-out",
+		questionIds,
+		note: ASK_TIMED_OUT_NOTE
+	} : {
+		reason: "user-cancelled",
+		questionIds,
+		note: ASK_CANCELLED_NOTE
+	};
+}
 /**
 * Pure decision function for the wizard_ask caps. Returns whether the
 * upcoming call should proceed and, if not, the message to surface to the
@@ -1538,6 +1315,34 @@ function templateEnvWriteRefusal(resolvedPath) {
 	if (!isTemplateEnvFileName(name)) return null;
 	return `Error: "${name}" is a committed template that documents key names, so it is not a valid target for set_env_values — a credential written there would be published with the repository. Write to .env or .env.local instead (it is created if missing). If you only mean to document the key name, edit the template directly.`;
 }
+/** Whole-word, so `NEXT_PUBLIC_POSTHOG_KEY` (`_` is a word character) does not count. */
+const LEGACY_KEY_USE = /\bPOSTHOG_KEY\b/;
+/** Files where a project reads or defines an env var: source, config, env, shell and build files. */
+const LEGACY_KEY_SCAN_FILE = /^(\.env.*|Dockerfile.*|Makefile|Procfile|package\.json|app\.json|eas\.json|.*\.[cm]?[jt]sx?|.*\.(vue|svelte|astro|py|rb|php|go|rs|exs?|java|kts?|swift|dart|cs|ya?ml|toml|sh|bash|gradle|properties|xcconfig|plist))$/;
+function projectReadsLegacyKey(workingDirectory) {
+	let found = false;
+	walkProjectFiles(workingDirectory, (name, fullPath) => {
+		if (found || !LEGACY_KEY_SCAN_FILE.test(name)) return;
+		const content = readProjectFile(fullPath);
+		if (content !== null && LEGACY_KEY_USE.test(content)) found = true;
+	}, 6);
+	return found;
+}
+/**
+* `set_env_values`' refusal for the legacy `POSTHOG_KEY` name, or null. Shared
+* by both facades so the two cannot disagree about it.
+*
+* `POSTHOG_KEY` is the old name for the project token, so a new project gets
+* the canonical one (e.g. NEXT_PUBLIC_POSTHOG_PROJECT_TOKEN). A project whose
+* code already reads `POSTHOG_KEY` keeps it: refusing there forces a rename of
+* working code, and every deploy step and CI secret that still passes the old
+* name then starts the app with an empty token.
+*/
+function legacyKeyNameRefusal(workingDirectory, keys) {
+	const key = keys.find((k) => k.toUpperCase() === "POSTHOG_KEY");
+	if (!key || projectReadsLegacyKey(workingDirectory)) return null;
+	return `Error: "${key}" is not a valid PostHog env var name. Use the key name from your framework's integration guide (e.g. NEXT_PUBLIC_POSTHOG_PROJECT_TOKEN). POSTHOG_KEY is accepted only when the project already reads it.`;
+}
 /**
 * Escape a key before it is interpolated into the match regex below. The key
 * comes from the agent, and a stray metacharacter would otherwise build a
@@ -1685,6 +1490,47 @@ function readLedger(targetPath) {
 		return [];
 	}
 }
+const AUDIT_SEED_CHECKS_DESCRIPTION = "Seed the audit ledger at .posthog-audit-checks.json with the full set of pending checks. Call this once at the start of the audit. Atomically replaces any existing ledger.";
+const AUDIT_SEED_CHECKS_PARAM_DESCRIPTION = "Full pending checklist to write to the ledger";
+const AUDIT_ADD_CHECKS_DESCRIPTION = "Append one or more pending checks to the existing audit ledger at .posthog-audit-checks.json. Call audit_seed_checks first. Atomically rejects duplicate ids without changing the ledger.";
+const AUDIT_ADD_CHECKS_PARAM_DESCRIPTION = "Additional checks to append to the existing ledger";
+const AUDIT_RESOLVE_CHECKS_DESCRIPTION = "Resolve one or more audit checks by id. Patches each entry's status (and optional file/details) and writes the ledger back atomically. Concurrent calls serialize.";
+const AUDIT_RESOLVE_CHECKS_PARAM_DESCRIPTION = "Patches to apply, keyed by check id";
+/** The three ledger mutations. The caller owns serialization (a mutex). */
+function seedAuditChecks(targetPath, checks) {
+	writeLedgerAtomic(targetPath, checks);
+	return {
+		ok: true,
+		message: `Seeded ${checks.length} audit checks.`
+	};
+}
+function addAuditChecks(targetPath, checks) {
+	const result = appendAuditChecksToLedger(targetPath, checks);
+	if (result.ok) return {
+		ok: true,
+		message: `Added ${result.added} audit check(s).`
+	};
+	if (result.reason === "missing-ledger") return {
+		ok: false,
+		message: "Error: audit ledger does not exist. Run audit_seed_checks first."
+	};
+	return {
+		ok: false,
+		message: `Error: duplicate check id(s): ${result.ids.join(", ")}. Check ids must be unique.`
+	};
+}
+function resolveAuditChecks(targetPath, updates) {
+	const { next, unknown } = applyAuditUpdates(readLedger(targetPath), updates);
+	if (unknown.length > 0) return {
+		ok: false,
+		message: `Error: unknown check id(s): ${unknown.join(", ")}. Run audit_seed_checks first or check the id.`
+	};
+	writeLedgerAtomic(targetPath, next);
+	return {
+		ok: true,
+		message: `Resolved ${updates.length} check(s).`
+	};
+}
 function appendAuditChecksToLedger(targetPath, additions) {
 	if (!fs.existsSync(targetPath)) return {
 		ok: false,
@@ -1935,11 +1781,11 @@ async function createWizardToolsServer(options) {
 		filePath: z.string().describe(ENV_FILE_PATH_DESCRIPTION),
 		values: z.record(z.string(), z.union([z.string(), z.object({ secretRef: z.string() })])).describe("Key → (literal string OR { secretRef } pointing to a vaulted secret)")
 	}, (args) => {
-		const forbidden = Object.keys(args.values).find((k) => k.toUpperCase() === "POSTHOG_KEY");
-		if (forbidden) return {
+		const keyRefusal = legacyKeyNameRefusal(workingDirectory, Object.keys(args.values));
+		if (keyRefusal) return {
 			content: [{
 				type: "text",
-				text: `Error: "${forbidden}" is not a valid PostHog env var name. Use the project-specific key name from your framework's integration guide (e.g. NEXT_PUBLIC_POSTHOG_PROJECT_TOKEN).`
+				text: keyRefusal
 			}],
 			isError: true
 		};
@@ -2049,58 +1895,40 @@ async function createWizardToolsServer(options) {
 	});
 	const auditLedgerPath = path.join(workingDirectory, AUDIT_CHECKS_FILE);
 	const auditMutex = makeMutex();
-	const auditSeedChecks = tool("audit_seed_checks", "Seed the audit ledger at .posthog-audit-checks.json with the full set of pending checks. Call this once at the start of the audit. Atomically replaces any existing ledger.", { checks: z.array(auditCheckSchema).describe("Full pending checklist to write to the ledger") }, async (args) => {
+	const auditSeedChecks = tool("audit_seed_checks", AUDIT_SEED_CHECKS_DESCRIPTION, { checks: z.array(auditCheckSchema).describe(AUDIT_SEED_CHECKS_PARAM_DESCRIPTION) }, async (args) => {
 		return auditMutex(() => {
-			writeLedgerAtomic(auditLedgerPath, args.checks);
+			const result = seedAuditChecks(auditLedgerPath, args.checks);
 			logToFile(`audit_seed_checks: wrote ${args.checks.length} entries`);
 			return { content: [{
 				type: "text",
-				text: `Seeded ${args.checks.length} audit checks.`
+				text: result.message
 			}] };
 		});
 	});
-	const auditAddChecks = tool("audit_add_checks", "Append one or more pending checks to the existing audit ledger at .posthog-audit-checks.json. Call audit_seed_checks first. Atomically rejects duplicate ids without changing the ledger.", { checks: z.array(auditCheckSchema).min(1).describe("Additional checks to append to the existing ledger") }, async (args) => {
+	const auditAddChecks = tool("audit_add_checks", AUDIT_ADD_CHECKS_DESCRIPTION, { checks: z.array(auditCheckSchema).min(1).describe(AUDIT_ADD_CHECKS_PARAM_DESCRIPTION) }, async (args) => {
 		return auditMutex(() => {
-			const result = appendAuditChecksToLedger(auditLedgerPath, args.checks);
-			if (!result.ok) {
-				if (result.reason === "missing-ledger") return {
-					content: [{
-						type: "text",
-						text: "Error: audit ledger does not exist. Run audit_seed_checks first."
-					}],
-					isError: true
-				};
-				return {
-					content: [{
-						type: "text",
-						text: `Error: duplicate check id(s): ${result.ids.join(", ")}. Check ids must be unique.`
-					}],
-					isError: true
-				};
-			}
-			logToFile(`audit_add_checks: added ${result.added} entries`);
-			return { content: [{
-				type: "text",
-				text: `Added ${result.added} audit check(s).`
-			}] };
+			const result = addAuditChecks(auditLedgerPath, args.checks);
+			logToFile(`audit_add_checks: ${result.message}`);
+			return {
+				content: [{
+					type: "text",
+					text: result.message
+				}],
+				...result.ok ? {} : { isError: true }
+			};
 		});
 	});
-	const auditResolveChecks = tool("audit_resolve_checks", "Resolve one or more audit checks by id. Patches each entry's status (and optional file/details) and writes the ledger back atomically. Concurrent calls serialize.", { updates: z.array(auditUpdateSchema).min(1).describe("Patches to apply, keyed by check id") }, async (args) => {
+	const auditResolveChecks = tool("audit_resolve_checks", AUDIT_RESOLVE_CHECKS_DESCRIPTION, { updates: z.array(auditUpdateSchema).min(1).describe(AUDIT_RESOLVE_CHECKS_PARAM_DESCRIPTION) }, async (args) => {
 		return auditMutex(() => {
-			const { next, unknown } = applyAuditUpdates(readLedger(auditLedgerPath), args.updates);
-			if (unknown.length > 0) return {
+			const result = resolveAuditChecks(auditLedgerPath, args.updates);
+			logToFile(`audit_resolve_checks: ${result.message}`);
+			return {
 				content: [{
 					type: "text",
-					text: `Error: unknown check id(s): ${unknown.join(", ")}. Run audit_seed_checks first or check the id.`
+					text: result.message
 				}],
-				isError: true
+				...result.ok ? {} : { isError: true }
 			};
-			writeLedgerAtomic(auditLedgerPath, next);
-			logToFile(`audit_resolve_checks: applied ${args.updates.length} update(s)`);
-			return { content: [{
-				type: "text",
-				text: `Resolved ${args.updates.length} check(s).`
-			}] };
 		});
 	});
 	const askQuestionSchema = z.object({
@@ -2110,7 +1938,7 @@ async function createWizardToolsServer(options) {
 			"single",
 			"multi",
 			"text"
-		]).describe("'single' = pick one option, 'multi' = pick any, 'text' = free-form single-line answer"),
+		]).optional().describe(WIZARD_ASK_KIND_DESCRIPTION),
 		options: z.array(z.object({
 			label: z.string(),
 			value: z.string(),
@@ -2159,7 +1987,8 @@ async function createWizardToolsServer(options) {
 						isError: capDecision.reason !== "adjacency"
 					};
 				}
-				for (const q of args.questions) {
+				const questions = resolveAskQuestionKinds(args.questions);
+				for (const q of questions) {
 					if ((q.kind === "single" || q.kind === "multi") && (!q.options || q.options.length === 0)) return {
 						content: [{
 							type: "text",
@@ -2176,7 +2005,7 @@ async function createWizardToolsServer(options) {
 					};
 				}
 				const ids = /* @__PURE__ */ new Set();
-				for (const q of args.questions) {
+				for (const q of questions) {
 					if (ids.has(q.id)) return {
 						content: [{
 							type: "text",
@@ -2188,16 +2017,20 @@ async function createWizardToolsServer(options) {
 				}
 				askAccounting.record(args.subject);
 				try {
-					const answers = await askBridge.request({
-						questions: args.questions,
+					const { answers, timedOut } = await askBridge.request({
+						questions,
 						subject: normaliseAskSubject(args.subject)
 					});
 					if (isFullyCancelled(answers)) askAccounting.refund(args.subject);
-					const sanitised = vaultSensitiveAnswers(args.questions, answers, secretVault);
-					logToFile(`wizard_ask: resolved ${Object.keys(answers).length} answer(s) for ${args.questions.length} question(s)`);
+					const sanitised = vaultSensitiveAnswers(questions, answers, secretVault);
+					const cancelled = describeAskCancellation(sanitised, timedOut);
+					logToFile(`wizard_ask: resolved ${Object.keys(answers).length} answer(s) for ${args.questions.length} question(s)${cancelled ? `, cancelled: ${cancelled.reason}` : ""}`);
 					return { content: [{
 						type: "text",
-						text: JSON.stringify({ answers: sanitised }, null, 2)
+						text: JSON.stringify({
+							answers: sanitised,
+							...cancelled ? { cancelled } : {}
+						}, null, 2)
 					}] };
 				} catch (err) {
 					askAccounting.refund(args.subject);
@@ -2247,9 +2080,8 @@ const GATEWAY_PROVIDER = "posthog-gateway";
 * OpenAI models take the Responses API because OpenAI rejects function tools
 * combined with `reasoning_effort` on chat completions and every task sends both.
 */
-function gatewayApiFor(modelId, legacy) {
-	if (!modelId.startsWith("openai/")) return "anthropic-messages";
-	return legacy ? "openai-completions" : "openai-responses";
+function gatewayApiFor(modelId) {
+	return modelId.startsWith("openai/") ? "openai-responses" : "anthropic-messages";
 }
 /**
 * Gateway HTTP headers, mirroring `buildAgentEnv` on the anthropic path: one
@@ -2257,10 +2089,10 @@ function gatewayApiFor(modelId, legacy) {
 * plus the 1M context beta, since pi otherwise runs at 200k and overflows on
 * larger projects (the post-run compaction failures).
 */
-function buildGatewayHeaders(wizardMetadata, wizardFlags, teamId, legacy) {
+function buildGatewayHeaders(wizardMetadata, wizardFlags, teamId) {
 	return {
 		"anthropic-beta": "context-1m-2025-08-07",
-		...legacy ? legacyGatewayHeaders(wizardMetadata, wizardFlags) : { "X-PostHog-Properties": buildWizardPropertiesBlob(wizardMetadata, wizardFlags, teamId) }
+		"X-PostHog-Properties": buildWizardPropertiesBlob(wizardMetadata, wizardFlags, teamId)
 	};
 }
 /**
@@ -2269,8 +2101,8 @@ function buildGatewayHeaders(wizardMetadata, wizardFlags, teamId, legacy) {
 * callers (scan triage) hand it straight to `completeSimple`.
 */
 function buildGatewayModel(inputs) {
-	const { gatewayUrl, wizardMetadata, wizardFlags, modelId, teamId, legacy } = inputs;
-	const api = gatewayApiFor(modelId, legacy);
+	const { gatewayUrl, wizardMetadata, wizardFlags, modelId, teamId } = inputs;
+	const api = gatewayApiFor(modelId);
 	return {
 		id: modelId,
 		name: `${modelId} (PostHog Gateway)`,
@@ -2287,7 +2119,7 @@ function buildGatewayModel(inputs) {
 		},
 		contextWindow: 1e6,
 		maxTokens: 64e3,
-		headers: buildGatewayHeaders(wizardMetadata, wizardFlags, teamId, legacy)
+		headers: buildGatewayHeaders(wizardMetadata, wizardFlags, teamId)
 	};
 }
 /**
@@ -2295,8 +2127,8 @@ function buildGatewayModel(inputs) {
 * plus the derived traits the session setup needs (`caps.thinkingLevel`).
 */
 function buildGatewayProvider(inputs) {
-	const { gatewayUrl, accessToken, modelId, effort, legacy } = inputs;
-	const api = gatewayApiFor(modelId, legacy);
+	const { gatewayUrl, accessToken, modelId, effort } = inputs;
+	const api = gatewayApiFor(modelId);
 	const tableCaps = modelCapabilities(modelId);
 	const caps = effort && effort !== "off" && tableCaps.reasoning ? modelCapabilities(modelId, effort) : effort === "off" && tableCaps.reasoning ? {
 		...tableCaps,
@@ -2391,7 +2223,6 @@ function createTriageLLMProvider(auth, harness) {
 			gatewayUrl: current.baseURL,
 			accessToken: authToken,
 			teamId: current.teamId,
-			legacy: current.legacy,
 			wizardMetadata: current.wizardMetadata ?? {},
 			wizardFlags: current.wizardFlags ?? {},
 			modelId
@@ -3260,13 +3091,11 @@ function isWarlockDisabled() {
 /**
 * Build ANTHROPIC_CUSTOM_HEADERS for the SDK subprocess: the run's metadata and
 * flags as one `X-PostHog-Properties` JSON blob. Bedrock fallback is native to
-* the gateway, so there is no opt-in header. The CI fallback sends the legacy
-* gateway's shape instead.
+* the gateway, so there is no opt-in header.
 */
-function buildAgentEnv(wizardMetadata, wizardFlags, auth) {
+function buildAgentEnv(wizardMetadata, wizardFlags, teamId) {
 	const headers = createCustomHeaders();
-	const shaped = auth.legacy ? legacyGatewayHeaders(wizardMetadata, wizardFlags) : { "X-PostHog-Properties": buildWizardPropertiesBlob(wizardMetadata, wizardFlags, auth.teamId) };
-	for (const [key, value] of Object.entries(shaped)) headers.add(key, value);
+	headers.add("X-PostHog-Properties", buildWizardPropertiesBlob(wizardMetadata, wizardFlags, teamId));
 	const encoded = headers.encode();
 	logToFile("ANTHROPIC_CUSTOM_HEADERS", encoded);
 	return encoded;
@@ -3376,7 +3205,6 @@ async function initializeAgent(config, options) {
 				baseURL: current.gatewayUrl,
 				authToken: current.token,
 				teamId: current.teamId,
-				legacy: current.legacy,
 				wizardMetadata: triageMetadata,
 				wizardFlags: config.wizardFlags ?? {}
 			};
@@ -3622,7 +3450,7 @@ async function runAgent(agentConfig, prompt, options, spinner, config, middlewar
 						CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: "true",
 						POSTHOG_MCP_TOKEN: agentConfig.posthogApiKey,
 						MCP_CONNECTION_NONBLOCKING: "0",
-						ANTHROPIC_CUSTOM_HEADERS: buildAgentEnv(agentConfig.wizardMetadata ?? {}, agentConfig.wizardFlags ?? {}, agentConfig.gatewayAuth)
+						ANTHROPIC_CUSTOM_HEADERS: buildAgentEnv(agentConfig.wizardMetadata ?? {}, agentConfig.wizardFlags ?? {}, agentConfig.gatewayAuth.teamId)
 					},
 					canUseTool: (toolName, input) => {
 						logToFile("canUseTool called:", {
@@ -4146,6 +3974,6 @@ function handleSDKMessage(message, options, spinner, signals, receivedSuccessRes
 	}
 }
 //#endregion
-export { WIZARD_TOOL_NAMES as A, templateEnvWriteRefusal as B, publishHandoff as C, WIZARD_ASK_SENSITIVE_DESCRIPTION as D, ENV_FILE_PATH_DESCRIPTION as E, installSkillById as F, gatewayAuth as G, fetchWithRetry as H, mergeEnvValues as I, isEnvFileName as J, setLegacyGatewayFallback as K, normaliseAskSubject as L, createAskAccounting as M, downloadSkill as N, WIZARD_ASK_SUBJECT_DESCRIPTION as O, fetchSkillMenu as P, resolveEnvPath as R, PUBLISH_HANDOFF_TOOL_NAME as S, CHECK_ENV_KEYS_FILE_PATH_DESCRIPTION as T, createWizardAskBridge as U, vaultSensitiveAnswers as V, isFullyCancelled as W, toPromptSafeRelativePath as X, parseEnvKeyNames as Y, markGrantRevoked as Z, buildGatewayProvider as _, wizardCanUseTool as a, PUBLISH_HANDOFF_CONTENT_DESCRIPTION as b, checkAllSettingsConflicts as c, restoreClaudeSettings as d, sanitizeAgentSubprocessEnv as f, GATEWAY_PROVIDER as g, createTriageLLMProvider as h, runAgent as i, checkEnvKeys as j, WIZARD_ASK_TOOL_DESCRIPTION as k, classifySettingsConflicts as l, assembleCommandments as m, buildRunTags as n, createIsolatedAgentConfigDir as o, AgentOutputSignals as p, MAX_ENV_KEY_SET as q, initializeAgent as r, backupAndFixClaudeSettings as s, buildAgentEnv as t, recoverOrphanedSettingsBackups as u, withGatewayRemint as v, CHECK_ENV_KEYS_DESCRIPTION as w, PUBLISH_HANDOFF_DESCRIPTION as x, createSecretVault as y, resolveEnvSecretRefs as z };
+export { resolveEnvSecretRefs as $, AUDIT_STATUSES as A, checkEnvKeys as B, publishHandoff as C, AUDIT_RESOLVE_CHECKS_PARAM_DESCRIPTION as D, AUDIT_RESOLVE_CHECKS_DESCRIPTION as E, WIZARD_ASK_SENSITIVE_DESCRIPTION as F, fetchSkillMenu as G, describeAskCancellation as H, WIZARD_ASK_SUBJECT_DESCRIPTION as I, mergeEnvValues as J, installSkillById as K, WIZARD_ASK_TOOL_DESCRIPTION as L, CHECK_ENV_KEYS_FILE_PATH_DESCRIPTION as M, ENV_FILE_PATH_DESCRIPTION as N, AUDIT_SEED_CHECKS_DESCRIPTION as O, WIZARD_ASK_KIND_DESCRIPTION as P, resolveEnvPath as Q, WIZARD_TOOL_NAMES as R, PUBLISH_HANDOFF_TOOL_NAME as S, AUDIT_ADD_CHECKS_PARAM_DESCRIPTION as T, downloadSkill as U, createAskAccounting as V, ensureGitignoreCoverage as W, resolveAskQuestionKinds as X, normaliseAskSubject as Y, resolveAuditChecks as Z, buildGatewayProvider as _, wizardCanUseTool as a, createWizardAskBridge as at, PUBLISH_HANDOFF_CONTENT_DESCRIPTION as b, checkAllSettingsConflicts as c, isEnvFileName as ct, restoreClaudeSettings as d, markGrantRevoked as dt, seedAuditChecks as et, sanitizeAgentSubprocessEnv as f, GATEWAY_PROVIDER as g, createTriageLLMProvider as h, runAgent as i, LONGER_ASK_TIMEOUT_MS as it, CHECK_ENV_KEYS_DESCRIPTION as j, AUDIT_SEED_CHECKS_PARAM_DESCRIPTION as k, classifySettingsConflicts as l, parseEnvKeyNames as lt, assembleCommandments as m, buildRunTags as n, vaultSensitiveAnswers as nt, createIsolatedAgentConfigDir as o, isFullyCancelled as ot, AgentOutputSignals as p, legacyKeyNameRefusal as q, initializeAgent as r, fetchWithRetry as rt, backupAndFixClaudeSettings as s, MAX_ENV_KEY_SET as st, buildAgentEnv as t, templateEnvWriteRefusal as tt, recoverOrphanedSettingsBackups as u, toPromptSafeRelativePath as ut, withGatewayRemint as v, AUDIT_ADD_CHECKS_DESCRIPTION as w, PUBLISH_HANDOFF_DESCRIPTION as x, createSecretVault as y, addAuditChecks as z };
 
-//# sourceMappingURL=agent-interface-lCIi_alS.js.map
+//# sourceMappingURL=agent-interface-CZWRgZMc.js.map