@ycodium-ai/agent-antigravity 0.2.2888 → 0.2.2896

package/dist/index.js

@@ -25657,6 +25657,60 @@ function approvalOutcomeForDecision(decision, optionId) {
   return decision !== "cancel" && optionId !== void 0 ? { outcome: "selected", optionId } : { outcome: "cancelled" };
 }
 
+// ../../packages/ycodium-acp-executor/src/artifacts.ts
+import * as NodePath from "node:path";
+import * as NodeURL from "node:url";
+function resourceLinkArtifacts(content) {
+  if (content["type"] !== "resource_link" || typeof content["uri"] !== "string") return [];
+  const uri = content["uri"].trim();
+  let path;
+  try {
+    path = uri.toLowerCase().startsWith("file:") ? NodeURL.fileURLToPath(uri) : uri;
+  } catch {
+    return [];
+  }
+  if (!NodePath.isAbsolute(path)) return [];
+  const name = typeof content["name"] === "string" ? content["name"].trim() : "";
+  const mimeType = typeof content["mimeType"] === "string" ? content["mimeType"].trim() : "";
+  return [
+    {
+      path,
+      ...name.length > 0 ? { name } : {},
+      ...mimeType.length > 0 ? { mimeType } : {}
+    }
+  ];
+}
+function acpArtifactEvent(input2) {
+  if (input2.artifacts.length === 0) return void 0;
+  const { toolCallId } = input2;
+  return {
+    ...input2.base,
+    type: "assistant.artifact.produced",
+    payload: {
+      artifacts: input2.artifacts.map((artifact) => ({
+        ...artifact,
+        ...toolCallId !== void 0 ? { toolCallId } : {}
+      }))
+    }
+  };
+}
+function makeArtifactEmitter(input2) {
+  return (artifacts, toolCallId) => {
+    const turnId = input2.turnId();
+    const event = acpArtifactEvent({
+      artifacts,
+      toolCallId,
+      base: {
+        ...input2.stamp(),
+        provider: input2.options.provider,
+        threadId: input2.options.threadId,
+        ...turnId === void 0 ? {} : { turnId }
+      }
+    });
+    if (event !== void 0) input2.emit(event);
+  };
+}
+
 // ../../packages/ycodium-acp-executor/src/event-stream.ts
 var UnboundedEventStream = class {
   subscribers = /* @__PURE__ */ new Set();
@@ -27147,9 +27201,8 @@ function createAcpExecutor(options2) {
       options2.originBindingGeneration === void 0 ? event : { ...event, originBindingGeneration: options2.originBindingGeneration }
     );
   };
-  const emit = (event) => {
-    publish(event);
-  };
+  const emit = publish;
+  const emitArtifacts = makeArtifactEmitter({ emit, stamp, options: options2, turnId: () => activeTurnId });
   const failIfDisposed = () => {
     if (disposed) {
       throw new AcpExecutorDisposedError();
@@ -27252,6 +27305,8 @@ function createAcpExecutor(options2) {
             payload: taskEvent.payload
           });
         }
+        if (nextToolCall.status === "completed" && hookResult && "artifacts" in hookResult)
+          emitArtifacts(hookResult.artifacts ?? [], nextToolCall.toolCallId);
         if (handledByHook || !decision.emit) {
           continue;
         }
@@ -27271,6 +27326,10 @@ function createAcpExecutor(options2) {
         );
         continue;
       }
+      if (event._tag === "AssistantContentBlock") {
+        emitArtifacts(resourceLinkArtifacts(event.content));
+        continue;
+      }
       if (event._tag === "CompactionUpdated") {
         applyCompactionUpdate(event);
         continue;
@@ -28334,7 +28393,7 @@ import { nodeStreamsFromHandle } from "@ycodium-ai/plugin-api/process-stdin";
 import * as NodeCrypto2 from "node:crypto";
 import * as NodeFSP from "node:fs/promises";
 import * as NodeOS from "node:os";
-import * as NodePath from "node:path";
+import * as NodePath2 from "node:path";
 import { mergeLaunchEnv } from "@ycodium-ai/plugin-api/executor";
 
 // src/hostPlatform.ts
@@ -28350,7 +28409,7 @@ function sha256Hex(value) {
 function expandHomePath(value) {
   if (value === "~") return NodeOS.homedir();
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return NodePath.join(NodeOS.homedir(), value.slice(2));
+    return NodePath2.join(NodeOS.homedir(), value.slice(2));
   }
   return value;
 }
@@ -28358,12 +28417,12 @@ function resolveAntigravityDirectories(input2) {
   const key = sha256Hex(input2.instanceId);
   const homePath = input2.homePath.trim();
   const custom2 = homePath.length > 0;
-  const profile = custom2 ? NodePath.resolve(expandHomePath(homePath)) : NodePath.join(input2.dataDir, "profiles", key);
+  const profile = custom2 ? NodePath2.resolve(expandHomePath(homePath)) : NodePath2.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: NodePath.join(input2.dataDir, "tmp", key.slice(0, 12)),
-    modelCacheFile: NodePath.join(input2.dataDir, "model-cache", `${key}.json`),
+    runtimeTempRoot: NodePath2.join(input2.dataDir, "tmp", key.slice(0, 12)),
+    modelCacheFile: NodePath2.join(input2.dataDir, "model-cache", `${key}.json`),
     continuationKey: `antigravity:profile:${sha256Hex(continuationSource).slice(0, 16)}`
   };
 }
@@ -28411,10 +28470,10 @@ function antigravityLaunchArgs(platform2 = HOST_PLATFORM) {
   return platform2 === "linux" ? ["--uid="] : [];
 }
 async function prepareAntigravityProfile(profile) {
-  const acpDirectory = NodePath.join(profile, "antigravity-acp");
+  const acpDirectory = NodePath2.join(profile, "antigravity-acp");
   await NodeFSP.mkdir(acpDirectory, { recursive: true, mode: 448 });
   await NodeFSP.writeFile(
-    NodePath.join(acpDirectory, "settings.json"),
+    NodePath2.join(acpDirectory, "settings.json"),
     `${JSON.stringify({ auth: { type: "oauth-personal" } })}
 `,
     "utf8"
@@ -28423,13 +28482,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(NodePath.join(root, RUN_DIR_PREFIX));
+  const directory = await NodeFSP.mkdtemp(NodePath2.join(root, RUN_DIR_PREFIX));
   liveRuntimeTempDirs.add(directory);
   return directory;
 }
 async function removeRuntimeTempDir(directory) {
   liveRuntimeTempDirs.delete(directory);
-  if (!NodePath.isAbsolute(directory) || !NodePath.basename(directory).startsWith(RUN_DIR_PREFIX)) {
+  if (!NodePath2.isAbsolute(directory) || !NodePath2.basename(directory).startsWith(RUN_DIR_PREFIX)) {
     return false;
   }
   try {
@@ -28449,7 +28508,7 @@ async function sweepRuntimeTempDirs(root) {
   let removed = 0;
   for (const name of names) {
     if (!name.startsWith(RUN_DIR_PREFIX)) continue;
-    const directory = NodePath.join(root, name);
+    const directory = NodePath2.join(root, name);
     if (liveRuntimeTempDirs.has(directory)) continue;
     if (await removeRuntimeTempDir(directory)) removed += 1;
   }
@@ -28881,16 +28940,16 @@ function createBackgroundCommandTracker(input2) {
 
 // src/clientFiles.ts
 import * as NodeFSP2 from "node:fs/promises";
-import * as NodePath2 from "node:path";
+import * as NodePath3 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 = NodePath2.relative(root, candidate);
+  const relative2 = NodePath3.relative(root, candidate);
   if (relative2 === "") return true;
-  const escapes = relative2 === ".." || relative2.startsWith(`..${NodePath2.sep}`);
-  return !escapes && !NodePath2.isAbsolute(relative2);
+  const escapes = relative2 === ".." || relative2.startsWith(`..${NodePath3.sep}`);
+  return !escapes && !NodePath3.isAbsolute(relative2);
 }
 async function realpathOrSelf(target) {
   try {
@@ -28903,13 +28962,13 @@ async function realTarget(resolved) {
   try {
     return await NodeFSP2.realpath(resolved);
   } catch {
-    const parent = NodePath2.dirname(resolved);
+    const parent = NodePath3.dirname(resolved);
     if (parent === resolved) return resolved;
-    return NodePath2.join(await realTarget(parent), NodePath2.basename(resolved));
+    return NodePath3.join(await realTarget(parent), NodePath3.basename(resolved));
   }
 }
 async function resolveInside(requestPath, cwd, roots) {
-  const target = await realTarget(NodePath2.resolve(cwd, requestPath));
+  const target = await realTarget(NodePath3.resolve(cwd, requestPath));
   const realRoots = await Promise.all(roots.map(realpathOrSelf));
   if (!realRoots.some((root) => isInside(root, target))) {
     throw RequestError.invalidParams(
@@ -28971,7 +29030,7 @@ async function writeTextFile(params, roots) {
   const content = requireString(params, "content");
   const filePath = await resolveInside(requestPath, roots.cwd, [roots.cwd]);
   try {
-    await NodeFSP2.mkdir(NodePath2.dirname(filePath), { recursive: true });
+    await NodeFSP2.mkdir(NodePath3.dirname(filePath), { recursive: true });
     await NodeFSP2.writeFile(filePath, content, "utf8");
   } catch {
     throw RequestError.internalError(void 0, `Could not write '${requestPath}'.`);
@@ -29140,7 +29199,7 @@ function forwardCallback(callback, timeoutMs = FORWARD_TIMEOUT_MS) {
 
 // src/modelCache.ts
 import * as NodeFSP3 from "node:fs/promises";
-import * as NodePath3 from "node:path";
+import * as NodePath4 from "node:path";
 var SCHEMA_VERSION = 1;
 function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -29216,7 +29275,7 @@ function updateAntigravityModelCache(file2, patch) {
       ...currentModel === void 0 ? {} : { currentModel },
       models: catalog?.models ?? existing?.models ?? []
     };
-    await NodeFSP3.mkdir(NodePath3.dirname(file2), { recursive: true });
+    await NodeFSP3.mkdir(NodePath4.dirname(file2), { recursive: true });
     const temporary = `${file2}.${String(process.pid)}.tmp`;
     await NodeFSP3.writeFile(temporary, `${JSON.stringify(merged)}
 `, "utf8");
@@ -29236,12 +29295,12 @@ function updateAntigravityModelCache(file2, patch) {
 
 // src/runtime.ts
 import * as NodeFSP5 from "node:fs/promises";
-import * as NodePath5 from "node:path";
+import * as NodePath6 from "node:path";
 
 // src/managedRuntime.ts
 import * as NodeCrypto4 from "node:crypto";
 import * as NodeFSP4 from "node:fs/promises";
-import * as NodePath4 from "node:path";
+import * as NodePath5 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;
@@ -29249,15 +29308,15 @@ var ManagedRuntimeInvalidError = class extends Error {
   name = "ManagedRuntimeInvalidError";
 };
 function managedLayout(dataDir, platform2, arch2) {
-  const root = NodePath4.join(dataDir, "runtime", `${platform2}-${arch2}`);
+  const root = NodePath5.join(dataDir, "runtime", `${platform2}-${arch2}`);
   return {
     root,
-    versionsDir: NodePath4.join(root, "versions"),
-    activeFile: NodePath4.join(root, "active.json")
+    versionsDir: NodePath5.join(root, "versions"),
+    activeFile: NodePath5.join(root, "active.json")
   };
 }
 function versionDirectoryOf(layout, releaseId) {
-  return NodePath4.join(layout.versionsDir, releaseId);
+  return NodePath5.join(layout.versionsDir, releaseId);
 }
 function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -29315,7 +29374,7 @@ async function readCompletedRelease(input2) {
   const directory = versionDirectoryOf(input2.layout, input2.releaseId);
   let parsed;
   try {
-    parsed = await readSmallJson(NodePath4.join(directory, RELEASE_RECORD_FILE));
+    parsed = await readSmallJson(NodePath5.join(directory, RELEASE_RECORD_FILE));
   } catch (error62) {
     if (isMissing(error62)) throw incomplete;
     throw error62;
@@ -29327,8 +29386,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 = NodePath4.join(directory, executable.name);
-  const harnessPath = NodePath4.join(directory, harness.name);
+  const executablePath = NodePath5.join(directory, executable.name);
+  const harnessPath = NodePath5.join(directory, harness.name);
   if (!await isExecutableFile(executablePath, executable.bytes, input2.platform) || !await isExecutableFile(harnessPath, harness.bytes, input2.platform)) {
     throw incomplete;
   }
@@ -29347,7 +29406,7 @@ async function readActiveRelease(input2) {
 }
 async function writeReleaseRecord(directory, record2) {
   await NodeFSP4.writeFile(
-    NodePath4.join(directory, RELEASE_RECORD_FILE),
+    NodePath5.join(directory, RELEASE_RECORD_FILE),
     `${JSON.stringify(record2)}
 `,
     { flag: "wx", mode: 384 }
@@ -29355,7 +29414,7 @@ async function writeReleaseRecord(directory, record2) {
 }
 async function writeActiveRelease(layout, releaseId) {
   await NodeFSP4.mkdir(layout.root, { recursive: true });
-  const pending = NodePath4.join(
+  const pending = NodePath5.join(
     layout.root,
     `active.json.${NodeCrypto4.randomBytes(6).toString("hex")}.tmp`
   );
@@ -29403,14 +29462,14 @@ function readPathValue(instanceEnvironment, processEnv, platform2) {
   return lookup(instanceEnvironment) ?? lookup(processEnv) ?? "";
 }
 function pathCandidates(binary, pathValue) {
-  return pathValue.split(NodePath5.delimiter).map((directory) => directory.trim().replace(/^"|"$/gu, "")).filter((directory) => directory.length > 0).map((directory) => NodePath5.resolve(directory, binary));
+  return pathValue.split(NodePath6.delimiter).map((directory) => directory.trim().replace(/^"|"$/gu, "")).filter((directory) => directory.length > 0).map((directory) => NodePath6.resolve(directory, binary));
 }
 async function managedDirectoryOf(executablePath, managed) {
   if (managed === void 0) return null;
   try {
     const realVersions = await NodeFSP5.realpath(managed.versionsDir);
-    const directory = NodePath5.dirname(executablePath);
-    return NodePath5.dirname(directory) === realVersions && RELEASE_ID_PATTERN.test(NodePath5.basename(directory)) ? directory : null;
+    const directory = NodePath6.dirname(executablePath);
+    return NodePath6.dirname(directory) === realVersions && RELEASE_ID_PATTERN.test(NodePath6.basename(directory)) ? directory : null;
   } catch {
     return null;
   }
@@ -29423,7 +29482,7 @@ async function resolveAntigravityExecutable(input2) {
   const accept = async (candidate, source) => {
     if (!await isExecutableFile2(candidate, platform2)) return void 0;
     const executablePath = await NodeFSP5.realpath(candidate);
-    const harnessPath = NodePath5.join(NodePath5.dirname(executablePath), names.harness);
+    const harnessPath = NodePath6.join(NodePath6.dirname(executablePath), names.harness);
     if (!await isExecutableFile2(harnessPath, platform2)) return void 0;
     return {
       executablePath,
@@ -29434,7 +29493,7 @@ async function resolveAntigravityExecutable(input2) {
     };
   };
   if (configured.length > 0) {
-    const candidates = NodePath5.isAbsolute(configured) || configured.includes("/") || configured.includes("\\") ? [NodePath5.resolve(configured)] : pathCandidates(configured, pathValue);
+    const candidates = NodePath6.isAbsolute(configured) || configured.includes("/") || configured.includes("\\") ? [NodePath6.resolve(configured)] : pathCandidates(configured, pathValue);
     for (const candidate of candidates) {
       const found = await accept(candidate, "configured");
       if (found !== void 0) return found;
@@ -29473,10 +29532,10 @@ async function resolveAntigravityExecutable(input2) {
 
 // src/signedInMarker.ts
 import * as NodeFSP6 from "node:fs/promises";
-import * as NodePath6 from "node:path";
+import * as NodePath7 from "node:path";
 var SCHEMA_VERSION2 = 1;
 function signedInMarkerFile(profile) {
-  return NodePath6.join(profile, "antigravity-acp", "ycodium-signed-in.json");
+  return NodePath7.join(profile, "antigravity-acp", "ycodium-signed-in.json");
 }
 async function readSignedInMarker(file2) {
   try {
@@ -29487,7 +29546,7 @@ async function readSignedInMarker(file2) {
   }
 }
 async function writeSignedInMarker(file2) {
-  await NodeFSP6.mkdir(NodePath6.dirname(file2), { recursive: true, mode: 448 });
+  await NodeFSP6.mkdir(NodePath7.dirname(file2), { recursive: true, mode: 448 });
   const temporary = `${file2}.${String(process.pid)}.tmp`;
   await NodeFSP6.writeFile(
     temporary,
@@ -30260,14 +30319,14 @@ import { nodeStreamsFromHandle as nodeStreamsFromHandle2 } from "@ycodium-ai/plu
 
 // src/sessionFiles.ts
 import * as NodeFSP7 from "node:fs/promises";
-import * as NodePath7 from "node:path";
+import * as NodePath8 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 = NodePath7.join(input2.profile, "antigravity-acp");
-  const base = NodePath7.join(acpDirectory, "conversations", sessionId);
+  const acpDirectory = NodePath8.join(input2.profile, "antigravity-acp");
+  const base = NodePath8.join(acpDirectory, "conversations", sessionId);
   try {
     const meta3 = JSON.parse(await NodeFSP7.readFile(`${base}.meta`, "utf8"));
     const cwd = typeof meta3 === "object" && meta3 !== null ? meta3.cwd : null;
@@ -30275,7 +30334,7 @@ async function removeTemporarySessionFiles(input2) {
     for (const suffix of SESSION_FILE_SUFFIXES) {
       await NodeFSP7.rm(`${base}${suffix}`, { force: true });
     }
-    await NodeFSP7.rm(NodePath7.join(acpDirectory, "brain", sessionId), {
+    await NodeFSP7.rm(NodePath8.join(acpDirectory, "brain", sessionId), {
       recursive: true,
       force: true
     });
@@ -30287,7 +30346,7 @@ async function removeTemporarySessionFiles(input2) {
 
 // src/textGenerationAvailability.ts
 import * as NodeFSP8 from "node:fs/promises";
-import * as NodePath8 from "node:path";
+import * as NodePath9 from "node:path";
 var MAX_CONFIG_BYTES = 64e3;
 var CONFIG_FILES = [
   { name: "hooks.json", key: "hooks" },
@@ -30308,7 +30367,7 @@ async function configIsEmpty(file2, key) {
 }
 async function isTextGenerationAvailable(profile) {
   for (const { name, key } of CONFIG_FILES) {
-    const file2 = NodePath8.join(profile, "config", name);
+    const file2 = NodePath9.join(profile, "config", name);
     try {
       await NodeFSP8.lstat(file2);
     } catch (error62) {
@@ -31052,7 +31111,7 @@ function antigravityPermissionUserInput(request2) {
 // src/userSkills.ts
 import * as NodeFSP10 from "node:fs/promises";
 import * as NodeOS2 from "node:os";
-import * as NodePath9 from "node:path";
+import * as NodePath10 from "node:path";
 var ANTIGRAVITY_SKILL_SCAN_LIMITS = {
   maxSkillBytes: 1e6,
   maxScanBytes: 8e6,
@@ -31070,24 +31129,24 @@ function resolveAntigravityUserHome(platform2, environment) {
 }
 function antigravityUserSkillDirectories(geminiHome) {
   return [
-    NodePath9.join(geminiHome, "config", "skills"),
-    NodePath9.join(geminiHome, "antigravity-cli", "skills")
+    NodePath10.join(geminiHome, "config", "skills"),
+    NodePath10.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, NodePath9.resolve(link), target)) return "kept";
+  if (sameFilePath(platform2, NodePath10.resolve(link), target)) return "kept";
   const existing = await NodeFSP10.lstat(link).catch((error62) => {
     if (error62.code === "ENOENT") return void 0;
     throw error62;
   });
   if (existing !== void 0) {
     if (!existing.isSymbolicLink()) return "kept";
-    const current = NodePath9.resolve(NodePath9.dirname(link), await NodeFSP10.readlink(link));
+    const current = NodePath10.resolve(NodePath10.dirname(link), await NodeFSP10.readlink(link));
     if (sameFilePath(platform2, current, target)) return "already";
     await NodeFSP10.unlink(link);
   }
-  await NodeFSP10.mkdir(NodePath9.dirname(link), { recursive: true });
+  await NodeFSP10.mkdir(NodePath10.dirname(link), { recursive: true });
   try {
     await NodeFSP10.symlink(target, link, platform2 === "win32" ? "junction" : "dir");
   } catch (error62) {
@@ -31098,7 +31157,7 @@ async function linkOne(link, target, platform2) {
 async function linkAntigravityUserSkills(input2) {
   const links = antigravityUserSkillDirectories(input2.profile);
   const targets = antigravityUserSkillDirectories(
-    NodePath9.resolve(NodePath9.join(input2.userHome, ".gemini"))
+    NodePath10.resolve(NodePath10.join(input2.userHome, ".gemini"))
   );
   const results = [];
   for (const [index, link] of links.entries()) {
@@ -31231,7 +31290,7 @@ async function readSkillFile(skillPath, budget, maxSkillBytes) {
   }
 }
 async function discoverAntigravityUserSkills(userHome, limits = ANTIGRAVITY_SKILL_SCAN_LIMITS) {
-  const roots = antigravityUserSkillDirectories(NodePath9.join(userHome, ".gemini"));
+  const roots = antigravityUserSkillDirectories(NodePath10.join(userHome, ".gemini"));
   const budget = {
     remainingBytes: limits.maxScanBytes,
     remainingEntries: limits.maxScanEntries
@@ -31255,7 +31314,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 = NodePath9.join(directory, skillFileName);
+      const skillPath = NodePath10.join(directory, skillFileName);
       const contents = await readSkillFile(skillPath, budget, limits.maxSkillBytes);
       if (contents === void 0) return;
       const skill = parseSkillFile(contents, skillFileName);
@@ -31271,7 +31330,7 @@ async function discoverAntigravityUserSkills(userHome, limits = ANTIGRAVITY_SKIL
     }
     if (!scanChildren) return;
     for (const entry of sorted.toSorted(compareSkillEntries)) {
-      await scanDirectory(NodePath9.join(directory, entry), false);
+      await scanDirectory(NodePath10.join(directory, entry), false);
     }
   };
   for (const root of roots) await scanDirectory(root, true);
@@ -31996,7 +32055,7 @@ function registerRuntimeCommands(ctx, manager) {
 
 // src/runtimeManager.ts
 import * as NodeFSP12 from "node:fs/promises";
-import * as NodePath12 from "node:path";
+import * as NodePath13 from "node:path";
 
 // src/release.ts
 var ANTIGRAVITY_RELEASE_VERSION = "agy_acp_server_1.1.1";
@@ -32066,7 +32125,7 @@ var Yauzl = __toESM(require_yauzl(), 1);
 import * as NodeCrypto6 from "node:crypto";
 import * as NodeFS from "node:fs";
 import * as NodeFSP11 from "node:fs/promises";
-import * as NodePath10 from "node:path";
+import * as NodePath11 from "node:path";
 import * as NodeStream2 from "node:stream";
 import * as NodeStreamPromises from "node:stream/promises";
 var DOWNLOAD_TIMEOUT_MS = 45 * 60 * 1e3;
@@ -32106,7 +32165,7 @@ async function sweepStaging(versionsDir) {
   }
   for (const name of names) {
     if (!name.startsWith(STAGING_PREFIX)) continue;
-    await removeTree(NodePath10.join(versionsDir, name)).catch(() => void 0);
+    await removeTree(NodePath11.join(versionsDir, name)).catch(() => void 0);
   }
 }
 async function downloadArchive(input2, archivePath) {
@@ -32273,7 +32332,7 @@ async function extractPair(archivePath, outDirectory, asset) {
         await NodeStreamPromises.pipeline(
           await openEntry(zip, entry),
           limiter,
-          NodeFS.createWriteStream(NodePath10.join(outDirectory, entry.fileName), {
+          NodeFS.createWriteStream(NodePath11.join(outDirectory, entry.fileName), {
             flags: "wx",
             mode: 448
           })
@@ -32315,8 +32374,8 @@ async function validateOrThrow(input2, executable) {
 }
 function executableOf(directory, input2, names) {
   return {
-    executablePath: NodePath10.join(directory, names.executable),
-    harnessPath: NodePath10.join(directory, names.harness),
+    executablePath: NodePath11.join(directory, names.executable),
+    harnessPath: NodePath11.join(directory, names.harness),
     source: "managed",
     version: input2.asset.version,
     managedVersionDirectory: directory
@@ -32362,10 +32421,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(NodePath10.join(layout.versionsDir, STAGING_PREFIX));
+    const staging = await NodeFSP11.mkdtemp(NodePath11.join(layout.versionsDir, STAGING_PREFIX));
     try {
-      const archivePath = NodePath10.join(staging, "download.zip");
-      const pairDirectory = NodePath10.join(staging, "runtime");
+      const archivePath = NodePath11.join(staging, "download.zip");
+      const pairDirectory = NodePath11.join(staging, "runtime");
       await NodeFSP11.mkdir(pairDirectory);
       const downloaded = await downloadArchive(input2, archivePath);
       if (downloaded.bytes !== asset.archiveBytes || downloaded.sha256 !== asset.sha256) {
@@ -32378,8 +32437,8 @@ async function installManagedRelease(input2) {
       await extractPair(archivePath, pairDirectory, asset);
       await NodeFSP11.rm(archivePath, { force: true });
       if (platform2 !== "win32") {
-        await NodeFSP11.chmod(NodePath10.join(pairDirectory, asset.executable.name), 493);
-        await NodeFSP11.chmod(NodePath10.join(pairDirectory, asset.harness.name), 493);
+        await NodeFSP11.chmod(NodePath11.join(pairDirectory, asset.executable.name), 493);
+        await NodeFSP11.chmod(NodePath11.join(pairDirectory, asset.harness.name), 493);
       }
       await validateOrThrow(input2, executableOf(pairDirectory, input2, names));
       await writeReleaseRecord(pairDirectory, {
@@ -32412,7 +32471,7 @@ async function installManagedRelease(input2) {
 
 // src/runtimeValidate.ts
 import { nodeStreamsFromHandle as nodeStreamsFromHandle4 } from "@ycodium-ai/plugin-api/process-stdin";
-import * as NodePath11 from "node:path";
+import * as NodePath12 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" };
@@ -32448,8 +32507,8 @@ async function waitForExit2(handle) {
 }
 async function validateInstalledRuntime(input2) {
   const platform2 = input2.platform ?? HOST_PLATFORM;
-  const profileRoot = NodePath11.join(input2.dataDir, "tmp", "validate-profile");
-  const tempRoot = NodePath11.join(input2.dataDir, "tmp", "validate");
+  const profileRoot = NodePath12.join(input2.dataDir, "tmp", "validate-profile");
+  const tempRoot = NodePath12.join(input2.dataDir, "tmp", "validate");
   await sweepRuntimeTempDirs(profileRoot);
   await sweepRuntimeTempDirs(tempRoot);
   const profile = await createRuntimeTempDir(profileRoot);
@@ -32662,8 +32721,8 @@ function createRuntimeManager(deps) {
         if (!(error62 instanceof AntigravityRuntimeError)) throw error62;
       }
       if (realRoot !== void 0) {
-        const real = await NodeFSP12.realpath(configured).catch(() => NodePath12.resolve(configured));
-        if (real.startsWith(`${realRoot}${NodePath12.sep}`)) return true;
+        const real = await NodeFSP12.realpath(configured).catch(() => NodePath13.resolve(configured));
+        if (real.startsWith(`${realRoot}${NodePath13.sep}`)) return true;
       }
     }
     return false;
@@ -32707,8 +32766,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(() => NodePath12.resolve(configured));
-      if (target.startsWith(`${real}${NodePath12.sep}`)) return true;
+      const target = await NodeFSP12.realpath(configured).catch(() => NodePath13.resolve(configured));
+      if (target.startsWith(`${real}${NodePath13.sep}`)) return true;
     }
     return false;
   };
@@ -32723,11 +32782,11 @@ function createRuntimeManager(deps) {
     try {
       await removeDirectory(directory);
       deps.log.info("removed an old antigravity runtime version", {
-        releaseId: NodePath12.basename(directory)
+        releaseId: NodePath13.basename(directory)
       });
     } catch (error62) {
       deps.log.warn("could not remove an old antigravity runtime version", {
-        releaseId: NodePath12.basename(directory),
+        releaseId: NodePath13.basename(directory),
         error: error62 instanceof Error ? error62.message : String(error62)
       });
     }

package/package.json

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