@dotobokuri/fleet-console 1.8.0 → 1.9.0

package/dist/cli-bin.mjs

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-import { execFile, spawn, spawnSync, execSync } from 'child_process';
+import { execFile, spawn, spawnSync, execFileSync, execSync } from 'child_process';
 import * as fs7 from 'fs';
-import fs7__default, { readFileSync, existsSync, mkdtempSync, writeFileSync, mkdirSync, rmSync, chmodSync, renameSync, readdirSync, constants, openSync, closeSync, lstatSync, unlinkSync, realpathSync, statSync, symlinkSync, fstatSync } from 'fs';
-import * as path93 from 'path';
-import path93__default, { join, resolve, relative, dirname } from 'path';
-import process7 from 'process';
+import fs7__default, { readFileSync, existsSync, mkdtempSync, writeFileSync, mkdirSync, realpathSync, rmSync, chmodSync, renameSync, readdirSync, constants, openSync, closeSync, accessSync, lstatSync, unlinkSync, statSync, fstatSync } from 'fs';
+import * as path92 from 'path';
+import path92__default, { join, resolve, relative, dirname } from 'path';
+import process9 from 'process';
 import { fileURLToPath, pathToFileURL } from 'url';
-import crypto4, { createHash, randomUUID, timingSafeEqual } from 'crypto';
+import crypto3, { createHash, randomUUID, timingSafeEqual } from 'crypto';
 import * as os22 from 'os';
 import os22__default from 'os';
 import { EventEmitter } from 'events';
@@ -27,7 +27,7 @@ var LOCK_FILE_MODE = 384;
 function createConsoleLock(deps = {}) {
   const fsImpl = deps.fs ?? fs7__default;
   const now = deps.now ?? Date.now;
-  const randomToken = deps.randomToken ?? (() => crypto4.randomBytes(32).toString("base64url"));
+  const randomToken = deps.randomToken ?? (() => crypto3.randomBytes(32).toString("base64url"));
   const hostname5 = deps.hostname ?? (() => "127.0.0.1");
   function ensureLockDir(dir) {
     fsImpl.mkdirSync(dir, { recursive: true, mode: LOCK_DIR_MODE });
@@ -82,7 +82,7 @@ function createConsoleLock(deps = {}) {
   }
   function assertLockModes(lockFile) {
     if (typeof process.getuid !== "function") return;
-    const dir = path93__default.dirname(lockFile);
+    const dir = path92__default.dirname(lockFile);
     const dirMode = fsImpl.statSync(dir).mode & 511;
     const fileMode = fsImpl.statSync(lockFile).mode & 511;
     if (dirMode !== LOCK_DIR_MODE) {
@@ -124,7 +124,7 @@ function createConsoleLock(deps = {}) {
 }
 var FLEET_DATA_DIR_NAME = ".fleet";
 function getFleetDataDir() {
-  return path93.join(os22.homedir(), FLEET_DATA_DIR_NAME);
+  return path92.join(os22.homedir(), FLEET_DATA_DIR_NAME);
 }
 var SECURE_DIR_MODE = 448;
 var SECURE_FILE_MODE = 384;
@@ -210,7 +210,7 @@ function cleanupTempFiles(dir, prefix, minAgeMs, now) {
     if (!entry.startsWith(prefix)) {
       continue;
     }
-    const tempPath = path93.join(dir, entry);
+    const tempPath = path92.join(dir, entry);
     try {
       const stat5 = fs7.lstatSync(tempPath);
       if (stat5?.isFile() && !stat5.isSymbolicLink() && now - stat5.mtimeMs >= minAgeMs) {
@@ -316,7 +316,7 @@ function writeLockOwner(lockDir, ownerFileName, startedAt) {
     hostname: os22.hostname(),
     startedAt
   };
-  const ownerPath = path93.join(lockDir, ownerFileName);
+  const ownerPath = path92.join(lockDir, ownerFileName);
   try {
     fs7.writeFileSync(ownerPath, JSON.stringify(owner), { encoding: "utf-8", mode: 384 });
   } catch (error51) {
@@ -325,7 +325,7 @@ function writeLockOwner(lockDir, ownerFileName, startedAt) {
   }
 }
 function readLockOwner(lockDir, ownerFileName) {
-  const ownerPath = path93.join(lockDir, ownerFileName);
+  const ownerPath = path92.join(lockDir, ownerFileName);
   try {
     return sanitizeLockOwner(JSON.parse(fs7.readFileSync(ownerPath, "utf-8")));
   } catch (error51) {
@@ -1144,10 +1144,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path35) {
-  if (!path35)
+function getElementAtPath(obj, path36) {
+  if (!path36)
     return obj;
-  return path35.reduce((acc, key) => acc?.[key], obj);
+  return path36.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1556,11 +1556,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path35, issues) {
+function prefixIssues(path36, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path35);
+    iss.path.unshift(path36);
     return iss;
   });
 }
@@ -1707,16 +1707,16 @@ function flattenError(error51, mapper = (issue3) => issue3.message) {
 }
 function formatError(error51, mapper = (issue3) => issue3.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path35 = []) => {
+  const processError = (error52, path36 = []) => {
     for (const issue3 of error52.issues) {
       if (issue3.code === "invalid_union" && issue3.errors.length) {
-        issue3.errors.map((issues) => processError({ issues }, [...path35, ...issue3.path]));
+        issue3.errors.map((issues) => processError({ issues }, [...path36, ...issue3.path]));
       } else if (issue3.code === "invalid_key") {
-        processError({ issues: issue3.issues }, [...path35, ...issue3.path]);
+        processError({ issues: issue3.issues }, [...path36, ...issue3.path]);
       } else if (issue3.code === "invalid_element") {
-        processError({ issues: issue3.issues }, [...path35, ...issue3.path]);
+        processError({ issues: issue3.issues }, [...path36, ...issue3.path]);
       } else {
-        const fullpath = [...path35, ...issue3.path];
+        const fullpath = [...path36, ...issue3.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue3));
         } else {
@@ -1743,17 +1743,17 @@ function formatError(error51, mapper = (issue3) => issue3.message) {
 }
 function treeifyError(error51, mapper = (issue3) => issue3.message) {
   const result = { errors: [] };
-  const processError = (error52, path35 = []) => {
+  const processError = (error52, path36 = []) => {
     var _a3, _b;
     for (const issue3 of error52.issues) {
       if (issue3.code === "invalid_union" && issue3.errors.length) {
-        issue3.errors.map((issues) => processError({ issues }, [...path35, ...issue3.path]));
+        issue3.errors.map((issues) => processError({ issues }, [...path36, ...issue3.path]));
       } else if (issue3.code === "invalid_key") {
-        processError({ issues: issue3.issues }, [...path35, ...issue3.path]);
+        processError({ issues: issue3.issues }, [...path36, ...issue3.path]);
       } else if (issue3.code === "invalid_element") {
-        processError({ issues: issue3.issues }, [...path35, ...issue3.path]);
+        processError({ issues: issue3.issues }, [...path36, ...issue3.path]);
       } else {
-        const fullpath = [...path35, ...issue3.path];
+        const fullpath = [...path36, ...issue3.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue3));
           continue;
@@ -1785,8 +1785,8 @@ function treeifyError(error51, mapper = (issue3) => issue3.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path35 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path35) {
+  const path36 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path36) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14450,13 +14450,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path35 = ref.slice(1).split("/").filter(Boolean);
-  if (path35.length === 0) {
+  const path36 = ref.slice(1).split("/").filter(Boolean);
+  if (path36.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path35[0] === defsKey) {
-    const key = path35[1];
+  if (path36[0] === defsKey) {
+    const key = path36[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -17641,7 +17641,7 @@ var AcpConnection = class extends BaseConnection {
   }
   /** Claude 계열 브릿지인지 여부를 단일 판별 지점으로 유지합니다. */
   isClaudeBackend() {
-    return this.cliType === "claude" || this.cliType === "claude-zai" || this.cliType === "claude-kimi";
+    return this.cliType === "claude" || this.cliType === "claude-zai" || this.cliType === "claude-kimi" || this.cliType === "claude-glm";
   }
   /** Claude bridge만 native system prompt append를 지원하므로 이 경로만 사용합니다. */
   getClaudeSystemPrompt(systemPrompt) {
@@ -18140,6 +18140,20 @@ var models_default = {
         opus: "kimi-k2.7-code"
       }
     },
+    "claude-glm": {
+      name: "Claude Code with ZhipuAI GLM",
+      defaultModel: "opus",
+      models: [
+        { modelId: "haiku", name: "GLM-4.5-Air (Haiku slot)", effort: { supported: false } },
+        { modelId: "sonnet", name: "GLM-4.7 (Sonnet slot)", effort: { supported: false } },
+        { modelId: "opus", name: "GLM-5.1 (Opus slot)", effort: { supported: false } }
+      ],
+      modelsMapping: {
+        haiku: "glm-4.5-air",
+        sonnet: "glm-4.7",
+        opus: "glm-5.1"
+      }
+    },
     codex: {
       name: "OpenAI Codex CLI",
       defaultModel: "gpt-5.4",
@@ -18386,6 +18400,32 @@ var CLI_BACKENDS = {
       API_TIMEOUT_MS: "3000000"
     }
   },
+  "claude-glm": {
+    id: "claude-glm",
+    cliCommand: "claude",
+    protocol: "acp",
+    authRequired: true,
+    npxPackage: "@agentclientprotocol/claude-agent-acp@0.33.1",
+    modes: [
+      { id: "default", label: "Default" },
+      { id: "plan", label: "Plan" },
+      { id: "bypassPermissions", label: "YOLO" }
+    ],
+    supportsSessionClose: true,
+    supportsSessionLoad: true,
+    requiresModelAtSpawn: false,
+    usesNpxBridge: true,
+    defaultMaxTokens: 16384,
+    defaultEnv: {
+      ANTHROPIC_BASE_URL: "https://open.bigmodel.cn/api/anthropic",
+      // ZhipuAI Claude Code 권장 슬롯 매핑 — 직접 launch(Native PTY) 경로에서도
+      // haiku/sonnet/opus 별칭이 GLM 모델로 해석되도록 env로 고정한다.
+      ANTHROPIC_DEFAULT_HAIKU_MODEL: "glm-4.5-air",
+      ANTHROPIC_DEFAULT_SONNET_MODEL: "glm-4.7",
+      ANTHROPIC_DEFAULT_OPUS_MODEL: "glm-5.1",
+      API_TIMEOUT_MS: "3000000"
+    }
+  },
   codex: {
     id: "codex",
     cliCommand: "codex",
@@ -18482,6 +18522,7 @@ function getYoloModeId(cli) {
     case "claude":
     case "claude-zai":
     case "claude-kimi":
+    case "claude-glm":
       return "bypassPermissions";
     case "opencode-go":
       return "build";
@@ -19717,12 +19758,12 @@ var CodexAppServerConnection = class extends BaseConnection {
     });
   }
   findRolloutPathForThreadId(threadId) {
-    const codexHome = this.codexHome ?? this.env.CODEX_HOME ?? path93.join(this.env.HOME ?? "", ".codex");
+    const codexHome = this.codexHome ?? this.env.CODEX_HOME ?? path92.join(this.env.HOME ?? "", ".codex");
     if (!codexHome) {
       return null;
     }
     for (const rootName of ["sessions", "archived_sessions"]) {
-      const found = findRolloutPath(path93.join(codexHome, rootName), threadId);
+      const found = findRolloutPath(path92.join(codexHome, rootName), threadId);
       if (found) {
         return found;
       }
@@ -19826,7 +19867,7 @@ function findRolloutPath(root, threadId) {
     return null;
   }
   for (const entry of fs7.readdirSync(root, { withFileTypes: true })) {
-    const entryPath = path93.join(root, entry.name);
+    const entryPath = path92.join(root, entry.name);
     if (entry.isDirectory()) {
       const found = findRolloutPath(entryPath, threadId);
       if (found) {
@@ -21220,6 +21261,7 @@ var UnifiedAgent = {
       case "claude":
       case "claude-zai":
       case "claude-kimi":
+      case "claude-glm":
         return new UnifiedClaudeAgentClient(cli);
       case "codex":
         return new UnifiedCodexAgentClient();
@@ -21238,7 +21280,7 @@ var UnifiedAgent = {
     }
     const preferred = await new CliDetector().getPreferred();
     if (!preferred) {
-      throw new Error("\uC0AC\uC6A9 \uAC00\uB2A5\uD55C CLI\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. claude, claude-zai, claude-kimi, codex, opencode-go, cursor \uC911 \uD558\uB098\uB97C \uC124\uCE58\uD574\uC8FC\uC138\uC694.");
+      throw new Error("\uC0AC\uC6A9 \uAC00\uB2A5\uD55C CLI\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. claude, claude-zai, claude-kimi, claude-glm, codex, opencode-go, cursor \uC911 \uD558\uB098\uB97C \uC124\uCE58\uD574\uC8FC\uC138\uC694.");
     }
     return this.createClient(preferred.cli);
   },
@@ -21251,6 +21293,8 @@ var UnifiedAgent = {
     return client;
   }
 };
+
+// ../../packages/fleet-infra/dist/chunk-35EEE5KI.js
 function readAuthStoreFile(filePath) {
   let fd;
   try {
@@ -21270,7 +21314,7 @@ function readAuthStoreFile(filePath) {
     }
   }
 }
-var DEFAULT_AUTH_PATH = path93.join(getFleetDataDir(), "auth.json");
+var DEFAULT_AUTH_PATH = path92.join(getFleetDataDir(), "auth.json");
 var AUTH_LOCK_OWNER_FILE_NAME = "owner.json";
 var AUTH_LOCK_TIMEOUT_MS = 5e3;
 function createAuthService(deps = {}) {
@@ -21326,7 +21370,7 @@ function createAuthService(deps = {}) {
       }
     },
     async setApiKey(providerId, key) {
-      const dir = path93.dirname(authPath);
+      const dir = path92.dirname(authPath);
       ensureSafeDirectory(dir);
       withAuthLock(authPath, lockDir, () => {
         const data = fs7.existsSync(authPath) ? readAuthStoreFile(authPath) : {};
@@ -21379,72 +21423,6 @@ function formatAuthValidationFailureMessage(input) {
   }
   return `Auth token validation failed (providerId: '${input.providerId}'). Check the token and try again.${detail}`;
 }
-var LEGACY_AUTH_PATH = path93.join(getFleetDataDir(), "agent", "auth.json");
-var CURRENT_AUTH_PATH = path93.join(getFleetDataDir(), "auth.json");
-function mergeAuthStoresNoOverwrite(legacy, current) {
-  const data = { ...current };
-  const migratedProviderIds = [];
-  const skippedProviderIds = [];
-  for (const [providerId, entry] of Object.entries(legacy)) {
-    if (Object.prototype.hasOwnProperty.call(data, providerId)) {
-      skippedProviderIds.push(providerId);
-      continue;
-    }
-    data[providerId] = entry;
-    migratedProviderIds.push(providerId);
-  }
-  return {
-    data,
-    migratedProviderIds,
-    skippedProviderIds
-  };
-}
-async function migrateLegacyAuthStore(options = {}) {
-  const legacyPath = options.legacyPath ?? LEGACY_AUTH_PATH;
-  const currentPath = options.currentPath ?? CURRENT_AUTH_PATH;
-  if (!fs7.existsSync(legacyPath)) {
-    return createMigrationResult({
-      legacyPath,
-      currentPath,
-      status: "legacy-missing",
-      migratedProviderIds: [],
-      skippedProviderIds: [],
-      shouldPrintNotice: false
-    });
-  }
-  const legacy = readAuthStoreFile(legacyPath);
-  const current = fs7.existsSync(currentPath) ? readAuthStoreFile(currentPath) : {};
-  const merged = mergeAuthStoresNoOverwrite(legacy, current);
-  if (merged.migratedProviderIds.length > 0) {
-    const dir = path93.dirname(currentPath);
-    ensureSafeDirectory(dir);
-    writeAtomicSync(currentPath, `${JSON.stringify(merged.data, null, 2)}
-`, {
-      mode: SECURE_FILE_MODE,
-      fsync: true
-    });
-  }
-  return createMigrationResult({
-    legacyPath,
-    currentPath,
-    status: merged.migratedProviderIds.length > 0 ? "migrated" : "unchanged",
-    migratedProviderIds: merged.migratedProviderIds,
-    skippedProviderIds: merged.skippedProviderIds,
-    shouldPrintNotice: options.notify !== false && merged.migratedProviderIds.length > 0
-  });
-}
-function createMigrationResult(input) {
-  return {
-    legacyPath: input.legacyPath,
-    currentPath: input.currentPath,
-    migratedCount: input.migratedProviderIds.length,
-    skippedCount: input.skippedProviderIds.length,
-    migratedProviderIds: input.migratedProviderIds,
-    skippedProviderIds: input.skippedProviderIds,
-    shouldPrintNotice: input.shouldPrintNotice,
-    status: input.status
-  };
-}
 var DEFAULT_AUTH_VALIDATION_TIMEOUT_MS = 5e3;
 async function validateAnthropicCompatibleApiKey(request) {
   const controller = new AbortController();
@@ -21517,8 +21495,14 @@ function buildMessagesUrl(baseUrl) {
 function isAbortError(error51) {
   return error51 instanceof DOMException && error51.name === "AbortError";
 }
+var CLI_TO_AUTH_PROVIDER_ID = {
+  "claude-zai": "Claude Code with Z.AI GLM",
+  "claude-kimi": "Claude Code with Moonshot Kimi",
+  "claude-glm": "Claude Code with ZhipuAI GLM"
+};
 var CLAUDE_ZAI_PROVIDER_ID = "Claude Code with Z.AI GLM";
 var CLAUDE_KIMI_PROVIDER_ID = "Claude Code with Moonshot Kimi";
+var CLAUDE_GLM_PROVIDER_ID = "Claude Code with ZhipuAI GLM";
 var AUTH_PROVIDER_DEFINITIONS = {
   "claude-zai": {
     providerId: CLAUDE_ZAI_PROVIDER_ID,
@@ -21529,12 +21513,16 @@ var AUTH_PROVIDER_DEFINITIONS = {
     providerId: CLAUDE_KIMI_PROVIDER_ID,
     baseUrl: CLI_BACKENDS["claude-kimi"].defaultEnv.ANTHROPIC_BASE_URL,
     env: CLI_BACKENDS["claude-kimi"].defaultEnv
+  },
+  "claude-glm": {
+    providerId: CLAUDE_GLM_PROVIDER_ID,
+    baseUrl: CLI_BACKENDS["claude-glm"].defaultEnv.ANTHROPIC_BASE_URL,
+    env: CLI_BACKENDS["claude-glm"].defaultEnv
   }
 };
 async function resolveAuthEnv(cli, deps) {
   const provider = AUTH_PROVIDER_DEFINITIONS[cli];
   if (!provider) return {};
-  await migrateLegacyAuthStore();
   const auth = deps?.authService ?? createAuthService({ authPath: DEFAULT_AUTH_PATH });
   const token = await auth.getApiKey(provider.providerId);
   if (!token) {
@@ -21555,13 +21543,32 @@ async function resolveAuthEnv(cli, deps) {
   }
   return { ...provider.env, ANTHROPIC_AUTH_TOKEN: token };
 }
+async function validateAuthKeyForCli(cli, apiKey) {
+  const provider = AUTH_PROVIDER_DEFINITIONS[cli];
+  if (!provider) {
+    return { providerId: cli, status: "success" };
+  }
+  const validation = await validateAnthropicCompatibleApiKey({
+    providerId: provider.providerId,
+    apiKey,
+    baseUrl: provider.baseUrl
+  });
+  if (isAuthValidationSuccess(validation)) {
+    return { providerId: validation.providerId, status: "success" };
+  }
+  return {
+    providerId: validation.providerId,
+    status: validation.status,
+    detail: validation.detail
+  };
+}
 var DEFAULT_TEMP_FILE_MIN_AGE_MS = 6e4;
 function createDurableJsonStore(deps) {
   const now = deps.now ?? (() => Date.now());
   const sensitivity = deps.sensitivity;
   const mode = sensitivity === "sensitive" ? SECURE_FILE_MODE : 420;
   const minAgeMs = deps.tempCleanupMinAgeMs ?? DEFAULT_TEMP_FILE_MIN_AGE_MS;
-  const dir = path93.dirname(deps.filePath);
+  const dir = path92.dirname(deps.filePath);
   return {
     path: deps.filePath,
     load() {
@@ -21645,8 +21652,8 @@ var LOCK_OWNER_FILE_NAME = "owner";
 var TEMP_FILE_PREFIX = `.tmp-${GLOBAL_OPTIONS_FILE_NAME}-`;
 function createGlobalOptionsStore(deps = {}) {
   const dataDir = deps.dataDir ?? getFleetDataDir();
-  const optionsPath = path93.join(dataDir, GLOBAL_OPTIONS_FILE_NAME);
-  const lockDir = path93.join(dataDir, LOCK_DIR_NAME);
+  const optionsPath = path92.join(dataDir, GLOBAL_OPTIONS_FILE_NAME);
+  const lockDir = path92.join(dataDir, LOCK_DIR_NAME);
   const store2 = createDurableJsonStore({
     filePath: optionsPath,
     lockDir,
@@ -21717,7 +21724,7 @@ function readFleetConsoleRelease() {
   const requireFromHere = createRequire(import.meta.url);
   const packageJsonPath = requireFromHere.resolve("../package.json");
   const pkg = requireFromHere(packageJsonPath);
-  const packageRoot = path93__default.dirname(packageJsonPath);
+  const packageRoot = path92__default.dirname(packageJsonPath);
   const version2 = pkg.version ?? "";
   if (pkg.private === true) {
     return { channel: "local", version: version2, packageRoot };
@@ -21735,14 +21742,14 @@ var CONSOLE_CAPTURES_DIR_NAME = "captures";
 function createConsolePaths(deps = {}) {
   const env = deps.env ?? process.env;
   const base = env.FLEET_CONSOLE_DIR ?? defaultConsoleBaseDir(deps);
-  return { dir: base, lockFile: path93__default.join(base, LOCK_FILE_NAME) };
+  return { dir: base, lockFile: path92__default.join(base, LOCK_FILE_NAME) };
 }
 function createConsoleDataPaths(deps = {}) {
-  const dir = path93__default.join(deps.fleetDataDir ?? getFleetDataDir(), CONSOLE_DATA_DIR_NAME);
+  const dir = defaultConsoleDataBaseDir(deps);
   return {
     dir,
-    stateFile: path93__default.join(dir, CONSOLE_STATE_FILE_NAME),
-    capturesDir: path93__default.join(dir, CONSOLE_CAPTURES_DIR_NAME)
+    stateFile: path92__default.join(dir, CONSOLE_STATE_FILE_NAME),
+    capturesDir: path92__default.join(dir, CONSOLE_CAPTURES_DIR_NAME)
   };
 }
 function defaultConsoleBaseDir(deps) {
@@ -21750,26 +21757,93 @@ function defaultConsoleBaseDir(deps) {
   const channel = deps.channel ?? (release = readFleetConsoleRelease()).channel;
   if (channel === "local") {
     const packageRoot = deps.packageRoot ?? (release ??= readFleetConsoleRelease()).packageRoot;
-    return path93__default.join(path93__default.resolve(packageRoot, "..", ".."), ".fleet", CONSOLE_RUNTIME_DIR_NAME);
+    return localConsoleDir(packageRoot);
   }
   const uid = deps.uid ?? (typeof process.getuid === "function" ? process.getuid() : 0);
-  return path93__default.join(os22__default.tmpdir(), `${LOCK_DIR_NAME2}-${uid}-${channel}`);
+  return path92__default.join(os22__default.tmpdir(), `${LOCK_DIR_NAME2}-${uid}-${channel}`);
+}
+function defaultConsoleDataBaseDir(deps) {
+  if (deps.fleetDataDir !== void 0) {
+    return path92__default.join(deps.fleetDataDir, CONSOLE_DATA_DIR_NAME);
+  }
+  const env = deps.env ?? process.env;
+  if (env.FLEET_CONSOLE_DIR) {
+    return env.FLEET_CONSOLE_DIR;
+  }
+  let release;
+  const channel = deps.channel ?? (release = readFleetConsoleRelease()).channel;
+  if (channel === "local") {
+    const packageRoot = deps.packageRoot ?? (release ??= readFleetConsoleRelease()).packageRoot;
+    return localConsoleDir(packageRoot);
+  }
+  return path92__default.join(getFleetDataDir(), CONSOLE_DATA_DIR_NAME);
+}
+function localConsoleDir(packageRoot) {
+  return path92__default.join(path92__default.resolve(packageRoot, "..", ".."), ".fleet", CONSOLE_RUNTIME_DIR_NAME);
 }
 
 // src/attention-hook.ts
 var ATTENTION_POST_TIMEOUT_MS = 1500;
-async function runAttentionHook(env = process7.env, options = {}) {
+var ATTENTION_STDIN_TIMEOUT_MS = 500;
+var ATTENTION_REASONS = /* @__PURE__ */ new Set([
+  "idle_prompt",
+  "permission_prompt",
+  "auth_success",
+  "elicitation_dialog",
+  "elicitation_complete",
+  "elicitation_response"
+]);
+async function runAttentionHook(env = process9.env, options = {}) {
   try {
     await postAttention(env, options);
   } catch {
   }
 }
+function normalizeAttentionReason(value) {
+  return typeof value === "string" && ATTENTION_REASONS.has(value) ? value : void 0;
+}
+async function readHookReason(options) {
+  const stream = options.stdin ?? process9.stdin;
+  const raw = await readHookStdin(stream, options.stdinTimeoutMs ?? ATTENTION_STDIN_TIMEOUT_MS);
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    return normalizeAttentionReason(parsed?.notification_type);
+  } catch {
+    return void 0;
+  }
+}
+async function readHookStdin(stream, timeoutMs) {
+  return await new Promise((resolve) => {
+    const chunks = [];
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      resolve(value);
+    };
+    const timer = setTimeout(() => finish(""), timeoutMs);
+    if (typeof timer.unref === "function") timer.unref();
+    stream.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    stream.on("end", () => {
+      clearTimeout(timer);
+      finish(Buffer.concat(chunks).toString("utf8"));
+    });
+    stream.on("error", () => {
+      clearTimeout(timer);
+      finish("");
+    });
+  });
+}
 async function postAttention(env, options) {
   const sessionId = env.FLEET_CONSOLE_SESSION_ID;
   if (!sessionId) return;
   const paths = createConsolePaths({ env });
   const lock = createConsoleLock().readLock(paths.lockFile);
   if (!lock) return;
+  const reason = await readHookReason(options);
   const fetchImpl = options.fetchImpl ?? fetch;
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? ATTENTION_POST_TIMEOUT_MS);
@@ -21780,7 +21854,7 @@ async function postAttention(env, options) {
         authorization: `Bearer ${lock.token}`,
         "content-type": "application/json"
       },
-      body: JSON.stringify({}),
+      body: JSON.stringify(reason ? { reason } : {}),
       signal: controller.signal
     });
   } finally {
@@ -21790,17 +21864,20 @@ async function postAttention(env, options) {
 function openBrowser(url2, deps = {}) {
   const platform = deps.platform ?? os22__default.platform();
   const spawnBrowser = deps.spawnBrowser ?? ((command2, args, options) => {
-    spawn(command2, [...args], options).unref();
+    const child = spawn(command2, [...args], options);
+    child.once("error", () => {
+    });
+    child.unref();
   });
   if (platform === "darwin") {
-    spawnBrowser("open", [url2], { detached: true, stdio: "ignore" });
+    spawnBrowser("open", [url2], { detached: true, stdio: "ignore", windowsHide: true });
     return;
   }
   if (platform === "win32") {
-    spawnBrowser("cmd", ["/c", "start", "", url2], { detached: true, stdio: "ignore" });
+    spawnBrowser("cmd", ["/c", "start", "", url2], { detached: true, stdio: "ignore", windowsHide: true });
     return;
   }
-  spawnBrowser("xdg-open", [url2], { detached: true, stdio: "ignore" });
+  spawnBrowser("xdg-open", [url2], { detached: true, stdio: "ignore", windowsHide: true });
 }
 
 // src/health.ts
@@ -21980,7 +22057,7 @@ function specToMcpTool(spec) {
 }
 function installExecutorToolCallRouter(runtime, sessionToken, ctx) {
   runtime.server.setOnToolCallArrived(sessionToken, (toolName, args) => {
-    const toolCallId = crypto4.randomUUID();
+    const toolCallId = crypto3.randomUUID();
     void runtime.registry.invoke(toolName, args, { cwd: ctx.cwd, sessionLabel: ctx.sessionLabel, toolCallId, signal: ctx.signal }).then((result) => runtime.server.resolveNextToolCall(sessionToken, toolCallId, result)).catch((err) => {
       runtime.server.resolveNextToolCall(sessionToken, toolCallId, {
         content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
@@ -22371,7 +22448,7 @@ function createInProcessMcpServer(deps = {}) {
       if (activeStopPromise) await activeStopPromise;
       if (activeServer && activeServerUrl) return activeServerUrl;
       if (activeStartPromise) return activeStartPromise;
-      activeOpaquePath = `/${crypto4.randomUUID()}`;
+      activeOpaquePath = `/${crypto3.randomUUID()}`;
       activeStartPromise = new Promise((resolve, reject) => {
         const srv = http.createServer(handleRequest);
         srv.timeout = MCP_SERVER_TIMEOUT_MS;
@@ -22628,7 +22705,7 @@ function createExecutorMcpSession(deps, toolTimeoutSeconds, request) {
     throw new Error("Executor session cwd is required");
   }
   assertNonEmptyExecutorTools(request.serverName, request.specs);
-  const token = crypto4.randomUUID();
+  const token = crypto3.randomUUID();
   registerExecutorSessionTools(runtime.runtime, token, [...request.specs]);
   installExecutorToolCallRouter(runtime.runtime, token, {
     cwd,
@@ -22674,7 +22751,7 @@ function issueSessionToken(deps, sessionTokensByLabel, request) {
     for (const { name, runtime } of deps.runtimes) {
       const tools = runtime.registry.getAllAgentTools();
       assertNonEmptyExecutorTools(name, tools);
-      const token = crypto4.randomUUID();
+      const token = crypto3.randomUUID();
       registerExecutorSessionTools(runtime, token, tools);
       installExecutorToolCallRouter(runtime, token, { cwd, sessionLabel: label, signal: request.signal });
       tokens.push({ name, token });
@@ -22850,7 +22927,7 @@ function createChildEnv(env, overlay) {
   return child;
 }
 function wrapWindowsShim(resolved, env, platform) {
-  if (platform !== "win32" || !WINDOWS_SHIM_EXTENSIONS.has(path93__default.extname(resolved).toLowerCase())) {
+  if (platform !== "win32" || !WINDOWS_SHIM_EXTENSIONS.has(path92__default.extname(resolved).toLowerCase())) {
     return { bin: resolved, prefixArgs: [] };
   }
   rejectCmdExpansionSensitiveShim(resolved);
@@ -22868,13 +22945,13 @@ function forceWindowsArgQuoting(value) {
   return `${value} `;
 }
 function findOnPath(bin, pathValue, pathExts, platform) {
-  const pathSeparator = platform === "win32" ? WINDOWS_PATH_SEPARATOR : path93__default.delimiter;
-  if (hasPathSeparator(bin, platform) || path93__default.isAbsolute(bin)) {
+  const pathSeparator = platform === "win32" ? WINDOWS_PATH_SEPARATOR : path92__default.delimiter;
+  if (hasPathSeparator(bin, platform) || path92__default.isAbsolute(bin)) {
     return resolveWithExtensions(bin, pathExts, platform);
   }
   for (const entry of pathValue.split(pathSeparator)) {
     const searchDir = entry.length === 0 ? "." : entry;
-    const candidate = resolveWithExtensions(path93__default.join(searchDir, bin), pathExts, platform);
+    const candidate = resolveWithExtensions(path92__default.join(searchDir, bin), pathExts, platform);
     if (candidate) {
       return candidate;
     }
@@ -22882,7 +22959,7 @@ function findOnPath(bin, pathValue, pathExts, platform) {
   return void 0;
 }
 function resolveWithExtensions(candidate, pathExts, platform) {
-  if (platform !== "win32" || path93__default.extname(candidate).length > 0) {
+  if (platform !== "win32" || path92__default.extname(candidate).length > 0) {
     return existsSync(candidate) ? candidate : void 0;
   }
   for (const ext of pathExts) {
@@ -23782,6 +23859,230 @@ function parseNumericPart(value) {
 function compareNumbers(left, right) {
   return left === right ? 0 : left > right ? 1 : -1;
 }
+var DEFAULT_CHANNEL = "latest";
+var PACKAGE_MANAGER_COMMANDS = ["npm", "pnpm"];
+function createGlobalPackageUpdater(deps) {
+  const resolvedDeps = resolveDeps(deps);
+  return {
+    detectPackageManager: () => detectPackageManager(resolvedDeps),
+    update: (options = {}) => updatePackages(resolvedDeps, options),
+    install: (manager, versionOrChannel) => installPackages(resolvedDeps, manager, versionOrChannel),
+    createManualInstallMessage: (channel, reason) => createManualInstallMessage(resolvedDeps, channel, reason),
+    formatInstallCommand: (command2, versionOrChannel) => formatInstallCommand(resolvedDeps.packageNames, command2, versionOrChannel)
+  };
+}
+function resolveDeps(deps) {
+  if (deps.packageNames.length === 0) {
+    throw new Error("packageNames must contain at least one package");
+  }
+  return {
+    packageNames: deps.packageNames,
+    resolveCurrentPackageRoot: deps.resolveCurrentPackageRoot,
+    resolveCurrentVersion: deps.resolveCurrentVersion,
+    resolveLatestVersion: deps.resolveLatestVersion ?? fetchLatestVersion,
+    isVersionGreater: deps.isVersionGreater ?? isVersionGreater,
+    prepareInstall: deps.prepareInstall,
+    finalizeSuccess: deps.finalizeSuccess,
+    report: deps.report,
+    env: deps.env ?? process.env,
+    platform: deps.platform ?? process.platform,
+    resolveBinary: deps.resolveBinary ?? resolvePathBinary,
+    execFile: deps.execFile ?? defaultExecFile,
+    spawnInstall: deps.spawnInstall ?? defaultSpawnInstall,
+    realpath: deps.realpath ?? realpathSync,
+    canWrite: deps.canWrite ?? defaultCanWrite
+  };
+}
+async function updatePackages(deps, options) {
+  const channel = options.channel ?? DEFAULT_CHANNEL;
+  const detection = await detectPackageManager(deps);
+  if (detection.manager === void 0) {
+    return {
+      status: "manual",
+      code: 0,
+      reason: detection.reason,
+      manualMessage: createManualInstallMessage(deps, channel, detection.reason)
+    };
+  }
+  const currentVersion = await deps.resolveCurrentVersion();
+  const latestVersion = await deps.resolveLatestVersion(deps.packageNames[0], channel);
+  if (currentVersion !== void 0 && latestVersion !== void 0 && !deps.isVersionGreater(latestVersion, currentVersion)) {
+    deps.report?.(`Global package is already on the latest version (v${currentVersion}).`);
+    return {
+      status: "current",
+      code: 0,
+      manager: detection.manager,
+      currentVersion,
+      latestVersion
+    };
+  }
+  const versionOrChannel = latestVersion ?? channel;
+  if (latestVersion === void 0) {
+    deps.report?.(`Could not resolve the latest package version; reinstalling ${channel}.`);
+  } else {
+    deps.report?.(`Installing global packages at ${versionOrChannel}.`);
+  }
+  const context = createInstallContext(deps, detection.manager, versionOrChannel);
+  await deps.prepareInstall?.(context);
+  const code = await installPackages(deps, detection.manager, versionOrChannel);
+  if (code === 0) {
+    await deps.finalizeSuccess?.(context);
+    return {
+      status: "installed",
+      code,
+      manager: detection.manager,
+      currentVersion,
+      latestVersion,
+      versionOrChannel
+    };
+  }
+  return {
+    status: "failed",
+    code,
+    manager: detection.manager,
+    currentVersion,
+    latestVersion,
+    versionOrChannel,
+    manualMessage: createManualInstallMessage(deps, channel, void 0)
+  };
+}
+async function detectPackageManager(deps) {
+  const packageRoot = await deps.resolveCurrentPackageRoot();
+  if (packageRoot === void 0) {
+    return { manager: void 0, reason: "local" };
+  }
+  for (const command2 of PACKAGE_MANAGER_COMMANDS) {
+    const detected = detectGlobalRoot(deps, command2, packageRoot);
+    if (detected?.manager !== void 0 || detected?.reason === "permission") {
+      return detected;
+    }
+  }
+  return { manager: void 0, reason: "local" };
+}
+function detectGlobalRoot(deps, command2, packageRoot) {
+  try {
+    const resolved = deps.resolveBinary(command2, deps.env, { platform: deps.platform });
+    if (resolved === void 0) {
+      return void 0;
+    }
+    const globalRoot = deps.execFile(resolved.bin, [...resolved.prefixArgs, "root", "-g"]).trim();
+    const resolvedRoot = normalizePath(deps, deps.realpath(resolvePathForPlatform(deps.platform, globalRoot)));
+    const normalizedPackageRoot = normalizeExistingPath(deps, packageRoot);
+    if (isPathInside(deps, normalizedPackageRoot, resolvedRoot)) {
+      return createManagerDetection(deps, command2, resolvedRoot, resolved);
+    }
+    const expectedPackageDir = joinPathForPlatform(deps.platform, globalRoot, deps.packageNames[0]);
+    try {
+      const resolvedPackageDir = normalizePath(deps, deps.realpath(expectedPackageDir));
+      if (resolvedPackageDir === normalizedPackageRoot) {
+        return createManagerDetection(deps, command2, resolvedRoot, resolved);
+      }
+    } catch {
+    }
+  } catch (error51) {
+    deps.report?.(`Failed to detect global ${command2} install: ${formatError2(error51)}`);
+    return void 0;
+  }
+  return void 0;
+}
+function createManagerDetection(deps, command2, globalRoot, resolved) {
+  if (!deps.canWrite(globalRoot)) {
+    return { manager: void 0, reason: "permission" };
+  }
+  return {
+    manager: {
+      command: command2,
+      globalRoot,
+      resolved
+    },
+    reason: void 0
+  };
+}
+function installPackages(deps, manager, versionOrChannel) {
+  const context = createInstallContext(deps, manager, versionOrChannel);
+  const commandArgs = [...manager.resolved.prefixArgs, "i", "-g", "--force", ...deps.packageNames.map((name) => `${name}@${versionOrChannel}`)];
+  const child = deps.spawnInstall(manager.resolved.bin, commandArgs, { ...context, commandArgs });
+  return new Promise((resolve) => {
+    child.once("error", () => {
+      resolve(1);
+    });
+    child.once("exit", (code, signal) => {
+      if (typeof code === "number") {
+        resolve(code);
+        return;
+      }
+      resolve(signal === null ? 0 : 1);
+    });
+  });
+}
+function createInstallContext(deps, manager, versionOrChannel) {
+  return {
+    manager,
+    versionOrChannel,
+    packageNames: deps.packageNames
+  };
+}
+function createManualInstallMessage(deps, channel, reason) {
+  const reasonLine = reason === "permission" ? "Global package install location is not writable, so no installer was run." : "Global npm or pnpm installation could not be detected, so no installer was run.";
+  const commands = PACKAGE_MANAGER_COMMANDS.map((command2) => formatInstallCommand(deps.packageNames, command2, channel));
+  return [reasonLine, "Run one of these commands manually:", ...commands].join("\n");
+}
+function formatInstallCommand(packageNames, command2, versionOrChannel) {
+  return `${command2} i -g ${packageNames.map((name) => `${name}@${versionOrChannel}`).join(" ")}`;
+}
+function isPathInside(deps, child, parent) {
+  const separator = deps.platform === "win32" ? "\\" : path92__default.sep;
+  return child === parent || child.startsWith(`${parent}${separator}`);
+}
+function normalizeExistingPath(deps, value) {
+  try {
+    return normalizePath(deps, deps.realpath(value));
+  } catch {
+    return normalizePath(deps, value);
+  }
+}
+function normalizePath(deps, value) {
+  const resolved = resolvePathForPlatform(deps.platform, value);
+  return deps.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function resolvePathForPlatform(platform, value) {
+  return platform === "win32" ? path92__default.win32.resolve(value) : path92__default.resolve(value);
+}
+function joinPathForPlatform(platform, ...parts) {
+  return platform === "win32" ? path92__default.win32.join(...parts) : path92__default.join(...parts);
+}
+function defaultExecFile(file2, args) {
+  return execFileSync(file2, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+}
+function defaultSpawnInstall(file2, args) {
+  return spawn(file2, args, { stdio: "inherit" });
+}
+function defaultCanWrite(targetPath) {
+  try {
+    accessSync(targetPath, constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function formatError2(error51) {
+  if (typeof error51 === "object" && error51 !== null) {
+    const stderr = "stderr" in error51 ? error51.stderr : void 0;
+    if (Buffer.isBuffer(stderr)) {
+      const text = stderr.toString("utf8").trim();
+      if (text.length > 0) {
+        return text;
+      }
+    }
+    if (typeof stderr === "string" && stderr.trim().length > 0) {
+      return stderr.trim();
+    }
+  }
+  if (error51 instanceof Error) {
+    return error51.message;
+  }
+  return String(error51);
+}
 
 // ../../node_modules/.pnpm/typebox@1.1.34/node_modules/typebox/build/system/memory/memory.mjs
 var memory_exports = {};
@@ -28247,7 +28548,7 @@ function readRawCarriersOrDefaultStore() {
 }
 function getCarriersFilePath() {
   if (!runtimeState.storeDir) return null;
-  return path93.join(runtimeState.storeDir, FILENAME);
+  return path92.join(runtimeState.storeDir, FILENAME);
 }
 function updateCarriers(mutator) {
   if (!runtimeState.storeDir) return;
@@ -28262,7 +28563,7 @@ function updateCarriers(mutator) {
 function withStoreLock(operation) {
   if (!runtimeState.storeDir) return operation();
   fs7.mkdirSync(runtimeState.storeDir, { recursive: true });
-  const lockDir = path93.join(runtimeState.storeDir, LOCK_DIRNAME);
+  const lockDir = path92.join(runtimeState.storeDir, LOCK_DIRNAME);
   return withDirectoryLock(
     { lockDir, ownerFileName: LOCK_OWNER_FILENAME },
     operation
@@ -28273,10 +28574,10 @@ function readCarriers() {
   return readCarriersFromDir(runtimeState.storeDir);
 }
 function resolveDefaultStoreDir() {
-  return path93.join(os22.homedir(), DEFAULT_STORE_DIRNAME);
+  return path92.join(os22.homedir(), DEFAULT_STORE_DIRNAME);
 }
 function readCarriersFromDir(dir) {
-  const filePath = path93.join(dir, FILENAME);
+  const filePath = path92.join(dir, FILENAME);
   let fd;
   try {
     const stat5 = fs7.lstatSync(filePath);
@@ -28306,7 +28607,7 @@ function recordLastLocalWriteFingerprint(filePath, generation) {
 function writeCarriers(s) {
   if (!runtimeState.storeDir) throw new Error("Fleet store is not initialized.");
   fs7.mkdirSync(runtimeState.storeDir, { recursive: true });
-  const filePath = path93.join(runtimeState.storeDir, FILENAME);
+  const filePath = path92.join(runtimeState.storeDir, FILENAME);
   const next = serializeFleetCarriers(s);
   writeAtomicSync(filePath, `${JSON.stringify(next, null, 2)}
 `, { fsync: false, mode: 420 });
@@ -28331,7 +28632,7 @@ function sanitizeFleetCarriers(value) {
 }
 function unlinkStaleSubagentModeFile(dir) {
   try {
-    fs7.unlinkSync(path93.join(dir, STALE_SUBAGENT_MODE_FILENAME));
+    fs7.unlinkSync(path92.join(dir, STALE_SUBAGENT_MODE_FILENAME));
   } catch {
   }
 }
@@ -31906,8 +32207,8 @@ function createBoundCarrierJobs(registry3, boundStream = createBoundCarrierStrea
 // src/hooks/subagents-context.ts
 var FLEET_PLUGIN_NAME = "fleet";
 function runSubagentsContextHook(env) {
-  const fleetRoot = env.FLEET_ROOT ?? path93__default.join(env.HOME ?? os22__default.homedir(), ".fleet");
-  if (!canReadCarrierState(path93__default.join(fleetRoot, "carriers.json"))) {
+  const fleetRoot = env.FLEET_ROOT ?? path92__default.join(env.HOME ?? os22__default.homedir(), ".fleet");
+  if (!canReadCarrierState(path92__default.join(fleetRoot, "carriers.json"))) {
     return JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: "" } });
   }
   const carrierRuntime = createCarrierRuntime();
@@ -32385,6 +32686,11 @@ var claudeCli = createClaudeFamilyCliDefinition({
   id: "claude",
   label: "Claude"
 });
+var claudeGlmCli = createClaudeFamilyCliDefinition({
+  authCli: "claude-glm",
+  id: "claude-glm",
+  label: "Claude GLM"
+});
 var claudeKimiCli = createClaudeFamilyCliDefinition({
   authCli: "claude-kimi",
   id: "claude-kimi",
@@ -32424,6 +32730,7 @@ var DEFAULT_CLI_ID = "claude";
 var DEFINITIONS = {
   claude: claudeCli,
   "claude-kimi": claudeKimiCli,
+  "claude-glm": claudeGlmCli,
   codex: codexCli
 };
 async function resolveAgentCliProfile(env, cwd, options = {}) {
@@ -32470,6 +32777,10 @@ var AGENT_CLI_INJECTION_CAPABILITIES = {
     builderId: "claude-native",
     enabled: true
   },
+  "claude-glm": {
+    builderId: "claude-native",
+    enabled: true
+  },
   codex: {
     builderId: "codex-native",
     enabled: true
@@ -32488,7 +32799,7 @@ function createSessionCaptureHookExec(deps) {
     deps.provider
   ] : [deps.entryPath, "hook", "capture-session", deps.provider];
   return {
-    command: deps.execPath ?? process7.execPath,
+    command: deps.execPath ?? process9.execPath,
     args
   };
 }
@@ -32661,16 +32972,10 @@ function writePrivateJson(filePath, value, rootBase) {
 function writePrivateFile(filePath, content, rootBase) {
   const resolvedBase = ensureRootBase(rootBase);
   ensurePathWithinRoot(resolvedBase, filePath);
-  ensureDirectorySegments(resolvedBase, path93__default.dirname(filePath));
+  ensureDirectorySegments(resolvedBase, path92__default.dirname(filePath));
   writeFileNoFollow(filePath, content);
   chmodBestEffort(filePath, FILE_MODE);
 }
-function linkPrivateSymlink(linkPath, target, rootBase) {
-  const resolvedBase = ensureRootBase(rootBase);
-  ensurePathWithinRoot(resolvedBase, linkPath);
-  ensureDirectorySegments(resolvedBase, path93__default.dirname(linkPath));
-  symlinkSync(target, linkPath);
-}
 function removePrivatePath(targetPath, rootBase) {
   const resolvedBase = assertRootBaseSafe(rootBase);
   ensurePathWithinRoot(resolvedBase, targetPath);
@@ -32714,20 +33019,20 @@ function writeFileNoFollow(filePath, content) {
   }
 }
 function ensureRootBase(rootBase) {
-  const resolvedBase = path93__default.resolve(rootBase);
-  const anchor = findExistingDirectoryAnchor(path93__default.dirname(resolvedBase));
+  const resolvedBase = path92__default.resolve(rootBase);
+  const anchor = findExistingDirectoryAnchor(path92__default.dirname(resolvedBase));
   ensureDirectorySegments(anchor, resolvedBase);
   assertDirectorySafe(resolvedBase, "Plugin root base");
   return resolvedBase;
 }
 function assertRootBaseSafe(rootBase) {
-  const resolvedBase = path93__default.resolve(rootBase);
-  assertExistingSegmentsSafe(findExistingDirectoryAnchor(path93__default.dirname(resolvedBase)), resolvedBase);
+  const resolvedBase = path92__default.resolve(rootBase);
+  assertExistingSegmentsSafe(findExistingDirectoryAnchor(path92__default.dirname(resolvedBase)), resolvedBase);
   assertDirectorySafe(resolvedBase, "Plugin root base");
   return resolvedBase;
 }
 function findExistingDirectoryAnchor(targetPath) {
-  const resolvedTarget = path93__default.resolve(targetPath);
+  const resolvedTarget = path92__default.resolve(targetPath);
   let current = resolvedTarget;
   while (true) {
     try {
@@ -32735,7 +33040,7 @@ function findExistingDirectoryAnchor(targetPath) {
       return current;
     } catch (error51) {
       if (error51 instanceof Error && "code" in error51 && error51.code === "ENOENT") {
-        const parent = path93__default.dirname(current);
+        const parent = path92__default.dirname(current);
         if (parent === current) throw error51;
         current = parent;
         continue;
@@ -32754,17 +33059,17 @@ function assertDirectorySafe(dirPath, label) {
   }
 }
 function ensurePathWithinRoot(resolvedBase, candidatePath) {
-  const resolvedCandidate = path93__default.resolve(candidatePath);
-  const relative = path93__default.relative(resolvedBase, resolvedCandidate);
-  if (relative === "" || !relative.startsWith("..") && !path93__default.isAbsolute(relative)) return;
+  const resolvedCandidate = path92__default.resolve(candidatePath);
+  const relative = path92__default.relative(resolvedBase, resolvedCandidate);
+  if (relative === "" || !relative.startsWith("..") && !path92__default.isAbsolute(relative)) return;
   throw new Error(`Plugin path escapes root base: ${candidatePath}`);
 }
 function ensureDirectorySegments(resolvedBase, dirPath) {
-  const target = path93__default.resolve(dirPath);
-  const relative = path93__default.relative(resolvedBase, target);
+  const target = path92__default.resolve(dirPath);
+  const relative = path92__default.relative(resolvedBase, target);
   let current = resolvedBase;
-  for (const segment of relative.split(path93__default.sep).filter(Boolean)) {
-    current = path93__default.join(current, segment);
+  for (const segment of relative.split(path92__default.sep).filter(Boolean)) {
+    current = path92__default.join(current, segment);
     try {
       const stat5 = lstatSync(current);
       if (stat5.isSymbolicLink()) {
@@ -32785,11 +33090,11 @@ function ensureDirectorySegments(resolvedBase, dirPath) {
   }
 }
 function assertExistingSegmentsSafe(resolvedBase, targetPath) {
-  const target = path93__default.resolve(targetPath);
-  const relative = path93__default.relative(resolvedBase, target);
+  const target = path92__default.resolve(targetPath);
+  const relative = path92__default.relative(resolvedBase, target);
   let current = resolvedBase;
-  for (const segment of relative.split(path93__default.sep).filter(Boolean)) {
-    current = path93__default.join(current, segment);
+  for (const segment of relative.split(path92__default.sep).filter(Boolean)) {
+    current = path92__default.join(current, segment);
     const stat5 = lstatSync(current);
     if (stat5.isSymbolicLink()) {
       throw new Error(`Plugin path segment is a symlink: ${current}`);
@@ -32801,13 +33106,13 @@ function assertExistingSegmentsSafe(resolvedBase, targetPath) {
   }
 }
 function assertExistingParentSegmentsSafe(resolvedBase, targetPath) {
-  assertExistingSegmentsSafe(resolvedBase, path93__default.dirname(targetPath));
+  assertExistingSegmentsSafe(resolvedBase, path92__default.dirname(targetPath));
 }
 function assertSegmentRealpathWithinRoot(resolvedBase, segmentPath) {
   const baseRealpath = realpathSync(resolvedBase);
   const segmentRealpath = realpathSync(segmentPath);
-  const relative = path93__default.relative(baseRealpath, segmentRealpath);
-  if (relative === "" || !relative.startsWith("..") && !path93__default.isAbsolute(relative)) return;
+  const relative = path92__default.relative(baseRealpath, segmentRealpath);
+  if (relative === "" || !relative.startsWith("..") && !path92__default.isAbsolute(relative)) return;
   throw new Error(`Plugin path segment escapes root base: ${segmentPath}`);
 }
 var CLAUDE_AGENT_FILE_STEM_ALLOWLIST = /^[A-Za-z0-9][A-Za-z0-9_-]{0,79}$/;
@@ -32825,11 +33130,11 @@ function renderAssetPluginRoot(pluginRoot, bundle, options) {
   if (bundle.includeClaudeAgents) {
     for (const subagent of options.claudeDefinitions) {
       const fileStem = parseClaudeAgentFileStem(subagent.name);
-      writePrivateFile(path93__default.join(pluginRoot, "agents", `${fileStem}.md`), claudeAgentFile(subagent), pluginRoot);
+      writePrivateFile(path92__default.join(pluginRoot, "agents", `${fileStem}.md`), claudeAgentFile(subagent), pluginRoot);
     }
   }
-  if (options.cliId === "claude" || options.cliId === "claude-kimi") {
-    writePrivateJson(path93__default.join(pluginRoot, "hooks", "hooks.json"), claudeHooks(options), pluginRoot);
+  if (options.cliId === "claude" || options.cliId === "claude-kimi" || options.cliId === "claude-glm") {
+    writePrivateJson(path92__default.join(pluginRoot, "hooks", "hooks.json"), claudeHooks(options), pluginRoot);
   }
 }
 function validateClaudeAgentFileStems(subagents) {
@@ -32838,7 +33143,7 @@ function validateClaudeAgentFileStems(subagents) {
   }
 }
 function parseClaudeAgentFileStem(name) {
-  if (CLAUDE_AGENT_FILE_STEM_ALLOWLIST.test(name) && path93__default.basename(name) === name) return name;
+  if (CLAUDE_AGENT_FILE_STEM_ALLOWLIST.test(name) && path92__default.basename(name) === name) return name;
   throw new Error(`Invalid Claude agent file name: ${name}`);
 }
 function claudeHooks(options) {
@@ -32846,7 +33151,7 @@ function claudeHooks(options) {
   if (!hookExec) {
     throw new Error("Fleet Claude session hook command is required");
   }
-  const userPromptSubmitExecs = [options.captureSessionHookExec, options.turnStartHookExec].filter((exec) => exec !== void 0);
+  const userPromptSubmitExecs = [options.captureSessionHookExec, options.turnStartHookExec, options.autoNameHookExec].filter((exec) => exec !== void 0);
   const stopExecs = [options.turnEndHookExec].filter((exec) => exec !== void 0);
   const inputWaitingExec = options.inputWaitingHookExec;
   return {
@@ -32908,74 +33213,8 @@ function yamlScalar(value) {
 }
 function renderEmbeddedSkillAssets(pluginRoot) {
   for (const asset of EMBEDDED_AGENT_CLI_SKILL_ASSETS) {
-    writePrivateFile(path93__default.join(pluginRoot, "skills", asset.relativePath), asset.content, pluginRoot);
-  }
-}
-function linkUserFleetSourcesIntoPlugin(sourceRoot, pluginRoot) {
-  const entries = listUserFleetSourceEntries(sourceRoot);
-  for (const entry of entries) {
-    linkPrivateSymlink(path93__default.join(pluginRoot, entry.pluginRelative), entry.sourcePath, pluginRoot);
-  }
-}
-function listUserFleetSourceEntries(sourceRoot) {
-  const entries = [];
-  for (const pluginRelative of ["skills", "agents", "hooks"]) {
-    const sourcePath = path93__default.join(sourceRoot, pluginRelative);
-    if (!existsSync(sourcePath)) continue;
-    const resolvedStat = statSync(sourcePath);
-    if (!resolvedStat.isDirectory()) {
-      throw new Error(`Fleet plugin source path is not a directory: ${sourcePath}`);
-    }
-    entries.push({ kind: "directory", pluginRelative, sourcePath });
-  }
-  const mcpPath = path93__default.join(sourceRoot, ".mcp.json");
-  if (existsSync(mcpPath)) {
-    const resolvedStat = statSync(mcpPath);
-    if (!resolvedStat.isFile()) {
-      throw new Error(`Fleet plugin source path is not a file: ${mcpPath}`);
-    }
-    entries.push({ kind: "file", pluginRelative: ".mcp.json", sourcePath: mcpPath });
-  }
-  return entries;
-}
-var GLOBAL_FLEET_SOURCE_ENTRIES = ["skills", "agents", "hooks", ".mcp.json"];
-var globalBundle = {
-  description: "Fleet global user-level agents, skills, hooks, and MCP plugin",
-  directoryName: "fleet-global",
-  displayName: "Fleet Global",
-  hashFileName: ".fleet-global-codex-plugin.hash",
-  name: "fleet-global",
-  source: "global"
-};
-function renderGlobalPluginRoot(pluginRoot, fleetRoot) {
-  linkUserFleetSourcesIntoPlugin(fleetRoot, pluginRoot);
-}
-function globalFleetContentExists(fleetRoot) {
-  return GLOBAL_FLEET_SOURCE_ENTRIES.some((entry) => existsSync(path93__default.join(fleetRoot, entry)));
-}
-var projectBundle = {
-  description: "Fleet project-local agents, skills, hooks, and MCP plugin",
-  directoryName: "fleet-project",
-  displayName: "Fleet Project",
-  hashFileName: ".fleet-project-codex-plugin.hash",
-  name: "fleet-project",
-  source: "project"
-};
-function renderProjectPluginRoot(pluginRoot, options) {
-  const fleetProjectRoot = resolveProjectFleetRoot(options.cwd);
-  linkUserFleetSourcesIntoPlugin(fleetProjectRoot, pluginRoot);
-}
-function resolveProjectFleetRoot(cwd) {
-  const fleetProjectRoot = path93__default.join(cwd, ".fleet");
-  const sourceStat = lstatSync(fleetProjectRoot);
-  if (sourceStat.isSymbolicLink()) {
-    throw new Error(`Fleet project plugin source root is a symlink: ${fleetProjectRoot}`);
-  }
-  const verifiedStat = statSync(fleetProjectRoot);
-  if (!verifiedStat.isDirectory()) {
-    throw new Error(`Fleet project plugin source root is not a directory: ${fleetProjectRoot}`);
+    writePrivateFile(path92__default.join(pluginRoot, "skills", asset.relativePath), asset.content, pluginRoot);
   }
-  return fleetProjectRoot;
 }
 var CONFIG_FILE_NAME = "config.toml";
 var CONFIG_FILE_MODE = 384;
@@ -32989,7 +33228,7 @@ function neutralizeCodexFleetPluginConfig(options) {
   mutateCodexConfigWithRetry(options, 0);
 }
 function mutateCodexConfigWithRetry(options, attempt) {
-  const configPath = path93__default.join(options.codexHome, CONFIG_FILE_NAME);
+  const configPath = path92__default.join(options.codexHome, CONFIG_FILE_NAME);
   const targetPath = resolveRealConfigPath(configPath);
   const snapshot = readConfigSnapshot(targetPath);
   const nextContent = patchCodexConfig(snapshot.content, options);
@@ -33010,7 +33249,7 @@ function resolveRealConfigPath(configPath) {
   } catch (error51) {
     if (!isNodeError(error51, "ENOENT")) throw error51;
     try {
-      return path93__default.join(realpathSync(path93__default.dirname(configPath)), path93__default.basename(configPath));
+      return path92__default.join(realpathSync(path92__default.dirname(configPath)), path92__default.basename(configPath));
     } catch (dirError) {
       if (isNodeError(dirError, "ENOENT")) return configPath;
       throw dirError;
@@ -33047,9 +33286,9 @@ function readConfigSnapshot(configPath) {
   }
 }
 function writeConfigIfUnchanged(configPath, snapshot, content) {
-  mkdirSync(path93__default.dirname(configPath), { recursive: true, mode: 448 });
+  mkdirSync(path92__default.dirname(configPath), { recursive: true, mode: 448 });
   assertConfigUnchanged(configPath, snapshot);
-  const tempPath = path93__default.join(path93__default.dirname(configPath), `.${path93__default.basename(configPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
+  const tempPath = path92__default.join(path92__default.dirname(configPath), `.${path92__default.basename(configPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
   let fd;
   try {
     fd = openSync(tempPath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, CONFIG_FILE_MODE);
@@ -33198,6 +33437,10 @@ function unlinkBestEffort(targetPath) {
   } catch {
   }
 }
+var DEPRECATED_HOME_PLUGIN_NAME = "fleet-global";
+var DEPRECATED_PROJECT_PLUGIN_NAME = "fleet-project";
+var DEPRECATED_PROJECT_MARKETPLACE_NAME_PREFIX = "fleet-project-";
+var FLAT_MARKETPLACE_FS_RESIDUE_ENTRIES = [".agents", ".claude-plugin", "plugin"];
 async function ensureCodexPluginRegistered(registration, command2, runCommand, withMarketplaceLock) {
   try {
     await withMarketplaceLock(registration.marketplaceDir, () => {
@@ -33208,6 +33451,47 @@ async function ensureCodexPluginRegistered(registration, command2, runCommand, w
     return error51 instanceof Error ? error51.message : String(error51);
   }
 }
+async function cleanupDeprecatedCodexPluginState(command2, runCommand, withMarketplaceLock, targets) {
+  try {
+    const marketplaceList = runCommand({ ...command2, args: [...command2.args, "plugin", "marketplace", "list"] });
+    assertCommandSucceeded("codex plugin marketplace list", marketplaceList);
+    const pluginList = runCommand({ ...command2, args: [...command2.args, "plugin", "list"] });
+    assertCommandSucceeded("codex plugin list", pluginList);
+    if (isCodexPluginInstalled(pluginList, DEPRECATED_HOME_PLUGIN_NAME, targets.homeMarketplaceName)) {
+      await withMarketplaceLock(targets.homeMarketplaceRoot, () => {
+        const removed = runCommand({
+          ...command2,
+          args: [...command2.args, "plugin", "remove", DEPRECATED_HOME_PLUGIN_NAME, "-m", targets.homeMarketplaceName]
+        });
+        assertCommandSucceeded("codex plugin remove fleet-global", removed);
+      });
+    }
+    const projectTargetRoot = normalizeMarketplaceRoot(targets.projectMarketplaceRoot, command2.cwd);
+    const projectMarketplaces = parseMarketplaceEntries(marketplaceList).filter(
+      (entry) => entry.name.startsWith(DEPRECATED_PROJECT_MARKETPLACE_NAME_PREFIX) && normalizeMarketplaceRoot(entry.root, command2.cwd) === projectTargetRoot
+    );
+    for (const marketplace of projectMarketplaces) {
+      await withMarketplaceLock(targets.projectMarketplaceRoot, () => {
+        if (isCodexPluginInstalled(pluginList, DEPRECATED_PROJECT_PLUGIN_NAME, marketplace.name)) {
+          const removedPlugin = runCommand({
+            ...command2,
+            args: [...command2.args, "plugin", "remove", DEPRECATED_PROJECT_PLUGIN_NAME, "-m", marketplace.name]
+          });
+          assertCommandSucceeded("codex plugin remove fleet-project", removedPlugin);
+        }
+        const removedMarketplace = runCommand({
+          ...command2,
+          args: [...command2.args, "plugin", "marketplace", "remove", marketplace.name]
+        });
+        assertCommandSucceeded("codex plugin marketplace remove fleet-project", removedMarketplace);
+        removeFlatMarketplaceResidue(targets.projectMarketplaceRoot);
+      });
+    }
+    return void 0;
+  } catch (error51) {
+    return error51 instanceof Error ? error51.message : String(error51);
+  }
+}
 function ensureCodexPluginRegisteredOrThrow(registration, command2, runCommand) {
   const marketplaceList = runCommand({ ...command2, args: [...command2.args, "plugin", "marketplace", "list"] });
   assertCommandSucceeded("codex plugin marketplace list", marketplaceList);
@@ -33250,7 +33534,7 @@ function ensureCodexPluginRegisteredOrThrow(registration, command2, runCommand)
     pluginKey
   });
   writePrivateFile(registration.hashPath, `${registration.contentHash}
-`, path93__default.dirname(registration.hashPath));
+`, path92__default.dirname(registration.hashPath));
 }
 function assertCommandSucceeded(label, result) {
   if (result.status === 0) return;
@@ -33258,20 +33542,23 @@ function assertCommandSucceeded(label, result) {
   throw new Error(`${label} failed${detail.length > 0 ? `: ${detail}` : ""}`);
 }
 function resolveCodexHome(env) {
-  return env.CODEX_HOME ?? path93__default.join(env.HOME ?? os22__default.homedir(), ".codex");
+  return env.CODEX_HOME ?? path92__default.join(env.HOME ?? os22__default.homedir(), ".codex");
 }
 function findMarketplaceEntries(result, marketplaceName) {
+  return parseMarketplaceEntries(result).filter((entry) => entry.name === marketplaceName);
+}
+function parseMarketplaceEntries(result) {
   const entries = [];
   for (const line of commandOutput(result).split(/\r?\n/)) {
     const match = line.trim().match(/^(\S+)\s+(.+)$/);
-    if (match?.[1] === marketplaceName) {
+    if (match) {
       entries.push({ name: match[1], root: match[2].trim() });
     }
   }
   return entries;
 }
 function normalizeMarketplaceRoot(rootPath, cwd) {
-  const resolved = path93__default.resolve(cwd, rootPath);
+  const resolved = path92__default.resolve(cwd, rootPath);
   try {
     return realpathSync(resolved);
   } catch (error51) {
@@ -33293,12 +33580,15 @@ function readHash(hashPath) {
   if (!existsSync(hashPath)) return void 0;
   return readFileSync(hashPath, "utf8").trim();
 }
+function removeFlatMarketplaceResidue(projectMarketplaceRoot) {
+  for (const entry of FLAT_MARKETPLACE_FS_RESIDUE_ENTRIES) {
+    removePrivatePath(path92__default.join(projectMarketplaceRoot, entry), projectMarketplaceRoot);
+  }
+}
 var FLEET_MARKETPLACE_NAME = "fleet-harness";
-var FLEET_PROJECT_MARKETPLACE_NAME_PREFIX = "fleet-project";
 var MARKETPLACE_DIR_NAME = "marketplace";
-var FLAT_PLUGIN_DIR_NAME = "plugin";
 var PLUGIN_BUNDLES_DIR_NAME = "plugins";
-var PLUGIN_BUNDLES = [assetBundle, projectBundle, globalBundle];
+var PLUGIN_BUNDLES = [assetBundle];
 var MARKETPLACE_MANAGED_ENTRIES = [
   ".agents",
   ".claude-plugin",
@@ -33310,11 +33600,6 @@ var MARKETPLACE_MANAGED_ENTRIES = [
   "codex-marketplace",
   "plugins"
 ];
-var FLAT_MARKETPLACE_MANAGED_ENTRIES = [
-  ".agents",
-  ".claude-plugin",
-  "plugin"
-];
 var MARKETPLACE_PRUNE_ENTRIES = [
   ".agents",
   ".claude-plugin",
@@ -33325,14 +33610,10 @@ var MARKETPLACE_PRUNE_ENTRIES = [
   "claude",
   "codex-marketplace"
 ];
-var FLAT_MARKETPLACE_PRUNE_ENTRIES = [
-  ".agents",
-  ".claude-plugin"
-];
 var HASH_IGNORED_RELATIVE_PATHS = new Set(PLUGIN_BUNDLES.map((bundle) => bundle.hashFileName));
 async function createAgentCliPlugin(options) {
   const fleetRoot = options.rootDir ?? options.dataDir;
-  const renderableBundles = resolveRenderablePluginBundles(options, fleetRoot);
+  const renderableBundles = resolveRenderablePluginBundles(fleetRoot);
   const marketplaceBundles = groupRenderableBundlesByMarketplace(renderableBundles);
   const pluginRoots = /* @__PURE__ */ new Map();
   const contentHashes = /* @__PURE__ */ new Map();
@@ -33341,7 +33622,7 @@ async function createAgentCliPlugin(options) {
     await options.withMarketplaceLock(marketplace.target.root, () => {
       for (const { bundle, target } of marketplace.bundles) {
         const pluginRoot = pluginRootForTarget(target, bundle);
-        renderPluginRoot(pluginRoot, bundle, options, fleetRoot);
+        renderPluginRoot(pluginRoot, bundle, options);
         pluginRoots.set(bundle, pluginRoot);
       }
       renderMarketplaceRoot(marketplace.target, marketplace.bundles.map(({ bundle }) => bundle));
@@ -33356,7 +33637,7 @@ async function createAgentCliPlugin(options) {
     cleanup,
     codexRegistrations: options.cliId === "codex" ? renderableBundles.map(({ bundle, target }, index) => ({
       contentHash: contentHashes.get(target.root),
-      hashPath: path93__default.join(target.root, bundle.hashFileName),
+      hashPath: path92__default.join(target.root, bundle.hashFileName),
       marketplaceDir: target.root,
       marketplaceName: target.name,
       pluginName: bundle.name,
@@ -33366,43 +33647,14 @@ async function createAgentCliPlugin(options) {
     pluginRoots: resolvedPluginRoots
   };
 }
-function resolveRenderablePluginBundles(options, fleetRoot) {
+function resolveRenderablePluginBundles(fleetRoot) {
   const homeMarketplace = homeMarketplaceTarget(fleetRoot);
-  let projectMarketplace;
-  const renderableBundles = [];
-  for (const bundle of PLUGIN_BUNDLES) {
-    switch (bundle.source) {
-      case "project": {
-        if (!existsSync(path93__default.join(options.cwd, ".fleet"))) break;
-        projectMarketplace ??= projectMarketplaceTarget(options.cwd);
-        renderableBundles.push({ bundle, target: projectMarketplace });
-        break;
-      }
-      case "global":
-        if (globalFleetContentExists(fleetRoot)) {
-          renderableBundles.push({ bundle, target: homeMarketplace });
-        }
-        break;
-      default:
-        renderableBundles.push({ bundle, target: homeMarketplace });
-    }
-  }
-  return renderableBundles;
+  return PLUGIN_BUNDLES.map((bundle) => ({ bundle, target: homeMarketplace }));
 }
 function homeMarketplaceTarget(fleetRoot) {
   return {
-    flat: false,
     name: FLEET_MARKETPLACE_NAME,
-    root: path93__default.join(fleetRoot, MARKETPLACE_DIR_NAME)
-  };
-}
-function projectMarketplaceTarget(cwd) {
-  const projectFleetRoot = resolveProjectFleetRoot(cwd);
-  const hash2 = crypto4.createHash("sha256").update(path93__default.resolve(cwd, ".fleet")).digest("hex").slice(0, 12);
-  return {
-    flat: true,
-    name: `${FLEET_PROJECT_MARKETPLACE_NAME_PREFIX}-${hash2}`,
-    root: projectFleetRoot
+    root: path92__default.join(fleetRoot, MARKETPLACE_DIR_NAME)
   };
 }
 function groupRenderableBundlesByMarketplace(bundles) {
@@ -33417,28 +33669,22 @@ function groupRenderableBundlesByMarketplace(bundles) {
   }
   return groups;
 }
-function renderPluginRoot(pluginRoot, bundle, options, fleetRoot) {
-  const parentRoot = path93__default.dirname(pluginRoot);
+function renderPluginRoot(pluginRoot, bundle, options) {
+  const parentRoot = path92__default.dirname(pluginRoot);
   ensurePrivateDir(parentRoot, parentRoot);
   const stageParent = createStagingDir(parentRoot);
-  const stagedPluginRoot = path93__default.join(stageParent, path93__default.basename(pluginRoot));
+  const stagedPluginRoot = path92__default.join(stageParent, path92__default.basename(pluginRoot));
   try {
     ensurePrivateDir(stagedPluginRoot, stagedPluginRoot);
-    writePrivateJson(path93__default.join(stagedPluginRoot, ".claude-plugin", "plugin.json"), claudeManifest(bundle), stagedPluginRoot);
+    writePrivateJson(path92__default.join(stagedPluginRoot, ".claude-plugin", "plugin.json"), claudeManifest(bundle), stagedPluginRoot);
     switch (bundle.source) {
       case "asset":
-        ensurePrivateDir(path93__default.join(stagedPluginRoot, "agents"), stagedPluginRoot);
-        ensurePrivateDir(path93__default.join(stagedPluginRoot, "skills"), stagedPluginRoot);
+        ensurePrivateDir(path92__default.join(stagedPluginRoot, "agents"), stagedPluginRoot);
+        ensurePrivateDir(path92__default.join(stagedPluginRoot, "skills"), stagedPluginRoot);
         renderAssetPluginRoot(stagedPluginRoot, bundle, options);
         break;
-      case "project":
-        renderProjectPluginRoot(stagedPluginRoot, options);
-        break;
-      case "global":
-        renderGlobalPluginRoot(stagedPluginRoot, fleetRoot);
-        break;
     }
-    writePrivateJson(path93__default.join(stagedPluginRoot, ".codex-plugin", "plugin.json"), codexManifest(bundle, stagedPluginRoot), stagedPluginRoot);
+    writePrivateJson(path92__default.join(stagedPluginRoot, ".codex-plugin", "plugin.json"), codexManifest(bundle, stagedPluginRoot), stagedPluginRoot);
     removePrivatePath(pluginRoot, parentRoot);
     renameSync(stagedPluginRoot, pluginRoot);
   } finally {
@@ -33450,26 +33696,35 @@ function renderMarketplaceRoot(target, bundles) {
   ensurePrivateDir(marketplaceRoot, marketplaceRoot);
   const stagedRoot = createStagingDir(marketplaceRoot);
   try {
-    writePrivateJson(path93__default.join(stagedRoot, ".agents", "plugins", "marketplace.json"), codexMarketplace(target, bundles), stagedRoot);
-    writePrivateJson(path93__default.join(stagedRoot, ".claude-plugin", "marketplace.json"), claudeMarketplace(target, bundles), stagedRoot);
+    writePrivateJson(path92__default.join(stagedRoot, ".agents", "plugins", "marketplace.json"), codexMarketplace(target, bundles), stagedRoot);
+    writePrivateJson(path92__default.join(stagedRoot, ".claude-plugin", "marketplace.json"), claudeMarketplace(target, bundles), stagedRoot);
     pruneMarketplaceRoot(target);
+    pruneStalePluginDirs(target, bundles);
     for (const entry of readdirSync(stagedRoot)) {
-      renameSync(path93__default.join(stagedRoot, entry), path93__default.join(marketplaceRoot, entry));
+      renameSync(path92__default.join(stagedRoot, entry), path92__default.join(marketplaceRoot, entry));
     }
   } finally {
     cleanupPrivateRoot(stagedRoot, marketplaceRoot);
   }
 }
 function pruneMarketplaceRoot(target) {
-  const entries = target.flat ? FLAT_MARKETPLACE_PRUNE_ENTRIES : MARKETPLACE_PRUNE_ENTRIES;
-  for (const entry of entries) {
-    removePrivatePath(path93__default.join(target.root, entry), target.root);
+  for (const entry of MARKETPLACE_PRUNE_ENTRIES) {
+    removePrivatePath(path92__default.join(target.root, entry), target.root);
+  }
+}
+function pruneStalePluginDirs(target, bundles) {
+  const pluginsDir = path92__default.join(target.root, PLUGIN_BUNDLES_DIR_NAME);
+  if (!existsSync(pluginsDir)) return;
+  const activeDirectoryNames = new Set(bundles.map((bundle) => bundle.directoryName));
+  for (const entry of readdirSync(pluginsDir)) {
+    if (activeDirectoryNames.has(entry)) continue;
+    removePrivatePath(path92__default.join(pluginsDir, entry), target.root);
   }
 }
 function buildContentHash(target) {
-  const hash2 = crypto4.createHash("sha256");
+  const hash2 = crypto3.createHash("sha256");
   for (const filePath of listRenderableFiles(target)) {
-    const relativePath2 = path93__default.relative(target.root, filePath);
+    const relativePath2 = path92__default.relative(target.root, filePath);
     hash2.update(relativePath2);
     hash2.update("\0");
     hash2.update(readFileSync(filePath));
@@ -33478,15 +33733,14 @@ function buildContentHash(target) {
   return hash2.digest("hex");
 }
 function createStagingDir(rootPath) {
-  const stageRoot = mkdtempSync(path93__default.join(rootPath, `.fleet-stage-${process.pid}-${Date.now()}-`));
+  const stageRoot = mkdtempSync(path92__default.join(rootPath, `.fleet-stage-${process.pid}-${Date.now()}-`));
   return stageRoot;
 }
 function listRenderableFiles(target) {
   const files = [];
   const ancestorRealDirs = /* @__PURE__ */ new Set();
-  const entries = target.flat ? FLAT_MARKETPLACE_MANAGED_ENTRIES : MARKETPLACE_MANAGED_ENTRIES;
-  for (const entry of entries) {
-    const entryPath = path93__default.join(target.root, entry);
+  for (const entry of MARKETPLACE_MANAGED_ENTRIES) {
+    const entryPath = path92__default.join(target.root, entry);
     if (!existsSync(entryPath)) continue;
     collectRenderableFiles(target.root, entryPath, files, ancestorRealDirs);
   }
@@ -33497,8 +33751,8 @@ function collectRenderableFiles(rootPath, currentPath, files, ancestorRealDirs)
   if (ancestorRealDirs.has(realDir)) return;
   ancestorRealDirs.add(realDir);
   for (const entry of readdirSync(currentPath)) {
-    const entryPath = path93__default.join(currentPath, entry);
-    const relativePath2 = path93__default.relative(rootPath, entryPath);
+    const entryPath = path92__default.join(currentPath, entry);
+    const relativePath2 = path92__default.relative(rootPath, entryPath);
     if (HASH_IGNORED_RELATIVE_PATHS.has(relativePath2)) continue;
     const stat5 = lstatSync(entryPath);
     if (stat5.isSymbolicLink()) {
@@ -33564,10 +33818,9 @@ function claudeMarketplace(target, bundles) {
   };
 }
 function pluginRootForTarget(target, bundle) {
-  return target.flat ? path93__default.join(target.root, FLAT_PLUGIN_DIR_NAME) : path93__default.join(target.root, PLUGIN_BUNDLES_DIR_NAME, bundle.directoryName);
+  return path92__default.join(target.root, PLUGIN_BUNDLES_DIR_NAME, bundle.directoryName);
 }
 function marketplacePluginPath(target, bundle) {
-  if (target.flat) return `./${FLAT_PLUGIN_DIR_NAME}`;
   return `./${PLUGIN_BUNDLES_DIR_NAME}/${bundle.directoryName}`;
 }
 function codexManifest(bundle, pluginRoot) {
@@ -33579,13 +33832,13 @@ function codexManifest(bundle, pluginRoot) {
   };
 }
 function codexManifestVersion(bundle, pluginRoot) {
-  const hash2 = crypto4.createHash("sha256");
+  const hash2 = crypto3.createHash("sha256");
   hash2.update(bundle.name);
   hash2.update("\0");
   hash2.update(bundle.description);
   hash2.update("\0");
   for (const filePath of listCodexEffectivePluginFiles(pluginRoot)) {
-    const relativePath2 = path93__default.relative(pluginRoot, filePath);
+    const relativePath2 = path92__default.relative(pluginRoot, filePath);
     hash2.update(relativePath2);
     hash2.update("\0");
     hash2.update(readFileSync(filePath));
@@ -33594,7 +33847,7 @@ function codexManifestVersion(bundle, pluginRoot) {
   return `0.0.0+${hash2.digest("hex").slice(0, 12)}`;
 }
 function listCodexEffectivePluginFiles(pluginRoot) {
-  const skillsPath = path93__default.join(pluginRoot, "skills");
+  const skillsPath = path92__default.join(pluginRoot, "skills");
   if (!existsSync(skillsPath)) return [];
   const files = [];
   collectRenderableFiles(pluginRoot, skillsPath, files, /* @__PURE__ */ new Set());
@@ -33619,13 +33872,13 @@ async function injectAgentCliProfile(profile, options) {
   const injectTone = options.enableMetaphor ?? false;
   const endpoint = await options.dedicatedMcpSession.getEndpoint();
   const startupDefinitions = buildStartupNativeDefinitions(profile.id, options.carrierRuntime);
-  const tokenLabel = options.mcpSessionLabel ?? `agent:${profile.id}:${crypto4.randomUUID()}`;
+  const tokenLabel = options.mcpSessionLabel ?? `agent:${profile.id}:${crypto3.randomUUID()}`;
   const tokens = await options.dedicatedMcpSession.issueSessionToken({ cwd: profile.cwd, label: tokenLabel });
   const mcpServers = buildAgentCliMcpServerConfigs(endpoint.servers, tokens);
   const doctrine = options.buildSystemPrompt(injectTone);
   const tempCleanups = [];
   try {
-    const systemPromptFile = profile.id === "claude" || profile.id === "claude-kimi" ? writeSystemPromptFile(profile.id, doctrine, (cleanup2) => tempCleanups.push(cleanup2)) : void 0;
+    const systemPromptFile = profile.id === "claude" || profile.id === "claude-kimi" || profile.id === "claude-glm" ? writeSystemPromptFile(profile.id, doctrine, (cleanup2) => tempCleanups.push(cleanup2)) : void 0;
     const plugin = await createAgentCliPlugin({
       claudeDefinitions: startupDefinitions.host === "claude" ? startupDefinitions.definitions : [],
       cliId: profile.id,
@@ -33637,6 +33890,7 @@ async function injectAgentCliProfile(profile, options) {
       turnStartHookExec: options.turnStartHookExec,
       turnEndHookExec: options.turnEndHookExec,
       inputWaitingHookExec: options.inputWaitingHookExec,
+      autoNameHookExec: options.autoNameHookExec,
       hookExec: startupDefinitions.host === "claude" ? requireHookExec(options.hookExec) : void 0,
       withMarketplaceLock: options.withMarketplaceLock
     });
@@ -33644,9 +33898,25 @@ async function injectAgentCliProfile(profile, options) {
     const codexProfile = profile.id === "codex" ? writeCodexFleetProfile(profile.env, doctrine, codexPluginKeys, {
       captureSessionHookExec: options.captureSessionHookExec,
       turnStartHookExec: options.turnStartHookExec,
-      turnEndHookExec: options.turnEndHookExec
+      turnEndHookExec: options.turnEndHookExec,
+      autoNameHookExec: options.autoNameHookExec
     }, (cleanup2) => tempCleanups.push(cleanup2)) : void 0;
     const launchWarnings = [];
+    if (profile.id === "codex") {
+      const cleanupWarning = await cleanupDeprecatedCodexPluginState({
+        args: [...profile.binPrefixArgs ?? []],
+        bin: profile.bin,
+        cwd: profile.cwd,
+        env: { ...profile.env }
+      }, requireCodexCommandRunner(options.codexCommandRunner), options.withMarketplaceLock, {
+        homeMarketplaceName: FLEET_MARKETPLACE_NAME,
+        homeMarketplaceRoot: path92__default.join(options.pluginRootDir ?? options.dataDir, "marketplace"),
+        projectMarketplaceRoot: path92__default.join(profile.cwd, ".fleet")
+      });
+      if (cleanupWarning !== void 0) {
+        launchWarnings.push(`Deprecated Codex plugin cleanup failed: ${cleanupWarning}`);
+      }
+    }
     for (const registration of plugin.codexRegistrations) {
       const registrationWarning = await ensureCodexPluginRegistered(registration, {
         args: [...profile.binPrefixArgs ?? []],
@@ -33697,7 +33967,7 @@ function buildStartupNativeDefinitions(cliId, carrierRuntime) {
   return { host, definitions: buildClaudeNativeSubagentPlan2(carrierRuntime.registry).definitions };
 }
 function getNativeSubagentHost(cliId) {
-  if (cliId === "claude" || cliId === "claude-kimi") return "claude";
+  if (cliId === "claude" || cliId === "claude-kimi" || cliId === "claude-glm") return "claude";
   return "none";
 }
 function buildAgentCliMcpServerConfigs(endpoints, tokens) {
@@ -33714,19 +33984,19 @@ function buildAgentCliMcpServerConfigs(endpoints, tokens) {
   });
 }
 function writeSystemPromptFile(cliId, systemPrompt, onCleanup) {
-  const tempDir = mkdtempSync(path93__default.join(os22__default.tmpdir(), `fleet-${cliId}-`));
+  const tempDir = mkdtempSync(path92__default.join(os22__default.tmpdir(), `fleet-${cliId}-`));
   onCleanup(() => rmBestEffort(tempDir));
-  const filePath = path93__default.join(tempDir, "system-prompt.md");
+  const filePath = path92__default.join(tempDir, "system-prompt.md");
   writeFileSync(filePath, systemPrompt, { encoding: "utf8", flag: "wx", mode: SYSTEM_PROMPT_FILE_MODE });
   chmodBestEffort2(filePath, SYSTEM_PROMPT_FILE_MODE);
   return filePath;
 }
 function writeCodexFleetProfile(env, doctrine, pluginKeys, hookExecs, onCleanup) {
-  const codexHome = env.CODEX_HOME ?? path93__default.join(env.HOME ?? os22__default.homedir(), ".codex");
+  const codexHome = env.CODEX_HOME ?? path92__default.join(env.HOME ?? os22__default.homedir(), ".codex");
   mkdirSync(codexHome, { recursive: true });
   pruneStaleCodexFleetProfiles(codexHome);
-  const profileName = `fleet-${crypto4.randomUUID()}`;
-  const profilePath = path93__default.join(codexHome, `${profileName}.config.toml`);
+  const profileName = `fleet-${crypto3.randomUUID()}`;
+  const profilePath = path92__default.join(codexHome, `${profileName}.config.toml`);
   onCleanup(() => rmBestEffort(profilePath));
   writeFileNoFollow2(profilePath, [
     CODEX_FLEET_PROFILE_MARKER,
@@ -33747,7 +34017,7 @@ function writeCodexFleetProfile(env, doctrine, pluginKeys, hookExecs, onCleanup)
   return { profileName, profilePath };
 }
 function codexHooksConfig(hookExecs) {
-  const userPromptSubmitExecs = [hookExecs.captureSessionHookExec, hookExecs.turnStartHookExec].filter((exec) => exec !== void 0);
+  const userPromptSubmitExecs = [hookExecs.captureSessionHookExec, hookExecs.turnStartHookExec, hookExecs.autoNameHookExec].filter((exec) => exec !== void 0);
   const stopExecs = [hookExecs.turnEndHookExec].filter((exec) => exec !== void 0);
   if (userPromptSubmitExecs.length === 0 && stopExecs.length === 0) return [];
   const lines = ["[hooks]"];
@@ -33786,7 +34056,7 @@ function pruneStaleCodexFleetProfiles(codexHome) {
   const now = Date.now();
   for (const entry of entries) {
     if (!CODEX_FLEET_PROFILE_FILE_NAME_PATTERN.test(entry)) continue;
-    const filePath = path93__default.join(codexHome, entry);
+    const filePath = path92__default.join(codexHome, entry);
     if (!isStaleFleetCodexProfile(filePath, now)) continue;
     unlinkBestEffort2(filePath);
   }
@@ -34230,7 +34500,7 @@ function extractLegacyMarkdownWikiLinks(body, wikiDir, basePath) {
 }
 function resolveLegacyWikiTarget(target, wikiDir, basePath) {
   if (!target || target.startsWith("#")) return null;
-  if (path93__default.isAbsolute(target)) return null;
+  if (path92__default.isAbsolute(target)) return null;
   if (/^[a-z][a-z0-9+.-]*:/i.test(target)) return null;
   const withoutFragment = target.split("#", 1)[0]?.split("?", 1)[0] ?? "";
   if (!withoutFragment.endsWith(".md")) return null;
@@ -34240,12 +34510,12 @@ function resolveLegacyWikiTarget(target, wikiDir, basePath) {
   } catch {
     return null;
   }
-  const resolved = path93__default.resolve(path93__default.dirname(basePath), decodedTarget);
-  const relative = path93__default.relative(wikiDir, resolved);
-  if (!relative || relative.startsWith("..") || path93__default.isAbsolute(relative)) return null;
+  const resolved = path92__default.resolve(path92__default.dirname(basePath), decodedTarget);
+  const relative = path92__default.relative(wikiDir, resolved);
+  if (!relative || relative.startsWith("..") || path92__default.isAbsolute(relative)) return null;
   return {
     target,
-    entryId: path93__default.basename(relative, ".md")
+    entryId: path92__default.basename(relative, ".md")
   };
 }
 var KNOWLEDGE_ROOT_DIRNAME = ".fleet/knowledge";
@@ -34503,18 +34773,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(path93__default.join(paths.schemaDir, WORKSPACE_SCHEMA_AGENTS_FILENAME), DEFAULT_WORKSPACE_SCHEMA_AGENTS);
-  await writeDefaultFileIfMissing(path93__default.join(paths.schemaDir, WORKSPACE_SCHEMA_FILENAME), DEFAULT_WORKSPACE_WIKI_SCHEMA);
+  await writeDefaultFileIfMissing(path92__default.join(paths.schemaDir, WORKSPACE_SCHEMA_AGENTS_FILENAME), DEFAULT_WORKSPACE_SCHEMA_AGENTS);
+  await writeDefaultFileIfMissing(path92__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(path93__default.join(paths.root, WORKSPACE_KNOWLEDGE_AGENTS_FILENAME), DEFAULT_WORKSPACE_KNOWLEDGE_AGENTS);
+  await writeDefaultFileIfMissing(path92__default.join(paths.root, WORKSPACE_KNOWLEDGE_AGENTS_FILENAME), DEFAULT_WORKSPACE_KNOWLEDGE_AGENTS);
 }
 async function readWorkspaceSchemaSummary(paths) {
-  const agentsPath = path93__default.join(paths.schemaDir, WORKSPACE_SCHEMA_AGENTS_FILENAME);
-  const wikiSchemaPath = path93__default.join(paths.schemaDir, WORKSPACE_SCHEMA_FILENAME);
+  const agentsPath = path92__default.join(paths.schemaDir, WORKSPACE_SCHEMA_AGENTS_FILENAME);
+  const wikiSchemaPath = path92__default.join(paths.schemaDir, WORKSPACE_SCHEMA_FILENAME);
   const wikiSchemaContent = await tryReadFile(wikiSchemaPath);
   const templates = await scanTemplates(paths);
   if (wikiSchemaContent === null) {
@@ -34553,7 +34823,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 (!id) continue;
-    const filePath = path93__default.join(paths.schemaDir, entry.name);
+    const filePath = path92__default.join(paths.schemaDir, entry.name);
     try {
       const parsed = parseTemplateMarkdown(await readFile(filePath, "utf8"));
       templates.push({
@@ -34587,7 +34857,7 @@ async function validateTemplateCompliance(paths, templateId, body) {
   }
 }
 function inferTemplateIdFromTarget(target, knownTemplateIds) {
-  const basename = path93__default.basename(target, ".md");
+  const basename = path92__default.basename(target, ".md");
   const ids = knownTemplateIds ?? DEFAULT_TEMPLATE_IDS;
   const sorted = [...ids].sort((a, b) => b.length - a.length);
   for (const id of sorted) {
@@ -34616,7 +34886,7 @@ function extractSchemaSummary(content) {
   return lines.find((line) => line.length > 0 && !line.startsWith("#")) ?? "Workspace schema is present.";
 }
 function buildTemplatePath(paths, id) {
-  return path93__default.join(paths.schemaDir, `${WORKSPACE_TEMPLATE_PREFIX}${id}${WORKSPACE_TEMPLATE_SUFFIX}`);
+  return path92__default.join(paths.schemaDir, `${WORKSPACE_TEMPLATE_PREFIX}${id}${WORKSPACE_TEMPLATE_SUFFIX}`);
 }
 function parseTemplateMarkdown(content) {
   const normalized = content.replace(/\r\n/g, "\n");
@@ -34641,16 +34911,16 @@ function isAlreadyExistsError(error51) {
   return typeof error51 === "object" && error51 !== null && "code" in error51 && error51.code === "EEXIST";
 }
 function resolveMemoryPaths(cwd) {
-  const root = path93__default.join(cwd, KNOWLEDGE_ROOT_DIRNAME);
+  const root = path92__default.join(cwd, KNOWLEDGE_ROOT_DIRNAME);
   return {
     root,
-    rawDir: path93__default.join(root, RAW_DIRNAME),
-    wikiDir: path93__default.join(root, WIKI_DIRNAME),
-    schemaDir: path93__default.join(root, SCHEMA_DIRNAME),
-    queueDir: path93__default.join(root, QUEUE_DIRNAME),
-    archiveDir: path93__default.join(root, ARCHIVE_DIRNAME),
-    conflictsDir: path93__default.join(root, CONFLICTS_DIRNAME),
-    indexFile: path93__default.join(root, INDEX_FILENAME)
+    rawDir: path92__default.join(root, RAW_DIRNAME),
+    wikiDir: path92__default.join(root, WIKI_DIRNAME),
+    schemaDir: path92__default.join(root, SCHEMA_DIRNAME),
+    queueDir: path92__default.join(root, QUEUE_DIRNAME),
+    archiveDir: path92__default.join(root, ARCHIVE_DIRNAME),
+    conflictsDir: path92__default.join(root, CONFLICTS_DIRNAME),
+    indexFile: path92__default.join(root, INDEX_FILENAME)
   };
 }
 async function ensureMemoryRoot(paths) {
@@ -34665,10 +34935,10 @@ async function ensureMemoryRoot(paths) {
   await ensureWorkspaceDoctrine(paths);
 }
 function getIndexMarkdownFile(paths) {
-  return path93__default.join(paths.wikiDir, INDEX_MD_FILENAME);
+  return path92__default.join(paths.wikiDir, INDEX_MD_FILENAME);
 }
 function getLogFile(paths) {
-  return path93__default.join(paths.root, LOG_MD_FILENAME);
+  return path92__default.join(paths.root, LOG_MD_FILENAME);
 }
 var LOG_HEADER_PATTERN = /^## (.+) — (.+)$/;
 var LOG_BULLET_PATTERN = /^- ([a-z0-9_]+): `([\s\S]*)`$/;
@@ -34826,12 +35096,12 @@ async function readWikiEntry(id, paths) {
   const index = await loadIndex(paths);
   const indexed = index[id];
   if (indexed) {
-    const resolved = path93__default.resolve(paths.root, indexed.path);
-    const rel = path93__default.relative(paths.wikiDir, resolved);
-    if (!rel || rel.startsWith("..") || path93__default.isAbsolute(rel)) return null;
+    const resolved = path92__default.resolve(paths.root, indexed.path);
+    const rel = path92__default.relative(paths.wikiDir, resolved);
+    if (!rel || rel.startsWith("..") || path92__default.isAbsolute(rel)) return null;
     return readMarkdownFile(resolved);
   }
-  const fallbackPath = path93__default.join(paths.wikiDir, `${id}.md`);
+  const fallbackPath = path92__default.join(paths.wikiDir, `${id}.md`);
   if (await pathExists(fallbackPath)) {
     return readMarkdownFile(fallbackPath);
   }
@@ -34842,20 +35112,20 @@ async function readWikiEntry(id, paths) {
 async function writeWikiEntryAtTarget(entry, target, paths) {
   await ensureMemoryRoot(paths);
   assertSafeEntryId(entry.id);
-  const absoluteTarget = path93__default.resolve(paths.root, target);
-  const relativeTarget = path93__default.relative(paths.wikiDir, absoluteTarget);
-  if (!relativeTarget || relativeTarget.startsWith("..") || path93__default.isAbsolute(relativeTarget)) {
+  const absoluteTarget = path92__default.resolve(paths.root, target);
+  const relativeTarget = path92__default.relative(paths.wikiDir, absoluteTarget);
+  if (!relativeTarget || relativeTarget.startsWith("..") || path92__default.isAbsolute(relativeTarget)) {
     throw new Error(`[fleet-wiki] wiki target escapes wiki/: ${target}`);
   }
   if (!absoluteTarget.endsWith(".md")) {
     throw new Error(`[fleet-wiki] wiki target must end with .md: ${target}`);
   }
-  if (path93__default.basename(absoluteTarget, ".md") !== entry.id) {
+  if (path92__default.basename(absoluteTarget, ".md") !== entry.id) {
     throw new Error("wiki patch body id must match target filename");
   }
-  await mkdir(path93__default.dirname(absoluteTarget), { recursive: true });
+  await mkdir(path92__default.dirname(absoluteTarget), { recursive: true });
   await writeMarkdownAtomic(absoluteTarget, serializeWikiEntry(entry), paths);
-  return path93__default.join("wiki", relativeTarget).replaceAll(path93__default.sep, "/");
+  return path92__default.join("wiki", relativeTarget).replaceAll(path92__default.sep, "/");
 }
 async function writeRawSourceEntry(entry, paths) {
   await ensureMemoryRoot(paths);
@@ -34874,11 +35144,11 @@ async function writeRawSourceEntry(entry, paths) {
     },
     entry.content
   );
-  await writeMarkdownAtomic(path93__default.join(paths.root, relativePath2), content, paths);
+  await writeMarkdownAtomic(path92__default.join(paths.root, relativePath2), content, paths);
   return relativePath2;
 }
 async function readRawSourceEntry(rawSourceRef, paths) {
-  const absolutePath = path93__default.resolve(paths.root, rawSourceRef);
+  const absolutePath = path92__default.resolve(paths.root, rawSourceRef);
   assertWithinRawDir(absolutePath, paths);
   const parsed = parseMarkdown(await readFile(absolutePath, "utf8"));
   return {
@@ -35066,11 +35336,11 @@ function stripLeadingFrontmatter(body) {
   return stripped ? next : body;
 }
 function computeContentHash(content) {
-  return crypto4.createHash("sha256").update(content, "utf8").digest("hex").slice(0, 8);
+  return crypto3.createHash("sha256").update(content, "utf8").digest("hex").slice(0, 8);
 }
 function assertWithinRawDir(absolutePath, paths) {
-  const relative = path93__default.relative(paths.rawDir, absolutePath);
-  if (!relative || relative.startsWith("..") || path93__default.isAbsolute(relative)) {
+  const relative = path92__default.relative(paths.rawDir, absolutePath);
+  if (!relative || relative.startsWith("..") || path92__default.isAbsolute(relative)) {
     throw new Error(`[fleet-wiki] raw source ref escapes raw/: ${absolutePath}`);
   }
 }
@@ -35126,7 +35396,7 @@ function parseWikiEntry(content) {
 async function listWikiRecords(paths) {
   return listMarkdownEntriesRecursive(paths.wikiDir, paths, (content, filePath) => ({
     entry: parseWikiEntry(content),
-    path: path93__default.relative(paths.root, filePath).replaceAll(path93__default.sep, "/")
+    path: path92__default.relative(paths.root, filePath).replaceAll(path92__default.sep, "/")
   }));
 }
 async function listMarkdownEntriesRecursive(dirPath, paths, parser) {
@@ -35139,7 +35409,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 = path93__default.join(dirPath, entry.name);
+    const filePath = path92__default.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       items.push(...await listMarkdownEntriesRecursive(filePath, paths, parser));
       continue;
@@ -35277,9 +35547,9 @@ async function writeJsonAtomic(filePath, value, paths) {
 }
 async function writeAtomic(filePath, content, paths) {
   await ensureMemoryRoot(paths);
-  const tempPath = path93__default.join(
-    path93__default.dirname(filePath),
-    `.tmp-${process.pid}-${Date.now()}-${crypto4.randomUUID()}-${os22__default.hostname()}`
+  const tempPath = path92__default.join(
+    path92__default.dirname(filePath),
+    `.tmp-${process.pid}-${Date.now()}-${crypto3.randomUUID()}-${os22__default.hostname()}`
   );
   await writeFile(tempPath, content, "utf8");
   await rename(tempPath, filePath);
@@ -35323,7 +35593,7 @@ async function enhancedSearch(paths, options) {
   for (const entry of entries) {
     if (!index[entry.id]) {
       index[entry.id] = {
-        path: path93__default.join("wiki", `${entry.id}.md`),
+        path: path92__default.join("wiki", `${entry.id}.md`),
         title: entry.title,
         tags: entry.tags,
         updated: entry.updated
@@ -35459,7 +35729,7 @@ function toEnhancedHit(entry, signals) {
     score: enhancedScore,
     reason: signals.legacyReason ?? "body",
     excerpt,
-    path: path93__default.join("wiki", `${entry.id}.md`),
+    path: path92__default.join("wiki", `${entry.id}.md`),
     tags: entry.tags,
     updated: entry.updated,
     version: entry.version,
@@ -35653,7 +35923,7 @@ function toRankedHit(entry, reason, detail, graphBoost, backlinksById) {
     score: basePriority * 100 + statusPriority * 10 + graphScore + (detail.tagBoost ?? 0),
     reason,
     excerpt,
-    path: path93__default.join("wiki", `${entry.id}.md`),
+    path: path92__default.join("wiki", `${entry.id}.md`),
     tags: entry.tags,
     updated: entry.updated,
     version: entry.version,
@@ -36077,15 +36347,15 @@ var PATCH_SET_DIRNAME = "_sets";
 var PATCH_SET_META_FILENAME = PATCH_META_FILENAME;
 function getPatchSetDir(paths, patchSetId) {
   assertSafePatchSetId(patchSetId);
-  const patchSetDir = path93__default.join(paths.queueDir, PATCH_SET_DIRNAME, patchSetId);
-  const relative = path93__default.relative(path93__default.join(paths.queueDir, PATCH_SET_DIRNAME), patchSetDir);
-  if (!relative || relative.startsWith("..") || path93__default.isAbsolute(relative)) {
+  const patchSetDir = path92__default.join(paths.queueDir, PATCH_SET_DIRNAME, patchSetId);
+  const relative = path92__default.relative(path92__default.join(paths.queueDir, PATCH_SET_DIRNAME), patchSetDir);
+  if (!relative || relative.startsWith("..") || path92__default.isAbsolute(relative)) {
     throw new Error(`[fleet-wiki] patch set id escapes queue/_sets: ${patchSetId}`);
   }
   return patchSetDir;
 }
 function getPatchSetMetaFile(paths, patchSetId) {
-  return path93__default.join(getPatchSetDir(paths, patchSetId), PATCH_SET_META_FILENAME);
+  return path92__default.join(getPatchSetDir(paths, patchSetId), PATCH_SET_META_FILENAME);
 }
 function buildPatchSetId(createdAt, sourceRef) {
   const compact = createdAt.replace(/[:.]/g, "-");
@@ -36118,7 +36388,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 = path93__default.join(paths.conflictsDir, conflictId);
+  const conflictDir = path92__default.join(paths.conflictsDir, conflictId);
   await mkdir(conflictDir, { recursive: true });
   const meta3 = {
     id: conflictId,
@@ -36138,13 +36408,13 @@ async function createConflict(input, paths) {
     currentHash: input.currentHash,
     warnings: input.warnings
   };
-  await writeJsonFile(path93__default.join(conflictDir, CONFLICT_META_FILENAME), meta3, paths);
-  await writePatchFile(path93__default.join(conflictDir, CONFLICT_PROPOSED_FILENAME), input.proposed, paths);
+  await writeJsonFile(path92__default.join(conflictDir, CONFLICT_META_FILENAME), meta3, paths);
+  await writePatchFile(path92__default.join(conflictDir, CONFLICT_PROPOSED_FILENAME), input.proposed, paths);
   if (input.current !== void 0) {
-    await writePatchFile(path93__default.join(conflictDir, CONFLICT_CURRENT_FILENAME), input.current, paths);
+    await writePatchFile(path92__default.join(conflictDir, CONFLICT_CURRENT_FILENAME), input.current, paths);
   }
   if (input.rawSource !== void 0) {
-    await writePatchFile(path93__default.join(conflictDir, CONFLICT_RAW_SOURCE_FILENAME), input.rawSource, paths);
+    await writePatchFile(path92__default.join(conflictDir, CONFLICT_RAW_SOURCE_FILENAME), input.rawSource, paths);
   }
   return {
     meta: meta3,
@@ -36158,7 +36428,7 @@ async function listConflicts(paths) {
   const metas = [];
   for (const id of ids) {
     try {
-      metas.push(await readJsonFile2(path93__default.join(paths.conflictsDir, id, CONFLICT_META_FILENAME)));
+      metas.push(await readJsonFile2(path92__default.join(paths.conflictsDir, id, CONFLICT_META_FILENAME)));
     } catch {
       continue;
     }
@@ -36167,13 +36437,13 @@ async function listConflicts(paths) {
 }
 async function readConflict(conflictId, paths) {
   const conflictDir = resolveConflictDir(conflictId, paths);
-  const meta3 = await readJsonFile2(path93__default.join(conflictDir, CONFLICT_META_FILENAME));
-  const currentPath = path93__default.join(conflictDir, CONFLICT_CURRENT_FILENAME);
-  const rawSourcePath = path93__default.join(conflictDir, CONFLICT_RAW_SOURCE_FILENAME);
+  const meta3 = await readJsonFile2(path92__default.join(conflictDir, CONFLICT_META_FILENAME));
+  const currentPath = path92__default.join(conflictDir, CONFLICT_CURRENT_FILENAME);
+  const rawSourcePath = path92__default.join(conflictDir, CONFLICT_RAW_SOURCE_FILENAME);
   return {
     meta: meta3,
     current: await pathExists(currentPath) ? await readPatchFile(currentPath) : void 0,
-    proposed: await readPatchFile(path93__default.join(conflictDir, CONFLICT_PROPOSED_FILENAME)),
+    proposed: await readPatchFile(path92__default.join(conflictDir, CONFLICT_PROPOSED_FILENAME)),
     rawSource: await pathExists(rawSourcePath) ? await readPatchFile(rawSourcePath) : void 0
   };
 }
@@ -36192,9 +36462,9 @@ function sanitizeConflictToken(value) {
   return value.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "unknown";
 }
 function resolveConflictDir(conflictId, paths) {
-  const conflictDir = path93__default.resolve(paths.conflictsDir, conflictId);
-  const relative = path93__default.relative(paths.conflictsDir, conflictDir);
-  if (!relative || relative.startsWith("..") || path93__default.isAbsolute(relative)) {
+  const conflictDir = path92__default.resolve(paths.conflictsDir, conflictId);
+  const relative = path92__default.relative(paths.conflictsDir, conflictDir);
+  if (!relative || relative.startsWith("..") || path92__default.isAbsolute(relative)) {
     throw new Error(`[fleet-wiki] conflict id escapes conflicts/: ${conflictId}`);
   }
   return conflictDir;
@@ -36230,11 +36500,11 @@ async function validatePatch(patch, paths) {
   if (!target || !summary || !proposer || !created) throw new Error("patch frontmatter is incomplete");
   if (summary.length > 120) throw new Error("patch summary exceeds 120 chars");
   assertCanonicalPatchTarget(target);
-  const absoluteTarget = path93__default.resolve(paths.root, target);
-  if (!absoluteTarget.startsWith(`${paths.root}${path93__default.sep}`) && absoluteTarget !== paths.root) {
+  const absoluteTarget = path92__default.resolve(paths.root, target);
+  if (!absoluteTarget.startsWith(`${paths.root}${path92__default.sep}`) && absoluteTarget !== paths.root) {
     throw new Error("patch target escapes wiki root");
   }
-  if (!absoluteTarget.startsWith(`${paths.wikiDir}${path93__default.sep}`)) throw new Error("wiki patch must target wiki/");
+  if (!absoluteTarget.startsWith(`${paths.wikiDir}${path92__default.sep}`)) throw new Error("wiki patch must target wiki/");
   assertNoSymlinkPathComponents(target, paths);
   if (op === "create_wiki" && await pathExists(absoluteTarget)) {
     throw new Error(
@@ -36255,19 +36525,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 = path93__default.join(paths.queueDir, patchId);
+  const queueDir = path92__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(path93__default.join(queueDir, PATCH_FILENAME), serializePatch(patch), paths);
+  await writePatchFile(path92__default.join(queueDir, PATCH_FILENAME), serializePatch(patch), paths);
   const meta3 = {
     id: patchId,
     status: "pending",
     createdAt: patch.frontmatter.created,
     ...metaOverrides
   };
-  await writeJsonFile(path93__default.join(queueDir, PATCH_META_FILENAME), meta3, paths);
+  await writeJsonFile(path92__default.join(queueDir, PATCH_META_FILENAME), meta3, paths);
   await appendLog(paths, "patch enqueued", {
     patch_id: patchId,
     patch_set_id: meta3.patch_set_id ?? null,
@@ -36285,7 +36555,7 @@ async function listQueue(paths) {
   for (const id of ids) {
     if (id === "_sets") continue;
     try {
-      const meta3 = await readJsonFile2(path93__default.join(paths.queueDir, id, PATCH_META_FILENAME));
+      const meta3 = await readJsonFile2(path92__default.join(paths.queueDir, id, PATCH_META_FILENAME));
       results.push({ id, meta: meta3 });
     } catch {
       continue;
@@ -36310,17 +36580,17 @@ async function resolveQueueSelection(id, paths) {
 }
 async function showQueue(id, paths) {
   const selection = await resolveQueueSelection(id, paths);
-  const queueDir = path93__default.join(paths.queueDir, selection.id);
-  const patch = await parsePatch(await readPatchFile(path93__default.join(queueDir, PATCH_FILENAME)));
-  const meta3 = await readJsonFile2(path93__default.join(queueDir, PATCH_META_FILENAME));
+  const queueDir = path92__default.join(paths.queueDir, selection.id);
+  const patch = await parsePatch(await readPatchFile(path92__default.join(queueDir, PATCH_FILENAME)));
+  const meta3 = await readJsonFile2(path92__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 = path93__default.join(paths.queueDir, id);
+    const queueDir = path92__default.join(paths.queueDir, id);
     if (expectedPatchHash !== void 0) {
-      const currentMarkdown = await readPatchFile(path93__default.join(queueDir, PATCH_FILENAME));
+      const currentMarkdown = await readPatchFile(path92__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}`);
@@ -36329,8 +36599,8 @@ async function rewriteQueuedPatch(id, paths, patch, meta3, expectedPatchHash) {
     const patchMarkdown = serializePatch(patch);
     const patchHash = computeContentHash(patchMarkdown);
     const nextMeta = { ...meta3, lastEditHash: patchHash };
-    await writePatchFile(path93__default.join(queueDir, PATCH_FILENAME), patchMarkdown, paths);
-    await writeJsonFile(path93__default.join(queueDir, PATCH_META_FILENAME), nextMeta, paths);
+    await writePatchFile(path92__default.join(queueDir, PATCH_FILENAME), patchMarkdown, paths);
+    await writeJsonFile(path92__default.join(queueDir, PATCH_META_FILENAME), nextMeta, paths);
     return patchHash;
   });
 }
@@ -36354,8 +36624,8 @@ async function approvePatch(id, paths) {
           rawSourceRef: meta3.rawSourceRef,
           warnings: meta3.warnings
         });
-        const queueDir = path93__default.join(paths.queueDir, id);
-        await writeJsonFile(path93__default.join(queueDir, PATCH_META_FILENAME), {
+        const queueDir = path92__default.join(paths.queueDir, id);
+        await writeJsonFile(path92__default.join(queueDir, PATCH_META_FILENAME), {
           ...meta3,
           conflictId
         }, paths);
@@ -36391,7 +36661,7 @@ async function approvePatchSet(patchSetId, paths) {
   const failed = [];
   const missing = [];
   for (const patchId of patchSet.patchIds) {
-    const queueDir = path93__default.join(paths.queueDir, patchId);
+    const queueDir = path92__default.join(paths.queueDir, patchId);
     if (!await pathExists(queueDir)) {
       missing.push(patchId);
       continue;
@@ -36457,7 +36727,7 @@ ${patch.body}`;
 }
 async function normalizeWikiEntryPatch(entry, target, paths) {
   assertSafeEntryId(entry.id);
-  if (entry.id !== path93__default.basename(target, ".md")) {
+  if (entry.id !== path92__default.basename(target, ".md")) {
     throw new Error("wiki patch body id must match target filename");
   }
   const inlineRawSourceRef = extractInlineRawSourceRef(entry.body);
@@ -36500,9 +36770,9 @@ function buildPatchId(createdAt, summary, target, body) {
 }
 async function validatePatchBase(patch, meta3, paths) {
   if (patch.frontmatter.op !== "update_wiki" || !meta3?.baseVersion && !meta3?.baseHash) return;
-  const wikiId = path93__default.basename(patch.frontmatter.target, ".md");
+  const wikiId = path92__default.basename(patch.frontmatter.target, ".md");
   const currentEntry = await readWikiEntry(wikiId, paths);
-  const currentPath = path93__default.join(paths.root, patch.frontmatter.target);
+  const currentPath = path92__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(
@@ -36561,17 +36831,17 @@ function assertCanonicalPatchTarget(target) {
   if (target.endsWith("/")) {
     throw new Error("patch target must not end with a slash");
   }
-  if (target.startsWith("/") || path93__default.posix.isAbsolute(target) || path93__default.win32.isAbsolute(target)) {
+  if (target.startsWith("/") || path92__default.posix.isAbsolute(target) || path92__default.win32.isAbsolute(target)) {
     throw new Error("patch target must be relative");
   }
-  if (path93__default.posix.normalize(target) !== target) {
+  if (path92__default.posix.normalize(target) !== target) {
     throw new Error("patch target must not contain dot segments or redundant separators");
   }
 }
 function canonicalApprovalLockKey(paths, target) {
   const wikiRoot = realpathSync(paths.wikiDir);
-  const relativeTarget = path93__default.posix.relative("wiki", target);
-  const targetPath = path93__default.join(wikiRoot, ...relativeTarget.split("/"));
+  const relativeTarget = path92__default.posix.relative("wiki", target);
+  const targetPath = path92__default.join(wikiRoot, ...relativeTarget.split("/"));
   return `${wikiRoot}\0${targetPath}`.toLowerCase();
 }
 function canonicalPatchEditLockKey(paths, patchId) {
@@ -36587,7 +36857,7 @@ function assertNoSymlinkPathComponents(target, paths) {
     throw error51;
   }
   for (const part of parts) {
-    current = path93__default.join(current, part);
+    current = path92__default.join(current, part);
     try {
       if (lstatSync(current).isSymbolicLink()) {
         throw new Error("patch target must not include symlink path components");
@@ -36602,8 +36872,8 @@ function assertSafeRawSourceRef(rawSourceRef, paths) {
   if (!rawSourceRef.startsWith("raw/")) {
     throw new Error("raw source provenance must point into raw/");
   }
-  const absoluteRef = path93__default.resolve(paths.root, rawSourceRef);
-  if (!absoluteRef.startsWith(`${paths.rawDir}${path93__default.sep}`)) {
+  const absoluteRef = path92__default.resolve(paths.root, rawSourceRef);
+  if (!absoluteRef.startsWith(`${paths.rawDir}${path92__default.sep}`)) {
     throw new Error("raw source provenance must point into raw/");
   }
 }
@@ -36619,14 +36889,14 @@ function classifyPatchConflict(error51) {
 }
 async function recordPatchConflict(patch, paths, reason, options) {
   const now = /* @__PURE__ */ new Date();
-  const targetPath = path93__default.join(paths.root, patch.frontmatter.target);
+  const targetPath = path92__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 record2 = await createConflict({
     reason,
     target: patch.frontmatter.target,
-    wikiId: proposedEntry?.id ?? path93__default.basename(patch.frontmatter.target, ".md"),
+    wikiId: proposedEntry?.id ?? path92__default.basename(patch.frontmatter.target, ".md"),
     title: proposedEntry?.title,
     proposer: patch.frontmatter.proposer,
     rawSourceRef: options?.rawSourceRef,
@@ -36722,11 +36992,11 @@ function parseInlineArray(value) {
   return inner.split(",").map((item) => item.trim().replace(/^"(.*)"$/, "$1"));
 }
 async function archiveQueueEntry(id, paths, meta3) {
-  const fromDir = path93__default.join(paths.queueDir, id);
-  const toDir = path93__default.join(paths.archiveDir, id);
+  const fromDir = path92__default.join(paths.queueDir, id);
+  const toDir = path92__default.join(paths.archiveDir, id);
   await removePath(toDir);
   await movePath(fromDir, toDir);
-  await writeJsonFile(path93__default.join(toDir, PATCH_META_FILENAME), meta3, paths);
+  await writeJsonFile(path92__default.join(toDir, PATCH_META_FILENAME), meta3, paths);
 }
 function buildQueueIdHelp(prefix, availableIds) {
   if (availableIds.length === 0) {
@@ -36934,7 +37204,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(path93__default.join(paths.root, sourceTarget));
+  const sourceExists = await pathExists(path92__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);
@@ -36956,7 +37226,7 @@ async function buildCompileProposals(input, paths, now, resolvedSource) {
     target: sourceTarget,
     summary: truncateSummary(`Compile source page ${sourcePageTitle}`),
     entry: sourceEntry,
-    baseHash: sourceExists ? computeContentHash(await readPatchFile(path93__default.join(paths.root, sourceTarget))) : void 0,
+    baseHash: sourceExists ? computeContentHash(await readPatchFile(path92__default.join(paths.root, sourceTarget))) : void 0,
     baseVersion: existingSourceEntry?.version
   }];
   const relatedCandidates = await discoverRelatedEntryCandidates(paths, resolvedSource.sourceContent, resolvedSource.sourceTitle);
@@ -36976,7 +37246,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(path93__default.join(paths.wikiDir, `${existing.id}.md`))),
+      baseHash: computeContentHash(await readPatchFile(path92__default.join(paths.wikiDir, `${existing.id}.md`))),
       baseVersion: existing.version
     });
   }
@@ -37111,13 +37381,13 @@ async function readClaims(entryId, paths) {
   }
 }
 function getClaimsDir(paths) {
-  return path93__default.join(paths.wikiDir, CLAIMS_DIRNAME);
+  return path92__default.join(paths.wikiDir, CLAIMS_DIRNAME);
 }
 function getClaimsFile(paths, entryId) {
   assertSafeEntryId(entryId);
-  const claimsFile = path93__default.join(getClaimsDir(paths), `${entryId}.json`);
-  const relative = path93__default.relative(getClaimsDir(paths), claimsFile);
-  if (!relative || relative.startsWith("..") || path93__default.isAbsolute(relative)) {
+  const claimsFile = path92__default.join(getClaimsDir(paths), `${entryId}.json`);
+  const relative = path92__default.relative(getClaimsDir(paths), claimsFile);
+  if (!relative || relative.startsWith("..") || path92__default.isAbsolute(relative)) {
     throw new Error(`[fleet-wiki] claims sidecar escapes wiki/.claims: ${entryId}`);
   }
   return claimsFile;
@@ -37208,7 +37478,7 @@ function assertSafeClaimRawRef(ref) {
   if (!ref.startsWith("raw/")) {
     throw new Error(`claim sourceRef must point into raw/: ${ref}`);
   }
-  if (ref.includes("..") || path93__default.isAbsolute(ref)) {
+  if (ref.includes("..") || path92__default.isAbsolute(ref)) {
     throw new Error(`claim sourceRef escapes raw/: ${ref}`);
   }
 }
@@ -37284,22 +37554,22 @@ async function runDryDock(paths, options = {}) {
   }
   for (const fileName of await listFileNames(paths.rawDir)) {
     if (!fileName.endsWith(".md")) continue;
-    const filePath = path93__default.join(paths.rawDir, fileName);
+    const filePath = path92__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 = path93__default.join(paths.queueDir, queueId);
+    const queueDir = path92__default.join(paths.queueDir, queueId);
     try {
-      const patchContent = await readPatchFile(path93__default.join(queueDir, PATCH_FILENAME));
-      issues.push(...safetyIssues(patchContent, path93__default.join(queueDir, PATCH_FILENAME)));
-      await readJsonFile2(path93__default.join(queueDir, PATCH_META_FILENAME));
+      const patchContent = await readPatchFile(path92__default.join(queueDir, PATCH_FILENAME));
+      issues.push(...safetyIssues(patchContent, path92__default.join(queueDir, PATCH_FILENAME)));
+      await readJsonFile2(path92__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(path93__default.join(paths.queueDir, PATCH_SET_DIRNAME))) {
-    const patchSetMetaFile = path93__default.join(paths.queueDir, PATCH_SET_DIRNAME, patchSetId, PATCH_META_FILENAME);
+  for (const patchSetId of await listDirectoryNames(path92__default.join(paths.queueDir, PATCH_SET_DIRNAME))) {
+    const patchSetMetaFile = path92__default.join(paths.queueDir, PATCH_SET_DIRNAME, patchSetId, PATCH_META_FILENAME);
     let patchSet;
     try {
       patchSet = await readPatchSet(paths, patchSetId);
@@ -37308,8 +37578,8 @@ async function runDryDock(paths, options = {}) {
       continue;
     }
     for (const patchId of patchSet.patchIds) {
-      const queueMetaFile = path93__default.join(paths.queueDir, patchId, PATCH_META_FILENAME);
-      const archiveMetaFile = path93__default.join(paths.archiveDir, patchId, PATCH_META_FILENAME);
+      const queueMetaFile = path92__default.join(paths.queueDir, patchId, PATCH_META_FILENAME);
+      const archiveMetaFile = path92__default.join(paths.archiveDir, patchId, PATCH_META_FILENAME);
       if (!await pathExists(queueMetaFile) && !await pathExists(archiveMetaFile)) {
         issues.push(
           issue2(
@@ -37346,7 +37616,7 @@ async function runDryDock(paths, options = {}) {
         "conflict_unresolved",
         "warning",
         `\uBBF8\uD574\uACB0 conflict: ${conflict.reason} (${conflict.target})`,
-        path93__default.join(paths.conflictsDir, conflict.id, "meta.json")
+        path92__default.join(paths.conflictsDir, conflict.id, "meta.json")
       )
     );
   }
@@ -37359,7 +37629,7 @@ async function runDryDock(paths, options = {}) {
           "unresolved_conflict",
           "warning",
           "\uC190\uC0C1\uB41C conflict \uC5D4\uD2B8\uB9AC",
-          path93__default.join(paths.conflictsDir, conflictId, "meta.json")
+          path92__default.join(paths.conflictsDir, conflictId, "meta.json")
         )
       );
     }
@@ -37416,8 +37686,8 @@ async function claimIssues(paths, wikiIds) {
   const claimsDir = getClaimsDir(paths);
   for (const fileName of await listFileNames(claimsDir)) {
     if (!fileName.endsWith(".json")) continue;
-    const filePath = path93__default.join(claimsDir, fileName);
-    const entryIdFromFile = path93__default.basename(fileName, ".json");
+    const filePath = path92__default.join(claimsDir, fileName);
+    const entryIdFromFile = path92__default.basename(fileName, ".json");
     let raw;
     try {
       raw = await readJsonFile2(filePath);
@@ -37496,7 +37766,7 @@ function toSemanticEntry(filePath, frontmatter, body) {
 async function schemaIssues(paths) {
   const issues = [];
   const schema = await readWorkspaceSchemaSummary(paths);
-  const agentsPath = path93__default.join(paths.schemaDir, WORKSPACE_SCHEMA_AGENTS_FILENAME);
+  const agentsPath = path92__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 {
@@ -37816,7 +38086,7 @@ function parseOptionalIsoDate(value) {
   return Number.isFinite(timestamp) ? timestamp : null;
 }
 function hashBodyForComparison(body) {
-  return crypto4.createHash("sha256").update(body.replace(/\s+/g, " ").trim(), "utf8").digest("hex").slice(0, 8);
+  return crypto3.createHash("sha256").update(body.replace(/\s+/g, " ").trim(), "utf8").digest("hex").slice(0, 8);
 }
 function hasConflictingStatuses(entries) {
   const statuses = new Set(entries.map((entry) => entry.status).filter((status) => status !== "unknown"));
@@ -37883,7 +38153,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 = path93__default.join(dirPath, entry.name);
+    const filePath = path92__default.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listWikiMarkdownFiles(filePath));
       continue;
@@ -37965,7 +38235,7 @@ async function planIngest(input, paths, now) {
   const target = `wiki/${input.id}.md`;
   const proposer = input.proposer ?? "tool:wiki_ingest";
   const currentEntry = await readWikiEntry(input.id, paths);
-  const currentMarkdown = currentEntry ? await readPatchFile(path93__default.join(paths.wikiDir, `${input.id}.md`)) : void 0;
+  const currentMarkdown = currentEntry ? await readPatchFile(path92__default.join(paths.wikiDir, `${input.id}.md`)) : void 0;
   const currentHash = currentMarkdown ? computeContentHash(currentMarkdown) : void 0;
   const rawSource = buildRawSourceEntry(input, now);
   await ensureWorkspaceSchema(paths);
@@ -38644,11 +38914,11 @@ async function editQueuedPatch(input, paths) {
   };
 }
 async function readQueuedPatchSnapshot(paths, patchId) {
-  const queueDir = path93__default.join(paths.queueDir, patchId);
-  const markdown = await readPatchFile(path93__default.join(queueDir, PATCH_FILENAME));
+  const queueDir = path92__default.join(paths.queueDir, patchId);
+  const markdown = await readPatchFile(path92__default.join(queueDir, PATCH_FILENAME));
   return {
     patch: await parsePatch(markdown),
-    meta: await readJsonFile2(path93__default.join(queueDir, PATCH_META_FILENAME)),
+    meta: await readJsonFile2(path92__default.join(queueDir, PATCH_META_FILENAME)),
     patchHash: computeContentHash(markdown)
   };
 }
@@ -39404,7 +39674,7 @@ ${input.answer ?? ""}`)}`;
   assertSafeEntryId(targetId);
   const subdir = input.targetType === "synthesis" ? "synthesis" : "queries";
   const target = `wiki/${subdir}/${targetId}.md`;
-  const absoluteTarget = path93__default.join(paths.root, target);
+  const absoluteTarget = path92__default.join(paths.root, target);
   const exists = await pathExists(absoluteTarget);
   const existingEntry = exists ? await readWikiEntry(targetId, paths) : null;
   if (exists && !existingEntry) {
@@ -39486,7 +39756,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("..") || path93__default.isAbsolute(rawRef)) {
+  if (rawRef.includes("..") || path92__default.isAbsolute(rawRef)) {
     throw new Error(`[fleet-wiki] wiki_query raw source ref escapes raw/: ${rawRef}`);
   }
 }
@@ -39605,7 +39875,7 @@ async function buildReadEntryResult(entry, paths, graph, input) {
     rawSourceRef: entry.rawSourceRef,
     rawSourceRefs,
     source: {
-      path: path93__default.join("wiki", `${entry.id}.md`),
+      path: path92__default.join("wiki", `${entry.id}.md`),
       rawSourceRef: entry.rawSourceRef,
       rawSourceRefs
     },
@@ -39731,7 +40001,7 @@ function buildRelatedEntries(entry, graph) {
     deduped.set(candidate.id, {
       id: relatedEntry.id,
       title: relatedEntry.title,
-      path: path93__default.join("wiki", `${relatedEntry.id}.md`),
+      path: path92__default.join("wiki", `${relatedEntry.id}.md`),
       reason: candidate.reason
     });
   }
@@ -40000,7 +40270,7 @@ function buildWikiToolSpec(config2, usage) {
 }
 
 // src/carrier-settings-routes.ts
-var SUBAGENT_CLI_TYPES = /* @__PURE__ */ new Set(["claude", "claude-zai", "claude-kimi"]);
+var SUBAGENT_CLI_TYPES = /* @__PURE__ */ new Set(["claude", "claude-zai", "claude-kimi", "claude-glm"]);
 var TASKFORCE_MIN_BACKENDS = 2;
 function createCarrierSettingsRouter(deps) {
   const controller = createStatusOverlayController(deps.registry);
@@ -40440,13 +40710,13 @@ function safeEqual(left, right) {
   return timingSafeEqual(leftBytes, rightBytes);
 }
 function workspaceHash(canonicalCwd) {
-  return crypto4.createHash("sha256").update(canonicalCwd).digest("hex").slice(0, 12);
+  return crypto3.createHash("sha256").update(canonicalCwd).digest("hex").slice(0, 12);
 }
 async function canonicalizeTheaterPath(cwd) {
   return canonicalizeTheaterPathSync(cwd);
 }
 function canonicalizeTheaterPathSync(cwd) {
-  const resolved = path93__default.resolve(cwd);
+  const resolved = path92__default.resolve(cwd);
   try {
     return fs7__default.realpathSync.native(resolved);
   } catch {
@@ -40454,7 +40724,7 @@ function canonicalizeTheaterPathSync(cwd) {
   }
 }
 function theaterLabel(cwd) {
-  return path93__default.basename(cwd) || cwd;
+  return path92__default.basename(cwd) || cwd;
 }
 
 // src/codex/workspaces.ts
@@ -40462,7 +40732,7 @@ var WorkspaceRegistry = class {
   #items = /* @__PURE__ */ new Map();
   #mruId = null;
   async register(cwdInput, lastOpenedAt) {
-    const cwd = path93__default.resolve(cwdInput);
+    const cwd = path92__default.resolve(cwdInput);
     const real = await canonicalizeTheaterPath(cwd);
     const paths = resolveMemoryPaths(real);
     if (!await directoryExists(paths.root)) {
@@ -40478,7 +40748,7 @@ var WorkspaceRegistry = class {
       id,
       cwd,
       realpath: real,
-      label: path93__default.basename(cwd),
+      label: path92__default.basename(cwd),
       paths,
       registeredAt: existing?.registeredAt ?? now,
       // 복원 경로는 durable lastOpenedAt을 그대로 보존해 재시작 후에도 워크스페이스 최근성
@@ -41281,7 +41551,7 @@ function statusRank(status) {
 
 // src/security-headers.ts
 var CONSOLE_SECURITY_HEADERS = {
-  "Content-Security-Policy": "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self' data:; connect-src 'self' ws: wss:; object-src 'none'; base-uri 'none'",
+  "Content-Security-Policy": "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self' data:; connect-src 'self' ws: wss: https://api.github.com; object-src 'none'; base-uri 'none'",
   "X-Content-Type-Options": "nosniff",
   "Referrer-Policy": "no-referrer",
   "Cache-Control": "no-store"
@@ -41533,7 +41803,7 @@ function createConsoleDurableStateStore(deps = {}) {
   const createStore = deps.createStore ?? createDurableJsonStore;
   return createStore({
     filePath: paths.stateFile,
-    lockDir: path93__default.join(paths.dir, STATE_LOCK_DIR_NAME),
+    lockDir: path92__default.join(paths.dir, STATE_LOCK_DIR_NAME),
     lockOwnerFileName: STATE_LOCK_OWNER_FILE_NAME,
     now: deps.now,
     sanitize: sanitizeDurableConsoleState,
@@ -41555,7 +41825,7 @@ function emptyDurableConsoleState() {
 function readProviderSessionCapture(fleetSessionId, deps = {}) {
   if (!isSafeCaptureId(fleetSessionId)) return null;
   const capturesDir = deps.capturesDir ?? createConsoleDataPaths().capturesDir;
-  const filePath = path93__default.join(capturesDir, `${fleetSessionId}.json`);
+  const filePath = path92__default.join(capturesDir, `${fleetSessionId}.json`);
   try {
     const parsed = JSON.parse(fs7__default.readFileSync(filePath, "utf8"));
     return sanitizeProviderSession(parsed);
@@ -41578,7 +41848,7 @@ function unlinkProviderSessionCapture(fleetSessionId, deps = {}) {
   if (!isSafeCaptureId(fleetSessionId)) return false;
   const capturesDir = deps.capturesDir ?? createConsoleDataPaths().capturesDir;
   try {
-    fs7__default.unlinkSync(path93__default.join(capturesDir, `${fleetSessionId}.json`));
+    fs7__default.unlinkSync(path92__default.join(capturesDir, `${fleetSessionId}.json`));
     return true;
   } catch {
     return false;
@@ -41627,6 +41897,9 @@ function sanitizeDurableOperation(value) {
   const sequence = readPositiveInteger(value.sequence);
   const createdAt = readFiniteNumber(value.createdAt);
   if (!sessionId || !theaterId || !cwd || !cwdLabel || sequence === null || createdAt === null) return null;
+  const label = readOptionalString(value.label);
+  const labelSource = readLabelSource(value.labelSource);
+  const autoNamePromptSeen = value.autoNamePromptSeen === true || labelSource === "auto" && label !== void 0;
   const providerSession = sanitizeProviderSession(value.providerSession);
   return {
     sessionId,
@@ -41634,7 +41907,9 @@ function sanitizeDurableOperation(value) {
     cwd,
     cwdLabel,
     sequence,
-    ...readOptionalString(value.label) ? { label: readOptionalString(value.label) } : {},
+    ...label ? { label } : {},
+    ...labelSource ? { labelSource } : {},
+    ...autoNamePromptSeen ? { autoNamePromptSeen: true } : {},
     ...readOptionalString(value.cliId) ? { cliId: readOptionalString(value.cliId) } : {},
     ...readOptionalString(value.cliLabel) ? { cliLabel: readOptionalString(value.cliLabel) } : {},
     createdAt,
@@ -41659,7 +41934,7 @@ function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isSafeCaptureId(value) {
-  return value.length > 0 && path93__default.basename(value) === value && !value.includes(path93__default.sep) && !value.includes(path93__default.posix.sep);
+  return value.length > 0 && path92__default.basename(value) === value && !value.includes(path92__default.sep) && !value.includes(path92__default.posix.sep);
 }
 function readNonEmptyString(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
@@ -41667,6 +41942,9 @@ function readNonEmptyString(value) {
 function readOptionalString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
+function readLabelSource(value) {
+  return value === "user" || value === "auto" ? value : void 0;
+}
 function readPositiveInteger(value) {
   return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : null;
 }
@@ -41674,6 +41952,69 @@ function readFiniteNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 
+// src/auto-name.ts
+var MAX_LABEL_LENGTH = 60;
+var MIN_LABEL_LENGTH = 4;
+var MAX_SCAN_LINES = 6;
+var SECRET_MIN_TOKEN_LENGTH = 24;
+var CODE_FENCE_PATTERN = /^(```|~~~)/;
+var MARKER_PREFIX_PATTERN = /^([>#]+|[-*+]|\d+[.)])\s+/;
+var WRAPPER_TRIM_PATTERN = /^[*_`~]+|[*_`~]+$/g;
+var CONTROL_CHAR_PATTERN2 = new RegExp("[\\u0000-\\u001F\\u007F]", "g");
+var WHITESPACE_RUN_PATTERN = /\s+/g;
+var TRAILING_PUNCT_PATTERN = /[.,;:!?)\]}'"]+$/;
+var URL_PATTERN = /(https?:\/\/|ftp:\/\/|www\.)/i;
+var PATH_PATTERN = /(^|\s)(\/[^\s/]|~\/|\.{1,2}\/|[a-zA-Z]:[\\/])/;
+var LOW_SIGNAL_PATTERN = /^(continue|계속|진행|다음|next|ok|okay|go|run|yes|yep|sure|y|n|no|네|응|예|그래|stop|wait|hold on|fix it|do it|please|thanks?|thank you)$/i;
+var SECRET_PREFIX_PATTERN = /^(ghp_|gho_|ghs_|ghu_|ghr_|github_pat_|sk-|sk_live_|sk_test_|pk-|rk-|xox[baprs]-|AKIA|ASIA|AIza|ya29\.|glpat-|eyJ)/;
+var SECRET_CHARSET_PATTERN = /^[A-Za-z0-9_\-+/=.]+$/;
+function deriveOperationLabel(prompt) {
+  if (typeof prompt !== "string" || prompt.length === 0) return null;
+  const lines = prompt.split(/\r?\n/);
+  let examined = 0;
+  let inFence = false;
+  for (const rawLine of lines) {
+    const trimmed = rawLine.trim();
+    if (trimmed.length === 0) continue;
+    if (CODE_FENCE_PATTERN.test(trimmed)) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) continue;
+    examined += 1;
+    if (examined > MAX_SCAN_LINES) break;
+    const candidate = normalizeLine(trimmed);
+    if (candidate !== null) return candidate;
+  }
+  return null;
+}
+function normalizeLine(line) {
+  let value = line.replace(CONTROL_CHAR_PATTERN2, " ").replace(WHITESPACE_RUN_PATTERN, " ").trim();
+  for (let depth = 0; depth < 4; depth += 1) {
+    const before = value;
+    value = value.replace(MARKER_PREFIX_PATTERN, "").trim();
+    value = value.replace(WRAPPER_TRIM_PATTERN, "").trim();
+    if (value === before) break;
+  }
+  if (value.length === 0) return null;
+  if (value.startsWith("/")) return null;
+  if (URL_PATTERN.test(value)) return null;
+  if (PATH_PATTERN.test(value)) return null;
+  if (hasSecretToken(value)) return null;
+  if (LOW_SIGNAL_PATTERN.test(value)) return null;
+  if (value.length < MIN_LABEL_LENGTH) return null;
+  return value.length > MAX_LABEL_LENGTH ? value.slice(0, MAX_LABEL_LENGTH).trimEnd() : value;
+}
+function hasSecretToken(value) {
+  return value.split(/\s+/).some(looksSecretToken);
+}
+function looksSecretToken(rawToken) {
+  const token = rawToken.replace(TRAILING_PUNCT_PATTERN, "");
+  if (token.length === 0) return false;
+  if (SECRET_PREFIX_PATTERN.test(token)) return true;
+  return token.length >= SECRET_MIN_TOKEN_LENGTH && SECRET_CHARSET_PATTERN.test(token) && /[0-9]/.test(token) && /[A-Za-z]/.test(token);
+}
+
 // src/global-settings-routes.ts
 function createGlobalSettingsRouter(deps) {
   return async function handleGlobalSettingsRoute(context) {
@@ -41740,6 +42081,259 @@ function isJsonRequest3(req) {
   const contentType = req.headers["content-type"];
   return typeof contentType === "string" && contentType.toLowerCase().split(";")[0]?.trim() === "application/json";
 }
+var BINARY_DISPLAY_NAMES = {
+  claude: "Claude Code",
+  codex: "Codex CLI",
+  opencode: "OpenCode",
+  "cursor-agent": "Cursor Agent"
+};
+var OVERRIDE_ENV_BY_COMMAND = {
+  claude: "CLAUDE_BIN",
+  codex: "CODEX_BIN"
+};
+var VERSION_PROBE_TIMEOUT_MS = 5e3;
+var SEMVER_PATTERN = /(\d+\.\d+\.\d+)/;
+function createAgentCliDetector(deps) {
+  return {
+    detect: async () => {
+      const commands = distinctBinaryCommands();
+      return Promise.all(commands.map((command2) => detectOne(command2, deps)));
+    }
+  };
+}
+function createDefaultAgentCliDetector() {
+  return createAgentCliDetector({
+    resolve: (command2) => resolveCommandWithOverride(command2, process.env),
+    runVersion: (bin, args) => execFileVersion(bin, args)
+  });
+}
+function resolveCommandWithOverride(command2, env) {
+  const overrideName = OVERRIDE_ENV_BY_COMMAND[command2];
+  const override = overrideName ? env[overrideName] : void 0;
+  if (override && override.trim().length > 0) {
+    return resolvePathBinary(override, env);
+  }
+  return resolvePathBinary(command2, env);
+}
+function distinctBinaryCommands() {
+  const seen = /* @__PURE__ */ new Set();
+  const commands = [];
+  for (const backend of Object.values(CLI_BACKENDS)) {
+    if (!seen.has(backend.cliCommand)) {
+      seen.add(backend.cliCommand);
+      commands.push(backend.cliCommand);
+    }
+  }
+  return commands;
+}
+async function detectOne(command2, deps) {
+  const resolved = deps.resolve(command2);
+  const available = resolved !== void 0;
+  let version2 = null;
+  if (resolved) {
+    version2 = await probeVersionSafe(resolved, deps);
+  }
+  return {
+    id: command2,
+    displayName: BINARY_DISPLAY_NAMES[command2] ?? command2,
+    available,
+    version: version2
+  };
+}
+async function probeVersionSafe(resolved, deps) {
+  try {
+    const output = await deps.runVersion(resolved.bin, [...resolved.prefixArgs, "--version"]);
+    return output.match(SEMVER_PATTERN)?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+function execFileVersion(bin, args) {
+  return new Promise((resolve, reject) => {
+    execFile(
+      bin,
+      [...args],
+      { encoding: "utf-8", timeout: VERSION_PROBE_TIMEOUT_MS, windowsHide: true },
+      (error51, stdout, stderr) => {
+        if (error51) {
+          reject(error51);
+          return;
+        }
+        resolve((stdout || stderr || "").trim());
+      }
+    );
+  });
+}
+
+// src/agent-cli-launch-metadata.ts
+function combineAgentCliLaunchMetadata(metadata, installStatuses, authStatuses) {
+  const availableByCommand = new Map(installStatuses.map((entry) => [entry.id, entry.available]));
+  const signedInByCli = new Map(authStatuses.map((entry) => [entry.cli, entry.signedIn]));
+  return metadata.map((meta3) => ({
+    id: meta3.id,
+    label: meta3.label,
+    // claude 계열 3종은 같은 `claude` 바이너리를 공유하므로 cliCommand로 설치 여부를 판정한다.
+    available: availableByCommand.get(CLI_BACKENDS[meta3.id].cliCommand) ?? false,
+    // model-auth 게이트 대상(claude-kimi/glm)만 실제 로그인 상태를 반영하고,
+    // 자체 인증 CLI(claude/codex)는 Fleet이 로그인 여부를 알 수 없으므로 게이트하지 않는다(true).
+    signedIn: signedInByCli.has(meta3.id) ? signedInByCli.get(meta3.id) ?? false : true
+  }));
+}
+
+// src/agent-cli-routes.ts
+function createAgentCliRouter(deps) {
+  return async function handleAgentCliRoute(context) {
+    const { req, res, pathname } = context;
+    if (pathname === "/agent-cli/state") {
+      if (req.method !== "GET") {
+        deps.writeJson(res, 405, { error: "Method not allowed" });
+        return true;
+      }
+      const clis = await deps.detect();
+      const body = { clis };
+      deps.writeJson(res, 200, body);
+      return true;
+    }
+    return false;
+  };
+}
+
+// src/model-auth-routes.ts
+var MODEL_AUTH_PROVIDERS = [
+  { cli: "claude-kimi", displayName: "Moonshot Kimi" },
+  { cli: "claude-glm", displayName: "ZhipuAI GLM" }
+];
+var UPSTREAM_FAILURE_STATUSES = /* @__PURE__ */ new Set(["timeout", "network", "server"]);
+function createModelAuthRouter(deps) {
+  return async function handleModelAuthRoute(context) {
+    const { req, res, pathname } = context;
+    if (pathname === "/model-auth/state") {
+      if (req.method !== "GET") {
+        deps.writeJson(res, 405, { error: "Method not allowed" });
+        return true;
+      }
+      deps.writeJson(res, 200, await buildModelAuthState(deps.authService));
+      return true;
+    }
+    const cli = parseProviderPath(pathname);
+    if (!cli) return false;
+    const provider = MODEL_AUTH_PROVIDERS.find((entry) => entry.cli === cli);
+    if (!provider) {
+      deps.writeJson(res, 404, { error: "provider_not_found" });
+      return true;
+    }
+    if (req.method === "PUT") {
+      await signInProvider(req, res, deps, provider);
+      return true;
+    }
+    if (req.method === "DELETE") {
+      await signOutProvider(req, res, deps, provider);
+      return true;
+    }
+    deps.writeJson(res, 405, { error: "Method not allowed" });
+    return true;
+  };
+}
+async function buildModelAuthState(authService) {
+  const signedInIds = new Set(await authService.listProviderIds());
+  return {
+    providers: MODEL_AUTH_PROVIDERS.map((provider) => toProviderState(provider, signedInIds))
+  };
+}
+async function signInProvider(req, res, deps, provider) {
+  if (!deps.isAuthorized(req)) {
+    deps.writeJson(res, 401, { error: "unauthorized" });
+    return;
+  }
+  if (!isJsonRequest4(req)) {
+    deps.writeJson(res, 415, { error: "unsupported_media_type" });
+    return;
+  }
+  const body = await deps.readJsonBody(req);
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    deps.writeJson(res, 400, { error: "invalid_json" });
+    return;
+  }
+  const apiKey = typeof body.apiKey === "string" ? body.apiKey.trim() : "";
+  if (apiKey.length === 0) {
+    deps.writeJson(res, 400, { error: "invalid_api_key" });
+    return;
+  }
+  const providerId = CLI_TO_AUTH_PROVIDER_ID[provider.cli];
+  if (!providerId) {
+    deps.writeJson(res, 500, { error: "provider_unavailable" });
+    return;
+  }
+  const validation = await deps.validateApiKey(provider.cli, apiKey);
+  if (validation.status !== "success") {
+    const status = UPSTREAM_FAILURE_STATUSES.has(validation.status) ? 502 : 400;
+    deps.writeJson(res, status, {
+      error: formatSignInFailureMessage(provider.displayName, validation.status),
+      status: validation.status
+    });
+    return;
+  }
+  await deps.authService.setApiKey(providerId, apiKey);
+  await writeMutationState2(res, deps);
+}
+async function signOutProvider(req, res, deps, provider) {
+  if (!deps.isAuthorized(req)) {
+    deps.writeJson(res, 401, { error: "unauthorized" });
+    return;
+  }
+  const providerId = CLI_TO_AUTH_PROVIDER_ID[provider.cli];
+  if (!providerId) {
+    deps.writeJson(res, 500, { error: "provider_unavailable" });
+    return;
+  }
+  await deps.authService.deleteApiKey(providerId);
+  await writeMutationState2(res, deps);
+}
+async function writeMutationState2(res, deps) {
+  const response = { state: await buildModelAuthState(deps.authService) };
+  deps.writeJson(res, 200, response);
+}
+function toProviderState(provider, signedInIds) {
+  const providerId = CLI_TO_AUTH_PROVIDER_ID[provider.cli] ?? provider.cli;
+  return {
+    cli: provider.cli,
+    displayName: provider.displayName,
+    signedIn: signedInIds.has(providerId)
+  };
+}
+function parseProviderPath(pathname) {
+  const parts = pathname.split("/").filter(Boolean);
+  if (parts.length !== 3 || parts[0] !== "model-auth" || parts[1] !== "providers") return null;
+  const cli = safeDecodeURIComponent2(parts[2] ?? "");
+  return cli ? cli : null;
+}
+function safeDecodeURIComponent2(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return null;
+  }
+}
+function isJsonRequest4(req) {
+  const contentType = req.headers["content-type"];
+  return typeof contentType === "string" && contentType.toLowerCase().split(";")[0]?.trim() === "application/json";
+}
+function formatSignInFailureMessage(displayName, status) {
+  switch (status) {
+    case "unauthorized":
+      return `${displayName} rejected the API key. Check the key and try again.`;
+    case "forbidden":
+      return `The API key is not allowed for ${displayName}. Check its permissions.`;
+    case "timeout":
+      return `Validating the ${displayName} API key timed out. Check your connection and try again.`;
+    case "network":
+      return `Could not reach ${displayName} to validate the API key. Check your connection and try again.`;
+    case "server":
+      return `${displayName} returned an error while validating the API key. Try again later.`;
+    default:
+      return `Could not validate the ${displayName} API key. Check the key and try again.`;
+  }
+}
 
 // src/observability-routes.ts
 function writeObserverEvents(req, res, workspace, store2) {
@@ -41779,10 +42373,14 @@ function writeAggregateObserverEvents(req, res, workspaces, store2, resolveWorks
   }
   const unsubscribers = options.subscribeAll ? [
     store2.subscribeAll((event) => {
-      if (isSessionUpdatedEvent(event) || isSessionAttentionEvent(event)) {
+      if (isSessionUpdatedEvent(event)) {
         writeEvent(res, 0, event.type, { session: event.session });
         return;
       }
+      if (isSessionAttentionEvent(event)) {
+        writeEvent(res, 0, event.type, { session: event.session, reason: event.reason });
+        return;
+      }
       writeEvent(res, event.id, event.type, { tenant: resolvedWorkspaceSnapshot(resolveWorkspace, event.tenantId), event });
     })
   ] : workspaces.map(
@@ -41932,7 +42530,7 @@ function createConsoleObservabilityStore(deps = {}) {
     return terminalSessionsById.get(sessionId)?.cwd ?? workspacesByCliRunId.get(sessionId)?.session.cwd ?? null;
   }
   function createPendingTerminalSession(input) {
-    if (!path93__default.isAbsolute(input.cwd)) throw new Error("Terminal session cwd must be absolute");
+    if (!path92__default.isAbsolute(input.cwd)) throw new Error("Terminal session cwd must be absolute");
     const createdAt = input.createdAt ?? now();
     const canonicalCwd = canonicalizeTheaterPathSync(input.cwd);
     const theaterId = workspaceHash(canonicalCwd);
@@ -41942,7 +42540,7 @@ function createConsoleObservabilityStore(deps = {}) {
       sessionId: input.sessionId,
       cwd: input.cwd,
       canonicalCwd,
-      cwdLabel: path93__default.basename(input.cwd) || input.cwd,
+      cwdLabel: path92__default.basename(input.cwd) || input.cwd,
       sequence,
       cliId: input.cliId,
       createdAt,
@@ -41963,6 +42561,8 @@ function createConsoleObservabilityStore(deps = {}) {
       cwdLabel: operation.cwdLabel,
       sequence: operation.sequence,
       label: operation.label,
+      labelSource: operation.labelSource,
+      autoNamePromptSeen: operation.autoNamePromptSeen,
       cliId: operation.cliId,
       cliLabel: operation.cliLabel,
       createdAt: operation.createdAt,
@@ -41985,6 +42585,8 @@ function createConsoleObservabilityStore(deps = {}) {
       cwdLabel: session.cwdLabel,
       sequence: session.sequence,
       ...session.label ? { label: session.label } : {},
+      ...session.labelSource ? { labelSource: session.labelSource } : {},
+      ...session.autoNamePromptSeen ? { autoNamePromptSeen: true } : {},
       ...session.cliId ? { cliId: session.cliId } : {},
       ...session.cliLabel ? { cliLabel: session.cliLabel } : {},
       createdAt: session.createdAt,
@@ -42030,11 +42632,31 @@ function createConsoleObservabilityStore(deps = {}) {
     const label = rawLabel.trim().slice(0, 200);
     if (label.length === 0) {
       delete session.label;
+      delete session.labelSource;
+      delete session.autoNamePromptSeen;
     } else {
       session.label = label;
+      session.labelSource = "user";
+      session.autoNamePromptSeen = true;
     }
     return toTerminalSessionInfo(session);
   }
+  function autoNameTerminalSession(sessionId, label) {
+    const session = terminalSessionsById.get(sessionId);
+    if (!session) return null;
+    const effectiveSource = session.labelSource ?? (session.label ? "user" : void 0);
+    if (effectiveSource === "user" || session.autoNamePromptSeen) {
+      return { session: toTerminalSessionInfo(session), changed: false, renamed: false };
+    }
+    session.autoNamePromptSeen = true;
+    const next = label?.trim().slice(0, 200) ?? "";
+    if (next.length === 0 || next === session.label) {
+      return { session: toTerminalSessionInfo(session), changed: true, renamed: false };
+    }
+    session.label = next;
+    session.labelSource = "auto";
+    return { session: toTerminalSessionInfo(session), changed: true, renamed: true };
+  }
   function notifySessionUpdated(session) {
     const event = { type: "session:updated", session };
     for (const listener of allListeners) listener(event);
@@ -42043,8 +42665,8 @@ function createConsoleObservabilityStore(deps = {}) {
     const session = terminalSessionsById.get(sessionId);
     return session ? toTerminalSessionInfo(session) : null;
   }
-  function notifySessionAttention(session) {
-    const event = { type: "session:attention", session };
+  function notifySessionAttention(session, reason) {
+    const event = { type: "session:attention", session, reason };
     for (const listener of allListeners) listener(event);
   }
   function removeTerminalSession(sessionId) {
@@ -42085,6 +42707,7 @@ function createConsoleObservabilityStore(deps = {}) {
     notifySessionAttention,
     notifySessionUpdated,
     renameTerminalSession,
+    autoNameTerminalSession,
     subscribe,
     subscribeAll,
     updateTerminalSessionProviderSession,
@@ -42318,7 +42941,7 @@ function tryServeStaticConsole(req, res, pathname) {
     res.end(JSON.stringify({ error: "Not found" }));
     return true;
   }
-  const absolutePath = path93__default.resolve(CONSOLE_ROOT, relativePath2);
+  const absolutePath = path92__default.resolve(CONSOLE_ROOT, relativePath2);
   if (!absolutePath.startsWith(CONSOLE_ROOT)) {
     res.writeHead(404, withSecurityHeaders2({ "Content-Type": "application/json" }));
     res.end(JSON.stringify({ error: "Not found" }));
@@ -42326,7 +42949,7 @@ function tryServeStaticConsole(req, res, pathname) {
   }
   try {
     const data = fs7__default.readFileSync(absolutePath);
-    const contentType = MIME_TYPES[path93__default.extname(absolutePath)] ?? "application/octet-stream";
+    const contentType = MIME_TYPES[path92__default.extname(absolutePath)] ?? "application/octet-stream";
     res.writeHead(200, withSecurityHeaders2({ "Content-Type": contentType }));
     if (req.method === "HEAD") {
       res.end();
@@ -42346,7 +42969,7 @@ function tryServeStaticConsole(req, res, pathname) {
 }
 function serveFallbackIndex(req, res) {
   try {
-    const data = fs7__default.readFileSync(path93__default.join(CONSOLE_ROOT, "index.html"));
+    const data = fs7__default.readFileSync(path92__default.join(CONSOLE_ROOT, "index.html"));
     res.writeHead(200, withSecurityHeaders2({ "Content-Type": MIME_TYPES[".html"] }));
     if (req.method === "HEAD") {
       res.end();
@@ -42372,7 +42995,7 @@ function resolveConsolePath(pathname) {
   }
   if (withoutPrefix === "") return "index.html";
   if (withoutPrefix.includes("\0")) return null;
-  if (!path93__default.extname(withoutPrefix)) return "index.html";
+  if (!path92__default.extname(withoutPrefix)) return "index.html";
   return withoutPrefix;
 }
 var TerminalFolderListError = class extends Error {
@@ -42406,14 +43029,14 @@ async function listTerminalFolders(requestedPath, deps = {}) {
 }
 function normalizeFolderBrowserPath(value, platform = process.platform) {
   if (typeof value !== "string" || value.length === 0 || value.includes("\0")) throw new TerminalFolderListError("invalid_path");
-  if (isWindowsAmbiguousPath(value, platform) || !path93__default.isAbsolute(value)) throw new TerminalFolderListError("invalid_path");
-  return path93__default.resolve(value);
+  if (isWindowsAmbiguousPath(value, platform) || !path92__default.isAbsolute(value)) throw new TerminalFolderListError("invalid_path");
+  return path92__default.resolve(value);
 }
 function normalizeListPath(requestedPath, platform, deps) {
   if (requestedPath === null || requestedPath === void 0) {
     const home = deps.homedir?.() ?? os22__default.homedir();
     const start = home || deps.cwd?.() || process.cwd();
-    return path93__default.resolve(start);
+    return path92__default.resolve(start);
   }
   return normalizeFolderBrowserPath(requestedPath, platform);
 }
@@ -42464,7 +43087,7 @@ async function openDirectory(targetPath, opendir) {
 }
 async function toTerminalFolderEntry(targetPath, dirent, stat5) {
   if (!dirent.isDirectory() && !dirent.isSymbolicLink()) return null;
-  const entryPath = path93__default.join(targetPath, dirent.name);
+  const entryPath = path92__default.join(targetPath, dirent.name);
   if (dirent.isDirectory()) return { name: dirent.name, path: entryPath, kind: "dir", accessible: true };
   const accessible = await statSymlinkDirectory(entryPath, stat5);
   if (accessible === null) return null;
@@ -42484,10 +43107,10 @@ function mapFsError(error51) {
   return new TerminalFolderListError("invalid_path");
 }
 function parentPath(targetPath, platform) {
-  const parsed = path93__default.parse(targetPath);
-  const resolved = path93__default.resolve(targetPath);
-  if (resolved === path93__default.resolve(parsed.root)) return null;
-  const parent = path93__default.dirname(resolved);
+  const parsed = path92__default.parse(targetPath);
+  const resolved = path92__default.resolve(targetPath);
+  if (resolved === path92__default.resolve(parsed.root)) return null;
+  const parent = path92__default.dirname(resolved);
   if (platform === "win32" && parent === resolved) return null;
   return parent;
 }
@@ -42498,14 +43121,14 @@ function isWindowsAmbiguousPath(value, platform) {
 var GRANT_ID_BYTES = 24;
 var DEFAULT_GRANT_TTL_MS = 6e4;
 function createFolderGrantStore(deps = {}) {
-  const randomId = deps.randomId ?? (() => crypto4.randomBytes(GRANT_ID_BYTES).toString("base64url"));
-  const statSync5 = deps.statSync ?? fs7__default.statSync;
+  const randomId = deps.randomId ?? (() => crypto3.randomBytes(GRANT_ID_BYTES).toString("base64url"));
+  const statSync4 = deps.statSync ?? fs7__default.statSync;
   const ttlMs = deps.ttlMs ?? DEFAULT_GRANT_TTL_MS;
   const now = deps.now ?? Date.now;
   const grants = /* @__PURE__ */ new Map();
   function issue3(cwd) {
     prune();
-    const normalized = validateAbsoluteDirectory(cwd, statSync5);
+    const normalized = validateAbsoluteDirectory(cwd, statSync4);
     const folderGrantId = randomId();
     grants.set(folderGrantId, { cwd: normalized, expiresAt: now() + ttlMs });
     return folderGrantId;
@@ -42525,11 +43148,11 @@ function createFolderGrantStore(deps = {}) {
   }
   return { issue: issue3, consume };
 }
-function validateAbsoluteDirectory(cwd, statSync5 = fs7__default.statSync) {
+function validateAbsoluteDirectory(cwd, statSync4 = fs7__default.statSync) {
   if (typeof cwd !== "string" || cwd.length === 0 || cwd.includes("\0")) throw new Error("invalid_folder");
-  if (isWindowsAmbiguousPath2(cwd) || !path93__default.isAbsolute(cwd)) throw new Error("invalid_folder");
-  const normalized = path93__default.resolve(cwd);
-  if (!statSync5(normalized).isDirectory()) throw new Error("invalid_folder");
+  if (isWindowsAmbiguousPath2(cwd) || !path92__default.isAbsolute(cwd)) throw new Error("invalid_folder");
+  const normalized = path92__default.resolve(cwd);
+  if (!statSync4(normalized).isDirectory()) throw new Error("invalid_folder");
   return normalized;
 }
 function isWindowsAmbiguousPath2(value) {
@@ -42551,8 +43174,11 @@ function buildConsoleTurnHookCommand(entry, phase) {
 function buildConsoleAttentionHookCommand(entry) {
   return buildConsoleCliHookExec(entry, ["hook", "attention"]);
 }
+function buildConsoleAutoNameHookCommand(entry) {
+  return buildConsoleCliHookExec(entry, ["hook", "auto-name"]);
+}
 function buildConsoleCaptureHookCommand(entry, cliId) {
-  const extension = path93__default.extname(entry.entryPath);
+  const extension = path92__default.extname(entry.entryPath);
   if (JAVASCRIPT_ENTRY_EXTENSIONS.has(extension)) {
     return createSessionCaptureHookExec({
       entryPath: entry.entryPath,
@@ -42592,11 +43218,11 @@ function runCodexCommand(command2) {
 }
 function withConsoleMarketplaceLock(target, fn) {
   const lockDir = `${target}${MARKETPLACE_LOCK_DIR_SUFFIX}`;
-  mkdirSync(path93__default.dirname(lockDir), { recursive: true });
+  mkdirSync(path92__default.dirname(lockDir), { recursive: true });
   return withDirectoryLock({ lockDir }, fn);
 }
 function buildConsoleCliHookExec(entry, trailingArgs) {
-  const extension = path93__default.extname(entry.entryPath);
+  const extension = path92__default.extname(entry.entryPath);
   if (JAVASCRIPT_ENTRY_EXTENSIONS.has(extension)) {
     return {
       command: entry.execPath,
@@ -42622,12 +43248,12 @@ var CONSOLE_ENTRY_PATH = fileURLToPath(import.meta.url);
 var HOOK_ENTRY_EXTENSIONS = /* @__PURE__ */ new Set([".cjs", ".cts", ".js", ".mjs", ".mts", ".ts", ".tsx"]);
 var require2 = createRequire(import.meta.url);
 function createDefaultTerminalLaunchResolver(deps = {}) {
-  const baseCwd = deps.cwd ?? process7.cwd();
-  const env = deps.env ?? process7.env;
-  const execPath = deps.execPath ?? process7.execPath;
+  const baseCwd = deps.cwd ?? process9.cwd();
+  const env = deps.env ?? process9.env;
+  const execPath = deps.execPath ?? process9.execPath;
   const homedir3 = deps.homedir ?? DEFAULT_TERMINAL_CWD_FALLBACK;
-  const platform = deps.platform ?? process7.platform;
-  const entryPath = resolveHookEntryPath(deps.entryPath ?? process7.argv[1]);
+  const platform = deps.platform ?? process9.platform;
+  const entryPath = resolveHookEntryPath(deps.entryPath ?? process9.argv[1]);
   const tsxLoaderPath = deps.tsxLoaderPath ?? resolveOptionalPackage("tsx");
   const dataDir = deps.dataDir ?? getFleetDataDir();
   const infraServices = deps.infraServices ?? createInfraServices();
@@ -42684,11 +43310,11 @@ function resolveHookEntryPath(candidate) {
   return CONSOLE_ENTRY_PATH;
 }
 function hasHookEntryExtension(entryPath) {
-  return HOOK_ENTRY_EXTENSIONS.has(path93__default.extname(entryPath));
+  return HOOK_ENTRY_EXTENSIONS.has(path92__default.extname(entryPath));
 }
 function startTerminalShell(launch, size) {
   const { spawn: spawnPty } = require2("node-pty");
-  const useConptyDll = resolveUseConptyDll(process7.platform, process7.env);
+  const useConptyDll = resolveUseConptyDll(process9.platform, process9.env);
   return spawnPty(launch.bin, [...launch.args], {
     cols: size.cols,
     rows: size.rows,
@@ -42728,6 +43354,7 @@ async function createAgentCliLaunchSpec(options) {
       turnStartHookExec: buildConsoleTurnHookCommand(options.hookEntry, "start"),
       turnEndHookExec: buildConsoleTurnHookCommand(options.hookEntry, "end"),
       inputWaitingHookExec: buildConsoleAttentionHookCommand(options.hookEntry),
+      autoNameHookExec: buildConsoleAutoNameHookCommand(options.hookEntry),
       hookExec: buildConsoleHookCommand(options.hookEntry),
       onCleanup: (cleanup) => cleanupStack.push(cleanup),
       replaceSystemPrompt: globalSettings.replaceSystemPrompt,
@@ -42861,6 +43488,9 @@ function createTerminalSessionManager(deps) {
     socket.on("message", (data, isBinary) => handleSocketMessage(session, data, isBinary));
     socket.once("close", () => detachSocket(session, socket));
   }
+  function hasLiveSessions() {
+    return sessions.size > 0 || pendingSessions.size > 0;
+  }
   async function createSession(context) {
     await getOrCreateSession(context);
   }
@@ -43002,7 +43632,7 @@ function createTerminalSessionManager(deps) {
       await runLaunchCleanup(session.cleanup);
     }
   }
-  return { canAttach, createSession, attach, getSessionMessagePolicy, getSessionRenameCommand, terminate, stop, writeToSession };
+  return { canAttach, createSession, attach, hasLiveSessions, getSessionMessagePolicy, getSessionRenameCommand, terminate, stop, writeToSession };
 }
 async function runLaunchCleanup(cleanup) {
   try {
@@ -43040,7 +43670,7 @@ var DEFAULT_TICKET_TTL_MS = 1e4;
 function createTerminalTicketRegistry(deps = {}) {
   const ttlMs = deps.ttlMs ?? DEFAULT_TICKET_TTL_MS;
   const now = deps.now ?? Date.now;
-  const randomTicket = deps.randomTicket ?? (() => crypto4.randomBytes(32).toString("base64url"));
+  const randomTicket = deps.randomTicket ?? (() => crypto3.randomBytes(32).toString("base64url"));
   const tickets = /* @__PURE__ */ new Map();
   function issue3(context) {
     prune();
@@ -43212,7 +43842,7 @@ var TheaterRegistry = class {
   #items = /* @__PURE__ */ new Map();
   #mruId = null;
   async register(cwd) {
-    const resolved = path93__default.resolve(cwd);
+    const resolved = path92__default.resolve(cwd);
     const real = await canonicalizeTheaterPath(resolved);
     const id = workspaceHash(real);
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -43267,6 +43897,383 @@ var TheaterRegistry = class {
     return removed;
   }
 };
+var PACKAGE_NAMES = ["@dotobokuri/fleet-cli", "@dotobokuri/fleet-console"];
+var WORKER_FILE_PREFIX = "fleet-console-update-";
+var WORKER_FILE_SUFFIX = ".mjs";
+var STATUS_FILE_SUFFIX = ".status.json";
+var LOG_FILE_SUFFIX = ".log";
+var TEMP_FILE_MODE = 384;
+function createConsoleUpdateApplyService(deps = {}) {
+  const env = deps.env ?? process9.env;
+  const execPath = deps.execPath ?? process9.execPath;
+  const makeDir = deps.makeDir ?? ((dirPath, options) => {
+    fs7__default.mkdirSync(dirPath, options);
+  });
+  const now = deps.now ?? Date.now;
+  const processPid = deps.processPid ?? process9.pid;
+  const preflightInstall = deps.preflightInstall ?? ((currentPackageRoot) => preflightPackageManager(currentPackageRoot, env));
+  const serverModulePath = deps.serverModulePath ?? resolveDefaultServerModulePath();
+  const spawnWorker = deps.spawnWorker ?? defaultSpawnWorker;
+  const tmpDir = deps.tmpDir ?? os22__default.tmpdir();
+  const writeFile4 = deps.writeFile ?? ((filePath, content, options) => {
+    fs7__default.writeFileSync(filePath, content, { mode: options.mode });
+  });
+  async function start(request) {
+    const packageManager = await preflightInstall(request.currentPackageRoot);
+    const stamp = `${now()}-${processPid}`;
+    const workerPath = path92__default.join(tmpDir, `${WORKER_FILE_PREFIX}${stamp}${WORKER_FILE_SUFFIX}`);
+    makeDir(request.dataDir, { recursive: true, mode: 448 });
+    const statusFile = path92__default.join(request.dataDir, `${WORKER_FILE_PREFIX}${stamp}${STATUS_FILE_SUFFIX}`);
+    const logFile = path92__default.join(request.dataDir, `${WORKER_FILE_PREFIX}${stamp}${LOG_FILE_SUFFIX}`);
+    const script = emitConsoleUpdateWorkerScript({
+      currentEndpoint: request.currentEndpoint,
+      currentPackageRoot: request.currentPackageRoot,
+      currentPid: request.currentPid,
+      lockFile: request.lockFile,
+      logFile,
+      packageManager,
+      packageNames: PACKAGE_NAMES,
+      serverModulePath,
+      statusFile,
+      targetVersion: request.targetVersion,
+      workerPath
+    });
+    writeFile4(workerPath, script, { mode: TEMP_FILE_MODE });
+    await spawnDetachedWorker(spawnWorker, execPath, [workerPath], env);
+    return { accepted: true };
+  }
+  return { start };
+}
+function emitConsoleUpdateWorkerScript(config2) {
+  return `import { execFileSync, spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const config = ${JSON.stringify(config2)};
+const stalePrefix = ${JSON.stringify(WORKER_FILE_PREFIX)};
+const workerSuffix = ${JSON.stringify(WORKER_FILE_SUFFIX)};
+const stopTimeoutMs = 60000;
+const startTimeoutMs = 60000;
+const sleepMs = 250;
+
+async function main() {
+  writeStatus("starting");
+  cleanupStaleWorkers();
+  const manager = detectPackageManager();
+  ensureGlobalRootWritable(manager);
+  writeStatus("preflight-ok", { manager: manager.command });
+  await stopCurrentConsole();
+  await waitForOldConsoleExit();
+  writeStatus("installing", { manager: manager.command });
+  await installPackages(manager);
+  writeStatus("starting-daemon");
+  const lock = await startNewDaemon();
+  openBrowser(new URL("console/", lock.endpoint).toString());
+  writeStatus("completed");
+}
+
+main()
+  .catch((error) => {
+    writeStatus("failed", { error: sanitizeError(error) });
+    log("failed: " + sanitizeError(error));
+    process.exitCode = 1;
+  })
+  .finally(() => {
+    try {
+      fs.rmSync(config.workerPath, { force: true });
+    } catch {
+      // \uC790\uAC00 \uC815\uB9AC\uB294 \uC2E4\uD328\uD574\uB3C4 \uC5C5\uB370\uC774\uD2B8 \uACB0\uACFC\uB97C \uB9C9\uC9C0 \uC54A\uB294\uB2E4.
+    }
+  });
+
+function writeStatus(phase, extra = {}) {
+  const payload = {
+    phase,
+    updatedAt: new Date().toISOString(),
+    ...extra,
+  };
+  fs.writeFileSync(config.statusFile, JSON.stringify(payload, null, 2), { mode: 0o600 });
+  log("phase: " + phase);
+}
+
+function log(message) {
+  fs.appendFileSync(config.logFile, new Date().toISOString() + " " + message + "\\n", { mode: 0o600 });
+}
+
+function cleanupStaleWorkers() {
+  const now = Date.now();
+  for (const entry of fs.readdirSync(os.tmpdir())) {
+    if (!entry.startsWith(stalePrefix) || !entry.endsWith(workerSuffix)) continue;
+    const filePath = path.join(os.tmpdir(), entry);
+    if (filePath === config.workerPath) continue;
+    try {
+      const stat = fs.statSync(filePath);
+      if (now - stat.mtimeMs > 24 * 60 * 60 * 1000) fs.rmSync(filePath, { force: true });
+    } catch {
+      // \uC624\uB798\uB41C \uC784\uC2DC worker \uC815\uB9AC\uB294 \uCD5C\uC120 \uB178\uB825\uC73C\uB85C\uB9CC \uC218\uD589\uD55C\uB2E4.
+    }
+  }
+}
+
+async function stopCurrentConsole() {
+  writeStatus("stopping-console");
+  try {
+    process.kill(config.currentPid, "SIGTERM");
+  } catch (error) {
+    if (!isNoSuchProcess(error)) throw error;
+  }
+}
+
+async function waitForOldConsoleExit() {
+  const deadline = Date.now() + stopTimeoutMs;
+  let escalated = false;
+  while (Date.now() < deadline) {
+    const pidGone = !isProcessAlive(config.currentPid);
+    const lockGone = !fs.existsSync(config.lockFile);
+    const healthGone = await isHealthGone(config.currentEndpoint);
+    if (pidGone && lockGone && healthGone) return;
+    if (!escalated && Date.now() > deadline - 10000 && isProcessAlive(config.currentPid)) {
+      escalated = true;
+      try {
+        process.kill(config.currentPid, "SIGKILL");
+      } catch (error) {
+        if (!isNoSuchProcess(error)) throw error;
+      }
+    }
+    await sleep(sleepMs);
+  }
+  throw new Error("old console did not stop before timeout");
+}
+
+function detectPackageManager() {
+  const configured = config.packageManager;
+  try {
+    const root = execFileSync(configured.bin, [...configured.prefixArgs, "root", "-g"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    if (!root) throw new Error("global package manager root is empty");
+    const rootReal = safeRealpath(root);
+    const packageReal = normalizeExistingPath(config.currentPackageRoot);
+    if (!rootReal || !packageReal) throw new Error("global package manager root could not be resolved");
+    if (isPathInside(packageReal, rootReal)) {
+      return { ...configured, root: rootReal };
+    }
+    for (const packageName of config.packageNames) {
+      if (packageReal === safeRealpath(path.join(root, packageName))) {
+        return { ...configured, root: rootReal };
+      }
+    }
+  } catch (error) {
+    throw new Error("no supported global package manager found: " + sanitizeError(error));
+  }
+  throw new Error("no supported global package manager found");
+}
+
+function ensureGlobalRootWritable(manager) {
+  try {
+    fs.accessSync(manager.root, fs.constants.W_OK);
+  } catch {
+    throw new Error("global package manager root is not writable");
+  }
+}
+
+async function installPackages(manager) {
+  const packages = config.packageNames.map((name) => name + "@" + config.targetVersion);
+  const code = await spawnExit(manager.bin, [...manager.prefixArgs, "i", "-g", "--force", ...packages]);
+  if (code !== 0) throw new Error("global package install failed with exit code " + code);
+}
+
+async function startNewDaemon() {
+  const child = spawn(process.execPath, [config.serverModulePath, "serve"], {
+    detached: true,
+    env: process.env,
+    stdio: "ignore",
+    windowsHide: true,
+  });
+  child.once("error", () => {});
+  child.unref();
+  const deadline = Date.now() + startTimeoutMs;
+  while (Date.now() < deadline) {
+    const lock = readLock();
+    if (lock && lock.pid !== config.currentPid && await isNewHealthOk(lock)) return lock;
+    await sleep(sleepMs);
+  }
+  throw new Error("new console daemon did not become healthy");
+}
+
+function openBrowser(url) {
+  const platform = os.platform();
+  if (platform === "darwin") {
+    spawnBrowser("open", [url]);
+    return;
+  }
+  if (platform === "win32") {
+    spawnBrowser("cmd", ["/c", "start", "", url]);
+    return;
+  }
+  spawnBrowser("xdg-open", [url]);
+}
+
+function spawnBrowser(command, args) {
+  const child = spawn(command, args, { detached: true, stdio: "ignore", windowsHide: true });
+  child.once("error", () => {});
+  child.unref();
+}
+
+function spawnExit(command, args) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, { stdio: "ignore", windowsHide: true });
+    child.once("error", () => resolve(1));
+    child.once("exit", (code) => resolve(code ?? 1));
+  });
+}
+
+function readLock() {
+  try {
+    return JSON.parse(fs.readFileSync(config.lockFile, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+async function isNewHealthOk(lock) {
+  if (!lock || typeof lock.endpoint !== "string" || typeof lock.token !== "string") return false;
+  try {
+    const response = await fetch(new URL("health", lock.endpoint), {
+      headers: { authorization: "Bearer " + lock.token },
+    });
+    if (!response.ok) return false;
+    const version = await readHealthVersion(response);
+    if (version === null) {
+      log("new health response did not expose a version; waiting for verified target");
+      return false;
+    }
+    return version === config.targetVersion;
+  } catch {
+    return false;
+  }
+}
+
+async function readHealthVersion(response) {
+  try {
+    const payload = await response.json();
+    return typeof payload.version === "string" ? payload.version : null;
+  } catch {
+    return null;
+  }
+}
+
+async function isHealthGone(endpoint) {
+  try {
+    await fetch(new URL("health", endpoint));
+    return false;
+  } catch {
+    return true;
+  }
+}
+
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !isNoSuchProcess(error);
+  }
+}
+
+function isNoSuchProcess(error) {
+  return error && typeof error === "object" && error.code === "ESRCH";
+}
+
+function safeRealpath(targetPath) {
+  try {
+    return normalizePath(fs.realpathSync(targetPath));
+  } catch {
+    return "";
+  }
+}
+
+function normalizeExistingPath(targetPath) {
+  return safeRealpath(targetPath) || normalizePath(targetPath);
+}
+
+function normalizePath(targetPath) {
+  const resolved = path.resolve(targetPath);
+  return os.platform() === "win32" ? resolved.toLowerCase() : resolved;
+}
+
+function isPathInside(targetPath, rootPath) {
+  const relative = path.relative(rootPath, targetPath);
+  return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function sanitizeError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message
+    .replaceAll(config.currentPackageRoot, "[path]")
+    .replaceAll(config.lockFile, "[path]")
+    .replaceAll(config.logFile, "[path]")
+    .replaceAll(config.statusFile, "[path]")
+    .replaceAll(config.workerPath, "[path]");
+}
+`;
+}
+async function preflightPackageManager(packageRoot, env) {
+  const updater = createGlobalPackageUpdater({
+    env,
+    packageNames: PACKAGE_NAMES,
+    resolveCurrentPackageRoot: () => packageRoot,
+    resolveCurrentVersion: () => void 0
+  });
+  const detection = await updater.detectPackageManager();
+  if (detection.manager === void 0) {
+    if (detection.reason === "permission") {
+      throw new Error("global package manager root is not writable");
+    }
+    throw new Error("no supported global package manager found");
+  }
+  return {
+    bin: detection.manager.resolved.bin,
+    command: detection.manager.command,
+    globalRoot: detection.manager.globalRoot,
+    prefixArgs: detection.manager.resolved.prefixArgs
+  };
+}
+function spawnDetachedWorker(spawnWorker, execPath, args, env) {
+  return new Promise((resolve, reject) => {
+    const child = spawnWorker(execPath, args, { detached: true, env, stdio: "ignore", windowsHide: true });
+    let settled = false;
+    child.once("error", (error51) => {
+      if (settled) return;
+      settled = true;
+      reject(error51);
+    });
+    child.unref();
+    queueMicrotask(() => {
+      if (settled) return;
+      settled = true;
+      resolve();
+    });
+  });
+}
+function defaultSpawnWorker(execPath, args, options) {
+  const child = spawn(execPath, [...args], options);
+  child.once("error", () => {
+  });
+  return child;
+}
+function resolveDefaultServerModulePath() {
+  const builtPath = fileURLToPath(new URL("../dist/cli.mjs", import.meta.url));
+  if (fs7__default.existsSync(builtPath)) return builtPath;
+  const sourcePath = fileURLToPath(import.meta.url);
+  if (sourcePath.endsWith(".ts")) {
+    return sourcePath.replace(/update-apply\.ts$/, "cli.ts");
+  }
+  return path92__default.join(path92__default.dirname(sourcePath), "cli.mjs");
+}
 
 // src/update-check.ts
 var FLEET_CONSOLE_PACKAGE_NAME = "@dotobokuri/fleet-console";
@@ -43288,9 +44295,9 @@ function createConsoleUpdateCheckService(deps = {}) {
     void refresh();
     return current?.status ?? NO_UPDATE_STATUS;
   };
-  const refresh = async () => {
+  const refresh = async (options = {}) => {
     const current = cached2;
-    if (current && now() - current.checkedAt < ttlMs) {
+    if (options.force !== true && current && now() - current.checkedAt < ttlMs) {
       return current.status;
     }
     if (inFlight) {
@@ -43328,23 +44335,26 @@ var SHELL_TERMINAL_SESSION_ID = "shell";
 var THEATER_SHELL_SESSION_PREFIX2 = "shell:";
 var SERVER_TIMEOUT_MS = 30 * 60 * 1e3;
 var MAX_BODY_BYTES = 1024 * 1024;
+var UPDATE_APPLY_FORBIDDEN_BODY_KEYS = /* @__PURE__ */ new Set(["channel", "package", "packageName", "packageVersion", "packages", "targetVersion", "version"]);
 function createConsoleServer(deps = {}) {
   const host = deps.host ?? DEFAULT_HOST2;
   const port = deps.port ?? DEFAULT_PORT2;
-  const version2 = deps.version ?? readFleetConsoleRelease().version;
-  const channel = readConsoleChannel();
+  const release = deps.release ?? readFleetConsoleRelease();
+  const version2 = deps.version ?? release.version;
+  const channel = release.channel;
   const carrierRegistry = createCarrierRegistry();
   registerDefaultCarriers(carrierRegistry);
   const lock = createConsoleLock({ hostname: () => host });
   const observability = createConsoleObservabilityStore();
   const updateCheck = deps.updateCheck ?? createConsoleUpdateCheckService();
+  const updateApply = deps.updateApply ?? createConsoleUpdateApplyService();
   const theaters = new TheaterRegistry();
   const terminalTickets = createTerminalTicketRegistry();
   const folderGrants = createFolderGrantStore();
   const infraServices = createInfraServices();
   const dataDir = deps.dataDir ?? getFleetDataDir();
   initStore(dataDir);
-  const durablePaths = createConsoleDataPaths({ fleetDataDir: dataDir });
+  const durablePaths = createConsoleDataPaths({ fleetDataDir: deps.dataDir });
   const durableStateStore = createConsoleDurableStateStore({ paths: durablePaths });
   const authEnvResolver = (cli) => resolveAuthEnv(cli, { authService: infraServices.authService });
   const ownsAgentRuntime = deps.agentRuntime === void 0;
@@ -43423,9 +44433,11 @@ function createConsoleServer(deps = {}) {
   let server = null;
   let loopbackServer = null;
   let lockHandle = null;
+  let activeLockFile = null;
   let activeEndpoint = null;
   let agentRuntimeStopped = false;
   let consoleResourcesDisposed = false;
+  let updateApplyInFlight = false;
   const carrierSettingsRouter = createCarrierSettingsRouter({
     registry: carrierRegistry,
     isAuthorized: isTerminalAuthorized,
@@ -43438,6 +44450,18 @@ function createConsoleServer(deps = {}) {
     readJsonBody,
     writeJson
   });
+  const agentCliDetector = deps.agentCliDetector ?? createDefaultAgentCliDetector();
+  const agentCliRouter = createAgentCliRouter({
+    detect: agentCliDetector.detect,
+    writeJson
+  });
+  const modelAuthRouter = createModelAuthRouter({
+    authService: infraServices.authService,
+    validateApiKey: (cli, apiKey) => validateAuthKeyForCli(cli, apiKey),
+    isAuthorized: isTerminalAuthorized,
+    readJsonBody,
+    writeJson
+  });
   function handleRequest(req, res) {
     const pathname = getPathname(req);
     if (pathname === "/console/codex" || pathname.startsWith("/console/codex/")) {
@@ -43484,6 +44508,11 @@ function createConsoleServer(deps = {}) {
       runAsyncHandler(handleTerminalSessionAttention(req, res, decodeURIComponent(terminalSessionAttentionMatch[1] ?? "")), res);
       return;
     }
+    const terminalSessionAutoNameMatch = pathname.match(/^\/terminal\/sessions\/([^/]+)\/auto-name$/);
+    if (terminalSessionAutoNameMatch) {
+      runAsyncHandler(handleTerminalSessionAutoName(req, res, decodeURIComponent(terminalSessionAutoNameMatch[1] ?? "")), res);
+      return;
+    }
     const terminalSessionItemMatch = pathname.match(/^\/terminal\/sessions\/([^/]+)$/);
     if (terminalSessionItemMatch) {
       runAsyncHandler(handleTerminalSessionItem(req, res, decodeURIComponent(terminalSessionItemMatch[1] ?? "")), res);
@@ -43507,6 +44536,10 @@ function createConsoleServer(deps = {}) {
       handleObserverStatus(req, res);
       return;
     }
+    if (pathname === "/update/apply") {
+      runAsyncHandler(handleUpdateApply(req, res), res);
+      return;
+    }
     if (pathname === "/observer/carriers") {
       handleObserverCarriers(req, res);
       return;
@@ -43519,6 +44552,14 @@ function createConsoleServer(deps = {}) {
       runAsyncBooleanHandler(globalSettingsRouter({ req, res, pathname }), res);
       return;
     }
+    if (pathname === "/agent-cli" || pathname.startsWith("/agent-cli/")) {
+      runAsyncBooleanHandler(agentCliRouter({ req, res, pathname }), res);
+      return;
+    }
+    if (pathname === "/model-auth" || pathname.startsWith("/model-auth/")) {
+      runAsyncBooleanHandler(modelAuthRouter({ req, res, pathname }), res);
+      return;
+    }
     if (pathname === "/observer/tenants") {
       handleObserverWorkspaces(req, res);
       return;
@@ -43593,9 +44634,31 @@ function createConsoleServer(deps = {}) {
       writeJson(res, 404, { error: "terminal_session_not_found" });
       return;
     }
-    observability.notifySessionAttention(session);
+    const body = await readJsonBody(req);
+    observability.notifySessionAttention(session, normalizeAttentionReason(body?.reason));
     writeJson(res, 200, { ok: true });
   }
+  async function handleTerminalSessionAutoName(req, res, sessionId) {
+    if (req.method !== "POST") {
+      writeJson(res, 405, { error: "Method not allowed" });
+      return;
+    }
+    const token = lockHandle?.payload.token;
+    if (!token || req.headers.authorization !== `Bearer ${token}`) {
+      writeJson(res, 401, { error: "Unauthorized" });
+      return;
+    }
+    const body = await readJsonBody(req);
+    const label = deriveOperationLabel(body?.prompt);
+    const result = observability.autoNameTerminalSession(sessionId, label);
+    if (result?.renamed) {
+      observability.notifySessionUpdated(result.session);
+    }
+    if (result?.changed) {
+      persistDurableState();
+    }
+    writeJson(res, 200, { ok: true, renamed: result?.renamed === true });
+  }
   async function handleTerminalTicket(req, res) {
     if (req.method !== "POST") {
       writeJson(res, 405, { error: "Method not allowed" });
@@ -43805,9 +44868,20 @@ function createConsoleServer(deps = {}) {
       writeJson(res, 503, { error: "terminal_unavailable" });
     }
   }
+  async function buildAgentCliLaunchMetadata() {
+    const metadata = getAgentCliMetadata();
+    if ((process.env.FLEET_TERMINAL_CMD ?? "").trim().length > 0) {
+      return metadata.map((meta3) => ({ id: meta3.id, label: meta3.label, available: true, signedIn: true }));
+    }
+    const [detected, modelAuth] = await Promise.all([
+      agentCliDetector.detect(),
+      buildModelAuthState(infraServices.authService)
+    ]);
+    return combineAgentCliLaunchMetadata(metadata, detected, modelAuth.providers);
+  }
   async function handleObserverTheaters(req, res) {
     if (req.method === "GET") {
-      writeJson(res, 200, { theaters: listTheaterInfos(), agentClis: getAgentCliMetadata() });
+      writeJson(res, 200, { theaters: listTheaterInfos(), agentClis: await buildAgentCliLaunchMetadata() });
       return;
     }
     if (req.method !== "POST") {
@@ -43877,7 +44951,14 @@ function createConsoleServer(deps = {}) {
     await createTerminalSessionForCwd(theater.path, res, cliId);
   }
   async function createTerminalSessionForCwd(cwd, res, cliId) {
-    const sessionId = crypto4.randomUUID();
+    if (cliId) {
+      const meta3 = (await buildAgentCliLaunchMetadata()).find((entry) => entry.id === cliId);
+      if (!meta3 || !meta3.available || !meta3.signedIn) {
+        writeJson(res, 409, { error: "agent_cli_unavailable" });
+        return;
+      }
+    }
+    const sessionId = crypto3.randomUUID();
     const session = observability.createPendingTerminalSession({ sessionId, cwd, cliId });
     try {
       await terminalSessions.createSession({ sessionId, cwd, cliId });
@@ -43906,6 +44987,69 @@ function createConsoleServer(deps = {}) {
     };
     writeJson(res, 200, payload);
   }
+  async function handleUpdateApply(req, res) {
+    if (req.method !== "POST") {
+      writeJson(res, 405, { error: "Method not allowed" });
+      return;
+    }
+    if (!isExactConsoleOrigin(req)) {
+      writeJson(res, 401, { error: "unauthorized" });
+      return;
+    }
+    const body = await readJsonBody(req);
+    if (body === null && requestHasBody(req)) {
+      writeJson(res, 400, { error: "invalid_update_apply_body" });
+      return;
+    }
+    if (body !== null && (!isPlainObject2(body) || hasForbiddenUpdateApplyBodyKeys(body))) {
+      writeJson(res, 400, { error: "invalid_update_apply_body" });
+      return;
+    }
+    if (channel === "local") {
+      writeJson(res, 403, { error: "local_channel" });
+      return;
+    }
+    if (updateApplyInFlight) {
+      writeJson(res, 409, { error: "update_already_in_progress" });
+      return;
+    }
+    if (terminalSessions.hasLiveSessions()) {
+      writeJson(res, 409, { error: "active_terminal_sessions" });
+      return;
+    }
+    const freshStatus = await updateCheck.refresh({ force: true });
+    if (!freshStatus.updateAvailable || !freshStatus.latestVersion) {
+      writeJson(res, 409, { error: "update_not_available" });
+      return;
+    }
+    const handle = lockHandle;
+    if (!handle || !activeEndpoint || !activeLockFile) {
+      writeJson(res, 503, { error: "console_not_ready" });
+      return;
+    }
+    updateApplyInFlight = true;
+    try {
+      await updateApply.start({
+        currentEndpoint: activeEndpoint,
+        currentPackageRoot: release.packageRoot,
+        currentPid: process.pid,
+        dataDir: durablePaths.dir,
+        lockFile: activeLockFile,
+        targetVersion: freshStatus.latestVersion
+      });
+    } catch {
+      updateApplyInFlight = false;
+      writeJson(res, 503, { error: "update_worker_unavailable" });
+      return;
+    }
+    res.once("finish", () => {
+      setImmediate(() => {
+        void stopAfterAcceptedUpdateApply();
+      });
+    });
+    const payload = { status: "accepted" };
+    writeJson(res, 202, payload);
+  }
   function handleObserverCarriers(_req, res) {
     writeJson(res, 200, {
       carriers: readCarrierStatusEntries(carrierRegistry).map(toCarrierReadinessEntry)
@@ -43949,6 +45093,10 @@ function createConsoleServer(deps = {}) {
     if (!lockHandle) return false;
     return isAllowedTerminalOrigin(req, lockHandle.payload.port ?? port);
   }
+  function isExactConsoleOrigin(req) {
+    if (!lockHandle) return false;
+    return req.headers.origin === `http://127.0.0.1:${lockHandle.payload.port ?? port}`;
+  }
   function listVisibleWorkspaces(requestedTenantId) {
     if (requestedTenantId) {
       const workspace = observability.getWorkspace(requestedTenantId);
@@ -44000,6 +45148,13 @@ function createConsoleServer(deps = {}) {
     await agentRuntime.cleanup();
     agentRuntimeStopped = true;
   }
+  async function stopAfterAcceptedUpdateApply() {
+    try {
+      await stopServer();
+    } catch (error51) {
+      console.warn(`[fleet-console] Update apply shutdown failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    }
+  }
   async function cleanupAfterFailedStart() {
     const current = server;
     const currentLoopback = loopbackServer;
@@ -44007,6 +45162,7 @@ function createConsoleServer(deps = {}) {
     server = null;
     loopbackServer = null;
     lockHandle = null;
+    activeLockFile = null;
     activeEndpoint = null;
     await Promise.all([
       closeHttpServer(current),
@@ -44097,7 +45253,35 @@ function createConsoleServer(deps = {}) {
       if (operation.providerSession) observability.updateTerminalSessionProviderSession(operation.sessionId, operation.providerSession);
     }
   }
-  return {
+  async function stopServer() {
+    const current = server;
+    const currentLoopback = loopbackServer;
+    const currentLock = lockHandle;
+    let cleanupError;
+    server = null;
+    loopbackServer = null;
+    lockHandle = null;
+    activeLockFile = null;
+    activeEndpoint = null;
+    try {
+      await Promise.all([
+        closeHttpServer(current),
+        closeHttpServer(currentLoopback)
+      ]);
+      await terminalSessions.stop();
+      if (!agentRuntimeStopped) {
+        try {
+          if (ownsAgentRuntime) await cleanupOwnedAgentRuntime();
+        } catch (error51) {
+          cleanupError = error51;
+        }
+      }
+    } finally {
+      disposeConsoleResources(currentLock);
+    }
+    if (cleanupError) throw cleanupError;
+  }
+  const returnedServer = {
     host,
     port,
     async start(lockPaths) {
@@ -44117,6 +45301,7 @@ function createConsoleServer(deps = {}) {
               server = srv;
               loopbackServer = localLoopbackServer;
               lockHandle = lock.writeLock({ dir: lockPaths.dir, lockFile: lockPaths.lockFile, pid: process.pid, port: actualPort, endpoint, version: version2 });
+              activeLockFile = lockPaths.lockFile;
               activeEndpoint = endpoint;
               resolve();
             } catch (err) {
@@ -44137,40 +45322,10 @@ function createConsoleServer(deps = {}) {
       return activeEndpoint;
     },
     async stop() {
-      const current = server;
-      const currentLoopback = loopbackServer;
-      const currentLock = lockHandle;
-      let cleanupError;
-      server = null;
-      loopbackServer = null;
-      lockHandle = null;
-      activeEndpoint = null;
-      try {
-        await Promise.all([
-          closeHttpServer(current),
-          closeHttpServer(currentLoopback)
-        ]);
-        await terminalSessions.stop();
-        if (!agentRuntimeStopped) {
-          try {
-            if (ownsAgentRuntime) await cleanupOwnedAgentRuntime();
-          } catch (error51) {
-            cleanupError = error51;
-          }
-        }
-      } finally {
-        disposeConsoleResources(currentLock);
-      }
-      if (cleanupError) throw cleanupError;
+      await stopServer();
     }
   };
-}
-function readConsoleChannel() {
-  try {
-    return readFleetConsoleRelease().channel;
-  } catch {
-    return "unknown";
-  }
+  return returnedServer;
 }
 function resolveCarrierEventOrigin(event, jobOriginById) {
   const originSessionId = event.originSessionId;
@@ -44261,6 +45416,14 @@ function terminalFolderListStatus(error51) {
 function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function hasForbiddenUpdateApplyBodyKeys(body) {
+  return Object.keys(body).some((key) => UPDATE_APPLY_FORBIDDEN_BODY_KEYS.has(key));
+}
+function requestHasBody(req) {
+  const contentLength = req.headers["content-length"];
+  if (typeof contentLength === "string" && contentLength !== "0") return true;
+  return req.headers["transfer-encoding"] !== void 0;
+}
 async function readJsonBody(req) {
   const chunks = [];
   let total = 0;
@@ -44320,9 +45483,9 @@ function isAllowedTerminalOrigin(req, expectedPort) {
   return origin === `http://127.0.0.1:${expectedPort}`;
 }
 var CAPTURE_TEMP_PREFIX = ".capture.";
-async function runCaptureSessionHook(provider, env = process7.env) {
+async function runCaptureSessionHook(provider, env = process9.env) {
   return captureSession({
-    diagnostics: process7.stderr,
+    diagnostics: process9.stderr,
     env,
     input: await readStdin(),
     provider
@@ -44339,12 +45502,12 @@ function captureSession(options) {
 }
 function captureSessionStrict(options) {
   const provider = parseProvider(options.provider);
-  const fleetSessionId = readFleetSessionId(options.env ?? process7.env);
+  const fleetSessionId = readFleetSessionId(options.env ?? process9.env);
   const input = parseHookInput(options.input ?? "");
   const providerSession = toProviderSession(provider, input, options.now ?? (() => /* @__PURE__ */ new Date()));
   const capturesDir = (options.paths ?? createConsoleDataPaths()).capturesDir;
-  const finalPath = path93__default.join(capturesDir, `${fleetSessionId}.json`);
-  const tempPath = path93__default.join(capturesDir, `${CAPTURE_TEMP_PREFIX}${fleetSessionId}.${process7.pid}.${Date.now()}.tmp`);
+  const finalPath = path92__default.join(capturesDir, `${fleetSessionId}.json`);
+  const tempPath = path92__default.join(capturesDir, `${CAPTURE_TEMP_PREFIX}${fleetSessionId}.${process9.pid}.${Date.now()}.tmp`);
   fs7__default.mkdirSync(capturesDir, { recursive: true, mode: 448 });
   fs7__default.writeFileSync(tempPath, `${JSON.stringify(providerSession, null, 2)}
 `, { mode: 384 });
@@ -44358,7 +45521,7 @@ function parseProvider(value) {
 function readFleetSessionId(env) {
   const value = env.FLEET_CONSOLE_SESSION_ID;
   if (!value) throw new Error("missing_fleet_session_id");
-  if (path93__default.basename(value) !== value || value.includes(path93__default.sep) || value.includes(path93__default.posix.sep)) {
+  if (path92__default.basename(value) !== value || value.includes(path92__default.sep) || value.includes(path92__default.posix.sep)) {
     throw new Error("invalid_fleet_session_id");
   }
   return value;
@@ -44384,11 +45547,11 @@ function toProviderSession(provider, input, now) {
 function readStdin() {
   return new Promise((resolve, reject) => {
     const chunks = [];
-    process7.stdin.on("data", (chunk) => {
+    process9.stdin.on("data", (chunk) => {
       chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
     });
-    process7.stdin.on("error", reject);
-    process7.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    process9.stdin.on("error", reject);
+    process9.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
   });
 }
 function createConsoleStalePolicy(deps = {}) {
@@ -44404,7 +45567,7 @@ function createConsoleStalePolicy(deps = {}) {
   return { isBuildStale };
 }
 var TURN_POST_TIMEOUT_MS = 1500;
-async function runTurnStateHook(phase, env = process7.env, options = {}) {
+async function runTurnStateHook(phase, env = process9.env, options = {}) {
   try {
     await postTurnState(phase, env, options);
   } catch {
@@ -44433,12 +45596,66 @@ async function postTurnState(phase, env, options) {
     clearTimeout(timer);
   }
 }
+var AUTO_NAME_POST_TIMEOUT_MS = 1500;
+var MAX_PROMPT_PAYLOAD = 2e3;
+async function runAutoNameHook(env = process9.env, options = {}) {
+  try {
+    await postAutoName(env, options);
+  } catch {
+  }
+}
+async function postAutoName(env, options) {
+  const sessionId = env.FLEET_CONSOLE_SESSION_ID;
+  if (!sessionId) return;
+  const prompt = extractPrompt(options.input ?? await readStdin2());
+  if (prompt === null) return;
+  const paths = createConsolePaths({ env });
+  const lock = createConsoleLock().readLock(paths.lockFile);
+  if (!lock) return;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? AUTO_NAME_POST_TIMEOUT_MS);
+  try {
+    await fetchImpl(`${lock.endpoint}terminal/sessions/${encodeURIComponent(sessionId)}/auto-name`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${lock.token}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({ prompt }),
+      signal: controller.signal
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function extractPrompt(input) {
+  try {
+    const parsed = JSON.parse(input);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const value = parsed.prompt;
+    if (typeof value !== "string" || value.trim().length === 0) return null;
+    return value.slice(0, MAX_PROMPT_PAYLOAD);
+  } catch {
+    return null;
+  }
+}
+function readStdin2() {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    process9.stdin.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    process9.stdin.on("error", reject);
+    process9.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+  });
+}
 
 // src/cli.ts
 var FIXED_HOST = "127.0.0.1";
 var HELP_BANNER_INDENT = "  ";
 var DEFAULT_HELP_RELEASE = "local";
-var CONSOLE_HOOK_COMMANDS = /* @__PURE__ */ new Set(["capture-session", "subagents-context", "turn-start", "turn-end", "attention"]);
+var CONSOLE_HOOK_COMMANDS = /* @__PURE__ */ new Set(["capture-session", "subagents-context", "turn-start", "turn-end", "attention", "auto-name"]);
 function parseConsoleCliMode(argv) {
   if (argv.length === 0) return "start";
   const [first, ...rest] = argv;
@@ -44472,6 +45689,7 @@ function parseConsoleHookCommand(argv) {
   if (commandName === "turn-start" && rest.length === 0) return { command: "turn-start" };
   if (commandName === "turn-end" && rest.length === 0) return { command: "turn-end" };
   if (commandName === "attention" && rest.length === 0) return { command: "attention" };
+  if (commandName === "auto-name" && rest.length === 0) return { command: "auto-name" };
   if (commandName === "capture-session" && rest.length === 1 && rest[0]) return { command: "capture-session", provider: rest[0] };
   throw new Error("Unknown fleet-console hook command");
 }
@@ -44535,11 +45753,14 @@ function buildWikiHelpText(options = {}) {
   return colorEnabled ? text : stripAnsi(text);
 }
 function createConsoleDaemonLifecycle(deps = {}) {
-  const env = deps.env ?? process7.env;
-  const execPath = deps.execPath ?? process7.execPath;
-  const serverModulePath = deps.serverModulePath ?? resolveDefaultServerModulePath();
+  const env = deps.env ?? process9.env;
+  const execPath = deps.execPath ?? process9.execPath;
+  const serverModulePath = deps.serverModulePath ?? resolveDefaultServerModulePath2();
   const spawnDetached = deps.spawnDetached ?? ((bin, args, options) => {
-    spawn(bin, [...args], options).unref();
+    const child = spawn(bin, [...args], options);
+    child.once("error", () => {
+    });
+    child.unref();
   });
   const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   const paths = createConsolePaths({ env });
@@ -44550,10 +45771,10 @@ function createConsoleDaemonLifecycle(deps = {}) {
     const server = createConsoleServer();
     await server.start(paths);
     await new Promise((resolve) => {
-      process7.once("SIGTERM", () => {
+      process9.once("SIGTERM", () => {
         void server.stop().finally(resolve);
       });
-      process7.once("SIGINT", () => {
+      process9.once("SIGINT", () => {
         void server.stop().finally(resolve);
       });
     });
@@ -44567,14 +45788,14 @@ function createConsoleDaemonLifecycle(deps = {}) {
     const payload = readTrustedLock();
     if (!payload) return;
     try {
-      process7.kill(payload.pid, "SIGTERM");
+      process9.kill(payload.pid, "SIGTERM");
     } catch (err) {
       if (err.code !== "ESRCH") throw err;
     }
     await sleep(200);
     try {
-      process7.kill(payload.pid, 0);
-      process7.kill(payload.pid, "SIGKILL");
+      process9.kill(payload.pid, 0);
+      process9.kill(payload.pid, "SIGKILL");
     } catch (err) {
       if (err.code !== "ESRCH") throw err;
     }
@@ -44589,7 +45810,7 @@ function createConsoleDaemonLifecycle(deps = {}) {
       if (typeof probeResult.health?.workspaceCount === "number" && probeResult.health.workspaceCount > 0) return current.endpoint;
     }
     if (current) await stop();
-    spawnDetached(execPath, [serverModulePath, "serve"], { detached: true, env, stdio: "ignore" });
+    spawnDetached(execPath, [serverModulePath, "serve"], { detached: true, env, stdio: "ignore", windowsHide: true });
     for (let i = 0; i < 30; i += 1) {
       await sleep(100);
       const next = await probe();
@@ -44640,7 +45861,7 @@ async function openFleetWikiWorkspace(options) {
       authorization: `Bearer ${status.lock.token}`,
       "content-type": "application/json"
     },
-    body: JSON.stringify({ cwd: path93__default.resolve(options.cwd) })
+    body: JSON.stringify({ cwd: path92__default.resolve(options.cwd) })
   });
   if (!response.ok) {
     throw new Error(`Fleet Console Codex workspace registration failed: ${response.status} ${await response.text()}`);
@@ -44681,59 +45902,63 @@ async function runConsoleRestart(deps = {}) {
   return openFleetConsole({ lifecycle, openBrowser: deps.openBrowser });
 }
 async function main() {
-  if (process7.argv[2] === "serve") {
+  if (process9.argv[2] === "serve") {
     await createConsoleDaemonLifecycle().runServer();
     return;
   }
-  if (process7.argv[2] === "hook") {
-    const hookCommand = parseConsoleHookCommand(process7.argv.slice(3));
+  if (process9.argv[2] === "hook") {
+    const hookCommand = parseConsoleHookCommand(process9.argv.slice(3));
     if (hookCommand.command === "subagents-context") {
-      process7.stdout.write(`${runSubagentsContextHook(process7.env)}
+      process9.stdout.write(`${runSubagentsContextHook(process9.env)}
 `);
       return;
     }
     if (hookCommand.command === "turn-start" || hookCommand.command === "turn-end") {
-      await runTurnStateHook(hookCommand.command === "turn-start" ? "start" : "end", process7.env);
+      await runTurnStateHook(hookCommand.command === "turn-start" ? "start" : "end", process9.env);
       return;
     }
     if (hookCommand.command === "attention") {
-      await runAttentionHook(process7.env);
+      await runAttentionHook(process9.env);
+      return;
+    }
+    if (hookCommand.command === "auto-name") {
+      await runAutoNameHook(process9.env);
       return;
     }
-    await runCaptureSessionHook(hookCommand.provider, process7.env);
+    await runCaptureSessionHook(hookCommand.provider, process9.env);
     return;
   }
-  if (process7.argv[2] === "codex") {
-    await mainWiki(process7.argv.slice(3));
+  if (process9.argv[2] === "codex") {
+    await mainWiki(process9.argv.slice(3));
     return;
   }
-  const mode = parseConsoleCliMode(process7.argv.slice(2));
+  const mode = parseConsoleCliMode(process9.argv.slice(2));
   if (mode === "help") {
-    process7.stdout.write(`${buildConsoleHelpText({ env: process7.env, isTTY: process7.stdout.isTTY })}
+    process9.stdout.write(`${buildConsoleHelpText({ env: process9.env, isTTY: process9.stdout.isTTY })}
 `);
     return;
   }
   if (mode === "status") {
-    process7.stdout.write(`${await runConsoleStatus()}
+    process9.stdout.write(`${await runConsoleStatus()}
 `);
     return;
   }
   if (mode === "stop") {
-    process7.stdout.write(`${await runConsoleStop()}
+    process9.stdout.write(`${await runConsoleStop()}
 `);
     return;
   }
   if (mode === "restart") {
     await runConsoleRestart();
-    process7.stdout.write("Fleet Console restarted.\n");
+    process9.stdout.write("Fleet Console restarted.\n");
     return;
   }
   await openFleetConsole();
-  process7.stdout.write("Fleet Console opened.\n");
+  process9.stdout.write("Fleet Console opened.\n");
 }
-async function mainWiki(argv = process7.argv.slice(2)) {
+async function mainWiki(argv = process9.argv.slice(2)) {
   if (argv.includes("--help") || argv.includes("-h")) {
-    process7.stdout.write(`${buildWikiHelpText({ env: process7.env, isTTY: process7.stdout.isTTY })}
+    process9.stdout.write(`${buildWikiHelpText({ env: process9.env, isTTY: process9.stdout.isTTY })}
 `);
     return;
   }
@@ -44745,19 +45970,19 @@ async function mainWiki(argv = process7.argv.slice(2)) {
   if (unsupported.length > 0) {
     throw new Error(`Unknown fleet wiki option: ${unsupported[0]}`);
   }
-  await openFleetWikiWorkspace({ cwd: process7.cwd() });
+  await openFleetWikiWorkspace({ cwd: process9.cwd() });
 }
-function resolveDefaultServerModulePath() {
+function resolveDefaultServerModulePath2() {
   const builtPath = new URL("../dist/cli.mjs", import.meta.url).pathname;
   if (fs7__default.existsSync(builtPath)) return builtPath;
   return fileURLToPath(import.meta.url);
 }
-var isDirectRun = process7.argv[1] && path93__default.resolve(process7.argv[1]) === fileURLToPath(import.meta.url);
+var isDirectRun = process9.argv[1] && path92__default.resolve(process9.argv[1]) === fileURLToPath(import.meta.url);
 if (isDirectRun) {
   await main().catch((error51) => {
-    process7.stderr.write(`${error51 instanceof Error ? error51.message : String(error51)}
+    process9.stderr.write(`${error51 instanceof Error ? error51.message : String(error51)}
 `);
-    process7.exitCode = 1;
+    process9.exitCode = 1;
   });
 }