@posthog/wizard 2.73.2 → 2.74.0

package/dist/{agent-interface-Dm28tBj-.js → agent-interface-CK6pmvkF.js}

@@ -1,12 +1,12 @@
 import { n as __require } from "./rolldown-runtime-B_-DWIq7.js";
-import { a as AgentSignals, o as REMARK_INSTRUCTION, s as classifyAuthFailure } from "./errors-u8z27V-x.js";
-import { D as CONTEXT_MILL_URL, St as runtimeEnv, T as AWS_SKILLS_BASE_URL, X as POSTHOG_PROPERTY_HEADER_PREFIX, a as getLogFilePath, f as getUI, ft as WIZARD_REMARK_EVENT_NAME, gt as wizardUserAgentForProgram, o as initLogFile, q as POSTHOG_FLAG_HEADER_PREFIX, r as debug, s as logToFile } from "./debug-BrWB-OAq.js";
+import { c as RESUME_INSTRUCTION, d as ErrorCodes, l as classifyAuthFailure, o as AgentSignals, s as REMARK_INSTRUCTION } from "./errors--OqLxmWR.js";
+import { D as CONTEXT_MILL_URL, T as AWS_SKILLS_BASE_URL, a as getLogFilePath, f as getUI, lt as WIZARD_REMARK_EVENT_NAME, o as initLogFile, pt as wizardUserAgentForProgram, r as debug, s as logToFile, yt as runtimeEnv } from "./debug-ECdmmlDM.js";
 import { n as ADDITIONAL_FEATURE_PROMPTS } from "./wizard-session-GdDN_aMS.js";
-import { n as analytics } from "./analytics-BY4qZ0AC.js";
-import { a as safeReadFile, i as readProjectFile, o as walkProjectFiles } from "./bounded-fs-DIYnGoSv.js";
-import { i as wizardAbort, n as registerCleanup, t as WizardError } from "./wizard-abort-DcuNitMi.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-BKhDtn2N.js";
-import { S as writeJsonAtomic, b as triageModelFor, c as buildOrchestratorTools, v as modelCapabilities, x as makeMutex } from "./queue-tools-CDqueOnz.js";
+import { n as analytics } from "./analytics-DZNb3aRN.js";
+import { a as safeReadFile, i as readProjectFile, o as walkProjectFiles } from "./bounded-fs-CErPpkN2.js";
+import { i as wizardAbort, n as registerCleanup, t as WizardError } from "./wizard-abort-RUnY1Dax.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-jBqAkgxw.js";
+import { S as writeJsonAtomic, b as triageModelFor, c as buildOrchestratorTools, v as modelCapabilities, x as makeMutex } from "./queue-tools-CbRM-OET.js";
 import { createRequire } from "node:module";
 import * as fs$1 from "fs";
 import fs from "fs";
@@ -185,27 +185,53 @@ function createCustomHeaders() {
 				value
 			});
 		},
-		addFlag(flagKey, variant) {
-			const headerName = POSTHOG_FLAG_HEADER_PREFIX + flagKey.toUpperCase();
-			entries.push({
-				key: headerName,
-				value: variant
-			});
-		},
 		encode() {
 			return entries.map(({ key, value }) => `${key}: ${value}`).join("\n");
 		}
 	};
 }
 //#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.
 *
-* A 404 resolves to the legacy posture (OAuth token, Python gateway); every
-* other failure throws, because the legacy path enforces none of those, so a
-* silent downgrade spends unattributed money to hide an outage.
+* 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;
 /**
@@ -214,15 +240,17 @@ let cached = null;
 */
 let inFlight = null;
 /**
-* Adoption floor. The anthropic subprocess holds its credential for the whole
-* session, so a token below this 401s mid-run.
+* 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;
-/** How long a legacy fallback sticks before the mint endpoint is retried. */
-const LEGACY_RETRY_MS = 600 * 1e3;
 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 ?? ""}`;
@@ -244,16 +272,20 @@ async function resolveGatewayAuth(host, accessToken, key, program) {
 		logToFile("[gateway] run has no program id; failing the run");
 		throw new GatewayMintFailed("this run has no program to attribute its spend to");
 	}
-	const minted = await mintGatewayToken(host, accessToken, program);
-	if (!minted) {
-		analytics.setTag("gateway_edition", "legacy");
-		const auth = legacyAuth(host, accessToken);
+	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,
-			staleAtMs: Date.now() + LEGACY_RETRY_MS
+			auth: legacy,
+			staleAtMs: legacy.refreshAtMs
 		};
-		return auth;
+		return legacy;
 	}
 	const expiresAtMs = Date.parse(minted.expiresAt);
 	const ttlMs = expiresAtMs - Date.now();
@@ -262,13 +294,12 @@ async function resolveGatewayAuth(host, accessToken, key, program) {
 		throw new GatewayMintFailed(`the PostHog gateway issued a token with ${ttlMs}ms of life`);
 	}
 	const staleAtMs = Date.now() + ttlMs * REFRESH_AT_FRACTION;
-	analytics.setTag("gateway_edition", "v2");
 	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,
-		edition: "v2",
-		teamId: minted.teamId
+		teamId: minted.teamId,
+		refreshAtMs: staleAtMs
 	};
 	cached = {
 		key,
@@ -277,13 +308,9 @@ async function resolveGatewayAuth(host, accessToken, key, program) {
 	};
 	return auth;
 }
-/** The legacy posture: the user's OAuth token against the Python gateway. */
-function legacyAuth(host, accessToken) {
-	return {
-		gatewayUrl: host.gatewayUrl,
-		token: accessToken,
-		edition: "legacy"
-	};
+/** 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:
@@ -309,41 +336,75 @@ function isTrustedGatewayUrl(value, apiHost) {
 }
 /**
 * A deliberate refusal from the mint endpoint, as opposed to the mint being
-* unavailable. Thrown rather than folded into the legacy fallback, so the run
-* stops instead of proceeding without the controls the refusal was enforcing.
+* 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 Error {
+var GatewayMintRefused = class extends WizardError {
 	status;
-	constructor(status, message) {
-		super(message);
+	/** 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 Error {
+var GatewayMintFailed = class extends WizardError {
 	constructor(message) {
-		super(message);
+		super(message, void 0, ErrorCodes.GatewayMintFailed);
 		this.name = "GatewayMintFailed";
 	}
 };
 /**
 * Whether a mint status means "refused this run" rather than "not available".
-* These are the statuses the endpoint returns after it has authenticated the
-* caller: 429 the daily run limit, 403 revoked project access, 400 a login
-* covering more than one project. 404 and 401 fall back instead.
+* 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 === 403 || status === 429;
+	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) {
+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.";
 	}
 }
@@ -355,17 +416,22 @@ async function mintGatewayToken(host, accessToken, program) {
 				Authorization: `Bearer ${accessToken}`,
 				"Content-Type": "application/json"
 			},
-			body: JSON.stringify({ program }),
+			body: JSON.stringify({
+				program,
+				reads_refusal_reason: true
+			}),
 			signal: AbortSignal.timeout(MINT_TIMEOUT_MS)
 		});
 		if (!resp.ok) {
 			if (isMintRefusal(resp.status)) {
-				logToFile(`[gateway] mint refused with HTTP ${resp.status}; failing the run`);
-				throw new GatewayMintRefused(resp.status, mintRefusalMessage(resp.status));
-			}
-			if (resp.status === 404 || resp.status === 401) {
-				logToFile(`[gateway] mint unavailable for this credential (HTTP ${resp.status}); staying on the existing gateway`);
-				return null;
+				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})`);
@@ -2162,11 +2228,11 @@ async function createWizardToolsServer(options) {
 //#endregion
 //#region src/lib/agent/runner/harness/pi/gateway.ts
 /**
-* PostHog LLM gateway provider spec for pi sessions — shared by the linear run
+* PostHog AI gateway provider spec for pi sessions, shared by the linear run
 * and the orchestrator's per-task runs so both speak to the gateway
-* identically: bearer auth, Bedrock-fallback + wizard metadata/flag headers,
-* transport shape inferred from the model id. The caller registers the spec on
-* its own (lazily imported, properly typed) pi ModelRegistry.
+* identically: bearer auth, the wizard properties header, transport shape
+* inferred from the model id. The caller registers the spec on its own
+* (lazily imported, properly typed) pi ModelRegistry.
 */
 /** Provider registered on the in-memory registry for this run. */
 const GATEWAY_PROVIDER = "posthog-gateway";
@@ -2177,38 +2243,24 @@ const GATEWAY_PROVIDER = "posthog-gateway";
 * `/v1/responses` or `/v1/chat/completions` (base URL keeps `/v1`). Infer the
 * shape from the model id so a pair's model selects the right transport.
 *
-* v2 takes the Responses API because OpenAI rejects function tools combined
-* with `reasoning_effort` on chat completions and every task sends both. Legacy
-* stays on chat completions, where litellm does that routing itself.
+* 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, edition = "legacy") {
+function gatewayApiFor(modelId, legacy) {
 	if (!modelId.startsWith("openai/")) return "anthropic-messages";
-	return edition === "v2" ? "openai-responses" : "openai-completions";
+	return legacy ? "openai-completions" : "openai-responses";
 }
 /**
-* Gateway HTTP headers, mirroring `buildAgentEnv` on the anthropic path. The
-* shape follows the gateway edition: legacy sends per-key metadata/flag
-* headers plus the explicit Bedrock-fallback opt-in; v2 (the Go ai-gateway)
-* takes one `X-PostHog-Properties` JSON blob and falls back natively. The 1M
-* context beta rides both, since pi otherwise runs at 200k and overflows on larger
-* projects (the post-run compaction failures).
+* Gateway HTTP headers, mirroring `buildAgentEnv` on the anthropic path: one
+* `X-PostHog-Properties` JSON blob (Bedrock fallback is native, so no opt-in)
+* 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, edition = "legacy", teamId) {
-	const headers = { "anthropic-beta": "context-1m-2025-08-07" };
-	if (edition === "v2") {
-		headers["X-PostHog-Properties"] = buildWizardPropertiesBlob(wizardMetadata, wizardFlags, teamId);
-		return headers;
-	}
-	headers["x-posthog-use-bedrock-fallback"] = "true";
-	for (const [key, value] of Object.entries(wizardMetadata)) {
-		const name = key.startsWith("X-POSTHOG-PROPERTY-") ? key : `${POSTHOG_PROPERTY_HEADER_PREFIX}${key}`;
-		headers[name] = value;
-	}
-	for (const [flagKey, variant] of Object.entries(wizardFlags)) {
-		if (!flagKey.toLowerCase().startsWith("wizard")) continue;
-		headers[POSTHOG_FLAG_HEADER_PREFIX + flagKey.toUpperCase()] = variant;
-	}
-	return headers;
+function buildGatewayHeaders(wizardMetadata, wizardFlags, teamId, legacy) {
+	return {
+		"anthropic-beta": "context-1m-2025-08-07",
+		...legacy ? legacyGatewayHeaders(wizardMetadata, wizardFlags) : { "X-PostHog-Properties": buildWizardPropertiesBlob(wizardMetadata, wizardFlags, teamId) }
+	};
 }
 /**
 * One gateway model spec — the single description of how to reach a model on
@@ -2216,8 +2268,8 @@ function buildGatewayHeaders(wizardMetadata, wizardFlags, edition = "legacy", te
 * callers (scan triage) hand it straight to `completeSimple`.
 */
 function buildGatewayModel(inputs) {
-	const { gatewayUrl, wizardMetadata, wizardFlags, modelId, edition, teamId } = inputs;
-	const api = gatewayApiFor(modelId, edition);
+	const { gatewayUrl, wizardMetadata, wizardFlags, modelId, teamId, legacy } = inputs;
+	const api = gatewayApiFor(modelId, legacy);
 	return {
 		id: modelId,
 		name: `${modelId} (PostHog Gateway)`,
@@ -2234,7 +2286,7 @@ function buildGatewayModel(inputs) {
 		},
 		contextWindow: 1e6,
 		maxTokens: 64e3,
-		headers: buildGatewayHeaders(wizardMetadata, wizardFlags, edition, teamId)
+		headers: buildGatewayHeaders(wizardMetadata, wizardFlags, teamId, legacy)
 	};
 }
 /**
@@ -2242,8 +2294,8 @@ function buildGatewayModel(inputs) {
 * plus the derived traits the session setup needs (`caps.thinkingLevel`).
 */
 function buildGatewayProvider(inputs) {
-	const { gatewayUrl, accessToken, modelId, effort, edition } = inputs;
-	const api = gatewayApiFor(modelId, edition);
+	const { gatewayUrl, accessToken, modelId, effort, legacy } = inputs;
+	const api = gatewayApiFor(modelId, legacy);
 	const tableCaps = modelCapabilities(modelId);
 	const caps = effort && effort !== "off" && tableCaps.reasoning ? modelCapabilities(modelId, effort) : effort === "off" && tableCaps.reasoning ? {
 		...tableCaps,
@@ -2266,6 +2318,53 @@ function buildGatewayProvider(inputs) {
 		baseUrl: model.baseUrl
 	};
 }
+/**
+* Whether a turn's error is the gateway rejecting the bearer. pi attaches the
+* SDK's own error to `diagnostics`, so its code decides when one is present.
+* The message match is the fallback for a turn that failed before pi built a
+* diagnostic, where the status survives only as prose.
+*/
+function isGatewayAuthRejection(turn) {
+	const { errorMessage, diagnostics } = typeof turn === "string" ? {
+		errorMessage: turn,
+		diagnostics: void 0
+	} : turn ?? {};
+	for (const diagnostic of diagnostics ?? []) {
+		const code = diagnostic.error?.code;
+		if (code === 401 || code === "401") return true;
+		if (/^authentication_?error$/i.test(diagnostic.error?.name ?? "")) return true;
+	}
+	return /\b401\b|authentication_error|unauthorized/i.test(errorMessage ?? "");
+}
+/**
+* Wraps a pi session's prompt(): when a turn ends on a 401 from a bearer past
+* its refresh instant, mint once, re-register the provider with the new
+* bearer (pi resolves the apiKey per request), and continue. A 401 on a fresh
+* bearer, or a second one, is left to the harness's normal failure path.
+*/
+function withGatewayRemint(opts) {
+	let auth = opts.auth;
+	let rejected = false;
+	let reminted = false;
+	return {
+		noteAssistantTurn(message) {
+			const turn = message;
+			rejected = turn?.stopReason === "error" && isGatewayAuthRejection(turn);
+		},
+		async prompt(text) {
+			rejected = false;
+			await opts.session.prompt(text);
+			if (!rejected || reminted || !isPastRefresh(auth)) return;
+			reminted = true;
+			auth = await opts.refreshAuth();
+			opts.registry.registerProvider(GATEWAY_PROVIDER, buildGatewayProvider(opts.providerInputs(auth)).provider);
+			opts.onRemint?.();
+			rejected = false;
+			const next = opts.continueText;
+			await opts.session.prompt(typeof next === "function" ? next() : next);
+		}
+	};
+}
 //#endregion
 //#region src/lib/agent/triage-provider.ts
 const TRIAGE_MAX_TOKENS = 16384;
@@ -2274,24 +2373,28 @@ const TRIAGE_TIMEOUT_MS = 2e4;
 * Triage provider for a harness. Auth is always explicit: every caller already
 * holds the gateway url and the run's token, and reading them back out of
 * ANTHROPIC_* made an unauthed provider silent — it returned undefined, the
-* caller failed closed, and a clean first-party skill got deleted.
+* caller failed closed, and a clean first-party skill got deleted. A resolver
+* is re-read on every call, so a run that re-mints mid-way scans with the
+* current bearer rather than the one it started with.
 */
 function createTriageLLMProvider(auth, harness) {
-	const { baseURL, authToken } = auth;
+	const resolveAuth = typeof auth === "function" ? auth : () => Promise.resolve(auth);
 	const modelId = triageModelFor(harness);
-	const model = buildGatewayModel({
-		gatewayUrl: baseURL,
-		accessToken: authToken,
-		edition: auth.edition,
-		teamId: auth.teamId,
-		wizardMetadata: auth?.wizardMetadata ?? {},
-		wizardFlags: auth?.wizardFlags ?? {},
-		modelId
-	});
 	const { reasoning, thinkingLevel } = modelCapabilities(modelId);
-	logToFile(`[YARA] triage provider ready (model: ${modelId}, api: ${model.api})`);
+	logToFile(`[YARA] triage provider ready (model: ${modelId}, api: ${gatewayApiFor(modelId)})`);
 	return async (prompt) => {
 		const { completeSimple } = await import("@earendil-works/pi-ai");
+		const current = await resolveAuth();
+		const authToken = current.authToken;
+		const model = buildGatewayModel({
+			gatewayUrl: current.baseURL,
+			accessToken: authToken,
+			teamId: current.teamId,
+			legacy: current.legacy,
+			wizardMetadata: current.wizardMetadata ?? {},
+			wizardFlags: current.wizardFlags ?? {},
+			modelId
+		});
 		const controller = new AbortController();
 		const timer = setTimeout(() => controller.abort(), TRIAGE_TIMEOUT_MS);
 		try {
@@ -2503,6 +2606,15 @@ var AgentOutputSignals = class {
 		if (SIGNAL_NEEDLES.some((n) => text.includes(n))) this.lines.push(text);
 	}
 	/**
+	* Drop the retained API-error lines and keep every other signal. Used after
+	* a re-mint so the run is judged on the resumed session, not on the 401
+	* that ended the first one.
+	*/
+	forgetApiErrors() {
+		const kept = this.lines.filter((line) => !line.includes(OUTPUT_SIGNALS.API_ERROR));
+		this.lines.splice(0, this.lines.length, ...kept);
+	}
+	/**
 	* Record the SDK's `apiKeySource` from its `init` message (e.g.
 	* `"/login managed key"`, `"ANTHROPIC_API_KEY"`). Used to triage a 401:
 	* a managed-login source means the SDK authenticated with a stored Claude
@@ -3118,10 +3230,10 @@ function createStopHook(featureQueue, signals, requestRemark = true) {
 }
 /**
 * Global identifiers attached to every LLM gateway trace for a run. They ride on
-* each `$ai_generation` the gateway emits (as `X-POSTHOG-PROPERTY-*` headers via
-* `buildAgentEnv`), so traces are filterable by program, framework, run, and build
-* type for cost attribution and dashboards. `skill_id` is omitted when the run has
-* none.
+* each `$ai_generation` the gateway emits (in the `X-PostHog-Properties` blob
+* `buildAgentEnv` builds), so traces are filterable by program, framework, run,
+* and build type for cost attribution and dashboards. `skill_id` is omitted when
+* the run has none.
 */
 function buildRunTags(args) {
 	return {
@@ -3145,24 +3257,15 @@ function isWarlockDisabled() {
 	return runtimeEnv("POSTHOG_WIZARD_WARLOCK_DISABLED") === "true";
 }
 /**
-* Build env for the SDK subprocess: process.env plus ANTHROPIC_CUSTOM_HEADERS.
-* The header shape follows the gateway edition. Legacy (Python gateway):
-* per-key `X-POSTHOG-PROPERTY-*`/`X-POSTHOG-FLAG-*` plus the explicit
-* `x-posthog-use-bedrock-fallback` opt-in. v2 (Go ai-gateway): one
-* `X-PostHog-Properties` JSON blob. Bedrock fallback is native there, and
-* per-key metadata headers are not read.
+* 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.
 */
 function buildAgentEnv(wizardMetadata, wizardFlags, auth) {
 	const headers = createCustomHeaders();
-	if (auth?.edition === "v2") headers.add("X-PostHog-Properties", buildWizardPropertiesBlob(wizardMetadata, wizardFlags, auth.teamId));
-	else {
-		headers.add("x-posthog-use-bedrock-fallback", "true");
-		for (const [key, value] of Object.entries(wizardMetadata)) headers.add(key.startsWith("X-POSTHOG-PROPERTY-") ? key : `${POSTHOG_PROPERTY_HEADER_PREFIX}${key}`, value);
-		for (const [flagKey, variant] of Object.entries(wizardFlags)) {
-			if (!flagKey.toLowerCase().startsWith("wizard")) continue;
-			headers.addFlag(flagKey, variant);
-		}
-	}
+	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);
 	const encoded = headers.encode();
 	logToFile("ANTHROPIC_CUSTOM_HEADERS", encoded);
 	return encoded;
@@ -3256,22 +3359,26 @@ async function initializeAgent(config, options) {
 	logToFile("Install directory:", options.installDir);
 	try {
 		process.env.CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS = "true";
-		const auth = await gatewayAuth(config.host, config.posthogApiKey, config.programId);
+		const currentGatewayAuth = () => gatewayAuth(config.host, config.posthogApiKey, config.programId);
+		const auth = await currentGatewayAuth();
 		const gatewayUrl = auth.gatewayUrl;
 		process.env.ANTHROPIC_BASE_URL = gatewayUrl;
 		process.env.ANTHROPIC_AUTH_TOKEN = auth.token;
 		process.env.CLAUDE_CODE_OAUTH_TOKEN = auth.token;
-		logToFile("Gateway edition:", auth.edition);
-		const triageProvider = createTriageLLMProvider({
-			baseURL: gatewayUrl,
-			authToken: auth.token,
-			edition: auth.edition,
-			teamId: auth.teamId,
-			wizardMetadata: {
-				...config.wizardMetadata ?? {},
-				call_type: "yara-triage"
-			},
-			wizardFlags: config.wizardFlags ?? {}
+		const triageMetadata = {
+			...config.wizardMetadata ?? {},
+			call_type: "yara-triage"
+		};
+		const triageProvider = createTriageLLMProvider(async () => {
+			const current = await currentGatewayAuth();
+			return {
+				baseURL: current.gatewayUrl,
+				authToken: current.token,
+				teamId: current.teamId,
+				legacy: current.legacy,
+				wizardMetadata: triageMetadata,
+				wizardFlags: config.wizardFlags ?? {}
+			};
 		}, "anthropic");
 		logToFile("Configured LLM gateway:", gatewayUrl);
 		logToFile("API key prefix:", config.posthogApiKey ? `${config.posthogApiKey.slice(0, 4)}***` : "(missing)");
@@ -3309,7 +3416,7 @@ async function initializeAgent(config, options) {
 			orchestrator: config.orchestrator,
 			triageProvider
 		});
-		const model = config.modelOverride ?? "claude-sonnet-4-6";
+		const model = config.modelOverride ?? "claude-sonnet-5";
 		const agentRunConfig = {
 			workingDirectory: config.workingDirectory,
 			mcpServers,
@@ -3324,6 +3431,7 @@ async function initializeAgent(config, options) {
 			capture: config.capture,
 			triageProvider,
 			gatewayAuth: auth,
+			refreshGatewayAuth: currentGatewayAuth,
 			program: config.integrationLabel,
 			sequence: config.orchestrator ? "orchestrator" : "linear"
 		};
@@ -3369,21 +3477,23 @@ async function runAgent(agentConfig, prompt, options, spinner, config, middlewar
 	let loggedInitialContext = false;
 	let lastResultMessage = null;
 	const tasks = /* @__PURE__ */ new Map();
-	let signalDone;
-	const resultReceived = new Promise((resolve) => {
-		signalDone = resolve;
-	});
-	const createPromptStream = async function* () {
-		yield {
-			type: "user",
-			session_id: "",
-			message: {
-				role: "user",
-				content: prompt
-			},
-			parent_tool_use_id: null
-		};
-		await resultReceived;
+	let signalDone = () => void 0;
+	const createPromptStream = (text) => {
+		const resultReceived = new Promise((resolve) => {
+			signalDone = resolve;
+		});
+		return (async function* () {
+			yield {
+				type: "user",
+				session_id: "",
+				message: {
+					role: "user",
+					content: text
+				},
+				parent_tool_use_id: null
+			};
+			await resultReceived;
+		})();
 	};
 	const completeWithSuccess = (suppressedError) => {
 		const durationMs = Date.now() - startTime;
@@ -3419,9 +3529,13 @@ async function runAgent(agentConfig, prompt, options, spinner, config, middlewar
 		spinner.stop(successMessage);
 		return {};
 	};
-	const abortController = new AbortController();
+	let abortController = new AbortController();
 	let abortReason = null;
 	let yaraViolationReason = null;
+	let sessionId;
+	let reminted = false;
+	let remintRequested = false;
+	const agentConfigDir = createIsolatedAgentConfigDir();
 	try {
 		const disallow = new Set(agentConfig.disallowedTools ?? []);
 		const allowedTools = [...BASE_ALLOWED_TOOLS, ...agentConfig.allowedTools ?? []].filter((t) => !disallow.has(t));
@@ -3440,197 +3554,228 @@ async function runAgent(agentConfig, prompt, options, spinner, config, middlewar
 			analytics.wizardCapture("warlock disabled", { reason: "env-override" });
 		}
 		agentConfig.capture?.setInitialPrompt(prompt);
-		const response = query({
-			prompt: createPromptStream(),
-			options: {
-				abortController,
-				model: agentConfig.model,
-				cwd: agentConfig.workingDirectory,
-				permissionMode: "acceptEdits",
-				betas: ["context-1m-2025-08-07"],
-				mcpServers: agentConfig.mcpServers,
-				agents: { "general-purpose": {
-					description: "General-purpose subagent. Inherits the parent run's tools plus the PostHog and wizard-tools MCP servers, so it can call mcp__posthog-wizard__* directly instead of curling the REST API.",
-					prompt: "You are a general-purpose subagent for the PostHog wizard. Prefer the authenticated mcp__posthog-wizard__* MCP tools over raw HTTP — they are already authenticated for this project. Only fall back to other transports if no MCP tool covers the operation.",
-					mcpServers: inheritedMcpServerNames,
-					disallowedTools: agentConfig.disallowedTools ? [...agentConfig.disallowedTools] : void 0
-				} },
-				settingSources: ["project"],
-				skills: "all",
-				allowedTools,
-				sandbox: {
-					enabled: true,
-					failIfUnavailable: false,
-					allowUnsandboxedCommands: false,
-					filesystem: { allowWrite: [
-						"/" + agentConfig.workingDirectory,
-						"/" + agentConfig.workingDirectory + "/**",
-						"//tmp",
-						"//tmp/**",
-						"//private/tmp",
-						"//private/tmp/**",
-						"~/Library/pnpm/**",
-						"~/.local/share/pnpm/**",
-						"~/.pnpm-store/**",
-						"~/.npm/**",
-						"~/.yarn/**",
-						"~/.bun/install/**",
-						"~/.cache/node/corepack/**",
-						"~/Library/Caches/node/corepack/**",
-						"~/.volta/**",
-						"~/.cache/pip/**",
-						"~/Library/Caches/pip/**",
-						"~/.cache/uv/**",
-						"~/Library/Caches/uv/**",
-						"~/.cache/pypoetry/**",
-						"~/Library/Caches/pypoetry/**",
-						"~/.bundle/**",
-						"~/.gem/**"
-					] },
-					network: { allowedDomains: [
-						"github.com",
-						"api.github.com",
-						"raw.githubusercontent.com",
-						"release-assets.githubusercontent.com",
-						"objects.githubusercontent.com"
-					] }
-				},
-				env: {
-					...sanitizeAgentSubprocessEnv(process.env),
-					ANTHROPIC_BASE_URL: agentConfig.gatewayAuth.gatewayUrl,
-					ANTHROPIC_AUTH_TOKEN: agentConfig.gatewayAuth.token,
-					CLAUDE_CODE_OAUTH_TOKEN: agentConfig.gatewayAuth.token,
-					CLAUDE_CONFIG_DIR: createIsolatedAgentConfigDir(),
-					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)
-				},
-				canUseTool: (toolName, input) => {
-					logToFile("canUseTool called:", {
-						toolName,
-						input
-					});
-					const result = wizardCanUseTool(toolName, input, {
-						wizardAskPending: agentConfig.getPendingQuestion?.() != null,
-						disallowedTools: agentConfig.disallowedTools
-					});
-					logToFile("canUseTool result:", result);
-					return Promise.resolve(result);
-				},
-				systemPrompt: {
-					type: "preset",
-					preset: "claude_code",
-					append: assembleCommandments({
-						program: agentConfig.program,
-						sequence: agentConfig.sequence,
-						harness: "anthropic"
-					})
-				},
-				tools: {
-					type: "preset",
-					preset: "claude_code"
-				},
-				stderr: (data) => {
-					logToFile("CLI stderr:", data);
-					if (options.debug) debug("CLI stderr:", data);
-				},
-				hooks: {
-					PreToolUse: warlockDisabled ? [] : createPreToolUseYaraHooks(triageProvider, onYaraTerminate),
-					PostToolUse: warlockDisabled ? [] : createPostToolUseYaraHooks(triageProvider, onYaraTerminate),
-					Stop: [{
-						hooks: [createStopHook(config?.additionalFeatureQueue ?? [], signals, config?.requestRemark ?? true)],
-						timeout: 30
-					}]
-				}
-			}
-		});
-		for await (const message of response) {
-			if (!loggedInitialContext && message.type === "assistant") {
-				const usage = message.message?.usage;
-				if (usage) {
-					const input = usage.input_tokens ?? 0;
-					const cacheCreation = usage.cache_creation_input_tokens ?? 0;
-					const cacheRead = usage.cache_read_input_tokens ?? 0;
-					const initialTokens = input + cacheCreation + cacheRead;
-					logToFile(`Initial context: ${initialTokens} tokens (input=${input}, cache_creation=${cacheCreation}, cache_read=${cacheRead})`);
-					analytics.wizardCapture("agent initial context", {
-						initial_tokens: initialTokens,
-						input_tokens: input,
-						cache_creation_input_tokens: cacheCreation,
-						cache_read_input_tokens: cacheRead
-					});
+		const runQuery = async (resume) => {
+			const response = query({
+				prompt: createPromptStream(resume ? RESUME_INSTRUCTION : prompt),
+				options: {
+					abortController,
+					resume,
+					model: agentConfig.model,
+					cwd: agentConfig.workingDirectory,
+					permissionMode: "acceptEdits",
+					betas: ["context-1m-2025-08-07"],
+					mcpServers: agentConfig.mcpServers,
+					agents: { "general-purpose": {
+						description: "General-purpose subagent. Inherits the parent run's tools plus the PostHog and wizard-tools MCP servers, so it can call mcp__posthog-wizard__* directly instead of curling the REST API.",
+						prompt: "You are a general-purpose subagent for the PostHog wizard. Prefer the authenticated mcp__posthog-wizard__* MCP tools over raw HTTP — they are already authenticated for this project. Only fall back to other transports if no MCP tool covers the operation.",
+						mcpServers: inheritedMcpServerNames,
+						disallowedTools: agentConfig.disallowedTools ? [...agentConfig.disallowedTools] : void 0
+					} },
+					settingSources: ["project"],
+					skills: "all",
+					allowedTools,
+					sandbox: {
+						enabled: true,
+						failIfUnavailable: false,
+						allowUnsandboxedCommands: false,
+						filesystem: { allowWrite: [
+							"/" + agentConfig.workingDirectory,
+							"/" + agentConfig.workingDirectory + "/**",
+							"//tmp",
+							"//tmp/**",
+							"//private/tmp",
+							"//private/tmp/**",
+							"~/Library/pnpm/**",
+							"~/.local/share/pnpm/**",
+							"~/.pnpm-store/**",
+							"~/.npm/**",
+							"~/.yarn/**",
+							"~/.bun/install/**",
+							"~/.cache/node/corepack/**",
+							"~/Library/Caches/node/corepack/**",
+							"~/.volta/**",
+							"~/.cache/pip/**",
+							"~/Library/Caches/pip/**",
+							"~/.cache/uv/**",
+							"~/Library/Caches/uv/**",
+							"~/.cache/pypoetry/**",
+							"~/Library/Caches/pypoetry/**",
+							"~/.bundle/**",
+							"~/.gem/**"
+						] },
+						network: { allowedDomains: [
+							"github.com",
+							"api.github.com",
+							"raw.githubusercontent.com",
+							"release-assets.githubusercontent.com",
+							"objects.githubusercontent.com",
+							new URL(AWS_SKILLS_BASE_URL).hostname
+						] }
+					},
+					env: {
+						...sanitizeAgentSubprocessEnv(process.env),
+						ANTHROPIC_BASE_URL: agentConfig.gatewayAuth.gatewayUrl,
+						ANTHROPIC_AUTH_TOKEN: agentConfig.gatewayAuth.token,
+						CLAUDE_CODE_OAUTH_TOKEN: agentConfig.gatewayAuth.token,
+						CLAUDE_CONFIG_DIR: agentConfigDir,
+						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)
+					},
+					canUseTool: (toolName, input) => {
+						logToFile("canUseTool called:", {
+							toolName,
+							input
+						});
+						const result = wizardCanUseTool(toolName, input, {
+							wizardAskPending: agentConfig.getPendingQuestion?.() != null,
+							disallowedTools: agentConfig.disallowedTools
+						});
+						logToFile("canUseTool result:", result);
+						return Promise.resolve(result);
+					},
+					systemPrompt: {
+						type: "preset",
+						preset: "claude_code",
+						append: assembleCommandments({
+							program: agentConfig.program,
+							sequence: agentConfig.sequence,
+							harness: "anthropic"
+						})
+					},
+					tools: {
+						type: "preset",
+						preset: "claude_code"
+					},
+					stderr: (data) => {
+						logToFile("CLI stderr:", data);
+						if (options.debug) debug("CLI stderr:", data);
+					},
+					hooks: {
+						PreToolUse: warlockDisabled ? [] : createPreToolUseYaraHooks(triageProvider, onYaraTerminate),
+						PostToolUse: warlockDisabled ? [] : createPostToolUseYaraHooks(triageProvider, onYaraTerminate),
+						Stop: [{
+							hooks: [createStopHook(config?.additionalFeatureQueue ?? [], signals, config?.requestRemark ?? true)],
+							timeout: 30
+						}]
+					}
 				}
-				loggedInitialContext = true;
-			}
-			agentConfig.capture?.captureFromAnthropicSDKMessage(message);
-			handleSDKMessage(message, options, spinner, signals, receivedSuccessResult, tasks, agentConfig.suppressTaskRender ?? false, emitStepEvents, resolveStepKey);
-			if (abortCases.length > 0 && !abortReason && message.type === "assistant") {
-				const content = message.message?.content;
-				if (Array.isArray(content)) {
-					for (const block of content) if (block.type === "text" && typeof block.text === "string") {
-						const match = block.text.match(/\[ABORT\]\s*(.+?)(?:\n|$)/);
-						if (match) {
-							abortReason = match[1].trim();
-							logToFile(`Agent emitted [ABORT]: ${abortReason}`);
+			});
+			try {
+				for await (const message of response) {
+					if (typeof message.session_id === "string" && message.session_id) sessionId = message.session_id;
+					if (!loggedInitialContext && message.type === "assistant") {
+						const usage = message.message?.usage;
+						if (usage) {
+							const input = usage.input_tokens ?? 0;
+							const cacheCreation = usage.cache_creation_input_tokens ?? 0;
+							const cacheRead = usage.cache_read_input_tokens ?? 0;
+							const initialTokens = input + cacheCreation + cacheRead;
+							logToFile(`Initial context: ${initialTokens} tokens (input=${input}, cache_creation=${cacheCreation}, cache_read=${cacheRead})`);
+							analytics.wizardCapture("agent initial context", {
+								initial_tokens: initialTokens,
+								input_tokens: input,
+								cache_creation_input_tokens: cacheCreation,
+								cache_read_input_tokens: cacheRead
+							});
+						}
+						loggedInitialContext = true;
+					}
+					agentConfig.capture?.captureFromAnthropicSDKMessage(message);
+					handleSDKMessage(message, options, spinner, signals, receivedSuccessResult, tasks, agentConfig.suppressTaskRender ?? false, emitStepEvents, resolveStepKey);
+					if (abortCases.length > 0 && !abortReason && message.type === "assistant") {
+						const content = message.message?.content;
+						if (Array.isArray(content)) {
+							for (const block of content) if (block.type === "text" && typeof block.text === "string") {
+								const match = block.text.match(/\[ABORT\]\s*(.+?)(?:\n|$)/);
+								if (match) {
+									abortReason = match[1].trim();
+									logToFile(`Agent emitted [ABORT]: ${abortReason}`);
+									abortController.abort();
+									signalDone();
+									break;
+								}
+							}
+						}
+					}
+					if (message.type === "assistant" && signals.hasApiErrorStatus(401)) {
+						signalDone();
+						if (agentConfig.refreshGatewayAuth && !reminted && isPastRefresh(agentConfig.gatewayAuth)) {
+							logToFile("Agent error: 401 on an aged gateway bearer; re-minting");
+							remintRequested = true;
 							abortController.abort();
-							signalDone();
 							break;
 						}
+						spinner.stop("Authentication failed");
+						const authError = buildAuthErrorContext(options.installDir, agentConfig.gatewayAuth.gatewayUrl, os.homedir(), signals.apiKeySource);
+						const sessionExpired = isGrantRevoked();
+						const authCode = classifyAuthFailure({
+							hasSettingsConflict: authError.hasSettingsConflict,
+							usingManagedLogin: authError.usingManagedLogin,
+							sessionExpired,
+							apiKey: options.apiKey,
+							gatewayRegion: authError.region,
+							sessionRegion: options.cloudRegion
+						});
+						logToFile("Agent error: 401, showing auth error screen", {
+							...authError,
+							sessionExpired
+						});
+						getUI().showAuthError({
+							hasSettingsConflict: authError.hasSettingsConflict,
+							conflicts: authError.conflicts,
+							usingManagedLogin: authError.usingManagedLogin,
+							credentialPlaces: authError.credentialPlaces,
+							sessionExpired,
+							logFilePath: getLogFilePath()
+						});
+						await wizardAbort({
+							code: authCode,
+							message: "Authentication failed (401)",
+							error: new WizardError("Authentication failed", {
+								hasSettingsConflict: authError.hasSettingsConflict,
+								conflictSources: authError.conflictSources,
+								conflictKeys: authError.conflictKeys,
+								gatewayUrl: authError.gatewayUrl,
+								region: authError.region,
+								usingManagedLogin: authError.usingManagedLogin,
+								apiKeySource: authError.apiKeySource
+							}, authCode)
+						});
+					}
+					try {
+						middleware?.onMessage(message);
+					} catch (e) {
+						logToFile(`${AgentSignals.BENCHMARK} Middleware onMessage error:`, e);
+					}
+					if (message.type === "result") {
+						if (message.subtype === "success" && !message.is_error) {
+							receivedSuccessResult = true;
+							lastResultMessage = message;
+						}
+						signalDone();
 					}
 				}
+			} catch (error) {
+				if (remintRequested) return "remint";
+				throw error;
 			}
-			if (message.type === "assistant" && signals.hasApiErrorStatus(401)) {
-				signalDone();
-				spinner.stop("Authentication failed");
-				const authError = buildAuthErrorContext(options.installDir, agentConfig.gatewayAuth.gatewayUrl, os.homedir(), signals.apiKeySource);
-				const sessionExpired = isGrantRevoked();
-				const authCode = classifyAuthFailure({
-					hasSettingsConflict: authError.hasSettingsConflict,
-					usingManagedLogin: authError.usingManagedLogin,
-					sessionExpired,
-					apiKey: options.apiKey,
-					gatewayRegion: authError.region,
-					sessionRegion: options.cloudRegion
-				});
-				logToFile("Agent error: 401, showing auth error screen", {
-					...authError,
-					sessionExpired
-				});
-				getUI().showAuthError({
-					hasSettingsConflict: authError.hasSettingsConflict,
-					conflicts: authError.conflicts,
-					usingManagedLogin: authError.usingManagedLogin,
-					credentialPlaces: authError.credentialPlaces,
-					sessionExpired,
-					logFilePath: getLogFilePath()
-				});
-				await wizardAbort({
-					code: authCode,
-					message: "Authentication failed (401)",
-					error: new WizardError("Authentication failed", {
-						hasSettingsConflict: authError.hasSettingsConflict,
-						conflictSources: authError.conflictSources,
-						conflictKeys: authError.conflictKeys,
-						gatewayUrl: authError.gatewayUrl,
-						region: authError.region,
-						usingManagedLogin: authError.usingManagedLogin,
-						apiKeySource: authError.apiKeySource
-					}, authCode)
-				});
-			}
-			try {
-				middleware?.onMessage(message);
-			} catch (e) {
-				logToFile(`${AgentSignals.BENCHMARK} Middleware onMessage error:`, e);
-			}
-			if (message.type === "result") {
-				if (message.subtype === "success" && !message.is_error) {
-					receivedSuccessResult = true;
-					lastResultMessage = message;
-				}
-				signalDone();
-			}
+			return remintRequested ? "remint" : "done";
+		};
+		const refreshGatewayAuth = agentConfig.refreshGatewayAuth;
+		if (await runQuery() === "remint" && refreshGatewayAuth) {
+			reminted = true;
+			remintRequested = false;
+			abortController = new AbortController();
+			signals.forgetApiErrors();
+			spinner.message("Renewing the gateway token...");
+			const stale = agentConfig.gatewayAuth;
+			agentConfig.gatewayAuth = await refreshGatewayAuth();
+			logToFile(`Gateway token renewed after a 401 (${Math.round((Date.now() - stale.refreshAtMs) / 1e3)}s past refresh); resuming session ${sessionId ?? "(none: fresh session)"}`);
+			analytics.wizardCapture("gateway token reminted", { resumed: sessionId !== void 0 });
+			spinner.message(spinnerMessage);
+			await runQuery(sessionId);
 		}
 		if (yaraViolationReason) {
 			logToFile("Agent error: YARA_VIOLATION");
@@ -4000,6 +4145,6 @@ function handleSDKMessage(message, options, spinner, signals, receivedSuccessRes
 	}
 }
 //#endregion
-export { checkEnvKeys as A, vaultSensitiveAnswers as B, CHECK_ENV_KEYS_DESCRIPTION as C, WIZARD_ASK_SUBJECT_DESCRIPTION as D, WIZARD_ASK_SENSITIVE_DESCRIPTION as E, mergeEnvValues as F, MAX_ENV_KEY_SET as G, createWizardAskBridge as H, normaliseAskSubject as I, toPromptSafeRelativePath as J, isEnvFileName as K, resolveEnvPath as L, downloadSkill as M, fetchSkillMenu as N, WIZARD_ASK_TOOL_DESCRIPTION as O, installSkillById as P, resolveEnvSecretRefs as R, publishHandoff as S, ENV_FILE_PATH_DESCRIPTION as T, isFullyCancelled as U, fetchWithRetry as V, gatewayAuth as W, markGrantRevoked as Y, buildGatewayProvider as _, wizardCanUseTool as a, PUBLISH_HANDOFF_DESCRIPTION as b, checkAllSettingsConflicts as c, restoreClaudeSettings as d, sanitizeAgentSubprocessEnv as f, GATEWAY_PROVIDER as g, createTriageLLMProvider as h, runAgent as i, createAskAccounting as j, WIZARD_TOOL_NAMES as k, classifySettingsConflicts as l, assembleCommandments as m, buildRunTags as n, createIsolatedAgentConfigDir as o, AgentOutputSignals as p, parseEnvKeyNames as q, initializeAgent as r, backupAndFixClaudeSettings as s, buildAgentEnv as t, recoverOrphanedSettingsBackups as u, createSecretVault as v, CHECK_ENV_KEYS_FILE_PATH_DESCRIPTION as w, PUBLISH_HANDOFF_TOOL_NAME as x, PUBLISH_HANDOFF_CONTENT_DESCRIPTION as y, templateEnvWriteRefusal as z };
+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 };
 
-//# sourceMappingURL=agent-interface-Dm28tBj-.js.map
+//# sourceMappingURL=agent-interface-CK6pmvkF.js.map