openmausbot 0.1.91 → 0.1.93

package/dist-server/server/drivers/acp/quiet-status.js

@@ -0,0 +1,257 @@
+// What an ACP agent is doing while it sends nothing.
+//
+// ACP has no "still working" message, and agents go quiet for minutes in
+// normal work: Qwen Code 0.24 says nothing over the wire while it waits out
+// a rate limit, while its SDK retries a request, or while one slow model
+// call runs. Silence alone cannot tell that from a wedged process, so a
+// quiet turn is probed from outside: the agent's own debug log where it
+// keeps one, and the process tree's open connections and CPU time. The
+// result becomes a plain-words notice in the chat, so the person is never
+// left watching a spinner without knowing why.
+import { execFile } from "node:child_process";
+import { closeSync, fstatSync, openSync, readSync } from "node:fs";
+/** Qwen Code's debug log (QWEN_DEBUG_LOG_FILE=1), lines like
+ *  `2026-10-02T02:50:41.757Z [WARN] [RETRY] Attempt 1 failed with status 429. Retrying after explicit delay of 20000ms...`.
+ *  Only the facts worth telling a person are parsed; every other line still
+ *  counts as proof the process is alive. */
+export function parseQwenLogLine(line) {
+    if (line.includes("[RETRY]") && /\bAttempt \d+ failed\b/.test(line)) {
+        const attempt = /\bAttempt (\d+) failed/.exec(line);
+        const status = /\bwith status (\d{3})\b/.exec(line);
+        const explicit = /explicit delay of (\d+)\s*ms/.exec(line);
+        const seconds = /Retrying in (\d+)\s*s\b/.exec(line);
+        return {
+            kind: "retry",
+            attempt: attempt ? Number(attempt[1]) : null,
+            status: status ? Number(status[1]) : null,
+            delayMs: explicit ? Number(explicit[1]) : seconds ? Number(seconds[1]) * 1000 : null,
+        };
+    }
+    if (/\[compaction\] hard-tier rescue triggered|Reactive compression|tryCompress/.test(line)
+        && !/succeeded|failed|skipped|stopped/.test(line)) {
+        return { kind: "compressing" };
+    }
+    const gate = /\[compaction\] cheap-gate NOOP: effectiveTokens=(\d+), auto=(\d+)/.exec(line);
+    if (gate)
+        return { kind: "context", tokens: Number(gate[1]), threshold: Number(gate[2]) };
+    return null;
+}
+/** Reads the lines appended to a log file since the last read. A file that
+ *  does not exist yet is simply empty; the first read skips what was already
+ *  there, so an old conversation's log is not replayed as news. */
+export class LogTail {
+    offset = null;
+    partial = "";
+    path;
+    maxBytes;
+    constructor(path, maxBytes = 256 * 1024) {
+        this.path = path;
+        this.maxBytes = maxBytes;
+    }
+    read() {
+        let fd;
+        try {
+            fd = openSync(this.path, "r");
+        }
+        catch {
+            if (this.offset === null)
+                this.offset = 0;
+            return [];
+        }
+        try {
+            const size = fstatSync(fd).size;
+            if (this.offset === null) {
+                this.offset = size;
+                return [];
+            }
+            // truncated or replaced: start over from its beginning
+            if (size < this.offset) {
+                this.offset = 0;
+                this.partial = "";
+            }
+            if (size === this.offset)
+                return [];
+            // a burst bigger than the cap keeps only its tail
+            const start = Math.max(this.offset, size - this.maxBytes);
+            if (start > this.offset)
+                this.partial = "";
+            const buf = Buffer.alloc(size - start);
+            readSync(fd, buf, 0, buf.length, start);
+            this.offset = size;
+            const text = this.partial + buf.toString("utf8");
+            const lines = text.split(/\r?\n/);
+            this.partial = lines.pop() ?? "";
+            return lines.filter((l) => l.trim());
+        }
+        catch {
+            return [];
+        }
+        finally {
+            try {
+                closeSync(fd);
+            }
+            catch { }
+        }
+    }
+}
+const run = (file, args, timeoutMs = 4_000) => new Promise((resolve) => {
+    execFile(file, args, { timeout: timeoutMs, maxBuffer: 4 * 1024 * 1024, windowsHide: true }, (err, stdout) => {
+        // lsof exits 1 when it finds nothing to list; its stdout is still the answer
+        if (err && !(typeof stdout === "string" && err.code === 1))
+            resolve(null);
+        else
+            resolve(String(stdout));
+    });
+});
+/** `ps` TIME: [[dd-]hh:]mm:ss[.cc] */
+function psTimeMs(raw) {
+    const m = /^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+(?:\.\d+)?)$/.exec(raw.trim());
+    if (!m)
+        return null;
+    const [, d, h, min, s] = m;
+    return ((Number(d ?? 0) * 24 + Number(h ?? 0)) * 60 + Number(min)) * 60_000 + Number(s) * 1000;
+}
+/** The root and every descendant, from a `pid ppid ...` table. */
+export function treePids(rows, root) {
+    const kids = new Map();
+    for (const r of rows) {
+        const list = kids.get(r.ppid);
+        if (list)
+            list.push(r.pid);
+        else
+            kids.set(r.ppid, [r.pid]);
+    }
+    const out = [];
+    const queue = [root];
+    while (queue.length && out.length < 512) {
+        const pid = queue.shift();
+        if (out.includes(pid))
+            continue;
+        out.push(pid);
+        queue.push(...(kids.get(pid) ?? []));
+    }
+    return out;
+}
+async function samplePosix(root) {
+    const table = await run("ps", ["-A", "-o", "pid=,ppid=,time="]);
+    if (table === null)
+        return { cpuMs: null, connections: null };
+    const rows = [];
+    for (const line of table.split("\n")) {
+        const [pid, ppid, time] = line.trim().split(/\s+/);
+        if (!pid || !ppid || !time)
+            continue;
+        rows.push({ pid: Number(pid), ppid: Number(ppid), cpuMs: psTimeMs(time) });
+    }
+    const pids = treePids(rows, root);
+    if (!rows.some((r) => r.pid === root))
+        return { cpuMs: null, connections: null };
+    let cpuMs = 0;
+    for (const r of rows)
+        if (pids.includes(r.pid))
+            cpuMs += r.cpuMs ?? 0;
+    const lsof = await run("lsof", ["-nP", "-a", "-p", pids.join(","), "-iTCP", "-sTCP:ESTABLISHED", "-Fn"]);
+    // -Fn prints one `n<addr>` line per connection
+    const connections = lsof === null ? null : lsof.split("\n").filter((l) => l.startsWith("n")).length;
+    return { cpuMs, connections };
+}
+async function sampleWindows(root) {
+    const script = "$ErrorActionPreference='SilentlyContinue';" +
+        "$all=Get-CimInstance Win32_Process|Select-Object ProcessId,ParentProcessId,KernelModeTime,UserModeTime;" +
+        `$ids=@(${root});$q=@(${root});` +
+        "while($q.Count){$p=$q[0];$q=@($q|Select-Object -Skip 1);foreach($c in $all|Where-Object{$_.ParentProcessId -eq $p}){if($ids -notcontains $c.ProcessId){$ids+=$c.ProcessId;$q+=$c.ProcessId}}};" +
+        "$cpu=($all|Where-Object{$ids -contains $_.ProcessId}|ForEach-Object{[double]$_.KernelModeTime+[double]$_.UserModeTime}|Measure-Object -Sum).Sum/10000;" +
+        "$n=@(Get-NetTCPConnection -State Established|Where-Object{$ids -contains $_.OwningProcess}).Count;" +
+        "Write-Output \"$cpu $n\"";
+    const out = await run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], 8_000);
+    const [cpu, n] = (out ?? "").trim().split(/\s+/);
+    const cpuMs = Number(cpu);
+    const connections = Number(n);
+    return {
+        cpuMs: cpu !== undefined && Number.isFinite(cpuMs) ? cpuMs : null,
+        connections: n !== undefined && Number.isFinite(connections) ? connections : null,
+    };
+}
+/** CPU time and open connections of a process and its children. Best
+ *  effort: a missing tool or a refused query reads as null (unknown), never
+ *  as "idle". */
+export function sampleProcessTree(pid) {
+    return (process.platform === "win32" ? sampleWindows(pid) : samplePosix(pid))
+        .catch(() => ({ cpuMs: null, connections: null }));
+}
+/** CPU a process tree can burn on bookkeeping while doing no real work. */
+const BUSY_CPU_MS_PER_MIN = 3_000;
+export function classifyQuiet(input) {
+    const { logged, sample, previous } = input;
+    if (logged?.kind === "retry")
+        return { kind: "retrying", status: logged.status, delayMs: logged.delayMs, attempt: logged.attempt };
+    if (logged?.kind === "compressing")
+        return { kind: "compressing" };
+    const nearFullContext = input.context !== null && input.context.threshold > 0
+        && input.context.tokens >= input.context.threshold * 0.9;
+    if (sample.connections !== null && sample.connections > 0)
+        return { kind: "waiting-model", nearFullContext };
+    const cpuDelta = sample.cpuMs !== null && previous?.cpuMs != null ? sample.cpuMs - previous.cpuMs : null;
+    if (cpuDelta !== null && input.sinceMs > 0 && cpuDelta > BUSY_CPU_MS_PER_MIN * (input.sinceMs / 60_000))
+        return { kind: "busy" };
+    if (sample.connections === 0 && cpuDelta !== null)
+        return { kind: "no-signs" };
+    return { kind: "unknown" };
+}
+/** Two states read the same to a person when this matches; a notice is
+ *  sent only when it changes. */
+export function quietKey(state) {
+    if (state.kind === "retrying")
+        return `retrying:${state.attempt ?? "?"}:${state.status ?? "?"}`;
+    if (state.kind === "waiting-model")
+        return `waiting-model:${state.nearFullContext}`;
+    return state.kind;
+}
+const minutes = (ms) => {
+    if (ms < 90_000)
+        return `${Math.max(1, Math.round(ms / 1000))} s`;
+    return `${Math.round(ms / 60_000)} min`;
+};
+/** The chat notice for a quiet state. */
+export function describeQuiet(name, state, quietMs, stopAfterMs) {
+    const quiet = minutes(quietMs);
+    switch (state.kind) {
+        case "retrying": {
+            const why = state.status === 429 ? "hit a rate limit (HTTP 429)"
+                : state.status !== null && state.status >= 500 ? `got a server error from its model provider (HTTP ${state.status})`
+                    : state.status !== null ? `got an error from its model provider (HTTP ${state.status})`
+                        : "had a failed model request";
+            const next = state.delayMs !== null ? ` Next try in ${Math.max(1, Math.round(state.delayMs / 1000))} s.` : "";
+            const attempt = state.attempt !== null ? ` (attempt ${state.attempt + 1})` : "";
+            return `${name} ${why} and is retrying${attempt}.${next} It is still working.`;
+        }
+        case "compressing":
+            return `${name} is compressing its conversation history to make room. This can take a few minutes; it is still working.`;
+        case "waiting-model":
+            return state.nearFullContext
+                ? `${name} is waiting on its model: no reply for ${quiet}, but its request is still open. Its history is nearly full, so it may be compressing it.`
+                : `${name} is waiting on its model: no reply for ${quiet}, but its request is still open. Slow models and rate limits look like this.`;
+        case "busy":
+            return `${name} is busy on this computer but has sent nothing for ${quiet}.`;
+        case "between-requests":
+            return `${name} has sent nothing for ${quiet} and has no request open to its model right now. ` +
+                "It may be waiting before a retry. Still waiting; press Stop to end the turn.";
+        case "no-signs":
+            return `${name} has sent nothing for ${quiet}, has no open request to its model, and is not using the CPU. It may be stuck. ` +
+                `Press Stop to end the turn; otherwise it is stopped after ${minutes(stopAfterMs)} of silence.`;
+        case "unknown":
+            return `${name} has sent nothing for ${quiet}. Still waiting; press Stop to end the turn.`;
+    }
+}
+/** A short phrase for the final stuck error: what the agent looked like last. */
+export function lastSeenPhrase(state) {
+    switch (state.kind) {
+        case "retrying": return "retrying a failed model request";
+        case "compressing": return "compressing its history";
+        case "waiting-model": return "waiting on its model with a request open";
+        case "busy": return "busy on this computer";
+        case "between-requests": return "no request open to its model";
+        case "no-signs": return "no open request and no CPU use";
+        case "unknown": return "no readable process state";
+    }
+}

package/dist-server/server/drivers/acp/qwen.js

@@ -6,6 +6,7 @@ import { createHash } from "node:crypto";
 import { join } from "node:path";
 import { qualifiedModelLabel } from "../../contracts.js";
 import { harnessHome } from "../../env-path.js";
+import { parseQwenLogLine } from "./quiet-status.js";
 import { decodeInjectId, hostApiKey, localHost, mergeLocalInject } from "../local-inject.js";
 import { createAcpDriver } from "./core.js";
 const EMPTY = { default: "", options: [] };
@@ -199,6 +200,15 @@ export function resolveQwenTurnModel(model, env) {
         throw new Error("This Qwen model is no longer configured. Refresh models and select it again.");
     return matches[0].id;
 }
+/** Where Qwen Code 0.24 writes a session's debug log: `<runtime dir>/debug/<session id>.txt`,
+ * the runtime dir being QWEN_RUNTIME_DIR, else QWEN_HOME, else ~/.qwen. */
+export function qwenDebugLogPath(env, sessionId) {
+    const off = ["", "0", "false", "off", "no"].includes((env.QWEN_DEBUG_LOG_FILE ?? "").trim().toLowerCase());
+    if (off || !/^[\w-]{1,128}$/.test(sessionId))
+        return null;
+    const base = env.QWEN_RUNTIME_DIR || env.QWEN_HOME || harnessHome("qwen", env);
+    return join(base, "debug", `${sessionId}.txt`);
+}
 /** Qwen Code's own approval ladder, passed through (qwen --help, 0.24):
  * `--approval-mode default` asks, `auto-edit` approves file edits, `auto`
  * runs Qwen's LLM classifier that approves safe actions and blocks risky
@@ -243,5 +253,13 @@ const support = {
     authFailure: "continue",
     isAuthenticated: () => true,
     buildPromptText: (turn) => (turn.system ? `${turn.system}\n\n${turn.text}` : turn.text),
+    // Qwen says nothing over ACP while it retries a rate limit or compresses
+    // its history, but its debug log does. Turn the log on (unless the person
+    // turned it off) and read it while a prompt is quiet.
+    transformEnv: (env) => {
+        if (env.QWEN_DEBUG_LOG_FILE === undefined)
+            env.QWEN_DEBUG_LOG_FILE = "1";
+    },
+    statusLog: { path: qwenDebugLogPath, parse: parseQwenLogLine },
 };
 export const QwenAgentDriver = createAcpDriver(support);

package/dist-server/server/drivers/agents-catalog.js

@@ -25,6 +25,7 @@ export function catalogProfileFromEnv(env) {
         sharedComputers: env.OMB_SHARED_COMPUTERS_ENABLED === "1",
         voiceNotes: env.OMB_VOICE_NOTES === "1",
         cloudHome: env.OMB_CLOUD_HOME === "1",
+        memoryEnabled: env.OMB_MEMORY_ENABLED !== "0",
         botId: env.OMB_BOT_ID ?? "",
     };
 }
@@ -210,14 +211,14 @@ const toolDefinitions = (externalRuntime) => [
     },
     {
         name: "coordinate_bots",
-        description: "Ask existing OpenMausBot teammates for advice or assign concrete work. From normal chat every assignment you send a teammate continues your one standing conversation with that teammate, so they keep the context of what you asked before; from a room it defaults to this room. Use group_id from list_room_targets for a specific room. Give 1-4 bot_ids — teammate ids as list_bots or your roster prints them; a unique teammate name also resolves: they receive only your brief and use their own model, tools and permissions. Busy bots queue. They can consult their specialists; all results return here and resume you automatically. Include exact file paths, constraints and what must be verified. After sending all assignments, END your turn; do not poll or wait. On return, resolve tradeoffs, verify the requested outcome and request concrete corrections if necessary before giving one final answer. Do not send acknowledgements as new work.",
+        description: "Ask existing OpenMausBot teammates for advice or assign concrete work. From normal chat each distinct assignment starts a fresh thread for that teammate; from a room it defaults to this room. Give a self-contained brief. Use group_id from list_room_targets for a specific room. Give 1-4 bot_ids — teammate ids as list_bots or your roster prints them; a unique teammate name also resolves: they receive only your brief and use their own model, tools and permissions. Busy bots queue. They can consult their specialists; all results return here and resume you automatically. Include exact file paths, constraints and what must be verified. After sending all assignments, END your turn; do not poll or wait. On return, resolve tradeoffs, verify the requested outcome and request concrete corrections if necessary before giving one final answer. Do not send acknowledgements as new work.",
         inputSchema: { type: "object", additionalProperties: false, properties: {
-                group_id: { type: "string", description: "Optional destination room. Omit for this room, or your standing conversation with each teammate when chatting directly." },
+                group_id: { type: "string", description: "Optional destination room. Omit for this room, or a fresh thread for each teammate when chatting directly." },
                 bot_ids: { type: "array", items: { type: "string", description: "A teammate's id exactly as list_bots or your roster prints it ([id: …]). A teammate's unique display name also resolves; a name shared by two reachable teammates is refused." }, minItems: 1, maxItems: 4, uniqueItems: true },
                 message: { type: "string", minLength: 1, maxLength: 4000, description: "Self-contained question or task for these teammates. Send separate requests when responsibilities differ." },
                 request_key: { type: "string", description: "A short unique assignment key. Reuse for an identical retry." },
                 rework: { type: "boolean", description: "True only for concrete additional work from someone who already completed a request." },
-                label: { type: "string", description: "Optional short name (one line, at most 60 characters) for this job. Used only when the teammate is still working on your previous assignment and this one therefore runs in its own thread beside your standing conversation." },
+                label: { type: "string", description: "Optional short name (one line, at most 60 characters) for this job. Names the new direct assignment thread." },
             }, required: ["bot_ids", "message", "request_key"] },
     },
     {
@@ -778,9 +779,8 @@ export function availableTools(profile) {
 }
 function catalogTools(profile) {
     const TOOLS = toolDefinitions(profile.externalRuntime);
-    const BOT_SCOPED_TOOLS = profile.botId === WATCHER_OPTIONS_CARD_BOT_ID
-        ? TOOLS
-        : TOOLS.filter((tool) => !WATCHER_TOOL_NAMES.has(tool.name));
+    const BOT_SCOPED_TOOLS = TOOLS.filter((tool) => (profile.botId === WATCHER_OPTIONS_CARD_BOT_ID || !WATCHER_TOOL_NAMES.has(tool.name)) &&
+        (profile.memoryEnabled !== false || (tool.name !== "memory_update" && tool.name !== "memory_log")));
     const AUTHORING_TOOLS = profile.skillAuthoring
         ? BOT_SCOPED_TOOLS
         : BOT_SCOPED_TOOLS.filter((tool) => !SKILL_TOOL_NAMES.has(tool.name));

package/dist-server/server/drivers/antigravity-acp.js

@@ -6,6 +6,7 @@ import { delimiter, join, resolve } from "node:path";
 import { DATA_DIR, stripWorkspaceCredentialEnv } from "../config.js";
 import { writeFileAtomic } from "../atomic.js";
 import { killCliTree, spawnCli } from "../procs.js";
+import { VERIFICATION_TEMP_KEY, antigravityTempDir, setAntigravityTempEnvironment, sweepAntigravityTemp, } from "./antigravity-temp.js";
 // Printed on stderr by Google's server, not stdout.
 export const ANTIGRAVITY_AUTH_PREFIX = "Open the following link to authenticate the ACP server: ";
 const AUTH_TIMEOUT_MS = 5 * 60_000;
@@ -16,6 +17,10 @@ const MAX_PROTOCOL_LINE_BYTES = 16 * 1024 * 1024;
 // Past the 16 KiB ceiling parseAntigravityAuthorizationUrl accepts, so a
 // partial stderr line is never dropped while it could still become a link.
 const MAX_DIAGNOSTIC_LINE_CHARS = 64 * 1024;
+// How long a closed runtime gets to exit on its own after its input ends.
+// A forced stop on Windows skips the runtime's own cleanup of the files it
+// unpacked; exiting by itself removes them. Same grace as the ACP pool.
+const GRACEFUL_EXIT_MS = 5_000;
 const REMOVED_ENVIRONMENT_KEYS = new Set([
     "GEMINI_API_KEY",
     "GOOGLE_API_KEY",
@@ -28,6 +33,8 @@ const REMOVED_ENVIRONMENT_KEYS = new Set([
     "CLOUDSDK_CORE_PROJECT",
     "AGY_ACP_CCPA_PROJECT",
     "AGY_ACP_ENABLE_OAUTH",
+    // OMB sets the new-session model itself (antigravity.ts sessionModelEnv).
+    "AGY_ACP_DEFAULT_MODEL",
     "GEMINI_HOME",
     "AGY_ACP_FORCE_FILE_STORAGE",
     "ANTIGRAVITY_HARNESS_PATH",
@@ -121,7 +128,22 @@ export async function prepareAntigravityProfile(input) {
         PYTHONUNBUFFERED: "1",
         ELECTRON_RUN_AS_NODE: "1",
     });
-    return { directory, tokenPath: join(acpDirectory, "acp_token.json"), environment };
+    // On Windows the runtime unpacks 0.34-1.26 GB into TEMP on every launch.
+    // Keep that in a folder OMB owns and can clean. It is the same folder for
+    // every launch of this instance, so the pooled process's spawn contract
+    // (which hashes this environment) does not change from turn to turn.
+    let tempDirectory;
+    if ((input.platform ?? process.platform) === "win32") {
+        tempDirectory = resolve(input.tempDirectory ?? antigravityTempDir(input.baseDir ?? DATA_DIR, input.instanceId));
+        await mkdir(tempDirectory, { recursive: true });
+        setAntigravityTempEnvironment(environment, tempDirectory, "win32");
+    }
+    return {
+        directory,
+        tokenPath: join(acpDirectory, "acp_token.json"),
+        environment,
+        ...(tempDirectory ? { tempDirectory } : {}),
+    };
 }
 export async function antigravityProfileAuthenticated(profile) {
     try {
@@ -177,6 +199,10 @@ export class AntigravityAcpClient {
         });
     }
     consume(chunk) {
+        // Output after close has no reader; do not buffer it while the process
+        // is given time to exit.
+        if (this.closed)
+            return;
         if (!this.initializationComplete)
             this.startupOutputBytes += Buffer.byteLength(chunk);
         this.buffer += chunk;
@@ -287,15 +313,40 @@ export class AntigravityAcpClient {
         this.nativeStartupHint = undefined;
         return initialized;
     }
+    /** End the runtime's input and let it exit by itself, so it removes what
+     * it unpacked; stop it by force only if it is still running after
+     * GRACEFUL_EXIT_MS. killCliTree also runs after a clean exit. On macOS and
+     * Linux that reaps any helper still in the process group. On Windows it
+     * does nothing once the runtime has exited (procs.ts stopCliTree), so a
+     * helper that outlives a clean exit is left running, as in the ACP pool. */
     close() {
         if (this.closed)
             return;
         this.closed = true;
         this.failAll(new Error("Antigravity ACP was closed."));
-        this.stopping = killCliTree(this.child);
+        this.stopping = this.stopGracefully();
     }
-    /** Allow the shared 5s TERM grace and 1s force-stop verification to finish. */
-    async closeAndWait(timeoutMs = 7_000) {
+    async stopGracefully() {
+        try {
+            this.child.stdin?.end();
+        }
+        catch {
+            /* already closed; the kill below still applies */
+        }
+        let timer;
+        await Promise.race([
+            this.exited,
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, GRACEFUL_EXIT_MS);
+                timer.unref?.();
+            }),
+        ]);
+        clearTimeout(timer);
+        return killCliTree(this.child);
+    }
+    /** Allow the graceful exit, the shared 5s TERM grace, and the 1s
+     * force-stop verification to finish. */
+    async closeAndWait(timeoutMs = 12_000) {
         this.close();
         let timer;
         const timedOut = new Promise((resolve) => {
@@ -478,20 +529,19 @@ export function isValidAntigravityInitializeResult(initialized, expectedVersion)
 export async function validateAntigravityRuntime(runtime, expectedVersion) {
     const profileDirectory = await mkdtemp(join(tmpdir(), "openmaus-antigravity-verify-"));
     let client;
+    let tempDirectory;
     let failed = false;
     let failure;
     try {
+        // On Windows every verification unpacks into one shared folder under
+        // DATA_DIR/tmp/agy, swept below once the runtime is gone.
         const profile = await prepareAntigravityProfile({
             instanceId: `verify-${randomUUID()}`,
             runtime,
             profileDirectory,
-            // Google's Windows one-file executable expands a large Python runtime
-            // into TEMP. Forced shutdown skips its own cleanup. Keep verification's
-            // extraction inside the profile we already remove after confirmed close.
-            baseEnv: process.platform === "win32"
-                ? { ...process.env, TEMP: profileDirectory, TMP: profileDirectory }
-                : undefined,
+            tempDirectory: antigravityTempDir(DATA_DIR, VERIFICATION_TEMP_KEY),
         });
+        tempDirectory = profile.tempDirectory;
         client = new AntigravityAcpClient(runtime, profile, profileDirectory);
         const initialized = await client.initialize();
         if (!isValidAntigravityInitializeResult(initialized, expectedVersion)) {
@@ -521,8 +571,16 @@ export async function validateAntigravityRuntime(runtime, expectedVersion) {
     if (stopped) {
         await rm(profileDirectory, { recursive: true, force: true, maxRetries: 4, retryDelay: 250 })
             .catch((error) => {
-            console.warn(`antigravity: could not remove verification profile ${profileDirectory}: ${error instanceof Error ? error.message : String(error)}`);
+            console.warn(`antigravity: could not remove verification files ${profileDirectory}: ${error instanceof Error ? error.message : String(error)}`);
         });
+        // The temp folder is shared, so only unpack folders whose process is
+        // gone go: this run's, and any an earlier run left when its runtime
+        // would not stop.
+        if (tempDirectory) {
+            await sweepAntigravityTemp(VERIFICATION_TEMP_KEY).catch((error) => {
+                console.warn(`antigravity: could not clear verification files: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        }
     }
     if (failed)
         throw failure;