@dotobokuri/fleet-console 1.17.1 → 1.18.0

package/dist/cli.mjs

@@ -1,19 +1,19 @@
 #!/usr/bin/env node
 import { spawn, execFileSync, execFile, execSync } from 'child_process';
 import * as fs11 from 'fs';
-import fs11__default, { readFileSync, realpathSync, accessSync, constants, existsSync, lstatSync } from 'fs';
-import * as path26 from 'path';
-import path26__default, { join, resolve, relative, sep, dirname } from 'path';
+import fs11__default, { realpathSync, accessSync, constants, existsSync, lstatSync } from 'fs';
+import * as path25 from 'path';
+import path25__default, { join, resolve, relative, sep, dirname } from 'path';
 import process4 from 'process';
 import { fileURLToPath, pathToFileURL } from 'url';
-import * as os3 from 'os';
-import os3__default from 'os';
-import { EventEmitter } from 'events';
-import { stat, readFile, realpath, readdir, mkdir, mkdtemp, writeFile, access, appendFile, rm, rename } from 'fs/promises';
-import { Writable, Readable } from 'stream';
+import * as os4 from 'os';
+import os4__default from 'os';
 import crypto5, { createHash, randomUUID } from 'crypto';
-import http2 from 'http';
 import { builtinModules, createRequire } from 'module';
+import http2 from 'http';
+import { EventEmitter } from 'events';
+import { stat, readFile, realpath, readdir, mkdir, mkdtemp, writeFile, appendFile, rm, rename, access } from 'fs/promises';
+import { Writable, Readable } from 'stream';
 import net2 from 'net';
 
 var __defProp = Object.defineProperty;
@@ -22,7 +22,7 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 function openBrowser(url2, deps = {}) {
-  const platform = deps.platform ?? os3__default.platform();
+  const platform = deps.platform ?? os4__default.platform();
   const spawnBrowser = deps.spawnBrowser ?? ((command2, args, options) => {
     const child = spawn(command2, [...args], options);
     child.once("error", () => {
@@ -214,6 +214,709 @@ function readStringControlSequence(text, start, scanStart, allowBelTerminator) {
 function isC1Control(code) {
   return code >= 128 && code <= 159;
 }
+var LOCK_DIR_MODE = 448;
+var LOCK_FILE_MODE = 384;
+function createConsoleLock(deps = {}) {
+  const fsImpl = deps.fs ?? fs11__default;
+  const now = deps.now ?? Date.now;
+  const randomToken = deps.randomToken ?? (() => crypto5.randomBytes(32).toString("base64url"));
+  const hostname5 = deps.hostname ?? (() => "127.0.0.1");
+  function ensureLockDir(dir) {
+    fsImpl.mkdirSync(dir, { recursive: true, mode: LOCK_DIR_MODE });
+    fsImpl.chmodSync(dir, LOCK_DIR_MODE);
+  }
+  function readLock(lockFile) {
+    try {
+      const stat5 = fsImpl.lstatSync(lockFile);
+      if (stat5.isSymbolicLink()) {
+        throw new Error(`Refusing symbolic console lock: ${lockFile}`);
+      }
+      return JSON.parse(fsImpl.readFileSync(lockFile, "utf8"));
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      throw err;
+    }
+  }
+  function writeLock(input) {
+    ensureLockDir(input.dir);
+    const payload = {
+      pid: input.pid,
+      host: hostname5(),
+      port: input.port,
+      endpoint: input.endpoint,
+      startedAt: now(),
+      token: randomToken(),
+      version: input.version
+    };
+    const fd = fsImpl.openSync(input.lockFile, fs11__default.constants.O_CREAT | fs11__default.constants.O_EXCL | fs11__default.constants.O_WRONLY, LOCK_FILE_MODE);
+    try {
+      fsImpl.writeFileSync(fd, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+      fsImpl.fchmodSync(fd, LOCK_FILE_MODE);
+    } finally {
+      fsImpl.closeSync(fd);
+    }
+    return { payload, release: () => removeLock(input.lockFile, payload.pid) };
+  }
+  function removeLock(lockFile, pid) {
+    let current = null;
+    try {
+      current = readLock(lockFile);
+    } catch (err) {
+      if (pid != null) throw err;
+    }
+    if (pid != null && current && current.pid !== pid) return;
+    try {
+      fsImpl.rmSync(lockFile, { force: true });
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+  function assertLockModes(lockFile) {
+    if (typeof process.getuid !== "function") return;
+    const dir = path25__default.dirname(lockFile);
+    const dirMode = fsImpl.statSync(dir).mode & 511;
+    const fileMode = fsImpl.statSync(lockFile).mode & 511;
+    if (dirMode !== LOCK_DIR_MODE) {
+      throw new Error(`Console lock directory mode must be 0700, got ${dirMode.toString(8)}`);
+    }
+    if (fileMode !== LOCK_FILE_MODE) {
+      throw new Error(`Console lock file mode must be 0600, got ${fileMode.toString(8)}`);
+    }
+  }
+  function assertTrustedLock(input) {
+    const dirStat = fsImpl.statSync(input.dir);
+    const fileStat = fsImpl.lstatSync(input.lockFile);
+    if (fileStat.isSymbolicLink()) {
+      throw new Error(`Refusing symbolic console lock: ${input.lockFile}`);
+    }
+    assertLockModes(input.lockFile);
+    const currentUid = typeof process.getuid === "function" ? process.getuid() : null;
+    if (currentUid != null && (dirStat.uid !== currentUid || fileStat.uid !== currentUid)) {
+      throw new Error("Console lock owner does not match current user");
+    }
+    if (input.payload.host !== input.host) {
+      throw new Error(`Console lock host must match ${input.host}: ${input.payload.host}`);
+    }
+    if (!Number.isInteger(input.payload.port) || input.payload.port < 1 || input.payload.port > 65535) {
+      throw new Error(`Console lock port must be a valid TCP port, got ${input.payload.port}`);
+    }
+    const endpoint = new URL(input.payload.endpoint);
+    if (endpoint.protocol !== "http:" || endpoint.pathname !== "/") {
+      throw new Error("Console lock endpoint must be the loopback server root");
+    }
+    if (endpoint.hostname !== input.host || Number(endpoint.port) !== input.payload.port) {
+      throw new Error("Console lock endpoint must use the loopback host and the lock port");
+    }
+    if (input.payload.endpoint !== `http://${input.host}:${input.payload.port}/`) {
+      throw new Error("Console lock endpoint must match the lock host and port");
+    }
+  }
+  return { ensureLockDir, readLock, writeLock, removeLock, assertLockModes, assertTrustedLock };
+}
+var FLEET_DATA_DIR_NAME = ".fleet";
+function getFleetDataDir() {
+  return path25.join(os4.homedir(), FLEET_DATA_DIR_NAME);
+}
+var SECURE_DIR_MODE = 448;
+var SECURE_FILE_MODE = 384;
+var NOFOLLOW_FLAG = fs11.constants.O_NOFOLLOW ?? 0;
+function safeLstat(targetPath) {
+  try {
+    return fs11.lstatSync(targetPath);
+  } catch (error51) {
+    if (error51.code === "ENOENT") {
+      return null;
+    }
+    throw error51;
+  }
+}
+function ensureSafeDirectory(dirPath) {
+  const stat5 = safeLstat(dirPath);
+  if (stat5) {
+    if (!stat5.isDirectory() || stat5.isSymbolicLink()) {
+      throw new Error(`Unsafe Fleet directory: ${dirPath}`);
+    }
+    fs11.chmodSync(dirPath, SECURE_DIR_MODE);
+    return;
+  }
+  fs11.mkdirSync(dirPath, { recursive: true, mode: SECURE_DIR_MODE });
+  const created = safeLstat(dirPath);
+  if (!created?.isDirectory() || created.isSymbolicLink()) {
+    throw new Error(`Unsafe Fleet directory: ${dirPath}`);
+  }
+  fs11.chmodSync(dirPath, SECURE_DIR_MODE);
+}
+
+// ../../packages/fleet-infra/src/fs-store/atomic-write.ts
+var DEFAULT_MAX_ATTEMPTS = 10;
+var IGNORED_FSYNC_ERROR_CODES = /* @__PURE__ */ new Set(["EPERM", "EINVAL", "ENOSYS"]);
+function buildTempPath(filePath) {
+  const suffix = `${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.${os4.hostname()}`;
+  return `${filePath}.${suffix}.tmp`;
+}
+function writeAtomicSync(filePath, content, options = {}) {
+  const mode = options.mode ?? SECURE_FILE_MODE;
+  const doFsync = options.fsync !== false;
+  const maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+  let lastExistsError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const tempPath = buildTempPath(filePath);
+    let tempCreated = false;
+    try {
+      fs11.writeFileSync(tempPath, content, { encoding: "utf-8", flag: "wx", mode });
+      tempCreated = true;
+      if (doFsync) {
+        const fd = fs11.openSync(tempPath, "r");
+        try {
+          fsyncSyncBestEffort(fd);
+        } finally {
+          fs11.closeSync(fd);
+        }
+      }
+      fs11.renameSync(tempPath, filePath);
+      return;
+    } catch (error51) {
+      const code = error51.code;
+      if (!tempCreated && code === "EEXIST") {
+        lastExistsError = error51;
+        continue;
+      }
+      if (tempCreated) {
+        try {
+          fs11.unlinkSync(tempPath);
+        } catch {
+        }
+      }
+      throw error51;
+    }
+  }
+  throw lastExistsError ?? new Error(`Failed to create temp file after ${maxAttempts} attempts: ${filePath}`);
+}
+function cleanupTempFiles(dir, prefix, minAgeMs, now) {
+  let entries;
+  try {
+    entries = fs11.readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.startsWith(prefix)) {
+      continue;
+    }
+    const tempPath = path25.join(dir, entry);
+    try {
+      const stat5 = fs11.lstatSync(tempPath);
+      if (stat5?.isFile() && !stat5.isSymbolicLink() && now - stat5.mtimeMs >= minAgeMs) {
+        fs11.unlinkSync(tempPath);
+      }
+    } catch {
+    }
+  }
+}
+function isIgnoredFsyncError(error51) {
+  const code = error51.code;
+  return typeof code === "string" && IGNORED_FSYNC_ERROR_CODES.has(code);
+}
+function fsyncSyncBestEffort(fd) {
+  try {
+    fs11.fsyncSync(fd);
+  } catch (error51) {
+    if (!isIgnoredFsyncError(error51)) {
+      throw error51;
+    }
+  }
+}
+var DEFAULT_LOCK_TIMEOUT_MS = 5e3;
+var DEFAULT_STALE_LOCK_MS = 3e4;
+var DEFAULT_RETRY_MS = 25;
+var DEFAULT_OWNER_FILE_NAME = "owner.json";
+function withDirectoryLock(deps, operation) {
+  const ownerFileName = deps.ownerFileName ?? DEFAULT_OWNER_FILE_NAME;
+  const timeoutMs = deps.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS;
+  const staleLockMs = deps.staleLockMs ?? DEFAULT_STALE_LOCK_MS;
+  const retryMs = deps.retryMs ?? DEFAULT_RETRY_MS;
+  const now = deps.now ?? (() => Date.now());
+  const startedAt = now();
+  while (true) {
+    try {
+      fs11.mkdirSync(deps.lockDir, { mode: 448 });
+      writeLockOwner(deps.lockDir, ownerFileName, now());
+      try {
+        return operation();
+      } finally {
+        releaseLock(deps.lockDir);
+      }
+    } catch (error51) {
+      const code = error51.code;
+      if (code !== "EEXIST") throw error51;
+      recoverStaleLock(deps.lockDir, ownerFileName, now, staleLockMs);
+      if (now() - startedAt >= timeoutMs) {
+        throw new Error(`Timed out waiting for Fleet directory lock: ${deps.lockDir}`);
+      }
+      sleepSync(retryMs);
+    }
+  }
+}
+function releaseLock(lockDir) {
+  try {
+    fs11.rmSync(lockDir, { recursive: true, force: true });
+  } catch {
+  }
+}
+function recoverStaleLock(lockDir, ownerFileName, now, staleLockMs) {
+  try {
+    const initialSnapshot = readLockSnapshot(lockDir, ownerFileName);
+    if (!isRecoverableSnapshot(initialSnapshot, now, staleLockMs)) return;
+    const quarantineDir = buildQuarantinePath(lockDir);
+    try {
+      fs11.renameSync(lockDir, quarantineDir);
+    } catch {
+      return;
+    }
+    try {
+      const quarantinedSnapshot = readLockSnapshot(quarantineDir, ownerFileName);
+      if (sameLockSnapshot(initialSnapshot, quarantinedSnapshot) && isRecoverableSnapshot(quarantinedSnapshot, now, staleLockMs)) {
+        fs11.rmSync(quarantineDir, { recursive: true, force: true });
+      } else {
+        restoreQuarantinedLock(quarantineDir, lockDir);
+      }
+    } catch (error51) {
+      const code = error51.code;
+      if (code !== "ENOENT") throw error51;
+    }
+  } catch (error51) {
+    const code = error51.code;
+    if (code !== "ENOENT") throw error51;
+  }
+}
+function readLockSnapshot(lockDir, ownerFileName) {
+  const stat5 = fs11.lstatSync(lockDir);
+  if (stat5.isSymbolicLink()) {
+    return { owner: null, mtimeMs: 0 };
+  }
+  return {
+    owner: readLockOwner(lockDir, ownerFileName),
+    mtimeMs: stat5.mtimeMs
+  };
+}
+function buildQuarantinePath(lockDir) {
+  const suffix = `${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}`;
+  return `${lockDir}.stale.${suffix}`;
+}
+function writeLockOwner(lockDir, ownerFileName, startedAt) {
+  const owner = {
+    pid: process.pid,
+    hostname: os4.hostname(),
+    startedAt
+  };
+  const ownerPath = path25.join(lockDir, ownerFileName);
+  try {
+    fs11.writeFileSync(ownerPath, JSON.stringify(owner), { encoding: "utf-8", mode: 384 });
+  } catch (error51) {
+    releaseLock(lockDir);
+    throw error51;
+  }
+}
+function readLockOwner(lockDir, ownerFileName) {
+  const ownerPath = path25.join(lockDir, ownerFileName);
+  try {
+    return sanitizeLockOwner(JSON.parse(fs11.readFileSync(ownerPath, "utf-8")));
+  } catch (error51) {
+    const code = error51.code;
+    if (code === "ENOENT") return null;
+    throw error51;
+  }
+}
+function isRecoverableOwner(owner, now, staleLockMs) {
+  if (owner.hostname !== os4.hostname()) return false;
+  if (now() - owner.startedAt < staleLockMs) return false;
+  return !isProcessAlive(owner.pid);
+}
+function isRecoverableSnapshot(snapshot, now, staleLockMs) {
+  if (snapshot.owner) return isRecoverableOwner(snapshot.owner, now, staleLockMs);
+  return now() - snapshot.mtimeMs >= staleLockMs;
+}
+function sameLockSnapshot(a, b) {
+  if (!a.owner || !b.owner) return !a.owner && !b.owner && a.mtimeMs === b.mtimeMs;
+  return a.owner.pid === b.owner.pid && a.owner.hostname === b.owner.hostname && a.owner.startedAt === b.owner.startedAt;
+}
+function restoreQuarantinedLock(quarantineDir, lockDir) {
+  try {
+    fs11.renameSync(quarantineDir, lockDir);
+  } catch {
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error51) {
+    const code = error51.code;
+    if (code === "ESRCH") return false;
+    return true;
+  }
+}
+function sanitizeLockOwner(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const record2 = value;
+  const pid = record2.pid;
+  const hostname5 = record2.hostname;
+  const startedAt = record2.startedAt;
+  if (!Number.isInteger(pid) || pid <= 0) return null;
+  if (typeof hostname5 !== "string" || !hostname5) return null;
+  if (!Number.isFinite(startedAt) || startedAt <= 0) return null;
+  return {
+    pid,
+    hostname: hostname5,
+    startedAt
+  };
+}
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function readAuthStoreFile(filePath) {
+  let fd;
+  try {
+    fd = fs11.openSync(filePath, fs11.constants.O_RDONLY | NOFOLLOW_FLAG);
+    if (!fs11.fstatSync(fd).isFile()) {
+      return {};
+    }
+    return JSON.parse(fs11.readFileSync(fd, "utf-8"));
+  } catch {
+    return {};
+  } finally {
+    if (fd !== void 0) {
+      try {
+        fs11.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+
+// ../../packages/fleet-infra/src/auth/auth-storage.ts
+var DEFAULT_AUTH_PATH = path25.join(getFleetDataDir(), "auth.json");
+var AUTH_LOCK_OWNER_FILE_NAME = "owner.json";
+var AUTH_LOCK_TIMEOUT_MS = 5e3;
+function createAuthService(deps = {}) {
+  const authPath = deps.authPath ?? DEFAULT_AUTH_PATH;
+  const lockDir = `${authPath}.lock`;
+  return {
+    // [HIGH #1] TOCTOU 수정: existsSync/read/check/delete/write 전체를 락 블록 안으로 이동
+    async deleteApiKey(providerId) {
+      let deleted = false;
+      withAuthLock(authPath, lockDir, () => {
+        if (!fs11.existsSync(authPath)) return;
+        const data = readAuthStoreFile(authPath);
+        if (!Object.prototype.hasOwnProperty.call(data, providerId)) return;
+        delete data[providerId];
+        writeAuthData(authPath, data);
+        deleted = true;
+      });
+      return deleted;
+    },
+    // [HIGH #2] 읽기 경로: fd 기반 O_RDONLY|O_NOFOLLOW+fstatSync isFile
+    async getApiKey(providerId) {
+      let fd;
+      try {
+        if (!fs11.existsSync(authPath)) {
+          return void 0;
+        }
+        fd = fs11.openSync(authPath, fs11.constants.O_RDONLY | NOFOLLOW_FLAG);
+        if (!fs11.fstatSync(fd).isFile()) {
+          return void 0;
+        }
+        const data = JSON.parse(fs11.readFileSync(fd, "utf-8"));
+        return typeof data[providerId]?.key === "string" ? data[providerId].key : void 0;
+      } catch {
+        return void 0;
+      } finally {
+        if (fd !== void 0) {
+          try {
+            fs11.closeSync(fd);
+          } catch {
+          }
+        }
+      }
+    },
+    // [HIGH #2] 읽기 경로: fd 기반 O_RDONLY|O_NOFOLLOW 통일
+    async listProviderIds() {
+      if (!fs11.existsSync(authPath)) {
+        return [];
+      }
+      try {
+        return Object.keys(readAuthStoreFile(authPath)).sort();
+      } catch {
+        return [];
+      }
+    },
+    async setApiKey(providerId, key) {
+      const dir = path25.dirname(authPath);
+      ensureSafeDirectory(dir);
+      withAuthLock(authPath, lockDir, () => {
+        const data = fs11.existsSync(authPath) ? readAuthStoreFile(authPath) : {};
+        data[providerId] = {
+          ...data[providerId] ?? {},
+          key
+        };
+        writeAuthData(authPath, data);
+      });
+    }
+  };
+}
+function withAuthLock(authPath, lockDir, operation) {
+  return withDirectoryLock(
+    {
+      lockDir,
+      ownerFileName: AUTH_LOCK_OWNER_FILE_NAME,
+      timeoutMs: AUTH_LOCK_TIMEOUT_MS
+    },
+    operation
+  );
+}
+function writeAuthData(authPath, data) {
+  writeAtomicSync(authPath, `${JSON.stringify(data, null, 2)}
+`, {
+    mode: SECURE_FILE_MODE,
+    fsync: true
+  });
+}
+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 = path25.dirname(deps.filePath);
+  return {
+    path: deps.filePath,
+    load() {
+      return readJsonFile(deps.filePath, deps.sanitize);
+    },
+    save(data) {
+      withLock(() => {
+        writeAtomicSync(deps.filePath, `${JSON.stringify(data, null, 2)}
+`, { mode });
+      });
+    },
+    update(mutate) {
+      let result;
+      withLock(() => {
+        const current = readJsonFile(deps.filePath, deps.sanitize);
+        const next = mutate(current);
+        writeAtomicSync(deps.filePath, `${JSON.stringify(next, null, 2)}
+`, { mode });
+        result = next;
+      });
+      return result;
+    }
+  };
+  function withLock(operation) {
+    if (!deps.lockDir) {
+      ensureSafeDirectoryIfSensitive(dir, sensitivity);
+      return operation();
+    }
+    ensureSafeDirectoryIfSensitive(dir, sensitivity);
+    return withDirectoryLock(
+      {
+        lockDir: deps.lockDir,
+        ownerFileName: deps.lockOwnerFileName,
+        timeoutMs: deps.timeoutMs,
+        staleLockMs: deps.staleLockMs,
+        now
+      },
+      () => {
+        if (deps.tempCleanupPrefix) {
+          cleanupTempFiles(dir, deps.tempCleanupPrefix, minAgeMs, now());
+        }
+        return operation();
+      }
+    );
+  }
+}
+function readJsonFile(filePath, sanitize) {
+  let fd;
+  try {
+    const stat5 = fs11.lstatSync(filePath);
+    if (!stat5 || !stat5.isFile() || stat5.isSymbolicLink()) {
+      return sanitize(void 0);
+    }
+    fd = fs11.openSync(filePath, fs11.constants.O_RDONLY | NOFOLLOW_FLAG);
+    if (!fs11.fstatSync(fd).isFile()) {
+      return sanitize(void 0);
+    }
+    return sanitize(JSON.parse(fs11.readFileSync(fd, "utf-8")));
+  } catch {
+    return sanitize(void 0);
+  } finally {
+    if (fd !== void 0) {
+      try {
+        fs11.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+function ensureSafeDirectoryIfSensitive(dir, sensitivity) {
+  if (sensitivity === "sensitive") {
+    ensureSafeDirectory(dir);
+  } else {
+    fs11.mkdirSync(dir, { recursive: true });
+  }
+}
+
+// ../../packages/fleet-infra/src/global-options/store.ts
+var GLOBAL_OPTIONS_VERSION = 1;
+var GLOBAL_OPTIONS_FILE_NAME = "settings.json";
+var LOCK_DIR_NAME = "settings.json.lock";
+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 = path25.join(dataDir, GLOBAL_OPTIONS_FILE_NAME);
+  const lockDir = path25.join(dataDir, LOCK_DIR_NAME);
+  const store2 = createDurableJsonStore({
+    filePath: optionsPath,
+    lockDir,
+    lockOwnerFileName: LOCK_OWNER_FILE_NAME,
+    sanitize: (value) => sanitizeGlobalOptionsData(value).data,
+    sensitivity: "sensitive",
+    timeoutMs: deps.timeoutMs,
+    staleLockMs: deps.staleLockMs,
+    tempCleanupPrefix: TEMP_FILE_PREFIX,
+    now: deps.now
+  });
+  return {
+    path: optionsPath,
+    load: () => store2.load(),
+    save: (data) => store2.save(sanitizeGlobalOptionsData(data).data),
+    update: (mutate) => store2.update((current) => sanitizeGlobalOptionsData(mutate(current)).data)
+  };
+}
+function createEmptyGlobalOptionsData() {
+  return {
+    version: GLOBAL_OPTIONS_VERSION
+  };
+}
+function sanitizeGlobalOptionsData(value) {
+  if (!isRecord(value)) {
+    return { data: createEmptyGlobalOptionsData(), changed: true };
+  }
+  if (value.version !== GLOBAL_OPTIONS_VERSION) {
+    return { data: createEmptyGlobalOptionsData(), changed: true };
+  }
+  const data = {
+    version: GLOBAL_OPTIONS_VERSION,
+    ...typeof value.replaceSystemPrompt === "boolean" ? { replaceSystemPrompt: value.replaceSystemPrompt } : {},
+    ...typeof value.enableMetaphor === "boolean" ? { enableMetaphor: value.enableMetaphor } : {}
+  };
+  const allowedKeys = /* @__PURE__ */ new Set(["version", "replaceSystemPrompt", "enableMetaphor"]);
+  const changed = Object.keys(value).some((key) => !allowedKeys.has(key)) || "replaceSystemPrompt" in value && typeof value.replaceSystemPrompt !== "boolean" || "enableMetaphor" in value && typeof value.enableMetaphor !== "boolean";
+  return { data, changed };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ../../packages/fleet-infra/src/global-options/service.ts
+function createGlobalOptionsService(deps = {}) {
+  const store2 = deps.store ?? createGlobalOptionsStore({ dataDir: deps.dataDir });
+  return {
+    load: () => store2.load(),
+    save: (data) => {
+      store2.save(data);
+      return store2.load();
+    },
+    update: (mutate) => updateGlobalOptions(store2, mutate)
+  };
+}
+function updateGlobalOptions(store2, mutate) {
+  return store2.update(mutate);
+}
+
+// ../../packages/fleet-infra/src/index.ts
+function createInfraServices(deps = {}) {
+  const globalOptionsService = createGlobalOptionsService();
+  const authService = createAuthService({ authPath: deps.authPath ?? DEFAULT_AUTH_PATH });
+  return {
+    authService,
+    globalOptionsService
+  };
+}
+function readFleetConsoleRelease() {
+  const requireFromHere = createRequire(import.meta.url);
+  const packageJsonPath = resolvePackageJsonPath(requireFromHere);
+  const pkg = requireFromHere(packageJsonPath);
+  const packageRoot = path25__default.dirname(packageJsonPath);
+  const version2 = pkg.version ?? "";
+  if (pkg.private === true) {
+    return { channel: "local", version: version2, packageRoot };
+  }
+  return { channel: "stable", version: version2, packageRoot };
+}
+function resolvePackageJsonPath(requireFromHere) {
+  for (const candidate of ["../package.json", "../../package.json"]) {
+    try {
+      return requireFromHere.resolve(candidate);
+    } catch (error51) {
+      if (error51.code !== "MODULE_NOT_FOUND") throw error51;
+    }
+  }
+  throw new Error("fleet_console_package_json_not_found");
+}
+
+// core/host/paths.ts
+var LOCK_DIR_NAME2 = "fleet-console";
+var CONSOLE_RUNTIME_DIR_NAME = "console";
+var LOCK_FILE_NAME = "console.lock";
+var CONSOLE_DATA_DIR_NAME = "console";
+var CONSOLE_STATE_FILE_NAME = "state.json";
+var CONSOLE_SETTINGS_FILE_NAME = "settings.json";
+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: path25__default.join(base, LOCK_FILE_NAME) };
+}
+function createConsoleDataPaths(deps = {}) {
+  const dir = defaultConsoleDataBaseDir(deps);
+  return {
+    dir,
+    stateFile: path25__default.join(dir, CONSOLE_STATE_FILE_NAME),
+    settingsFile: path25__default.join(dir, CONSOLE_SETTINGS_FILE_NAME),
+    capturesDir: path25__default.join(dir, CONSOLE_CAPTURES_DIR_NAME)
+  };
+}
+function defaultConsoleBaseDir(deps) {
+  let release;
+  const channel = deps.channel ?? (release = readFleetConsoleRelease()).channel;
+  if (channel === "local") {
+    const packageRoot = deps.packageRoot ?? (release ??= readFleetConsoleRelease()).packageRoot;
+    return localConsoleDir(packageRoot);
+  }
+  const uid = deps.uid ?? (typeof process.getuid === "function" ? process.getuid() : 0);
+  return path25__default.join(os4__default.tmpdir(), `${LOCK_DIR_NAME2}-${uid}-${channel}`);
+}
+function defaultConsoleDataBaseDir(deps) {
+  if (deps.fleetDataDir !== void 0) {
+    return path25__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 path25__default.join(getFleetDataDir(), CONSOLE_DATA_DIR_NAME);
+}
+function localConsoleDir(packageRoot) {
+  return path25__default.join(path25__default.resolve(packageRoot, "..", ".."), ".fleet", CONSOLE_RUNTIME_DIR_NAME);
+}
 
 // ../../packages/fleet-carriers/src/dispatch/framework.ts
 var framework_exports = {};
@@ -374,7 +1077,7 @@ __export(external_exports, {
   guid: () => guid2,
   hash: () => hash,
   hex: () => hex2,
-  hostname: () => hostname2,
+  hostname: () => hostname4,
   httpUrl: () => httpUrl,
   includes: () => _includes,
   instanceof: () => _instanceof,
@@ -1004,10 +1707,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path47) {
-  if (!path47)
+function getElementAtPath(obj, path46) {
+  if (!path46)
     return obj;
-  return path47.reduce((acc, key) => acc?.[key], obj);
+  return path46.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1416,11 +2119,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path47, issues) {
+function prefixIssues(path46, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path47);
+    iss.path.unshift(path46);
     return iss;
   });
 }
@@ -1567,16 +2270,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path47 = []) => {
+  const processError = (error52, path46 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path47, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path46, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path47, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path46, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path47, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path46, ...issue2.path]);
       } else {
-        const fullpath = [...path47, ...issue2.path];
+        const fullpath = [...path46, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1603,17 +2306,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path47 = []) => {
+  const processError = (error52, path46 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path47, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path46, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path47, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path46, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path47, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path46, ...issue2.path]);
       } else {
-        const fullpath = [...path47, ...issue2.path];
+        const fullpath = [...path46, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1645,8 +2348,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path47 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path47) {
+  const path46 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path46) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -1782,7 +2485,7 @@ __export(regexes_exports, {
   extendedDuration: () => extendedDuration,
   guid: () => guid,
   hex: () => hex,
-  hostname: () => hostname,
+  hostname: () => hostname3,
   html5Email: () => html5Email,
   httpProtocol: () => httpProtocol,
   idnEmail: () => idnEmail,
@@ -1860,7 +2563,7 @@ var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]
 var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
 var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
 var base64url = /^[A-Za-z0-9_-]*$/;
-var hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
+var hostname3 = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
 var domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
 var httpProtocol = /^https?$/;
 var e164 = /^\+[1-9]\d{6,14}$/;
@@ -12714,7 +13417,7 @@ __export(schemas_exports2, {
   guid: () => guid2,
   hash: () => hash,
   hex: () => hex2,
-  hostname: () => hostname2,
+  hostname: () => hostname4,
   httpUrl: () => httpUrl,
   instanceof: () => _instanceof,
   int: () => int,
@@ -13334,7 +14037,7 @@ var ZodCustomStringFormat = /* @__PURE__ */ $constructor("ZodCustomStringFormat"
 function stringFormat(format, fnOrRegex, _params = {}) {
   return _stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);
 }
-function hostname2(_params) {
+function hostname4(_params) {
   return _stringFormat(ZodCustomStringFormat, "hostname", regexes_exports.hostname, _params);
 }
 function hex2(_params) {
@@ -14310,13 +15013,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path47 = ref.slice(1).split("/").filter(Boolean);
-  if (path47.length === 0) {
+  const path46 = ref.slice(1).split("/").filter(Boolean);
+  if (path46.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path47[0] === defsKey) {
-    const key = path47[1];
+  if (path46[0] === defsKey) {
+    const key = path46[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -17627,7 +18330,7 @@ var AcpConnection = class extends BaseConnection {
   }
   /** Claude 계열 브릿지인지 여부를 단일 판별 지점으로 유지합니다. */
   isClaudeBackend() {
-    return this.cliType === "claude" || this.cliType === "claude-zai" || this.cliType === "claude-kimi" || this.cliType === "claude-glm";
+    return this.cliType === "claude";
   }
   /** Claude bridge만 native system prompt append를 지원하므로 이 경로만 사용합니다. */
   getClaudeSystemPrompt(systemPrompt) {
@@ -18125,7 +18828,7 @@ function inferBinName(packageName) {
 // ../../packages/core-unified-agent/models.json
 var models_default = {
   version: 1,
-  updatedAt: "2026-06-16T00:00:00Z",
+  updatedAt: "2026-07-04T00:00:00Z",
   providers: {
     claude: {
       name: "Claude Code with Anthropic",
@@ -18140,48 +18843,6 @@ var models_default = {
         { modelId: "claude-opus-4-8[1m]", name: "Claude Opus 4.8 [1M]", effort: { supported: true, levels: ["low", "medium", "high", "xhigh", "max"], default: "high" } }
       ]
     },
-    "claude-zai": {
-      name: "Claude Code with Z.AI GLM",
-      defaultModel: "opus",
-      models: [
-        { modelId: "haiku", name: "GLM-4.5 Air (Haiku slot)", effort: { supported: false } },
-        { modelId: "sonnet", name: "GLM-5 Turbo (Sonnet slot)", effort: { supported: false } },
-        { modelId: "opus", name: "GLM-5.1 (Opus slot)", effort: { supported: false } }
-      ],
-      modelsMapping: {
-        haiku: "glm-4.5-air",
-        sonnet: "glm-5-turbo",
-        opus: "glm-5.1"
-      }
-    },
-    "claude-kimi": {
-      name: "Claude Code with Moonshot Kimi",
-      defaultModel: "opus",
-      models: [
-        { modelId: "haiku", name: "Kimi K2.7 Code (Haiku slot)", effort: { supported: false } },
-        { modelId: "sonnet", name: "Kimi K2.7 Code (Sonnet slot)", effort: { supported: false } },
-        { modelId: "opus", name: "Kimi K2.7 Code (Opus slot)", effort: { supported: false } }
-      ],
-      modelsMapping: {
-        haiku: "kimi-k2.7-code",
-        sonnet: "kimi-k2.7-code",
-        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",
@@ -18199,7 +18860,9 @@ var models_default = {
         { modelId: "opencode-go/deepseek-v4-pro", name: "DeepSeek V4 Pro", effort: { supported: false } },
         { modelId: "opencode-go/glm-5", name: "GLM-5", effort: { supported: false } },
         { modelId: "opencode-go/glm-5.1", name: "GLM-5.1", effort: { supported: false } },
-        { modelId: "opencode-go/kimi-k2.6", name: "Kimi K2.6 (3x limits)", effort: { supported: false } }
+        { modelId: "opencode-go/glm-5.2", name: "GLM-5.2", effort: { supported: false } },
+        { modelId: "opencode-go/kimi-k2.6", name: "Kimi K2.6 (3x limits)", effort: { supported: false } },
+        { modelId: "opencode-go/kimi-k2.7-code", name: "Kimi K2.7 Code", effort: { supported: false } }
       ]
     },
     cursor: {
@@ -18212,9 +18875,9 @@ var models_default = {
         { modelId: "gemini-3.1-pro", name: "Gemini 3.1 Pro", effort: { supported: false } },
         { modelId: "gemini-3-flash", name: "Gemini 3 Flash", effort: { supported: false } },
         { modelId: "gemini-3.5-flash", name: "Gemini 3.5 Flash", effort: { supported: false } },
-        { modelId: "claude-opus-4-7-thinking", name: "Claude Opus 4.7 Thinking", spawnModelTemplate: "claude-opus-4-7-thinking-{effort}", effort: { supported: true, levels: ["low", "medium", "high", "xhigh", "max"], default: "xhigh" } },
-        { modelId: "claude-opus-4-8-thinking", name: "Claude Opus 4.8 Thinking", spawnModelTemplate: "claude-opus-4-8-thinking-{effort}", effort: { supported: true, levels: ["low", "medium", "high", "xhigh", "max"], default: "xhigh" } },
-        { modelId: "claude-4.6-sonnet-medium-thinking", name: "Claude Sonnet 4.6 Medium Thinking", effort: { supported: false } }
+        { modelId: "kimi-k2.7-code", name: "Kimi K2.7 Code", effort: { supported: false } },
+        { modelId: "glm-5.2", name: "GLM 5.2", spawnModelTemplate: "glm-5.2-{effort}", effort: { supported: true, levels: ["high", "max"], default: "max" } },
+        { modelId: "claude-opus-4-8-thinking", name: "Claude Opus 4.8 Thinking", spawnModelTemplate: "claude-opus-4-8-thinking-{effort}", effort: { supported: true, levels: ["low", "medium", "high", "xhigh", "max"], default: "xhigh" } }
       ]
     }
   }
@@ -18385,77 +19048,6 @@ var CLI_BACKENDS = {
     usesNpxBridge: true,
     defaultMaxTokens: 16384
   },
-  "claude-zai": {
-    id: "claude-zai",
-    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://api.z.ai/api/anthropic",
-      API_TIMEOUT_MS: "3000000"
-    }
-  },
-  "claude-kimi": {
-    id: "claude-kimi",
-    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://api.kimi.com/coding/",
-      ENABLE_TOOL_SEARCH: "false",
-      ANTHROPIC_MODEL: "kimi-k2.7-code",
-      CLAUDE_CODE_SUBAGENT_MODEL: "kimi-k2.7-code",
-      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",
@@ -18550,9 +19142,6 @@ function getBackendConfig(cli) {
 function getYoloModeId(cli) {
   switch (cli) {
     case "claude":
-    case "claude-zai":
-    case "claude-kimi":
-    case "claude-glm":
       return "bypassPermissions";
     case "opencode-go":
       return "build";
@@ -19886,12 +20475,12 @@ var CodexAppServerConnection = class extends BaseConnection {
     );
   }
   findRolloutPathForThreadId(threadId) {
-    const codexHome = this.codexHome ?? this.env.CODEX_HOME ?? path26.join(this.env.HOME ?? "", ".codex");
+    const codexHome = this.codexHome ?? this.env.CODEX_HOME ?? path25.join(this.env.HOME ?? "", ".codex");
     if (!codexHome) {
       return null;
     }
     for (const rootName of ["sessions", "archived_sessions"]) {
-      const found = findRolloutPath(path26.join(codexHome, rootName), threadId);
+      const found = findRolloutPath(path25.join(codexHome, rootName), threadId);
       if (found) {
         return found;
       }
@@ -20002,7 +20591,7 @@ function findRolloutPath(root, threadId) {
     return null;
   }
   for (const entry of fs11.readdirSync(root, { withFileTypes: true })) {
-    const entryPath = path26.join(root, entry.name);
+    const entryPath = path25.join(root, entry.name);
     if (entry.isDirectory()) {
       const found = findRolloutPath(entryPath, threadId);
       if (found) {
@@ -21454,9 +22043,6 @@ var UnifiedAgent = {
   createClient(cli) {
     switch (cli) {
       case "claude":
-      case "claude-zai":
-      case "claude-kimi":
-      case "claude-glm":
         return new UnifiedClaudeAgentClient(cli);
       case "codex":
         return new UnifiedCodexAgentClient();
@@ -21476,7 +22062,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, claude-glm, codex, opencode-go, cursor \uC911 \uD558\uB098\uB97C \uC124\uCE58\uD574\uC8FC\uC138\uC694."
+        "\uC0AC\uC6A9 \uAC00\uB2A5\uD55C CLI\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. claude, codex, opencode-go, cursor \uC911 \uD558\uB098\uB97C \uC124\uCE58\uD574\uC8FC\uC138\uC694."
       );
     }
     return this.createClient(preferred.cli);
@@ -21509,47 +22095,6 @@ var CLI_DISPLAY_NAMES = {
 };
 var CARRIER_JOBS_SELF_CALL_HINT = `When the Admiral passes prior \`job_id\` references in <prior_jobs>, use the \`carrier_jobs\` tool (available via your MCP server) to self-fetch results. Full lookup: \`carrier_jobs(action:"result", format:"full", job_id:"<id>")\`. If archive content has expired (\`full_invalidated\` is true), fall back to \`carrier_jobs(action:"result", format:"summary", job_id:"<id>")\`.`;
 
-// ../../packages/fleet-carriers/src/store/index.ts
-var store_exports = {};
-__export(store_exports, {
-  applyAgentCliTypeSelectionUpdate: () => applyAgentCliTypeSelectionUpdate,
-  buildHealedCarriers: () => buildHealedCarriers,
-  filterCarrierAgentModesToRegisteredIds: () => filterCarrierAgentModesToRegisteredIds,
-  getAgentCliSelection: () => getAgentCliSelection,
-  getCarriersFilePath: () => getCarriersFilePath,
-  getConfiguredTaskForceBackends: () => getConfiguredTaskForceBackends,
-  getConfiguredTaskForceBackendsFromSnapshot: () => getConfiguredTaskForceBackendsFromSnapshot,
-  getConfiguredTaskForceCarrierIds: () => getConfiguredTaskForceCarrierIds,
-  getConfiguredTaskForceCarrierIdsFromSnapshot: () => getConfiguredTaskForceCarrierIdsFromSnapshot,
-  getEnabledCarrierSubagentIds: () => getEnabledCarrierSubagentIds,
-  getTaskForceModelConfig: () => getTaskForceModelConfig,
-  initStore: () => initStore,
-  isCarrierAgentModeSubagent: () => isCarrierAgentModeSubagent,
-  loadCarrierDisplayNameOverrides: () => loadCarrierDisplayNameOverrides,
-  loadCarrierStates: () => loadCarrierStates,
-  normalizeCarrierDisplayNameInput: () => normalizeCarrierDisplayNameInput,
-  readCarrierAgentModeSnapshot: () => readCarrierAgentModeSnapshot,
-  readCarriersSnapshot: () => readCarriersSnapshot,
-  readFileBackedCarriersSnapshot: () => readFileBackedCarriersSnapshot,
-  readRawCarriers: () => readRawCarriers,
-  readRawCarriersOrDefaultStore: () => readRawCarriersOrDefaultStore,
-  resetCarrierTaskForceConfig: () => resetCarrierTaskForceConfig,
-  resetStoreForTests: () => resetStoreForTests,
-  resetTaskForceModelSelection: () => resetTaskForceModelSelection,
-  resolveAgentCliType: () => resolveAgentCliType,
-  resolveCarrierState: () => resolveCarrierState,
-  sanitizeCarrierDisplayName: () => sanitizeCarrierDisplayName,
-  saveAgentCliSelection: () => saveAgentCliSelection,
-  setCarrierAgentMode: () => setCarrierAgentMode,
-  store: () => store,
-  updateAgentCliSelection: () => updateAgentCliSelection,
-  updateAgentCliTypeOverride: () => updateAgentCliTypeOverride,
-  updateCarrierDisplayName: () => updateCarrierDisplayName,
-  updateCarriers: () => updateCarriers,
-  updateTaskForceModelSelection: () => updateTaskForceModelSelection,
-  withStoreLock: () => withStoreLock
-});
-
 // ../../packages/fleet-carriers/src/store/cli-types.ts
 var cli_types_exports = {};
 __export(cli_types_exports, {
@@ -21578,17 +22123,14 @@ function sanitizeFreeformText(value) {
   if (!trimmed || CONTROL_AND_C1_CHAR_PATTERN.test(trimmed)) return null;
   return trimmed;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function sanitizeAgentMode(value) {
-  return value === "cli" || value === "subagent" ? value : void 0;
-}
 function sanitizeAgentCliType(value) {
   return typeof value === "string" && value in CLI_BACKENDS ? value : void 0;
 }
 function sanitizeAgentCliSelection(value) {
-  if (!isRecord(value)) return void 0;
+  if (!isRecord2(value)) return void 0;
   const model = sanitizeFreeformText(value.model);
   if (!model) return void 0;
   const effort = sanitizeFreeformText(value.effort);
@@ -21610,7 +22152,7 @@ function sanitizeAgentCliSelectionForCliType(cliType, value) {
   };
 }
 function sanitizeAgentCli(value) {
-  if (!isRecord(value)) return {};
+  if (!isRecord2(value)) return {};
   const result = /* @__PURE__ */ Object.create(null);
   for (const [cliType, selection] of Object.entries(value)) {
     const sanitizedCliType = sanitizeAgentCliType(cliType);
@@ -21620,7 +22162,7 @@ function sanitizeAgentCli(value) {
   return result;
 }
 function sanitizeTaskforce(value) {
-  if (!isRecord(value)) return {};
+  if (!isRecord2(value)) return {};
   const result = /* @__PURE__ */ Object.create(null);
   for (const [cliType, selection] of Object.entries(value)) {
     const sanitizedCliType = sanitizeAgentCliType(cliType);
@@ -21632,14 +22174,12 @@ function sanitizeTaskforce(value) {
   return result;
 }
 function sanitizeCarrierState(value) {
-  if (!isRecord(value)) return void 0;
-  const agentMode = sanitizeAgentMode(value.agentMode);
+  if (!isRecord2(value)) return void 0;
   const agentCliType = sanitizeAgentCliType(value.agentCliType);
   const agentCli = sanitizeAgentCli(value.agentCli);
   const taskforce = sanitizeTaskforce(value.taskforce);
   const displayName = sanitizeFreeformText(value.displayName);
   const result = {};
-  if (agentMode) result.agentMode = agentMode;
   if (agentCliType) result.agentCliType = agentCliType;
   if (Object.keys(agentCli).length > 0) result.agentCli = agentCli;
   if (Object.keys(taskforce).length > 0) result.taskforce = taskforce;
@@ -21647,7 +22187,7 @@ function sanitizeCarrierState(value) {
   return Object.keys(result).length > 0 ? result : {};
 }
 function sanitizeCarriersMap(value) {
-  if (!isRecord(value)) return {};
+  if (!isRecord2(value)) return {};
   const result = /* @__PURE__ */ Object.create(null);
   for (const [carrierId, state] of Object.entries(value)) {
     const sanitizedCarrierId = sanitizeConfigKey(carrierId);
@@ -21836,7 +22376,7 @@ function resolvePathBinary(command2, env, options = {}) {
   return resolved ? wrapWindowsShim(resolved, env, platform) : void 0;
 }
 function wrapWindowsShim(resolved, env, platform) {
-  if (platform !== "win32" || !WINDOWS_SHIM_EXTENSIONS.has(path26__default.extname(resolved).toLowerCase())) {
+  if (platform !== "win32" || !WINDOWS_SHIM_EXTENSIONS.has(path25__default.extname(resolved).toLowerCase())) {
     return { bin: resolved, prefixArgs: [] };
   }
   rejectCmdExpansionSensitiveShim(resolved);
@@ -21854,13 +22394,13 @@ function forceWindowsArgQuoting(value) {
   return `${value} `;
 }
 function findOnPath(bin, pathValue, pathExts, platform) {
-  const pathSeparator = platform === "win32" ? WINDOWS_PATH_SEPARATOR : path26__default.delimiter;
-  if (hasPathSeparator(bin, platform) || path26__default.isAbsolute(bin)) {
+  const pathSeparator = platform === "win32" ? WINDOWS_PATH_SEPARATOR : path25__default.delimiter;
+  if (hasPathSeparator(bin, platform) || path25__default.isAbsolute(bin)) {
     return resolveWithExtensions(bin, pathExts, platform);
   }
   for (const entry of pathValue.split(pathSeparator)) {
     const searchDir = entry.length === 0 ? "." : entry;
-    const candidate = resolveWithExtensions(path26__default.join(searchDir, bin), pathExts, platform);
+    const candidate = resolveWithExtensions(path25__default.join(searchDir, bin), pathExts, platform);
     if (candidate) {
       return candidate;
     }
@@ -21868,7 +22408,7 @@ function findOnPath(bin, pathValue, pathExts, platform) {
   return void 0;
 }
 function resolveWithExtensions(candidate, pathExts, platform) {
-  if (platform !== "win32" || path26__default.extname(candidate).length > 0) {
+  if (platform !== "win32" || path25__default.extname(candidate).length > 0) {
     return existsSync(candidate) ? candidate : void 0;
   }
   for (const ext of pathExts) {
@@ -22933,7 +23473,7 @@ 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" ? "\\" : path26__default.sep;
+  const separator = deps.platform === "win32" ? "\\" : path25__default.sep;
   return child === parent || child.startsWith(`${parent}${separator}`);
 }
 function normalizeExistingPath(deps, value) {
@@ -22948,10 +23488,10 @@ function normalizePath(deps, value) {
   return deps.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function resolvePathForPlatform(platform, value) {
-  return platform === "win32" ? path26__default.win32.resolve(value) : path26__default.resolve(value);
+  return platform === "win32" ? path25__default.win32.resolve(value) : path25__default.resolve(value);
 }
 function joinPathForPlatform(platform, ...parts) {
-  return platform === "win32" ? path26__default.win32.join(...parts) : path26__default.join(...parts);
+  return platform === "win32" ? path25__default.win32.join(...parts) : path25__default.join(...parts);
 }
 function defaultExecFile(file2, args) {
   return execFileSync(file2, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
@@ -23031,350 +23571,6 @@ __export(state_io_exports, {
   updateCarriers: () => updateCarriers,
   withStoreLock: () => withStoreLock
 });
-var SECURE_DIR_MODE = 448;
-var SECURE_FILE_MODE = 384;
-var NOFOLLOW_FLAG = fs11.constants.O_NOFOLLOW ?? 0;
-function safeLstat(targetPath) {
-  try {
-    return fs11.lstatSync(targetPath);
-  } catch (error51) {
-    if (error51.code === "ENOENT") {
-      return null;
-    }
-    throw error51;
-  }
-}
-function ensureSafeDirectory(dirPath) {
-  const stat5 = safeLstat(dirPath);
-  if (stat5) {
-    if (!stat5.isDirectory() || stat5.isSymbolicLink()) {
-      throw new Error(`Unsafe Fleet directory: ${dirPath}`);
-    }
-    fs11.chmodSync(dirPath, SECURE_DIR_MODE);
-    return;
-  }
-  fs11.mkdirSync(dirPath, { recursive: true, mode: SECURE_DIR_MODE });
-  const created = safeLstat(dirPath);
-  if (!created?.isDirectory() || created.isSymbolicLink()) {
-    throw new Error(`Unsafe Fleet directory: ${dirPath}`);
-  }
-  fs11.chmodSync(dirPath, SECURE_DIR_MODE);
-}
-
-// ../../packages/fleet-infra/src/fs-store/atomic-write.ts
-var DEFAULT_MAX_ATTEMPTS = 10;
-var IGNORED_FSYNC_ERROR_CODES = /* @__PURE__ */ new Set(["EPERM", "EINVAL", "ENOSYS"]);
-function buildTempPath(filePath) {
-  const suffix = `${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.${os3.hostname()}`;
-  return `${filePath}.${suffix}.tmp`;
-}
-function writeAtomicSync(filePath, content, options = {}) {
-  const mode = options.mode ?? SECURE_FILE_MODE;
-  const doFsync = options.fsync !== false;
-  const maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
-  let lastExistsError;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const tempPath = buildTempPath(filePath);
-    let tempCreated = false;
-    try {
-      fs11.writeFileSync(tempPath, content, { encoding: "utf-8", flag: "wx", mode });
-      tempCreated = true;
-      if (doFsync) {
-        const fd = fs11.openSync(tempPath, "r");
-        try {
-          fsyncSyncBestEffort(fd);
-        } finally {
-          fs11.closeSync(fd);
-        }
-      }
-      fs11.renameSync(tempPath, filePath);
-      return;
-    } catch (error51) {
-      const code = error51.code;
-      if (!tempCreated && code === "EEXIST") {
-        lastExistsError = error51;
-        continue;
-      }
-      if (tempCreated) {
-        try {
-          fs11.unlinkSync(tempPath);
-        } catch {
-        }
-      }
-      throw error51;
-    }
-  }
-  throw lastExistsError ?? new Error(`Failed to create temp file after ${maxAttempts} attempts: ${filePath}`);
-}
-function cleanupTempFiles(dir, prefix, minAgeMs, now) {
-  let entries;
-  try {
-    entries = fs11.readdirSync(dir);
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (!entry.startsWith(prefix)) {
-      continue;
-    }
-    const tempPath = path26.join(dir, entry);
-    try {
-      const stat5 = fs11.lstatSync(tempPath);
-      if (stat5?.isFile() && !stat5.isSymbolicLink() && now - stat5.mtimeMs >= minAgeMs) {
-        fs11.unlinkSync(tempPath);
-      }
-    } catch {
-    }
-  }
-}
-function isIgnoredFsyncError(error51) {
-  const code = error51.code;
-  return typeof code === "string" && IGNORED_FSYNC_ERROR_CODES.has(code);
-}
-function fsyncSyncBestEffort(fd) {
-  try {
-    fs11.fsyncSync(fd);
-  } catch (error51) {
-    if (!isIgnoredFsyncError(error51)) {
-      throw error51;
-    }
-  }
-}
-var DEFAULT_LOCK_TIMEOUT_MS = 5e3;
-var DEFAULT_STALE_LOCK_MS = 3e4;
-var DEFAULT_RETRY_MS = 25;
-var DEFAULT_OWNER_FILE_NAME = "owner.json";
-function withDirectoryLock(deps, operation) {
-  const ownerFileName = deps.ownerFileName ?? DEFAULT_OWNER_FILE_NAME;
-  const timeoutMs = deps.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS;
-  const staleLockMs = deps.staleLockMs ?? DEFAULT_STALE_LOCK_MS;
-  const retryMs = deps.retryMs ?? DEFAULT_RETRY_MS;
-  const now = deps.now ?? (() => Date.now());
-  const startedAt = now();
-  while (true) {
-    try {
-      fs11.mkdirSync(deps.lockDir, { mode: 448 });
-      writeLockOwner(deps.lockDir, ownerFileName, now());
-      try {
-        return operation();
-      } finally {
-        releaseLock(deps.lockDir);
-      }
-    } catch (error51) {
-      const code = error51.code;
-      if (code !== "EEXIST") throw error51;
-      recoverStaleLock(deps.lockDir, ownerFileName, now, staleLockMs);
-      if (now() - startedAt >= timeoutMs) {
-        throw new Error(`Timed out waiting for Fleet directory lock: ${deps.lockDir}`);
-      }
-      sleepSync(retryMs);
-    }
-  }
-}
-function releaseLock(lockDir) {
-  try {
-    fs11.rmSync(lockDir, { recursive: true, force: true });
-  } catch {
-  }
-}
-function recoverStaleLock(lockDir, ownerFileName, now, staleLockMs) {
-  try {
-    const initialSnapshot = readLockSnapshot(lockDir, ownerFileName);
-    if (!isRecoverableSnapshot(initialSnapshot, now, staleLockMs)) return;
-    const quarantineDir = buildQuarantinePath(lockDir);
-    try {
-      fs11.renameSync(lockDir, quarantineDir);
-    } catch {
-      return;
-    }
-    try {
-      const quarantinedSnapshot = readLockSnapshot(quarantineDir, ownerFileName);
-      if (sameLockSnapshot(initialSnapshot, quarantinedSnapshot) && isRecoverableSnapshot(quarantinedSnapshot, now, staleLockMs)) {
-        fs11.rmSync(quarantineDir, { recursive: true, force: true });
-      } else {
-        restoreQuarantinedLock(quarantineDir, lockDir);
-      }
-    } catch (error51) {
-      const code = error51.code;
-      if (code !== "ENOENT") throw error51;
-    }
-  } catch (error51) {
-    const code = error51.code;
-    if (code !== "ENOENT") throw error51;
-  }
-}
-function readLockSnapshot(lockDir, ownerFileName) {
-  const stat5 = fs11.lstatSync(lockDir);
-  if (stat5.isSymbolicLink()) {
-    return { owner: null, mtimeMs: 0 };
-  }
-  return {
-    owner: readLockOwner(lockDir, ownerFileName),
-    mtimeMs: stat5.mtimeMs
-  };
-}
-function buildQuarantinePath(lockDir) {
-  const suffix = `${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}`;
-  return `${lockDir}.stale.${suffix}`;
-}
-function writeLockOwner(lockDir, ownerFileName, startedAt) {
-  const owner = {
-    pid: process.pid,
-    hostname: os3.hostname(),
-    startedAt
-  };
-  const ownerPath = path26.join(lockDir, ownerFileName);
-  try {
-    fs11.writeFileSync(ownerPath, JSON.stringify(owner), { encoding: "utf-8", mode: 384 });
-  } catch (error51) {
-    releaseLock(lockDir);
-    throw error51;
-  }
-}
-function readLockOwner(lockDir, ownerFileName) {
-  const ownerPath = path26.join(lockDir, ownerFileName);
-  try {
-    return sanitizeLockOwner(JSON.parse(fs11.readFileSync(ownerPath, "utf-8")));
-  } catch (error51) {
-    const code = error51.code;
-    if (code === "ENOENT") return null;
-    throw error51;
-  }
-}
-function isRecoverableOwner(owner, now, staleLockMs) {
-  if (owner.hostname !== os3.hostname()) return false;
-  if (now() - owner.startedAt < staleLockMs) return false;
-  return !isProcessAlive(owner.pid);
-}
-function isRecoverableSnapshot(snapshot, now, staleLockMs) {
-  if (snapshot.owner) return isRecoverableOwner(snapshot.owner, now, staleLockMs);
-  return now() - snapshot.mtimeMs >= staleLockMs;
-}
-function sameLockSnapshot(a, b) {
-  if (!a.owner || !b.owner) return !a.owner && !b.owner && a.mtimeMs === b.mtimeMs;
-  return a.owner.pid === b.owner.pid && a.owner.hostname === b.owner.hostname && a.owner.startedAt === b.owner.startedAt;
-}
-function restoreQuarantinedLock(quarantineDir, lockDir) {
-  try {
-    fs11.renameSync(quarantineDir, lockDir);
-  } catch {
-  }
-}
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error51) {
-    const code = error51.code;
-    if (code === "ESRCH") return false;
-    return true;
-  }
-}
-function sanitizeLockOwner(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
-  const record2 = value;
-  const pid = record2.pid;
-  const hostname5 = record2.hostname;
-  const startedAt = record2.startedAt;
-  if (!Number.isInteger(pid) || pid <= 0) return null;
-  if (typeof hostname5 !== "string" || !hostname5) return null;
-  if (!Number.isFinite(startedAt) || startedAt <= 0) return null;
-  return {
-    pid,
-    hostname: hostname5,
-    startedAt
-  };
-}
-function sleepSync(ms) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-
-// ../../packages/fleet-infra/src/fs-store/json-store.ts
-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 = path26.dirname(deps.filePath);
-  return {
-    path: deps.filePath,
-    load() {
-      return readJsonFile(deps.filePath, deps.sanitize);
-    },
-    save(data) {
-      withLock(() => {
-        writeAtomicSync(deps.filePath, `${JSON.stringify(data, null, 2)}
-`, { mode });
-      });
-    },
-    update(mutate) {
-      let result;
-      withLock(() => {
-        const current = readJsonFile(deps.filePath, deps.sanitize);
-        const next = mutate(current);
-        writeAtomicSync(deps.filePath, `${JSON.stringify(next, null, 2)}
-`, { mode });
-        result = next;
-      });
-      return result;
-    }
-  };
-  function withLock(operation) {
-    if (!deps.lockDir) {
-      ensureSafeDirectoryIfSensitive(dir, sensitivity);
-      return operation();
-    }
-    ensureSafeDirectoryIfSensitive(dir, sensitivity);
-    return withDirectoryLock(
-      {
-        lockDir: deps.lockDir,
-        ownerFileName: deps.lockOwnerFileName,
-        timeoutMs: deps.timeoutMs,
-        staleLockMs: deps.staleLockMs,
-        now
-      },
-      () => {
-        if (deps.tempCleanupPrefix) {
-          cleanupTempFiles(dir, deps.tempCleanupPrefix, minAgeMs, now());
-        }
-        return operation();
-      }
-    );
-  }
-}
-function readJsonFile(filePath, sanitize) {
-  let fd;
-  try {
-    const stat5 = fs11.lstatSync(filePath);
-    if (!stat5 || !stat5.isFile() || stat5.isSymbolicLink()) {
-      return sanitize(void 0);
-    }
-    fd = fs11.openSync(filePath, fs11.constants.O_RDONLY | NOFOLLOW_FLAG);
-    if (!fs11.fstatSync(fd).isFile()) {
-      return sanitize(void 0);
-    }
-    return sanitize(JSON.parse(fs11.readFileSync(fd, "utf-8")));
-  } catch {
-    return sanitize(void 0);
-  } finally {
-    if (fd !== void 0) {
-      try {
-        fs11.closeSync(fd);
-      } catch {
-      }
-    }
-  }
-}
-function ensureSafeDirectoryIfSensitive(dir, sensitivity) {
-  if (sensitivity === "sensitive") {
-    ensureSafeDirectory(dir);
-  } else {
-    fs11.mkdirSync(dir, { recursive: true });
-  }
-}
-
-// ../../packages/fleet-carriers/src/store/state-io.ts
 var FILENAME = "carriers.json";
 var DEFAULT_STORE_DIRNAME = ".fleet";
 var STALE_SUBAGENT_MODE_FILENAME = "carrier-subagent.json";
@@ -23405,7 +23601,7 @@ function readRawCarriersOrDefaultStore() {
 }
 function getCarriersFilePath() {
   if (!runtimeState.storeDir) return null;
-  return path26.join(runtimeState.storeDir, FILENAME);
+  return path25.join(runtimeState.storeDir, FILENAME);
 }
 function updateCarriers(mutator) {
   if (!runtimeState.storeDir) return;
@@ -23420,7 +23616,7 @@ function updateCarriers(mutator) {
 function withStoreLock(operation) {
   if (!runtimeState.storeDir) return operation();
   fs11.mkdirSync(runtimeState.storeDir, { recursive: true });
-  const lockDir = path26.join(runtimeState.storeDir, LOCK_DIRNAME);
+  const lockDir = path25.join(runtimeState.storeDir, LOCK_DIRNAME);
   return withDirectoryLock(
     { lockDir, ownerFileName: LOCK_OWNER_FILENAME },
     operation
@@ -23431,10 +23627,10 @@ function readCarriers() {
   return readCarriersFromDir(runtimeState.storeDir);
 }
 function resolveDefaultStoreDir() {
-  return path26.join(os3.homedir(), DEFAULT_STORE_DIRNAME);
+  return path25.join(os4.homedir(), DEFAULT_STORE_DIRNAME);
 }
 function readCarriersFromDir(dir) {
-  const filePath = path26.join(dir, FILENAME);
+  const filePath = path25.join(dir, FILENAME);
   let fd;
   try {
     const stat5 = fs11.lstatSync(filePath);
@@ -23464,7 +23660,7 @@ function recordLastLocalWriteFingerprint(filePath, generation) {
 function writeCarriers(s) {
   if (!runtimeState.storeDir) throw new Error("Fleet store is not initialized.");
   fs11.mkdirSync(runtimeState.storeDir, { recursive: true });
-  const filePath = path26.join(runtimeState.storeDir, FILENAME);
+  const filePath = path25.join(runtimeState.storeDir, FILENAME);
   const next = serializeFleetCarriers(s);
   writeAtomicSync(filePath, `${JSON.stringify(next, null, 2)}
 `, { fsync: false, mode: 420 });
@@ -23489,7 +23685,7 @@ function sanitizeFleetCarriers(value) {
 }
 function unlinkStaleSubagentModeFile(dir) {
   try {
-    fs11.unlinkSync(path26.join(dir, STALE_SUBAGENT_MODE_FILENAME));
+    fs11.unlinkSync(path25.join(dir, STALE_SUBAGENT_MODE_FILENAME));
   } catch {
   }
 }
@@ -23691,7 +23887,6 @@ function resolveCarriersRecord(raw, defaultsByCarrier, resolve2) {
 function buildResolvedCarrierState(state, defaults, agentCliType, taskforce) {
   const agentCli = sanitizeAgentCli(state.agentCli);
   return {
-    agentMode: state.agentMode ?? defaults?.defaultAgentMode ?? "cli",
     agentCliType,
     agentCli: {
       ...agentCli,
@@ -23717,57 +23912,6 @@ function resolveSelectionForCliType(stored, cliType, defaults) {
   return { model, effort };
 }
 
-// ../../packages/fleet-carriers/src/store/subagent-mode.ts
-var subagent_mode_exports = {};
-__export(subagent_mode_exports, {
-  filterCarrierAgentModesToRegisteredIds: () => filterCarrierAgentModesToRegisteredIds,
-  getEnabledCarrierSubagentIds: () => getEnabledCarrierSubagentIds,
-  isCarrierAgentModeSubagent: () => isCarrierAgentModeSubagent,
-  readCarrierAgentModeSnapshot: () => readCarrierAgentModeSnapshot,
-  setCarrierAgentMode: () => setCarrierAgentMode
-});
-function readCarrierAgentModeSnapshot(defaultsByCarrier = {}) {
-  const raw = readRawCarriers();
-  const carriers = buildHealedCarriers(defaultsByCarrier);
-  return {
-    agentModes: Object.fromEntries(
-      Object.entries(carriers).filter(([, state]) => state.agentMode === "subagent").map(([id]) => [id, "subagent"])
-    ),
-    generation: raw._meta?.generation ?? 0
-  };
-}
-function isCarrierAgentModeSubagent(carrierId, defaultAgentMode = "cli") {
-  const rawMode = readRawCarriers().carriers?.[carrierId]?.agentMode;
-  return (rawMode ?? defaultAgentMode) === "subagent";
-}
-function setCarrierAgentMode(carrierId, enabled, defaultAgentMode = "cli") {
-  const sanitizedCarrierId = sanitizeConfigKey(carrierId);
-  if (!sanitizedCarrierId) return;
-  const nextAgentMode = enabled ? "subagent" : "cli";
-  updateCarriers((states) => {
-    const carriers = { ...states.carriers ?? {} };
-    const current = carriers[sanitizedCarrierId] ?? {};
-    const next = { ...current };
-    if (nextAgentMode === defaultAgentMode) delete next.agentMode;
-    else next.agentMode = nextAgentMode;
-    carriers[sanitizedCarrierId] = next;
-    states.carriers = carriers;
-  });
-}
-function filterCarrierAgentModesToRegisteredIds(snapshot, registeredCarrierIds) {
-  const allowed = new Set(registeredCarrierIds);
-  return {
-    agentModes: Object.fromEntries(
-      Object.entries(snapshot.agentModes).filter(([carrierId]) => allowed.has(carrierId))
-    ),
-    generation: snapshot.generation
-  };
-}
-function getEnabledCarrierSubagentIds(snapshot, registeredCarrierIds) {
-  const filtered = registeredCarrierIds ? filterCarrierAgentModesToRegisteredIds(snapshot, registeredCarrierIds) : snapshot;
-  return Object.keys(filtered.agentModes).sort();
-}
-
 // ../../packages/fleet-carriers/src/store/taskforce-config.ts
 var taskforce_config_exports = {};
 __export(taskforce_config_exports, {
@@ -23890,20 +24034,12 @@ function isTaskForceCliType(value) {
 }
 
 // ../../packages/fleet-carriers/src/store/index.ts
-var store = {
+({
   ...state_io_exports,
-  ...subagent_mode_exports,
   ...models_exports,
   ...taskforce_config_exports,
   ...cli_types_exports,
-  ...display_names_exports,
-  stateIo: state_io_exports,
-  subagentMode: subagent_mode_exports,
-  models: models_exports,
-  taskforceConfig: taskforce_config_exports,
-  cliTypes: cli_types_exports,
-  displayNames: display_names_exports
-};
+  ...display_names_exports});
 
 // ../../packages/fleet-carriers/src/dispatch/framework.ts
 var CarrierRegistry = class {
@@ -23949,7 +24085,6 @@ function registerCarrier(registry3, config2) {
     existing.defaultModel = config2.defaultModel;
     existing.defaultEffort = config2.defaultEffort;
     existing.carrierMetadata = config2.carrierMetadata;
-    existing.subagent = config2.subagent;
   } else {
     gs.modes.set(config2.id, { config: config2 });
   }
@@ -24064,27 +24199,6 @@ function getModelEffort(cliType, modelId) {
   return normalizeEffort(getEffort(cliType, modelId));
 }
 
-// ../../packages/fleet-carriers/src/personas/index.ts
-var personas_exports = {};
-__export(personas_exports, {
-  CHRONICLE_DEFAULTS: () => CHRONICLE_DEFAULTS,
-  CHRONICLE_METADATA: () => CARRIER_METADATA,
-  GENESIS_DEFAULTS: () => GENESIS_DEFAULTS,
-  GENESIS_METADATA: () => CARRIER_METADATA2,
-  KIROV_DEFAULTS: () => KIROV_DEFAULTS,
-  KIROV_METADATA: () => CARRIER_METADATA3,
-  NIMITZ_DEFAULTS: () => NIMITZ_DEFAULTS,
-  NIMITZ_METADATA: () => CARRIER_METADATA4,
-  OHIO_DEFAULTS: () => OHIO_DEFAULTS,
-  OHIO_METADATA: () => CARRIER_METADATA5,
-  SENTINEL_DEFAULTS: () => SENTINEL_DEFAULTS,
-  SENTINEL_METADATA: () => CARRIER_METADATA6,
-  TEMPEST_DEFAULTS: () => TEMPEST_DEFAULTS,
-  TEMPEST_METADATA: () => CARRIER_METADATA7,
-  VANGUARD_DEFAULTS: () => VANGUARD_DEFAULTS,
-  VANGUARD_METADATA: () => CARRIER_METADATA8
-});
-
 // ../../packages/fleet-carriers/src/personas/chronicle.ts
 var CHRONICLE_DEFAULTS = {
   id: "chronicle",
@@ -24093,14 +24207,8 @@ var CHRONICLE_DEFAULTS = {
   agent: {
     dispatch: {
       defaultCliType: "claude",
-      defaultAgentMode: "subagent",
       defaultModel: "sonnet",
       defaultEffort: "low"
-    },
-    nativeSubagents: {
-      byHost: {
-        claude: { defaultModel: "sonnet", defaultEffort: "low" }
-      }
     }
   }
 };
@@ -24193,14 +24301,8 @@ var GENESIS_DEFAULTS = {
   agent: {
     dispatch: {
       defaultCliType: "claude",
-      defaultAgentMode: "subagent",
       defaultModel: "sonnet",
       defaultEffort: "medium"
-    },
-    nativeSubagents: {
-      byHost: {
-        claude: { defaultModel: "sonnet", defaultEffort: "medium" }
-      }
     }
   }
 };
@@ -24268,14 +24370,8 @@ var KIROV_DEFAULTS = {
   agent: {
     dispatch: {
       defaultCliType: "claude",
-      defaultAgentMode: "subagent",
       defaultModel: "opus[1m]",
       defaultEffort: "xhigh"
-    },
-    nativeSubagents: {
-      byHost: {
-        claude: { defaultModel: "opus[1m]", defaultEffort: "xhigh" }
-      }
     }
   }
 };
@@ -24338,14 +24434,8 @@ var NIMITZ_DEFAULTS = {
   agent: {
     dispatch: {
       defaultCliType: "claude",
-      defaultAgentMode: "subagent",
       defaultModel: "opus[1m]",
       defaultEffort: "max"
-    },
-    nativeSubagents: {
-      byHost: {
-        claude: { defaultModel: "opus[1m]", defaultEffort: "xhigh" }
-      }
     }
   }
 };
@@ -24409,14 +24499,8 @@ var OHIO_DEFAULTS = {
   agent: {
     dispatch: {
       defaultCliType: "claude",
-      defaultAgentMode: "subagent",
       defaultModel: "sonnet",
       defaultEffort: "low"
-    },
-    nativeSubagents: {
-      byHost: {
-        claude: { defaultModel: "sonnet", defaultEffort: "low" }
-      }
     }
   }
 };
@@ -24481,14 +24565,8 @@ var SENTINEL_DEFAULTS = {
   agent: {
     dispatch: {
       defaultCliType: "claude",
-      defaultAgentMode: "subagent",
       defaultModel: "sonnet",
       defaultEffort: "max"
-    },
-    nativeSubagents: {
-      byHost: {
-        claude: { defaultModel: "sonnet", defaultEffort: "xhigh" }
-      }
     }
   }
 };
@@ -24544,14 +24622,8 @@ var TEMPEST_DEFAULTS = {
   agent: {
     dispatch: {
       defaultCliType: "claude",
-      defaultAgentMode: "subagent",
       defaultModel: "sonnet",
       defaultEffort: "medium"
-    },
-    nativeSubagents: {
-      byHost: {
-        claude: { defaultModel: "sonnet", defaultEffort: "medium" }
-      }
     }
   }
 };
@@ -24606,14 +24678,8 @@ var VANGUARD_DEFAULTS = {
   agent: {
     dispatch: {
       defaultCliType: "claude",
-      defaultAgentMode: "subagent",
       defaultModel: "haiku",
       defaultEffort: "low"
-    },
-    nativeSubagents: {
-      byHost: {
-        claude: { defaultModel: "haiku", defaultEffort: "low" }
-      }
     }
   }
 };
@@ -24678,24 +24744,14 @@ function registerDefaultCarriers(registry3) {
 }
 function buildDefaultCarrierConfig(registration) {
   const { defaults, metadata } = registration;
-  const claudeSubagentDefaults = defaults.agent.nativeSubagents?.byHost?.claude;
   return {
     id: defaults.id,
     defaultCliType: defaults.agent.dispatch.defaultCliType,
-    defaultAgentMode: defaults.agent.dispatch.defaultAgentMode,
     defaultEffort: defaults.agent.dispatch.defaultEffort,
     defaultModel: defaults.agent.dispatch.defaultModel,
     slot: defaults.slot,
     displayName: defaults.displayName,
-    carrierMetadata: metadata,
-    subagent: {
-      provider: "claude",
-      defaultModel: claudeSubagentDefaults?.defaultModel,
-      defaultEffort: claudeSubagentDefaults?.defaultEffort,
-      byHost: {
-        claude: claudeSubagentDefaults
-      }
-    }
+    carrierMetadata: metadata
   };
 }
 
@@ -24828,7 +24884,7 @@ var StatusOverlayController = class {
 function buildCarrierModelDefaults(config2, cliType) {
   if (!config2) return {};
   if (cliType === "claude") {
-    return config2.subagent?.byHost?.claude ?? {
+    return {
       ...config2.defaultModel ? { defaultModel: config2.defaultModel } : {},
       ...config2.defaultEffort ? { defaultEffort: config2.defaultEffort } : {}
     };
@@ -24845,46 +24901,8 @@ __export(taskforce_exports, {
   launchTaskForceJob: () => launchTaskForceJob
 });
 
-// ../../packages/fleet-carriers/src/jobs/archive.ts
-var archive_exports = {};
-__export(archive_exports, {
-  appendBlock: () => appendBlock,
-  createJobArchive: () => createJobArchive,
-  createJobStreamArchiveStore: () => createJobStreamArchiveStore,
-  detachJobArchive: () => detachJobArchive,
-  finalizeJobArchive: () => finalizeJobArchive,
-  getFinalized: () => getFinalized,
-  hasFinalizedJobArchive: () => hasFinalizedJobArchive,
-  hasJobArchive: () => hasJobArchive,
-  redactSecrets: () => redactSecrets,
-  resetJobArchivesForTest: () => resetJobArchivesForTest,
-  sanitizeArchiveText: () => sanitizeArchiveText,
-  serializeJobArchive: () => serializeJobArchive,
-  toArchiveBlock: () => toArchiveBlock,
-  toMessageArchiveBlock: () => toMessageArchiveBlock,
-  toThoughtArchiveBlock: () => toThoughtArchiveBlock,
-  toToolCallArchiveBlock: () => toToolCallArchiveBlock
-});
-
 // ../../packages/fleet-carriers/src/jobs/types.ts
-var types_exports2 = {};
-__export(types_exports2, {
-  CARRIER_JOBS_FULL_RESULT_BYTE_CAP: () => CARRIER_JOBS_FULL_RESULT_BYTE_CAP,
-  CARRIER_JOBS_GLOBAL_BYTE_CAP: () => CARRIER_JOBS_GLOBAL_BYTE_CAP,
-  CARRIER_JOBS_PER_SUBOP_BYTE_CAP: () => CARRIER_JOBS_PER_SUBOP_BYTE_CAP,
-  CARRIER_JOB_TTL_MS: () => CARRIER_JOB_TTL_MS,
-  JOB_LAUNCH_NOTICE: () => JOB_LAUNCH_NOTICE,
-  buildCarrierJobId: () => buildCarrierJobId,
-  buildJobSummary: () => buildJobSummary,
-  computeFinalStatus: () => computeFinalStatus,
-  formatLaunchResponseText: () => formatLaunchResponseText,
-  isCarrierJobId: () => isCarrierJobId,
-  parseCarrierJobId: () => parseCarrierJobId
-});
 var CARRIER_JOB_TTL_MS = 3 * 60 * 60 * 1e3;
-var CARRIER_JOBS_FULL_RESULT_BYTE_CAP = 2e4;
-var CARRIER_JOBS_PER_SUBOP_BYTE_CAP = 2e4;
-var CARRIER_JOBS_GLOBAL_BYTE_CAP = 6e4;
 var JOB_LAUNCH_NOTICE = [
   "Job accepted from carrier_dispatch; result arrives later via carrier-completion follow-up push tagged [carrier:result].",
   "Task Force is an execution mode of carrier_dispatch when the selected carrier is configured for it.",
@@ -24925,19 +24943,6 @@ function buildCarrierJobId(kind, toolCallId) {
   }
   return `${kind}:${toolCallId}`;
 }
-function parseCarrierJobId(jobId) {
-  const separatorIndex = jobId.indexOf(":");
-  if (separatorIndex <= 0 || separatorIndex === jobId.length - 1) return null;
-  const prefix = jobId.slice(0, separatorIndex);
-  if (!JOB_PREFIXES.has(prefix)) return null;
-  return {
-    kind: prefix,
-    toolCallId: jobId.slice(separatorIndex + 1)
-  };
-}
-function isCarrierJobId(jobId) {
-  return parseCarrierJobId(jobId) !== null;
-}
 function buildJobSummaryText(prefix, status, successCount, failureCount, error51) {
   if (status === "aborted") return `${prefix} aborted: ${successCount} done, ${failureCount} failed`;
   if (error51) return `${prefix} failed: ${error51}`;
@@ -24945,9 +24950,7 @@ function buildJobSummaryText(prefix, status, successCount, failureCount, error51
 }
 
 // ../../packages/fleet-carriers/src/jobs/archive.ts
-var HEAD_BYTE_RATIO = 0.25;
 var MAX_TEXT_CHARS = 24e3;
-var MAX_RAW_OUTPUT_CHARS = 12e3;
 var ANSI_PATTERN2 = /\x1b\[[0-?]*[ -/]*[@-~]/g;
 var CONTROL_PATTERN2 = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g;
 var SECRET_PATTERNS2 = [
@@ -24962,270 +24965,6 @@ var MAX_TOTAL_BYTES = 8 * 1024 * 1024;
 var PRESERVE_HEAD_BLOCKS = 20;
 var PRESERVE_TAIL_BLOCKS = 50;
 var defaultJobStreamArchiveStore = createJobStreamArchiveStore();
-function serializeJobArchive(archive, opts) {
-  const blocks = archive.truncated ? [...archive.blocks] : [...archive.blocks].sort((a, b) => a.timestamp - b.timestamp);
-  if (blocks.length === 0) {
-    return `(no archived output)`;
-  }
-  const perSubOpMaxBytes = opts?.perSubOpMaxBytes;
-  if (perSubOpMaxBytes !== void 0 && perSubOpMaxBytes > 0) {
-    let merged = applyPerSubOpByteCap(blocks, perSubOpMaxBytes);
-    const globalMax = opts?.maxBytes;
-    if (globalMax !== void 0 && globalMax > 0) {
-      merged = applyByteCap(merged, globalMax, void 0, false);
-    }
-    return merged.map((block) => renderBlock(block)).join("\n\n").trimEnd();
-  }
-  return applyByteCap(blocks, opts?.maxBytes, void 0, false).map((block) => renderBlock(block)).join("\n\n").trimEnd();
-}
-function applyPerSubOpByteCap(blocks, perSubOpMaxBytes) {
-  const groupMap = /* @__PURE__ */ new Map();
-  const orderedKeys = [];
-  for (const block of blocks) {
-    const key = subOpGroupKey(block);
-    if (!groupMap.has(key)) {
-      groupMap.set(key, []);
-      orderedKeys.push(key);
-    }
-    groupMap.get(key).push(block);
-  }
-  const merged = [];
-  for (const key of orderedKeys) {
-    const groupBlocks = groupMap.get(key);
-    const headerLabel = groupBlocks[0]?.label;
-    if (headerLabel !== void 0 && headerLabel !== "") {
-      const minTs = Math.min(...groupBlocks.map((b) => b.timestamp));
-      if (groupBlocks.every((block) => !block.text?.trim())) {
-        merged.push(groupHeaderBlock(headerLabel, minTs - 1));
-        merged.push(emptyGroupPlaceholderBlock(headerLabel, minTs));
-        continue;
-      }
-      const header = groupHeaderBlock(headerLabel, minTs - 1);
-      merged.push(...applyByteCap([header, ...groupBlocks], perSubOpMaxBytes, headerLabel, true));
-    } else {
-      merged.push(...applyByteCap(groupBlocks, perSubOpMaxBytes, void 0, true));
-    }
-  }
-  return merged;
-}
-function subOpGroupKey(block) {
-  return `${block.source}\0${block.label ?? ""}`;
-}
-function groupHeaderBlock(label, timestamp) {
-  return {
-    kind: "text",
-    timestamp,
-    source: "archive",
-    label: void 0,
-    text: `\u2500\u2500 ${label} \u2500\u2500`
-  };
-}
-function emptyGroupPlaceholderBlock(label, timestamp) {
-  return {
-    kind: "text",
-    timestamp,
-    source: "archive",
-    label: void 0,
-    text: `(no archived output for ${label})`
-  };
-}
-function applyByteCap(blocks, maxBytes, truncatedInLabel, enableSingleBlockCharSlice = false) {
-  if (!maxBytes || maxBytes <= 0) return blocks;
-  const full = blocks.map((block) => renderBlock(block)).join("\n\n").trimEnd();
-  if (byteLength2(full) <= maxBytes) return blocks;
-  if (enableSingleBlockCharSlice) {
-    const sliced = trySliceOversizedSingleOrHeaderPayload(blocks, maxBytes, truncatedInLabel);
-    if (sliced) return sliced;
-  }
-  const headBudget = Math.floor(maxBytes * HEAD_BYTE_RATIO);
-  const head = [];
-  let headBytes = 0;
-  for (const block of blocks) {
-    const blockBytes2 = serializedBlockBytes(block, head.length > 0);
-    if (headBytes + blockBytes2 > headBudget) break;
-    head.push(block);
-    headBytes += blockBytes2;
-  }
-  const tail = [];
-  for (let index = blocks.length - 1; index >= head.length; index--) {
-    const nextTail = [blocks[index], ...tail];
-    const omittedCount = blocks.length - head.length - nextTail.length;
-    const marker = buildTruncatedMarker(blocks, head.length, omittedCount, truncatedInLabel);
-    const candidateBytes = serializedBlocksBytes([...head, marker, ...nextTail]);
-    if (candidateBytes > maxBytes) continue;
-    tail.unshift(blocks[index]);
-  }
-  let selected = buildCappedSelection(blocks, head, tail, truncatedInLabel);
-  if (selected === blocks) return blocks;
-  while (serializedBlocksBytes(selected) > maxBytes && tail.length > 0) {
-    tail.shift();
-    selected = buildCappedSelection(blocks, head, tail, truncatedInLabel);
-  }
-  while (serializedBlocksBytes(selected) > maxBytes && head.length > 0) {
-    head.pop();
-    selected = buildCappedSelection(blocks, head, tail, truncatedInLabel);
-  }
-  return selected;
-}
-function trySliceOversizedSingleOrHeaderPayload(blocks, maxBytes, truncatedInLabel) {
-  if (blocks.length === 1) {
-    const block = blocks[0];
-    const rendered = renderBlock(block);
-    if (byteLength2(rendered) <= maxBytes) return null;
-    return sliceSingleOversizedTextBlock(block, rendered, maxBytes, truncatedInLabel);
-  }
-  if (blocks.length === 2 && isSerializerGroupHeaderBlock(blocks[0]) && blocks[1]?.kind === "text") {
-    const headerBlock = blocks[0];
-    const payloadBlock = blocks[1];
-    const headerRendered = renderBlock(headerBlock);
-    const bodyRendered = renderBlock(payloadBlock);
-    const sep3 = "\n\n";
-    const prefixBytes = byteLength2(headerRendered) + byteLength2(sep3);
-    const innerBudget = maxBytes - prefixBytes;
-    if (innerBudget <= 0) {
-      return [headerBlock, buildCharTruncatedMarkerBlock(payloadBlock.timestamp, countCodepointsInUtf8Buffer(Buffer.from(bodyRendered, "utf8")), truncatedInLabel)];
-    }
-    if (byteLength2(bodyRendered) <= innerBudget) return null;
-    const { head, marker, tail } = splitRenderedUtf8AtByteCap(bodyRendered, innerBudget, truncatedInLabel);
-    return [
-      headerBlock,
-      { ...payloadBlock, text: head },
-      {
-        kind: "text",
-        timestamp: payloadBlock.timestamp,
-        source: "archive",
-        label: "truncated",
-        text: marker
-      },
-      { ...payloadBlock, text: tail, timestamp: payloadBlock.timestamp + 1 }
-    ];
-  }
-  return null;
-}
-function sliceSingleOversizedTextBlock(block, rendered, maxBytes, truncatedInLabel) {
-  const { head, marker, tail } = splitRenderedUtf8AtByteCap(rendered, maxBytes, truncatedInLabel);
-  const ts = block.timestamp;
-  return [
-    { ...block, text: head },
-    { kind: "text", timestamp: ts, source: "archive", label: "truncated", text: marker },
-    { ...block, text: tail, timestamp: ts + 1 }
-  ];
-}
-function isSerializerGroupHeaderBlock(block) {
-  if (block.kind !== "text" || block.source !== "archive" || block.label !== void 0) return false;
-  const line = block.text?.trim() ?? "";
-  return /^── .+ ──$/.test(line);
-}
-function splitRenderedUtf8AtByteCap(rendered, maxBytes, charLabel) {
-  const buf = Buffer.from(rendered, "utf8");
-  if (buf.length <= maxBytes) {
-    return { head: rendered, marker: "", tail: "" };
-  }
-  const sepLen = byteLength2("\n\n");
-  let headBudget = Math.min(buf.length, Math.floor(maxBytes * HEAD_BYTE_RATIO));
-  const tailBudget = Math.min(buf.length, Math.floor(maxBytes * (1 - HEAD_BYTE_RATIO)));
-  for (let iter = 0; iter < 200; iter++) {
-    let headLen2 = utf8PrefixByteLength(buf, headBudget);
-    let tailStart2 = utf8SuffixStartIndex(buf, tailBudget);
-    if (tailStart2 < headLen2) {
-      tailStart2 = utf8SuffixStartIndex(buf, Math.max(0, Math.min(tailBudget, buf.length - headLen2)));
-    }
-    if (tailStart2 < headLen2) {
-      tailStart2 = headLen2;
-    }
-    const midBuf = buf.subarray(headLen2, tailStart2);
-    const omittedChars = countCodepointsInUtf8Buffer(midBuf);
-    const marker2 = buildCharTruncatedMarker(omittedChars, charLabel);
-    const headStr = buf.subarray(0, headLen2).toString("utf8");
-    const tailStr = buf.subarray(tailStart2).toString("utf8");
-    const total = byteLength2(headStr) + sepLen + byteLength2(marker2) + sepLen + byteLength2(tailStr);
-    if (total <= maxBytes) {
-      return { head: headStr, marker: marker2, tail: tailStr };
-    }
-    headBudget = Math.max(0, headBudget - Math.max(16, Math.floor(headBudget * 0.08)));
-    if (headBudget === 0) break;
-  }
-  const marker = buildCharTruncatedMarker(Math.max(1, countCodepointsInUtf8Buffer(buf) - 1), charLabel);
-  const markerTotal = byteLength2(marker) + 2 * sepLen;
-  const room = Math.max(1, maxBytes - markerTotal);
-  const tailBudgetFallback = Math.min(buf.length, Math.max(1, Math.floor(room * (1 - HEAD_BYTE_RATIO))));
-  let tailStart = utf8SuffixStartIndex(buf, tailBudgetFallback);
-  let headLen = utf8PrefixByteLength(buf, Math.min(buf.length, Math.floor(room * HEAD_BYTE_RATIO)));
-  if (tailStart < headLen) {
-    tailStart = utf8SuffixStartIndex(buf, Math.max(0, Math.min(tailBudgetFallback, buf.length - headLen)));
-  }
-  if (tailStart < headLen) {
-    tailStart = headLen;
-  }
-  return {
-    head: buf.subarray(0, headLen).toString("utf8"),
-    marker,
-    tail: buf.subarray(tailStart).toString("utf8")
-  };
-}
-function buildCharTruncatedMarkerBlock(timestamp, omittedChars, label) {
-  return {
-    kind: "text",
-    timestamp,
-    source: "archive",
-    label: "truncated",
-    text: buildCharTruncatedMarker(omittedChars, label)
-  };
-}
-function buildCharTruncatedMarker(omittedChars, label) {
-  if (label !== void 0 && label.length > 0) {
-    return `[truncated ${omittedChars} chars in ${label}]`;
-  }
-  return `[truncated ${omittedChars} chars]`;
-}
-function utf8PrefixByteLength(buf, maxBytes) {
-  let len = Math.min(maxBytes, buf.length);
-  while (len > 0 && len < buf.length && (buf[len] & 192) === 128) {
-    len--;
-  }
-  return len;
-}
-function utf8SuffixStartIndex(buf, tailMaxBytes) {
-  if (tailMaxBytes <= 0) return buf.length;
-  const capped = Math.min(tailMaxBytes, buf.length);
-  let start = buf.length - capped;
-  while (start < buf.length && (buf[start] & 192) === 128) {
-    start++;
-  }
-  return start;
-}
-function countCodepointsInUtf8Buffer(slice) {
-  if (slice.length === 0) return 0;
-  return [...slice.toString("utf8")].length;
-}
-function renderBlock(block) {
-  return block.text?.trim() || "(empty)";
-}
-function buildCappedSelection(blocks, head, tail, truncatedInLabel) {
-  const omittedCount = blocks.length - head.length - tail.length;
-  if (omittedCount <= 0) return blocks;
-  return [...head, buildTruncatedMarker(blocks, head.length, omittedCount, truncatedInLabel), ...tail];
-}
-function buildTruncatedMarker(blocks, omittedStart, omittedCount, truncatedInLabel) {
-  const timestamp = blocks[omittedStart]?.timestamp ?? blocks.at(-1)?.timestamp ?? 0;
-  const text = truncatedInLabel !== void 0 && truncatedInLabel.length > 0 ? `[truncated ${omittedCount} blocks in ${truncatedInLabel}]` : `[truncated ${omittedCount} blocks]`;
-  return {
-    kind: "text",
-    timestamp,
-    source: "archive",
-    label: "truncated",
-    text
-  };
-}
-function serializedBlocksBytes(blocks) {
-  return byteLength2(blocks.map((block) => renderBlock(block)).join("\n\n").trimEnd());
-}
-function serializedBlockBytes(block, includeSeparator) {
-  return byteLength2(`${includeSeparator ? "\n\n" : ""}${renderBlock(block)}`);
-}
-function byteLength2(value) {
-  return Buffer.byteLength(value, "utf8");
-}
 function toArchiveBlock(kind, source, text, label, timestamp = Date.now()) {
   return {
     kind,
@@ -25235,24 +24974,6 @@ function toArchiveBlock(kind, source, text, label, timestamp = Date.now()) {
     text: sanitizeArchiveText(text, MAX_TEXT_CHARS)
   };
 }
-function toMessageArchiveBlock(source, text, label, timestamp = Date.now()) {
-  return toArchiveBlock("text", source, text, label, timestamp);
-}
-function toThoughtArchiveBlock(source, text, label, timestamp = Date.now()) {
-  return toArchiveBlock("thought", source, text, label, timestamp);
-}
-function toToolCallArchiveBlock(source, title, status, rawOutput, toolCallId, label, timestamp = Date.now()) {
-  return {
-    kind: "tool_call",
-    timestamp,
-    source: sanitizeArchiveText(source, 400),
-    label: label ? sanitizeArchiveText(label, 400) : void 0,
-    title: sanitizeArchiveText(title, 800),
-    status: sanitizeArchiveText(status, 200),
-    rawOutput: rawOutput === void 0 ? void 0 : safeSerialize(rawOutput, MAX_RAW_OUTPUT_CHARS),
-    toolCallId: toolCallId ? sanitizeArchiveText(toolCallId, 400) : void 0
-  };
-}
 function sanitizeArchiveText(value, maxChars = MAX_TEXT_CHARS) {
   const cleaned = value.replace(ANSI_PATTERN2, "").replace(CONTROL_PATTERN2, "");
   if (cleaned.length <= maxChars) return cleaned;
@@ -25265,14 +24986,6 @@ function redactSecrets(value) {
     value
   );
 }
-function safeSerialize(value, maxChars) {
-  if (typeof value === "string") return sanitizeArchiveText(value, maxChars);
-  try {
-    return sanitizeArchiveText(JSON.stringify(value, null, 2), maxChars);
-  } catch {
-    return sanitizeArchiveText(String(value), maxChars);
-  }
-}
 function createJobStreamArchiveStore() {
   const state = { archives: /* @__PURE__ */ new Map() };
   function getLiveArchive(jobId, now) {
@@ -25351,21 +25064,6 @@ function appendBlock(jobId, block, now = Date.now()) {
 function finalizeJobArchive(jobId, status, now = Date.now()) {
   return defaultJobStreamArchiveStore.finalizeJobArchive(jobId, status, now);
 }
-function getFinalized(jobId, now = Date.now()) {
-  return defaultJobStreamArchiveStore.getFinalized(jobId, now);
-}
-function hasJobArchive(jobId, now = Date.now()) {
-  return defaultJobStreamArchiveStore.hasJobArchive(jobId, now);
-}
-function hasFinalizedJobArchive(jobId, now = Date.now()) {
-  return defaultJobStreamArchiveStore.hasFinalizedJobArchive(jobId, now);
-}
-function detachJobArchive(jobId) {
-  defaultJobStreamArchiveStore.detachJobArchive(jobId);
-}
-function resetJobArchivesForTest() {
-  defaultJobStreamArchiveStore.resetJobArchivesForTest();
-}
 function buildTruncatedBlock(timestamp) {
   return {
     kind: "text",
@@ -25457,26 +25155,6 @@ function blockBytes(block) {
   return Buffer.byteLength(JSON.stringify(block), "utf8");
 }
 
-// ../../packages/fleet-carriers/src/jobs/dispatch.ts
-var dispatch_exports = {};
-__export(dispatch_exports, {
-  CARRIER_JOBS_DOCTRINE: () => CARRIER_JOBS_DOCTRINE,
-  CARRIER_RESULT_PUSH_PREFIX: () => CARRIER_RESULT_PUSH_PREFIX,
-  JOB_LAUNCH_NOTICE: () => JOB_LAUNCH_NOTICE,
-  buildCarrierJobsSchema: () => buildCarrierJobsSchema,
-  buildCarrierJobsToolSpec: () => buildCarrierJobsToolSpec,
-  buildCarrierResultSystemReminder: () => buildCarrierResultSystemReminder,
-  configureJobSummaryCache: () => configureJobSummaryCache,
-  createJobSummaryCache: () => createJobSummaryCache,
-  dispatchCarrierJobsAction: () => dispatchCarrierJobsAction,
-  formatLaunchResponseText: () => formatLaunchResponseText,
-  getJobSummary: () => getJobSummary,
-  listJobSummaries: () => listJobSummaries,
-  putJobSummary: () => putJobSummary,
-  resetJobSummaryCacheForTest: () => resetJobSummaryCacheForTest,
-  wrapSystemReminder: () => wrapSystemReminder
-});
-
 // ../../node_modules/.pnpm/typebox@1.1.34/node_modules/typebox/build/system/memory/memory.mjs
 var memory_exports = {};
 __export(memory_exports, {
@@ -29684,29 +29362,6 @@ __export(typebox_exports, {
   Void: () => Void
 });
 
-// ../../packages/fleet-carriers/src/jobs/lifecycle.ts
-var lifecycle_exports = {};
-__export(lifecycle_exports, {
-  acquireJobPermit: () => acquireJobPermit,
-  cancelJob: () => cancelJob,
-  combineAbortSignals: () => combineAbortSignals,
-  configureDetachedJobCap: () => configureDetachedJobCap,
-  createJobCancelRegistry: () => createJobCancelRegistry,
-  finalizeDetachedJob: () => finalizeDetachedJob,
-  getActiveBackgroundJobCount: () => getActiveBackgroundJobCount,
-  getActiveJob: () => getActiveJob,
-  hasJobCancelControllers: () => hasJobCancelControllers,
-  launchResponseResult: () => launchResponseResult,
-  listActiveJobs: () => listActiveJobs,
-  onActiveJobCountChange: () => onActiveJobCountChange,
-  registerJobAbortController: () => registerJobAbortController,
-  releaseJobPermit: () => releaseJobPermit,
-  resetJobCancelRegistryForTest: () => resetJobCancelRegistryForTest,
-  resetJobConcurrencyForTest: () => resetJobConcurrencyForTest,
-  startDetachedJob: () => startDetachedJob,
-  unregisterJobAbortControllers: () => unregisterJobAbortControllers
-});
-
 // ../../packages/fleet-carriers/src/jobs/summary-cache.ts
 var DEFAULT_MAX_ENTRIES = 50;
 var defaultJobSummaryCache = createJobSummaryCache();
@@ -29762,18 +29417,6 @@ function createJobSummaryCache() {
 function putJobSummary(summary, now = Date.now()) {
   defaultJobSummaryCache.putJobSummary(summary, now);
 }
-function getJobSummary(jobId, now = Date.now()) {
-  return defaultJobSummaryCache.getJobSummary(jobId, now);
-}
-function listJobSummaries(now = Date.now()) {
-  return defaultJobSummaryCache.listJobSummaries(now);
-}
-function configureJobSummaryCache(maxEntries, onEvict) {
-  defaultJobSummaryCache.configureJobSummaryCache(maxEntries, onEvict);
-}
-function resetJobSummaryCacheForTest() {
-  defaultJobSummaryCache.resetJobSummaryCacheForTest();
-}
 
 // ../../packages/fleet-carriers/src/jobs/lifecycle.ts
 var DEFAULT_MAX_DETACHED_JOBS = 5;
@@ -29819,33 +29462,6 @@ function releaseJobPermit(jobId, finished = {}) {
   state.activeJobs.delete(jobId);
   notifyActiveJobCountChange(state);
 }
-function getActiveJob(jobId) {
-  return getGuardState().activeJobs.get(jobId) ?? null;
-}
-function listActiveJobs() {
-  return [...getGuardState().activeJobs.values()].sort((a, b) => b.startedAt - a.startedAt);
-}
-function getActiveBackgroundJobCount() {
-  return getGuardState().activeJobs.size;
-}
-function onActiveJobCountChange(callback) {
-  const state = getGuardState();
-  state.activeJobCountCallbacks.push(callback);
-  return () => {
-    const index = state.activeJobCountCallbacks.indexOf(callback);
-    if (index >= 0) state.activeJobCountCallbacks.splice(index, 1);
-  };
-}
-function configureDetachedJobCap(maxDetachedJobs) {
-  getGuardState().maxDetachedJobs = maxDetachedJobs;
-}
-function resetJobConcurrencyForTest() {
-  const state = getGuardState();
-  state.activeJobs.clear();
-  state.activeCarrierJobs.clear();
-  state.maxDetachedJobs = DEFAULT_MAX_DETACHED_JOBS;
-  state.activeJobCountCallbacks = [];
-}
 function createJobCancelRegistry() {
   const state = { controllers: /* @__PURE__ */ new Map() };
   return {
@@ -29880,15 +29496,6 @@ function registerJobAbortController(jobId, controller) {
 function unregisterJobAbortControllers(jobId) {
   defaultJobCancelRegistry.unregisterJobAbortControllers(jobId);
 }
-function cancelJob(jobId) {
-  return defaultJobCancelRegistry.cancelJob(jobId);
-}
-function hasJobCancelControllers(jobId) {
-  return defaultJobCancelRegistry.hasJobCancelControllers(jobId);
-}
-function resetJobCancelRegistryForTest() {
-  defaultJobCancelRegistry.resetJobCancelRegistryForTest();
-}
 function combineAbortSignals(signals) {
   if (signals.length === 0) {
     return new AbortController().signal;
@@ -29963,43 +29570,74 @@ function getGuardState() {
   return guardState;
 }
 
+// ../../packages/fleet-carriers/src/jobs/workspace-manifest.ts
+var WORKSPACE_CHANGE_LIMIT = 200;
+var WORKSPACE_CHANGE_CLEARED_STATUS = "cleared";
+async function captureWorkspaceSnapshot(scanner, cwd) {
+  if (!scanner) return null;
+  try {
+    return await scanner.snapshot(cwd);
+  } catch {
+    return null;
+  }
+}
+async function captureJobWindowManifest(scanner, cwd, baseline) {
+  if (!scanner) return void 0;
+  const end = await captureWorkspaceSnapshot(scanner, cwd);
+  return buildWorkspaceManifest(baseline, end);
+}
+function buildWorkspaceManifest(baseline, end) {
+  if (!baseline || !end) return void 0;
+  const baselineByPath = new Map(baseline.map((entry) => [entry.path, normalizeSnapshotEntry(entry)]));
+  const endChanges = end.map(normalizeSnapshotEntry).filter((entry) => hasWindowChange(baselineByPath.get(entry.path), entry)).map(toManifestEntry);
+  const endPaths = new Set(end.map((entry) => entry.path));
+  const clearedChanges = [...baselineByPath.values()].filter((entry) => !endPaths.has(entry.path)).map((entry) => ({ status: WORKSPACE_CHANGE_CLEARED_STATUS, path: entry.path }));
+  const changes = [...endChanges, ...clearedChanges];
+  const truncated = changes.length > WORKSPACE_CHANGE_LIMIT;
+  const capped = changes.slice(0, WORKSPACE_CHANGE_LIMIT);
+  return {
+    changes: capped,
+    truncated
+  };
+}
+function buildStatLine(changeCount, truncated) {
+  const suffix = changeCount === 1 ? "file" : "files";
+  return `${truncated ? `${WORKSPACE_CHANGE_LIMIT}+` : String(changeCount)} ${suffix} (window-approx)`;
+}
+function normalizeSnapshotEntry(entry) {
+  return {
+    status: entry.status.trim(),
+    path: entry.path,
+    contentHash: entry.contentHash?.trim()
+  };
+}
+function toManifestEntry(entry) {
+  return {
+    status: entry.status,
+    path: entry.path
+  };
+}
+function hasWindowChange(baseline, end) {
+  if (!baseline) return true;
+  if (baseline.status !== end.status) return true;
+  if (baseline.contentHash && end.contentHash) {
+    return baseline.contentHash !== end.contentHash;
+  }
+  return false;
+}
+
 // ../../packages/fleet-carriers/src/jobs/dispatch.ts
 var CARRIER_RESULT_PUSH_PREFIX = "[carrier:result]";
-var CARRIER_JOBS_DOCTRINE = {
-  id: "carrier_jobs",
-  tag: "carrier_jobs",
-  title: "carrier_jobs Tool Guidelines",
-  description: `Lookup and control detached carrier jobs registered by carrier_dispatch. This is not a delegation tool and not a polling tool; use it only to inspect archived output, cancel by job_id, or list jobs.`,
-  promptSnippet: `carrier_jobs \u2014 Lookup/control detached carrier jobs: status, result, cancel, list.`,
-  whenToUse: [
-    `Use carrier_jobs when a follow-up push is missing, explicit job inspection is required, or the Admiral needs completion metadata, full archived output, cancellation, or a job list.`,
-    `Use action:"result" only after the job is finalized; full results remain repeatable for 3 hours.`
-  ],
-  whenNotToUse: [
-    `Do not use carrier_jobs to delegate new work; use carrier_dispatch.`,
-    `Do not request results for active jobs. Results are finalized-only, read-many for 3 hours, and expire by TTL.`,
-    `Do not poll, wait-check, or call carrier_jobs merely to see whether a launched job is done; terminal results arrive through the [carrier:result] follow-up push.`
-  ],
-  usageGuidelines: [
-    `carrier_jobs has exactly four actions: status, result, cancel, list.`,
-    `After launch, continue independent work if available; otherwise stop tool use and wait passively for the follow-up push instead of issuing status probes.`,
-    `Treat carrier_jobs as the fallback channel for missing pushes or explicit lookups, not as a polling loop.`,
-    `Results are finalized-only, read-many for 3h in process memory.`,
-    `Task Force dispatch full responses return results: { [cliType]: "..." }; non-Task-Force full responses still return full_result.`,
-    `carrier_jobs reads the process-memory summary cache and JobStreamArchive only. It never reads the Agent Panel stream-store.`
-  ]
-};
 var REMINDER_TEXT_LIMIT = 500;
 var REMINDER_CONTROL_CHARS = /[\u0000-\u001F\u007F-\u009F]/g;
 var REMINDER_WHITESPACE = /\s+/g;
-var ACTIVE_STATUS_NOTICE = "Job is still running. The [carrier:result] push will be delivered automatically when it finishes \u2014 do not call carrier_jobs again until that push arrives. Stop calling tools now and return control to the user; the push wakes the agent even after this response ends.";
-var ACTIVE_CANCEL_NOTICE = "Cancel did not apply: the job is still running normally, not hung. Long-running carrier jobs are expected \u2014 do not retry cancel without an explicit user request to abort. The [carrier:result] push will arrive automatically; stop calling tools and return control to the user.";
 function buildCarrierResultSystemReminder(input) {
+  const changes = input.summary.workspaceChanges ? buildStatLine(input.summary.workspaceChanges.changes.length, input.summary.workspaceChanges.truncated) : "unavailable";
   const lines = [`- ${input.jobId}: ${sanitizeReminderText(input.summary.summary)}`];
   const metadata = [
     `kind=${input.kind}`,
     `status=${input.status}`,
-    `changes=${sanitizeReminderText(input.summary.workspaceChanges?.statLine ?? "unavailable")}`,
+    `changes=${sanitizeReminderText(changes)}`,
     input.label ? `label=${sanitizeReminderText(input.label)}` : void 0,
     input.taskforceBackend ? `backend=${sanitizeReminderText(input.taskforceBackend)}` : void 0,
     input.error ? `error=${sanitizeReminderText(input.error)}` : void 0
@@ -30014,66 +29652,6 @@ function wrapSystemReminder(text, attrs) {
 ${text}
 </system-reminder>`;
 }
-function buildCarrierJobsSchema() {
-  return typebox_exports.Object({
-    action: typebox_exports.Unsafe({
-      type: "string",
-      enum: ["status", "result", "cancel", "list"],
-      description: "Job action to perform."
-    }),
-    job_id: typebox_exports.Optional(typebox_exports.String({
-      description: "Required for status, result, and cancel. Must be a prefixed job ID such as sortie:<toolCallId>."
-    })),
-    format: typebox_exports.Optional(typebox_exports.Unsafe({
-      type: "string",
-      enum: ["summary", "full"],
-      description: "Optional result detail level for renderers and result lookups."
-    }))
-  });
-}
-function buildCarrierJobsToolSpec() {
-  return {
-    ...CARRIER_JOBS_DOCTRINE,
-    parameters: buildCarrierJobsSchema(),
-    async execute(args) {
-      const result = dispatchCarrierJobsAction(args);
-      return {
-        content: [{ type: "text", text: JSON.stringify(result) }],
-        isError: false,
-        details: result
-      };
-    }
-  };
-}
-function dispatchCarrierJobsAction(params, now = Date.now()) {
-  if (params.action === "list") {
-    return {
-      action: "list",
-      ok: true,
-      active: listActiveJobs(),
-      recent: listJobSummaries(now)
-    };
-  }
-  const jobIdError = validateJobId(params.job_id);
-  if (jobIdError) {
-    return {
-      action: params.action,
-      job_id: params.job_id,
-      ok: false,
-      error: jobIdError
-    };
-  }
-  const jobId = params.job_id;
-  if (params.action === "status") return statusResponse(jobId, now);
-  if (params.action === "result") return resultResponse(jobId, normalizeFormat(params.format), now);
-  if (params.action === "cancel") return cancelResponse(jobId, now);
-  return {
-    action: String(params.action),
-    job_id: jobId,
-    ok: false,
-    error: "unsupported action"
-  };
-}
 function sanitizeReminderText(text) {
   return escapeXmlText(
     text.replace(REMINDER_CONTROL_CHARS, " ").replace(REMINDER_WHITESPACE, " ").trim().slice(0, REMINDER_TEXT_LIMIT)
@@ -30091,131 +29669,8 @@ function escapeXmlAttribute(value) {
 function escapeXmlText(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-function statusResponse(jobId, now) {
-  const active = getActiveJob(jobId);
-  const summary = getJobSummary(jobId, now);
-  const availability = getAvailability(jobId, summary, now);
-  return {
-    action: "status",
-    job_id: jobId,
-    ok: Boolean(active || summary || availability.full_available),
-    status: active?.status ?? summary?.status ?? "not_found",
-    summary: summary ?? void 0,
-    notice: active ? ACTIVE_STATUS_NOTICE : void 0,
-    ...availability
-  };
-}
-function resultResponse(jobId, format, now) {
-  const active = getActiveJob(jobId);
-  const summary = getJobSummary(jobId, now);
-  const availability = getAvailability(jobId, summary, now);
-  if (active) {
-    return {
-      action: "result",
-      format,
-      job_id: jobId,
-      ok: false,
-      status: active.status,
-      summary: summary ?? void 0,
-      ...availability,
-      error: "job not finalized",
-      retry_after: "do not retry; wait for the [carrier:result] push that will arrive automatically when the job reaches done, error, or aborted.",
-      notice: ACTIVE_STATUS_NOTICE
-    };
-  }
-  if (format === "summary") {
-    return {
-      action: "result",
-      format,
-      job_id: jobId,
-      ok: Boolean(summary),
-      status: summary?.status ?? "not_found",
-      summary: summary ?? void 0,
-      ...availability,
-      error: summary ? void 0 : "summary unavailable or expired"
-    };
-  }
-  const archive = getFinalized(jobId, now);
-  const isTaskForceJob = jobId.startsWith("taskforce:");
-  const isSubOpJob = isTaskForceJob;
-  const serializeOpts = isSubOpJob ? { perSubOpMaxBytes: CARRIER_JOBS_PER_SUBOP_BYTE_CAP, maxBytes: CARRIER_JOBS_GLOBAL_BYTE_CAP } : { maxBytes: CARRIER_JOBS_FULL_RESULT_BYTE_CAP };
-  const fullResult = archive ? serializeJobArchive(archive, serializeOpts) : void 0;
-  return {
-    action: "result",
-    format,
-    job_id: jobId,
-    ok: Boolean(archive),
-    status: archive?.status ?? summary?.status ?? "not_found",
-    summary: summary ?? void 0,
-    ...availability,
-    full_result: isTaskForceJob ? void 0 : fullResult,
-    results: archive && isTaskForceJob ? serializeTaskForceResultsByBackend(archive) : void 0,
-    error: archive ? void 0 : "full result unavailable or expired"
-  };
-}
-function cancelResponse(jobId, now) {
-  const result = cancelJob(jobId);
-  const active = getActiveJob(jobId);
-  const summary = getJobSummary(jobId, now);
-  return {
-    action: "cancel",
-    job_id: jobId,
-    ok: result.cancelled,
-    cancelled: result.cancelled,
-    status: result.cancelled ? "cancelled" : active?.status ?? summary?.status ?? "not_found",
-    summary: summary ?? void 0,
-    notice: !result.cancelled && active ? ACTIVE_CANCEL_NOTICE : void 0,
-    ...getAvailability(jobId, summary, now),
-    error: result.cancelled ? void 0 : "job not found or already finished"
-  };
-}
-function getAvailability(jobId, summary, now) {
-  const fullAvailable = hasFinalizedJobArchive(jobId, now);
-  return {
-    summary_available: Boolean(summary),
-    full_available: fullAvailable,
-    full_invalidated: !hasJobArchive(jobId, now) && Boolean(summary)
-  };
-}
-function validateJobId(jobId) {
-  if (!jobId) return "job_id is required";
-  if (!isCarrierJobId(jobId)) return "job_id must start with carrier:, sortie:, or taskforce:";
-  return null;
-}
-function normalizeFormat(format) {
-  return format === "summary" ? "summary" : "full";
-}
-function serializeTaskForceResultsByBackend(archive) {
-  const grouped = /* @__PURE__ */ new Map();
-  const orderedKeys = [];
-  for (const block of archive.blocks) {
-    if (!block.label) continue;
-    if (!grouped.has(block.label)) {
-      grouped.set(block.label, []);
-      orderedKeys.push(block.label);
-    }
-    grouped.get(block.label).push(block);
-  }
-  const results = {};
-  for (const cliType of orderedKeys) {
-    const blocks = grouped.get(cliType);
-    results[cliType] = serializeJobArchive(
-      { ...archive, blocks },
-      { maxBytes: CARRIER_JOBS_PER_SUBOP_BYTE_CAP }
-    );
-  }
-  return results;
-}
 
 // ../../packages/fleet-carriers/src/jobs/sanitize.ts
-var sanitize_exports = {};
-__export(sanitize_exports, {
-  sanitizeChunk: () => sanitizeChunk,
-  sanitizeOneLineText: () => sanitizeOneLineText,
-  sanitizeToolBlockLabel: () => sanitizeToolBlockLabel,
-  sanitizeToolLabel: () => sanitizeToolLabel,
-  stripTerminalControlSequences: () => stripTerminalControlSequences
-});
 var CONTROL_CHARS = /[\u0000-\u001f\u007f]/g;
 var MULTILINE_CONTROL_CHARS = /[\u0000-\u0009\u000b-\u001f\u007f]/g;
 var LINE_BREAKS = /[\r\n]+/g;
@@ -30301,84 +29756,17 @@ function isEscIntermediate(code) {
   return code >= 32 && code <= 47;
 }
 
-// ../../packages/fleet-carriers/src/jobs/workspace-manifest.ts
-var WORKSPACE_CHANGE_ATTRIBUTION = "window-approximate";
-var WORKSPACE_CHANGE_LIMIT = 200;
-var WORKSPACE_CHANGE_CLEARED_STATUS = "cleared";
-async function captureWorkspaceSnapshot(scanner, cwd) {
-  if (!scanner) return null;
-  try {
-    return await scanner.snapshot(cwd);
-  } catch {
-    return null;
-  }
-}
-async function captureJobWindowManifest(scanner, cwd, baseline) {
-  if (!scanner) {
-    return unavailableWorkspaceManifest("scanner-not-configured");
-  }
-  const end = await captureWorkspaceSnapshot(scanner, cwd);
-  return buildWorkspaceManifest(baseline, end);
-}
-function buildWorkspaceManifest(baseline, end, reason) {
-  if (!baseline || !end) {
-    return unavailableWorkspaceManifest("snapshot-unavailable");
-  }
-  const baselineByPath = new Map(baseline.map((entry) => [entry.path, normalizeSnapshotEntry(entry)]));
-  const endChanges = end.map(normalizeSnapshotEntry).filter((entry) => hasWindowChange(baselineByPath.get(entry.path), entry)).map(toManifestEntry);
-  const endPaths = new Set(end.map((entry) => entry.path));
-  const clearedChanges = [...baselineByPath.values()].filter((entry) => !endPaths.has(entry.path)).map((entry) => ({ status: WORKSPACE_CHANGE_CLEARED_STATUS, path: entry.path }));
-  const changes = [...endChanges, ...clearedChanges];
-  const truncated = changes.length > WORKSPACE_CHANGE_LIMIT;
-  const capped = changes.slice(0, WORKSPACE_CHANGE_LIMIT);
-  return {
-    attribution: WORKSPACE_CHANGE_ATTRIBUTION,
-    available: true,
-    changes: capped,
-    statLine: buildStatLine(changes.length, truncated),
-    truncated
-  };
-}
-function unavailableWorkspaceManifest(reason) {
-  return {
-    attribution: WORKSPACE_CHANGE_ATTRIBUTION,
-    available: false,
-    reason,
-    changes: [],
-    statLine: "unavailable",
-    truncated: false
-  };
-}
-function normalizeSnapshotEntry(entry) {
-  return {
-    status: entry.status.trim(),
-    path: entry.path,
-    contentHash: entry.contentHash?.trim()
-  };
-}
-function toManifestEntry(entry) {
-  return {
-    status: entry.status,
-    path: entry.path
-  };
-}
-function hasWindowChange(baseline, end) {
-  if (!baseline) return true;
-  if (baseline.status !== end.status) return true;
-  if (baseline.contentHash && end.contentHash) {
-    return baseline.contentHash !== end.contentHash;
-  }
-  return false;
-}
-function buildStatLine(changeCount, truncated) {
-  const suffix = changeCount === 1 ? "file" : "files";
-  return `${truncated ? `${WORKSPACE_CHANGE_LIMIT}+` : String(changeCount)} ${suffix} (window-approx)`;
-}
-
 // ../../packages/fleet-carriers/src/dispatch/prompt.ts
 var CARRIER_FLEET_BACKGROUND = String.raw`You are an autonomous agent (Carrier) operating within a coordinated multi-agent Fleet system. The Admiral, your superior, dispatches specialized tasks to you and synthesizes your output for the user. Below is your identity, operational permissions, behavioral principles, and required output format. Your assigned task arrives in the user message channel below.`;
+var COMMON_RESPONSE_PROTOCOL = `<response_protocol>
+Keep progress narration concise \u2014 at most one line per meaningful step. No verbose play-by-play or step-by-step essays (short streaming lines are acceptable for the live observation channel).
+
+When the mission is complete, wrap the entire final output in a <report>...</report> tag and emit it exactly once, at the very end. The Admiral retrieves only the report block, so everything you need to convey \u2014 results, evidence, file paths, caveats \u2014 must be inside it. Your persona's output_format structure applies inside the report block as usual.
+
+Do not mention or demonstrate the literal opening and closing report tag anywhere in the body outside that final block.
+</response_protocol>`;
 function buildCarrierSystemPrompt(metadata) {
-  const parts = [CARRIER_FLEET_BACKGROUND];
+  const parts = [CARRIER_FLEET_BACKGROUND, COMMON_RESPONSE_PROTOCOL];
   if (metadata) {
     parts.push(`<your_identity>
 ${metadata.title}
@@ -30838,7 +30226,6 @@ function buildCarrierDispatchToolSpec(registry3, deps) {
         });
       }
       const metadata = config2.carrierMetadata;
-      const isNativeSubagentMode = isCarrierAgentModeSubagent(carrierId, config2.defaultAgentMode);
       if (metadata) {
         const blockValidation = validateRequiredRequestBlocks(metadata, request, carrierId);
         if (!blockValidation.ok) {
@@ -30849,7 +30236,7 @@ function buildCarrierDispatchToolSpec(registry3, deps) {
           });
         }
       }
-      if (!isNativeSubagentMode && getConfiguredTaskForceBackends(carrierId).length >= 2) {
+      if (getConfiguredTaskForceBackends(carrierId).length >= 2) {
         return launchTaskForceJob({
           registry: registry3,
           carrierId,
@@ -31084,7 +30471,6 @@ function resolveCarrierTrackModelInfo(registry3, carrierId) {
   const modelConfig = loadCarrierStates({
     [carrierId]: carrierConfig ? {
       cliType,
-      ...carrierConfig.defaultAgentMode ? { defaultAgentMode: carrierConfig.defaultAgentMode } : {},
       ...carrierConfig.defaultEffort ? { defaultEffort: carrierConfig.defaultEffort } : {},
       ...carrierConfig.defaultModel ? { defaultModel: carrierConfig.defaultModel } : {}
     } : cliType
@@ -31110,7 +30496,7 @@ function resolveDispatchCwd(rawCwd, fallbackCwd) {
   if (rawCwd === void 0) return { ok: true, cwd: fallbackCwd };
   const trimmed = rawCwd.trim();
   if (trimmed.length === 0) return { ok: true, cwd: fallbackCwd };
-  if (!path26__default.isAbsolute(trimmed)) {
+  if (!path25__default.isAbsolute(trimmed)) {
     return {
       ok: false,
       error: `Invalid cwd "${rawCwd}": must be an absolute path. Provide an absolute directory or omit cwd to use the host session cwd.`
@@ -31172,593 +30558,11 @@ function formatRequestBlocksGuide(meta3) {
   });
 }
 
-// ../../packages/fleet-carriers/src/subagents/index.ts
-var subagents_exports = {};
-__export(subagents_exports, {
-  CLAUDE_SUBAGENT_COLORS: () => CLAUDE_SUBAGENT_COLORS,
-  buildClaudeSubagentDefinition: () => buildClaudeSubagentDefinition,
-  buildClaudeSubagentDefinitions: () => buildClaudeSubagentDefinitions,
-  buildClaudeSubagentName: () => buildClaudeSubagentName
-});
-
-// ../../packages/fleet-carriers/src/subagents/claude.ts
-var NAME_SEGMENT_SPLIT_PATTERN = /[^a-zA-Z0-9]+/;
-var CLAUDE_MAX_EFFORT = "xhigh";
-var CLAUDE_SUBAGENT_COLORS = {
-  nimitz: "blue",
-  vanguard: "cyan",
-  chronicle: "green",
-  genesis: "orange",
-  kirov: "purple",
-  ohio: "yellow",
-  sentinel: "red",
-  tempest: "pink"
-};
-function buildClaudeSubagentDefinitions(options) {
-  const enabled = new Set(options.enabledCarrierIds);
-  return options.carrierConfigs.filter((config2) => enabled.has(config2.id)).map((config2) => buildClaudeSubagentDefinition(config2));
-}
-function buildClaudeSubagentDefinition(config2) {
-  const color = CLAUDE_SUBAGENT_COLORS[config2.id];
-  const effort = getClaudeEffort(config2);
-  const model = getClaudeModel(config2);
-  const definition = {
-    carrierId: config2.id,
-    ...color ? { color } : {},
-    description: buildDescription(config2),
-    ...effort ? { effort } : {},
-    ...model ? { model } : {},
-    name: buildClaudeSubagentName(config2.id),
-    prompt: buildCarrierSystemPrompt(config2.carrierMetadata)
-  };
-  return definition;
-}
-function buildClaudeSubagentName(carrierId) {
-  const lowerCaseName = carrierId.split(NAME_SEGMENT_SPLIT_PATTERN).filter((segment) => segment.length > 0).map((segment) => segment.toLowerCase()).join("");
-  return lowerCaseName || "carrier";
-}
-function buildDescription(config2) {
-  const metadata = config2.carrierMetadata;
-  const parts = [
-    config2.displayName,
-    metadata?.title,
-    metadata?.summary,
-    metadata?.whenToUse?.length ? `Use for: ${metadata.whenToUse.join(", ")}.` : void 0
-  ];
-  return parts.filter((part) => typeof part === "string" && part.trim().length > 0).join(" - ").replace(/\s+/g, " ").trim();
-}
-function getClaudeEffort(config2) {
-  const effort = config2.subagent?.byHost?.claude?.defaultEffort ?? config2.subagent?.defaultEffort;
-  return clampClaudeEffort(effort);
-}
-function getClaudeModel(config2) {
-  return config2.subagent?.byHost?.claude?.defaultModel ?? config2.subagent?.defaultModel;
-}
-function clampClaudeEffort(effort) {
-  return effort === "max" ? CLAUDE_MAX_EFFORT : effort;
-}
-
 // ../../packages/fleet-carriers/src/index.ts
-var dispatch = {
-  ...framework_exports,
-  framework: framework_exports,
-  statusOverlayController: status_overlay_exports,
-  taskforce: taskforce_exports,
-  toolSpec: tool_spec_exports,
-  types: types_exports,
-  buildToolSpecs: buildCarrierDispatchToolSpec
-};
-var jobs = {
-  archive: archive_exports,
-  dispatch: dispatch_exports,
-  lifecycle: lifecycle_exports,
-  sanitize: sanitize_exports,
-  types: types_exports2,
-  buildToolSpec: buildCarrierJobsToolSpec,
-  configureJobSummaryCache,
-  detachJobArchive,
-  acquireJobPermit,
-  getActiveBackgroundJobCount,
-  onActiveJobCountChange,
-  resetJobConcurrencyForTest,
-  streaming: {
-    register: registerStreamHandler,
-    unregister: unregisterStreamHandler,
-    emit: emitStreamEvent
-  }
-};
-function createCarrierRuntime() {
-  const registry3 = createCarrierRegistry();
-  const boundStream = createBoundCarrierStream(registry3);
-  const boundCarrierJobs = createBoundCarrierJobs(registry3, boundStream);
-  return {
-    registry: registry3,
-    dispatch,
-    jobs: boundCarrierJobs,
-    personas: personas_exports,
-    subagents: subagents_exports,
-    store: store_exports,
-    stream: boundStream,
-    registerCarrierDefaults() {
-      registerDefaultCarriers(registry3);
-    }
-  };
-}
-function createBoundCarrierStream(registry3) {
-  return {
-    register(handler) {
-      return registerStreamHandler(registry3, handler);
-    },
-    unregister(handler) {
-      unregisterStreamHandler(registry3, handler);
-    },
-    emit(event) {
-      emitStreamEvent(registry3, event);
-    }
-  };
-}
-function createBoundCarrierJobs(registry3, boundStream = createBoundCarrierStream(registry3)) {
-  return {
-    ...jobs,
-    streaming: boundStream
-  };
-}
-
-// core/host/hooks/subagents-context.ts
-var FLEET_PLUGIN_NAME = "fleet";
-function runSubagentsContextHook(env) {
-  const fleetRoot = env.FLEET_ROOT ?? path26__default.join(env.HOME ?? os3__default.homedir(), ".fleet");
-  if (!canReadCarrierState(path26__default.join(fleetRoot, "carriers.json"))) {
-    return JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: "" } });
-  }
-  const carrierRuntime = createCarrierRuntime();
-  carrierRuntime.store.initStore(fleetRoot);
-  carrierRuntime.registerCarrierDefaults();
-  const { carrierConfigs, definitions } = buildClaudeNativeSubagentPlan(carrierRuntime.registry);
-  const configsById = new Map(carrierConfigs.map((config2) => [config2.id, config2]));
-  const additionalContext = buildSubagentsSection(definitions.map((definition) => ({
-    carrierId: definition.carrierId,
-    displayName: configsById.get(definition.carrierId)?.displayName,
-    nativeName: `${FLEET_PLUGIN_NAME}:${definition.name}`
-  }))) ?? "";
-  return JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart", additionalContext } });
-}
-function buildClaudeNativeSubagentPlan(registry3) {
-  const carrierIds = getRegisteredOrder(registry3);
-  const carrierConfigs = carrierIds.map((carrierId) => getCarrierConfig(registry3, carrierId)).filter((config2) => config2 !== void 0);
-  const defaultsByCarrier = Object.fromEntries(
-    carrierConfigs.map((config2) => [config2.id, buildHostCarrierModelDefaults(config2)])
-  );
-  const enabledCarrierIds = getEnabledCarrierSubagentIds(
-    readCarrierAgentModeSnapshot(defaultsByCarrier),
-    carrierIds
-  );
-  return {
-    carrierConfigs,
-    definitions: buildClaudeSubagentDefinitions({ carrierConfigs, enabledCarrierIds })
-  };
-}
-function buildHostCarrierModelDefaults(config2) {
-  const cliType = resolveAgentCliType2(config2.id, config2.defaultCliType);
-  const cliDefaults = buildCarrierModelDefaults(config2, cliType);
-  return {
-    cliType,
-    ...config2.defaultAgentMode ? { defaultAgentMode: config2.defaultAgentMode } : {},
-    ...cliDefaults.defaultEffort ? { defaultEffort: cliDefaults.defaultEffort } : {},
-    ...cliDefaults.defaultModel ? { defaultModel: cliDefaults.defaultModel } : {}
-  };
-}
-function buildSubagentsSection(entries) {
-  if (entries.length === 0) return void 0;
-  const lines = entries.map((entry) => {
-    const label = entry.displayName ? `${entry.displayName} (${entry.carrierId})` : entry.carrierId;
-    return `- ${label}: invoke as Claude native subagent \`${entry.nativeName}\`.`;
-  }).join("\n");
-  return `<fleet section="subagents">
-# Claude Native Subagents
-
-The following Fleet carriers are exposed as Claude native subagents for this session:
-
-${lines}
-
-Native subagent calls return inline and do not emit \`[carrier:result]\`. Do not wait for a carrier job completion push after native invocation.
-
-\`carrier_dispatch\` remains available as a separate Fleet delegation path for carriers that are not invoked through the native subagent interface.
-</fleet>`;
-}
-function canReadCarrierState(filePath) {
-  try {
-    return isReadableCarrierStateRoot(JSON.parse(readFileSync(filePath, "utf8")));
-  } catch {
-    return false;
-  }
-}
-function isReadableCarrierStateRoot(value) {
-  if (!isRecord2(value)) return false;
-  const carriers = value.carriers;
-  return carriers === void 0 || isRecord2(carriers);
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var LOCK_DIR_MODE = 448;
-var LOCK_FILE_MODE = 384;
-function createConsoleLock(deps = {}) {
-  const fsImpl = deps.fs ?? fs11__default;
-  const now = deps.now ?? Date.now;
-  const randomToken = deps.randomToken ?? (() => crypto5.randomBytes(32).toString("base64url"));
-  const hostname5 = deps.hostname ?? (() => "127.0.0.1");
-  function ensureLockDir(dir) {
-    fsImpl.mkdirSync(dir, { recursive: true, mode: LOCK_DIR_MODE });
-    fsImpl.chmodSync(dir, LOCK_DIR_MODE);
-  }
-  function readLock(lockFile) {
-    try {
-      const stat5 = fsImpl.lstatSync(lockFile);
-      if (stat5.isSymbolicLink()) {
-        throw new Error(`Refusing symbolic console lock: ${lockFile}`);
-      }
-      return JSON.parse(fsImpl.readFileSync(lockFile, "utf8"));
-    } catch (err) {
-      if (err.code === "ENOENT") return null;
-      throw err;
-    }
-  }
-  function writeLock(input) {
-    ensureLockDir(input.dir);
-    const payload = {
-      pid: input.pid,
-      host: hostname5(),
-      port: input.port,
-      endpoint: input.endpoint,
-      startedAt: now(),
-      token: randomToken(),
-      version: input.version
-    };
-    const fd = fsImpl.openSync(input.lockFile, fs11__default.constants.O_CREAT | fs11__default.constants.O_EXCL | fs11__default.constants.O_WRONLY, LOCK_FILE_MODE);
-    try {
-      fsImpl.writeFileSync(fd, `${JSON.stringify(payload, null, 2)}
-`, "utf8");
-      fsImpl.fchmodSync(fd, LOCK_FILE_MODE);
-    } finally {
-      fsImpl.closeSync(fd);
-    }
-    return { payload, release: () => removeLock(input.lockFile, payload.pid) };
-  }
-  function removeLock(lockFile, pid) {
-    let current = null;
-    try {
-      current = readLock(lockFile);
-    } catch (err) {
-      if (pid != null) throw err;
-    }
-    if (pid != null && current && current.pid !== pid) return;
-    try {
-      fsImpl.rmSync(lockFile, { force: true });
-    } catch (err) {
-      if (err.code !== "ENOENT") throw err;
-    }
-  }
-  function assertLockModes(lockFile) {
-    if (typeof process.getuid !== "function") return;
-    const dir = path26__default.dirname(lockFile);
-    const dirMode = fsImpl.statSync(dir).mode & 511;
-    const fileMode = fsImpl.statSync(lockFile).mode & 511;
-    if (dirMode !== LOCK_DIR_MODE) {
-      throw new Error(`Console lock directory mode must be 0700, got ${dirMode.toString(8)}`);
-    }
-    if (fileMode !== LOCK_FILE_MODE) {
-      throw new Error(`Console lock file mode must be 0600, got ${fileMode.toString(8)}`);
-    }
-  }
-  function assertTrustedLock(input) {
-    const dirStat = fsImpl.statSync(input.dir);
-    const fileStat = fsImpl.lstatSync(input.lockFile);
-    if (fileStat.isSymbolicLink()) {
-      throw new Error(`Refusing symbolic console lock: ${input.lockFile}`);
-    }
-    assertLockModes(input.lockFile);
-    const currentUid = typeof process.getuid === "function" ? process.getuid() : null;
-    if (currentUid != null && (dirStat.uid !== currentUid || fileStat.uid !== currentUid)) {
-      throw new Error("Console lock owner does not match current user");
-    }
-    if (input.payload.host !== input.host) {
-      throw new Error(`Console lock host must match ${input.host}: ${input.payload.host}`);
-    }
-    if (!Number.isInteger(input.payload.port) || input.payload.port < 1 || input.payload.port > 65535) {
-      throw new Error(`Console lock port must be a valid TCP port, got ${input.payload.port}`);
-    }
-    const endpoint = new URL(input.payload.endpoint);
-    if (endpoint.protocol !== "http:" || endpoint.pathname !== "/") {
-      throw new Error("Console lock endpoint must be the loopback server root");
-    }
-    if (endpoint.hostname !== input.host || Number(endpoint.port) !== input.payload.port) {
-      throw new Error("Console lock endpoint must use the loopback host and the lock port");
-    }
-    if (input.payload.endpoint !== `http://${input.host}:${input.payload.port}/`) {
-      throw new Error("Console lock endpoint must match the lock host and port");
-    }
-  }
-  return { ensureLockDir, readLock, writeLock, removeLock, assertLockModes, assertTrustedLock };
-}
-var FLEET_DATA_DIR_NAME = ".fleet";
-function getFleetDataDir() {
-  return path26.join(os3.homedir(), FLEET_DATA_DIR_NAME);
-}
-function readAuthStoreFile(filePath) {
-  let fd;
-  try {
-    fd = fs11.openSync(filePath, fs11.constants.O_RDONLY | NOFOLLOW_FLAG);
-    if (!fs11.fstatSync(fd).isFile()) {
-      return {};
-    }
-    return JSON.parse(fs11.readFileSync(fd, "utf-8"));
-  } catch {
-    return {};
-  } finally {
-    if (fd !== void 0) {
-      try {
-        fs11.closeSync(fd);
-      } catch {
-      }
-    }
-  }
-}
-
-// ../../packages/fleet-infra/src/auth/auth-storage.ts
-var DEFAULT_AUTH_PATH = path26.join(getFleetDataDir(), "auth.json");
-var AUTH_LOCK_OWNER_FILE_NAME = "owner.json";
-var AUTH_LOCK_TIMEOUT_MS = 5e3;
-function createAuthService(deps = {}) {
-  const authPath = deps.authPath ?? DEFAULT_AUTH_PATH;
-  const lockDir = `${authPath}.lock`;
-  return {
-    // [HIGH #1] TOCTOU 수정: existsSync/read/check/delete/write 전체를 락 블록 안으로 이동
-    async deleteApiKey(providerId) {
-      let deleted = false;
-      withAuthLock(authPath, lockDir, () => {
-        if (!fs11.existsSync(authPath)) return;
-        const data = readAuthStoreFile(authPath);
-        if (!Object.prototype.hasOwnProperty.call(data, providerId)) return;
-        delete data[providerId];
-        writeAuthData(authPath, data);
-        deleted = true;
-      });
-      return deleted;
-    },
-    // [HIGH #2] 읽기 경로: fd 기반 O_RDONLY|O_NOFOLLOW+fstatSync isFile
-    async getApiKey(providerId) {
-      let fd;
-      try {
-        if (!fs11.existsSync(authPath)) {
-          return void 0;
-        }
-        fd = fs11.openSync(authPath, fs11.constants.O_RDONLY | NOFOLLOW_FLAG);
-        if (!fs11.fstatSync(fd).isFile()) {
-          return void 0;
-        }
-        const data = JSON.parse(fs11.readFileSync(fd, "utf-8"));
-        return typeof data[providerId]?.key === "string" ? data[providerId].key : void 0;
-      } catch {
-        return void 0;
-      } finally {
-        if (fd !== void 0) {
-          try {
-            fs11.closeSync(fd);
-          } catch {
-          }
-        }
-      }
-    },
-    // [HIGH #2] 읽기 경로: fd 기반 O_RDONLY|O_NOFOLLOW 통일
-    async listProviderIds() {
-      if (!fs11.existsSync(authPath)) {
-        return [];
-      }
-      try {
-        return Object.keys(readAuthStoreFile(authPath)).sort();
-      } catch {
-        return [];
-      }
-    },
-    async setApiKey(providerId, key) {
-      const dir = path26.dirname(authPath);
-      ensureSafeDirectory(dir);
-      withAuthLock(authPath, lockDir, () => {
-        const data = fs11.existsSync(authPath) ? readAuthStoreFile(authPath) : {};
-        data[providerId] = {
-          ...data[providerId] ?? {},
-          key
-        };
-        writeAuthData(authPath, data);
-      });
-    }
-  };
-}
-function withAuthLock(authPath, lockDir, operation) {
-  return withDirectoryLock(
-    {
-      lockDir,
-      ownerFileName: AUTH_LOCK_OWNER_FILE_NAME,
-      timeoutMs: AUTH_LOCK_TIMEOUT_MS
-    },
-    operation
-  );
-}
-function writeAuthData(authPath, data) {
-  writeAtomicSync(authPath, `${JSON.stringify(data, null, 2)}
-`, {
-    mode: SECURE_FILE_MODE,
-    fsync: true
-  });
-}
-var GLOBAL_OPTIONS_VERSION = 1;
-var GLOBAL_OPTIONS_FILE_NAME = "settings.json";
-var LOCK_DIR_NAME = "settings.json.lock";
-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 = path26.join(dataDir, GLOBAL_OPTIONS_FILE_NAME);
-  const lockDir = path26.join(dataDir, LOCK_DIR_NAME);
-  const store2 = createDurableJsonStore({
-    filePath: optionsPath,
-    lockDir,
-    lockOwnerFileName: LOCK_OWNER_FILE_NAME,
-    sanitize: (value) => sanitizeGlobalOptionsData(value).data,
-    sensitivity: "sensitive",
-    timeoutMs: deps.timeoutMs,
-    staleLockMs: deps.staleLockMs,
-    tempCleanupPrefix: TEMP_FILE_PREFIX,
-    now: deps.now
-  });
-  return {
-    path: optionsPath,
-    load: () => store2.load(),
-    save: (data) => store2.save(sanitizeGlobalOptionsData(data).data),
-    update: (mutate) => store2.update((current) => sanitizeGlobalOptionsData(mutate(current)).data)
-  };
-}
-function createEmptyGlobalOptionsData() {
-  return {
-    version: GLOBAL_OPTIONS_VERSION
-  };
-}
-function sanitizeGlobalOptionsData(value) {
-  if (!isRecord3(value)) {
-    return { data: createEmptyGlobalOptionsData(), changed: true };
-  }
-  if (value.version !== GLOBAL_OPTIONS_VERSION) {
-    return { data: createEmptyGlobalOptionsData(), changed: true };
-  }
-  const data = {
-    version: GLOBAL_OPTIONS_VERSION,
-    ...typeof value.replaceSystemPrompt === "boolean" ? { replaceSystemPrompt: value.replaceSystemPrompt } : {},
-    ...typeof value.enableMetaphor === "boolean" ? { enableMetaphor: value.enableMetaphor } : {}
-  };
-  const allowedKeys = /* @__PURE__ */ new Set(["version", "replaceSystemPrompt", "enableMetaphor"]);
-  const changed = Object.keys(value).some((key) => !allowedKeys.has(key)) || "replaceSystemPrompt" in value && typeof value.replaceSystemPrompt !== "boolean" || "enableMetaphor" in value && typeof value.enableMetaphor !== "boolean";
-  return { data, changed };
-}
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// ../../packages/fleet-infra/src/global-options/service.ts
-function createGlobalOptionsService(deps = {}) {
-  const store2 = deps.store ?? createGlobalOptionsStore({ dataDir: deps.dataDir });
-  return {
-    load: () => store2.load(),
-    save: (data) => {
-      store2.save(data);
-      return store2.load();
-    },
-    update: (mutate) => updateGlobalOptions(store2, mutate)
-  };
-}
-function updateGlobalOptions(store2, mutate) {
-  return store2.update(mutate);
-}
 ({
-  "claude-zai": {
-    baseUrl: CLI_BACKENDS["claude-zai"].defaultEnv.ANTHROPIC_BASE_URL,
-    env: CLI_BACKENDS["claude-zai"].defaultEnv
-  },
-  "claude-kimi": {
-    baseUrl: CLI_BACKENDS["claude-kimi"].defaultEnv.ANTHROPIC_BASE_URL,
-    env: CLI_BACKENDS["claude-kimi"].defaultEnv
-  },
-  "claude-glm": {
-    baseUrl: CLI_BACKENDS["claude-glm"].defaultEnv.ANTHROPIC_BASE_URL,
-    env: CLI_BACKENDS["claude-glm"].defaultEnv
-  }
-});
-
-// ../../packages/fleet-infra/src/index.ts
-function createInfraServices(deps = {}) {
-  const globalOptionsService = createGlobalOptionsService();
-  const authService = createAuthService({ authPath: deps.authPath ?? DEFAULT_AUTH_PATH });
-  return {
-    authService,
-    globalOptionsService
-  };
-}
-function readFleetConsoleRelease() {
-  const requireFromHere = createRequire(import.meta.url);
-  const packageJsonPath = resolvePackageJsonPath(requireFromHere);
-  const pkg = requireFromHere(packageJsonPath);
-  const packageRoot = path26__default.dirname(packageJsonPath);
-  const version2 = pkg.version ?? "";
-  if (pkg.private === true) {
-    return { channel: "local", version: version2, packageRoot };
-  }
-  return { channel: "stable", version: version2, packageRoot };
-}
-function resolvePackageJsonPath(requireFromHere) {
-  for (const candidate of ["../package.json", "../../package.json"]) {
-    try {
-      return requireFromHere.resolve(candidate);
-    } catch (error51) {
-      if (error51.code !== "MODULE_NOT_FOUND") throw error51;
-    }
-  }
-  throw new Error("fleet_console_package_json_not_found");
-}
-
-// core/host/paths.ts
-var LOCK_DIR_NAME2 = "fleet-console";
-var CONSOLE_RUNTIME_DIR_NAME = "console";
-var LOCK_FILE_NAME = "console.lock";
-var CONSOLE_DATA_DIR_NAME = "console";
-var CONSOLE_STATE_FILE_NAME = "state.json";
-var CONSOLE_SETTINGS_FILE_NAME = "settings.json";
-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: path26__default.join(base, LOCK_FILE_NAME) };
-}
-function createConsoleDataPaths(deps = {}) {
-  const dir = defaultConsoleDataBaseDir(deps);
-  return {
-    dir,
-    stateFile: path26__default.join(dir, CONSOLE_STATE_FILE_NAME),
-    settingsFile: path26__default.join(dir, CONSOLE_SETTINGS_FILE_NAME),
-    capturesDir: path26__default.join(dir, CONSOLE_CAPTURES_DIR_NAME)
-  };
-}
-function defaultConsoleBaseDir(deps) {
-  let release;
-  const channel = deps.channel ?? (release = readFleetConsoleRelease()).channel;
-  if (channel === "local") {
-    const packageRoot = deps.packageRoot ?? (release ??= readFleetConsoleRelease()).packageRoot;
-    return localConsoleDir(packageRoot);
-  }
-  const uid = deps.uid ?? (typeof process.getuid === "function" ? process.getuid() : 0);
-  return path26__default.join(os3__default.tmpdir(), `${LOCK_DIR_NAME2}-${uid}-${channel}`);
-}
-function defaultConsoleDataBaseDir(deps) {
-  if (deps.fleetDataDir !== void 0) {
-    return path26__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 path26__default.join(getFleetDataDir(), CONSOLE_DATA_DIR_NAME);
-}
-function localConsoleDir(packageRoot) {
-  return path26__default.join(path26__default.resolve(packageRoot, "..", ".."), ".fleet", CONSOLE_RUNTIME_DIR_NAME);
-}
+  ...framework_exports});
 
 // core/host/carrier-settings-routes.ts
-var SUBAGENT_CLI_TYPES = /* @__PURE__ */ new Set(["claude", "claude-zai", "claude-kimi", "claude-glm"]);
 var TASKFORCE_MIN_BACKENDS = 2;
 var CARRIER_SETTINGS_API_CATALOG = [
   {
@@ -31778,7 +30582,7 @@ var CARRIER_SETTINGS_API_CATALOG = [
   {
     method: "PATCH",
     path: "/api/v1/settings/carriers/:id",
-    summary: "Update carrier settings fields (cli, model, displayName, agentMode).",
+    summary: "Update carrier settings fields (cli, model, displayName).",
     category: "Settings",
     gate: "origin-write"
   },
@@ -31932,22 +30736,8 @@ async function mutateCarrierPatch(req, res, deps, controller, carrierId) {
     }
     normalizedDisplayName = parsed;
   }
-  if (body.agentMode !== void 0) {
-    if (body.agentMode !== "cli" && body.agentMode !== "subagent") {
-      deps.writeJson(res, 400, { error: "invalid_agent_mode" });
-      return;
-    }
-    if (body.agentMode === "subagent" && !SUBAGENT_CLI_TYPES.has(effectiveCliType)) {
-      deps.writeJson(res, 400, { error: "subagent_unsupported" });
-      return;
-    }
-  }
   if (newCliType) {
     await controller.changeCliType(carrierId, newCliType);
-    if (!SUBAGENT_CLI_TYPES.has(newCliType)) {
-      const resolved = readCarriersSnapshot(buildDefaultsByCarrier(deps.registry)).carriers[carrierId];
-      if (resolved?.agentMode === "subagent") updateCarrierAgentModeAtomically(carrierId, "cli", config2.defaultAgentMode ?? "cli");
-    }
   }
   if (modelSelection) {
     await updateAgentCliSelection(carrierId, effectiveCliType, modelSelection);
@@ -31957,11 +30747,6 @@ async function mutateCarrierPatch(req, res, deps, controller, carrierId) {
     updateCarrierDisplayName(carrierId, normalizedDisplayName, getCarrierSourceDisplayName(deps.registry, carrierId));
     notifyStatusUpdate(deps.registry);
   }
-  if (body.agentMode === "cli" || body.agentMode === "subagent") {
-    updateCarrierAgentModeAtomically(carrierId, body.agentMode, config2.defaultAgentMode ?? "cli");
-    if (body.agentMode === "subagent") refreshTaskForceConfiguredCarriers(deps.registry);
-    notifyStatusUpdate(deps.registry);
-  }
   writeMutationState(res, deps);
 }
 function mutateTaskForceBackend(res, deps, carrierId, cliType, body) {
@@ -31993,7 +30778,6 @@ function buildDefaultsByCarrier(registry3) {
       const config2 = requireCarrierConfig(registry3, carrierId);
       return [carrierId, {
         cliType: config2.defaultCliType,
-        ...config2.defaultAgentMode ? { defaultAgentMode: config2.defaultAgentMode } : {},
         ...buildCarrierModelDefaults(config2, config2.defaultCliType)
       }];
     })
@@ -32015,8 +30799,6 @@ function toCarrierSettingsCarrier(registry3, config2, resolved) {
     defaultCliType: config2.defaultCliType,
     model: selection.model,
     ...selection.effort ? { effort: selection.effort } : {},
-    agentMode: resolved.agentMode,
-    subagentMode: resolved.agentMode === "subagent",
     taskForceBackendCount: taskForceBackends.length,
     taskforce: { backends: taskForceBackends }
   };
@@ -32037,7 +30819,6 @@ function toCliOption(cliType) {
   return {
     id: cliType,
     displayName: CLI_DISPLAY_NAMES[cliType] ?? provider.name,
-    supportsSubagent: SUBAGENT_CLI_TYPES.has(cliType),
     models: provider.models.map((model) => {
       const effort = getEffort(cliType, model.modelId);
       return {
@@ -32082,28 +30863,12 @@ function createStatusOverlayController(registry3) {
     notifyStatusUpdate: () => notifyStatusUpdate(registry3)
   });
 }
-function updateCarrierAgentModeAtomically(carrierId, agentMode, defaultAgentMode) {
-  if (agentMode === "cli") {
-    setCarrierAgentMode(carrierId, false, defaultAgentMode);
-    return;
-  }
-  updateCarriers((states) => {
-    const carriers = { ...states.carriers ?? {} };
-    const current = carriers[carrierId] ?? {};
-    const next = { ...current };
-    next.agentMode = "subagent";
-    delete next.taskforce;
-    carriers[carrierId] = next;
-    states.carriers = carriers;
-  });
-}
 function updateTaskForceBackendAtomically(carrierId, cliType, selection) {
   updateCarriers((states) => {
     const carriers = { ...states.carriers ?? {} };
     const current = carriers[carrierId] ?? {};
     carriers[carrierId] = {
       ...current,
-      agentMode: "cli",
       taskforce: {
         ...current.taskforce ?? {},
         [cliType]: selection
@@ -32142,7 +30907,6 @@ function readCurrentModelSelection(registry3, carrierId) {
   const defaults = {
     [carrierId]: {
       cliType: config2.defaultCliType,
-      ...config2.defaultAgentMode ? { defaultAgentMode: config2.defaultAgentMode } : {},
       ...buildCarrierModelDefaults(config2, config2.defaultCliType)
     }
   };
@@ -32152,7 +30916,6 @@ function readCurrentModelSelection(registry3, carrierId) {
 }
 function fallbackResolvedState(config2) {
   return {
-    agentMode: config2.defaultAgentMode ?? "cli",
     agentCliType: config2.defaultCliType,
     agentCli: { [config2.defaultCliType]: readDefaultSelection(config2.defaultCliType) },
     taskforce: {}
@@ -32307,7 +31070,7 @@ function createConsoleSettingsStore(deps = {}) {
   const createStore = deps.createStore ?? createDurableJsonStore;
   return createStore({
     filePath: paths.settingsFile,
-    lockDir: path26__default.join(paths.dir, SETTINGS_LOCK_DIR_NAME),
+    lockDir: path25__default.join(paths.dir, SETTINGS_LOCK_DIR_NAME),
     lockOwnerFileName: SETTINGS_LOCK_OWNER_FILE_NAME,
     now: deps.now,
     sanitize: sanitizeConsoleSettingsData,
@@ -32316,7 +31079,7 @@ function createConsoleSettingsStore(deps = {}) {
   });
 }
 function sanitizeConsoleSettingsData(value) {
-  if (!isRecord4(value)) return emptyConsoleSettingsData();
+  if (!isRecord3(value)) return emptyConsoleSettingsData();
   if (value.version !== SETTINGS_VERSION) return emptyConsoleSettingsData();
   const general = readConsoleGeneralSettings(value.general);
   const plugins = readConsolePluginSettings(value.plugins);
@@ -32330,7 +31093,7 @@ function emptyConsoleSettingsData() {
   return { version: 1, general: {}, plugins: {} };
 }
 function readConsoleGeneralSettings(value) {
-  if (!isRecord4(value)) return null;
+  if (!isRecord3(value)) return null;
   const consolePortMode = value.consolePortMode === "dynamic" || value.consolePortMode === "static" ? value.consolePortMode : void 0;
   const consoleStaticPort = isValidConsoleStaticPort2(value.consoleStaticPort) ? value.consoleStaticPort : void 0;
   const theme = value.theme === "maritime" || value.theme === "carbon" ? value.theme : void 0;
@@ -32341,16 +31104,16 @@ function readConsoleGeneralSettings(value) {
   };
 }
 function readConsolePluginSettings(value) {
-  if (!isRecord4(value)) return null;
+  if (!isRecord3(value)) return null;
   const result = {};
   for (const [key, entry] of Object.entries(value)) {
     if (!PLUGIN_ID_PATTERN.test(key)) continue;
-    if (!isRecord4(entry)) continue;
+    if (!isRecord3(entry)) continue;
     result[key] = entry;
   }
   return result;
 }
-function isRecord4(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isValidConsoleStaticPort2(value) {
@@ -32409,7 +31172,7 @@ function createPluginSettingsRouter(deps) {
         return true;
       }
       const body = await deps.readJsonBody(req);
-      if (!isRecord5(body)) {
+      if (!isRecord4(body)) {
         deps.writeJson(res, 400, { error: "invalid_json" });
         return true;
       }
@@ -32429,7 +31192,7 @@ function createPluginSettingsRouter(deps) {
     return true;
   };
 }
-function isRecord5(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isJsonRequest3(req) {
@@ -32854,18 +31617,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(path26__default.join(paths.schemaDir, WORKSPACE_SCHEMA_AGENTS_FILENAME), DEFAULT_WORKSPACE_SCHEMA_AGENTS);
-  await writeDefaultFileIfMissing(path26__default.join(paths.schemaDir, WORKSPACE_SCHEMA_FILENAME), DEFAULT_WORKSPACE_WIKI_SCHEMA);
+  await writeDefaultFileIfMissing(path25__default.join(paths.schemaDir, WORKSPACE_SCHEMA_AGENTS_FILENAME), DEFAULT_WORKSPACE_SCHEMA_AGENTS);
+  await writeDefaultFileIfMissing(path25__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(path26__default.join(paths.root, WORKSPACE_KNOWLEDGE_AGENTS_FILENAME), DEFAULT_WORKSPACE_KNOWLEDGE_AGENTS);
+  await writeDefaultFileIfMissing(path25__default.join(paths.root, WORKSPACE_KNOWLEDGE_AGENTS_FILENAME), DEFAULT_WORKSPACE_KNOWLEDGE_AGENTS);
 }
 async function readWorkspaceSchemaSummary(paths) {
-  const agentsPath = path26__default.join(paths.schemaDir, WORKSPACE_SCHEMA_AGENTS_FILENAME);
-  const wikiSchemaPath = path26__default.join(paths.schemaDir, WORKSPACE_SCHEMA_FILENAME);
+  const agentsPath = path25__default.join(paths.schemaDir, WORKSPACE_SCHEMA_AGENTS_FILENAME);
+  const wikiSchemaPath = path25__default.join(paths.schemaDir, WORKSPACE_SCHEMA_FILENAME);
   const wikiSchemaContent = await tryReadFile(wikiSchemaPath);
   const templates = await scanTemplates(paths);
   if (wikiSchemaContent === null) {
@@ -32904,7 +31667,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 = path26__default.join(paths.schemaDir, entry.name);
+    const filePath = path25__default.join(paths.schemaDir, entry.name);
     try {
       const parsed = parseTemplateMarkdown(await readFile(filePath, "utf8"));
       templates.push({
@@ -32938,7 +31701,7 @@ async function validateTemplateCompliance(paths, templateId, body) {
   }
 }
 function inferTemplateIdFromTarget(target, knownTemplateIds) {
-  const basename = path26__default.basename(target, ".md");
+  const basename = path25__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) {
@@ -32967,7 +31730,7 @@ function extractSchemaSummary(content) {
   return lines.find((line) => line.length > 0 && !line.startsWith("#")) ?? "Workspace schema is present.";
 }
 function buildTemplatePath(paths, id) {
-  return path26__default.join(paths.schemaDir, `${WORKSPACE_TEMPLATE_PREFIX}${id}${WORKSPACE_TEMPLATE_SUFFIX}`);
+  return path25__default.join(paths.schemaDir, `${WORKSPACE_TEMPLATE_PREFIX}${id}${WORKSPACE_TEMPLATE_SUFFIX}`);
 }
 function parseTemplateMarkdown(content) {
   const normalized = content.replace(/\r\n/g, "\n");
@@ -32994,16 +31757,16 @@ function isAlreadyExistsError(error51) {
 
 // ../../packages/fleet-wiki/src/paths.ts
 function resolveMemoryPaths(cwd) {
-  const root = path26__default.join(cwd, KNOWLEDGE_ROOT_DIRNAME);
+  const root = path25__default.join(cwd, KNOWLEDGE_ROOT_DIRNAME);
   return {
     root,
-    rawDir: path26__default.join(root, RAW_DIRNAME),
-    wikiDir: path26__default.join(root, WIKI_DIRNAME),
-    schemaDir: path26__default.join(root, SCHEMA_DIRNAME),
-    queueDir: path26__default.join(root, QUEUE_DIRNAME),
-    archiveDir: path26__default.join(root, ARCHIVE_DIRNAME),
-    conflictsDir: path26__default.join(root, CONFLICTS_DIRNAME),
-    indexFile: path26__default.join(root, INDEX_FILENAME)
+    rawDir: path25__default.join(root, RAW_DIRNAME),
+    wikiDir: path25__default.join(root, WIKI_DIRNAME),
+    schemaDir: path25__default.join(root, SCHEMA_DIRNAME),
+    queueDir: path25__default.join(root, QUEUE_DIRNAME),
+    archiveDir: path25__default.join(root, ARCHIVE_DIRNAME),
+    conflictsDir: path25__default.join(root, CONFLICTS_DIRNAME),
+    indexFile: path25__default.join(root, INDEX_FILENAME)
   };
 }
 async function ensureMemoryRoot(paths) {
@@ -33018,10 +31781,10 @@ async function ensureMemoryRoot(paths) {
   await ensureWorkspaceDoctrine(paths);
 }
 function getIndexMarkdownFile(paths) {
-  return path26__default.join(paths.wikiDir, INDEX_MD_FILENAME);
+  return path25__default.join(paths.wikiDir, INDEX_MD_FILENAME);
 }
 function getLogFile(paths) {
-  return path26__default.join(paths.root, LOG_MD_FILENAME);
+  return path25__default.join(paths.root, LOG_MD_FILENAME);
 }
 
 // ../../packages/fleet-wiki/src/log.ts
@@ -33087,12 +31850,12 @@ async function readWikiEntry(id, paths) {
   const index = await loadIndex(paths);
   const indexed = index[id];
   if (indexed) {
-    const resolved = path26__default.resolve(paths.root, indexed.path);
-    const rel = path26__default.relative(paths.wikiDir, resolved);
-    if (!rel || rel.startsWith("..") || path26__default.isAbsolute(rel)) return null;
+    const resolved = path25__default.resolve(paths.root, indexed.path);
+    const rel = path25__default.relative(paths.wikiDir, resolved);
+    if (!rel || rel.startsWith("..") || path25__default.isAbsolute(rel)) return null;
     return readMarkdownFile(resolved);
   }
-  const fallbackPath = path26__default.join(paths.wikiDir, `${id}.md`);
+  const fallbackPath = path25__default.join(paths.wikiDir, `${id}.md`);
   if (await pathExists(fallbackPath)) {
     return readMarkdownFile(fallbackPath);
   }
@@ -33103,20 +31866,20 @@ async function readWikiEntry(id, paths) {
 async function writeWikiEntryAtTarget(entry, target, paths) {
   await ensureMemoryRoot(paths);
   assertSafeEntryId(entry.id);
-  const absoluteTarget = path26__default.resolve(paths.root, target);
-  const relativeTarget = path26__default.relative(paths.wikiDir, absoluteTarget);
-  if (!relativeTarget || relativeTarget.startsWith("..") || path26__default.isAbsolute(relativeTarget)) {
+  const absoluteTarget = path25__default.resolve(paths.root, target);
+  const relativeTarget = path25__default.relative(paths.wikiDir, absoluteTarget);
+  if (!relativeTarget || relativeTarget.startsWith("..") || path25__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 (path26__default.basename(absoluteTarget, ".md") !== entry.id) {
+  if (path25__default.basename(absoluteTarget, ".md") !== entry.id) {
     throw new Error("wiki patch body id must match target filename");
   }
-  await mkdir(path26__default.dirname(absoluteTarget), { recursive: true });
+  await mkdir(path25__default.dirname(absoluteTarget), { recursive: true });
   await writeMarkdownAtomic(absoluteTarget, serializeWikiEntry(entry), paths);
-  return path26__default.join("wiki", relativeTarget).replaceAll(path26__default.sep, "/");
+  return path25__default.join("wiki", relativeTarget).replaceAll(path25__default.sep, "/");
 }
 async function listWiki(paths) {
   const entries = await listWikiRecords(paths);
@@ -33339,7 +32102,7 @@ function parseWikiEntry(content) {
 async function listWikiRecords(paths) {
   return listMarkdownEntriesRecursive(paths.wikiDir, paths, (content, filePath) => ({
     entry: parseWikiEntry(content),
-    path: path26__default.relative(paths.root, filePath).replaceAll(path26__default.sep, "/")
+    path: path25__default.relative(paths.root, filePath).replaceAll(path25__default.sep, "/")
   }));
 }
 async function listMarkdownEntriesRecursive(dirPath, paths, parser) {
@@ -33352,7 +32115,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 = path26__default.join(dirPath, entry.name);
+    const filePath = path25__default.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       items.push(...await listMarkdownEntriesRecursive(filePath, paths, parser));
       continue;
@@ -33490,9 +32253,9 @@ async function writeJsonAtomic(filePath, value, paths) {
 }
 async function writeAtomic(filePath, content, paths) {
   await ensureMemoryRoot(paths);
-  const tempPath = path26__default.join(
-    path26__default.dirname(filePath),
-    `.tmp-${process.pid}-${Date.now()}-${crypto5.randomUUID()}-${os3__default.hostname()}`
+  const tempPath = path25__default.join(
+    path25__default.dirname(filePath),
+    `.tmp-${process.pid}-${Date.now()}-${crypto5.randomUUID()}-${os4__default.hostname()}`
   );
   await writeFile(tempPath, content, "utf8");
   await rename(tempPath, filePath);
@@ -33585,7 +32348,7 @@ function toRankedHit(entry, reason, detail, graphBoost, backlinksById) {
     score: basePriority * 100 + statusPriority * 10 + graphScore + (detail.tagBoost ?? 0),
     reason,
     excerpt,
-    path: path26__default.join("wiki", `${entry.id}.md`),
+    path: path25__default.join("wiki", `${entry.id}.md`),
     tags: entry.tags,
     updated: entry.updated,
     version: entry.version,
@@ -33695,15 +32458,15 @@ var PATCH_SET_DIRNAME = "_sets";
 var PATCH_SET_META_FILENAME = PATCH_META_FILENAME;
 function getPatchSetDir(paths, patchSetId) {
   assertSafePatchSetId(patchSetId);
-  const patchSetDir = path26__default.join(paths.queueDir, PATCH_SET_DIRNAME, patchSetId);
-  const relative = path26__default.relative(path26__default.join(paths.queueDir, PATCH_SET_DIRNAME), patchSetDir);
-  if (!relative || relative.startsWith("..") || path26__default.isAbsolute(relative)) {
+  const patchSetDir = path25__default.join(paths.queueDir, PATCH_SET_DIRNAME, patchSetId);
+  const relative = path25__default.relative(path25__default.join(paths.queueDir, PATCH_SET_DIRNAME), patchSetDir);
+  if (!relative || relative.startsWith("..") || path25__default.isAbsolute(relative)) {
     throw new Error(`[fleet-wiki] patch set id escapes queue/_sets: ${patchSetId}`);
   }
   return patchSetDir;
 }
 function getPatchSetMetaFile(paths, patchSetId) {
-  return path26__default.join(getPatchSetDir(paths, patchSetId), PATCH_SET_META_FILENAME);
+  return path25__default.join(getPatchSetDir(paths, patchSetId), PATCH_SET_META_FILENAME);
 }
 async function readPatchSet(paths, patchSetId) {
   const patchSet = await readJsonFile2(getPatchSetMetaFile(paths, patchSetId));
@@ -33726,7 +32489,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 = path26__default.join(paths.conflictsDir, conflictId);
+  const conflictDir = path25__default.join(paths.conflictsDir, conflictId);
   await mkdir(conflictDir, { recursive: true });
   const meta3 = {
     id: conflictId,
@@ -33746,13 +32509,13 @@ async function createConflict(input, paths) {
     currentHash: input.currentHash,
     warnings: input.warnings
   };
-  await writeJsonFile(path26__default.join(conflictDir, CONFLICT_META_FILENAME), meta3, paths);
-  await writePatchFile(path26__default.join(conflictDir, CONFLICT_PROPOSED_FILENAME), input.proposed, paths);
+  await writeJsonFile(path25__default.join(conflictDir, CONFLICT_META_FILENAME), meta3, paths);
+  await writePatchFile(path25__default.join(conflictDir, CONFLICT_PROPOSED_FILENAME), input.proposed, paths);
   if (input.current !== void 0) {
-    await writePatchFile(path26__default.join(conflictDir, CONFLICT_CURRENT_FILENAME), input.current, paths);
+    await writePatchFile(path25__default.join(conflictDir, CONFLICT_CURRENT_FILENAME), input.current, paths);
   }
   if (input.rawSource !== void 0) {
-    await writePatchFile(path26__default.join(conflictDir, CONFLICT_RAW_SOURCE_FILENAME), input.rawSource, paths);
+    await writePatchFile(path25__default.join(conflictDir, CONFLICT_RAW_SOURCE_FILENAME), input.rawSource, paths);
   }
   return {
     meta: meta3,
@@ -33802,11 +32565,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 = path26__default.resolve(paths.root, target);
-  if (!absoluteTarget.startsWith(`${paths.root}${path26__default.sep}`) && absoluteTarget !== paths.root) {
+  const absoluteTarget = path25__default.resolve(paths.root, target);
+  if (!absoluteTarget.startsWith(`${paths.root}${path25__default.sep}`) && absoluteTarget !== paths.root) {
     throw new Error("patch target escapes wiki root");
   }
-  if (!absoluteTarget.startsWith(`${paths.wikiDir}${path26__default.sep}`)) throw new Error("wiki patch must target wiki/");
+  if (!absoluteTarget.startsWith(`${paths.wikiDir}${path25__default.sep}`)) throw new Error("wiki patch must target wiki/");
   assertNoSymlinkPathComponents(target, paths);
   if (op === "create_wiki" && await pathExists(absoluteTarget)) {
     throw new Error(
@@ -33830,7 +32593,7 @@ async function listQueue(paths) {
   for (const id of ids) {
     if (id === "_sets") continue;
     try {
-      const meta3 = await readJsonFile2(path26__default.join(paths.queueDir, id, PATCH_META_FILENAME));
+      const meta3 = await readJsonFile2(path25__default.join(paths.queueDir, id, PATCH_META_FILENAME));
       results.push({ id, meta: meta3 });
     } catch {
       continue;
@@ -33855,9 +32618,9 @@ async function resolveQueueSelection(id, paths) {
 }
 async function showQueue(id, paths) {
   const selection = await resolveQueueSelection(id, paths);
-  const queueDir = path26__default.join(paths.queueDir, selection.id);
-  const patch = await parsePatch(await readPatchFile(path26__default.join(queueDir, PATCH_FILENAME)));
-  const meta3 = await readJsonFile2(path26__default.join(queueDir, PATCH_META_FILENAME));
+  const queueDir = path25__default.join(paths.queueDir, selection.id);
+  const patch = await parsePatch(await readPatchFile(path25__default.join(queueDir, PATCH_FILENAME)));
+  const meta3 = await readJsonFile2(path25__default.join(queueDir, PATCH_META_FILENAME));
   return { patch, meta: meta3 };
 }
 async function approvePatch(id, paths) {
@@ -33880,8 +32643,8 @@ async function approvePatch(id, paths) {
           rawSourceRef: meta3.rawSourceRef,
           warnings: meta3.warnings
         });
-        const queueDir = path26__default.join(paths.queueDir, id);
-        await writeJsonFile(path26__default.join(queueDir, PATCH_META_FILENAME), {
+        const queueDir = path25__default.join(paths.queueDir, id);
+        await writeJsonFile(path25__default.join(queueDir, PATCH_META_FILENAME), {
           ...meta3,
           conflictId
         }, paths);
@@ -33934,7 +32697,7 @@ async function rejectPatch(id, reason, paths) {
 }
 async function normalizeWikiEntryPatch(entry, target, paths) {
   assertSafeEntryId(entry.id);
-  if (entry.id !== path26__default.basename(target, ".md")) {
+  if (entry.id !== path25__default.basename(target, ".md")) {
     throw new Error("wiki patch body id must match target filename");
   }
   const inlineRawSourceRef = extractInlineRawSourceRef(entry.body);
@@ -33972,9 +32735,9 @@ function extractInlineRawSourceRef(body) {
 }
 async function validatePatchBase(patch, meta3, paths) {
   if (patch.frontmatter.op !== "update_wiki" || !meta3?.baseVersion && !meta3?.baseHash) return;
-  const wikiId = path26__default.basename(patch.frontmatter.target, ".md");
+  const wikiId = path25__default.basename(patch.frontmatter.target, ".md");
   const currentEntry = await readWikiEntry(wikiId, paths);
-  const currentPath = path26__default.join(paths.root, patch.frontmatter.target);
+  const currentPath = path25__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(
@@ -34033,17 +32796,17 @@ function assertCanonicalPatchTarget(target) {
   if (target.endsWith("/")) {
     throw new Error("patch target must not end with a slash");
   }
-  if (target.startsWith("/") || path26__default.posix.isAbsolute(target) || path26__default.win32.isAbsolute(target)) {
+  if (target.startsWith("/") || path25__default.posix.isAbsolute(target) || path25__default.win32.isAbsolute(target)) {
     throw new Error("patch target must be relative");
   }
-  if (path26__default.posix.normalize(target) !== target) {
+  if (path25__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 = path26__default.posix.relative("wiki", target);
-  const targetPath = path26__default.join(wikiRoot, ...relativeTarget.split("/"));
+  const relativeTarget = path25__default.posix.relative("wiki", target);
+  const targetPath = path25__default.join(wikiRoot, ...relativeTarget.split("/"));
   return `${wikiRoot}\0${targetPath}`.toLowerCase();
 }
 function canonicalPatchEditLockKey(paths, patchId) {
@@ -34059,7 +32822,7 @@ function assertNoSymlinkPathComponents(target, paths) {
     throw error51;
   }
   for (const part of parts) {
-    current = path26__default.join(current, part);
+    current = path25__default.join(current, part);
     try {
       if (lstatSync(current).isSymbolicLink()) {
         throw new Error("patch target must not include symlink path components");
@@ -34074,8 +32837,8 @@ function assertSafeRawSourceRef(rawSourceRef, paths) {
   if (!rawSourceRef.startsWith("raw/")) {
     throw new Error("raw source provenance must point into raw/");
   }
-  const absoluteRef = path26__default.resolve(paths.root, rawSourceRef);
-  if (!absoluteRef.startsWith(`${paths.rawDir}${path26__default.sep}`)) {
+  const absoluteRef = path25__default.resolve(paths.root, rawSourceRef);
+  if (!absoluteRef.startsWith(`${paths.rawDir}${path25__default.sep}`)) {
     throw new Error("raw source provenance must point into raw/");
   }
 }
@@ -34091,14 +32854,14 @@ function classifyPatchConflict(error51) {
 }
 async function recordPatchConflict(patch, paths, reason, options) {
   const now = /* @__PURE__ */ new Date();
-  const targetPath = path26__default.join(paths.root, patch.frontmatter.target);
+  const targetPath = path25__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 ?? path26__default.basename(patch.frontmatter.target, ".md"),
+    wikiId: proposedEntry?.id ?? path25__default.basename(patch.frontmatter.target, ".md"),
     title: proposedEntry?.title,
     proposer: patch.frontmatter.proposer,
     rawSourceRef: options?.rawSourceRef,
@@ -34194,11 +32957,11 @@ function parseInlineArray(value) {
   return inner.split(",").map((item) => item.trim().replace(/^"(.*)"$/, "$1"));
 }
 async function archiveQueueEntry(id, paths, meta3) {
-  const fromDir = path26__default.join(paths.queueDir, id);
-  const toDir = path26__default.join(paths.archiveDir, id);
+  const fromDir = path25__default.join(paths.queueDir, id);
+  const toDir = path25__default.join(paths.archiveDir, id);
   await removePath(toDir);
   await movePath(fromDir, toDir);
-  await writeJsonFile(path26__default.join(toDir, PATCH_META_FILENAME), meta3, paths);
+  await writeJsonFile(path25__default.join(toDir, PATCH_META_FILENAME), meta3, paths);
 }
 function buildQueueIdHelp(prefix, availableIds) {
   if (availableIds.length === 0) {
@@ -34920,7 +33683,7 @@ async function canonicalizeTheaterPath(cwd) {
   return canonicalizeTheaterPathSync(cwd);
 }
 function canonicalizeTheaterPathSync(cwd) {
-  const resolved = path26__default.resolve(cwd);
+  const resolved = path25__default.resolve(cwd);
   try {
     return fs11__default.realpathSync.native(resolved);
   } catch {
@@ -34928,7 +33691,7 @@ function canonicalizeTheaterPathSync(cwd) {
   }
 }
 function theaterLabel(cwd) {
-  return path26__default.basename(cwd) || cwd;
+  return path25__default.basename(cwd) || cwd;
 }
 
 // core/host/codex/workspaces.ts
@@ -34936,7 +33699,7 @@ var WorkspaceRegistry = class {
   #items = /* @__PURE__ */ new Map();
   #mruId = null;
   async register(cwdInput, lastOpenedAt) {
-    const cwd = path26__default.resolve(cwdInput);
+    const cwd = path25__default.resolve(cwdInput);
     const real = await canonicalizeTheaterPath(cwd);
     const paths = resolveMemoryPaths(real);
     if (!await directoryExists(paths.root)) {
@@ -34952,7 +33715,7 @@ var WorkspaceRegistry = class {
       id,
       cwd,
       realpath: real,
-      label: path26__default.basename(cwd),
+      label: path25__default.basename(cwd),
       paths,
       registeredAt: existing?.registeredAt ?? now,
       // 복원 경로는 durable lastOpenedAt을 그대로 보존해 재시작 후에도 워크스페이스 최근성
@@ -35091,7 +33854,7 @@ function createCodexGateway(deps) {
     }
   };
 }
-function buildAllowedAccessSets(host, port, interfaces = os3__default.networkInterfaces()) {
+function buildAllowedAccessSets(host, port, interfaces = os4__default.networkInterfaces()) {
   const hosts = isWildcardBindHost(host) ? enumerateWildcardAccessHosts(interfaces) : isDualBindHost(host) ? [host, LOOPBACK_HOST] : [host];
   const allowedHosts = /* @__PURE__ */ new Set();
   const allowedOrigins = /* @__PURE__ */ new Set();
@@ -35270,7 +34033,7 @@ function createConsoleDurableStateStore(deps = {}) {
   const createStore = deps.createStore ?? createDurableJsonStore;
   return createStore({
     filePath: paths.stateFile,
-    lockDir: path26__default.join(paths.dir, STATE_LOCK_DIR_NAME),
+    lockDir: path25__default.join(paths.dir, STATE_LOCK_DIR_NAME),
     lockOwnerFileName: STATE_LOCK_OWNER_FILE_NAME,
     now: deps.now,
     sanitize: sanitizeDurableConsoleState,
@@ -35279,7 +34042,7 @@ function createConsoleDurableStateStore(deps = {}) {
   });
 }
 function sanitizeDurableConsoleState(value) {
-  if (!isRecord6(value)) return emptyDurableConsoleState();
+  if (!isRecord5(value)) return emptyDurableConsoleState();
   const upgraded = migrateToCurrentVersion(value);
   if (upgraded.version !== STATE_VERSION) return emptyDurableConsoleState();
   return {
@@ -35306,13 +34069,13 @@ function migrateV1ToV2(v1) {
   };
 }
 function migrateV1Operation(value) {
-  if (!isRecord6(value)) return null;
+  if (!isRecord5(value)) return null;
   const sessionId = readNonEmptyString(value.sessionId);
   const theaterId = readNonEmptyString(value.theaterId);
   const cwd = readNonEmptyString(value.cwd);
   const createdAt = readFiniteNumber(value.createdAt);
   if (!sessionId || !theaterId || !cwd || createdAt === null) return null;
-  const title = readOptionalString(value.label) ?? (path26__default.basename(cwd) || cwd);
+  const title = readOptionalString(value.label) ?? (path25__default.basename(cwd) || cwd);
   const payload = { cwd };
   const cliId = readOptionalString(value.cliId);
   const cliLabel = readOptionalString(value.cliLabel);
@@ -35320,7 +34083,7 @@ function migrateV1Operation(value) {
   if (cliId) payload.cliId = cliId;
   if (cliLabel) payload.cliLabel = cliLabel;
   if (labelSource) payload.labelSource = labelSource;
-  if (isRecord6(value.providerSession)) payload.providerSession = value.providerSession;
+  if (isRecord5(value.providerSession)) payload.providerSession = value.providerSession;
   return {
     id: sessionId,
     theaterId,
@@ -35351,7 +34114,7 @@ function readOperations(value) {
   return nodes;
 }
 function sanitizeTheaterRegistration(value) {
-  if (!isRecord6(value)) return null;
+  if (!isRecord5(value)) return null;
   const id = readNonEmptyString(value.id);
   const theaterPath = readNonEmptyString(value.path);
   const realpath2 = readNonEmptyString(value.realpath);
@@ -35362,7 +34125,7 @@ function sanitizeTheaterRegistration(value) {
   return { id, path: theaterPath, realpath: realpath2, label, registeredAt, lastOpenedAt };
 }
 function sanitizeOperationNode(value) {
-  if (!isRecord6(value)) return null;
+  if (!isRecord5(value)) return null;
   const id = readNonEmptyString(value.id);
   const theaterId = readNonEmptyString(value.theaterId);
   const type = readNonEmptyString(value.type);
@@ -35386,7 +34149,7 @@ function sanitizeOperationNode(value) {
   };
 }
 function sanitizeOperationTimestamps(value) {
-  if (!isRecord6(value)) return null;
+  if (!isRecord5(value)) return null;
   const createdAt = readFiniteNumber(value.createdAt);
   const updatedAt = readFiniteNumber(value.updatedAt);
   if (createdAt === null || updatedAt === null) return null;
@@ -35394,7 +34157,7 @@ function sanitizeOperationTimestamps(value) {
 }
 function sanitizeOperationGeometry(value) {
   if (value === null || value === void 0) return null;
-  if (!isRecord6(value)) return null;
+  if (!isRecord5(value)) return null;
   const x = readFiniteNumber(value.x);
   const y = readFiniteNumber(value.y);
   const width = readFiniteNumber(value.width);
@@ -35403,7 +34166,7 @@ function sanitizeOperationGeometry(value) {
   if (x === null || y === null || width === null || height === null || zIndex === null) return null;
   return { x, y, width, height, zIndex };
 }
-function isRecord6(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readNonEmptyString(value) {
@@ -35413,7 +34176,7 @@ function readOptionalString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function readRecord(value) {
-  return isRecord6(value) ? value : {};
+  return isRecord5(value) ? value : {};
 }
 function remapTerminalPluginId(pluginId) {
   return pluginId === "agent" || pluginId === "shell" ? "terminal" : pluginId;
@@ -35447,7 +34210,7 @@ function readOperationGroups(value) {
   return groups;
 }
 function sanitizeOperationGroup(value) {
-  if (!isRecord6(value)) return null;
+  if (!isRecord5(value)) return null;
   const id = readNonEmptyString(value.id);
   const theaterId = readNonEmptyString(value.theaterId);
   const rawName = readNonEmptyString(value.name);
@@ -35489,10 +34252,10 @@ function sanitizeRecord(value, sensitiveFields) {
 }
 function sanitizeValue(value, sensitiveFields) {
   if (Array.isArray(value)) return value.map((item) => sanitizeValue(item, sensitiveFields));
-  if (!isRecord7(value)) return value;
+  if (!isRecord6(value)) return value;
   return sanitizeRecord(value, sensitiveFields);
 }
-function isRecord7(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -35511,6 +34274,14 @@ function createOperationsRouter(deps) {
       deps.writeJson(res, 200, deps.resolveLaunchCatalog ? await deps.resolveLaunchCatalog() : { plugins: [] });
       return true;
     }
+    if (pathname === "/api/v1/operations/events") {
+      if (req.method !== "GET") {
+        deps.writeJson(res, 405, { error: "Method not allowed" });
+        return true;
+      }
+      deps.subscribeOperationSse?.(res);
+      return true;
+    }
     if (pathname === "/api/v1/operations/groups") {
       await handleGroupCollection(req, res, deps);
       return true;
@@ -35560,8 +34331,8 @@ async function handleCollection(req, res, deps) {
       pluginId: body.pluginId,
       title: body.title,
       ...typeof body.accent === "string" ? { accent: body.accent } : {},
-      payload: isRecord8(body.payload) ? body.payload : {},
-      geometry: isRecord8(body.geometry) ? readGeometry(body.geometry) : null
+      payload: isRecord7(body.payload) ? body.payload : {},
+      geometry: isRecord7(body.geometry) ? readGeometry(body.geometry) : null
     });
     deps.persist();
     deps.writeJson(res, 201, { operation: sanitizeOperationNode2(node, deps) });
@@ -35618,23 +34389,24 @@ async function handleItem(req, res, id, deps) {
       ...typeof body.title === "string" ? { title: body.title } : {},
       ...typeof body.accent === "string" || body.accent === null ? { accent: body.accent } : {},
       ...typeof body.groupId === "string" || body.groupId === null ? { groupId: body.groupId } : {},
-      ...isRecord8(body.payload) ? { payload: body.payload } : {},
-      ...isRecord8(body.geometry) || body.geometry === null ? { geometry: body.geometry === null ? null : readGeometry(body.geometry) } : {}
+      ...isRecord7(body.payload) ? { payload: body.payload } : {},
+      ...isRecord7(body.geometry) || body.geometry === null ? { geometry: body.geometry === null ? null : readGeometry(body.geometry) } : {}
     });
     if (!node) {
       deps.writeJson(res, 404, { error: "operation_not_found" });
       return;
     }
     deps.persist();
-    if (previousNode && previousNode.title !== node.title) {
+    if (previousNode && typeof body.title === "string") {
       deps.publishRenameEvent?.({
         operationId: node.id,
         pluginId: node.pluginId,
         type: node.type,
-        title: node.title,
+        title: body.title.trim() === "" ? "" : node.title,
         previousTitle: previousNode.title
       });
     }
+    deps.broadcastOperationChanged?.(deps.store.get(id) ?? node);
     deps.writeJson(res, 200, { operation: sanitizeOperationNode2(node, deps) });
   } catch (error51) {
     deps.writeJson(res, 400, { error: error51 instanceof Error ? error51.message : "invalid_operation_patch" });
@@ -35723,7 +34495,7 @@ function readFiniteNumber2(value) {
 function readRequestUrl(req) {
   return new URL(req.url ?? "/", "http://127.0.0.1");
 }
-function isRecord8(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function createOperationStore(deps = {}) {
@@ -36008,14 +34780,14 @@ function renderShim(definition) {
   ].join("\n");
 }
 function isSubpath(root, target) {
-  const relative = path26__default.relative(root, target);
-  return relative === "" || !relative.startsWith("..") && !path26__default.isAbsolute(relative);
+  const relative = path25__default.relative(root, target);
+  return relative === "" || !relative.startsWith("..") && !path25__default.isAbsolute(relative);
 }
 function discoverFleetPlugins(options = {}) {
-  const builtInSourceRoot = options.builtInSourceRoot ?? (options.cwd ? path26__default.resolve(options.cwd, "runtime/fleet-plugins") : null);
+  const builtInSourceRoot = options.builtInSourceRoot ?? (options.cwd ? path25__default.resolve(options.cwd, "runtime/fleet-plugins") : null);
   const roots = [
     ...builtInSourceRoot ? [{ root: builtInSourceRoot, builtInDistRoot: options.builtInDistRoot ?? null, external: false }] : [],
-    { root: path26__default.join(options.homeDir ?? os3__default.homedir(), ".fleet", "plugins"), builtInDistRoot: null, external: true }
+    { root: path25__default.join(options.homeDir ?? os4__default.homedir(), ".fleet", "plugins"), builtInDistRoot: null, external: true }
   ];
   const sourcePlugins = roots.flatMap((root) => discoverPluginRoot(root.root, root.builtInDistRoot, root.external));
   const sourcePluginIds = new Set(sourcePlugins.map((plugin) => plugin.manifest.id));
@@ -36023,7 +34795,7 @@ function discoverFleetPlugins(options = {}) {
   return [...sourcePlugins, ...distPlugins];
 }
 function parseFleetPluginManifest(value) {
-  if (!isRecord9(value)) return null;
+  if (!isRecord8(value)) return null;
   const id = readPluginId(value.id);
   if (!id) return null;
   return {
@@ -36041,8 +34813,8 @@ function discoverPluginRoot(root, builtInDistRoot, external) {
   const plugins = [];
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name === "shared") continue;
-    const pluginRoot = path26__default.join(root, entry.name);
-    const manifestPath = path26__default.join(pluginRoot, "plugin.json");
+    const pluginRoot = path25__default.join(root, entry.name);
+    const manifestPath = path25__default.join(pluginRoot, "plugin.json");
     if (!fs11__default.existsSync(manifestPath)) continue;
     const manifest = readManifest(manifestPath);
     if (!manifest) continue;
@@ -36060,8 +34832,8 @@ function discoverDistPluginRoot(root) {
   const plugins = [];
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name === "shared") continue;
-    const pluginRoot = path26__default.join(root, entry.name);
-    const manifestPath = path26__default.join(pluginRoot, "plugin.json");
+    const pluginRoot = path25__default.join(root, entry.name);
+    const manifestPath = path25__default.join(pluginRoot, "plugin.json");
     const manifest = fs11__default.existsSync(manifestPath) ? readManifest(manifestPath) : readDistPluginManifest(entry.name);
     if (!manifest) continue;
     const clientEntry = resolveOptionalManifestEntry(pluginRoot, manifest.client, "client");
@@ -36088,10 +34860,10 @@ function resolveRoutesEntry(pluginRoot, manifest, builtInDistRoot) {
     if (manifestRoute2 === false) return false;
     if (manifestRoute2) return manifestRoute2;
   }
-  const manifestRoute = path26__default.join(pluginRoot, "routes.ts");
+  const manifestRoute = path25__default.join(pluginRoot, "routes.ts");
   if (fs11__default.existsSync(manifestRoute)) return manifestRoute;
   if (!builtInDistRoot) return null;
-  const builtRoute = path26__default.join(builtInDistRoot, manifest.id, "routes.mjs");
+  const builtRoute = path25__default.join(builtInDistRoot, manifest.id, "routes.mjs");
   return fs11__default.existsSync(builtRoute) ? builtRoute : null;
 }
 function resolveDistRoutesEntry(pluginRoot, manifest) {
@@ -36105,7 +34877,7 @@ function resolveOptionalManifestEntry(pluginRoot, entryPath, label) {
     console.warn(`[fleet-console] Plugin ${label} entry skipped: unsafe relative path ${entryPath}`);
     return false;
   }
-  const candidate = path26__default.resolve(pluginRoot, entryPath);
+  const candidate = path25__default.resolve(pluginRoot, entryPath);
   if (!fs11__default.existsSync(candidate)) return null;
   const rootRealpath = fs11__default.realpathSync.native(pluginRoot);
   const entryRealpath = fs11__default.realpathSync.native(candidate);
@@ -36123,14 +34895,14 @@ function readDistPluginManifest(id) {
   return pluginId ? { id: pluginId, routes: "routes.mjs" } : null;
 }
 function isSafeRelativeEntry(entryPath) {
-  if (path26__default.isAbsolute(entryPath)) return false;
+  if (path25__default.isAbsolute(entryPath)) return false;
   return entryPath.split(/[\\/]+/u).every((segment) => segment !== "..");
 }
 function isSubpath2(root, candidate) {
-  const relative = path26__default.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path26__default.isAbsolute(relative);
+  const relative = path25__default.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path25__default.isAbsolute(relative);
 }
-function isRecord9(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -36151,7 +34923,7 @@ var PLUGIN_DEV_EXTERNALS = [
   "@dotobokuri/*",
   "@fleet-plugins/*"
 ];
-var __dirname$1 = path26__default.dirname(fileURLToPath(import.meta.url));
+var __dirname$1 = path25__default.dirname(fileURLToPath(import.meta.url));
 function createFleetPluginHost(deps) {
   const plugins = filterDiscoveredPlugins(discoverFleetPlugins(deps));
   const sensitiveFieldsByPluginId = new Map(plugins.map((plugin) => [plugin.manifest.id, plugin.manifest.sensitiveFields ?? []]));
@@ -36225,39 +34997,39 @@ async function importPluginModule(entry) {
   return await import(pathToFileURL(entry).href);
 }
 async function writeTemporaryPluginBundle(entry, source) {
-  const cacheRoot = path26__default.join(resolvePluginBundleNodeModules(entry), ".cache");
+  const cacheRoot = path25__default.join(resolvePluginBundleNodeModules(entry), ".cache");
   await mkdir(cacheRoot, { recursive: true });
-  const dir = await mkdtemp(path26__default.join(cacheRoot, "fleet-console-plugin-"));
-  const file2 = path26__default.join(dir, "routes.mjs");
+  const dir = await mkdtemp(path25__default.join(cacheRoot, "fleet-console-plugin-"));
+  const file2 = path25__default.join(dir, "routes.mjs");
   await writeFile(file2, source, "utf8");
   return file2;
 }
 function resolvePluginBundleNodeModules(entry) {
   const packageNodeModules = resolveConsolePackageNodeModules();
-  let dir = path26__default.dirname(entry);
+  let dir = path25__default.dirname(entry);
   let fallback = packageNodeModules;
   while (true) {
-    const workspaceConsoleNodeModules = path26__default.join(dir, "runtime", "fleet-console", "node_modules");
+    const workspaceConsoleNodeModules = path25__default.join(dir, "runtime", "fleet-console", "node_modules");
     if (hasFleetConsoleSdk(workspaceConsoleNodeModules)) return workspaceConsoleNodeModules;
-    const candidate = path26__default.join(dir, "node_modules");
+    const candidate = path25__default.join(dir, "node_modules");
     if (hasFleetConsoleSdk(candidate)) return candidate;
     if (fallback === null && existsSync(candidate)) fallback = candidate;
-    const parent = path26__default.dirname(dir);
-    if (parent === dir) return fallback ?? path26__default.join(path26__default.dirname(entry), "node_modules");
+    const parent = path25__default.dirname(dir);
+    if (parent === dir) return fallback ?? path25__default.join(path25__default.dirname(entry), "node_modules");
     dir = parent;
   }
 }
 function resolveConsolePackageNodeModules() {
   for (const candidate of [
-    path26__default.resolve(__dirname$1, "..", "node_modules"),
-    path26__default.resolve(__dirname$1, "..", "..", "..", "node_modules")
+    path25__default.resolve(__dirname$1, "..", "node_modules"),
+    path25__default.resolve(__dirname$1, "..", "..", "..", "node_modules")
   ]) {
     if (hasFleetConsoleSdk(candidate)) return candidate;
   }
   return null;
 }
 function hasFleetConsoleSdk(nodeModules) {
-  return existsSync(path26__default.join(nodeModules, "@fleet-console", "sdk"));
+  return existsSync(path25__default.join(nodeModules, "@fleet-console", "sdk"));
 }
 function resolveRegister(mod) {
   if (mod.register) return mod.register;
@@ -36516,6 +35288,14 @@ function normalizePrefix3(prefix) {
 function matchesPrefix2(pathname, prefix) {
   return pathname === prefix || pathname.startsWith(`${prefix}/`);
 }
+
+// core/host/sse.ts
+function encodeSseData(event, data) {
+  return `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+}
 var MIME_TYPES = {
   ".css": "text/css; charset=utf-8",
   ".html": "text/html; charset=utf-8",
@@ -36525,7 +35305,7 @@ var MIME_TYPES = {
   ".woff2": "font/woff2"
 };
 function createStaticConsoleHandler(packageRoot) {
-  const consoleRoot = path26__default.join(packageRoot, "dist", "client");
+  const consoleRoot = path25__default.join(packageRoot, "dist", "client");
   return (req, res, pathname) => tryServeStaticConsole(req, res, pathname, consoleRoot);
 }
 function tryServeStaticConsole(req, res, pathname, consoleRoot) {
@@ -36541,7 +35321,7 @@ function tryServeStaticConsole(req, res, pathname, consoleRoot) {
     res.end(JSON.stringify({ error: "Not found" }));
     return true;
   }
-  const absolutePath = path26__default.resolve(consoleRoot, relativePath2);
+  const absolutePath = path25__default.resolve(consoleRoot, relativePath2);
   if (!absolutePath.startsWith(consoleRoot)) {
     res.writeHead(404, withSecurityHeaders2({ "Content-Type": "application/json" }));
     res.end(JSON.stringify({ error: "Not found" }));
@@ -36549,7 +35329,7 @@ function tryServeStaticConsole(req, res, pathname, consoleRoot) {
   }
   try {
     const data = fs11__default.readFileSync(absolutePath);
-    const contentType = MIME_TYPES[path26__default.extname(absolutePath)] ?? "application/octet-stream";
+    const contentType = MIME_TYPES[path25__default.extname(absolutePath)] ?? "application/octet-stream";
     res.writeHead(200, withSecurityHeaders2({ "Content-Type": contentType }));
     if (req.method === "HEAD") {
       res.end();
@@ -36569,7 +35349,7 @@ function tryServeStaticConsole(req, res, pathname, consoleRoot) {
 }
 function serveFallbackIndex(req, res, consoleRoot) {
   try {
-    const data = fs11__default.readFileSync(path26__default.join(consoleRoot, "index.html"));
+    const data = fs11__default.readFileSync(path25__default.join(consoleRoot, "index.html"));
     res.writeHead(200, withSecurityHeaders2({ "Content-Type": MIME_TYPES[".html"] }));
     if (req.method === "HEAD") {
       res.end();
@@ -36595,7 +35375,7 @@ function resolveConsolePath(pathname) {
   }
   if (withoutPrefix === "") return "index.html";
   if (withoutPrefix.includes("\0")) return null;
-  if (!path26__default.extname(withoutPrefix)) return "index.html";
+  if (!path25__default.extname(withoutPrefix)) return "index.html";
   return withoutPrefix;
 }
 var TheaterFolderListError = class extends Error {
@@ -36629,14 +35409,14 @@ async function listTheaterFolders(requestedPath, deps = {}) {
 }
 function normalizeFolderBrowserPath(value, platform = process.platform) {
   if (typeof value !== "string" || value.length === 0 || value.includes("\0")) throw new TheaterFolderListError("invalid_path");
-  if (isWindowsAmbiguousPath(value, platform) || !path26__default.isAbsolute(value)) throw new TheaterFolderListError("invalid_path");
-  return path26__default.resolve(value);
+  if (isWindowsAmbiguousPath(value, platform) || !path25__default.isAbsolute(value)) throw new TheaterFolderListError("invalid_path");
+  return path25__default.resolve(value);
 }
 function normalizeListPath(requestedPath, platform, deps) {
   if (requestedPath === null || requestedPath === void 0) {
-    const home = deps.homedir?.() ?? os3__default.homedir();
+    const home = deps.homedir?.() ?? os4__default.homedir();
     const start = home || deps.cwd?.() || process.cwd();
-    return path26__default.resolve(start);
+    return path25__default.resolve(start);
   }
   return normalizeFolderBrowserPath(requestedPath, platform);
 }
@@ -36687,7 +35467,7 @@ async function openDirectory(targetPath, opendir) {
 }
 async function toTheaterFolderEntry(targetPath, dirent, stat5) {
   if (!dirent.isDirectory() && !dirent.isSymbolicLink()) return null;
-  const entryPath = path26__default.join(targetPath, dirent.name);
+  const entryPath = path25__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;
@@ -36707,10 +35487,10 @@ function mapFsError(error51) {
   return new TheaterFolderListError("invalid_path");
 }
 function parentPath(targetPath, platform) {
-  const parsed = path26__default.parse(targetPath);
-  const resolved = path26__default.resolve(targetPath);
-  if (resolved === path26__default.resolve(parsed.root)) return null;
-  const parent = path26__default.dirname(resolved);
+  const parsed = path25__default.parse(targetPath);
+  const resolved = path25__default.resolve(targetPath);
+  if (resolved === path25__default.resolve(parsed.root)) return null;
+  const parent = path25__default.dirname(resolved);
   if (platform === "win32" && parent === resolved) return null;
   return parent;
 }
@@ -36750,8 +35530,8 @@ function createFolderGrantStore(deps = {}) {
 }
 function validateAbsoluteDirectory(cwd, statSync2 = fs11__default.statSync) {
   if (typeof cwd !== "string" || cwd.length === 0 || cwd.includes("\0")) throw new Error("invalid_folder");
-  if (isWindowsAmbiguousPath2(cwd) || !path26__default.isAbsolute(cwd)) throw new Error("invalid_folder");
-  const normalized = path26__default.resolve(cwd);
+  if (isWindowsAmbiguousPath2(cwd) || !path25__default.isAbsolute(cwd)) throw new Error("invalid_folder");
+  const normalized = path25__default.resolve(cwd);
   if (!statSync2(normalized).isDirectory()) throw new Error("invalid_folder");
   return normalized;
 }
@@ -36763,7 +35543,7 @@ var TheaterRegistry = class {
   #items = /* @__PURE__ */ new Map();
   #mruId = null;
   async register(cwd) {
-    const resolved = path26__default.resolve(cwd);
+    const resolved = path25__default.resolve(cwd);
     const real = await canonicalizeTheaterPath(resolved);
     const id = workspaceHash(real);
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -36835,17 +35615,17 @@ function createConsoleUpdateApplyService(deps = {}) {
   const preflightInstall = deps.preflightInstall ?? ((currentPackageRoot) => preflightPackageManager(currentPackageRoot, env));
   const serverModulePath = deps.serverModulePath ?? resolveDefaultServerModulePath();
   const spawnWorker = deps.spawnWorker ?? defaultSpawnWorker;
-  const tmpDir = deps.tmpDir ?? os3__default.tmpdir();
+  const tmpDir = deps.tmpDir ?? os4__default.tmpdir();
   const writeFile5 = deps.writeFile ?? ((filePath, content, options) => {
     fs11__default.writeFileSync(filePath, content, { mode: options.mode });
   });
   async function start(request) {
     const packageManager = await preflightInstall(request.currentPackageRoot);
     const stamp = `${now()}-${processPid}`;
-    const workerPath = path26__default.join(tmpDir, `${WORKER_FILE_PREFIX}${stamp}${WORKER_FILE_SUFFIX}`);
+    const workerPath = path25__default.join(tmpDir, `${WORKER_FILE_PREFIX}${stamp}${WORKER_FILE_SUFFIX}`);
     makeDir(request.dataDir, { recursive: true, mode: 448 });
-    const statusFile = path26__default.join(request.dataDir, `${WORKER_FILE_PREFIX}${stamp}${STATUS_FILE_SUFFIX}`);
-    const logFile = path26__default.join(request.dataDir, `${WORKER_FILE_PREFIX}${stamp}${LOG_FILE_SUFFIX}`);
+    const statusFile = path25__default.join(request.dataDir, `${WORKER_FILE_PREFIX}${stamp}${STATUS_FILE_SUFFIX}`);
+    const logFile = path25__default.join(request.dataDir, `${WORKER_FILE_PREFIX}${stamp}${LOG_FILE_SUFFIX}`);
     const script = emitConsoleUpdateWorkerScript({
       currentEndpoint: request.currentEndpoint,
       currentPackageRoot: request.currentPackageRoot,
@@ -37193,7 +35973,7 @@ function resolveDefaultServerModulePath() {
   if (sourcePath.endsWith(".ts")) {
     return sourcePath.replace(/update-apply\.ts$/, "cli.ts");
   }
-  return path26__default.join(path26__default.dirname(sourcePath), "cli.mjs");
+  return path25__default.join(path25__default.dirname(sourcePath), "cli.mjs");
 }
 
 // core/host/update-check.ts
@@ -37323,27 +36103,6 @@ var SERVER_API_CATALOG = [
     category: "Terminal Plugin",
     gate: "origin-write"
   },
-  {
-    method: "GET",
-    path: "/plugins/terminal/model-auth/state",
-    summary: "Get Terminal plugin model sign-in status.",
-    category: "Terminal Plugin",
-    gate: "loopback"
-  },
-  {
-    method: "PUT",
-    path: "/plugins/terminal/model-auth/providers/:cli",
-    summary: "Register a Terminal plugin model provider API key.",
-    category: "Terminal Plugin",
-    gate: "origin-write"
-  },
-  {
-    method: "DELETE",
-    path: "/plugins/terminal/model-auth/providers/:cli",
-    summary: "Remove a Terminal plugin model provider API key.",
-    category: "Terminal Plugin",
-    gate: "origin-write"
-  },
   {
     method: "POST",
     path: "/api/v1/theaters/folder-listings",
@@ -37408,6 +36167,7 @@ function createConsoleServer(deps = {}) {
   const pluginLaunchCatalogProviders = /* @__PURE__ */ new Map();
   const pluginCleanupCallbacks = /* @__PURE__ */ new Set();
   const pluginEventListeners = /* @__PURE__ */ new Map();
+  const operationSseSubscribers = /* @__PURE__ */ new Set();
   const pluginHostCapabilities = {
     operations: {
       list: () => operations.list(),
@@ -37418,8 +36178,14 @@ function createConsoleServer(deps = {}) {
         return operation;
       },
       patch: (id, input) => {
+        const previousTitle = "title" in input ? operations.get(id)?.title : void 0;
         const operation = operations.patch(id, input);
-        if (operation) persistDurableState();
+        if (operation) {
+          persistDurableState();
+          if (previousTitle !== void 0 && previousTitle !== operation.title) {
+            broadcastOperationChanged(operation);
+          }
+        }
         return operation;
       },
       delete: (id) => {
@@ -37473,7 +36239,7 @@ function createConsoleServer(deps = {}) {
     paths: {
       dataDir: durablePaths.dir,
       capturesDir: durablePaths.capturesDir,
-      pluginDataDir: (pluginId) => path26__default.join(durablePaths.dir, "plugins", pluginId),
+      pluginDataDir: (pluginId) => path25__default.join(durablePaths.dir, "plugins", pluginId),
       resolveTheaterPath: (theaterId) => theaters.get(theaterId)?.path ?? null,
       canonicalizeTheaterPath: canonicalizeTheaterPathSync,
       workspaceHash
@@ -37577,7 +36343,20 @@ function createConsoleServer(deps = {}) {
     ],
     resolveLaunchCatalog: resolveOperationCatalog,
     publishRenameEvent: (event) => pluginHostCapabilities.events.publish(OPERATION_RENAMED_EVENT_CHANNEL, event),
-    publishDeleteEvent: (event) => pluginHostCapabilities.events.publish(OPERATION_DELETED_EVENT_CHANNEL, event)
+    publishDeleteEvent: (event) => pluginHostCapabilities.events.publish(OPERATION_DELETED_EVENT_CHANNEL, event),
+    broadcastOperationChanged,
+    subscribeOperationSse: (res) => {
+      res.writeHead(200, withSecurityHeaders2({
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+      }));
+      res.write(":connected\n\n");
+      operationSseSubscribers.add(res);
+      res.on("close", () => {
+        operationSseSubscribers.delete(res);
+      });
+    }
   });
   routeRegistry.register("/api/v1/operations", operationsRouter);
   routeRegistry.register("/api/v1/settings", async (ctx) => {
@@ -37996,6 +36775,18 @@ function createConsoleServer(deps = {}) {
       }
     }
   }
+  function broadcastOperationChanged(node) {
+    if (operationSseSubscribers.size === 0) return;
+    const sensitiveFields = [
+      ...pluginHost.sensitiveFieldsByPluginId.get(node.pluginId) ?? [],
+      ...pluginPayloadSanitizers.get(node.pluginId) ?? []
+    ];
+    const sanitized = createSanitizedOpDto(node, { sensitiveFields });
+    const data = encodeSseData("operation:changed", { operation: sanitized });
+    for (const res of operationSseSubscribers) {
+      res.write(data);
+    }
+  }
   function persistDurableState() {
     try {
       durableStateStore.save({
@@ -38134,11 +36925,11 @@ function createConsoleServer(deps = {}) {
   return returnedServer;
 }
 function resolveBuiltInPluginDiscoveryRoots(packageRoot) {
-  const packageRootRepo = path26__default.resolve(packageRoot, "..", "..");
-  const sourceRoot = path26__default.join(packageRootRepo, "runtime", "fleet-plugins");
+  const packageRootRepo = path25__default.resolve(packageRoot, "..", "..");
+  const sourceRoot = path25__default.join(packageRootRepo, "runtime", "fleet-plugins");
   return {
     ...fs11__default.existsSync(sourceRoot) ? { builtInSourceRoot: sourceRoot } : {},
-    builtInDistRoot: path26__default.join(packageRoot, "dist", "fleet-plugins")
+    builtInDistRoot: path25__default.join(packageRoot, "dist", "fleet-plugins")
   };
 }
 function createHttpServer(handler, upgradeRegistry) {
@@ -38291,14 +37082,14 @@ async function readPluginStorageJson(dataDir, pluginId, key) {
 }
 async function writePluginStorageJson(dataDir, pluginId, key, value) {
   const file2 = resolvePluginStorageFile(dataDir, pluginId, key);
-  await fs11__default.promises.mkdir(path26__default.dirname(file2), { recursive: true });
+  await fs11__default.promises.mkdir(path25__default.dirname(file2), { recursive: true });
   await fs11__default.promises.writeFile(file2, JSON.stringify(value), "utf8");
 }
 function resolvePluginStorageFile(dataDir, pluginId, key) {
   if (!/^[a-z0-9][a-z0-9._-]*$/i.test(pluginId) || !/^[a-z0-9][a-z0-9._-]*$/i.test(key)) {
     throw new Error("invalid_plugin_storage_key");
   }
-  return path26__default.join(dataDir, "plugins", pluginId, `${key}.json`);
+  return path25__default.join(dataDir, "plugins", pluginId, `${key}.json`);
 }
 function isNodeError(error51) {
   return error51 instanceof Error && "code" in error51;
@@ -38320,7 +37111,7 @@ function createConsoleStalePolicy(deps = {}) {
 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", "auto-name"]);
+var CONSOLE_HOOK_COMMANDS = /* @__PURE__ */ new Set(["capture-session", "turn-start", "turn-end", "attention", "auto-name"]);
 function parseConsoleCliMode(argv) {
   if (argv.length === 0) return "start";
   const [first, ...rest] = argv;
@@ -38350,7 +37141,6 @@ function parseConsoleHookCommand(argv) {
   if (!commandName || !CONSOLE_HOOK_COMMANDS.has(commandName)) {
     throw new Error("Unknown fleet-console hook command");
   }
-  if (commandName === "subagents-context" && rest.length === 0) return { command: "subagents-context" };
   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" };
@@ -38522,11 +37312,6 @@ async function main() {
   }
   if (process4.argv[2] === "hook") {
     const hookCommand = parseConsoleHookCommand(process4.argv.slice(3));
-    if (hookCommand.command === "subagents-context") {
-      process4.stdout.write(`${runSubagentsContextHook(process4.env)}
-`);
-      return;
-    }
     if (hookCommand.command === "turn-start" || hookCommand.command === "turn-end") {
       await postAgentHook(`/sessions/${readHookSessionId(process4.env)}/turn`, { phase: hookCommand.command === "turn-start" ? "start" : "end" }, process4.env);
       return;
@@ -38622,7 +37407,7 @@ function readStdinBestEffort() {
     });
   });
 }
-var isDirectRun = process4.argv[1] && path26__default.resolve(process4.argv[1]) === fileURLToPath(import.meta.url);
+var isDirectRun = process4.argv[1] && path25__default.resolve(process4.argv[1]) === fileURLToPath(import.meta.url);
 if (isDirectRun) {
   await main().catch((error51) => {
     process4.stderr.write(`${error51 instanceof Error ? error51.message : String(error51)}