@dotobokuri/fleet-console 1.71.1 → 1.72.0

package/dist/fleet-plugins/terminal/routes.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import * as path18 from 'node:path';
-import path18__default, { posix } from 'node:path';
+import * as path19 from 'node:path';
+import path19__default, { posix } from 'node:path';
 import * as fs9 from 'node:fs';
 import fs9__default, { existsSync, readFileSync, lstatSync, rmSync, mkdirSync, mkdtempSync, writeFileSync, chmodSync, promises, renameSync as renameSync$1, readdirSync, closeSync, fstatSync, accessSync, constants as constants$1, realpathSync, openSync } from 'node:fs';
 import * as os3 from 'node:os';
@@ -8,9 +8,9 @@ import os3__default, { tmpdir, homedir } from 'node:os';
 import { randomUUID, createHash } from 'crypto';
 import * as fs42 from 'fs';
 import { constants, mkdirSync as mkdirSync$1, rmSync as rmSync$1, renameSync, appendFileSync, statSync } from 'fs';
-import * as path32 from 'path';
-import path32__default, { dirname } from 'path';
-import { execFile } from 'child_process';
+import * as path42 from 'path';
+import path42__default, { dirname } from 'path';
+import { execFile, spawn } from 'child_process';
 import fs22, { appendFile, chmod, mkdir, stat, unlink, rename as rename$1 } from 'fs/promises';
 import os5 from 'os';
 import { promisify } from 'util';
@@ -61,8 +61,8 @@ var FLEET_DATA_DIR_NAME = ".fleet";
 var FLEET_DATA_DIR_ENV = "FLEET_DATA_DIR";
 function getFleetDataDir(env = process.env) {
   const override = env[FLEET_DATA_DIR_ENV];
-  if (override === void 0 || override.trim().length === 0) return path18.join(os3.homedir(), FLEET_DATA_DIR_NAME);
-  if (!path18.isAbsolute(override)) throw new Error(`${FLEET_DATA_DIR_ENV} must be an absolute path, received: ${override}`);
+  if (override === void 0 || override.trim().length === 0) return path19.join(os3.homedir(), FLEET_DATA_DIR_NAME);
+  if (!path19.isAbsolute(override)) throw new Error(`${FLEET_DATA_DIR_ENV} must be an absolute path, received: ${override}`);
   return override;
 }
 var SECURE_DIR_MODE = 448;
@@ -95,9 +95,9 @@ function ensureSafeDirectory(dirPath) {
   fs9.chmodSync(dirPath, SECURE_DIR_MODE);
 }
 function assertWithinRoot(root, candidatePath) {
-  const resolvedRoot = path18.resolve(root);
-  const resolvedCandidate = path18.resolve(candidatePath);
-  if (!resolvedCandidate.startsWith(`${resolvedRoot}${path18.sep}`) && resolvedCandidate !== resolvedRoot) {
+  const resolvedRoot = path19.resolve(root);
+  const resolvedCandidate = path19.resolve(candidatePath);
+  if (!resolvedCandidate.startsWith(`${resolvedRoot}${path19.sep}`) && resolvedCandidate !== resolvedRoot) {
     throw new Error(`Path escapes root: ${candidatePath}`);
   }
 }
@@ -158,7 +158,7 @@ function cleanupTempFiles(dir, prefix, minAgeMs, now) {
     if (!entry.startsWith(prefix)) {
       continue;
     }
-    const tempPath = path18.join(dir, entry);
+    const tempPath = path19.join(dir, entry);
     try {
       const stat4 = fs9.lstatSync(tempPath);
       if (stat4?.isFile() && !stat4.isSymbolicLink() && now - stat4.mtimeMs >= minAgeMs) {
@@ -264,7 +264,7 @@ function writeLockOwner(lockDir, ownerFileName, startedAt) {
     hostname: os3.hostname(),
     startedAt
   };
-  const ownerPath = path18.join(lockDir, ownerFileName);
+  const ownerPath = path19.join(lockDir, ownerFileName);
   try {
     fs9.writeFileSync(ownerPath, JSON.stringify(owner), { encoding: "utf-8", mode: 384 });
   } catch (error51) {
@@ -273,7 +273,7 @@ function writeLockOwner(lockDir, ownerFileName, startedAt) {
   }
 }
 function readLockOwner(lockDir, ownerFileName) {
-  const ownerPath = path18.join(lockDir, ownerFileName);
+  const ownerPath = path19.join(lockDir, ownerFileName);
   try {
     return sanitizeLockOwner(JSON.parse(fs9.readFileSync(ownerPath, "utf-8")));
   } catch (error51) {
@@ -331,7 +331,7 @@ function sleepSync(ms) {
 }
 
 // ../../packages/core-infra/src/auth/auth-storage.ts
-var DEFAULT_AUTH_PATH = path18.join(getFleetDataDir(), "auth.json");
+var DEFAULT_AUTH_PATH = path19.join(getFleetDataDir(), "auth.json");
 var AUTH_LOCK_OWNER_FILE_NAME = "owner.json";
 var AUTH_LOCK_TIMEOUT_MS = 5e3;
 function readAuthStoreFile(filePath) {
@@ -406,7 +406,7 @@ function createAuthService(deps = {}) {
       }
     },
     async setApiKey(providerId, key) {
-      const dir = path18.dirname(authPath);
+      const dir = path19.dirname(authPath);
       ensureSafeDirectory(dir);
       withAuthLock(authPath, lockDir, () => {
         const data = fs9.existsSync(authPath) ? readAuthStoreFile(authPath) : {};
@@ -442,7 +442,7 @@ function createDurableJsonStore(deps) {
   const sensitivity = deps.sensitivity;
   const mode = sensitivity === "sensitive" ? SECURE_FILE_MODE : 420;
   const minAgeMs = deps.tempCleanupMinAgeMs ?? DEFAULT_TEMP_FILE_MIN_AGE_MS;
-  const dir = path18.dirname(deps.filePath);
+  const dir = path19.dirname(deps.filePath);
   return {
     path: deps.filePath,
     load() {
@@ -542,8 +542,8 @@ function updateGlobalOptions(store, mutate) {
 }
 function createGlobalOptionsStore(deps = {}) {
   const dataDir = deps.dataDir ?? getFleetDataDir();
-  const optionsPath = path18.join(dataDir, GLOBAL_OPTIONS_FILE_NAME);
-  const lockDir = path18.join(dataDir, LOCK_DIR_NAME);
+  const optionsPath = path19.join(dataDir, GLOBAL_OPTIONS_FILE_NAME);
+  const lockDir = path19.join(dataDir, LOCK_DIR_NAME);
   const store = createDurableJsonStore({
     filePath: optionsPath,
     lockDir,
@@ -684,7 +684,7 @@ function getWorkspaceDirectoryRoot(dataDir) {
   if (!dataDir.trim()) {
     throw new Error("Fleet data directory is required");
   }
-  return path18.join(path18.resolve(dataDir), WORKSPACES_DIRECTORY_NAME);
+  return path19.join(path19.resolve(dataDir), WORKSPACES_DIRECTORY_NAME);
 }
 function resolveWorkspaceDirectory(dataDir, cwd) {
   const canonicalCwd = canonicalizeWorkspaceCwd(cwd);
@@ -692,7 +692,7 @@ function resolveWorkspaceDirectory(dataDir, cwd) {
 }
 function ensureWorkspaceDirectory(dataDir, cwd) {
   const workspace = resolveWorkspaceDirectory(dataDir, cwd);
-  const resolvedDataDir = path18.resolve(dataDir);
+  const resolvedDataDir = path19.resolve(dataDir);
   ensureSafeDirectory(resolvedDataDir);
   ensureSafeDirectory(workspace.root);
   assertWithinRoot(workspace.root, workspace.path);
@@ -717,11 +717,11 @@ function ensureWorkspaceDirectory(dataDir, cwd) {
 function buildWorkspaceDirectory(dataDir, name, cwd) {
   assertWorkspaceDirectoryName(name);
   const root = getWorkspaceDirectoryRoot(dataDir);
-  const workspacePath = path18.join(root, name);
+  const workspacePath = path19.join(root, name);
   assertWithinRoot(root, workspacePath);
   return {
     cwd,
-    identityPath: path18.join(workspacePath, WORKSPACE_IDENTITY_FILE_NAME),
+    identityPath: path19.join(workspacePath, WORKSPACE_IDENTITY_FILE_NAME),
     name,
     path: workspacePath,
     root
@@ -731,7 +731,7 @@ function canonicalizeWorkspaceCwd(cwd) {
   if (!cwd.trim()) {
     throw new Error("Workspace cwd is required");
   }
-  return fs9.realpathSync.native(path18.resolve(cwd));
+  return fs9.realpathSync.native(path19.resolve(cwd));
 }
 function assertWorkspaceDirectoryName(name) {
   if (!name || !WORKSPACE_NAME_PATTERN.test(name)) {
@@ -893,12 +893,12 @@ function writeLaunchPromptPointer(body, onCleanup, cmdWrapped) {
   return written.instruction;
 }
 function writeLaunchPromptFile(body, onCleanup) {
-  const tempRoot = path18__default.resolve(os3__default.tmpdir());
+  const tempRoot = path19__default.resolve(os3__default.tmpdir());
   mkdirSync(tempRoot, { recursive: true });
-  const tempDir = mkdtempSync(path18__default.join(tempRoot, LAUNCH_PROMPT_TEMP_DIR_PREFIX));
+  const tempDir = mkdtempSync(path19__default.join(tempRoot, LAUNCH_PROMPT_TEMP_DIR_PREFIX));
   const cleanup = () => rmBestEffort(tempDir);
   try {
-    const filePath = path18__default.join(tempDir, LAUNCH_PROMPT_FILE_NAME);
+    const filePath = path19__default.join(tempDir, LAUNCH_PROMPT_FILE_NAME);
     writeFileSync(filePath, body, { encoding: "utf8", flag: "wx", mode: LAUNCH_PROMPT_FILE_MODE });
     chmodBestEffort(filePath, LAUNCH_PROMPT_FILE_MODE);
     onCleanup(cleanup);
@@ -20464,6 +20464,27 @@ function isClaudeUsageLimitDirective(text2) {
 function omitClaudeWebSearchTools(request) {
   return omitClaudeClientTools(request, CLAUDE_WEB_SEARCH_TOOL_IDENTIFIERS);
 }
+var CLAUDE_BILLING_HEADER_BLOCK = /^\s*x-anthropic-billing-header:[^\n]*[ \t]*$/;
+var CLAUDE_CLIENT_IDENTITY_SENTENCES = [
+  "You are Claude Code, Anthropic's official CLI for Claude.",
+  "You are a Claude agent, built on Anthropic's Claude Agent SDK."
+];
+var CLAUDE_IDENTITY_MAX_BLOCK_LENGTH = Math.max(...CLAUDE_CLIENT_IDENTITY_SENTENCES.map((sentence) => sentence.length)) + 16;
+function stripClaudeClientIdentity(system) {
+  if (system === void 0) return { system, changed: false, removed: 0 };
+  const kept = system.filter((block) => !isClaudeClientIdentityBlock(block));
+  const removed = system.length - kept.length;
+  if (removed === 0) return { system, changed: false, removed: 0 };
+  return { system: kept.length > 0 ? kept : void 0, changed: true, removed };
+}
+function isClaudeClientIdentityBlock(block) {
+  const text2 = block.text;
+  if (typeof text2 !== "string") return false;
+  if (CLAUDE_BILLING_HEADER_BLOCK.test(text2)) return true;
+  if (text2.length > CLAUDE_IDENTITY_MAX_BLOCK_LENGTH) return false;
+  const trimmed = text2.trim();
+  return CLAUDE_CLIENT_IDENTITY_SENTENCES.includes(trimmed);
+}
 var benchmarks_default = {
   version: 2,
   sources: {
@@ -20683,6 +20704,46 @@ var models_default = {
   version: 1,
   updatedAt: "2026-08-22T00:00:00Z",
   providers: {
+    antigravity: {
+      name: "Antigravity",
+      defaultModel: "gemini-3.7-flash",
+      source: "live POST https://daily-cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels read with the credential the Antigravity CLI (agy 1.1.18) owns, 2026-08-22; the same read reported defaultAgentModelId gemini-3.7-flash-high and a deprecatedModelIds entry mapping gemini-3.1-pro-high to gemini-pro-agent, and a live streamGenerateContent probe on that date confirmed gemini-3.1-pro-high is refused with INVALID_ARGUMENT while gemini-pro-agent answers. Effort spelling was measured per model on one fixed prompt: gemini-3.7-flash-tiered honours generationConfig.thinkingConfig.thinkingLevel (343 / 407 / 434 reasoning tokens at low / medium / high) so its ladder is a request field, while Gemini 3.1 Pro encodes the rung in the wire id. thinkingLevel accepts low, medium, and high only: minimal and max are both refused. Claude and GPT-OSS models are served by the same subscription but are deliberately not exposed here",
+      models: [
+        {
+          modelId: "gemini-3.7-flash",
+          name: "Gemini-3.7-Flash",
+          capabilityClass: "light",
+          providerModelId: "gemini-3.7-flash-tiered",
+          contextWindow: 1048576,
+          effort: {
+            supported: true,
+            levels: [
+              "low",
+              "medium",
+              "high"
+            ]
+          }
+        },
+        {
+          modelId: "gemini-3.1-pro",
+          name: "Gemini-3.1-Pro",
+          capabilityClass: "flagship",
+          providerModelId: "gemini-3.1-pro-low",
+          contextWindow: 1048576,
+          effort: {
+            supported: true,
+            levels: [
+              "low",
+              "high"
+            ],
+            upstreamModelIds: {
+              low: "gemini-3.1-pro-low",
+              high: "gemini-pro-agent"
+            }
+          }
+        }
+      ]
+    },
     codex: {
       name: "Codex",
       defaultModel: "gpt-5.6-sol",
@@ -21681,7 +21742,7 @@ var models_default = {
 var KIMI_AUTH_PROVIDER_ID = "Claude Code with Moonshot Kimi";
 var KIMI_CODE_API_BASE_URL = "https://api.kimi.com/coding";
 var KIMI_CODE_MODEL = "k3";
-var GATEWAY_PROVIDERS = ["codex", "xai", "cursor", "opencode", "kimi"];
+var GATEWAY_PROVIDERS = ["codex", "xai", "cursor", "opencode", "antigravity", "kimi"];
 var GATEWAY_MODEL_WIRES = ["anthropic", "responses", "chat-completions"];
 var GATEWAY_REASONING_EFFORTS = [
   "low",
@@ -21789,7 +21850,8 @@ var GatewayModelsRegistrySchema = external_exports.object({
     cursor: GatewayProviderSchema,
     kimi: GatewayProviderSchema,
     opencode: GatewayProviderSchema,
-    xai: GatewayProviderSchema
+    xai: GatewayProviderSchema,
+    antigravity: GatewayProviderSchema
   }).strict(),
   pricing: GatewayPricingRegistrySchema
 }).strict();
@@ -21815,7 +21877,6 @@ var registry2 = (() => {
   return parsed;
 })();
 var GATEWAY_MODELS_UPDATED_AT = registry2.updatedAt;
-registry2.pricing.observedAt;
 Object.freeze(
   Object.fromEntries(
     Object.entries(registry2.pricing.models).map(([modelId, pricing]) => [
@@ -22101,8 +22162,8 @@ function validateRegistry(value) {
           }
         }
         if (exactModelIds) {
-          if (provider !== "cursor") {
-            throw new Error(`Gateway effort model id overrides are only supported by Cursor: ${provider}/${model.modelId}`);
+          if (provider !== "cursor" && provider !== "antigravity") {
+            throw new Error(`Gateway effort model id overrides are only supported by Cursor and Antigravity: ${provider}/${model.modelId}`);
           }
           for (const effort of Object.keys(exactModelIds)) {
             if (!model.effort.levels.includes(effort)) {
@@ -24528,6 +24589,967 @@ function anthropicNativeHeaders(requestHeaders) {
   }
   return headers;
 }
+var execFileAsync = promisify(execFile);
+var MAX_CREDENTIAL_BYTES = 65536;
+var CREDENTIAL_OPEN_FLAGS = process.platform === "win32" ? constants.O_RDONLY : constants.O_RDONLY | constants.O_NONBLOCK;
+async function readBoundedFile(filePath, maxBytes) {
+  const handle = await fs22.open(filePath, CREDENTIAL_OPEN_FLAGS);
+  try {
+    const stat22 = await handle.stat();
+    if (!stat22.isFile() || stat22.size > maxBytes) return null;
+    const buffer = Buffer.allocUnsafe(maxBytes + 1);
+    let totalBytes = 0;
+    while (totalBytes < buffer.byteLength) {
+      const { bytesRead } = await handle.read(
+        buffer,
+        totalBytes,
+        buffer.byteLength - totalBytes,
+        totalBytes
+      );
+      if (bytesRead === 0) break;
+      totalBytes += bytesRead;
+    }
+    return totalBytes > maxBytes ? null : buffer.subarray(0, totalBytes).toString("utf8");
+  } finally {
+    await handle.close();
+  }
+}
+var defaultCredentialDeps = {
+  platform: process.platform,
+  homedir: os5.homedir,
+  env: process.env,
+  readBounded: readBoundedFile,
+  execFile: async (file2, args, options) => {
+    const result = await execFileAsync(file2, [...args], options);
+    return result.stdout;
+  }
+};
+function credentialRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function optionalTrimmedString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+var ANTIGRAVITY_KEYCHAIN_SERVICE = "gemini";
+var ANTIGRAVITY_KEYCHAIN_ACCOUNT = "antigravity";
+var GO_KEYRING_BASE64_PREFIX = "go-keyring-base64:";
+var ANTIGRAVITY_CLI_BINARY = "agy";
+var ANTIGRAVITY_CLI_REFRESH_ARGS = ["models"];
+var ANTIGRAVITY_DAILY_API = "https://daily-cloudcode-pa.googleapis.com";
+var ANTIGRAVITY_PROD_API = "https://cloudcode-pa.googleapis.com";
+var ANTIGRAVITY_IDE_VERSION = "2.5.5";
+var ARCH_LABELS = Object.freeze({
+  x64: "amd64",
+  arm64: "arm64",
+  ia32: "386"
+});
+function antigravityUserAgent(platform = process.platform, arch = process.arch) {
+  const osType = platform === "win32" ? "windows" : platform;
+  const archLabel = ARCH_LABELS[arch] ?? arch;
+  return `antigravity/ide/${ANTIGRAVITY_IDE_VERSION} (os_type=${osType}; arch=${archLabel}; aidev_client; auth_method=oauth)`;
+}
+var ANTIGRAVITY_REFRESH_BUFFER_MS = 6e4;
+var VENDOR_REFRESH_TIMEOUT_MS = 2e4;
+var KEYCHAIN_TIMEOUT_MS = 5e3;
+var WINDOWS_CREDENTIAL_TIMEOUT_MS = 15e3;
+var vendorRefreshInFlight = /* @__PURE__ */ new Map();
+function expiry(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value < 1e12 ? Math.round(value * 1e3) : Math.round(value);
+  }
+  if (typeof value !== "string") return void 0;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function firstString(source, keys) {
+  for (const key of keys) {
+    const value = optionalTrimmedString(source[key]);
+    if (value !== void 0) return value;
+  }
+  return void 0;
+}
+function parseAntigravityKeychainValue(raw) {
+  let body = raw.trim();
+  if (body.length === 0) return null;
+  if (body.startsWith(GO_KEYRING_BASE64_PREFIX)) {
+    try {
+      body = Buffer.from(body.slice(GO_KEYRING_BASE64_PREFIX.length), "base64").toString("utf8");
+    } catch {
+      return null;
+    }
+  }
+  if (/^bearer /i.test(body)) body = body.slice(7).trim();
+  if (!body.startsWith("{")) {
+    return body.length > 0 ? { accessToken: body } : null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return null;
+  }
+  const root = credentialRecord(parsed);
+  if (!root) return null;
+  const source = credentialRecord(root.token) ?? credentialRecord(root.tokens) ?? credentialRecord(root.oauth) ?? credentialRecord(root.oauth2) ?? credentialRecord(root.credentials) ?? credentialRecord(root.auth) ?? root;
+  const accessToken = firstString(source, [
+    "access_token",
+    "accessToken",
+    "token",
+    "id_token",
+    "idToken",
+    "bearerToken",
+    "auth_token",
+    "authToken"
+  ]);
+  const refreshToken2 = firstString(source, ["refresh_token", "refreshToken"]);
+  const expiresAt = expiry(source.expiry) ?? expiry(source.expires_at) ?? expiry(source.expiresAt);
+  if (!accessToken && !refreshToken2) return null;
+  return {
+    ...accessToken === void 0 ? {} : { accessToken },
+    ...refreshToken2 === void 0 ? {} : { refreshToken: refreshToken2 },
+    ...expiresAt === void 0 ? {} : { expiresAt }
+  };
+}
+var WINDOWS_CREDENTIAL_TARGET = `${ANTIGRAVITY_KEYCHAIN_SERVICE}:${ANTIGRAVITY_KEYCHAIN_ACCOUNT}`;
+var WINDOWS_CREDENTIAL_READER = `$ErrorActionPreference = 'Stop'
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+public static class FleetAntigravityCredential {
+  [DllImport("advapi32.dll", SetLastError=true, CharSet=CharSet.Unicode, EntryPoint="CredReadW")]
+  private static extern bool CredRead(string target, uint type, uint flags, out IntPtr credential);
+  [DllImport("advapi32.dll")]
+  private static extern void CredFree(IntPtr credential);
+  [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
+  private struct CREDENTIAL {
+    public uint Flags; public uint Type; public IntPtr TargetName; public IntPtr Comment;
+    public long LastWritten; public uint CredentialBlobSize; public IntPtr CredentialBlob;
+    public uint Persist; public uint AttributeCount; public IntPtr Attributes;
+    public IntPtr TargetAlias; public IntPtr UserName;
+  }
+  public static string Read(string target) {
+    IntPtr handle;
+    if (!CredRead(target, 1, 0, out handle)) return "";
+    try {
+      CREDENTIAL cred = (CREDENTIAL)Marshal.PtrToStructure(handle, typeof(CREDENTIAL));
+      byte[] blob = new byte[cred.CredentialBlobSize];
+      Marshal.Copy(cred.CredentialBlob, blob, 0, (int)cred.CredentialBlobSize);
+      return Convert.ToBase64String(blob);
+    } finally { CredFree(handle); }
+  }
+}
+'@
+[Console]::Out.Write([FleetAntigravityCredential]::Read('${WINDOWS_CREDENTIAL_TARGET}'))
+`;
+function windowsPowerShell(deps) {
+  const systemRoot = optionalTrimmedString(deps.env.SystemRoot);
+  return systemRoot === void 0 ? "powershell.exe" : path42__default.win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+}
+async function readKeychainValue(deps) {
+  if (deps.platform === "darwin") {
+    const raw = await deps.execFile(
+      "security",
+      [
+        "find-generic-password",
+        "-s",
+        ANTIGRAVITY_KEYCHAIN_SERVICE,
+        "-a",
+        ANTIGRAVITY_KEYCHAIN_ACCOUNT,
+        "-w"
+      ],
+      { timeout: KEYCHAIN_TIMEOUT_MS }
+    );
+    return raw.length > MAX_CREDENTIAL_BYTES ? null : raw;
+  }
+  if (deps.platform === "linux") {
+    const raw = await deps.execFile(
+      "secret-tool",
+      [
+        "lookup",
+        "service",
+        ANTIGRAVITY_KEYCHAIN_SERVICE,
+        "username",
+        ANTIGRAVITY_KEYCHAIN_ACCOUNT
+      ],
+      { timeout: KEYCHAIN_TIMEOUT_MS }
+    );
+    return raw.length > MAX_CREDENTIAL_BYTES ? null : raw;
+  }
+  if (deps.platform === "win32") {
+    const encoded = await deps.execFile(
+      windowsPowerShell(deps),
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-EncodedCommand",
+        // `-EncodedCommand` takes UTF-16LE base64, which is what keeps a script
+        // full of quotes and `$` out of Windows command-line quoting entirely.
+        Buffer.from(WINDOWS_CREDENTIAL_READER, "utf16le").toString("base64")
+      ],
+      { timeout: WINDOWS_CREDENTIAL_TIMEOUT_MS }
+    );
+    const blob = encoded.trim();
+    if (blob.length === 0) return null;
+    const raw = Buffer.from(blob, "base64").toString("utf8");
+    return raw.length > MAX_CREDENTIAL_BYTES ? null : raw;
+  }
+  return null;
+}
+function spawnVendorRefresh(deps) {
+  const binary = optionalTrimmedString(deps.env.FLEET_ANTIGRAVITY_CLI) ?? ANTIGRAVITY_CLI_BINARY;
+  return new Promise((resolve3) => {
+    let child;
+    try {
+      child = spawn(binary, [...ANTIGRAVITY_CLI_REFRESH_ARGS], { stdio: "ignore" });
+    } catch {
+      resolve3();
+      return;
+    }
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve3();
+    };
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      finish();
+    }, VENDOR_REFRESH_TIMEOUT_MS);
+    child.once("error", finish);
+    child.once("close", finish);
+  });
+}
+async function runVendorRefresh(deps, refresh) {
+  const binary = optionalTrimmedString(deps.env.FLEET_ANTIGRAVITY_CLI) ?? ANTIGRAVITY_CLI_BINARY;
+  const key = `${binary}\0${deps.homedir()}`;
+  const existing = vendorRefreshInFlight.get(key);
+  if (existing) return existing;
+  const task = refresh(deps).catch(() => void 0).finally(() => {
+    vendorRefreshInFlight.delete(key);
+  });
+  vendorRefreshInFlight.set(key, task);
+  return task;
+}
+async function resolveAntigravityAuth(deps, options = {}) {
+  const now = options.now ?? Date.now;
+  const read = async () => {
+    let raw;
+    try {
+      raw = await readKeychainValue(deps);
+    } catch {
+      return null;
+    }
+    return raw === null ? null : parseAntigravityKeychainValue(raw);
+  };
+  const usable = (token) => {
+    if (!token.accessToken) return null;
+    if (token.expiresAt !== void 0 && token.expiresAt <= now()) return null;
+    return {
+      status: "ok",
+      credentials: {
+        accessToken: token.accessToken,
+        method: "keychain",
+        ...token.expiresAt === void 0 ? {} : { expiresAt: token.expiresAt }
+      }
+    };
+  };
+  const stored = await read();
+  if (!stored) return { status: "signed_out" };
+  const stale = stored.expiresAt !== void 0 && stored.expiresAt - now() <= ANTIGRAVITY_REFRESH_BUFFER_MS;
+  if (options.forceRefresh !== true && !stale) {
+    const ready2 = usable(stored);
+    if (ready2) return ready2;
+  }
+  if (!stored.refreshToken) {
+    return usable(stored) ?? { status: stored.accessToken ? "expired" : "signed_out" };
+  }
+  await runVendorRefresh(deps, options.refreshVendorCredential ?? spawnVendorRefresh);
+  const renewed = await read();
+  const ready = renewed ? usable(renewed) : null;
+  if (ready) return ready;
+  return { status: "expired" };
+}
+async function resolveAntigravityCredentials(deps, options = {}) {
+  const result = await resolveAntigravityAuth(deps, options);
+  return result.status === "ok" ? result.credentials : null;
+}
+var ANTIGRAVITY_LOAD_CODE_ASSIST_URL = `${ANTIGRAVITY_PROD_API}/v1internal:loadCodeAssist`;
+var REQUEST_TIMEOUT_MS = 1e4;
+var ANTIGRAVITY_CODE_ASSIST_TTL_MS = 36e5;
+var MAX_PROJECT_ID_LENGTH = 128;
+var TIER_LABELS = Object.freeze({
+  "free-tier": "Free",
+  "legacy-tier": "Legacy",
+  "standard-tier": "Standard",
+  "g1-pro-tier": "Pro",
+  "g1-ultra-tier": "Ultra"
+});
+function antigravityPlanLabel(tierId) {
+  const id = optionalTrimmedString(tierId)?.toLowerCase();
+  if (!id) return void 0;
+  const known = TIER_LABELS[id];
+  if (known) return known;
+  const bare = id.replace(/-tier$/, "").replace(/[-_]+/g, " ").trim();
+  if (bare.length === 0 || bare.length > 24 || !/^[a-z0-9][a-z0-9 .+-]*$/.test(bare)) return void 0;
+  return bare.replace(/(^|\s)([a-z0-9])/g, (_, lead, char) => `${lead}${char.toUpperCase()}`);
+}
+function projectId(value) {
+  const id = optionalTrimmedString(value);
+  if (!id || id.length > MAX_PROJECT_ID_LENGTH) return void 0;
+  return /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(id) ? id : void 0;
+}
+async function loadAntigravityCodeAssist(fetchImpl, accessToken, signal) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  const onAbort = () => controller.abort();
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    const response = await fetchImpl(ANTIGRAVITY_LOAD_CODE_ASSIST_URL, {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${accessToken}`,
+        "User-Agent": antigravityUserAgent()
+      },
+      body: JSON.stringify({ metadata: { ideType: "ANTIGRAVITY" } }),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      await response.body?.cancel().catch(() => void 0);
+      return {};
+    }
+    const payload = credentialRecord(await response.json());
+    if (!payload) return {};
+    const project = projectId(payload.cloudaicompanionProject);
+    const plan = antigravityPlanLabel(credentialRecord(payload.currentTier)?.id);
+    return {
+      ...project === void 0 ? {} : { projectId: project },
+      ...plan === void 0 ? {} : { plan }
+    };
+  } catch {
+    return {};
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+  }
+}
+function createAntigravityCodeAssistCache(now = Date.now, ttlMs = ANTIGRAVITY_CODE_ASSIST_TTL_MS) {
+  let entry;
+  let inFlight;
+  return {
+    async read(fetchImpl, accessToken, signal) {
+      if (entry && entry.token === accessToken && entry.expiresAt > now()) return entry.value;
+      if (inFlight && inFlight.token === accessToken) return inFlight.task;
+      const task = loadAntigravityCodeAssist(fetchImpl, accessToken, signal).then((value) => {
+        if (value.projectId !== void 0 || value.plan !== void 0) {
+          entry = { token: accessToken, value, expiresAt: now() + ttlMs };
+        }
+        return value;
+      }).finally(() => {
+        if (inFlight?.token === accessToken) inFlight = void 0;
+      });
+      inFlight = { token: accessToken, task };
+      return task;
+    },
+    clear() {
+      entry = void 0;
+      inFlight = void 0;
+    }
+  };
+}
+function thinkingLevel(effort) {
+  if (effort === "low" || effort === "minimal") return "low";
+  if (effort === "medium") return "medium";
+  return "high";
+}
+function resolveAntigravityModelSelection(modelId, requestedEffort, catalog = GATEWAY_MODELS) {
+  const model = findGatewayModel(modelId, catalog) ?? catalog.find((candidate) => candidate.provider === "antigravity" && upstreamModelId(candidate) === modelId);
+  if (!model || model.provider !== "antigravity") return { wireModelId: modelId };
+  const baseId = upstreamModelId(model);
+  if (!model.effort.supported) return { wireModelId: baseId };
+  const effort = clampReasoningEffort(
+    requestedEffort ?? "high",
+    model.effort.levels,
+    baseId
+  );
+  const exactModelId = model.effort.upstreamModelIds?.[effort] ?? model.effort.upstreamModelIdTemplate?.replace("{effort}", effort);
+  if (exactModelId) return { wireModelId: exactModelId };
+  return { wireModelId: baseId, thinkingLevel: thinkingLevel(effort) };
+}
+var GEMINI_TOOL_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_.-]{0,63}$/;
+var MAX_TOOL_NAME_LENGTH = 64;
+function createToolNameCodec() {
+  const toWireMap = /* @__PURE__ */ new Map();
+  const fromWireMap = /* @__PURE__ */ new Map();
+  return {
+    toWire(name) {
+      const cached22 = toWireMap.get(name);
+      if (cached22 !== void 0) return cached22;
+      let wire = name;
+      if (!GEMINI_TOOL_NAME_PATTERN.test(name)) {
+        const suffix = createHash("sha256").update(name, "utf8").digest("hex").slice(0, 8);
+        const cleaned = name.replace(/[^A-Za-z0-9_.-]/g, "_").replace(/^[^A-Za-z_]/, "_");
+        wire = `${cleaned.slice(0, MAX_TOOL_NAME_LENGTH - suffix.length - 1)}_${suffix}`;
+      }
+      toWireMap.set(name, wire);
+      if (!fromWireMap.has(wire)) fromWireMap.set(wire, name);
+      return wire;
+    },
+    fromWire(name) {
+      return fromWireMap.get(name) ?? name;
+    }
+  };
+}
+var GEMINI_SCHEMA_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "format",
+  "description",
+  "nullable",
+  "enum",
+  "items",
+  "properties",
+  "required",
+  "minItems",
+  "maxItems",
+  "minimum",
+  "maximum",
+  "anyOf"
+]);
+var GEMINI_STRING_FORMATS = /* @__PURE__ */ new Set(["enum", "date-time"]);
+var GEMINI_NUMBER_FORMATS = /* @__PURE__ */ new Set(["float", "double", "int32", "int64"]);
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sanitizeGeminiSchema(value) {
+  if (!isRecord5(value)) return { type: "object", properties: {} };
+  const out = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (!GEMINI_SCHEMA_KEYS.has(key)) continue;
+    switch (key) {
+      case "properties": {
+        if (!isRecord5(raw)) break;
+        const properties = {};
+        for (const [name, schema] of Object.entries(raw)) {
+          properties[name] = sanitizeGeminiSchema(schema);
+        }
+        out.properties = properties;
+        break;
+      }
+      case "items":
+        out.items = sanitizeGeminiSchema(raw);
+        break;
+      case "anyOf":
+        if (Array.isArray(raw)) out.anyOf = raw.map((entry) => sanitizeGeminiSchema(entry));
+        break;
+      case "format": {
+        const type = typeof value.type === "string" ? value.type : "";
+        const format = typeof raw === "string" ? raw : "";
+        const allowed = type === "string" ? GEMINI_STRING_FORMATS : GEMINI_NUMBER_FORMATS;
+        if (allowed.has(format)) out.format = format;
+        break;
+      }
+      case "required":
+        if (Array.isArray(raw)) out.required = raw.filter((entry) => typeof entry === "string");
+        break;
+      default:
+        out[key] = raw;
+    }
+  }
+  if (out.type === void 0 && out.properties !== void 0) out.type = "object";
+  return out;
+}
+function geminiFunctionDeclarations(tools, codec2) {
+  return tools.map((tool) => ({
+    name: codec2.toWire(tool.name),
+    ...tool.description === void 0 ? {} : { description: tool.description },
+    parameters: sanitizeGeminiSchema(tool.parameters)
+  }));
+}
+function geminiToolConfig(choice, codec2) {
+  if (choice === void 0 || choice === "auto") return void 0;
+  if (choice === "none") return { functionCallingConfig: { mode: "NONE" } };
+  if (choice === "required") return { functionCallingConfig: { mode: "ANY" } };
+  return {
+    functionCallingConfig: { mode: "ANY", allowedFunctionNames: [codec2.toWire(choice.name)] }
+  };
+}
+var DATA_URL = /^data:([^;,]+);base64,(.*)$/s;
+function imagePart(imageUrl) {
+  const match = DATA_URL.exec(imageUrl);
+  if (!match) return void 0;
+  const [, mimeType, data] = match;
+  if (!mimeType || !data) return void 0;
+  return { inline_data: { mime_type: mimeType, data } };
+}
+function createAntigravitySignatureLedger(maxEntries = 512) {
+  const entries = /* @__PURE__ */ new Map();
+  return {
+    record(callId, signature) {
+      if (callId.length === 0 || signature.length === 0) return;
+      entries.delete(callId);
+      entries.set(callId, signature);
+      while (entries.size > maxEntries) {
+        const oldest = entries.keys().next();
+        if (oldest.done) break;
+        entries.delete(oldest.value);
+      }
+    },
+    recall(callId) {
+      return entries.get(callId);
+    }
+  };
+}
+function isAntigravitySignature(value) {
+  return typeof value === "string" && value.length >= 16 && !/^(fc|ctc|tsc|call|msg|rs|resp|reasoning|item|ws|toolu|tool|func|function)[-_]/i.test(value) && /^[A-Za-z0-9+/_=-]+$/.test(value);
+}
+function parsedArguments(raw) {
+  if (raw.trim().length === 0) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return isRecord5(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function signatureFor(item, callId, ledger) {
+  if (isAntigravitySignature(item.reasoning_encrypted)) return item.reasoning_encrypted;
+  const recalled = ledger.recall(callId);
+  return isAntigravitySignature(recalled) ? recalled : void 0;
+}
+function geminiContents(input, codec2, ledger) {
+  const contents = [];
+  const push = (role, parts) => {
+    if (parts.length === 0) return;
+    const tail = contents.at(-1);
+    if (tail && tail.role === role) tail.parts.push(...parts);
+    else contents.push({ role, parts });
+  };
+  for (const item of input) {
+    if (item.type === "function_call") {
+      const signature = signatureFor(item, item.call_id, ledger);
+      push("model", [{
+        ...signature === void 0 ? {} : { thoughtSignature: signature },
+        functionCall: {
+          name: codec2.toWire(item.name),
+          args: parsedArguments(item.arguments),
+          id: item.call_id
+        }
+      }]);
+      continue;
+    }
+    if (item.type === "function_call_output") {
+      push("user", [{
+        functionResponse: {
+          name: codec2.toWire(item.call_id),
+          response: { result: item.output },
+          id: item.call_id
+        }
+      }]);
+      continue;
+    }
+    const role = item.role === "assistant" ? "model" : "user";
+    const parts = [];
+    const text2 = canonicalMessageText(item.content);
+    if (text2.length > 0) {
+      const signature = role === "model" && isAntigravitySignature(item.reasoning_encrypted) ? item.reasoning_encrypted : void 0;
+      parts.push({ text: text2, ...signature === void 0 ? {} : { thoughtSignature: signature } });
+    }
+    for (const image of canonicalMessageImages(item.content)) {
+      const part = imagePart(image.image_url);
+      if (part) parts.push(part);
+    }
+    push(role, parts);
+  }
+  return contents;
+}
+function linkFunctionResponseNames(contents) {
+  const namesByCallId = /* @__PURE__ */ new Map();
+  for (const content of contents) {
+    for (const part of content.parts) {
+      if (part.functionCall?.id) namesByCallId.set(part.functionCall.id, part.functionCall.name);
+    }
+  }
+  for (const content of contents) {
+    for (const part of content.parts) {
+      const response = part.functionResponse;
+      if (!response?.id) continue;
+      const name = namesByCallId.get(response.id);
+      if (name) response.name = name;
+    }
+  }
+  return contents;
+}
+function antigravitySessionId(input) {
+  const anchor = input.find(
+    (item) => item.type === "message" && item.role === "user"
+  );
+  const text2 = anchor ? canonicalMessageText(anchor.content) : "";
+  const digest = createHash("sha256").update(text2, "utf8").digest();
+  const masked = digest.readBigUInt64BE(0) & 0x7fffffffffffffffn;
+  return `-${masked.toString()}`;
+}
+function buildAntigravityEnvelope(request, options) {
+  const selection = resolveAntigravityModelSelection(request.model, request.reasoning?.effort);
+  const contents = linkFunctionResponseNames(
+    geminiContents(request.input, options.codec, options.ledger)
+  );
+  const declarations = geminiFunctionDeclarations(request.tools ?? [], options.codec);
+  const toolConfig = geminiToolConfig(request.tool_choice, options.codec);
+  return {
+    model: selection.wireModelId,
+    userAgent: "antigravity",
+    requestType: "agent",
+    ...options.project === void 0 ? {} : { project: options.project },
+    requestId: options.requestId,
+    request: {
+      contents,
+      ...request.instructions === void 0 || request.instructions.length === 0 ? {} : { systemInstruction: { role: "user", parts: [{ text: request.instructions }] } },
+      ...declarations.length > 0 ? { tools: [{ functionDeclarations: declarations }] } : {},
+      ...toolConfig === void 0 ? {} : { toolConfig },
+      generationConfig: {
+        ...request.max_output_tokens === void 0 ? {} : { maxOutputTokens: request.max_output_tokens },
+        ...selection.thinkingLevel === void 0 ? {} : { thinkingConfig: { thinkingLevel: selection.thinkingLevel } }
+      },
+      sessionId: antigravitySessionId(request.input)
+    }
+  };
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function positiveNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function antigravityUsage(value) {
+  if (!isRecord6(value)) return null;
+  const inputTokens = positiveNumber(value.promptTokenCount) ?? 0;
+  const visibleOutput = positiveNumber(value.candidatesTokenCount) ?? 0;
+  const reasoning = positiveNumber(value.thoughtsTokenCount);
+  const cached22 = positiveNumber(value.cachedContentTokenCount);
+  const total = positiveNumber(value.totalTokenCount);
+  return {
+    input_tokens: inputTokens,
+    output_tokens: visibleOutput + (reasoning ?? 0),
+    ...cached22 === void 0 ? {} : { cached_input_tokens: cached22 },
+    ...reasoning === void 0 ? {} : { reasoning_output_tokens: reasoning },
+    ...total === void 0 ? {} : { total_tokens: total }
+  };
+}
+function antigravityError(value) {
+  const error51 = isRecord6(value) ? value.error : void 0;
+  if (!isRecord6(error51)) return void 0;
+  const message = typeof error51.message === "string" && error51.message.length > 0 ? error51.message : "Antigravity request failed";
+  const status = typeof error51.status === "string" ? error51.status : void 0;
+  const code = typeof error51.code === "number" ? error51.code : void 0;
+  return { type: canonicalErrorType(status, code), message };
+}
+function canonicalErrorType(status, code) {
+  switch (status) {
+    case "UNAUTHENTICATED":
+      return "authentication_error";
+    case "PERMISSION_DENIED":
+      return "permission_error";
+    case "RESOURCE_EXHAUSTED":
+      return "rate_limit_error";
+    case "INVALID_ARGUMENT":
+    case "NOT_FOUND":
+      return "invalid_request_error";
+    case "UNAVAILABLE":
+      return "overloaded_error";
+  }
+  if (code === 401) return "authentication_error";
+  if (code === 403) return "permission_error";
+  if (code === 429) return "rate_limit_error";
+  if (code === 400 || code === 404) return "invalid_request_error";
+  if (code === 503) return "overloaded_error";
+  return "api_error";
+}
+function parseAntigravityFrame(data) {
+  const trimmed = data.trim();
+  if (trimmed.length === 0) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    throw new UpstreamProtocolError("Antigravity stream frame was not valid JSON");
+  }
+  if (!isRecord6(parsed)) return void 0;
+  logRawWireEvent("antigravity.wire.event", void 0, parsed);
+  if (isRecord6(parsed.error)) return { error: parsed };
+  const response = isRecord6(parsed.response) ? parsed.response : void 0;
+  return response === void 0 ? void 0 : { response };
+}
+function partSignature(part) {
+  const direct = part.thoughtSignature ?? part.thought_signature;
+  return isAntigravitySignature(direct) ? direct : void 0;
+}
+async function* translateAntigravityStream(frames, options) {
+  let started = false;
+  let responseId = "";
+  let model = options.model;
+  let usage4 = null;
+  let outputIndex = 0;
+  let sequence = 0;
+  const callIdPrefix = options.callIdPrefix && options.callIdPrefix.length > 0 ? options.callIdPrefix : randomUUID();
+  let textItemId;
+  let reasoningItemId;
+  let failed;
+  const snapshot = () => ({ id: responseId, model, usage: usage4 });
+  function* closeText() {
+    if (textItemId === void 0) return;
+    yield { type: "response.output_text.done", item_id: textItemId, output_index: outputIndex, content_index: 0, text: "" };
+    outputIndex += 1;
+    textItemId = void 0;
+  }
+  function* closeReasoning(signature) {
+    if (reasoningItemId === void 0 && signature === void 0) return;
+    const id = reasoningItemId ?? `agr_${sequence++}`;
+    yield {
+      type: "response.output_item.done",
+      output_index: outputIndex,
+      item: {
+        id,
+        type: "reasoning",
+        ...signature === void 0 ? {} : { encrypted_content: signature }
+      }
+    };
+    outputIndex += 1;
+    reasoningItemId = void 0;
+  }
+  for await (const frame of frames) {
+    if (frame.error !== void 0) {
+      failed = antigravityError(frame.error) ?? { type: "api_error", message: "Antigravity request failed" };
+      break;
+    }
+    const response = frame.response;
+    if (!response) continue;
+    if (typeof response.responseId === "string" && responseId.length === 0) responseId = response.responseId;
+    if (typeof response.modelVersion === "string" && response.modelVersion.length > 0) {
+      model = response.modelVersion;
+    }
+    const frameUsage = antigravityUsage(response.usageMetadata);
+    if (frameUsage) usage4 = frameUsage;
+    if (!started) {
+      started = true;
+      yield { type: "response.created", response: { id: responseId, model, usage: null } };
+    }
+    const candidates = Array.isArray(response.candidates) ? response.candidates : [];
+    const candidate = isRecord6(candidates[0]) ? candidates[0] : void 0;
+    const content = isRecord6(candidate?.content) ? candidate.content : void 0;
+    const parts = Array.isArray(content?.parts) ? content.parts.filter(isRecord6) : [];
+    for (const part of parts) {
+      const call = isRecord6(part.functionCall) ? part.functionCall : void 0;
+      if (call) {
+        yield* closeText();
+        const signature2 = partSignature(part);
+        yield* closeReasoning(signature2);
+        const wireName = typeof call.name === "string" ? call.name : "";
+        const callId = typeof call.id === "string" && call.id.length > 0 ? call.id : `agc_${callIdPrefix}_${sequence++}`;
+        if (signature2 !== void 0) options.ledger.record(callId, signature2);
+        const args = JSON.stringify(isRecord6(call.args) ? call.args : {});
+        const itemId = `agf_${sequence++}`;
+        yield {
+          type: "response.output_item.added",
+          output_index: outputIndex,
+          item: {
+            id: itemId,
+            type: "function_call",
+            call_id: callId,
+            name: options.codec.fromWire(wireName),
+            arguments: ""
+          }
+        };
+        yield { type: "response.function_call_arguments.delta", item_id: itemId, output_index: outputIndex, delta: args };
+        yield { type: "response.function_call_arguments.done", item_id: itemId, output_index: outputIndex, arguments: args };
+        yield {
+          type: "response.output_item.done",
+          output_index: outputIndex,
+          item: {
+            id: itemId,
+            type: "function_call",
+            call_id: callId,
+            name: options.codec.fromWire(wireName),
+            arguments: args
+          }
+        };
+        outputIndex += 1;
+        continue;
+      }
+      const text2 = typeof part.text === "string" ? part.text : "";
+      const signature = partSignature(part);
+      if (part.thought === true) {
+        if (text2.length > 0) {
+          if (reasoningItemId === void 0) {
+            yield* closeText();
+            reasoningItemId = `agr_${sequence++}`;
+          }
+          yield { type: "response.reasoning_summary_text.delta", item_id: reasoningItemId, output_index: outputIndex, delta: text2 };
+        }
+        if (signature !== void 0) yield* closeReasoning(signature);
+        continue;
+      }
+      if (text2.length > 0) {
+        yield* closeReasoning(void 0);
+        if (textItemId === void 0) {
+          textItemId = `agm_${sequence++}`;
+          yield {
+            type: "response.content_part.added",
+            item_id: textItemId,
+            output_index: outputIndex,
+            content_index: 0,
+            part: { type: "output_text", text: "" }
+          };
+        }
+        yield { type: "response.output_text.delta", item_id: textItemId, output_index: outputIndex, content_index: 0, delta: text2 };
+      }
+      if (signature !== void 0) yield* closeReasoning(signature);
+    }
+  }
+  yield* closeText();
+  yield* closeReasoning(void 0);
+  if (failed) {
+    yield { type: "response.failed", response: { ...snapshot(), error: failed } };
+    return;
+  }
+  if (!started) {
+    throw new UpstreamProtocolError("Antigravity stream produced no response frames");
+  }
+  yield { type: "response.completed", response: snapshot() };
+}
+var ANTIGRAVITY_STREAM_URL = `${ANTIGRAVITY_DAILY_API}/v1internal:streamGenerateContent?alt=sse`;
+var DEFAULT_ANTIGRAVITY_MAX_UPSTREAM_BODY_BYTES = 64 * 1024 * 1024;
+var AUTH_REJECTION_STATUS = /* @__PURE__ */ new Set([401, 403]);
+async function discardResponseBody(response) {
+  await response.body?.cancel().catch(() => void 0);
+}
+var DEFAULT_ANTIGRAVITY_UPSTREAM_IDLE_TIMEOUT_MS = 3e5;
+var AntigravityGenerateContentAdapter = class {
+  capabilities = {};
+  fetchImpl;
+  maxBodyBytes;
+  idleTimeoutMs;
+  project;
+  codeAssist;
+  ledger;
+  renewCredential;
+  constructor(options = {}) {
+    this.fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
+    this.maxBodyBytes = options.maxBodyBytes === void 0 ? DEFAULT_ANTIGRAVITY_MAX_UPSTREAM_BODY_BYTES : positiveInteger(options.maxBodyBytes, "maxBodyBytes");
+    this.idleTimeoutMs = options.idleTimeoutMs === void 0 ? DEFAULT_ANTIGRAVITY_UPSTREAM_IDLE_TIMEOUT_MS : positiveInteger(options.idleTimeoutMs, "idleTimeoutMs");
+    this.project = options.project;
+    this.codeAssist = options.codeAssist ?? createAntigravityCodeAssistCache();
+    this.ledger = options.signatureLedger ?? createAntigravitySignatureLedger();
+    this.renewCredential = options.renewCredential;
+  }
+  async stream(request, options) {
+    const controller = new AbortController();
+    const unlink2 = linkAbortSignal(options.signal, controller);
+    const codec2 = createToolNameCodec();
+    const project = this.project ?? (await this.codeAssist.read(this.fetchImpl, options.apiKey, controller.signal)).projectId;
+    const envelope = buildAntigravityEnvelope(request, {
+      ...project === void 0 ? {} : { project },
+      requestId: `agent-${randomUUID()}`,
+      codec: codec2,
+      ledger: this.ledger
+    });
+    const replayable = envelope.request.contents.flatMap((content) => content.role === "model" ? content.parts.filter((part) => part.functionCall !== void 0) : []);
+    wireLog("antigravity.wire.request", {
+      url: ANTIGRAVITY_STREAM_URL,
+      model: envelope.model,
+      hasProject: project !== void 0,
+      contents: envelope.request.contents.length,
+      replayableCalls: replayable.length,
+      replayedSignatures: replayable.filter((part) => part.thoughtSignature !== void 0).length,
+      tools: envelope.request.tools?.[0].functionDeclarations.length ?? 0,
+      toolConfig: envelope.request.toolConfig,
+      generationConfig: envelope.request.generationConfig
+    });
+    const body = JSON.stringify(envelope);
+    const send = (token) => this.fetchImpl(ANTIGRAVITY_STREAM_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "text/event-stream",
+        Authorization: `Bearer ${token}`,
+        "User-Agent": antigravityUserAgent()
+      },
+      body,
+      signal: controller.signal
+    });
+    let response;
+    try {
+      response = await send(options.apiKey);
+      if (AUTH_REJECTION_STATUS.has(response.status) && this.renewCredential) {
+        const renewed = await this.renewCredential().catch(() => null);
+        if (renewed && renewed !== options.apiKey) {
+          wireLog("antigravity.wire.auth_retry", { status: response.status });
+          await discardResponseBody(response);
+          response = await send(renewed);
+        }
+      }
+    } catch (error51) {
+      unlink2();
+      throw error51;
+    }
+    const readOptions = {
+      controller,
+      idleTimeoutMs: this.idleTimeoutMs,
+      maxBodyBytes: this.maxBodyBytes
+    };
+    if (!response.ok) {
+      try {
+        return {
+          ok: false,
+          status: response.status,
+          headers: response.headers,
+          body: await readBoundedBody(response.body, readOptions)
+        };
+      } finally {
+        unlink2();
+      }
+    }
+    const frames = parseUpstreamSseStream(response.body, {
+      ...readOptions,
+      onClose: unlink2,
+      missingBodyMessage: "Antigravity response had no body"
+    }, (frame) => parseAntigravityFrame(parseSseFrameFields(frame).data));
+    return {
+      ok: true,
+      status: response.status,
+      headers: response.headers,
+      events: translateAntigravityStream(frames, {
+        codec: codec2,
+        ledger: this.ledger,
+        model: request.model,
+        // The envelope's own request id is already unique per request.
+        callIdPrefix: envelope.requestId
+      })
+    };
+  }
+  /**
+   * Every declared tool is serialized: this wire has no deferred-loading contract
+   * to honour, so the pre-flight estimate measures exactly what is sent.
+   */
+  wireTools(request) {
+    return request.tools ?? [];
+  }
+};
+var HOUR_MS = 36e5;
+var WEEK_MS = 7 * 24 * HOUR_MS;
+var SESSION_MS = 5 * HOUR_MS;
+var BUCKETS = Object.freeze({
+  "gemini-5h": { id: "session", label: "Gemini", durationMs: SESSION_MS, reported: true },
+  "gemini-weekly": { id: "weekly", label: "Gemini", durationMs: WEEK_MS, reported: true },
+  "3p-5h": { id: "session", label: "Claude & GPT", durationMs: SESSION_MS, reported: false },
+  "3p-weekly": { id: "weekly", label: "Claude & GPT", durationMs: WEEK_MS, reported: false }
+});
+Object.freeze(
+  Object.keys(BUCKETS).filter((bucketId) => BUCKETS[bucketId]?.reported === true)
+);
 var MS_PER_HOUR = 36e5;
 var CADENCE_SESSION_MAX_MS = 20 * MS_PER_HOUR;
 var CADENCE_DAILY_MAX_MS = 3 * 24 * MS_PER_HOUR;
@@ -24584,54 +25606,11 @@ function deriveQuotaWindowRisk(window, at) {
     pressure: windowPressure(window.usedPercent, paceRatio)
   };
 }
-var execFileAsync = promisify(execFile);
-var MAX_CREDENTIAL_BYTES = 65536;
-var CREDENTIAL_OPEN_FLAGS = process.platform === "win32" ? constants.O_RDONLY : constants.O_RDONLY | constants.O_NONBLOCK;
-async function readBoundedFile(filePath, maxBytes) {
-  const handle = await fs22.open(filePath, CREDENTIAL_OPEN_FLAGS);
-  try {
-    const stat22 = await handle.stat();
-    if (!stat22.isFile() || stat22.size > maxBytes) return null;
-    const buffer = Buffer.allocUnsafe(maxBytes + 1);
-    let totalBytes = 0;
-    while (totalBytes < buffer.byteLength) {
-      const { bytesRead } = await handle.read(
-        buffer,
-        totalBytes,
-        buffer.byteLength - totalBytes,
-        totalBytes
-      );
-      if (bytesRead === 0) break;
-      totalBytes += bytesRead;
-    }
-    return totalBytes > maxBytes ? null : buffer.subarray(0, totalBytes).toString("utf8");
-  } finally {
-    await handle.close();
-  }
-}
-var defaultCredentialDeps = {
-  platform: process.platform,
-  homedir: os5.homedir,
-  env: process.env,
-  readBounded: readBoundedFile,
-  execFile: async (file2, args, options) => {
-    const result = await execFileAsync(file2, [...args], options);
-    return result.stdout;
-  }
-};
-function credentialRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
-}
-function optionalTrimmedString(value) {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
 function optionalNonEmptyString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function codexAuthFilePath(deps) {
-  return path32__default.join(deps.env.CODEX_HOME || path32__default.join(deps.homedir(), ".codex"), "auth.json");
+  return path42__default.join(deps.env.CODEX_HOME || path42__default.join(deps.homedir(), ".codex"), "auth.json");
 }
 async function resolveCodexCredentials(deps) {
   try {
@@ -24670,12 +25649,12 @@ function parseCursorCredentialJson(raw, method) {
 function cursorAuthFilePath(deps) {
   const home = deps.homedir();
   if (deps.platform === "win32") {
-    return path32__default.join(deps.env.APPDATA || path32__default.join(home, "AppData", "Roaming"), "Cursor", "auth.json");
+    return path42__default.join(deps.env.APPDATA || path42__default.join(home, "AppData", "Roaming"), "Cursor", "auth.json");
   }
   if (deps.platform === "darwin") {
-    return path32__default.join(home, ".cursor", "auth.json");
+    return path42__default.join(home, ".cursor", "auth.json");
   }
-  return path32__default.join(deps.env.XDG_CONFIG_HOME || path32__default.join(home, ".config"), "cursor", "auth.json");
+  return path42__default.join(deps.env.XDG_CONFIG_HOME || path42__default.join(home, ".config"), "cursor", "auth.json");
 }
 async function resolveCursorCredentials(deps) {
   if (deps.platform === "darwin") {
@@ -24968,16 +25947,16 @@ function pruneUndeclaredArguments(raw, schema) {
   return pruned === parsed ? raw : JSON.stringify(pruned);
 }
 function pruneUndeclaredValue(value, schema) {
-  if (!isRecord5(schema)) return value;
+  if (!isRecord7(schema)) return value;
   if (typeof schema.$ref === "string") return value;
   if (Array.isArray(schema.anyOf) || Array.isArray(schema.oneOf) || Array.isArray(schema.allOf)) {
     return value;
   }
-  if (isRecord5(schema.patternProperties) || isRecord5(schema.dependentSchemas) || schema.if !== void 0 || schema.unevaluatedProperties !== void 0) {
+  if (isRecord7(schema.patternProperties) || isRecord7(schema.dependentSchemas) || schema.if !== void 0 || schema.unevaluatedProperties !== void 0) {
     return value;
   }
   if (Array.isArray(value)) {
-    if (!isRecord5(schema.items)) return value;
+    if (!isRecord7(schema.items)) return value;
     let changed2 = false;
     const next2 = value.map((entry) => {
       const pruned = pruneUndeclaredValue(entry, schema.items);
@@ -24986,8 +25965,8 @@ function pruneUndeclaredValue(value, schema) {
     });
     return changed2 ? next2 : value;
   }
-  if (!isRecord5(value)) return value;
-  const properties = isRecord5(schema.properties) ? schema.properties : void 0;
+  if (!isRecord7(value)) return value;
+  const properties = isRecord7(schema.properties) ? schema.properties : void 0;
   if (properties === void 0) return value;
   const closed = schema.additionalProperties === false;
   let changed = false;
@@ -25026,10 +26005,10 @@ async function* translateChatCompletionsStream(body, options, toolSchemas) {
   const toolCalls = /* @__PURE__ */ new Map();
   const MESSAGE_ITEM_ID = "chat_message_0";
   function* consumeChunk(value) {
-    if (!isRecord5(value)) {
+    if (!isRecord7(value)) {
       throw new UpstreamProtocolError("Chat Completions SSE event was not an object");
     }
-    if (isRecord5(value.error)) {
+    if (isRecord7(value.error)) {
       failed = true;
       yield { type: "error", error: chatCanonicalError(value.error) };
       return;
@@ -25051,13 +26030,13 @@ async function* translateChatCompletionsStream(body, options, toolSchemas) {
         }
       };
     }
-    if (isRecord5(value.usage)) {
+    if (isRecord7(value.usage)) {
       usage4 = chatUsage(value.usage);
     }
     const choices = Array.isArray(value.choices) ? value.choices : [];
     for (const choice of choices) {
-      if (!isRecord5(choice)) continue;
-      const delta = isRecord5(choice.delta) ? choice.delta : {};
+      if (!isRecord7(choice)) continue;
+      const delta = isRecord7(choice.delta) ? choice.delta : {};
       if (typeof delta.reasoning_content === "string" && delta.reasoning_content.length > 0) {
         yield {
           type: "response.reasoning_summary_text.delta",
@@ -25079,13 +26058,13 @@ async function* translateChatCompletionsStream(body, options, toolSchemas) {
       }
       const wireToolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
       for (const call of wireToolCalls) {
-        if (!isRecord5(call)) continue;
+        if (!isRecord7(call)) continue;
         const index = typeof call.index === "number" ? call.index : 0;
         const pending = toolCalls.get(index) ?? { arguments: "" };
         if (typeof call.id === "string" && call.id.length > 0) {
           pending.id ??= call.id;
         }
-        const fn = isRecord5(call.function) ? call.function : {};
+        const fn = isRecord7(call.function) ? call.function : {};
         if (typeof fn.name === "string" && fn.name.length > 0) {
           pending.name ??= fn.name;
         }
@@ -25207,8 +26186,8 @@ function chatFrameData(frame) {
 function chatUsage(value) {
   const inputTokens = nonNegativeOrZero(value.prompt_tokens);
   const outputTokens = nonNegativeOrZero(value.completion_tokens);
-  const promptDetails = isRecord5(value.prompt_tokens_details) ? value.prompt_tokens_details : void 0;
-  const completionDetails = isRecord5(value.completion_tokens_details) ? value.completion_tokens_details : void 0;
+  const promptDetails = isRecord7(value.prompt_tokens_details) ? value.prompt_tokens_details : void 0;
+  const completionDetails = isRecord7(value.completion_tokens_details) ? value.completion_tokens_details : void 0;
   const cachedInputTokens = promptDetails === void 0 ? void 0 : optionalNonNegative(promptDetails.cached_tokens);
   const reasoningOutputTokens = completionDetails === void 0 ? void 0 : optionalNonNegative(completionDetails.reasoning_tokens);
   const totalTokens = optionalNonNegative(value.total_tokens);
@@ -25231,7 +26210,7 @@ function nonNegativeOrZero(value) {
 function optionalNonNegative(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
 }
-function isRecord5(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var OPENCODE_GO_RESPONSES_URL = "https://opencode.ai/zen/go/v1/responses";
@@ -25396,13 +26375,13 @@ function parseEventFrame2(frame) {
     );
   }
   logRawWireEvent("opencode-go-responses.wire.event", eventName, parsed);
-  if (isRecord6(parsed) && typeof parsed.type !== "string" && eventName !== void 0) {
+  if (isRecord8(parsed) && typeof parsed.type !== "string" && eventName !== void 0) {
     parsed = { ...parsed, type: eventName };
   }
   return canonicalEvent2(parsed);
 }
 function canonicalEvent2(value) {
-  if (!isRecord6(value) || typeof value.type !== "string") {
+  if (!isRecord8(value) || typeof value.type !== "string") {
     throw new UpstreamProtocolError("OpenCode Go SSE event was not an object with a type");
   }
   switch (value.type) {
@@ -25546,26 +26525,26 @@ var STRICT_ALLOWED_KEYWORDS2 = /* @__PURE__ */ new Set([
   "format"
 ]);
 function strictCompatible2(schema) {
-  if (!isRecord6(schema)) return true;
+  if (!isRecord8(schema)) return true;
   for (const key of Object.keys(schema)) {
     if (!STRICT_ALLOWED_KEYWORDS2.has(key)) return false;
   }
   if (!("type" in schema) && !Array.isArray(schema.anyOf) && typeof schema.$ref !== "string") {
     return false;
   }
-  if (schema.type === "object" && !isRecord6(schema.properties)) return false;
-  if (schema.type === "array" && !isRecord6(schema.items)) return false;
-  if (isRecord6(schema.properties)) {
+  if (schema.type === "object" && !isRecord8(schema.properties)) return false;
+  if (schema.type === "array" && !isRecord8(schema.items)) return false;
+  if (isRecord8(schema.properties)) {
     for (const value of Object.values(schema.properties)) {
       if (!strictCompatible2(value)) return false;
     }
   }
-  if (isRecord6(schema.$defs)) {
+  if (isRecord8(schema.$defs)) {
     for (const value of Object.values(schema.$defs)) {
       if (!strictCompatible2(value)) return false;
     }
   }
-  if (isRecord6(schema.items) && !strictCompatible2(schema.items)) return false;
+  if (isRecord8(schema.items) && !strictCompatible2(schema.items)) return false;
   if (Array.isArray(schema.anyOf)) {
     for (const branch of schema.anyOf) {
       if (!strictCompatible2(branch)) return false;
@@ -25575,10 +26554,10 @@ function strictCompatible2(schema) {
 }
 function strictParameters2(schema) {
   const converted = strictSchema2(schema);
-  return isRecord6(converted) ? converted : schema;
+  return isRecord8(converted) ? converted : schema;
 }
 function strictSchema2(schema) {
-  if (!isRecord6(schema)) return schema;
+  if (!isRecord8(schema)) return schema;
   const next = { ...schema };
   delete next.$schema;
   delete next.default;
@@ -25587,8 +26566,8 @@ function strictSchema2(schema) {
     const branches = next[key];
     if (Array.isArray(branches)) next[key] = branches.map(strictSchema2);
   }
-  if (isRecord6(next.items)) next.items = strictSchema2(next.items);
-  if (isRecord6(next.$defs)) {
+  if (isRecord8(next.items)) next.items = strictSchema2(next.items);
+  if (isRecord8(next.$defs)) {
     const rewrittenDefs = {};
     for (const [name, value] of Object.entries(next.$defs)) {
       rewrittenDefs[name] = strictSchema2(value);
@@ -25596,7 +26575,7 @@ function strictSchema2(schema) {
     next.$defs = rewrittenDefs;
   }
   const properties = next.properties;
-  if (isRecord6(properties)) {
+  if (isRecord8(properties)) {
     const required2 = new Set(
       Array.isArray(next.required) ? next.required.filter((name) => typeof name === "string") : []
     );
@@ -25612,7 +26591,7 @@ function strictSchema2(schema) {
   return next;
 }
 function nullableSchema2(schema) {
-  if (!isRecord6(schema)) return schema;
+  if (!isRecord8(schema)) return schema;
   const next = { ...schema };
   if (Array.isArray(next.enum) && !next.enum.includes(null)) {
     next.enum = [...next.enum, null];
@@ -25637,7 +26616,7 @@ function stripNullArguments2(raw) {
   } catch {
     return raw;
   }
-  if (!isRecord6(parsed)) return raw;
+  if (!isRecord8(parsed)) return raw;
   return JSON.stringify(withoutNulls2(parsed));
 }
 function withoutNulls2(value) {
@@ -25649,7 +26628,7 @@ function withoutNulls2(value) {
   return out;
 }
 function withoutNullMembers2(entry) {
-  if (isRecord6(entry)) return withoutNulls2(entry);
+  if (isRecord8(entry)) return withoutNulls2(entry);
   if (Array.isArray(entry)) return entry.map(withoutNullMembers2);
   return entry;
 }
@@ -25689,7 +26668,7 @@ function outputItem2(value) {
   return void 0;
 }
 function webSearchAction2(value) {
-  if (!isRecord6(value) || typeof value.type !== "string") {
+  if (!isRecord8(value) || typeof value.type !== "string") {
     return void 0;
   }
   const action = { type: value.type };
@@ -25720,7 +26699,7 @@ function webSearchSources2(value) {
   }
   const sources = [];
   for (const entry of value) {
-    if (!isRecord6(entry) || typeof entry.url !== "string" || entry.url.length === 0) {
+    if (!isRecord8(entry) || typeof entry.url !== "string" || entry.url.length === 0) {
       continue;
     }
     const source = {
@@ -25740,11 +26719,11 @@ function canonicalError2(value) {
   const type = typeof error51.type === "string" && error51.type !== "error" ? error51.type : typeof error51.code === "string" ? error51.code : "api_error";
   return { type, message };
 }
-function isRecord6(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function record22(value, name) {
-  if (!isRecord6(value)) {
+  if (!isRecord8(value)) {
     throw new UpstreamProtocolError(`${name} must be an object`);
   }
   return value;
@@ -25819,9 +26798,9 @@ var XAI_CLI_REFRESH_BUFFER_MS = 5 * 60 * 1e3;
 var REFRESH_TIMEOUT_MS = 15e3;
 var FALLBACK_ACCESS_TOKEN_TTL_MS = 36e5;
 function xaiCliAuthFilePath(deps) {
-  return path32__default.join(deps.env.GROK_HOME || path32__default.join(deps.homedir(), ".grok"), "auth.json");
+  return path42__default.join(deps.env.GROK_HOME || path42__default.join(deps.homedir(), ".grok"), "auth.json");
 }
-function expiry(value) {
+function expiry2(value) {
   if (typeof value !== "string" && typeof value !== "number") return void 0;
   const parsed = typeof value === "number" ? value : Date.parse(value);
   if (!Number.isFinite(parsed)) return void 0;
@@ -25841,7 +26820,7 @@ function jwtExpiry(token) {
   }
 }
 function effectiveExpiry(entry, accessToken) {
-  const fromEntry = expiry(entry.expires_at) ?? expiry(entry.expires);
+  const fromEntry = expiry2(entry.expires_at) ?? expiry2(entry.expires);
   const fromJwt = jwtExpiry(accessToken);
   if (fromEntry !== void 0 && fromJwt !== void 0) return Math.min(fromEntry, fromJwt);
   return fromEntry ?? fromJwt;
@@ -25995,7 +26974,7 @@ var VERSION_PATTERN = /\b(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\b/;
 var VERSION_EXEC_TIMEOUT_MS = 2e3;
 var MAX_VERSION_FILE_BYTES = 256;
 function grokHomeDir(deps) {
-  return optionalTrimmedString(deps.env.GROK_HOME) ?? path32__default.join(deps.homedir(), ".grok");
+  return optionalTrimmedString(deps.env.GROK_HOME) ?? path42__default.join(deps.homedir(), ".grok");
 }
 function versionFrom(value) {
   if (typeof value !== "string") return void 0;
@@ -26003,20 +26982,20 @@ function versionFrom(value) {
 }
 async function fromInstallerSymlink(home, readLink) {
   try {
-    return versionFrom(path32__default.basename(await readLink(path32__default.join(home, "bin", "grok"))));
+    return versionFrom(path42__default.basename(await readLink(path42__default.join(home, "bin", "grok"))));
   } catch {
     return void 0;
   }
 }
 async function fromMetadataMarker(home, deps) {
   try {
-    return versionFrom(await deps.readBounded(path32__default.join(home, ".metadata_version"), MAX_VERSION_FILE_BYTES));
+    return versionFrom(await deps.readBounded(path42__default.join(home, ".metadata_version"), MAX_VERSION_FILE_BYTES));
   } catch {
     return void 0;
   }
 }
 function grokExecutablePath(home, deps) {
-  return path32__default.join(home, "bin", deps.platform === "win32" ? "grok.exe" : "grok");
+  return path42__default.join(home, "bin", deps.platform === "win32" ? "grok.exe" : "grok");
 }
 async function fromCommand(deps, file2) {
   try {
@@ -26044,8 +27023,8 @@ function sanitizeXaiEndpoint(value) {
   return typeof value === "string" && XAI_ENDPOINT_PREFERENCES.includes(value) ? value : void 0;
 }
 function normalizeAiGatewaySettings(value) {
-  if (!isRecord7(value) || value.version !== 1) return { version: 1 };
-  const models = Array.isArray(value.models) ? value.models.filter((entry) => isRecord7(entry) && typeof entry.id === "string" && entry.id.length > 0).flatMap((entry) => {
+  if (!isRecord9(value) || value.version !== 1) return { version: 1 };
+  const models = Array.isArray(value.models) ? value.models.filter((entry) => isRecord9(entry) && typeof entry.id === "string" && entry.id.length > 0).flatMap((entry) => {
     const model = findGatewayModel(entry.id);
     if (!model) return [];
     const efforts = Array.isArray(entry.efforts) ? entry.efforts.filter((level) => typeof level === "string" && level.length > 0) : [];
@@ -26083,7 +27062,7 @@ function sanitizeProviderPriority(value) {
   }
   return cleaned.length > 0 ? cleaned : void 0;
 }
-function isRecord7(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function resolveAiGatewaySelection(settings2) {
@@ -26866,7 +27845,7 @@ function parseEventFrame3(frame) {
     );
   }
   logRawWireEvent("xai-responses.wire.event", eventName, parsed);
-  if (isRecord8(parsed) && typeof parsed.type !== "string" && eventName !== void 0) {
+  if (isRecord10(parsed) && typeof parsed.type !== "string" && eventName !== void 0) {
     parsed = { ...parsed, type: eventName };
   }
   return canonicalEvent3(parsed);
@@ -26876,7 +27855,7 @@ function withoutXaiSentinel(text2) {
   return text2.includes(XAI_EOS_SENTINEL) ? text2.split(XAI_EOS_SENTINEL).join("") : text2;
 }
 function canonicalEvent3(value) {
-  if (!isRecord8(value) || typeof value.type !== "string") {
+  if (!isRecord10(value) || typeof value.type !== "string") {
     throw new UpstreamProtocolError("Grok CLI SSE event was not an object with a type");
   }
   switch (value.type) {
@@ -27044,11 +28023,11 @@ function xaiErrorType(error51, message) {
   if (typeof error51.code === "string") return error51.code;
   return XAI_CAPACITY_MESSAGE.test(message) ? XAI_OVERLOADED_ERROR_TYPE : "api_error";
 }
-function isRecord8(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function record3(value, name) {
-  if (!isRecord8(value)) {
+  if (!isRecord10(value)) {
     throw new UpstreamProtocolError(`${name} must be an object`);
   }
   return value;
@@ -27120,38 +28099,38 @@ function cursorNativeExecPolicyReplies(exec2, clientTools) {
     "shell_command",
     "exec_command"
   ]);
-  if (isRecord9(exec2.readArgs)) {
+  if (isRecord11(exec2.readArgs)) {
     return [execReply(exec2, "readResult", {
       error: { path: stringValue(exec2.readArgs.path), error: readMessage3 }
     })];
   }
-  if (isRecord9(exec2.writeArgs)) {
+  if (isRecord11(exec2.writeArgs)) {
     return [execReply(exec2, "writeResult", {
       rejected: { path: stringValue(exec2.writeArgs.path), reason: mutationMessage }
     })];
   }
-  if (isRecord9(exec2.deleteArgs)) {
+  if (isRecord11(exec2.deleteArgs)) {
     return [execReply(exec2, "deleteResult", {
       rejected: { path: stringValue(exec2.deleteArgs.path), reason: mutationMessage }
     })];
   }
-  if (isRecord9(exec2.lsArgs)) {
+  if (isRecord11(exec2.lsArgs)) {
     return [execReply(exec2, "lsResult", {
       error: { path: stringValue(exec2.lsArgs.path), error: listMessage }
     })];
   }
-  if (isRecord9(exec2.grepArgs)) {
+  if (isRecord11(exec2.grepArgs)) {
     return [execReply(exec2, "grepResult", { error: { error: grepMessage } })];
   }
-  if (isRecord9(exec2.shellArgs)) {
+  if (isRecord11(exec2.shellArgs)) {
     return [execReply(exec2, "shellResult", shellFailure(exec2.shellArgs, shellMessage))];
   }
-  if (isRecord9(exec2.shellStreamArgs)) {
+  if (isRecord11(exec2.shellStreamArgs)) {
     const args = exec2.shellStreamArgs;
     const cwd = stringValue(args.workingDirectory);
     return [
       execReply(exec2, "shellStream", {
-        start: isRecord9(args.requestedSandboxPolicy) ? { sandboxPolicy: args.requestedSandboxPolicy } : {}
+        start: isRecord11(args.requestedSandboxPolicy) ? { sandboxPolicy: args.requestedSandboxPolicy } : {}
       }),
       execReply(exec2, "shellStream", { stderr: { data: shellMessage } }),
       execReply(exec2, "shellStream", { exit: { code: 1, cwd, aborted: true } }),
@@ -27159,7 +28138,7 @@ function cursorNativeExecPolicyReplies(exec2, clientTools) {
       { execClientControlMessage: { streamClose: { id: numberValue(exec2.id) } } }
     ];
   }
-  if (isRecord9(exec2.backgroundShellSpawnArgs)) {
+  if (isRecord11(exec2.backgroundShellSpawnArgs)) {
     const args = exec2.backgroundShellSpawnArgs;
     return [execReply(exec2, "backgroundShellSpawnResult", {
       error: {
@@ -27169,15 +28148,15 @@ function cursorNativeExecPolicyReplies(exec2, clientTools) {
       }
     })];
   }
-  if (isRecord9(exec2.writeShellStdinArgs)) {
+  if (isRecord11(exec2.writeShellStdinArgs)) {
     return [execReply(exec2, "writeShellStdinResult", { error: { error: shellMessage } })];
   }
-  if (isRecord9(exec2.fetchArgs)) {
+  if (isRecord11(exec2.fetchArgs)) {
     return [execReply(exec2, "fetchResult", {
       error: { url: stringValue(exec2.fetchArgs.url), error: networkMessage }
     })];
   }
-  if (isRecord9(exec2.diagnosticsArgs)) {
+  if (isRecord11(exec2.diagnosticsArgs)) {
     return [execReply(exec2, "diagnosticsResult", {
       error: {
         path: stringValue(exec2.diagnosticsArgs.path),
@@ -27185,12 +28164,12 @@ function cursorNativeExecPolicyReplies(exec2, clientTools) {
       }
     })];
   }
-  if (isRecord9(exec2.listMcpResourcesExecArgs)) {
+  if (isRecord11(exec2.listMcpResourcesExecArgs)) {
     return [execReply(exec2, "listMcpResourcesExecResult", {
       error: { error: retryMessage(clientTools, ["ListMcpResources", "list_mcp_resources"]) }
     })];
   }
-  if (isRecord9(exec2.readMcpResourceExecArgs)) {
+  if (isRecord11(exec2.readMcpResourceExecArgs)) {
     return [execReply(exec2, "readMcpResourceExecResult", {
       error: {
         uri: stringValue(exec2.readMcpResourceExecArgs.uri),
@@ -27198,12 +28177,12 @@ function cursorNativeExecPolicyReplies(exec2, clientTools) {
       }
     })];
   }
-  if (isRecord9(exec2.recordScreenArgs)) {
+  if (isRecord11(exec2.recordScreenArgs)) {
     return [execReply(exec2, "recordScreenResult", {
       failure: { error: retryMessage(clientTools, ["record_screen", "computer_use"]) }
     })];
   }
-  if (isRecord9(exec2.computerUseArgs)) {
+  if (isRecord11(exec2.computerUseArgs)) {
     return [execReply(exec2, "computerUseResult", {
       error: {
         error: retryMessage(clientTools, ["computer_use"]),
@@ -27213,7 +28192,7 @@ function cursorNativeExecPolicyReplies(exec2, clientTools) {
       }
     })];
   }
-  if (isRecord9(exec2.mcpArgs)) {
+  if (isRecord11(exec2.mcpArgs)) {
     return [execReply(exec2, "mcpResult", {
       error: { error: retryMessage(clientTools, []) }
     })];
@@ -27285,7 +28264,7 @@ function numberValue(value) {
 function stringValue(value) {
   return typeof value === "string" ? value : "";
 }
-function isRecord9(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var EXECUTE_HOOK_FIELD_NUMBER = 27;
@@ -27441,14 +28420,14 @@ function isCursorWithheldToolName(name) {
 function cursorNativeExecRedirect(exec2, tools, providerIdentifier) {
   const messageId = numberValue2(exec2.id ?? 0);
   const execId = stringValue2(exec2.execId) || `redirect-${messageId}`;
-  if (isRecord10(exec2.readArgs)) {
-    const path82 = stringValue2(exec2.readArgs.path);
-    if (!path82) return null;
+  if (isRecord12(exec2.readArgs)) {
+    const path92 = stringValue2(exec2.readArgs.path);
+    if (!path92) return null;
     if ([exec2.readArgs.offset, exec2.readArgs.limit].some((value) => typeof value === "number" && value < 0)) return null;
-    const offset = positiveNumber(exec2.readArgs.offset);
-    const limit = positiveNumber(exec2.readArgs.limit);
+    const offset = positiveNumber2(exec2.readArgs.offset);
+    const limit = positiveNumber2(exec2.readArgs.limit);
     if (offset !== void 0 || limit !== void 0) return null;
-    const mapped = tools.filter((tool) => matchesLeaf(tool, READ_CANDIDATES)).map((tool) => ({ tool, args: readArguments(tool.inputSchemaValue, path82) })).find((candidate) => candidate.args !== null);
+    const mapped = tools.filter((tool) => matchesLeaf(tool, READ_CANDIDATES)).map((tool) => ({ tool, args: readArguments(tool.inputSchemaValue, path92) })).find((candidate) => candidate.args !== null);
     if (!mapped?.args) return null;
     return redirect(
       exec2,
@@ -27460,14 +28439,14 @@ function cursorNativeExecRedirect(exec2, tools, providerIdentifier) {
       "readResult",
       "read-direct",
       mapped.args,
-      { path: path82 }
+      { path: path92 }
     );
   }
-  if (isRecord10(exec2.grepArgs)) {
+  if (isRecord12(exec2.grepArgs)) {
     const grepArgs = exec2.grepArgs;
     const pattern = stringValue2(grepArgs.pattern);
     if (!pattern.trim()) return null;
-    const path82 = stringValue2(grepArgs.path) || ".";
+    const path92 = stringValue2(grepArgs.path) || ".";
     const glob = stringValue2(grepArgs.glob);
     const outputMode = normalizedGrepOutputMode(stringValue2(grepArgs.outputMode));
     if (!outputMode) return null;
@@ -27483,27 +28462,27 @@ function cursorNativeExecRedirect(exec2, tools, providerIdentifier) {
     if (numericOptions.some((value) => typeof value === "number" && value < 0)) return null;
     const mappingInput = {
       pattern,
-      path: path82,
+      path: path92,
       glob,
       outputMode,
       caseInsensitive: grepArgs.caseInsensitive === true,
-      contextBefore: positiveNumber(grepArgs.contextBefore),
-      contextAfter: positiveNumber(grepArgs.contextAfter),
-      context: positiveNumber(grepArgs.context),
+      contextBefore: positiveNumber2(grepArgs.contextBefore),
+      contextAfter: positiveNumber2(grepArgs.contextAfter),
+      context: positiveNumber2(grepArgs.context),
       type: stringValue2(grepArgs.type) || void 0,
-      headLimit: positiveNumber(grepArgs.headLimit),
+      headLimit: positiveNumber2(grepArgs.headLimit),
       multiline: grepArgs.multiline === true,
       sort,
       sortAscending: Object.prototype.hasOwnProperty.call(grepArgs, "sortAscending") ? grepArgs.sortAscending === true : void 0,
-      offset: positiveNumber(grepArgs.offset)
+      offset: positiveNumber2(grepArgs.offset)
     };
     const mapped = tools.filter((tool) => matchesLeaf(tool, GREP_CANDIDATES)).map((tool) => ({ tool, args: grepArguments(tool, mappingInput) })).find((candidate) => candidate.args !== null);
     const nativeArgs = {
       pattern,
-      path: path82,
+      path: path92,
       outputMode,
       ...glob ? { glob } : {},
-      ...positiveNumber(grepArgs.offset) === void 0 ? {} : { offset: String(positiveNumber(grepArgs.offset)) }
+      ...positiveNumber2(grepArgs.offset) === void 0 ? {} : { offset: String(positiveNumber2(grepArgs.offset)) }
     };
     if (mapped?.args) {
       return redirect(
@@ -27537,15 +28516,15 @@ function cursorNativeExecRedirect(exec2, tools, providerIdentifier) {
       nativeArgs
     );
   }
-  if (isRecord10(exec2.shellArgs) || isRecord10(exec2.shellStreamArgs)) {
-    const argsRecord = isRecord10(exec2.shellArgs) ? exec2.shellArgs : exec2.shellStreamArgs;
+  if (isRecord12(exec2.shellArgs) || isRecord12(exec2.shellStreamArgs)) {
+    const argsRecord = isRecord12(exec2.shellArgs) ? exec2.shellArgs : exec2.shellStreamArgs;
     const command = stringValue2(argsRecord.command);
     if (!command) return null;
     const cwd = stringValue2(argsRecord.workingDirectory);
-    const timeout = positiveNumber(argsRecord.timeout) ?? positiveNumber(argsRecord.hardTimeout);
+    const timeout = positiveNumber2(argsRecord.timeout) ?? positiveNumber2(argsRecord.hardTimeout);
     const mapped = tools.filter((tool) => matchesLeaf(tool, SHELL_CANDIDATES)).map((tool) => ({ tool, args: shellArguments(tool.inputSchemaValue, command, cwd || void 0, timeout) })).find((candidate) => candidate.args !== null);
     if (!mapped?.args) return null;
-    const stream = isRecord10(exec2.shellStreamArgs);
+    const stream = isRecord12(exec2.shellStreamArgs);
     return redirect(
       exec2,
       mapped.tool,
@@ -27635,9 +28614,9 @@ function cursorNativeRedirectErrorReplies(correlation, error51) {
     }
   }
 }
-function readArguments(schema, path82) {
+function readArguments(schema, path92) {
   const pathKey = firstSchemaProperty(schema, ["file_path", "path"]);
-  return pathKey ? { [pathKey]: path82 } : null;
+  return pathKey ? { [pathKey]: path92 } : null;
 }
 function grepArguments(tool, input) {
   const leaf = normalizedLeaf(tool.clientName);
@@ -27804,7 +28783,7 @@ function parseGrepShellReceipt(output, expectedOutputMode) {
     const decoded = JSON.parse(inflateRawSync(compressed, {
       maxOutputLength: CURSOR_GREP_RECEIPT_MAX_BYTES
     }).toString("utf8"));
-    if (!isRecord10(decoded)) throw new Error("receipt is not an object");
+    if (!isRecord12(decoded)) throw new Error("receipt is not an object");
     if (decoded.ok === false && typeof decoded.error === "string") {
       return { ok: false, error: decoded.error };
     }
@@ -27817,7 +28796,7 @@ function parseGrepShellReceipt(output, expectedOutputMode) {
     if (!Array.isArray(decoded.counts) || !decoded.counts.every((entry) => Array.isArray(entry) && entry.length === 2 && typeof entry[0] === "string" && typeof entry[1] === "number" && Number.isSafeInteger(entry[1]) && entry[1] >= 0)) {
       throw new Error("receipt counts are invalid");
     }
-    if (!Array.isArray(decoded.matches) || !decoded.matches.every((entry) => isRecord10(entry) && typeof entry.file === "string" && typeof entry.lineNumber === "number" && Number.isSafeInteger(entry.lineNumber) && entry.lineNumber > 0 && typeof entry.content === "string" && typeof entry.contentTruncated === "boolean" && typeof entry.isContextLine === "boolean")) {
+    if (!Array.isArray(decoded.matches) || !decoded.matches.every((entry) => isRecord12(entry) && typeof entry.file === "string" && typeof entry.lineNumber === "number" && Number.isSafeInteger(entry.lineNumber) && entry.lineNumber > 0 && typeof entry.content === "string" && typeof entry.contentTruncated === "boolean" && typeof entry.isContextLine === "boolean")) {
       throw new Error("receipt matches are invalid");
     }
     for (const key of ["totalFiles", "totalLines", "totalMatchedLines"]) {
@@ -27835,7 +28814,7 @@ function parseGrepShellReceipt(output, expectedOutputMode) {
   }
 }
 function buildGrepReceiptSuccess(args, receipt) {
-  const path82 = args.path || ".";
+  const path92 = args.path || ".";
   let result;
   if (receipt.outputMode === "files_with_matches") {
     result = {
@@ -27881,15 +28860,15 @@ function buildGrepReceiptSuccess(args, receipt) {
   }
   return {
     pattern: args.pattern ?? "",
-    path: path82,
+    path: path92,
     outputMode: receipt.outputMode,
-    workspaceResults: { [path82]: result }
+    workspaceResults: { [path92]: result }
   };
 }
 function buildGrepSuccess(args, output) {
   const outputMode = normalizedGrepOutputMode(args.outputMode) ?? "content";
   const lines = output.split(/\r?\n/).map((line) => line.trimEnd()).filter((line) => line.length > 0 && !line.startsWith("[") && !/^no matches/i.test(line));
-  const path82 = args.path || ".";
+  const path92 = args.path || ".";
   let result;
   if (outputMode === "files_with_matches") {
     result = {
@@ -27952,9 +28931,9 @@ function buildGrepSuccess(args, output) {
   }
   return {
     pattern: args.pattern ?? "",
-    path: path82,
+    path: path92,
     outputMode,
-    workspaceResults: { [path82]: result }
+    workspaceResults: { [path92]: result }
   };
 }
 function parseCallerShellOutput(output, isError) {
@@ -28016,7 +28995,7 @@ function redirect(exec2, tool, providerIdentifier, messageId, execId, execCase,
 }
 function execArgsToolCallId(exec2) {
   for (const value of Object.values(exec2)) {
-    if (!isRecord10(value)) continue;
+    if (!isRecord12(value)) continue;
     const toolCallId = stringValue2(value.toolCallId);
     if (toolCallId) return toolCallId;
   }
@@ -28037,7 +29016,7 @@ function firstSchemaProperty(schema, candidates) {
   return candidates.find((candidate) => schemaHasProperty(schema, candidate));
 }
 function schemaHasProperty(schema, name) {
-  return isRecord10(schema.properties) && Object.prototype.hasOwnProperty.call(schema.properties, name);
+  return isRecord12(schema.properties) && Object.prototype.hasOwnProperty.call(schema.properties, name);
 }
 function execReply2(exec2, resultName, result) {
   return {
@@ -28057,14 +29036,14 @@ function numberValue2(value) {
 function numberOrUndefined(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function positiveNumber(value) {
+function positiveNumber2(value) {
   const number42 = numberOrUndefined(value);
   return number42 !== void 0 && number42 > 0 ? number42 : void 0;
 }
 function stringValue2(value) {
   return typeof value === "string" ? value : "";
 }
-function isRecord10(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var cursorAgentDescriptor = [
@@ -28895,18 +29874,18 @@ function decodeCursorServerMessage(payload) {
   const message = fromBinary(AgentServerMessageSchema, payload);
   const unknownExecFields = extractCursorUnknownExecFields(message);
   const json2 = toJson(AgentServerMessageSchema, message);
-  if (!isRecord11(json2)) throw new TypeError("Cursor server frame was not a message object");
+  if (!isRecord13(json2)) throw new TypeError("Cursor server frame was not a message object");
   if (unknownExecFields.length > 0) {
     Object.defineProperty(json2, CURSOR_UNKNOWN_EXEC_FIELDS, { value: unknownExecFields });
   }
   return json2;
 }
 function extractCursorUnknownExecFields(message) {
-  if (!isRecord11(message) || !isRecord11(message.message)) return [];
-  if (message.message.case !== "execServerMessage" || !isRecord11(message.message.value)) return [];
+  if (!isRecord13(message) || !isRecord13(message.message)) return [];
+  if (message.message.case !== "execServerMessage" || !isRecord13(message.message.value)) return [];
   const fields = message.message.value.$unknown;
   if (!Array.isArray(fields)) return [];
-  return fields.filter((field) => isRecord11(field) && typeof field.no === "number" && typeof field.wireType === "number" && field.data instanceof Uint8Array);
+  return fields.filter((field) => isRecord13(field) && typeof field.no === "number" && typeof field.wireType === "number" && field.data instanceof Uint8Array);
 }
 function parseConnectEndStreamError(payload) {
   try {
@@ -29228,7 +30207,7 @@ function cursorToolArgumentBytes(argumentsText) {
   } catch {
     return {};
   }
-  if (!isRecord11(parsed)) return {};
+  if (!isRecord13(parsed)) return {};
   return Object.fromEntries(Object.entries(parsed).map(([name, value]) => [
     name,
     Buffer.from(toBinary(ValueSchema, fromJson(ValueSchema, value))).toString("base64")
@@ -30513,7 +31492,7 @@ ${argumentsText}`;
   const handleFrame = (frame, replayed = false) => {
     const unknownExecFields = frame[CURSOR_UNKNOWN_EXEC_FIELDS] ?? [];
     lastFrame = describeCursorServerFrame(frame, unknownExecFields);
-    const tokenDetails = isRecord11(frame.conversationCheckpointUpdate) && isRecord11(frame.conversationCheckpointUpdate.tokenDetails) ? frame.conversationCheckpointUpdate.tokenDetails : void 0;
+    const tokenDetails = isRecord13(frame.conversationCheckpointUpdate) && isRecord13(frame.conversationCheckpointUpdate.tokenDetails) ? frame.conversationCheckpointUpdate.tokenDetails : void 0;
     const checkpointContextTokens = positiveTokenCount(tokenDetails?.usedTokens);
     const checkpointContextWindow = positiveTokenCount(tokenDetails?.maxTokens);
     if (!replayed) {
@@ -30526,7 +31505,7 @@ ${argumentsText}`;
         ...checkpointContextWindow === void 0 ? {} : { contextWindow: checkpointContextWindow }
       });
     }
-    if (isRecord11(frame.conversationCheckpointUpdate)) {
+    if (isRecord13(frame.conversationCheckpointUpdate)) {
       if (checkpointContextTokens !== void 0) {
         wireLog("cursor.wire.checkpoint", {
           model: diagnosticModel,
@@ -30549,7 +31528,7 @@ ${argumentsText}`;
       }
       return;
     }
-    if (isRecord11(frame.kvServerMessage)) {
+    if (isRecord13(frame.kvServerMessage)) {
       const kv = kvReply(frame.kvServerMessage, blobs);
       stream.write(encodeCursorClientMessage(kv.message));
       if (kv.fetch) {
@@ -30570,7 +31549,7 @@ ${argumentsText}`;
       });
       return;
     }
-    if (isRecord11(frame.interactionQuery)) {
+    if (isRecord13(frame.interactionQuery)) {
       const reply = cursorInteractionQueryReply(frame.interactionQuery);
       stream.write(encodeCursorClientMessage(reply.message));
       report("client.reply", { model: diagnosticModel, reply: reply.replyKind });
@@ -30586,7 +31565,7 @@ ${argumentsText}`;
       }
       return;
     }
-    if (isRecord11(frame.error)) {
+    if (isRecord13(frame.error)) {
       if (state === "attached") {
         emit({ type: "error", error: cursorError(frame.error) });
         completeRun("server_error");
@@ -30615,8 +31594,8 @@ ${argumentsText}`;
       return;
     }
     if (state !== "attached") return;
-    if (isRecord11(frame.execServerMessage)) {
-      if (isRecord11(frame.execServerMessage.requestContextArgs)) {
+    if (isRecord13(frame.execServerMessage)) {
+      if (isRecord13(frame.execServerMessage.requestContextArgs)) {
         stream.write(encodeCursorClientMessage(cursorRequestContextReply(frame.execServerMessage, tools)));
         report("client.reply", { model: diagnosticModel, reply: "exec.requestContext" });
         return;
@@ -30705,10 +31684,10 @@ ${argumentsText}`;
       }
       return;
     }
-    const update = isRecord11(frame.interactionUpdate) ? frame.interactionUpdate : void 0;
+    const update = isRecord13(frame.interactionUpdate) ? frame.interactionUpdate : void 0;
     if (update === void 0) return;
     if (isSettledToolUpdate(update)) return;
-    if (isRecord11(update.textDelta) && typeof update.textDelta.text === "string") {
+    if (isRecord13(update.textDelta) && typeof update.textDelta.text === "string") {
       activeSegment.outputText += update.textDelta.text;
       emit({
         type: "response.output_text.delta",
@@ -30719,7 +31698,7 @@ ${argumentsText}`;
       });
       return;
     }
-    if (isRecord11(update.thinkingDelta) && typeof update.thinkingDelta.text === "string") {
+    if (isRecord13(update.thinkingDelta) && typeof update.thinkingDelta.text === "string") {
       activeSegment.outputText += update.thinkingDelta.text;
       emit({
         type: "response.reasoning_summary_text.delta",
@@ -30729,12 +31708,12 @@ ${argumentsText}`;
       });
       return;
     }
-    if (isRecord11(update.tokenDelta)) {
+    if (isRecord13(update.tokenDelta)) {
       const tokens = positiveTokenCount(update.tokenDelta.tokens);
       if (tokens !== void 0) activeSegment.contextOutputTokens += tokens;
       return;
     }
-    if (isRecord11(update.toolCallStarted)) {
+    if (isRecord13(update.toolCallStarted)) {
       const wireCall = mcpCallFromToolUpdate(update.toolCallStarted);
       const call = wireCall ? cursorClientMcpCall(wireCall, tools) : null;
       if (call) {
@@ -30744,7 +31723,7 @@ ${argumentsText}`;
       }
       return;
     }
-    if (isRecord11(update.partialToolCall)) {
+    if (isRecord13(update.partialToolCall)) {
       const wireCall = mcpCallFromToolUpdate(update.partialToolCall);
       const call = wireCall ? cursorClientMcpCall(wireCall, tools) : null;
       if (!call) return;
@@ -30755,7 +31734,7 @@ ${argumentsText}`;
       rescheduleToolTurnFinish();
       return;
     }
-    if (isRecord11(update.toolCallCompleted)) {
+    if (isRecord13(update.toolCallCompleted)) {
       const wireCall = mcpCallFromToolUpdate(update.toolCallCompleted);
       const call = wireCall ? cursorClientMcpCall(wireCall, tools) : null;
       if (!call) return;
@@ -30768,7 +31747,7 @@ ${argumentsText}`;
       rescheduleToolTurnFinish();
       return;
     }
-    if (isRecord11(update.turnEnded)) completeRun("turn_ended");
+    if (isRecord13(update.turnEnded)) completeRun("turn_ended");
   };
   const eventsFor = (segment) => (async function* () {
     try {
@@ -30979,34 +31958,34 @@ var CURSOR_INTERACTION_QUERY_CASES = [
 ];
 var CURSOR_KV_CASES = ["getBlobArgs", "setBlobArgs"];
 function describeCursorServerFrame(frame, unknownExecFields = []) {
-  if (isRecord11(frame.interactionUpdate)) {
+  if (isRecord13(frame.interactionUpdate)) {
     return `interactionUpdate.${cursorNestedRecordCase(
       frame.interactionUpdate,
       CURSOR_INTERACTION_UPDATE_CASES
     )}`;
   }
-  if (isRecord11(frame.execServerMessage)) {
+  if (isRecord13(frame.execServerMessage)) {
     const knownCase = cursorNestedRecordCase(frame.execServerMessage, CURSOR_EXEC_CASES);
     return `execServerMessage.${knownCase === "unknown" ? cursorUnknownExecCaseName(unknownExecFields) : knownCase}`;
   }
-  if (isRecord11(frame.interactionQuery)) {
+  if (isRecord13(frame.interactionQuery)) {
     return `interactionQuery.${cursorNestedRecordCase(
       frame.interactionQuery,
       CURSOR_INTERACTION_QUERY_CASES
     )}`;
   }
-  if (isRecord11(frame.kvServerMessage)) {
+  if (isRecord13(frame.kvServerMessage)) {
     return `kvServerMessage.${cursorNestedRecordCase(frame.kvServerMessage, CURSOR_KV_CASES)}`;
   }
-  if (isRecord11(frame.conversationCheckpointUpdate)) return "conversationCheckpointUpdate";
-  if (isRecord11(frame.error)) return "error";
+  if (isRecord13(frame.conversationCheckpointUpdate)) return "conversationCheckpointUpdate";
+  if (isRecord13(frame.error)) return "error";
   return "unknown";
 }
 function isCursorHeartbeatFrame(frame) {
-  return isRecord11(frame.interactionUpdate) && isRecord11(frame.interactionUpdate.heartbeat);
+  return isRecord13(frame.interactionUpdate) && isRecord13(frame.interactionUpdate.heartbeat);
 }
 function cursorNestedRecordCase(value, cases) {
-  return cases.find((candidate) => isRecord11(value[candidate])) ?? "unknown";
+  return cases.find((candidate) => isRecord13(value[candidate])) ?? "unknown";
 }
 function positiveTokenCount(value) {
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) return void 0;
@@ -31018,8 +31997,8 @@ function cursorInteractionQueryReply(query) {
   const response = (result = {}) => ({
     interactionResponse: { id, ...result }
   });
-  if (isRecord11(query.createPlanRequestQuery)) {
-    const args = isRecord11(query.createPlanRequestQuery.args) ? query.createPlanRequestQuery.args : void 0;
+  if (isRecord13(query.createPlanRequestQuery)) {
+    const args = isRecord13(query.createPlanRequestQuery.args) ? query.createPlanRequestQuery.args : void 0;
     const name = stringValue3(args?.name)?.trim();
     const overview = stringValue3(args?.overview)?.trim();
     const plan = stringValue3(args?.plan)?.trim();
@@ -31035,7 +32014,7 @@ function cursorInteractionQueryReply(query) {
 ` } : {}
     };
   }
-  if (isRecord11(query.askQuestionInteractionQuery)) {
+  if (isRecord13(query.askQuestionInteractionQuery)) {
     return {
       message: response({
         askQuestionInteractionResponse: {
@@ -31045,7 +32024,7 @@ function cursorInteractionQueryReply(query) {
       replyKind: "interaction.askQuestion.rejected"
     };
   }
-  if (isRecord11(query.switchModeRequestQuery)) {
+  if (isRecord13(query.switchModeRequestQuery)) {
     return {
       message: response({
         switchModeRequestResponse: {
@@ -31055,19 +32034,19 @@ function cursorInteractionQueryReply(query) {
       replyKind: "interaction.switchMode.rejected"
     };
   }
-  if (isRecord11(query.webSearchRequestQuery)) {
+  if (isRecord13(query.webSearchRequestQuery)) {
     return {
       message: response({ webSearchRequestResponse: { approved: {} } }),
       replyKind: "interaction.webSearch.approved"
     };
   }
-  if (isRecord11(query.exaSearchRequestQuery)) {
+  if (isRecord13(query.exaSearchRequestQuery)) {
     return {
       message: response({ exaSearchRequestResponse: { approved: {} } }),
       replyKind: "interaction.exaSearch.approved"
     };
   }
-  if (isRecord11(query.exaFetchRequestQuery)) {
+  if (isRecord13(query.exaFetchRequestQuery)) {
     return {
       message: response({ exaFetchRequestResponse: { approved: {} } }),
       replyKind: "interaction.exaFetch.approved"
@@ -31077,7 +32056,7 @@ function cursorInteractionQueryReply(query) {
 }
 function kvReply(kv, blobs) {
   const id = kv.id ?? 0;
-  if (isRecord11(kv.getBlobArgs)) {
+  if (isRecord13(kv.getBlobArgs)) {
     const blobId = typeof kv.getBlobArgs.blobId === "string" ? kv.getBlobArgs.blobId : "";
     const blobData = blobs.get(blobId);
     return {
@@ -31089,7 +32068,7 @@ function kvReply(kv, blobs) {
       }
     };
   }
-  if (isRecord11(kv.setBlobArgs)) {
+  if (isRecord13(kv.setBlobArgs)) {
     const blobId = typeof kv.setBlobArgs.blobId === "string" ? kv.setBlobArgs.blobId : "";
     const blobData = typeof kv.setBlobArgs.blobData === "string" ? kv.setBlobArgs.blobData : "";
     if (blobId) blobs.set(blobId, blobData);
@@ -31140,7 +32119,7 @@ function repairCursorArgumentValue(value, schema) {
     return { value: String(value), count: 1 };
   }
   if (Array.isArray(value)) {
-    const itemSchema = isRecord11(schema) ? schema.items : void 0;
+    const itemSchema = isRecord13(schema) ? schema.items : void 0;
     if (itemSchema === void 0) return { value, count: 0 };
     let repairedValues;
     let count2 = 0;
@@ -31153,7 +32132,7 @@ function repairCursorArgumentValue(value, schema) {
     });
     return { value: repairedValues ?? value, count: count2 };
   }
-  if (!isRecord11(value) || !isRecord11(schema) || !isRecord11(schema.properties)) {
+  if (!isRecord13(value) || !isRecord13(schema) || !isRecord13(schema.properties)) {
     return { value, count: 0 };
   }
   let repairedValue;
@@ -31169,12 +32148,12 @@ function repairCursorArgumentValue(value, schema) {
   return { value: repairedValue ?? value, count };
 }
 function cursorSchemaRequiresString(schema) {
-  if (!isRecord11(schema)) return false;
+  if (!isRecord13(schema)) return false;
   if (schema.type === "string") return true;
   return Array.isArray(schema.type) && schema.type.includes("string") && schema.type.every((type) => type === "string" || type === "null");
 }
 function mcpCallFromToolUpdate(value) {
-  const toolCall = isRecord11(value.toolCall) ? value.toolCall : void 0;
+  const toolCall = isRecord13(value.toolCall) ? value.toolCall : void 0;
   const args = toolCall ? mcpArgsFromToolCall(toolCall) : void 0;
   if (!args) return null;
   const publicCallId = stringValue3(value.callId);
@@ -31199,7 +32178,7 @@ var CURSOR_TOOL_UPDATE_CASES = [
 function cursorToolUpdateIdentifiers(update) {
   for (const key of CURSOR_TOOL_UPDATE_CASES) {
     const value = update[key];
-    if (!isRecord11(value)) continue;
+    if (!isRecord13(value)) continue;
     const call = mcpCallFromToolUpdate(value);
     if (!call) return [];
     return [...new Set(
@@ -31209,9 +32188,9 @@ function cursorToolUpdateIdentifiers(update) {
   return void 0;
 }
 function isCursorClientToolFrame(frame, tools, redirectTools) {
-  const update = isRecord11(frame.interactionUpdate) ? frame.interactionUpdate : void 0;
+  const update = isRecord13(frame.interactionUpdate) ? frame.interactionUpdate : void 0;
   if (update !== void 0) return cursorToolUpdateIdentifiers(update) !== void 0;
-  const exec2 = isRecord11(frame.execServerMessage) ? frame.execServerMessage : void 0;
+  const exec2 = isRecord13(frame.execServerMessage) ? frame.execServerMessage : void 0;
   if (exec2 === void 0) return false;
   const wireCall = mcpCallFromExecMessage(exec2);
   const call = wireCall ? cursorClientMcpCall(wireCall, tools) : null;
@@ -31227,16 +32206,16 @@ function isCursorClientToolFrame(frame, tools, redirectTools) {
   ) !== null;
 }
 function isCursorParkedResidueFrame(frame, parked) {
-  const update = isRecord11(frame.interactionUpdate) ? frame.interactionUpdate : void 0;
+  const update = isRecord13(frame.interactionUpdate) ? frame.interactionUpdate : void 0;
   if (update === void 0) return false;
-  if (isRecord11(update.tokenDelta)) return true;
+  if (isRecord13(update.tokenDelta)) return true;
   const identifiers = cursorToolUpdateIdentifiers(update);
   if (identifiers === void 0 || identifiers.length === 0 || parked === void 0) return false;
   const sealed = new Set(parked.flatMap((call) => [call.callId, call.toolCallId]));
   return identifiers.some((identifier) => sealed.has(identifier));
 }
 function mcpCallFromExecMessage(value) {
-  const args = isRecord11(value.mcpArgs) ? value.mcpArgs : void 0;
+  const args = isRecord13(value.mcpArgs) ? value.mcpArgs : void 0;
   if (!args) return null;
   const toolCallId = stringValue3(args.toolCallId);
   if (!toolCallId) return null;
@@ -31254,14 +32233,14 @@ function mcpCallFromExecMessage(value) {
   };
 }
 function mcpArgsFromToolCall(toolCall) {
-  const direct = isRecord11(toolCall.mcpToolCall) ? toolCall.mcpToolCall : void 0;
-  if (direct && isRecord11(direct.args)) return direct.args;
-  const tool = isRecord11(toolCall.tool) ? toolCall.tool : void 0;
-  const nested = tool && isRecord11(tool.mcpToolCall) ? tool.mcpToolCall : void 0;
-  return nested && isRecord11(nested.args) ? nested.args : void 0;
+  const direct = isRecord13(toolCall.mcpToolCall) ? toolCall.mcpToolCall : void 0;
+  if (direct && isRecord13(direct.args)) return direct.args;
+  const tool = isRecord13(toolCall.tool) ? toolCall.tool : void 0;
+  const nested = tool && isRecord13(tool.mcpToolCall) ? tool.mcpToolCall : void 0;
+  return nested && isRecord13(nested.args) ? nested.args : void 0;
 }
 function cursorMcpArguments(args) {
-  if (!isRecord11(args.args) || Object.keys(args.args).length === 0) return {};
+  if (!isRecord13(args.args) || Object.keys(args.args).length === 0) return {};
   const decoded = {};
   for (const [name, value] of Object.entries(args.args)) {
     if (typeof value !== "string") {
@@ -31336,7 +32315,7 @@ function cursorError(value) {
     message: typeof value.message === "string" ? value.message : "Cursor request failed"
   };
 }
-function isRecord11(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var DEFAULT_CURSOR_DIAGNOSTIC_MAX_BYTES = 4 * 1024 * 1024;
@@ -31370,7 +32349,7 @@ var CURSOR_DIAGNOSTIC_EVENTS = /* @__PURE__ */ new Set([
   "turn.finish"
 ]);
 function createCursorDiagnosticLog(dir, options = {}) {
-  const logPath = path32__default.join(dir, CURSOR_DIAGNOSTIC_FILE);
+  const logPath = path42__default.join(dir, CURSOR_DIAGNOSTIC_FILE);
   const backupPath = `${logPath}.1`;
   const maxBytes = positiveInteger2(options.maxBytes) ?? DEFAULT_CURSOR_DIAGNOSTIC_MAX_BYTES;
   let initialized = false;
@@ -31751,27 +32730,32 @@ function createFailureJournal(options) {
     flush: () => chain
   };
 }
+var antigravityRequestPolicy = {
+  provider: "antigravity",
+  shapeRequest: (request, steps) => steps.stripClientIdentity(steps.withholdWebSearchTools(steps.pruneSkillPayloads(request)))
+};
 var codexRequestPolicy = {
   provider: "codex",
-  shapeRequest: (request, steps) => steps.withholdWebSearchTools(steps.pruneSkillPayloads(request))
+  shapeRequest: (request, steps) => steps.stripClientIdentity(steps.withholdWebSearchTools(steps.pruneSkillPayloads(request)))
 };
 var cursorRequestPolicy = {
   provider: "cursor",
-  shapeRequest: (request, steps) => steps.withholdWebSearchTools(steps.pruneSkillPayloads(request))
+  shapeRequest: (request, steps) => steps.stripClientIdentity(steps.withholdWebSearchTools(steps.pruneSkillPayloads(request)))
 };
 var kimiRequestPolicy = {
   provider: "kimi",
-  shapeRequest: (request, steps) => steps.pruneSkillPayloads(request)
+  shapeRequest: (request, steps) => steps.stripClientIdentity(steps.pruneSkillPayloads(request))
 };
 var opencodeGoRequestPolicy = {
   provider: "opencode",
-  shapeRequest: (request, steps) => steps.withholdWebSearchTools(steps.pruneSkillPayloads(request))
+  shapeRequest: (request, steps) => steps.stripClientIdentity(steps.withholdWebSearchTools(steps.pruneSkillPayloads(request)))
 };
 var xaiRequestPolicy = {
   provider: "xai",
-  shapeRequest: (request, steps) => steps.withholdWebSearchTools(steps.pruneSkillPayloads(request))
+  shapeRequest: (request, steps) => steps.stripClientIdentity(steps.withholdWebSearchTools(steps.pruneSkillPayloads(request)))
 };
 var POLICIES = {
+  antigravity: antigravityRequestPolicy,
   codex: codexRequestPolicy,
   cursor: cursorRequestPolicy,
   kimi: kimiRequestPolicy,
@@ -31805,6 +32789,15 @@ function buildPolicySteps(context) {
     withholdWebSearchTools: (request) => {
       const omitted = omitClaudeWebSearchTools(request);
       return omitted.changed ? omitted.request : request;
+    },
+    stripClientIdentity: (request) => {
+      const stripped = stripClaudeClientIdentity(request.system);
+      if (!stripped.changed) return request;
+      if (stripped.system === void 0) {
+        const { system: _dropped, ...rest } = request;
+        return rest;
+      }
+      return { ...request, system: [...stripped.system] };
     }
   };
 }
@@ -31934,6 +32927,13 @@ async function readXaiSubscriptionToken() {
   const credentials = await resolveXaiCliCredentials(defaultCredentialDeps);
   return credentials?.accessToken ?? null;
 }
+async function readAntigravitySubscriptionToken(options = {}) {
+  const credentials = await resolveAntigravityCredentials(
+    defaultCredentialDeps,
+    options.forceRenew === true ? { forceRefresh: true } : {}
+  );
+  return credentials?.accessToken ?? null;
+}
 async function readCodexSubscriptionAuth() {
   const credentials = await resolveCodexCredentials(defaultCredentialDeps);
   if (!credentials?.accountId) return null;
@@ -31948,6 +32948,16 @@ function createAiGatewayRouter(deps) {
   const fetchImpl = upstreamGate.fetch;
   const ownedCursorAdapter = deps.gateway ? void 0 : new CursorAdapter({ diagnostics: deps.cursorDiagnostics });
   const ownedCursorGateway = ownedCursorAdapter ? new AnthropicMessagesGateway(ownedCursorAdapter) : void 0;
+  let ownedAntigravityGateway;
+  const antigravityGateway = () => {
+    ownedAntigravityGateway ??= new AnthropicMessagesGateway(
+      new AntigravityGenerateContentAdapter({
+        fetch: fetchImpl,
+        ...deps.renewAntigravityToken ? { renewCredential: async () => await deps.renewAntigravityToken?.() ?? null } : {}
+      })
+    );
+    return ownedAntigravityGateway;
+  };
   const withheldSkills = /* @__PURE__ */ new Set();
   const gatewaySettings = () => deps.readAiGatewaySettings ? deps.readAiGatewaySettings() : void 0;
   const isModelExposed = (model) => {
@@ -32084,6 +33094,13 @@ function createAiGatewayRouter(deps) {
         return true;
       }
       credential = xaiToken;
+    } else if (target2?.provider === "antigravity") {
+      const antigravityToken = await deps.readAntigravityToken?.();
+      if (!antigravityToken) {
+        writeAnthropicError(res, 401, "authentication_error", "No active Antigravity sign-in was found. Run `agy` and sign in first.");
+        return true;
+      }
+      credential = antigravityToken;
     }
     const controller = new AbortController();
     const abort = () => controller.abort(new Error("client disconnected"));
@@ -32130,7 +33147,7 @@ function createAiGatewayRouter(deps) {
       ) : target2.provider === "xai" ? new AnthropicMessagesGateway(new XaiResponsesAdapter({
         fetch: fetchImpl,
         endpoint: xaiEndpoint()
-      })) : createGatewayFor(target2, chatgptAccountId, deps.originator, fetchImpl));
+      })) : target2.provider === "antigravity" ? antigravityGateway() : createGatewayFor(target2, chatgptAccountId, deps.originator, fetchImpl));
       const diagnosticsEnabled = target2.provider === "cursor" ? cursorDiagnosticsEnabled() : void 0;
       const modelContextWindow = typeof target2.contextWindow === "number" && Number.isFinite(target2.contextWindow) && target2.contextWindow > 0 ? target2.contextWindow : void 0;
       const upstream = await gateway.stream(body, {
@@ -32265,11 +33282,11 @@ var LOCK_OWNER_FILE_NAME2 = "owner";
 var TEMP_FILE_PREFIX2 = `${AI_GATEWAY_SETTINGS_FILE_NAME}.`;
 function createAiGatewaySettingsStore(deps = {}) {
   const dataDir = deps.dataDir ?? getFleetDataDir();
-  const settingsPath = path32.join(dataDir, AI_GATEWAY_SETTINGS_FILE_NAME);
-  const legacyPath = deps.legacyDir === void 0 ? void 0 : path32.join(deps.legacyDir, AI_GATEWAY_SETTINGS_FILE_NAME);
+  const settingsPath = path42.join(dataDir, AI_GATEWAY_SETTINGS_FILE_NAME);
+  const legacyPath = deps.legacyDir === void 0 ? void 0 : path42.join(deps.legacyDir, AI_GATEWAY_SETTINGS_FILE_NAME);
   const store = createDurableJsonStore({
     filePath: settingsPath,
-    lockDir: path32.join(dataDir, LOCK_DIR_NAME2),
+    lockDir: path42.join(dataDir, LOCK_DIR_NAME2),
     lockOwnerFileName: LOCK_OWNER_FILE_NAME2,
     sanitize: (value) => normalizeAiGatewaySettings(value),
     sensitivity: "sensitive",
@@ -32439,14 +33456,14 @@ function prepareAiGatewayLaunchProfile(profile, options) {
   return { ...profile, env };
 }
 function writeClaudeGatewayModelCache(baseUrl, env, homeDir, exposedModels = GATEWAY_MODELS) {
-  const configDir = env.CLAUDE_CONFIG_DIR && env.CLAUDE_CONFIG_DIR.length > 0 ? env.CLAUDE_CONFIG_DIR : path18__default.join(homeDir, ".claude");
+  const configDir = env.CLAUDE_CONFIG_DIR && env.CLAUDE_CONFIG_DIR.length > 0 ? env.CLAUDE_CONFIG_DIR : path19__default.join(homeDir, ".claude");
   return writeGatewayModelCacheForHome({ baseUrl, configDir, models: exposedModels });
 }
 function writeGatewayModelCacheForHome(options) {
   const { baseUrl, configDir } = options;
   const exposedModels = options.models ?? GATEWAY_MODELS;
-  const cacheDir = path18__default.join(configDir, "cache");
-  const cachePath = path18__default.join(cacheDir, "gateway-models.json");
+  const cacheDir = path19__default.join(configDir, "cache");
+  const cachePath = path19__default.join(cacheDir, "gateway-models.json");
   const models = buildAnthropicModelList(exposedModels).data.filter((model) => /^(claude|anthropic)/i.test(model.id)).map((model) => ({ id: model.id, display_name: model.display_name }));
   fs9__default.mkdirSync(cacheDir, { recursive: true, mode: 448 });
   writeAtomicSync(cachePath, JSON.stringify({ baseUrl, fetchedAt: Date.now(), models }), { mode: 384 });
@@ -32763,7 +33780,7 @@ function createChildEnv(env, overlay) {
   return child;
 }
 function wrapWindowsShim(resolved, env, platform) {
-  if (platform !== "win32" || !WINDOWS_SHIM_EXTENSIONS.has(path18__default.extname(resolved).toLowerCase())) {
+  if (platform !== "win32" || !WINDOWS_SHIM_EXTENSIONS.has(path19__default.extname(resolved).toLowerCase())) {
     return { bin: resolved, prefixArgs: [] };
   }
   rejectCmdExpansionSensitiveShim(resolved);
@@ -32781,13 +33798,13 @@ function forceWindowsArgQuoting(value) {
   return `${value} `;
 }
 function findOnPath(bin, pathValue, pathExts, platform) {
-  const pathSeparator = platform === "win32" ? WINDOWS_PATH_SEPARATOR : path18__default.delimiter;
-  if (hasPathSeparator(bin, platform) || path18__default.isAbsolute(bin)) {
+  const pathSeparator = platform === "win32" ? WINDOWS_PATH_SEPARATOR : path19__default.delimiter;
+  if (hasPathSeparator(bin, platform) || path19__default.isAbsolute(bin)) {
     return resolveWithExtensions(bin, pathExts, platform);
   }
   for (const entry of pathValue.split(pathSeparator)) {
     const searchDir = entry.length === 0 ? "." : entry;
-    const candidate = resolveWithExtensions(path18__default.join(searchDir, bin), pathExts, platform);
+    const candidate = resolveWithExtensions(path19__default.join(searchDir, bin), pathExts, platform);
     if (candidate) {
       return candidate;
     }
@@ -32795,7 +33812,7 @@ function findOnPath(bin, pathValue, pathExts, platform) {
   return void 0;
 }
 function resolveWithExtensions(candidate, pathExts, platform) {
-  if (platform !== "win32" || path18__default.extname(candidate).length > 0) {
+  if (platform !== "win32" || path19__default.extname(candidate).length > 0) {
     return isAccessibleExecutable(candidate, platform) ? candidate : void 0;
   }
   for (const ext of pathExts) {
@@ -33041,7 +34058,7 @@ function writePrivateJson(filePath, value, rootBase) {
 function writePrivateFile(filePath, content, rootBase) {
   const resolvedBase = ensureRootBase(rootBase);
   ensurePathWithinRoot(resolvedBase, filePath);
-  ensureDirectorySegments(resolvedBase, path18__default.dirname(filePath));
+  ensureDirectorySegments(resolvedBase, path19__default.dirname(filePath));
   writeFileNoFollow(filePath, content);
   chmodBestEffort2(filePath, FILE_MODE);
 }
@@ -33088,20 +34105,20 @@ function writeFileNoFollow(filePath, content) {
   }
 }
 function ensureRootBase(rootBase) {
-  const resolvedBase = path18__default.resolve(rootBase);
-  const anchor = findExistingDirectoryAnchor(path18__default.dirname(resolvedBase));
+  const resolvedBase = path19__default.resolve(rootBase);
+  const anchor = findExistingDirectoryAnchor(path19__default.dirname(resolvedBase));
   ensureDirectorySegments(anchor, resolvedBase);
   assertDirectorySafe(resolvedBase, "Plugin root base");
   return resolvedBase;
 }
 function assertRootBaseSafe(rootBase) {
-  const resolvedBase = path18__default.resolve(rootBase);
-  assertExistingSegmentsSafe(findExistingDirectoryAnchor(path18__default.dirname(resolvedBase)), resolvedBase);
+  const resolvedBase = path19__default.resolve(rootBase);
+  assertExistingSegmentsSafe(findExistingDirectoryAnchor(path19__default.dirname(resolvedBase)), resolvedBase);
   assertDirectorySafe(resolvedBase, "Plugin root base");
   return resolvedBase;
 }
 function findExistingDirectoryAnchor(targetPath) {
-  const resolvedTarget = path18__default.resolve(targetPath);
+  const resolvedTarget = path19__default.resolve(targetPath);
   let current = resolvedTarget;
   while (true) {
     try {
@@ -33109,7 +34126,7 @@ function findExistingDirectoryAnchor(targetPath) {
       return current;
     } catch (error51) {
       if (error51 instanceof Error && "code" in error51 && error51.code === "ENOENT") {
-        const parent = path18__default.dirname(current);
+        const parent = path19__default.dirname(current);
         if (parent === current) throw error51;
         current = parent;
         continue;
@@ -33128,17 +34145,17 @@ function assertDirectorySafe(dirPath, label) {
   }
 }
 function ensurePathWithinRoot(resolvedBase, candidatePath) {
-  const resolvedCandidate = path18__default.resolve(candidatePath);
-  const relative = path18__default.relative(resolvedBase, resolvedCandidate);
-  if (relative === "" || !relative.startsWith("..") && !path18__default.isAbsolute(relative)) return;
+  const resolvedCandidate = path19__default.resolve(candidatePath);
+  const relative = path19__default.relative(resolvedBase, resolvedCandidate);
+  if (relative === "" || !relative.startsWith("..") && !path19__default.isAbsolute(relative)) return;
   throw new Error(`Plugin path escapes root base: ${candidatePath}`);
 }
 function ensureDirectorySegments(resolvedBase, dirPath) {
-  const target2 = path18__default.resolve(dirPath);
-  const relative = path18__default.relative(resolvedBase, target2);
+  const target2 = path19__default.resolve(dirPath);
+  const relative = path19__default.relative(resolvedBase, target2);
   let current = resolvedBase;
-  for (const segment of relative.split(path18__default.sep).filter(Boolean)) {
-    current = path18__default.join(current, segment);
+  for (const segment of relative.split(path19__default.sep).filter(Boolean)) {
+    current = path19__default.join(current, segment);
     try {
       const stat4 = lstatSync(current);
       if (stat4.isSymbolicLink()) {
@@ -33159,11 +34176,11 @@ function ensureDirectorySegments(resolvedBase, dirPath) {
   }
 }
 function assertExistingSegmentsSafe(resolvedBase, targetPath) {
-  const target2 = path18__default.resolve(targetPath);
-  const relative = path18__default.relative(resolvedBase, target2);
+  const target2 = path19__default.resolve(targetPath);
+  const relative = path19__default.relative(resolvedBase, target2);
   let current = resolvedBase;
-  for (const segment of relative.split(path18__default.sep).filter(Boolean)) {
-    current = path18__default.join(current, segment);
+  for (const segment of relative.split(path19__default.sep).filter(Boolean)) {
+    current = path19__default.join(current, segment);
     const stat4 = lstatSync(current);
     if (stat4.isSymbolicLink()) {
       throw new Error(`Plugin path segment is a symlink: ${current}`);
@@ -33175,13 +34192,13 @@ function assertExistingSegmentsSafe(resolvedBase, targetPath) {
   }
 }
 function assertExistingParentSegmentsSafe(resolvedBase, targetPath) {
-  assertExistingSegmentsSafe(resolvedBase, path18__default.dirname(targetPath));
+  assertExistingSegmentsSafe(resolvedBase, path19__default.dirname(targetPath));
 }
 function assertSegmentRealpathWithinRoot(resolvedBase, segmentPath) {
   const baseRealpath = realpathSync(resolvedBase);
   const segmentRealpath = realpathSync(segmentPath);
-  const relative = path18__default.relative(baseRealpath, segmentRealpath);
-  if (relative === "" || !relative.startsWith("..") && !path18__default.isAbsolute(relative)) return;
+  const relative = path19__default.relative(baseRealpath, segmentRealpath);
+  if (relative === "" || !relative.startsWith("..") && !path19__default.isAbsolute(relative)) return;
   throw new Error(`Plugin path segment escapes root base: ${segmentPath}`);
 }
 
@@ -33201,23 +34218,23 @@ function resolveAssetPluginDirectoryName() {
 function renderAssetPluginRoot(pluginRoot, bundle, options) {
   renderEmbeddedSkillAssets(pluginRoot);
   const modelGuardScriptPath = writeModelGuardScript(pluginRoot);
-  writePrivateJson(path18__default.join(pluginRoot, "hooks", "hooks.json"), claudeHooks(options, modelGuardScriptPath), pluginRoot);
+  writePrivateJson(path19__default.join(pluginRoot, "hooks", "hooks.json"), claudeHooks(options, modelGuardScriptPath), pluginRoot);
   renderGatewayAgentAssets(pluginRoot, options);
 }
 function renderEmbeddedSkillAssets(pluginRoot) {
   for (const asset of EMBEDDED_AGENT_CLI_SKILL_ASSETS) {
-    writePrivateFile(path18__default.join(pluginRoot, "skills", asset.relativePath), asset.content, pluginRoot);
+    writePrivateFile(path19__default.join(pluginRoot, "skills", asset.relativePath), asset.content, pluginRoot);
   }
 }
 function renderGatewayAgentAssets(pluginRoot, options) {
   for (const file2 of buildGatewayAgentFiles(options.gatewayDelegationModels ?? [], options.gatewayEffortExposure)) {
-    writePrivateFile(path18__default.join(pluginRoot, "agents", file2.fileName), file2.content, pluginRoot);
+    writePrivateFile(path19__default.join(pluginRoot, "agents", file2.fileName), file2.content, pluginRoot);
   }
 }
 function writeModelGuardScript(pluginRoot) {
   const asset = EMBEDDED_AGENT_CLI_HOOK_ASSETS.find((entry) => entry.relativePath === MODEL_GUARD_SCRIPT_NAME);
   if (!asset) throw new Error(`Missing embedded ${MODEL_GUARD_SCRIPT_NAME} hook asset`);
-  const scriptPath = path18__default.join(pluginRoot, "hooks", MODEL_GUARD_SCRIPT_NAME);
+  const scriptPath = path19__default.join(pluginRoot, "hooks", MODEL_GUARD_SCRIPT_NAME);
   writePrivateFile(scriptPath, asset.content, pluginRoot);
   return scriptPath;
 }
@@ -33339,7 +34356,7 @@ function resolveRenderablePluginBundles(fleetRoot, options) {
 function homeMarketplaceTarget(fleetRoot) {
   return {
     name: FLEET_MARKETPLACE_NAME,
-    root: path18__default.join(fleetRoot, MARKETPLACE_DIR_NAME)
+    root: path19__default.join(fleetRoot, MARKETPLACE_DIR_NAME)
   };
 }
 function groupRenderableBundlesByMarketplace(bundles) {
@@ -33355,16 +34372,16 @@ function groupRenderableBundlesByMarketplace(bundles) {
   return groups;
 }
 function renderPluginRoot(pluginRoot, bundle, options) {
-  const parentRoot = path18__default.dirname(pluginRoot);
+  const parentRoot = path19__default.dirname(pluginRoot);
   ensurePrivateDir(parentRoot, parentRoot);
   const stageParent = createStagingDir(parentRoot);
-  const stagedPluginRoot = path18__default.join(stageParent, path18__default.basename(pluginRoot));
+  const stagedPluginRoot = path19__default.join(stageParent, path19__default.basename(pluginRoot));
   try {
     ensurePrivateDir(stagedPluginRoot, stagedPluginRoot);
-    writePrivateJson(path18__default.join(stagedPluginRoot, ".claude-plugin", "plugin.json"), claudeManifest(bundle), stagedPluginRoot);
+    writePrivateJson(path19__default.join(stagedPluginRoot, ".claude-plugin", "plugin.json"), claudeManifest(bundle), stagedPluginRoot);
     switch (bundle.source) {
       case "asset":
-        ensurePrivateDir(path18__default.join(stagedPluginRoot, "agents"), stagedPluginRoot);
+        ensurePrivateDir(path19__default.join(stagedPluginRoot, "agents"), stagedPluginRoot);
         renderAssetPluginRoot(stagedPluginRoot, bundle, options);
         break;
     }
@@ -33379,11 +34396,11 @@ function renderMarketplaceRoot(target2, bundles) {
   ensurePrivateDir(marketplaceRoot, marketplaceRoot);
   const stagedRoot = createStagingDir(marketplaceRoot);
   try {
-    writePrivateJson(path18__default.join(stagedRoot, ".claude-plugin", "marketplace.json"), claudeMarketplace(target2, bundles), stagedRoot);
+    writePrivateJson(path19__default.join(stagedRoot, ".claude-plugin", "marketplace.json"), claudeMarketplace(target2, bundles), stagedRoot);
     pruneMarketplaceRoot(target2);
     pruneStalePluginDirs(target2, bundles);
     for (const entry of readdirSync(stagedRoot)) {
-      renameSync$1(path18__default.join(stagedRoot, entry), path18__default.join(marketplaceRoot, entry));
+      renameSync$1(path19__default.join(stagedRoot, entry), path19__default.join(marketplaceRoot, entry));
     }
   } finally {
     cleanupPrivateRoot(stagedRoot, marketplaceRoot);
@@ -33391,11 +34408,11 @@ function renderMarketplaceRoot(target2, bundles) {
 }
 function pruneMarketplaceRoot(target2) {
   for (const entry of MARKETPLACE_PRUNE_ENTRIES) {
-    removePrivatePath(path18__default.join(target2.root, entry), target2.root);
+    removePrivatePath(path19__default.join(target2.root, entry), target2.root);
   }
 }
 function pruneStalePluginDirs(target2, bundles) {
-  const pluginsDir = path18__default.join(target2.root, PLUGIN_BUNDLES_DIR_NAME);
+  const pluginsDir = path19__default.join(target2.root, PLUGIN_BUNDLES_DIR_NAME);
   if (!existsSync(pluginsDir)) return;
   const activeDirectoryNames = /* @__PURE__ */ new Set();
   for (const bundle of bundles) {
@@ -33409,11 +34426,11 @@ function pruneStalePluginDirs(target2, bundles) {
   }
   for (const entry of readdirSync(pluginsDir)) {
     if (activeDirectoryNames.has(entry)) continue;
-    removePrivatePath(path18__default.join(pluginsDir, entry), target2.root);
+    removePrivatePath(path19__default.join(pluginsDir, entry), target2.root);
   }
 }
 function createStagingDir(rootPath) {
-  const stageRoot = mkdtempSync(path18__default.join(rootPath, `.fleet-stage-${process.pid}-${Date.now()}-`));
+  const stageRoot = mkdtempSync(path19__default.join(rootPath, `.fleet-stage-${process.pid}-${Date.now()}-`));
   return stageRoot;
 }
 function claudeMarketplace(target2, bundles) {
@@ -33435,7 +34452,7 @@ function claudeMarketplace(target2, bundles) {
   };
 }
 function pluginRootForTarget(target2, bundle) {
-  return path18__default.join(target2.root, PLUGIN_BUNDLES_DIR_NAME, bundle.directoryName);
+  return path19__default.join(target2.root, PLUGIN_BUNDLES_DIR_NAME, bundle.directoryName);
 }
 function marketplacePluginPath(target2, bundle) {
   return `./${PLUGIN_BUNDLES_DIR_NAME}/${bundle.directoryName}`;
@@ -34733,18 +35750,18 @@ Always read \`schema/wiki-schema.md\` directly before composing or revising entr
 `;
 async function ensureWorkspaceSchema(paths) {
   await mkdir$1(paths.schemaDir, { recursive: true });
-  await writeDefaultFileIfMissing(path18__default.join(paths.schemaDir, WORKSPACE_SCHEMA_AGENTS_FILENAME), DEFAULT_WORKSPACE_SCHEMA_AGENTS);
-  await writeDefaultFileIfMissing(path18__default.join(paths.schemaDir, WORKSPACE_SCHEMA_FILENAME), DEFAULT_WORKSPACE_WIKI_SCHEMA);
+  await writeDefaultFileIfMissing(path19__default.join(paths.schemaDir, WORKSPACE_SCHEMA_AGENTS_FILENAME), DEFAULT_WORKSPACE_SCHEMA_AGENTS);
+  await writeDefaultFileIfMissing(path19__default.join(paths.schemaDir, WORKSPACE_SCHEMA_FILENAME), DEFAULT_WORKSPACE_WIKI_SCHEMA);
   await writeDefaultFileIfMissing(buildTemplatePath(paths, "prd"), DEFAULT_TEMPLATE_PRD);
   return readWorkspaceSchemaSummary(paths);
 }
 async function ensureWorkspaceDoctrine(paths) {
   await mkdir$1(paths.root, { recursive: true });
-  await writeDefaultFileIfMissing(path18__default.join(paths.root, WORKSPACE_KNOWLEDGE_AGENTS_FILENAME), DEFAULT_WORKSPACE_KNOWLEDGE_AGENTS);
+  await writeDefaultFileIfMissing(path19__default.join(paths.root, WORKSPACE_KNOWLEDGE_AGENTS_FILENAME), DEFAULT_WORKSPACE_KNOWLEDGE_AGENTS);
 }
 async function readWorkspaceSchemaSummary(paths) {
-  const agentsPath = path18__default.join(paths.schemaDir, WORKSPACE_SCHEMA_AGENTS_FILENAME);
-  const wikiSchemaPath = path18__default.join(paths.schemaDir, WORKSPACE_SCHEMA_FILENAME);
+  const agentsPath = path19__default.join(paths.schemaDir, WORKSPACE_SCHEMA_AGENTS_FILENAME);
+  const wikiSchemaPath = path19__default.join(paths.schemaDir, WORKSPACE_SCHEMA_FILENAME);
   const wikiSchemaContent = await tryReadSchemaFile(paths, wikiSchemaPath);
   const templates = await scanTemplates(paths);
   if (wikiSchemaContent === null) {
@@ -34783,7 +35800,7 @@ async function scanTemplates(paths) {
     if (!entry.name.startsWith(WORKSPACE_TEMPLATE_PREFIX) || !entry.name.endsWith(WORKSPACE_TEMPLATE_SUFFIX)) continue;
     const id = entry.name.slice(WORKSPACE_TEMPLATE_PREFIX.length, -WORKSPACE_TEMPLATE_SUFFIX.length);
     if (!TEMPLATE_ID_PATTERN.test(id)) continue;
-    const filePath = path18__default.join(paths.schemaDir, entry.name);
+    const filePath = path19__default.join(paths.schemaDir, entry.name);
     try {
       const parsed = parseTemplateMarkdown(await readFile(filePath, "utf8"));
       templates.push({
@@ -34815,7 +35832,7 @@ async function readSchemaCatalog(paths) {
 }
 async function readSchemaDocument(paths, resource, templateId) {
   const ref = resource === "schema" ? "schema/wiki-schema.md" : schemaTemplateRef(templateId ?? "");
-  const absolute = path18__default.resolve(paths.root, ref);
+  const absolute = path19__default.resolve(paths.root, ref);
   await assertContainedSchemaFile(paths, absolute, false);
   return { ref, content: await readFile(absolute, "utf8") };
 }
@@ -34840,10 +35857,10 @@ async function validateSchemaTemplateCreate(paths, templateId, markdown) {
     if (folded.has(key)) throw new Error(`schema template contains duplicate ## section: ${section}`);
     folded.add(key);
   }
-  const absolute = path18__default.resolve(paths.root, ref);
+  const absolute = path19__default.resolve(paths.root, ref);
   await assertContainedSchemaFile(paths, absolute, true);
   const entries = await readdir(paths.schemaDir).catch(() => []);
-  const basename = path18__default.basename(absolute).toLocaleLowerCase("en-US");
+  const basename = path19__default.basename(absolute).toLocaleLowerCase("en-US");
   if (entries.some((entry) => entry.toLocaleLowerCase("en-US") === basename)) throw new Error("schema template target already exists");
   return absolute;
 }
@@ -34851,13 +35868,13 @@ function assertTemplateId(id) {
   if (!TEMPLATE_ID_PATTERN.test(id)) throw new Error("template_id must match /^[a-z][a-z0-9-]{0,63}$/");
 }
 async function assertContainedSchemaFile(paths, absolute, allowMissing) {
-  const schemaReal = await realpath(paths.schemaDir).catch(() => path18__default.resolve(paths.schemaDir));
-  const parentReal = await realpath(path18__default.dirname(absolute)).catch(() => path18__default.resolve(path18__default.dirname(absolute)));
+  const schemaReal = await realpath(paths.schemaDir).catch(() => path19__default.resolve(paths.schemaDir));
+  const parentReal = await realpath(path19__default.dirname(absolute)).catch(() => path19__default.resolve(path19__default.dirname(absolute)));
   if (parentReal !== schemaReal) throw new Error("schema resource escapes schema directory");
-  const relative = path18__default.relative(paths.root, absolute);
+  const relative = path19__default.relative(paths.root, absolute);
   let cursor = paths.root;
-  for (const part of relative.split(path18__default.sep)) {
-    cursor = path18__default.join(cursor, part);
+  for (const part of relative.split(path19__default.sep)) {
+    cursor = path19__default.join(cursor, part);
     try {
       if ((await lstat(cursor)).isSymbolicLink()) throw new Error("schema resource path contains symlink");
     } catch (error51) {
@@ -34885,7 +35902,7 @@ async function validateTemplateCompliance(paths, templateId, body) {
   }
 }
 function inferTemplateIdFromTarget(target2, knownTemplateIds) {
-  const basename = path18__default.basename(target2, ".md");
+  const basename = path19__default.basename(target2, ".md");
   const ids = knownTemplateIds ?? DEFAULT_TEMPLATE_IDS;
   const sorted = [...ids].sort((a, b) => b.length - a.length);
   for (const id of sorted) {
@@ -34917,7 +35934,7 @@ function extractSchemaSummary(content) {
   return lines.find((line) => line.length > 0 && !line.startsWith("#")) ?? "Workspace schema is present.";
 }
 function buildTemplatePath(paths, id) {
-  return path18__default.join(paths.schemaDir, `${WORKSPACE_TEMPLATE_PREFIX}${id}${WORKSPACE_TEMPLATE_SUFFIX}`);
+  return path19__default.join(paths.schemaDir, `${WORKSPACE_TEMPLATE_PREFIX}${id}${WORKSPACE_TEMPLATE_SUFFIX}`);
 }
 function parseTemplateMarkdown(content) {
   const normalized = content.replace(/\r\n/g, "\n");
@@ -35022,18 +36039,18 @@ function isAlreadyExistsError(error51) {
 
 // ../../packages/fleet-wiki/src/paths.ts
 function resolveMemoryPaths(cwd) {
-  return createMemoryPaths(path18__default.join(cwd, KNOWLEDGE_ROOT_DIRNAME));
+  return createMemoryPaths(path19__default.join(cwd, KNOWLEDGE_ROOT_DIRNAME));
 }
 function createMemoryPaths(root) {
   return {
     root,
-    rawDir: path18__default.join(root, RAW_DIRNAME),
-    wikiDir: path18__default.join(root, WIKI_DIRNAME),
-    schemaDir: path18__default.join(root, SCHEMA_DIRNAME),
-    queueDir: path18__default.join(root, QUEUE_DIRNAME),
-    archiveDir: path18__default.join(root, ARCHIVE_DIRNAME),
-    conflictsDir: path18__default.join(root, CONFLICTS_DIRNAME),
-    indexFile: path18__default.join(root, INDEX_FILENAME)
+    rawDir: path19__default.join(root, RAW_DIRNAME),
+    wikiDir: path19__default.join(root, WIKI_DIRNAME),
+    schemaDir: path19__default.join(root, SCHEMA_DIRNAME),
+    queueDir: path19__default.join(root, QUEUE_DIRNAME),
+    archiveDir: path19__default.join(root, ARCHIVE_DIRNAME),
+    conflictsDir: path19__default.join(root, CONFLICTS_DIRNAME),
+    indexFile: path19__default.join(root, INDEX_FILENAME)
   };
 }
 function resolveToolMemoryPaths(ctx) {
@@ -35051,10 +36068,10 @@ async function ensureMemoryRoot(paths) {
   await ensureWorkspaceDoctrine(paths);
 }
 function getIndexMarkdownFile(paths) {
-  return path18__default.join(paths.wikiDir, INDEX_MD_FILENAME);
+  return path19__default.join(paths.wikiDir, INDEX_MD_FILENAME);
 }
 function getLogFile(paths) {
-  return path18__default.join(paths.root, LOG_MD_FILENAME);
+  return path19__default.join(paths.root, LOG_MD_FILENAME);
 }
 
 // ../../packages/fleet-wiki/src/conflicts.ts
@@ -35066,7 +36083,7 @@ async function createConflict(input, paths) {
   await ensureMemoryRoot(paths);
   const now = input.now ?? /* @__PURE__ */ new Date();
   const conflictId = buildConflictId(now, input.wikiId, input.reason, input.proposed);
-  const conflictDir = path18__default.join(paths.conflictsDir, conflictId);
+  const conflictDir = path19__default.join(paths.conflictsDir, conflictId);
   await mkdir$1(conflictDir, { recursive: true });
   const meta3 = {
     id: conflictId,
@@ -35086,13 +36103,13 @@ async function createConflict(input, paths) {
     currentHash: input.currentHash,
     warnings: input.warnings
   };
-  await writeJsonFile(path18__default.join(conflictDir, CONFLICT_META_FILENAME), meta3, paths);
-  await writePatchFile(path18__default.join(conflictDir, CONFLICT_PROPOSED_FILENAME), input.proposed, paths);
+  await writeJsonFile(path19__default.join(conflictDir, CONFLICT_META_FILENAME), meta3, paths);
+  await writePatchFile(path19__default.join(conflictDir, CONFLICT_PROPOSED_FILENAME), input.proposed, paths);
   if (input.current !== void 0) {
-    await writePatchFile(path18__default.join(conflictDir, CONFLICT_CURRENT_FILENAME), input.current, paths);
+    await writePatchFile(path19__default.join(conflictDir, CONFLICT_CURRENT_FILENAME), input.current, paths);
   }
   if (input.rawSource !== void 0) {
-    await writePatchFile(path18__default.join(conflictDir, CONFLICT_RAW_SOURCE_FILENAME), input.rawSource, paths);
+    await writePatchFile(path19__default.join(conflictDir, CONFLICT_RAW_SOURCE_FILENAME), input.rawSource, paths);
   }
   return {
     meta: meta3,
@@ -35106,7 +36123,7 @@ async function listConflicts(paths) {
   const metas = [];
   for (const id of ids) {
     try {
-      metas.push(await readJsonFile2(path18__default.join(paths.conflictsDir, id, CONFLICT_META_FILENAME)));
+      metas.push(await readJsonFile2(path19__default.join(paths.conflictsDir, id, CONFLICT_META_FILENAME)));
     } catch {
       continue;
     }
@@ -35115,13 +36132,13 @@ async function listConflicts(paths) {
 }
 async function readConflict(conflictId, paths) {
   const conflictDir = resolveConflictDir(conflictId, paths);
-  const meta3 = await readJsonFile2(path18__default.join(conflictDir, CONFLICT_META_FILENAME));
-  const currentPath = path18__default.join(conflictDir, CONFLICT_CURRENT_FILENAME);
-  const rawSourcePath = path18__default.join(conflictDir, CONFLICT_RAW_SOURCE_FILENAME);
+  const meta3 = await readJsonFile2(path19__default.join(conflictDir, CONFLICT_META_FILENAME));
+  const currentPath = path19__default.join(conflictDir, CONFLICT_CURRENT_FILENAME);
+  const rawSourcePath = path19__default.join(conflictDir, CONFLICT_RAW_SOURCE_FILENAME);
   return {
     meta: meta3,
     current: await pathExists(currentPath) ? await readPatchFile(currentPath) : void 0,
-    proposed: await readPatchFile(path18__default.join(conflictDir, CONFLICT_PROPOSED_FILENAME)),
+    proposed: await readPatchFile(path19__default.join(conflictDir, CONFLICT_PROPOSED_FILENAME)),
     rawSource: await pathExists(rawSourcePath) ? await readPatchFile(rawSourcePath) : void 0
   };
 }
@@ -35140,9 +36157,9 @@ function sanitizeConflictToken(value) {
   return value.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "unknown";
 }
 function resolveConflictDir(conflictId, paths) {
-  const conflictDir = path18__default.resolve(paths.conflictsDir, conflictId);
-  const relative = path18__default.relative(paths.conflictsDir, conflictDir);
-  if (!relative || relative.startsWith("..") || path18__default.isAbsolute(relative)) {
+  const conflictDir = path19__default.resolve(paths.conflictsDir, conflictId);
+  const relative = path19__default.relative(paths.conflictsDir, conflictDir);
+  if (!relative || relative.startsWith("..") || path19__default.isAbsolute(relative)) {
     throw new Error(`[fleet-wiki] conflict id escapes conflicts/: ${conflictId}`);
   }
   return conflictDir;
@@ -35306,11 +36323,11 @@ async function validatePatch(patch, paths) {
   if (!target2 || !summary || !proposer || !created) throw new Error("patch frontmatter is incomplete");
   if (summary.length > 120) throw new Error("patch summary exceeds 120 chars");
   assertCanonicalPatchTarget(target2);
-  const absoluteTarget = path18__default.resolve(paths.root, target2);
-  if (!absoluteTarget.startsWith(`${paths.root}${path18__default.sep}`) && absoluteTarget !== paths.root) {
+  const absoluteTarget = path19__default.resolve(paths.root, target2);
+  if (!absoluteTarget.startsWith(`${paths.root}${path19__default.sep}`) && absoluteTarget !== paths.root) {
     throw new Error("patch target escapes wiki root");
   }
-  if (!absoluteTarget.startsWith(`${paths.wikiDir}${path18__default.sep}`)) throw new Error("wiki patch must target wiki/");
+  if (!absoluteTarget.startsWith(`${paths.wikiDir}${path19__default.sep}`)) throw new Error("wiki patch must target wiki/");
   assertNoSymlinkPathComponents(target2, paths);
   if (op === "create_wiki" && await pathExists(absoluteTarget)) {
     throw new Error(
@@ -35331,19 +36348,19 @@ async function applyPatch(patch, paths) {
 async function enqueuePatch(patch, paths, metaOverrides) {
   await ensureMemoryRoot(paths);
   const patchId = buildPatchId(patch.frontmatter.created, patch.frontmatter.summary, patch.frontmatter.target, patch.body);
-  const queueDir = path18__default.join(paths.queueDir, patchId);
+  const queueDir = path19__default.join(paths.queueDir, patchId);
   if (await pathExists(queueDir)) {
     throw new Error(`[fleet-wiki] patch id collision: ${patchId} - this should never happen with target+body hashing`);
   }
   await mkdir$1(queueDir, { recursive: true });
-  await writePatchFile(path18__default.join(queueDir, PATCH_FILENAME), serializePatch(patch), paths);
+  await writePatchFile(path19__default.join(queueDir, PATCH_FILENAME), serializePatch(patch), paths);
   const meta3 = {
     id: patchId,
     status: "pending",
     createdAt: patch.frontmatter.created,
     ...metaOverrides
   };
-  await writeJsonFile(path18__default.join(queueDir, PATCH_META_FILENAME), meta3, paths);
+  await writeJsonFile(path19__default.join(queueDir, PATCH_META_FILENAME), meta3, paths);
   await appendLog(paths, "patch enqueued", {
     patch_id: patchId,
     patch_set_id: meta3.patch_set_id ?? null,
@@ -35361,7 +36378,7 @@ async function listQueue(paths) {
   for (const id of ids) {
     if (id === "_sets") continue;
     try {
-      const meta3 = await readJsonFile2(path18__default.join(paths.queueDir, id, PATCH_META_FILENAME));
+      const meta3 = await readJsonFile2(path19__default.join(paths.queueDir, id, PATCH_META_FILENAME));
       results.push({ id, meta: meta3 });
     } catch {
       continue;
@@ -35386,17 +36403,17 @@ async function resolveQueueSelection(id, paths) {
 }
 async function showQueue(id, paths) {
   const selection = await resolveQueueSelection(id, paths);
-  const queueDir = path18__default.join(paths.queueDir, selection.id);
-  const patch = await parsePatch(await readPatchFile(path18__default.join(queueDir, PATCH_FILENAME)));
-  const meta3 = await readJsonFile2(path18__default.join(queueDir, PATCH_META_FILENAME));
+  const queueDir = path19__default.join(paths.queueDir, selection.id);
+  const patch = await parsePatch(await readPatchFile(path19__default.join(queueDir, PATCH_FILENAME)));
+  const meta3 = await readJsonFile2(path19__default.join(queueDir, PATCH_META_FILENAME));
   return { patch, meta: meta3 };
 }
 async function rewriteQueuedPatch(id, paths, patch, meta3, expectedPatchHash) {
   assertSafeQueueId(id);
   return withPatchEditLock(paths, id, async () => {
-    const queueDir = path18__default.join(paths.queueDir, id);
+    const queueDir = path19__default.join(paths.queueDir, id);
     if (expectedPatchHash !== void 0) {
-      const currentMarkdown = await readPatchFile(path18__default.join(queueDir, PATCH_FILENAME));
+      const currentMarkdown = await readPatchFile(path19__default.join(queueDir, PATCH_FILENAME));
       const currentHash = computeContentHash(currentMarkdown);
       if (currentHash !== expectedPatchHash) {
         throw new Error(`[fleet-wiki] wiki_patch_edit stale base_patch_hash: expected ${currentHash}, got ${expectedPatchHash}`);
@@ -35405,8 +36422,8 @@ async function rewriteQueuedPatch(id, paths, patch, meta3, expectedPatchHash) {
     const patchMarkdown = serializePatch(patch);
     const patchHash = computeContentHash(patchMarkdown);
     const nextMeta = { ...meta3, lastEditHash: patchHash };
-    await writePatchFile(path18__default.join(queueDir, PATCH_FILENAME), patchMarkdown, paths);
-    await writeJsonFile(path18__default.join(queueDir, PATCH_META_FILENAME), nextMeta, paths);
+    await writePatchFile(path19__default.join(queueDir, PATCH_FILENAME), patchMarkdown, paths);
+    await writeJsonFile(path19__default.join(queueDir, PATCH_META_FILENAME), nextMeta, paths);
     return patchHash;
   });
 }
@@ -35430,8 +36447,8 @@ async function approvePatch(id, paths) {
           rawSourceRef: meta3.rawSourceRef,
           warnings: meta3.warnings
         });
-        const queueDir = path18__default.join(paths.queueDir, id);
-        await writeJsonFile(path18__default.join(queueDir, PATCH_META_FILENAME), {
+        const queueDir = path19__default.join(paths.queueDir, id);
+        await writeJsonFile(path19__default.join(queueDir, PATCH_META_FILENAME), {
           ...meta3,
           conflictId
         }, paths);
@@ -35467,7 +36484,7 @@ async function approvePatchSet(patchSetId, paths) {
   const failed = [];
   const missing = [];
   for (const patchId of patchSet.patchIds) {
-    const queueDir = path18__default.join(paths.queueDir, patchId);
+    const queueDir = path19__default.join(paths.queueDir, patchId);
     if (!await pathExists(queueDir)) {
       missing.push(patchId);
       continue;
@@ -35533,7 +36550,7 @@ ${patch.body}`;
 }
 async function normalizeWikiEntryPatch(entry, target2, paths) {
   assertSafeEntryId(entry.id);
-  if (entry.id !== path18__default.basename(target2, ".md")) {
+  if (entry.id !== path19__default.basename(target2, ".md")) {
     throw new Error("wiki patch body id must match target filename");
   }
   const inlineRawSourceRef = extractInlineRawSourceRef(entry.body);
@@ -35576,9 +36593,9 @@ function buildPatchId(createdAt, summary, target2, body) {
 }
 async function validatePatchBase(patch, meta3, paths) {
   if (patch.frontmatter.op !== "update_wiki" || !meta3?.baseVersion && !meta3?.baseHash) return;
-  const wikiId = path18__default.basename(patch.frontmatter.target, ".md");
+  const wikiId = path19__default.basename(patch.frontmatter.target, ".md");
   const currentEntry = await readWikiEntry(wikiId, paths);
-  const currentPath = path18__default.join(paths.root, patch.frontmatter.target);
+  const currentPath = path19__default.join(paths.root, patch.frontmatter.target);
   const currentMarkdown = await pathExists(currentPath) ? await readPatchFile(currentPath) : void 0;
   if (meta3.baseVersion !== void 0 && currentEntry?.version !== meta3.baseVersion) {
     throw new Error(
@@ -35637,17 +36654,17 @@ function assertCanonicalPatchTarget(target2) {
   if (target2.endsWith("/")) {
     throw new Error("patch target must not end with a slash");
   }
-  if (target2.startsWith("/") || path18__default.posix.isAbsolute(target2) || path18__default.win32.isAbsolute(target2)) {
+  if (target2.startsWith("/") || path19__default.posix.isAbsolute(target2) || path19__default.win32.isAbsolute(target2)) {
     throw new Error("patch target must be relative");
   }
-  if (path18__default.posix.normalize(target2) !== target2) {
+  if (path19__default.posix.normalize(target2) !== target2) {
     throw new Error("patch target must not contain dot segments or redundant separators");
   }
 }
 function canonicalApprovalLockKey(paths, target2) {
   const wikiRoot = realpathSync(paths.wikiDir);
-  const relativeTarget = path18__default.posix.relative("wiki", target2);
-  const targetPath = path18__default.join(wikiRoot, ...relativeTarget.split("/"));
+  const relativeTarget = path19__default.posix.relative("wiki", target2);
+  const targetPath = path19__default.join(wikiRoot, ...relativeTarget.split("/"));
   return `${wikiRoot}\0${targetPath}`.toLowerCase();
 }
 function canonicalPatchEditLockKey(paths, patchId) {
@@ -35663,7 +36680,7 @@ function assertNoSymlinkPathComponents(target2, paths) {
     throw error51;
   }
   for (const part of parts) {
-    current = path18__default.join(current, part);
+    current = path19__default.join(current, part);
     try {
       if (lstatSync(current).isSymbolicLink()) {
         throw new Error("patch target must not include symlink path components");
@@ -35678,8 +36695,8 @@ function assertSafeRawSourceRef(rawSourceRef, paths) {
   if (!rawSourceRef.startsWith("raw/")) {
     throw new Error("raw source provenance must point into raw/");
   }
-  const absoluteRef = path18__default.resolve(paths.root, rawSourceRef);
-  if (!absoluteRef.startsWith(`${paths.rawDir}${path18__default.sep}`)) {
+  const absoluteRef = path19__default.resolve(paths.root, rawSourceRef);
+  if (!absoluteRef.startsWith(`${paths.rawDir}${path19__default.sep}`)) {
     throw new Error("raw source provenance must point into raw/");
   }
 }
@@ -35695,14 +36712,14 @@ function classifyPatchConflict(error51) {
 }
 async function recordPatchConflict(patch, paths, reason, options) {
   const now = /* @__PURE__ */ new Date();
-  const targetPath = path18__default.join(paths.root, patch.frontmatter.target);
+  const targetPath = path19__default.join(paths.root, patch.frontmatter.target);
   const current = await pathExists(targetPath) ? await readPatchFile(targetPath) : void 0;
   const currentEntry = current ? parseStoredWikiEntry(current) : void 0;
   const proposedEntry = parsePatchBodyEntry(patch.body);
   const record7 = await createConflict({
     reason,
     target: patch.frontmatter.target,
-    wikiId: proposedEntry?.id ?? path18__default.basename(patch.frontmatter.target, ".md"),
+    wikiId: proposedEntry?.id ?? path19__default.basename(patch.frontmatter.target, ".md"),
     title: proposedEntry?.title,
     proposer: patch.frontmatter.proposer,
     rawSourceRef: options?.rawSourceRef,
@@ -35814,11 +36831,11 @@ function parseInlineArray(value) {
   return inner.split(",").map((item) => decodeFrontmatter(item.trim().replace(/^"(.*)"$/, "$1")));
 }
 async function archiveQueueEntry(id, paths, meta3) {
-  const fromDir = path18__default.join(paths.queueDir, id);
-  const toDir = path18__default.join(paths.archiveDir, id);
+  const fromDir = path19__default.join(paths.queueDir, id);
+  const toDir = path19__default.join(paths.archiveDir, id);
   await removePath(toDir);
   await movePath(fromDir, toDir);
-  await writeJsonFile(path18__default.join(toDir, PATCH_META_FILENAME), meta3, paths);
+  await writeJsonFile(path19__default.join(toDir, PATCH_META_FILENAME), meta3, paths);
 }
 function buildQueueIdHelp(prefix, availableIds) {
   if (availableIds.length === 0) {
@@ -35850,15 +36867,15 @@ var PATCH_SET_DIRNAME = "_sets";
 var PATCH_SET_META_FILENAME = PATCH_META_FILENAME;
 function getPatchSetDir(paths, patchSetId) {
   assertSafePatchSetId(patchSetId);
-  const patchSetDir = path18__default.join(paths.queueDir, PATCH_SET_DIRNAME, patchSetId);
-  const relative = path18__default.relative(path18__default.join(paths.queueDir, PATCH_SET_DIRNAME), patchSetDir);
-  if (!relative || relative.startsWith("..") || path18__default.isAbsolute(relative)) {
+  const patchSetDir = path19__default.join(paths.queueDir, PATCH_SET_DIRNAME, patchSetId);
+  const relative = path19__default.relative(path19__default.join(paths.queueDir, PATCH_SET_DIRNAME), patchSetDir);
+  if (!relative || relative.startsWith("..") || path19__default.isAbsolute(relative)) {
     throw new Error(`[fleet-wiki] patch set id escapes queue/_sets: ${patchSetId}`);
   }
   return patchSetDir;
 }
 function getPatchSetMetaFile(paths, patchSetId) {
-  return path18__default.join(getPatchSetDir(paths, patchSetId), PATCH_SET_META_FILENAME);
+  return path19__default.join(getPatchSetDir(paths, patchSetId), PATCH_SET_META_FILENAME);
 }
 function buildPatchSetId(createdAt, sourceRef) {
   const compact = createdAt.replace(/[:.]/g, "-");
@@ -35917,12 +36934,12 @@ async function readWikiEntry(id, paths) {
   const index = await loadIndex(paths);
   const indexed = index[id];
   if (indexed) {
-    const resolved = path18__default.resolve(paths.root, indexed.path);
-    const rel = path18__default.relative(paths.wikiDir, resolved);
-    if (!rel || rel.startsWith("..") || path18__default.isAbsolute(rel)) return null;
+    const resolved = path19__default.resolve(paths.root, indexed.path);
+    const rel = path19__default.relative(paths.wikiDir, resolved);
+    if (!rel || rel.startsWith("..") || path19__default.isAbsolute(rel)) return null;
     return readMarkdownFile(resolved);
   }
-  const fallbackPath = path18__default.join(paths.wikiDir, `${id}.md`);
+  const fallbackPath = path19__default.join(paths.wikiDir, `${id}.md`);
   if (await pathExists(fallbackPath)) {
     return readMarkdownFile(fallbackPath);
   }
@@ -35933,20 +36950,20 @@ async function readWikiEntry(id, paths) {
 async function writeWikiEntryAtTarget(entry, target2, paths) {
   await ensureMemoryRoot(paths);
   assertSafeEntryId(entry.id);
-  const absoluteTarget = path18__default.resolve(paths.root, target2);
-  const relativeTarget = path18__default.relative(paths.wikiDir, absoluteTarget);
-  if (!relativeTarget || relativeTarget.startsWith("..") || path18__default.isAbsolute(relativeTarget)) {
+  const absoluteTarget = path19__default.resolve(paths.root, target2);
+  const relativeTarget = path19__default.relative(paths.wikiDir, absoluteTarget);
+  if (!relativeTarget || relativeTarget.startsWith("..") || path19__default.isAbsolute(relativeTarget)) {
     throw new Error(`[fleet-wiki] wiki target escapes wiki/: ${target2}`);
   }
   if (!absoluteTarget.endsWith(".md")) {
     throw new Error(`[fleet-wiki] wiki target must end with .md: ${target2}`);
   }
-  if (path18__default.basename(absoluteTarget, ".md") !== entry.id) {
+  if (path19__default.basename(absoluteTarget, ".md") !== entry.id) {
     throw new Error("wiki patch body id must match target filename");
   }
-  await mkdir$1(path18__default.dirname(absoluteTarget), { recursive: true });
+  await mkdir$1(path19__default.dirname(absoluteTarget), { recursive: true });
   await writeAtomic(absoluteTarget, serializeWikiEntry(entry), paths);
-  return path18__default.join("wiki", relativeTarget).replaceAll(path18__default.sep, "/");
+  return path19__default.join("wiki", relativeTarget).replaceAll(path19__default.sep, "/");
 }
 async function writeRawSourceEntry(entry, paths) {
   await ensureMemoryRoot(paths);
@@ -35965,11 +36982,11 @@ async function writeRawSourceEntry(entry, paths) {
     },
     entry.content
   );
-  await writeAtomic(path18__default.join(paths.root, relativePath), content, paths);
+  await writeAtomic(path19__default.join(paths.root, relativePath), content, paths);
   return relativePath;
 }
 async function readRawSourceEntry(rawSourceRef, paths) {
-  const absolutePath = path18__default.resolve(paths.root, rawSourceRef);
+  const absolutePath = path19__default.resolve(paths.root, rawSourceRef);
   assertWithinRawDir(absolutePath, paths);
   const parsed = parseMarkdown(await readFile(absolutePath, "utf8"));
   return {
@@ -36160,8 +37177,8 @@ function computeContentHash(content) {
   return crypto5.createHash("sha256").update(content, "utf8").digest("hex").slice(0, 8);
 }
 function assertWithinRawDir(absolutePath, paths) {
-  const relative = path18__default.relative(paths.rawDir, absolutePath);
-  if (!relative || relative.startsWith("..") || path18__default.isAbsolute(relative)) {
+  const relative = path19__default.relative(paths.rawDir, absolutePath);
+  if (!relative || relative.startsWith("..") || path19__default.isAbsolute(relative)) {
     throw new Error(`[fleet-wiki] raw source ref escapes raw/: ${absolutePath}`);
   }
 }
@@ -36217,7 +37234,7 @@ function parseWikiEntry(content) {
 async function listWikiRecords(paths) {
   return listMarkdownEntriesRecursive(paths.wikiDir, paths, (content, filePath) => ({
     entry: parseWikiEntry(content),
-    path: path18__default.relative(paths.root, filePath).replaceAll(path18__default.sep, "/")
+    path: path19__default.relative(paths.root, filePath).replaceAll(path19__default.sep, "/")
   }));
 }
 async function listMarkdownEntriesRecursive(dirPath, paths, parser) {
@@ -36230,7 +37247,7 @@ async function listMarkdownEntriesRecursive(dirPath, paths, parser) {
   }
   const sortedEntries = entries.sort((left, right) => left.name.localeCompare(right.name));
   for (const entry of sortedEntries) {
-    const filePath = path18__default.join(dirPath, entry.name);
+    const filePath = path19__default.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       items.push(...await listMarkdownEntriesRecursive(filePath, paths, parser));
       continue;
@@ -36365,8 +37382,8 @@ async function writeJsonAtomic(filePath, value, paths) {
 }
 async function writeAtomic(filePath, content, paths) {
   await ensureMemoryRoot(paths);
-  const tempPath = path18__default.join(
-    path18__default.dirname(filePath),
+  const tempPath = path19__default.join(
+    path19__default.dirname(filePath),
     `.tmp-${process.pid}-${Date.now()}-${crypto5.randomUUID()}-${os3__default.hostname()}`
   );
   await writeFile(tempPath, content, "utf8");
@@ -36447,7 +37464,7 @@ function extractLegacyMarkdownWikiLinks(body, wikiDir, basePath) {
 }
 function resolveLegacyWikiTarget(target2, wikiDir, basePath) {
   if (!target2 || target2.startsWith("#")) return null;
-  if (path18__default.isAbsolute(target2)) return null;
+  if (path19__default.isAbsolute(target2)) return null;
   if (/^[a-z][a-z0-9+.-]*:/i.test(target2)) return null;
   const withoutFragment = target2.split("#", 1)[0]?.split("?", 1)[0] ?? "";
   if (!withoutFragment.endsWith(".md")) return null;
@@ -36457,12 +37474,12 @@ function resolveLegacyWikiTarget(target2, wikiDir, basePath) {
   } catch {
     return null;
   }
-  const resolved = path18__default.resolve(path18__default.dirname(basePath), decodedTarget);
-  const relative = path18__default.relative(wikiDir, resolved);
-  if (!relative || relative.startsWith("..") || path18__default.isAbsolute(relative)) return null;
+  const resolved = path19__default.resolve(path19__default.dirname(basePath), decodedTarget);
+  const relative = path19__default.relative(wikiDir, resolved);
+  if (!relative || relative.startsWith("..") || path19__default.isAbsolute(relative)) return null;
   return {
     target: target2,
-    entryId: path18__default.basename(relative, ".md")
+    entryId: path19__default.basename(relative, ".md")
   };
 }
 var FLEET_WIKI_ENTRY_BEGIN = "<<<FLEET_WIKI_ENTRY_BEGIN";
@@ -36529,7 +37546,7 @@ async function enhancedSearch(paths, options) {
   for (const entry of entries) {
     if (!index[entry.id]) {
       index[entry.id] = {
-        path: path18__default.join("wiki", `${entry.id}.md`),
+        path: path19__default.join("wiki", `${entry.id}.md`),
         title: entry.title,
         tags: entry.tags,
         updated: entry.updated
@@ -36665,7 +37682,7 @@ function toEnhancedHit(entry, signals) {
     score: enhancedScore,
     reason: signals.legacyReason ?? "body",
     excerpt,
-    path: path18__default.join("wiki", `${entry.id}.md`),
+    path: path19__default.join("wiki", `${entry.id}.md`),
     tags: entry.tags,
     updated: entry.updated,
     version: entry.version,
@@ -36861,7 +37878,7 @@ function toRankedHit(entry, reason, detail, graphBoost, backlinksById) {
     score: basePriority * 100 + statusPriority * 10 + graphScore + (detail.tagBoost ?? 0),
     reason,
     excerpt,
-    path: path18__default.join("wiki", `${entry.id}.md`),
+    path: path19__default.join("wiki", `${entry.id}.md`),
     tags: entry.tags,
     updated: entry.updated,
     version: entry.version,
@@ -41627,13 +42644,13 @@ async function readClaims(entryId, paths) {
   }
 }
 function getClaimsDir(paths) {
-  return path18__default.join(paths.wikiDir, CLAIMS_DIRNAME);
+  return path19__default.join(paths.wikiDir, CLAIMS_DIRNAME);
 }
 function getClaimsFile(paths, entryId) {
   assertSafeEntryId(entryId);
-  const claimsFile = path18__default.join(getClaimsDir(paths), `${entryId}.json`);
-  const relative = path18__default.relative(getClaimsDir(paths), claimsFile);
-  if (!relative || relative.startsWith("..") || path18__default.isAbsolute(relative)) {
+  const claimsFile = path19__default.join(getClaimsDir(paths), `${entryId}.json`);
+  const relative = path19__default.relative(getClaimsDir(paths), claimsFile);
+  if (!relative || relative.startsWith("..") || path19__default.isAbsolute(relative)) {
     throw new Error(`[fleet-wiki] claims sidecar escapes wiki/.claims: ${entryId}`);
   }
   return claimsFile;
@@ -41724,7 +42741,7 @@ function assertSafeClaimRawRef(ref) {
   if (!ref.startsWith("raw/")) {
     throw new Error(`claim sourceRef must point into raw/: ${ref}`);
   }
-  if (ref.includes("..") || path18__default.isAbsolute(ref)) {
+  if (ref.includes("..") || path19__default.isAbsolute(ref)) {
     throw new Error(`claim sourceRef escapes raw/: ${ref}`);
   }
 }
@@ -41802,22 +42819,22 @@ async function runDryDock(paths, options = {}) {
   }
   for (const fileName of await listFileNames(paths.rawDir)) {
     if (!fileName.endsWith(".md")) continue;
-    const filePath = path18__default.join(paths.rawDir, fileName);
+    const filePath = path19__default.join(paths.rawDir, fileName);
     issues.push(...safetyIssues(await readPatchFile(filePath), filePath));
   }
   for (const queueId of await listDirectoryNames(paths.queueDir)) {
     if (queueId === PATCH_SET_DIRNAME) continue;
-    const queueDir = path18__default.join(paths.queueDir, queueId);
+    const queueDir = path19__default.join(paths.queueDir, queueId);
     try {
-      const patchContent = await readPatchFile(path18__default.join(queueDir, PATCH_FILENAME));
-      issues.push(...safetyIssues(patchContent, path18__default.join(queueDir, PATCH_FILENAME)));
-      await readJsonFile2(path18__default.join(queueDir, PATCH_META_FILENAME));
+      const patchContent = await readPatchFile(path19__default.join(queueDir, PATCH_FILENAME));
+      issues.push(...safetyIssues(patchContent, path19__default.join(queueDir, PATCH_FILENAME)));
+      await readJsonFile2(path19__default.join(queueDir, PATCH_META_FILENAME));
     } catch {
       issues.push(issue2("malformed_queue", "error", "\uC190\uC0C1\uB41C queue \uC5D4\uD2B8\uB9AC", queueDir));
     }
   }
-  for (const patchSetId of await listDirectoryNames(path18__default.join(paths.queueDir, PATCH_SET_DIRNAME))) {
-    const patchSetMetaFile = path18__default.join(paths.queueDir, PATCH_SET_DIRNAME, patchSetId, PATCH_META_FILENAME);
+  for (const patchSetId of await listDirectoryNames(path19__default.join(paths.queueDir, PATCH_SET_DIRNAME))) {
+    const patchSetMetaFile = path19__default.join(paths.queueDir, PATCH_SET_DIRNAME, patchSetId, PATCH_META_FILENAME);
     let patchSet;
     try {
       patchSet = await readPatchSet(paths, patchSetId);
@@ -41826,8 +42843,8 @@ async function runDryDock(paths, options = {}) {
       continue;
     }
     for (const patchId of patchSet.patchIds) {
-      const queueMetaFile = path18__default.join(paths.queueDir, patchId, PATCH_META_FILENAME);
-      const archiveMetaFile = path18__default.join(paths.archiveDir, patchId, PATCH_META_FILENAME);
+      const queueMetaFile = path19__default.join(paths.queueDir, patchId, PATCH_META_FILENAME);
+      const archiveMetaFile = path19__default.join(paths.archiveDir, patchId, PATCH_META_FILENAME);
       if (!await pathExists(queueMetaFile) && !await pathExists(archiveMetaFile)) {
         issues.push(
           issue2(
@@ -41864,7 +42881,7 @@ async function runDryDock(paths, options = {}) {
         "conflict_unresolved",
         "warning",
         `\uBBF8\uD574\uACB0 conflict: ${conflict.reason} (${conflict.target})`,
-        path18__default.join(paths.conflictsDir, conflict.id, "meta.json")
+        path19__default.join(paths.conflictsDir, conflict.id, "meta.json")
       )
     );
   }
@@ -41877,7 +42894,7 @@ async function runDryDock(paths, options = {}) {
           "unresolved_conflict",
           "warning",
           "\uC190\uC0C1\uB41C conflict \uC5D4\uD2B8\uB9AC",
-          path18__default.join(paths.conflictsDir, conflictId, "meta.json")
+          path19__default.join(paths.conflictsDir, conflictId, "meta.json")
         )
       );
     }
@@ -41934,8 +42951,8 @@ async function claimIssues(paths, wikiIds) {
   const claimsDir = getClaimsDir(paths);
   for (const fileName of await listFileNames(claimsDir)) {
     if (!fileName.endsWith(".json")) continue;
-    const filePath = path18__default.join(claimsDir, fileName);
-    const entryIdFromFile = path18__default.basename(fileName, ".json");
+    const filePath = path19__default.join(claimsDir, fileName);
+    const entryIdFromFile = path19__default.basename(fileName, ".json");
     let raw;
     try {
       raw = await readJsonFile2(filePath);
@@ -42014,7 +43031,7 @@ function toSemanticEntry(filePath, frontmatter, body) {
 async function schemaIssues(paths) {
   const issues = [];
   const schema = await readWorkspaceSchemaSummary(paths);
-  const agentsPath = path18__default.join(paths.schemaDir, WORKSPACE_SCHEMA_AGENTS_FILENAME);
+  const agentsPath = path19__default.join(paths.schemaDir, WORKSPACE_SCHEMA_AGENTS_FILENAME);
   if (!await pathExists(schema.wikiSchemaPath)) {
     issues.push(issue2("schema_missing", "warning", `Workspace schema file is missing: schema/${WORKSPACE_SCHEMA_FILENAME}`, schema.wikiSchemaPath));
   } else {
@@ -42401,7 +43418,7 @@ async function listWikiMarkdownFiles(dirPath) {
   const files = [];
   const sortedEntries = entries.sort((left, right) => left.name.localeCompare(right.name));
   for (const entry of sortedEntries) {
-    const filePath = path18__default.join(dirPath, entry.name);
+    const filePath = path19__default.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listWikiMarkdownFiles(filePath));
       continue;
@@ -42625,7 +43642,7 @@ async function resolveCompileSource(input, paths, now) {
 }
 async function buildCompileProposals(input, paths, now, resolvedSource) {
   const sourceTarget = `wiki/sources/${resolvedSource.sourcePageId}.md`;
-  const sourceExists = await pathExists(path18__default.join(paths.root, sourceTarget));
+  const sourceExists = await pathExists(path19__default.join(paths.root, sourceTarget));
   const existingEntries = await listWiki(paths);
   const sourcePageTitle = resolvedSource.sourceTitle?.trim() || `Source ${resolvedSource.sourcePageId}`;
   const existingSourceEntry = existingEntries.find((entry) => entry.id === resolvedSource.sourcePageId);
@@ -42647,7 +43664,7 @@ async function buildCompileProposals(input, paths, now, resolvedSource) {
     target: sourceTarget,
     summary: truncateSummary(`Compile source page ${sourcePageTitle}`),
     entry: sourceEntry,
-    baseHash: sourceExists ? computeContentHash(await readPatchFile(path18__default.join(paths.root, sourceTarget))) : void 0,
+    baseHash: sourceExists ? computeContentHash(await readPatchFile(path19__default.join(paths.root, sourceTarget))) : void 0,
     baseVersion: existingSourceEntry?.version
   }];
   const relatedCandidates = await discoverRelatedEntryCandidates(paths, resolvedSource.sourceContent, resolvedSource.sourceTitle);
@@ -42667,7 +43684,7 @@ async function buildCompileProposals(input, paths, now, resolvedSource) {
         rawSourceRefs: mergeRawSourceRefs(existing.rawSourceRefs, existing.rawSourceRef, { ref: resolvedSource.rawSourceRef }),
         body: appendSourceCompileNote(existing.body, resolvedSource.sourcePageId, resolvedSource.rawSourceRef)
       },
-      baseHash: computeContentHash(await readPatchFile(path18__default.join(paths.wikiDir, `${existing.id}.md`))),
+      baseHash: computeContentHash(await readPatchFile(path19__default.join(paths.wikiDir, `${existing.id}.md`))),
       baseVersion: existing.version
     });
   }
@@ -42841,7 +43858,7 @@ async function planIngest(input, paths, now) {
   const target2 = `wiki/${input.id}.md`;
   const proposer = input.proposer ?? "tool:wiki_ingest";
   const currentEntry = await readWikiEntry(input.id, paths);
-  const currentMarkdown = currentEntry ? await readPatchFile(path18__default.join(paths.wikiDir, `${input.id}.md`)) : void 0;
+  const currentMarkdown = currentEntry ? await readPatchFile(path19__default.join(paths.wikiDir, `${input.id}.md`)) : void 0;
   const currentHash = currentMarkdown ? computeContentHash(currentMarkdown) : void 0;
   const rawSource = buildRawSourceEntry(input, now);
   await ensureWorkspaceSchema(paths);
@@ -43520,11 +44537,11 @@ async function editQueuedPatch(input, paths) {
   };
 }
 async function readQueuedPatchSnapshot(paths, patchId) {
-  const queueDir = path18__default.join(paths.queueDir, patchId);
-  const markdown = await readPatchFile(path18__default.join(queueDir, PATCH_FILENAME));
+  const queueDir = path19__default.join(paths.queueDir, patchId);
+  const markdown = await readPatchFile(path19__default.join(queueDir, PATCH_FILENAME));
   return {
     patch: await parsePatch(markdown),
-    meta: await readJsonFile2(path18__default.join(queueDir, PATCH_META_FILENAME)),
+    meta: await readJsonFile2(path19__default.join(queueDir, PATCH_META_FILENAME)),
     patchHash: computeContentHash(markdown)
   };
 }
@@ -44286,7 +45303,7 @@ ${input.answer ?? ""}`)}`;
   assertSafeEntryId(targetId);
   const subdir = input.targetType === "synthesis" ? "synthesis" : "queries";
   const target2 = `wiki/${subdir}/${targetId}.md`;
-  const absoluteTarget = path18__default.join(paths.root, target2);
+  const absoluteTarget = path19__default.join(paths.root, target2);
   const exists = await pathExists(absoluteTarget);
   const existingEntry = exists ? await readWikiEntry(targetId, paths) : null;
   if (exists && !existingEntry) {
@@ -44368,7 +45385,7 @@ function assertSafeRawRef(rawRef) {
   if (!rawRef.startsWith("raw/")) {
     throw new Error(`[fleet-wiki] wiki_query raw source ref must point into raw/: ${rawRef}`);
   }
-  if (rawRef.includes("..") || path18__default.isAbsolute(rawRef)) {
+  if (rawRef.includes("..") || path19__default.isAbsolute(rawRef)) {
     throw new Error(`[fleet-wiki] wiki_query raw source ref escapes raw/: ${rawRef}`);
   }
 }
@@ -44974,16 +45991,16 @@ function createResolver(deps, hooks) {
   } };
 }
 function resolveLocked(workspace, hooks) {
-  const destination = path18__default.join(workspace.path, "knowledge");
-  const source = path18__default.join(workspace.cwd, ".fleet", "knowledge");
-  const markerPath = path18__default.join(workspace.path, MARKER_NAME);
+  const destination = path19__default.join(workspace.path, "knowledge");
+  const source = path19__default.join(workspace.cwd, ".fleet", "knowledge");
+  const markerPath = path19__default.join(workspace.path, MARKER_NAME);
   const destinationState = inspectTree(destination, true);
   if (destinationState === "content") return createMemoryPaths(destination);
   if (destinationState === "unsafe") throw new Error("Unsafe Fleet Wiki destination state");
   const marker = readMarker(markerPath);
   const stagingEntries = inspectReservedControlState(workspace.path);
   if (marker) {
-    const staging2 = path18__default.join(workspace.path, `${STAGING_PREFIX}${marker.transactionId}`);
+    const staging2 = path19__default.join(workspace.path, `${STAGING_PREFIX}${marker.transactionId}`);
     const stagingState = inspectTree(staging2);
     if (stagingState === "content") {
       removeEmptyDirectories(destination);
@@ -44998,7 +46015,7 @@ function resolveLocked(workspace, hooks) {
   if (sourceState !== "content") return createMemoryPaths(destination);
   removeEmptyDirectories(destination);
   const transactionId = randomUUID$1();
-  const staging = path18__default.join(workspace.path, `${STAGING_PREFIX}${transactionId}`);
+  const staging = path19__default.join(workspace.path, `${STAGING_PREFIX}${transactionId}`);
   copyTree(source, staging, hooks);
   if (inspectTree(staging) !== "content") throw new Error("Invalid Fleet Wiki migration staging result");
   syncDirectory(staging);
@@ -45026,7 +46043,7 @@ function inspectTree(target2, regularRootIsContent = false, treeRoot = target2)
   if (nodeKind === "file") return regularRootIsContent ? "content" : "unsafe";
   let content = false;
   for (const entry of fs9.readdirSync(target2, { withFileTypes: true })) {
-    const entryPath = path18__default.join(target2, entry.name);
+    const entryPath = path19__default.join(target2, entry.name);
     if (entry.isSymbolicLink()) {
       if (readSafeFileSymlink(treeRoot, entryPath) === null) return "unsafe";
       content = true;
@@ -45065,8 +46082,8 @@ function readMarker(markerPath) {
 function copyTree(source, destination, hooks, sourceRoot = source) {
   fs9.mkdirSync(destination, { recursive: true });
   for (const entry of fs9.readdirSync(source, { withFileTypes: true })) {
-    const from = path18__default.join(source, entry.name);
-    const to = path18__default.join(destination, entry.name);
+    const from = path19__default.join(source, entry.name);
+    const to = path19__default.join(destination, entry.name);
     const stat4 = fs9.lstatSync(from);
     if (stat4.isSymbolicLink()) {
       const target2 = readSafeFileSymlink(sourceRoot, from);
@@ -45086,9 +46103,9 @@ function copyTree(source, destination, hooks, sourceRoot = source) {
 }
 function readSafeFileSymlink(treeRoot, linkPath) {
   const target2 = fs9.readlinkSync(linkPath);
-  if (path18__default.posix.isAbsolute(target2) || path18__default.win32.isAbsolute(target2)) return null;
-  const lexicalRoot = path18__default.resolve(treeRoot);
-  const lexicalTarget = path18__default.resolve(path18__default.dirname(linkPath), target2);
+  if (path19__default.posix.isAbsolute(target2) || path19__default.win32.isAbsolute(target2)) return null;
+  const lexicalRoot = path19__default.resolve(treeRoot);
+  const lexicalTarget = path19__default.resolve(path19__default.dirname(linkPath), target2);
   if (!isWithinRoot(lexicalRoot, lexicalTarget)) return null;
   let canonicalRoot;
   let canonicalTarget;
@@ -45105,8 +46122,8 @@ function readSafeFileSymlink(treeRoot, linkPath) {
   return target2;
 }
 function isWithinRoot(root, target2) {
-  const relative = path18__default.relative(root, target2);
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${path18__default.sep}`) && !path18__default.isAbsolute(relative);
+  const relative = path19__default.relative(root, target2);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path19__default.sep}`) && !path19__default.isAbsolute(relative);
 }
 function classifyWikiWorkspaceNodeForTest(stat4) {
   if (stat4.isSymbolicLink()) return "unsafe";
@@ -45121,13 +46138,13 @@ function removeEmptyDirectories(target2) {
   if (state === "empty") fs9.rmSync(target2, { recursive: true, force: false });
 }
 function removePriorStaging(workspacePath, stagingEntries) {
-  for (const name of stagingEntries) fs9.rmSync(path18__default.join(workspacePath, name), { recursive: true, force: false });
+  for (const name of stagingEntries) fs9.rmSync(path19__default.join(workspacePath, name), { recursive: true, force: false });
 }
 function inspectReservedControlState(workspacePath) {
   const stagingEntries = [];
   for (const entry of fs9.readdirSync(workspacePath, { withFileTypes: true })) {
     if (entry.name.startsWith(`${MARKER_NAME}.`)) {
-      const residuePath = path18__default.join(workspacePath, entry.name);
+      const residuePath = path19__default.join(workspacePath, entry.name);
       const residue = fs9.lstatSync(residuePath);
       if (MARKER_TEMP_REGEXP.test(entry.name) && residue.isFile() && !residue.isSymbolicLink()) {
         fs9.unlinkSync(residuePath);
@@ -45137,7 +46154,7 @@ function inspectReservedControlState(workspacePath) {
     }
     if (!entry.name.startsWith(STAGING_PREFIX)) continue;
     if (!/^[0-9a-f-]{36}$/i.test(entry.name.slice(STAGING_PREFIX.length)) || entry.isSymbolicLink() || !entry.isDirectory()) throw new Error("Unsafe Fleet Wiki migration staging state");
-    if (inspectTree(path18__default.join(workspacePath, entry.name)) === "unsafe") throw new Error("Unsafe Fleet Wiki migration staging state");
+    if (inspectTree(path19__default.join(workspacePath, entry.name)) === "unsafe") throw new Error("Unsafe Fleet Wiki migration staging state");
     stagingEntries.push(entry.name);
   }
   return stagingEntries;
@@ -45225,18 +46242,18 @@ function resolveConsolePackageRequire(currentFile, fallback) {
 function findConsolePackageRequire(currentFile) {
   const explicitRoot = process.env.FLEET_CONSOLE_PACKAGE_ROOT;
   if (explicitRoot) {
-    const explicitPackageJson = path18__default.join(explicitRoot, "package.json");
+    const explicitPackageJson = path19__default.join(explicitRoot, "package.json");
     if (isFleetConsolePackage(explicitPackageJson)) return createRequire(explicitPackageJson);
   }
-  let dir = path18__default.dirname(currentFile);
+  let dir = path19__default.dirname(currentFile);
   while (true) {
-    const packageJson = path18__default.join(dir, "package.json");
+    const packageJson = path19__default.join(dir, "package.json");
     if (isFleetConsolePackage(packageJson)) return createRequire(packageJson);
-    const nestedConsolePackage = path18__default.join(dir, "runtime", "fleet-console", "package.json");
+    const nestedConsolePackage = path19__default.join(dir, "runtime", "fleet-console", "package.json");
     if (isFleetConsolePackage(nestedConsolePackage)) return createRequire(nestedConsolePackage);
-    const siblingConsolePackage = path18__default.join(dir, "..", "..", "fleet-console", "package.json");
+    const siblingConsolePackage = path19__default.join(dir, "..", "..", "fleet-console", "package.json");
     if (isFleetConsolePackage(siblingConsolePackage)) return createRequire(siblingConsolePackage);
-    const parent = path18__default.dirname(dir);
+    const parent = path19__default.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -45308,7 +46325,7 @@ function resolveUseConptyDll(platform, env) {
 }
 function loadNodePty() {
   const nodePtyRequire = loadNodePtyRequire(fileURLToPath(import.meta.url));
-  ensureNodePtySpawnHelpersExecutable(path18__default.dirname(nodePtyRequire.resolve("node-pty/package.json")));
+  ensureNodePtySpawnHelpersExecutable(path19__default.dirname(nodePtyRequire.resolve("node-pty/package.json")));
   return nodePtyRequire("node-pty");
 }
 function loadNodePtyRequire(currentFile) {
@@ -45317,7 +46334,7 @@ function loadNodePtyRequire(currentFile) {
 function ensureNodePtySpawnHelpersExecutable(packageRoot, platform = process4.platform, architecture = process4.arch) {
   if (platform !== "darwin") return;
   for (const directory of ["build/Release", "build/Debug", `prebuilds/darwin-${architecture}`]) {
-    const helper = path18__default.join(packageRoot, directory, "spawn-helper");
+    const helper = path19__default.join(packageRoot, directory, "spawn-helper");
     try {
       const stat4 = lstatSync(helper);
       if (!stat4.isFile() || stat4.isSymbolicLink() || (stat4.mode & 73) === 73) continue;
@@ -46050,7 +47067,7 @@ function serializeAgentCliPathsWrite(write) {
   return result;
 }
 function normalizeAgentCliPaths(value) {
-  if (!isRecord12(value) || value.version !== 1 || !isRecord12(value.paths)) {
+  if (!isRecord14(value) || value.version !== 1 || !isRecord14(value.paths)) {
     return { version: 1, paths: {} };
   }
   const paths = {};
@@ -46065,7 +47082,7 @@ function resolveAgentCliBinary(options) {
   const envName = OVERRIDE_ENV_BY_COMMAND[options.cliCommand];
   const envOverride = envName ? options.env[envName]?.trim() : void 0;
   if (envOverride) {
-    const searchedPathEntries2 = path18__default.isAbsolute(envOverride) ? [] : readPathEntries(options.env, platform);
+    const searchedPathEntries2 = path19__default.isAbsolute(envOverride) ? [] : readPathEntries(options.env, platform);
     const resolved2 = resolveBinarySafely(envOverride, options.env, platform);
     if (!resolved2) {
       return { resolved: void 0, source: "env", error: "path_not_found", launchPath: envOverride, searchedPathEntries: searchedPathEntries2 };
@@ -46107,7 +47124,7 @@ function applyAgentCliPathEnvOverlay(env, cliId, userPaths) {
   return { ...env, [envName]: userPath };
 }
 function resolveConfiguredPath(executablePath, env, platform) {
-  if (executablePath.includes("\0") || executablePath.startsWith("~") || !path18__default.isAbsolute(executablePath)) {
+  if (executablePath.includes("\0") || executablePath.startsWith("~") || !path19__default.isAbsolute(executablePath)) {
     return { resolved: void 0, error: "path_not_absolute" };
   }
   let stats;
@@ -46148,10 +47165,10 @@ function validateResolvedFile(resolved, platform) {
 }
 function readPathEntries(env, platform) {
   const value = platform === "win32" ? env.Path ?? env.PATH ?? "" : env.PATH ?? "";
-  const separator = platform === "win32" ? ";" : path18__default.delimiter;
+  const separator = platform === "win32" ? ";" : path19__default.delimiter;
   return value.split(separator).filter((entry) => entry.length > 0);
 }
-function isRecord12(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isNodeError(error51) {
@@ -46435,19 +47452,6 @@ function looksSecretToken(rawToken) {
   return token.length >= SECRET_MIN_TOKEN_LENGTH && SECRET_CHARSET_PATTERN.test(token) && /[0-9]/.test(token) && /[A-Za-z]/.test(token);
 }
 
-// ../fleet-plugins/terminal/server/agent-api/attention-hook.ts
-var ATTENTION_REASONS = /* @__PURE__ */ new Set([
-  "idle_prompt",
-  "permission_prompt",
-  "auth_success",
-  "elicitation_dialog",
-  "elicitation_complete",
-  "elicitation_response"
-]);
-function normalizeAttentionReason(value) {
-  return typeof value === "string" && ATTENTION_REASONS.has(value) ? value : void 0;
-}
-
 // ../fleet-plugins/terminal/server/agent-api/background-report.ts
 var AGENT_BACKGROUND_TASK_TYPES = /* @__PURE__ */ new Set(["subagent", "teammate", "workflow"]);
 var NON_AGENT_BACKGROUND_TASK_TYPES = /* @__PURE__ */ new Set(["shell", "monitor"]);
@@ -46728,7 +47732,7 @@ function claudeGatewayModelCache(options) {
 
 // ../../packages/core-agent/src/claude/config-dir.ts
 function createSharedClaudeConfigHome(configDir) {
-  if (typeof configDir !== "string" || !path18__default.isAbsolute(configDir)) {
+  if (typeof configDir !== "string" || !path19__default.isAbsolute(configDir)) {
     throw new TypeError("A shared Claude config home requires an absolute config directory path.");
   }
   return {
@@ -46740,9 +47744,9 @@ function createSharedClaudeConfigHome(configDir) {
   };
 }
 async function createIsolatedClaudeConfigDir(tempRoot = tmpdir()) {
-  const root = await mkdtemp(path18__default.join(tempRoot, "core-agent-claude-"));
-  const cachePath = path18__default.join(root, CLAUDE_GATEWAY_MODEL_CACHE_RELPATH);
-  await mkdir$1(path18__default.dirname(cachePath), { recursive: true, mode: 448 });
+  const root = await mkdtemp(path19__default.join(tempRoot, "core-agent-claude-"));
+  const cachePath = path19__default.join(root, CLAUDE_GATEWAY_MODEL_CACHE_RELPATH);
+  await mkdir$1(path19__default.dirname(cachePath), { recursive: true, mode: 448 });
   let disposed = false;
   return {
     path: root,
@@ -47219,7 +48223,7 @@ function createClaudeExecutionEventDecoder() {
   const toolNames = /* @__PURE__ */ new Map();
   return {
     decode(message) {
-      if (!isRecord13(message)) return [];
+      if (!isRecord15(message)) return [];
       if (message.type === "stream_event") return decodeStreamEvent(message);
       if (message.type === "assistant") return decodeAssistant(message, toolNames);
       if (message.type === "user") return decodeUser(message, toolNames);
@@ -47284,9 +48288,9 @@ function blocks(message) {
   return Array.isArray(content) ? content.map(record5) : [];
 }
 function record5(value) {
-  return isRecord13(value) ? value : {};
+  return isRecord15(value) ? value : {};
 }
-function isRecord13(value) {
+function isRecord15(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
@@ -47630,7 +48634,7 @@ function buildConsoleAutoNameHookCommand(entry) {
   return buildConsoleCliHookExec(entry, ["hook", "auto-name"]);
 }
 function buildConsoleCaptureHookCommand(entry, cliId, createCaptureHook = createSessionCaptureHookExec) {
-  const extension = path18__default.extname(entry.entryPath);
+  const extension = path19__default.extname(entry.entryPath);
   if (JAVASCRIPT_ENTRY_EXTENSIONS.has(extension)) {
     return createCaptureHook({
       entryPath: entry.entryPath,
@@ -47656,11 +48660,11 @@ function toCaptureProvider(cliId) {
 }
 function withConsoleMarketplaceLock(target2, fn) {
   const lockDir = `${target2}${MARKETPLACE_LOCK_DIR_SUFFIX}`;
-  mkdirSync(path18__default.dirname(lockDir), { recursive: true });
+  mkdirSync(path19__default.dirname(lockDir), { recursive: true });
   return withDirectoryLock({ lockDir }, fn);
 }
 function buildConsoleCliHookExec(entry, trailingArgs) {
-  const extension = path18__default.extname(entry.entryPath);
+  const extension = path19__default.extname(entry.entryPath);
   if (JAVASCRIPT_ENTRY_EXTENSIONS.has(extension)) {
     return {
       command: entry.execPath,
@@ -47801,7 +48805,7 @@ function resolveHookEntryPath(candidate) {
   return CONSOLE_ENTRY_PATH;
 }
 function hasHookEntryExtension(entryPath) {
-  return HOOK_ENTRY_EXTENSIONS.has(path18__default.extname(entryPath));
+  return HOOK_ENTRY_EXTENSIONS.has(path19__default.extname(entryPath));
 }
 async function createAgentCliLaunchSpec(options) {
   const cleanupStack = [];
@@ -48076,8 +49080,8 @@ function createLaunchAttachmentStore(options) {
         );
       }
       mkdirSync(namespaceRoot, { recursive: true });
-      const dir = mkdtempSync(path18__default.join(namespaceRoot, "attachment-"));
-      const filePath = path18__default.join(dir, `image.${sniffed.ext}`);
+      const dir = mkdtempSync(path19__default.join(namespaceRoot, "attachment-"));
+      const filePath = path19__default.join(dir, `image.${sniffed.ext}`);
       try {
         writeFileSync(filePath, bytes, { flag: "wx", mode: LAUNCH_ATTACHMENT_FILE_MODE });
         chmodBestEffort3(filePath, LAUNCH_ATTACHMENT_FILE_MODE);
@@ -48155,8 +49159,8 @@ function createLaunchAttachmentStore(options) {
   };
 }
 function resolveLaunchAttachmentNamespaceRoot(dataDir) {
-  const hash2 = crypto5.createHash("sha256").update(path18__default.resolve(dataDir)).digest("hex").slice(0, 12);
-  return path18__default.join(path18__default.resolve(os3__default.tmpdir()), `${LAUNCH_ATTACHMENT_NAMESPACE_PREFIX}${hash2}`);
+  const hash2 = crypto5.createHash("sha256").update(path19__default.resolve(dataDir)).digest("hex").slice(0, 12);
+  return path19__default.join(path19__default.resolve(os3__default.tmpdir()), `${LAUNCH_ATTACHMENT_NAMESPACE_PREFIX}${hash2}`);
 }
 function chmodBestEffort3(targetPath, mode) {
   try {
@@ -48250,7 +49254,7 @@ function createConsoleObservabilityStore(deps = {}) {
     return terminalSessionsById.get(sessionId)?.cwd ?? workspacesByCliRunId.get(sessionId)?.session.cwd ?? null;
   }
   function createPendingTerminalSession(input) {
-    if (!path18__default.isAbsolute(input.cwd)) throw new Error("Terminal session cwd must be absolute");
+    if (!path19__default.isAbsolute(input.cwd)) throw new Error("Terminal session cwd must be absolute");
     const createdAt = input.createdAt ?? now();
     const canonicalCwd = canonicalizeTheaterPath(input.cwd);
     const theaterId = workspaceHash(canonicalCwd);
@@ -48260,7 +49264,7 @@ function createConsoleObservabilityStore(deps = {}) {
       sessionId: input.sessionId,
       cwd: input.cwd,
       canonicalCwd,
-      cwdLabel: path18__default.basename(input.cwd) || input.cwd,
+      cwdLabel: path19__default.basename(input.cwd) || input.cwd,
       cliId: input.cliId,
       createdAt,
       theaterId,
@@ -48277,7 +49281,7 @@ function createConsoleObservabilityStore(deps = {}) {
       sessionId: operation.sessionId,
       cwd: operation.cwd,
       canonicalCwd: canonicalizeTheaterPath(operation.cwd),
-      cwdLabel: path18__default.basename(operation.cwd) || operation.cwd,
+      cwdLabel: path19__default.basename(operation.cwd) || operation.cwd,
       label: operation.label,
       labelSource: operation.labelSource,
       providerTitle: operation.providerTitle,
@@ -48583,7 +49587,7 @@ function defaultWorkspaceHash(canonicalCwd) {
   return crypto5.createHash("sha256").update(canonicalCwd).digest("hex").slice(0, 12);
 }
 function defaultCanonicalizeTheaterPath(cwd) {
-  const resolved = path18__default.resolve(cwd);
+  const resolved = path19__default.resolve(cwd);
   try {
     return fs9__default.realpathSync.native(resolved);
   } catch {
@@ -49446,7 +50450,7 @@ var AgentChatSession = class {
     this.operationId = operationId;
     this.seed = seed;
     this.createSdk = createSdk;
-    this.latestSessionId = seed.origin.kind === "resume" ? path18__default.basename(seed.origin.transcriptPath, ".jsonl") : null;
+    this.latestSessionId = seed.origin.kind === "resume" ? path19__default.basename(seed.origin.transcriptPath, ".jsonl") : null;
   }
   get busy() {
     return this.pendingTurns > 0;
@@ -49728,7 +50732,7 @@ var AgentChatSession = class {
     const id = message.task_id;
     const file2 = message.output_file;
     if (typeof id !== "string" || id.length === 0) return;
-    if (typeof file2 !== "string" || !path18__default.isAbsolute(file2)) return;
+    if (typeof file2 !== "string" || !path19__default.isAbsolute(file2)) return;
     this.jobOutputs.set(id, file2);
     if (this.jobOutputs.size > JOB_KIND_CAP) {
       const oldest = this.jobOutputs.keys().next();
@@ -49761,7 +50765,7 @@ var AgentChatSession = class {
     }
     const dir = await this.resolveJobSessionDir();
     if (dir === null) return null;
-    const window = await readFileTail(path18__default.join(dir, "subagents", `agent-${jobId}.jsonl`), JOB_TRANSCRIPT_READ_BYTES);
+    const window = await readFileTail(path19__default.join(dir, "subagents", `agent-${jobId}.jsonl`), JOB_TRANSCRIPT_READ_BYTES);
     if (window === null) return null;
     const trail = chatSubagentTrailFromTranscript(window.text, { cwd: this.seed.cwd });
     return { kind: "agent", steps: trail.steps, truncated: trail.truncated || window.headCut };
@@ -49783,7 +50787,7 @@ var AgentChatSession = class {
     if (!sessionId) return null;
     const transcriptPath = await this.locateTranscript(sessionId);
     if (!transcriptPath) return null;
-    return path18__default.join(path18__default.dirname(transcriptPath), sessionId);
+    return path19__default.join(path19__default.dirname(transcriptPath), sessionId);
   }
   /**
    * 자식이 도구를 쓰기 전에 부르는 자리. 대화형 도구 둘만 여기서 멈춰 사용자를 기다리고,
@@ -49918,7 +50922,7 @@ var AgentChatSession = class {
     if (message.type !== "stream_event") return;
     if (typeof message.parent_tool_use_id === "string" && message.parent_tool_use_id.length > 0) return;
     const event = message.event;
-    if (!isRecord14(event) || event.type !== "message_delta") return;
+    if (!isRecord16(event) || event.type !== "message_delta") return;
     const total = readClaudeOccupiedInputTokens(event.usage);
     if (total === null) return;
     const claudeCoordinate = this.claudeCoordinate();
@@ -50360,15 +51364,15 @@ var AgentChatSession = class {
    */
   async locateTranscript(sessionId) {
     if (this.seed.origin.kind === "resume") {
-      const sibling = path18__default.join(path18__default.dirname(this.seed.origin.transcriptPath), `${sessionId}.jsonl`);
+      const sibling = path19__default.join(path19__default.dirname(this.seed.origin.transcriptPath), `${sessionId}.jsonl`);
       if (await isExistingFile(sibling)) return sibling;
     }
-    const projectsRoot = path18__default.join(this.seed.claudeConfigDir, "projects");
+    const projectsRoot = path19__default.join(this.seed.claudeConfigDir, "projects");
     const entries = await promises.readdir(projectsRoot, { withFileTypes: true }).catch(() => null);
     if (!entries) return null;
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const candidate = path18__default.join(projectsRoot, entry.name, `${sessionId}.jsonl`);
+      const candidate = path19__default.join(projectsRoot, entry.name, `${sessionId}.jsonl`);
       if (await isExistingFile(candidate)) return candidate;
     }
     return null;
@@ -50437,11 +51441,11 @@ var AgentChatRegistry = class {
     await Promise.all([...operationIds].map((operationId) => this.dispose(operationId)));
   }
 };
-function isRecord14(value) {
+function isRecord16(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readClaudeOccupiedInputTokens(usage4) {
-  if (!isRecord14(usage4)) return null;
+  if (!isRecord16(usage4)) return null;
   let total = 0;
   let found = false;
   for (const field of ["input_tokens", "cache_read_input_tokens", "cache_creation_input_tokens"]) {
@@ -50625,7 +51629,7 @@ function analysisError(code, message) {
   return { error: { code, message } };
 }
 function isAnalysisSelection(catalog, value) {
-  if (!isRecord15(value) || !hasExactKeys(value, ["cliId", "model", "effort", "language"]) || typeof value.cliId !== "string" || typeof value.model !== "string" || value.effort !== void 0 && typeof value.effort !== "string" || value.language !== void 0 && value.language !== "en" && value.language !== "ko") return false;
+  if (!isRecord17(value) || !hasExactKeys(value, ["cliId", "model", "effort", "language"]) || typeof value.cliId !== "string" || typeof value.model !== "string" || value.effort !== void 0 && typeof value.effort !== "string" || value.language !== void 0 && value.language !== "en" && value.language !== "ko") return false;
   const cli = catalog.clis.find((candidate) => candidate.cliId === value.cliId);
   if (!cli?.available) return false;
   const model = cli.models.find((candidate) => candidate.id === value.model);
@@ -50634,9 +51638,9 @@ function isAnalysisSelection(catalog, value) {
   return typeof value.effort === "string" && value.effort.length > 0 && model.effortLevels.includes(value.effort);
 }
 function isMessageBody(value) {
-  return isRecord15(value) && hasExactKeys(value, ["text"]) && typeof value.text === "string" && value.text.trim().length > 0;
+  return isRecord17(value) && hasExactKeys(value, ["text"]) && typeof value.text === "string" && value.text.trim().length > 0;
 }
-function isRecord15(value) {
+function isRecord17(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasExactKeys(value, keys) {
@@ -50644,14 +51648,14 @@ function hasExactKeys(value, keys) {
 }
 async function resolveTranscriptPath(capturePath, operationCreatedAt) {
   if (await transcriptFileExists(capturePath)) return capturePath;
-  const dir = path18__default.dirname(capturePath);
+  const dir = path19__default.dirname(capturePath);
   const bornCutoff = operationCreatedAt - 6e4;
   try {
     const entries = await promises.readdir(dir);
     const candidates = [];
     for (const entry of entries) {
       if (!entry.endsWith(".jsonl")) continue;
-      const candidate = path18__default.join(dir, entry);
+      const candidate = path19__default.join(dir, entry);
       const stat4 = await promises.stat(candidate).catch(() => null);
       if (!stat4?.isFile()) continue;
       if (stat4.birthtimeMs > 0 && stat4.birthtimeMs < bornCutoff) continue;
@@ -50668,6 +51672,19 @@ async function transcriptFileExists(filePath) {
   return stat4?.isFile() ?? false;
 }
 
+// ../fleet-plugins/terminal/server/agent-api/types.ts
+var AGENT_ATTENTION_REASONS = [
+  "idle_prompt",
+  "permission_prompt",
+  "auth_success",
+  "elicitation_dialog",
+  "elicitation_complete",
+  "elicitation_response"
+];
+function normalizeAttentionReason(value) {
+  return typeof value === "string" && AGENT_ATTENTION_REASONS.includes(value) ? value : void 0;
+}
+
 // ../fleet-plugins/terminal/server/agent-idle-dormant-sweeper.ts
 var AGENT_IDLE_DORMANT_SWEEP_INTERVAL_MS = 6e4;
 function sweepIdleAgentSessions(deps) {
@@ -50713,7 +51730,7 @@ var CHAT_SUPPORTED_CLI_ID = "claude-gateway";
 var MAX_CHAT_ANSWER_MESSAGE_CHARS2 = 2e3;
 function resolveClaudeConfigDir() {
   const configured = process4.env.CLAUDE_CONFIG_DIR;
-  return configured && configured.length > 0 ? configured : path18__default.join(os3__default.homedir(), ".claude");
+  return configured && configured.length > 0 ? configured : path19__default.join(os3__default.homedir(), ".claude");
 }
 async function registerAgentRoutes(ctx, terminalRuntime, deps) {
   const api = await createAgentApi(ctx, terminalRuntime, deps);
@@ -51240,7 +52257,7 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
       theaterId,
       type: AGENT_OPERATION_TYPE,
       pluginId: ctx.pluginId,
-      title: namedSession.label ?? session.label ?? path18__default.basename(cwd),
+      title: namedSession.label ?? session.label ?? path19__default.basename(cwd),
       // 공급자는 실행 시점에 한 번 확정되고 이후 어떤 patch도 다시 쓰지 않는다 —
       // toOperationPayload가 지우는 키 목록 밖이라 resume·복원을 지나도 그대로 남는다.
       payload: {
@@ -51871,7 +52888,7 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
     if (result?.renamed) {
       observability.notifySessionUpdated(result.session);
       const autoNameCwd = readPayloadString(ctx.host.operations.get(sessionId)?.payload ?? {}, "cwd") ?? result.session.cwdLabel;
-      ctx.host.operations.patch(sessionId, { title: result.session.label ?? path18__default.basename(autoNameCwd) });
+      ctx.host.operations.patch(sessionId, { title: result.session.label ?? path19__default.basename(autoNameCwd) });
     }
     ctx.host.http.writeJson(res, 200, { ok: true, renamed: result?.renamed === true });
     return true;
@@ -52125,7 +53142,7 @@ function createTerminalWikiToolSpecs(fleetDataDir) {
   const resolver = createWikiWorkspaceResolver({
     ensureWorkspace: (cwd) => ensureWorkspaceDirectory(fleetDataDir, cwd),
     withMigrationLock: (workspace, operation) => withDirectoryLock(
-      { lockDir: path18__default.join(workspace.path, "knowledge.migration.lock") },
+      { lockDir: path19__default.join(workspace.path, "knowledge.migration.lock") },
       operation
     )
   });
@@ -53481,12 +54498,12 @@ function artifactHeaders() {
   return { "Content-Type": "text/html; charset=utf-8", "Content-Security-Policy": ANALYSIS_ARTIFACT_CSP, "Cache-Control": "no-store", "Referrer-Policy": "no-referrer", "X-Content-Type-Options": "nosniff" };
 }
 function registerAiGatewayRoutes(ctx, deps = {}) {
-  const ownedDiagnostics = deps.cursorDiagnostics ? void 0 : createCursorDiagnosticLog(path18__default.join(
+  const ownedDiagnostics = deps.cursorDiagnostics ? void 0 : createCursorDiagnosticLog(path19__default.join(
     ctx.host.paths.pluginDataDir(ctx.pluginId),
     "ai-gateway"
   ));
   const ownedFailureJournal = deps.failureJournal ? void 0 : createFailureJournal({
-    filePath: path18__default.join(
+    filePath: path19__default.join(
       ctx.host.paths.pluginDataDir(ctx.pluginId),
       "ai-gateway",
       "failures.jsonl"
@@ -53500,6 +54517,8 @@ function registerAiGatewayRoutes(ctx, deps = {}) {
     readAuth: deps.readAuth ?? (() => readCodexSubscriptionAuth()),
     readCursorToken: deps.readCursorToken ?? (() => readCursorSubscriptionToken()),
     readXaiToken: deps.readXaiToken ?? (() => readXaiSubscriptionToken()),
+    readAntigravityToken: deps.readAntigravityToken ?? (() => readAntigravitySubscriptionToken()),
+    renewAntigravityToken: deps.renewAntigravityToken ?? (() => readAntigravitySubscriptionToken({ forceRenew: true })),
     readModelOverride: () => process.env[AI_GATEWAY_MODEL_ENV],
     cursorDiagnostics: deps.cursorDiagnostics ?? ownedDiagnostics?.write
   });
@@ -53777,7 +54796,7 @@ function isRestoredShellEvent(value, pluginId) {
 var CONTROL_HOLDER_EVENT_CHANNEL = "control:holder";
 function applyWireLog(ctx, stored) {
   setWireLogTarget(stored === void 0 ? void 0 : stored ? {
-    path: path18__default.join(ctx.host.paths.pluginDataDir(ctx.pluginId), "ai-gateway", "wire-log.jsonl"),
+    path: path19__default.join(ctx.host.paths.pluginDataDir(ctx.pluginId), "ai-gateway", "wire-log.jsonl"),
     maxBytes: DEFAULT_WIRE_LOG_MAX_BYTES
   } : null);
 }