dsh-agy-link 0.1.2

package/dist/index.js

@@ -0,0 +1,2285 @@
+import { delimiter, dirname, join } from "node:path";
+import { accessSync, constants, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { LlmAdapter, LlmError } from "@deepseek-ai/dsh-llm";
+import { execFileSync, spawn } from "node:child_process";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+//#region src/common/types.ts
+const PROVIDER_ID = "antigravity";
+const PLUGIN_ID = "agy-link";
+const DEFAULT_FALLBACK_MODELS = [
+	{
+		id: "gemini-3-6-flash",
+		name: "Gemini 3.6 Flash",
+		efforts: [
+			"low",
+			"medium",
+			"high"
+		]
+	},
+	{
+		id: "gemini-3-1-pro",
+		name: "Gemini 3.1 Pro",
+		efforts: ["low", "high"]
+	},
+	{
+		id: "claude-sonnet-4-6",
+		name: "Claude Sonnet 4.6 (Thinking)"
+	}
+];
+function defaultConfig() {
+	return {
+		enabled: true,
+		agyBin: "",
+		extraArgs: [],
+		permissionMode: "skip",
+		defaultModel: "",
+		defaultEffort: "",
+		timeoutMs: 6e5,
+		maxConcurrent: 3,
+		contextWindowDefault: 1048576,
+		maxTokensDefault: 65536,
+		forwardSystemPrompt: false,
+		digestMaxChars: 8e3,
+		modelsCacheTtlMs: 3e5,
+		allowAuxiliary: true,
+		compactionMaxChars: 8e5,
+		workspaceRoot: "",
+		fallbackModels: DEFAULT_FALLBACK_MODELS,
+		askTool: false
+	};
+}
+const Err = {
+	AUTH: "AUTH",
+	AGY_NOT_INSTALLED: "AGY_NOT_INSTALLED",
+	AGY_VERSION_UNSUPPORTED: "AGY_VERSION_UNSUPPORTED",
+	AGY_ERROR: "AGY_ERROR",
+	TIMEOUT: "TIMEOUT",
+	PROCESS_EXIT: "PROCESS_EXIT",
+	INVALID_OUTPUT: "INVALID_OUTPUT",
+	UNKNOWN_MODEL: "UNKNOWN_MODEL",
+	UNSUPPORTED_REASONING_EFFORT: "UNSUPPORTED_REASONING_EFFORT",
+	AUX_DISABLED: "AUX_DISABLED",
+	BUSY: "BUSY"
+};
+function looksLikeAuthFailure(text) {
+	return /authentication required|authentication failed|please sign in|not signed in|timed out waiting for authentication/i.test(text);
+}
+function extractAuthUrl(text) {
+	const m = text.match(/https:\/\/accounts\.google\.com\/\S+/);
+	if (!m) return void 0;
+	return m[0].replace(/[)\]>.,;\x27\x22]+$/, "");
+}
+//#endregion
+//#region src/common/config.ts
+function dshHome() {
+	return process.env.DSH_HOME ?? join(homedir(), ".dsh");
+}
+function stateDir() {
+	return join(dshHome(), "agy-link");
+}
+function overridesPath() {
+	return join(stateDir(), "runtime-overrides.json");
+}
+function readJson(file) {
+	try {
+		if (!existsSync(file)) return {};
+		const v = JSON.parse(readFileSync(file, "utf8"));
+		return v && typeof v === "object" ? v : {};
+	} catch {
+		return {};
+	}
+}
+function readOverrides(file = overridesPath()) {
+	return readJson(file);
+}
+function asString(v) {
+	return typeof v === "string" ? v : void 0;
+}
+function asBool(v) {
+	if (typeof v === "boolean") return v;
+	if (typeof v === "string") return v === "true" || v === "1";
+}
+function asNum(v) {
+	if (typeof v === "number" && Number.isFinite(v)) return v;
+	if (typeof v === "string" && v.trim() !== "" && Number.isFinite(Number(v))) return Number(v);
+}
+const MODES = [
+	"skip",
+	"plan",
+	"accept-edits"
+];
+function asMode(v) {
+	return typeof v === "string" && MODES.includes(v) ? v : void 0;
+}
+/** Layered config read; cheap enough to call per request (thunk pattern). */
+function resolveConfig(entry, env = process.env, overrides = readOverrides()) {
+	const base = defaultConfig();
+	const layers = [entry ?? {}, overrides];
+	const get = (k) => {
+		for (const l of layers) if (l[k] !== void 0 && l[k] !== null && l[k] !== "") return l[k];
+	};
+	const cfg = {
+		...base,
+		enabled: asBool(get("enabled")) ?? base.enabled,
+		agyBin: asString(get("agyBin")) ?? base.agyBin,
+		extraArgs: Array.isArray(get("extraArgs")) ? get("extraArgs").filter((x) => typeof x === "string") : base.extraArgs,
+		permissionMode: asMode(get("permissionMode")) ?? base.permissionMode,
+		defaultModel: asString(get("defaultModel")) ?? base.defaultModel,
+		defaultEffort: asString(get("defaultEffort")) ?? base.defaultEffort,
+		timeoutMs: asNum(get("timeoutMs")) ?? base.timeoutMs,
+		maxConcurrent: asNum(get("maxConcurrent")) ?? base.maxConcurrent,
+		contextWindowDefault: asNum(get("contextWindowDefault")) ?? base.contextWindowDefault,
+		maxTokensDefault: asNum(get("maxTokensDefault")) ?? base.maxTokensDefault,
+		forwardSystemPrompt: asBool(get("forwardSystemPrompt")) ?? base.forwardSystemPrompt,
+		digestMaxChars: asNum(get("digestMaxChars")) ?? base.digestMaxChars,
+		modelsCacheTtlMs: asNum(get("modelsCacheTtlMs")) ?? base.modelsCacheTtlMs,
+		allowAuxiliary: asBool(get("allowAuxiliary")) ?? base.allowAuxiliary,
+		compactionMaxChars: asNum(get("compactionMaxChars")) ?? base.compactionMaxChars,
+		workspaceRoot: asString(get("workspaceRoot")) ?? base.workspaceRoot,
+		fallbackModels: Array.isArray(get("fallbackModels")) ? get("fallbackModels").filter((x) => !!x && typeof x === "object" && typeof x.id === "string") : base.fallbackModels,
+		askTool: asBool(get("askTool")) ?? base.askTool
+	};
+	if (env.DSH_AGY_ENABLED !== void 0) cfg.enabled = asBool(env.DSH_AGY_ENABLED) ?? cfg.enabled;
+	if (env.DSH_AGY_BIN) cfg.agyBin = env.DSH_AGY_BIN;
+	if (env.DSH_AGY_MODE) {
+		const m = asMode(env.DSH_AGY_MODE);
+		if (m) cfg.permissionMode = m;
+	}
+	if (env.DSH_AGY_SKIP_PERMISSIONS !== void 0) {
+		const skip = asBool(env.DSH_AGY_SKIP_PERMISSIONS);
+		if (skip !== void 0) cfg.permissionMode = skip ? "skip" : "plan";
+	}
+	if (env.DSH_AGY_DEFAULT_MODEL) cfg.defaultModel = env.DSH_AGY_DEFAULT_MODEL;
+	if (env.DSH_AGY_DEFAULT_EFFORT) cfg.defaultEffort = env.DSH_AGY_DEFAULT_EFFORT;
+	if (env.DSH_AGY_TIMEOUT_MS) {
+		const t = asNum(env.DSH_AGY_TIMEOUT_MS);
+		if (t && t > 0) cfg.timeoutMs = t;
+	}
+	if (env.DSH_AGY_EXTRA_ARGS) cfg.extraArgs = env.DSH_AGY_EXTRA_ARGS.split(/\s+/).filter(Boolean);
+	return cfg;
+}
+//#endregion
+//#region src/host/discovery.ts
+function defaultConversationsDir() {
+	return process.env.DSH_AGY_CONVERSATIONS_DIR ?? join(homedir(), ".gemini", "antigravity-cli", "conversations");
+}
+function snapshotConversations(dir = defaultConversationsDir()) {
+	const files = /* @__PURE__ */ new Map();
+	try {
+		if (existsSync(dir)) for (const name of readdirSync(dir)) {
+			if (!name.endsWith(".db")) continue;
+			try {
+				files.set(name, statSync(join(dir, name)).mtimeMs);
+			} catch {}
+		}
+	} catch {}
+	return {
+		dir,
+		files
+	};
+}
+function diffConversations(before, dir = defaultConversationsDir()) {
+	const after = snapshotConversations(dir);
+	const added = [];
+	for (const [name, mtime] of after.files) if (!before.files.has(name)) added.push({
+		name,
+		mtime
+	});
+	if (added.length === 0) return {
+		conversationId: null,
+		ambiguous: false
+	};
+	added.sort((a, b) => b.mtime - a.mtime);
+	const top = added[0];
+	return {
+		conversationId: top !== void 0 ? top.name.replace(/\.db$/, "") : "",
+		ambiguous: added.length > 1
+	};
+}
+//#endregion
+//#region src/host/mapper.ts
+function briefArgs(args) {
+	if (args === void 0 || args === null) return "";
+	try {
+		const s = typeof args === "string" ? args : JSON.stringify(args);
+		return s.length > 300 ? s.slice(0, 300) + "..." : s;
+	} catch {
+		return String(args).slice(0, 120);
+	}
+}
+function defaultAnnounce(name, args) {
+	const brief = briefArgs(args);
+	return brief === "" ? "[agy tool: " + name + "]\n" : "[agy tool: " + name + "] " + brief + "\n";
+}
+function defaultOutput(output) {
+	if (output === void 0 || output === null) return null;
+	let s;
+	try {
+		s = typeof output === "string" ? output : JSON.stringify(output);
+	} catch {
+		s = String(output);
+	}
+	if (s === "") return null;
+	return "-> " + (s.length > 2048 ? s.slice(0, 2048) + "... (+" + (s.length - 2048) + " chars)" : s) + "\n";
+}
+function usageFromRaw(raw) {
+	return {
+		inputTokens: raw.input_tokens ?? 0,
+		outputTokens: raw.output_tokens ?? 0,
+		cacheReadTokens: raw.cache_read_tokens ?? void 0,
+		cacheWriteTokens: raw.cache_write_tokens ?? void 0,
+		reasoningTokens: raw.thinking_tokens ?? void 0
+	};
+}
+/** Suffix-delta: emit only what grew; fall back to a newline + full text. */
+function suffixDelta(prev, next) {
+	if (next === prev) return "";
+	if (prev === "") return next;
+	if (next.startsWith(prev)) return next.slice(prev.length);
+	return "\n" + next;
+}
+var EventMapper = class {
+	opts;
+	blockIdx = 0;
+	openType = null;
+	openAcc = "";
+	emittedByKey = /* @__PURE__ */ new Map();
+	toolPhaseSeen = /* @__PURE__ */ new Set();
+	sawTextStep = false;
+	finished = false;
+	constructor(opts = {}) {
+		this.opts = opts;
+	}
+	/** Whether a terminal finish chunk has been emitted. */
+	get isFinished() {
+		return this.finished;
+	}
+	*ensureBlock(type) {
+		if (this.openType === type) return;
+		const close = this.closeOpen();
+		if (close) yield close;
+		this.openType = type;
+		this.openAcc = "";
+		yield {
+			type: "block-start",
+			index: this.blockIdx,
+			blockType: type
+		};
+	}
+	closeOpen() {
+		if (this.openType === null) return null;
+		const block = this.openType === "text" ? {
+			type: "text",
+			text: this.openAcc
+		} : {
+			type: "reasoning",
+			text: this.openAcc
+		};
+		const chunk = {
+			type: "block-end",
+			index: this.blockIdx,
+			block
+		};
+		this.blockIdx++;
+		this.openType = null;
+		this.openAcc = "";
+		return chunk;
+	}
+	appendDelta(delta) {
+		if (delta === "") return null;
+		this.openAcc += delta;
+		return this.openType === "text" ? {
+			type: "text-delta",
+			index: this.blockIdx,
+			text: delta
+		} : {
+			type: "reasoning-delta",
+			index: this.blockIdx,
+			text: delta
+		};
+	}
+	*map(ev) {
+		if (this.finished) return;
+		if (ev.kind === "init") return;
+		if (ev.kind === "garbage") return;
+		if (ev.kind === "step") {
+			if (ev.stepKind === "text") {
+				this.sawTextStep = true;
+				yield* this.ensureBlock("text");
+				const delta = suffixDelta(this.emittedByKey.get(ev.stepKey) ?? "", ev.text);
+				this.emittedByKey.set(ev.stepKey, ev.text);
+				const d = this.appendDelta(delta);
+				if (d) yield d;
+				return;
+			}
+			if (ev.stepKind === "thinking" || ev.stepKind === "tool" || ev.stepKind === "subagent") {
+				yield* this.ensureBlock("reasoning");
+				if (ev.stepKind === "thinking") {
+					const delta = suffixDelta(this.emittedByKey.get(ev.stepKey) ?? "", ev.text);
+					this.emittedByKey.set(ev.stepKey, ev.text);
+					const d = this.appendDelta(delta);
+					if (d) yield d;
+				} else if (ev.stepKind === "tool" && ev.tool) {
+					const announceKey = ev.stepKey + ":a";
+					if (!this.toolPhaseSeen.has(announceKey)) {
+						this.toolPhaseSeen.add(announceKey);
+						const line = (this.opts.announce ?? defaultAnnounce)(ev.tool.name, ev.tool.args);
+						const d = this.appendDelta(line);
+						if (d) yield d;
+					}
+					const outKey = ev.stepKey + ":o";
+					if (ev.tool.output !== void 0 && !this.toolPhaseSeen.has(outKey)) {
+						this.toolPhaseSeen.add(outKey);
+						const rendered = this.opts.toolOutput ? this.opts.toolOutput(ev.tool.name, ev.tool.args, ev.tool.output) : defaultOutput(ev.tool.output);
+						if (rendered !== null) {
+							const d = this.appendDelta(rendered);
+							if (d) yield d;
+						}
+					}
+				} else if (ev.stepKind === "subagent") {
+					const d = this.appendDelta("[agy subagent] " + ev.text + "\n");
+					if (d) yield d;
+				}
+				return;
+			}
+			return;
+		}
+		if (!ev.ok) return;
+		if (!this.sawTextStep && ev.response !== "") {
+			yield* this.ensureBlock("text");
+			const d = this.appendDelta(ev.response);
+			if (d) yield d;
+		}
+		const close = this.closeOpen();
+		if (close) yield close;
+		yield {
+			type: "usage",
+			usage: usageFromRaw(ev.usage)
+		};
+		yield {
+			type: "finish",
+			reason: { kind: "stop" },
+			replayState: ev.conversationId !== "" ? { response: { conversationId: ev.conversationId } } : void 0
+		};
+		this.finished = true;
+	}
+	/** Terminal error/abort: close what is open, zero usage, failure finish. */
+	*emitFailure(kind, code, message) {
+		if (this.finished) return;
+		const close = this.closeOpen();
+		if (close) yield close;
+		yield {
+			type: "usage",
+			usage: {
+				inputTokens: 0,
+				outputTokens: 0
+			}
+		};
+		yield {
+			type: "finish",
+			reason: kind === "error" ? {
+				kind: "error",
+				failure: {
+					message,
+					code
+				}
+			} : {
+				kind: "aborted",
+				failure: {
+					message,
+					code
+				}
+			}
+		};
+		this.finished = true;
+	}
+};
+//#endregion
+//#region src/host/models.ts
+/** Parse `agy models` stdout: JSON shapes first, then two-column text. */
+function parseModelsOutput(stdout) {
+	const text = stdout.trim();
+	if (text === "") return [];
+	try {
+		const list = extractModelList(JSON.parse(text));
+		if (list) return list;
+	} catch {}
+	const out = [];
+	for (const line of text.split(/\n/)) {
+		const t = line.trim();
+		if (t === "" || t.startsWith("Fetching") || t.startsWith("Error")) continue;
+		const m = t.match(/^(\S+)\s{2,}(.+)$/);
+		if (m && m[1] !== void 0 && m[2] !== void 0) out.push({
+			slug: m[1],
+			label: m[2].trim()
+		});
+		else if (/^\S+$/.test(t)) out.push({
+			slug: t,
+			label: t
+		});
+	}
+	return out;
+}
+function extractModelList(parsed) {
+	let arr = null;
+	if (Array.isArray(parsed)) arr = parsed;
+	else if (parsed && typeof parsed === "object") {
+		const o = parsed;
+		for (const k of [
+			"models",
+			"items",
+			"data",
+			"result"
+		]) if (Array.isArray(o[k])) {
+			arr = o[k];
+			break;
+		}
+	}
+	if (!arr) return null;
+	const out = [];
+	for (const item of arr) {
+		if (typeof item === "string") {
+			out.push({
+				slug: item,
+				label: item
+			});
+			continue;
+		}
+		if (!item || typeof item !== "object") continue;
+		const o = item;
+		const slugV = o.slug ?? o.id ?? o.name ?? o.model;
+		const labelV = o.label ?? o.display_name ?? o.displayName ?? o.title ?? slugV;
+		if (typeof slugV === "string" && slugV !== "") out.push({
+			slug: slugV,
+			label: typeof labelV === "string" ? labelV : slugV
+		});
+	}
+	return out;
+}
+const EFFORT_SUFFIXES = [
+	"low",
+	"medium",
+	"high"
+];
+/** Fold Gemini effort variants into base + effort set (spec ADR-10). */
+function foldEfforts(raw) {
+	const bases = /* @__PURE__ */ new Map();
+	const verbatim = [];
+	const slugSet = new Set(raw.map((r) => r.slug));
+	for (const r of raw) {
+		if (!r.slug.startsWith("gemini")) {
+			verbatim.push({
+				id: r.slug,
+				name: r.label,
+				efforts: null
+			});
+			continue;
+		}
+		let folded = false;
+		for (const eff of EFFORT_SUFFIXES) {
+			const suffix = "-" + eff;
+			if (r.slug.endsWith(suffix)) {
+				const base = r.slug.slice(0, -suffix.length);
+				const hasBare = slugSet.has(base);
+				const hasSibling = raw.some((x) => x.slug.startsWith(base + "-") && EFFORT_SUFFIXES.some((e) => x.slug.endsWith("-" + e)) && x.slug !== r.slug);
+				if (hasBare || hasSibling) {
+					const entry = bases.get(base) ?? {
+						label: stripEffortLabel(r.label, eff),
+						efforts: /* @__PURE__ */ new Set()
+					};
+					entry.efforts.add(eff);
+					bases.set(base, entry);
+					folded = true;
+					break;
+				}
+			}
+		}
+		if (!folded) verbatim.push({
+			id: r.slug,
+			name: r.label,
+			efforts: null
+		});
+	}
+	const folded = [];
+	for (const [id, v] of bases) {
+		const efforts = EFFORT_SUFFIXES.filter((e) => v.efforts.has(e));
+		folded.push({
+			id,
+			name: v.label !== "" ? v.label : id,
+			efforts: efforts.length > 0 ? efforts : null
+		});
+	}
+	const rawOrder = new Map(raw.map((r, i) => [r.slug, i]));
+	const rank = (e) => {
+		let best = Infinity;
+		for (const r of raw) if (r.slug === e.id || r.slug.startsWith(e.id + "-")) best = Math.min(best, rawOrder.get(r.slug) ?? Infinity);
+		return best;
+	};
+	folded.sort((a, b) => rank(a) - rank(b));
+	verbatim.sort((a, b) => rank(a) - rank(b));
+	return [...folded, ...verbatim];
+}
+function stripEffortLabel(label, eff) {
+	const re = new RegExp("\\s*\\(?" + eff + "\\)?\\s*$", "i");
+	return label.replace(re, "").trim();
+}
+function buildFallbackCatalog(defs) {
+	return defs.map((d) => ({
+		id: d.id,
+		name: d.name,
+		efforts: d.efforts ?? null
+	}));
+}
+var ModelCatalog = class {
+	discover;
+	ttlMs;
+	current;
+	refreshing = null;
+	constructor(discover, fallbackDefs, ttlMs) {
+		this.discover = discover;
+		this.ttlMs = ttlMs;
+		this.current = {
+			source: "fallback",
+			models: buildFallbackCatalog(fallbackDefs),
+			discoveredAt: 0
+		};
+	}
+	get() {
+		return this.current;
+	}
+	/** Refresh if stale; never throws — failures keep the previous catalog. */
+	async refreshIfNeeded() {
+		if (this.refreshing) return this.refreshing;
+		const age = Date.now() - this.current.discoveredAt;
+		if (this.current.source === "discovered" && age < this.ttlMs) return;
+		this.refreshing = this.refresh().finally(() => {
+			this.refreshing = null;
+		});
+		return this.refreshing;
+	}
+	async forceRefresh() {
+		await this.refresh();
+		return this.current;
+	}
+	async refresh() {
+		try {
+			const ac = new AbortController();
+			const timer = setTimeout(() => ac.abort(), 3e4);
+			try {
+				const { stdout } = await this.discover(ac.signal);
+				const raw = parseModelsOutput(stdout);
+				if (raw.length > 0) {
+					this.current = {
+						source: "discovered",
+						models: foldEfforts(raw),
+						discoveredAt: Date.now()
+					};
+					return;
+				}
+				this.current = {
+					...this.current,
+					lastError: "agy models returned no entries"
+				};
+			} finally {
+				clearTimeout(timer);
+			}
+		} catch (err) {
+			this.current = {
+				...this.current,
+				lastError: err instanceof Error ? err.message : String(err)
+			};
+		}
+	}
+};
+function findEntry(catalog, id) {
+	return catalog.models.find((m) => m.id === id);
+}
+function defaultEffortFor(entry, cfg) {
+	if (!entry.efforts) return void 0;
+	if (cfg.defaultEffort !== "" && entry.efforts.includes(cfg.defaultEffort)) return cfg.defaultEffort;
+	return entry.efforts.includes("medium") ? "medium" : entry.efforts[entry.efforts.length - 1];
+}
+//#endregion
+//#region src/host/parser.ts
+const TEXT_STEP_TYPES = /* @__PURE__ */ new Set([
+	"agent_text",
+	"agenttext",
+	"text",
+	"model_response",
+	"modelresponse",
+	"message",
+	"response_text"
+]);
+const THINKING_STEP_TYPES = /* @__PURE__ */ new Set([
+	"thinking",
+	"thought",
+	"reasoning"
+]);
+const TOOL_STEP_TYPES = /* @__PURE__ */ new Set([
+	"tool_call",
+	"toolcall",
+	"tool",
+	"tool_use",
+	"tooluse",
+	"tool_run",
+	"toolrun",
+	"function_call"
+]);
+const TITLE_STEP_TYPES = /* @__PURE__ */ new Set(["title"]);
+const SUBAGENT_STEP_TYPES = /* @__PURE__ */ new Set([
+	"subagent",
+	"subagent_message",
+	"subagent_result"
+]);
+const USER_INPUT_STEP_TYPES = /* @__PURE__ */ new Set([
+	"user_input",
+	"userinput",
+	"user_message"
+]);
+const NUMERIC_STEP_TYPES = {
+	14: "thinking",
+	15: "text",
+	23: "title",
+	5: "tool",
+	7: "tool",
+	8: "tool",
+	9: "tool",
+	17: "tool",
+	21: "tool",
+	33: "tool",
+	101: "tool",
+	132: "tool",
+	138: "tool",
+	139: "tool"
+};
+function pick(obj, keys) {
+	for (const k of keys) {
+		const v = obj[k];
+		if (v !== void 0 && v !== null) return v;
+	}
+}
+function normalizeStepKind(v) {
+	if (typeof v === "number") return NUMERIC_STEP_TYPES[v] ?? "unknown";
+	if (typeof v === "string") {
+		const s = v.toLowerCase();
+		if (TEXT_STEP_TYPES.has(s)) return "text";
+		if (THINKING_STEP_TYPES.has(s)) return "thinking";
+		if (TOOL_STEP_TYPES.has(s)) return "tool";
+		if (TITLE_STEP_TYPES.has(s)) return "title";
+		if (SUBAGENT_STEP_TYPES.has(s)) return "subagent";
+		if (USER_INPUT_STEP_TYPES.has(s)) return "user-input";
+	}
+	return "unknown";
+}
+function extractText(obj) {
+	const direct = pick(obj, [
+		"text",
+		"content",
+		"agent_text",
+		"agentText",
+		"output_text",
+		"payload_text"
+	]);
+	if (typeof direct === "string") return direct;
+	const payload = obj.payload ?? obj.step_payload ?? obj.stepPayload;
+	if (payload && typeof payload === "object") {
+		const inner = pick(payload, [
+			"text",
+			"content",
+			"agent_text",
+			"agentText"
+		]);
+		if (typeof inner === "string") return inner;
+	}
+	return "";
+}
+function extractTool(obj) {
+	const info = pick(obj, [
+		"tool_info",
+		"toolInfo",
+		"tool",
+		"tool_call",
+		"toolCall"
+	]);
+	const src = info && typeof info === "object" ? info : obj;
+	const name = pick(src, [
+		"name",
+		"tool_name",
+		"toolName",
+		"canonical_name"
+	]);
+	if (typeof name !== "string" || name === "") return void 0;
+	return {
+		name,
+		args: pick(src, [
+			"parameters",
+			"params",
+			"input",
+			"args",
+			"input_json",
+			"inputJson"
+		]),
+		output: pick(src, [
+			"output",
+			"result",
+			"output_text"
+		])
+	};
+}
+function parseUsage(v) {
+	if (!v || typeof v !== "object") return {};
+	const o = v;
+	const num = (x) => typeof x === "number" && Number.isFinite(x) ? x : void 0;
+	return {
+		input_tokens: num(o.input_tokens),
+		output_tokens: num(o.output_tokens),
+		thinking_tokens: num(o.thinking_tokens),
+		cache_read_tokens: num(o.cache_read_tokens),
+		cache_write_tokens: num(o.cache_write_tokens),
+		total_tokens: num(o.total_tokens)
+	};
+}
+/** Parse one decoded JSON object into a typed event; undefined = ignore. */
+function classifyEvent(obj, seq) {
+	if (!obj || typeof obj !== "object" || Array.isArray(obj)) return void 0;
+	const o = obj;
+	const evt = typeof o.event === "string" ? o.event : typeof o.type === "string" ? o.type : "";
+	if (evt === "init" || evt === "initialized") {
+		const cid = pick(o, [
+			"conversation_id",
+			"conversationId",
+			"session_id",
+			"sessionId"
+		]);
+		const model = pick(o, [
+			"model",
+			"model_name",
+			"modelName"
+		]);
+		return {
+			kind: "init",
+			conversationId: typeof cid === "string" && cid !== "" ? cid : void 0,
+			model: typeof model === "string" ? model : void 0,
+			raw: o
+		};
+	}
+	if (evt === "step_update" || evt === "step" || evt === "stepUpdate") {
+		const idxV = pick(o, [
+			"idx",
+			"index",
+			"step_idx",
+			"stepIdx",
+			"id",
+			"step_id",
+			"stepId"
+		]);
+		const stepKey = typeof idxV === "number" || typeof idxV === "string" ? String(idxV) : String(seq);
+		const stepKind = normalizeStepKind(pick(o, [
+			"step_type",
+			"stepType",
+			"type"
+		]));
+		return {
+			kind: "step",
+			stepKey,
+			stepKind,
+			text: extractText(o),
+			tool: stepKind === "tool" ? extractTool(o) : void 0,
+			raw: o
+		};
+	}
+	if (evt === "result" || evt === "done" || evt === "final") {
+		const r = o.result ?? o;
+		const inner = r && typeof r === "object" ? r : {};
+		const cid = pick(inner, ["conversation_id", "conversationId"]);
+		const status = pick(inner, ["status"]);
+		const response = pick(inner, [
+			"response",
+			"text",
+			"content"
+		]);
+		const error = pick(inner, [
+			"error",
+			"error_message",
+			"errorMessage"
+		]);
+		const ok = status === void 0 ? !error : String(status).toUpperCase() !== "ERROR";
+		return {
+			kind: "result",
+			conversationId: typeof cid === "string" ? cid : "",
+			ok,
+			response: typeof response === "string" ? response : "",
+			error: typeof error === "string" ? error : void 0,
+			usage: parseUsage(inner.usage),
+			raw: o
+		};
+	}
+	if (o.usage && typeof o.usage === "object" && (o.status !== void 0 || o.response !== void 0)) return classifyEvent({
+		event: "result",
+		result: o
+	}, seq);
+	if (o.step_type !== void 0 || o.stepType !== void 0) return classifyEvent({
+		event: "step_update",
+		...o
+	}, seq);
+}
+var StreamJsonParser = class {
+	buffer = "";
+	seq = 0;
+	stats = {
+		lines: 0,
+		garbage: 0,
+		consecutiveGarbage: 0,
+		authUrl: void 0,
+		sawAuthFailure: false
+	};
+	/** Ring buffer of raw stdout lines for /agy doctor export. */
+	recentLines = [];
+	maxRecent = 2e3;
+	/** Feed a stdout chunk; returns the events completed by it. */
+	feed(chunk) {
+		this.buffer += chunk;
+		const out = [];
+		let nl;
+		while ((nl = this.buffer.indexOf("\n")) >= 0) {
+			const line = this.buffer.slice(0, nl).replace(/\r$/, "");
+			this.buffer = this.buffer.slice(nl + 1);
+			const ev = this.takeLine(line);
+			if (ev) out.push(ev);
+		}
+		return out;
+	}
+	/** Flush a trailing line without a newline (agy killed mid-write). */
+	flush() {
+		const rest = this.buffer;
+		this.buffer = "";
+		if (rest.trim() === "") return [];
+		const ev = this.takeLine(rest);
+		return ev ? [ev] : [];
+	}
+	takeLine(line) {
+		if (line.trim() === "") return void 0;
+		this.stats.lines++;
+		this.recentLines.push(line);
+		if (this.recentLines.length > this.maxRecent) this.recentLines.splice(0, this.recentLines.length - this.maxRecent);
+		if (looksLikeAuthFailure(line)) this.stats.sawAuthFailure = true;
+		if (this.stats.authUrl === void 0) {
+			const u = extractAuthUrl(line);
+			if (u) this.stats.authUrl = u;
+		}
+		let obj;
+		try {
+			obj = JSON.parse(line);
+		} catch {
+			this.stats.garbage++;
+			this.stats.consecutiveGarbage++;
+			return {
+				kind: "garbage",
+				line
+			};
+		}
+		const ev = classifyEvent(obj, this.seq++);
+		if (!ev) {
+			this.stats.garbage++;
+			this.stats.consecutiveGarbage++;
+			return {
+				kind: "garbage",
+				line
+			};
+		}
+		this.stats.consecutiveGarbage = 0;
+		return ev;
+	}
+};
+function resolveAgyBin(cfg) {
+	const candidates = [];
+	if (cfg.agyBin !== "") candidates.push(cfg.agyBin);
+	const pathEnv = process.env.PATH ?? "";
+	for (const dir of pathEnv.split(delimiter)) if (dir !== "") candidates.push(join(dir, "agy"));
+	candidates.push(join(homedir(), ".local", "bin", "agy"));
+	candidates.push("/usr/local/bin/agy");
+	for (const c of candidates) try {
+		accessSync(c, constants.X_OK);
+		return c;
+	} catch {
+		continue;
+	}
+	return null;
+}
+function compareVersions(a, b) {
+	const pa = a.split(/\./).map(Number);
+	const pb = b.split(/\./).map(Number);
+	for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+		const x = pa[i] ?? 0;
+		const y = pb[i] ?? 0;
+		if (x !== y) return x - y;
+	}
+	return 0;
+}
+function parseVersion(out) {
+	return out.match(/(\d+\.\d+\.\d+)/)?.[1] ?? null;
+}
+function killTree(child) {
+	if (child.pid === void 0) return;
+	try {
+		process.kill(-child.pid, "SIGTERM");
+	} catch {
+		try {
+			child.kill("SIGTERM");
+		} catch {}
+	}
+}
+function startAgyProcess(opts) {
+	const started = Date.now();
+	const child = spawn(opts.bin, opts.args, {
+		cwd: opts.cwd,
+		env: process.env,
+		detached: true,
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		]
+	});
+	let stdout = "";
+	let stderr = "";
+	let timedOut = false;
+	let aborted = false;
+	let settled = false;
+	const watchdog = opts.timeoutMs && opts.timeoutMs > 0 ? setTimeout(() => {
+		timedOut = true;
+		killTree(child);
+	}, opts.timeoutMs) : null;
+	const onAbort = () => {
+		aborted = true;
+		killTree(child);
+	};
+	opts.signal?.addEventListener("abort", onAbort, { once: true });
+	if (child.stdout) child.stdout.setEncoding("utf8");
+	if (child.stderr) child.stderr.setEncoding("utf8");
+	let pending = "";
+	child.stdout?.on("data", (chunk) => {
+		stdout += chunk;
+		if (stdout.length > 4e6) stdout = stdout.slice(-2e6);
+		pending += chunk;
+		let nl;
+		while ((nl = pending.indexOf("\n")) >= 0) {
+			const line = pending.slice(0, nl);
+			pending = pending.slice(nl + 1);
+			opts.onLine?.(line);
+		}
+	});
+	child.stderr?.on("data", (chunk) => {
+		stderr = (stderr + chunk).slice(-4096);
+	});
+	return {
+		child,
+		outcome: new Promise((resolve) => {
+			const finish = (code, signal) => {
+				if (settled) return;
+				settled = true;
+				if (watchdog) clearTimeout(watchdog);
+				opts.signal?.removeEventListener("abort", onAbort);
+				if (pending !== "") {
+					opts.onLine?.(pending);
+					pending = "";
+				}
+				if (!opts.keepStdin) try {
+					child.stdin?.end();
+				} catch {}
+				resolve({
+					code,
+					signal,
+					timedOut,
+					aborted,
+					stdout,
+					stderrTail: stderr,
+					durationMs: Date.now() - started
+				});
+			};
+			child.on("exit", (code, signal) => finish(code, signal));
+			child.on("error", (err) => {
+				stderr = (stderr + String(err)).slice(-4096);
+				finish(null, null);
+			});
+		}),
+		kill: (reason) => {
+			if (reason === "timeout") timedOut = true;
+			else aborted = true;
+			killTree(child);
+		}
+	};
+}
+/** Simple one-shot helper for --version / models probes. */
+async function probeProcess(bin, args, timeoutMs = 3e4, signal) {
+	return startAgyProcess({
+		bin,
+		args,
+		timeoutMs,
+		signal
+	}).outcome;
+}
+//#endregion
+//#region src/host/adapter.ts
+function textOf(m) {
+	const parts = [];
+	for (const b of m.content) if (b.type === "text") parts.push(b.text);
+	return parts.filter((s) => s !== "").join("\n");
+}
+function isForeignAssistant(m) {
+	if (m.role !== "assistant") return false;
+	const src = m.source;
+	return !src || src.provider !== "antigravity";
+}
+/** Rolling digest of turns this agy conversation has not seen (ADR-7). */
+function buildDigest(messages, fromIdx, maxChars) {
+	const parts = [];
+	let budget = maxChars;
+	for (let i = messages.length - 1; i >= fromIdx; i--) {
+		const m = messages[i];
+		if (m === void 0 || m.role === "system") continue;
+		const text = textOf(m);
+		if (text === "") continue;
+		const line = (m.role === "user" ? "User: " : "Assistant: ") + text;
+		if (line.length > budget) {
+			parts.unshift(line.slice(0, Math.max(0, budget)));
+			break;
+		}
+		budget -= line.length;
+		parts.unshift(line);
+	}
+	if (parts.length === 0) return "";
+	return "[conversation so far]\n" + parts.join("\n\n") + "\n[end of conversation so far]\n\n";
+}
+var ChunkQueue = class {
+	chunks = [];
+	wake = null;
+	closed = false;
+	push(ch) {
+		this.chunks.push(ch);
+		this.wake?.();
+		this.wake = null;
+	}
+	close() {
+		this.closed = true;
+		this.wake?.();
+		this.wake = null;
+	}
+	async *drain() {
+		for (;;) {
+			while (this.chunks.length > 0) {
+				const ch = this.chunks.shift();
+				if (ch !== void 0) yield ch;
+			}
+			if (this.closed) return;
+			await new Promise((resolve) => {
+				this.wake = resolve;
+			});
+		}
+	}
+};
+function brief(s) {
+	const flat = s.trim().replace(/\s+/g, " ");
+	return flat.length > 300 ? flat.slice(0, 300) + "..." : flat;
+}
+function sawAuthFailure(parser, outcome) {
+	if (parser.stats.sawAuthFailure) return true;
+	return looksLikeAuthFailure(outcome.stderrTail) || looksLikeAuthFailure(outcome.stdout.slice(0, 4e3));
+}
+var AgyAdapter = class extends LlmAdapter {
+	deps;
+	constructor(deps) {
+		super();
+		this.deps = deps;
+	}
+	/**
+	* Fail fast on auth and abort; allow one retry for transient process
+	* failures (timeout, crash, malformed stream) per ADR-11.
+	*/
+	providerRetryPolicy(_provider) {
+		return {
+			mode: "normal",
+			maxRetries: 1,
+			retryableCodes: [
+				Err.TIMEOUT,
+				Err.PROCESS_EXIT,
+				Err.INVALID_OUTPUT
+			],
+			initialDelayMs: 2e3,
+			maxDelayMs: 1e4,
+			jitterRatio: .1
+		};
+	}
+	providerInfo(_provider) {
+		return {
+			id: PROVIDER_ID,
+			name: "Antigravity (agy CLI)"
+		};
+	}
+	async listModels(_provider) {
+		this.deps.catalog.refreshIfNeeded();
+		return this.deps.catalog.get().models.map((m) => ({
+			provider: PROVIDER_ID,
+			id: m.id,
+			name: m.name,
+			inputModalities: ["text"]
+		}));
+	}
+	async resolveModel(_provider, model, _signal) {
+		const cfg = this.deps.getConfig();
+		const entry = findEntry(this.deps.catalog.get(), model);
+		const name = entry ? entry.name : model;
+		const resolved = {
+			provider: PROVIDER_ID,
+			id: model,
+			name,
+			inputModalities: ["text"],
+			context: { contextWindow: cfg.contextWindowDefault },
+			defaultMaxTokens: cfg.maxTokensDefault
+		};
+		if (entry && entry.efforts) {
+			const def = defaultEffortFor(entry, cfg);
+			resolved.reasoning = {
+				efforts: entry.efforts.map((e) => ({
+					id: e,
+					name: e
+				})),
+				...def ? { defaultEffort: def } : {}
+			};
+		}
+		return resolved;
+	}
+	/** Build the agy argv for one call. Exported for tests. */
+	buildArgs(opts) {
+		const args = [
+			"--output-format",
+			"stream-json",
+			"--print-timeout",
+			Math.max(1, Math.ceil(opts.timeoutMs / 6e4)) + "m"
+		];
+		if (opts.permissionMode === "skip") args.push("--dangerously-skip-permissions");
+		else args.push("--mode", opts.permissionMode);
+		if (opts.model !== "") args.push("--model", opts.model);
+		if (opts.effort && opts.effort !== "") args.push("--effort", opts.effort);
+		if (opts.conversationId) args.push("--conversation", opts.conversationId);
+		args.push(...opts.extraArgs);
+		args.push("-p", opts.prompt);
+		return args;
+	}
+	async *stream(options) {
+		const cfg = this.deps.getConfig();
+		const bin = this.deps.bin();
+		if (!bin) throw new LlmError("agy binary not found on PATH — install it via https://antigravity.google/docs/cli/install", Err.AGY_NOT_INSTALLED);
+		const isAux = options.purpose === "compaction" || options.purpose === "session-title";
+		if (isAux && !cfg.allowAuxiliary) throw new LlmError("auxiliary calls are disabled for the antigravity route (allowAuxiliary: false)", Err.AUX_DISABLED);
+		const sessionKey = options.sessionId !== void 0 ? String(options.sessionId) : "";
+		const catalog = this.deps.catalog.get();
+		const model = options.model;
+		const entry = findEntry(catalog, model);
+		let effort;
+		if (options.reasoningEffort !== void 0) {
+			const wanted = String(options.reasoningEffort);
+			if (entry && entry.efforts === null) throw new LlmError("model " + model + " has no selectable reasoning efforts", Err.UNSUPPORTED_REASONING_EFFORT);
+			if (entry && entry.efforts && !entry.efforts.includes(wanted)) throw new LlmError("reasoning effort " + wanted + " is not supported by " + model, Err.UNSUPPORTED_REASONING_EFFORT);
+			effort = wanted;
+		} else if (entry && entry.efforts) effort = defaultEffortFor(entry, cfg);
+		const messages = options.messages;
+		let lastAssistantIdx = -1;
+		for (let i = messages.length - 1; i >= 0; i--) {
+			const mm = messages[i];
+			if (mm !== void 0 && mm.role === "assistant") {
+				lastAssistantIdx = i;
+				break;
+			}
+		}
+		const trailingUser = messages.slice(lastAssistantIdx + 1).filter((m) => m.role === "user");
+		const binding = sessionKey !== "" ? this.deps.store.get(sessionKey) : void 0;
+		let prompt = "";
+		if (isAux && options.purpose === "compaction") {
+			const cap = cfg.compactionMaxChars > 0 ? cfg.compactionMaxChars : 8e5;
+			const parts = [];
+			let used = 0;
+			for (const m of messages) {
+				const text = textOf(m);
+				if (text === "") continue;
+				const line = (m.role === "user" ? "User: " : "Assistant: ") + text;
+				parts.push(line);
+				used += line.length;
+				if (used > cap) break;
+			}
+			prompt = "[summarize this conversation for context compaction]\n\n" + parts.join("\n\n") + "\n\nProduce a compact summary that preserves decisions, file paths, and open tasks.";
+		} else {
+			prompt = trailingUser.map(textOf).filter((s) => s !== "").join("\n\n");
+			if (binding === void 0 && lastAssistantIdx >= 0) prompt = buildDigest(messages, 0, cfg.digestMaxChars) + prompt;
+			else if (binding !== void 0) {
+				const from = Math.min(binding.lastMessageCount, messages.length);
+				const end = Math.max(from, lastAssistantIdx + 1);
+				const span = messages.slice(from, end).filter((m) => m.role !== "assistant" || isForeignAssistant(m));
+				if (span.some((m) => m.role === "assistant")) prompt = buildDigest(span, 0, cfg.digestMaxChars) + prompt;
+			}
+		}
+		if (prompt.trim() === "") throw new LlmError("request carries no user text to forward to agy", Err.AGY_ERROR);
+		if (cfg.forwardSystemPrompt && options.system) prompt = "System instructions:\n" + options.system + "\n\n" + prompt;
+		const before = snapshotConversations();
+		const mapper = new EventMapper({ toolOutput: this.deps.toolOutput });
+		const parser = new StreamJsonParser();
+		this.deps.onParser?.(parser);
+		const queue = new ChunkQueue();
+		let streamCid = null;
+		const args = this.buildArgs({
+			prompt,
+			model: model === "" ? cfg.defaultModel : model,
+			effort,
+			conversationId: !isAux && binding !== void 0 ? binding.conversationId : void 0,
+			permissionMode: isAux ? "plan" : cfg.permissionMode,
+			timeoutMs: cfg.timeoutMs,
+			extraArgs: cfg.extraArgs
+		});
+		const release = await this.deps.acquire();
+		let released = false;
+		const releaseOnce = () => {
+			if (released) return;
+			released = true;
+			release();
+		};
+		let proc;
+		try {
+			proc = startAgyProcess({
+				bin,
+				args,
+				cwd: cfg.workspaceRoot !== "" ? cfg.workspaceRoot : void 0,
+				timeoutMs: cfg.timeoutMs,
+				signal: options.signal,
+				onLine: (line) => {
+					for (const ev of parser.feed(line + "\n")) {
+						if (ev.kind === "init" && ev.conversationId) streamCid = ev.conversationId;
+						if (ev.kind === "result" && ev.conversationId !== "") streamCid = ev.conversationId;
+						for (const ch of mapper.map(ev)) queue.push(ch);
+					}
+				}
+			});
+		} catch (e) {
+			releaseOnce();
+			throw new LlmError("failed to spawn agy: " + brief(String(e)), Err.PROCESS_EXIT);
+		}
+		(async () => {
+			const outcome = await proc.outcome;
+			releaseOnce();
+			for (const ev of parser.flush()) {
+				if (ev.kind === "result" && ev.conversationId !== "") streamCid = ev.conversationId;
+				for (const ch of mapper.map(ev)) queue.push(ch);
+			}
+			const diffed = diffConversations(before).conversationId;
+			const conversationId = streamCid ?? diffed;
+			let failure = null;
+			if (outcome.aborted) failure = {
+				kind: "aborted",
+				code: "ABORTED",
+				message: "agy run aborted by caller"
+			};
+			else if (outcome.timedOut) failure = {
+				kind: "error",
+				code: Err.TIMEOUT,
+				message: "agy run exceeded the watchdog budget (" + cfg.timeoutMs + "ms)"
+			};
+			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"
+			};
+			else if (!mapper.isFinished) {
+				if (outcome.code !== 0) failure = {
+					kind: "error",
+					code: Err.PROCESS_EXIT,
+					message: "agy exited with code " + outcome.code + (outcome.stderrTail !== "" ? ": " + brief(outcome.stderrTail) : "")
+				};
+				else failure = {
+					kind: "error",
+					code: Err.INVALID_OUTPUT,
+					message: "agy produced no result event (" + parser.stats.garbage + " unparseable lines)"
+				};
+			}
+			if (failure !== null) for (const ch of mapper.emitFailure(failure.kind, failure.code, failure.message)) queue.push(ch);
+			if (!isAux && sessionKey !== "" && failure === null) {
+				const finalId = binding !== void 0 ? binding.conversationId : conversationId;
+				if (finalId) this.deps.store.set(sessionKey, {
+					conversationId: finalId,
+					lastMessageCount: messages.length,
+					updatedAt: Date.now(),
+					model
+				});
+			}
+			this.deps.onRun?.({
+				ok: failure === null,
+				code: failure !== null ? failure.code : "OK",
+				durationMs: outcome.durationMs,
+				model
+			});
+			queue.close();
+		})().catch((err) => {
+			releaseOnce();
+			for (const ch of mapper.emitFailure("error", Err.PROCESS_EXIT, "internal error: " + brief(String(err)))) queue.push(ch);
+			queue.close();
+		});
+		yield* queue.drain();
+	}
+};
+//#endregion
+//#region src/host/oneshot.ts
+async function runAgyOnce(deps, req) {
+	const cfg = deps.cfg();
+	const bin = deps.bin();
+	if (!bin) return {
+		ok: false,
+		text: "",
+		conversationId: null,
+		error: "agy binary not found",
+		durationMs: 0
+	};
+	const timeoutMs = req.timeoutMs ?? cfg.timeoutMs;
+	const args = [
+		"--output-format",
+		"stream-json",
+		"--print-timeout",
+		Math.max(1, Math.ceil(timeoutMs / 6e4)) + "m"
+	];
+	const mode = req.mode ?? cfg.permissionMode;
+	if (mode === "skip") args.push("--dangerously-skip-permissions");
+	else args.push("--mode", mode);
+	if (req.model) args.push("--model", req.model);
+	if (req.effort) args.push("--effort", req.effort);
+	args.push("-p", req.prompt);
+	const parser = new StreamJsonParser();
+	const textParts = [];
+	let resultText = "";
+	let conversationId = null;
+	const outcome = await startAgyProcess({
+		bin,
+		args,
+		cwd: cfg.workspaceRoot !== "" ? cfg.workspaceRoot : void 0,
+		timeoutMs,
+		signal: req.signal,
+		onLine: (line) => {
+			for (const ev of parser.feed(line + "\n")) {
+				if (ev.kind === "init" && ev.conversationId) conversationId = ev.conversationId;
+				if (ev.kind === "step" && ev.stepKind === "text" && ev.text !== "") textParts.push(ev.text);
+				if (ev.kind === "result") {
+					if (ev.conversationId !== "") conversationId = ev.conversationId;
+					resultText = ev.response;
+				}
+			}
+		}
+	}).outcome;
+	for (const ev of parser.flush()) if (ev.kind === "result") {
+		if (ev.conversationId !== "") conversationId = ev.conversationId;
+		resultText = ev.response;
+	}
+	if (outcome.aborted) return {
+		ok: false,
+		text: "",
+		conversationId,
+		error: "aborted",
+		durationMs: outcome.durationMs
+	};
+	if (outcome.timedOut) return {
+		ok: false,
+		text: "",
+		conversationId,
+		error: "timed out after " + timeoutMs + "ms",
+		durationMs: outcome.durationMs
+	};
+	if (looksLikeAuthFailure(outcome.stderrTail) || looksLikeAuthFailure(outcome.stdout.slice(0, 4e3))) return {
+		ok: false,
+		text: "",
+		conversationId,
+		error: "agy is not signed in — run /agy auth",
+		durationMs: outcome.durationMs
+	};
+	const joined = textParts.join("\n").trim();
+	const text = joined !== "" ? joined : resultText;
+	if (outcome.code !== 0 && text === "") return {
+		ok: false,
+		text: "",
+		conversationId,
+		error: "agy exited with code " + outcome.code + ": " + outcome.stderrTail.slice(-300),
+		durationMs: outcome.durationMs
+	};
+	return {
+		ok: text !== "",
+		text: text === "" ? "(no output)" : text,
+		conversationId,
+		durationMs: outcome.durationMs
+	};
+}
+//#endregion
+//#region src/host/ask-tool.ts
+const ALIASES = {
+	flash: "gemini",
+	pro: "gemini",
+	gemini: "gemini",
+	sonnet: "claude",
+	opus: "claude",
+	claude: "claude",
+	"gpt-oss": "gpt-oss",
+	oss: "gpt-oss"
+};
+/** Resolve a user-facing model word against the live catalog. */
+function resolveAskModel(input, catalog, defaultModel) {
+	const q = input.trim().toLowerCase();
+	if (q === "") return defaultModel;
+	const ids = catalog.models.map((m) => m.id);
+	if (ids.includes(q)) return q;
+	const prefix = ALIASES[q] ?? q.replace(/\s+/g, "-");
+	let level = "";
+	for (const eff of [
+		"high",
+		"medium",
+		"low"
+	]) if (q.endsWith(" " + eff) || q.endsWith("-" + eff)) level = eff;
+	const base = level !== "" ? prefix.replace(/-?(high|medium|low)$/, "") : prefix;
+	const candidates = ids.filter((id) => id.startsWith(base));
+	if (candidates.length === 0) return defaultModel !== "" ? defaultModel : q;
+	const sorted = candidates.slice().sort(compareNatural);
+	const last = sorted[sorted.length - 1] ?? q;
+	if (level === "") return last;
+	return sorted.find((id) => id.endsWith("-" + level)) ?? last;
+}
+function compareNatural(a, b) {
+	const na = a.split(/(\d+)/);
+	const nb = b.split(/(\d+)/);
+	for (let i = 0; i < Math.max(na.length, nb.length); i++) {
+		const x = na[i] ?? "";
+		const y = nb[i] ?? "";
+		const xn = Number(x);
+		const yn = Number(y);
+		if (Number.isFinite(xn) && Number.isFinite(yn) && x !== "" && y !== "") {
+			if (xn !== yn) return xn - yn;
+		} else if (x !== y) return x < y ? -1 : 1;
+	}
+	return 0;
+}
+function defineAgyAskTool(deps) {
+	return defineTool({
+		name: "agy_ask",
+		description: "Delegate a one-shot task to a Google Antigravity model via the agy CLI (e.g. ask Gemini for a review while keeping the current model). Returns the final answer text.",
+		parameters: {
+			prompt: {
+				type: "string",
+				required: true,
+				description: "The task or question for the Antigravity model."
+			},
+			model: {
+				type: "string",
+				description: "Model to ask: flash, pro, gemini, sonnet, opus, gpt-oss, or an exact slug (default: the bridge default model)."
+			},
+			effort: {
+				type: "string",
+				description: "Reasoning effort for effort-capable models: low, medium, or high."
+			},
+			mode: {
+				type: "string",
+				description: "agy execution mode: plan (read-only) or accept-edits. Defaults to the bridge permission mode."
+			},
+			timeoutMinutes: {
+				type: "number",
+				description: "Optional timeout budget in minutes (default 10)."
+			}
+		},
+		output: {
+			schema: { type: "string" },
+			render: (_args, value) => [{
+				type: "text",
+				text: value
+			}]
+		},
+		timeoutMs: 9e5,
+		async execute(args, exec) {
+			exec.signal;
+			const cfg = deps.cfg();
+			const model = resolveAskModel(args.model ?? "", deps.catalog(), cfg.defaultModel);
+			const res = await runAgyOnce(deps, {
+				prompt: args.prompt,
+				model: model === "" ? void 0 : model,
+				effort: args.effort,
+				mode: args.mode,
+				timeoutMs: args.timeoutMinutes ? args.timeoutMinutes * 6e4 : void 0,
+				signal: exec.signal
+			});
+			if (!res.ok) throw new Error("agy_ask failed: " + (res.error ?? "unknown error"));
+			const footer = res.conversationId ? "\n\n(agy conversation: " + res.conversationId + " — continue it with: agy --conversation " + res.conversationId + ")" : "";
+			return res.text + footer + "\n(" + Math.round(res.durationMs / 100) / 10 + "s)";
+		}
+	});
+}
+//#endregion
+//#region src/host/auth.ts
+const URL_WAIT_MS = 15e3;
+const CODE_SETTLE_MS = 9e4;
+var AuthHelper = class {
+	bin;
+	state = { phase: "idle" };
+	probe = null;
+	capturedUrl = null;
+	urlWaiter = null;
+	urlTimer = null;
+	constructor(bin) {
+		this.bin = bin;
+	}
+	status() {
+		return { ...this.state };
+	}
+	startProbe() {
+		const bin = this.bin();
+		if (!bin) return null;
+		this.cancel();
+		this.capturedUrl = null;
+		const proc = startAgyProcess({
+			bin,
+			args: [
+				"-p",
+				"ping",
+				"--output-format",
+				"stream-json",
+				"--print-timeout",
+				"4m"
+			],
+			timeoutMs: 3e5,
+			keepStdin: true,
+			onLine: (line) => {
+				if (this.capturedUrl) return;
+				const url = extractAuthUrl(line);
+				if (url) {
+					this.capturedUrl = url;
+					this.urlWaiter?.(url);
+					this.urlWaiter = null;
+					if (this.urlTimer) clearTimeout(this.urlTimer);
+					this.urlTimer = null;
+				}
+			}
+		});
+		proc.child.stderr?.on("data", (chunk) => {
+			if (this.capturedUrl) return;
+			const url = extractAuthUrl(chunk);
+			if (url) {
+				this.capturedUrl = url;
+				this.urlWaiter?.(url);
+				this.urlWaiter = null;
+				if (this.urlTimer) clearTimeout(this.urlTimer);
+				this.urlTimer = null;
+			}
+		});
+		this.probe = proc;
+		return proc;
+	}
+	/** Start (or restart) the login flow; resolves with the consent URL. */
+	async begin() {
+		if (!this.startProbe()) {
+			this.state = {
+				phase: "failed",
+				message: "agy binary not found"
+			};
+			return this.status();
+		}
+		const startedAt = Date.now();
+		this.state = {
+			phase: "pending",
+			startedAt,
+			expiresAt: startedAt + 55e3
+		};
+		const url = await new Promise((resolve) => {
+			this.urlWaiter = resolve;
+			this.urlTimer = setTimeout(() => {
+				this.urlWaiter = null;
+				resolve(null);
+			}, URL_WAIT_MS);
+		});
+		if (this.urlTimer) clearTimeout(this.urlTimer);
+		this.urlTimer = null;
+		if (!url) {
+			this.state = {
+				phase: "ok",
+				startedAt,
+				message: "no login URL produced — already authenticated?"
+			};
+			this.cancel();
+			return this.status();
+		}
+		this.state = {
+			phase: "pending",
+			url,
+			startedAt,
+			expiresAt: startedAt + 55e3
+		};
+		return this.status();
+	}
+	/** Pipe the pasted authorization code into the waiting probe. */
+	async submitCode(code) {
+		if (this.state.phase !== "pending" || !this.probe) {
+			this.state = {
+				phase: "failed",
+				message: "no pending login — run /agy auth first"
+			};
+			return this.status();
+		}
+		if (this.state.expiresAt && Date.now() > this.state.expiresAt) {
+			this.state = {
+				phase: "failed",
+				message: "login window expired — restart with /agy auth"
+			};
+			this.cancel();
+			return this.status();
+		}
+		this.state = {
+			...this.state,
+			phase: "submitting"
+		};
+		const proc = this.probe;
+		try {
+			proc.child.stdin?.write(code.trim() + "\n");
+		} catch {
+			this.state = {
+				phase: "failed",
+				message: "probe stdin closed"
+			};
+			return this.status();
+		}
+		const outcome = await Promise.race([proc.outcome, new Promise((resolve) => setTimeout(() => resolve(null), CODE_SETTLE_MS))]);
+		if (outcome === null) {
+			this.state = {
+				phase: "failed",
+				message: "timed out waiting for agy to finish the exchange"
+			};
+			this.cancel();
+			return this.status();
+		}
+		const tail = outcome.stdout + outcome.stderrTail;
+		if (outcome.code === 0 && !looksLikeAuthFailure(tail)) this.state = {
+			phase: "ok",
+			message: "authenticated"
+		};
+		else this.state = {
+			phase: "failed",
+			message: outcome.stderrTail.trim() || "authorization code rejected"
+		};
+		this.probe = null;
+		return this.status();
+	}
+	cancel() {
+		if (this.probe) {
+			this.probe.kill("abort");
+			this.probe = null;
+		}
+		if (this.urlTimer) clearTimeout(this.urlTimer);
+		this.urlTimer = null;
+		this.urlWaiter = null;
+	}
+	dispose() {
+		this.cancel();
+		this.state = { phase: "idle" };
+	}
+};
+//#endregion
+//#region src/host/commands.ts
+const HELP = [
+	"**/agy** — Antigravity (agy CLI) bridge",
+	"- `/agy status` — binary, version, auth, mode, catalog, bindings",
+	"- `/agy auth` — start Google login (returns the consent URL)",
+	"- `/agy auth-code <code>` — paste the authorization code",
+	"- `/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 clear` — drop the most recent conversation binding",
+	"- `/agy doctor` — write a diagnostic report and return its path",
+	"- `/agy help` — this text"
+].join("\n");
+function agyCommandDefinition(deps) {
+	return {
+		name: "agy",
+		description: "Antigravity (agy CLI) bridge: status, login, models, mode, diagnostics",
+		handler: (invocation) => handle(deps, invocation.rawInput)
+	};
+}
+async function handle(deps, raw) {
+	const parts = raw.trim().split(/\s+/).filter(Boolean);
+	const sub = parts[0] ?? "help";
+	const arg = parts[1] ?? "";
+	try {
+		if (sub === "status") return ok(renderStatus(deps));
+		if (sub === "auth") {
+			const auth = deps.auth();
+			if (!auth) return err("agy binary not found — install the CLI first");
+			const st = await auth.begin();
+			if (st.phase === "pending" && st.url) return ok([
+				"**Google login required** — open the URL, approve access, then bring the authorization code back:",
+				"",
+				st.url,
+				"",
+				"Then run: `/agy auth-code <authorization code>`",
+				"The GUI panel offers the same flow with a QR code and a paste box."
+			].join("\n"));
+			return ok("Auth probe: " + (st.message ?? st.phase));
+		}
+		if (sub === "auth-code") {
+			if (arg === "") return err("usage: /agy auth-code <code>");
+			const auth = deps.auth();
+			if (!auth) return err("agy binary not found");
+			const st = await auth.submitCode(arg);
+			return st.phase === "ok" ? ok("Logged in to Antigravity.") : err(st.message ?? "login failed");
+		}
+		if (sub === "models") {
+			const cat = await deps.catalog().forceRefresh();
+			const lines = ["**Antigravity models** — source: " + cat.source + (cat.lastError === void 0 ? "" : " — " + cat.lastError) + ":"];
+			for (const m of cat.models) lines.push("- `" + m.id + "` — " + m.name + (m.efforts ? " — efforts: " + m.efforts.join(" / ") : ""));
+			return ok(lines.join("\n"));
+		}
+		if (sub === "mode") {
+			if (![
+				"skip",
+				"plan",
+				"accept-edits"
+			].includes(arg)) return err("usage: /agy mode <skip|plan|accept-edits>");
+			deps.setOverride("permissionMode", arg);
+			return ok("Permission mode set to **" + arg + "** — effective next turn.");
+		}
+		if (sub === "effort") {
+			if (![
+				"low",
+				"medium",
+				"high",
+				"default"
+			].includes(arg)) return err("usage: /agy effort <low|medium|high|default>");
+			deps.setOverride("defaultEffort", arg === "default" ? "" : arg);
+			return ok("Default effort set to **" + (arg === "default" ? "model default" : arg) + "**.");
+		}
+		if (sub === "clear") {
+			const all = deps.store().all();
+			const keys = Object.keys(all);
+			if (keys.length === 0) return ok("No conversation bindings yet.");
+			const key = keys.reduce((a, b) => (all[a]?.updatedAt ?? 0) >= (all[b]?.updatedAt ?? 0) ? a : b);
+			const dropped = all[key];
+			if (dropped === void 0) return ok("No conversation bindings yet.");
+			deps.store().delete(key);
+			return ok("Dropped binding for session `" + key + "` — agy conversation " + dropped.conversationId + ". The next turn starts a fresh agy conversation.");
+		}
+		if (sub === "doctor") return ok("Diagnostic report written to `" + await deps.runDoctor() + "` — attach it when opening an issue.");
+		return ok(HELP);
+	} catch (e) {
+		return err(e instanceof Error ? e.message : String(e));
+	}
+}
+function renderStatus(deps) {
+	const cfg = deps.cfg();
+	const bin = deps.bin();
+	const auth = deps.auth()?.status();
+	const cat = deps.catalog().get();
+	const bindings = Object.keys(deps.store().all()).length;
+	const last = deps.lastRun();
+	return [
+		"**dsh-agy-link status**",
+		"- agy binary: " + (bin ?? "not found — install via https://antigravity.google/docs/cli/install"),
+		"- version: " + (deps.version() ?? "unknown"),
+		"- auth: " + (auth ? auth.phase + (auth.message ? " — " + auth.message : "") : "unknown"),
+		"- permission mode: " + cfg.permissionMode + (cfg.permissionMode === "skip" ? " — WARNING: agy runs tools without approval" : ""),
+		"- default model: " + (cfg.defaultModel === "" ? "(agy default)" : cfg.defaultModel),
+		"- default effort: " + (cfg.defaultEffort === "" ? "(model default)" : cfg.defaultEffort),
+		"- catalog: " + cat.models.length + " models — " + cat.source + (cat.lastError === void 0 ? "" : " — last error: " + cat.lastError),
+		"- conversation bindings: " + bindings,
+		"- last run: " + (last ? (last.ok ? "ok" : last.code) + " — " + last.model + " in " + Math.round(last.durationMs / 100) / 10 + "s" : "none yet")
+	].join("\n");
+}
+function ok(text) {
+	return {
+		kind: "success",
+		text
+	};
+}
+function err(text) {
+	return {
+		kind: "error",
+		text
+	};
+}
+//#endregion
+//#region src/host/diagnostics.ts
+/** Redact auth URLs, long tokens, and authorization codes. */
+function redactLine(line) {
+	let out = line;
+	out = out.replace(/https:\/\/accounts\.google\.com\/\S+/g, "<auth-url-redacted>");
+	out = out.replace(/\b[0-9]{4,}\//g, "4/<code-redacted>");
+	out = out.replace(/ya29\.[A-Za-z0-9._-]+/g, "<oauth-token-redacted>");
+	out = out.replace(/Bearer\s+\S+/gi, "Bearer <redacted>");
+	return out;
+}
+function writeDoctorReport(deps) {
+	const cfg = deps.cfg();
+	const cat = deps.catalog().get();
+	const bindings = deps.store().all();
+	const lines = [];
+	lines.push("# dsh-agy-link diagnostic report");
+	lines.push("");
+	lines.push("- generated: " + (/* @__PURE__ */ new Date()).toISOString());
+	lines.push("- agy binary: " + (deps.bin() ?? "NOT FOUND"));
+	lines.push("- agy version: " + (deps.version() ?? "unknown"));
+	lines.push("- plugin config: " + JSON.stringify({
+		...cfg,
+		extraArgs: cfg.extraArgs.length
+	}));
+	lines.push("- catalog: " + cat.source + " — " + cat.models.length + " models" + (cat.lastError === void 0 ? "" : " — error: " + cat.lastError));
+	for (const m of cat.models) lines.push("  - " + m.id + (m.efforts ? " [" + m.efforts.join("/") + "]" : ""));
+	lines.push("- conversation bindings: " + Object.keys(bindings).length);
+	for (const [k, b] of Object.entries(bindings)) lines.push("  - " + k + " -> " + b.conversationId + " @ " + new Date(b.updatedAt).toISOString());
+	lines.push("- node: " + process.version + " — " + process.platform + " " + process.arch);
+	lines.push("");
+	lines.push("## last stream-json stdout (redacted, tail)");
+	lines.push("");
+	lines.push("```");
+	const recent = deps.recentLines();
+	for (const l of recent.slice(-400)) lines.push(redactLine(l));
+	lines.push("```");
+	lines.push("");
+	const dir = join(stateDir(), "diagnostics");
+	mkdirSync(dir, { recursive: true });
+	const file = join(dir, "doctor-" + (/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "").slice(0, 14) + ".md");
+	writeFileSync(file, lines.join("\n"), "utf8");
+	return file;
+}
+//#endregion
+//#region src/host/diff-render.ts
+const FILE_KEYS = [
+	"file_path",
+	"filePath",
+	"path",
+	"file",
+	"filename",
+	"target_file",
+	"absolute_path"
+];
+function pickFile(args) {
+	if (!args || typeof args !== "object") return null;
+	const o = args;
+	for (const k of FILE_KEYS) {
+		const v = o[k];
+		if (typeof v === "string" && v !== "") return v;
+	}
+	return null;
+}
+function looksLikeEditTool(name) {
+	const n = name.toLowerCase();
+	return n.includes("write") || n.includes("edit") || n.includes("replace") || n.includes("str_replace");
+}
+function renderToolActivity(name, args, output, cwd) {
+	const parts = [];
+	if (looksLikeEditTool(name)) {
+		const file = pickFile(args);
+		if (file) {
+			const diff = gitDiff(file, cwd);
+			if (diff !== null) parts.push("[agy edit: " + file + "]\n" + diff);
+		}
+	}
+	if (output !== void 0 && output !== null) {
+		let s;
+		try {
+			s = typeof output === "string" ? output : JSON.stringify(output);
+		} catch {
+			s = String(output);
+		}
+		if (s !== "") parts.push("-> " + (s.length > 2048 ? s.slice(0, 2048) + "..." : s));
+	}
+	return parts.length === 0 ? null : parts.join("\n") + "\n";
+}
+function gitDiff(file, cwd) {
+	try {
+		const out = execFileSync("git", [
+			"-C",
+			cwd,
+			"diff",
+			"HEAD",
+			"--",
+			file
+		], {
+			encoding: "utf8",
+			timeout: 5e3,
+			maxBuffer: 1e6,
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		});
+		if (out.trim() === "") return null;
+		return out.split("\n").slice(0, 100).join("\n");
+	} catch {
+		return null;
+	}
+}
+//#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();
+	}
+	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 = p.lastIndexOf("/");
+	return i >= 0 ? p.slice(i + 1) : p;
+}
+//#endregion
+//#region src/index.ts
+const name = "dsh-agy-link";
+const inject = ["llm", "commands"];
+/** Cross-session concurrency limiter (ADR-12). */
+var Semaphore = class {
+	max;
+	active = 0;
+	queue = [];
+	constructor(max) {
+		this.max = max;
+	}
+	async acquire() {
+		if (this.active < Math.max(1, this.max())) {
+			this.active++;
+			return () => this.releaseOne();
+		}
+		return new Promise((resolve) => {
+			this.queue.push(() => {
+				this.active++;
+				resolve(() => this.releaseOne());
+			});
+		});
+	}
+	releaseOne() {
+		this.active--;
+		const next = this.queue.shift();
+		if (next) next();
+	}
+};
+function apply(ctx, entryConfig = {}) {
+	const tag = "[dsh-agy-link] ";
+	const log = (msg) => {
+		ctx.logger?.info?.(tag + msg);
+	};
+	let binCache = void 0;
+	let versionCache = null;
+	let dormantReason = null;
+	let lastRun = null;
+	let lastParser = new StreamJsonParser();
+	const getConfig = () => resolveConfig(entryConfig);
+	const bin = () => {
+		if (binCache === void 0) binCache = resolveAgyBin(getConfig());
+		return binCache;
+	};
+	const version = () => versionCache;
+	const store = new SessionStore(join(stateDir(), "sessions.json"));
+	const semaphore = new Semaphore(() => getConfig().maxConcurrent);
+	const catalog = new ModelCatalog(async (signal) => {
+		const b = bin();
+		if (!b) throw new Error("agy binary not found");
+		const out = await probeProcess(b, [
+			"models",
+			"--output-format",
+			"json"
+		], 3e4, signal);
+		if (out.code !== 0 && out.stdout.trim() === "") throw new Error("agy models failed: " + (out.stderrTail.trim() !== "" ? out.stderrTail.trim().slice(-200) : "exit " + String(out.code)));
+		return {
+			stdout: out.stdout,
+			stderr: out.stderrTail
+		};
+	}, getConfig().fallbackModels, 3e5);
+	const auth = new AuthHelper(bin);
+	const adapter = new AgyAdapter({
+		getConfig,
+		catalog,
+		store,
+		bin,
+		acquire: () => semaphore.acquire(),
+		log,
+		toolOutput: (name, args, output) => {
+			const ws = getConfig().workspaceRoot;
+			return renderToolActivity(name, args, output, ws !== "" ? ws : process.cwd());
+		},
+		onRun: (info) => {
+			lastRun = info;
+		},
+		onParser: (p) => {
+			lastParser = p;
+		}
+	});
+	const setOverride = (key, value) => {
+		const file = overridesPath();
+		const current = readOverrides(file);
+		current[key] = value;
+		try {
+			mkdirSync(stateDir(), { recursive: true });
+			writeFileSync(file, JSON.stringify(current, null, 2), "utf8");
+		} catch (e) {
+			log("failed to persist override: " + String(e));
+		}
+	};
+	(async () => {
+		if (!getConfig().enabled) {
+			dormantReason = "disabled by config";
+			log("dormant: disabled by config");
+			return;
+		}
+		if (!bin()) {
+			dormantReason = "agy binary not found — install via https://antigravity.google/docs/cli/install";
+			log("dormant: agy binary not found");
+			return;
+		}
+		try {
+			versionCache = parseVersion((await probeProcess(bin(), ["--version"], 1e4)).stdout);
+			if (versionCache && compareVersions(versionCache, "1.1.8") < 0) {
+				dormantReason = "agy " + versionCache + " is older than 1.1.8 — run: agy update";
+				log("dormant: " + dormantReason);
+				return;
+			}
+			log("agy detected: " + (versionCache ?? "unknown version"));
+		} catch {
+			log("version probe failed — continuing with fallback catalog");
+		}
+		await catalog.refreshIfNeeded().catch(() => void 0);
+	})();
+	if (getConfig().enabled && bin()) try {
+		ctx.llm.registerAdapter([PROVIDER_ID], adapter);
+		log("registered provider route: antigravity");
+	} catch (e) {
+		log("adapter registration failed: " + String(e));
+	}
+	try {
+		ctx.llm.registerConfigurableProviders([{
+			provider: PROVIDER_ID,
+			displayName: "Antigravity (agy CLI)",
+			settingsNs: PLUGIN_ID,
+			settingsPath: [],
+			declared: false
+		}]);
+	} catch {}
+	ctx.commands.register(agyCommandDefinition({
+		cfg: getConfig,
+		bin,
+		version,
+		auth: () => auth,
+		catalog: () => catalog,
+		store: () => store,
+		lastRun: () => lastRun,
+		setOverride,
+		runDoctor: async () => {
+			return writeDoctorReport({
+				cfg: getConfig,
+				bin,
+				version,
+				catalog: () => catalog,
+				store: () => store,
+				recentLines: () => lastParser.recentLines
+			});
+		}
+	}));
+	const toolsSvc = ctx.get("tools");
+	const askToolDispose = { current: null };
+	const syncAskTool = () => {
+		const want = getConfig().askTool && bin() !== null;
+		if (want && askToolDispose.current === null && toolsSvc) {
+			const reg = toolsSvc.register(defineAgyAskTool({
+				cfg: getConfig,
+				bin,
+				catalog: () => catalog.get()
+			}));
+			askToolDispose.current = typeof reg === "function" ? reg : null;
+		} else if (!want && askToolDispose.current !== null) {
+			askToolDispose.current();
+			askToolDispose.current = null;
+		}
+	};
+	syncAskTool();
+	const webServer = ctx.get("webServer");
+	const sendJson = (res, status, body) => {
+		res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+		res.end(JSON.stringify(body));
+	};
+	const readBody = (req) => {
+		const r = req;
+		return new Promise((resolve) => {
+			const chunks = [];
+			r.on?.("data", (c) => chunks.push(c));
+			r.on?.("end", () => {
+				try {
+					const v = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+					resolve(v && typeof v === "object" ? v : {});
+				} catch {
+					resolve({});
+				}
+			});
+		});
+	};
+	const methodOf = (req) => {
+		const m = req.method;
+		return typeof m === "string" ? m.toUpperCase() : "GET";
+	};
+	if (webServer) {
+		webServer.register({
+			kind: "exact",
+			path: "/plugins/agy-link/status",
+			handler: (_req, res) => {
+				const cfg = getConfig();
+				const cat = catalog.get();
+				sendJson(res, 200, {
+					plugin: "dsh-agy-link",
+					bin: bin(),
+					version: versionCache,
+					dormantReason,
+					enabled: cfg.enabled,
+					permissionMode: cfg.permissionMode,
+					defaultModel: cfg.defaultModel,
+					defaultEffort: cfg.defaultEffort,
+					askTool: cfg.askTool,
+					auth: auth.status(),
+					catalog: {
+						source: cat.source,
+						count: cat.models.length,
+						lastError: cat.lastError ?? null
+					},
+					bindings: Object.keys(store.all()).length,
+					lastRun
+				});
+			}
+		});
+		webServer.register({
+			kind: "exact",
+			path: "/plugins/agy-link/auth",
+			handler: (req, res) => {
+				(async () => {
+					if (methodOf(req) !== "POST") {
+						sendJson(res, 405, { error: "POST only" });
+						return;
+					}
+					await readBody(req);
+					const st = await auth.begin();
+					sendJson(res, 200, st);
+				})();
+			}
+		});
+		webServer.register({
+			kind: "exact",
+			path: "/plugins/agy-link/auth-code",
+			handler: (req, res) => {
+				(async () => {
+					if (methodOf(req) !== "POST") {
+						sendJson(res, 405, { error: "POST only" });
+						return;
+					}
+					const body = await readBody(req);
+					const code = typeof body.code === "string" ? body.code : "";
+					if (code === "") {
+						sendJson(res, 400, { error: "missing code" });
+						return;
+					}
+					const st = await auth.submitCode(code);
+					if (st.phase === "ok") catalog.forceRefresh().catch(() => void 0);
+					sendJson(res, 200, st);
+				})();
+			}
+		});
+		webServer.register({
+			kind: "exact",
+			path: "/plugins/agy-link/config",
+			handler: (req, res) => {
+				(async () => {
+					if (methodOf(req) !== "POST") {
+						sendJson(res, 405, { error: "POST only" });
+						return;
+					}
+					const body = await readBody(req);
+					const key = typeof body.key === "string" ? body.key : "";
+					if (![
+						"permissionMode",
+						"defaultModel",
+						"defaultEffort",
+						"askTool"
+					].includes(key)) {
+						sendJson(res, 400, { error: "key not settable" });
+						return;
+					}
+					setOverride(key, body.value);
+					syncAskTool();
+					sendJson(res, 200, {
+						ok: true,
+						key,
+						value: body.value
+					});
+				})();
+			}
+		});
+		webServer.register({
+			kind: "exact",
+			path: "/plugins/agy-link/qr",
+			handler: (_req, res) => {
+				(async () => {
+					const st = auth.status();
+					const url = st.phase === "pending" ? st.url : void 0;
+					if (!url) {
+						const r404 = res;
+						r404.writeHead(404, { "Content-Type": "text/plain" });
+						r404.end("no pending auth");
+						return;
+					}
+					try {
+						const png = await (await import("qrcode")).toBuffer(url, {
+							type: "png",
+							width: 220,
+							margin: 1
+						});
+						const r2 = res;
+						r2.writeHead(200, {
+							"Content-Type": "image/png",
+							"Cache-Control": "no-store"
+						});
+						r2.end(png);
+					} catch {
+						sendJson(res, 500, { error: "qr generation failed" });
+					}
+				})();
+			}
+		});
+	}
+	ctx.effect(() => {
+		auth.dispose();
+		if (askToolDispose.current !== null) askToolDispose.current();
+		return () => void 0;
+	});
+}
+//#endregion
+export { apply, inject, name };