@dotobokuri/fleet-console 1.57.2 → 1.58.0

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

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-import * as path18 from 'node:path';
-import path18__default, { posix, dirname } from 'node:path';
+import * as path19 from 'node:path';
+import path19__default, { posix, dirname } from 'node:path';
 import * as fs9 from 'node:fs';
 import fs9__default, { constants, existsSync, readFileSync, mkdirSync, rmSync, renameSync, appendFileSync, mkdtempSync, writeFileSync, statSync, chmodSync, readdirSync, closeSync, fstatSync, lstatSync, accessSync, realpathSync, openSync, promises } from 'node:fs';
 import * as os3 from 'node:os';
 import os3__default, { tmpdir } from 'node:os';
 import { execFile } from 'node:child_process';
-import fs7, { appendFile, chmod, open, mkdtemp, mkdir, rm, writeFile, rename, stat, readFile, readdir, realpath, lstat, unlink } from 'node:fs/promises';
+import fs32, { appendFile, chmod, open, mkdtemp, mkdir, rm, writeFile, rename, stat, readFile, readdir, realpath, lstat, unlink } from 'node:fs/promises';
 import { promisify } from 'node:util';
 import crypto5, { randomUUID, createHash } from 'node:crypto';
 import http2 from 'node:http2';
@@ -26,33 +26,33 @@ var __export = (target2, all) => {
 function definePlugin(definition) {
   return definition;
 }
-function registerRouter(ctx, path42, handler, catalog) {
+function registerRouter(ctx, path43, handler, catalog) {
   if (catalog) {
-    ctx.registerRouter(normalizePath(path42), handler, catalog);
+    ctx.registerRouter(normalizePath(path43), handler, catalog);
     return;
   }
-  ctx.registerRouter(normalizePath(path42), handler);
+  ctx.registerRouter(normalizePath(path43), handler);
 }
-function registerWsHandler(ctx, path42, handler, catalog) {
+function registerWsHandler(ctx, path43, handler, catalog) {
   if (catalog) {
-    ctx.registerWsHandler(normalizePath(path42), handler, catalog);
+    ctx.registerWsHandler(normalizePath(path43), handler, catalog);
     return;
   }
-  ctx.registerWsHandler(normalizePath(path42), handler);
+  ctx.registerWsHandler(normalizePath(path43), handler);
 }
 function registerLaunchCatalog(ctx, provider) {
   return ctx.host.operations.registerLaunchCatalog(ctx.pluginId, provider);
 }
-function normalizePath(path42) {
-  if (path42.length === 0 || path42 === "/") return "/";
-  return path42;
+function normalizePath(path43) {
+  if (path43.length === 0 || path43 === "/") return "/";
+  return path43;
 }
 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;
@@ -85,9 +85,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}`);
   }
 }
@@ -148,7 +148,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) {
@@ -254,7 +254,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) {
@@ -263,7 +263,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) {
@@ -303,10 +303,10 @@ function isProcessAlive(pid) {
 }
 function sanitizeLockOwner(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
-  const record6 = value;
-  const pid = record6.pid;
-  const hostname5 = record6.hostname;
-  const startedAt = record6.startedAt;
+  const record7 = value;
+  const pid = record7.pid;
+  const hostname5 = record7.hostname;
+  const startedAt = record7.startedAt;
   if (!Number.isInteger(pid) || pid <= 0) return null;
   if (typeof hostname5 !== "string" || !hostname5) return null;
   if (!Number.isFinite(startedAt) || startedAt <= 0) return null;
@@ -321,7 +321,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) {
@@ -396,7 +396,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) : {};
@@ -432,7 +432,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() {
@@ -532,8 +532,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,
@@ -676,7 +676,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);
@@ -684,7 +684,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);
@@ -709,11 +709,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
@@ -723,7 +723,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)) {
@@ -749,8 +749,8 @@ function readWorkspaceIdentity(identityPath) {
 }
 function isWorkspaceDirectoryIdentity(value) {
   if (typeof value !== "object" || value === null) return false;
-  const record6 = value;
-  return typeof record6.cwd === "string" && record6.cwd.length > 0;
+  const record7 = value;
+  return typeof record7.cwd === "string" && record7.cwd.length > 0;
 }
 
 // ../../packages/core-infra/src/index.ts
@@ -1008,9 +1008,14 @@ function isHostSessionToolAllowed(_toolId, _doctrine) {
 
 // ../../packages/fleet-admiral/src/agent-cli/types.ts
 var MAX_LAUNCH_PROMPT_CHARS = 16e3;
-
-// ../../packages/fleet-admiral/src/agent-cli/prompt.ts
 var CMD_UNSAFE_PROMPT_PATTERN = /["&<>()@^|%]/;
+var LAUNCH_PROMPT_FILE_MODE = 384;
+var LAUNCH_PROMPT_TEMP_DIR_PREFIX = "fleet-quick-launch-";
+var LAUNCH_PROMPT_FILE_NAME = "prompt.md";
+var LAUNCH_PROMPT_FILE_INSTRUCTION_PREFIX = "Read and follow the launch prompt file: ";
+function launchPromptHasCmdUnsafeChars(prompt) {
+  return CMD_UNSAFE_PROMPT_PATTERN.test(prompt);
+}
 var WINDOWS_CMD_SHIM_COMMAND_LINE_MAX_CHARS = 8191;
 var WINDOWS_CREATE_PROCESS_COMMAND_LINE_MAX_CHARS = 32767;
 var LaunchPromptError = class extends Error {
@@ -1074,6 +1079,12 @@ function assertLaunchCommandLineBudget(options) {
       `The launch command line is ${withoutPrompt} characters before any launch prompt, over the ${limit.maxChars}-character Windows ${boundary} limit. Shortening the prompt cannot help; reduce the launch configuration instead.`
     );
   }
+  if (options.promptIsFixedLength === true) {
+    throw new LaunchPromptError(
+      "launch_command_line_too_long",
+      `The launch command line is ${total} characters, over the ${limit.maxChars}-character Windows ${boundary} limit even after moving the launch prompt into a file. Shortening the prompt cannot help; reduce the launch configuration instead.`
+    );
+  }
   const shortenByChars = total - limit.maxChars;
   throw new LaunchPromptError(
     "prompt_command_line_too_long",
@@ -1087,6 +1098,57 @@ function sanitizeLaunchPrompt(value) {
   const trimmed = normalized.trim();
   return trimmed.length === 0 ? void 0 : trimmed;
 }
+function formatLaunchPromptFileInstruction(filePath) {
+  return `${LAUNCH_PROMPT_FILE_INSTRUCTION_PREFIX}${filePath}`;
+}
+function writeLaunchPromptPointer(body, onCleanup, cmdWrapped) {
+  const written = writeLaunchPromptFile(body, onCleanup);
+  try {
+    assertLaunchPromptShimSafe(written.instruction, cmdWrapped ? ["cmd-shim"] : []);
+  } catch (error51) {
+    written.cleanup();
+    if (error51 instanceof LaunchPromptError && error51.code === "prompt_unsafe_for_shim") {
+      throw new LaunchPromptError(
+        "prompt_unsafe_for_shim",
+        'The launch prompt file path contains a character cmd.exe would reinterpret (" & < > ( ) @ ^ | %) while running the Windows shim. Fleet cannot start this launch from the current Windows temp directory.'
+      );
+    }
+    throw error51;
+  }
+  return written.instruction;
+}
+function writeLaunchPromptFile(body, onCleanup) {
+  const tempRoot = path19__default.resolve(os3__default.tmpdir());
+  mkdirSync(tempRoot, { recursive: true });
+  const tempDir = mkdtempSync(path19__default.join(tempRoot, LAUNCH_PROMPT_TEMP_DIR_PREFIX));
+  const cleanup = () => rmBestEffort(tempDir);
+  try {
+    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);
+    return {
+      cleanup,
+      filePath,
+      instruction: formatLaunchPromptFileInstruction(filePath)
+    };
+  } catch (error51) {
+    cleanup();
+    throw error51;
+  }
+}
+function chmodBestEffort(targetPath, mode) {
+  try {
+    chmodSync(targetPath, mode);
+  } catch {
+  }
+}
+function rmBestEffort(targetPath) {
+  try {
+    rmSync(targetPath, { force: true, recursive: true });
+  } catch {
+  }
+}
 
 // ../../node_modules/.pnpm/zod@4.4.1/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -1850,10 +1912,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path42) {
-  if (!path42)
+function getElementAtPath(obj, path43) {
+  if (!path43)
     return obj;
-  return path42.reduce((acc, key) => acc?.[key], obj);
+  return path43.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -2262,11 +2324,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path42, issues) {
+function prefixIssues(path43, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path42);
+    iss.path.unshift(path43);
     return iss;
   });
 }
@@ -2413,16 +2475,16 @@ function flattenError(error51, mapper = (issue3) => issue3.message) {
 }
 function formatError(error51, mapper = (issue3) => issue3.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path42 = []) => {
+  const processError = (error52, path43 = []) => {
     for (const issue3 of error52.issues) {
       if (issue3.code === "invalid_union" && issue3.errors.length) {
-        issue3.errors.map((issues) => processError({ issues }, [...path42, ...issue3.path]));
+        issue3.errors.map((issues) => processError({ issues }, [...path43, ...issue3.path]));
       } else if (issue3.code === "invalid_key") {
-        processError({ issues: issue3.issues }, [...path42, ...issue3.path]);
+        processError({ issues: issue3.issues }, [...path43, ...issue3.path]);
       } else if (issue3.code === "invalid_element") {
-        processError({ issues: issue3.issues }, [...path42, ...issue3.path]);
+        processError({ issues: issue3.issues }, [...path43, ...issue3.path]);
       } else {
-        const fullpath = [...path42, ...issue3.path];
+        const fullpath = [...path43, ...issue3.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue3));
         } else {
@@ -2449,17 +2511,17 @@ function formatError(error51, mapper = (issue3) => issue3.message) {
 }
 function treeifyError(error51, mapper = (issue3) => issue3.message) {
   const result = { errors: [] };
-  const processError = (error52, path42 = []) => {
+  const processError = (error52, path43 = []) => {
     var _a3, _b;
     for (const issue3 of error52.issues) {
       if (issue3.code === "invalid_union" && issue3.errors.length) {
-        issue3.errors.map((issues) => processError({ issues }, [...path42, ...issue3.path]));
+        issue3.errors.map((issues) => processError({ issues }, [...path43, ...issue3.path]));
       } else if (issue3.code === "invalid_key") {
-        processError({ issues: issue3.issues }, [...path42, ...issue3.path]);
+        processError({ issues: issue3.issues }, [...path43, ...issue3.path]);
       } else if (issue3.code === "invalid_element") {
-        processError({ issues: issue3.issues }, [...path42, ...issue3.path]);
+        processError({ issues: issue3.issues }, [...path43, ...issue3.path]);
       } else {
-        const fullpath = [...path42, ...issue3.path];
+        const fullpath = [...path43, ...issue3.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue3));
           continue;
@@ -2491,8 +2553,8 @@ function treeifyError(error51, mapper = (issue3) => issue3.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path42 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path42) {
+  const path43 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path43) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -15156,13 +15218,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path42 = ref.slice(1).split("/").filter(Boolean);
-  if (path42.length === 0) {
+  const path43 = ref.slice(1).split("/").filter(Boolean);
+  if (path43.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path42[0] === defsKey) {
-    const key = path42[1];
+  if (path43[0] === defsKey) {
+    const key = path43[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -18564,8 +18626,8 @@ function bootEnumDescriptorProto(init) {
 }
 
 // ../../node_modules/.pnpm/@bufbuild+protobuf@2.13.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/message.js
-function messageDesc(file2, path42, ...paths) {
-  return paths.reduce((acc, cur) => acc.nestedMessages[cur], file2.messages[path42]);
+function messageDesc(file2, path43, ...paths) {
+  return paths.reduce((acc, cur) => acc.nestedMessages[cur], file2.messages[path43]);
 }
 
 // ../../node_modules/.pnpm/@bufbuild+protobuf@2.13.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/descriptor_pb.js
@@ -19963,11 +20025,11 @@ function fieldMaskFromJson(fieldMask, json2) {
   if (json2 === "") {
     return;
   }
-  fieldMask.paths = json2.split(",").map((path42) => {
-    if (path42.includes("_")) {
+  fieldMask.paths = json2.split(",").map((path43) => {
+    if (path43.includes("_")) {
       throw new Error(`cannot decode message ${fieldMask.$typeName} from JSON: path names must be lowerCamelCase`);
     }
-    return protoSnakeCase(path42);
+    return protoSnakeCase(path43);
   });
 }
 function structFromJson(struct, json2, ctx) {
@@ -20329,17 +20391,17 @@ function projectAnthropicUsageEnvelope(value, contextWindow, responseModel) {
   return { changed, value: projectedValue };
 }
 function projectUsageProperty(container, property, contextWindow) {
-  const usage3 = container[property];
-  if (!isRecord2(usage3)) return { changed: false, value: container };
+  const usage4 = container[property];
+  if (!isRecord2(usage4)) return { changed: false, value: container };
   const coordinates = ANTHROPIC_INPUT_USAGE_FIELDS.map((field) => {
-    const tokens = usage3[field];
+    const tokens = usage4[field];
     return typeof tokens === "number" && Number.isFinite(tokens) && tokens >= 0 ? { field, tokens } : void 0;
   }).filter((entry) => entry !== void 0);
   if (coordinates.length === 0) return { changed: false, value: container };
   const total = coordinates.reduce((sum, entry) => sum + entry.tokens, 0);
   const projectedTotal = projectClaudeContextInputTokens(total, contextWindow);
   if (projectedTotal === total) return { changed: false, value: container };
-  const projectedUsage = { ...usage3 };
+  const projectedUsage = { ...usage4 };
   const remainderField = coordinates.some((entry) => entry.field === "input_tokens") ? "input_tokens" : coordinates[0].field;
   let assigned = 0;
   for (const entry of coordinates) {
@@ -20486,6 +20548,39 @@ function removeClaudeSkillListingEntries(text2, withheld, delisted) {
 function withheldClaudeSkillStub(name, tokens, budget) {
   return `[Fleet AI gateway withheld the "${name}" skill: its body is about ${tokens} tokens, over the ${budget}-token ceiling one skill may take from this model's context window. Read the skill's own files if you need it, or run this work on a model with a larger window.]`;
 }
+var CLAUDE_WEB_SEARCH_TOOL_NAME = "WebSearch";
+var ANTHROPIC_WEB_SEARCH_TOOL_NAME = "web_search";
+var ANTHROPIC_WEB_SEARCH_TOOL_TYPE = "web_search_20250305";
+function isClaudeWebSearchTool(tool) {
+  return tool.type === ANTHROPIC_WEB_SEARCH_TOOL_TYPE || tool.name === CLAUDE_WEB_SEARCH_TOOL_NAME || tool.name === ANTHROPIC_WEB_SEARCH_TOOL_NAME;
+}
+function isClaudeWebSearchToolChoice(choice) {
+  return choice?.type === "tool" && (choice.name === CLAUDE_WEB_SEARCH_TOOL_NAME || choice.name === ANTHROPIC_WEB_SEARCH_TOOL_NAME);
+}
+function omitClaudeWebSearchTools(request) {
+  const tools = request.tools;
+  const kept = tools?.filter((tool) => !isClaudeWebSearchTool(tool));
+  const toolsChanged = tools !== void 0 && kept !== void 0 && kept.length !== tools.length;
+  const choice = request.tool_choice;
+  const choiceChanged = isClaudeWebSearchToolChoice(choice);
+  if (!toolsChanged && !choiceChanged) {
+    return { request, changed: false };
+  }
+  const { tools: _tools, tool_choice: _toolChoice, ...rest } = request;
+  return {
+    request: {
+      ...rest,
+      ...toolsChanged ? kept.length === 0 ? {} : { tools: kept } : tools === void 0 ? {} : { tools },
+      ...choiceChanged ? {
+        tool_choice: {
+          type: "auto",
+          ...choice?.disable_parallel_tool_use === void 0 ? {} : { disable_parallel_tool_use: choice.disable_parallel_tool_use }
+        }
+      } : choice === void 0 ? {} : { tool_choice: choice }
+    },
+    changed: true
+  };
+}
 var benchmarks_default = {
   version: 2,
   sources: {
@@ -20683,7 +20778,7 @@ var benchmarks_default = {
 };
 var models_default = {
   version: 1,
-  updatedAt: "2026-08-13T00:00:00Z",
+  updatedAt: "2026-08-14T00:00:00Z",
   providers: {
     codex: {
       name: "Codex",
@@ -21068,13 +21163,37 @@ var models_default = {
           contextWindow: 256e3
         }
       ]
+    },
+    xai: {
+      name: "xAI",
+      defaultModel: "grok-4.6",
+      source: "official Grok CLI 1.0.3 ~/.grok/models_cache.json from GET https://cli-chat-proxy.grok.com/v1/models (observed 2026-08-13)",
+      models: [
+        {
+          modelId: "grok-4.6",
+          name: "Grok-4.6",
+          capabilityClass: "flagship",
+          wire: "responses",
+          contextWindow: 5e5,
+          effort: {
+            supported: true,
+            levels: [
+              "low",
+              "medium",
+              "high",
+              "xhigh"
+            ]
+          },
+          benchmarkKey: "grok-4.6"
+        }
+      ]
     }
   }
 };
 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", "cursor", "kimi", "opencode"];
+var GATEWAY_PROVIDERS = ["codex", "xai", "cursor", "opencode", "kimi"];
 var GATEWAY_MODEL_WIRES = ["anthropic", "responses", "chat-completions"];
 var GATEWAY_REASONING_EFFORTS = [
   "low",
@@ -21162,7 +21281,8 @@ var GatewayModelsRegistrySchema = external_exports.object({
     codex: GatewayProviderSchema,
     cursor: GatewayProviderSchema,
     kimi: GatewayProviderSchema,
-    opencode: GatewayProviderSchema
+    opencode: GatewayProviderSchema,
+    xai: GatewayProviderSchema
   }).strict()
 }).strict();
 var UNSUPPORTED_GATEWAY_MODEL_EFFORT = Object.freeze({ supported: false });
@@ -21427,8 +21547,8 @@ function validateRegistry(value) {
       if (model.quotaScope && provider !== "cursor") {
         throw new Error(`Gateway quota scope is only supported by Cursor: ${provider}/${model.modelId}`);
       }
-      if (model.wire && provider !== "opencode") {
-        throw new Error(`Gateway model wire is only supported by OpenCode: ${provider}/${model.modelId}`);
+      if (model.wire && provider !== "opencode" && provider !== "xai") {
+        throw new Error(`Gateway model wire is not supported by provider: ${provider}/${model.modelId}`);
       }
       if (model.effort?.supported) {
         if (new Set(model.effort.levels).size !== model.effort.levels.length) {
@@ -21883,14 +22003,14 @@ function nonNegativeCacheValue(value) {
   }
   return value;
 }
-function anthropicUsageFromCanonical(usage3, advertisedContextWindow, options = {}) {
+function anthropicUsageFromCanonical(usage4, advertisedContextWindow, options = {}) {
   return toAnthropicCacheAwareUsage(
-    usage3?.input_tokens ?? 0,
-    usage3?.cached_input_tokens,
-    usage3?.cache_write_input_tokens,
-    options.forceOutputZero ? 0 : usage3?.output_tokens ?? 0,
+    usage4?.input_tokens ?? 0,
+    usage4?.cached_input_tokens,
+    usage4?.cache_write_input_tokens,
+    options.forceOutputZero ? 0 : usage4?.output_tokens ?? 0,
     advertisedContextWindow,
-    usage3?.context_window
+    usage4?.context_window
   );
 }
 async function collectAnthropicMessage(events, fallbackModel, options = {}) {
@@ -23731,7 +23851,7 @@ 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 fs7.open(filePath, CREDENTIAL_OPEN_FLAGS);
+  const handle = await fs32.open(filePath, CREDENTIAL_OPEN_FLAGS);
   try {
     const stat22 = await handle.stat();
     if (!stat22.isFile() || stat22.size > maxBytes) return null;
@@ -23774,7 +23894,7 @@ function optionalNonEmptyString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function codexAuthFilePath(deps) {
-  return path18__default.join(deps.env.CODEX_HOME || path18__default.join(deps.homedir(), ".codex"), "auth.json");
+  return path19__default.join(deps.env.CODEX_HOME || path19__default.join(deps.homedir(), ".codex"), "auth.json");
 }
 async function resolveCodexCredentials(deps) {
   try {
@@ -23813,12 +23933,12 @@ function parseCursorCredentialJson(raw, method) {
 function cursorAuthFilePath(deps) {
   const home = deps.homedir();
   if (deps.platform === "win32") {
-    return path18__default.join(deps.env.APPDATA || path18__default.join(home, "AppData", "Roaming"), "Cursor", "auth.json");
+    return path19__default.join(deps.env.APPDATA || path19__default.join(home, "AppData", "Roaming"), "Cursor", "auth.json");
   }
   if (deps.platform === "darwin") {
-    return path18__default.join(home, ".cursor", "auth.json");
+    return path19__default.join(home, ".cursor", "auth.json");
   }
-  return path18__default.join(deps.env.XDG_CONFIG_HOME || path18__default.join(home, ".config"), "cursor", "auth.json");
+  return path19__default.join(deps.env.XDG_CONFIG_HOME || path19__default.join(home, ".config"), "cursor", "auth.json");
 }
 async function resolveCursorCredentials(deps) {
   if (deps.platform === "darwin") {
@@ -24140,7 +24260,7 @@ async function* translateChatCompletionsStream(body, options, toolSchemas) {
   let createdEmitted = false;
   let textSeen = false;
   let accumulatedText = "";
-  let usage3 = null;
+  let usage4 = null;
   let failed = false;
   const toolCalls = /* @__PURE__ */ new Map();
   const MESSAGE_ITEM_ID = "chat_message_0";
@@ -24171,7 +24291,7 @@ async function* translateChatCompletionsStream(body, options, toolSchemas) {
       };
     }
     if (isRecord5(value.usage)) {
-      usage3 = chatUsage(value.usage);
+      usage4 = chatUsage(value.usage);
     }
     const choices = Array.isArray(value.choices) ? value.choices : [];
     for (const choice of choices) {
@@ -24264,7 +24384,7 @@ async function* translateChatCompletionsStream(body, options, toolSchemas) {
         model: responseModel ?? "",
         // 하류 message_delta는 usage가 필수다. include_usage에도 usage 청크를 주지
         // 않는 백엔드에서는 0-usage로 완결하고, 실제 회계는 provider 콘솔이 맡는다.
-        usage: usage3 ?? { input_tokens: 0, output_tokens: 0 }
+        usage: usage4 ?? { input_tokens: 0, output_tokens: 0 }
       }
     };
   }
@@ -24925,6 +25045,610 @@ function createOpencodeGoAdapter(wire, options = {}) {
     ...options.fetch ? { fetch: options.fetch } : {}
   });
 }
+var XAI_OIDC_ISSUER = "https://auth.x.ai";
+var XAI_CLI_REFRESH_URL = "https://auth.x.ai/oauth2/token";
+var XAI_CLI_DEFAULT_CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828";
+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 path19__default.join(deps.env.GROK_HOME || path19__default.join(deps.homedir(), ".grok"), "auth.json");
+}
+function expiry(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;
+  return parsed < 1e12 ? Math.round(parsed * 1e3) : Math.round(parsed);
+}
+function jwtExpiry(token) {
+  const parts = token.split(".");
+  if (parts.length < 2) return void 0;
+  try {
+    const payload = JSON.parse(Buffer.from(parts[1] ?? "", "base64url").toString("utf8"));
+    const record42 = credentialRecord(payload);
+    const exp = record42?.exp;
+    if (typeof exp !== "number" || !Number.isFinite(exp)) return void 0;
+    return Math.round(exp * 1e3);
+  } catch {
+    return void 0;
+  }
+}
+function effectiveExpiry(entry, accessToken) {
+  const fromEntry = expiry(entry.expires_at) ?? expiry(entry.expires);
+  const fromJwt = jwtExpiry(accessToken);
+  if (fromEntry !== void 0 && fromJwt !== void 0) return Math.min(fromEntry, fromJwt);
+  return fromEntry ?? fromJwt;
+}
+function clientId(entryKey, entry) {
+  const fromEntry = optionalTrimmedString(entry.oidc_client_id);
+  if (fromEntry) return fromEntry;
+  const suffix = optionalTrimmedString(entryKey.split("::").at(-1));
+  return suffix ?? XAI_CLI_DEFAULT_CLIENT_ID;
+}
+function refreshToken(entry) {
+  return optionalTrimmedString(entry.refresh_token) ?? optionalTrimmedString(entry.refresh);
+}
+async function defaultWriteAuthFile(filePath, contents) {
+  const tmpPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await fs32.writeFile(tmpPath, contents, { encoding: "utf8", mode: 384 });
+    await fs32.rename(tmpPath, filePath);
+  } catch (error51) {
+    await fs32.unlink(tmpPath).catch(() => void 0);
+    throw error51;
+  }
+}
+async function persistRefreshedEntry(deps, filePath, entryKey, expected, patch, writeAuthFile) {
+  const raw = await deps.readBounded(filePath, MAX_CREDENTIAL_BYTES);
+  if (raw === null) return;
+  const auth = credentialRecord(JSON.parse(raw));
+  if (!auth) return;
+  const current = credentialRecord(auth[entryKey]);
+  if (!current) return;
+  if (optionalTrimmedString(current.key) !== expected.accessToken) return;
+  if (expected.refreshToken !== void 0 && refreshToken(current) !== expected.refreshToken) return;
+  auth[entryKey] = { ...current, ...patch };
+  await writeAuthFile(filePath, `${JSON.stringify(auth, null, 2)}
+`);
+}
+async function refreshAccessToken(entryKey, entry, fetchImpl, now) {
+  const token = refreshToken(entry);
+  if (!token) return null;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REFRESH_TIMEOUT_MS);
+  try {
+    const body = new URLSearchParams({
+      grant_type: "refresh_token",
+      client_id: clientId(entryKey, entry),
+      refresh_token: token
+    });
+    const response = await fetchImpl(XAI_CLI_REFRESH_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded", Accept: "application/json" },
+      body,
+      signal: controller.signal
+    });
+    if (!response.ok) return null;
+    const payload = credentialRecord(await response.json());
+    const accessToken = optionalTrimmedString(payload?.access_token);
+    if (!accessToken) return null;
+    const expiresIn = payload?.expires_in;
+    const expiresAt = typeof expiresIn === "number" && Number.isFinite(expiresIn) && expiresIn > 0 ? now() + Math.round(expiresIn * 1e3) : jwtExpiry(accessToken) ?? now() + FALLBACK_ACCESS_TOKEN_TTL_MS;
+    const rotated = optionalTrimmedString(payload?.refresh_token);
+    return {
+      accessToken,
+      expiresAt,
+      ...rotated === void 0 ? {} : { refreshToken: rotated }
+    };
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function resolveXaiCliAuth(deps, options = {}) {
+  const now = options.now ?? Date.now;
+  const fetchImpl = options.fetch ?? fetch;
+  const writeAuthFile = options.writeAuthFile ?? defaultWriteAuthFile;
+  const filePath = xaiCliAuthFilePath(deps);
+  try {
+    const raw = await deps.readBounded(filePath, MAX_CREDENTIAL_BYTES);
+    if (raw === null || raw.length > MAX_CREDENTIAL_BYTES) return { status: "signed_out" };
+    const auth = credentialRecord(JSON.parse(raw));
+    if (!auth) return { status: "signed_out" };
+    let sawExpired = false;
+    for (const [entryKey, value] of Object.entries(auth)) {
+      if (!entryKey.startsWith(`${XAI_OIDC_ISSUER}::`)) continue;
+      const entry = credentialRecord(value);
+      const issuer = optionalTrimmedString(entry?.oidc_issuer);
+      const accessToken = optionalTrimmedString(entry?.key);
+      if (!entry || issuer !== XAI_OIDC_ISSUER || !accessToken) continue;
+      const expiresAt = effectiveExpiry(entry, accessToken);
+      const expired2 = expiresAt !== void 0 && expiresAt <= now();
+      const needsRefresh = options.forceRefresh === true || expiresAt !== void 0 && expiresAt - now() <= XAI_CLI_REFRESH_BUFFER_MS;
+      if (needsRefresh) {
+        const refreshed = await refreshAccessToken(entryKey, entry, fetchImpl, now);
+        if (refreshed) {
+          const userId2 = optionalTrimmedString(entry.user_id) ?? optionalTrimmedString(entry.principal_id);
+          const patch = {
+            key: refreshed.accessToken,
+            expires_at: new Date(refreshed.expiresAt).toISOString()
+          };
+          if (refreshed.refreshToken !== void 0) patch.refresh_token = refreshed.refreshToken;
+          try {
+            await persistRefreshedEntry(
+              deps,
+              filePath,
+              entryKey,
+              { accessToken, refreshToken: refreshToken(entry) },
+              patch,
+              writeAuthFile
+            );
+          } catch {
+          }
+          return {
+            status: "ok",
+            credentials: {
+              accessToken: refreshed.accessToken,
+              expiresAt: refreshed.expiresAt,
+              ...userId2 === void 0 ? {} : { userId: userId2 }
+            }
+          };
+        }
+        if (options.forceRefresh === true || expired2) {
+          sawExpired = true;
+          continue;
+        }
+      } else if (expired2) {
+        sawExpired = true;
+        continue;
+      }
+      const userId = optionalTrimmedString(entry.user_id) ?? optionalTrimmedString(entry.principal_id);
+      return {
+        status: "ok",
+        credentials: {
+          accessToken,
+          ...expiresAt === void 0 ? {} : { expiresAt },
+          ...userId === void 0 ? {} : { userId }
+        }
+      };
+    }
+    return { status: sawExpired ? "expired" : "signed_out" };
+  } catch {
+    return { status: "signed_out" };
+  }
+}
+async function resolveXaiCliCredentials(deps, nowOrOptions = Date.now) {
+  const options = typeof nowOrOptions === "function" ? { now: nowOrOptions } : nowOrOptions;
+  const result = await resolveXaiCliAuth(deps, options);
+  return result.status === "ok" ? result.credentials : null;
+}
+var XAI_CLI_RESPONSES_URL = "https://cli-chat-proxy.grok.com/v1/responses";
+var XAI_CLI_CLIENT_VERSION = "1.0.3";
+var DEFAULT_XAI_RESPONSES_MAX_UPSTREAM_BODY_BYTES = 64 * 1024 * 1024;
+var DEFAULT_XAI_RESPONSES_UPSTREAM_IDLE_TIMEOUT_MS = 3e4;
+var DEFAULT_XAI_RESPONSES_FUNCTION_CALL_TIMEOUT_MS = 3e4;
+var XaiResponsesAdapter = class {
+  capabilities = {};
+  fetchImpl;
+  maxBodyBytes;
+  idleTimeoutMs;
+  functionCallTimeoutMs;
+  url;
+  extraHeaders;
+  constructor(options = {}) {
+    this.url = XAI_CLI_RESPONSES_URL;
+    this.extraHeaders = options.headers ?? {};
+    this.fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.maxBodyBytes = positiveInteger(
+      options.maxBodyBytes ?? DEFAULT_XAI_RESPONSES_MAX_UPSTREAM_BODY_BYTES,
+      "maxBodyBytes"
+    );
+    this.idleTimeoutMs = positiveInteger(
+      options.idleTimeoutMs ?? DEFAULT_XAI_RESPONSES_UPSTREAM_IDLE_TIMEOUT_MS,
+      "idleTimeoutMs"
+    );
+    this.functionCallTimeoutMs = positiveInteger(
+      options.functionCallTimeoutMs ?? DEFAULT_XAI_RESPONSES_FUNCTION_CALL_TIMEOUT_MS,
+      "functionCallTimeoutMs"
+    );
+  }
+  async stream(request, options) {
+    if (options.apiKey.length === 0) {
+      throw new TypeError("apiKey must not be empty");
+    }
+    const controller = new AbortController();
+    const unlinkAbort = linkAbortSignal(options.signal, controller);
+    const payload = forXaiResponsesBackend(request);
+    wireLog("xai-responses.wire.request", { url: this.url, payload });
+    let response;
+    try {
+      response = await this.fetchImpl(this.url, {
+        method: "POST",
+        headers: {
+          accept: "text/event-stream",
+          authorization: `Bearer ${options.apiKey}`,
+          "content-type": "application/json",
+          "x-xai-token-auth": "xai-grok-cli",
+          "x-grok-client-version": XAI_CLI_CLIENT_VERSION,
+          "x-grok-model-override": request.model,
+          ...this.extraHeaders
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+    } catch (error51) {
+      unlinkAbort();
+      throw error51;
+    }
+    if (!response.ok) {
+      if (process.env.FLEET_AI_GATEWAY_DEBUG === "1") {
+        const roles = payload.input.map((item) => "role" in item ? item.role : item.type);
+        console.error(`[ai-gateway] upstream ${response.status} input roles=${JSON.stringify(roles)} keys=${JSON.stringify(Object.keys(payload))}`);
+      }
+      try {
+        const body = await readBoundedBody(response.body, {
+          controller,
+          idleTimeoutMs: this.idleTimeoutMs,
+          maxBodyBytes: this.maxBodyBytes
+        });
+        return {
+          ok: false,
+          status: response.status,
+          headers: response.headers,
+          body
+        };
+      } finally {
+        unlinkAbort();
+      }
+    }
+    return {
+      ok: true,
+      status: response.status,
+      headers: response.headers,
+      events: parseXaiEventStream(response.body, {
+        controller,
+        idleTimeoutMs: this.idleTimeoutMs,
+        maxBodyBytes: this.maxBodyBytes,
+        onClose: unlinkAbort
+      }, this.functionCallTimeoutMs)
+    };
+  }
+};
+function forXaiResponsesBackend(request) {
+  const { metadata: _metadata, native_tools: _nativeTools, ...rest } = request;
+  return {
+    ...rest,
+    input: request.input.map((item) => {
+      if (item.type === "function_call_output") {
+        const { is_error: _isError, tool_references: _toolReferences, ...wireItem2 } = item;
+        return wireItem2;
+      }
+      const { reasoning_content: _reasoningContent, ...wireItem } = item;
+      return wireItem;
+    }),
+    ...request.tools === void 0 ? {} : { tools: request.tools.map(({ defer_loading: _deferLoading, ...tool }) => tool) }
+  };
+}
+function parseXaiEventStream(body, options, functionCallTimeoutMs) {
+  return assembleXaiFunctionCalls(
+    parseUpstreamSseStream(
+      body,
+      { ...options, missingBodyMessage: "Grok CLI streaming response had no body" },
+      parseEventFrame3
+    ),
+    options.controller,
+    functionCallTimeoutMs
+  );
+}
+async function* assembleXaiFunctionCalls(source, controller, timeoutMs) {
+  const iterator = source[Symbol.asyncIterator]();
+  const pending = /* @__PURE__ */ new Map();
+  let completedNormally = false;
+  try {
+    while (true) {
+      const deadlineAt = earliestXaiFunctionCallDeadline(pending);
+      const result = deadlineAt === void 0 ? await iterator.next() : await nextXaiEventBeforeDeadline(iterator, deadlineAt, controller, timeoutMs);
+      if (result.done) {
+        if (pending.size > 0) {
+          throw incompleteXaiFunctionCall("stream ended before function call output_item.done");
+        }
+        completedNormally = true;
+        return;
+      }
+      const event = result.value;
+      if (event.type === "response.completed" && pending.size > 0) {
+        throw incompleteXaiFunctionCall("response.completed arrived before function call output_item.done");
+      }
+      if (event.type === "response.output_item.added" && event.item.type === "function_call") {
+        const key = xaiFunctionCallKey(event.output_index, event.item.id);
+        pending.set(key, {
+          added: event,
+          // Each call gets a full timeout from its own added event. Waiting uses the
+          // earliest active deadline, so a later parallel call is never shortened by
+          // an earlier call's age.
+          deadlineAt: Date.now() + timeoutMs
+        });
+        continue;
+      }
+      if (event.type === "response.function_call_arguments.done") {
+        const call = pending.get(xaiFunctionCallKey(event.output_index, event.item_id));
+        if (call !== void 0) {
+          call.argumentsDone = event;
+          continue;
+        }
+      }
+      if (event.type === "response.output_item.done" && event.item.type === "function_call") {
+        const key = xaiFunctionCallKey(event.output_index, event.item.id);
+        const call = pending.get(key);
+        if (call !== void 0) {
+          pending.delete(key);
+          yield call.added;
+          if (call.argumentsDone !== void 0) {
+            yield call.argumentsDone;
+          } else if (event.item.arguments.length > 0) {
+            yield {
+              type: "response.function_call_arguments.done",
+              item_id: event.item.id,
+              output_index: event.output_index,
+              arguments: event.item.arguments
+            };
+          }
+          yield event;
+          continue;
+        }
+      }
+      yield event;
+    }
+  } finally {
+    if (!completedNormally && !controller.signal.aborted) {
+      controller.abort();
+    }
+    const returned = iterator.return?.();
+    if (returned !== void 0) {
+      await returned.catch(() => void 0);
+    }
+  }
+}
+function earliestXaiFunctionCallDeadline(pending) {
+  let earliest;
+  for (const call of pending.values()) {
+    if (earliest === void 0 || call.deadlineAt < earliest) {
+      earliest = call.deadlineAt;
+    }
+  }
+  return earliest;
+}
+async function nextXaiEventBeforeDeadline(iterator, deadlineAt, controller, timeoutMs) {
+  const remainingMs = deadlineAt - Date.now();
+  if (remainingMs <= 0) {
+    const error51 = incompleteXaiFunctionCall(`function call assembly exceeded ${timeoutMs}ms`);
+    controller.abort(error51);
+    throw error51;
+  }
+  let timeout;
+  const next = iterator.next();
+  void next.catch(() => void 0);
+  try {
+    return await Promise.race([
+      next,
+      new Promise((_, reject) => {
+        timeout = setTimeout(() => {
+          const error51 = incompleteXaiFunctionCall(`function call assembly exceeded ${timeoutMs}ms`);
+          controller.abort(error51);
+          reject(error51);
+        }, remainingMs);
+      })
+    ]);
+  } finally {
+    if (timeout !== void 0) {
+      clearTimeout(timeout);
+    }
+  }
+}
+function incompleteXaiFunctionCall(reason) {
+  return new UpstreamProtocolError(`Grok CLI ${reason}`);
+}
+function xaiFunctionCallKey(outputIndex, itemId) {
+  return `${outputIndex}:${itemId}`;
+}
+function parseEventFrame3(frame) {
+  const { event: eventName, data } = parseSseFrameFields(frame);
+  if (data.length === 0 || data === "[DONE]") {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch (error51) {
+    throw new UpstreamProtocolError(
+      `Grok CLI SSE contained invalid JSON: ${error51 instanceof Error ? error51.message : String(error51)}`
+    );
+  }
+  if (isRecord7(parsed) && typeof parsed.type !== "string" && eventName !== void 0) {
+    parsed = { ...parsed, type: eventName };
+  }
+  return canonicalEvent3(parsed);
+}
+function canonicalEvent3(value) {
+  if (!isRecord7(value) || typeof value.type !== "string") {
+    throw new UpstreamProtocolError("Grok CLI SSE event was not an object with a type");
+  }
+  switch (value.type) {
+    case "response.created":
+      return { type: value.type, response: responseSnapshot3(value.response) };
+    case "response.content_part.added": {
+      const part = record3(value.part, "response.content_part.added.part");
+      if (part.type !== "output_text") {
+        return void 0;
+      }
+      return {
+        type: value.type,
+        item_id: string32(value.item_id, "item_id"),
+        output_index: number32(value.output_index, "output_index"),
+        content_index: number32(value.content_index, "content_index"),
+        part: {
+          type: "output_text",
+          text: typeof part.text === "string" ? part.text : ""
+        }
+      };
+    }
+    case "response.output_text.delta":
+      return {
+        type: value.type,
+        item_id: string32(value.item_id, "item_id"),
+        output_index: number32(value.output_index, "output_index"),
+        content_index: number32(value.content_index, "content_index"),
+        delta: string32(value.delta, "delta")
+      };
+    case "response.output_text.done":
+      return {
+        type: value.type,
+        item_id: string32(value.item_id, "item_id"),
+        output_index: number32(value.output_index, "output_index"),
+        content_index: number32(value.content_index, "content_index"),
+        text: string32(value.text, "text")
+      };
+    case "response.reasoning_summary_text.delta":
+    case "response.reasoning_text.delta":
+      return {
+        type: "response.reasoning_summary_text.delta",
+        item_id: string32(value.item_id, "item_id"),
+        output_index: number32(value.output_index, "output_index"),
+        delta: string32(value.delta, "delta")
+      };
+    case "response.output_item.added":
+    case "response.output_item.done": {
+      const item = outputItem3(value.item);
+      if (item === void 0) {
+        return void 0;
+      }
+      return {
+        type: value.type,
+        output_index: number32(value.output_index, "output_index"),
+        item
+      };
+    }
+    // Hold argument fragments until the Grok CLI proxy's partial-JSON behavior is observed.
+    // The `.done` event carries the complete argument object, which downstream treats as the
+    // remainder when nothing was streamed ahead of it.
+    case "response.function_call_arguments.delta":
+      return void 0;
+    case "response.function_call_arguments.done":
+      return {
+        type: value.type,
+        item_id: string32(value.item_id, "item_id"),
+        output_index: number32(value.output_index, "output_index"),
+        arguments: string32(value.arguments, "arguments")
+      };
+    case "response.completed":
+      return { type: value.type, response: responseSnapshot3(value.response) };
+    case "response.failed": {
+      const response = record3(value.response, "response.failed.response");
+      return {
+        type: value.type,
+        response: {
+          ...responseSnapshot3(response),
+          error: canonicalError3(response.error)
+        }
+      };
+    }
+    case "error":
+      return { type: "error", error: canonicalError3(value.error ?? value) };
+    default:
+      return void 0;
+  }
+}
+function responseSnapshot3(value) {
+  const response = record3(value, "response");
+  return {
+    id: string32(response.id, "response.id"),
+    model: string32(response.model, "response.model"),
+    usage: response.usage === null || response.usage === void 0 ? null : usage3(response.usage)
+  };
+}
+function usage3(value) {
+  const parsed = record3(value, "usage");
+  const inputTokens = number32(parsed.input_tokens, "usage.input_tokens");
+  const outputTokens = number32(parsed.output_tokens, "usage.output_tokens");
+  const inputDetails = optionalRecord3(parsed.input_tokens_details, "usage.input_tokens_details");
+  const cachedInputTokens = inputDetails === void 0 ? void 0 : optionalNonNegativeNumber3(inputDetails.cached_tokens, "usage.input_tokens_details.cached_tokens");
+  const cacheWriteInputTokens = inputDetails === void 0 ? void 0 : optionalNonNegativeNumber3(inputDetails.cache_write_tokens, "usage.input_tokens_details.cache_write_tokens");
+  const outputDetails = optionalRecord3(parsed.output_tokens_details, "usage.output_tokens_details");
+  const reasoningOutputTokens = outputDetails === void 0 ? void 0 : optionalNonNegativeNumber3(outputDetails.reasoning_tokens, "usage.output_tokens_details.reasoning_tokens");
+  const totalTokens = optionalNonNegativeNumber3(parsed.total_tokens, "usage.total_tokens");
+  return {
+    input_tokens: inputTokens,
+    output_tokens: outputTokens,
+    ...cachedInputTokens === void 0 ? {} : { cached_input_tokens: cachedInputTokens },
+    ...cacheWriteInputTokens === void 0 ? {} : { cache_write_input_tokens: cacheWriteInputTokens },
+    ...reasoningOutputTokens === void 0 ? {} : { reasoning_output_tokens: reasoningOutputTokens },
+    ...totalTokens === void 0 ? {} : { total_tokens: totalTokens }
+  };
+}
+function outputItem3(value) {
+  const item = record3(value, "item");
+  if (item.type === "message") {
+    return {
+      id: string32(item.id, "item.id"),
+      type: "message",
+      role: "assistant"
+    };
+  }
+  if (item.type === "function_call") {
+    const id = string32(item.id, "item.id");
+    return {
+      id,
+      type: "function_call",
+      call_id: typeof item.call_id === "string" ? item.call_id : id,
+      name: string32(item.name, "item.name"),
+      arguments: typeof item.arguments === "string" ? item.arguments : ""
+    };
+  }
+  return void 0;
+}
+function canonicalError3(value) {
+  const error51 = record3(value, "error");
+  const message = string32(error51.message, "error.message");
+  const type = typeof error51.type === "string" && error51.type !== "error" ? error51.type : typeof error51.code === "string" ? error51.code : "api_error";
+  return { type, message };
+}
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function record3(value, name) {
+  if (!isRecord7(value)) {
+    throw new UpstreamProtocolError(`${name} must be an object`);
+  }
+  return value;
+}
+function optionalRecord3(value, name) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  return record3(value, name);
+}
+function string32(value, name) {
+  if (typeof value !== "string") {
+    throw new UpstreamProtocolError(`${name} must be a string`);
+  }
+  return value;
+}
+function number32(value, name) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new UpstreamProtocolError(`${name} must be a number`);
+  }
+  return value;
+}
+function optionalNonNegativeNumber3(value, name) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new UpstreamProtocolError(`${name} must be a finite nonnegative number`);
+  }
+  return value;
+}
 var NO_USER_FACING_BLOCK = "Do not tell the user access is blocked, disabled, or denied.";
 var CLIENT_TOOL_RETRY = `${NO_USER_FACING_BLOCK} Silently retry with the matching client bridge tool from the current catalog.`;
 function cursorNativeExecPolicyReplies(exec2, clientTools) {
@@ -24965,38 +25689,38 @@ function cursorNativeExecPolicyReplies(exec2, clientTools) {
     "shell_command",
     "exec_command"
   ]);
-  if (isRecord7(exec2.readArgs)) {
+  if (isRecord8(exec2.readArgs)) {
     return [execReply(exec2, "readResult", {
       error: { path: stringValue(exec2.readArgs.path), error: readMessage3 }
     })];
   }
-  if (isRecord7(exec2.writeArgs)) {
+  if (isRecord8(exec2.writeArgs)) {
     return [execReply(exec2, "writeResult", {
       rejected: { path: stringValue(exec2.writeArgs.path), reason: mutationMessage }
     })];
   }
-  if (isRecord7(exec2.deleteArgs)) {
+  if (isRecord8(exec2.deleteArgs)) {
     return [execReply(exec2, "deleteResult", {
       rejected: { path: stringValue(exec2.deleteArgs.path), reason: mutationMessage }
     })];
   }
-  if (isRecord7(exec2.lsArgs)) {
+  if (isRecord8(exec2.lsArgs)) {
     return [execReply(exec2, "lsResult", {
       error: { path: stringValue(exec2.lsArgs.path), error: listMessage }
     })];
   }
-  if (isRecord7(exec2.grepArgs)) {
+  if (isRecord8(exec2.grepArgs)) {
     return [execReply(exec2, "grepResult", { error: { error: grepMessage } })];
   }
-  if (isRecord7(exec2.shellArgs)) {
+  if (isRecord8(exec2.shellArgs)) {
     return [execReply(exec2, "shellResult", shellFailure(exec2.shellArgs, shellMessage))];
   }
-  if (isRecord7(exec2.shellStreamArgs)) {
+  if (isRecord8(exec2.shellStreamArgs)) {
     const args = exec2.shellStreamArgs;
     const cwd = stringValue(args.workingDirectory);
     return [
       execReply(exec2, "shellStream", {
-        start: isRecord7(args.requestedSandboxPolicy) ? { sandboxPolicy: args.requestedSandboxPolicy } : {}
+        start: isRecord8(args.requestedSandboxPolicy) ? { sandboxPolicy: args.requestedSandboxPolicy } : {}
       }),
       execReply(exec2, "shellStream", { stderr: { data: shellMessage } }),
       execReply(exec2, "shellStream", { exit: { code: 1, cwd, aborted: true } }),
@@ -25004,7 +25728,7 @@ function cursorNativeExecPolicyReplies(exec2, clientTools) {
       { execClientControlMessage: { streamClose: { id: numberValue(exec2.id) } } }
     ];
   }
-  if (isRecord7(exec2.backgroundShellSpawnArgs)) {
+  if (isRecord8(exec2.backgroundShellSpawnArgs)) {
     const args = exec2.backgroundShellSpawnArgs;
     return [execReply(exec2, "backgroundShellSpawnResult", {
       error: {
@@ -25014,15 +25738,15 @@ function cursorNativeExecPolicyReplies(exec2, clientTools) {
       }
     })];
   }
-  if (isRecord7(exec2.writeShellStdinArgs)) {
+  if (isRecord8(exec2.writeShellStdinArgs)) {
     return [execReply(exec2, "writeShellStdinResult", { error: { error: shellMessage } })];
   }
-  if (isRecord7(exec2.fetchArgs)) {
+  if (isRecord8(exec2.fetchArgs)) {
     return [execReply(exec2, "fetchResult", {
       error: { url: stringValue(exec2.fetchArgs.url), error: networkMessage }
     })];
   }
-  if (isRecord7(exec2.diagnosticsArgs)) {
+  if (isRecord8(exec2.diagnosticsArgs)) {
     return [execReply(exec2, "diagnosticsResult", {
       error: {
         path: stringValue(exec2.diagnosticsArgs.path),
@@ -25030,12 +25754,12 @@ function cursorNativeExecPolicyReplies(exec2, clientTools) {
       }
     })];
   }
-  if (isRecord7(exec2.listMcpResourcesExecArgs)) {
+  if (isRecord8(exec2.listMcpResourcesExecArgs)) {
     return [execReply(exec2, "listMcpResourcesExecResult", {
       error: { error: retryMessage(clientTools, ["ListMcpResources", "list_mcp_resources"]) }
     })];
   }
-  if (isRecord7(exec2.readMcpResourceExecArgs)) {
+  if (isRecord8(exec2.readMcpResourceExecArgs)) {
     return [execReply(exec2, "readMcpResourceExecResult", {
       error: {
         uri: stringValue(exec2.readMcpResourceExecArgs.uri),
@@ -25043,12 +25767,12 @@ function cursorNativeExecPolicyReplies(exec2, clientTools) {
       }
     })];
   }
-  if (isRecord7(exec2.recordScreenArgs)) {
+  if (isRecord8(exec2.recordScreenArgs)) {
     return [execReply(exec2, "recordScreenResult", {
       failure: { error: retryMessage(clientTools, ["record_screen", "computer_use"]) }
     })];
   }
-  if (isRecord7(exec2.computerUseArgs)) {
+  if (isRecord8(exec2.computerUseArgs)) {
     return [execReply(exec2, "computerUseResult", {
       error: {
         error: retryMessage(clientTools, ["computer_use"]),
@@ -25058,7 +25782,7 @@ function cursorNativeExecPolicyReplies(exec2, clientTools) {
       }
     })];
   }
-  if (isRecord7(exec2.mcpArgs)) {
+  if (isRecord8(exec2.mcpArgs)) {
     return [execReply(exec2, "mcpResult", {
       error: { error: retryMessage(clientTools, []) }
     })];
@@ -25130,7 +25854,7 @@ function numberValue(value) {
 function stringValue(value) {
   return typeof value === "string" ? value : "";
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var EXECUTE_HOOK_FIELD_NUMBER = 27;
@@ -25282,14 +26006,14 @@ function isCursorNativeRedirectToolName(name) {
 function cursorNativeExecRedirect(exec2, tools, providerIdentifier) {
   const messageId = numberValue2(exec2.id ?? 0);
   const execId = stringValue2(exec2.execId) || `redirect-${messageId}`;
-  if (isRecord8(exec2.readArgs)) {
-    const path72 = stringValue2(exec2.readArgs.path);
-    if (!path72) return null;
+  if (isRecord9(exec2.readArgs)) {
+    const path82 = stringValue2(exec2.readArgs.path);
+    if (!path82) 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);
     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, path72) })).find((candidate) => candidate.args !== null);
+    const mapped = tools.filter((tool) => matchesLeaf(tool, READ_CANDIDATES)).map((tool) => ({ tool, args: readArguments(tool.inputSchemaValue, path82) })).find((candidate) => candidate.args !== null);
     if (!mapped?.args) return null;
     return redirect(
       exec2,
@@ -25301,14 +26025,14 @@ function cursorNativeExecRedirect(exec2, tools, providerIdentifier) {
       "readResult",
       "read-direct",
       mapped.args,
-      { path: path72 }
+      { path: path82 }
     );
   }
-  if (isRecord8(exec2.grepArgs)) {
+  if (isRecord9(exec2.grepArgs)) {
     const grepArgs = exec2.grepArgs;
     const pattern = stringValue2(grepArgs.pattern);
     if (!pattern.trim()) return null;
-    const path72 = stringValue2(grepArgs.path) || ".";
+    const path82 = stringValue2(grepArgs.path) || ".";
     const glob = stringValue2(grepArgs.glob);
     const outputMode = normalizedGrepOutputMode(stringValue2(grepArgs.outputMode));
     if (!outputMode) return null;
@@ -25324,7 +26048,7 @@ function cursorNativeExecRedirect(exec2, tools, providerIdentifier) {
     if (numericOptions.some((value) => typeof value === "number" && value < 0)) return null;
     const mappingInput = {
       pattern,
-      path: path72,
+      path: path82,
       glob,
       outputMode,
       caseInsensitive: grepArgs.caseInsensitive === true,
@@ -25341,7 +26065,7 @@ function cursorNativeExecRedirect(exec2, tools, providerIdentifier) {
     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: path72,
+      path: path82,
       outputMode,
       ...glob ? { glob } : {},
       ...positiveNumber(grepArgs.offset) === void 0 ? {} : { offset: String(positiveNumber(grepArgs.offset)) }
@@ -25378,15 +26102,15 @@ function cursorNativeExecRedirect(exec2, tools, providerIdentifier) {
       nativeArgs
     );
   }
-  if (isRecord8(exec2.shellArgs) || isRecord8(exec2.shellStreamArgs)) {
-    const argsRecord = isRecord8(exec2.shellArgs) ? exec2.shellArgs : exec2.shellStreamArgs;
+  if (isRecord9(exec2.shellArgs) || isRecord9(exec2.shellStreamArgs)) {
+    const argsRecord = isRecord9(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 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 = isRecord8(exec2.shellStreamArgs);
+    const stream = isRecord9(exec2.shellStreamArgs);
     return redirect(
       exec2,
       mapped.tool,
@@ -25476,9 +26200,9 @@ function cursorNativeRedirectErrorReplies(correlation, error51) {
     }
   }
 }
-function readArguments(schema, path72) {
+function readArguments(schema, path82) {
   const pathKey = firstSchemaProperty(schema, ["file_path", "path"]);
-  return pathKey ? { [pathKey]: path72 } : null;
+  return pathKey ? { [pathKey]: path82 } : null;
 }
 function grepArguments(tool, input) {
   const leaf = normalizedLeaf(tool.clientName);
@@ -25639,7 +26363,7 @@ function parseGrepShellReceipt(output, expectedOutputMode) {
       output.slice(CURSOR_GREP_RECEIPT_PREFIX.length).trim(),
       "base64url"
     ).toString("utf8"));
-    if (!isRecord8(decoded)) throw new Error("receipt is not an object");
+    if (!isRecord9(decoded)) throw new Error("receipt is not an object");
     if (decoded.ok === false && typeof decoded.error === "string") {
       return { ok: false, error: decoded.error };
     }
@@ -25652,7 +26376,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) => isRecord8(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) => isRecord9(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"]) {
@@ -25670,7 +26394,7 @@ function parseGrepShellReceipt(output, expectedOutputMode) {
   }
 }
 function buildGrepReceiptSuccess(args, receipt) {
-  const path72 = args.path || ".";
+  const path82 = args.path || ".";
   let result;
   if (receipt.outputMode === "files_with_matches") {
     result = {
@@ -25716,15 +26440,15 @@ function buildGrepReceiptSuccess(args, receipt) {
   }
   return {
     pattern: args.pattern ?? "",
-    path: path72,
+    path: path82,
     outputMode: receipt.outputMode,
-    workspaceResults: { [path72]: result }
+    workspaceResults: { [path82]: 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 path72 = args.path || ".";
+  const path82 = args.path || ".";
   let result;
   if (outputMode === "files_with_matches") {
     result = {
@@ -25787,9 +26511,9 @@ function buildGrepSuccess(args, output) {
   }
   return {
     pattern: args.pattern ?? "",
-    path: path72,
+    path: path82,
     outputMode,
-    workspaceResults: { [path72]: result }
+    workspaceResults: { [path82]: result }
   };
 }
 function parseCallerShellOutput(output, isError) {
@@ -25851,7 +26575,7 @@ function redirect(exec2, tool, providerIdentifier, messageId, execId, execCase,
 }
 function execArgsToolCallId(exec2) {
   for (const value of Object.values(exec2)) {
-    if (!isRecord8(value)) continue;
+    if (!isRecord9(value)) continue;
     const toolCallId = stringValue2(value.toolCallId);
     if (toolCallId) return toolCallId;
   }
@@ -25872,7 +26596,7 @@ function firstSchemaProperty(schema, candidates) {
   return candidates.find((candidate) => schemaHasProperty(schema, candidate));
 }
 function schemaHasProperty(schema, name) {
-  return isRecord8(schema.properties) && Object.prototype.hasOwnProperty.call(schema.properties, name);
+  return isRecord9(schema.properties) && Object.prototype.hasOwnProperty.call(schema.properties, name);
 }
 function execReply2(exec2, resultName, result) {
   return {
@@ -25893,13 +26617,13 @@ function numberOrUndefined(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
 function positiveNumber(value) {
-  const number32 = numberOrUndefined(value);
-  return number32 !== void 0 && number32 > 0 ? number32 : void 0;
+  const number42 = numberOrUndefined(value);
+  return number42 !== void 0 && number42 > 0 ? number42 : void 0;
 }
 function stringValue2(value) {
   return typeof value === "string" ? value : "";
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var cursorAgentDescriptor = [
@@ -26730,18 +27454,18 @@ function decodeCursorServerMessage(payload) {
   const message = fromBinary(AgentServerMessageSchema, payload);
   const unknownExecFields = extractCursorUnknownExecFields(message);
   const json2 = toJson(AgentServerMessageSchema, message);
-  if (!isRecord9(json2)) throw new TypeError("Cursor server frame was not a message object");
+  if (!isRecord10(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 (!isRecord9(message) || !isRecord9(message.message)) return [];
-  if (message.message.case !== "execServerMessage" || !isRecord9(message.message.value)) return [];
+  if (!isRecord10(message) || !isRecord10(message.message)) return [];
+  if (message.message.case !== "execServerMessage" || !isRecord10(message.message.value)) return [];
   const fields = message.message.value.$unknown;
   if (!Array.isArray(fields)) return [];
-  return fields.filter((field) => isRecord9(field) && typeof field.no === "number" && typeof field.wireType === "number" && field.data instanceof Uint8Array);
+  return fields.filter((field) => isRecord10(field) && typeof field.no === "number" && typeof field.wireType === "number" && field.data instanceof Uint8Array);
 }
 function parseConnectEndStreamError(payload) {
   try {
@@ -27036,7 +27760,7 @@ function cursorToolArgumentBytes(argumentsText) {
   } catch {
     return {};
   }
-  if (!isRecord9(parsed)) return {};
+  if (!isRecord10(parsed)) return {};
   return Object.fromEntries(Object.entries(parsed).map(([name, value]) => [
     name,
     Buffer.from(toBinary(ValueSchema, fromJson(ValueSchema, value))).toString("base64")
@@ -28013,7 +28737,7 @@ function createCursorLiveRun(options) {
   let blobFetchBytes = 0;
   let blobFetchMisses = 0;
   let redirectOperationSequence = 0;
-  const usage3 = (segment) => {
+  const usage4 = (segment) => {
     const outputTokens = Math.max(
       segment.contextOutputTokens,
       estimateTokens(segment.outputText, model)
@@ -28059,7 +28783,7 @@ function createCursorLiveRun(options) {
     else if (segment.started) {
       segment.queue.push({
         type: "response.completed",
-        response: { id: segment.responseId, model, usage: usage3(segment) }
+        response: { id: segment.responseId, model, usage: usage4(segment) }
       });
     }
     report("turn.finish", {
@@ -28126,7 +28850,7 @@ function createCursorLiveRun(options) {
         response: {
           id: activeSegment.responseId,
           model,
-          usage: usage3(activeSegment)
+          usage: usage4(activeSegment)
         }
       });
     }
@@ -28316,7 +29040,7 @@ ${argumentsText}`;
   const handleFrame = (frame, replayed = false) => {
     const unknownExecFields = frame[CURSOR_UNKNOWN_EXEC_FIELDS] ?? [];
     lastFrame = describeCursorServerFrame(frame, unknownExecFields);
-    const tokenDetails = isRecord9(frame.conversationCheckpointUpdate) && isRecord9(frame.conversationCheckpointUpdate.tokenDetails) ? frame.conversationCheckpointUpdate.tokenDetails : void 0;
+    const tokenDetails = isRecord10(frame.conversationCheckpointUpdate) && isRecord10(frame.conversationCheckpointUpdate.tokenDetails) ? frame.conversationCheckpointUpdate.tokenDetails : void 0;
     const checkpointContextTokens = positiveTokenCount(tokenDetails?.usedTokens);
     const checkpointContextWindow = positiveTokenCount(tokenDetails?.maxTokens);
     if (!replayed) {
@@ -28329,7 +29053,7 @@ ${argumentsText}`;
         ...checkpointContextWindow === void 0 ? {} : { contextWindow: checkpointContextWindow }
       });
     }
-    if (isRecord9(frame.conversationCheckpointUpdate)) {
+    if (isRecord10(frame.conversationCheckpointUpdate)) {
       if (checkpointContextTokens !== void 0) {
         wireLog("cursor.wire.checkpoint", {
           model: diagnosticModel,
@@ -28352,7 +29076,7 @@ ${argumentsText}`;
       }
       return;
     }
-    if (isRecord9(frame.kvServerMessage)) {
+    if (isRecord10(frame.kvServerMessage)) {
       const kv = kvReply(frame.kvServerMessage, blobs);
       stream.write(encodeCursorClientMessage(kv.message));
       if (kv.fetch) {
@@ -28373,7 +29097,7 @@ ${argumentsText}`;
       });
       return;
     }
-    if (isRecord9(frame.interactionQuery)) {
+    if (isRecord10(frame.interactionQuery)) {
       const reply = cursorInteractionQueryReply(frame.interactionQuery);
       stream.write(encodeCursorClientMessage(reply.message));
       report("client.reply", { model: diagnosticModel, reply: reply.replyKind });
@@ -28389,7 +29113,7 @@ ${argumentsText}`;
       }
       return;
     }
-    if (isRecord9(frame.error)) {
+    if (isRecord10(frame.error)) {
       if (state === "attached") {
         emit({ type: "error", error: cursorError(frame.error) });
         completeRun("server_error");
@@ -28418,8 +29142,8 @@ ${argumentsText}`;
       return;
     }
     if (state !== "attached") return;
-    if (isRecord9(frame.execServerMessage)) {
-      if (isRecord9(frame.execServerMessage.requestContextArgs)) {
+    if (isRecord10(frame.execServerMessage)) {
+      if (isRecord10(frame.execServerMessage.requestContextArgs)) {
         stream.write(encodeCursorClientMessage(cursorRequestContextReply(frame.execServerMessage, tools)));
         report("client.reply", { model: diagnosticModel, reply: "exec.requestContext" });
         return;
@@ -28508,10 +29232,10 @@ ${argumentsText}`;
       }
       return;
     }
-    const update = isRecord9(frame.interactionUpdate) ? frame.interactionUpdate : void 0;
+    const update = isRecord10(frame.interactionUpdate) ? frame.interactionUpdate : void 0;
     if (update === void 0) return;
     if (isSettledToolUpdate(update)) return;
-    if (isRecord9(update.textDelta) && typeof update.textDelta.text === "string") {
+    if (isRecord10(update.textDelta) && typeof update.textDelta.text === "string") {
       activeSegment.outputText += update.textDelta.text;
       emit({
         type: "response.output_text.delta",
@@ -28522,7 +29246,7 @@ ${argumentsText}`;
       });
       return;
     }
-    if (isRecord9(update.thinkingDelta) && typeof update.thinkingDelta.text === "string") {
+    if (isRecord10(update.thinkingDelta) && typeof update.thinkingDelta.text === "string") {
       activeSegment.outputText += update.thinkingDelta.text;
       emit({
         type: "response.reasoning_summary_text.delta",
@@ -28532,12 +29256,12 @@ ${argumentsText}`;
       });
       return;
     }
-    if (isRecord9(update.tokenDelta)) {
+    if (isRecord10(update.tokenDelta)) {
       const tokens = positiveTokenCount(update.tokenDelta.tokens);
       if (tokens !== void 0) activeSegment.contextOutputTokens += tokens;
       return;
     }
-    if (isRecord9(update.toolCallStarted)) {
+    if (isRecord10(update.toolCallStarted)) {
       const wireCall = mcpCallFromToolUpdate(update.toolCallStarted);
       const call = wireCall ? cursorClientMcpCall(wireCall, tools) : null;
       if (call) {
@@ -28547,7 +29271,7 @@ ${argumentsText}`;
       }
       return;
     }
-    if (isRecord9(update.partialToolCall)) {
+    if (isRecord10(update.partialToolCall)) {
       const wireCall = mcpCallFromToolUpdate(update.partialToolCall);
       const call = wireCall ? cursorClientMcpCall(wireCall, tools) : null;
       if (!call) return;
@@ -28558,7 +29282,7 @@ ${argumentsText}`;
       rescheduleToolTurnFinish();
       return;
     }
-    if (isRecord9(update.toolCallCompleted)) {
+    if (isRecord10(update.toolCallCompleted)) {
       const wireCall = mcpCallFromToolUpdate(update.toolCallCompleted);
       const call = wireCall ? cursorClientMcpCall(wireCall, tools) : null;
       if (!call) return;
@@ -28571,7 +29295,7 @@ ${argumentsText}`;
       rescheduleToolTurnFinish();
       return;
     }
-    if (isRecord9(update.turnEnded)) completeRun("turn_ended");
+    if (isRecord10(update.turnEnded)) completeRun("turn_ended");
   };
   const eventsFor = (segment) => (async function* () {
     try {
@@ -28781,34 +29505,34 @@ var CURSOR_INTERACTION_QUERY_CASES = [
 ];
 var CURSOR_KV_CASES = ["getBlobArgs", "setBlobArgs"];
 function describeCursorServerFrame(frame, unknownExecFields = []) {
-  if (isRecord9(frame.interactionUpdate)) {
+  if (isRecord10(frame.interactionUpdate)) {
     return `interactionUpdate.${cursorNestedRecordCase(
       frame.interactionUpdate,
       CURSOR_INTERACTION_UPDATE_CASES
     )}`;
   }
-  if (isRecord9(frame.execServerMessage)) {
+  if (isRecord10(frame.execServerMessage)) {
     const knownCase = cursorNestedRecordCase(frame.execServerMessage, CURSOR_EXEC_CASES);
     return `execServerMessage.${knownCase === "unknown" ? cursorUnknownExecCaseName(unknownExecFields) : knownCase}`;
   }
-  if (isRecord9(frame.interactionQuery)) {
+  if (isRecord10(frame.interactionQuery)) {
     return `interactionQuery.${cursorNestedRecordCase(
       frame.interactionQuery,
       CURSOR_INTERACTION_QUERY_CASES
     )}`;
   }
-  if (isRecord9(frame.kvServerMessage)) {
+  if (isRecord10(frame.kvServerMessage)) {
     return `kvServerMessage.${cursorNestedRecordCase(frame.kvServerMessage, CURSOR_KV_CASES)}`;
   }
-  if (isRecord9(frame.conversationCheckpointUpdate)) return "conversationCheckpointUpdate";
-  if (isRecord9(frame.error)) return "error";
+  if (isRecord10(frame.conversationCheckpointUpdate)) return "conversationCheckpointUpdate";
+  if (isRecord10(frame.error)) return "error";
   return "unknown";
 }
 function isCursorHeartbeatFrame(frame) {
-  return isRecord9(frame.interactionUpdate) && isRecord9(frame.interactionUpdate.heartbeat);
+  return isRecord10(frame.interactionUpdate) && isRecord10(frame.interactionUpdate.heartbeat);
 }
 function cursorNestedRecordCase(value, cases) {
-  return cases.find((candidate) => isRecord9(value[candidate])) ?? "unknown";
+  return cases.find((candidate) => isRecord10(value[candidate])) ?? "unknown";
 }
 function positiveTokenCount(value) {
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) return void 0;
@@ -28820,8 +29544,8 @@ function cursorInteractionQueryReply(query) {
   const response = (result = {}) => ({
     interactionResponse: { id, ...result }
   });
-  if (isRecord9(query.createPlanRequestQuery)) {
-    const args = isRecord9(query.createPlanRequestQuery.args) ? query.createPlanRequestQuery.args : void 0;
+  if (isRecord10(query.createPlanRequestQuery)) {
+    const args = isRecord10(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();
@@ -28837,7 +29561,7 @@ function cursorInteractionQueryReply(query) {
 ` } : {}
     };
   }
-  if (isRecord9(query.askQuestionInteractionQuery)) {
+  if (isRecord10(query.askQuestionInteractionQuery)) {
     return {
       message: response({
         askQuestionInteractionResponse: {
@@ -28847,7 +29571,7 @@ function cursorInteractionQueryReply(query) {
       replyKind: "interaction.askQuestion.rejected"
     };
   }
-  if (isRecord9(query.switchModeRequestQuery)) {
+  if (isRecord10(query.switchModeRequestQuery)) {
     return {
       message: response({
         switchModeRequestResponse: {
@@ -28857,19 +29581,19 @@ function cursorInteractionQueryReply(query) {
       replyKind: "interaction.switchMode.rejected"
     };
   }
-  if (isRecord9(query.webSearchRequestQuery)) {
+  if (isRecord10(query.webSearchRequestQuery)) {
     return {
       message: response({ webSearchRequestResponse: { approved: {} } }),
       replyKind: "interaction.webSearch.approved"
     };
   }
-  if (isRecord9(query.exaSearchRequestQuery)) {
+  if (isRecord10(query.exaSearchRequestQuery)) {
     return {
       message: response({ exaSearchRequestResponse: { approved: {} } }),
       replyKind: "interaction.exaSearch.approved"
     };
   }
-  if (isRecord9(query.exaFetchRequestQuery)) {
+  if (isRecord10(query.exaFetchRequestQuery)) {
     return {
       message: response({ exaFetchRequestResponse: { approved: {} } }),
       replyKind: "interaction.exaFetch.approved"
@@ -28879,7 +29603,7 @@ function cursorInteractionQueryReply(query) {
 }
 function kvReply(kv, blobs) {
   const id = kv.id ?? 0;
-  if (isRecord9(kv.getBlobArgs)) {
+  if (isRecord10(kv.getBlobArgs)) {
     const blobId = typeof kv.getBlobArgs.blobId === "string" ? kv.getBlobArgs.blobId : "";
     const blobData = blobs.get(blobId);
     return {
@@ -28891,7 +29615,7 @@ function kvReply(kv, blobs) {
       }
     };
   }
-  if (isRecord9(kv.setBlobArgs)) {
+  if (isRecord10(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);
@@ -28942,7 +29666,7 @@ function repairCursorArgumentValue(value, schema) {
     return { value: String(value), count: 1 };
   }
   if (Array.isArray(value)) {
-    const itemSchema = isRecord9(schema) ? schema.items : void 0;
+    const itemSchema = isRecord10(schema) ? schema.items : void 0;
     if (itemSchema === void 0) return { value, count: 0 };
     let repairedValues;
     let count2 = 0;
@@ -28955,7 +29679,7 @@ function repairCursorArgumentValue(value, schema) {
     });
     return { value: repairedValues ?? value, count: count2 };
   }
-  if (!isRecord9(value) || !isRecord9(schema) || !isRecord9(schema.properties)) {
+  if (!isRecord10(value) || !isRecord10(schema) || !isRecord10(schema.properties)) {
     return { value, count: 0 };
   }
   let repairedValue;
@@ -28971,12 +29695,12 @@ function repairCursorArgumentValue(value, schema) {
   return { value: repairedValue ?? value, count };
 }
 function cursorSchemaRequiresString(schema) {
-  if (!isRecord9(schema)) return false;
+  if (!isRecord10(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 = isRecord9(value.toolCall) ? value.toolCall : void 0;
+  const toolCall = isRecord10(value.toolCall) ? value.toolCall : void 0;
   const args = toolCall ? mcpArgsFromToolCall(toolCall) : void 0;
   if (!args) return null;
   const publicCallId = stringValue3(value.callId);
@@ -29001,7 +29725,7 @@ var CURSOR_TOOL_UPDATE_CASES = [
 function cursorToolUpdateIdentifiers(update) {
   for (const key of CURSOR_TOOL_UPDATE_CASES) {
     const value = update[key];
-    if (!isRecord9(value)) continue;
+    if (!isRecord10(value)) continue;
     const call = mcpCallFromToolUpdate(value);
     if (!call) return [];
     return [...new Set(
@@ -29011,9 +29735,9 @@ function cursorToolUpdateIdentifiers(update) {
   return void 0;
 }
 function isCursorClientToolFrame(frame, tools, redirectTools) {
-  const update = isRecord9(frame.interactionUpdate) ? frame.interactionUpdate : void 0;
+  const update = isRecord10(frame.interactionUpdate) ? frame.interactionUpdate : void 0;
   if (update !== void 0) return cursorToolUpdateIdentifiers(update) !== void 0;
-  const exec2 = isRecord9(frame.execServerMessage) ? frame.execServerMessage : void 0;
+  const exec2 = isRecord10(frame.execServerMessage) ? frame.execServerMessage : void 0;
   if (exec2 === void 0) return false;
   const wireCall = mcpCallFromExecMessage(exec2);
   const call = wireCall ? cursorClientMcpCall(wireCall, tools) : null;
@@ -29029,16 +29753,16 @@ function isCursorClientToolFrame(frame, tools, redirectTools) {
   ) !== null;
 }
 function isCursorParkedResidueFrame(frame, parked) {
-  const update = isRecord9(frame.interactionUpdate) ? frame.interactionUpdate : void 0;
+  const update = isRecord10(frame.interactionUpdate) ? frame.interactionUpdate : void 0;
   if (update === void 0) return false;
-  if (isRecord9(update.tokenDelta)) return true;
+  if (isRecord10(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 = isRecord9(value.mcpArgs) ? value.mcpArgs : void 0;
+  const args = isRecord10(value.mcpArgs) ? value.mcpArgs : void 0;
   if (!args) return null;
   const toolCallId = stringValue3(args.toolCallId);
   if (!toolCallId) return null;
@@ -29056,14 +29780,14 @@ function mcpCallFromExecMessage(value) {
   };
 }
 function mcpArgsFromToolCall(toolCall) {
-  const direct = isRecord9(toolCall.mcpToolCall) ? toolCall.mcpToolCall : void 0;
-  if (direct && isRecord9(direct.args)) return direct.args;
-  const tool = isRecord9(toolCall.tool) ? toolCall.tool : void 0;
-  const nested = tool && isRecord9(tool.mcpToolCall) ? tool.mcpToolCall : void 0;
-  return nested && isRecord9(nested.args) ? nested.args : void 0;
+  const direct = isRecord10(toolCall.mcpToolCall) ? toolCall.mcpToolCall : void 0;
+  if (direct && isRecord10(direct.args)) return direct.args;
+  const tool = isRecord10(toolCall.tool) ? toolCall.tool : void 0;
+  const nested = tool && isRecord10(tool.mcpToolCall) ? tool.mcpToolCall : void 0;
+  return nested && isRecord10(nested.args) ? nested.args : void 0;
 }
 function cursorMcpArguments(args) {
-  if (!isRecord9(args.args) || Object.keys(args.args).length === 0) return {};
+  if (!isRecord10(args.args) || Object.keys(args.args).length === 0) return {};
   const decoded = {};
   for (const [name, value] of Object.entries(args.args)) {
     if (typeof value !== "string") {
@@ -29138,7 +29862,7 @@ function cursorError(value) {
     message: typeof value.message === "string" ? value.message : "Cursor request failed"
   };
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var DEFAULT_CURSOR_DIAGNOSTIC_MAX_BYTES = 4 * 1024 * 1024;
@@ -29172,7 +29896,7 @@ var CURSOR_DIAGNOSTIC_EVENTS = /* @__PURE__ */ new Set([
   "turn.finish"
 ]);
 function createCursorDiagnosticLog(dir, options = {}) {
-  const logPath = path18__default.join(dir, CURSOR_DIAGNOSTIC_FILE);
+  const logPath = path19__default.join(dir, CURSOR_DIAGNOSTIC_FILE);
   const backupPath = `${logPath}.1`;
   const maxBytes = positiveInteger2(options.maxBytes) ?? DEFAULT_CURSOR_DIAGNOSTIC_MAX_BYTES;
   let initialized = false;
@@ -29230,43 +29954,43 @@ function createCursorDiagnosticLog(dir, options = {}) {
 }
 function serializeCursorDiagnosticEvent(event) {
   if (!CURSOR_DIAGNOSTIC_EVENTS.has(event.event)) return null;
-  const record32 = {
+  const record42 = {
     timestamp: safeString(event.timestamp, 40),
     runId: safeString(event.runId, 64),
     event: event.event,
     elapsedMs: safeNumber(event.elapsedMs)
   };
-  addString(record32, "model", event.model, 128);
-  addString(record32, "wireModel", event.wireModel, 128);
-  addString(record32, "previousWireModel", event.previousWireModel, 128);
+  addString(record42, "model", event.model, 128);
+  addString(record42, "wireModel", event.wireModel, 128);
+  addString(record42, "previousWireModel", event.previousWireModel, 128);
   if (event.requestedEffort && CURSOR_DIAGNOSTIC_EFFORTS.has(event.requestedEffort)) {
-    record32.requestedEffort = event.requestedEffort;
-  }
-  if (event.turn === "prompt" || event.turn === "tool-continuation") record32.turn = event.turn;
-  addNumber(record32, "status", event.status);
-  addString(record32, "frame", event.frame, 128);
-  addString(record32, "reply", event.reply, 128);
-  addNumber(record32, "sequence", event.sequence);
-  addNumber(record32, "count", event.count);
-  addNumber(record32, "frameCount", event.frameCount);
-  addString(record32, "lastFrame", event.lastFrame, 128);
-  addNumber(record32, "toolCount", event.toolCount);
-  addNumber(record32, "argumentRepairCount", event.argumentRepairCount);
-  addNumber(record32, "estimatedInputTokens", event.estimatedInputTokens);
-  addNumber(record32, "contextTokens", event.contextTokens);
-  addNumber(record32, "contextWindow", event.contextWindow);
-  addString(record32, "outcome", event.outcome, 128);
-  addNumber(record32, "operationSequence", event.operationSequence);
-  addString(record32, "adapter", event.adapter, 32);
-  addString(record32, "error", event.error, 128);
-  return `${JSON.stringify(record32)}
+    record42.requestedEffort = event.requestedEffort;
+  }
+  if (event.turn === "prompt" || event.turn === "tool-continuation") record42.turn = event.turn;
+  addNumber(record42, "status", event.status);
+  addString(record42, "frame", event.frame, 128);
+  addString(record42, "reply", event.reply, 128);
+  addNumber(record42, "sequence", event.sequence);
+  addNumber(record42, "count", event.count);
+  addNumber(record42, "frameCount", event.frameCount);
+  addString(record42, "lastFrame", event.lastFrame, 128);
+  addNumber(record42, "toolCount", event.toolCount);
+  addNumber(record42, "argumentRepairCount", event.argumentRepairCount);
+  addNumber(record42, "estimatedInputTokens", event.estimatedInputTokens);
+  addNumber(record42, "contextTokens", event.contextTokens);
+  addNumber(record42, "contextWindow", event.contextWindow);
+  addString(record42, "outcome", event.outcome, 128);
+  addNumber(record42, "operationSequence", event.operationSequence);
+  addString(record42, "adapter", event.adapter, 32);
+  addString(record42, "error", event.error, 128);
+  return `${JSON.stringify(record42)}
 `;
 }
-function addString(record32, key, value, maxLength) {
-  if (value !== void 0) record32[key] = safeString(value, maxLength);
+function addString(record42, key, value, maxLength) {
+  if (value !== void 0) record42[key] = safeString(value, maxLength);
 }
-function addNumber(record32, key, value) {
-  if (value !== void 0) record32[key] = safeNumber(value);
+function addNumber(record42, key, value) {
+  if (value !== void 0) record42[key] = safeNumber(value);
 }
 function safeString(value, maxLength) {
   return value.replace(/[\r\n\t]/g, " ").slice(0, maxLength);
@@ -29316,8 +30040,8 @@ function kimiAnthropicHeaders(requestHeaders, apiKey) {
   return headers;
 }
 function normalizeAiGatewaySettings(value) {
-  if (!isRecord10(value) || value.version !== 1) return { version: 1 };
-  const models = Array.isArray(value.models) ? value.models.filter((entry) => isRecord10(entry) && typeof entry.id === "string" && entry.id.length > 0).flatMap((entry) => {
+  if (!isRecord11(value) || value.version !== 1) return { version: 1 };
+  const models = Array.isArray(value.models) ? value.models.filter((entry) => isRecord11(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) : [];
@@ -29351,7 +30075,7 @@ function sanitizeProviderPriority(value) {
   }
   return cleaned.length > 0 ? cleaned : void 0;
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function resolveAiGatewaySelection(settings2) {
@@ -29391,15 +30115,15 @@ function sortGatewayModelsByProvider(models) {
 function parseAiGatewayUpdate(value) {
   if (value === null) return { ok: true, value: void 0 };
   if (!value || typeof value !== "object" || Array.isArray(value)) return { ok: false };
-  const record32 = value;
-  const extraKeys = Object.keys(record32).filter(
+  const record42 = value;
+  const extraKeys = Object.keys(record42).filter(
     (key) => key !== "models" && key !== "defaultModel" && key !== "providerPriority"
   );
   if (extraKeys.length > 0) return { ok: false };
   const models = [];
-  if (record32.models !== void 0) {
-    if (!Array.isArray(record32.models)) return { ok: false };
-    for (const raw of record32.models) {
+  if (record42.models !== void 0) {
+    if (!Array.isArray(record42.models)) return { ok: false };
+    for (const raw of record42.models) {
       if (!raw || typeof raw !== "object" || Array.isArray(raw)) return { ok: false };
       const entry = raw;
       if (Object.keys(entry).some((key) => key !== "id" && key !== "efforts" && key !== "hostOnly")) {
@@ -29420,11 +30144,11 @@ function parseAiGatewayUpdate(value) {
     }
   }
   let providerPriority;
-  const hasProviderPriority = Object.prototype.hasOwnProperty.call(record32, "providerPriority");
+  const hasProviderPriority = Object.prototype.hasOwnProperty.call(record42, "providerPriority");
   if (hasProviderPriority) {
-    if (!Array.isArray(record32.providerPriority)) return { ok: false };
+    if (!Array.isArray(record42.providerPriority)) return { ok: false };
     providerPriority = [];
-    for (const raw of record32.providerPriority) {
+    for (const raw of record42.providerPriority) {
       if (typeof raw !== "string") return { ok: false };
       if (!GATEWAY_PROVIDERS.includes(raw)) return { ok: false };
       const provider = raw;
@@ -29596,6 +30320,10 @@ async function readCursorSubscriptionToken() {
   const credentials = await resolveCursorCredentials(defaultCredentialDeps);
   return credentials?.accessToken ?? null;
 }
+async function readXaiSubscriptionToken() {
+  const credentials = await resolveXaiCliCredentials(defaultCredentialDeps);
+  return credentials?.accessToken ?? null;
+}
 async function readCodexSubscriptionAuth() {
   const credentials = await resolveCodexCredentials(defaultCredentialDeps);
   if (!credentials?.accountId) return null;
@@ -29693,6 +30421,10 @@ function createAiGatewayRouter(deps) {
       for (const skill of pruned.withheld) withheldSkills.add(skill.name);
       if (pruned.changed) body = { ...body, messages: [...pruned.messages] };
     }
+    if (target2 && target2.provider !== "kimi") {
+      const omitted = omitClaudeWebSearchTools(body);
+      if (omitted.changed) body = omitted.request;
+    }
     let credential = "";
     let chatgptAccountId = "";
     if (target2?.provider === "cursor") {
@@ -29724,6 +30456,13 @@ function createAiGatewayRouter(deps) {
         return true;
       }
       credential = opencodeApiKey;
+    } else if (target2?.provider === "xai") {
+      const xaiToken = await deps.readXaiToken?.();
+      if (!xaiToken) {
+        writeAnthropicError(res, 401, "authentication_error", "No active Grok CLI sign-in was found. Run `grok login` first.");
+        return true;
+      }
+      credential = xaiToken;
     }
     const controller = new AbortController();
     const abort = () => controller.abort(new Error("client disconnected"));
@@ -29760,7 +30499,7 @@ function createAiGatewayRouter(deps) {
         );
         return true;
       }
-      const gateway = deps.gateway ?? (target2.provider === "cursor" ? ownedCursorGateway : target2.provider === "opencode" ? createOpencodeGateway(opencodeGoWire(target2)) : createGatewayFor(target2, chatgptAccountId, deps.originator));
+      const gateway = deps.gateway ?? (target2.provider === "cursor" ? ownedCursorGateway : target2.provider === "opencode" ? createOpencodeGateway(opencodeGoWire(target2)) : target2.provider === "xai" ? new AnthropicMessagesGateway(new XaiResponsesAdapter({ fetch: fetchImpl })) : createGatewayFor(target2, chatgptAccountId, deps.originator));
       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, {
@@ -29866,11 +30605,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 = path18.join(dataDir, AI_GATEWAY_SETTINGS_FILE_NAME);
-  const legacyPath = deps.legacyDir === void 0 ? void 0 : path18.join(deps.legacyDir, AI_GATEWAY_SETTINGS_FILE_NAME);
+  const settingsPath = path19.join(dataDir, AI_GATEWAY_SETTINGS_FILE_NAME);
+  const legacyPath = deps.legacyDir === void 0 ? void 0 : path19.join(deps.legacyDir, AI_GATEWAY_SETTINGS_FILE_NAME);
   const store = createDurableJsonStore({
     filePath: settingsPath,
-    lockDir: path18.join(dataDir, LOCK_DIR_NAME2),
+    lockDir: path19.join(dataDir, LOCK_DIR_NAME2),
     lockOwnerFileName: LOCK_OWNER_FILE_NAME2,
     sanitize: (value) => normalizeAiGatewaySettings(value),
     sensitivity: "sensitive",
@@ -30018,9 +30757,9 @@ 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 cacheDir = path18__default.join(configDir, "cache");
-  const cachePath = path18__default.join(cacheDir, "gateway-models.json");
+  const configDir = env.CLAUDE_CONFIG_DIR && env.CLAUDE_CONFIG_DIR.length > 0 ? env.CLAUDE_CONFIG_DIR : path19__default.join(homeDir, ".claude");
+  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 });
@@ -30309,7 +31048,7 @@ async function resolveLoadout(deps) {
 }
 
 // ../../packages/fleet-admiral/src/ai-gateway/quota-snapshot.ts
-function record3(value) {
+function record4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 var AMOUNT_PATTERN = /^\d{1,15}$/;
@@ -30317,7 +31056,7 @@ var MAX_WINDOW_DURATION_MS2 = 400 * 24 * 36e5;
 var DURATION_BASES = /* @__PURE__ */ new Set(["upstream", "catalog"]);
 var START_BASES = /* @__PURE__ */ new Set(["upstream", "derived"]);
 function toWindowPeriod(value) {
-  const period = record3(value);
+  const period = record4(value);
   if (!period) return void 0;
   const durationMs = period.durationMs;
   const durationBasis = period.durationBasis;
@@ -30334,7 +31073,7 @@ function toWindowPeriod(value) {
   };
 }
 function toWindowAmounts(value) {
-  const amounts = record3(value);
+  const amounts = record4(value);
   if (!amounts) return void 0;
   const used = amounts.used;
   const limit = amounts.limit;
@@ -30343,14 +31082,14 @@ function toWindowAmounts(value) {
   return { used, limit };
 }
 function parseGatewayQuotaSnapshot(value) {
-  const providers = record3(record3(value)?.providers);
+  const providers = record4(record4(value)?.providers);
   if (!providers) return void 0;
   const snapshot = {};
   for (const [id, value2] of Object.entries(providers)) {
-    const provider = record3(value2);
+    const provider = record4(value2);
     if (!provider || typeof provider.status !== "string") continue;
     const windows = Array.isArray(provider.windows) ? provider.windows.flatMap((entry) => {
-      const window = record3(entry);
+      const window = record4(entry);
       if (!window || typeof window.id !== "string" || typeof window.usedPercent !== "number") return [];
       const period = toWindowPeriod(window.period);
       const amounts = toWindowAmounts(window.amounts);
@@ -30418,7 +31157,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);
@@ -30436,13 +31175,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;
     }
@@ -30450,7 +31189,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) {
@@ -30496,7 +31235,6 @@ function createClaudeFamilyCliDefinition(options) {
     async createProfile(profileOptions) {
       const { bin, prefixArgs } = resolveBinary("claude", "CLAUDE_BIN", profileOptions.env);
       const launchPrompt = sanitizeLaunchPrompt(profileOptions.prompt);
-      assertLaunchPromptShimSafe(launchPrompt, prefixArgs);
       const commandLineLimit = resolveLaunchCommandLineLimit(prefixArgs);
       const childEnv = createChildEnv(profileOptions.env, {});
       return {
@@ -30692,9 +31430,9 @@ 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);
-  chmodBestEffort(filePath, FILE_MODE);
+  chmodBestEffort2(filePath, FILE_MODE);
 }
 function removePrivatePath(targetPath, rootBase) {
   const resolvedBase = assertRootBaseSafe(rootBase);
@@ -30722,7 +31460,7 @@ function cleanupPrivateRoot(rootPath, rootBase) {
     throw error51;
   }
 }
-function chmodBestEffort(targetPath, mode) {
+function chmodBestEffort2(targetPath, mode) {
   try {
     chmodSync(targetPath, mode);
   } catch (_error) {
@@ -30739,20 +31477,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 {
@@ -30760,7 +31498,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;
@@ -30779,17 +31517,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()) {
@@ -30801,7 +31539,7 @@ function ensureDirectorySegments(resolvedBase, dirPath) {
     } catch (error51) {
       if (error51 instanceof Error && "code" in error51 && error51.code === "ENOENT") {
         mkdirSync(current, { mode: DIR_MODE });
-        chmodBestEffort(current, DIR_MODE);
+        chmodBestEffort2(current, DIR_MODE);
       } else {
         throw error51;
       }
@@ -30810,11 +31548,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}`);
@@ -30826,13 +31564,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}`);
 }
 
@@ -30852,18 +31590,18 @@ function renderAssetPluginRoot(pluginRoot, bundle, options) {
   options.doctrine ?? resolveDoctrineFromCliId(options.cliId);
   renderEmbeddedSkillAssets(pluginRoot);
   const workflowGuardScriptPath = writeWorkflowGuardScript(pluginRoot);
-  writePrivateJson(path18__default.join(pluginRoot, "hooks", "hooks.json"), claudeHooks(options, workflowGuardScriptPath), pluginRoot);
+  writePrivateJson(path19__default.join(pluginRoot, "hooks", "hooks.json"), claudeHooks(options, workflowGuardScriptPath), pluginRoot);
   renderGatewayAgentAssets(pluginRoot, options);
 }
 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 writeWorkflowGuardScript(pluginRoot) {
   const asset = EMBEDDED_AGENT_CLI_HOOK_ASSETS.find((entry) => entry.relativePath === "workflow-guard.mjs");
   if (!asset) throw new Error("Missing embedded workflow-guard hook asset");
-  const scriptPath = path18__default.join(pluginRoot, "hooks", "workflow-guard.mjs");
+  const scriptPath = path19__default.join(pluginRoot, "hooks", "workflow-guard.mjs");
   writePrivateFile(scriptPath, asset.content, pluginRoot);
   return scriptPath;
 }
@@ -30922,7 +31660,7 @@ function claudeCommandHook(hookExec) {
 }
 function renderEmbeddedSkillAssets(pluginRoot, doctrine) {
   for (const asset of selectSkillAssetsForDoctrine()) {
-    writePrivateFile(path18__default.join(pluginRoot, "skills", asset.relativePath), asset.content, pluginRoot);
+    writePrivateFile(path19__default.join(pluginRoot, "skills", asset.relativePath), asset.content, pluginRoot);
   }
 }
 function selectSkillAssetsForDoctrine(_doctrine) {
@@ -30999,7 +31737,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) {
@@ -31015,17 +31753,17 @@ 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(path18__default.join(stagedPluginRoot, "skills"), stagedPluginRoot);
+        ensurePrivateDir(path19__default.join(stagedPluginRoot, "agents"), stagedPluginRoot);
+        ensurePrivateDir(path19__default.join(stagedPluginRoot, "skills"), stagedPluginRoot);
         renderAssetPluginRoot(stagedPluginRoot, bundle, options);
         break;
     }
@@ -31040,11 +31778,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(path18__default.join(stagedRoot, entry), path18__default.join(marketplaceRoot, entry));
+      renameSync(path19__default.join(stagedRoot, entry), path19__default.join(marketplaceRoot, entry));
     }
   } finally {
     cleanupPrivateRoot(stagedRoot, marketplaceRoot);
@@ -31052,11 +31790,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) {
@@ -31070,11 +31808,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) {
@@ -31096,7 +31834,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}`;
@@ -31127,6 +31865,22 @@ async function injectAgentCliProfile(profile, options) {
   const tempCleanups = [];
   try {
     const systemPromptFile = systemPromptMode === "off" ? void 0 : writeSystemPromptFile(profile.id, options.buildSystemPrompt(), (cleanup2) => tempCleanups.push(cleanup2));
+    let promptArgs = [...profile.promptArgs ?? []];
+    let deliveredViaFile = false;
+    const cmdWrapped = profile.commandLineLimit?.via === "cmd-shim";
+    const windowsLaunch = profile.commandLineLimit !== void 0;
+    const convertPromptToFile = (body) => {
+      promptArgs = [writeLaunchPromptPointer(
+        body,
+        (cleanupFn) => tempCleanups.push(cleanupFn),
+        cmdWrapped
+      )];
+      deliveredViaFile = true;
+    };
+    if (promptArgs.length > 0 && windowsLaunch) {
+      const body = takeLaunchPromptBody(promptArgs);
+      if (launchPromptHasCmdUnsafeChars(body)) convertPromptToFile(body);
+    }
     const plugin = await createAgentCliPlugin({
       cliId: profile.id,
       doctrine,
@@ -31163,26 +31917,39 @@ async function injectAgentCliProfile(profile, options) {
       systemPromptFile
     };
     const injectedArgs = buildAgentCliArgs(capability2.builderId, context);
-    const mergedArgs = mergeAgentCliArgs(profile, capability2.builderId, context, injectedArgs);
+    const mergeArgs = (nextPromptArgs) => mergeAgentCliArgs(
+      { ...profile, promptArgs: nextPromptArgs },
+      capability2.builderId,
+      context,
+      injectedArgs
+    );
+    const argsWithoutPrompt = mergeArgs([]);
+    const checkBudget = () => assertLaunchCommandLineBudget({
+      args: mergeArgs(promptArgs),
+      argsWithoutPrompt,
+      bin: profile.bin,
+      limit: profile.commandLineLimit,
+      promptIsFixedLength: deliveredViaFile
+    });
     try {
-      assertLaunchCommandLineBudget({
-        args: mergedArgs,
-        argsWithoutPrompt: mergeAgentCliArgs(
-          { ...profile, promptArgs: [] },
-          capability2.builderId,
-          context,
-          injectedArgs
-        ),
-        bin: profile.bin,
-        limit: profile.commandLineLimit
-      });
+      checkBudget();
     } catch (error51) {
-      cleanup();
-      throw error51;
+      const canMoveToFile = !deliveredViaFile && windowsLaunch && promptArgs.length === 1 && error51 instanceof LaunchPromptError && error51.code === "prompt_command_line_too_long";
+      if (!canMoveToFile) {
+        cleanup();
+        throw error51;
+      }
+      convertPromptToFile(takeLaunchPromptBody(promptArgs));
+      try {
+        checkBudget();
+      } catch (retryError) {
+        cleanup();
+        throw retryError;
+      }
     }
     return {
       ...profile,
-      args: mergedArgs,
+      args: mergeArgs(promptArgs),
       // 위치 인자는 이미 args 끝에 합쳐졌으므로 비운다. 남겨 두면 하류가 한 번 더 붙일 수 있다.
       promptArgs: [],
       cleanup
@@ -31208,21 +31975,27 @@ function buildAgentCliMcpServerConfigs(endpoints, tokens) {
     };
   });
 }
+function takeLaunchPromptBody(promptArgs) {
+  if (promptArgs.length !== 1) {
+    throw new Error(`Launch prompt file conversion expects a single positional prompt, got ${promptArgs.length}`);
+  }
+  return promptArgs[0];
+}
 function writeSystemPromptFile(cliId, systemPrompt, onCleanup) {
-  const tempDir = mkdtempSync(path18__default.join(os3__default.tmpdir(), `fleet-${cliId}-`));
-  onCleanup(() => rmBestEffort(tempDir));
-  const filePath = path18__default.join(tempDir, "system-prompt.md");
+  const tempDir = mkdtempSync(path19__default.join(os3__default.tmpdir(), `fleet-${cliId}-`));
+  onCleanup(() => rmBestEffort2(tempDir));
+  const filePath = path19__default.join(tempDir, "system-prompt.md");
   writeFileSync(filePath, systemPrompt, { encoding: "utf8", flag: "wx", mode: SYSTEM_PROMPT_FILE_MODE });
-  chmodBestEffort2(filePath, SYSTEM_PROMPT_FILE_MODE);
+  chmodBestEffort3(filePath, SYSTEM_PROMPT_FILE_MODE);
   return filePath;
 }
-function chmodBestEffort2(targetPath, mode) {
+function chmodBestEffort3(targetPath, mode) {
   try {
     chmodSync(targetPath, mode);
   } catch {
   }
 }
-function rmBestEffort(targetPath) {
+function rmBestEffort2(targetPath) {
   try {
     rmSync(targetPath, { force: true, recursive: true });
   } catch {
@@ -32383,18 +33156,18 @@ Always read \`schema/wiki-schema.md\` directly before composing or revising entr
 `;
 async function ensureWorkspaceSchema(paths) {
   await mkdir(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(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) {
@@ -32433,7 +33206,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({
@@ -32465,7 +33238,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") };
 }
@@ -32490,10 +33263,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;
 }
@@ -32501,13 +33274,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) {
@@ -32535,7 +33308,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) {
@@ -32567,7 +33340,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");
@@ -32672,18 +33445,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) {
@@ -32701,10 +33474,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
@@ -32716,7 +33489,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(conflictDir, { recursive: true });
   const meta3 = {
     id: conflictId,
@@ -32736,13 +33509,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,
@@ -32756,7 +33529,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;
     }
@@ -32765,13 +33538,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
   };
 }
@@ -32790,9 +33563,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;
@@ -32956,11 +33729,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(
@@ -32981,19 +33754,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(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,
@@ -33011,7 +33784,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;
@@ -33036,17 +33809,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}`);
@@ -33055,8 +33828,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;
   });
 }
@@ -33080,8 +33853,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);
@@ -33117,7 +33890,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;
@@ -33183,7 +33956,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);
@@ -33226,9 +33999,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(
@@ -33287,17 +34060,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) {
@@ -33313,7 +34086,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");
@@ -33328,8 +34101,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/");
   }
 }
@@ -33345,14 +34118,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 record6 = await createConflict({
+  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,
@@ -33368,14 +34141,14 @@ async function recordPatchConflict(patch, paths, reason, options) {
     now
   }, paths);
   await appendLog(paths, "conflict detected", {
-    conflict_id: record6.meta.id,
+    conflict_id: record7.meta.id,
     patch_id: options?.patchId ?? null,
     raw_source_ref: options?.rawSourceRef ?? null,
     reason,
     target: patch.frontmatter.target,
-    wiki_id: record6.meta.wikiId
+    wiki_id: record7.meta.wikiId
   }, now);
-  return record6.meta.id;
+  return record7.meta.id;
 }
 function parsePatchBodyEntry(content) {
   try {
@@ -33464,11 +34237,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) {
@@ -33500,15 +34273,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, "-");
@@ -33567,36 +34340,36 @@ 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);
   }
   const records = await listWikiRecords(paths);
-  const match = records.find((record6) => record6.entry.id === id);
+  const match = records.find((record7) => record7.entry.id === id);
   return match ? match.entry : null;
 }
 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(path18__default.dirname(absoluteTarget), { recursive: true });
+  await mkdir(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);
@@ -33615,11 +34388,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 {
@@ -33810,8 +34583,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}`);
   }
 }
@@ -33867,7 +34640,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) {
@@ -33880,7 +34653,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;
@@ -34015,8 +34788,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");
@@ -34097,7 +34870,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;
@@ -34107,12 +34880,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";
@@ -34179,7 +34952,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
@@ -34315,7 +35088,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,
@@ -34511,7 +35284,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,
@@ -36053,8 +36826,8 @@ function CreateObject(types, value) {
 }
 function FromUnionKey(types, value) {
   const flattened = Flatten(types);
-  const record6 = TryBuildRecord(flattened, value);
-  return IsSchema(record6) ? record6 : CreateObject(flattened, value);
+  const record7 = TryBuildRecord(flattened, value);
+  return IsSchema(record7) ? record7 : CreateObject(flattened, value);
 }
 
 // ../../node_modules/.pnpm/typebox@1.1.34/node_modules/typebox/build/type/engine/record/from_key.mjs
@@ -39277,13 +40050,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;
@@ -39374,7 +40147,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}`);
   }
 }
@@ -39452,22 +40225,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);
@@ -39476,8 +40249,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(
@@ -39514,7 +40287,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")
       )
     );
   }
@@ -39527,7 +40300,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")
         )
       );
     }
@@ -39584,8 +40357,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);
@@ -39664,7 +40437,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 {
@@ -40051,7 +40824,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;
@@ -40275,7 +41048,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);
@@ -40297,7 +41070,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);
@@ -40317,7 +41090,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
     });
   }
@@ -40491,7 +41264,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);
@@ -40686,7 +41459,7 @@ async function stageIngestPlan(plan, paths) {
     })
   };
   if (plan.kind === "conflict") {
-    const record6 = await createConflict({
+    const record7 = await createConflict({
       reason: plan.conflict.reason,
       target: `wiki/${entry.id}.md`,
       wikiId: entry.id,
@@ -40704,17 +41477,17 @@ async function stageIngestPlan(plan, paths) {
       warnings: plan.warnings
     }, paths);
     await appendLog(paths, "conflict detected", {
-      conflict_id: record6.meta.id,
+      conflict_id: record7.meta.id,
       patch_id: null,
       raw_source_ref: rawSourceRef,
       reason: plan.conflict.reason,
-      target: record6.meta.target,
-      wiki_id: record6.meta.wikiId
+      target: record7.meta.target,
+      wiki_id: record7.meta.wikiId
     });
     return {
       ok: false,
       mode: plan.mode,
-      conflict_id: record6.meta.id,
+      conflict_id: record7.meta.id,
       raw_source_ref: rawSourceRef,
       warnings: plan.warnings
     };
@@ -41170,11 +41943,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)
   };
 }
@@ -41260,11 +42033,11 @@ function applyBodyReplacement(entry, replaceInput) {
 }
 function parseBodyReplace(value) {
   if (value === void 0 || value === null) return void 0;
-  const record6 = value;
+  const record7 = value;
   return {
-    find: String(record6.find ?? ""),
-    replace: String(record6.replace ?? ""),
-    expected_occurrences: typeof record6.expected_occurrences === "number" ? record6.expected_occurrences : void 0
+    find: String(record7.find ?? ""),
+    replace: String(record7.replace ?? ""),
+    expected_occurrences: typeof record7.expected_occurrences === "number" ? record7.expected_occurrences : void 0
   };
 }
 function stringParam(value) {
@@ -41936,7 +42709,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) {
@@ -42018,7 +42791,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}`);
   }
 }
@@ -42587,15 +43360,15 @@ function buildWikiResolveSpec(resolver) {
     ]
   }, resolver);
 }
-function buildWikiToolSpec(config2, usage3, resolver) {
+function buildWikiToolSpec(config2, usage4, resolver) {
   return {
     id: config2.name,
     tag: config2.name,
     title: config2.label,
     description: config2.description,
     promptSnippet: config2.promptSnippet,
-    whenToUse: usage3.whenToUse,
-    whenNotToUse: usage3.whenNotToUse,
+    whenToUse: usage4.whenToUse,
+    whenNotToUse: usage4.whenNotToUse,
     usageGuidelines: config2.promptGuidelines,
     parameters: config2.parameters,
     execute: async (args, ctx) => {
@@ -42624,16 +43397,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);
@@ -42648,7 +43421,7 @@ function resolveLocked(workspace, hooks) {
   if (sourceState !== "content") return createMemoryPaths(destination);
   removeEmptyDirectories(destination);
   const transactionId = randomUUID();
-  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);
@@ -42676,7 +43449,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;
@@ -42708,15 +43481,15 @@ function readMarker(markerPath) {
     throw new Error("Invalid Fleet Wiki migration marker");
   }
   if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid Fleet Wiki migration marker");
-  const record6 = value;
-  if (record6.version !== 1 || record6.outcome !== "copied" || typeof record6.transactionId !== "string" || !/^[0-9a-f-]{36}$/i.test(record6.transactionId) || typeof record6.completedAt !== "string") throw new Error("Invalid Fleet Wiki migration marker");
-  return record6;
+  const record7 = value;
+  if (record7.version !== 1 || record7.outcome !== "copied" || typeof record7.transactionId !== "string" || !/^[0-9a-f-]{36}$/i.test(record7.transactionId) || typeof record7.completedAt !== "string") throw new Error("Invalid Fleet Wiki migration marker");
+  return record7;
 }
 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);
@@ -42736,9 +43509,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;
@@ -42755,8 +43528,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";
@@ -42771,13 +43544,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);
@@ -42787,7 +43560,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;
@@ -42872,18 +43645,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;
   }
@@ -42950,7 +43723,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) {
@@ -42959,7 +43732,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;
@@ -43660,7 +44433,7 @@ function serializeAgentCliPathsWrite(write) {
   return result;
 }
 function normalizeAgentCliPaths(value) {
-  if (!isRecord11(value) || value.version !== 1 || !isRecord11(value.paths)) {
+  if (!isRecord12(value) || value.version !== 1 || !isRecord12(value.paths)) {
     return { version: 1, paths: {} };
   }
   const paths = {};
@@ -43675,7 +44448,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 };
@@ -43717,7 +44490,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;
@@ -43758,10 +44531,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 isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isNodeError(error51) {
@@ -44153,9 +44926,9 @@ function claudeGatewayModelCache(options) {
 
 // ../../packages/core-agent/src/claude/config-dir.ts
 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(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(path19__default.dirname(cachePath), { recursive: true, mode: 448 });
   let disposed = false;
   return {
     path: root,
@@ -44441,7 +45214,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,
@@ -44467,11 +45240,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,
@@ -44586,7 +45359,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 = [];
@@ -44825,7 +45598,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);
@@ -44835,7 +45608,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,
@@ -44852,7 +45625,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,
@@ -45113,7 +45886,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 {
@@ -45543,24 +46316,24 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
     registerCleanup: (cleanup2) => ctx.host.lifecycle.registerCleanup(cleanup2)
   });
   async function handle({ req, res, pathname }) {
-    const path42 = pathname.slice(`${ctx.basePath}/agent`.length) || "/";
-    if (path42 === "/state") {
+    const path43 = pathname.slice(`${ctx.basePath}/agent`.length) || "/";
+    if (path43 === "/state") {
       if (req.method !== "GET") return methodNotAllowed2(res);
       ctx.host.http.writeJson(res, 200, { agentClis: await buildAgentCliLaunchMetadata() });
       return true;
     }
-    if (path42 === "/agent-cli/state") {
+    if (path43 === "/agent-cli/state") {
       if (req.method !== "GET") return methodNotAllowed2(res);
       ctx.host.http.writeJson(res, 200, { clis: await detector.detect() });
       return true;
     }
-    if (path42 === "/agent-cli/diagnostics") {
+    if (path43 === "/agent-cli/diagnostics") {
       if (req.method !== "GET") return methodNotAllowed2(res);
       if (!ctx.host.security.isTerminalAuthorized(req)) return unauthorized(res);
       ctx.host.http.writeJson(res, 200, await buildAgentCliDiagnostics());
       return true;
     }
-    if (path42 === "/agent-cli/path") {
+    if (path43 === "/agent-cli/path") {
       if (req.method !== "PUT") return methodNotAllowed2(res);
       if (!ctx.host.security.isTerminalAuthorized(req)) return unauthorized(res);
       const body = await ctx.host.http.readJsonBody(req);
@@ -45580,15 +46353,15 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
       ctx.host.http.writeJson(res, 200, { ok: true });
       return true;
     }
-    if (path42 === "/events") {
+    if (path43 === "/events") {
       if (req.method !== "GET") return methodNotAllowed2(res);
       writeAgentSessionEvents(req, res, observability);
       return true;
     }
-    if (path42 === "/sessions") return handleSessions(req, res);
-    const sessionMatch = path42.match(/^\/sessions\/([^/]+)(?:\/([^/]+))?$/);
+    if (path43 === "/sessions") return handleSessions(req, res);
+    const sessionMatch = path43.match(/^\/sessions\/([^/]+)(?:\/([^/]+))?$/);
     if (sessionMatch) return handleSessionItem(req, res, decodeURIComponent(sessionMatch[1] ?? ""), sessionMatch[2] ?? "");
-    if (path42 === "/ticket") {
+    if (path43 === "/ticket") {
       if (req.method !== "POST") return methodNotAllowed2(res);
       if (!ctx.host.security.isTerminalAuthorized(req)) {
         ctx.host.http.writeJson(res, 401, { error: "Unauthorized" });
@@ -45737,16 +46510,18 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
     }
     const sessionId = crypto5.randomUUID();
     const session = observability.createPendingTerminalSession({ sessionId, cwd, cliId });
+    const named = launchOptions.prompt === void 0 ? null : observability.autoNameTerminalSession(sessionId, deriveOperationLabel(launchOptions.prompt));
+    const namedSession = named?.session ?? session;
     ctx.host.operations.create({
       id: session.sessionId,
       theaterId,
       type: AGENT_OPERATION_TYPE,
       pluginId: ctx.pluginId,
-      title: session.label ?? path18__default.basename(cwd),
+      title: namedSession.label ?? session.label ?? path19__default.basename(cwd),
       // 공급자는 실행 시점에 한 번 확정되고 이후 어떤 patch도 다시 쓰지 않는다 —
       // toOperationPayload가 지우는 키 목록 밖이라 resume·복원을 지나도 그대로 남는다.
       payload: {
-        ...toOperationPayload(void 0, cwd, session),
+        ...toOperationPayload(void 0, cwd, namedSession),
         [AGENT_LAUNCH_PROVIDER_PAYLOAD_KEY]: agentLaunchProviderFromModel(launchOptions.model),
         // Claude Code의 resume가 launch 좌표를 자체 복원한다고 가정하지 않는다 — 정규화된
         // 최초 선택을 Operation에 남겨 dormant·Console 재시작 뒤에도 같은 인자로 재개한다.
@@ -45772,7 +46547,7 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
       });
       const runtimeSession = pendingRuntimeSessions.get(sessionId);
       pendingRuntimeSessions.delete(sessionId);
-      const created = runtimeSession ? observability.registerTerminalRuntimeSession(runtimeSession) ?? session : observability.updateTerminalSessionStatus(sessionId, "terminal-only") ?? session;
+      const created = runtimeSession ? observability.registerTerminalRuntimeSession(runtimeSession) ?? namedSession : observability.updateTerminalSessionStatus(sessionId, "terminal-only") ?? namedSession;
       observability.notifySessionUpdated(created);
       ctx.host.operations.patch(sessionId, { payload: toOperationPayload(ctx.host.operations.get(sessionId)?.payload, cwd, created, void 0, observability.getDurableOperation(sessionId)?.providerTitle) });
       ctx.host.http.writeJson(res, 200, created);
@@ -45995,7 +46770,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;
@@ -46212,7 +46987,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
     )
   });
@@ -46696,7 +47471,7 @@ var AnalystTools = class {
       id: metadata.id,
       description: metadata.description,
       parameters: metadata.parameters,
-      execute: async (args) => execute(record4(args))
+      execute: async (args) => execute(record5(args))
     };
   }
   events(args) {
@@ -46741,7 +47516,7 @@ var AnalystTools = class {
     return { artifact: { id: artifact.id, title, createdAt: artifact.createdAt } };
   }
 };
-function record4(value) {
+function record5(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function integer2(value) {
@@ -46919,9 +47694,9 @@ var AnalystSession = class {
 };
 function toAnalystEvents(event, toolNames, redact) {
   if (event.type === "stream_event") {
-    const inner = record5(event.event);
+    const inner = record6(event.event);
     if (inner.type !== "content_block_delta") return [];
-    const delta = record5(inner.delta);
+    const delta = record6(inner.delta);
     if (delta.type === "text_delta" && typeof delta.text === "string" && delta.text.length > 0) {
       return [{ type: "chunk", text: redact(delta.text) }];
     }
@@ -46959,10 +47734,10 @@ function toAnalystEvents(event, toolNames, redact) {
   return [];
 }
 function blocks(message) {
-  const content = record5(message).content;
-  return Array.isArray(content) ? content.map(record5) : [];
+  const content = record6(message).content;
+  return Array.isArray(content) ? content.map(record6) : [];
 }
-function record5(value) {
+function record6(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function errorMessage2(error51) {
@@ -47166,7 +47941,7 @@ function analysisError(code, message) {
   return { error: { code, message } };
 }
 function isAnalysisSelection(catalog, value) {
-  if (!isRecord12(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 (!isRecord13(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);
@@ -47175,9 +47950,9 @@ function isAnalysisSelection(catalog, value) {
   return typeof value.effort === "string" && value.effort.length > 0 && model.effortLevels.includes(value.effort);
 }
 function isMessageBody(value) {
-  return isRecord12(value) && hasExactKeys(value, ["text"]) && typeof value.text === "string" && value.text.trim().length > 0;
+  return isRecord13(value) && hasExactKeys(value, ["text"]) && typeof value.text === "string" && value.text.trim().length > 0;
 }
-function isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasExactKeys(value, keys) {
@@ -47210,14 +47985,14 @@ function registerAnalysisRoutes(ctx, deps = {}) {
       writeError(ctx, res, 403, ANALYSIS_ERROR_CODES.catalogInvalid, "Analysis request is not accepted by this host.");
       return true;
     }
-    const path42 = pathname.slice(`${ctx.basePath}/analysis`.length) || "/";
-    if (path42 === "/catalog") return handleCatalog(ctx, req, res, catalog);
-    if (path42 === "/stream") return handleGlobalStream(ctx, req, res, registry3);
-    const artifactMatch = path42.match(/^\/artifacts\/([^/]+)$/);
+    const path43 = pathname.slice(`${ctx.basePath}/analysis`.length) || "/";
+    if (path43 === "/catalog") return handleCatalog(ctx, req, res, catalog);
+    if (path43 === "/stream") return handleGlobalStream(ctx, req, res, registry3);
+    const artifactMatch = path43.match(/^\/artifacts\/([^/]+)$/);
     if (artifactMatch) return handleArtifact(ctx, req, res, decodeURIComponent(artifactMatch[1] ?? ""), registry3);
-    const clearArtifactsMatch = path42.match(/^\/([^/]+)\/artifacts$/);
+    const clearArtifactsMatch = path43.match(/^\/([^/]+)\/artifacts$/);
     if (clearArtifactsMatch) return handleClearArtifacts(ctx, req, res, decodeURIComponent(clearArtifactsMatch[1] ?? ""), registry3);
-    const match = path42.match(/^\/([^/]+)\/(ready|start|message|stream|stop)$/);
+    const match = path43.match(/^\/([^/]+)\/(ready|start|message|stream|stop)$/);
     if (!match) return false;
     const operationId = decodeURIComponent(match[1] ?? "");
     const action = match[2] ?? "";
@@ -47667,14 +48442,14 @@ async function handleStop(ctx, req, res, operationId, registry3) {
 }
 async function resolveTranscriptPath(capturePath, operationCreatedAt) {
   if (await fileExists2(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;
@@ -47724,7 +48499,7 @@ 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"
   ));
@@ -47734,6 +48509,7 @@ function registerAiGatewayRoutes(ctx, deps = {}) {
     // 자격증명 조달은 호스트 결정이다 — Console은 core-ai-gateway가 export한 기본 reader를 주입한다.
     readAuth: deps.readAuth ?? (() => readCodexSubscriptionAuth()),
     readCursorToken: deps.readCursorToken ?? (() => readCursorSubscriptionToken()),
+    readXaiToken: deps.readXaiToken ?? (() => readXaiSubscriptionToken()),
     readModelOverride: () => process.env[AI_GATEWAY_MODEL_ENV],
     cursorDiagnostics: deps.cursorDiagnostics ?? ownedDiagnostics?.write
   });
@@ -47863,8 +48639,8 @@ function registerTerminalModelAuthRoutes(ctx, deps) {
 }
 function createTerminalModelAuthRouter(ctx, deps) {
   return async function handleTerminalModelAuthRoute({ req, res, pathname }) {
-    const path42 = pathname.slice(`${ctx.basePath}/model-auth`.length) || "/";
-    if (path42 === "/state") {
+    const path43 = pathname.slice(`${ctx.basePath}/model-auth`.length) || "/";
+    if (path43 === "/state") {
       if (req.method !== "GET") {
         ctx.host.http.writeJson(res, 405, { error: "Method not allowed" });
         return true;
@@ -47872,7 +48648,7 @@ function createTerminalModelAuthRouter(ctx, deps) {
       ctx.host.http.writeJson(res, 200, await buildModelAuthState(deps.authService));
       return true;
     }
-    const providerId = parseProviderPath(path42);
+    const providerId = parseProviderPath(path43);
     if (!providerId) return false;
     if (!isTerminalModelAuthProviderId(providerId)) {
       ctx.host.http.writeJson(res, 404, { error: "provider_not_found" });
@@ -47940,8 +48716,8 @@ async function findProvider(deps, providerId) {
   const state = await buildModelAuthState(deps.authService);
   return state.providers.find((provider) => provider.provider === providerId) ?? null;
 }
-function parseProviderPath(path42) {
-  const parts = path42.split("/").filter(Boolean);
+function parseProviderPath(path43) {
+  const parts = path43.split("/").filter(Boolean);
   if (parts.length !== 2 || parts[0] !== "providers") return null;
   try {
     return decodeURIComponent(parts[1] ?? "");
@@ -48076,7 +48852,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);
 }