@aiden-ade/sandbox-agent 0.1.53 → 0.1.54

package/dist/index.cjs

@@ -7761,7 +7761,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve7.call(this, root, ref);
+      let _sch = resolve9.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a2 = root.localRefs) === null || _a2 === void 0 ? void 0 : _a2[ref];
         const { schemaId } = this.opts;
@@ -7788,7 +7788,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve7(root, ref) {
+    function resolve9(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -8419,55 +8419,55 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve7(baseURI, relativeURI, options) {
+    function resolve9(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse6(baseURI, schemelessOptions), parse6(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base, relative3, options, skipNormalization) {
+    function resolveComponent(base, relative4, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base = parse6(serialize(base, options), options);
-        relative3 = parse6(serialize(relative3, options), options);
+        relative4 = parse6(serialize(relative4, options), options);
       }
       options = options || {};
-      if (!options.tolerant && relative3.scheme) {
-        target.scheme = relative3.scheme;
-        target.userinfo = relative3.userinfo;
-        target.host = relative3.host;
-        target.port = relative3.port;
-        target.path = removeDotSegments(relative3.path || "");
-        target.query = relative3.query;
+      if (!options.tolerant && relative4.scheme) {
+        target.scheme = relative4.scheme;
+        target.userinfo = relative4.userinfo;
+        target.host = relative4.host;
+        target.port = relative4.port;
+        target.path = removeDotSegments(relative4.path || "");
+        target.query = relative4.query;
       } else {
-        if (relative3.userinfo !== void 0 || relative3.host !== void 0 || relative3.port !== void 0) {
-          target.userinfo = relative3.userinfo;
-          target.host = relative3.host;
-          target.port = relative3.port;
-          target.path = removeDotSegments(relative3.path || "");
-          target.query = relative3.query;
+        if (relative4.userinfo !== void 0 || relative4.host !== void 0 || relative4.port !== void 0) {
+          target.userinfo = relative4.userinfo;
+          target.host = relative4.host;
+          target.port = relative4.port;
+          target.path = removeDotSegments(relative4.path || "");
+          target.query = relative4.query;
         } else {
-          if (!relative3.path) {
+          if (!relative4.path) {
             target.path = base.path;
-            if (relative3.query !== void 0) {
-              target.query = relative3.query;
+            if (relative4.query !== void 0) {
+              target.query = relative4.query;
             } else {
               target.query = base.query;
             }
           } else {
-            if (relative3.path[0] === "/") {
-              target.path = removeDotSegments(relative3.path);
+            if (relative4.path[0] === "/") {
+              target.path = removeDotSegments(relative4.path);
             } else {
               if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-                target.path = "/" + relative3.path;
+                target.path = "/" + relative4.path;
               } else if (!base.path) {
-                target.path = relative3.path;
+                target.path = relative4.path;
               } else {
-                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative3.path;
+                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative4.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative3.query;
+            target.query = relative4.query;
           }
           target.userinfo = base.userinfo;
           target.host = base.host;
@@ -8475,7 +8475,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base.scheme;
       }
-      target.fragment = relative3.fragment;
+      target.fragment = relative4.fragment;
       return target;
     }
     function equal(uriA, uriB, options) {
@@ -8677,7 +8677,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve7,
+      resolve: resolve9,
       resolveComponent,
       equal,
       serialize,
@@ -11703,9 +11703,7 @@ var PROVIDER_ALIASES = {
   agy: "antigravity_cli",
   antigravity: "antigravity_cli",
   antigravity_cli: "antigravity_cli",
-  codex: "codex_app_server",
-  gemini: "antigravity_cli",
-  gemini_cli: "antigravity_cli"
+  codex: "codex_app_server"
 };
 var BACKEND_CLI_COMMANDS = {
   claude_cli: "claude",
@@ -11716,11 +11714,10 @@ var BACKEND_CLI_COMMANDS = {
   agy: "agy",
   antigravity: "agy",
   antigravity_cli: "agy",
-  gemini_cli: "agy",
-  gemini: "agy",
   kimi_cli: "kimi-cli",
   grok_cli: "grok",
   opencode_cli: "opencode",
+  opencode_serve: "opencode",
   droid_cli: "droid",
   supatest_cli: "supatest"
 };
@@ -11812,7 +11809,7 @@ function resolveViaWhere(command, env) {
   return null;
 }
 function runCliProbeAsync(executable, env, args = ["--version"], timeoutMs = 3e3, spawnOptions) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve9) => {
     const isWin = (0, import_node_os.platform)() === "win32";
     let command = executable;
     let commandArgs = args;
@@ -11832,7 +11829,7 @@ function runCliProbeAsync(executable, env, args = ["--version"], timeoutMs = 3e3
         stdio: closeStdin ? ["pipe", "pipe", "pipe"] : void 0
       });
     } catch (error2) {
-      resolve7({ status: null, stdout: "", stderr: "", error: error2 });
+      resolve9({ status: null, stdout: "", stderr: "", error: error2 });
       return;
     }
     if (closeStdin) {
@@ -11846,10 +11843,10 @@ function runCliProbeAsync(executable, env, args = ["--version"], timeoutMs = 3e3
     child.stderr?.setEncoding("utf8").on("data", (chunk) => {
       stderr += chunk;
     });
-    child.once("error", (error2) => resolve7({ status: null, stdout, stderr, error: error2 }));
+    child.once("error", (error2) => resolve9({ status: null, stdout, stderr, error: error2 }));
     child.once(
       "close",
-      (status, signal) => resolve7({ status, stdout, stderr, signal: signal ?? null })
+      (status, signal) => resolve9({ status, stdout, stderr, signal: signal ?? null })
     );
   });
 }
@@ -12161,7 +12158,7 @@ You MUST NOT call these tools:
 
 You MUST NOT call \`start_task_session\` before you have written a plan or requirements document. Delegate only after scope is defined.
 
-Read-only inspection is fine when you need to understand what exists.
+Read-only inspection is fine when you need to understand what exists \u2014 but check the platform first. See "Platform tools come before local tools" below.
 
 ## Platform document policy
 
@@ -12169,13 +12166,37 @@ Platform Documents are the default destination and source of truth for PM work.
 
 Do NOT call \`create_plan\`, \`create_document_artifact\`, or another artifact-creation tool unless the user explicitly asks for an **artifact**. If \`create_document\` is unavailable or fails, report that blocker; do not silently substitute an artifact.
 
-## How to access docs
+## Platform tools come before local tools
 
-When asked to access, check, consult, or answer from docs, use this order:
-1. **Platform Documents first** \u2014 use \`list_documents\` or \`search\` to locate the relevant platform document, then \`get_document\` to read it. If a document ID is already known, call \`get_document\` directly.
-2. **Local repository docs only as fallback** \u2014 read \`README.md\`, \`AGENTS.md\`, \`notes/\`, or \`docs/\` only when no relevant platform document exists or the platform document tools are unavailable.
+You work on the Alan platform. The platform is where product truth lives: tasks, subtasks, decisions, events, sessions, artifacts, memory, and Documents. Local files and shell commands are a **last resort**, not a starting point.
 
-Do not inspect local repository docs first when the user asks to access docs. Cite which document answered the question and say when local fallback was necessary. If neither source covers it, say so instead of guessing.
+**Before every lookup, ask: does the platform know this?** If a platform MCP tool could plausibly answer the question, you MUST call it before any \`Read\`, \`Glob\`, \`Grep\`, or \`Bash\`. Reaching for a local tool first is a mistake even when it would be faster or you already know the file path.
+
+| What you want | Use this | Not this |
+|---|---|---|
+| Requirements, PRDs, specs, notes, any written knowledge | \`list_documents\`, \`search\`, \`get_document\` | reading \`docs/\`, \`notes/\`, \`README.md\` |
+| Scope, status, priority, or history of work | \`get_task\`, \`list_subtasks\`, \`list_tasks\` | \`git log\`, commit messages |
+| What was decided and why | \`list_task_decisions\`, \`list_task_events\` | code comments, in-repo ADRs |
+| What an agent did or is doing | \`list_sessions\`, \`get_session_context\` | \`git log\`, diffing the worktree |
+| Prior agent context | \`list_agent_memory\`, \`get_task_memory\` | scratch files |
+| Outputs of completed work | \`list_artifacts\`, \`get_artifact\` | build output, generated files |
+| Where code lives or how it works | \`search_code_context\` first, then \`Read\` the cited files | \`Grep\`/\`Glob\` sweeps |
+
+**If you do fall back to a local tool, say so out loud** \u2014 name the platform tool you tried and what it returned (nothing, unavailable, insufficient). A silent local read is a violation of this rule. If no platform tool was tried, you have not earned the local read.
+
+Code is the exception that proves the rule: understanding how something works legitimately ends in reading source. Even then, start with \`search_code_context\` and read only the files it cites.
+
+**Default for written knowledge: platform Documents.** Any request to find, check, consult, review, summarize, or answer from written knowledge resolves against platform Documents \u2014 use \`list_documents\` or \`search\` to locate it, then \`get_document\` to read it. If a document ID is already known, call \`get_document\` directly.
+
+This applies no matter which word the user uses. Treat all of these as the same request: docs, documentation, documents, notes, PRD, spec, requirements, design doc, plan, proposal, RFC, wiki, runbook, onboarding, guidelines, "what did we decide", "what did we write down", "what do we have on X". The noun never changes where you look.
+
+**Local repository files are off-limits for knowledge lookup** unless the user unambiguously points you at the repository. Do not read \`README.md\`, \`AGENTS.md\`, \`notes/\`, \`docs/\`, or any other in-repo file as a fallback, as corroboration, because no platform document matched, or because the user's wording happens to match a directory name.
+
+A bare noun is never a pointer to the repository. "Check the notes" means platform Documents, not \`notes/\`. "Check the docs" means platform Documents, not \`docs/\`. Only these count as pointing at the repository:
+- an explicit location \u2014 "in the repo", "in the codebase", "local files", "on disk", "in the worktree"
+- a concrete path or filename \u2014 \`notes/foo.md\`, \`AGENTS.md\`, "the readme"
+
+When platform Documents do not cover the question, stop and say so, then offer to check the repository. Do not read local files first, and do not guess. Cite which document answered the question.
 
 ## Your primary tools
 
@@ -12631,7 +12652,10 @@ function toAntigravityMcpServers(src) {
     const s = raw;
     if (typeof s.type === "string" && s.type === "http" || typeof s.url === "string") {
       out[name] = {
-        httpUrl: s.url,
+        // Antigravity's current mcp_config.json schema uses `serverUrl`. Its
+        // legacy settings.json integration used `httpUrl`, which the current CLI
+        // intentionally does not read for MCP registration.
+        serverUrl: s.url,
         ...s.headers && typeof s.headers === "object" && s.headers !== null && Object.keys(s.headers).length > 0 ? { headers: s.headers } : {}
       };
     } else if (typeof s.command === "string") {
@@ -12720,11 +12744,7 @@ function renderAlanMcpConfigFiles(mcpServers, home) {
       content: JSON.stringify({ mcpServers: toFactoryMcpServers(mcpServers) })
     },
     {
-      path: `${home}/.gemini/settings.json`,
-      content: JSON.stringify({ mcpServers: toAntigravityMcpServers(mcpServers) })
-    },
-    {
-      path: `${home}/.gemini/antigravity-cli/settings.json`,
+      path: `${home}/.gemini/config/mcp_config.json`,
       content: JSON.stringify({ mcpServers: toAntigravityMcpServers(mcpServers) })
     },
     {
@@ -12747,8 +12767,9 @@ function alanMcpConfigFilesForBackend(backendKind, mcpServers, home) {
     case "droid_cli":
       return byPathSuffix("/.factory/mcp.json");
     case "antigravity_cli":
-      return byPathSuffix("/.gemini/settings.json", "/.gemini/antigravity-cli/settings.json");
+      return byPathSuffix("/.gemini/config/mcp_config.json");
     case "opencode_cli":
+    case "opencode_serve":
       return byPathSuffix("/.config/opencode/opencode.json");
     default:
       return all;
@@ -17310,6 +17331,55 @@ function getAlanAgentPrompt(agentId) {
   return getAgentSystemPrompt(agentId);
 }
 
+// ../shared/dist/constants/agent.js
+var INTERACTIVE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "askuserquestion",
+  "askquestion",
+  "exitplanmode",
+  "enterplanmode"
+]);
+var HARNESS_ASK_TOOL_NAMES = /* @__PURE__ */ new Set(["askuserquestion", "askquestion"]);
+function normalizeToolName2(name) {
+  const lower = name.toLowerCase();
+  const mcp = lower.match(/^mcp__[a-z0-9-]+__(.+)$/);
+  const bare = mcp ? mcp[1] : lower;
+  return bare.replace(/[_\s-]/g, "");
+}
+function toolNameFromInput(input) {
+  if (!input || typeof input !== "object")
+    return null;
+  const rec = input;
+  if (typeof rec.toolName === "string" && rec.toolName.trim())
+    return rec.toolName;
+  if (typeof rec.name === "string" && rec.name.trim())
+    return rec.name;
+  return null;
+}
+function inputLooksLikeAskUserQuestion(input) {
+  if (!input || typeof input !== "object")
+    return false;
+  const rec = input;
+  const args = typeof rec.args === "object" && rec.args !== null ? rec.args : rec;
+  return Array.isArray(args.questions) && args.questions.length > 0;
+}
+function isAskUserQuestionTool(name, input) {
+  if (HARNESS_ASK_TOOL_NAMES.has(normalizeToolName2(name)))
+    return true;
+  const nested = toolNameFromInput(input);
+  if (nested && nested !== name && HARNESS_ASK_TOOL_NAMES.has(normalizeToolName2(nested))) {
+    return true;
+  }
+  return inputLooksLikeAskUserQuestion(input);
+}
+function isInteractiveToolName(name, input) {
+  const normalized = normalizeToolName2(name);
+  if (INTERACTIVE_TOOL_NAMES.has(normalized))
+    return true;
+  return isAskUserQuestionTool(name, input);
+}
+var ALAN_AGENT_WORKOS_USER_ID_PREFIX = "alan-agent:";
+var ALAN_AGENT_WORKOS_USER_ID_LIKE_PATTERN = `${ALAN_AGENT_WORKOS_USER_ID_PREFIX}%`;
+
 // ../shared/dist/effort.js
 var EFFORT_LEVELS = ["minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
 var CLAUDE_EFFORT_LEVELS = [
@@ -17736,6 +17806,9 @@ var PROVIDER_MODELS = {
   cursor_agent_cli: CURSOR_AGENT_MODELS,
   antigravity_cli: ANTIGRAVITY_CLI_SEED_MODELS,
   opencode_cli: OPENCODE_ZEN_MODELS,
+  // Server transport dispatches the same "opencode" binary/models as opencode_cli —
+  // share the catalog reference rather than duplicating it.
+  opencode_serve: OPENCODE_ZEN_MODELS,
   droid_cli: [
     { id: "claude-opus-4-8", name: "Claude Opus 4.8" },
     { id: "claude-haiku-4-5-20251001", name: "Claude Haiku 4.5" },
@@ -17946,17 +18019,17 @@ var CODEX_APP_SERVER_PICKER_FALLBACK_MODELS = [
 var ANTIGRAVITY_CLI_PICKER_FALLBACK_MODELS = [
   { id: "", name: "CLI default", capabilities: caps([]) },
   {
-    id: "Antigravity 3.5 Flash",
+    id: "gemini-3.5-flash",
     name: "Antigravity 3.5 Flash",
     capabilities: caps(ANTIGRAVITY_EFFORT)
   },
   {
-    id: "Antigravity 3.1 Pro",
+    id: "gemini-3.1-pro",
     name: "Antigravity 3.1 Pro",
     capabilities: caps(ANTIGRAVITY_EFFORT)
   },
   {
-    id: "Antigravity 3 Flash",
+    id: "gemini-3-flash",
     name: "Antigravity 3 Flash",
     capabilities: caps(ANTIGRAVITY_EFFORT)
   },
@@ -18027,14 +18100,16 @@ var DISCOVERY_SEED_PROVIDERS = /* @__PURE__ */ new Set([
   "antigravity_cli",
   "cursor_agent_cli",
   "opencode_cli",
+  "opencode_serve",
   "kimi_cli",
   "grok_cli",
   "copilot_cli",
   "droid_cli"
 ]);
 function baseCatalogForProvider(providerKind) {
-  const fallback = getProviderPickerFallbackModels(providerKind);
-  const staticCatalog = PROVIDER_MODELS[providerKind] ?? [];
+  const catalogProvider = providerKind === "opencode_serve" ? "opencode_cli" : providerKind;
+  const fallback = getProviderPickerFallbackModels(catalogProvider);
+  const staticCatalog = PROVIDER_MODELS[catalogProvider] ?? [];
   if (staticCatalog.length === 0) {
     return fallback;
   }
@@ -18063,68 +18138,25 @@ var import_os2 = require("os");
 var import_path2 = require("path");
 var import_child_process = require("child_process");
 var import_fs3 = require("fs");
-var import_os3 = require("os");
 var import_path3 = require("path");
+var import_fs4 = require("fs");
+var import_os3 = require("os");
+var import_path4 = require("path");
 var import_readline = require("readline");
 var import_crypto2 = require("crypto");
 var import_child_process2 = require("child_process");
 var import_child_process3 = require("child_process");
-var import_crypto3 = require("crypto");
-var import_fs4 = require("fs");
+var import_fs5 = require("fs");
 var import_os4 = require("os");
-var import_path4 = require("path");
+var import_path5 = require("path");
+var import_url = require("url");
+var import_crypto3 = require("crypto");
+var import_fs6 = require("fs");
+var import_os5 = require("os");
+var import_path6 = require("path");
 var import_child_process4 = require("child_process");
 var import_util4 = require("util");
 
-// ../shared/dist/constants/agent.js
-var INTERACTIVE_TOOL_NAMES = /* @__PURE__ */ new Set([
-  "askuserquestion",
-  "askquestion",
-  "exitplanmode",
-  "enterplanmode"
-]);
-var HARNESS_ASK_TOOL_NAMES = /* @__PURE__ */ new Set(["askuserquestion", "askquestion"]);
-function normalizeToolName2(name) {
-  const lower = name.toLowerCase();
-  const mcp = lower.match(/^mcp__[a-z0-9-]+__(.+)$/);
-  const bare = mcp ? mcp[1] : lower;
-  return bare.replace(/[_\s-]/g, "");
-}
-function toolNameFromInput(input) {
-  if (!input || typeof input !== "object")
-    return null;
-  const rec = input;
-  if (typeof rec.toolName === "string" && rec.toolName.trim())
-    return rec.toolName;
-  if (typeof rec.name === "string" && rec.name.trim())
-    return rec.name;
-  return null;
-}
-function inputLooksLikeAskUserQuestion(input) {
-  if (!input || typeof input !== "object")
-    return false;
-  const rec = input;
-  const args = typeof rec.args === "object" && rec.args !== null ? rec.args : rec;
-  return Array.isArray(args.questions) && args.questions.length > 0;
-}
-function isAskUserQuestionTool(name, input) {
-  if (HARNESS_ASK_TOOL_NAMES.has(normalizeToolName2(name)))
-    return true;
-  const nested = toolNameFromInput(input);
-  if (nested && nested !== name && HARNESS_ASK_TOOL_NAMES.has(normalizeToolName2(nested))) {
-    return true;
-  }
-  return inputLooksLikeAskUserQuestion(input);
-}
-function isInteractiveToolName(name, input) {
-  const normalized = normalizeToolName2(name);
-  if (INTERACTIVE_TOOL_NAMES.has(normalized))
-    return true;
-  return isAskUserQuestionTool(name, input);
-}
-var ALAN_AGENT_WORKOS_USER_ID_PREFIX = "alan-agent:";
-var ALAN_AGENT_WORKOS_USER_ID_LIKE_PATTERN = `${ALAN_AGENT_WORKOS_USER_ID_PREFIX}%`;
-
 // ../shared/dist/constants/colors.js
 var CATEGORICAL_COLORS = {
   slate: "#7280a0",
@@ -18368,23 +18400,23 @@ var PRIORITY_OPTIONS = [
 ];
 
 // ../agent-core/dist/index.js
-var import_fs5 = require("fs");
-var import_os5 = require("os");
-var import_path5 = require("path");
-var import_fs6 = require("fs");
-var import_os6 = require("os");
-var import_path6 = require("path");
 var import_fs7 = require("fs");
-var import_os7 = require("os");
+var import_os6 = require("os");
 var import_path7 = require("path");
-var import_readline2 = require("readline");
-var import_url = require("url");
 var import_fs8 = require("fs");
-var import_os8 = require("os");
+var import_os7 = require("os");
 var import_path8 = require("path");
-var import_crypto4 = require("crypto");
 var import_fs9 = require("fs");
+var import_os8 = require("os");
 var import_path9 = require("path");
+var import_readline2 = require("readline");
+var import_url2 = require("url");
+var import_fs10 = require("fs");
+var import_os9 = require("os");
+var import_path10 = require("path");
+var import_crypto4 = require("crypto");
+var import_fs11 = require("fs");
+var import_path11 = require("path");
 var MANAGED_ALAN_MCP_SERVER_NAMES = [
   "alan",
   "alan-prod",
@@ -18438,7 +18470,7 @@ async function acquireConfigLock(path) {
       if (Date.now() - startedAt >= 2e3) {
         throw new Error(`Alan could not safely update ${path}`);
       }
-      await new Promise((resolve22) => setTimeout(resolve22, 20));
+      await new Promise((resolve42) => setTimeout(resolve42, 20));
     }
   }
 }
@@ -18674,23 +18706,10 @@ function buildJsonTargets(home) {
         server.headers = headers;
       }
     },
-    {
-      cli: "Antigravity",
-      configPath: (0, import_path2.join)(home, ".gemini", "settings.json"),
-      guardDir: (0, import_path2.join)(home, ".gemini"),
-      readServers: (config2) => config2.mcpServers ?? {},
-      writeServers: (config2, servers) => {
-        config2.mcpServers = servers;
-      },
-      readHeaders: (server) => server.headers,
-      writeHeaders: (server, headers) => {
-        server.headers = headers;
-      }
-    },
     {
       cli: "Antigravity CLI",
-      configPath: (0, import_path2.join)(home, ".gemini", "antigravity-cli", "settings.json"),
-      guardDir: (0, import_path2.join)(home, ".gemini"),
+      configPath: (0, import_path2.join)(home, ".gemini", "config", "mcp_config.json"),
+      guardDir: (0, import_path2.join)(home, ".gemini", "config"),
       readServers: (config2) => config2.mcpServers ?? {},
       writeServers: (config2, servers) => {
         config2.mcpServers = servers;
@@ -18736,8 +18755,8 @@ var mcpConfigWriteGateTail = Promise.resolve();
 function acquireMcpConfigWriteGate() {
   const previous = mcpConfigWriteGateTail;
   let releaseCurrent;
-  const current = new Promise((resolve22) => {
-    releaseCurrent = resolve22;
+  const current = new Promise((resolve42) => {
+    releaseCurrent = resolve42;
   });
   mcpConfigWriteGateTail = previous.then(() => current);
   return previous.then(() => {
@@ -18749,6 +18768,64 @@ function acquireMcpConfigWriteGate() {
     };
   });
 }
+var AGENT_INSTRUCTIONS_FILE = "AGENTS.md";
+var MAX_INSTRUCTION_CHARS = 48e3;
+function isWorkspaceRoot(dir) {
+  return (0, import_fs3.existsSync)((0, import_path3.join)(dir, ".git"));
+}
+function findWorkspaceRoot(cwd) {
+  let current = (0, import_path3.resolve)(cwd);
+  while (true) {
+    if (isWorkspaceRoot(current)) return current;
+    const parent = (0, import_path3.dirname)(current);
+    if (parent === current) return (0, import_path3.resolve)(cwd);
+    current = parent;
+  }
+}
+function instructionPaths(cwd) {
+  const root = findWorkspaceRoot(cwd);
+  const paths = [];
+  let current = (0, import_path3.resolve)(cwd);
+  while (true) {
+    const path = (0, import_path3.join)(current, AGENT_INSTRUCTIONS_FILE);
+    try {
+      if ((0, import_fs3.existsSync)(path) && (0, import_fs3.statSync)(path).isFile()) paths.unshift(path);
+    } catch {
+    }
+    if (current === root) return paths;
+    const parent = (0, import_path3.dirname)(current);
+    if (parent === current) return paths;
+    current = parent;
+  }
+}
+function buildAntigravityWorkspaceInstructions(cwd) {
+  let remaining = MAX_INSTRUCTION_CHARS;
+  const sections = [];
+  for (const path of instructionPaths(cwd)) {
+    if (remaining <= 0) break;
+    let content;
+    try {
+      content = (0, import_fs3.readFileSync)(path, "utf8").trim();
+    } catch {
+      continue;
+    }
+    if (!content) continue;
+    const included = content.slice(0, remaining);
+    sections.push(
+      [
+        `<workspace_agent_instructions source="${path}">`,
+        included,
+        "</workspace_agent_instructions>"
+      ].join("\n")
+    );
+    remaining -= included.length;
+  }
+  if (sections.length === 0) return void 0;
+  return [
+    "Treat the following repository agent instructions as active for this session.",
+    ...sections
+  ].join("\n\n");
+}
 function buildPromptWithSystem(config2, promptText) {
   const parts2 = [
     config2.systemPrompt?.trim(),
@@ -18780,16 +18857,16 @@ function imageFileExtension(mimeType) {
 }
 function createImageTempDirectory(cwd) {
   const candidates = [
-    cwd ? (0, import_path3.join)(cwd, ".alan-images-") : null,
-    (0, import_path3.join)((0, import_os3.tmpdir)(), "alan-images-")
+    cwd ? (0, import_path4.join)(cwd, ".alan-images-") : null,
+    (0, import_path4.join)((0, import_os3.tmpdir)(), "alan-images-")
   ].filter((value2) => Boolean(value2));
   for (const candidate of candidates) {
     try {
-      return (0, import_fs3.mkdtempSync)(candidate);
+      return (0, import_fs4.mkdtempSync)(candidate);
     } catch {
     }
   }
-  return (0, import_fs3.mkdtempSync)((0, import_path3.join)((0, import_os3.tmpdir)(), "alan-images-"));
+  return (0, import_fs4.mkdtempSync)((0, import_path4.join)((0, import_os3.tmpdir)(), "alan-images-"));
 }
 function safeFilename(filename) {
   const safe = filename.replace(/[^a-zA-Z0-9._-]/g, "_").replace(/^_+/, "");
@@ -18803,8 +18880,8 @@ function writeImagesToTempFiles(images, cwd) {
   const files = [];
   for (const img of images) {
     const ext = imageFileExtension(img.mimeType);
-    const filePath = (0, import_path3.join)(directory, `alan-img-${img.id}.${ext}`);
-    (0, import_fs3.writeFileSync)(filePath, Buffer.from(img.data, "base64"));
+    const filePath = (0, import_path4.join)(directory, `alan-img-${img.id}.${ext}`);
+    (0, import_fs4.writeFileSync)(filePath, Buffer.from(img.data, "base64"));
     paths.push(filePath);
     files.push({
       filename: img.filename,
@@ -18819,7 +18896,7 @@ function writeImagesToTempFiles(images, cwd) {
     files,
     cleanup: () => {
       try {
-        (0, import_fs3.rmSync)(directory, { recursive: true, force: true });
+        (0, import_fs4.rmSync)(directory, { recursive: true, force: true });
       } catch {
       }
     }
@@ -18845,8 +18922,8 @@ function writeFilesToTempFiles(files, cwd) {
   }
   for (const file2 of dataFiles) {
     if (!directory || file2.data === void 0) continue;
-    const filePath = (0, import_path3.join)(directory, `${file2.id}-${safeFilename(file2.filename)}`);
-    (0, import_fs3.writeFileSync)(filePath, Buffer.from(file2.data, "base64"));
+    const filePath = (0, import_path4.join)(directory, `${file2.id}-${safeFilename(file2.filename)}`);
+    (0, import_fs4.writeFileSync)(filePath, Buffer.from(file2.data, "base64"));
     paths.push(filePath);
     tempFiles.push({
       filename: file2.filename,
@@ -18861,7 +18938,7 @@ function writeFilesToTempFiles(files, cwd) {
     cleanup: () => {
       if (!directory) return;
       try {
-        (0, import_fs3.rmSync)(directory, { recursive: true, force: true });
+        (0, import_fs4.rmSync)(directory, { recursive: true, force: true });
       } catch {
       }
     }
@@ -19322,15 +19399,15 @@ var SPAWN_RETRY_DELAYS_BY_CODE = {
   ETXTBSY: [250, 750, 1500, 3e3, 5e3],
   ENOENT: [250, 750]
 };
-var delay = (ms) => new Promise((resolve22) => setTimeout(resolve22, ms));
+var delay = (ms) => new Promise((resolve42) => setTimeout(resolve42, ms));
 var SPAWN_OUTCOME_TIMEOUT_MS = 2e3;
 function waitForSpawnOutcome(child, timeoutMs = SPAWN_OUTCOME_TIMEOUT_MS) {
-  return new Promise((resolve22) => {
-    const timer = setTimeout(() => resolve22(null), timeoutMs);
+  return new Promise((resolve42) => {
+    const timer = setTimeout(() => resolve42(null), timeoutMs);
     timer.unref?.();
     const settle = (value2) => {
       clearTimeout(timer);
-      resolve22(value2);
+      resolve42(value2);
     };
     child.once("spawn", () => settle(null));
     child.once("error", (error2) => settle(error2));
@@ -19457,36 +19534,36 @@ function createGenericCliBackend(options) {
       let idleTimedOut = false;
       let idleTimeoutReason = null;
       try {
-        const exitPromise = new Promise((resolve22, reject) => {
+        const exitPromise = new Promise((resolve42, reject) => {
           child.on("error", (error2) => {
             reject(formatCliSpawnError(options.command, error2));
           });
-          child.on("close", (exitCode2, signal) => resolve22({ exitCode: exitCode2, signal }));
+          child.on("close", (exitCode2, signal) => resolve42({ exitCode: exitCode2, signal }));
           const onAbort = () => {
             killProcessTree(child.pid, { signal: "SIGTERM", child });
           };
           context.abortController.signal.addEventListener("abort", onAbort, { once: true });
         });
         if (options.keepStdinOpen) {
-          const resultPromise = new Promise((resolve22) => {
-            state.onResultReceived = () => resolve22("result_received");
-            if (state.resultReceived) resolve22("result_received");
+          const resultPromise = new Promise((resolve42) => {
+            state.onResultReceived = () => resolve42("result_received");
+            if (state.resultReceived) resolve42("result_received");
           });
           const IDLE_MS = options.resultIdleTimeoutMs ?? 10 * 60 * 1e3;
           let idleTimer = null;
-          const idlePromise = new Promise((resolve22) => {
+          const idlePromise = new Promise((resolve42) => {
             const armIdleTimer = () => {
               if (idleTimer) clearTimeout(idleTimer);
               idleTimer = setTimeout(() => {
                 if (presenter.pendingAskUserToolIds?.size) {
                   idleTimeoutReason = "pending_user_answer";
-                  resolve22("idle_timeout");
+                  resolve42("idle_timeout");
                 } else if (state.awaitingPostBackgroundSynthesis || state.resultDeferredOnBackgroundWork && state.activeBackgroundTaskIds?.size) {
                   idleTimeoutReason = state.awaitingPostBackgroundSynthesis ? "post_subagent_synthesis" : "background_task";
-                  resolve22("idle_timeout");
+                  resolve42("idle_timeout");
                 } else if (options.postStartupSilenceTimeoutMs && sawStdoutLine && typeof state.lastRawOutputAtMs === "number" && Date.now() - state.lastRawOutputAtMs >= options.postStartupSilenceTimeoutMs) {
                   idleTimeoutReason = "post_startup_silence";
-                  resolve22("idle_timeout");
+                  resolve42("idle_timeout");
                 } else {
                   armIdleTimer();
                 }
@@ -19507,14 +19584,14 @@ function createGenericCliBackend(options) {
             processExit = await Promise.race([
               exitPromise,
               new Promise(
-                (resolve22) => setTimeout(() => resolve22({ exitCode: null, signal: "SIGKILL" }), 5e3)
+                (resolve42) => setTimeout(() => resolve42({ exitCode: null, signal: "SIGKILL" }), 5e3)
               )
             ]);
           } else if (raceResult === "result_received") {
             const GRACE_MS = 5e3;
             const gracedExit = await Promise.race([
               exitPromise,
-              new Promise((resolve22) => setTimeout(() => resolve22(null), GRACE_MS))
+              new Promise((resolve42) => setTimeout(() => resolve42(null), GRACE_MS))
             ]);
             if (gracedExit) processExit = gracedExit;
             if (child.exitCode === null && !child.killed) {
@@ -19832,6 +19909,234 @@ function createGenericCliBackend(options) {
     }
   };
 }
+function stringField(record2, key) {
+  const value2 = record2[key];
+  return typeof value2 === "string" && value2.trim().length > 0 ? value2 : void 0;
+}
+function backgroundTaskKeys(record2) {
+  return [
+    stringField(record2, "task_id"),
+    stringField(record2, "taskId"),
+    stringField(record2, "tool_use_id"),
+    stringField(record2, "toolUseId"),
+    stringField(record2, "id")
+  ].filter((key) => Boolean(key));
+}
+function backgroundTaskId(record2) {
+  return stringField(record2, "task_id") ?? stringField(record2, "taskId");
+}
+function backgroundToolUseId(record2) {
+  return stringField(record2, "tool_use_id") ?? stringField(record2, "toolUseId");
+}
+function registerBackgroundTaskIds(state, keys) {
+  for (const key of keys) {
+    if (!key) continue;
+    if (!state.activeBackgroundTaskIds) state.activeBackgroundTaskIds = /* @__PURE__ */ new Set();
+    state.activeBackgroundTaskIds.add(key);
+  }
+}
+function registerBackgroundLauncher(state, toolUseId) {
+  registerBackgroundTaskIds(state, [toolUseId]);
+  if (!state.pendingLauncherToolIds) state.pendingLauncherToolIds = [];
+  if (!state.pendingLauncherToolIds.includes(toolUseId)) {
+    state.pendingLauncherToolIds.push(toolUseId);
+  }
+}
+function drainNextUnlinkedBackgroundLauncher(state) {
+  const launcherId = state.pendingLauncherToolIds?.shift();
+  if (state.pendingLauncherToolIds?.length === 0) state.pendingLauncherToolIds = void 0;
+  if (launcherId) clearBackgroundTaskIds(state, [launcherId]);
+  return launcherId;
+}
+function registerBackgroundTaskRecord(state, record2, launcherToolUseId) {
+  const taskId = backgroundTaskId(record2);
+  let toolUseId = backgroundToolUseId(record2) ?? launcherToolUseId ?? void 0;
+  if (!toolUseId && taskId) {
+    const nextLauncher = state.pendingLauncherToolIds?.[0];
+    if (nextLauncher) {
+      toolUseId = nextLauncher;
+    } else if (state.activeBackgroundTaskIds?.size === 1) {
+      const [candidate] = state.activeBackgroundTaskIds;
+      if (candidate && candidate !== taskId) toolUseId = candidate;
+    }
+  }
+  registerBackgroundTaskIds(state, backgroundTaskKeys(record2));
+  if (!taskId || !toolUseId) return;
+  if (state.pendingLauncherToolIds) {
+    const idx = state.pendingLauncherToolIds.indexOf(toolUseId);
+    if (idx >= 0) state.pendingLauncherToolIds.splice(idx, 1);
+    if (state.pendingLauncherToolIds.length === 0) state.pendingLauncherToolIds = void 0;
+  }
+  if (!state.backgroundToolIdByTaskId) state.backgroundToolIdByTaskId = /* @__PURE__ */ new Map();
+  if (!state.backgroundTaskIdsByToolId) state.backgroundTaskIdsByToolId = /* @__PURE__ */ new Map();
+  state.backgroundToolIdByTaskId.set(taskId, toolUseId);
+  const taskIds = state.backgroundTaskIdsByToolId.get(toolUseId) ?? /* @__PURE__ */ new Set();
+  taskIds.add(taskId);
+  state.backgroundTaskIdsByToolId.set(toolUseId, taskIds);
+}
+function clearBackgroundTaskIds(state, keys) {
+  const activeIds = state.activeBackgroundTaskIds;
+  if (!activeIds) return;
+  for (const key of keys) {
+    if (!key) continue;
+    activeIds.delete(key);
+    const toolUseId = state.backgroundToolIdByTaskId?.get(key);
+    if (toolUseId) {
+      activeIds.delete(toolUseId);
+      state.backgroundToolIdByTaskId?.delete(key);
+      const taskIds2 = state.backgroundTaskIdsByToolId?.get(toolUseId);
+      taskIds2?.delete(key);
+      if (taskIds2?.size === 0) state.backgroundTaskIdsByToolId?.delete(toolUseId);
+    }
+    const taskIds = state.backgroundTaskIdsByToolId?.get(key);
+    if (taskIds) {
+      for (const taskId of taskIds) {
+        activeIds.delete(taskId);
+        state.backgroundToolIdByTaskId?.delete(taskId);
+      }
+      state.backgroundTaskIdsByToolId?.delete(key);
+    }
+  }
+  if (state.pendingLauncherToolIds) {
+    state.pendingLauncherToolIds = state.pendingLauncherToolIds.filter((id) => activeIds.has(id));
+    if (state.pendingLauncherToolIds.length === 0) state.pendingLauncherToolIds = void 0;
+  }
+  if (activeIds.size === 0) state.activeBackgroundTaskIds = void 0;
+}
+function resolveBackgroundTaskToolUseId(state, record2) {
+  const explicitToolUseId = backgroundToolUseId(record2);
+  if (explicitToolUseId) return explicitToolUseId;
+  const taskId = backgroundTaskId(record2);
+  return taskId ? state.backgroundToolIdByTaskId?.get(taskId) : void 0;
+}
+var TERMINAL_BACKGROUND_STATUSES = /* @__PURE__ */ new Set([
+  "complete",
+  "completed",
+  "done",
+  "success",
+  "succeeded",
+  "failed",
+  "failure",
+  "error",
+  "cancelled",
+  "canceled",
+  "aborted",
+  "interrupted",
+  "stopped"
+]);
+var NON_TERMINAL_BACKGROUND_STATUSES = /* @__PURE__ */ new Set([
+  "running",
+  "in_progress",
+  "inprogress",
+  "started",
+  "pending",
+  "active",
+  "working",
+  "queued"
+]);
+var ASYNC_LAUNCH_ACK_RE = /^(async agent launched successfully|background (?:task|agent|subagent) (?:launched|started|running)|task (?:launched|started) successfully)/i;
+function isTerminalBackgroundStatus(record2) {
+  const status = stringField(record2, "status")?.toLowerCase();
+  if (status && TERMINAL_BACKGROUND_STATUSES.has(status)) return true;
+  if (status && NON_TERMINAL_BACKGROUND_STATUSES.has(status)) return false;
+  return typeof record2.duration_ms === "number" || typeof record2.durationMs === "number" || typeof record2.total_tokens === "number" || typeof record2.totalTokens === "number" || typeof record2.tool_uses === "number" || typeof record2.toolUses === "number";
+}
+function isFailedBackgroundStatus(record2) {
+  const status = stringField(record2, "status")?.toLowerCase();
+  return status === "failed" || status === "failure" || status === "error" || status === "cancelled" || status === "canceled" || status === "aborted" || status === "interrupted";
+}
+function extractBackgroundTaskIdFromPayload(value2) {
+  if (typeof value2 === "string") {
+    const trimmed = value2.trim();
+    if (!trimmed) return void 0;
+    try {
+      return extractBackgroundTaskIdFromPayload(JSON.parse(trimmed));
+    } catch {
+      const match = trimmed.match(/\btask[_-]?id["']?\s*[:=]\s*["']?([A-Za-z0-9_.-]+)/i) ?? trimmed.match(/\btasks\/([A-Za-z0-9_.-]+)/i);
+      if (match?.[1]) return match[1];
+      if (/^[A-Za-z0-9_-]{6,128}$/.test(trimmed) && /(?:task|bg|async|job|agent)/i.test(trimmed)) {
+        return trimmed;
+      }
+      return void 0;
+    }
+  }
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) return void 0;
+  const record2 = value2;
+  return stringField(record2, "task_id") ?? stringField(record2, "taskId") ?? stringField(record2, "agentId") ?? stringField(record2, "agent_id") ?? extractBackgroundTaskIdFromPayload(record2.value) ?? extractBackgroundTaskIdFromPayload(record2.result) ?? extractBackgroundTaskIdFromPayload(record2.data) ?? extractBackgroundTaskIdFromPayload(record2.content);
+}
+function looksLikeBackgroundLaunchAck(options) {
+  const taskId = extractBackgroundTaskIdFromPayload(options.value) ?? extractBackgroundTaskIdFromPayload(options.content);
+  const content = options.content.trim();
+  const explicitAckText = ASYNC_LAUNCH_ACK_RE.test(content);
+  if (!options.trackedUnlinkedLauncher) return { isAck: false, taskId };
+  if (options.explicitBackground && taskId) return { isAck: true, taskId };
+  if (explicitAckText) return { isAck: true, taskId };
+  if (taskId && content.length > 0 && content.length < 400) {
+    const record2 = options.value && typeof options.value === "object" && !Array.isArray(options.value) ? options.value : null;
+    const looksStructured = record2 !== null || content.startsWith("{") || /^task[_-]?id\b/i.test(content) || content === taskId;
+    if (looksStructured) return { isAck: true, taskId };
+  }
+  return { isAck: false, taskId };
+}
+function settleBackgroundTerminalNotification(kind, context, state, record2, options) {
+  const toolUseId = resolveBackgroundTaskToolUseId(state, record2);
+  const keys = backgroundTaskKeys(record2);
+  const wasActive = !!toolUseId && state.activeBackgroundTaskIds?.has(toolUseId) === true || keys.some((key) => state.activeBackgroundTaskIds?.has(key) === true);
+  if (toolUseId && wasActive) {
+    options.emitToolResult(toolUseId, options.resultText, options.isError);
+    clearBackgroundTaskIds(state, keys);
+    maybeFinalizeDeferredResult(kind, context, state);
+    return toolUseId;
+  }
+  clearBackgroundTaskIds(state, keys);
+  const drainedLauncher = drainNextUnlinkedBackgroundLauncher(state);
+  if (drainedLauncher) {
+    options.emitToolResult(drainedLauncher, options.resultText, options.isError);
+  }
+  maybeFinalizeDeferredResult(kind, context, state);
+  return drainedLauncher;
+}
+function finalizeStructuredResult(kind, state) {
+  state.resultReceived = true;
+  state.onResultReceived?.();
+  if (state.stdin && !state.stdin.destroyed) {
+    state.stdin.end();
+    console.info(`[${kind}] Closed stdin after result event to signal CLI exit`);
+  }
+}
+function deferOrFinalizeStructuredResult(kind, context, state) {
+  const pendingAsks = context.presenter.pendingAskUserToolIds?.size ?? 0;
+  if (pendingAsks > 0) {
+    console.info(
+      `[${kind}] Keeping stdin open \u2014 ${pendingAsks} interactive question(s) awaiting user response`
+    );
+    state.resultDeferredOnPendingAnswer = true;
+    return "deferred_pending_answer";
+  }
+  const activeBackgroundTasks = state.activeBackgroundTaskIds?.size ?? 0;
+  if (activeBackgroundTasks > 0) {
+    console.info(
+      `[${kind}] Keeping stdin open \u2014 ${activeBackgroundTasks} background task(s) still active`
+    );
+    state.resultDeferredOnBackgroundWork = true;
+    return "deferred_background_work";
+  }
+  finalizeStructuredResult(kind, state);
+  return "finalized";
+}
+function maybeFinalizeDeferredResult(kind, context, state) {
+  if (!state.resultDeferredOnBackgroundWork && !state.resultDeferredOnPendingAnswer) return;
+  if (context.presenter.pendingAskUserToolIds?.size || state.activeBackgroundTaskIds?.size) return;
+  if (state.resultDeferredOnBackgroundWork) {
+    state.awaitingPostBackgroundSynthesis = true;
+    console.info(
+      `[${kind}] Background work drained \u2014 awaiting post-subagent synthesis before stdin close`
+    );
+    return;
+  }
+  state.resultDeferredOnPendingAnswer = false;
+  finalizeStructuredResult(kind, state);
+}
 var MAX_INLINE_GENERATED_IMAGE_BYTES = 20 * 1024 * 1024;
 function inferImageMimeType(buffer) {
   if (buffer.length >= 8 && buffer.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
@@ -19947,6 +20252,20 @@ function buildToolResultText(parsed) {
   const status = typeof parsed.status === "string" ? parsed.status.trim() : "";
   return status || "Tool completed";
 }
+function buildSubagentResultText(parsed) {
+  const output = buildToolResultText(parsed);
+  const status = typeof parsed.status === "string" ? parsed.status.trim() : "";
+  const details = [
+    typeof parsed.duration_ms === "number" ? `Duration: ${parsed.duration_ms}ms.` : "",
+    typeof parsed.durationMs === "number" ? `Duration: ${parsed.durationMs}ms.` : "",
+    typeof parsed.tool_uses === "number" ? `Tool uses: ${parsed.tool_uses}.` : "",
+    typeof parsed.toolUses === "number" ? `Tool uses: ${parsed.toolUses}.` : "",
+    typeof parsed.total_tokens === "number" ? `Tokens: ${parsed.total_tokens}.` : "",
+    typeof parsed.totalTokens === "number" ? `Tokens: ${parsed.totalTokens}.` : ""
+  ].filter(Boolean);
+  if (output !== "Tool completed") return output;
+  return [`Subagent ${status || "completed"}.`, ...details].join(" ");
+}
 function extractText(parsed) {
   for (const key of ["text", "delta", "content", "message", "result"]) {
     const value2 = parsed[key];
@@ -19993,6 +20312,286 @@ function extractSubagentInput(parsed) {
     workspace: parsed.workspace
   };
 }
+function antigravityTranscriptRoot(context) {
+  const home = context.env.HOME || process.env.HOME || (0, import_os4.homedir)();
+  return (0, import_path5.resolve)(home, ".gemini", "antigravity-cli", "brain");
+}
+function resolveAntigravityTranscriptPath(parsed, context) {
+  const logUri = stringField2(parsed, "log_uri");
+  const conversationId = stringField2(parsed, "task_id") ?? stringField2(parsed, "conversation_id");
+  if (!logUri || !conversationId) return void 0;
+  try {
+    const url3 = new URL(logUri);
+    if (url3.protocol !== "file:") return void 0;
+    const root = antigravityTranscriptRoot(context);
+    const transcriptPath = (0, import_path5.resolve)((0, import_url.fileURLToPath)(url3));
+    const pathFromRoot = (0, import_path5.relative)(root, transcriptPath);
+    const segments = pathFromRoot.split(import_path5.sep);
+    if (!pathFromRoot || pathFromRoot === ".." || pathFromRoot.startsWith(`..${import_path5.sep}`) || (0, import_path5.isAbsolute)(pathFromRoot) || segments[0] !== conversationId || segments.at(-1) !== "transcript.jsonl" || segments.at(-2) !== "logs" || segments.at(-3) !== ".system_generated") {
+      return void 0;
+    }
+    return transcriptPath;
+  } catch {
+    return void 0;
+  }
+}
+function antigravityTranscriptToolId(parentToolUseId, lineIndex, toolIndex) {
+  return `${parentToolUseId}-transcript-${lineIndex}-${toolIndex}`;
+}
+var ANTIGRAVITY_TOOL_RESULT_TYPES = /* @__PURE__ */ new Set([
+  "LIST_DIRECTORY",
+  "VIEW_FILE",
+  "MCP_TOOL",
+  "INVOKE_SUBAGENT",
+  "RUN_COMMAND",
+  "GENERIC",
+  "GREP_SEARCH",
+  "CODE_ACTION",
+  "SEND_MESSAGE"
+]);
+function isAntigravityToolResultEntry(entry) {
+  const type = stringField2(entry, "type")?.toUpperCase();
+  if (type && ANTIGRAVITY_TOOL_RESULT_TYPES.has(type)) return true;
+  const content = stringField2(entry, "content");
+  return Boolean(content?.startsWith("Created At:"));
+}
+function stripAntigravityToolResultEnvelope(content) {
+  const stripped = content.replace(/^(?:Created At:[^\n]*\n|Completed At:[^\n]*\n)+/u, "");
+  return stripped.trim().length > 0 ? stripped : content;
+}
+function readAntigravityTranscriptLines(transcriptPath) {
+  try {
+    const lines = (0, import_fs5.readFileSync)(transcriptPath, "utf8").split(/\r?\n/);
+    if (lines.at(-1) === "") lines.pop();
+    return lines;
+  } catch {
+    return void 0;
+  }
+}
+function syncAntigravitySubagentTranscript(transcriptPath, parentToolUseId, presenter, startLine = 0, pendingToolIds = []) {
+  const lines = readAntigravityTranscriptLines(transcriptPath);
+  if (!lines) {
+    return { processedLineCount: startLine, emittedEventCount: 0, pendingToolIds };
+  }
+  let processedLineCount = startLine > lines.length ? 0 : startLine;
+  let emittedEventCount = 0;
+  for (let lineIndex = processedLineCount; lineIndex < lines.length; lineIndex += 1) {
+    const line = lines[lineIndex];
+    if (!line) {
+      processedLineCount = lineIndex + 1;
+      continue;
+    }
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      break;
+    }
+    processedLineCount = lineIndex + 1;
+    if (stringField2(entry, "source") !== "MODEL") continue;
+    const thinking = stringField2(entry, "thinking") ?? stringField2(entry, "thinking_delta");
+    if (thinking) {
+      emittedEventCount += 1;
+      void presenter.onThinking(thinking, parentToolUseId);
+    }
+    const toolCalls = Array.isArray(entry.tool_calls) ? entry.tool_calls : [];
+    toolCalls.forEach((rawToolCall, toolIndex) => {
+      const toolCall = asRecord(rawToolCall);
+      const toolName = toolCall && stringField2(toolCall, "name");
+      if (!toolName) return;
+      const toolId = antigravityTranscriptToolId(parentToolUseId, lineIndex, toolIndex);
+      pendingToolIds.push(toolId);
+      emittedEventCount += 1;
+      void presenter.onToolUse(
+        toolName,
+        toolCall?.args ?? toolCall?.parameters ?? {},
+        toolId,
+        parentToolUseId
+      );
+    });
+    const content = stringField2(entry, "content");
+    if (content && isAntigravityToolResultEntry(entry)) {
+      const toolId = pendingToolIds.shift();
+      if (toolId) {
+        emittedEventCount += 1;
+        void presenter.onToolResult?.(
+          toolId,
+          stripAntigravityToolResultEnvelope(content),
+          void 0,
+          parentToolUseId
+        );
+      }
+      continue;
+    }
+    if (!content) continue;
+    const entryType = stringField2(entry, "type")?.toUpperCase();
+    if (entryType === "SYSTEM_MESSAGE") continue;
+    emittedEventCount += 1;
+    void presenter.onAssistantText(content, parentToolUseId);
+  }
+  return { processedLineCount, emittedEventCount, pendingToolIds };
+}
+function resolveAntigravityParentTranscriptPath(conversationId, context) {
+  return (0, import_path5.resolve)(
+    antigravityTranscriptRoot(context),
+    conversationId,
+    ".system_generated",
+    "logs",
+    "transcript.jsonl"
+  );
+}
+function syncAntigravityParentThinkingFromTranscript(context, state) {
+  const parent = state.antigravityParentTranscript;
+  if (!parent?.transcriptPath) return 0;
+  const lines = readAntigravityTranscriptLines(parent.transcriptPath);
+  if (!lines) return 0;
+  let processedLineCount = parent.replayedLineCount > lines.length ? 0 : parent.replayedLineCount;
+  let emittedEventCount = 0;
+  for (let lineIndex = processedLineCount; lineIndex < lines.length; lineIndex += 1) {
+    const line = lines[lineIndex];
+    if (!line) {
+      processedLineCount = lineIndex + 1;
+      continue;
+    }
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      break;
+    }
+    processedLineCount = lineIndex + 1;
+    if (stringField2(entry, "source") !== "MODEL") continue;
+    const thinking = stringField2(entry, "thinking") ?? stringField2(entry, "thinking_delta");
+    if (!thinking) continue;
+    emittedEventCount += 1;
+    void context.presenter.onThinking(thinking);
+  }
+  parent.replayedLineCount = processedLineCount;
+  return emittedEventCount;
+}
+function syncAntigravitySubagentEventsFromTranscripts(context, state) {
+  let emittedEventCount = syncAntigravityParentThinkingFromTranscript(context, state);
+  for (const [launcherId, task] of state.antigravitySubagentTranscripts ?? []) {
+    if (!task.transcriptPath) continue;
+    const replay = syncAntigravitySubagentTranscript(
+      task.transcriptPath,
+      launcherId,
+      context.presenter,
+      task.replayedLineCount,
+      task.pendingToolIds ?? []
+    );
+    task.replayedLineCount = replay.processedLineCount;
+    task.pendingToolIds = replay.pendingToolIds;
+    task.emittedEventCount += replay.emittedEventCount;
+    emittedEventCount += replay.emittedEventCount;
+  }
+  if (emittedEventCount > 0) state.onNewOutput?.();
+  return emittedEventCount;
+}
+function ensureAntigravitySubagentTranscriptPolling(context, state) {
+  if (state.providerTranscriptPollTimer) {
+    syncAntigravitySubagentEventsFromTranscripts(context, state);
+    return;
+  }
+  const poll = () => {
+    try {
+      syncAntigravitySubagentEventsFromTranscripts(context, state);
+      state.providerTranscriptPollErrorLogged = false;
+    } catch (error2) {
+      if (!state.providerTranscriptPollErrorLogged) {
+        console.warn("[antigravity_cli] Failed to poll child transcript:", error2);
+        state.providerTranscriptPollErrorLogged = true;
+      }
+    }
+  };
+  poll();
+  const timer = setInterval(poll, 750);
+  timer.unref?.();
+  state.providerTranscriptPollTimer = timer;
+}
+function clearAntigravityTranscriptPollingIfIdle(state) {
+  const hasChildren = (state.antigravitySubagentTranscripts?.size ?? 0) > 0;
+  const hasParent = Boolean(state.antigravityParentTranscript);
+  if (hasChildren || hasParent) return;
+  if (state.providerTranscriptPollTimer) clearInterval(state.providerTranscriptPollTimer);
+  state.providerTranscriptPollTimer = void 0;
+}
+function registerAntigravityParentTranscript(conversationId, context, state) {
+  if (!conversationId) return;
+  const existing = state.antigravityParentTranscript;
+  if (existing?.conversationId === conversationId) {
+    ensureAntigravitySubagentTranscriptPolling(context, state);
+    return;
+  }
+  state.antigravityParentTranscript = {
+    conversationId,
+    transcriptPath: resolveAntigravityParentTranscriptPath(conversationId, context),
+    // Skip historical rows from prior turns on resume; only stream new thinking.
+    replayedLineCount: readAntigravityTranscriptLines(
+      resolveAntigravityParentTranscriptPath(conversationId, context)
+    )?.length ?? 0
+  };
+  ensureAntigravitySubagentTranscriptPolling(context, state);
+}
+function registerAntigravitySubagentTranscript(parsed, toolId, context, state) {
+  if (!state.antigravitySubagentTranscripts) state.antigravitySubagentTranscripts = /* @__PURE__ */ new Map();
+  const task = state.antigravitySubagentTranscripts.get(toolId) ?? {
+    replayedLineCount: 0,
+    emittedEventCount: 0,
+    pendingToolIds: []
+  };
+  const incomingConversationId = stringField2(parsed, "task_id");
+  if (task.conversationId && incomingConversationId && incomingConversationId !== task.conversationId) {
+    if (!state.antigravityCorrelationWarnLogged) {
+      console.warn(
+        `[antigravity_cli] Subagent launcher ${toolId} saw a conversation id change (${task.conversationId} -> ${incomingConversationId}); keeping the original transcript association.`
+      );
+      state.antigravityCorrelationWarnLogged = true;
+    }
+    return;
+  }
+  task.conversationId = incomingConversationId ?? task.conversationId;
+  const resolvedPath = resolveAntigravityTranscriptPath(parsed, context);
+  if (!resolvedPath && !task.transcriptPath && stringField2(parsed, "log_uri")) {
+    if (!state.antigravityTranscriptPathWarnLogged) {
+      console.warn(
+        `[antigravity_cli] Subagent log_uri for ${toolId} did not match the expected Antigravity transcript path layout; its live stream will not be tailed.`
+      );
+      state.antigravityTranscriptPathWarnLogged = true;
+    }
+  }
+  task.transcriptPath = resolvedPath ?? task.transcriptPath;
+  state.antigravitySubagentTranscripts.set(toolId, task);
+  if (task.transcriptPath) ensureAntigravitySubagentTranscriptPolling(context, state);
+}
+function settleAntigravitySubagentTranscripts(context, state, isError = false) {
+  syncAntigravitySubagentEventsFromTranscripts(context, state);
+  for (const [toolId, task] of state.antigravitySubagentTranscripts ?? []) {
+    settleBackgroundTerminalNotification(
+      "antigravity_cli",
+      context,
+      state,
+      {
+        tool_use_id: toolId,
+        ...task.conversationId ? { task_id: task.conversationId } : {},
+        status: isError ? "error" : "completed"
+      },
+      {
+        resultText: isError ? "Subagent ended because the parent run failed" : "Subagent completed",
+        isError: isError || void 0,
+        emitToolResult: (id, text, error2) => {
+          void context.presenter.onToolResult?.(id, text, error2);
+        }
+      }
+    );
+    state.antigravitySubagentTranscripts?.delete(toolId);
+  }
+  if (state.antigravitySubagentTranscripts?.size === 0) {
+    state.antigravitySubagentTranscripts = void 0;
+  }
+  state.antigravityParentTranscript = void 0;
+  clearAntigravityTranscriptPollingIfIdle(state);
+}
 function extractToolId(parsed, state) {
   for (const key of ["tool_id", "toolId", "id", "call_id"]) {
     const value2 = parsed[key];
@@ -20001,21 +20600,140 @@ function extractToolId(parsed, state) {
   state.iterations += 1;
   return `antigravity-tool-${state.iterations}`;
 }
-function parseAntigravityStructuredLine(line, context, state) {
-  const presenter = context.presenter;
-  let parsed = null;
-  try {
-    parsed = JSON.parse(line);
-  } catch {
-    void presenter.onLog(`[antigravity] ${line}`);
-    return;
+function asRecord(value2) {
+  return typeof value2 === "object" && value2 !== null && !Array.isArray(value2) ? value2 : void 0;
+}
+function stringField2(value2, key) {
+  const field = value2[key];
+  return typeof field === "string" && field.trim() ? field : void 0;
+}
+function liveStepId(step, subagentIndex) {
+  const conversationId = stringField2(step, "conversation_id") ?? "unknown";
+  const stepIndex = typeof step.step_index === "number" ? step.step_index : "unknown";
+  const base = `antigravity-${conversationId}-step-${stepIndex}`;
+  return typeof subagentIndex === "number" ? `${base}-subagent-${subagentIndex}` : base;
+}
+function isActiveStep(step) {
+  return stringField2(step, "state")?.toLowerCase() === "active";
+}
+function normalizeLiveAntigravityEvent(parsed) {
+  const event = stringField2(parsed, "event");
+  if (!event) return void 0;
+  const conversationId = stringField2(parsed, "conversation_id");
+  if (event === "init") {
+    return [
+      {
+        ...asRecord(parsed.init) ?? {},
+        type: "init",
+        ...conversationId ? { conversation_id: conversationId } : {}
+      }
+    ];
+  }
+  if (event === "result") {
+    const result = asRecord(parsed.result) ?? {};
+    return [
+      {
+        ...result,
+        type: "complete",
+        ...conversationId && !stringField2(result, "conversation_id") ? { conversation_id: conversationId } : {},
+        ...typeof result.response === "string" && typeof result.result !== "string" ? { result: result.response } : {}
+      }
+    ];
+  }
+  if (event !== "step_update") return [{ type: `antigravity_event:${event}` }];
+  const step = asRecord(parsed.step_update);
+  if (!step) return [{ type: "antigravity_step_update" }];
+  const normalizedStep = {
+    ...step,
+    ...conversationId && !stringField2(step, "conversation_id") ? { conversation_id: conversationId } : {}
+  };
+  const stepType = stringField2(normalizedStep, "step_type")?.toLowerCase();
+  const thinkingText = stringField2(normalizedStep, "thinking_delta") ?? stringField2(normalizedStep, "thinking");
+  const thinkingEvents = thinkingText ? [{ type: "thinking", text: thinkingText, content: thinkingText }] : [];
+  if (stepType === "agent_response") {
+    return [
+      ...thinkingEvents,
+      {
+        ...normalizedStep,
+        type: "assistant_message",
+        ...typeof normalizedStep.text_delta === "string" ? { content: normalizedStep.text_delta } : {}
+      }
+    ];
   }
+  if (stepType === "tool") {
+    const toolInfo = asRecord(normalizedStep.tool_info) ?? {};
+    const toolName = stringField2(normalizedStep, "tool_name") ?? stringField2(toolInfo, "name") ?? "Antigravity Tool";
+    const toolId = liveStepId(normalizedStep);
+    if (isActiveStep(normalizedStep)) {
+      return [
+        ...thinkingEvents,
+        {
+          ...normalizedStep,
+          ...toolInfo,
+          type: "tool_call",
+          tool_id: toolId,
+          tool_name: toolName,
+          parameters: toolInfo.parameters ?? normalizedStep.parameters ?? {}
+        }
+      ];
+    }
+    const toolOutput = stringField2(toolInfo, "output") ?? stringField2(normalizedStep, "output") ?? `${toolName} completed`;
+    return [
+      ...thinkingEvents,
+      {
+        ...normalizedStep,
+        type: "tool_result",
+        tool_id: toolId,
+        output: toolOutput
+      }
+    ];
+  }
+  if (stepType === "subagent") {
+    const subagents = asRecord(normalizedStep.subagent_info)?.subagents;
+    const children = Array.isArray(subagents) ? subagents.map(asRecord).filter((subagent) => Boolean(subagent)) : [];
+    const entries = children.length > 0 ? children : [void 0];
+    return [
+      ...thinkingEvents,
+      ...entries.map((subagent, index) => {
+        const toolId = liveStepId(normalizedStep, index);
+        const childConversationId = subagent && stringField2(subagent, "conversation_id");
+        return {
+          ...normalizedStep,
+          // AGY's DONE means the invocation was accepted, not that the child has
+          // finished. The authenticated stream emits it milliseconds after ACTIVE
+          // while the child transcript is still growing.
+          type: isActiveStep(normalizedStep) ? "subagent_started" : "subagent_launch_ack",
+          antigravity_live: true,
+          tool_id: toolId,
+          task_id: childConversationId ?? toolId,
+          role: subagent && stringField2(subagent, "role"),
+          type_name: subagent && stringField2(subagent, "type_name"),
+          prompt: subagent && (stringField2(subagent, "initial_prompt") ?? stringField2(subagent, "prompt")),
+          workspace: subagent && stringField2(subagent, "workspace"),
+          log_uri: subagent && stringField2(subagent, "log_uri"),
+          status: isActiveStep(normalizedStep) ? "running" : "launched"
+        };
+      })
+    ];
+  }
+  if (thinkingEvents.length > 0) return thinkingEvents;
+  return [{ ...normalizedStep, type: "antigravity_step_update" }];
+}
+function handleAntigravityStructuredEvent(parsed, context, state) {
+  const normalized = normalizeLiveAntigravityEvent(parsed);
+  if (normalized) {
+    return normalized.every((event) => handleAntigravityStructuredEvent(event, context, state));
+  }
+  const presenter = context.presenter;
   state.onNewOutput?.();
   const type = typeof parsed.type === "string" ? parsed.type : "";
-  if (!type) return;
+  if (!type) return false;
   if (typeof parsed.session_id === "string") state.runtimeSessionId = parsed.session_id;
   if (typeof parsed.conversation_id === "string") state.runtimeSessionId = parsed.conversation_id;
   if (typeof parsed.model === "string") state.activeModel = parsed.model;
+  if (typeof state.runtimeSessionId === "string" && state.runtimeSessionId.trim()) {
+    registerAntigravityParentTranscript(state.runtimeSessionId, context, state);
+  }
   switch (type) {
     case "init":
     case "session_start": {
@@ -20023,29 +20741,31 @@ function parseAntigravityStructuredLine(line, context, state) {
       void presenter.onLog(
         `[antigravity] Session initialized with ${formatAntigravityModelName(model)}`
       );
-      break;
+      return true;
     }
+    case "antigravity_step_update":
+      return true;
     case "thinking":
     case "reasoning":
     case "thought": {
       const text = extractText(parsed);
-      if (!text) break;
+      if (!text) return true;
       state.iterations = Math.max(state.iterations, 1);
       void presenter.onThinking(text);
-      break;
+      return true;
     }
     case "message":
     case "assistant_message":
     case "text":
     case "content": {
       const role = typeof parsed.role === "string" ? parsed.role : "assistant";
-      if (role !== "assistant") break;
+      if (role !== "assistant") return true;
       const content = extractText(parsed);
-      if (!content) break;
+      if (!content) return true;
       state.iterations = Math.max(state.iterations, 1);
       state.summary += content;
       void presenter.onAssistantText(content);
-      break;
+      return true;
     }
     case "tool_use":
     case "tool_call":
@@ -20054,7 +20774,7 @@ function parseAntigravityStructuredLine(line, context, state) {
       const toolId = extractToolId(parsed, state);
       state.iterations = Math.max(state.iterations, 1);
       void presenter.onToolUse(extractToolName(parsed), extractToolInput(parsed), toolId);
-      break;
+      return true;
     }
     case "subagent_start":
     case "subagent_started":
@@ -20064,12 +20784,22 @@ function parseAntigravityStructuredLine(line, context, state) {
     case "background_subagent_started": {
       const toolId = extractToolId(parsed, state);
       state.iterations = Math.max(state.iterations, 1);
+      registerBackgroundLauncher(state, toolId);
+      registerBackgroundTaskRecord(state, { ...parsed, tool_use_id: toolId }, toolId);
       void presenter.onToolUse(
         `Subagent: ${extractSubagentName(parsed)}`,
         extractSubagentInput(parsed),
         toolId
       );
-      break;
+      if (parsed.antigravity_live === true || stringField2(parsed, "log_uri")) {
+        registerAntigravitySubagentTranscript(parsed, toolId, context, state);
+      }
+      return true;
+    }
+    case "subagent_launch_ack": {
+      const toolId = extractToolId(parsed, state);
+      registerAntigravitySubagentTranscript(parsed, toolId, context, state);
+      return true;
     }
     case "tool_result":
     case "tool_response":
@@ -20078,24 +20808,52 @@ function parseAntigravityStructuredLine(line, context, state) {
       const toolId = extractToolId(parsed, state);
       state.iterations = Math.max(state.iterations, 1);
       void presenter.onToolResult?.(toolId, buildToolResultText(parsed));
-      break;
+      return true;
     }
     case "subagent_result":
     case "subagent_complete":
     case "subagent_completed":
     case "background_subagent_result":
     case "background_subagent_completed": {
-      const toolId = extractToolId(parsed, state);
       state.iterations = Math.max(state.iterations, 1);
-      void presenter.onToolResult?.(toolId, buildToolResultText(parsed));
-      break;
+      const toolId = extractToolId(parsed, state);
+      const settledToolId = settleBackgroundTerminalNotification(
+        "antigravity_cli",
+        context,
+        state,
+        { ...parsed, tool_use_id: toolId },
+        {
+          resultText: buildSubagentResultText(parsed),
+          isError: isFailedBackgroundStatus(parsed),
+          emitToolResult: (toolId2, text, isError) => {
+            void presenter.onToolResult?.(toolId2, text, isError);
+          }
+        }
+      );
+      if (settledToolId) state.antigravitySubagentTranscripts?.delete(settledToolId);
+      return true;
+    }
+    case "subagent_status":
+    case "background_subagent_status":
+    case "background_task_status": {
+      registerBackgroundTaskRecord(state, parsed);
+      if (isTerminalBackgroundStatus(parsed)) {
+        settleBackgroundTerminalNotification("antigravity_cli", context, state, parsed, {
+          resultText: buildSubagentResultText(parsed),
+          isError: isFailedBackgroundStatus(parsed),
+          emitToolResult: (toolId, text, isError) => {
+            void presenter.onToolResult?.(toolId, text, isError);
+          }
+        });
+      }
+      return true;
     }
     case "image_generation_end":
     case "generated_image":
     case "image": {
       const image = buildGeneratedImageFromAntigravityPayload(parsed);
       if (image) void presenter.onGeneratedImage?.(image);
-      break;
+      return true;
     }
     case "error": {
       const errObj = typeof parsed.error === "object" && parsed.error !== null ? parsed.error : null;
@@ -20109,20 +20867,31 @@ function parseAntigravityStructuredLine(line, context, state) {
           void presenter.onLog(`[antigravity/${severity}] ${message}`);
         }
       }
-      break;
+      return true;
     }
     case "result":
     case "complete": {
-      const stats = typeof parsed.stats === "object" && parsed.stats !== null ? parsed.stats : parsed;
-      state.iterations = Math.max(state.iterations, 1);
+      const stats = asRecord(parsed.usage) ?? asRecord(parsed.stats) ?? parsed;
+      state.iterations = Math.max(
+        state.iterations,
+        typeof parsed.num_turns === "number" ? parsed.num_turns : 1
+      );
+      const resultText = typeof parsed.result === "string" ? parsed.result : "";
+      if (resultText && !state.summary.trim()) {
+        state.summary += resultText;
+        void presenter.onAssistantText(resultText);
+      }
       const usageModel = state.activeModel || (typeof context.config.selectedModel === "string" && context.config.selectedModel.trim() ? context.config.selectedModel : "antigravity");
       state.usage = {
         model: formatAntigravityModelName(usageModel),
         numTurns: Math.max(state.iterations, 1),
+        // AGY's result.duration_seconds is conversation-scoped on resumed
+        // sessions, so it is not a trustworthy per-turn duration. Keep this at
+        // zero until the stream provides a dedicated turn-level metric.
         durationMs: typeof stats.duration_ms === "number" ? stats.duration_ms : 0,
         inputTokens: typeof stats.input_tokens === "number" ? stats.input_tokens : typeof stats.input === "number" ? stats.input : 0,
         outputTokens: typeof stats.output_tokens === "number" ? stats.output_tokens : 0,
-        cacheReadTokens: typeof stats.cached === "number" ? stats.cached : 0,
+        cacheReadTokens: typeof stats.cache_read_tokens === "number" ? stats.cache_read_tokens : typeof stats.cached_input_tokens === "number" ? stats.cached_input_tokens : typeof stats.cached === "number" ? stats.cached : 0,
         cacheCreationTokens: 0,
         costUsd: 0
       };
@@ -20133,15 +20902,15 @@ function parseAntigravityStructuredLine(line, context, state) {
         cacheReadTokens: state.usage.cacheReadTokens,
         cacheCreationTokens: state.usage.cacheCreationTokens
       });
-      if (type === "complete" || parsed.status === "success") state.resultReceived = true;
-      state.onResultReceived?.();
-      if (typeof parsed.status === "string" && parsed.status !== "success" && !state.error) {
+      const status = typeof parsed.status === "string" ? parsed.status.toLowerCase() : "";
+      if (status && !["success", "completed", "complete"].includes(status) && !state.error) {
         const errObj = typeof parsed.error === "object" && parsed.error !== null ? parsed.error : null;
-        const errMsg = typeof parsed.error === "string" && parsed.error.trim() || errObj && typeof errObj.message === "string" && errObj.message.trim() || typeof parsed.error_message === "string" && parsed.error_message.trim() || typeof parsed.message === "string" && parsed.message.trim() || typeof parsed.result === "string" && parsed.result.trim() || parsed.status;
+        const errMsg = typeof parsed.error === "string" && parsed.error.trim() || errObj && typeof errObj.message === "string" && errObj.message.trim() || typeof parsed.error_message === "string" && parsed.error_message.trim() || typeof parsed.message === "string" && parsed.message.trim() || typeof parsed.result === "string" && parsed.result.trim() || status;
         state.error = errMsg;
+        void presenter.onError(errMsg);
         console.error(
           "[antigravity] result status=",
-          parsed.status,
+          status,
           "error:",
           JSON.stringify({
             error: parsed.error,
@@ -20150,12 +20919,23 @@ function parseAntigravityStructuredLine(line, context, state) {
           })
         );
       }
-      break;
+      const completedSuccessfully = !status || ["success", "completed", "complete"].includes(status);
+      if (type === "complete" || status) {
+        settleAntigravitySubagentTranscripts(context, state, !completedSuccessfully);
+      }
+      if (type === "complete" || status === "success") {
+        deferOrFinalizeStructuredResult("antigravity_cli", context, state);
+      }
+      return true;
     }
     default:
-      break;
+      return false;
   }
 }
+var parseAntigravityStructuredLine = createStructuredLineParser(
+  "antigravity_cli",
+  handleAntigravityStructuredEvent
+);
 function parseAntigravityLine(line, context, state) {
   try {
     JSON.parse(line);
@@ -20204,7 +20984,14 @@ function detectAntigravityCliCapabilities(command, context) {
       version: versionOutput || void 0,
       supportsStructuredPrint: hasOutputFormat && hasStructuredFormat,
       supportsConversationResume: help.includes("--conversation") || help.includes("--continue"),
-      supportsReliableNonTtyPrint: help.includes("-p") || help.includes("--print") || help.includes("--print-timeout")
+      supportsReliableNonTtyPrint: help.includes("-p") || help.includes("--print") || help.includes("--print-timeout"),
+      supportsAddDir: help.includes("--add-dir"),
+      supportsAgentSelection: help.includes("--agent"),
+      supportsExecutionMode: help.includes("--mode"),
+      supportsSandbox: help.includes("--sandbox"),
+      supportsProject: help.includes("--project"),
+      supportsNewProject: help.includes("--new-project"),
+      supportsJsonSchema: help.includes("--json-schema")
     };
     capabilityCache.set(cacheKey, capabilities);
     return capabilities;
@@ -20229,7 +21016,33 @@ function buildAntigravityCliArgs(context, prompt, defaultArgs = [], capabilities
     if (effort && isEffortLevel(effort)) args.push("--effort", effort);
   }
   if (resumeId) args.push("--conversation", resumeId);
-  if (!shouldUseReadOnlyRuntimePermissions(context.config)) {
+  const antigravity = context.config.antigravity;
+  if (capabilities?.supportsAddDir) {
+    const workspacePaths = Array.from(
+      new Set(
+        (antigravity?.additionalWorkspacePaths ?? []).map((path) => path.trim()).filter(Boolean)
+      )
+    );
+    for (const path of workspacePaths) args.push("--add-dir", path);
+  }
+  const agent = antigravity?.agent?.trim();
+  if (agent && capabilities?.supportsAgentSelection) args.push("--agent", agent);
+  const project = antigravity?.project?.trim();
+  if (project && capabilities?.supportsProject) {
+    args.push("--project", project);
+  } else if (antigravity?.newProject && capabilities?.supportsNewProject) {
+    args.push("--new-project");
+  }
+  const jsonSchema = antigravity?.jsonSchema?.trim();
+  if (jsonSchema && capabilities?.supportsJsonSchema) args.push("--json-schema", jsonSchema);
+  const readOnly = shouldUseReadOnlyRuntimePermissions(context.config);
+  if (capabilities?.supportsExecutionMode) {
+    args.push("--mode", readOnly ? "plan" : "accept-edits");
+  }
+  if (readOnly && capabilities?.supportsSandbox) {
+    args.push("--sandbox");
+  }
+  if (!readOnly) {
     args.push("--dangerously-skip-permissions");
   }
   if (capabilities?.supportsStructuredPrint) {
@@ -20243,7 +21056,11 @@ function buildAntigravityAugmentedPrompt(context, images) {
     context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim()
   );
   const base = buildResumeAwarePrompt(context.config, context.promptText, { isResume });
-  const prompt = context.config.mode === "plan" ? buildPlanModePrefix(base) : base;
+  const workspaceInstructions = isResume ? void 0 : buildAntigravityWorkspaceInstructions(context.cwd);
+  const withWorkspaceInstructions = workspaceInstructions ? `${workspaceInstructions}
+
+${base}` : base;
+  const prompt = context.config.mode === "plan" ? buildPlanModePrefix(withWorkspaceInstructions) : withWorkspaceInstructions;
   return appendImagePathReferences(prompt, images);
 }
 function createAntigravityCliBackend(command = "agy", defaultArgs = []) {
@@ -20278,18 +21095,18 @@ function createAntigravityCliBackend(command = "agy", defaultArgs = []) {
 }
 function resolveClaudeHome(env, variant = "claude") {
   if (variant === "supatest") {
-    return (0, import_path4.join)((0, import_os4.homedir)(), ".supatest", "claude-internal");
+    return (0, import_path6.join)((0, import_os5.homedir)(), ".supatest", "claude-internal");
   }
-  return env.CLAUDE_CONFIG_DIR || process.env.CLAUDE_CONFIG_DIR || (0, import_path4.join)((0, import_os4.homedir)(), ".claude");
+  return env.CLAUDE_CONFIG_DIR || process.env.CLAUDE_CONFIG_DIR || (0, import_path6.join)((0, import_os5.homedir)(), ".claude");
 }
 function encodeClaudeProjectDir(cwd) {
   return cwd.replace(/[^a-zA-Z0-9]/g, "-");
 }
 function claudeSessionLogExists(input) {
   if (!input.sessionId || !input.cwd) return false;
-  const projectDir = (0, import_path4.join)(input.home, "projects", encodeClaudeProjectDir(input.cwd));
-  if (!(0, import_fs4.existsSync)(projectDir)) return false;
-  return (0, import_fs4.existsSync)((0, import_path4.join)(projectDir, `${input.sessionId}.jsonl`));
+  const projectDir = (0, import_path6.join)(input.home, "projects", encodeClaudeProjectDir(input.cwd));
+  if (!(0, import_fs6.existsSync)(projectDir)) return false;
+  return (0, import_fs6.existsSync)((0, import_path6.join)(projectDir, `${input.sessionId}.jsonl`));
 }
 var execFileAsync = (0, import_util4.promisify)(import_child_process4.execFile);
 var flagSupportCache = /* @__PURE__ */ new Map();
@@ -20315,234 +21132,6 @@ async function cliSupportsFlag(command, flag, env = {}) {
   flagSupportCache.set(key, supported);
   return supported;
 }
-function stringField(record2, key) {
-  const value2 = record2[key];
-  return typeof value2 === "string" && value2.trim().length > 0 ? value2 : void 0;
-}
-function backgroundTaskKeys(record2) {
-  return [
-    stringField(record2, "task_id"),
-    stringField(record2, "taskId"),
-    stringField(record2, "tool_use_id"),
-    stringField(record2, "toolUseId"),
-    stringField(record2, "id")
-  ].filter((key) => Boolean(key));
-}
-function backgroundTaskId(record2) {
-  return stringField(record2, "task_id") ?? stringField(record2, "taskId");
-}
-function backgroundToolUseId(record2) {
-  return stringField(record2, "tool_use_id") ?? stringField(record2, "toolUseId");
-}
-function registerBackgroundTaskIds(state, keys) {
-  for (const key of keys) {
-    if (!key) continue;
-    if (!state.activeBackgroundTaskIds) state.activeBackgroundTaskIds = /* @__PURE__ */ new Set();
-    state.activeBackgroundTaskIds.add(key);
-  }
-}
-function registerBackgroundLauncher(state, toolUseId) {
-  registerBackgroundTaskIds(state, [toolUseId]);
-  if (!state.pendingLauncherToolIds) state.pendingLauncherToolIds = [];
-  if (!state.pendingLauncherToolIds.includes(toolUseId)) {
-    state.pendingLauncherToolIds.push(toolUseId);
-  }
-}
-function drainNextUnlinkedBackgroundLauncher(state) {
-  const launcherId = state.pendingLauncherToolIds?.shift();
-  if (state.pendingLauncherToolIds?.length === 0) state.pendingLauncherToolIds = void 0;
-  if (launcherId) clearBackgroundTaskIds(state, [launcherId]);
-  return launcherId;
-}
-function registerBackgroundTaskRecord(state, record2, launcherToolUseId) {
-  const taskId = backgroundTaskId(record2);
-  let toolUseId = backgroundToolUseId(record2) ?? launcherToolUseId ?? void 0;
-  if (!toolUseId && taskId) {
-    const nextLauncher = state.pendingLauncherToolIds?.[0];
-    if (nextLauncher) {
-      toolUseId = nextLauncher;
-    } else if (state.activeBackgroundTaskIds?.size === 1) {
-      const [candidate] = state.activeBackgroundTaskIds;
-      if (candidate && candidate !== taskId) toolUseId = candidate;
-    }
-  }
-  registerBackgroundTaskIds(state, backgroundTaskKeys(record2));
-  if (!taskId || !toolUseId) return;
-  if (state.pendingLauncherToolIds) {
-    const idx = state.pendingLauncherToolIds.indexOf(toolUseId);
-    if (idx >= 0) state.pendingLauncherToolIds.splice(idx, 1);
-    if (state.pendingLauncherToolIds.length === 0) state.pendingLauncherToolIds = void 0;
-  }
-  if (!state.backgroundToolIdByTaskId) state.backgroundToolIdByTaskId = /* @__PURE__ */ new Map();
-  if (!state.backgroundTaskIdsByToolId) state.backgroundTaskIdsByToolId = /* @__PURE__ */ new Map();
-  state.backgroundToolIdByTaskId.set(taskId, toolUseId);
-  const taskIds = state.backgroundTaskIdsByToolId.get(toolUseId) ?? /* @__PURE__ */ new Set();
-  taskIds.add(taskId);
-  state.backgroundTaskIdsByToolId.set(toolUseId, taskIds);
-}
-function clearBackgroundTaskIds(state, keys) {
-  const activeIds = state.activeBackgroundTaskIds;
-  if (!activeIds) return;
-  for (const key of keys) {
-    if (!key) continue;
-    activeIds.delete(key);
-    const toolUseId = state.backgroundToolIdByTaskId?.get(key);
-    if (toolUseId) {
-      activeIds.delete(toolUseId);
-      state.backgroundToolIdByTaskId?.delete(key);
-      const taskIds2 = state.backgroundTaskIdsByToolId?.get(toolUseId);
-      taskIds2?.delete(key);
-      if (taskIds2?.size === 0) state.backgroundTaskIdsByToolId?.delete(toolUseId);
-    }
-    const taskIds = state.backgroundTaskIdsByToolId?.get(key);
-    if (taskIds) {
-      for (const taskId of taskIds) {
-        activeIds.delete(taskId);
-        state.backgroundToolIdByTaskId?.delete(taskId);
-      }
-      state.backgroundTaskIdsByToolId?.delete(key);
-    }
-  }
-  if (state.pendingLauncherToolIds) {
-    state.pendingLauncherToolIds = state.pendingLauncherToolIds.filter((id) => activeIds.has(id));
-    if (state.pendingLauncherToolIds.length === 0) state.pendingLauncherToolIds = void 0;
-  }
-  if (activeIds.size === 0) state.activeBackgroundTaskIds = void 0;
-}
-function resolveBackgroundTaskToolUseId(state, record2) {
-  const explicitToolUseId = backgroundToolUseId(record2);
-  if (explicitToolUseId) return explicitToolUseId;
-  const taskId = backgroundTaskId(record2);
-  return taskId ? state.backgroundToolIdByTaskId?.get(taskId) : void 0;
-}
-var TERMINAL_BACKGROUND_STATUSES = /* @__PURE__ */ new Set([
-  "complete",
-  "completed",
-  "done",
-  "success",
-  "succeeded",
-  "failed",
-  "failure",
-  "error",
-  "cancelled",
-  "canceled",
-  "aborted",
-  "interrupted",
-  "stopped"
-]);
-var NON_TERMINAL_BACKGROUND_STATUSES = /* @__PURE__ */ new Set([
-  "running",
-  "in_progress",
-  "inprogress",
-  "started",
-  "pending",
-  "active",
-  "working",
-  "queued"
-]);
-var ASYNC_LAUNCH_ACK_RE = /^(async agent launched successfully|background (?:task|agent|subagent) (?:launched|started|running)|task (?:launched|started) successfully)/i;
-function isTerminalBackgroundStatus(record2) {
-  const status = stringField(record2, "status")?.toLowerCase();
-  if (status && TERMINAL_BACKGROUND_STATUSES.has(status)) return true;
-  if (status && NON_TERMINAL_BACKGROUND_STATUSES.has(status)) return false;
-  return typeof record2.duration_ms === "number" || typeof record2.durationMs === "number" || typeof record2.total_tokens === "number" || typeof record2.totalTokens === "number" || typeof record2.tool_uses === "number" || typeof record2.toolUses === "number";
-}
-function isFailedBackgroundStatus(record2) {
-  const status = stringField(record2, "status")?.toLowerCase();
-  return status === "failed" || status === "failure" || status === "error" || status === "cancelled" || status === "canceled" || status === "aborted" || status === "interrupted";
-}
-function extractBackgroundTaskIdFromPayload(value2) {
-  if (typeof value2 === "string") {
-    const trimmed = value2.trim();
-    if (!trimmed) return void 0;
-    try {
-      return extractBackgroundTaskIdFromPayload(JSON.parse(trimmed));
-    } catch {
-      const match = trimmed.match(/\btask[_-]?id["']?\s*[:=]\s*["']?([A-Za-z0-9_.-]+)/i) ?? trimmed.match(/\btasks\/([A-Za-z0-9_.-]+)/i);
-      if (match?.[1]) return match[1];
-      if (/^[A-Za-z0-9_-]{6,128}$/.test(trimmed) && /(?:task|bg|async|job|agent)/i.test(trimmed)) {
-        return trimmed;
-      }
-      return void 0;
-    }
-  }
-  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) return void 0;
-  const record2 = value2;
-  return stringField(record2, "task_id") ?? stringField(record2, "taskId") ?? stringField(record2, "agentId") ?? stringField(record2, "agent_id") ?? extractBackgroundTaskIdFromPayload(record2.value) ?? extractBackgroundTaskIdFromPayload(record2.result) ?? extractBackgroundTaskIdFromPayload(record2.data) ?? extractBackgroundTaskIdFromPayload(record2.content);
-}
-function looksLikeBackgroundLaunchAck(options) {
-  const taskId = extractBackgroundTaskIdFromPayload(options.value) ?? extractBackgroundTaskIdFromPayload(options.content);
-  const content = options.content.trim();
-  const explicitAckText = ASYNC_LAUNCH_ACK_RE.test(content);
-  if (!options.trackedUnlinkedLauncher) return { isAck: false, taskId };
-  if (options.explicitBackground && taskId) return { isAck: true, taskId };
-  if (explicitAckText) return { isAck: true, taskId };
-  if (taskId && content.length > 0 && content.length < 400) {
-    const record2 = options.value && typeof options.value === "object" && !Array.isArray(options.value) ? options.value : null;
-    const looksStructured = record2 !== null || content.startsWith("{") || /^task[_-]?id\b/i.test(content) || content === taskId;
-    if (looksStructured) return { isAck: true, taskId };
-  }
-  return { isAck: false, taskId };
-}
-function settleBackgroundTerminalNotification(kind, context, state, record2, options) {
-  const toolUseId = resolveBackgroundTaskToolUseId(state, record2);
-  const keys = backgroundTaskKeys(record2);
-  const wasActive = !!toolUseId && state.activeBackgroundTaskIds?.has(toolUseId) === true || keys.some((key) => state.activeBackgroundTaskIds?.has(key) === true);
-  if (toolUseId && wasActive) {
-    options.emitToolResult(toolUseId, options.resultText, options.isError);
-    clearBackgroundTaskIds(state, keys);
-    maybeFinalizeDeferredResult(kind, context, state);
-    return toolUseId;
-  }
-  clearBackgroundTaskIds(state, keys);
-  const drainedLauncher = drainNextUnlinkedBackgroundLauncher(state);
-  if (drainedLauncher) {
-    options.emitToolResult(drainedLauncher, options.resultText, options.isError);
-  }
-  maybeFinalizeDeferredResult(kind, context, state);
-  return drainedLauncher;
-}
-function finalizeStructuredResult(kind, state) {
-  state.resultReceived = true;
-  state.onResultReceived?.();
-  if (state.stdin && !state.stdin.destroyed) {
-    state.stdin.end();
-    console.info(`[${kind}] Closed stdin after result event to signal CLI exit`);
-  }
-}
-function deferOrFinalizeStructuredResult(kind, context, state) {
-  const pendingAsks = context.presenter.pendingAskUserToolIds?.size ?? 0;
-  if (pendingAsks > 0) {
-    console.info(
-      `[${kind}] Keeping stdin open \u2014 ${pendingAsks} interactive question(s) awaiting user response`
-    );
-    state.resultDeferredOnPendingAnswer = true;
-    return "deferred_pending_answer";
-  }
-  const activeBackgroundTasks = state.activeBackgroundTaskIds?.size ?? 0;
-  if (activeBackgroundTasks > 0) {
-    console.info(
-      `[${kind}] Keeping stdin open \u2014 ${activeBackgroundTasks} background task(s) still active`
-    );
-    state.resultDeferredOnBackgroundWork = true;
-    return "deferred_background_work";
-  }
-  finalizeStructuredResult(kind, state);
-  return "finalized";
-}
-function maybeFinalizeDeferredResult(kind, context, state) {
-  if (!state.resultDeferredOnBackgroundWork && !state.resultDeferredOnPendingAnswer) return;
-  if (context.presenter.pendingAskUserToolIds?.size || state.activeBackgroundTaskIds?.size) return;
-  if (state.resultDeferredOnBackgroundWork) {
-    state.awaitingPostBackgroundSynthesis = true;
-    console.info(
-      `[${kind}] Background work drained \u2014 awaiting post-subagent synthesis before stdin close`
-    );
-    return;
-  }
-  state.resultDeferredOnPendingAnswer = false;
-  finalizeStructuredResult(kind, state);
-}
 var DEBUG_ASK = process.env.ALAN_DEBUG_ASK === "1" || process.env.ALAN_DEBUG === "1";
 function debugAskLog(message) {
   if (DEBUG_ASK) console.info(message);
@@ -20580,22 +21169,22 @@ function extractToolResultContent(content) {
     return "";
   }).filter(Boolean).join("\n");
 }
-function stringField2(record2, key) {
+function stringField3(record2, key) {
   const value2 = record2[key];
   return typeof value2 === "string" && value2.trim().length > 0 ? value2 : void 0;
 }
 function isTerminalTaskNotification(record2) {
-  const status = stringField2(record2, "status")?.toLowerCase();
+  const status = stringField3(record2, "status")?.toLowerCase();
   if (status && TERMINAL_TASK_NOTIFICATION_STATUSES.has(status)) return true;
   if (status && NON_TERMINAL_TASK_NOTIFICATION_STATUSES.has(status)) return false;
   return typeof record2.duration_ms === "number" || typeof record2.durationMs === "number" || typeof record2.total_tokens === "number" || typeof record2.totalTokens === "number" || typeof record2.tool_uses === "number" || typeof record2.toolUses === "number";
 }
 function isFailedTaskNotification(record2) {
-  const status = stringField2(record2, "status")?.toLowerCase();
+  const status = stringField3(record2, "status")?.toLowerCase();
   return status === "failed" || status === "failure" || status === "error" || status === "cancelled" || status === "canceled";
 }
 function formatClaudeTaskNotificationResult(record2) {
-  const status = stringField2(record2, "status") ?? "completed";
+  const status = stringField3(record2, "status") ?? "completed";
   const details = [`Subagent ${status}.`];
   const durationMs = record2.duration_ms ?? record2.durationMs;
   const toolUses = record2.tool_uses ?? record2.toolUses;
@@ -21032,29 +21621,29 @@ function normalizeCodexMcpToolResult(output) {
   return raw;
 }
 function resolveCodexHome(env) {
-  return env.CODEX_HOME || process.env.CODEX_HOME || (0, import_path5.join)((0, import_os5.homedir)(), ".codex");
+  return env.CODEX_HOME || process.env.CODEX_HOME || (0, import_path7.join)((0, import_os6.homedir)(), ".codex");
 }
 function findCodexSessionLog(runtimeSessionId, codexHome) {
-  if (!runtimeSessionId || !(0, import_fs5.existsSync)(codexHome)) return null;
-  const root = (0, import_path5.join)(codexHome, "sessions");
-  if (!(0, import_fs5.existsSync)(root)) return null;
+  if (!runtimeSessionId || !(0, import_fs7.existsSync)(codexHome)) return null;
+  const root = (0, import_path7.join)(codexHome, "sessions");
+  if (!(0, import_fs7.existsSync)(root)) return null;
   const matches = [];
   const stack = [root];
   while (stack.length > 0) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = (0, import_fs5.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_fs7.readdirSync)(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const path = (0, import_path5.join)(dir, entry.name);
+      const path = (0, import_path7.join)(dir, entry.name);
       if (entry.isDirectory()) {
         stack.push(path);
       } else if (entry.isFile() && entry.name.includes(runtimeSessionId) && entry.name.endsWith(".jsonl")) {
         try {
-          matches.push({ path, mtimeMs: (0, import_fs5.statSync)(path).mtimeMs });
+          matches.push({ path, mtimeMs: (0, import_fs7.statSync)(path).mtimeMs });
         } catch {
           matches.push({ path, mtimeMs: 0 });
         }
@@ -21108,21 +21697,21 @@ function firstUserMessageLineIndex(lines) {
     const line = lines[index];
     if (!line) continue;
     const entry = parseJsonObject(line);
-    const payload = asRecord(entry?.payload);
+    const payload = asRecord2(entry?.payload);
     if (payload?.type === "message" && payload.role === "user" && !isSyntheticUserRolloutMessage(payload)) {
       return index;
     }
   }
   return -1;
 }
-function asRecord(value2) {
+function asRecord2(value2) {
   return value2 && typeof value2 === "object" ? value2 : null;
 }
 function rolloutTextContent(content) {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
   return content.flatMap((block) => {
-    const record2 = asRecord(block);
+    const record2 = asRecord2(block);
     const text = record2?.text;
     return typeof text === "string" ? [text] : [];
   }).join("");
@@ -21151,14 +21740,14 @@ function collectCodexWorkerReplays(lines, state) {
   const workersByThreadId = /* @__PURE__ */ new Map();
   for (const line of lines) {
     const entry = parseJsonObject(line);
-    const payload = asRecord(entry?.payload);
+    const payload = asRecord2(entry?.payload);
     if (!payload) continue;
     if (entry?.type === "response_item" && payload.type === "function_call" && payload.name === "spawn_agent") {
       const namespace = typeof payload.namespace === "string" ? payload.namespace : "";
       if (namespace !== "collaboration" && namespace !== "multi_agent_v1") continue;
       const callId = typeof payload.call_id === "string" ? payload.call_id : "";
       if (!callId) continue;
-      const args = asRecord(parseMaybeJson(payload.arguments));
+      const args = asRecord2(parseMaybeJson(payload.arguments));
       const taskName = typeof args?.task_name === "string" ? args.task_name : "";
       const message = typeof args?.message === "string" ? args.message : "";
       spawnByCallId.set(callId, {
@@ -21171,7 +21760,7 @@ function collectCodexWorkerReplays(lines, state) {
       const callId = typeof payload.call_id === "string" ? payload.call_id : "";
       const spawn32 = spawnByCallId.get(callId);
       if (!spawn32) continue;
-      const output = asRecord(parseMaybeJson(payload.output));
+      const output = asRecord2(parseMaybeJson(payload.output));
       const threadId = typeof output?.agent_id === "string" ? output.agent_id : "";
       if (!threadId) continue;
       const nickname = typeof output?.nickname === "string" ? output.nickname : void 0;
@@ -21213,7 +21802,7 @@ function replayCodexWorkerTranscript(context, worker, codexHome, state) {
   if (!state.codexWorkerSessionLogPathByThreadId)
     state.codexWorkerSessionLogPathByThreadId = /* @__PURE__ */ new Map();
   state.codexWorkerSessionLogPathByThreadId.set(worker.threadId, logPath);
-  const allLines = (0, import_fs5.readFileSync)(logPath, "utf8").split(/\r?\n/).filter(Boolean);
+  const allLines = (0, import_fs7.readFileSync)(logPath, "utf8").split(/\r?\n/).filter(Boolean);
   const firstUserLineIndex = firstUserMessageLineIndex(allLines);
   const lines = firstUserLineIndex >= 0 ? allLines.slice(firstUserLineIndex + 1) : allLines;
   const emittedToolNames = /* @__PURE__ */ new Map();
@@ -21224,7 +21813,7 @@ function replayCodexWorkerTranscript(context, worker, codexHome, state) {
     if (!line) continue;
     const entry = parseJsonObject(line);
     if (entry?.type !== "response_item") continue;
-    const payload = asRecord(entry.payload);
+    const payload = asRecord2(entry.payload);
     if (!payload) continue;
     if (payload.type === "message" && payload.role === "assistant") {
       const text = rolloutTextContent(payload.content);
@@ -21318,7 +21907,7 @@ function syncCodexWorkerEventsFromSessionLog(context, state) {
   const logPath = state.codexSessionLogPath ?? findCodexSessionLog(runtimeSessionId, codexHome);
   if (!logPath) return [];
   state.codexSessionLogPath = logPath;
-  const allLines = (0, import_fs5.readFileSync)(logPath, "utf8").split(/\r?\n/).filter(Boolean);
+  const allLines = (0, import_fs7.readFileSync)(logPath, "utf8").split(/\r?\n/).filter(Boolean);
   const latestUserLineIndex = latestUserMessageLineIndex(allLines);
   const lines = latestUserLineIndex >= 0 ? allLines.slice(latestUserLineIndex + 1) : allLines;
   const workers = collectCodexWorkerReplays(lines, state);
@@ -21357,7 +21946,7 @@ async function replayCodexMcpToolEventsFromSessionLog(context, state) {
   const codexHome = resolveCodexHome(context.env);
   const logPath = findCodexSessionLog(runtimeSessionId, codexHome);
   if (!logPath) return;
-  const allLines = (0, import_fs5.readFileSync)(logPath, "utf8").split(/\r?\n/).filter(Boolean);
+  const allLines = (0, import_fs7.readFileSync)(logPath, "utf8").split(/\r?\n/).filter(Boolean);
   const latestUserLineIndex = latestUserMessageLineIndex(allLines);
   const lines = latestUserLineIndex >= 0 ? allLines.slice(latestUserLineIndex + 1) : allLines;
   const streamedToolIds = state.codexStreamedToolIds ?? /* @__PURE__ */ new Set();
@@ -22207,7 +22796,7 @@ ${ctx.promptText}` : ctx.promptText;
   };
 }
 var explicitBackgroundLaunchers = /* @__PURE__ */ new WeakMap();
-function asRecord2(value2) {
+function asRecord3(value2) {
   return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
 }
 function asString(value2) {
@@ -22338,7 +22927,7 @@ function handleCopilotStructuredEvent(parsed, context, state) {
     case "tool.execution_start": {
       const toolId = typeof data.toolCallId === "string" ? data.toolCallId : `copilot-tool-${Date.now()}`;
       const rawName = typeof data.toolName === "string" ? data.toolName : "Copilot Tool";
-      const rawArgs = asRecord2(data.arguments) ?? {};
+      const rawArgs = asRecord3(data.arguments) ?? {};
       const softTrack = isCloudDelegateTool(rawName, rawArgs);
       const localBg = isLocalBackgroundLauncher(rawName, rawArgs);
       const args = softTrack || localBg ? normalizeLauncherArgs(rawArgs, softTrack) : rawArgs;
@@ -22497,7 +23086,7 @@ function createCopilotCliBackend(command = "copilot", defaultArgs = []) {
     }
   };
 }
-function asRecord3(value2) {
+function asRecord4(value2) {
   return typeof value2 === "object" && value2 !== null ? value2 : null;
 }
 function extractCursorToolEntry(toolCall) {
@@ -22519,12 +23108,12 @@ function formatCursorToolName(rawName, payload) {
   return trimmed.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/^[a-z]/, (char) => char.toUpperCase());
 }
 function cursorTaskResultVariant(payload, variant) {
-  const result = asRecord3(payload.result);
+  const result = asRecord4(payload.result);
   if (!result) return null;
-  const direct = asRecord3(result[variant]);
+  const direct = asRecord4(result[variant]);
   if (direct) return direct;
-  const oneof = asRecord3(result.result);
-  return oneof?.case === variant ? asRecord3(oneof.value) : null;
+  const oneof = asRecord4(result.result);
+  return oneof?.case === variant ? asRecord4(oneof.value) : null;
 }
 function cursorSubagentType(value2) {
   const normalize = (candidate) => {
@@ -22535,18 +23124,18 @@ function cursorSubagentType(value2) {
     return trimmed;
   };
   if (typeof value2 === "string") return normalize(value2);
-  const record2 = asRecord3(value2);
+  const record2 = asRecord4(value2);
   if (!record2) return void 0;
   if (typeof record2.case === "string" && record2.case) return normalize(record2.case);
   if (typeof record2.type === "string" && record2.type) return normalize(record2.type);
-  const nestedType = asRecord3(record2.type);
+  const nestedType = asRecord4(record2.type);
   if (typeof nestedType?.case === "string" && nestedType.case) return normalize(nestedType.case);
   return normalize(
     Object.keys(nestedType ?? record2).find((key) => key !== "value" && key !== "case")
   );
 }
 function cursorToolArgs(entry) {
-  const args = asRecord3(entry.payload.args) ?? asRecord3(entry.payload.arguments) ?? entry.payload;
+  const args = asRecord4(entry.payload.args) ?? asRecord4(entry.payload.arguments) ?? entry.payload;
   if (entry.rawName !== "taskToolCall") return args;
   const subagentType = cursorSubagentType(args.subagentType ?? args.subagent_type);
   return {
@@ -22557,15 +23146,15 @@ function cursorToolArgs(entry) {
   };
 }
 function cursorConversationStepValue(step, key) {
-  const direct = asRecord3(step[key]);
+  const direct = asRecord4(step[key]);
   if (direct) return direct;
-  const message = asRecord3(step.message);
-  return message?.case === key ? asRecord3(message.value) : null;
+  const message = asRecord4(step.message);
+  return message?.case === key ? asRecord4(message.value) : null;
 }
 function cursorConversationStepText(steps) {
   if (!Array.isArray(steps)) return "";
   return steps.flatMap((step) => {
-    const record2 = asRecord3(step);
+    const record2 = asRecord4(step);
     if (!record2) return [];
     const assistant = cursorConversationStepValue(record2, "assistantMessage");
     return typeof assistant?.text === "string" ? [assistant.text] : [];
@@ -22595,7 +23184,7 @@ function buildCursorToolResultText(result) {
 function emitCursorSubagentConversationSteps(steps, parentToolUseId, presenter) {
   if (!Array.isArray(steps)) return;
   steps.forEach((step, index) => {
-    const record2 = asRecord3(step);
+    const record2 = asRecord4(step);
     if (!record2) return;
     const assistant = cursorConversationStepValue(record2, "assistantMessage");
     if (typeof assistant?.text === "string" && assistant.text) {
@@ -22636,7 +23225,7 @@ function emitCursorSubagentTranscript(transcriptPath, parentToolUseId, presenter
   }
   let lines;
   try {
-    lines = (0, import_fs6.readFileSync)(transcriptPath, "utf8").split(/\r?\n/);
+    lines = (0, import_fs8.readFileSync)(transcriptPath, "utf8").split(/\r?\n/);
     if (lines.at(-1) === "") lines.pop();
   } catch {
     return { found: false, processedLineCount: startLine, emittedEventCount: 0 };
@@ -22657,10 +23246,10 @@ function emitCursorSubagentTranscript(transcriptPath, parentToolUseId, presenter
     }
     processedLineCount = lineIndex + 1;
     if (entry.role !== "assistant") continue;
-    const message = asRecord3(entry.message);
+    const message = asRecord4(entry.message);
     const content = Array.isArray(message?.content) ? message.content : [];
     content.forEach((rawBlock, blockIndex) => {
-      const block = asRecord3(rawBlock);
+      const block = asRecord4(rawBlock);
       if (!block) return;
       const type = typeof block.type === "string" ? block.type : "";
       const text = typeof block.text === "string" ? block.text : "";
@@ -22678,18 +23267,18 @@ function emitCursorSubagentTranscript(transcriptPath, parentToolUseId, presenter
       const name = typeof block.name === "string" && block.name ? block.name : "Cursor Tool";
       const toolId = typeof block.id === "string" && block.id || `${parentToolUseId}-transcript-${lineIndex}-${blockIndex}`;
       emittedEventCount += 1;
-      void presenter.onToolUse(name, asRecord3(block.input) ?? {}, toolId, parentToolUseId);
+      void presenter.onToolUse(name, asRecord4(block.input) ?? {}, toolId, parentToolUseId);
     });
   }
   return { found: true, processedLineCount, emittedEventCount };
 }
 function cursorTranscriptsRoot(context) {
   const projectKey = context.cwd.replace(/^[/\\]+/, "").replace(/[/\\]+/g, "-");
-  const home = context.env.HOME || process.env.HOME || (0, import_os6.homedir)();
-  return (0, import_path6.join)(home, ".cursor", "projects", projectKey, "agent-transcripts");
+  const home = context.env.HOME || process.env.HOME || (0, import_os7.homedir)();
+  return (0, import_path8.join)(home, ".cursor", "projects", projectKey, "agent-transcripts");
 }
 function cursorTranscriptPathForAgent(context, agentId) {
-  return (0, import_path6.join)(cursorTranscriptsRoot(context), agentId, `${agentId}.jsonl`);
+  return (0, import_path8.join)(cursorTranscriptsRoot(context), agentId, `${agentId}.jsonl`);
 }
 function resolveCursorSubagentTranscriptPath(success2, context) {
   const explicit = success2?.transcriptPath ?? success2?.transcript_path;
@@ -22699,14 +23288,14 @@ function resolveCursorSubagentTranscriptPath(success2, context) {
 }
 function cursorTranscriptUserText(transcriptPath) {
   try {
-    for (const line of (0, import_fs6.readFileSync)(transcriptPath, "utf8").split(/\r?\n/)) {
+    for (const line of (0, import_fs8.readFileSync)(transcriptPath, "utf8").split(/\r?\n/)) {
       if (!line) continue;
-      const entry = asRecord3(JSON.parse(line));
+      const entry = asRecord4(JSON.parse(line));
       if (entry?.role !== "user") continue;
-      const message = asRecord3(entry.message);
+      const message = asRecord4(entry.message);
       const content = Array.isArray(message?.content) ? message.content : [];
       return content.flatMap((block) => {
-        const record2 = asRecord3(block);
+        const record2 = asRecord4(block);
         return typeof record2?.text === "string" ? [record2.text] : [];
       }).join("");
     }
@@ -22716,13 +23305,13 @@ function cursorTranscriptUserText(transcriptPath) {
 }
 function discoverCursorSubagentTranscript(context, state, task) {
   const root = cursorTranscriptsRoot(context);
-  if (!(0, import_fs6.existsSync)(root)) return void 0;
+  if (!(0, import_fs8.existsSync)(root)) return void 0;
   const prompt = task.prompt?.trim();
   const description = task.description?.trim().toLowerCase();
   const candidates = [];
   let entries;
   try {
-    entries = (0, import_fs6.readdirSync)(root, { withFileTypes: true });
+    entries = (0, import_fs8.readdirSync)(root, { withFileTypes: true });
   } catch {
     return void 0;
   }
@@ -22731,7 +23320,7 @@ function discoverCursorSubagentTranscript(context, state, task) {
     const path = cursorTranscriptPathForAgent(context, entry.name);
     let mtimeMs;
     try {
-      mtimeMs = (0, import_fs6.statSync)(path).mtimeMs;
+      mtimeMs = (0, import_fs8.statSync)(path).mtimeMs;
     } catch {
       continue;
     }
@@ -23157,7 +23746,7 @@ var DROID_TASK_OUTPUT_NAMES = /* @__PURE__ */ new Set(["taskoutput", "task_outpu
 var DROID_TASK_STOP_NAMES = /* @__PURE__ */ new Set(["taskstop", "task_stop"]);
 var pendingTaskIdByToolId = /* @__PURE__ */ new WeakMap();
 var explicitBackgroundLaunchers2 = /* @__PURE__ */ new WeakMap();
-function asRecord4(value2) {
+function asRecord5(value2) {
   return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
 }
 function asString2(value2) {
@@ -23309,7 +23898,7 @@ function handleDroidStructuredEvent(parsed, context, state) {
       const ack = looksLikeBackgroundLaunchAck({
         content,
         value: value2,
-        explicitBackground: wasExplicitBackground2(state, toolId) || boolish2(asRecord4(value2)?.run_in_background),
+        explicitBackground: wasExplicitBackground2(state, toolId) || boolish2(asRecord5(value2)?.run_in_background),
         trackedUnlinkedLauncher: trackedLauncher && !linkedBackground
       });
       if (ack.isAck && ack.taskId) {
@@ -23451,7 +24040,7 @@ function createDroidCliBackend(command = "droid", defaultArgs = []) {
   };
 }
 var ACP_PROTOCOL_VERSION = 1;
-function asRecord5(value2) {
+function asRecord6(value2) {
   return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
 }
 function asString3(value2) {
@@ -23461,7 +24050,7 @@ function resumeSessionId(context) {
   return context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim() || "";
 }
 function chunkText(content) {
-  const record2 = asRecord5(content);
+  const record2 = asRecord6(content);
   if (!record2) return "";
   if (typeof record2.text === "string") return record2.text;
   return chunkText(record2.content);
@@ -23477,8 +24066,8 @@ function toolResultText(update) {
   return "";
 }
 function toolMetaName(update) {
-  const meta3 = asRecord5(update._meta);
-  const tool = asRecord5(meta3?.["x.ai/tool"]);
+  const meta3 = asRecord6(update._meta);
+  const tool = asRecord6(meta3?.["x.ai/tool"]);
   return asString3(tool?.name);
 }
 function normalizeToolKey2(name) {
@@ -23509,18 +24098,18 @@ function normalizeGrokSubagentInput(toolName, rawInput) {
   return input;
 }
 function resolvePermission(params, context) {
-  const record2 = asRecord5(params);
+  const record2 = asRecord6(params);
   const options = Array.isArray(record2?.options) ? record2?.options : [];
-  const toolCall = asRecord5(record2?.toolCall);
-  const meta3 = asRecord5(toolCall?._meta);
-  const tool = asRecord5(meta3?.["x.ai/tool"]);
+  const toolCall = asRecord6(record2?.toolCall);
+  const meta3 = asRecord6(toolCall?._meta);
+  const tool = asRecord6(meta3?.["x.ai/tool"]);
   const isReadOnlyTool = tool?.read_only === true || asString3(tool?.kind) === "read";
   const allow = !shouldUseReadOnlyRuntimePermissions(context.config) || isReadOnlyTool;
   const allowKinds = ["allow_always", "allow_once", "allow"];
   const rejectKinds = ["reject_always", "reject_once", "reject", "deny"];
   const wanted = allow ? allowKinds : rejectKinds;
-  const chosen = options.find((option) => wanted.includes(asString3(asRecord5(option)?.kind))) ?? (allow ? options[0] : options[options.length - 1]);
-  const optionId = asString3(asRecord5(chosen)?.optionId);
+  const chosen = options.find((option) => wanted.includes(asString3(asRecord6(option)?.kind))) ?? (allow ? options[0] : options[options.length - 1]);
+  const optionId = asString3(asRecord6(chosen)?.optionId);
   if (!optionId) return { outcome: { outcome: "cancelled" } };
   return { outcome: { outcome: "selected", optionId } };
 }
@@ -23613,9 +24202,9 @@ function createGrokAcpDriver(imageFiles) {
       forceFinalize(state);
       return;
     }
-    const result = asRecord5(message.result);
+    const result = asRecord6(message.result);
     if (message.id === initId) {
-      const modelState = asRecord5(asRecord5(result?._meta)?.modelState);
+      const modelState = asRecord6(asRecord6(result?._meta)?.modelState);
       const model = asString3(modelState?.currentModelId);
       if (model) state.activeModel = model;
       beginSession(context, state);
@@ -23629,7 +24218,7 @@ function createGrokAcpDriver(imageFiles) {
       return;
     }
     if (message.id === promptId) {
-      const meta3 = asRecord5(result?._meta);
+      const meta3 = asRecord6(result?._meta);
       const model = asString3(meta3?.modelId) || state.activeModel || (typeof context.config.selectedModel === "string" && context.config.selectedModel.trim() ? context.config.selectedModel.trim() : "grok");
       const inputTokens = typeof meta3?.inputTokens === "number" ? meta3.inputTokens : 0;
       const outputTokens = typeof meta3?.outputTokens === "number" ? meta3.outputTokens : 0;
@@ -23676,8 +24265,8 @@ function createGrokAcpDriver(imageFiles) {
     }
   }
   function handleNotification(message, context, state) {
-    const params = asRecord5(message.params);
-    const update = asRecord5(params?.update);
+    const params = asRecord6(message.params);
+    const update = asRecord6(params?.update);
     if (!update || !isPromptActive) return;
     const presenter = context.presenter;
     switch (asString3(update.sessionUpdate)) {
@@ -23699,7 +24288,7 @@ function createGrokAcpDriver(imageFiles) {
       case "tool_call": {
         const toolId = asString3(update.toolCallId);
         const rawName = asString3(update.title) || toolMetaName(update) || "Grok Tool";
-        const rawInput = asRecord5(update.rawInput);
+        const rawInput = asRecord6(update.rawInput);
         const isSubagent = isGrokSubagentTool(rawName, rawInput);
         const toolName = isSubagent ? presentGrokSubagentName(rawName) : rawName;
         const input = isSubagent ? normalizeGrokSubagentInput(rawName, rawInput) : rawInput ?? {};
@@ -23774,7 +24363,7 @@ function createGrokAcpDriver(imageFiles) {
       if (line.trim().length > 0) void context.presenter.onLog(`[grok_cli] ${line}`);
       return;
     }
-    const message = asRecord5(parsed);
+    const message = asRecord6(parsed);
     if (!message) return;
     if (message.id !== void 0 && message.method === void 0) {
       handleResponse(message, context, state);
@@ -23841,9 +24430,9 @@ function buildGrokAgentArgs(config2, defaultArgs = []) {
   return args;
 }
 var DEFAULT_SKILL_ROOTS = [
-  (0, import_path7.join)((0, import_os7.homedir)(), ".agents", "skills"),
-  (0, import_path7.join)((0, import_os7.homedir)(), ".claude", "skills"),
-  (0, import_path7.join)((0, import_os7.homedir)(), ".config", "opencode", "skills")
+  (0, import_path9.join)((0, import_os8.homedir)(), ".agents", "skills"),
+  (0, import_path9.join)((0, import_os8.homedir)(), ".claude", "skills"),
+  (0, import_path9.join)((0, import_os8.homedir)(), ".config", "opencode", "skills")
 ];
 function parseFrontmatter(content) {
   if (!content.startsWith("---\n")) return {};
@@ -23859,12 +24448,12 @@ function parseFrontmatter(content) {
   return result;
 }
 function listSkillFiles(root) {
-  if (!(0, import_fs7.existsSync)(root)) return [];
+  if (!(0, import_fs9.existsSync)(root)) return [];
   const files = [];
-  for (const entry of (0, import_fs7.readdirSync)(root, { withFileTypes: true })) {
+  for (const entry of (0, import_fs9.readdirSync)(root, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const skillPath = (0, import_path7.join)(root, entry.name, "SKILL.md");
-    if ((0, import_fs7.existsSync)(skillPath)) files.push(skillPath);
+    const skillPath = (0, import_path9.join)(root, entry.name, "SKILL.md");
+    if ((0, import_fs9.existsSync)(skillPath)) files.push(skillPath);
   }
   return files;
 }
@@ -23873,7 +24462,7 @@ function loadInstalledSkills(roots = DEFAULT_SKILL_ROOTS) {
   for (const root of roots) {
     for (const skillPath of listSkillFiles(root)) {
       try {
-        const frontmatter = parseFrontmatter((0, import_fs7.readFileSync)(skillPath, "utf8"));
+        const frontmatter = parseFrontmatter((0, import_fs9.readFileSync)(skillPath, "utf8"));
         const name = frontmatter.name;
         const description = frontmatter.description;
         if (!name || !description || skills.has(name)) continue;
@@ -23912,7 +24501,7 @@ var KIMI_SUBAGENT_TOOL_NAMES = /* @__PURE__ */ new Set([
   "subagent"
 ]);
 var explicitBackgroundLaunchers3 = /* @__PURE__ */ new WeakMap();
-function asRecord6(value2) {
+function asRecord7(value2) {
   return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
 }
 function asString4(value2) {
@@ -24094,7 +24683,7 @@ function handleKimiStructuredEvent(parsed, context, state) {
       );
       return true;
     }
-    const statusRecord = asRecord6(
+    const statusRecord = asRecord7(
       (() => {
         try {
           return JSON.parse(content);
@@ -24427,10 +25016,18 @@ var parseOpencodeStructuredLine = createStructuredLineParser(
   "opencode_cli",
   handleOpencodeStructuredEvent
 );
+function normalizeOpenCodeVariant(value2) {
+  const trimmed = value2?.trim();
+  const containsControlCharacter = Array.from(trimmed ?? "").some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code === 127;
+  });
+  if (!trimmed || trimmed.length > 256 || containsControlCharacter) return null;
+  return trimmed;
+}
 function buildOpencodeEffortArgs(selectedEffortLevel) {
-  const trimmed = selectedEffortLevel?.trim().toLowerCase();
-  if (!trimmed || !isEffortLevel(trimmed)) return [];
-  return ["--variant", trimmed];
+  const variant = normalizeOpenCodeVariant(selectedEffortLevel);
+  return variant ? ["--variant", variant] : [];
 }
 function createOpencodeCliBackend(command = "opencode", defaultArgs = []) {
   return {
@@ -24547,9 +25144,27 @@ var SERVER_LISTENING_PATTERN = /listening on (https?:\/\/\S+)/i;
 var STARTUP_TIMEOUT_MS = 2e4;
 var HEALTH_POLL_INTERVAL_MS = 200;
 var HEALTH_POLL_MAX_ATTEMPTS = 50;
+var LEASE_IDLE_TTL_MS = 10 * 60 * 1e3;
+var serveLeases = /* @__PURE__ */ new Map();
+function leaseKeyFor(context) {
+  const conversationId = context.config.conversationId?.trim();
+  return conversationId ? `conv:${conversationId}` : null;
+}
+function isLeaseUsable(lease) {
+  const alive = lease.child.exitCode === null && lease.child.signalCode === null;
+  const fresh = Date.now() - lease.lastUsedAtMs <= LEASE_IDLE_TTL_MS;
+  return alive && fresh;
+}
+function evictLease(key) {
+  if (!key) return;
+  const lease = serveLeases.get(key);
+  if (!lease) return;
+  serveLeases.delete(key);
+  killProcessTree(lease.child.pid, { signal: "SIGTERM", child: lease.child });
+}
 function startOpenCodeServer(command, context) {
   const child = spawnCli(command, ["serve", "--port", "0", "--hostname", "127.0.0.1"], context);
-  const ready = new Promise((resolve22, reject) => {
+  const ready = new Promise((resolve42, reject) => {
     let settled = false;
     const timeout = setTimeout(() => {
       if (settled) return;
@@ -24567,7 +25182,7 @@ function startOpenCodeServer(command, context) {
       if (!match) return;
       settled = true;
       clearTimeout(timeout);
-      resolve22({ baseUrl: match[1].replace(/\/$/, "") });
+      resolve42({ baseUrl: match[1].replace(/\/$/, "") });
     };
     stdoutRl.on("line", checkLine);
     stderrRl.on("line", (line) => {
@@ -24605,7 +25220,7 @@ async function waitForHealthy(baseUrl, signal) {
       }
     } catch {
     }
-    await new Promise((resolve22) => setTimeout(resolve22, HEALTH_POLL_INTERVAL_MS));
+    await new Promise((resolve42) => setTimeout(resolve42, HEALTH_POLL_INTERVAL_MS));
   }
   throw new Error(`opencode server at ${baseUrl} did not become healthy in time`);
 }
@@ -24642,27 +25257,30 @@ function buildPromptParts(promptText, imageFiles, attachmentFiles) {
       type: "file",
       mime: file2.mimeType,
       filename: file2.filename,
-      url: (0, import_url.pathToFileURL)(file2.path).href
+      url: (0, import_url2.pathToFileURL)(file2.path).href
     })
   );
   return [...attachments, { type: "text", text: promptText }];
 }
-async function sendPrompt(baseUrl, sessionId, context, parts2, signal) {
+function buildOpenCodePromptRequest(context, parts2) {
   const model = context.config.selectedModel?.trim();
   const modelBody = model?.includes("/") ? (() => {
     const slashIndex = model.indexOf("/");
     return { providerID: model.slice(0, slashIndex), modelID: model.slice(slashIndex + 1) };
   })() : void 0;
-  const variant = context.config.selectedEffortLevel?.trim().toLowerCase();
+  const variant = normalizeOpenCodeVariant(context.config.selectedEffortLevel);
+  return {
+    parts: parts2,
+    ...modelBody ? { model: modelBody } : {},
+    ...variant ? { variant } : {}
+  };
+}
+async function sendPrompt(baseUrl, sessionId, context, parts2, signal) {
   const response = await fetch(`${baseUrl}/session/${encodeURIComponent(sessionId)}/message`, {
     method: "POST",
     signal,
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      parts: parts2,
-      ...modelBody ? { model: modelBody } : {},
-      ...variant && isEffortLevel(variant) ? { variant } : {}
-    })
+    body: JSON.stringify(buildOpenCodePromptRequest(context, parts2))
   });
   if (!response.ok) {
     const text = await response.text().catch(() => "");
@@ -24679,6 +25297,18 @@ async function replyToPermission(baseUrl, requestId, reply, signal) {
     console.warn("[opencode_serve] Failed to reply to permission request", requestId, error2);
   });
 }
+var NON_INTERACTIVE_PERMISSION_KINDS = /* @__PURE__ */ new Set(["question", "plan_enter", "plan_exit"]);
+function decideAndReplyToPermission(presenter, baseUrl, properties, readOnly, signal, origin) {
+  const requestId = getString(properties.id);
+  if (!requestId) return;
+  const permissionKind = getString(properties.permission) || "an action";
+  const nonInteractive = NON_INTERACTIVE_PERMISSION_KINDS.has(permissionKind);
+  const reply = nonInteractive || readOnly ? "reject" : "once";
+  const subject = origin === "root" ? "OpenCode" : "OpenCode's background session";
+  const message = nonInteractive ? `${subject} tried to ${permissionKind.replace(/_/g, " ")} \u2014 denied (Alan does not yet support interactive requests for OpenCode).` : readOnly ? `${subject} requested permission to ${permissionKind} \u2014 automatically denied (read-only session).` : `${subject} requested permission to ${permissionKind} \u2014 automatically approved (autonomous mode).`;
+  emitSessionNotice(presenter, "permission_decision", message);
+  void replyToPermission(baseUrl, requestId, reply, signal);
+}
 function buildAgentResult(state, sessionId, aborted2) {
   if (aborted2) {
     return {
@@ -24726,7 +25356,13 @@ function createOpencodeServeBackend(command = "opencode") {
       );
       const runContext = withAutonomousOpenCodePermissions(context);
       const readOnly = shouldUseReadOnlyRuntimePermissions(context.config);
-      const { child, ready } = startOpenCodeServer(command, runContext);
+      const leaseKey = leaseKeyFor(context);
+      const existingLease = leaseKey ? serveLeases.get(leaseKey) : void 0;
+      const reuseLease = Boolean(existingLease && isLeaseUsable(existingLease));
+      if (existingLease && !reuseLease) evictLease(leaseKey);
+      const spawnedServer = reuseLease && existingLease ? null : startOpenCodeServer(command, runContext);
+      const child = reuseLease && existingLease ? existingLease.child : spawnedServer.child;
+      const ready = reuseLease && existingLease ? Promise.resolve({ baseUrl: existingLease.baseUrl }) : spawnedServer.ready;
       const state = { process: child, iterations: 0, summary: "" };
       context.onProcessSpawned?.(child);
       context.registerLivenessProbe?.(() => ({
@@ -24739,13 +25375,19 @@ function createOpencodeServeBackend(command = "opencode") {
       const onAbort = () => {
         aborted2 = true;
         sseClose?.();
+        if (leaseKey) serveLeases.delete(leaseKey);
         killProcessTree(child.pid, { signal: "SIGTERM", child });
       };
       context.abortController.signal.addEventListener("abort", onAbort, { once: true });
       try {
         const server = await ready;
         state.lastRawOutputAtMs = Date.now();
-        await waitForHealthy(server.baseUrl, context.abortController.signal);
+        if (!reuseLease) {
+          await waitForHealthy(server.baseUrl, context.abortController.signal);
+        }
+        if (leaseKey) {
+          serveLeases.set(leaseKey, { child, baseUrl: server.baseUrl, lastUsedAtMs: Date.now() });
+        }
         const session = await resolveSession(
           server.baseUrl,
           runContext,
@@ -24803,17 +25445,94 @@ function createOpencodeServeBackend(command = "opencode") {
       } finally {
         context.abortController.signal.removeEventListener("abort", onAbort);
         sseClose?.();
-        killProcessTree(child.pid, { signal: "SIGTERM", child });
+        const wasAborted = aborted2 || context.abortController.signal.aborted;
+        if (wasAborted || !leaseKey) {
+          if (leaseKey) serveLeases.delete(leaseKey);
+          killProcessTree(child.pid, { signal: "SIGTERM", child });
+        } else {
+          const lease = serveLeases.get(leaseKey);
+          if (lease) lease.lastUsedAtMs = Date.now();
+        }
         cleanupImages();
         cleanupFiles();
       }
     }
   };
 }
+function resolveChildSessionLauncherToolId(state, eventSessionId) {
+  const existing = state.backgroundToolIdByTaskId?.get(eventSessionId);
+  if (existing) return existing;
+  registerBackgroundTaskRecord(state, { task_id: eventSessionId });
+  return state.backgroundToolIdByTaskId?.get(eventSessionId);
+}
+function handleOpenCodeChildSessionEvent(event, eventSessionId, context, state, readOnly, baseUrl) {
+  const properties = event.properties;
+  switch (event.type) {
+    case "message.updated": {
+      const info = getRecord(properties.info);
+      if (getString(info?.role) === "user") {
+        const messageId = getString(info?.id);
+        if (messageId) {
+          state.opencodeUserMessageIds ??= /* @__PURE__ */ new Set();
+          state.opencodeUserMessageIds.add(messageId);
+        }
+      }
+      return false;
+    }
+    case "message.part.updated": {
+      const part = getRecord(properties.part);
+      if (!part) return false;
+      const messageId = getString(part.messageID);
+      if (messageId && state.opencodeUserMessageIds?.has(messageId)) return false;
+      const parentToolUseId = resolveChildSessionLauncherToolId(state, eventSessionId);
+      if (!parentToolUseId && !state.opencodeUnlinkedChildSessionIds?.has(eventSessionId)) {
+        state.opencodeUnlinkedChildSessionIds ??= /* @__PURE__ */ new Set();
+        state.opencodeUnlinkedChildSessionIds.add(eventSessionId);
+        void context.presenter.onLog(
+          `[opencode] Background session ${eventSessionId} is active (no linked launcher \u2014 showing at top level)`
+        );
+      }
+      mapOpencodePart(part, context, state, { parentToolUseId });
+      return false;
+    }
+    case "message.part.delta":
+      return false;
+    case "permission.asked": {
+      decideAndReplyToPermission(
+        context.presenter,
+        baseUrl,
+        properties,
+        readOnly,
+        context.abortController.signal,
+        "background session"
+      );
+      return false;
+    }
+    case "session.error": {
+      const errorRecord = getRecord(properties.error);
+      const message = getString(errorRecord?.message) || getString(properties.error) || "Background OpenCode session error.";
+      void context.presenter.onLog(
+        `[opencode] Background session ${eventSessionId} error: ${message}`
+      );
+      return false;
+    }
+    default:
+      return false;
+  }
+}
 function handleOpenCodeServeEvent(event, sessionId, context, state, readOnly, baseUrl) {
   const properties = event.properties;
   const eventSessionId = getString(properties.sessionID);
-  if (eventSessionId && eventSessionId !== sessionId) return false;
+  if (eventSessionId && eventSessionId !== sessionId) {
+    return handleOpenCodeChildSessionEvent(
+      event,
+      eventSessionId,
+      context,
+      state,
+      readOnly,
+      baseUrl
+    );
+  }
   switch (event.type) {
     // Live-verified: the SSE bus emits a message.updated (and matching
     // message.part.updated) for the USER's own message too, not just the
@@ -24843,15 +25562,14 @@ function handleOpenCodeServeEvent(event, sessionId, context, state, readOnly, ba
     case "message.part.delta":
       return false;
     case "permission.asked": {
-      const requestId = getString(properties.id);
-      if (requestId) {
-        void replyToPermission(
-          baseUrl,
-          requestId,
-          readOnly ? "reject" : "once",
-          context.abortController.signal
-        );
-      }
+      decideAndReplyToPermission(
+        context.presenter,
+        baseUrl,
+        properties,
+        readOnly,
+        context.abortController.signal,
+        "root"
+      );
       return false;
     }
     case "session.error": {
@@ -25024,22 +25742,31 @@ function parseRepoNamespace(command) {
   };
 }
 function hasSkillLayout(dir) {
-  return SKILL_LAYOUT_PARTS.some((parts2) => (0, import_fs8.existsSync)((0, import_path8.join)(dir, ...parts2)));
+  return SKILL_LAYOUT_PARTS.some((parts2) => (0, import_fs10.existsSync)((0, import_path10.join)(dir, ...parts2)));
 }
 function isGitRepo(dir) {
-  return (0, import_fs8.existsSync)((0, import_path8.join)(dir, ".git"));
+  return (0, import_fs10.existsSync)((0, import_path10.join)(dir, ".git"));
 }
 function isLeafProjectRoot(dir) {
   return isGitRepo(dir) || hasSkillLayout(dir);
 }
 function skillDirsForRoot(root) {
-  return SKILL_LAYOUT_PARTS.map((parts2) => (0, import_path8.join)(root, ...parts2));
+  return SKILL_LAYOUT_PARTS.map((parts2) => (0, import_path10.join)(root, ...parts2));
+}
+function pluginSkillDirsForRoot(root) {
+  const pluginsDir = (0, import_path10.join)(root, ".agents", "plugins");
+  if (!(0, import_fs10.existsSync)(pluginsDir)) return [];
+  try {
+    return (0, import_fs10.readdirSync)(pluginsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => (0, import_path10.join)(pluginsDir, entry.name, "skills"));
+  } catch {
+    return [];
+  }
 }
 function listImmediateChildDirs(cwd) {
-  if (!(0, import_fs8.existsSync)(cwd)) return [];
+  if (!(0, import_fs10.existsSync)(cwd)) return [];
   let entries = [];
   try {
-    entries = (0, import_fs8.readdirSync)(cwd, { withFileTypes: true });
+    entries = (0, import_fs10.readdirSync)(cwd, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -25047,40 +25774,50 @@ function listImmediateChildDirs(cwd) {
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith(".")) continue;
-    children.push((0, import_path8.join)(cwd, entry.name));
+    children.push((0, import_path10.join)(cwd, entry.name));
   }
   return children;
 }
 function projectCandidateRoots(cwd) {
   if (!cwd) return [];
-  const roots = [...skillDirsForRoot(cwd)];
+  const roots = [...skillDirsForRoot(cwd), ...pluginSkillDirsForRoot(cwd)];
   if (!isLeafProjectRoot(cwd)) {
     for (const child of listImmediateChildDirs(cwd)) {
       roots.push(...skillDirsForRoot(child));
+      roots.push(...pluginSkillDirsForRoot(child));
     }
   }
   return Array.from(new Set(roots));
 }
-function globalCandidateRoots() {
-  return skillDirsForRoot((0, import_os8.homedir)());
+function globalCandidateRoots(home) {
+  const antigravityConfig = (0, import_path10.join)(home, ".gemini", "config");
+  return Array.from(
+    /* @__PURE__ */ new Set([
+      ...skillDirsForRoot(home),
+      (0, import_path10.join)(antigravityConfig, "skills"),
+      ...pluginSkillDirsForRoot(antigravityConfig)
+    ])
+  );
 }
 function namespacedCandidateRoots(cwd, repoLabel) {
   const roots = [];
   if (cwd) {
-    roots.push(...skillDirsForRoot((0, import_path8.join)(cwd, repoLabel)));
+    roots.push(...skillDirsForRoot((0, import_path10.join)(cwd, repoLabel)));
+    roots.push(...pluginSkillDirsForRoot((0, import_path10.join)(cwd, repoLabel)));
     const base = cwd.replace(/[/\\]+$/, "").split(/[/\\]/).pop();
     if (base === repoLabel) {
       roots.push(...skillDirsForRoot(cwd));
+      roots.push(...pluginSkillDirsForRoot(cwd));
     }
   }
   return Array.from(new Set(roots));
 }
 function readSkillAt(root, command) {
-  const skillPath = (0, import_path8.join)(root, command, "SKILL.md");
-  if (!(0, import_fs8.existsSync)(skillPath)) return null;
+  const skillPath = (0, import_path10.join)(root, command, "SKILL.md");
+  if (!(0, import_fs10.existsSync)(skillPath)) return null;
   let content;
   try {
-    content = (0, import_fs8.readFileSync)(skillPath, "utf-8");
+    content = (0, import_fs10.readFileSync)(skillPath, "utf-8");
   } catch {
     return null;
   }
@@ -25103,7 +25840,7 @@ function collectMatches(roots, command, userRequest) {
   }
   return matches;
 }
-function resolveSkillInvocation(text, cwd) {
+function resolveSkillInvocation(text, cwd, home = (0, import_os9.homedir)()) {
   const parsed = parseSkillInvocation(text);
   if (!parsed) return null;
   const projectExact = collectMatches(
@@ -25115,7 +25852,11 @@ function resolveSkillInvocation(text, cwd) {
   if (projectExact.length > 1) {
     return null;
   }
-  const globalExact = collectMatches(globalCandidateRoots(), parsed.command, parsed.userRequest);
+  const globalExact = collectMatches(
+    globalCandidateRoots(home),
+    parsed.command,
+    parsed.userRequest
+  );
   if (globalExact.length === 1) return globalExact[0];
   const namespaced = parseRepoNamespace(parsed.command);
   if (!namespaced) return null;
@@ -25132,8 +25873,8 @@ function resolveSkillInvocation(text, cwd) {
   }
   return null;
 }
-function expandSkillInvocationPrompt(text, cwd) {
-  const invocation = resolveSkillInvocation(text, cwd);
+function expandSkillInvocationPrompt(text, cwd, home = (0, import_os9.homedir)()) {
+  const invocation = resolveSkillInvocation(text, cwd, home);
   if (!invocation) return { text, invocation: null };
   const request = invocation.userRequest || "(No additional request text was provided.)";
   return {
@@ -25157,7 +25898,6 @@ var DROID_DEFAULT_MODEL = "claude-opus-4-7";
 var AGENT_ACTIVITY_HEARTBEAT_MS = 1e4;
 function normalizeBackendKind(kind) {
   if (kind === "codex") return "codex_app_server";
-  if (kind === "gemini" || kind === "gemini_cli") return "antigravity_cli";
   return kind || "claude_cli";
 }
 function firstCatalogModelId(backendKind) {
@@ -25567,18 +26307,18 @@ ${runtimeConfig.task}` } : {}
           `[base-machine-agent] Transient error (attempt ${attempt + 1}/${_BaseMachineAgent.MAX_RETRIES + 1}), retrying in ${delayMs}ms: ${lastResult.error}`
         );
         void this.presenter.onLog(`Transient error, retrying in ${Math.round(delayMs / 1e3)}s...`);
-        await new Promise((resolve22) => {
+        await new Promise((resolve42) => {
           const signal = this.abortController?.signal;
           if (signal?.aborted) {
-            resolve22();
+            resolve42();
             return;
           }
-          const timeoutId = setTimeout(resolve22, delayMs);
+          const timeoutId = setTimeout(resolve42, delayMs);
           signal?.addEventListener(
             "abort",
             () => {
               clearTimeout(timeoutId);
-              resolve22();
+              resolve42();
             },
             { once: true }
           );
@@ -25748,14 +26488,14 @@ function normalizePath2(candidate, cwd) {
   } catch {
   }
   if (path.startsWith("~/")) return null;
-  if ((0, import_path9.isAbsolute)(path)) return path;
-  return cwd ? (0, import_path9.join)(cwd, path) : null;
+  if ((0, import_path11.isAbsolute)(path)) return path;
+  return cwd ? (0, import_path11.join)(cwd, path) : null;
 }
 function resolveToolCwd(cwd, toolInput) {
   if (!isRecord(toolInput)) return cwd;
   const raw = typeof toolInput.cwd === "string" ? toolInput.cwd : typeof toolInput.workdir === "string" ? toolInput.workdir : typeof toolInput.workingDirectory === "string" ? toolInput.workingDirectory : null;
   if (!raw) return cwd;
-  return (0, import_path9.isAbsolute)(raw) || !cwd ? raw : (0, import_path9.join)(cwd, raw);
+  return (0, import_path11.isAbsolute)(raw) || !cwd ? raw : (0, import_path11.join)(cwd, raw);
 }
 function extractBrowserMediaPathHints(content, cwd, toolName, options = {}, kind = "video") {
   if (!isAgentBrowserMediaInvocation(toolName, content, options.toolInput, kind)) return [];
@@ -25798,19 +26538,19 @@ function extractGeneratedImagesFromToolResult(toolId, content, cwd, toolName, op
   const effectiveCwd = resolveToolCwd(cwd, options.toolInput);
   for (const candidate of extractPathCandidates(content, options)) {
     const path = normalizePath2(candidate, effectiveCwd);
-    if (!path || seen.has(path) || !(0, import_fs9.existsSync)(path)) continue;
+    if (!path || seen.has(path) || !(0, import_fs11.existsSync)(path)) continue;
     seen.add(path);
-    const ext = (0, import_path9.extname)(path).toLowerCase();
+    const ext = (0, import_path11.extname)(path).toLowerCase();
     const mimeType = IMAGE_MIME_BY_EXT[ext];
     if (!mimeType) continue;
-    const stat = (0, import_fs9.statSync)(path);
+    const stat = (0, import_fs11.statSync)(path);
     if (!stat.isFile() || stat.size <= 0 || stat.size > MAX_GENERATED_IMAGE_BYTES) continue;
-    const buffer = (0, import_fs9.readFileSync)(path);
+    const buffer = (0, import_fs11.readFileSync)(path);
     const { width, height } = readImageDimensions2(buffer, mimeType);
     images.push({
       type: "generated_image",
       id: (0, import_crypto4.randomUUID)(),
-      filename: (0, import_path9.basename)(path),
+      filename: (0, import_path11.basename)(path),
       mimeType,
       size: buffer.length,
       width,
@@ -25837,20 +26577,20 @@ function extractSessionMediaFromToolResult(toolId, content, cwd, toolName, optio
   const mimeByExt = kind === "video" ? VIDEO_MIME_BY_EXT : IMAGE_MIME_BY_EXT;
   for (const candidate of extractPathCandidates(content, options, extensionsPattern)) {
     const path = normalizePath2(candidate, effectiveCwd);
-    if (!path || seen.has(path) || !(0, import_fs9.existsSync)(path)) continue;
+    if (!path || seen.has(path) || !(0, import_fs11.existsSync)(path)) continue;
     seen.add(path);
-    const ext = (0, import_path9.extname)(path).toLowerCase();
+    const ext = (0, import_path11.extname)(path).toLowerCase();
     const mimeType = mimeByExt[ext];
     if (!mimeType) continue;
-    const stat = (0, import_fs9.statSync)(path);
+    const stat = (0, import_fs11.statSync)(path);
     if (!stat.isFile() || stat.size <= 0 || stat.size > maxBytes) continue;
-    const buffer = (0, import_fs9.readFileSync)(path);
+    const buffer = (0, import_fs11.readFileSync)(path);
     const dimensions = kind === "image" ? readImageDimensions2(buffer, mimeType) : null;
     media.push({
       type: "session_media",
       kind,
       id: (0, import_crypto4.randomUUID)(),
-      filename: (0, import_path9.basename)(path),
+      filename: (0, import_path11.basename)(path),
       mimeType,
       size: buffer.length,
       width: dimensions?.width,
@@ -25896,6 +26636,14 @@ var MCP_INSPECTION_PLANS = {
     args: ["mcp", "list"],
     updateGuidance: "Update OpenCode CLI",
     requireExpectedUrl: false
+  },
+  opencode_serve: {
+    backendKind: "opencode_serve",
+    providerLabel: "OpenCode CLI",
+    command: "opencode",
+    args: ["mcp", "list"],
+    updateGuidance: "Update OpenCode CLI",
+    requireExpectedUrl: false
   }
 };
 var UNSUPPORTED_COMMAND_PATTERN = /unknown (?:command|subcommand)|unrecognized (?:command|subcommand)|unexpected argument|invalid command|not a recognized command/i;
@@ -26065,8 +26813,8 @@ async function withTimeout(promise2, timeoutMs, fallback) {
   try {
     return await Promise.race([
       promise2,
-      new Promise((resolve7) => {
-        timer = setTimeout(() => resolve7(fallback), timeoutMs);
+      new Promise((resolve9) => {
+        timer = setTimeout(() => resolve9(fallback), timeoutMs);
       })
     ]);
   } finally {
@@ -26079,7 +26827,7 @@ async function collectCodexLimits(env) {
   const codexCommand = resolveExecutable("codex", runtimeEnv, "ALAN_CODEX_PATH");
   if (!codexCommand)
     return [];
-  return withTimeout(new Promise((resolve7) => {
+  return withTimeout(new Promise((resolve9) => {
     const child = (0, import_node_child_process2.spawn)(codexCommand, ["-s", "read-only", "-a", "untrusted", "app-server"], {
       env: runtimeEnv,
       stdio: ["pipe", "pipe", "ignore"]
@@ -26091,7 +26839,7 @@ async function collectCodexLimits(env) {
       pending.clear();
       if (!child.killed)
         child.kill();
-      resolve7(windows);
+      resolve9(windows);
     };
     const request = (method, params = {}) => {
       const id = nextId++;
@@ -28924,9 +29672,9 @@ var Socket2 = class extends Emitter {
    * @return a Promise that will be fulfilled when the server acknowledges the event
    */
   emitWithAck(ev, ...args) {
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve9, reject) => {
       const fn = (arg1, arg2) => {
-        return arg1 ? reject(arg1) : resolve7(arg2);
+        return arg1 ? reject(arg1) : resolve9(arg2);
       };
       fn.withError = true;
       args.push(fn);
@@ -31066,7 +31814,9 @@ var INSTALLABLE_PROVIDER_PACKAGES = {
   claude_cli: { npmPackage: "@anthropic-ai/claude-code", command: "claude", label: "Claude Code" },
   codex_app_server: { npmPackage: "@openai/codex", command: "codex", label: "Codex" },
   copilot_cli: { npmPackage: "@github/copilot", command: "copilot", label: "Copilot" },
-  opencode_cli: { npmPackage: "opencode-ai", command: "opencode", label: "opencode" }
+  opencode_cli: { npmPackage: "opencode-ai", command: "opencode", label: "opencode" },
+  // Server transport installs the same "opencode" binary.
+  opencode_serve: { npmPackage: "opencode-ai", command: "opencode", label: "opencode" }
 };
 var INSTALL_TIMEOUT_MS = 12e4;
 var installOutcomes = /* @__PURE__ */ new Map();
@@ -31085,7 +31835,7 @@ function pinnedVersion(npmPackage) {
   return "latest";
 }
 function runNpmInstall(installSpec, env, timeoutMs) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve9) => {
     const isWin = (0, import_node_os5.platform)() === "win32";
     let child;
     try {
@@ -31097,7 +31847,7 @@ function runNpmInstall(installSpec, env, timeoutMs) {
         stdio: ["ignore", "pipe", "pipe"]
       });
     } catch (error2) {
-      resolve7({ status: null, stdout: "", stderr: "", error: error2 });
+      resolve9({ status: null, stdout: "", stderr: "", error: error2 });
       return;
     }
     let stdout = "";
@@ -31108,10 +31858,10 @@ function runNpmInstall(installSpec, env, timeoutMs) {
     child.stderr?.setEncoding("utf8").on("data", (chunk) => {
       stderr += chunk;
     });
-    child.once("error", (error2) => resolve7({ status: null, stdout, stderr, error: error2 }));
+    child.once("error", (error2) => resolve9({ status: null, stdout, stderr, error: error2 }));
     child.once(
       "close",
-      (status, signal) => resolve7({
+      (status, signal) => resolve9({
         status,
         stdout,
         stderr,
@@ -45268,7 +46018,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve7) => setTimeout(resolve7, pollInterval));
+        await new Promise((resolve9) => setTimeout(resolve9, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -45285,7 +46035,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve9, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -45363,7 +46113,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve7(parseResult.data);
+            resolve9(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -45624,12 +46374,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve9, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve7, interval);
+      const timeoutId = setTimeout(resolve9, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -47978,7 +48728,7 @@ function skipVoid(str, ptr, banNewLines, banComments) {
   }
   return ptr;
 }
-function skipUntil(str, ptr, sep3, end, banNewLines = false) {
+function skipUntil(str, ptr, sep4, end, banNewLines = false) {
   if (!end) {
     ptr = indexOfNewline(str, ptr);
     return ptr < 0 ? str.length : ptr;
@@ -47987,7 +48737,7 @@ function skipUntil(str, ptr, sep3, end, banNewLines = false) {
     let c = str[i];
     if (c === "#") {
       i = indexOfNewline(str, i);
-    } else if (c === sep3) {
+    } else if (c === sep4) {
       return i + 1;
     } else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i + 1] === "\n")) {
       return i;
@@ -48716,7 +49466,7 @@ async function waitForConfigLock(lockPath) {
       if (Date.now() - startedAt >= CONFIG_LOCK_WAIT_MS) {
         throw new Error(`Alan could not safely update ${lockPath.slice(0, -".alan-lock".length)}`);
       }
-      await new Promise((resolve7) => setTimeout(resolve7, CONFIG_LOCK_POLL_MS));
+      await new Promise((resolve9) => setTimeout(resolve9, CONFIG_LOCK_POLL_MS));
     }
   }
 }
@@ -48740,10 +49490,11 @@ function parseJsonObject2(path, content) {
   );
 }
 function mergeJsonConfig(path, existingContent, desiredContent) {
-  if (existingContent !== null) {
-    parseJsonObject2(path, existingContent);
+  const normalizedExisting = existingContent?.trim() ? existingContent : null;
+  if (normalizedExisting !== null) {
+    parseJsonObject2(path, normalizedExisting);
   }
-  return mergeAlanMcpJsonConfig(existingContent, desiredContent);
+  return mergeAlanMcpJsonConfig(normalizedExisting, desiredContent);
 }
 function assertValidExistingToml(path, content) {
   try {
@@ -49031,6 +49782,10 @@ function readAlanMcpRegistration(path) {
       const url4 = normalizeHttpUrl(server.httpUrl);
       return url4 ? { url: url4, headers } : null;
     }
+    if (path.endsWith("/.gemini/config/mcp_config.json")) {
+      const url4 = normalizeHttpUrl(server.serverUrl);
+      return url4 ? { url: url4, headers } : null;
+    }
     const url3 = server.type === "http" ? normalizeHttpUrl(server.url) : null;
     return url3 ? { url: url3, headers } : null;
   } catch {
@@ -49089,7 +49844,7 @@ function failureFromError(error2, paths) {
   };
 }
 async function waitBeforeRetry() {
-  await new Promise((resolve7) => setTimeout(resolve7, RETRY_DELAY_MS2));
+  await new Promise((resolve9) => setTimeout(resolve9, RETRY_DELAY_MS2));
 }
 async function probeAlanMcpReadiness(registration, options = {}) {
   const paths = options.paths ?? [];
@@ -49630,11 +50385,25 @@ function parseOpenCodeVerboseModelOutput(text) {
   }
   return entries;
 }
+function extractOpenCodeModelCapabilitiesFromVerboseOutput(text) {
+  return parseOpenCodeVerboseModelOutput(text).filter((entry) => entry.id.startsWith("opencode/")).map((entry) => ({
+    id: entry.id,
+    variants: entry.reasoning ? entry.variants.filter((variant) => {
+      const trimmed = variant.trim();
+      return Boolean(trimmed) && trimmed.length <= 256 && !Array.from(trimmed).some((character) => {
+        const code = character.charCodeAt(0);
+        return code <= 31 || code === 127;
+      });
+    }) : []
+  }));
+}
 function extractOpenCodeDiscoveredModelIdsFromVerboseOutput(text) {
-  const entries = parseOpenCodeVerboseModelOutput(text);
+  const entries = extractOpenCodeModelCapabilitiesFromVerboseOutput(text);
   const ids = [];
   for (const entry of entries) {
-    const knownVariants = entry.reasoning ? entry.variants.filter((variant) => OPENCODE_KNOWN_VARIANT_KEYS.has(variant)) : [];
+    const knownVariants = entry.variants.filter(
+      (variant) => OPENCODE_KNOWN_VARIANT_KEYS.has(variant)
+    );
     if (knownVariants.length === 0) {
       ids.push(entry.id);
       continue;
@@ -49720,7 +50489,8 @@ function extractClaudeModelIdsFromExecutable(executable) {
   }
 }
 function getCatalogModelIds(provider) {
-  return [...CATALOG_MODEL_IDS_BY_PROVIDER[provider] ?? []];
+  const catalogProvider = provider === "opencode_serve" ? "opencode_cli" : provider;
+  return [...CATALOG_MODEL_IDS_BY_PROVIDER[catalogProvider] ?? []];
 }
 function withModelProbeEnv(env) {
   const term = env.TERM;
@@ -49810,14 +50580,14 @@ async function discoverGenericModels(executable, env) {
 }
 var CATALOG_ONLY_PROVIDERS = /* @__PURE__ */ new Set(["supatest_cli", "droid_cli", "copilot_cli"]);
 function supportsProviderModelDiscovery(provider) {
-  return provider in CATALOG_MODEL_IDS_BY_PROVIDER;
+  return provider === "opencode_serve" || provider in CATALOG_MODEL_IDS_BY_PROVIDER;
 }
 async function discoverProviderModels(provider, executable, env) {
   if (CATALOG_ONLY_PROVIDERS.has(provider)) {
     return getCatalogModelIds(provider);
   }
   let probed = [];
-  if (provider === "opencode_cli") {
+  if (provider === "opencode_cli" || provider === "opencode_serve") {
     probed = await discoverOpenCodeModels(executable, env);
   } else if (provider === "antigravity_cli") {
     probed = await discoverAntigravityModels(executable, env);
@@ -50003,8 +50773,8 @@ var RunStartGate = class {
   async acquire() {
     const previous = this.tail;
     let releaseCurrent;
-    const current = new Promise((resolve7) => {
-      releaseCurrent = resolve7;
+    const current = new Promise((resolve9) => {
+      releaseCurrent = resolve9;
     });
     this.tail = previous.then(() => current);
     await previous;
@@ -50331,7 +51101,7 @@ var SuspensionDetector = class {
 };
 
 // src/version.ts
-var AGENT_VERSION = "0.1.53";
+var AGENT_VERSION = "0.1.54";
 
 // src/workspace-relocation.ts
 var import_node_child_process6 = require("child_process");
@@ -52037,11 +52807,10 @@ function getLocalApiPort(args, stored) {
 }
 function sleep(ms) {
   if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 function normalizeBackendKind2(backendKind) {
   if (backendKind === "codex") return "codex_app_server";
-  if (backendKind === "gemini" || backendKind === "gemini_cli") return "antigravity_cli";
   return backendKind;
 }
 function providerModelCacheKey(provider, executable) {
@@ -52776,7 +53545,7 @@ async function setupDaemon(args) {
     }
     const retriableStatus = response && (response.status === 408 || response.status === 429 || response.status >= 500);
     if (response && (!retriableStatus || response.ok) || attempt === 3) break;
-    await new Promise((resolve7) => setTimeout(resolve7, attempt * 100));
+    await new Promise((resolve9) => setTimeout(resolve9, attempt * 100));
   }
   if (!response) {
     const detail = transportError instanceof Error ? transportError.message : String(transportError);
@@ -53145,7 +53914,11 @@ async function startDaemon(args) {
         try {
           response = await fetch(`${stored.apiUrl}/public/runtimes/${runtimeId}/tokens/renew`, {
             method: "POST",
-            headers: { authorization: `Bearer ${runtimeRenewalToken}` },
+            headers: {
+              authorization: `Bearer ${runtimeRenewalToken}`,
+              "content-type": "application/json"
+            },
+            body: "{}",
             signal: AbortSignal.timeout(1e4)
           });
           transportError = null;
@@ -54297,7 +55070,7 @@ async function startDaemon(args) {
       `${describeOccupiedLocalDaemon(localApiPort)} The token in ${getConfigPath()} no longer matches the running daemon; quit Alan desktop or run setup again.`
     );
   }
-  const localApiListening = new Promise((resolve7, reject) => {
+  const localApiListening = new Promise((resolve9, reject) => {
     const onError = (error2) => {
       clearInterval(heartbeat);
       clearInterval(versionRefresh);
@@ -54327,7 +55100,7 @@ async function startDaemon(args) {
       if (address && typeof address === "object") localApiPort = address.port;
       pushLog(`local_api listening port=${localApiPort}`);
       console.info("[alan-agent] Local daemon API listening", { port: localApiPort });
-      resolve7();
+      resolve9();
     });
   });
   try {
@@ -54347,7 +55120,7 @@ async function startDaemon(args) {
     clearInterval(workspaceLeaseMonitor);
     suspensionDetector.stop();
     socket.disconnect();
-    await new Promise((resolve7) => localServer.close(() => resolve7()));
+    await new Promise((resolve9) => localServer.close(() => resolve9()));
     releaseOwnerLease();
     releaseStartupLease();
     throw error2;
@@ -54367,8 +55140,8 @@ async function startDaemon(args) {
       }
       activeAgents.clear();
       socket.disconnect();
-      await new Promise((resolve7) => {
-        localServer.close(() => resolve7());
+      await new Promise((resolve9) => {
+        localServer.close(() => resolve9());
       });
     } finally {
       sleepInhibitor.dispose();
@@ -55313,9 +56086,9 @@ var WSClient = class {
     });
   }
   waitForConnection(timeoutMs = 15e3) {
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve9, reject) => {
       if (this.socket.connected) {
-        resolve7();
+        resolve9();
         return;
       }
       const timeout = setTimeout(
@@ -55324,7 +56097,7 @@ var WSClient = class {
       );
       this.socket.once("connect", () => {
         clearTimeout(timeout);
-        resolve7();
+        resolve9();
       });
       this.socket.once("connect_error", (err) => {
         clearTimeout(timeout);
@@ -55506,9 +56279,9 @@ async function runSandbox(config2) {
       onUserMessage: (payload) => {
         if (payload === null) {
           if (pendingMessageResolve) {
-            const resolve7 = pendingMessageResolve;
+            const resolve9 = pendingMessageResolve;
             pendingMessageResolve = null;
-            resolve7(null);
+            resolve9(null);
           }
           return;
         }
@@ -55530,9 +56303,9 @@ async function runSandbox(config2) {
           fileCount: payload.files?.length ?? 0
         });
         if (pendingMessageResolve) {
-          const resolve7 = pendingMessageResolve;
+          const resolve9 = pendingMessageResolve;
           pendingMessageResolve = null;
-          resolve7(payload);
+          resolve9(payload);
         } else {
           queuedMessages.push(payload);
         }
@@ -55751,8 +56524,8 @@ async function runSandbox(config2) {
       });
       if (stopped) break;
     }
-    const nextPayload = queuedMessages.shift() ?? await new Promise((resolve7) => {
-      pendingMessageResolve = resolve7;
+    const nextPayload = queuedMessages.shift() ?? await new Promise((resolve9) => {
+      pendingMessageResolve = resolve9;
     });
     if (nextPayload === null || stopped) {
       break;