@ycodium-ai/agent-antigravity 0.2.3210 → 0.2.3214

package/dist/index.js

@@ -28540,6 +28540,92 @@ function readOpenToolCalls(toolCalls, turnId) {
   return running;
 }
 
+// ../../packages/ycodium-acp-executor/src/protocol-log.ts
+import * as NodeFS from "node:fs";
+import * as NodeOS from "node:os";
+import * as NodePath2 from "node:path";
+var DEFAULT_MAX_BYTES = 8 * 1024 * 1024;
+var UNSAFE_FILE_CHARS = /[^A-Za-z0-9._-]+/gu;
+function safeFileName(value) {
+  return value.replaceAll(UNSAFE_FILE_CHARS, "_");
+}
+function createAcpProtocolLogFile(input2) {
+  const maxBytes = input2.maxBytes ?? DEFAULT_MAX_BYTES;
+  NodeFS.mkdirSync(input2.directory, { recursive: true });
+  const filePath = NodePath2.join(
+    input2.directory,
+    `${safeFileName(input2.provider)}-${safeFileName(input2.threadId)}-${Date.now().toString(36)}.ndjson`
+  );
+  const stream = (input2.openStream ?? ((path) => NodeFS.createWriteStream(path, { flags: "a" })))(
+    filePath
+  );
+  let bytes = 0;
+  let stopped = false;
+  const closed = Promise.withResolvers();
+  let closing = false;
+  stream.once("close", () => closed.resolve());
+  stream.on("error", () => {
+    stopped = true;
+    stream.destroy();
+  });
+  const writeTruncated = () => {
+    stopped = true;
+    const marker = `${JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), stage: "truncated" })}
+`;
+    if (bytes + Buffer.byteLength(marker) <= maxBytes) stream.write(marker);
+    stream.end();
+  };
+  const writeLine = (value) => {
+    if (stopped) return;
+    const line = `${JSON.stringify(value)}
+`;
+    const lineBytes = Buffer.byteLength(line);
+    if (bytes + lineBytes > maxBytes) {
+      writeTruncated();
+      return;
+    }
+    bytes += lineBytes;
+    stream.write(line);
+  };
+  return {
+    path: filePath,
+    write: (event) => writeLine({
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      direction: event.direction,
+      stage: event.stage,
+      payload: event.payload
+    }),
+    close: async () => {
+      if (closing) return closed.promise;
+      closing = true;
+      stopped = true;
+      stream.end();
+      await closed.promise;
+    }
+  };
+}
+function createAcpProtocolLogFromEnv(input2) {
+  const flag = process.env.YCODIUM_ACP_PROTOCOL_LOG;
+  if (flag !== "1" && flag?.toLowerCase() !== "true") return void 0;
+  const configured = process.env.YCODIUM_ACP_PROTOCOL_LOG_DIR?.trim();
+  const directory = configured && configured.length > 0 ? configured : NodePath2.join(NodeOS.tmpdir(), "ycodium-acp-protocol");
+  try {
+    const sink = createAcpProtocolLogFile({
+      directory,
+      provider: input2.provider,
+      threadId: input2.threadId
+    });
+    input2.log?.info("acp protocol frames are being recorded", { path: sink.path });
+    return sink;
+  } catch (error62) {
+    input2.log?.warn?.("acp protocol frame log could not be opened", {
+      directory,
+      error: error62 instanceof Error ? error62.message : String(error62)
+    });
+    return void 0;
+  }
+}
+
 // ../../packages/ycodium-acp-executor/src/executor.ts
 var DEFAULT_CANCEL_GRACE_MS = 5e3;
 function defaultNowIso() {
@@ -28648,9 +28734,16 @@ function createAcpExecutor(options2) {
   });
   const { rememberSettledPromptKey, abortPendingSettlement, settleFromNotification } = createExecutorSettlement({ hooks, shared });
   const promptResults = createPromptResults({ options: options2, shared });
+  const protocolLogSink = options2.protocolLog === void 0 ? createAcpProtocolLogFromEnv({
+    provider: options2.provider,
+    threadId: options2.threadId,
+    ...options2.log === void 0 ? {} : { log: options2.log }
+  }) : void 0;
+  const protocolLog = options2.protocolLog ?? protocolLogSink?.write;
   const connection = createAcpConnection({
     readable: options2.readable,
     writable: options2.writable,
+    ...protocolLog === void 0 ? {} : { logger: protocolLog },
     onInboundFailure: (error62) => {
       options2.log?.warn?.("acp connection closed: an inbound request could not be answered", {
         threadId: options2.threadId,
@@ -28747,7 +28840,11 @@ function createAcpExecutor(options2) {
     notifyPromptSettled,
     shared
   });
-  const { cancel, compact, dispose } = createExecutorLifecycle({
+  const {
+    cancel,
+    compact,
+    dispose: disposeLifecycle
+  } = createExecutorLifecycle({
     promptResults,
     failIfDisposed,
     requireStarted,
@@ -28774,6 +28871,7 @@ function createAcpExecutor(options2) {
     onInputDead,
     shared
   });
+  let disposeOnce;
   return {
     get generation() {
       return shared.generation;
@@ -28796,7 +28894,16 @@ function createAcpExecutor(options2) {
     setNativeMode,
     compact,
     openToolCalls: () => readOpenToolCalls(toolCalls, shared.activeTurnId),
-    dispose
+    dispose: () => {
+      disposeOnce ??= (async () => {
+        try {
+          await disposeLifecycle();
+        } finally {
+          await protocolLogSink?.close();
+        }
+      })();
+      return disposeOnce;
+    }
   };
 }
 
@@ -28987,8 +29094,8 @@ var realAgentClock = {
 // src/profile.ts
 import * as NodeCrypto2 from "node:crypto";
 import * as NodeFSP from "node:fs/promises";
-import * as NodeOS from "node:os";
-import * as NodePath2 from "node:path";
+import * as NodeOS2 from "node:os";
+import * as NodePath3 from "node:path";
 import { mergeLaunchEnv } from "@ycodium-ai/plugin-api/executor";
 
 // src/hostPlatform.ts
@@ -29002,9 +29109,9 @@ function sha256Hex(value) {
   return NodeCrypto2.createHash("sha256").update(value).digest("hex");
 }
 function expandHomePath(value) {
-  if (value === "~") return NodeOS.homedir();
+  if (value === "~") return NodeOS2.homedir();
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return NodePath2.join(NodeOS.homedir(), value.slice(2));
+    return NodePath3.join(NodeOS2.homedir(), value.slice(2));
   }
   return value;
 }
@@ -29012,12 +29119,12 @@ function resolveAntigravityDirectories(input2) {
   const key = sha256Hex(input2.instanceId);
   const homePath = input2.homePath.trim();
   const custom2 = homePath.length > 0;
-  const profile = custom2 ? NodePath2.resolve(expandHomePath(homePath)) : NodePath2.join(input2.dataDir, "profiles", key);
+  const profile = custom2 ? NodePath3.resolve(expandHomePath(homePath)) : NodePath3.join(input2.dataDir, "profiles", key);
   const continuationSource = custom2 ? `home\0${(input2.platform ?? HOST_PLATFORM) === "win32" ? profile.toLowerCase() : profile}` : `instance\0${input2.instanceId}`;
   return {
     profile,
-    runtimeTempRoot: NodePath2.join(input2.dataDir, "tmp", key.slice(0, 12)),
-    modelCacheFile: NodePath2.join(input2.dataDir, "model-cache", `${key}.json`),
+    runtimeTempRoot: NodePath3.join(input2.dataDir, "tmp", key.slice(0, 12)),
+    modelCacheFile: NodePath3.join(input2.dataDir, "model-cache", `${key}.json`),
     continuationKey: `antigravity:profile:${sha256Hex(continuationSource).slice(0, 16)}`
   };
 }
@@ -29065,10 +29172,10 @@ function antigravityLaunchArgs(platform2 = HOST_PLATFORM) {
   return platform2 === "linux" ? ["--uid="] : [];
 }
 async function prepareAntigravityProfile(profile) {
-  const acpDirectory = NodePath2.join(profile, "antigravity-acp");
+  const acpDirectory = NodePath3.join(profile, "antigravity-acp");
   await NodeFSP.mkdir(acpDirectory, { recursive: true, mode: 448 });
   await NodeFSP.writeFile(
-    NodePath2.join(acpDirectory, "settings.json"),
+    NodePath3.join(acpDirectory, "settings.json"),
     `${JSON.stringify({ auth: { type: "oauth-personal" } })}
 `,
     "utf8"
@@ -29077,13 +29184,13 @@ async function prepareAntigravityProfile(profile) {
 var liveRuntimeTempDirs = /* @__PURE__ */ new Set();
 async function createRuntimeTempDir(root) {
   await NodeFSP.mkdir(root, { recursive: true, mode: 448 });
-  const directory = await NodeFSP.mkdtemp(NodePath2.join(root, RUN_DIR_PREFIX));
+  const directory = await NodeFSP.mkdtemp(NodePath3.join(root, RUN_DIR_PREFIX));
   liveRuntimeTempDirs.add(directory);
   return directory;
 }
 async function removeRuntimeTempDir(directory) {
   liveRuntimeTempDirs.delete(directory);
-  if (!NodePath2.isAbsolute(directory) || !NodePath2.basename(directory).startsWith(RUN_DIR_PREFIX)) {
+  if (!NodePath3.isAbsolute(directory) || !NodePath3.basename(directory).startsWith(RUN_DIR_PREFIX)) {
     return false;
   }
   try {
@@ -29103,7 +29210,7 @@ async function sweepRuntimeTempDirs(root) {
   let removed = 0;
   for (const name of names) {
     if (!name.startsWith(RUN_DIR_PREFIX)) continue;
-    const directory = NodePath2.join(root, name);
+    const directory = NodePath3.join(root, name);
     if (liveRuntimeTempDirs.has(directory)) continue;
     if (await removeRuntimeTempDir(directory)) removed += 1;
   }
@@ -29590,16 +29697,16 @@ function createBackgroundCommandTracker(input2) {
 
 // src/clientFiles.ts
 import * as NodeFSP2 from "node:fs/promises";
-import * as NodePath3 from "node:path";
+import * as NodePath4 from "node:path";
 var CLIENT_FILE_MAX_BYTES = 8 * 1024 * 1024;
 function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isInside(root, candidate) {
-  const relative2 = NodePath3.relative(root, candidate);
+  const relative2 = NodePath4.relative(root, candidate);
   if (relative2 === "") return true;
-  const escapes = relative2 === ".." || relative2.startsWith(`..${NodePath3.sep}`);
-  return !escapes && !NodePath3.isAbsolute(relative2);
+  const escapes = relative2 === ".." || relative2.startsWith(`..${NodePath4.sep}`);
+  return !escapes && !NodePath4.isAbsolute(relative2);
 }
 async function realpathOrSelf(target) {
   try {
@@ -29612,13 +29719,13 @@ async function realTarget(resolved) {
   try {
     return await NodeFSP2.realpath(resolved);
   } catch {
-    const parent = NodePath3.dirname(resolved);
+    const parent = NodePath4.dirname(resolved);
     if (parent === resolved) return resolved;
-    return NodePath3.join(await realTarget(parent), NodePath3.basename(resolved));
+    return NodePath4.join(await realTarget(parent), NodePath4.basename(resolved));
   }
 }
 async function resolveInside(requestPath, cwd, roots) {
-  const target = await realTarget(NodePath3.resolve(cwd, requestPath));
+  const target = await realTarget(NodePath4.resolve(cwd, requestPath));
   const realRoots = await Promise.all(roots.map(realpathOrSelf));
   if (!realRoots.some((root) => isInside(root, target))) {
     throw RequestError.invalidParams(
@@ -29680,7 +29787,7 @@ async function writeTextFile(params, roots) {
   const content = requireString(params, "content");
   const filePath = await resolveInside(requestPath, roots.cwd, [roots.cwd]);
   try {
-    await NodeFSP2.mkdir(NodePath3.dirname(filePath), { recursive: true });
+    await NodeFSP2.mkdir(NodePath4.dirname(filePath), { recursive: true });
     await NodeFSP2.writeFile(filePath, content, "utf8");
   } catch {
     throw RequestError.internalError(void 0, `Could not write '${requestPath}'.`);
@@ -29701,7 +29808,7 @@ function createClientFileHandler(roots) {
 
 // src/modelCache.ts
 import * as NodeFSP3 from "node:fs/promises";
-import * as NodePath4 from "node:path";
+import * as NodePath5 from "node:path";
 var SCHEMA_VERSION = 1;
 function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -29781,7 +29888,7 @@ function updateAntigravityModelCache(file2, patch) {
       ...currentModel === void 0 ? {} : { currentModel },
       models: catalog?.models ?? existing?.models ?? []
     };
-    await NodeFSP3.mkdir(NodePath4.dirname(file2), { recursive: true });
+    await NodeFSP3.mkdir(NodePath5.dirname(file2), { recursive: true });
     const temporary = `${file2}.${String(process.pid)}.tmp`;
     await NodeFSP3.writeFile(temporary, `${JSON.stringify(merged)}
 `, "utf8");
@@ -30070,8 +30177,8 @@ function antigravityPermissionUserInput(request2) {
 
 // src/userSkills.ts
 import * as NodeFSP4 from "node:fs/promises";
-import * as NodeOS2 from "node:os";
-import * as NodePath5 from "node:path";
+import * as NodeOS3 from "node:os";
+import * as NodePath6 from "node:path";
 var ANTIGRAVITY_SKILL_SCAN_LIMITS = {
   maxSkillBytes: 1e6,
   maxScanBytes: 8e6,
@@ -30083,30 +30190,30 @@ function resolveAntigravityUserHome(platform2, environment) {
     if (environment["HOMEDRIVE"] && environment["HOMEPATH"]) {
       return `${environment["HOMEDRIVE"]}${environment["HOMEPATH"]}`;
     }
-    return NodeOS2.homedir();
+    return NodeOS3.homedir();
   }
-  return environment["HOME"] || NodeOS2.homedir();
+  return environment["HOME"] || NodeOS3.homedir();
 }
 function antigravityUserSkillDirectories(geminiHome) {
   return [
-    NodePath5.join(geminiHome, "config", "skills"),
-    NodePath5.join(geminiHome, "antigravity-cli", "skills")
+    NodePath6.join(geminiHome, "config", "skills"),
+    NodePath6.join(geminiHome, "antigravity-cli", "skills")
   ];
 }
 var sameFilePath = (platform2, left, right) => platform2 === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right;
 async function linkOne(link, target, platform2) {
-  if (sameFilePath(platform2, NodePath5.resolve(link), target)) return "kept";
+  if (sameFilePath(platform2, NodePath6.resolve(link), target)) return "kept";
   const existing = await NodeFSP4.lstat(link).catch((error62) => {
     if (error62.code === "ENOENT") return void 0;
     throw error62;
   });
   if (existing !== void 0) {
     if (!existing.isSymbolicLink()) return "kept";
-    const current = NodePath5.resolve(NodePath5.dirname(link), await NodeFSP4.readlink(link));
+    const current = NodePath6.resolve(NodePath6.dirname(link), await NodeFSP4.readlink(link));
     if (sameFilePath(platform2, current, target)) return "already";
     await NodeFSP4.unlink(link);
   }
-  await NodeFSP4.mkdir(NodePath5.dirname(link), { recursive: true });
+  await NodeFSP4.mkdir(NodePath6.dirname(link), { recursive: true });
   try {
     await NodeFSP4.symlink(target, link, platform2 === "win32" ? "junction" : "dir");
   } catch (error62) {
@@ -30117,7 +30224,7 @@ async function linkOne(link, target, platform2) {
 async function linkAntigravityUserSkills(input2) {
   const links = antigravityUserSkillDirectories(input2.profile);
   const targets = antigravityUserSkillDirectories(
-    NodePath5.resolve(NodePath5.join(input2.userHome, ".gemini"))
+    NodePath6.resolve(NodePath6.join(input2.userHome, ".gemini"))
   );
   const results = [];
   for (const [index, link] of links.entries()) {
@@ -30250,7 +30357,7 @@ async function readSkillFile(skillPath, budget, maxSkillBytes) {
   }
 }
 async function discoverAntigravityUserSkills(userHome, limits = ANTIGRAVITY_SKILL_SCAN_LIMITS) {
-  const roots = antigravityUserSkillDirectories(NodePath5.join(userHome, ".gemini"));
+  const roots = antigravityUserSkillDirectories(NodePath6.join(userHome, ".gemini"));
   const budget = {
     remainingBytes: limits.maxScanBytes,
     remainingEntries: limits.maxScanEntries
@@ -30274,7 +30381,7 @@ async function discoverAntigravityUserSkills(userHome, limits = ANTIGRAVITY_SKIL
     const skillFileName = sorted.find((entry) => entry.toLowerCase() === "skill.md");
     if (skillFileName !== void 0) {
       if (!skillFileName.endsWith(".md")) return;
-      const skillPath = NodePath5.join(directory, skillFileName);
+      const skillPath = NodePath6.join(directory, skillFileName);
       const contents = await readSkillFile(skillPath, budget, limits.maxSkillBytes);
       if (contents === void 0) return;
       const skill = parseSkillFile(contents, skillFileName);
@@ -30290,7 +30397,7 @@ async function discoverAntigravityUserSkills(userHome, limits = ANTIGRAVITY_SKIL
     }
     if (!scanChildren) return;
     for (const entry of sorted.toSorted(compareSkillEntries)) {
-      await scanDirectory(NodePath5.join(directory, entry), false);
+      await scanDirectory(NodePath6.join(directory, entry), false);
     }
   };
   for (const root of roots) await scanDirectory(root, true);
@@ -30825,12 +30932,12 @@ function forwardCallback(callback, timeoutMs = FORWARD_TIMEOUT_MS) {
 
 // src/runtime.ts
 import * as NodeFSP6 from "node:fs/promises";
-import * as NodePath7 from "node:path";
+import * as NodePath8 from "node:path";
 
 // src/managedRuntime.ts
 import * as NodeCrypto5 from "node:crypto";
 import * as NodeFSP5 from "node:fs/promises";
-import * as NodePath6 from "node:path";
+import * as NodePath7 from "node:path";
 var RELEASE_RECORD_FILE = ".install-complete.json";
 var RELEASE_ID_PATTERN = /^[a-f0-9]{64}$/u;
 var RECORD_MAX_BYTES = 8 * 1024;
@@ -30838,15 +30945,15 @@ var ManagedRuntimeInvalidError = class extends Error {
   name = "ManagedRuntimeInvalidError";
 };
 function managedLayout(dataDir, platform2, arch2) {
-  const root = NodePath6.join(dataDir, "runtime", `${platform2}-${arch2}`);
+  const root = NodePath7.join(dataDir, "runtime", `${platform2}-${arch2}`);
   return {
     root,
-    versionsDir: NodePath6.join(root, "versions"),
-    activeFile: NodePath6.join(root, "active.json")
+    versionsDir: NodePath7.join(root, "versions"),
+    activeFile: NodePath7.join(root, "active.json")
   };
 }
 function versionDirectoryOf(layout, releaseId) {
-  return NodePath6.join(layout.versionsDir, releaseId);
+  return NodePath7.join(layout.versionsDir, releaseId);
 }
 function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -30904,7 +31011,7 @@ async function readCompletedRelease(input2) {
   const directory = versionDirectoryOf(input2.layout, input2.releaseId);
   let parsed;
   try {
-    parsed = await readSmallJson(NodePath6.join(directory, RELEASE_RECORD_FILE));
+    parsed = await readSmallJson(NodePath7.join(directory, RELEASE_RECORD_FILE));
   } catch (error62) {
     if (isMissing2(error62)) throw incomplete;
     throw error62;
@@ -30916,8 +31023,8 @@ async function readCompletedRelease(input2) {
   if (parsed["releaseId"] !== input2.releaseId || executable === void 0 || harness === void 0 || typeof version2 !== "string" || version2.trim().length === 0 || executable.name !== input2.names.executable || harness.name !== input2.names.harness) {
     throw incomplete;
   }
-  const executablePath = NodePath6.join(directory, executable.name);
-  const harnessPath = NodePath6.join(directory, harness.name);
+  const executablePath = NodePath7.join(directory, executable.name);
+  const harnessPath = NodePath7.join(directory, harness.name);
   if (!await isExecutableFile(executablePath, executable.bytes, input2.platform) || !await isExecutableFile(harnessPath, harness.bytes, input2.platform)) {
     throw incomplete;
   }
@@ -30936,7 +31043,7 @@ async function readActiveRelease(input2) {
 }
 async function writeReleaseRecord(directory, record2) {
   await NodeFSP5.writeFile(
-    NodePath6.join(directory, RELEASE_RECORD_FILE),
+    NodePath7.join(directory, RELEASE_RECORD_FILE),
     `${JSON.stringify(record2)}
 `,
     { flag: "wx", mode: 384 }
@@ -30944,7 +31051,7 @@ async function writeReleaseRecord(directory, record2) {
 }
 async function writeActiveRelease(layout, releaseId) {
   await NodeFSP5.mkdir(layout.root, { recursive: true });
-  const pending = NodePath6.join(
+  const pending = NodePath7.join(
     layout.root,
     `active.json.${NodeCrypto5.randomBytes(6).toString("hex")}.tmp`
   );
@@ -30992,14 +31099,14 @@ function readPathValue(instanceEnvironment, processEnv, platform2) {
   return lookup(instanceEnvironment) ?? lookup(processEnv) ?? "";
 }
 function pathCandidates(binary, pathValue) {
-  return pathValue.split(NodePath7.delimiter).map((directory) => directory.trim().replace(/^"|"$/gu, "")).filter((directory) => directory.length > 0).map((directory) => NodePath7.resolve(directory, binary));
+  return pathValue.split(NodePath8.delimiter).map((directory) => directory.trim().replace(/^"|"$/gu, "")).filter((directory) => directory.length > 0).map((directory) => NodePath8.resolve(directory, binary));
 }
 async function managedDirectoryOf(executablePath, managed) {
   if (managed === void 0) return null;
   try {
     const realVersions = await NodeFSP6.realpath(managed.versionsDir);
-    const directory = NodePath7.dirname(executablePath);
-    return NodePath7.dirname(directory) === realVersions && RELEASE_ID_PATTERN.test(NodePath7.basename(directory)) ? directory : null;
+    const directory = NodePath8.dirname(executablePath);
+    return NodePath8.dirname(directory) === realVersions && RELEASE_ID_PATTERN.test(NodePath8.basename(directory)) ? directory : null;
   } catch {
     return null;
   }
@@ -31012,7 +31119,7 @@ async function resolveAntigravityExecutable(input2) {
   const accept = async (candidate, source) => {
     if (!await isExecutableFile2(candidate, platform2)) return void 0;
     const executablePath = await NodeFSP6.realpath(candidate);
-    const harnessPath = NodePath7.join(NodePath7.dirname(executablePath), names.harness);
+    const harnessPath = NodePath8.join(NodePath8.dirname(executablePath), names.harness);
     if (!await isExecutableFile2(harnessPath, platform2)) return void 0;
     return {
       executablePath,
@@ -31023,7 +31130,7 @@ async function resolveAntigravityExecutable(input2) {
     };
   };
   if (configured.length > 0) {
-    const candidates = NodePath7.isAbsolute(configured) || configured.includes("/") || configured.includes("\\") ? [NodePath7.resolve(configured)] : pathCandidates(configured, pathValue);
+    const candidates = NodePath8.isAbsolute(configured) || configured.includes("/") || configured.includes("\\") ? [NodePath8.resolve(configured)] : pathCandidates(configured, pathValue);
     for (const candidate of candidates) {
       const found = await accept(candidate, "configured");
       if (found !== void 0) return found;
@@ -31062,10 +31169,10 @@ async function resolveAntigravityExecutable(input2) {
 
 // src/signedInMarker.ts
 import * as NodeFSP7 from "node:fs/promises";
-import * as NodePath8 from "node:path";
+import * as NodePath9 from "node:path";
 var SCHEMA_VERSION2 = 1;
 function signedInMarkerFile(profile) {
-  return NodePath8.join(profile, "antigravity-acp", "ycodium-signed-in.json");
+  return NodePath9.join(profile, "antigravity-acp", "ycodium-signed-in.json");
 }
 async function readSignedInMarker(file2) {
   try {
@@ -31076,7 +31183,7 @@ async function readSignedInMarker(file2) {
   }
 }
 async function writeSignedInMarker(file2) {
-  await NodeFSP7.mkdir(NodePath8.dirname(file2), { recursive: true, mode: 448 });
+  await NodeFSP7.mkdir(NodePath9.dirname(file2), { recursive: true, mode: 448 });
   const temporary = `${file2}.${String(process.pid)}.tmp`;
   await NodeFSP7.writeFile(
     temporary,
@@ -31617,14 +31724,14 @@ import { nodeStreamsFromHandle as nodeStreamsFromHandle3 } from "@ycodium-ai/plu
 
 // src/sessionFiles.ts
 import * as NodeFSP8 from "node:fs/promises";
-import * as NodePath9 from "node:path";
+import * as NodePath10 from "node:path";
 var UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
 var SESSION_FILE_SUFFIXES = [".db", ".db-wal", ".db-shm", ".db-journal", ".meta"];
 async function removeTemporarySessionFiles(input2) {
   const { sessionId } = input2;
   if (sessionId === void 0 || !UUID_V4.test(sessionId)) return false;
-  const acpDirectory = NodePath9.join(input2.profile, "antigravity-acp");
-  const base = NodePath9.join(acpDirectory, "conversations", sessionId);
+  const acpDirectory = NodePath10.join(input2.profile, "antigravity-acp");
+  const base = NodePath10.join(acpDirectory, "conversations", sessionId);
   try {
     const meta3 = JSON.parse(await NodeFSP8.readFile(`${base}.meta`, "utf8"));
     const cwd = typeof meta3 === "object" && meta3 !== null ? meta3.cwd : null;
@@ -31632,7 +31739,7 @@ async function removeTemporarySessionFiles(input2) {
     for (const suffix of SESSION_FILE_SUFFIXES) {
       await NodeFSP8.rm(`${base}${suffix}`, { force: true });
     }
-    await NodeFSP8.rm(NodePath9.join(acpDirectory, "brain", sessionId), {
+    await NodeFSP8.rm(NodePath10.join(acpDirectory, "brain", sessionId), {
       recursive: true,
       force: true
     });
@@ -31644,7 +31751,7 @@ async function removeTemporarySessionFiles(input2) {
 
 // src/textGenerationAvailability.ts
 import * as NodeFSP9 from "node:fs/promises";
-import * as NodePath10 from "node:path";
+import * as NodePath11 from "node:path";
 var MAX_CONFIG_BYTES = 64e3;
 var CONFIG_FILES = [
   { name: "hooks.json", key: "hooks" },
@@ -31665,7 +31772,7 @@ async function configIsEmpty(file2, key) {
 }
 async function isTextGenerationAvailable(profile) {
   for (const { name, key } of CONFIG_FILES) {
-    const file2 = NodePath10.join(profile, "config", name);
+    const file2 = NodePath11.join(profile, "config", name);
     try {
       await NodeFSP9.lstat(file2);
     } catch (error62) {
@@ -32808,7 +32915,7 @@ function registerRuntimeCommands(ctx, manager) {
 
 // src/runtimeManager.ts
 import * as NodeFSP12 from "node:fs/promises";
-import * as NodePath13 from "node:path";
+import * as NodePath14 from "node:path";
 
 // src/release.ts
 var ANTIGRAVITY_RELEASE_VERSION = "agy_acp_server_1.1.1";
@@ -32876,9 +32983,9 @@ function resolveAntigravityReleaseAsset(platform2, arch2) {
 // src/runtimeInstaller.ts
 var Yauzl = __toESM(require_yauzl(), 1);
 import * as NodeCrypto7 from "node:crypto";
-import * as NodeFS from "node:fs";
+import * as NodeFS2 from "node:fs";
 import * as NodeFSP11 from "node:fs/promises";
-import * as NodePath11 from "node:path";
+import * as NodePath12 from "node:path";
 import * as NodeStream2 from "node:stream";
 import * as NodeStreamPromises from "node:stream/promises";
 var DOWNLOAD_TIMEOUT_MS = 45 * 60 * 1e3;
@@ -32918,7 +33025,7 @@ async function sweepStaging(versionsDir) {
   }
   for (const name of names) {
     if (!name.startsWith(STAGING_PREFIX)) continue;
-    await removeTree(NodePath11.join(versionsDir, name)).catch(() => void 0);
+    await removeTree(NodePath12.join(versionsDir, name)).catch(() => void 0);
   }
 }
 async function downloadArchive(input2, archivePath) {
@@ -32973,7 +33080,7 @@ async function downloadArchive(input2, archivePath) {
     await NodeStreamPromises.pipeline(
       NodeStream2.Readable.fromWeb(response.body),
       meter,
-      NodeFS.createWriteStream(archivePath, { flags: "wx", mode: 384 }),
+      NodeFS2.createWriteStream(archivePath, { flags: "wx", mode: 384 }),
       { signal: input2.downloadSignal }
     );
   } catch (error62) {
@@ -33085,7 +33192,7 @@ async function extractPair(archivePath, outDirectory, asset) {
         await NodeStreamPromises.pipeline(
           await openEntry(zip, entry),
           limiter,
-          NodeFS.createWriteStream(NodePath11.join(outDirectory, entry.fileName), {
+          NodeFS2.createWriteStream(NodePath12.join(outDirectory, entry.fileName), {
             flags: "wx",
             mode: 448
           })
@@ -33127,8 +33234,8 @@ async function validateOrThrow(input2, executable) {
 }
 function executableOf(directory, input2, names) {
   return {
-    executablePath: NodePath11.join(directory, names.executable),
-    harnessPath: NodePath11.join(directory, names.harness),
+    executablePath: NodePath12.join(directory, names.executable),
+    harnessPath: NodePath12.join(directory, names.harness),
     source: "managed",
     version: input2.asset.version,
     managedVersionDirectory: directory
@@ -33174,10 +33281,10 @@ async function installManagedRelease(input2) {
         `Antigravity needs at least ${String(Math.ceil(needed / 1024 / 1024))} MiB of free space to install.`
       );
     }
-    const staging = await NodeFSP11.mkdtemp(NodePath11.join(layout.versionsDir, STAGING_PREFIX));
+    const staging = await NodeFSP11.mkdtemp(NodePath12.join(layout.versionsDir, STAGING_PREFIX));
     try {
-      const archivePath = NodePath11.join(staging, "download.zip");
-      const pairDirectory = NodePath11.join(staging, "runtime");
+      const archivePath = NodePath12.join(staging, "download.zip");
+      const pairDirectory = NodePath12.join(staging, "runtime");
       await NodeFSP11.mkdir(pairDirectory);
       const downloaded = await downloadArchive(input2, archivePath);
       if (downloaded.bytes !== asset.archiveBytes || downloaded.sha256 !== asset.sha256) {
@@ -33190,8 +33297,8 @@ async function installManagedRelease(input2) {
       await extractPair(archivePath, pairDirectory, asset);
       await NodeFSP11.rm(archivePath, { force: true });
       if (platform2 !== "win32") {
-        await NodeFSP11.chmod(NodePath11.join(pairDirectory, asset.executable.name), 493);
-        await NodeFSP11.chmod(NodePath11.join(pairDirectory, asset.harness.name), 493);
+        await NodeFSP11.chmod(NodePath12.join(pairDirectory, asset.executable.name), 493);
+        await NodeFSP11.chmod(NodePath12.join(pairDirectory, asset.harness.name), 493);
       }
       await validateOrThrow(input2, executableOf(pairDirectory, input2, names));
       await writeReleaseRecord(pairDirectory, {
@@ -33224,7 +33331,7 @@ async function installManagedRelease(input2) {
 
 // src/runtimeValidate.ts
 import { nodeStreamsFromHandle as nodeStreamsFromHandle4 } from "@ycodium-ai/plugin-api/process-stdin";
-import * as NodePath12 from "node:path";
+import * as NodePath13 from "node:path";
 var VALIDATE_REQUEST_TIMEOUT_MS = 9e4;
 var EXIT_WAIT_MS = 1e4;
 var VALIDATE_CLIENT_INFO = { name: "ycodium-agent-antigravity", version: "0.1.0" };
@@ -33246,8 +33353,8 @@ function matchesExpectedRuntime(initializeResult, expectedVersion) {
 }
 async function validateInstalledRuntime(input2) {
   const platform2 = input2.platform ?? HOST_PLATFORM;
-  const profileRoot = NodePath12.join(input2.dataDir, "tmp", "validate-profile");
-  const tempRoot = NodePath12.join(input2.dataDir, "tmp", "validate");
+  const profileRoot = NodePath13.join(input2.dataDir, "tmp", "validate-profile");
+  const tempRoot = NodePath13.join(input2.dataDir, "tmp", "validate");
   await sweepRuntimeTempDirs(profileRoot);
   await sweepRuntimeTempDirs(tempRoot);
   const profile = await createRuntimeTempDir(profileRoot);
@@ -33463,8 +33570,8 @@ function createRuntimeManager(deps) {
         if (!(error62 instanceof AntigravityRuntimeError)) throw error62;
       }
       if (realRoot !== void 0) {
-        const real = await NodeFSP12.realpath(configured).catch(() => NodePath13.resolve(configured));
-        if (real.startsWith(`${realRoot}${NodePath13.sep}`)) return true;
+        const real = await NodeFSP12.realpath(configured).catch(() => NodePath14.resolve(configured));
+        if (real.startsWith(`${realRoot}${NodePath14.sep}`)) return true;
       }
     }
     return false;
@@ -33508,8 +33615,8 @@ function createRuntimeManager(deps) {
     for (const entry of instances) {
       const configured = entry.binaryPath.trim();
       if (configured.length === 0) continue;
-      const target = await NodeFSP12.realpath(configured).catch(() => NodePath13.resolve(configured));
-      if (target.startsWith(`${real}${NodePath13.sep}`)) return true;
+      const target = await NodeFSP12.realpath(configured).catch(() => NodePath14.resolve(configured));
+      if (target.startsWith(`${real}${NodePath14.sep}`)) return true;
     }
     return false;
   };
@@ -33524,11 +33631,11 @@ function createRuntimeManager(deps) {
     try {
       await removeDirectory(directory);
       deps.log.info("removed an old antigravity runtime version", {
-        releaseId: NodePath13.basename(directory)
+        releaseId: NodePath14.basename(directory)
       });
     } catch (error62) {
       deps.log.warn("could not remove an old antigravity runtime version", {
-        releaseId: NodePath13.basename(directory),
+        releaseId: NodePath14.basename(directory),
         error: error62 instanceof Error ? error62.message : String(error62)
       });
     }
@@ -33772,7 +33879,7 @@ var executors = [
 ];
 var index_default = definePlugin({
   id: "agent-antigravity",
-  apiVersion: 20,
+  apiVersion: 21,
   executors,
   activate(ctx) {
     const runtime = createRuntimeManager({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/agent-antigravity",
-  "version": "0.2.3210",
+  "version": "0.2.3214",
   "description": "Google Antigravity executor: runs the Antigravity agent over Agent Client Protocol stdio.",
   "keywords": [
     "ycodium",
@@ -31,9 +31,9 @@
     "typescript": "~6.0.3",
     "vite-plus": "0.2.2",
     "yauzl": "^3.4.0",
+    "ycodium-acp-executor": "0.2.3214",
     "ycodium-executor-testing": "0.0.0",
-    "ycodium-acp-executor": "0.2.3210",
-    "@ycodium-ai/plugin-api": "0.2.3210"
+    "@ycodium-ai/plugin-api": "0.2.3214"
   },
   "ycodium": {
     "plugin": "./dist/index.js",