dsh-agy-link 0.4.41 → 0.4.43

package/dist/index.js

@@ -86,6 +86,7 @@ function defaultConfig() {
 		maxTokensDefault: 65536,
 		forwardSystemPrompt: false,
 		digestMaxChars: 8e3,
+		contextTransferMaxChars: 66e4,
 		modelsCacheTtlMs: 3e5,
 		allowAuxiliary: true,
 		compactionMaxChars: 8e5,
@@ -135,6 +136,20 @@ const Err = {
 	AGY_NOT_INSTALLED: "AGY_NOT_INSTALLED",
 	AGY_VERSION_UNSUPPORTED: "AGY_VERSION_UNSUPPORTED",
 	AGY_ERROR: "AGY_ERROR",
+	/**
+	* Hard server-issued quota / rate-limit refusal. Distinct from AGY_ERROR so
+	* the provider retry policy can retry it (the failed account is already in
+	* cooldown, so the retry lands on the next account) without also retrying
+	* deterministic AGY_ERRORs (bad region, empty request, dead pool).
+	*/
+	RATE_LIMIT: "RATE_LIMIT",
+	/**
+	* Google-side region / account eligibility refusal ("User location is not
+	* supported for the API use"). Account-level, so it is retryable: the
+	* adapter rotates the sticky pointer first, which lets an account whose
+	* proxy/egress region IS supported serve the retry.
+	*/
+	ELIGIBILITY: "ELIGIBILITY",
 	TIMEOUT: "TIMEOUT",
 	PROCESS_EXIT: "PROCESS_EXIT",
 	INVALID_OUTPUT: "INVALID_OUTPUT",
@@ -152,7 +167,7 @@ function looksLikeAuthFailure(text) {
 * location" — not an auth bug and not something the bridge can retry past.
 */
 function looksLikeEligibilityFailure(text) {
-	return /eligibility check failed|not eligible for antigravity|not currently available in your (?:location|country|region)|not available in your (?:location|country|region)/i.test(text);
+	return /eligibility check failed|not eligible for antigravity|not currently available in your (?:location|country|region)|not available in your (?:location|country|region)|user location is not supported|location is not supported for the api|not supported in your (?:location|country|region)/i.test(text);
 }
 /** One-line guidance for an eligibility refusal (shown in the turn error). */
 const ELIGIBILITY_ERROR_HINT = "Google Antigravity is not eligible for this account/region. Use an account and network location where Antigravity is available (see https://antigravity.google).";
@@ -273,6 +288,7 @@ function resolveConfig(entry, env = process.env, overrides = readOverrides()) {
 		maxTokensDefault: asNum(get("maxTokensDefault")) ?? base.maxTokensDefault,
 		forwardSystemPrompt: asBool(get("forwardSystemPrompt")) ?? base.forwardSystemPrompt,
 		digestMaxChars: asNum(get("digestMaxChars")) ?? base.digestMaxChars,
+		contextTransferMaxChars: asNum(get("contextTransferMaxChars")) ?? base.contextTransferMaxChars,
 		modelsCacheTtlMs: asNum(get("modelsCacheTtlMs")) ?? base.modelsCacheTtlMs,
 		allowAuxiliary: asBool(get("allowAuxiliary")) ?? base.allowAuxiliary,
 		compactionMaxChars: asNum(get("compactionMaxChars")) ?? base.compactionMaxChars,
@@ -1897,10 +1913,27 @@ const EXT = {
 	"image/webp": "webp",
 	"image/gif": "gif"
 };
-/** Deterministic staged path: same session+turn+index reuses the file. */
-function stagedPath(dir, key, index, mediaType) {
+/**
+* Sanitize an attachment id into a stable filename fragment. Ids whose
+* sanitized form collides (e.g. "a/b" vs "a_b") get a short raw-id hash
+* suffix so distinct attachments never overwrite each other's files.
+*/
+function idFragment(attachmentId) {
+	const cleaned = attachmentId.replace(/[^a-zA-Z0-9_-]+/g, "_");
+	if (cleaned === "") return "img";
+	if (cleaned === attachmentId) return cleaned.slice(0, 80);
+	let h = 0;
+	for (let i = 0; i < attachmentId.length; i++) h = h * 31 + attachmentId.charCodeAt(i) | 0;
+	return (cleaned.slice(0, 40) + "-" + (h >>> 0).toString(36)).slice(0, 80);
+}
+/**
+* Deterministic staged path keyed by the attachment id (not the call index):
+* the same picture always lands on the same file, so a continuation that
+* legitimately re-references it overwrites instead of accumulating copies.
+*/
+function stagedPath(dir, key, attachmentId, mediaType) {
 	const ext = EXT[mediaType] ?? "png";
-	return join(dir, key + "-" + String(index) + "." + ext);
+	return join(dir, key + "-" + idFragment(attachmentId) + "." + ext);
 }
 /**
 * Stage up to `maxImages` images into `dir`, returning prompt lines that
@@ -1909,6 +1942,7 @@ function stagedPath(dir, key, index, mediaType) {
 */
 async function stageImages(opts) {
 	const staged = [];
+	const stagedIds = [];
 	const lines = [];
 	let skipped = 0;
 	const budget = Math.max(0, opts.maxImages);
@@ -1939,15 +1973,17 @@ async function stageImages(opts) {
 				i++;
 				continue;
 			}
-			const path = stagedPath(opts.dir, opts.key, i, ref.mediaType);
+			const path = stagedPath(opts.dir, opts.key, ref.attachmentId, ref.mediaType);
 			await writeFile(path, data);
 			staged.push({
 				path,
 				name: label,
 				width: ref.width,
 				height: ref.height,
-				bytes: ref.bytes
+				bytes: ref.bytes,
+				attachmentId: ref.attachmentId
 			});
+			stagedIds.push(ref.attachmentId);
 			lines.push("[image attached: \"" + label + "\" — staged at " + path + " (" + ref.width + "x" + ref.height + ", " + ref.bytes + " bytes). Inspect it using the view_file tool with AbsolutePath: \"" + path + "\"]");
 			i++;
 		}
@@ -1955,6 +1991,7 @@ async function stageImages(opts) {
 	return {
 		promptSuffix: lines.join("\n"),
 		staged,
+		stagedIds,
 		skipped
 	};
 }
@@ -1990,6 +2027,95 @@ function defaultMediaDir(stateDir) {
 //#endregion
 //#region src/host/runner.ts
 const IS_WIN = process.platform === "win32";
+/**
+* Windows pipes carry bytes in the CHILD's console code page: agy captures
+* pwsh tool output as CP936 (GBK) bytes on a zh-CN Windows, so decoding them
+* as UTF-8 mangles every non-ASCII character - and the mangled text is what
+* agy stores in its conversation database, so it can never be repaired later
+* (issue #37: the Chinese refusal text arrives mangled).
+*/
+const OEM_ENCODINGS = {
+	932: "shift_jis",
+	936: "gbk",
+	949: "euc-kr",
+	950: "big5",
+	65001: "utf-8",
+	1250: "windows-1250",
+	1251: "windows-1251",
+	1252: "windows-1252",
+	1253: "windows-1253",
+	1254: "windows-1254",
+	1255: "windows-1255",
+	1256: "windows-1256",
+	1257: "windows-1257",
+	1258: "windows-1258"
+};
+let consoleEncoding = null;
+/**
+* Console/OEM code page of this process as a TextDecoder label ('utf-8' off
+* Windows). Probed once; the child inherits our console, so its tool output is
+* written in this page.
+*/
+function consoleOutputEncoding(platform = process.platform) {
+	if (platform !== "win32") return "utf-8";
+	if (consoleEncoding !== null) return consoleEncoding;
+	consoleEncoding = "utf-8";
+	try {
+		const out = execFileSync(process.env.ComSpec ?? "cmd.exe", [
+			"/d",
+			"/s",
+			"/c",
+			"chcp"
+		], {
+			encoding: "utf8",
+			windowsHide: true,
+			timeout: 5e3
+		});
+		const m = /([0-9]{3,5})/.exec(out);
+		const cp = m ? Number(m[1]) : NaN;
+		const mapped = OEM_ENCODINGS[cp];
+		if (mapped !== void 0) consoleEncoding = mapped;
+	} catch {}
+	return consoleEncoding;
+}
+/**
+* Decode one LINE of child output: UTF-8 first, and when that produces
+* replacement characters re-decode those bytes with the console code page.
+* Lines (not raw chunks) are the unit on purpose - a multi-byte character can
+* straddle a chunk boundary but never a newline, in UTF-8 or the OEM pages.
+*/
+function decodeConsoleLine(bytes, encoding = consoleOutputEncoding()) {
+	const text = bytes.toString("utf8");
+	if (encoding === "utf-8" || !text.includes("�")) return text;
+	try {
+		const alt = new TextDecoder(encoding).decode(bytes);
+		return alt.includes("�") ? text : alt;
+	} catch {
+		return text;
+	}
+}
+/** Byte stream to decoded line text, holding an unterminated tail back. */
+function makeLineDecoder(encoding) {
+	let rest = Buffer.alloc(0);
+	return {
+		push(chunk) {
+			rest = rest.length === 0 ? chunk : Buffer.concat([rest, chunk]);
+			let out = "";
+			let nl;
+			while ((nl = rest.indexOf(10)) >= 0) {
+				out += decodeConsoleLine(rest.subarray(0, nl + 1), encoding);
+				rest = rest.subarray(nl + 1);
+			}
+			return out;
+		},
+		flush() {
+			if (rest.length === 0) return "";
+			const out = decodeConsoleLine(rest, encoding);
+			rest = Buffer.alloc(0);
+			return out;
+		}
+	};
+}
 /** Executable candidates for one PATH entry, per-platform. Exported for tests. */
 function binCandidates(dir, platform = process.platform) {
 	return (platform === "win32" ? [
@@ -2067,13 +2193,16 @@ function ensureIsolatedKeychain(dir, platform = process.platform, run = (file, a
 	if (platform !== "darwin") return false;
 	if (dir === "") return false;
 	const kc = join(dir, "Library", "Keychains", "login.keychain-db");
-	if (existsSync(kc)) return false;
 	try {
-		mkdirSync(join(dir, "Library", "Keychains"), { recursive: true });
 		const env = {
 			...process.env,
 			HOME: dir
 		};
+		if (existsSync(kc)) {
+			run("security", ["set-keychain-settings", kc], env);
+			return false;
+		}
+		mkdirSync(join(dir, "Library", "Keychains"), { recursive: true });
 		run("security", [
 			"create-keychain",
 			"-p",
@@ -2085,6 +2214,7 @@ function ensureIsolatedKeychain(dir, platform = process.platform, run = (file, a
 			"-s",
 			kc
 		], env);
+		run("security", ["set-keychain-settings", kc], env);
 		return true;
 	} catch {
 		return false;
@@ -2307,14 +2437,16 @@ function startAgyProcess(opts) {
 		killTree(child);
 	};
 	opts.signal?.addEventListener("abort", onAbort, { once: true });
-	if (child.stdout) child.stdout.setEncoding("utf8");
-	if (child.stderr) child.stderr.setEncoding("utf8");
+	const stdoutDecoder = makeLineDecoder(consoleOutputEncoding());
+	const stderrDecoder = makeLineDecoder(consoleOutputEncoding());
 	let pending = "";
 	child.stdout?.on("data", (chunk) => {
 		refreshWatchdog();
-		stdout += chunk;
+		const text = stdoutDecoder.push(chunk);
+		if (text === "") return;
+		stdout += text;
 		if (stdout.length > 4e6) stdout = stdout.slice(-2e6);
-		pending += chunk;
+		pending += text;
 		let nl;
 		while ((nl = pending.indexOf("\n")) >= 0) {
 			const line = pending.slice(0, nl).replace(/\r$/, "");
@@ -2324,7 +2456,8 @@ function startAgyProcess(opts) {
 	});
 	child.stderr?.on("data", (chunk) => {
 		if (opts.stderrKeepalive) refreshWatchdog();
-		stderr = (stderr + chunk).slice(-4096);
+		const text = stderrDecoder.push(chunk);
+		if (text !== "") stderr = (stderr + text).slice(-4096);
 	});
 	return {
 		child,
@@ -2334,6 +2467,13 @@ function startAgyProcess(opts) {
 				settled = true;
 				if (watchdog) clearTimeout(watchdog);
 				opts.signal?.removeEventListener("abort", onAbort);
+				const stdoutTail = stdoutDecoder.flush();
+				if (stdoutTail !== "") {
+					stdout += stdoutTail;
+					pending += stdoutTail;
+				}
+				const stderrTail = stderrDecoder.flush();
+				if (stderrTail !== "") stderr = (stderr + stderrTail).slice(-4096);
 				if (pending !== "") {
 					opts.onLine?.(pending);
 					pending = "";
@@ -2377,6 +2517,54 @@ async function probeProcess(bin, args, timeoutMs = 3e4, signal, env) {
 	}).outcome;
 }
 //#endregion
+//#region src/host/sessions.ts
+var SessionStore = class {
+	file;
+	data = {};
+	constructor(file) {
+		this.file = file;
+		this.load();
+	}
+	load() {
+		try {
+			if (!existsSync(this.file)) return;
+			const v = JSON.parse(readFileSync(this.file, "utf8"));
+			if (v && typeof v === "object") this.data = v;
+		} catch {}
+	}
+	get(key) {
+		return this.data[key];
+	}
+	set(key, b) {
+		this.data[key] = b;
+		this.persist();
+	}
+	delete(key) {
+		delete this.data[key];
+		this.persist();
+	}
+	clear() {
+		this.data = {};
+		this.persist();
+	}
+	all() {
+		return this.data;
+	}
+	/** Atomic write: tmp file + rename, then merge on next load. */
+	persist() {
+		try {
+			mkdirSync(dirname(this.file), { recursive: true });
+			const tmp = join(dirname(this.file), "." + require$$basename(this.file) + ".tmp");
+			writeFileSync(tmp, JSON.stringify(this.data, null, 2), "utf8");
+			renameSync(tmp, this.file);
+		} catch {}
+	}
+};
+function require$$basename(p) {
+	const i = Math.max(p.lastIndexOf("/"), p.lastIndexOf("\\"));
+	return i >= 0 ? p.slice(i + 1) : p;
+}
+//#endregion
 //#region src/host/agy-db.ts
 const execFileAsync = promisify(execFile);
 let AGY_DB_DIR = join(homedir(), ".gemini", "antigravity-cli", "conversations");
@@ -2886,6 +3074,47 @@ function digestLabel(m) {
 	return m.role === "user" ? "User: " : "Assistant: ";
 }
 /**
+* Images this hop should forward, minus what the current agy conversation
+* has already received. Trailing-span attachments come first (this hop's
+* screenshots), then any user-turn attachments since `fromIdx` that carry
+* unseen ids (tool-hop continuations and foreign-model turns used to fall
+* into a "re-send every historical screenshot" path).
+*/
+function collectUnsentImageRefs(messages, trailingUser, fromIdx, sentIds) {
+	const sent = new Set(sentIds);
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	const push = (m) => {
+		const refs = [];
+		collectImageRefs(m, refs);
+		for (const r of refs) {
+			const id = r.attachmentId;
+			if (typeof id !== "string" || id === "" || sent.has(id) || seen.has(id)) continue;
+			seen.add(id);
+			out.push(r);
+		}
+	};
+	for (const m of trailingUser) push(m);
+	const start = Math.max(0, Math.min(fromIdx, messages.length));
+	for (let i = start; i < messages.length; i++) {
+		const m = messages[i];
+		if (m === void 0 || m.role !== "user" || isToolResultMessage(m)) continue;
+		push(m);
+	}
+	return out;
+}
+/** Merge newly forwarded attachment ids into a bounded, oldest-first list. */
+function mergeSentImageIds(existing, added, max = 64) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const id of [...existing ?? [], ...added]) {
+		if (typeof id !== "string" || id === "" || seen.has(id)) continue;
+		seen.add(id);
+		out.push(id);
+	}
+	return out.length > max ? out.slice(out.length - max) : out;
+}
+/**
 * Rolling digest of turns this agy conversation has not seen (ADR-7).
 *
 * Budget policy (issue #35): the latest real user task is reserved first so
@@ -2964,6 +3193,14 @@ function sawAuthFailure(parser, outcome) {
 	if (parser.stats.sawAuthFailure) return true;
 	return looksLikeAuthFailure(outcome.stderrTail) || looksLikeAuthFailure(outcome.stdout.slice(0, 4e3));
 }
+/**
+* Bounded wait for an aborted run to settle, so a steer replacement never
+* overlaps the process it just killed on the same agy conversation.
+*/
+async function waitForRunSettle(run, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	while (!run.isSettled && Date.now() < deadline) await new Promise((r) => setTimeout(r, 50));
+}
 var AgyAdapter = class extends LlmAdapter {
 	deps;
 	warnedKeys = /* @__PURE__ */ new Set();
@@ -3002,6 +3239,11 @@ var AgyAdapter = class extends LlmAdapter {
 	/**
 	* Fail fast on auth and abort; allow one retry for transient process
 	* failures (timeout, crash, malformed stream) per ADR-11.
+	*
+	* RATE_LIMIT is retryable on purpose: the failed account was put into
+	* cooldown and the sticky pointer advanced before the error surfaced, so the
+	* retry is served by the NEXT account in the pool — quota exhaustion used to
+	* dead-end in a user-visible error even though a healthy account was idle.
 	*/
 	providerRetryPolicy(_provider) {
 		return {
@@ -3010,7 +3252,9 @@ var AgyAdapter = class extends LlmAdapter {
 			retryableCodes: [
 				Err.TIMEOUT,
 				Err.PROCESS_EXIT,
-				Err.INVALID_OUTPUT
+				Err.INVALID_OUTPUT,
+				Err.RATE_LIMIT,
+				Err.ELIGIBILITY
 			],
 			initialDelayMs: 2e3,
 			maxDelayMs: 1e4,
@@ -3210,14 +3454,25 @@ var AgyAdapter = class extends LlmAdapter {
 		let family = modelFamilyOf(activeModel);
 		let account = this.deps.pool ? this.deps.pool.selectAccount(family) : void 0;
 		if (this.deps.pool && this.deps.pool.getAccounts().length > 0 && !account) {
-			if (cfg.autoFallbackModel) for (const fb of ["gemini-3.5-flash", "gemini-3.6-flash"]) {
-				const fbFam = modelFamilyOf(fb);
-				const fbAcc = this.deps.pool.selectAccount(fbFam);
-				if (fbAcc) {
-					account = fbAcc;
-					family = fbFam;
-					activeModel = fb;
-					break;
+			if (cfg.autoFallbackModel) {
+				const familyModel = {
+					google: "gemini-3.8-flash",
+					anthropic: "claude-sonnet-4-6",
+					openai: "gpt-oss-120b-medium"
+				};
+				for (const fbFam of [
+					"google",
+					"anthropic",
+					"openai"
+				]) {
+					if (fbFam === family) continue;
+					const fbAcc = this.deps.pool.selectAccount(fbFam);
+					if (fbAcc) {
+						account = fbAcc;
+						family = fbFam;
+						activeModel = familyModel[fbFam] ?? activeModel;
+						break;
+					}
 				}
 			}
 			if (!account) {
@@ -3226,6 +3481,7 @@ var AgyAdapter = class extends LlmAdapter {
 				throw new LlmError(`All Antigravity accounts in pool are in cooldown for ${family}${waitStr}. Add an account or wait for reset.`, Err.AGY_ERROR);
 			}
 		}
+		if (account && !isAux) this.deps.pool?.markAccountActive(account.id);
 		const sessionAccountKey = account ? `${sessionKey}:${account.id}` : sessionKey;
 		let binding = sessionAccountKey !== "" ? this.deps.store.get(sessionAccountKey) : void 0;
 		if (binding === void 0 && !isAux && sessionKey !== "") {
@@ -3267,7 +3523,7 @@ var AgyAdapter = class extends LlmAdapter {
 			const trailingJoined = trailingText.join("\n\n");
 			if (taskText !== "") prompt = trailingText.includes(taskText) || trailingJoined.includes(taskText) ? trailingJoined : trailingJoined === "" ? taskText : taskText + "\n\n" + trailingJoined;
 			else prompt = trailingJoined;
-			if (binding === void 0 && lastAssistantIdx >= 0) prompt = buildDigest(messages, 0, cfg.digestMaxChars) + prompt;
+			if (binding === void 0 && lastAssistantIdx >= 0) prompt = buildDigest(messages, 0, cfg.contextTransferMaxChars) + prompt;
 			else if (binding !== void 0) {
 				const from = Math.min(binding.lastMessageCount, messages.length);
 				const end = Math.max(from, lastAssistantIdx + 1);
@@ -3277,18 +3533,15 @@ var AgyAdapter = class extends LlmAdapter {
 		}
 		if (cfg.forwardSystemPrompt && options.system) prompt = "System instructions:\n" + options.system + "\n\n" + prompt;
 		let stagedDirs = [];
+		const newlySentImageIds = [];
 		if (!isAux) {
-			const imageRefs = [];
-			for (const m of trailingUser) collectImageRefs(m, imageRefs);
-			if (imageRefs.length === 0) for (const m of messages) {
-				if (m.role !== "user" || isToolResultMessage(m)) continue;
-				collectImageRefs(m, imageRefs);
-			}
+			const sentIds = binding?.sentImageIds ?? [];
+			const imageRefs = collectUnsentImageRefs(messages, trailingUser, binding !== void 0 ? binding.lastMessageCount : 0, sentIds);
 			if (imageRefs.length > 0 && this.deps.readImage) {
 				const dir = cfg.mediaDir !== "" ? cfg.mediaDir : defaultMediaDir(stateDir());
 				const res = await stageImages({
 					dir,
-					key: (sessionKey !== "" ? sessionKey.replace(/[^a-zA-Z0-9_-]+/g, "_") : "anon") + "-" + messages.length,
+					key: sessionKey !== "" ? sessionKey.replace(/[^a-zA-Z0-9_-]+/g, "_") : "anon",
 					images: imageRefs,
 					readImage: this.deps.readImage,
 					maxImages: cfg.mediaMaxImages,
@@ -3296,6 +3549,7 @@ var AgyAdapter = class extends LlmAdapter {
 				});
 				if (res.promptSuffix !== "") prompt = prompt === "" ? res.promptSuffix + "\n\n[Please inspect the attached image(s) using view_file and assist the user.]" : prompt + "\n\n" + res.promptSuffix;
 				if (res.staged.length > 0) stagedDirs = [dir];
+				newlySentImageIds.push(...res.stagedIds);
 			}
 			if (prompt.trim() === "") throw new LlmError("request carries no user text or images to forward to agy", Err.AGY_ERROR);
 		} else if (prompt.trim() === "") throw new LlmError("request carries no user text to forward to agy", Err.AGY_ERROR);
@@ -3319,6 +3573,7 @@ var AgyAdapter = class extends LlmAdapter {
 					model: currentModel
 				};
 				liveRun.requestAbort?.();
+				await waitForRunSettle(liveRun, 3500);
 			}
 			this.activeSessionPrompts.set(sessionKey, {
 				prompt,
@@ -3445,20 +3700,19 @@ var AgyAdapter = class 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 silentTimeout = outcome.timedOut === true && outcome.stdout.trim() === "";
 			let failure = null;
 			if (outcome.aborted) failure = {
 				kind: "aborted",
 				code: "ABORTED",
 				message: "agy run aborted by caller"
 			};
-			else if (outcome.timedOut) {
-				const neverSpoke = outcome.stdout.trim() === "";
-				failure = {
-					kind: "error",
-					code: Err.TIMEOUT,
-					message: "agy run was idle for " + cfg.timeoutMs + "ms without output" + (neverSpoke ? " — agy never emitted a single event; it is likely unable to reach Google (check proxy/network). 无法连接 Google，请检查代理或网络配置" : "")
-				};
-			} else if (sawAuthFailure(parser, outcome)) failure = {
+			else if (outcome.timedOut) failure = {
+				kind: "error",
+				code: Err.TIMEOUT,
+				message: "agy run was idle for " + cfg.timeoutMs + "ms without output" + (silentTimeout ? " — agy never emitted a single event; it is likely unable to reach Google (check proxy/network). 无法连接 Google，请检查代理或网络配置" : "")
+			};
+			else if (sawAuthFailure(parser, outcome)) failure = {
 				kind: "error",
 				code: Err.AUTH,
 				message: "agy is not signed in — run /agy auth (or run agy once in a terminal) to login"
@@ -3467,14 +3721,14 @@ var AgyAdapter = class extends LlmAdapter {
 				const bestMsg = parser.stats.lastResultError || (outcome.stderrTail ? brief(outcome.stderrTail) : "Rate limit or quota reached");
 				failure = {
 					kind: "error",
-					code: Err.AGY_ERROR,
+					code: looksLikeHardRateLimit(rawErrText) ? Err.RATE_LIMIT : Err.AGY_ERROR,
 					message: "Google Antigravity quota / rate limit reached: " + bestMsg
 				};
 			} else if (looksLikeEligibilityFailure(rawErrText) || looksLikeEligibilityFailure(parser.stats.lastResultError ?? "")) {
 				const detail = parser.stats.lastResultError ?? (outcome.stderrTail !== "" ? brief(outcome.stderrTail) : "");
 				failure = {
 					kind: "error",
-					code: Err.AGY_ERROR,
+					code: Err.ELIGIBILITY,
 					message: ELIGIBILITY_ERROR_HINT + (detail !== "" ? " (" + detail + ")" : "")
 				};
 			} else if (!consumable) {
@@ -3505,12 +3759,15 @@ var AgyAdapter = class extends LlmAdapter {
 						conversationId: finalId,
 						lastMessageCount: messages.length,
 						updatedAt: Date.now(),
-						model: activeModel
+						model: activeModel,
+						sentImageIds: mergeSentImageIds(binding?.sentImageIds, newlySentImageIds)
 					});
 				}
 			} else {
 				const effectiveRateLimit = isRateLimit || looksLikeRateLimit(failure.message);
-				if (account && looksLikeHardRateLimit(rawErrText)) this.deps.pool?.recordFailure(account.id, family, failure.message);
+				if (account && !outcome.aborted && looksLikeHardRateLimit(rawErrText)) this.deps.pool?.recordFailure(account.id, family, failure.message);
+				if (account && silentTimeout) this.deps.pool?.advanceAccount(account.id, family);
+				if (account && failure.code === Err.ELIGIBILITY) this.deps.pool?.advanceAccount(account.id, family);
 				if (account && shouldMarkAuthRequired(failure.code, failure.message)) this.deps.pool?.markAuthRequired(account.id, failure.message);
 				const staleConversation = failure.code === Err.AUTH || effectiveRateLimit || failure.message && /conversation.*(not found|invalid|not recognized|expired|does not exist)|session.*(expired|invalid)/i.test(failure.message);
 				if (!isAux && sessionAccountKey !== "" && staleConversation) this.deps.store.delete(sessionAccountKey);
@@ -3520,7 +3777,8 @@ var AgyAdapter = class extends LlmAdapter {
 						conversationId: finalId,
 						lastMessageCount: messages.length,
 						updatedAt: Date.now(),
-						model: activeModel
+						model: activeModel,
+						sentImageIds: mergeSentImageIds(binding?.sentImageIds, newlySentImageIds)
 					});
 				}
 			}
@@ -28166,54 +28424,6 @@ function writeDoctorReport(deps) {
 	return file;
 }
 //#endregion
-//#region src/host/sessions.ts
-var SessionStore = class {
-	file;
-	data = {};
-	constructor(file) {
-		this.file = file;
-		this.load();
-	}
-	load() {
-		try {
-			if (!existsSync(this.file)) return;
-			const v = JSON.parse(readFileSync(this.file, "utf8"));
-			if (v && typeof v === "object") this.data = v;
-		} catch {}
-	}
-	get(key) {
-		return this.data[key];
-	}
-	set(key, b) {
-		this.data[key] = b;
-		this.persist();
-	}
-	delete(key) {
-		delete this.data[key];
-		this.persist();
-	}
-	clear() {
-		this.data = {};
-		this.persist();
-	}
-	all() {
-		return this.data;
-	}
-	/** Atomic write: tmp file + rename, then merge on next load. */
-	persist() {
-		try {
-			mkdirSync(dirname(this.file), { recursive: true });
-			const tmp = join(dirname(this.file), "." + require$$basename(this.file) + ".tmp");
-			writeFileSync(tmp, JSON.stringify(this.data, null, 2), "utf8");
-			renameSync(tmp, this.file);
-		} catch {}
-	}
-};
-function require$$basename(p) {
-	const i = Math.max(p.lastIndexOf("/"), p.lastIndexOf("\\"));
-	return i >= 0 ? p.slice(i + 1) : p;
-}
-//#endregion
 //#region src/host/pool.ts
 function defaultPoolDir() {
 	const dshState = process.env.DSH_STATE_DIR || join(homedir(), ".dsh");
@@ -28235,10 +28445,15 @@ var AccountPoolManager = class {
 			if (existsSync(this.file)) {
 				const raw = readFileSync(this.file, "utf8");
 				const parsed = JSON.parse(raw);
-				if (parsed && Array.isArray(parsed.accounts)) return {
-					...defaultPoolData(),
-					...parsed
-				};
+				if (parsed && Array.isArray(parsed.accounts)) {
+					for (const acc of parsed.accounts) if (acc.cooldowns) {
+						for (const [fam, cd] of Object.entries(acc.cooldowns)) if (cd && cd.reason === "agy run aborted by caller") delete acc.cooldowns[fam];
+					}
+					return {
+						...defaultPoolData(),
+						...parsed
+					};
+				}
 			}
 		} catch {}
 		return defaultPoolData();
@@ -28297,7 +28512,10 @@ var AccountPoolManager = class {
 		this.persist();
 	}
 	getPoolData() {
-		return this.data;
+		return {
+			...this.data,
+			activeAccountId: this.getActiveAccountId("google")
+		};
 	}
 	getAccounts() {
 		return this.data.accounts;
@@ -28430,6 +28648,7 @@ var AccountPoolManager = class {
 			});
 		} catch {}
 		if (this.data.primaryAccountId === id) this.data.primaryAccountId = void 0;
+		if (this.data.lastActiveAccountId === id) this.data.lastActiveAccountId = void 0;
 		if (this.data.activeAccountIds) {
 			for (const [fam, accId] of Object.entries(this.data.activeAccountIds)) if (accId === id) delete this.data.activeAccountIds[fam];
 		}
@@ -28455,18 +28674,31 @@ var AccountPoolManager = class {
 		const acc = this.getAccount(id);
 		if (!acc) return false;
 		acc.enabled = enabled;
-		if (!enabled && this.data.activeAccountIds) {
-			for (const [fam, accId] of Object.entries(this.data.activeAccountIds)) if (accId === id) delete this.data.activeAccountIds[fam];
+		if (!enabled) {
+			if (this.data.lastActiveAccountId === id) this.data.lastActiveAccountId = void 0;
+			if (this.data.activeAccountIds) {
+				for (const [fam, accId] of Object.entries(this.data.activeAccountIds)) if (accId === id) delete this.data.activeAccountIds[fam];
+			}
 		}
 		this.persist();
 		return true;
 	}
+	/**
+	* Record the account a run actually spawned with. The console derives its
+	* single "in use" badge from this; exactly one account runs agy at a time.
+	*/
+	markAccountActive(id) {
+		if (this.data.lastActiveAccountId === id) return;
+		this.data.lastActiveAccountId = id;
+		this.persist();
+	}
 	markAuthRequired(id, reason) {
 		const acc = this.getAccount(id);
 		if (!acc) return;
 		acc.authRequired = true;
 		acc.authMarkedAt = Date.now();
 		acc.authError = reason || "Authentication expired or revoked (invalid_grant)";
+		if (this.data.lastActiveAccountId === id) this.data.lastActiveAccountId = void 0;
 		if (this.data.activeAccountIds) {
 			for (const [fam, accId] of Object.entries(this.data.activeAccountIds)) if (accId === id) delete this.data.activeAccountIds[fam];
 		}
@@ -28508,6 +28740,7 @@ var AccountPoolManager = class {
 			anthropic: id,
 			openai: id
 		};
+		this.data.lastActiveAccountId = id;
 		this.persist();
 		return true;
 	}
@@ -28530,6 +28763,104 @@ var AccountPoolManager = class {
 		this.data.mode = mode;
 		this.persist();
 	}
+	/**
+	* Check whether an account is eligible to serve requests for the given family.
+	*/
+	isAccountEligible(acc, family, now = Date.now()) {
+		if (!acc.enabled || acc.authRequired) return false;
+		const cd = acc.cooldowns[family];
+		if (cd && cd.cooldownUntil > now) return false;
+		const quota = acc.quotas[family];
+		if (quota && typeof quota.remainingFraction === "number" && quota.remainingFraction <= .02) {
+			if (quota.resetTime) {
+				const resetMs = Date.parse(quota.resetTime);
+				if (!Number.isNaN(resetMs) && resetMs > now) return false;
+			}
+		}
+		if (quota && typeof quota.weeklyFraction === "number" && quota.weeklyFraction <= .01) {
+			if (quota.weeklyResetTime) {
+				const resetMs = Date.parse(quota.weeklyResetTime);
+				if (!Number.isNaN(resetMs) && resetMs > now) return false;
+			}
+		}
+		return true;
+	}
+	/**
+	* Returns the currently active and healthy account ID.
+	* If the recorded lastActiveAccountId is healthy, returns it;
+	* otherwise falls back to selectAccount(family) to advance to the next healthy candidate,
+	* or primaryAccountId if all are exhausted.
+	*/
+	getActiveAccountId(family = "google") {
+		const now = Date.now();
+		if (this.data.lastActiveAccountId) {
+			const active = this.getAccount(this.data.lastActiveAccountId);
+			if (active && this.isAccountEligible(active, family, now)) return active.id;
+		}
+		const next = this.selectAccount(family);
+		if (next) return next.id;
+		return this.data.primaryAccountId ?? this.data.accounts[0]?.id;
+	}
+	/**
+	* Next moment this account's quota state refreshes for one family: the
+	* sooner of the 5h window reset and the weekly cap reset. NaN when unknown.
+	*/
+	nextQuotaResetAt(acc, family) {
+		const q = acc.quotas[family];
+		const stamps = [q?.resetTime, q?.weeklyResetTime].filter((v) => typeof v === "string" && v !== "").map((v) => Date.parse(v)).filter((t) => !Number.isNaN(t));
+		return stamps.length === 0 ? NaN : Math.min(...stamps);
+	}
+	/** Cyclic distance from `fromId` (0 = itself), so ties keep pool order. */
+	cyclicDistance(fromId, id) {
+		const total = this.data.accounts.length;
+		const idx = this.data.accounts.findIndex((a) => a.id === id);
+		if (idx === -1) return Number.MAX_SAFE_INTEGER;
+		if (fromId === void 0) return idx;
+		const start = this.data.accounts.findIndex((a) => a.id === fromId);
+		if (start === -1) return idx;
+		return (idx - start + total) % total;
+	}
+	/**
+	* "Use it or lose it" rotation order. When the sticky account is drained we
+	* prefer the eligible account whose quota window refreshes SOONEST: residual
+	* quota disappears at that reset, so draining it first is free capacity the
+	* pool would otherwise throw away. Accounts with no quota metadata yet keep
+	* the legacy cyclic order (which also keeps a drained slot from bouncing
+	* straight back to the primary).
+	*/
+	orderByExpiry(candidates, family, fromId) {
+		return candidates.map((acc, index) => ({
+			acc,
+			index,
+			at: this.nextQuotaResetAt(acc, family)
+		})).sort((a, b) => {
+			const aKnown = !Number.isNaN(a.at);
+			const bKnown = !Number.isNaN(b.at);
+			if (aKnown !== bKnown) return aKnown ? -1 : 1;
+			if (aKnown && bKnown && a.at !== b.at) return a.at - b.at;
+			const da = this.cyclicDistance(fromId, a.acc.id);
+			const db = this.cyclicDistance(fromId, b.acc.id);
+			return da !== db ? da - db : a.index - b.index;
+		}).map((e) => e.acc);
+	}
+	/**
+	* Move the active pointer past `fromId` for one family WITHOUT cooling the
+	* account down, and return the account the next run should use. Used when a
+	* run produced no output at all (silent timeout): the retry must try another
+	* account, but a healthy account should not be punished with a cooldown
+	* because the network blipped.
+	*/
+	advanceAccount(fromId, family) {
+		const now = Date.now();
+		const candidates = this.data.accounts.filter((a) => a.id !== fromId && this.isAccountEligible(a, family, now));
+		if (candidates.length === 0) return null;
+		const next = this.orderByExpiry(candidates, family, fromId)[0];
+		if (!this.data.activeAccountIds) this.data.activeAccountIds = {};
+		this.data.activeAccountIds[family] = next.id;
+		this.data.lastActiveAccountId = next.id;
+		this.persist();
+		return next.id;
+	}
 	updateAccountQuotas(id, quotas, email) {
 		const acc = this.getAccount(id);
 		if (!acc) return;
@@ -28538,6 +28869,15 @@ var AccountPoolManager = class {
 			...quotas
 		};
 		if (email) acc.email = email;
+		const now = Date.now();
+		for (const [famKey, info] of Object.entries(quotas)) {
+			if (!info) continue;
+			const isExhausted5h = typeof info.remainingFraction === "number" && info.remainingFraction <= .02 && (!info.resetTime || Date.parse(info.resetTime) > now);
+			const isExhaustedWeekly = typeof info.weeklyFraction === "number" && info.weeklyFraction <= .01 && (!info.weeklyResetTime || Date.parse(info.weeklyResetTime) > now);
+			if (isExhausted5h || isExhaustedWeekly) {
+				if (this.data.activeAccountIds?.[famKey] === id || this.data.lastActiveAccountId === id) this.selectAccount(famKey);
+			}
+		}
 		this.persist();
 	}
 	/**
@@ -28560,6 +28900,7 @@ var AccountPoolManager = class {
 			reason,
 			consecutiveFailures: failures
 		};
+		if (this.data.activeAccountIds?.[family] === id || this.data.lastActiveAccountId === id) this.selectAccount(family);
 		this.persist();
 	}
 	/**
@@ -28594,48 +28935,33 @@ var AccountPoolManager = class {
 	*/
 	selectAccount(family) {
 		const now = Date.now();
-		const candidates = this.data.accounts.filter((acc) => {
-			if (!acc.enabled || acc.authRequired) return false;
-			const cd = acc.cooldowns[family];
-			if (cd && cd.cooldownUntil > now) return false;
-			const quota = acc.quotas[family];
-			if (quota && typeof quota.remainingFraction === "number" && quota.remainingFraction <= .02) {
-				if (quota.resetTime) {
-					const resetMs = Date.parse(quota.resetTime);
-					if (!Number.isNaN(resetMs) && resetMs > now) return false;
-				}
-			}
-			if (quota && typeof quota.weeklyFraction === "number" && quota.weeklyFraction <= .01) {
-				if (quota.weeklyResetTime) {
-					const resetMs = Date.parse(quota.weeklyResetTime);
-					if (!Number.isNaN(resetMs) && resetMs > now) return false;
-				}
-			}
-			return true;
-		});
+		const candidates = this.data.accounts.filter((acc) => this.isAccountEligible(acc, family, now));
 		if (candidates.length === 0) return null;
-		if (this.data.mode === "round-robin" && candidates.length > 1) return candidates.slice().sort((a, b) => (a.lastUsedAt ?? 0) - (b.lastUsedAt ?? 0))[0] ?? null;
+		if (this.data.mode === "round-robin" && candidates.length > 1) {
+			const picked = candidates.slice().sort((a, b) => (a.lastUsedAt ?? 0) - (b.lastUsedAt ?? 0))[0] ?? null;
+			if (picked) {
+				if (!this.data.activeAccountIds) this.data.activeAccountIds = {};
+				this.data.activeAccountIds[family] = picked.id;
+				this.data.lastActiveAccountId = picked.id;
+				this.persist();
+			}
+			return picked;
+		}
 		const activeId = this.data.activeAccountIds?.[family];
 		if (activeId) {
 			const activeCandidate = candidates.find((a) => a.id === activeId);
-			if (activeCandidate) return activeCandidate;
-		}
-		let nextAccount = candidates[0];
-		if (activeId) {
-			const currentIndex = this.data.accounts.findIndex((a) => a.id === activeId);
-			if (currentIndex !== -1) {
-				const total = this.data.accounts.length;
-				for (let i = 1; i < total; i++) {
-					const checkAcc = this.data.accounts[(currentIndex + i) % total];
-					if (candidates.some((c) => c.id === checkAcc.id)) {
-						nextAccount = checkAcc;
-						break;
-					}
+			if (activeCandidate) {
+				if (this.data.lastActiveAccountId !== activeCandidate.id) {
+					this.data.lastActiveAccountId = activeCandidate.id;
+					this.persist();
 				}
+				return activeCandidate;
 			}
 		}
+		const nextAccount = this.orderByExpiry(candidates, family, activeId)[0];
 		if (!this.data.activeAccountIds) this.data.activeAccountIds = {};
 		this.data.activeAccountIds[family] = nextAccount.id;
+		this.data.lastActiveAccountId = nextAccount.id;
 		this.persist();
 		return nextAccount;
 	}
@@ -29954,6 +30280,31 @@ function apply(ctx, entryConfig = {}) {
 				})();
 			}
 		});
+		reg({
+			kind: "exact",
+			path: "/plugins/agy-link/mermaid.min.js",
+			handler: (_req, res) => {
+				const p = join(import.meta.dirname, "mermaid.min.js");
+				const fallback = join(import.meta.dirname, "..", "assets", "mermaid.min.js");
+				const file = existsSync(p) ? p : existsSync(fallback) ? fallback : null;
+				if (!file) {
+					res.writeHead(404, { "content-type": "text/plain" });
+					res.end("mermaid.min.js not found");
+					return;
+				}
+				try {
+					const content = readFileSync(file);
+					res.writeHead(200, {
+						"content-type": "application/javascript; charset=utf-8",
+						"cache-control": "public, max-age=86400"
+					});
+					res.end(content);
+				} catch (err) {
+					res.writeHead(500, { "content-type": "text/plain" });
+					res.end("read error: " + String(err));
+				}
+			}
+		});
 		reg({
 			kind: "exact",
 			path: "/plugins/agy-link/pool",