@sagentlab/navarch-runtime 0.1.106 → 0.1.111

package/dist/adapters/antigravity.cjs

@@ -0,0 +1,348 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.antigravityAdapter = exports.ANTIGRAVITY_PROCESS_WRAPPER = void 0;
+exports.runAntigravityAdapter = runAntigravityAdapter;
+exports.normalizeAntigravityOutput = normalizeAntigravityOutput;
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = __importDefault(require("node:path"));
+const node_string_decoder_1 = require("node:string_decoder");
+const config_cjs_1 = require("../config.cjs");
+const kill_agent_cjs_1 = require("../kill-agent.cjs");
+const antigravity_mcp_cjs_1 = require("./antigravity-mcp.cjs");
+/** Documented agy 1.3.1 contract, not Gemini CLI's similarly named format.
+ * https://antigravity.google/docs/cli/headless/
+ * https://antigravity.google/docs/changelog (1.1.27, 1.1.28, 1.2.6, 1.2.10)
+ * One stdin user event + EOF per process; later lease-local turns may resume
+ * only the exact validated AG conversation. No interactive approval protocol.
+ */
+async function runAntigravityAdapter(options) {
+    if (options.signal?.aborted)
+        return failure("", { killedByLeaseLoss: true, exitCode: null });
+    if (options.antigravityHostGuard && !options.dockerExec)
+        return failure(config_cjs_1.ANTIGRAVITY_HOST_GUARD_MESSAGE);
+    if (!options.cwd || !node_path_1.default.isAbsolute(options.cwd))
+        return failure("Antigravity requires an absolute session working directory.");
+    const args = antigravityArgs(options);
+    if (typeof args === "string")
+        return failure(args);
+    const started = performance.now();
+    // --version is local and does not start a model turn or sign in. Require the
+    // verified contract rather than inheriting older silent-success behavior.
+    const version = await runProcess({ ...options, timeoutMs: options.timeoutMs > 0 ? Math.min(options.timeoutMs, 10_000) : 10_000, env: agentEnvironment(options.env), onOutput: undefined, onActivity: undefined }, ["--version"], "");
+    if (version.exitCode !== 0 || version.timedOut || version.killedByLeaseLoss)
+        return version;
+    const match = /\b(\d+)\.(\d+)\.(\d+)\b/.exec(version.stdout);
+    const current = match ? match.slice(1).map(Number) : [];
+    if (current.length !== 3 || (current[0] < 1) || (current[0] === 1 && (current[1] < 3 || (current[1] === 3 && current[2] < 1)))) {
+        return failure("Antigravity CLI 1.3.1 or later is required. Verify the official agy installation with agy --version.");
+    }
+    if (options.signal?.aborted)
+        return failure("", { killedByLeaseLoss: true, exitCode: null });
+    const remaining = options.timeoutMs > 0 ? options.timeoutMs - (performance.now() - started) : 0;
+    if (options.timeoutMs > 0 && remaining <= 0)
+        return failure("Antigravity startup exceeded the session deadline.", { timedOut: true, exitCode: null });
+    let mcp;
+    let raw = failure("Antigravity did not start.");
+    try {
+        mcp = await (0, antigravity_mcp_cjs_1.prepareAntigravityMcp)(options);
+        const turnRemaining = options.timeoutMs > 0 ? options.timeoutMs - (performance.now() - started) : 0;
+        if (options.timeoutMs > 0 && turnRemaining <= 0)
+            raw = failure("Antigravity setup exceeded the session deadline.", { timedOut: true, exitCode: null });
+        else if (options.signal?.aborted)
+            raw = failure("", { killedByLeaseLoss: true, exitCode: null });
+        else
+            raw = await runProcess({ ...options, timeoutMs: turnRemaining,
+                env: agentEnvironment(options.env),
+            }, args, `${JSON.stringify({ event: "user", message: { content: options.prompt } })}\n`);
+    }
+    catch {
+        // Configuration and network errors can contain bearer values. Diagnostics
+        // identify the phase only; source values are never copied into a report.
+        raw = failure("Antigravity MCP setup failed. The workspace must allow a new .agents/mcp_config.json; existing files and symlinks are never overwritten, and a repository-local .gitignore must ignore .agents/mcp_config.json. Check the lease MCP configuration and use an isolated session directory.");
+    }
+    finally {
+        if (mcp) {
+            try {
+                await mcp.close();
+            }
+            catch {
+                raw = { ...raw, exitCode: raw.exitCode === 0 ? 1 : raw.exitCode, stderr: `${raw.stderr}\nAntigravity MCP cleanup could not be verified; session failed closed.` };
+            }
+        }
+    }
+    if (mcp?.failed()) {
+        raw = { ...raw, exitCode: 1, stderr: `${raw.stderr}\nAntigravity lease MCP relay failed.` };
+    }
+    return normalizeAntigravityOutput(raw, options);
+}
+function agentEnvironment(env) {
+    const out = {};
+    for (const [name, value] of Object.entries(env)) {
+        if (typeof value === "string" && !name.startsWith("NAVARCH_OPENCODE_MCP_") && !name.startsWith("NAVARCH_AGY_MCP_") && !["NAVARCH_MACHINE_TOKEN", "NAVARCH_ENROLLMENT_SECRET", "NAVARCH_ENROLLMENT_TOKEN"].includes(name))
+            out[name] = value;
+    }
+    return out;
+}
+function failure(stderr, overrides = {}) {
+    return { exitCode: 1, timedOut: false, killedByLeaseLoss: false, stdout: "", stderr, ...overrides };
+}
+/** Extra args are deliberately bounded: no prompt/protocol/timeout/session overrides. */
+function antigravityArgs(options) {
+    const args = ["--input-format", "stream-json", "--output-format", "stream-json"];
+    const valueFlags = new Set(["--agent", "--model", "--effort"]);
+    const boolFlags = new Set(["--sandbox", "--dangerously-skip-permissions"]);
+    const values = new Map();
+    for (let i = 0; i < options.extraArgs.length; i++) {
+        const token = options.extraArgs[i];
+        const eq = token.indexOf("=");
+        const name = eq >= 0 ? token.slice(0, eq) : token;
+        if (valueFlags.has(name)) {
+            const value = eq >= 0 ? token.slice(eq + 1) : options.extraArgs[++i];
+            if (!value || value.startsWith("-") || values.has(name))
+                return "Antigravity extra arguments contain a missing or duplicate value.";
+            values.set(name, value);
+        }
+        else if (boolFlags.has(name) && eq < 0) {
+            if (args.includes(name))
+                return "Antigravity extra arguments contain a duplicate flag.";
+            args.push(name);
+        }
+        else {
+            return "Unsupported Antigravity extra argument. Only --agent, --model, --effort, --sandbox and --dangerously-skip-permissions are allowed; Navarch owns input/output, timeout and conversation identity.";
+        }
+    }
+    const model = options.model && options.model !== "default" ? options.model : values.get("--model");
+    if (values.has("--model") && options.model && options.model !== "default" && values.get("--model") !== options.model)
+        return "Antigravity model arguments conflict with the selected execution model.";
+    if (model)
+        values.set("--model", model);
+    const effort = options.reasoningEffort ?? values.get("--effort");
+    if (effort) {
+        if (!["low", "medium", "high"].includes(effort))
+            return "Antigravity supports low, medium or high reasoning effort only.";
+        if (values.has("--effort") && values.get("--effort") !== effort)
+            return "Antigravity reasoning effort arguments conflict.";
+        values.set("--effort", effort);
+    }
+    for (const [name, value] of values)
+        args.push(name, value);
+    const resume = options.antigravityResume;
+    if (resume) {
+        if (resume.provider !== "antigravity" || !validId(resume.conversationId) || resume.cwd !== node_path_1.default.resolve(options.cwd) || resume.model !== (model ?? "default") || !metric(resume.numTurns) || resume.numTurns < 1) {
+            return "Antigravity resume identity does not match this provider, workspace and model. Start a new session explicitly.";
+        }
+        args.push("--conversation", resume.conversationId);
+    }
+    return args;
+}
+function object(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validId(value) {
+    return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9_-]{0,199}$/.test(value);
+}
+function metric(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function hasDeniedActions(value) {
+    // The changelog specifies the field but not an item schema. Empty array is
+    // the only explicit no-denial value; unknown shapes fail closed.
+    return "denied_actions" in value && (!Array.isArray(value.denied_actions) || value.denied_actions.length > 0);
+}
+/** Require one complete, well-formed turn. OS exit 0 alone never means success. */
+function normalizeAntigravityOutput(raw, options) {
+    if (raw.killedByLeaseLoss || raw.timedOut || raw.exitCode === null)
+        return raw;
+    let id;
+    let result;
+    let invalid = false;
+    let denied = false;
+    for (const line of raw.stdout.split(/\r?\n/).filter((line) => line.trim())) {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            invalid = true;
+            continue;
+        }
+        if (!object(event) || result) {
+            invalid = true;
+            continue;
+        }
+        denied ||= hasDeniedActions(event);
+        if (event.event === "init") {
+            if (id || !validId(event.conversation_id) || !object(event.init))
+                invalid = true;
+            else
+                id = event.conversation_id;
+        }
+        else if (event.event === "step_update") {
+            const step = event.step_update;
+            if (!id || !object(step) || step.conversation_id !== id || !metric(step.step_index) || !["ACTIVE", "DONE"].includes(String(step.state)) || typeof step.step_type !== "string" || ("text_delta" in step && typeof step.text_delta !== "string"))
+                invalid = true;
+            if (object(step)) {
+                denied ||= hasDeniedActions(step);
+                if (object(step.tool_info) && object(step.tool_info.error)) {
+                    const error = step.tool_info.error;
+                    denied ||= /permission|denied|approval|refused/i.test(`${String(error.type ?? "")} ${String(error.message ?? "")}`);
+                }
+            }
+        }
+        else if (event.event === "result" && object(event.result)) {
+            result = event.result;
+            denied ||= hasDeniedActions(result);
+        }
+        else
+            invalid = true;
+    }
+    const diagnosticFailure = /^\s*AGY_ERROR\s*:/m.test(raw.stderr)
+        || /(?:soft[- ]denied|permission[^\n]*(?:denied|required)|(?:denied|refused)[^\n]*(?:action|tool)|not permitted|print-timeout|(?:timeout|timed out)[^\n]*(?:partial|response)|partial[^\n]*(?:timeout|timed out))/i.test(raw.stderr);
+    const previous = options.antigravityResume;
+    if (!result || !id || result.conversation_id !== id || typeof result.response !== "string" || !metric(result.num_turns) || result.num_turns < 1)
+        invalid = true;
+    if (result && "error" in result && typeof result.error !== "string")
+        invalid = true;
+    if (previous && (id !== previous.conversationId || result?.num_turns !== previous.numTurns + 1))
+        invalid = true;
+    if (!previous && result?.num_turns !== 1)
+        invalid = true;
+    const out = { ...raw };
+    const usage = result && object(result.usage) ? result.usage : undefined;
+    const totalIn = usage && metric(usage.input_tokens) ? usage.input_tokens : undefined;
+    const totalOut = usage && metric(usage.output_tokens) ? usage.output_tokens : undefined;
+    // Resume counters are cumulative. Never sum the whole historical bill again.
+    if (!invalid) {
+        if (totalIn !== undefined && (!previous || previous.tokensIn !== undefined)) {
+            const delta = totalIn - (previous?.tokensIn ?? 0);
+            if (delta < 0)
+                invalid = true;
+            else
+                out.tokensIn = delta;
+        }
+        if (totalOut !== undefined && (!previous || previous.tokensOut !== undefined)) {
+            const delta = totalOut - (previous?.tokensOut ?? 0);
+            if (delta < 0)
+                invalid = true;
+            else
+                out.tokensOut = delta;
+        }
+    }
+    // Vendor docs do not establish cached-token inclusion consistently. Keep
+    // the raw input/output measures; neither fabricate USD nor a cache split.
+    const succeeded = raw.exitCode === 0 && !invalid && !denied && !diagnosticFailure && result?.status === "SUCCESS" && !(typeof result.error === "string" && result.error);
+    if (!succeeded) {
+        out.exitCode = raw.exitCode === 0 ? 1 : raw.exitCode;
+        const detail = denied ? "A required action was denied by Antigravity permission policy."
+            : invalid ? "Antigravity returned an invalid, incomplete or mismatched event stream."
+                : diagnosticFailure ? "Antigravity reported a CLI error, permission denial or partial timeout."
+                    : `Antigravity did not complete successfully (status ${typeof result?.status === "string" ? result.status : "missing"}).`;
+        out.stderr = `${raw.stderr}\n${detail}`.trim();
+        // Only structured CLI errors and CLI stderr participate, never assistant prose.
+        const cliError = `${typeof result?.error === "string" ? result.error : ""}\n${raw.stderr}`;
+        if (/RESOURCE_EXHAUSTED|\brate[ _-]+limit|too many requests/i.test(cliError)) {
+            out.capacityError = "Antigravity rate limit or provider capacity exhausted; retry after the machine cooldown.";
+        }
+        if (/authentication required|not logged in|unauthenticated|please.*(?:login|sign in)/i.test(cliError)) {
+            out.authError = "Antigravity authentication is required. Authenticate agy interactively on this machine; Gemini CLI credentials are not reused.";
+        }
+        return out;
+    }
+    out.reportText = String(result.response).trim();
+    const modelArg = options.extraArgs.findIndex((arg) => arg === "--model");
+    const extraModel = modelArg >= 0 ? options.extraArgs[modelArg + 1] : options.extraArgs.find((arg) => arg.startsWith("--model="))?.slice(8);
+    out.antigravityResume = {
+        provider: "antigravity", conversationId: id, cwd: node_path_1.default.resolve(options.cwd),
+        model: options.model && options.model !== "default" ? options.model : extraModel ?? "default",
+        numTurns: result.num_turns, tokensIn: totalIn, tokensOut: totalOut,
+    };
+    return out;
+}
+async function runProcess(options, args, input) {
+    if (options.dockerExec)
+        return runDocker(options, args, input);
+    return new Promise((resolve) => {
+        let stdout = "", stderr = "", timedOut = false, killedByLeaseLoss = false;
+        const stdoutDecoder = new node_string_decoder_1.StringDecoder("utf8"), stderrDecoder = new node_string_decoder_1.StringDecoder("utf8");
+        const child = (0, node_child_process_1.spawn)(options.bin, args, { cwd: options.cwd, detached: process.platform !== "win32", env: agentEnvironment({ ...process.env, ...options.env }) });
+        child.stdin?.on("error", () => undefined);
+        child.stdin?.end(input);
+        options.onProcessStarted?.(child.pid);
+        let escalation;
+        const stop = () => {
+            (0, kill_agent_cjs_1.killAgent)(child, "SIGINT");
+            escalation ??= setTimeout(() => (0, kill_agent_cjs_1.killAgent)(child), 1_000);
+        };
+        const timer = options.timeoutMs > 0 ? setTimeout(() => { timedOut = true; stop(); }, options.timeoutMs) : undefined;
+        const onAbort = () => { killedByLeaseLoss = true; stop(); };
+        options.signal?.addEventListener("abort", onAbort, { once: true });
+        if (options.signal?.aborted)
+            onAbort();
+        child.stdout.on("data", (chunk) => { const text = stdoutDecoder.write(chunk); stdout += text; options.onActivity?.(); options.onOutput?.("stdout", text); });
+        child.stderr.on("data", (chunk) => { const text = stderrDecoder.write(chunk); stderr += text; options.onActivity?.(); options.onOutput?.("stderr", text); });
+        let settled = false;
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            clearTimeout(escalation);
+            options.signal?.removeEventListener("abort", onAbort);
+            // Stop the owned process group even when agy exits before its tools.
+            (0, kill_agent_cjs_1.killAgent)(child);
+            stdout += stdoutDecoder.end();
+            stderr += stderrDecoder.end();
+            resolve({ exitCode: code, timedOut, killedByLeaseLoss, stdout, stderr });
+        };
+        child.on("error", () => { stderr += "\nAntigravity process could not be started; check NAVARCH_ANTIGRAVITY_BIN."; finish(null); });
+        child.on("exit", () => (0, kill_agent_cjs_1.killAgent)(child));
+        child.on("close", finish);
+    });
+}
+/** Node is already required by the MCP relay. A separate process group also
+ * prevents redirected-stdio background tools outliving a successful Docker turn. */
+exports.ANTIGRAVITY_PROCESS_WRAPPER = `const{spawn}=require('node:child_process');const c=spawn(process.argv[1],process.argv.slice(2),{detached:process.platform!=='win32',stdio:['pipe','inherit','inherit']});let timer;function kill(signal='SIGKILL'){try{if(c.pid&&process.platform!=='win32'){process.kill(-c.pid,signal);return;}}catch{}c.kill(signal);}c.stdin.on('error',()=>{});process.stdin.pipe(c.stdin);for(const signal of ['SIGINT','SIGTERM'])process.on(signal,()=>{kill(signal);timer??=setTimeout(()=>kill(),1000);});c.on('exit',()=>kill());c.on('error',()=>{process.stderr.write('Antigravity process could not start\\n');process.exitCode=1;process.stdin.destroy();});c.on('close',(code)=>{clearTimeout(timer);kill();process.exitCode=code??1;process.stdin.destroy();});`;
+async function runDocker(options, args, input) {
+    const { containerName, runner } = options.dockerExec;
+    let killedByLeaseLoss = false, timedOut = false;
+    const abort = new AbortController();
+    let killing;
+    let killFailed = false;
+    const kill = () => {
+        abort.abort();
+        killing ??= runner.run("docker", ["kill", containerName], { timeoutMs: 10_000 })
+            .then((result) => { if (result.code !== 0)
+            killFailed = true; }, () => { killFailed = true; });
+    };
+    const onAbort = () => { killedByLeaseLoss = true; kill(); };
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    const timer = options.timeoutMs > 0 ? setTimeout(() => { timedOut = true; kill(); }, options.timeoutMs) : undefined;
+    if (options.signal?.aborted)
+        onAbort();
+    try {
+        if (abort.signal.aborted)
+            return failure("", { exitCode: null, timedOut, killedByLeaseLoss });
+        const command = `[ -f /tmp/session.env ] && . /tmp/session.env; cd ${quote(options.cwd)} && exec ${["node", "-e", exports.ANTIGRAVITY_PROCESS_WRAPPER, options.bin, ...args].map(quote).join(" ")}`;
+        const result = await runner.run("docker", ["exec", "-i", ...Object.keys(options.env).flatMap((name) => ["--env", name]), containerName, "sh", "-c", command], {
+            input, env: agentEnvironment({ ...process.env, ...options.env }), signal: abort.signal,
+            onActivity: options.onActivity, onStdout: (chunk) => options.onOutput?.("stdout", chunk), onStderr: (chunk) => options.onOutput?.("stderr", chunk),
+        });
+        await killing;
+        return { exitCode: result.code, timedOut, killedByLeaseLoss, stdout: result.stdout,
+            stderr: result.stderr + (killFailed ? "\nAntigravity container termination could not be verified." : "") };
+    }
+    catch {
+        await killing;
+        return failure(killFailed ? "Antigravity Docker process failed; container termination could not be verified." : "Antigravity Docker process failed.", { exitCode: null, timedOut, killedByLeaseLoss });
+    }
+    finally {
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", onAbort);
+        await killing;
+    }
+}
+function quote(value) { return `'${value.replace(/'/g, `'\\''`)}'`; }
+exports.antigravityAdapter = { agentType: "antigravity", run: runAntigravityAdapter };

package/dist/adapters/gemini.cjs

@@ -2,292 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.geminiAdapter = void 0;
 exports.runGeminiAdapter = runGeminiAdapter;
-const node_child_process_1 = require("node:child_process");
-const node_fs_1 = require("node:fs");
-const kill_agent_cjs_1 = require("../kill-agent.cjs");
-/**
- * Headless Google Gemini CLI adapter. Gemini's `stream-json` output gives the
- * same normalized boundary as the Claude and Codex adapters: raw process
- * signals plus an optional final report and token counts. Gemini CLI does not
- * report USD cost, so costUsd remains absent.
- *
- * The CLI reads MCP servers from settings rather than accepting Claude's
- * `--mcp-config` flag. The adapter converts the lease-scoped config into a
- * temporary system-settings file and restricts the run to those server names.
- *
- * The prompt arrives on stdin rather than `--prompt`: Gemini runs headlessly
- * whenever stdin is not a TTY and uses the piped text as the prompt. Its
- * native sandbox puts stdin back into argv, so that path still has Linux's
- * 128 KiB per-string limit. Gemini also caps stdin at 8 MiB.
- */
+/** Tombstone for stale claims. Provider IDs and credentials are never aliased. */
 async function runGeminiAdapter(options) {
-    if (options.signal?.aborted) {
-        return { exitCode: null, timedOut: false, killedByLeaseLoss: true, stdout: "", stderr: "" };
-    }
-    const promptBytes = Buffer.byteLength(options.prompt, "utf8");
-    // Gemini's readStdin() silently truncates at 8 MiB. Reject before any
-    // settings writes or process launch rather than execute a partial task.
-    if (promptBytes > 8 * 1024 * 1024) {
-        return inputFailure(`Gemini CLI stdin is limited to 8 MiB; the task prompt is ${promptBytes} bytes. Reduce the context bundle or select another runtime.`);
-    }
-    const args = [];
-    const env = { ...options.env };
-    if (!hasArg(options.extraArgs, "--output-format", "-o")) {
-        args.push("--output-format", "stream-json");
-    }
-    if (!hasArg(options.extraArgs, "--skip-trust")) {
-        args.push("--skip-trust");
-    }
-    if (!hasExplicitApprovalMode(options.extraArgs)) {
-        // Navarch sessions have no interactive operator. Host sessions still use
-        // Gemini's sandbox below when the worktree guard is enabled.
-        args.push("--approval-mode", "yolo");
-    }
-    const sandboxMounts = [...(options.geminiSandboxMounts ?? [])];
-    if (options.mcpConfigPath) {
-        const mcp = await prepareGeminiMcpSettings(options.mcpConfigPath, env);
-        env.GEMINI_CLI_SYSTEM_SETTINGS_PATH = mcp.settingsPath;
-        sandboxMounts.push(`${mcp.settingsPath}:${mcp.settingsPath}:ro`);
-        if (mcp.serverNames.length > 0 && !hasArg(options.extraArgs, "--allowed-mcp-server-names")) {
-            args.push("--allowed-mcp-server-names", mcp.serverNames.join(","));
-        }
-    }
-    if (!hasArg(options.extraArgs, "--sandbox", "-s")) {
-        if (options.geminiSandboxMounts) {
-            args.push("--sandbox");
-            env.SANDBOX_MOUNTS = sandboxMounts.join(",");
-        }
-        else {
-            // YOLO mode enables Gemini's own sandbox implicitly. Disable that
-            // nested sandbox when Navarch already supplied Docker isolation, or
-            // when an operator explicitly disabled the host worktree guard.
-            args.push("--sandbox=false");
-        }
-    }
-    args.push(...options.extraArgs);
-    if (options.model)
-        args.push("--model", options.model);
-    // Gemini's sandbox launcher reads stdin and injects it back into --prompt
-    // for its child process (packages/cli/src/gemini.tsx injectStdinIntoArgs).
-    // Moving our first spawn's prompt to stdin cannot fix that second spawn.
-    // Check the effective flag, including operator overrides, without disabling
-    // the worktree guard. Even on macOS a Docker sandbox may launch on Linux.
-    if (geminiSandboxEnabled(args) && promptBytes >= 128 * 1024) {
-        return inputFailure(`Gemini CLI re-encodes stdin as --prompt when launching its native sandbox; the ${promptBytes}-byte task prompt exceeds Linux's argv limit. Reduce the context bundle or select another runtime that supports large prompts in its sandbox.`);
-    }
-    const runOptions = { ...options, env };
-    const raw = runOptions.dockerExec
-        ? await runViaDocker(runOptions, args)
-        : await runOnHost(runOptions, args);
-    return attachGeminiOutput(raw);
-}
-function inputFailure(stderr) {
-    return { exitCode: 1, timedOut: false, killedByLeaseLoss: false, stdout: "", stderr };
-}
-function geminiSandboxEnabled(args) {
-    // There is always a generated --sandbox flag unless extraArgs supplies one.
-    // Like yargs, later explicit values override earlier ones.
-    let enabled = false;
-    for (let index = 0; index < args.length; index++) {
-        const arg = args[index];
-        if (arg === "--sandbox" || arg === "-s") {
-            enabled = args[index + 1] !== "false";
-        }
-        else if (arg.startsWith("--sandbox=") || arg.startsWith("-s=")) {
-            enabled = arg.slice(arg.indexOf("=") + 1) !== "false";
-        }
-        else if (arg === "--no-sandbox") {
-            enabled = false;
-        }
-    }
-    return enabled;
-}
-function hasArg(args, ...flags) {
-    return args.some((arg) => flags.some((flag) => arg === flag || arg.startsWith(`${flag}=`)));
-}
-function hasExplicitApprovalMode(args) {
-    return hasArg(args, "--approval-mode", "--yolo", "-y");
-}
-async function prepareGeminiMcpSettings(mcpConfigPath, env) {
-    const parsed = JSON.parse(await node_fs_1.promises.readFile(mcpConfigPath, "utf8"));
-    const mcpServers = {};
-    for (const [name, server] of Object.entries(parsed.mcpServers ?? {})) {
-        const httpUrl = server.httpUrl ?? (server.type === "http" ? server.url : undefined);
-        if (!httpUrl && !server.url)
-            continue;
-        const headers = {};
-        let headerIndex = 0;
-        for (const [header, value] of Object.entries(server.headers ?? {})) {
-            const envName = `NAVARCH_GEMINI_MCP_${safeEnvSegment(name)}_${headerIndex++}`;
-            env[envName] = value;
-            headers[header] = `\${${envName}}`;
-        }
-        mcpServers[name] = {
-            ...(httpUrl ? { httpUrl } : { url: server.url }),
-            ...(Object.keys(headers).length > 0 ? { headers } : {}),
-        };
-    }
-    const settingsPath = `${mcpConfigPath}.gemini-settings.json`;
-    await node_fs_1.promises.writeFile(settingsPath, JSON.stringify({ mcpServers }, null, 2), { mode: 0o600 });
-    await node_fs_1.promises.chmod(settingsPath, 0o600);
-    return { settingsPath, serverNames: Object.keys(mcpServers) };
-}
-function safeEnvSegment(value) {
-    return value.toUpperCase().replace(/[^A-Z0-9_]/g, "_");
-}
-function parseGeminiStream(stdout) {
-    const events = [];
-    for (const line of stdout.split(/\r?\n/)) {
-        if (!line.trim())
-            continue;
-        try {
-            const event = JSON.parse(line);
-            if (event && typeof event === "object")
-                events.push(event);
-        }
-        catch {
-            // Parser drift must not turn a successfully completed CLI run into a
-            // runtime crash. Unknown lines remain available in the transcript.
-        }
-    }
-    return events;
-}
-function attachGeminiOutput(result) {
-    const events = parseGeminiStream(result.stdout);
-    if (events.length === 0)
-        return result;
-    let reportText = "";
-    let tokensIn;
-    let tokensOut;
-    for (const event of events) {
-        if (event.type === "tool_use") {
-            // Gemini emits pre-tool assistant text as message deltas. Only retain
-            // the answer produced after the last tool call as the completion report.
-            reportText = "";
-        }
-        else if (event.type === "message" &&
-            event.role === "assistant" &&
-            typeof event.content === "string") {
-            reportText = event.delta === false ? event.content : reportText + event.content;
-        }
-        else if (event.type === "result" && event.stats) {
-            const reportedInput = nonNegativeMetric(event.stats.input_tokens);
-            const reportedOutput = nonNegativeMetric(event.stats.output_tokens);
-            if (reportedInput !== undefined)
-                tokensIn = reportedInput;
-            if (reportedOutput !== undefined)
-                tokensOut = reportedOutput;
-        }
-    }
     return {
-        ...result,
-        ...(tokensIn !== undefined ? { tokensIn } : {}),
-        ...(tokensOut !== undefined ? { tokensOut } : {}),
-        ...(reportText.trim() ? { reportText: reportText.trim() } : {}),
-    };
-}
-function nonNegativeMetric(value) {
-    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
-}
-async function runOnHost(options, args) {
-    return new Promise((resolve) => {
-        let stdout = "";
-        let stderr = "";
-        let timedOut = false;
-        let killedByLeaseLoss = false;
-        const child = (0, node_child_process_1.spawn)(options.bin, args, {
-            detached: process.platform !== "win32",
-            cwd: options.cwd,
-            env: { ...process.env, ...options.env },
-        });
-        // Ignore EPIPE from a child that exits before reading; `close` reports it.
-        child.stdin?.on("error", () => undefined);
-        child.stdin?.end(options.prompt);
-        options.onProcessStarted?.(child.pid);
-        const timer = options.timeoutMs > 0 ? setTimeout(() => {
-            timedOut = true;
-            (0, kill_agent_cjs_1.killAgent)(child);
-        }, options.timeoutMs) : undefined;
-        const onAbort = () => {
-            killedByLeaseLoss = true;
-            (0, kill_agent_cjs_1.killAgent)(child);
-        };
-        options.signal?.addEventListener("abort", onAbort, { once: true });
-        if (options.signal?.aborted)
-            onAbort();
-        child.stdout.on("data", (data) => {
-            options.onActivity?.();
-            const text = data.toString();
-            stdout += text;
-            options.onOutput?.("stdout", text);
-        });
-        child.stderr.on("data", (data) => {
-            options.onActivity?.();
-            const text = data.toString();
-            stderr += text;
-            options.onOutput?.("stderr", text);
-        });
-        child.on("error", (err) => {
-            clearTimeout(timer);
-            options.signal?.removeEventListener("abort", onAbort);
-            stderr += `\n${String(err)}`;
-            resolve({ exitCode: null, timedOut, killedByLeaseLoss, stdout, stderr });
-        });
-        child.on("close", (code) => {
-            clearTimeout(timer);
-            options.signal?.removeEventListener("abort", onAbort);
-            resolve({ exitCode: code, timedOut, killedByLeaseLoss, stdout, stderr });
-        });
-    });
-}
-async function runViaDocker(options, args) {
-    const { containerName, runner } = options.dockerExec;
-    const command = `[ -f /tmp/session.env ] && . /tmp/session.env; cd repo 2>/dev/null; ${[
-        options.bin,
-        ...args,
-    ].map(shellQuote).join(" ")}`;
-    let killedByLeaseLoss = false;
-    const onAbort = () => {
-        killedByLeaseLoss = true;
-        runner.run("docker", ["kill", containerName], { timeoutMs: 10_000 }).catch(() => undefined);
+        exitCode: options.signal?.aborted ? null : 1,
+        timedOut: false,
+        killedByLeaseLoss: options.signal?.aborted ?? false,
+        stdout: "",
+        stderr: "Gemini CLI is retired. Explicitly install and authenticate Antigravity, select antigravity, and update the task's runtime pin. No Gemini credentials or conversation IDs are transferred.",
     };
-    options.signal?.addEventListener("abort", onAbort, { once: true });
-    if (options.signal?.aborted)
-        onAbort();
-    try {
-        const forwardedEnv = Object.keys(options.env).flatMap((name) => ["--env", name]);
-        const result = await runner.run("docker", ["exec", "-i", ...forwardedEnv, containerName, "sh", "-c", command], { input: options.prompt,
-            timeoutMs: options.timeoutMs,
-            onActivity: options.onActivity,
-            onStdout: (chunk) => options.onOutput?.("stdout", chunk),
-            onStderr: (chunk) => options.onOutput?.("stderr", chunk),
-            signal: options.signal,
-            env: { ...process.env, ...options.env }, });
-        return {
-            exitCode: result.code,
-            timedOut: false,
-            killedByLeaseLoss,
-            stdout: result.stdout,
-            stderr: result.stderr,
-        };
-    }
-    catch (err) {
-        return {
-            exitCode: null,
-            timedOut: false,
-            killedByLeaseLoss,
-            stdout: "",
-            stderr: String(err),
-        };
-    }
-    finally {
-        options.signal?.removeEventListener("abort", onAbort);
-    }
-}
-function shellQuote(value) {
-    return `'${value.replace(/'/g, `'\\''`)}'`;
 }
-exports.geminiAdapter = {
-    agentType: "gemini",
-    run: runGeminiAdapter,
-};
+exports.geminiAdapter = { agentType: "gemini", run: runGeminiAdapter };