dsh-agy-link 0.4.53 → 0.4.59

package/dist/index.js

@@ -77,7 +77,32 @@ function defaultConfig() {
 		defaultEffort: "",
 		timeoutMs: 6e5,
 		longToolIdleMinutes: 240,
-		maxConcurrent: 3,
+		/**
+		* Hard cap (minutes) on waiting for the Windows credential slot before the
+		* dispatch releases, backs off and retries (dispatchRetries). Each attempt
+		* waits up to this long, so persistence ≈ (1 + dispatchRetries) × N
+		* minutes before the turn fails visibly. 0 = wait indefinitely (the wait
+		* stays abort-aware, poll-healed and heartbeat-logged).
+		*/
+		dispatchTimeoutMinutes: 15,
+		/** Extra dispatch attempts after a credential-slot hard-cap timeout. */
+		dispatchRetries: 1,
+		/**
+		* Same-account credential-slot fast path (default true): sessions running
+		* on the account whose credential already sits in the Windows slot start
+		* immediately WITHOUT exclusivity — agy is a stateless CLI and handles
+		* concurrent processes natively. Only account SWITCHES serialize.
+		* false restores full-run slot exclusivity (one agy process at a time).
+		*/
+		parallelSameAccount: true,
+		/**
+		* Cross-session cap on concurrent agy request streams. 0 = UNLIMITED
+		* (default): native agy concurrency — agy is a stateless CLI and runs
+		* concurrent processes natively; Google rate limits and the account
+		* pool's cooldowns are the natural regulators. Set a positive number to
+		* re-introduce an admission bound.
+		*/
+		maxConcurrent: 0,
 		contextWindowDefault: 1048576,
 		maxTokensDefault: 65536,
 		forwardSystemPrompt: false,
@@ -129,6 +154,35 @@ function looksLikeNetworkError(message) {
 	return /dial tcp|fetch failed|econn(?:refused|reset|aborted)|enotfound|ehostunreach|enetunreach|socket hang up|getaddrinfo|bad gateway|service unavailable|unexpected eof|\beof\b|tls handshake timeout|i\/o timeout|network (?:error|is unreachable)|no route to host|connection reset|context deadline exceeded|temporary failure in name resolution|proxyconnect|token validation failed|validate (?:the )?token|silent auth failed/i.test(message);
 }
 /**
+* Evidence from agy's OWN per-run log that a stored credential was present but
+* could not be VALIDATED over the network — i.e. jitter wearing an auth costume.
+*
+* The stderr banner agy prints when silent auth fails is byte-identical for a
+* genuine sign-out and for a keyring validation that missed its hard 10s
+* window, so the banner cannot decide AUTH vs NETWORK. The log can:
+*
+*   real sign-out   printmode.go:403 not authenticated, trying silent auth
+*                   printmode.go:409 silent auth failed        ← 29 ms later,
+*                   (NO keyringAuth: line — nothing to validate)  no keyring line
+*   network blip    printmode.go:403 not authenticated, trying silent auth
+*                   keyring.go:64   keyringAuth: loaded token … expired=false
+*                   keyring.go:111  keyringAuth: timed out after 10s
+*                   printmode.go:409 silent auth failed
+*                   keyring.go:93   keyringAuth: failed to fetch user info:
+*                                   userinfo request failed: … i/o timeout
+*
+* `keyringAuth:` lines only exist when agy actually HAD a credential to
+* validate, and the timeout / userinfo markers are transport failures inside
+* that validation. Verified against real logs (2026-10-16): the sign-out log
+* contains 0 occurrences of every marker below, the blip log contains all of
+* them.
+*/
+function looksLikeAuthVerificationJitter(agyLogText) {
+	if (agyLogText === "") return false;
+	if (isAuthoritativeAuthError(agyLogText)) return false;
+	return /keyringAuth: timed out after|failed to fetch user info|userinfo request failed/i.test(agyLogText);
+}
+/**
 * Decide whether a failed call may flag an account as "needs re-login".
 * Genuine AUTH classification wins (unless the failure was transport-shaped),
 * and the message must name an authoritative token state otherwise.
@@ -334,6 +388,9 @@ function resolveConfig(entry, env = process.env, overrides = readOverrides()) {
 		defaultEffort: asString(get("defaultEffort")) ?? base.defaultEffort,
 		timeoutMs: asNum(get("timeoutMs")) ?? base.timeoutMs,
 		longToolIdleMinutes: asNum(get("longToolIdleMinutes")) ?? base.longToolIdleMinutes,
+		dispatchTimeoutMinutes: asNum(get("dispatchTimeoutMinutes")) ?? base.dispatchTimeoutMinutes,
+		dispatchRetries: asNum(get("dispatchRetries")) ?? base.dispatchRetries,
+		parallelSameAccount: asBool(get("parallelSameAccount")) ?? base.parallelSameAccount,
 		maxConcurrent: asNum(get("maxConcurrent")) ?? base.maxConcurrent,
 		contextWindowDefault: asNum(get("contextWindowDefault")) ?? base.contextWindowDefault,
 		maxTokensDefault: asNum(get("maxTokensDefault")) ?? base.maxTokensDefault,
@@ -421,10 +478,18 @@ function resolveConfig(entry, env = process.env, overrides = readOverrides()) {
 }
 //#endregion
 //#region src/common/pool-types.ts
-/** Map a model slug to its backend quota counter family. */
+/**
+* Map a model slug to its backend quota counter family.
+*
+* Gemini 4 Argon (Pro/Ultra-only) bills against its OWN weekly quota pool —
+* never the plain Gemini one. Its ids look like `gemini-4-argon-low/-medium`
+* and MUST be detected before the generic `gemini-` prefix below, otherwise
+* argon usage would silently drain/report the Gemini counter.
+*/
 function modelFamilyOf(modelId) {
 	if (!modelId) return "unknown";
 	const id = modelId.toLowerCase();
+	if (id.includes("argon")) return "argon";
 	if (id.startsWith("claude-") || id.includes("claude")) return "anthropic";
 	if (id.startsWith("gemini-") || id.startsWith("gemma-") || id.includes("gemini")) return "google";
 	if (id.startsWith("gpt-") || id.startsWith("openai/") || id.includes("gpt-oss")) return "openai";
@@ -1371,9 +1436,9 @@ function parseGoalRoundText(text) {
 	const maxRounds = roundMatch && roundMatch[2] ? parseInt(roundMatch[2], 10) : void 0;
 	const objMatch = text.match(/Objective:\s*(?:"([^"]*)"|'([^']*)'|([^\n]+))/);
 	const objective = objMatch ? (objMatch[1] || objMatch[2] || objMatch[3])?.trim() : void 0;
-	const idMatch = text.match(/goal-[a-zA-Z0-9_-]+/);
+	const idMatch = text.match(/goal-[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/) ?? text.match(/\bid:\s*["']?([a-zA-Z0-9_-]+)["']?/);
 	return {
-		goalId: idMatch ? idMatch[0] : void 0,
+		goalId: idMatch ? idMatch[1] ?? idMatch[0] : void 0,
 		round,
 		maxRounds,
 		objective
@@ -1435,14 +1500,21 @@ function isPlanMode(messages) {
 	return false;
 }
 /**
-* Check if the trailing message is the tool result of a bridge-emitted `update_goal` call.
+* Check if the trailing span represents completion of a bridge-emitted `update_goal` call.
+* This covers both the direct tool-result message and DSH's deferred `<goal_complete>` notice.
 */
 function isGoalToolContinuation(messages) {
 	if (messages.length === 0) return false;
-	const last = messages[messages.length - 1];
-	if (!last) return false;
-	const callId = last.toolCallId ?? last.source?.callId;
-	if (typeof callId === "string" && callId.startsWith("agytc-bridge-goal-")) return true;
+	const spanStart = Math.max(0, messages.length - 4);
+	for (let i = messages.length - 1; i >= spanStart; i--) {
+		const m = messages[i];
+		if (!m) continue;
+		const callId = m.toolCallId ?? m.source?.callId;
+		if (typeof callId === "string" && callId.startsWith("agytc-bridge-goal-")) return true;
+		const src = m.source;
+		if (src && typeof src === "object" && src.kind === "tool-goal") return true;
+		if (extractText$1(m).includes("<goal_complete>")) return true;
+	}
 	return false;
 }
 /**
@@ -1780,21 +1852,7 @@ var EventMapper = class {
 				const d = this.appendDelta("[agy finished with error] " + ev.error + "\n");
 				if (d) yield d;
 			}
-			const closeErr = this.closeOpen();
-			if (closeErr) yield closeErr;
-			yield {
-				type: "usage",
-				usage: usageFromRaw(this.opts.usage?.finalUsage(ev.usage) ?? ev.usage)
-			};
-			yield {
-				type: "finish",
-				reason: { kind: "stop" },
-				...ev.conversationId !== "" ? { replayState: { response: { conversationId: ev.conversationId } } } : {}
-			};
-			this.finished = true;
-			return;
-		}
-		if (!this.sawTextStep && ev.response !== "") {
+		} else if (!this.sawTextStep && ev.response !== "") {
 			yield* this.ensureBlock("text");
 			const d = this.appendDelta(ev.response);
 			if (d) yield d;
@@ -1805,7 +1863,7 @@ var EventMapper = class {
 			type: "usage",
 			usage: usageFromRaw(this.opts.usage?.finalUsage(ev.usage) ?? ev.usage)
 		};
-		if (this.opts.supportsGoalUpdate && this.opts.goalContext?.goalId) {
+		if (this.opts.supportsGoalUpdate && this.opts.goalContext) {
 			for (const ch of buildGoalCompleteToolCallBlock(this.opts.goalContext, this.blockIdx)) yield ch;
 			this.blockIdx++;
 			yield {
@@ -2824,6 +2882,209 @@ function ensureIsolatedKeychain(dir, platform = process.platform, run = (file, a
 		return false;
 	}
 }
+/**
+* Purge any stale locked keychain from an isolated account HOME directory.
+* Keychains from older versions (v0.4.41-v0.4.44) were provisioned with
+* ephemeral random passwords that cannot be unlocked with an empty password,
+* causing repeated modal password dialogs from macOS SecurityAgent.
+* If unlocking with `-p ""` fails, the file and its registration in securityd
+* are purged so that ensureIsolatedKeychain can cleanly re-provision it.
+*/
+function purgeStaleIsolatedKeychain(dir, platform = process.platform, run = (file, args, env) => execFileSync(file, args, {
+	stdio: "ignore",
+	env,
+	timeout: 5e3
+})) {
+	if (platform !== "darwin") return false;
+	if (dir === "") return false;
+	const kc = join(dir, "Library", "Keychains", "login.keychain-db");
+	if (!existsSync(kc)) return false;
+	const env = {
+		...process.env,
+		HOME: dir
+	};
+	try {
+		run("security", [
+			"unlock-keychain",
+			"-p",
+			"",
+			kc
+		], env);
+		return false;
+	} catch {
+		try {
+			run("security", ["delete-keychain", kc], env);
+		} catch {}
+		try {
+			rmSync(kc, { force: true });
+		} catch {}
+		return true;
+	}
+}
+/**
+* macOS: Repair hijacked user-level keychain configuration.
+*
+* Versions prior to v0.4.49 set `security default-keychain -s <isolated-kc>`,
+* redirecting the user's desktop session default and login keychain into an
+* account-specific folder under ~/.dsh/agy-accounts/.
+*
+* This function detects if default-keychain, login-keychain, or the search list
+* (`list-keychains -d user`) point to any path containing `agy-accounts` or `.dsh`,
+* and restores them to the user's real login keychain (`~/Library/Keychains/login.keychain-db`).
+*/
+function repairMacSystemKeychain(userHome = homedir(), platform = process.platform, run = (file, args, env) => execFileSync(file, args, {
+	encoding: "utf8",
+	env: env ?? process.env,
+	timeout: 5e3
+})) {
+	if (platform !== "darwin") return false;
+	if (!userHome) return false;
+	let repaired = false;
+	const realKc = [join(userHome, "Library", "Keychains", "login.keychain-db"), join(userHome, "Library", "Keychains", "login.keychain")].find((p) => existsSync(p));
+	if (!realKc) return false;
+	const isIsolatedPath = (p) => /[\\/]\.dsh[\\/]agy-accounts[\\/]/i.test(p);
+	const env = {
+		...process.env,
+		HOME: userHome
+	};
+	try {
+		if (isIsolatedPath(run("security", ["default-keychain"], env).trim().replace(/^"|"$/g, ""))) {
+			run("security", [
+				"default-keychain",
+				"-s",
+				realKc
+			], env);
+			repaired = true;
+		}
+	} catch {}
+	try {
+		if (isIsolatedPath(run("security", ["login-keychain"], env).trim().replace(/^"|"$/g, ""))) {
+			run("security", [
+				"login-keychain",
+				"-s",
+				realKc
+			], env);
+			repaired = true;
+		}
+	} catch {}
+	try {
+		const entries = run("security", [
+			"list-keychains",
+			"-d",
+			"user"
+		], env).split("\n").map((l) => l.trim().replace(/^"|"$/g, "")).filter(Boolean);
+		const hasTainted = entries.some(isIsolatedPath);
+		const hasReal = entries.includes(realKc);
+		if (hasTainted || !hasReal) {
+			const cleaned = entries.filter((p) => !isIsolatedPath(p));
+			if (!cleaned.includes(realKc)) cleaned.unshift(realKc);
+			const sysKc = "/Library/Keychains/System.keychain";
+			if (!cleaned.includes(sysKc) && existsSync(sysKc)) cleaned.push(sysKc);
+			run("security", [
+				"list-keychains",
+				"-d",
+				"user",
+				"-s",
+				...cleaned
+			], env);
+			repaired = true;
+		}
+	} catch {}
+	return repaired;
+}
+/**
+* Open an interactive terminal session inside the given account directory.
+* Supports macOS (Terminal.app via AppleScript), Windows (cmd.exe start),
+* and Linux (xdg-terminal-exec, x-terminal-emulator, gnome-terminal, konsole,
+* xfce4-terminal, alacritty, xterm across distributions).
+* Safe, non-blocking and non-throwing.
+*/
+function openAccountTerminal(accDir, platform = process.platform, run = (file, args, opts) => execFile(file, [...args], { windowsHide: opts?.windowsHide }, () => {})) {
+	if (!accDir) return false;
+	if (platform === "darwin") {
+		const script = `tell application "Terminal" to activate\ntell application "Terminal" to do script "export HOME='${accDir}'; agy"`;
+		try {
+			run("osascript", ["-e", script]);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	if (platform === "win32") try {
+		run("cmd.exe", [
+			"/c",
+			"start",
+			"cmd.exe",
+			"/k",
+			`set "HOME=${accDir}" && set "USERPROFILE=${accDir}" && agy`
+		], { windowsHide: true });
+		return true;
+	} catch {
+		return false;
+	}
+	const cmd = `export HOME='${accDir}'; agy; exec bash`;
+	const candidates = [
+		{
+			bin: "xdg-terminal-exec",
+			args: [
+				"bash",
+				"-c",
+				cmd
+			]
+		},
+		{
+			bin: "x-terminal-emulator",
+			args: ["-e", `sh -c "export HOME='${accDir}'; agy; exec sh"`]
+		},
+		{
+			bin: "gnome-terminal",
+			args: [
+				"--",
+				"bash",
+				"-c",
+				cmd
+			]
+		},
+		{
+			bin: "konsole",
+			args: [
+				"-e",
+				"bash",
+				"-c",
+				cmd
+			]
+		},
+		{
+			bin: "xfce4-terminal",
+			args: ["-e", `bash -c "${cmd}"`]
+		},
+		{
+			bin: "alacritty",
+			args: [
+				"-e",
+				"bash",
+				"-c",
+				cmd
+			]
+		},
+		{
+			bin: "xterm",
+			args: [
+				"-e",
+				"bash",
+				"-c",
+				cmd
+			]
+		}
+	];
+	for (const c of candidates) try {
+		run(c.bin, c.args);
+		return true;
+	} catch {
+		continue;
+	}
+	return false;
+}
 function resolveAgyBin(cfg) {
 	const candidates = [];
 	if (cfg.agyBin !== "") candidates.push(cfg.agyBin);
@@ -3307,15 +3568,42 @@ function parseWindowsProxyServer(raw) {
 	}
 	return /^https?:\/\//i.test(s) ? s : `http://${s}`;
 }
+/**
+* Parse macOS `scutil --proxy` dictionary output.
+* Keys of interest:
+*   HTTPEnable : 1
+*   HTTPPort : 7890
+*   HTTPProxy : 127.0.0.1
+*   HTTPSEnable : 1
+*   HTTPSPort : 7890
+*   HTTPSProxy : 127.0.0.1
+*   SOCKSEnable : 1
+*   SOCKSPort : 7890
+*   SOCKSProxy : 127.0.0.1
+*/
+function parseMacScutilProxy(raw) {
+	if (!raw.trim()) return void 0;
+	const lines = raw.split("\n");
+	const dict = {};
+	for (const line of lines) {
+		const m = /^\s*([A-Za-z0-9_]+)\s*:\s*(.+)$/.exec(line);
+		if (m && m[1] && m[2]) dict[m[1]] = m[2].trim();
+	}
+	if (dict.HTTPSEnable === "1" && dict.HTTPSProxy && dict.HTTPSPort) return `http://${dict.HTTPSProxy}:${dict.HTTPSPort}`;
+	if (dict.HTTPEnable === "1" && dict.HTTPProxy && dict.HTTPPort) return `http://${dict.HTTPProxy}:${dict.HTTPPort}`;
+	if (dict.SOCKSEnable === "1" && dict.SOCKSProxy && dict.SOCKSPort) return `socks5://${dict.SOCKSProxy}:${dict.SOCKSPort}`;
+}
 let cachedProxy = null;
 /**
-* Detect system proxy configuration.
+* Detect system proxy configuration across Windows, macOS, and Linux.
 * Priority:
-* 1. Standard environment variables (HTTPS_PROXY, HTTP_PROXY, ALL_PROXY)
+* 1. Standard environment variables (HTTPS_PROXY, HTTP_PROXY, ALL_PROXY, and lowercase)
 * 2. Windows Registry (HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings)
-* Results are cached for 5 seconds to minimize registry queries.
+* 3. macOS scutil (--proxy)
+* 4. Linux desktop system proxy (GNOME gsettings)
+* Results are cached for 5 minutes (300s) to minimize subprocess and registry queries.
 */
-function detectSystemProxy() {
+function detectSystemProxy(platform = process.platform) {
 	const now = Date.now();
 	if (cachedProxy && cachedProxy.expiresAt > now) return cachedProxy.value;
 	const envProxy = process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy || process.env.ALL_PROXY || process.env.all_proxy;
@@ -3327,7 +3615,7 @@ function detectSystemProxy() {
 		};
 		return val;
 	}
-	if (IS_WIN$1) try {
+	if (platform === "win32") try {
 		const out = execFileSync("reg", ["query", "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings"], {
 			encoding: "utf8",
 			timeout: 2e3,
@@ -3353,6 +3641,74 @@ function detectSystemProxy() {
 			}
 		}
 	} catch {}
+	if (platform === "darwin") try {
+		const val = parseMacScutilProxy(execFileSync("scutil", ["--proxy"], {
+			encoding: "utf8",
+			timeout: 2e3,
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}));
+		if (val) {
+			cachedProxy = {
+				value: val,
+				expiresAt: now + 3e5
+			};
+			return val;
+		}
+	} catch {}
+	if (platform === "linux") try {
+		if (execFileSync("gsettings", [
+			"get",
+			"org.gnome.system.proxy",
+			"mode"
+		], {
+			encoding: "utf8",
+			timeout: 1e3,
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim().replace(/^'|'$/g, "") === "manual") {
+			const host = execFileSync("gsettings", [
+				"get",
+				"org.gnome.system.proxy.https",
+				"host"
+			], {
+				encoding: "utf8",
+				timeout: 1e3,
+				stdio: [
+					"ignore",
+					"pipe",
+					"ignore"
+				]
+			}).trim().replace(/^'|'$/g, "");
+			const port = execFileSync("gsettings", [
+				"get",
+				"org.gnome.system.proxy.https",
+				"port"
+			], {
+				encoding: "utf8",
+				timeout: 1e3,
+				stdio: [
+					"ignore",
+					"pipe",
+					"ignore"
+				]
+			}).trim();
+			if (host && port && port !== "0") {
+				const val = `http://${host}:${port}`;
+				cachedProxy = {
+					value: val,
+					expiresAt: now + 3e5
+				};
+				return val;
+			}
+		}
+	} catch {}
 	cachedProxy = {
 		value: void 0,
 		expiresAt: now + 3e5
@@ -3375,6 +3731,13 @@ var AccountPoolManager = class {
 	* sessions.json: web + headless share this file).
 	*/
 	knownIds = /* @__PURE__ */ new Set();
+	/**
+	* Consecutive non-authoritative auth failures per account id (noteAuthFailure).
+	* Deliberately in-memory: losing the streak on restart only costs one extra
+	* confirmation round, while persisting it could quarantine an account for a
+	* blip that healed while the process was down.
+	*/
+	authStrikes = /* @__PURE__ */ new Map();
 	/** Serialized snapshot of the last successful persist/load; skips no-op writes. */
 	persistedJson = "";
 	constructor(baseDir = defaultPoolDir()) {
@@ -3717,9 +4080,34 @@ var AccountPoolManager = class {
 		if (this.data.activeAccountIds) {
 			for (const [fam, accId] of Object.entries(this.data.activeAccountIds)) if (accId === id) delete this.data.activeAccountIds[fam];
 		}
+		this.authStrikes.delete(id);
 		this.persist();
 	}
 	/**
+	* Confirmation-gated quarantine for auth-classified failures that carry NO
+	* authoritative evidence (no invalid_grant / revoked / unauthorized_client).
+	*
+	* agy prints the same "not signed in" banner whether the login is really
+	* dead or its keyring validation merely missed a 10s window on a flaky
+	* network, so one banner used to sticky-quarantine healthy accounts — the
+	* user then saw a red 需重新登录 and could not even 设为当前使用. A single
+	* strike now only rotates the account away for the current retry; the flag
+	* hardens into a real quarantine only when the failure repeats with no
+	* success in between. Authoritative OAuth paths keep calling
+	* markAuthRequired directly and quarantine on first sight.
+	*
+	* Returns true when the account is now hard-quarantined.
+	*/
+	noteAuthFailure(id, reason) {
+		const strikes = (this.authStrikes.get(id) ?? 0) + 1;
+		if (strikes < 2) {
+			this.authStrikes.set(id, strikes);
+			return false;
+		}
+		this.markAuthRequired(id, reason);
+		return true;
+	}
+	/**
 	* External re-login detected (agy logout + new login): identity-bound
 	* state from the PREVIOUS account (cooldowns, quotas, auth quarantine)
 	* must not leak onto the new one. Resets everything email-bound while
@@ -3742,6 +4130,7 @@ var AccountPoolManager = class {
 		delete acc.authRequired;
 		delete acc.authError;
 		delete acc.authMarkedAt;
+		this.authStrikes.delete(id);
 		this.persist();
 	}
 	/**
@@ -3958,6 +4347,7 @@ var AccountPoolManager = class {
 			delete acc.authMarkedAt;
 		}
 		if (acc.cooldowns?.[family]) delete acc.cooldowns[family];
+		this.authStrikes.delete(id);
 		this.persist();
 	}
 	clearCooldown(id, family) {
@@ -27547,10 +27937,10 @@ const OAUTH_USERINFO_URL$1 = "https://www.googleapis.com/oauth2/v1/userinfo";
 /** Fixed loopback callback registered for the Antigravity client (like opencode). */
 const OAUTH_CALLBACK_PORT = 51121;
 const OAUTH_REDIRECT_URI = `http://localhost:${OAUTH_CALLBACK_PORT}/oauth-callback`;
-/** Runtime endpoint fallback order (daily first, mirroring OmniRoute). */
+/** Runtime endpoint fallback order (official production first, then staging/daily fallbacks). */
 const AGY_ENDPOINTS = [
-	"https://daily-cloudcode-pa.googleapis.com",
 	"https://cloudcode-pa.googleapis.com",
+	"https://daily-cloudcode-pa.googleapis.com",
 	"https://daily-cloudcode-pa.sandbox.googleapis.com",
 	"https://autopush-cloudcode-pa.sandbox.googleapis.com"
 ];
@@ -27891,30 +28281,138 @@ function accountTokenFilePath(account, homeDir) {
 /**
 * FIFO async mutex. One instance guards the single Windows credential slot;
 * holding it across an entire agy run is what makes the handoff safe.
+*
+* The original implementation chained promises (`tail.then(gate)`), which is
+* FIFO but structurally unable to remove a waiter: a turn abandoned or aborted
+* while queued stayed in the chain forever, and if its gate was never resolved
+* every later waiter wedged with it (the 2026-10-16 cardboard-empire zombie
+* turn: queued 30+ minutes past the slot's release, immune to Stop, because
+* nothing observed the wait). This rewrite keeps an explicit queue so a
+* cancelled or timed-out waiter is REMOVED and the next waiter is woken in its
+* place, and the wait is guarded by a short poll that re-checks liveness — a
+* lost wakeup can no longer park a turn silently.
 */
 var AsyncMutex = class {
-	tail = Promise.resolve();
-	depth = 0;
+	holders = 0;
+	queue = [];
 	/** Number of holders plus waiters; 0 means the mutex is free. */
 	get pending() {
-		return this.depth;
+		return this.holders + this.queue.length;
 	}
-	async acquire() {
-		this.depth += 1;
-		let release;
-		const gate = new Promise((resolve) => {
-			release = resolve;
+	/** Waiters currently queued behind the holder(s). */
+	get waiting() {
+		return this.queue.length;
+	}
+	/**
+	* Acquire the mutex.
+	*
+	* @param opts.signal  cancel the wait (the waiter is removed and the next
+	*   one is woken); rejects with `AbortedWaitError`
+	* @param opts.timeoutMs  bound the wait; rejects with `WaitTimeoutError`
+	* @param opts.pollMs  liveness self-check interval while queued (0 = off).
+	*   The poll re-checks `shouldProceed` — a hook that lets the caller verify
+	*   the wait is still legitimate (e.g. the queue actually advanced). If it
+	*   returns true while the mutex appears free, the waiter takes the mutex
+	*   directly, healing a lost wakeup within one poll interval instead of
+	*   hanging forever.
+	*/
+	async acquire(opts = {}) {
+		const signal = opts.signal;
+		if (signal?.aborted) throw new AbortedWaitError("aborted before mutex acquisition");
+		if (this.holders < 1) {
+			this.holders += 1;
+			return () => this.releaseOne();
+		}
+		const pollMs = opts.pollMs ?? 0;
+		const timeoutMs = opts.timeoutMs;
+		let onAbort = null;
+		let timer = null;
+		let pollTimer = null;
+		return new Promise((resolve, reject) => {
+			let settled = false;
+			let entry = null;
+			let takenDirectly = false;
+			const cleanup = () => {
+				if (onAbort) {
+					signal?.removeEventListener("abort", onAbort);
+					onAbort = null;
+				}
+				if (timer) {
+					clearTimeout(timer);
+					timer = null;
+				}
+				if (pollTimer) {
+					clearInterval(pollTimer);
+					pollTimer = null;
+				}
+			};
+			const take = () => {
+				this.holders += 1;
+				return () => this.releaseOne();
+			};
+			const grant = () => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				resolve(take());
+			};
+			const fail = (err) => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				if (entry !== null) {
+					const idx = this.queue.indexOf(entry);
+					if (idx >= 0) this.queue.splice(idx, 1);
+					entry = null;
+				} else if (takenDirectly) this.releaseOne();
+				reject(err);
+			};
+			entry = () => grant();
+			this.queue.push(entry);
+			onAbort = () => {
+				fail(new AbortedWaitError("aborted while waiting for the mutex"));
+			};
+			signal?.addEventListener("abort", onAbort, { once: true });
+			if (timeoutMs !== void 0 && timeoutMs > 0) {
+				timer = setTimeout(() => fail(new WaitTimeoutError("timed out waiting for the mutex")), timeoutMs);
+				timer.unref?.();
+			}
+			if (pollMs > 0 && opts.shouldProceed !== void 0) {
+				pollTimer = setInterval(() => {
+					if (settled) return;
+					if (this.holders < 1 && this.queue[0] === entry && opts.shouldProceed?.()) {
+						const idx = this.queue.indexOf(entry);
+						if (idx >= 0) this.queue.splice(idx, 1);
+						entry = null;
+						takenDirectly = true;
+						grant();
+					}
+				}, pollMs);
+				pollTimer.unref?.();
+			}
 		});
-		const previous = this.tail;
-		this.tail = previous.then(() => gate, () => gate);
-		await previous;
-		let released = false;
-		return () => {
-			if (released) return;
-			released = true;
-			this.depth -= 1;
-			release();
-		};
+	}
+	releaseOne() {
+		this.holders -= 1;
+		this.wakeNext();
+	}
+	wakeNext() {
+		const next = this.queue.shift();
+		if (next) queueMicrotask(next);
+	}
+};
+/** The caller's abort signal fired while queued on the mutex. */
+var AbortedWaitError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AbortedWaitError";
+	}
+};
+/** The bounded wait elapsed before the mutex became available. */
+var WaitTimeoutError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "WaitTimeoutError";
 	}
 };
 const credentialSlotMutex = new AsyncMutex();
@@ -28045,16 +28543,38 @@ var SlotUnavailableError = class extends Error {
 		this.name = "SlotUnavailableError";
 	}
 };
+let primaryFastRuns = 0;
+let slotSwitchPending = false;
+/** Live fast-path (same-account) run count — exported for diagnostics. */
+function fastPathRunCount() {
+	return primaryFastRuns;
+}
 /**
-* Take exclusive ownership of the credential slot for a run and arrange its
-* guaranteed restoration.
+* Take ownership of the credential slot for a run and arrange its guaranteed
+* restoration.
 *
 * Non-Windows platforms have no shared slot (per-account Keychain isolation
 * works), so this is a no-op there.
 *
+* Same-account runs (the sticky primary — the common case) take a FAST PATH:
+* when the slot already provably holds this account's credential and no slot
+* switch is pending, the run starts IMMEDIATELY without the mutex, so
+* multiple sessions on one account run truly in parallel (agy is a stateless
+* CLI and handles concurrent processes natively). Only identity SWITCHES
+* serialize.
+*
+* @param options.signal  cancels the wait for the slot — without it a turn
+*   queued behind another session's long run ignored Stop entirely (the
+*   cardboard-empire zombie turn, 2026-10-16).
+* @param options.dispatchTimeoutMs  bounds the wait; 0/undefined waits
+*   indefinitely (the wait stays observable and cancellable either way).
+* @param options.parallel  same-account fast path (default true). false
+*   restores full-run exclusivity.
 * @throws SlotUnavailableError when the slot cannot be handed over safely.
-* The caller must abort the run instead of silently signing in as the wrong
-* account (which would spend that account's quota).
+*   The caller must abort the run instead of silently signing in as the wrong
+*   account (which would spend that account's quota).
+* @throws AbortedWaitError when the signal aborted while queued.
+* @throws WaitTimeoutError when the bounded wait elapsed.
 */
 async function acquireCredentialSlot(account, pool, options = {}) {
 	const io = resolveIo(options);
@@ -28062,13 +28582,46 @@ async function acquireCredentialSlot(account, pool, options = {}) {
 	const baseDir = options.baseDir ?? defaultPoolDir();
 	const homeDir = options.homeDir ?? process.env.HOME ?? process.env.USERPROFILE ?? "";
 	const log = options.log ?? (() => {});
-	const releaseMutex = await credentialSlotMutex.acquire();
+	const parallel = options.parallel !== false;
+	const isPrimarySlot = Boolean(account.systemHome) || !account.dir;
+	if (parallel && isPrimarySlot && !slotSwitchPending && !options.signal?.aborted) {
+		const stored = readPrimaryCredential(baseDir);
+		if (stored && sameCredentialGrant(io.readSlot(), stored.raw)) {
+			primaryFastRuns += 1;
+			log("[agy-link] same-account fast path: slot already holds the primary credential — running without exclusivity");
+			return {
+				identity: stored.email,
+				release: () => {
+					primaryFastRuns = Math.max(0, primaryFastRuns - 1);
+					try {
+						const afterRaw = io.readSlot();
+						if (afterRaw && afterRaw !== stored.raw && sameCredentialGrant(afterRaw, stored.raw)) writePrimaryCredential({
+							raw: afterRaw,
+							email: stored.email,
+							savedAt: Date.now()
+						}, baseDir);
+					} catch {}
+				}
+			};
+		}
+	}
+	const releaseMutex = await credentialSlotMutex.acquire({
+		signal: options.signal,
+		timeoutMs: options.dispatchTimeoutMs,
+		pollMs: 5e3,
+		shouldProceed: () => true
+	});
 	let released = false;
 	const done = () => {
 		if (released) return;
 		released = true;
+		slotSwitchPending = false;
 		releaseMutex();
 	};
+	if (options.signal?.aborted) {
+		done();
+		throw new AbortedWaitError("aborted after acquiring the credential slot");
+	}
 	try {
 		const primary = await resolvePrimaryCredential(pool, {
 			...options,
@@ -28077,7 +28630,6 @@ async function acquireCredentialSlot(account, pool, options = {}) {
 		});
 		const accountFile = accountTokenFilePath(account, homeDir);
 		const accountRaw = readTokenFileRaw(accountFile);
-		const isPrimarySlot = Boolean(account.systemHome) || !account.dir;
 		if (!primary) {
 			done();
 			throw new SlotUnavailableError("Cannot verify the primary Antigravity credential, so the Windows credential slot cannot be handed over safely. Sign the primary account in again, then retry.");
@@ -28109,6 +28661,23 @@ async function acquireCredentialSlot(account, pool, options = {}) {
 				}
 			};
 		}
+		if (parallel && primaryFastRuns > 0) {
+			slotSwitchPending = true;
+			const deadline = options.dispatchTimeoutMs !== void 0 && options.dispatchTimeoutMs > 0 ? Date.now() + options.dispatchTimeoutMs : 0;
+			log(`[agy-link] waiting for ${primaryFastRuns} same-account run(s) to finish before switching the credential slot to ${account.alias || account.id}`);
+			while (primaryFastRuns > 0) {
+				if (options.signal?.aborted) {
+					slotSwitchPending = false;
+					throw new AbortedWaitError("aborted while waiting for same-account runs to finish");
+				}
+				if (deadline !== 0 && Date.now() > deadline) {
+					slotSwitchPending = false;
+					throw new WaitTimeoutError(`timed out waiting for ${primaryFastRuns} same-account run(s) to finish before switching the credential slot`);
+				}
+				await new Promise((r) => setTimeout(r, 200));
+			}
+			slotSwitchPending = false;
+		}
 		if (!accountRaw) {
 			done();
 			throw new SlotUnavailableError(`Account ${account.alias || account.id} has no stored credential. Sign it in again before using it.`);
@@ -28166,6 +28735,58 @@ function findDuplicateCredentialIdentities(accounts, homeDir) {
 	return reports;
 }
 //#endregion
+//#region src/host/agy-log.ts
+/** Same home resolution quota.ts uses for per-account credential access. */
+function agyHomeDirFor(account) {
+	return account?.systemHome || !account?.dir ? homedir() : account.dir;
+}
+function agyLogDir(homeDir) {
+	return join(homeDir, ".gemini", "antigravity-cli", "log");
+}
+/** Names of the cli-*.log files present right now (cheap readdir). */
+function snapshotAgyLogs(homeDir) {
+	const dir = agyLogDir(homeDir);
+	try {
+		return new Set(readdirSync(dir).filter((f) => f.startsWith("cli-") && f.endsWith(".log")));
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+/** Upper bound so one pathological log cannot balloon the failure path. */
+const MAX_LOG_BYTES = 262144;
+const MAX_LOG_FILES = 3;
+/**
+* Concatenated text of the log files THIS run created (present now, absent
+* from the pre-spawn snapshot), newest first. Returns '' when the run wrote no
+* readable log — callers must treat that as "no evidence", never as proof
+* either way.
+*/
+function readAgyRunLogText(homeDir, before) {
+	const dir = agyLogDir(homeDir);
+	let names;
+	try {
+		if (!existsSync(dir)) return "";
+		names = readdirSync(dir).filter((f) => f.startsWith("cli-") && f.endsWith(".log") && !before.has(f)).map((f) => ({
+			f,
+			m: statSync(join(dir, f)).mtimeMs
+		})).sort((a, b) => b.m - a.m).slice(0, MAX_LOG_FILES).map((e) => e.f);
+	} catch {
+		return "";
+	}
+	const parts = [];
+	let budget = MAX_LOG_BYTES;
+	for (const name of names) {
+		if (budget <= 0) break;
+		try {
+			const text = readFileSync(join(dir, name), "utf8");
+			const slice = text.length > budget ? text.slice(-budget) : text;
+			parts.push(slice);
+			budget -= slice.length;
+		} catch {}
+	}
+	return parts.join("\n");
+}
+//#endregion
 //#region src/host/sessions.ts
 var SessionStore = class {
 	file;
@@ -28842,11 +29463,11 @@ function isSyntheticHarnessMessage(m) {
 	const src = m.source;
 	const kind = src?.kind;
 	if (kind !== void 0 && kind !== "" && kind !== "user") {
-		if (kind === "time-context" || kind === "skill-catalog" || kind === "runtime-context" || kind === "model-selection" || kind === "system-reminder" || kind === "dsh-session-title-llm" || kind === "synthetic") return true;
+		if (kind === "time-context" || kind === "skill-catalog" || kind === "runtime-context" || kind === "model-selection" || kind === "system-reminder" || kind === "dsh-session-title-llm" || kind === "tool-goal" || kind === "synthetic") return true;
 		if (kind === "plugin" && src.form === "snapshot") return true;
 	}
 	const text = textOf(m).trim();
-	if (text.startsWith("Time sampled while preparing") || text.startsWith("<system-reminder>") || text.startsWith("Current runtime context") || text.startsWith("[model changed:") || text.startsWith("[conversation so far]") || text.startsWith("A skill is a reusable set of task-specific instructions")) return true;
+	if (text.startsWith("Time sampled while preparing") || text.startsWith("<system-reminder>") || text.startsWith("Current runtime context") || text.startsWith("[model changed:") || text.startsWith("[conversation so far]") || text.startsWith("<goal_complete>") || text.startsWith("A skill is a reusable set of task-specific instructions")) return true;
 	return false;
 }
 /**
@@ -29248,9 +29869,13 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 	* { model: LlmResolvedModelInfo; stream(options): AsyncIterable<StreamChunk> }.
 	*/
 	async prepareCall(provider, model, signal) {
+		if (signal?.aborted) throw signal.reason ?? new LlmError("aborted", "ABORTED");
 		return {
 			model: await this.resolveModel(provider, model, signal),
-			stream: (options) => this.stream(options)
+			stream: (options) => this.stream({
+				...options,
+				signal: options.signal ?? signal
+			})
 		};
 	}
 	/** Build the agy argv for one call. Exported for tests. */
@@ -29300,12 +29925,18 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 			};
 			return;
 		}
-		const goalContext = detectGoalContext(options.messages);
-		if (goalContext && (!goalContext.goalId || goalContext.revision === void 0) && sessionKey && this.deps.sessionGoal) {
+		let goalContext = detectGoalContext(options.messages);
+		if ((!goalContext || !goalContext.goalId || goalContext.revision === void 0) && sessionKey && this.deps.sessionGoal) {
 			const sg = this.deps.sessionGoal(sessionKey);
 			if (sg) {
-				if (!goalContext.goalId) goalContext.goalId = sg.goalId;
-				if (goalContext.revision === void 0) goalContext.revision = sg.revision;
+				if (!goalContext) goalContext = {
+					goalId: sg.goalId,
+					revision: sg.revision
+				};
+				else {
+					if (!goalContext.goalId) goalContext.goalId = sg.goalId;
+					if (goalContext.revision === void 0) goalContext.revision = sg.revision;
+				}
 			}
 		}
 		const supportsGoalUpdate = Boolean(options.tools?.some((t) => t.name === "update_goal"));
@@ -29315,7 +29946,7 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 			const rec = this.deps.runs.get(continuation.runId);
 			const deadFailure = rec !== void 0 && rec.isSettled ? rec.failureInfo : null;
 			if (rec !== void 0 && !(deadFailure !== null && this.claimFailover(sessionKey, deadFailure.code))) {
-				yield* this.driveSpan(rec, continuation.eventIndex + 1, hasToolSupport, isCodeMode, goalContext, supportsGoalUpdate, supportsPlanExit);
+				yield* this.driveSpan(rec, continuation.eventIndex + 1, hasToolSupport, isCodeMode, goalContext, supportsGoalUpdate, supportsPlanExit, options.signal);
 				return;
 			}
 			if (rec !== void 0) {
@@ -29357,7 +29988,17 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 			while (this.requestTimestamps.length > 0 && this.requestTimestamps[0] < windowStart) this.requestTimestamps.shift();
 			if (this.requestTimestamps.length >= cfg.rateLimitPerMinute) {
 				const delayMs = this.requestTimestamps[0] + 6e4 - now;
-				if (delayMs > 0) await new Promise((r) => setTimeout(r, delayMs));
+				if (delayMs > 0) await new Promise((resolve, reject) => {
+					const timer = setTimeout(() => {
+						options.signal?.removeEventListener("abort", onAbort);
+						resolve();
+					}, delayMs);
+					const onAbort = () => {
+						clearTimeout(timer);
+						reject(new LlmError("aborted during rate-limit spacing", Err.AGY_ERROR));
+					};
+					options.signal?.addEventListener("abort", onAbort, { once: true });
+				});
 			}
 			this.requestTimestamps.push(Date.now());
 		}
@@ -29548,7 +30189,7 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 						startedAt: now,
 						inFlight: true
 					});
-					yield* this.driveSpan(liveRun, rescueFrom, hasToolSupport, isCodeMode, goalContext, supportsGoalUpdate, supportsPlanExit);
+					yield* this.driveSpan(liveRun, rescueFrom, hasToolSupport, isCodeMode, goalContext, supportsGoalUpdate, supportsPlanExit, options.signal);
 					return;
 				}
 				throw new LlmError("Duplicate request ignored: an identical request is already running for this session.", Err.BUSY);
@@ -29659,34 +30300,97 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 			promptViaStdin: true
 		}) : argsBase;
 		const stdinPayload = promptViaStdin ? buildStreamInputLine(prompt) : void 0;
-		const release = await this.deps.acquire();
+		const dispatchHardCapMs = cfg.dispatchTimeoutMinutes > 0 ? cfg.dispatchTimeoutMinutes * 6e4 : 0;
+		const dispatchStartedAt = Date.now();
+		const DISPATCH_HEARTBEAT_MS = 12e4;
+		let dispatchHeartbeat = null;
+		const stopDispatchHeartbeat = () => {
+			if (dispatchHeartbeat !== null) {
+				clearInterval(dispatchHeartbeat);
+				dispatchHeartbeat = null;
+			}
+		};
+		const startDispatchHeartbeat = () => {
+			if (dispatchHeartbeat !== null) return;
+			dispatchHeartbeat = setInterval(() => {
+				const mins = Math.max(1, Math.round((Date.now() - dispatchStartedAt) / 6e4));
+				const mutex = credentialSlotMutex;
+				this.deps.log?.("agy dispatch still waiting: " + mins + "m — credential slot queue: " + mutex.waiting + " waiter(s), " + (mutex.pending - mutex.waiting) + " holder(s) (another session may be running a long agy tool) — the turn is waiting for the slot; press Stop to cancel");
+			}, DISPATCH_HEARTBEAT_MS);
+			dispatchHeartbeat.unref?.();
+		};
+		const dispatchSleep = async (ms) => {
+			if (options.signal?.aborted) throw new LlmError("request aborted during dispatch backoff", Err.AGY_ERROR);
+			await new Promise((resolve, reject) => {
+				const timer = setTimeout(() => {
+					options.signal?.removeEventListener("abort", onAbort);
+					resolve();
+				}, ms);
+				const onAbort = () => {
+					clearTimeout(timer);
+					reject(new LlmError("request aborted during dispatch backoff", Err.AGY_ERROR));
+				};
+				options.signal?.addEventListener("abort", onAbort, { once: true });
+			});
+		};
+		let release = null;
 		let released = false;
 		let slotLease;
+		let granted = false;
+		let dispatchBackoffMs = 2e3;
+		const maxDispatchAttempts = 1 + Math.max(0, cfg.dispatchRetries);
 		try {
-			slotLease = process.env.NODE_TEST_CONTEXT === void 0 ? await acquireCredentialSlot(account ?? void 0, this.deps.pool, {
-				baseDir: this.deps.pool?.dir,
-				proxyUrl: account?.proxyUrl || cfg.proxyUrl || detectSystemProxy() || void 0,
-				log: (msg) => this.deps.log?.(msg)
-			}) : void 0;
+			for (let attempt = 1; attempt <= maxDispatchAttempts && !granted; attempt++) try {
+				release = await this.deps.acquire(options.signal);
+				startDispatchHeartbeat();
+				slotLease = process.env.NODE_TEST_CONTEXT === void 0 ? await acquireCredentialSlot(account ?? void 0, this.deps.pool, {
+					baseDir: this.deps.pool?.dir,
+					proxyUrl: account?.proxyUrl || cfg.proxyUrl || detectSystemProxy() || void 0,
+					log: (msg) => this.deps.log?.(msg),
+					signal: options.signal,
+					dispatchTimeoutMs: dispatchHardCapMs,
+					parallel: cfg.parallelSameAccount
+				}) : void 0;
+				granted = true;
+			} catch (e) {
+				release?.();
+				release = null;
+				if (e instanceof AbortedWaitError) throw new LlmError("request aborted while waiting for the agy credential slot", Err.AGY_ERROR);
+				if (e instanceof WaitTimeoutError) {
+					if (attempt < maxDispatchAttempts) {
+						this.deps.log?.("agy dispatch attempt " + attempt + "/" + maxDispatchAttempts + " timed out after " + cfg.dispatchTimeoutMinutes + "m waiting for the credential slot — releasing and retrying in " + Math.round(dispatchBackoffMs / 1e3) + "s");
+						stopDispatchHeartbeat();
+						await dispatchSleep(dispatchBackoffMs);
+						dispatchBackoffMs = Math.min(dispatchBackoffMs * 2, 15e3);
+						continue;
+					}
+					throw new LlmError("could not take the agy credential slot within " + cfg.dispatchTimeoutMinutes + "m (another run may be wedged holding it). Check the console for the dispatch heartbeat, restart DSH if a run is truly stuck.", Err.TIMEOUT);
+				}
+				const detail = e instanceof SlotUnavailableError ? e.message : brief(String(e));
+				throw new LlmError(detail, Err.AGY_ERROR);
+			}
 		} catch (e) {
-			release();
+			stopDispatchHeartbeat();
 			this.clearInFlightPrompt(sessionKey, prompt);
-			const detail = e instanceof SlotUnavailableError ? e.message : brief(String(e));
-			throw new LlmError(detail, Err.AGY_ERROR);
+			throw e;
 		}
+		stopDispatchHeartbeat();
 		const releaseOnce = () => {
 			if (released) return;
 			released = true;
 			try {
 				slotLease?.release();
 			} catch {}
-			release();
+			release?.();
+			release = null;
 		};
 		if (options.signal?.aborted) {
 			releaseOnce();
 			throw new LlmError("request aborted before the agy process was spawned", Err.AGY_ERROR);
 		}
 		if (account && account.dir) ensureIsolatedKeychain(account.dir);
+		const runLogHome = agyHomeDirFor(account);
+		const runLogsBefore = snapshotAgyLogs(runLogHome);
 		const effectiveProxy = account?.proxyUrl || cfg.proxyUrl || detectSystemProxy() || void 0;
 		const env = {
 			...process.env,
@@ -29707,7 +30411,20 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 				const elapsed = Date.now() - lastSpawn;
 				const jitter = Math.floor(Math.random() * 300);
 				const targetInterval = this.minSpawnIntervalMs + jitter;
-				if (elapsed < targetInterval) await new Promise((r) => setTimeout(r, targetInterval - elapsed));
+				if (elapsed < targetInterval) {
+					if (options.signal?.aborted) throw new LlmError("request aborted before the agy process was spawned", Err.AGY_ERROR);
+					await new Promise((r, reject) => {
+						const timer = setTimeout(() => {
+							options.signal?.removeEventListener("abort", onAbort);
+							r();
+						}, targetInterval - elapsed);
+						const onAbort = () => {
+							clearTimeout(timer);
+							reject(new LlmError("request aborted before the agy process was spawned", Err.AGY_ERROR));
+						};
+						options.signal?.addEventListener("abort", onAbort, { once: true });
+					});
+				}
 				this.lastAccountSpawnTime.set(account.id, Date.now());
 			}
 			proc = startAgyProcess({
@@ -29781,7 +30498,9 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 			const consumable = r !== null && (r.ok || r.response !== "");
 			const rawErrText = [outcome.stderrTail, parser.stats.lastResultError].filter(Boolean).join(" ");
 			const isRateLimit = looksLikeRateLimit(rawErrText);
-			const transportFailure = looksLikeNetworkError([
+			const runLogText = readAgyRunLogText(runLogHome, runLogsBefore);
+			const keyringJitter = looksLikeAuthVerificationJitter(runLogText);
+			const transportFailure = keyringJitter || looksLikeNetworkError([
 				rawErrText,
 				parser.stats.authFailureText ?? "",
 				outcome.stderrTail,
@@ -29803,7 +30522,7 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 				if (sawAuthFailure(parser, outcome)) failure = transportFailure ? {
 					kind: "error",
 					code: Err.NETWORK,
-					message: "agy could not validate its Google login over the network (transport failure, not a sign-out) — retrying on another account. " + (rawErrText !== "" ? brief(rawErrText) : "")
+					message: "agy could not validate its Google login over the network (transport failure" + (keyringJitter ? "; its own log shows keyring auth timing out on the network, not a sign-out" : "") + ", not a sign-out) — retrying on another account. " + (rawErrText !== "" ? brief(rawErrText) : "")
 				} : {
 					kind: "error",
 					code: Err.AUTH,
@@ -29871,7 +30590,11 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 				if (account && silentTimeout) this.deps.pool?.advanceAccount(account.id, family);
 				if (account && failure.code === Err.ELIGIBILITY) this.deps.pool?.advanceAccount(account.id, family);
 				if (!outcome.aborted && failure.code !== Err.RATE_LIMIT && (failure.code === Err.NETWORK || failure.code === Err.OVERLOADED || failure.code === Err.AUTH) && account) this.deps.pool?.advanceAccount(account.id, family);
-				if (account && shouldMarkAuthRequired(failure.code, failure.message)) this.deps.pool?.markAuthRequired(account.id, failure.message);
+				if (account && shouldMarkAuthRequired(failure.code, failure.message)) {
+					const authoritative = isAuthoritativeAuthError(rawErrText + " " + runLogText);
+					if (failure.code === Err.AUTH && !authoritative) this.deps.pool?.noteAuthFailure(account.id, failure.message);
+					else this.deps.pool?.markAuthRequired(account.id, failure.message);
+				}
 				const staleConversation = failure.code === Err.AUTH || failure.message !== "" && /conversation.*(not found|invalid|not recognized|expired|does not exist)|session.*(expired|invalid)/i.test(failure.message);
 				const interruptedTurn = failure.kind === "aborted" || outcome.timedOut === true;
 				if (!isAux && sessionAccountKey !== "" && staleConversation) this.deps.store.delete(sessionAccountKey);
@@ -29903,7 +30626,7 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 				message: "internal error: " + brief(String(err))
 			});
 		});
-		yield* this.driveSpan(rec, 0, !isAux && hasToolSupport, isCodeMode, goalContext, supportsGoalUpdate, supportsPlanExit);
+		yield* this.driveSpan(rec, 0, !isAux && hasToolSupport, isCodeMode, goalContext, supportsGoalUpdate, supportsPlanExit, options.signal);
 	}
 	/**
 	* Stream one span of a recording: map events from `from` until the mapper
@@ -29912,19 +30635,50 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 	* as this span's terminal chunk — the turn ends exactly like a native
 	* provider error.
 	*/
-	async *driveSpan(rec, from, cutOnTool, useCodeWrapper, goalContext, supportsGoalUpdate, supportsPlanExit) {
+	async *driveSpan(rec, from, cutOnTool, useCodeWrapper, goalContext, supportsGoalUpdate, supportsPlanExit, signal) {
+		if (signal?.aborted) {
+			rec.requestAbort?.();
+			yield {
+				type: "finish",
+				reason: {
+					kind: "aborted",
+					failure: {
+						code: "ABORTED",
+						message: "aborted by caller"
+					}
+				}
+			};
+			return;
+		}
 		this.deps.runs.remember(rec);
 		this.deps.runs.pin(rec.runId);
 		try {
-			yield* this.driveSpanBody(rec, from, cutOnTool, useCodeWrapper, goalContext, supportsGoalUpdate, supportsPlanExit);
+			yield* this.driveSpanBody(rec, from, cutOnTool, useCodeWrapper, goalContext, supportsGoalUpdate, supportsPlanExit, signal);
 		} finally {
 			this.deps.runs.unpin(rec.runId);
 			this.deps.runs.remember(rec);
 		}
 	}
 	/** Body of {@link driveSpan}: map recorded events until the span finishes. */
-	async *driveSpanBody(rec, from, cutOnTool, useCodeWrapper, goalContext, supportsGoalUpdate, supportsPlanExit) {
+	async *driveSpanBody(rec, from, cutOnTool, useCodeWrapper, goalContext, supportsGoalUpdate, supportsPlanExit, signal) {
 		const queue = new ChunkQueue();
+		let abortedLocally = false;
+		const onAbort = () => {
+			abortedLocally = true;
+			rec.requestAbort?.();
+			queue.push({
+				type: "finish",
+				reason: {
+					kind: "aborted",
+					failure: {
+						code: "ABORTED",
+						message: "aborted by caller"
+					}
+				}
+			});
+			queue.close();
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
 		(async () => {
 			const resolved = /* @__PURE__ */ new Map();
 			const resolvedThoughts = /* @__PURE__ */ new Map();
@@ -29945,6 +30699,7 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 			let i = from;
 			try {
 				for await (const ev of rec.eventsFrom(from)) {
+					if (abortedLocally || signal?.aborted) break;
 					const recordedThought = rec.getThoughts(i);
 					if (recordedThought !== void 0) resolvedThoughts.set(i, recordedThought);
 					else if (ev.kind === "step") {
@@ -30008,17 +30763,21 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 						break;
 					}
 				}
-				if (!mapper.isFinished) {
+				if (!mapper.isFinished && !abortedLocally && !signal?.aborted) {
 					const f = rec.failureInfo;
 					if (f !== null) for (const ch of mapper.emitFailure(f.kind, f.code, f.message)) queue.push(ch);
 					else for (const ch of mapper.emitFailure("error", Err.INVALID_OUTPUT, "agy stream ended without a result event")) queue.push(ch);
 				}
 			} catch (err) {
-				for (const ch of mapper.emitFailure("error", Err.PROCESS_EXIT, "internal error: " + brief(String(err)))) queue.push(ch);
+				if (!abortedLocally && !signal?.aborted) for (const ch of mapper.emitFailure("error", Err.PROCESS_EXIT, "internal error: " + brief(String(err)))) queue.push(ch);
 			}
 			queue.close();
 		})();
-		yield* queue.drain();
+		try {
+			yield* queue.drain();
+		} finally {
+			signal?.removeEventListener("abort", onAbort);
+		}
 	}
 };
 /**
@@ -30689,6 +31448,10 @@ const HELP = [
 	"- `/agy models` — refresh and list discovered models",
 	"- `/agy mode <skip|plan|accept-edits>` — permission mode (next turn)",
 	"- `/agy effort <low|medium|high|default>` — default reasoning effort",
+	"- `/agy dispatch [minutes|off]` — credential-slot wait cap per attempt (omit to inspect; `off` = unlimited)",
+	"- `/agy dispatch-retries <n>` — extra dispatch attempts after the cap",
+	"- `/agy parallel <on|off>` — same-account parallel agy runs (Windows slot fast path)",
+	"- `/agy max-concurrent <n|off>` — cap on concurrent agy request streams (off = unlimited, native)",
 	"- `/agy workspace [path]` — set the agy working directory (absolute path; omit to show)",
 	"- `/agy clear` — drop the most recent conversation binding",
 	"- `/agy doctor` — write a diagnostic report and return its path",
@@ -30698,7 +31461,7 @@ function agyCommandDefinition(deps) {
 	return {
 		name: "agy",
 		description: "Antigravity (agy CLI) bridge: status, login, models, mode, diagnostics, goal",
-		input: { hint: "<status|pool|goal|session|enable-account|disable-account|models|mode|effort|workspace|clear|doctor|help>" },
+		input: { hint: "<status|pool|goal|session|enable-account|disable-account|models|mode|effort|dispatch|dispatch-retries|parallel|max-concurrent|workspace|clear|doctor|help>" },
 		handler: (invocation) => handle(deps, invocation.rawInput, invocation)
 	};
 }
@@ -30721,6 +31484,8 @@ async function handle(deps, raw, invocation) {
 				const qG = a.quotas.google?.remainingFraction !== void 0 ? `${Math.round(a.quotas.google.remainingFraction * 100)}%` : "unknown";
 				const qC = a.quotas.anthropic?.remainingFraction !== void 0 ? `${Math.round(a.quotas.anthropic.remainingFraction * 100)}%` : "unknown";
 				const qO = a.quotas.openai?.remainingFraction !== void 0 ? `${Math.round(a.quotas.openai.remainingFraction * 100)}%` : "unknown";
+				const qA = a.quotas.argon?.weeklyFraction;
+				const quotaLine = `   - Quota: Gemini ${qG} | Claude ${qC} | GPT-OSS ${qO}` + (qA !== void 0 ? ` | Argon ${Math.round(qA * 100)}% (weekly)` : "");
 				const cds = [];
 				for (const [fam, cd] of Object.entries(a.cooldowns)) if (cd && cd.cooldownUntil > Date.now()) {
 					const sec = Math.ceil((cd.cooldownUntil - Date.now()) / 1e3);
@@ -30730,7 +31495,7 @@ async function handle(deps, raw, invocation) {
 				if (!a.enabled) statusText = "   - Status: ⏸️ Disabled";
 				else if (a.authRequired) statusText = `   - Status: 🔴 Auth required (${a.authError || "sign in again"})`;
 				else if (cds.length > 0) statusText = `   - ⚠️ ${cds.join("; ")}`;
-				lines.push(`${i + 1}. **${a.alias}** (${a.email || a.id})${isPrimary ? " ⭐ primary" : ""}`, `   - Proxy: ${a.proxyUrl ? redactProxyUrl(a.proxyUrl) : deps.cfg().proxyUrl ? redactProxyUrl(deps.cfg().proxyUrl) : "system default"}`, `   - Quota: Gemini ${qG} | Claude ${qC} | GPT-OSS ${qO}`, statusText);
+				lines.push(`${i + 1}. **${a.alias}** (${a.email || a.id})${isPrimary ? " ⭐ primary" : ""}`, `   - Proxy: ${a.proxyUrl ? redactProxyUrl(a.proxyUrl) : deps.cfg().proxyUrl ? redactProxyUrl(deps.cfg().proxyUrl) : "system default"}`, quotaLine, statusText);
 			}
 			return ok(lines.join("\n"));
 		}
@@ -30979,6 +31744,49 @@ async function handle(deps, raw, invocation) {
 			deps.setOverride("defaultEffort", arg === "default" ? "" : arg);
 			return ok("Default effort set to **" + (arg === "default" ? "model default" : arg) + "**.");
 		}
+		if (sub === "dispatch" || sub === "dispatch-retries") {
+			const cfg = deps.cfg();
+			const mutex = credentialSlotMutex;
+			if (arg === "") return ok([
+				"**Agy 派发守护（dispatch guards）**",
+				`- 硬超时：**${cfg.dispatchTimeoutMinutes > 0 ? `${cfg.dispatchTimeoutMinutes} 分钟/次` : "不限时（无限等待）"}**（重试次数 ${cfg.dispatchRetries}${cfg.dispatchTimeoutMinutes > 0 ? `，总坚持 ≈ ${(1 + cfg.dispatchRetries) * cfg.dispatchTimeoutMinutes} 分钟` : ""}）`,
+				"- 同账号并行：**" + (cfg.parallelSameAccount ? "开（快路径，多会话并行跑同一账号）" : "关（同一时刻仅 1 个 agy 进程）") + "**",
+				`- 并发上限：**${cfg.maxConcurrent > 0 ? cfg.maxConcurrent + " 个流" : "不限制（原生并发）"}**`,
+				`- 当前凭据槽位队列：**${mutex.waiting} 个等待者 / ${mutex.pending - mutex.waiting} 个持有者**，同账号快路径活跃 **${fastPathRunCount()}** 个`,
+				`- 排队期间：Stop 随时可停；丢失唤醒 5 秒内自愈；每 2 分钟心跳日志`,
+				`- 修改：/agy dispatch <分钟|off>　/agy dispatch-retries <次数>　/agy parallel <on|off>`
+			].join("\n"));
+			if (sub === "dispatch") {
+				if (arg === "off" || arg === "0") {
+					deps.setOverride("dispatchTimeoutMinutes", 0);
+					return ok("派发硬超时已关闭：排队将无限等待（仍然 Stop 可停、轮询自愈、心跳可见）。");
+				}
+				const minutes = Number(arg);
+				if (!Number.isFinite(minutes) || minutes <= 0 || !Number.isInteger(minutes)) return err("usage: /agy dispatch <分钟数|off>");
+				deps.setOverride("dispatchTimeoutMinutes", minutes);
+				return ok(`派发硬超时设为 **${minutes} 分钟/次**（含 ${cfg.dispatchRetries} 次重试，总坚持 ≈ ${(1 + cfg.dispatchRetries) * minutes} 分钟）— 下一个回合生效。`);
+			}
+			const retries = Number(arg);
+			if (!Number.isFinite(retries) || retries < 0 || !Number.isInteger(retries) || retries > 10) return err("usage: /agy dispatch-retries <0-10>");
+			deps.setOverride("dispatchRetries", retries);
+			return ok(`派发重试次数设为 **${retries}**${cfg.dispatchTimeoutMinutes > 0 ? `，总坚持 ≈ ${(1 + retries) * cfg.dispatchTimeoutMinutes} 分钟` : ""} — 下一个回合生效。`);
+		}
+		if (sub === "parallel") {
+			if (arg !== "on" && arg !== "off") return err("usage: /agy parallel <on|off>");
+			const on = arg === "on";
+			deps.setOverride("parallelSameAccount", on);
+			return ok(on ? "同账号并行已**开启**：同一账号的多个会话立即并行跑 agy（无需独占凭据槽位），仅账号切换时串行 — 下一个回合生效。" : "同账号并行已**关闭**：恢复同一时刻仅 1 个 agy 进程（全串行）— 下一个回合生效。");
+		}
+		if (sub === "max-concurrent") {
+			if (arg === "off" || arg === "0") {
+				deps.setOverride("maxConcurrent", 0);
+				return ok("并发上限已移除：**不限制**（原生 agy 并发，Google 速率与账号冷却为天然调节）— 下一个回合生效。");
+			}
+			const n = Number(arg);
+			if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1 || n > 64) return err("usage: /agy max-concurrent <1-64|off>");
+			deps.setOverride("maxConcurrent", n);
+			return ok(`并发上限设为 **${n}** 个请求流 — 下一个回合生效。`);
+		}
 		if (sub === "workspace") {
 			if (arg === "") return ok("Current workspace: " + (deps.cfg().workspaceRoot !== "" ? deps.cfg().workspaceRoot : "(session cwd / process cwd)"));
 			if (arg === "default" || arg === "clear") {
@@ -31691,32 +32499,44 @@ var QuotaService = class {
 		for (let i = 0; i < total; i++) ordered.push(AGY_ENDPOINTS[(this.preferredEndpointIndex + i) % total]);
 		return ordered;
 	}
+	async fetchSummaryEndpoint(endpoint, accessToken, proxyUrl) {
+		return agyFetch(`${endpoint}/v1internal:retrieveUserQuotaSummary`, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${accessToken}`,
+				"Content-Type": "application/json",
+				"User-Agent": agyUserAgent()
+			},
+			body: JSON.stringify({})
+		}, proxyUrl);
+	}
 	/**
 	* Fetch official multi-bucket quota summary (both weekly and 5h limit windows)
 	* via v1internal:retrieveUserQuotaSummary.
 	*/
 	async fetchQuotaSummary(accessToken, proxyUrl) {
 		const endpoints = this.getOrderedEndpoints();
+		let partialSummary = null;
 		for (let i = 0; i < endpoints.length; i++) {
 			const endpoint = endpoints[i];
 			try {
-				const res = await agyFetch(`${endpoint}/v1internal:retrieveUserQuotaSummary`, {
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${accessToken}`,
-						"Content-Type": "application/json",
-						"User-Agent": agyUserAgent()
-					},
-					body: JSON.stringify({})
-				}, proxyUrl);
+				const res = await this.fetchSummaryEndpoint(endpoint, accessToken, proxyUrl);
 				if (res.ok) {
-					this.preferredEndpointIndex = AGY_ENDPOINTS.indexOf(endpoint);
-					return await res.json();
+					const summary = await res.json();
+					if (summary?.groups?.some((g) => {
+						const name = (g.displayName || "").toLowerCase();
+						const desc = (g.description || "").toLowerCase();
+						return name.includes("gemini") || desc.includes("gemini");
+					})) {
+						this.preferredEndpointIndex = AGY_ENDPOINTS.indexOf(endpoint);
+						return summary;
+					}
+					if (!partialSummary && summary && Array.isArray(summary.groups) && summary.groups.length > 0) partialSummary = summary;
 				}
 				if (res.status === 401 || res.status === 403) break;
 			} catch {}
 		}
-		return null;
+		return partialSummary;
 	}
 	/**
 	* Fetch available models and model-level quotas via v1internal:fetchAvailableModels.
@@ -31736,7 +32556,7 @@ var QuotaService = class {
 					body: JSON.stringify({})
 				}, proxyUrl);
 				if (res.ok) {
-					this.preferredEndpointIndex = AGY_ENDPOINTS.indexOf(endpoint);
+					if (AGY_ENDPOINTS.indexOf(endpoint) === 0) this.preferredEndpointIndex = 0;
 					return await res.json();
 				}
 				if (res.status === 401 || res.status === 403) break;
@@ -31795,9 +32615,10 @@ var QuotaService = class {
 		if (summary && Array.isArray(summary.groups)) for (const group of summary.groups) {
 			const dName = (group.displayName || "").toLowerCase();
 			const desc = (group.description || "").toLowerCase();
-			const isGoogle = dName.includes("gemini") || desc.includes("gemini");
+			const isArgon = dName.includes("argon") || desc.includes("argon");
+			const isGoogle = !isArgon && (dName.includes("gemini") || desc.includes("gemini"));
 			const is3P = dName.includes("claude") || dName.includes("gpt") || desc.includes("claude") || desc.includes("gpt");
-			const targetFamilies = isGoogle ? ["google"] : is3P ? ["anthropic", "openai"] : [];
+			const targetFamilies = isArgon ? ["argon"] : isGoogle ? ["google"] : is3P ? ["anthropic", "openai"] : [];
 			let fiveHourFrac;
 			let fiveHourReset;
 			let weeklyFrac;
@@ -31842,13 +32663,18 @@ var QuotaService = class {
 				resetTime,
 				updatedAt: now
 			});
-			else if (familyQuotas[fam].remainingFraction === void 0) {
+			else {
 				const curRemaining = familyQuotas[fam].remainingFraction ?? 1;
-				if (remaining < curRemaining) {
-					familyQuotas[fam].remainingFraction = remaining;
-					familyQuotas[fam].resetTime = resetTime;
-				} else if (remaining === curRemaining) {
-					if (resetTime && (!familyQuotas[fam].resetTime || Date.parse(resetTime) > Date.parse(familyQuotas[fam].resetTime))) familyQuotas[fam].resetTime = resetTime;
+				const fbReset = resetTime ? Date.parse(resetTime) : NaN;
+				const is5hWindow = !Number.isNaN(fbReset) && fbReset - now <= 216e5;
+				if (familyQuotas[fam].remainingFraction === void 0 || is5hWindow) {
+					if (remaining < curRemaining) {
+						familyQuotas[fam].remainingFraction = remaining;
+						familyQuotas[fam].resetTime = resetTime;
+					} else if (familyQuotas[fam].remainingFraction === void 0) {
+						familyQuotas[fam].remainingFraction = remaining;
+						familyQuotas[fam].resetTime = resetTime;
+					}
 				}
 			}
 		}
@@ -32263,7 +33089,7 @@ function resolveAssetDir() {
 	for (const c of candidates) if (existsSync(c)) return c;
 	return join(currentDir, "assets");
 }
-/** Cross-session concurrency limiter (ADR-12). */
+/** Cross-session concurrency limiter (ADR-12). max() <= 0 means unlimited. */
 var Semaphore = class {
 	max;
 	active = 0;
@@ -32271,16 +33097,31 @@ var Semaphore = class {
 	constructor(max) {
 		this.max = max;
 	}
-	async acquire() {
-		if (this.active < Math.max(1, this.max())) {
+	async acquire(signal) {
+		if (signal?.aborted) throw new Error("aborted before semaphore acquisition");
+		const limit = this.max();
+		if (limit <= 0) {
+			this.active++;
+			return () => this.releaseOne();
+		}
+		if (this.active < limit) {
 			this.active++;
 			return () => this.releaseOne();
 		}
-		return new Promise((resolve) => {
-			this.queue.push(() => {
+		return new Promise((resolve, reject) => {
+			let entry;
+			const onAbort = () => {
+				const idx = this.queue.indexOf(entry);
+				if (idx >= 0) this.queue.splice(idx, 1);
+				reject(/* @__PURE__ */ new Error("aborted while waiting for semaphore slot"));
+			};
+			entry = () => {
+				signal?.removeEventListener("abort", onAbort);
 				this.active++;
 				resolve(() => this.releaseOne());
-			});
+			};
+			signal?.addEventListener("abort", onAbort, { once: true });
+			this.queue.push(entry);
 		});
 	}
 	releaseOne() {
@@ -32355,8 +33196,14 @@ function apply(ctx, entryConfig = {}) {
 	if (swept > 0) log("swept " + swept + " stale staging dir(s)");
 	const logsSwept = pool.sweepOldLogs(getConfig().logRetentionDays);
 	if (logsSwept > 0) log("swept " + logsSwept + " old log file(s)");
+	if (process.platform === "darwin") try {
+		if (repairMacSystemKeychain()) log("repaired macOS system keychain settings (restored real login keychain)");
+	} catch {}
 	let kcProvisioned = 0;
-	for (const acc of pool.getAccounts()) if (acc.dir && ensureIsolatedKeychain(acc.dir)) kcProvisioned++;
+	for (const acc of pool.getAccounts()) if (acc.dir) {
+		purgeStaleIsolatedKeychain(acc.dir);
+		if (ensureIsolatedKeychain(acc.dir)) kcProvisioned++;
+	}
 	if (kcProvisioned > 0) log("provisioned isolated keychains for " + kcProvisioned + " pool account(s)");
 	if (process.platform === "win32") {
 		resolvePrimaryCredential(pool, {
@@ -32375,7 +33222,7 @@ function apply(ctx, entryConfig = {}) {
 		store,
 		pool,
 		bin,
-		acquire: () => semaphore.acquire(),
+		acquire: (signal) => semaphore.acquire(signal),
 		log,
 		runs,
 		getMediaBaseUrl: () => webServerPort.current ? `http://127.0.0.1:${webServerPort.current}/plugins/agy-link/media` : null,
@@ -32383,10 +33230,23 @@ function apply(ctx, entryConfig = {}) {
 			return ctx.get("sessions")?.get(sessionId)?.header?.cwd;
 		},
 		sessionGoal: (sessionId) => {
+			try {
+				const agents = ctx.get("agents") ?? ctx.agents;
+				const goals = ctx.get("goals") ?? ctx.goals;
+				const agent = agents?.get(sessionId);
+				if (agent && goals) {
+					const g = goals.get(agent);
+					if (g?.id && g.phase === "active" && (g.activation === void 0 || g.activation === "armed")) return {
+						goalId: g.id,
+						revision: typeof g.revision === "number" ? g.revision : 1
+					};
+				}
+			} catch {}
 			const session = (ctx.get("sessions") ?? ctx.sessions)?.get(sessionId);
-			if (!session?.events) return null;
-			for (let i = session.events.length - 1; i >= 0; i--) {
-				const ev = session.events[i];
+			const evs = session?.snapshotEvents?.() ?? session?.ownEvents?.() ?? session?.log ?? session?.events;
+			if (!evs) return null;
+			for (let i = evs.length - 1; i >= 0; i--) {
+				const ev = evs[i];
 				if (ev?.type === "goal/change" && ev.data && typeof ev.data === "object") {
 					const d = ev.data;
 					if (d.operation === "clear") return null;
@@ -32799,19 +33659,7 @@ function apply(ctx, entryConfig = {}) {
 					const alias = typeof body.alias === "string" ? body.alias : void 0;
 					const acc = pool.createAccountSlot(alias);
 					pool.markAuthRequired(acc.id, "not signed in yet — complete the terminal login");
-					if (body.autoOpenTerminal !== false && acc.dir) {
-						if (process.platform === "darwin") {
-							const script = `tell application "Terminal" to activate\ntell application "Terminal" to do script "export HOME='${acc.dir}'; agy"`;
-							execFile("osascript", ["-e", script], () => {});
-						} else if (process.platform === "win32") execFile("cmd.exe", [
-							"/c",
-							"start",
-							"cmd.exe",
-							"/k",
-							`set "HOME=${acc.dir}" && set "USERPROFILE=${acc.dir}" && agy`
-						], { windowsHide: true }, () => {});
-						else execFile("x-terminal-emulator", ["-e", `sh -c "export HOME='${acc.dir}'; agy; exec sh"`], () => {});
-					}
+					if (body.autoOpenTerminal !== false && acc.dir) openAccountTerminal(acc.dir);
 					sendJson(res, 200, {
 						ok: true,
 						account: acc,
@@ -32836,17 +33684,7 @@ function apply(ctx, entryConfig = {}) {
 						sendJson(res, 400, { error: "account has no isolated directory" });
 						return;
 					}
-					if (process.platform === "darwin") {
-						const script = `tell application "Terminal" to activate\ntell application "Terminal" to do script "export HOME='${acc.dir}'; agy"`;
-						execFile("osascript", ["-e", script], () => {});
-					} else if (process.platform === "win32") execFile("cmd.exe", [
-						"/c",
-						"start",
-						"cmd.exe",
-						"/k",
-						`set "HOME=${acc.dir}" && set "USERPROFILE=${acc.dir}" && agy`
-					], { windowsHide: true }, () => {});
-					else execFile("x-terminal-emulator", ["-e", `sh -c "export HOME='${acc.dir}'; agy; exec sh"`], () => {});
+					openAccountTerminal(acc.dir);
 					sendJson(res, 200, {
 						ok: true,
 						dir: acc.dir