openmausbot 0.1.91 → 0.1.92

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;

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

@@ -0,0 +1,360 @@
+// Where Google's Windows Antigravity runtime unpacks itself, and how the
+// space it leaves behind is reclaimed.
+//
+// Adapted from pingdotgg/t3code@c18e5ea6ed, MIT License, Copyright (c) 2026
+// T3 Tools Inc. (full text in third_party/t3-code/LICENSE); modified:
+//   - apps/server/src/provider/antigravityAuthSupport.ts:187-212, 238-253
+//     (a short temp folder per instance, beside rather than inside the
+//     profile, and TEMP/TMP pointed at it for the runtime);
+//   - apps/server/src/provider/acp/AntigravitySessionFiles.ts:45-61 and
+//     apps/server/src/provider/Drivers/AntigravityDriver.ts:121-132
+//     (reclaim what earlier runs left behind when the driver starts).
+// What OMB does differently: the folder is stable per instance, never per
+// process, because the ACP pool's contractKey hashes the launch environment
+// and a new TEMP per process would respawn on every turn. t3code's per-process
+// run-* folders (AntigravityDriver.ts:202-227) are deliberately not copied.
+// Because the folder is shared, the sweep removes only unpack folders whose
+// process is gone instead of the whole folder. The user-started cleanup of the
+// system temp folder is OMB's own; t3code never touches system temp.
+//
+// Background: agy_acp_server.exe is a PyInstaller one-file build. Every launch
+// unpacks thousands of files (0.34-1.26 GB) into a new %TEMP%\_MEI... folder,
+// and a forced stop (taskkill /T /F) skips PyInstaller's own cleanup, so the
+// folder stays behind. PyInstaller names it `_MEI` + the unpacking process ID
+// + a counter from _wtempnam: the ID is `%08x` since 6.22.1 and `%d` before
+// (bootloader/src/pyi_utils_win32.c, pyi_create_temporary_application_directory).
+import { createHash, randomUUID } from "node:crypto";
+import { lstat, readdir, realpath, rename, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { DATA_DIR } from "../config.js";
+const UNPACK_PREFIX = "_MEI";
+/** An unpack folder OMB has claimed by renaming it and is deleting. If the
+ * delete stops part way, the next sweep finishes it. */
+const CLAIM_PREFIX = ".omb-removing-";
+/** Files at the root of every Antigravity unpack folder. Other programs use
+ * PyInstaller too; without both of these a folder is not Antigravity's. */
+const ANTIGRAVITY_MARKERS = ["agy_acp_licenses.txt", "python310.dll"];
+/** A folder this recent may still be unpacking, even if its ID looks free. */
+export const SYSTEM_LEFTOVER_MIN_AGE_MS = 10 * 60_000;
+const INSTANCE_FOLDER = /^[0-9a-f]{12}$/u;
+/** The folder every instance's temp folder lives in. `tmp/` is already left
+ * out of workspace backups (workspace-backup.ts EXCLUDED). */
+export function antigravityTempRoot(dataDir = DATA_DIR) {
+    return join(dataDir, "tmp", "agy");
+}
+/** Used in place of an instance ID for the one temp folder every runtime
+ * verification shares. It has a space, which no instance ID has, so no
+ * instance shares the folder. Being one fixed folder, what a verification
+ * leaves behind (a runtime that would not stop) is swept like an instance's
+ * leftovers: after the next verification and when the driver starts. */
+export const VERIFICATION_TEMP_KEY = "runtime verification";
+/** One stable, short temp folder per instance. Short, because the runtime
+ * unpacks files up to 120 characters deep and Windows paths stop at 260.
+ * Hashed, so instance IDs that differ only in case stay apart on
+ * case-insensitive disks. */
+export function antigravityTempDir(dataDir, instanceId) {
+    const key = createHash("sha256").update(instanceId).digest("hex").slice(0, 12);
+    return join(antigravityTempRoot(dataDir), key);
+}
+/** Point the runtime's temp folder at `directory`. Windows only: that is
+ * where the runtime unpacks itself. Windows environment names ignore case,
+ * so an inherited `Temp` or `tmp` would otherwise sit beside ours and either
+ * could win. */
+export function setAntigravityTempEnvironment(environment, directory, platform = process.platform) {
+    if (platform !== "win32")
+        return;
+    for (const key of Object.keys(environment)) {
+        const upper = key.toUpperCase();
+        if (upper === "TEMP" || upper === "TMP")
+            delete environment[key];
+    }
+    environment.TEMP = directory;
+    environment.TMP = directory;
+}
+/** Process IDs that could own an unpack folder with this name, or null when
+ * the name is not a PyInstaller unpack folder at all.
+ *
+ * Since 6.22.1 the ID is 8 hex digits. Before that it is plain decimal and
+ * runs straight into _wtempnam's decimal counter, so the split is ambiguous:
+ * every split that leaves a 1-3 digit counter is a candidate. A folder counts
+ * as abandoned only when every candidate is gone, so the guess can keep a
+ * leftover a while longer but can never delete a live one. */
+export function unpackFolderOwnerPids(name) {
+    if (!name.startsWith(UNPACK_PREFIX))
+        return null;
+    const rest = name.slice(UNPACK_PREFIX.length);
+    const pids = new Set();
+    if (/^[0-9a-f]{8}\d+$/iu.test(rest))
+        pids.add(Number.parseInt(rest.slice(0, 8), 16));
+    if (/^[1-9]\d+$/u.test(rest)) {
+        for (let counter = 1; counter <= 3 && counter < rest.length; counter++) {
+            pids.add(Number.parseInt(rest.slice(0, rest.length - counter), 10));
+        }
+    }
+    const valid = [...pids].filter((pid) => Number.isSafeInteger(pid) && pid > 0);
+    return valid.length ? valid : null;
+}
+/** Whether a process with this ID exists. Only "no such process" (ESRCH)
+ * proves it is gone: EPERM means it exists but belongs to someone else. */
+export function processIsAlive(pid, kill = (target, signal) => process.kill(target, signal)) {
+    try {
+        kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error?.code !== "ESRCH";
+    }
+}
+function ownedByDeadProcess(name, isAlive) {
+    const pids = unpackFolderOwnerPids(name);
+    return pids !== null && !pids.some((pid) => isAlive(pid));
+}
+/** A real directory (not a link or junction to one), nothing there at all,
+ * or anything else. */
+async function entryKind(path) {
+    try {
+        const info = await lstat(path);
+        return info.isDirectory() && !info.isSymbolicLink() ? "directory" : "other";
+    }
+    catch (error) {
+        return error?.code === "ENOENT" ? "gone" : "other";
+    }
+}
+async function realDirectory(path) {
+    return (await entryKind(path)) === "directory";
+}
+async function listDirectory(path) {
+    try {
+        return await readdir(path, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+}
+/** The instance folders under OMB's temp root, each resolved through the
+ * disk. Returns nothing when any step of dataDir/tmp/agy/<id> is a link or
+ * junction, so a sweep can never be steered outside OMB's own folder. */
+async function ownedTempDirectories(dataDir, only) {
+    const root = resolve(antigravityTempRoot(dataDir));
+    let realRoot;
+    try {
+        const realData = await realpath(resolve(dataDir));
+        realRoot = await realpath(root);
+        if (realRoot !== join(realData, "tmp", "agy"))
+            return [];
+    }
+    catch {
+        return [];
+    }
+    const names = only === undefined
+        ? (await listDirectory(root)).filter((entry) => entry.isDirectory()).map((entry) => entry.name)
+        : [only];
+    const owned = [];
+    for (const name of names) {
+        if (!INSTANCE_FOLDER.test(name))
+            continue;
+        const directory = join(root, name);
+        try {
+            if (await realpath(directory) !== join(realRoot, name))
+                continue;
+        }
+        catch {
+            continue;
+        }
+        owned.push(directory);
+    }
+    return owned;
+}
+/** Unpack folders in one OMB-owned temp folder whose process is gone, and
+ * folders a previous sweep claimed but did not finish deleting. */
+async function abandonedIn(directory, isAlive) {
+    const found = [];
+    for (const entry of await listDirectory(directory)) {
+        // Dirent follows lstat: a link or junction is never a directory here.
+        if (!entry.isDirectory())
+            continue;
+        if (entry.name.startsWith(CLAIM_PREFIX) || ownedByDeadProcess(entry.name, isAlive)) {
+            found.push(join(directory, entry.name));
+        }
+    }
+    return found;
+}
+async function isAntigravityUnpack(directory) {
+    for (const marker of ANTIGRAVITY_MARKERS) {
+        try {
+            if (!(await lstat(join(directory, marker))).isFile())
+                return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    return true;
+}
+/** Antigravity unpack folders in the system temp folder: both marker files,
+ * no live owner, and untouched for ten minutes. Other apps (Zed, t3code)
+ * start the same runtime, so this runs only when the person asks. */
+async function systemLeftovers(systemTemp, isAlive, now) {
+    const found = [];
+    for (const entry of await listDirectory(systemTemp)) {
+        if (!entry.isDirectory())
+            continue;
+        const directory = join(systemTemp, entry.name);
+        const claimed = entry.name.startsWith(CLAIM_PREFIX + UNPACK_PREFIX);
+        if (!claimed && !ownedByDeadProcess(entry.name, isAlive))
+            continue;
+        if (!claimed && !(await isAntigravityUnpack(directory)))
+            continue;
+        try {
+            if (now - (await lstat(directory)).mtimeMs < SYSTEM_LEFTOVER_MIN_AGE_MS)
+                continue;
+        }
+        catch {
+            continue;
+        }
+        found.push(directory);
+    }
+    return found;
+}
+/** Bytes under a folder, without following links. Stops at the deadline. */
+async function folderBytes(directory, deadline = Infinity) {
+    let bytes = 0;
+    const pending = [directory];
+    while (pending.length) {
+        if (Date.now() > deadline)
+            return { bytes, complete: false };
+        const current = pending.pop();
+        for (const entry of await listDirectory(current)) {
+            const path = join(current, entry.name);
+            if (entry.isDirectory())
+                pending.push(path);
+            else if (entry.isFile()) {
+                try {
+                    bytes += (await lstat(path)).size;
+                }
+                catch { /* already gone */ }
+            }
+        }
+    }
+    return { bytes, complete: true };
+}
+/** Claim a folder by renaming it, then delete it. On Windows the rename
+ * fails while any process still has a file inside open (every live runtime
+ * has its DLLs loaded), which is a second check after the process ID.
+ * Returns the bytes freed; "gone" when someone else (the automatic sweep and
+ * "Free up space" can pick the same folder) removed it first; or null when
+ * the folder was left alone. */
+async function claimAndRemove(directory, countBytes) {
+    const name = basename(directory);
+    // Checked again at the last moment: the listing may be stale.
+    const kind = await entryKind(directory);
+    if (kind !== "directory")
+        return kind === "gone" ? "gone" : null;
+    let claimed = directory;
+    if (!name.startsWith(CLAIM_PREFIX)) {
+        claimed = join(dirname(directory), `${CLAIM_PREFIX}${name}-${randomUUID().slice(0, 8)}`);
+        try {
+            await rename(directory, claimed);
+        }
+        catch (error) {
+            // Lost the race to another remover: the folder is gone, not in use.
+            if (error?.code === "ENOENT" && (await entryKind(directory)) === "gone")
+                return "gone";
+            return null;
+        }
+    }
+    const { bytes } = countBytes ? await folderBytes(claimed) : { bytes: 0 };
+    try {
+        await rm(claimed, { recursive: true, force: true, maxRetries: 3, retryDelay: 200 });
+        return bytes;
+    }
+    catch {
+        // The claimed name stays, and the next sweep finishes the job.
+        return null;
+    }
+}
+const sweeps = new Map();
+/** Delete this instance's abandoned unpack folders. Runs when the driver
+ * starts and before each launch (and, for VERIFICATION_TEMP_KEY, after each
+ * runtime verification). Touches nothing outside dataDir/tmp/agy/<instance>.
+ * Returns how many folders it removed. */
+export function sweepAntigravityTemp(instanceId, options = {}) {
+    const dataDir = options.dataDir ?? DATA_DIR;
+    const key = antigravityTempDir(dataDir, instanceId);
+    const running = sweeps.get(key);
+    if (running)
+        return running;
+    const sweep = (async () => {
+        const isAlive = options.isAlive ?? processIsAlive;
+        let removed = 0;
+        for (const directory of await ownedTempDirectories(dataDir, basename(key))) {
+            for (const folder of await abandonedIn(directory, isAlive)) {
+                if (typeof await claimAndRemove(folder, false) === "number")
+                    removed++;
+            }
+        }
+        return removed;
+    })().finally(() => sweeps.delete(key));
+    sweeps.set(key, sweep);
+    return sweep;
+}
+/** Fire-and-forget form for launch paths: never delays or fails a turn. */
+export function scheduleAntigravityTempSweep(instanceId, options = {}) {
+    void sweepAntigravityTemp(instanceId, options).catch((error) => {
+        console.warn(`antigravity: could not clear leftover runtime files: ${error instanceof Error ? error.message : String(error)}`);
+    });
+}
+async function leftoverCandidates(options) {
+    const isAlive = options.isAlive ?? processIsAlive;
+    const candidates = [];
+    for (const directory of await ownedTempDirectories(options.dataDir ?? DATA_DIR)) {
+        for (const path of await abandonedIn(directory, isAlive))
+            candidates.push({ path, where: "app" });
+    }
+    if ((options.platform ?? process.platform) === "win32") {
+        // TEMP itself may legitimately be a junction; what is inside it may not.
+        const systemTemp = await realpath(resolve(options.systemTemp ?? tmpdir())).catch(() => null);
+        if (systemTemp && await realDirectory(systemTemp)) {
+            for (const path of await systemLeftovers(systemTemp, isAlive, options.now ?? Date.now())) {
+                candidates.push({ path, where: "system" });
+            }
+        }
+    }
+    return candidates;
+}
+/** What "Free up space" would delete, and roughly how much it is. Deletes
+ * nothing. */
+export async function findAntigravityLeftovers(options = {}) {
+    const deadline = Date.now() + (options.budgetMs ?? 15_000);
+    const folders = [];
+    let complete = true;
+    for (const candidate of await leftoverCandidates(options)) {
+        const counted = await folderBytes(candidate.path, deadline);
+        complete &&= counted.complete;
+        folders.push({ ...candidate, bytes: counted.bytes });
+    }
+    return { folders, bytes: folders.reduce((total, folder) => total + folder.bytes, 0), complete };
+}
+/** "Free up space": looks again rather than trusting an earlier scan, so a
+ * folder that came back to life since is left alone. */
+export async function removeAntigravityLeftovers(options = {}) {
+    const deadline = Date.now() + (options.budgetMs ?? 120_000);
+    const candidates = await leftoverCandidates(options);
+    let removed = 0;
+    let alreadyGone = 0;
+    let freedBytes = 0;
+    for (const candidate of candidates) {
+        if (Date.now() > deadline)
+            break;
+        const bytes = await claimAndRemove(candidate.path, true);
+        if (bytes === "gone")
+            alreadyGone++;
+        if (typeof bytes !== "number")
+            continue;
+        removed++;
+        freedBytes += bytes;
+    }
+    // A folder another remover got to first is not "still in use".
+    return { removed, freedBytes, remaining: candidates.length - removed - alreadyGone };
+}

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

@@ -2,6 +2,7 @@ import { createAcpDriver } from "./acp/core.js";
 import { AntigravityAuthController, antigravityProfileAuthenticated, catalogFromAntigravityConfigOptions, prepareAntigravityProfile, probeAntigravityModels, validateAntigravityRuntime, } from "./antigravity-acp.js";
 import { antigravityManagedInstallAvailable, installAntigravityRuntime, resolveAntigravityRuntime, } from "./antigravity-runtime.js";
 import { resolveAntigravityReleaseAsset } from "./antigravity-release.js";
+import { VERIFICATION_TEMP_KEY, scheduleAntigravityTempSweep } from "./antigravity-temp.js";
 import { augmentedPath } from "../env-path.js";
 export const STATIC_ANTIGRAVITY_MODELS = {
     default: "gemini-3.8-flash-high",
@@ -39,6 +40,14 @@ const support = {
     images: true,
     spawnArgs: () => [],
     selectModel: { configId: "model" },
+    // Google's server reads its new-session default from this variable
+    // (model_selection.get_default_model_id in agy_acp_server 1.1.1). Starting
+    // on OMB's model skips a switch that re-fetches the account's model list
+    // from Google: 1.3-1.8 s on every new or cold-resumed conversation.
+    sessionModelEnv: "AGY_ACP_DEFAULT_MODEL",
+    // configureSession sets the permission mode on every turn and nothing in
+    // the launch depends on it, so an approval change keeps the process.
+    sessionScopedApproval: true,
     resumeMethod: "resume",
     clientFileSystem: true,
     redactStderr: true,
@@ -47,6 +56,11 @@ const support = {
     resolveCommand: async (env, config, instanceId) => {
         const runtime = await resolveAntigravityRuntime(config.cli, env);
         const profile = await prepareAntigravityProfile({ instanceId, runtime, baseEnv: env });
+        // A process stopped by force since the last launch (an idle close that
+        // outlived its grace, a crash) left its unpacked files behind. Reclaim
+        // them in the background; live folders are kept.
+        if (profile.tempDirectory)
+            scheduleAntigravityTempSweep(instanceId);
         return {
             command: runtime.executablePath,
             args: process.platform === "linux" ? ["--uid="] : [],
@@ -112,6 +126,13 @@ export const AntigravityDriver = {
     ...AcpAntigravityDriver,
     async create(input) {
         const base = await AcpAntigravityDriver.create(input);
+        // Reclaim what a previous run of this instance left behind when it was
+        // stopped by force (Windows keeps 0.34-1.26 GB per forced stop). Only
+        // this instance's folder under DATA_DIR/tmp/agy, only folders whose
+        // process is gone; the system temp folder is cleaned only on request.
+        scheduleAntigravityTempSweep(input.instanceId);
+        // The same for a runtime verification whose runtime would not stop.
+        scheduleAntigravityTempSweep(VERIFICATION_TEMP_KEY);
         const auth = new AntigravityAuthController();
         let installFailure;
         const runtimeAndProfile = async () => {