deskbuddy 0.2.0-beta.7 → 0.2.0-beta.8

package/dist/cli.js

@@ -1,7 +1,13 @@
 #!/usr/bin/env node
 
 // src/commands/daemon.ts
-import { writeFileSync as writeFileSync17, rmSync as rmSync12 } from "fs";
+import { writeFileSync as writeFileSync18, rmSync as rmSync14 } from "fs";
+
+// src/core/api.ts
+import { execFileSync } from "child_process";
+import { createHash, randomBytes, randomUUID as randomUUID2 } from "crypto";
+import { readFileSync as readFileSync3 } from "fs";
+import { release } from "os";
 
 // src/core/config.ts
 import { randomUUID } from "crypto";
@@ -89,7 +95,8 @@ function loadConfig() {
       remoteCwd: parsed.remoteCwd,
       // 不认识的值一律回落默认，不能让一个手滑写错的配置变成"全放行"或"全拦"
       approvalPolicy: parsed.approvalPolicy === "all" ? "all" : parsed.approvalPolicy === "commands" ? "commands" : void 0,
-      codexAppServer: typeof parsed.codexAppServer === "string" ? parsed.codexAppServer : void 0
+      codexAppServer: typeof parsed.codexAppServer === "string" ? parsed.codexAppServer : void 0,
+      autoUpdate: typeof parsed.autoUpdate === "boolean" ? parsed.autoUpdate : void 0
     };
   } catch {
     return fallback;
@@ -110,16 +117,531 @@ function ensureClientId() {
   return config.clientId;
 }
 
+// src/core/hookFile.ts
+import { copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "fs";
+import { createRequire } from "module";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+var here = dirname(fileURLToPath(import.meta.url));
+function packagedHookPath() {
+  const candidates = [
+    join2(here, "hook.cjs"),
+    // dist/cli.js 旁边（发布形态）
+    join2(here, "..", "hook", "hook.cjs"),
+    // dist/../hook/
+    join2(here, "..", "..", "hook", "hook.cjs")
+    // src/core/../../hook/（开发形态）
+  ];
+  for (const c of candidates) {
+    if (existsSync2(c)) return c;
+  }
+  throw new Error("\u627E\u4E0D\u5230\u5305\u5185\u7684 hook.cjs\uFF0C\u5B89\u88C5\u5305\u53EF\u80FD\u4E0D\u5B8C\u6574\uFF0C\u8BF7\u91CD\u65B0\u5B89\u88C5 deskbuddy");
+}
+function packageVersion() {
+  const require2 = createRequire(import.meta.url);
+  for (const c of ["../package.json", "../../package.json", "../../../package.json"]) {
+    try {
+      const pkg = require2(c);
+      if (pkg?.name === "deskbuddy" && pkg.version) return pkg.version;
+    } catch {
+    }
+  }
+  return "0.0.0-dev";
+}
+function hookVersionPath(target = installedHookPath()) {
+  return join2(dirname(target), "hook-version");
+}
+function installedHookVersion(target = installedHookPath()) {
+  try {
+    return readFileSync2(hookVersionPath(target), "utf8").trim() || null;
+  } catch {
+    return null;
+  }
+}
+function atomicCopy(from, to) {
+  const tmp = `${to}.${process.pid}.tmp`;
+  copyFileSync(from, tmp);
+  renameSync2(tmp, to);
+}
+function syncHookFile(opts = {}) {
+  const target = opts.target ?? installedHookPath();
+  const version = opts.version ?? packageVersion();
+  const SIBLINGS = ["gate.cjs", "opencode.mjs", "wake.cjs", "launcher.cjs"];
+  const siblingMissing = () => SIBLINGS.some((name) => {
+    if (existsSync2(join2(dirname(target), name))) return false;
+    try {
+      return existsSync2(join2(dirname(opts.source ?? packagedHookPath()), name));
+    } catch {
+      return false;
+    }
+  });
+  if (installedHookVersion(target) === version && existsSync2(target) && !siblingMissing()) return false;
+  const source = opts.source ?? packagedHookPath();
+  mkdirSync2(dirname(target), { recursive: true });
+  atomicCopy(source, target);
+  for (const name of SIBLINGS) {
+    const from = join2(dirname(source), name);
+    if (existsSync2(from)) atomicCopy(from, join2(dirname(target), name));
+  }
+  writeFileSync2(hookVersionPath(target), version, "utf8");
+  return true;
+}
+
+// src/core/api.ts
+var SERVICES = {
+  authCode: "com.shifeng.api.service.api.v2.deskbuddy.deskbuddyauthcodeapi",
+  authToken: "com.shifeng.api.service.api.v2.deskbuddy.deskbuddyauthtokenapi",
+  sessionReport: "com.shifeng.api.service.api.v2.deskbuddy.deskbuddysessionreportapi",
+  toolRegistry: "com.shifeng.api.service.api.v2.deskbuddy.deskbuddytoolregistryapi",
+  /** App 扫码确认时调的，CLI 用不到，列在这里只为对照 */
+  confirmAuth: "com.shifeng.api.service.api.v2.deskbuddy.deskbuddyconfirmauthapi"
+};
+var DIRS_SERVICE = "com.shifeng.api.service.api.v2.deskbuddy.deskbuddyclientdirsreportapi";
+var INSTALL_REDEEM_SERVICE = "com.shifeng.api.service.api.v2.deskbuddy.deskbuddyinstallredeemapi";
+var CMD_RESULT_SERVICE = "com.shifeng.api.service.api.v2.deskbuddy.deskbuddycommandresultapi";
+var APPROVAL_SERVICES = {
+  create: "com.shifeng.api.service.api.v2.deskbuddy.deskbuddyapprovalcreateapi",
+  cancel: "com.shifeng.api.service.api.v2.deskbuddy.deskbuddyapprovalcancelapi",
+  sync: "com.shifeng.api.service.api.v2.deskbuddy.deskbuddyapprovalsyncapi"
+};
+var APP_ID = process.env.DESKBUDDY_APPID || "deskbuddy-cli";
+var APP_SECRET = process.env.DESKBUDDY_APPSECRET || "3aeb6e0afc144e188dd3ede5c7865643";
+var GATEWAY_VERSION = "1.0";
+var DEFAULT_TIMEOUT_MS = 1e4;
+function sign(p) {
+  const source = [p.appId, p.appSecret, p.timestamp, p.deviceId, p.deviceName, p.nonce, p.body].join("_");
+  return createHash("md5").update(source, "utf8").digest("hex");
+}
+function buildGatewayBody(service, data, requestId) {
+  return JSON.stringify({
+    service,
+    version: GATEWAY_VERSION,
+    requestId: requestId || randomUUID2(),
+    base: { encode: "false" },
+    // data 是业务 JSON 序列化后的字符串
+    data: JSON.stringify(data ?? {})
+  });
+}
+function buildHeaders(cfg, body, opts = {}) {
+  const timestamp = opts.timestamp || String(Date.now());
+  const nonce = opts.nonce || randomBytes(8).toString("hex");
+  return {
+    "Content-Type": "application/json;charset=UTF-8",
+    "Content-Length": String(Buffer.byteLength(body)),
+    "ShiFeng-AppId": APP_ID,
+    "ShiFeng-Timestamp": timestamp,
+    "ShiFeng-Device-ID": cfg.clientId,
+    "ShiFeng-Device-Name": cfg.hostName,
+    "ShiFeng-Nonce": nonce,
+    "ShiFeng-Signature": sign({
+      appId: APP_ID,
+      appSecret: APP_SECRET,
+      timestamp,
+      deviceId: cfg.clientId,
+      deviceName: cfg.hostName,
+      nonce,
+      body
+    })
+    // 没有 ShiFeng-Token：鉴权靠 clientId ↔ userId 绑定关系，CLI 不持有用户凭证
+  };
+}
+function isSuccessCode(code) {
+  return code === "0000";
+}
+var ApiError = class extends Error {
+  constructor(code, message) {
+    super(`${code}: ${message}`);
+    this.code = code;
+    this.name = "ApiError";
+  }
+  code;
+};
+function humanOs(platform = process.platform) {
+  const known = {
+    darwin: "macOS",
+    win32: "Windows",
+    linux: "Linux"
+  };
+  return known[platform] ?? platform;
+}
+var defaultOsVersionDeps = {
+  runSwVers: () => execFileSync("sw_vers", ["-productVersion"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: 2e3
+  }),
+  readOsRelease: () => readFileSync3("/etc/os-release", "utf8"),
+  kernelRelease: () => release()
+};
+function productOsVersion(platform = process.platform, deps = defaultOsVersionDeps) {
+  try {
+    if (platform === "darwin") {
+      const v = deps.runSwVers().trim();
+      if (v) return v;
+    } else if (platform === "linux") {
+      const m = /^PRETTY_NAME=(.*)$/m.exec(deps.readOsRelease());
+      if (m) {
+        const v = m[1].trim().replace(/^(["'])(.*)\1$/, "$2").trim();
+        if (v) return v;
+      }
+    }
+  } catch {
+  }
+  try {
+    return deps.kernelRelease();
+  } catch {
+    return "";
+  }
+}
+var machineInfoCache = null;
+function machineInfo() {
+  if (!machineInfoCache) {
+    machineInfoCache = {
+      os: humanOs(),
+      osVersion: productOsVersion(),
+      arch: process.arch,
+      cliVersion: packageVersion()
+    };
+  }
+  return machineInfoCache;
+}
+async function call(service, data, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const cfg = loadConfig();
+  const body = buildGatewayBody(service, data);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(`${cfg.apiBase}/gateway`, {
+      method: "POST",
+      headers: buildHeaders(cfg, body),
+      body,
+      // 与签名用的是同一个字符串
+      signal: controller.signal
+    });
+    const json = await res.json();
+    if (!isSuccessCode(json?.code)) {
+      throw new ApiError(String(json?.code), json?.message ?? "");
+    }
+    return json?.data;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var api = {
+  authCode: (clientId, hostName) => call(SERVICES.authCode, { clientId, hostName, ...machineInfo() }),
+  authToken: (authCode) => call(SERVICES.authToken, { authCode }),
+  toolRegistry: () => call(SERVICES.toolRegistry, {}),
+  // 🔴 2 秒超时：这条调用发生在 hook 链路上，慢一点就是拖慢用户的 agent
+  report: (payload) => call(SERVICES.sessionReport, payload, 2e3),
+  approvalCreate: (payload) => call(APPROVAL_SERVICES.create, payload),
+  approvalCancel: (approvalId, reason) => call(APPROVAL_SERVICES.cancel, { approvalId, reason }),
+  approvalSync: (approvalIds) => call(APPROVAL_SERVICES.sync, { approvalIds }),
+  dirsReport: (payload) => call(DIRS_SERVICE, payload),
+  installRedeem: (installCode, clientId, hostName) => call(INSTALL_REDEEM_SERVICE, { installCode, clientId, hostName, ...machineInfo() }),
+  // 2 秒超时、失败不重试（spec §4.1）：回报丢了只是设备少一句提示，任务状态仍由会话快照负责
+  commandResult: (payload) => call(CMD_RESULT_SERVICE, payload, 2e3)
+};
+
+// src/core/versions.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { cpSync, existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync4, renameSync as renameSync3, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { basename, dirname as dirname2, join as join3, relative, resolve, sep } from "path";
+
+// src/core/semver.ts
+var SEMVER_RE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?$/;
+var MAX_LEN = 64;
+function isValidVersion(v) {
+  return typeof v === "string" && v.length <= MAX_LEN && SEMVER_RE.test(v);
+}
+function parse(v) {
+  const m = SEMVER_RE.exec(v);
+  if (!m) return null;
+  return { nums: [Number(m[1]), Number(m[2]), Number(m[3])], pre: m[4] ? m[4].split(".") : [] };
+}
+function cmpIdent(a, b) {
+  const an = /^\d+$/.test(a);
+  const bn = /^\d+$/.test(b);
+  if (an && bn) return Math.sign(Number(a) - Number(b));
+  if (an) return -1;
+  if (bn) return 1;
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function compareVersions(a, b) {
+  const pa = parse(a);
+  const pb = parse(b);
+  if (!pa || !pb) throw new Error(`\u4E0D\u662F\u5408\u6CD5\u7684\u7248\u672C\u53F7\uFF1A${!pa ? a : b}`);
+  for (let i = 0; i < 3; i++) {
+    if (pa.nums[i] !== pb.nums[i]) return Math.sign(pa.nums[i] - pb.nums[i]);
+  }
+  if (pa.pre.length === 0 || pb.pre.length === 0) return pa.pre.length === pb.pre.length ? 0 : pa.pre.length === 0 ? 1 : -1;
+  for (let i = 0; i < Math.max(pa.pre.length, pb.pre.length); i++) {
+    if (i >= pa.pre.length) return -1;
+    if (i >= pb.pre.length) return 1;
+    const c = cmpIdent(pa.pre[i], pb.pre[i]);
+    if (c !== 0) return c;
+  }
+  return 0;
+}
+function semverGt(a, b) {
+  return compareVersions(a, b) > 0;
+}
+function semverLt(a, b) {
+  return compareVersions(a, b) < 0;
+}
+
+// src/core/versions.ts
+function versionsDir(home = deskbuddyHome()) {
+  return join3(home, "versions");
+}
+function currentJsonPath(home) {
+  return join3(versionsDir(home), "current.json");
+}
+function failedJsonPath(home) {
+  return join3(versionsDir(home), "failed.json");
+}
+function crashesJsonPath(home) {
+  return join3(versionsDir(home), "crashes.json");
+}
+function launcherPath(home = deskbuddyHome()) {
+  return join3(home, "launcher.cjs");
+}
+function versionDir(version, home) {
+  if (!isValidVersion(version)) throw new Error(`\u4E0D\u662F\u5408\u6CD5\u7684\u7248\u672C\u53F7\uFF1A${version}`);
+  return join3(versionsDir(home), version);
+}
+function versionCliPath(version, home) {
+  return join3(versionDir(version, home), "node_modules", "deskbuddy", "dist", "cli.js");
+}
+function atomicWriteJson(path, value) {
+  mkdirSync3(dirname2(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync3(tmp, JSON.stringify(value, null, 2), "utf8");
+  renameSync3(tmp, path);
+}
+function isRef(v) {
+  const r = v;
+  return !!r && typeof r.version === "string" && typeof r.cliPath === "string" && r.cliPath !== "";
+}
+function readCurrent(home) {
+  try {
+    const raw = JSON.parse(readFileSync4(currentJsonPath(home), "utf8"));
+    if (!isRef(raw)) return null;
+    return {
+      version: raw.version,
+      cliPath: raw.cliPath,
+      previous: isRef(raw.previous) ? { version: raw.previous.version, cliPath: raw.previous.cliPath } : null,
+      state: raw.state === "verifying" ? "verifying" : "good",
+      switchedAt: typeof raw.switchedAt === "number" ? raw.switchedAt : 0
+    };
+  } catch {
+    return null;
+  }
+}
+function writeCurrent(cur, home) {
+  atomicWriteJson(currentJsonPath(home), cur);
+}
+function readFailed(home) {
+  try {
+    const raw = JSON.parse(readFileSync4(failedJsonPath(home), "utf8"));
+    const versions = Array.isArray(raw.versions) ? raw.versions.filter((v) => typeof v === "string") : [];
+    const attempts = {};
+    if (raw.attempts && typeof raw.attempts === "object") {
+      for (const [k, v] of Object.entries(raw.attempts)) if (typeof v === "number") attempts[k] = v;
+    }
+    return { versions, attempts };
+  } catch {
+    return { versions: [], attempts: {} };
+  }
+}
+function recordAttemptFailure(version, now, home) {
+  const f = readFailed(home);
+  f.attempts[version] = now;
+  atomicWriteJson(failedJsonPath(home), f);
+}
+function markGood(version, home) {
+  const cur = readCurrent(home);
+  if (!cur || cur.version !== version || cur.state !== "verifying") return false;
+  writeCurrent({ ...cur, state: "good" }, home);
+  try {
+    rmSync(crashesJsonPath(home), { force: true });
+  } catch {
+  }
+  return true;
+}
+function versionDirOf(cliPath, home) {
+  const rel = relative(versionsDir(home), resolve(cliPath));
+  if (!rel || rel.startsWith("..") || rel.startsWith(sep) || /^[a-zA-Z]:/.test(rel)) return null;
+  const first = rel.split(/[\\/]/)[0];
+  return isValidVersion(first) ? first : null;
+}
+function cleanupVersions(cur, home) {
+  const keep = /* @__PURE__ */ new Set();
+  for (const ref of [cur, cur.previous]) {
+    if (!ref) continue;
+    const d = versionDirOf(ref.cliPath, home);
+    if (d) keep.add(d);
+  }
+  const removed = [];
+  let names = [];
+  try {
+    names = readdirSync(versionsDir(home), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return removed;
+  }
+  for (const name of names) {
+    const ours = isValidVersion(name) || /^\.tmp-/.test(name);
+    if (!ours || keep.has(name)) continue;
+    try {
+      rmSync(join3(versionsDir(home), name), { recursive: true, force: true });
+      removed.push(name);
+    } catch {
+    }
+  }
+  return removed;
+}
+function cliReportsVersion(cliPath, version, nodePath = process.execPath) {
+  try {
+    const out = execFileSync2(nodePath, [cliPath, "--version"], {
+      encoding: "utf8",
+      timeout: 3e4,
+      windowsHide: true,
+      shell: false,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return out.trim() === version;
+  } catch {
+    return false;
+  }
+}
+function installedPackageVersion(dir) {
+  try {
+    const pkg = JSON.parse(readFileSync4(join3(dir, "node_modules", "deskbuddy", "package.json"), "utf8"));
+    return pkg.name === "deskbuddy" && typeof pkg.version === "string" ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+function readPkg(dir) {
+  try {
+    return JSON.parse(readFileSync4(join3(dir, "package.json"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function findDepDir(name, fromDir) {
+  let d = fromDir;
+  for (; ; ) {
+    const c = join3(d, "node_modules", name);
+    if (existsSync3(join3(c, "package.json"))) return c;
+    const up = dirname2(d);
+    if (up === d) return null;
+    d = up;
+  }
+}
+function copyRunningCli(pkgRoot, version, home) {
+  const dest = versionDir(version, home);
+  const tmp = join3(versionsDir(home), `.tmp-${version}-${process.pid}`);
+  rmSync(tmp, { recursive: true, force: true });
+  const nm = join3(tmp, "node_modules");
+  mkdirSync3(nm, { recursive: true });
+  const copied = /* @__PURE__ */ new Set();
+  const copyPkg = (name, from) => {
+    copied.add(name);
+    cpSync(from, join3(nm, name), {
+      recursive: true,
+      dereference: true,
+      // 包自己的嵌套 node_modules 不整个搬：依赖由下面的递归平铺
+      filter: (src) => !(src !== from && basename(src) === "node_modules" && dirname2(src) === from)
+    });
+  };
+  copyPkg("deskbuddy", pkgRoot);
+  const queue = [{ dir: pkgRoot, pkg: readPkg(pkgRoot) ?? {} }];
+  while (queue.length > 0) {
+    const { dir, pkg } = queue.shift();
+    const deps = [
+      ...Object.keys(pkg.dependencies ?? {}).map((n) => [n, false]),
+      ...Object.keys(pkg.optionalDependencies ?? {}).map((n) => [n, true])
+    ];
+    for (const [name, optional] of deps) {
+      if (copied.has(name)) continue;
+      const found = findDepDir(name, dir);
+      if (!found) {
+        if (optional) continue;
+        rmSync(tmp, { recursive: true, force: true });
+        throw new Error(`\u627E\u4E0D\u5230\u4F9D\u8D56 ${name}`);
+      }
+      copyPkg(name, found);
+      queue.push({ dir: found, pkg: readPkg(found) ?? {} });
+    }
+  }
+  rmSync(dest, { recursive: true, force: true });
+  renameSync3(tmp, dest);
+  return versionCliPath(version, home);
+}
+function registerRunningCli(running, deps = {}) {
+  const home = deps.home;
+  const now = deps.now ?? Date.now();
+  const verify = deps.verify ?? ((p, v) => cliReportsVersion(p, v));
+  if (!isValidVersion(running.version) || running.version.startsWith("0.0.0")) {
+    throw new Error(`\u5F00\u53D1\u7248\uFF08${running.version}\uFF09\u4E0D\u767B\u8BB0`);
+  }
+  let cliPath = resolve(running.cliPath);
+  if (!existsSync3(cliPath)) throw new Error(`\u5165\u53E3\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${cliPath}`);
+  let how = "already";
+  let note;
+  if (versionDirOf(cliPath, home) !== running.version) {
+    const distDir = dirname2(cliPath);
+    const pkgRoot = dirname2(distDir);
+    const pkg = readPkg(pkgRoot);
+    const copyable = basename(distDir) === "dist" && pkg?.name === "deskbuddy" && pkg.version === running.version && !existsSync3(join3(pkgRoot, "src"));
+    how = "inPlace";
+    if (copyable) {
+      const target = versionCliPath(running.version, home);
+      try {
+        if (!(installedPackageVersion(versionDir(running.version, home)) === running.version && verify(target, running.version))) {
+          copyRunningCli(pkgRoot, running.version, home);
+        }
+        if (verify(target, running.version)) {
+          cliPath = target;
+          how = "copied";
+        } else note = "\u590D\u5236\u51FA\u6765\u7684\u90A3\u4EFD\u8DD1\u4E0D\u8D77\u6765";
+      } catch (e) {
+        note = `\u590D\u5236\u5931\u8D25\uFF1A${e.message}`;
+      }
+    } else note = "\u4E0D\u662F\u53D1\u5E03\u5F62\u6001\u7684\u5B89\u88C5\u5305";
+  }
+  const old = readCurrent(home);
+  const from = deps.from && isValidVersion(deps.from.version) && deps.from.version !== running.version && existsSync3(deps.from.cliPath) ? deps.from : null;
+  const changed = !!old && old.version !== running.version || !old && !!from;
+  const prevRef = old && old.version !== running.version ? { version: old.version, cliPath: old.cliPath } : from;
+  const current = {
+    version: running.version,
+    cliPath,
+    previous: changed ? prevRef : old?.previous ?? from,
+    // 版本变了一律 verifying（新版起不来要能退回去）；同版本重复登记保持原状态
+    state: changed ? "verifying" : old && old.cliPath === cliPath ? old.state : from ? "verifying" : "good",
+    switchedAt: changed || !old ? now : old.switchedAt
+  };
+  writeCurrent(current, home);
+  if (changed) {
+    try {
+      rmSync(crashesJsonPath(home), { force: true });
+    } catch {
+    }
+  }
+  return { current, how, note };
+}
+
 // src/daemon/autostart.ts
 import { execFile, spawn } from "child_process";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir2 } from "os";
-import { fileURLToPath } from "url";
-import { basename, dirname, join as join2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { basename as basename2, dirname as dirname3, join as join4 } from "path";
 import { promisify } from "util";
 
 // src/core/winproc.ts
-import { execFileSync } from "child_process";
+import { execFileSync as execFileSync3 } from "child_process";
 function winSplitArgs(cmdline) {
   const out = [];
   let cur = "";
@@ -213,7 +735,7 @@ var cache = null;
 function winProcs(now = Date.now()) {
   if (cache && now - cache.at < (cache.procs ? CACHE_MS : FAIL_CACHE_MS)) return cache.procs;
   try {
-    const out = execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", WIN_PS_SCRIPT], {
+    const out = execFileSync3("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", WIN_PS_SCRIPT], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       maxBuffer: 32 * 1024 * 1024,
@@ -235,8 +757,8 @@ var SYSTEMD_UNIT = "deskbuddy.service";
 var SCHTASK_NAME = "DeskBuddyDaemon";
 var CLI_ENTRY = "cli.js";
 function defaultCliPath(argv1 = process.argv[1]) {
-  const sibling = fileURLToPath(new URL("./" + CLI_ENTRY, import.meta.url));
-  if (typeof argv1 === "string" && basename(argv1) === CLI_ENTRY) return argv1;
+  const sibling = fileURLToPath2(new URL("./" + CLI_ENTRY, import.meta.url));
+  if (typeof argv1 === "string" && basename2(argv1) === CLI_ENTRY) return argv1;
   return sibling;
 }
 function xmlEscape(s) {
@@ -275,8 +797,8 @@ RestartSec=10
 WantedBy=default.target
 `;
 }
-function winStartupVbsPath(appData = process.env.APPDATA ?? join2(homedir2(), "AppData", "Roaming")) {
-  return join2(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "DeskBuddyDaemon.vbs");
+function winStartupVbsPath(appData = process.env.APPDATA ?? join4(homedir2(), "AppData", "Roaming")) {
+  return join4(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "DeskBuddyDaemon.vbs");
 }
 function vbsQuote(s) {
   return '"' + s.replace(/"/g, '""') + '"';
@@ -294,16 +816,25 @@ function isOurDaemonCmdline(cmdline) {
   const i = argv.findIndex((a) => /(?:^|[\\/])deskbuddy[\\/]dist[\\/]cli\.js$/i.test(a));
   return i >= 1 && argv[i + 1] === "daemon";
 }
+function isOurLauncherCmdline(cmdline) {
+  const argv = winSplitArgs(cmdline);
+  const i = argv.findIndex((a) => /(?:^|[\\/])launcher\.cjs$/i.test(a));
+  return i >= 1 && argv[i + 1] === "daemon";
+}
 async function stopPidFileDaemon() {
+  await stopByPidFile(launcherPidPath(), isOurLauncherCmdline);
+  await stopByPidFile(pidFilePath(), isOurDaemonCmdline);
+}
+async function stopByPidFile(file, ours) {
   let pid = 0;
   try {
-    pid = Number(readFileSync2(pidFilePath(), "utf8").trim());
+    pid = Number(readFileSync5(file, "utf8").trim());
   } catch {
     return;
   }
   if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid) return;
   const p = winProcs()?.find((x) => x.pid === pid);
-  if (!p || !isOurDaemonCmdline(p.cmdline)) return;
+  if (!p || !ours(p.cmdline)) return;
   try {
     process.kill(pid);
   } catch {
@@ -319,33 +850,69 @@ async function stopPidFileDaemon() {
   }
 }
 function launchAgentPath(home = homedir2()) {
-  return join2(home, "Library", "LaunchAgents", `${LAUNCH_LABEL}.plist`);
+  return join4(home, "Library", "LaunchAgents", `${LAUNCH_LABEL}.plist`);
 }
 function systemdUnitPath(home = homedir2()) {
-  return join2(home, ".config", "systemd", "user", SYSTEMD_UNIT);
+  return join4(home, ".config", "systemd", "user", SYSTEMD_UNIT);
 }
 function write(path, content) {
-  mkdirSync2(dirname(path), { recursive: true });
-  writeFileSync2(path, content, "utf8");
+  mkdirSync4(dirname3(path), { recursive: true });
+  writeFileSync4(path, content, "utf8");
 }
 var BOOTSTRAP_RETRIES = 10;
 var BOOTSTRAP_RETRY_MS = 500;
-async function installAutostart(t, platform = process.platform) {
+var AUTO_BOOTSTRAP_RETRIES = 120;
+async function retryAsync(fn, retries, delayMs) {
+  for (let i = 0; ; i++) {
+    try {
+      await fn();
+      return;
+    } catch (e) {
+      if (i >= retries) throw e;
+      await new Promise((r) => setTimeout(r, delayMs));
+    }
+  }
+}
+function shouldFallbackSpawn(daemonPid, alive) {
+  return !(daemonPid && daemonPid > 0 && alive(daemonPid));
+}
+function readDaemonPid() {
+  try {
+    const n = Number(readFileSync5(pidFilePath(), "utf8").trim());
+    return Number.isInteger(n) && n > 0 ? n : null;
+  } catch {
+    return null;
+  }
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+function fallbackSpawn(t) {
+  if (!shouldFallbackSpawn(readDaemonPid(), pidAlive)) return "\u65E7\u5B88\u62A4\u8FDB\u7A0B\u4ECD\u5728\u8FD0\u884C\uFF0C\u672A\u53E6\u8D77";
+  try {
+    spawn(t.execPath, [t.cliPath, "daemon"], { detached: true, stdio: "ignore", windowsHide: true, shell: false }).unref();
+    return "\u5DF2\u76F4\u63A5\u62C9\u8D77\u5B88\u62A4\u8FDB\u7A0B\u515C\u5E95\uFF08\u672C\u6B21\u5F00\u673A\u5185\u6709\u6548\uFF09";
+  } catch (e) {
+    return `\u76F4\u63A5\u62C9\u8D77\u5B88\u62A4\u8FDB\u7A0B\u4E5F\u5931\u8D25\u4E86\uFF1A${e.message}`;
+  }
+}
+async function installAutostart(t, platform = process.platform, opts = {}) {
   try {
     if (platform === "darwin") {
       const p = launchAgentPath();
       write(p, launchAgentPlist(t));
       await run("launchctl", ["bootout", `gui/${process.getuid?.() ?? 501}/${LAUNCH_LABEL}`]).catch(() => {
       });
-      for (let i = 0; ; i++) {
-        try {
-          await run("launchctl", ["bootstrap", `gui/${process.getuid?.() ?? 501}`, p]);
-          break;
-        } catch (e) {
-          if (i >= BOOTSTRAP_RETRIES) throw e;
-          await new Promise((r) => setTimeout(r, BOOTSTRAP_RETRY_MS));
-        }
-      }
+      await retryAsync(
+        () => run("launchctl", ["bootstrap", `gui/${process.getuid?.() ?? 501}`, p]),
+        opts.auto ? AUTO_BOOTSTRAP_RETRIES : BOOTSTRAP_RETRIES,
+        BOOTSTRAP_RETRY_MS
+      );
       return { ok: true, message: "\u5DF2\u8BBE\u7F6E\u5F00\u673A\u81EA\u542F\uFF08launchd\uFF09" };
     }
     if (platform === "linux") {
@@ -357,8 +924,8 @@ async function installAutostart(t, platform = process.platform) {
     }
     if (platform === "win32") {
       const p = winStartupVbsPath();
-      mkdirSync2(dirname(p), { recursive: true });
-      writeFileSync2(p, "\uFEFF" + winStartupVbs(t), "utf16le");
+      mkdirSync4(dirname3(p), { recursive: true });
+      writeFileSync4(p, "\uFEFF" + winStartupVbs(t), "utf16le");
       await run("schtasks", ["/delete", "/f", "/tn", SCHTASK_NAME], { windowsHide: true }).catch(() => {
       });
       await stopPidFileDaemon();
@@ -367,6 +934,9 @@ async function installAutostart(t, platform = process.platform) {
     }
     return { ok: false, message: `\u6682\u4E0D\u652F\u6301\u5728 ${platform} \u4E0A\u8BBE\u7F6E\u5F00\u673A\u81EA\u542F\uFF0C\u8BF7\u81EA\u884C\u5E38\u9A7B\u8FD0\u884C deskbuddy daemon` };
   } catch (e) {
+    if (opts.auto && platform !== "win32") {
+      return { ok: false, message: `\u5F00\u673A\u81EA\u542F\u6CA1\u8BBE\u7F6E\u6210\u529F\uFF08${e.message}\uFF09\uFF0C${fallbackSpawn(t)}` };
+    }
     return { ok: false, message: `\u5F00\u673A\u81EA\u542F\u6CA1\u8BBE\u7F6E\u6210\u529F\uFF08${e.message}\uFF09\uFF0C\u53EF\u4EE5\u624B\u52A8\u8DD1 deskbuddy daemon` };
   }
 }
@@ -376,14 +946,14 @@ async function uninstallAutostart(platform = process.platform) {
       await run("launchctl", ["bootout", `gui/${process.getuid?.() ?? 501}/${LAUNCH_LABEL}`]).catch(() => {
       });
       const p = launchAgentPath();
-      if (existsSync2(p)) rmSync(p, { force: true });
+      if (existsSync4(p)) rmSync2(p, { force: true });
       return { ok: true, message: "\u5DF2\u53D6\u6D88\u5F00\u673A\u81EA\u542F" };
     }
     if (platform === "linux") {
       await run("systemctl", ["--user", "disable", "--now", SYSTEMD_UNIT]).catch(() => {
       });
       const p = systemdUnitPath();
-      if (existsSync2(p)) rmSync(p, { force: true });
+      if (existsSync4(p)) rmSync2(p, { force: true });
       await run("systemctl", ["--user", "daemon-reload"]).catch(() => {
       });
       return { ok: true, message: "\u5DF2\u53D6\u6D88\u5F00\u673A\u81EA\u542F" };
@@ -391,29 +961,390 @@ async function uninstallAutostart(platform = process.platform) {
     if (platform === "win32") {
       await run("schtasks", ["/delete", "/f", "/tn", SCHTASK_NAME], { windowsHide: true }).catch(() => {
       });
-      const p = winStartupVbsPath();
-      if (existsSync2(p)) rmSync(p, { force: true });
-      await stopPidFileDaemon();
-      return { ok: true, message: "\u5DF2\u53D6\u6D88\u5F00\u673A\u81EA\u542F" };
+      const p = winStartupVbsPath();
+      if (existsSync4(p)) rmSync2(p, { force: true });
+      await stopPidFileDaemon();
+      return { ok: true, message: "\u5DF2\u53D6\u6D88\u5F00\u673A\u81EA\u542F" };
+    }
+    return { ok: true, message: "" };
+  } catch (e) {
+    return { ok: false, message: `\u53D6\u6D88\u5F00\u673A\u81EA\u542F\u65F6\u51FA\u9519\uFF08${e.message}\uFF09\uFF0C\u53EF\u80FD\u9700\u8981\u624B\u52A8\u6E05\u7406` };
+  }
+}
+function pidFilePath() {
+  return join4(deskbuddyHome(), "daemon.pid");
+}
+function launcherPidPath() {
+  return join4(deskbuddyHome(), "launcher.pid");
+}
+function autostartTarget(out = () => {
+}, from = null) {
+  const legacy = { execPath: process.execPath, cliPath: defaultCliPath() };
+  try {
+    const r = registerRunningCli({ version: packageVersion(), cliPath: defaultCliPath() }, { from });
+    syncHookFile();
+    const launcher = launcherPath();
+    if (!existsSync4(launcher)) throw new Error("launcher.cjs \u6CA1\u6709\u540C\u6B65\u5230 " + deskbuddyHome());
+    if (r.note) out(`\u26A0\uFE0F  \u5F53\u524D\u7248\u672C\u6CA1\u80FD\u590D\u5236\u8FDB ${deskbuddyHome()}/versions\uFF08${r.note}\uFF09\uFF0C\u5148\u539F\u5730\u767B\u8BB0`);
+    const removed = cleanupVersions(r.current);
+    if (removed.length > 0) out(`\u5DF2\u6E05\u7406\u65E7\u7248\u672C\uFF1A${removed.join(", ")}`);
+    return { execPath: process.execPath, cliPath: launcher };
+  } catch (e) {
+    out(`\u26A0\uFE0F  \u6CA1\u80FD\u63A5\u5165\u81EA\u52A8\u5347\u7EA7\uFF08${e.message}\uFF09\uFF0C\u5F00\u673A\u81EA\u542F\u4ECD\u76F4\u63A5\u6307\u5411\u5F53\u524D\u7248\u672C`);
+    return legacy;
+  }
+}
+
+// src/daemon/autoUpdate.ts
+import { execFile as execFile2, execFileSync as execFileSync4, spawn as spawn2 } from "child_process";
+import { closeSync, existsSync as existsSync6, mkdirSync as mkdirSync5, openSync, rmSync as rmSync3 } from "fs";
+import { dirname as dirname5, join as join6, posix, win32 } from "path";
+
+// src/wrap/pty.ts
+import { chmodSync, existsSync as existsSync5, statSync } from "fs";
+import { createRequire as createRequire2 } from "module";
+import { dirname as dirname4, join as join5 } from "path";
+var req = createRequire2(import.meta.url);
+function fixSpawnHelper() {
+  if (process.platform !== "darwin") return;
+  try {
+    const dir = join5(dirname4(req.resolve("node-pty/package.json")), "prebuilds", `darwin-${process.arch}`);
+    const helper = join5(dir, "spawn-helper");
+    if (existsSync5(helper) && (statSync(helper).mode & 73) === 0) chmodSync(helper, 493);
+  } catch {
+  }
+}
+function loadPty() {
+  try {
+    fixSpawnHelper();
+    const m = req("node-pty");
+    return typeof m?.spawn === "function" ? m : null;
+  } catch {
+    return null;
+  }
+}
+function loadHeadless() {
+  try {
+    const m = req("@xterm/headless");
+    return typeof m?.Terminal === "function" ? m.Terminal : null;
+  } catch {
+    return null;
+  }
+}
+function screenLines(term) {
+  const b = term.buffer.active;
+  const out = [];
+  for (let i = b.viewportY; i < b.viewportY + term.rows; i++) {
+    const l = b.getLine(i);
+    out.push(l ? l.translateToString(true) : "");
+  }
+  return out;
+}
+function screenLinesUndimmed(term) {
+  const b = term.buffer.active;
+  const out = [];
+  for (let i = b.viewportY; i < b.viewportY + term.rows; i++) {
+    const l = b.getLine(i);
+    if (!l) {
+      out.push("");
+      continue;
+    }
+    if (typeof l.getCell !== "function") {
+      out.push(l.translateToString(true));
+      continue;
+    }
+    let s = "";
+    for (let x = 0; x < term.cols; x++) {
+      const c = l.getCell(x);
+      if (!c) break;
+      const w = c.getWidth();
+      if (w === 0) continue;
+      s += c.isDim() ? " ".repeat(w) : c.getChars() || " ";
+    }
+    out.push(s.trimEnd());
+  }
+  return out;
+}
+
+// src/daemon/autoUpdate.ts
+var PACKAGE_NAME = "deskbuddy";
+var REGISTRIES = ["https://registry.npmjs.org/", "https://registry.npmmirror.com/"];
+var FIRST_CHECK_MS = 60 * 1e3;
+var CHECK_INTERVAL_MS = 60 * 60 * 1e3;
+var IDLE_POLL_MS = 30 * 1e3;
+var IDLE_MAX_WAIT_MS = 24 * 60 * 60 * 1e3;
+var RETRY_AFTER_FAIL_MS = 6 * 60 * 60 * 1e3;
+var INSTALL_TIMEOUT_MS = 5 * 60 * 1e3;
+var SWITCH_GRACE_MS = 10 * 60 * 1e3;
+var SWITCH_EXIT_GRACE_MS = 5 * 1e3;
+function decideUpdate(current, cli, cfg, failed, now) {
+  const none = (reason2, target2 = "") => ({ action: "none", target: target2, reason: reason2 });
+  if (cfg.autoUpdate === false) return none("\u672C\u5730\u5DF2\u5173\u95ED\u81EA\u52A8\u5347\u7EA7");
+  if (!isValidVersion(current) || current.startsWith("0.0.0")) return none(`\u5F53\u524D\u662F\u5F00\u53D1\u7248\uFF08${current}\uFF09\uFF0C\u4E0D\u81EA\u52A8\u5347\u7EA7`);
+  const latest = typeof cli?.latestVersion === "string" ? cli.latestVersion.trim() : "";
+  if (!latest) return none("\u670D\u52A1\u7AEF\u6CA1\u6709\u6307\u5B9A\u7248\u672C");
+  if (!isValidVersion(latest)) return none(`\u670D\u52A1\u7AEF\u4E0B\u53D1\u7684\u7248\u672C\u53F7\u4E0D\u5408\u6CD5\uFF1A${latest.slice(0, 64)}`);
+  const minRaw = typeof cli?.minVersion === "string" ? cli.minVersion.trim() : "";
+  const min = isValidVersion(minRaw) ? minRaw : "";
+  let target = "";
+  let reason = "";
+  if (min && semverLt(current, min)) {
+    target = compareVersions(latest, min) >= 0 ? latest : min;
+    reason = `\u5F53\u524D ${current} \u4F4E\u4E8E\u6700\u4F4E\u7248\u672C ${min}\uFF0C\u5F3A\u5236\u5347\u7EA7\u5230 ${target}`;
+  } else if (semverGt(latest, current)) {
+    target = latest;
+    reason = `\u6709\u65B0\u7248\u672C ${latest}\uFF08\u5F53\u524D ${current}\uFF09`;
+  } else {
+    return none(`\u5DF2\u662F\u6700\u65B0\uFF08\u5F53\u524D ${current}\uFF0C\u670D\u52A1\u7AEF\u6307\u5B9A ${latest}\uFF09`);
+  }
+  if (failed.versions.includes(target)) return none(`${target} \u66FE\u7ECF\u56DE\u6EDA\u8FC7\uFF0C\u4E0D\u518D\u81EA\u52A8\u5347\u5230\u5B83`, target);
+  const at = failed.attempts[target];
+  if (typeof at === "number" && now - at < RETRY_AFTER_FAIL_MS) {
+    return none(`${target} \u4E0A\u6B21\u5B89\u88C5\u5931\u8D25\uFF0C${Math.ceil((RETRY_AFTER_FAIL_MS - (now - at)) / 6e4)} \u5206\u949F\u540E\u518D\u8BD5`, target);
+  }
+  return { action: "update", target, reason };
+}
+function npmCliCandidates(execPath = process.execPath, platform = process.platform) {
+  if (platform === "win32") return [win32.join(win32.dirname(execPath), "node_modules", "npm", "bin", "npm-cli.js")];
+  const dir = posix.dirname(execPath);
+  return [
+    posix.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js"),
+    posix.join(dir, "..", "libexec", "lib", "node_modules", "npm", "bin", "npm-cli.js")
+  ];
+}
+function npmCliPath(execPath = process.execPath, platform = process.platform, exists = existsSync6) {
+  return npmCliCandidates(execPath, platform).find((p) => exists(p)) ?? null;
+}
+function npmInstallArgs(npmCli, dir, target, registry) {
+  if (!isValidVersion(target)) throw new Error(`\u4E0D\u662F\u5408\u6CD5\u7684\u7248\u672C\u53F7\uFF1A${target}`);
+  if (!REGISTRIES.includes(registry)) throw new Error(`\u4E0D\u5141\u8BB8\u7684\u6E90\uFF1A${registry}`);
+  return [npmCli, "install", "--prefix", dir, "--no-audit", "--no-fund", "--omit=dev", `${PACKAGE_NAME}@${target}`, "--registry", registry];
+}
+var defaultExec = (file, args, opts) => new Promise((resolve6, reject) => {
+  execFile2(file, args, { ...opts, maxBuffer: 16 * 1024 * 1024 }, (err, _stdout, stderr) => {
+    if (err) {
+      const tail = String(stderr || "").trim().split("\n").slice(-3).join(" | ");
+      reject(new Error(`${err.message.split("\n")[0]}${tail ? ` \u2014 ${tail.slice(0, 300)}` : ""}`));
+    } else resolve6();
+  });
+});
+function ptyLoadsIn(dir, execPath = process.execPath) {
+  try {
+    execFileSync4(execPath, ["-e", "const m=require(process.argv[1]);if(typeof m.spawn!=='function')process.exit(3)", join6(dir, "node_modules", "node-pty")], {
+      timeout: 3e4,
+      windowsHide: true,
+      shell: false,
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installVersion(target, deps) {
+  const execPath = deps.execPath ?? process.execPath;
+  const verifyCli = deps.verifyCli ?? ((p, v) => cliReportsVersion(p, v, execPath));
+  const dir = versionDir(target, deps.home);
+  const cliPath = versionCliPath(target, deps.home);
+  const oldPtyOk = deps.oldPtyOk ?? (() => loadPty() !== null);
+  const newPtyOk = deps.newPtyOk ?? ((d) => ptyLoadsIn(d, execPath));
+  const verified = () => installedPackageVersion(dir) === target && existsSync6(cliPath) && verifyCli(cliPath, target) && (!oldPtyOk() || newPtyOk(dir));
+  if (verified()) {
+    deps.log(`${target} \u5DF2\u5728\u672C\u673A\u88C5\u597D\uFF0C\u76F4\u63A5\u7528`);
+    return cliPath;
+  }
+  const platform = deps.platform ?? process.platform;
+  const npmCli = npmCliPath(execPath, platform);
+  if (!npmCli) throw new Error(`\u627E\u4E0D\u5230 node \u81EA\u5E26\u7684 npm\uFF08${npmCliCandidates(execPath, platform).join(" / ")}\uFF09`);
+  const exec = deps.exec ?? defaultExec;
+  const errors = [];
+  for (const registry of REGISTRIES) {
+    rmSync3(dir, { recursive: true, force: true });
+    mkdirSync5(dir, { recursive: true });
+    deps.log(`\u5B89\u88C5 ${PACKAGE_NAME}@${target}\uFF08\u6E90 ${registry}\uFF09`);
+    try {
+      await exec(execPath, npmInstallArgs(npmCli, dir, target, registry), {
+        timeout: INSTALL_TIMEOUT_MS,
+        shell: false,
+        windowsHide: true,
+        env: { ...process.env, npm_config_update_notifier: "false", npm_config_fund: "false" }
+      });
+    } catch (e) {
+      errors.push(`${registry} ${e.message}`);
+      deps.log(`\u4ECE ${registry} \u5B89\u88C5\u5931\u8D25\uFF1A${e.message}`);
+      continue;
     }
-    return { ok: true, message: "" };
-  } catch (e) {
-    return { ok: false, message: `\u53D6\u6D88\u5F00\u673A\u81EA\u542F\u65F6\u51FA\u9519\uFF08${e.message}\uFF09\uFF0C\u53EF\u80FD\u9700\u8981\u624B\u52A8\u6E05\u7406` };
+    const got = installedPackageVersion(dir);
+    if (got !== target) {
+      errors.push(`${registry} \u88C5\u51FA\u6765\u7684\u7248\u672C\u662F ${got ?? "(\u65E0)"}`);
+      continue;
+    }
+    if (!verifyCli(cliPath, target)) {
+      errors.push(`${registry} \u88C5\u597D\u7684 cli.js --version \u4E0D\u662F ${target}`);
+      continue;
+    }
+    if (oldPtyOk() && !newPtyOk(dir)) {
+      errors.push(`${registry} \u88C5\u597D\u7684\u7248\u672C\u52A0\u8F7D\u4E0D\u4E86 node-pty`);
+      continue;
+    }
+    return cliPath;
   }
+  rmSync3(dir, { recursive: true, force: true });
+  throw new Error(errors.join("\uFF1B"));
 }
-function pidFilePath() {
-  return join2(deskbuddyHome(), "daemon.pid");
+var FROM_VERSION_ENV = "DESKBUDDY_UPDATE_FROM_VERSION";
+var FROM_CLI_ENV = "DESKBUDDY_UPDATE_FROM_CLI";
+function switchFromEnv(env = process.env) {
+  const version = env[FROM_VERSION_ENV] ?? "";
+  const cliPath = env[FROM_CLI_ENV] ?? "";
+  return isValidVersion(version) && cliPath ? { version, cliPath } : null;
+}
+function spawnSwitch(cliPath, logFile, from, onExit, execPath = process.execPath) {
+  let fd = "ignore";
+  try {
+    mkdirSync5(dirname5(logFile), { recursive: true });
+    fd = openSync(logFile, "a");
+  } catch {
+    fd = "ignore";
+  }
+  const child = spawn2(execPath, [cliPath, "update", "--auto"], {
+    detached: true,
+    stdio: ["ignore", fd, fd],
+    windowsHide: true,
+    shell: false,
+    env: { ...process.env, [FROM_VERSION_ENV]: from.version, [FROM_CLI_ENV]: from.cliPath }
+  });
+  child.on("exit", (code) => onExit?.(code));
+  child.on("error", () => onExit?.(null));
+  child.unref();
+  if (typeof fd === "number") closeSync(fd);
 }
+var AutoUpdater = class {
+  #d;
+  #running = false;
+  #stopped = false;
+  #switched = null;
+  #first = null;
+  #timer = null;
+  constructor(deps) {
+    this.#d = deps;
+  }
+  start() {
+    this.#first = setTimeout(() => void this.check(), this.#d.firstCheckMs ?? FIRST_CHECK_MS);
+    this.#first.unref?.();
+    this.#timer = setInterval(() => void this.check(), this.#d.intervalMs ?? CHECK_INTERVAL_MS);
+    this.#timer.unref?.();
+  }
+  stop() {
+    this.#stopped = true;
+    if (this.#first) clearTimeout(this.#first);
+    if (this.#timer) clearInterval(this.#timer);
+  }
+  #now() {
+    return this.#d.now ? this.#d.now() : Date.now();
+  }
+  /** 查一次并在需要时走完整个升级。正在进行中的一轮没结束就跳过。返回这一轮的结局（给测试和日志） */
+  async check() {
+    if (this.#switched) {
+      if (this.#now() - this.#switched.at < (this.#d.switchGraceMs ?? SWITCH_GRACE_MS)) return "busy";
+      this.#d.log(`\u4EA4\u7ED9 ${this.#switched.target} \u5207\u6362\u4E4B\u540E\u5B88\u62A4\u8FDB\u7A0B\u4E00\u76F4\u6CA1\u88AB\u91CD\u542F\uFF0C\u89C6\u4E3A\u5207\u6362\u5931\u8D25`);
+      (this.#d.recordFailure ?? ((t, n) => recordAttemptFailure(t, n)))(this.#switched.target, this.#now());
+      this.#switched = null;
+      this.#d.endDrain?.();
+    }
+    if (this.#running) return "busy";
+    this.#running = true;
+    try {
+      return await this.#check();
+    } catch (e) {
+      this.#d.log(`\u81EA\u52A8\u5347\u7EA7\u51FA\u9519\uFF1A${e?.stack ?? String(e)}`);
+      return "failed";
+    } finally {
+      this.#running = false;
+    }
+  }
+  async #check() {
+    const log2 = this.#d.log;
+    let policy;
+    try {
+      policy = await this.#d.fetchPolicy();
+    } catch (e) {
+      log2(`\u7248\u672C\u68C0\u67E5\u5931\u8D25\uFF1A${e.message}`);
+      return "failed";
+    }
+    const decision = decideUpdate(
+      this.#d.currentVersion,
+      policy,
+      this.#d.config(),
+      (this.#d.failed ?? (() => readFailed()))(),
+      this.#now()
+    );
+    log2(`\u7248\u672C\u68C0\u67E5\uFF1A${decision.action === "update" ? "\u5347\u7EA7" : "\u4E0D\u5347\u7EA7"} \u2014\u2014 ${decision.reason}`);
+    if (decision.action !== "update") return "none";
+    const target = decision.target;
+    let cliPath;
+    try {
+      cliPath = await this.#d.install(target);
+    } catch (e) {
+      log2(`\u5B89\u88C5 ${target} \u5931\u8D25\uFF1A${e.message}\uFF1B6 \u5C0F\u65F6\u5185\u4E0D\u518D\u91CD\u8BD5\u8FD9\u4E00\u7248`);
+      (this.#d.recordFailure ?? ((t, n) => recordAttemptFailure(t, n)))(target, this.#now());
+      return "failed";
+    }
+    log2(`${target} \u5DF2\u88C5\u597D\u5E76\u6821\u9A8C\u901A\u8FC7\uFF0C\u7B49\u5B88\u62A4\u8FDB\u7A0B\u7A7A\u95F2\u540E\u5207\u6362`);
+    const sleep2 = this.#d.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms).unref?.()));
+    const deadline = this.#now() + (this.#d.idleMaxWaitMs ?? IDLE_MAX_WAIT_MS);
+    let lastWhy = "";
+    for (; ; ) {
+      if (this.#stopped) return "stopped";
+      const st = this.#d.idle();
+      if (st.idle) break;
+      if (st.why !== lastWhy) {
+        log2(`\u7B49\u5F85\u7A7A\u95F2\uFF1A${st.why}`);
+        lastWhy = st.why;
+      }
+      if (this.#now() >= deadline) {
+        log2(`\u7B49\u4E86 24 \u5C0F\u65F6\u4ECD\u4E0D\u7A7A\u95F2\uFF0C\u653E\u5F03\u8FD9\u4E00\u8F6E\uFF0C\u4E0B\u6B21\u68C0\u67E5\u518D\u5224\u5B9A`);
+        return "timeout";
+      }
+      await sleep2(this.#d.idlePollMs ?? IDLE_POLL_MS);
+    }
+    if (this.#stopped) return "stopped";
+    this.#d.beginDrain?.();
+    log2(`\u5B88\u62A4\u8FDB\u7A0B\u7A7A\u95F2\uFF0C\u7528 ${target} \u6267\u884C update --auto \u5B8C\u6210\u5207\u6362\uFF08\u5B88\u62A4\u8FDB\u7A0B\u4F1A\u88AB\u91CD\u542F\uFF09`);
+    const mine = { target, at: this.#now() };
+    this.#switched = mine;
+    const onExit = (code) => {
+      const t = setTimeout(() => {
+        if (this.#switched !== mine || this.#stopped) return;
+        this.#switched = null;
+        this.#d.endDrain?.();
+        log2(`\u5207\u6362\u5B50\u8FDB\u7A0B\u5DF2\u9000\u51FA\uFF08\u9000\u51FA\u7801 ${code ?? "\u65E0"}\uFF09\u800C\u5B88\u62A4\u8FDB\u7A0B\u4ECD\u5728\u8FD0\u884C\uFF0C\u89C6\u4E3A\u5207\u6362\u5230 ${target} \u5931\u8D25\uFF0C\u6062\u590D\u63A5\u6307\u4EE4`);
+        (this.#d.recordFailure ?? ((t2, n) => recordAttemptFailure(t2, n)))(target, this.#now());
+      }, this.#d.switchExitGraceMs ?? SWITCH_EXIT_GRACE_MS);
+      t.unref?.();
+    };
+    try {
+      this.#d.switchTo(cliPath, target, onExit);
+    } catch (e) {
+      this.#switched = null;
+      this.#d.endDrain?.();
+      log2(`\u5207\u6362\u5230 ${target} \u5931\u8D25\uFF1A${e.message}`);
+      (this.#d.recordFailure ?? ((t, n) => recordAttemptFailure(t, n)))(target, this.#now());
+      return "failed";
+    }
+    return "switched";
+  }
+};
 
 // src/daemon/index.ts
 import { randomBytes as randomBytes7 } from "crypto";
-import { existsSync as existsSync10 } from "fs";
-import { basename as basename6 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { basename as basename7 } from "path";
 import WebSocket2 from "ws";
 
 // src/adapters/ocPlugin.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync6, renameSync as renameSync4, unlinkSync, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname6, join as join7 } from "path";
 import { pathToFileURL } from "url";
 var OC_MARKER = "// deskbuddy:opencode-plugin";
 function ocPluginSource(pluginModule, nodePath, platform = process.platform) {
@@ -427,26 +1358,26 @@ function ocPluginSource(pluginModule, nodePath, platform = process.platform) {
   ].join("\n");
 }
 function ocPluginModule(hookPath) {
-  return join3(dirname2(hookPath), "opencode.mjs");
+  return join7(dirname6(hookPath), "opencode.mjs");
 }
 function installOcPlugin(pluginPath, hookPath, nodePath) {
-  if (existsSync3(pluginPath) && !readFileSync3(pluginPath, "utf8").includes(OC_MARKER)) {
+  if (existsSync7(pluginPath) && !readFileSync6(pluginPath, "utf8").includes(OC_MARKER)) {
     throw new Error(`${pluginPath} \u5DF2\u5B58\u5728\u4E14\u4E0D\u662F DeskBuddy \u751F\u6210\u7684\uFF0C\u8BF7\u5148\u632A\u8D70\u518D\u91CD\u8BD5`);
   }
-  mkdirSync3(dirname2(pluginPath), { recursive: true });
+  mkdirSync6(dirname6(pluginPath), { recursive: true });
   const tmp = pluginPath + ".deskbuddy.tmp";
-  writeFileSync3(tmp, ocPluginSource(ocPluginModule(hookPath), nodePath), "utf8");
-  renameSync2(tmp, pluginPath);
+  writeFileSync5(tmp, ocPluginSource(ocPluginModule(hookPath), nodePath), "utf8");
+  renameSync4(tmp, pluginPath);
 }
 function uninstallOcPlugin(pluginPath) {
   try {
-    if (readFileSync3(pluginPath, "utf8").includes(OC_MARKER)) unlinkSync(pluginPath);
+    if (readFileSync6(pluginPath, "utf8").includes(OC_MARKER)) unlinkSync(pluginPath);
   } catch {
   }
 }
 function isOcPluginInstalled(pluginPath) {
   try {
-    return readFileSync3(pluginPath, "utf8").includes(OC_MARKER);
+    return readFileSync6(pluginPath, "utf8").includes(OC_MARKER);
   } catch {
     return false;
   }
@@ -454,16 +1385,16 @@ function isOcPluginInstalled(pluginPath) {
 var OC_NOTICE = "   \u5DF2\u5F00\u7740\u7684 opencode \u7A97\u53E3\u91CD\u5F00\u540E\u751F\u6548";
 
 // src/core/state.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync5, renameSync as renameSync4, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync8, readdirSync as readdirSync3, readFileSync as readFileSync8, renameSync as renameSync6, rmSync as rmSync5, writeFileSync as writeFileSync7 } from "fs";
+import { join as join9 } from "path";
 
 // src/core/process.ts
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFileSync as execFileSync5 } from "child_process";
 var WIN = process.platform === "win32";
 function processName(pid) {
   if (WIN) return winProcs()?.find((p) => p.pid === pid)?.name ?? null;
   try {
-    const out = execFileSync2("ps", ["-p", String(pid), "-o", "comm="], {
+    const out = execFileSync5("ps", ["-p", String(pid), "-o", "comm="], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -492,27 +1423,27 @@ function isAlive(pid, expectName) {
 }
 
 // src/core/ended.ts
-import { closeSync, mkdirSync as mkdirSync4, openSync, readdirSync, readFileSync as readFileSync4, readSync, realpathSync, renameSync as renameSync3, rmSync as rmSync2, statSync, writeFileSync as writeFileSync4 } from "fs";
-import { join as join4 } from "path";
+import { closeSync as closeSync2, mkdirSync as mkdirSync7, openSync as openSync2, readdirSync as readdirSync2, readFileSync as readFileSync7, readSync, realpathSync, renameSync as renameSync5, rmSync as rmSync4, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
+import { join as join8 } from "path";
 var ENDED_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 var SID_RE = /^[A-Za-z0-9_-]{1,64}$/;
 function endedDir(home = deskbuddyHome()) {
-  return join4(home, "ended");
+  return join8(home, "ended");
 }
 function writeEnded(s, now = Date.now()) {
   if (!SID_RE.test(s.sessionId)) return;
   try {
     const dir = endedDir();
-    mkdirSync4(dir, { recursive: true, mode: 448 });
+    mkdirSync7(dir, { recursive: true, mode: 448 });
     const rec = { sessionId: s.sessionId, tool: s.tool, cwd: s.cwd ?? "", interactive: s.interactive === true, endedAt: now };
-    const file = join4(dir, `${s.sessionId}.json`);
+    const file = join8(dir, `${s.sessionId}.json`);
     const tmp = `${file}.${process.pid}.tmp`;
-    writeFileSync4(tmp, JSON.stringify(rec), { encoding: "utf8", mode: 384 });
-    renameSync3(tmp, file);
-    for (const n of readdirSync(dir)) {
-      const f = join4(dir, n);
+    writeFileSync6(tmp, JSON.stringify(rec), { encoding: "utf8", mode: 384 });
+    renameSync5(tmp, file);
+    for (const n of readdirSync2(dir)) {
+      const f = join8(dir, n);
       try {
-        if (now - statSync(f).mtimeMs > ENDED_TTL_MS) rmSync2(f, { force: true });
+        if (now - statSync2(f).mtimeMs > ENDED_TTL_MS) rmSync4(f, { force: true });
       } catch {
       }
     }
@@ -522,7 +1453,7 @@ function writeEnded(s, now = Date.now()) {
 function readEnded(sessionId, now = Date.now()) {
   if (!SID_RE.test(sessionId)) return null;
   try {
-    const r = JSON.parse(readFileSync4(join4(endedDir(), `${sessionId}.json`), "utf8"));
+    const r = JSON.parse(readFileSync7(join8(endedDir(), `${sessionId}.json`), "utf8"));
     if (!r || r.sessionId !== sessionId || typeof r.endedAt !== "number" || now - r.endedAt > ENDED_TTL_MS) return null;
     return r;
   } catch {
@@ -537,14 +1468,14 @@ function projectDirName(cwd) {
 function readChunk(file, fromEnd, max) {
   let fd;
   try {
-    const size = statSync(file).size;
+    const size = statSync2(file).size;
     const len = Math.min(size, max);
     const buf = Buffer.alloc(len);
-    fd = openSync(file, "r");
+    fd = openSync2(file, "r");
     readSync(fd, buf, 0, len, fromEnd ? size - len : 0);
     return buf.toString("utf8");
   } finally {
-    if (fd !== void 0) closeSync(fd);
+    if (fd !== void 0) closeSync2(fd);
   }
 }
 function cwdsIn(text) {
@@ -563,14 +1494,14 @@ function claudeTranscriptCwd(sessionId, home = claudeHome()) {
   if (!SID_RE.test(sessionId)) return "";
   let dirs = [];
   try {
-    dirs = readdirSync(join4(home, "projects"));
+    dirs = readdirSync2(join8(home, "projects"));
   } catch {
     return "";
   }
   for (const d of dirs) {
-    const file = join4(home, "projects", d, `${sessionId}.jsonl`);
+    const file = join8(home, "projects", d, `${sessionId}.jsonl`);
     try {
-      statSync(file);
+      statSync2(file);
     } catch {
       continue;
     }
@@ -606,320 +1537,89 @@ function resolveEndedCwd(sessionId, tool, d) {
 }
 function isDirSync(p) {
   try {
-    return statSync(p).isDirectory();
+    return statSync2(p).isDirectory();
   } catch {
     return false;
-  }
-}
-
-// src/core/state.ts
-function stateDir() {
-  return join5(deskbuddyHome(), "state");
-}
-function statePath(sessionId) {
-  const safe = sessionId.replace(/[^A-Za-z0-9_-]/g, "");
-  return join5(stateDir(), `${safe || "unknown"}.json`);
-}
-function readState(sessionId) {
-  try {
-    return JSON.parse(readFileSync5(statePath(sessionId), "utf8"));
-  } catch {
-    return null;
-  }
-}
-function retireState(s, now = Date.now()) {
-  writeEnded(s, now);
-  removeState(s.sessionId);
-}
-function removeState(sessionId) {
-  try {
-    rmSync3(statePath(sessionId), { force: true });
-  } catch {
-  }
-}
-function readAliveStates(tool) {
-  if (!existsSync4(stateDir())) return [];
-  const alive = [];
-  for (const file of readdirSync2(stateDir())) {
-    if (!file.endsWith(".json")) continue;
-    let s;
-    try {
-      s = JSON.parse(readFileSync5(join5(stateDir(), file), "utf8"));
-    } catch {
-      rmSync3(join5(stateDir(), file), { force: true });
-      continue;
-    }
-    if (s.tool !== tool) continue;
-    if (s.pid && !isAlive(s.pid, s.pidName)) {
-      retireState(s);
-      continue;
-    }
-    alive.push(s);
-  }
-  return alive;
-}
-function noticeDir() {
-  return join5(deskbuddyHome(), "notice");
-}
-function writeNotice(sessionId, text, now = Date.now()) {
-  try {
-    const safe = sessionId.replace(/[^A-Za-z0-9_-]/g, "");
-    if (!safe) return;
-    mkdirSync5(noticeDir(), { recursive: true });
-    const file = join5(noticeDir(), `${safe}.json`);
-    writeFileSync5(file + ".tmp", JSON.stringify({ text, at: now }), "utf8");
-    renameSync4(file + ".tmp", file);
-  } catch {
-  }
-}
-var NOTICE_TTL_MS = 60 * 60 * 1e3;
-var ALIAS_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
-function resolveAlias(sessionId, now = Date.now()) {
-  let map = {};
-  try {
-    map = JSON.parse(readFileSync5(join5(deskbuddyHome(), "alias.json"), "utf8")) || {};
-  } catch {
-    return sessionId;
-  }
-  let cur = sessionId;
-  for (let i = 0; i < 5; i++) {
-    const a = map[cur];
-    if (!a || typeof a.to !== "string" || !a.to || typeof a.at !== "number" || now - a.at >= ALIAS_TTL_MS) break;
-    cur = a.to;
-  }
-  return cur;
-}
-
-// src/core/api.ts
-import { execFileSync as execFileSync3 } from "child_process";
-import { createHash, randomBytes, randomUUID as randomUUID2 } from "crypto";
-import { readFileSync as readFileSync7 } from "fs";
-import { release } from "os";
-
-// src/core/hookFile.ts
-import { copyFileSync, existsSync as existsSync5, mkdirSync as mkdirSync6, readFileSync as readFileSync6, renameSync as renameSync5, writeFileSync as writeFileSync6 } from "fs";
-import { createRequire } from "module";
-import { dirname as dirname3, join as join6 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var here = dirname3(fileURLToPath2(import.meta.url));
-function packagedHookPath() {
-  const candidates = [
-    join6(here, "hook.cjs"),
-    // dist/cli.js 旁边（发布形态）
-    join6(here, "..", "hook", "hook.cjs"),
-    // dist/../hook/
-    join6(here, "..", "..", "hook", "hook.cjs")
-    // src/core/../../hook/（开发形态）
-  ];
-  for (const c of candidates) {
-    if (existsSync5(c)) return c;
-  }
-  throw new Error("\u627E\u4E0D\u5230\u5305\u5185\u7684 hook.cjs\uFF0C\u5B89\u88C5\u5305\u53EF\u80FD\u4E0D\u5B8C\u6574\uFF0C\u8BF7\u91CD\u65B0\u5B89\u88C5 deskbuddy");
-}
-function packageVersion() {
-  const require2 = createRequire(import.meta.url);
-  for (const c of ["../package.json", "../../package.json", "../../../package.json"]) {
-    try {
-      const pkg = require2(c);
-      if (pkg?.name === "deskbuddy" && pkg.version) return pkg.version;
-    } catch {
-    }
-  }
-  return "0.0.0-dev";
-}
-function hookVersionPath(target = installedHookPath()) {
-  return join6(dirname3(target), "hook-version");
-}
-function installedHookVersion(target = installedHookPath()) {
-  try {
-    return readFileSync6(hookVersionPath(target), "utf8").trim() || null;
-  } catch {
-    return null;
-  }
-}
-function atomicCopy(from, to) {
-  const tmp = `${to}.${process.pid}.tmp`;
-  copyFileSync(from, tmp);
-  renameSync5(tmp, to);
-}
-function syncHookFile(opts = {}) {
-  const target = opts.target ?? installedHookPath();
-  const version = opts.version ?? packageVersion();
-  const SIBLINGS = ["gate.cjs", "opencode.mjs", "wake.cjs"];
-  const siblingMissing = () => SIBLINGS.some((name) => {
-    if (existsSync5(join6(dirname3(target), name))) return false;
-    try {
-      return existsSync5(join6(dirname3(opts.source ?? packagedHookPath()), name));
-    } catch {
-      return false;
-    }
-  });
-  if (installedHookVersion(target) === version && existsSync5(target) && !siblingMissing()) return false;
-  const source = opts.source ?? packagedHookPath();
-  mkdirSync6(dirname3(target), { recursive: true });
-  atomicCopy(source, target);
-  for (const name of SIBLINGS) {
-    const from = join6(dirname3(source), name);
-    if (existsSync5(from)) atomicCopy(from, join6(dirname3(target), name));
-  }
-  writeFileSync6(hookVersionPath(target), version, "utf8");
-  return true;
-}
-
-// src/core/api.ts
-var SERVICES = {
-  authCode: "com.shifeng.api.service.api.v2.deskbuddy.deskbuddyauthcodeapi",
-  authToken: "com.shifeng.api.service.api.v2.deskbuddy.deskbuddyauthtokenapi",
-  sessionReport: "com.shifeng.api.service.api.v2.deskbuddy.deskbuddysessionreportapi",
-  toolRegistry: "com.shifeng.api.service.api.v2.deskbuddy.deskbuddytoolregistryapi",
-  /** App 扫码确认时调的，CLI 用不到，列在这里只为对照 */
-  confirmAuth: "com.shifeng.api.service.api.v2.deskbuddy.deskbuddyconfirmauthapi"
-};
-var DIRS_SERVICE = "com.shifeng.api.service.api.v2.deskbuddy.deskbuddyclientdirsreportapi";
-var INSTALL_REDEEM_SERVICE = "com.shifeng.api.service.api.v2.deskbuddy.deskbuddyinstallredeemapi";
-var CMD_RESULT_SERVICE = "com.shifeng.api.service.api.v2.deskbuddy.deskbuddycommandresultapi";
-var APPROVAL_SERVICES = {
-  create: "com.shifeng.api.service.api.v2.deskbuddy.deskbuddyapprovalcreateapi",
-  cancel: "com.shifeng.api.service.api.v2.deskbuddy.deskbuddyapprovalcancelapi",
-  sync: "com.shifeng.api.service.api.v2.deskbuddy.deskbuddyapprovalsyncapi"
-};
-var APP_ID = process.env.DESKBUDDY_APPID || "deskbuddy-cli";
-var APP_SECRET = process.env.DESKBUDDY_APPSECRET || "3aeb6e0afc144e188dd3ede5c7865643";
-var GATEWAY_VERSION = "1.0";
-var DEFAULT_TIMEOUT_MS = 1e4;
-function sign(p) {
-  const source = [p.appId, p.appSecret, p.timestamp, p.deviceId, p.deviceName, p.nonce, p.body].join("_");
-  return createHash("md5").update(source, "utf8").digest("hex");
-}
-function buildGatewayBody(service, data, requestId) {
-  return JSON.stringify({
-    service,
-    version: GATEWAY_VERSION,
-    requestId: requestId || randomUUID2(),
-    base: { encode: "false" },
-    // data 是业务 JSON 序列化后的字符串
-    data: JSON.stringify(data ?? {})
-  });
-}
-function buildHeaders(cfg, body, opts = {}) {
-  const timestamp = opts.timestamp || String(Date.now());
-  const nonce = opts.nonce || randomBytes(8).toString("hex");
-  return {
-    "Content-Type": "application/json;charset=UTF-8",
-    "Content-Length": String(Buffer.byteLength(body)),
-    "ShiFeng-AppId": APP_ID,
-    "ShiFeng-Timestamp": timestamp,
-    "ShiFeng-Device-ID": cfg.clientId,
-    "ShiFeng-Device-Name": cfg.hostName,
-    "ShiFeng-Nonce": nonce,
-    "ShiFeng-Signature": sign({
-      appId: APP_ID,
-      appSecret: APP_SECRET,
-      timestamp,
-      deviceId: cfg.clientId,
-      deviceName: cfg.hostName,
-      nonce,
-      body
-    })
-    // 没有 ShiFeng-Token：鉴权靠 clientId ↔ userId 绑定关系，CLI 不持有用户凭证
-  };
-}
-function isSuccessCode(code) {
-  return code === "0000";
-}
-var ApiError = class extends Error {
-  constructor(code, message) {
-    super(`${code}: ${message}`);
-    this.code = code;
-    this.name = "ApiError";
-  }
-  code;
-};
-function humanOs(platform = process.platform) {
-  const known = {
-    darwin: "macOS",
-    win32: "Windows",
-    linux: "Linux"
-  };
-  return known[platform] ?? platform;
+  }
 }
-var defaultOsVersionDeps = {
-  runSwVers: () => execFileSync3("sw_vers", ["-productVersion"], {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "ignore"],
-    timeout: 2e3
-  }),
-  readOsRelease: () => readFileSync7("/etc/os-release", "utf8"),
-  kernelRelease: () => release()
-};
-function productOsVersion(platform = process.platform, deps = defaultOsVersionDeps) {
+
+// src/core/state.ts
+function stateDir() {
+  return join9(deskbuddyHome(), "state");
+}
+function statePath(sessionId) {
+  const safe = sessionId.replace(/[^A-Za-z0-9_-]/g, "");
+  return join9(stateDir(), `${safe || "unknown"}.json`);
+}
+function readState(sessionId) {
   try {
-    if (platform === "darwin") {
-      const v = deps.runSwVers().trim();
-      if (v) return v;
-    } else if (platform === "linux") {
-      const m = /^PRETTY_NAME=(.*)$/m.exec(deps.readOsRelease());
-      if (m) {
-        const v = m[1].trim().replace(/^(["'])(.*)\1$/, "$2").trim();
-        if (v) return v;
-      }
-    }
+    return JSON.parse(readFileSync8(statePath(sessionId), "utf8"));
   } catch {
+    return null;
   }
+}
+function retireState(s, now = Date.now()) {
+  writeEnded(s, now);
+  removeState(s.sessionId);
+}
+function removeState(sessionId) {
   try {
-    return deps.kernelRelease();
+    rmSync5(statePath(sessionId), { force: true });
   } catch {
-    return "";
   }
 }
-var machineInfoCache = null;
-function machineInfo() {
-  if (!machineInfoCache) {
-    machineInfoCache = {
-      os: humanOs(),
-      osVersion: productOsVersion(),
-      arch: process.arch,
-      cliVersion: packageVersion()
-    };
+function readAliveStates(tool) {
+  if (!existsSync8(stateDir())) return [];
+  const alive = [];
+  for (const file of readdirSync3(stateDir())) {
+    if (!file.endsWith(".json")) continue;
+    let s;
+    try {
+      s = JSON.parse(readFileSync8(join9(stateDir(), file), "utf8"));
+    } catch {
+      rmSync5(join9(stateDir(), file), { force: true });
+      continue;
+    }
+    if (s.tool !== tool) continue;
+    if (s.pid && !isAlive(s.pid, s.pidName)) {
+      retireState(s);
+      continue;
+    }
+    alive.push(s);
   }
-  return machineInfoCache;
+  return alive;
 }
-async function call(service, data, timeoutMs = DEFAULT_TIMEOUT_MS) {
-  const cfg = loadConfig();
-  const body = buildGatewayBody(service, data);
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
+function noticeDir() {
+  return join9(deskbuddyHome(), "notice");
+}
+function writeNotice(sessionId, text, now = Date.now()) {
   try {
-    const res = await fetch(`${cfg.apiBase}/gateway`, {
-      method: "POST",
-      headers: buildHeaders(cfg, body),
-      body,
-      // 与签名用的是同一个字符串
-      signal: controller.signal
-    });
-    const json = await res.json();
-    if (!isSuccessCode(json?.code)) {
-      throw new ApiError(String(json?.code), json?.message ?? "");
-    }
-    return json?.data;
-  } finally {
-    clearTimeout(timer);
+    const safe = sessionId.replace(/[^A-Za-z0-9_-]/g, "");
+    if (!safe) return;
+    mkdirSync8(noticeDir(), { recursive: true });
+    const file = join9(noticeDir(), `${safe}.json`);
+    writeFileSync7(file + ".tmp", JSON.stringify({ text, at: now }), "utf8");
+    renameSync6(file + ".tmp", file);
+  } catch {
   }
 }
-var api = {
-  authCode: (clientId, hostName) => call(SERVICES.authCode, { clientId, hostName, ...machineInfo() }),
-  authToken: (authCode) => call(SERVICES.authToken, { authCode }),
-  toolRegistry: () => call(SERVICES.toolRegistry, {}),
-  // 🔴 2 秒超时：这条调用发生在 hook 链路上，慢一点就是拖慢用户的 agent
-  report: (payload) => call(SERVICES.sessionReport, payload, 2e3),
-  approvalCreate: (payload) => call(APPROVAL_SERVICES.create, payload),
-  approvalCancel: (approvalId, reason) => call(APPROVAL_SERVICES.cancel, { approvalId, reason }),
-  approvalSync: (approvalIds) => call(APPROVAL_SERVICES.sync, { approvalIds }),
-  dirsReport: (payload) => call(DIRS_SERVICE, payload),
-  installRedeem: (installCode, clientId, hostName) => call(INSTALL_REDEEM_SERVICE, { installCode, clientId, hostName, ...machineInfo() }),
-  // 2 秒超时、失败不重试（spec §4.1）：回报丢了只是设备少一句提示，任务状态仍由会话快照负责
-  commandResult: (payload) => call(CMD_RESULT_SERVICE, payload, 2e3)
-};
+var NOTICE_TTL_MS = 60 * 60 * 1e3;
+var ALIAS_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+function resolveAlias(sessionId, now = Date.now()) {
+  let map = {};
+  try {
+    map = JSON.parse(readFileSync8(join9(deskbuddyHome(), "alias.json"), "utf8")) || {};
+  } catch {
+    return sessionId;
+  }
+  let cur = sessionId;
+  for (let i = 0; i < 5; i++) {
+    const a = map[cur];
+    if (!a || typeof a.to !== "string" || !a.to || typeof a.at !== "number" || now - a.at >= ALIAS_TTL_MS) break;
+    cur = a.to;
+  }
+  return cur;
+}
 
 // src/core/report.ts
 async function postReport(payload) {
@@ -930,7 +1630,7 @@ async function postReport(payload) {
 }
 
 // src/core/snapshot.ts
-import { basename as basename2 } from "path";
+import { basename as basename3 } from "path";
 var KEEPALIVE_MS = 2 * 60 * 1e3;
 var MAX_SESSIONS = 20;
 var CAPS = ["cmd_result", "window_inject", "resume_ended"];
@@ -939,7 +1639,7 @@ function buildSnapshot(states, tool, cfg, nowMs, remote) {
     sessionId: s.sessionId,
     title: s.title,
     // 隐私：只带目录名，不带全路径——全路径会暴露公司目录结构与用户名
-    project: basename2(s.project || ""),
+    project: basename3(s.project || ""),
     state: s.state,
     startedAt: s.startedAt,
     updatedAt: s.updatedAt,
@@ -951,15 +1651,15 @@ function buildSnapshot(states, tool, cfg, nowMs, remote) {
 
 // src/core/dirs.ts
 import { createHmac, randomBytes as randomBytes2 } from "crypto";
-import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
-import { basename as basename3, join as join7 } from "path";
+import { chmodSync as chmodSync2, existsSync as existsSync9, mkdirSync as mkdirSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "fs";
+import { basename as basename4, join as join10 } from "path";
 
 // src/core/dirFilter.ts
 import { homedir as homedir3, tmpdir } from "os";
-import { posix, win32 } from "path";
+import { posix as posix2, win32 as win322 } from "path";
 function norm(p, win) {
-  if (win) return win32.resolve(p).replace(/[\\/]+$/, "").toLowerCase();
-  return posix.resolve(p).replace(/\/+$/, "");
+  if (win) return win322.resolve(p).replace(/[\\/]+$/, "").toLowerCase();
+  return posix2.resolve(p).replace(/\/+$/, "");
 }
 function isUnder(p, base, win) {
   return p === base || p.startsWith(base + (win ? "\\" : "/"));
@@ -967,7 +1667,7 @@ function isUnder(p, base, win) {
 function isAutoWorkspace(p, opts = {}) {
   if (!p) return false;
   const win = (opts.platform ?? process.platform) === "win32";
-  const P = win ? win32 : posix;
+  const P = win ? win322 : posix2;
   const home = norm(opts.home ?? homedir3(), win);
   const full = norm(p, win);
   const name = P.basename(full);
@@ -978,7 +1678,7 @@ function isAutoWorkspace(p, opts = {}) {
 function isReportableDir(p, opts = {}) {
   if (!p) return false;
   const win = (opts.platform ?? process.platform) === "win32";
-  const P = win ? win32 : posix;
+  const P = win ? win322 : posix2;
   const full = norm(p, win);
   if (full === norm(P.parse(P.resolve(p)).root, win)) return false;
   if (full === norm(opts.home ?? homedir3(), win)) return false;
@@ -991,20 +1691,20 @@ function isReportableDir(p, opts = {}) {
 // src/core/dirs.ts
 var DIRS_REPORT_MAX = 10;
 function dirsPath() {
-  return join7(deskbuddyHome(), "dirs.json");
+  return join10(deskbuddyHome(), "dirs.json");
 }
 function dirSecret() {
-  const file = join7(deskbuddyHome(), "dir-secret");
+  const file = join10(deskbuddyHome(), "dir-secret");
   try {
-    const s2 = readFileSync8(file, "utf8").trim();
+    const s2 = readFileSync9(file, "utf8").trim();
     if (s2) return s2;
   } catch {
   }
   const s = randomBytes2(32).toString("hex");
   try {
-    mkdirSync7(deskbuddyHome(), { recursive: true });
-    writeFileSync7(file, s, { encoding: "utf8", mode: 384 });
-    chmodSync(file, 384);
+    mkdirSync9(deskbuddyHome(), { recursive: true });
+    writeFileSync8(file, s, { encoding: "utf8", mode: 384 });
+    chmodSync2(file, 384);
   } catch {
   }
   return s;
@@ -1014,7 +1714,7 @@ function dirRef(path) {
 }
 function readMap() {
   try {
-    const m = JSON.parse(readFileSync8(dirsPath(), "utf8"));
+    const m = JSON.parse(readFileSync9(dirsPath(), "utf8"));
     const out = {};
     for (const [k, v] of Object.entries(m ?? {})) if (typeof v === "number") out[k] = v;
     return out;
@@ -1022,17 +1722,17 @@ function readMap() {
     return {};
   }
 }
-function recentDirs(limit = DIRS_REPORT_MAX, exists = existsSync6, reportable = (p) => isReportableDir(p)) {
+function recentDirs(limit = DIRS_REPORT_MAX, exists = existsSync9, reportable = (p) => isReportableDir(p)) {
   const list = Object.entries(readMap()).filter(([p]) => p && reportable(p) && exists(p)).sort((a, b) => b[1] - a[1]).slice(0, limit);
   const counts = /* @__PURE__ */ new Map();
-  for (const [p] of list) counts.set(basename3(p), (counts.get(basename3(p)) ?? 0) + 1);
+  for (const [p] of list) counts.set(basename4(p), (counts.get(basename4(p)) ?? 0) + 1);
   return list.map(([p, at]) => {
     const ref = dirRef(p);
-    const name = basename3(p) || "/";
-    return { path: p, ref, name: (counts.get(basename3(p)) ?? 0) > 1 ? `${name} \xB7 ${ref.slice(0, 4)}` : name, lastUsedAt: at };
+    const name = basename4(p) || "/";
+    return { path: p, ref, name: (counts.get(basename4(p)) ?? 0) > 1 ? `${name} \xB7 ${ref.slice(0, 4)}` : name, lastUsedAt: at };
   });
 }
-function dirOf(ref, exists = existsSync6) {
+function dirOf(ref, exists = existsSync9) {
   for (const p of Object.keys(readMap())) if (dirRef(p) === ref && exists(p)) return p;
   return "";
 }
@@ -1110,12 +1810,12 @@ function isExpired(cmd, now = Date.now()) {
 }
 
 // src/daemon/executor.ts
-import { execFile as execFile2, execFileSync as execFileSync5 } from "child_process";
+import { execFile as execFile3, execFileSync as execFileSync7 } from "child_process";
 import { homedir as homedir5 } from "os";
-import { join as join9 } from "path";
+import { join as join12 } from "path";
 
 // src/daemon/gate/settings.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var GATE_HOOK_TIMEOUT_S = 7 * 24 * 60 * 60;
 function waitModeFor(tool) {
@@ -1142,7 +1842,7 @@ function defaultGateScript() {
     fileURLToPath3(new URL("./gate.cjs", import.meta.url)),
     fileURLToPath3(new URL("../../../hook/gate.cjs", import.meta.url))
   ];
-  return candidates.find((p) => existsSync7(p)) ?? candidates[0];
+  return candidates.find((p) => existsSync10(p)) ?? candidates[0];
 }
 function gateCommand(t, platform = process.platform) {
   if (platform === "win32") return winGateCommand(t);
@@ -1170,24 +1870,24 @@ function codexGateArgs(t) {
 }
 
 // src/daemon/locate.ts
-import { execFileSync as execFileSync4 } from "child_process";
-import { accessSync, constants, existsSync as existsSync8, lstatSync, readFileSync as readFileSync9, statSync as statSync2 } from "fs";
+import { execFileSync as execFileSync6 } from "child_process";
+import { accessSync, constants, existsSync as existsSync11, lstatSync, readFileSync as readFileSync10, statSync as statSync3 } from "fs";
 import { homedir as homedir4 } from "os";
-import { delimiter, dirname as dirname4, join as join8, win32 as win322 } from "path";
+import { delimiter, dirname as dirname7, join as join11, win32 as win323 } from "path";
 var defaultLocateDeps = () => ({
   home: homedir4(),
   path: process.env.PATH ?? "",
   nodePath: process.execPath,
   isExecutable: (p) => {
     try {
-      if (!statSync2(p).isFile()) return false;
+      if (!statSync3(p).isFile()) return false;
       accessSync(p, constants.X_OK);
       return true;
     } catch {
       return false;
     }
   },
-  exists: (p) => existsSync8(p),
+  exists: (p) => existsSync11(p),
   lexists: (p) => {
     try {
       lstatSync(p);
@@ -1201,22 +1901,22 @@ var defaultLocateDeps = () => ({
   localAppData: process.env.LOCALAPPDATA ?? "",
   readText: (p) => {
     try {
-      return readFileSync9(p, "utf8");
+      return readFileSync10(p, "utf8");
     } catch {
       return null;
     }
   },
   // 🔴 daemon 自己也不能找到垫片：远程任务要的是真程序（窗口接管 spec 2026-09-30 §3.1）
-  skipDirs: [join8(deskbuddyHome(), "bin")],
+  skipDirs: [join11(deskbuddyHome(), "bin")],
   winAppHints: (product, exe) => winInstallDirs(product, exe)
 });
 function installDirsFromProcs(procs, exe) {
   const out = [];
   for (const p of procs ?? []) {
     const first = winSplitArgs(p.cmdline)[0] ?? "";
-    if (win322.basename(first).toLowerCase() !== exe.toLowerCase()) continue;
-    const dir = win322.dirname(first);
-    if (win322.isAbsolute(dir) && !out.some((d) => d.toLowerCase() === dir.toLowerCase())) out.push(dir);
+    if (win323.basename(first).toLowerCase() !== exe.toLowerCase()) continue;
+    const dir = win323.dirname(first);
+    if (win323.isAbsolute(dir) && !out.some((d) => d.toLowerCase() === dir.toLowerCase())) out.push(dir);
   }
   return out;
 }
@@ -1224,8 +1924,8 @@ function parseUninstallDirs(out) {
   const dirs = [];
   for (const raw of out.split(/\r?\n/)) {
     let v = raw.trim().replace(/,\s*-?\d+$/, "").replace(/^"|"$/g, "").trim();
-    if (!v || !win322.isAbsolute(v)) continue;
-    if (/\.exe$/i.test(v)) v = win322.dirname(v);
+    if (!v || !win323.isAbsolute(v)) continue;
+    if (/\.exe$/i.test(v)) v = win323.dirname(v);
     v = v.replace(/[\\/]+$/, "");
     if (!dirs.some((d) => d.toLowerCase() === v.toLowerCase())) dirs.push(v);
   }
@@ -1237,7 +1937,7 @@ function winInstallDirs(product, exe) {
   try {
     const name = product.replace(/'/g, "''");
     const script = `[Console]::OutputEncoding=[Text.Encoding]::UTF8;Get-ItemProperty 'HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*','HKLM:\\Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*','HKLM:\\Software\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*' -ErrorAction SilentlyContinue | Where-Object { $_.DisplayName -like '${name}*' } | ForEach-Object { $_.InstallLocation; $_.DisplayIcon }`;
-    const out = execFileSync4("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
+    const out = execFileSync6("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       windowsHide: true,
@@ -1253,23 +1953,23 @@ var WIN_EXTS = [".exe", ".cmd", ".bat"];
 function extraBinDirs(home, nodePath = "", win) {
   if (win) {
     return [
-      join8(home, ".local", "bin"),
-      ...win.appData ? [join8(win.appData, "npm")] : [],
-      join8(home, ".bun", "bin"),
-      ...win.localAppData ? [join8(win.localAppData, "Volta", "bin")] : [],
-      join8(home, "scoop", "shims"),
-      ...nodePath ? [dirname4(nodePath)] : []
+      join11(home, ".local", "bin"),
+      ...win.appData ? [join11(win.appData, "npm")] : [],
+      join11(home, ".bun", "bin"),
+      ...win.localAppData ? [join11(win.localAppData, "Volta", "bin")] : [],
+      join11(home, "scoop", "shims"),
+      ...nodePath ? [dirname7(nodePath)] : []
     ];
   }
   return [
-    join8(home, ".local", "bin"),
-    join8(home, ".claude", "local"),
-    join8(home, ".npm-global", "bin"),
-    join8(home, ".bun", "bin"),
-    join8(home, ".volta", "bin"),
+    join11(home, ".local", "bin"),
+    join11(home, ".claude", "local"),
+    join11(home, ".npm-global", "bin"),
+    join11(home, ".bun", "bin"),
+    join11(home, ".volta", "bin"),
     "/opt/homebrew/bin",
     "/usr/local/bin",
-    ...nodePath ? [dirname4(nodePath)] : []
+    ...nodePath ? [dirname7(nodePath)] : []
   ];
 }
 function whichIn(name, d) {
@@ -1280,7 +1980,7 @@ function whichAllIn(name, d) {
   const out = [];
   for (const dir of binDirs(d)) {
     for (const ext of exts) {
-      const p = join8(dir, name + ext);
+      const p = join11(dir, name + ext);
       if (d.isExecutable(p)) out.push(p);
     }
   }
@@ -1288,9 +1988,9 @@ function whichAllIn(name, d) {
 }
 function binDirs(d) {
   const win = isWin(d);
-  const sep2 = win ? ";" : delimiter;
+  const sep3 = win ? ";" : delimiter;
   const all = [
-    ...d.path.split(sep2).filter(Boolean),
+    ...d.path.split(sep3).filter(Boolean),
     ...extraBinDirs(d.home, d.nodePath, win ? { appData: d.appData, localAppData: d.localAppData } : void 0)
   ];
   if (!d.skipDirs || d.skipDirs.length === 0) return all;
@@ -1304,7 +2004,7 @@ function binDirs(d) {
 function parseNpmCmdShim(shimPath, text) {
   const m = text.match(/"%~?dp0%?\\?([^"%]+)"\s+%\*/i);
   if (!m) return null;
-  return join8(dirname4(shimPath), m[1].replace(/^\\/, ""));
+  return join11(dirname7(shimPath), m[1].replace(/^\\/, ""));
 }
 function resolveWinLaunch(file, d) {
   const lower = file.toLowerCase();
@@ -1322,21 +2022,21 @@ function resolveWinLaunch(file, d) {
   return null;
 }
 function appDirs(home) {
-  return ["/Applications", join8(home, "Applications")];
+  return ["/Applications", join11(home, "Applications")];
 }
 function winAppDirs(d, product) {
   return [
-    ...d.localAppData ? [join8(d.localAppData, "Programs", product)] : [],
-    join8("C:\\Program Files", product),
-    join8("C:\\Program Files (x86)", product)
+    ...d.localAppData ? [join11(d.localAppData, "Programs", product)] : [],
+    join11("C:\\Program Files", product),
+    join11("C:\\Program Files (x86)", product)
   ];
 }
 var WORKBUDDY_CLI_IN_WIN_APP = "resources/app.asar.unpacked/cli/bin/codebuddy";
 var QODER_CN_WORKER_IN_WIN_APP = "resources/app.asar.unpacked/node_modules/@qoder-ai/qoder-cn-agent-sdk/dist/_worker/qoder-worker-runtime.obf.mjs";
 function winClaudeExeCandidates(d) {
   return [
-    ...d.home ? [join8(d.home, ".local", "bin", "claude.exe")] : [],
-    ...d.appData ? [join8(d.appData, "npm", "node_modules", "@anthropic-ai", "claude-code", "bin", "claude.exe")] : []
+    ...d.home ? [join11(d.home, ".local", "bin", "claude.exe")] : [],
+    ...d.appData ? [join11(d.appData, "npm", "node_modules", "@anthropic-ai", "claude-code", "bin", "claude.exe")] : []
   ];
 }
 function locateWin(tool, d) {
@@ -1357,7 +2057,7 @@ function locateWin(tool, d) {
       const inApp = (dirs) => {
         for (const dir of dirs) {
           for (const ext of [".exe", ".cmd", ""]) {
-            const p = join8(dir, WORKBUDDY_CLI_IN_WIN_APP + ext);
+            const p = join11(dir, WORKBUDDY_CLI_IN_WIN_APP + ext);
             if (d.exists(p)) {
               const r = resolveWinLaunch(p, d);
               if (r) return r;
@@ -1370,13 +2070,13 @@ function locateWin(tool, d) {
     }
     case "qoder": {
       for (const dir of winAppDirs(d, "Qoder CN")) {
-        const p = join8(dir, QODER_CN_WORKER_IN_WIN_APP);
+        const p = join11(dir, QODER_CN_WORKER_IN_WIN_APP);
         if (d.exists(p)) return { file: d.nodePath, prefixArgs: [p] };
       }
       return plain("qodercli");
     }
     case "opencode": {
-      const p = join8(d.home, ".opencode", "bin", "opencode.exe");
+      const p = join11(d.home, ".opencode", "bin", "opencode.exe");
       if (d.exists(p)) return { file: p, prefixArgs: [] };
       return plain("opencode");
     }
@@ -1399,20 +2099,20 @@ function locate(tool, d = defaultLocateDeps()) {
       return plain("codex");
     case "workbuddy": {
       for (const dir of appDirs(d.home)) {
-        const p = join8(dir, WORKBUDDY_CLI_IN_APP);
+        const p = join11(dir, WORKBUDDY_CLI_IN_APP);
         if (d.isExecutable(p)) return { file: p, prefixArgs: [] };
       }
       return plain("codebuddy");
     }
     case "qoder": {
       for (const dir of appDirs(d.home)) {
-        const p = join8(dir, QODER_CN_WORKER_IN_APP);
+        const p = join11(dir, QODER_CN_WORKER_IN_APP);
         if (d.exists(p)) return { file: d.nodePath, prefixArgs: [p] };
       }
       return plain("qodercli");
     }
     case "opencode": {
-      const p = join8(d.home, ".opencode", "bin", "opencode");
+      const p = join11(d.home, ".opencode", "bin", "opencode");
       if (d.isExecutable(p)) return { file: p, prefixArgs: [] };
       return plain("opencode");
     }
@@ -1429,7 +2129,7 @@ function findWt(d = defaultLocateDeps()) {
   if (!isWin(d)) return null;
   const hit = whichIn("wt", d);
   if (hit) return hit;
-  const alias = d.localAppData ? join8(d.localAppData, "Microsoft", "WindowsApps", "wt.exe") : "";
+  const alias = d.localAppData ? join11(d.localAppData, "Microsoft", "WindowsApps", "wt.exe") : "";
   return alias && (d.exists(alias) || (d.lexists?.(alias) ?? false)) ? alias : null;
 }
 
@@ -1511,7 +2211,7 @@ function buildSpawnPlan(cmd, cwd, gate, home = homedir5()) {
     case "codex":
       return { file, args: codexPlan(cmd, gate), cwd };
     case "workbuddy":
-      return { file, args: workbuddyPlan(cmd, gate), cwd, env: { CODEBUDDY_CONFIG_DIR: join9(home, ".workbuddy") } };
+      return { file, args: workbuddyPlan(cmd, gate), cwd, env: { CODEBUDDY_CONFIG_DIR: join12(home, ".workbuddy") } };
     case "qoder":
       return gate ? { file, args: qoderPlan(cmd, gate), cwd } : null;
     case "opencode":
@@ -1611,8 +2311,8 @@ function startCommand(plan, tool, limitMs = EXEC_TIMEOUT_MS) {
     }, Math.max(0, remaining));
   };
   let timedOut = false;
-  const done = new Promise((resolve5) => {
-    child = execFile2(
+  const done = new Promise((resolve6) => {
+    child = execFile3(
       plan.file,
       plan.args,
       {
@@ -1629,10 +2329,10 @@ function startCommand(plan, tool, limitMs = EXEC_TIMEOUT_MS) {
         const out = String(stdout7 ?? "");
         if (err || timedOut) {
           const msg = timedOut ? `\u6267\u884C\u8D85\u8FC7 ${Math.round(limitMs / 1e3)} \u79D2\u6D3B\u52A8\u65F6\u95F4\uFF0C\u5DF2\u7EC8\u6B62` : err.message;
-          resolve5({ ok: false, sessionId: parseSessionId(tool, out), stdout: out, error: msg });
+          resolve6({ ok: false, sessionId: parseSessionId(tool, out), stdout: out, error: msg });
           return;
         }
-        resolve5({ ok: true, sessionId: parseSessionId(tool, out), stdout: out });
+        resolve6({ ok: true, sessionId: parseSessionId(tool, out), stdout: out });
       }
     );
     child?.stdin?.end();
@@ -1668,7 +2368,7 @@ function killTree(child) {
   if (!child) return;
   if (process.platform === "win32" && child.pid) {
     try {
-      execFileSync5("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+      execFileSync7("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
       return;
     } catch {
     }
@@ -1678,8 +2378,8 @@ function killTree(child) {
 
 // src/daemon/gate/approvals.ts
 import { createHash as createHash2 } from "crypto";
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync10, renameSync as renameSync6, writeFileSync as writeFileSync8 } from "fs";
-import { join as join10 } from "path";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync11, renameSync as renameSync7, writeFileSync as writeFileSync9 } from "fs";
+import { join as join13 } from "path";
 var RETAIN_MS = 7 * 24 * 60 * 60 * 1e3;
 function fingerprint(toolName, toolInput) {
   let input = "";
@@ -1691,7 +2391,7 @@ function fingerprint(toolName, toolInput) {
   return createHash2("sha256").update(toolName).update("\0").update(input).digest("hex");
 }
 function storePath() {
-  return join10(deskbuddyHome(), "approvals.json");
+  return join13(deskbuddyHome(), "approvals.json");
 }
 var ApprovalStore = class _ApprovalStore {
   #records;
@@ -1700,7 +2400,7 @@ var ApprovalStore = class _ApprovalStore {
   }
   static load() {
     try {
-      const raw = JSON.parse(readFileSync10(storePath(), "utf8"));
+      const raw = JSON.parse(readFileSync11(storePath(), "utf8"));
       return new _ApprovalStore(Array.isArray(raw) ? raw : []);
     } catch {
       return new _ApprovalStore();
@@ -1708,10 +2408,10 @@ var ApprovalStore = class _ApprovalStore {
   }
   save() {
     try {
-      mkdirSync8(deskbuddyHome(), { recursive: true });
+      mkdirSync10(deskbuddyHome(), { recursive: true });
       const tmp = storePath() + ".tmp";
-      writeFileSync8(tmp, JSON.stringify(this.#records), { encoding: "utf8", mode: 384 });
-      renameSync6(tmp, storePath());
+      writeFileSync9(tmp, JSON.stringify(this.#records), { encoding: "utf8", mode: 384 });
+      renameSync7(tmp, storePath());
     } catch {
     }
   }
@@ -1751,7 +2451,7 @@ var ApprovalStore = class _ApprovalStore {
 };
 
 // src/daemon/gate/backend.ts
-import { basename as basename4 } from "path";
+import { basename as basename5 } from "path";
 function serverBackend(client = api) {
   return {
     create: (r) => client.approvalCreate({
@@ -1760,7 +2460,7 @@ function serverBackend(client = api) {
       sessionId: r.sessionId,
       kind: r.kind,
       summary: r.summary,
-      cwdName: basename4(r.cwd),
+      cwdName: basename5(r.cwd),
       source: r.mode === "window" ? "window" : "remote",
       ...r.remember ? { remember: r.remember } : {}
     }),
@@ -1792,11 +2492,11 @@ function mapStatus(s) {
 
 // src/daemon/gate/coordinator.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { existsSync as existsSync9, realpathSync as realpathSync2 } from "fs";
-import { basename as basename5, dirname as dirname5, join as join11 } from "path";
+import { existsSync as existsSync12, realpathSync as realpathSync2 } from "fs";
+import { basename as basename6, dirname as dirname8, join as join14 } from "path";
 
 // src/daemon/gate/classify.ts
-import { isAbsolute, relative, resolve, sep } from "path";
+import { isAbsolute, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
 var SUMMARY_MAX = 200;
 var READ_TOOLS = /* @__PURE__ */ new Set([
   "Read",
@@ -1837,13 +2537,13 @@ var PROTECTED_DIRS = /* @__PURE__ */ new Set([
 ]);
 var PROTECTED_FILES = /* @__PURE__ */ new Set([".envrc", ".mcp.json", ".gitmodules", ".gitattributes"]);
 function isProtectedPath(cwd, p) {
-  const segs = resolve(cwd || "/", p).split(sep).filter(Boolean).map((s) => s.toLowerCase());
+  const segs = resolve2(cwd || "/", p).split(sep2).filter(Boolean).map((s) => s.toLowerCase());
   if (segs.some((s) => PROTECTED_DIRS.has(s))) return true;
   return PROTECTED_FILES.has(segs[segs.length - 1] ?? "");
 }
 function isInside(cwd, p) {
   if (!cwd || !p) return false;
-  const rel = relative(resolve(cwd), resolve(cwd, p));
+  const rel = relative2(resolve2(cwd), resolve2(cwd, p));
   if (rel === "") return true;
   return !rel.startsWith("..") && !isAbsolute(rel);
 }
@@ -1900,12 +2600,12 @@ function classify(toolName, toolInput, cwd, policy = "commands", opts = {}) {
   const inside = (p) => {
     if (!roots.some((r) => isInside(r, p))) return false;
     if (!real2) return true;
-    const rp = real2(resolve(roots[0] ?? "/", p));
+    const rp = real2(resolve2(roots[0] ?? "/", p));
     return roots.some((r) => isInside(real2(r), rp));
   };
   const rel = (p) => {
     const r = roots.find((x) => isInside(x, p)) ?? roots[0] ?? "";
-    return relative(resolve(r), resolve(r, p));
+    return relative2(resolve2(r), resolve2(r, p));
   };
   const input = toolInput && typeof toolInput === "object" ? toolInput : {};
   if (READ_TOOLS.has(toolName)) return { action: "auto" };
@@ -1918,7 +2618,7 @@ function classify(toolName, toolInput, cwd, policy = "commands", opts = {}) {
   if (paths) {
     const allInside = paths.length > 0 && paths.every(inside);
     const touchesProtected = paths.some(
-      (p) => isProtectedPath(roots[0] ?? "/", p) || (real2 ? isProtectedPath("/", real2(resolve(roots[0] ?? "/", p))) : false)
+      (p) => isProtectedPath(roots[0] ?? "/", p) || (real2 ? isProtectedPath("/", real2(resolve2(roots[0] ?? "/", p))) : false)
     );
     if (policy === "commands" && allInside && !touchesProtected) return { action: "auto" };
     const shown = paths.map((p) => inside(p) ? rel(p) : p);
@@ -1941,14 +2641,14 @@ function describe(toolName, toolInput, cwd) {
 }
 
 // src/daemon/gate/procs.ts
-import { execFileSync as execFileSync6 } from "child_process";
+import { execFileSync as execFileSync8 } from "child_process";
 function listDescendants(rootPid) {
   if (process.platform === "win32") {
     return descendantsOf(rootPid, (winProcs() ?? []).map((p) => ({ pid: p.pid, ppid: p.ppid, args: p.cmdline })));
   }
   let out = "";
   try {
-    out = execFileSync6("ps", ["-A", "-ww", "-o", "pid=,ppid=,args="], {
+    out = execFileSync8("ps", ["-A", "-ww", "-o", "pid=,ppid=,args="], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       maxBuffer: 16 * 1024 * 1024
@@ -2080,7 +2780,7 @@ var ApprovalCoordinator = class {
     store.save();
     let early = null;
     let settle;
-    const decided = new Promise((resolve5) => settle = resolve5);
+    const decided = new Promise((resolve6) => settle = resolve6);
     this.#waiters.set(rec.approvalId, (r) => {
       early = r;
       settle(r);
@@ -2104,8 +2804,8 @@ var ApprovalCoordinator = class {
     }
     run2.onWaitStart?.();
     try {
-      return await new Promise((resolve5) => {
-        void decided.then(resolve5);
+      return await new Promise((resolve6) => {
+        void decided.then(resolve6);
         const onAbort = () => {
           if (!this.#waiters.delete(rec.approvalId)) return;
           if (rec.status === "pending") {
@@ -2114,7 +2814,7 @@ var ApprovalCoordinator = class {
             store.save();
             void this.#cancelRemote(rec.approvalId, "\u667A\u80FD\u4F53\u8FDB\u7A0B\u5DF2\u7ED3\u675F");
           }
-          resolve5({ decision: "deny", reason: "\u5DF2\u53D6\u6D88" });
+          resolve6({ decision: "deny", reason: "\u5DF2\u53D6\u6D88" });
         };
         if (signal.aborted) onAbort();
         else signal.addEventListener("abort", onAbort, { once: true });
@@ -2166,7 +2866,7 @@ var ApprovalCoordinator = class {
       ...watchProcs ? { pid, cmd, baseline: new Set(this.#descendants(pid).map((p) => p.pid)) } : {}
     });
     let settle;
-    const decided = new Promise((resolve5) => settle = resolve5);
+    const decided = new Promise((resolve6) => settle = resolve6);
     this.#waiters.set(rec.approvalId, settle);
     try {
       await this.#d.backend.create(rec);
@@ -2182,11 +2882,11 @@ var ApprovalCoordinator = class {
     }
     this.#d.log(`\u7A97\u53E3\u6388\u6743 ${rec.approvalId} \u5DF2\u63A8\u5230\u8BBE\u5907 kind=${rec.kind}`);
     if (rec.status !== "pending") void this.#cancelRemote(rec.approvalId, "\u7535\u8111\u4E0A\u5DF2\u5904\u7406");
-    return new Promise((resolve5) => {
-      void decided.then(resolve5);
+    return new Promise((resolve6) => {
+      void decided.then(resolve6);
       const onAbort = () => {
         if (this.#waiters.has(rec.approvalId)) this.#settleWindow(rec, "hook \u5DF2\u7ED3\u675F");
-        resolve5(none);
+        resolve6(none);
       };
       if (signal.aborted) onAbort();
       else signal.addEventListener("abort", onAbort, { once: true });
@@ -2447,13 +3147,13 @@ function realpathNearest(p) {
   const tail = [];
   for (let i = 0; i < 64; i++) {
     try {
-      if (existsSync9(cur)) return join11(realpathSync2(cur), ...tail.reverse());
+      if (existsSync12(cur)) return join14(realpathSync2(cur), ...tail.reverse());
     } catch {
       return p;
     }
-    const parent = dirname5(cur);
+    const parent = dirname8(cur);
     if (parent === cur) return p;
-    tail.push(basename5(cur));
+    tail.push(basename6(cur));
     cur = parent;
   }
   return p;
@@ -2470,11 +3170,11 @@ function cwdForms(cwd) {
 // src/daemon/gate/server.ts
 import { randomBytes as randomBytes3, timingSafeEqual } from "crypto";
 import { createServer } from "http";
-import { mkdirSync as mkdirSync9, renameSync as renameSync7, rmSync as rmSync4, writeFileSync as writeFileSync9 } from "fs";
-import { join as join12 } from "path";
+import { mkdirSync as mkdirSync11, renameSync as renameSync8, rmSync as rmSync6, writeFileSync as writeFileSync10 } from "fs";
+import { join as join15 } from "path";
 var MAX_BODY_BYTES = 8 * 1024 * 1024;
 function gateConfPath() {
-  return join12(deskbuddyHome(), "gate.json");
+  return join15(deskbuddyHome(), "gate.json");
 }
 function tokenEquals(a, b) {
   const x = Buffer.from(a);
@@ -2485,39 +3185,46 @@ var GateServer = class {
   #handler;
   #token = randomBytes3(32).toString("hex");
   #server = null;
+  #inflight = 0;
+  /** 自动升级排空中：所有请求直接 503（远程 gate → exit 2 拦下；窗口 gate → 退回窗口里本地确认） */
+  refusing = false;
   constructor(handler) {
     this.#handler = handler;
   }
   get token() {
     return this.#token;
   }
+  /** 正在处理（多半是挂着等设备批准）的授权请求数。自动升级的空闲判定用（spec 2026-10-01 §4.3） */
+  get inflight() {
+    return this.#inflight;
+  }
   /** 起监听并写 gate.json。返回实际端口 */
   async start() {
     const server = createServer((req2, res) => void this.#serve(req2, res));
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       server.once("error", reject);
-      server.listen(0, "127.0.0.1", () => resolve5());
+      server.listen(0, "127.0.0.1", () => resolve6());
     });
     this.#server = server;
     const addr = server.address();
     const port = typeof addr === "object" && addr ? addr.port : 0;
-    mkdirSync9(deskbuddyHome(), { recursive: true });
+    mkdirSync11(deskbuddyHome(), { recursive: true });
     const tmp = gateConfPath() + ".tmp";
-    writeFileSync9(tmp, JSON.stringify({ port, token: this.#token, pid: process.pid }), {
+    writeFileSync10(tmp, JSON.stringify({ port, token: this.#token, pid: process.pid }), {
       encoding: "utf8",
       mode: 384
     });
-    renameSync7(tmp, gateConfPath());
+    renameSync8(tmp, gateConfPath());
     return port;
   }
   async stop() {
     try {
-      rmSync4(gateConfPath(), { force: true });
+      rmSync6(gateConfPath(), { force: true });
     } catch {
     }
     const s = this.#server;
     this.#server = null;
-    if (s) await new Promise((resolve5) => s.close(() => resolve5()));
+    if (s) await new Promise((resolve6) => s.close(() => resolve6()));
   }
   async #serve(req2, res) {
     const reply = (status, body2) => {
@@ -2528,6 +3235,7 @@ var GateServer = class {
     if (req2.method !== "POST" || req2.url !== "/gate") return reply(404);
     const token = req2.headers["x-gate-token"];
     if (typeof token !== "string" || !tokenEquals(token, this.#token)) return reply(403);
+    if (this.refusing) return reply(503);
     let body = "";
     let size = 0;
     try {
@@ -2552,6 +3260,7 @@ var GateServer = class {
     res.on("close", () => {
       if (!res.writableEnded) ac.abort();
     });
+    this.#inflight++;
     try {
       const req3 = window ? {
         window: true,
@@ -2562,6 +3271,8 @@ var GateServer = class {
       reply(200, out);
     } catch {
       reply(500);
+    } finally {
+      this.#inflight--;
     }
   }
 };
@@ -2576,6 +3287,7 @@ var PARAM = {
   deviceName: "ShiFeng-Device-Name",
   nonce: "ShiFeng-Nonce"
 };
+var CLI_VERSION_PARAM = "cliVersion";
 var WS_PATH = "/deskbuddy";
 function sanitizeParamValue(value) {
   return (value || "").replace(/[=&]/g, "-");
@@ -2616,21 +3328,23 @@ function buildHandshakeUrl(cfg, opts = {}) {
     [PARAM.signature, p.signature],
     [PARAM.deviceId, p.deviceId],
     [PARAM.deviceName, p.deviceName],
-    [PARAM.nonce, p.nonce]
+    [PARAM.nonce, p.nonce],
+    // 不参与签名，服务端可据此刷新 DeskBuddyClient.cliVersion（自动升级 spec 2026-10-01 §4.6）
+    [CLI_VERSION_PARAM, packageVersion()]
   ].map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
   return `${toWsOrigin(cfg.apiBase)}${WS_PATH}?${query}`;
 }
 
 // src/daemon/log.ts
-import { appendFileSync, mkdirSync as mkdirSync10, statSync as statSync3, truncateSync } from "fs";
-import { join as join13 } from "path";
+import { appendFileSync, mkdirSync as mkdirSync12, statSync as statSync4, truncateSync } from "fs";
+import { join as join16 } from "path";
 var MAX_LOG_BYTES = 2 * 1024 * 1024;
 function logPath() {
-  return join13(deskbuddyHome(), "daemon.log");
+  return join16(deskbuddyHome(), "daemon.log");
 }
 function rotateIfNeeded(path) {
   try {
-    if (statSync3(path).size > MAX_LOG_BYTES) truncateSync(path, 0);
+    if (statSync4(path).size > MAX_LOG_BYTES) truncateSync(path, 0);
   } catch {
   }
 }
@@ -2638,7 +3352,7 @@ function log(line) {
   const stamped = `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `;
   try {
-    mkdirSync10(deskbuddyHome(), { recursive: true });
+    mkdirSync12(deskbuddyHome(), { recursive: true });
     const p = logPath();
     rotateIfNeeded(p);
     appendFileSync(p, stamped, "utf8");
@@ -2696,18 +3410,18 @@ var SessionQueue = class {
 };
 
 // src/daemon/remote.ts
-import { mkdirSync as mkdirSync11, readFileSync as readFileSync11, renameSync as renameSync8, writeFileSync as writeFileSync10 } from "fs";
-import { join as join14 } from "path";
+import { mkdirSync as mkdirSync13, readFileSync as readFileSync12, renameSync as renameSync9, writeFileSync as writeFileSync11 } from "fs";
+import { join as join17 } from "path";
 function handleDir() {
-  return join14(deskbuddyHome(), "remote");
+  return join17(deskbuddyHome(), "remote");
 }
 function handlePath(tool) {
   const safe = (tool || "").replace(/[^0-9a-zA-Z_-]/g, "");
-  return join14(handleDir(), `${safe || "unknown"}.json`);
+  return join17(handleDir(), `${safe || "unknown"}.json`);
 }
 function readHandle(tool) {
   try {
-    const h = JSON.parse(readFileSync11(handlePath(tool), "utf8"));
+    const h = JSON.parse(readFileSync12(handlePath(tool), "utf8"));
     if (typeof h?.sessionId !== "string" || !h.sessionId) return null;
     if (typeof h?.cwd !== "string" || !h.cwd) return null;
     return h;
@@ -2717,10 +3431,10 @@ function readHandle(tool) {
 }
 function writeHandle(tool, handle) {
   try {
-    mkdirSync11(handleDir(), { recursive: true });
+    mkdirSync13(handleDir(), { recursive: true });
     const tmp = handlePath(tool) + ".tmp";
-    writeFileSync10(tmp, JSON.stringify(handle), "utf8");
-    renameSync8(tmp, handlePath(tool));
+    writeFileSync11(tmp, JSON.stringify(handle), "utf8");
+    renameSync9(tmp, handlePath(tool));
   } catch {
   }
 }
@@ -2773,11 +3487,11 @@ function failureMessage(reason) {
 }
 
 // src/daemon/seen.ts
-import { mkdirSync as mkdirSync12, readFileSync as readFileSync12, renameSync as renameSync9, writeFileSync as writeFileSync11 } from "fs";
-import { join as join15 } from "path";
+import { mkdirSync as mkdirSync14, readFileSync as readFileSync13, renameSync as renameSync10, writeFileSync as writeFileSync12 } from "fs";
+import { join as join18 } from "path";
 var SEEN_CAPACITY = 200;
 function seenPath() {
-  return join15(deskbuddyHome(), "seen.json");
+  return join18(deskbuddyHome(), "seen.json");
 }
 var SeenIds = class _SeenIds {
   #ids = [];
@@ -2808,7 +3522,7 @@ var SeenIds = class _SeenIds {
   }
   static load() {
     try {
-      const raw = JSON.parse(readFileSync12(seenPath(), "utf8"));
+      const raw = JSON.parse(readFileSync13(seenPath(), "utf8"));
       return new _SeenIds(Array.isArray(raw?.ids) ? raw.ids.filter((x) => typeof x === "string") : []);
     } catch {
       return new _SeenIds();
@@ -2816,17 +3530,17 @@ var SeenIds = class _SeenIds {
   }
   save() {
     try {
-      mkdirSync12(deskbuddyHome(), { recursive: true });
+      mkdirSync14(deskbuddyHome(), { recursive: true });
       const tmp = seenPath() + ".tmp";
-      writeFileSync11(tmp, JSON.stringify({ ids: this.#ids }), "utf8");
-      renameSync9(tmp, seenPath());
+      writeFileSync12(tmp, JSON.stringify({ ids: this.#ids }), "utf8");
+      renameSync10(tmp, seenPath());
     } catch {
     }
   }
 };
 
 // src/daemon/codexWatch.ts
-import { execFileSync as execFileSync7 } from "child_process";
+import { execFileSync as execFileSync9 } from "child_process";
 import WebSocket from "ws";
 var TURN_LIMIT_MS = 10 * 60 * 1e3;
 var QUEUE_MAX_MS = 10 * 60 * 1e3;
@@ -2871,7 +3585,7 @@ function discoverAppServers(configured) {
     return parseAppServerUrls((winProcs() ?? []).map((p) => p.cmdline).join("\n"));
   }
   try {
-    const out = execFileSync7("ps", ["-A", "-ww", "-o", "args="], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    const out = execFileSync9("ps", ["-A", "-ww", "-o", "args="], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
     return parseAppServerUrls(out);
   } catch {
     return [];
@@ -3014,13 +3728,13 @@ var CodexWatch = class {
   }
   #request(method, params) {
     const id = this.#nextId++;
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const timer = setTimeout(() => {
         this.#calls.delete(id);
-        resolve5({ error: { message: "timeout" }, local: true });
+        resolve6({ error: { message: "timeout" }, local: true });
       }, REQUEST_TIMEOUT_MS);
       timer.unref?.();
-      this.#calls.set(id, { resolve: resolve5, timer });
+      this.#calls.set(id, { resolve: resolve6, timer });
       this.#send({ id, method, params });
     });
   }
@@ -3243,7 +3957,7 @@ var CodexWatch = class {
     return { ...out, ...merged ? { merged } : {} };
   }
   #trackTurn(threadId, turnId) {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const limit = this.#d.turnLimitMs ?? TURN_LIMIT_MS;
       const step = this.#d.turnTickMs ?? 1e3;
       const t = {
@@ -3253,7 +3967,7 @@ var CodexWatch = class {
         used: 0,
         timer: null,
         grace: null,
-        done: (end, text, error) => resolve5({ sent: true, end, turnId, text, ...error ? { error } : {} })
+        done: (end, text, error) => resolve6({ sent: true, end, turnId, text, ...error ? { error } : {} })
       };
       this.#turns.set(turnId, t);
       const early = this.#early.get(turnId);
@@ -3300,7 +4014,7 @@ var CodexWatch = class {
     t.done(end, text || (end === "completed" ? "" : finalReply(t.items)), error);
   }
   #waitThread(threadId, ms) {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       let set = this.#wake.get(threadId);
       if (!set) this.#wake.set(threadId, set = /* @__PURE__ */ new Set());
       const s = set;
@@ -3308,7 +4022,7 @@ var CodexWatch = class {
         clearTimeout(timer);
         s.delete(fire);
         if (s.size === 0 && this.#wake.get(threadId) === s) this.#wake.delete(threadId);
-        resolve5();
+        resolve6();
       };
       const timer = setTimeout(fire, ms);
       timer.unref?.();
@@ -3481,43 +4195,43 @@ var CodexWatch = class {
 };
 
 // src/core/codexRemote.ts
-import { mkdirSync as mkdirSync13, renameSync as renameSync10, rmSync as rmSync5, writeFileSync as writeFileSync12 } from "fs";
-import { join as join16 } from "path";
+import { mkdirSync as mkdirSync15, renameSync as renameSync11, rmSync as rmSync7, writeFileSync as writeFileSync13 } from "fs";
+import { join as join19 } from "path";
 function codexRemotePath() {
-  return join16(deskbuddyHome(), "codex-remote.json");
+  return join19(deskbuddyHome(), "codex-remote.json");
 }
 function writeCodexRemote(threads, pid = process.pid, now = Date.now()) {
   try {
-    mkdirSync13(deskbuddyHome(), { recursive: true });
+    mkdirSync15(deskbuddyHome(), { recursive: true });
     const p = codexRemotePath();
-    writeFileSync12(p + ".tmp", JSON.stringify({ pid, threads: [...threads], at: now }), "utf8");
-    renameSync10(p + ".tmp", p);
+    writeFileSync13(p + ".tmp", JSON.stringify({ pid, threads: [...threads], at: now }), "utf8");
+    renameSync11(p + ".tmp", p);
   } catch {
   }
 }
 function removeCodexRemote() {
   try {
-    rmSync5(codexRemotePath(), { force: true });
+    rmSync7(codexRemotePath(), { force: true });
   } catch {
   }
 }
 
 // src/wrap/channel.ts
 import { randomBytes as randomBytes5 } from "crypto";
-import { chmodSync as chmodSync3, rmSync as rmSync7 } from "fs";
+import { chmodSync as chmodSync4, rmSync as rmSync9 } from "fs";
 import { connect, createServer as createServer2 } from "net";
 
 // src/core/wake.ts
-import { execFileSync as execFileSync8 } from "child_process";
+import { execFileSync as execFileSync10 } from "child_process";
 import { createHash as createHash3, createHmac as createHmac2, timingSafeEqual as timingSafeEqual2 } from "crypto";
-import { chmodSync as chmodSync2, closeSync as closeSync2, mkdirSync as mkdirSync14, openSync as openSync2, readdirSync as readdirSync3, readFileSync as readFileSync13, readSync as readSync2, renameSync as renameSync11, rmSync as rmSync6, statSync as statSync4, writeFileSync as writeFileSync13 } from "fs";
+import { chmodSync as chmodSync3, closeSync as closeSync3, mkdirSync as mkdirSync16, openSync as openSync3, readdirSync as readdirSync4, readFileSync as readFileSync14, readSync as readSync2, renameSync as renameSync12, rmSync as rmSync8, statSync as statSync5, writeFileSync as writeFileSync14 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join17 } from "path";
+import { join as join20 } from "path";
 function wakeDir(home = deskbuddyHome()) {
-  return join17(home, "wake");
+  return join20(home, "wake");
 }
 function marksDir(home = deskbuddyHome()) {
-  return join17(wakeDir(home), "marks");
+  return join20(wakeDir(home), "marks");
 }
 function safeSid(sessionId) {
   return String(sessionId).replace(/[^A-Za-z0-9_-]/g, "");
@@ -3527,10 +4241,10 @@ function homeTag(home) {
 }
 function wakeChannelPath(platform = process.platform, home = deskbuddyHome()) {
   if (platform === "win32") return `\\\\.\\pipe\\deskbuddy-wake-${homeTag(home)}`;
-  const primary = join17(wakeDir(home), "wake.sock");
+  const primary = join20(wakeDir(home), "wake.sock");
   if (Buffer.byteLength(primary) <= 103) return primary;
   const uid = typeof process.getuid === "function" ? process.getuid() : 0;
-  return join17(tmpdir2(), `deskbuddy-${uid}`, `wake-${homeTag(home)}.sock`);
+  return join20(tmpdir2(), `deskbuddy-${uid}`, `wake-${homeTag(home)}.sock`);
 }
 function pidExists(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
@@ -3545,11 +4259,11 @@ function writeWakeMark(sessionId, agentPid, now = Date.now()) {
   const safe = safeSid(sessionId);
   if (!safe) return;
   try {
-    mkdirSync14(marksDir(), { recursive: true, mode: 448 });
-    const file = join17(marksDir(), `${safe}.json`);
+    mkdirSync16(marksDir(), { recursive: true, mode: 448 });
+    const file = join20(marksDir(), `${safe}.json`);
     const tmp = `${file}.${process.pid}.tmp`;
-    writeFileSync13(tmp, JSON.stringify({ agentPid: agentPid ?? 0, daemonPid: process.pid, at: now }), { encoding: "utf8", mode: 384 });
-    renameSync11(tmp, file);
+    writeFileSync14(tmp, JSON.stringify({ agentPid: agentPid ?? 0, daemonPid: process.pid, at: now }), { encoding: "utf8", mode: 384 });
+    renameSync12(tmp, file);
   } catch {
   }
 }
@@ -3557,20 +4271,20 @@ function removeWakeMark(sessionId) {
   const safe = safeSid(sessionId);
   if (!safe) return;
   try {
-    rmSync6(join17(marksDir(), `${safe}.json`), { force: true });
+    rmSync8(join20(marksDir(), `${safe}.json`), { force: true });
   } catch {
   }
 }
 function clearWakeMarks() {
   let names = [];
   try {
-    names = readdirSync3(marksDir());
+    names = readdirSync4(marksDir());
   } catch {
     return;
   }
   for (const n of names) {
     try {
-      rmSync6(join17(marksDir(), n), { force: true });
+      rmSync8(join20(marksDir(), n), { force: true });
     } catch {
     }
   }
@@ -3579,7 +4293,7 @@ function isWakeMarked(sessionId, alive = pidExists) {
   const safe = safeSid(sessionId);
   if (!safe) return false;
   try {
-    const m = JSON.parse(readFileSync13(join17(marksDir(), `${safe}.json`), "utf8"));
+    const m = JSON.parse(readFileSync14(join20(marksDir(), `${safe}.json`), "utf8"));
     const daemonPid = Number(m?.daemonPid) || 0;
     if (!daemonPid || !alive(daemonPid)) return false;
     const pid = Number(m?.agentPid) || 0;
@@ -3592,30 +4306,30 @@ function withWake(states, alive) {
   return states.map((s) => s.remoteWindow === true || !isWakeMarked(s.sessionId, alive) ? s : { ...s, remoteWindow: true });
 }
 function wakeSecretPath(home = deskbuddyHome()) {
-  return join17(wakeDir(home), "secret");
+  return join20(wakeDir(home), "secret");
 }
 function writeWakeSecret(hex, platform = process.platform) {
   const file = wakeSecretPath();
-  mkdirSync14(wakeDir(), { recursive: true, mode: 448 });
+  mkdirSync16(wakeDir(), { recursive: true, mode: 448 });
   const tmp = `${file}.${process.pid}.tmp`;
-  writeFileSync13(tmp, hex, { encoding: "utf8", mode: 384 });
+  writeFileSync14(tmp, hex, { encoding: "utf8", mode: 384 });
   if (platform === "win32") {
     try {
-      execFileSync8("icacls", [tmp, "/inheritance:r", "/grant:r", `${currentUserSid()}:F`], { stdio: "ignore", windowsHide: true });
+      execFileSync10("icacls", [tmp, "/inheritance:r", "/grant:r", `${currentUserSid()}:F`], { stdio: "ignore", windowsHide: true });
     } catch {
-      renameSync11(tmp, file);
+      renameSync12(tmp, file);
       return "\u7A97\u53E3\u5524\u9192\u5BC6\u94A5\u6587\u4EF6\u7684\u6743\u9650\u6CA1\u80FD\u6536\u7D27\uFF08icacls \u5931\u8D25\uFF09";
     }
   } else {
-    chmodSync2(tmp, 384);
+    chmodSync3(tmp, 384);
   }
-  renameSync11(tmp, file);
+  renameSync12(tmp, file);
   return "";
 }
 function restrictToUser(file, platform = process.platform) {
   if (platform !== "win32") return true;
   try {
-    execFileSync8("icacls", [file, "/inheritance:r", "/grant:r", `${currentUserSid()}:F`], { stdio: "ignore", windowsHide: true });
+    execFileSync10("icacls", [file, "/inheritance:r", "/grant:r", `${currentUserSid()}:F`], { stdio: "ignore", windowsHide: true });
     return true;
   } catch {
     return false;
@@ -3623,7 +4337,7 @@ function restrictToUser(file, platform = process.platform) {
 }
 function currentUserSid() {
   try {
-    const out = execFileSync8("whoami", ["/user", "/fo", "csv", "/nh"], { encoding: "utf8", windowsHide: true });
+    const out = execFileSync10("whoami", ["/user", "/fo", "csv", "/nh"], { encoding: "utf8", windowsHide: true });
     const m = /"(S-1-[0-9-]+)"/.exec(out);
     if (m) return `*${m[1]}`;
   } catch {
@@ -3658,10 +4372,10 @@ function analyzeTranscript(file) {
   if (!file) return null;
   let fd;
   try {
-    const size = statSync4(file).size;
+    const size = statSync5(file).size;
     const len = Math.min(size, TRANSCRIPT_TAIL2);
     const buf = Buffer.alloc(len);
-    fd = openSync2(file, "r");
+    fd = openSync3(file, "r");
     readSync2(fd, buf, 0, len, size - len);
     const lines2 = buf.toString("utf8").split("\n");
     let seg = false;
@@ -3703,7 +4417,7 @@ function analyzeTranscript(file) {
   } finally {
     if (fd !== void 0) {
       try {
-        closeSync2(fd);
+        closeSync3(fd);
       } catch {
       }
     }
@@ -3754,7 +4468,7 @@ function replyMac(secret, nonceC, r) {
   return wakeMac(secret, "r", nonceC, r.instructionId, r.status, r.reason ?? "");
 }
 function startChannelServer(path, secret, onRequest, platform = process.platform) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const server = createServer2((sock) => {
       let open = true;
       let phase = "hello";
@@ -3805,7 +4519,7 @@ function startChannelServer(path, secret, onRequest, platform = process.platform
     });
     if (platform !== "win32") {
       try {
-        rmSync7(path, { force: true });
+        rmSync9(path, { force: true });
       } catch {
       }
     }
@@ -3815,19 +4529,19 @@ function startChannelServer(path, secret, onRequest, platform = process.platform
     };
     server.once("error", () => {
       restore();
-      resolve5(null);
+      resolve6(null);
     });
     server.listen(path, () => {
       restore();
       if (platform !== "win32") {
         try {
-          chmodSync3(path, 384);
+          chmodSync4(path, 384);
         } catch {
         }
       }
       server.on("error", () => {
       });
-      resolve5(server);
+      resolve6(server);
     });
   });
 }
@@ -3838,16 +4552,16 @@ function closeChannelServer(server, path, platform = process.platform) {
   }
   if (platform !== "win32") {
     try {
-      rmSync7(path, { force: true });
+      rmSync9(path, { force: true });
     } catch {
     }
   }
 }
 var FINAL = /* @__PURE__ */ new Set(["started", "rejected", "failed", "not_here"]);
 function sendToWindow(path, secret, req2, onReply, opts = {}) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     if (!secret) {
-      resolve5("fallback");
+      resolve6("fallback");
       return;
     }
     let settled = false;
@@ -3860,13 +4574,13 @@ function sendToWindow(path, secret, req2, onReply, opts = {}) {
       settled = true;
       handled = v === "handled";
       clearTimeout(timer);
-      resolve5(v);
+      resolve6(v);
     };
     let sock;
     try {
       sock = connect(path);
     } catch {
-      resolve5("fallback");
+      resolve6("fallback");
       return;
     }
     const timer = setTimeout(() => {
@@ -3988,29 +4702,29 @@ function boxMatches(view, body) {
 }
 
 // src/core/wrapWindows.ts
-import { chmodSync as chmodSync4, mkdirSync as mkdirSync15, readdirSync as readdirSync4, readFileSync as readFileSync14, renameSync as renameSync12, rmSync as rmSync8, statSync as statSync5, writeFileSync as writeFileSync14 } from "fs";
+import { chmodSync as chmodSync5, mkdirSync as mkdirSync17, readdirSync as readdirSync5, readFileSync as readFileSync15, renameSync as renameSync13, rmSync as rmSync10, statSync as statSync6, writeFileSync as writeFileSync15 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join18 } from "path";
+import { join as join21 } from "path";
 var WINDOW_ID_RE = /^[a-f0-9]{32}$/;
 function windowsDir() {
-  return join18(deskbuddyHome(), "windows");
+  return join21(deskbuddyHome(), "windows");
 }
 function bySessionDir() {
-  return join18(windowsDir(), "by-session");
+  return join21(windowsDir(), "by-session");
 }
 function safeSid2(sessionId) {
   return String(sessionId).replace(/[^A-Za-z0-9_-]/g, "");
 }
 function ensureDir(dir) {
-  mkdirSync15(dir, { recursive: true, mode: 448 });
+  mkdirSync17(dir, { recursive: true, mode: 448 });
 }
 function atomicWrite(file, text) {
   const tmp = `${file}.${process.pid}.tmp`;
-  writeFileSync14(tmp, text, { encoding: "utf8", mode: 384 });
-  renameSync12(tmp, file);
+  writeFileSync15(tmp, text, { encoding: "utf8", mode: 384 });
+  renameSync13(tmp, file);
 }
 function windowFile(windowId) {
-  return join18(windowsDir(), `${windowId}.json`);
+  return join21(windowsDir(), `${windowId}.json`);
 }
 function writeWindow(windowId, rec) {
   if (!WINDOW_ID_RE.test(windowId)) return;
@@ -4025,7 +4739,7 @@ function windowSecret(windowId) {
 function readWindow(windowId) {
   if (!WINDOW_ID_RE.test(windowId)) return null;
   try {
-    const r = JSON.parse(readFileSync14(windowFile(windowId), "utf8"));
+    const r = JSON.parse(readFileSync15(windowFile(windowId), "utf8"));
     return r && typeof r.pid === "number" ? r : null;
   } catch {
     return null;
@@ -4035,20 +4749,20 @@ function removeWindow(windowId) {
   if (!WINDOW_ID_RE.test(windowId)) return;
   for (const f of [windowFile(windowId), lastEventFile(windowId)]) {
     try {
-      rmSync8(f, { force: true });
+      rmSync10(f, { force: true });
     } catch {
     }
   }
   let names = [];
   try {
-    names = readdirSync4(bySessionDir());
+    names = readdirSync5(bySessionDir());
   } catch {
     return;
   }
   for (const n of names) {
-    const f = join18(bySessionDir(), n);
+    const f = join21(bySessionDir(), n);
     try {
-      if (readFileSync14(f, "utf8").trim() === windowId) rmSync8(f, { force: true });
+      if (readFileSync15(f, "utf8").trim() === windowId) rmSync10(f, { force: true });
     } catch {
     }
   }
@@ -4057,19 +4771,19 @@ function readBySession(sessionId) {
   const safe = safeSid2(sessionId);
   if (!safe) return null;
   try {
-    const id = readFileSync14(join18(bySessionDir(), safe), "utf8").trim();
+    const id = readFileSync15(join21(bySessionDir(), safe), "utf8").trim();
     return WINDOW_ID_RE.test(id) ? id : null;
   } catch {
     return null;
   }
 }
 function lastEventFile(windowId) {
-  return join18(windowsDir(), `${windowId}.last`);
+  return join21(windowsDir(), `${windowId}.last`);
 }
 function readLastEvent(windowId) {
   if (!WINDOW_ID_RE.test(windowId)) return null;
   try {
-    const e = JSON.parse(readFileSync14(lastEventFile(windowId), "utf8"));
+    const e = JSON.parse(readFileSync15(lastEventFile(windowId), "utf8"));
     return e && typeof e.ev === "string" && typeof e.at === "number" ? { ev: e.ev, sid: String(e.sid ?? ""), at: e.at } : null;
   } catch {
     return null;
@@ -4078,18 +4792,18 @@ function readLastEvent(windowId) {
 function channelPath(windowId, platform = process.platform, home = deskbuddyHome()) {
   if (platform === "win32") return `\\\\.\\pipe\\deskbuddy-${windowId}`;
   const name = `${windowId.slice(0, 16)}.sock`;
-  const primary = join18(home, "win", name);
+  const primary = join21(home, "win", name);
   if (Buffer.byteLength(primary) <= 103) return primary;
   const uid = typeof process.getuid === "function" ? process.getuid() : 0;
-  return join18(tmpdir3(), `deskbuddy-${uid}`, name);
+  return join21(tmpdir3(), `deskbuddy-${uid}`, name);
 }
 function ensureChannelDir(sockPath) {
-  const dir = join18(sockPath, "..");
+  const dir = join21(sockPath, "..");
   try {
-    mkdirSync15(dir, { recursive: true, mode: 448 });
-    const st = statSync5(dir);
+    mkdirSync17(dir, { recursive: true, mode: 448 });
+    const st = statSync6(dir);
     if (typeof process.getuid === "function" && st.uid !== process.getuid()) return false;
-    chmodSync4(dir, 448);
+    chmodSync5(dir, 448);
     return true;
   } catch {
     return false;
@@ -4106,35 +4820,35 @@ function windowForSession(sessionId) {
 }
 
 // src/core/launch.ts
-import { mkdirSync as mkdirSync16, readFileSync as readFileSync15, renameSync as renameSync13, rmSync as rmSync9, writeFileSync as writeFileSync15 } from "fs";
-import { join as join19 } from "path";
+import { mkdirSync as mkdirSync18, readFileSync as readFileSync16, renameSync as renameSync14, rmSync as rmSync11, writeFileSync as writeFileSync16 } from "fs";
+import { join as join22 } from "path";
 var RUN_ID_RE = /^[a-f0-9]{32}$/;
 var SESSION_UUID_RE = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
 function launchDir(home = deskbuddyHome()) {
-  return join19(home, "launch");
+  return join22(home, "launch");
 }
 function planFile(runId) {
-  return join19(launchDir(), `${runId}.json`);
+  return join22(launchDir(), `${runId}.json`);
 }
 function writeLaunch(runId, plan) {
   if (!RUN_ID_RE.test(runId)) throw new Error("bad runId");
   if (plan.resume && !SESSION_UUID_RE.test(plan.resume)) throw new Error("bad session id");
-  mkdirSync16(launchDir(), { recursive: true, mode: 448 });
+  mkdirSync18(launchDir(), { recursive: true, mode: 448 });
   const tmp = `${planFile(runId)}.${process.pid}.tmp`;
-  writeFileSync15(tmp, JSON.stringify(plan), { encoding: "utf8", mode: 384 });
+  writeFileSync16(tmp, JSON.stringify(plan), { encoding: "utf8", mode: 384 });
   restrictToUser(tmp);
-  renameSync13(tmp, planFile(runId));
+  renameSync14(tmp, planFile(runId));
 }
 function claimLaunch(runId) {
   if (!RUN_ID_RE.test(runId)) return null;
-  const claimed = join19(launchDir(), `${runId}.${process.pid}.claimed`);
+  const claimed = join22(launchDir(), `${runId}.${process.pid}.claimed`);
   try {
-    renameSync13(planFile(runId), claimed);
+    renameSync14(planFile(runId), claimed);
   } catch {
     return null;
   }
   try {
-    const p = JSON.parse(readFileSync15(claimed, "utf8"));
+    const p = JSON.parse(readFileSync16(claimed, "utf8"));
     if (!p || typeof p.cwd !== "string" || typeof p.resume !== "string") return null;
     if (p.resume && !SESSION_UUID_RE.test(p.resume)) return null;
     return p;
@@ -4142,14 +4856,14 @@ function claimLaunch(runId) {
     return null;
   } finally {
     try {
-      rmSync9(claimed, { force: true });
+      rmSync11(claimed, { force: true });
     } catch {
     }
   }
 }
 function launchPending(runId) {
   try {
-    readFileSync15(planFile(runId));
+    readFileSync16(planFile(runId));
     return true;
   } catch {
     return false;
@@ -4157,10 +4871,10 @@ function launchPending(runId) {
 }
 
 // src/daemon/openWindow.ts
-import { execFile as execFile3, execFileSync as execFileSync9, spawn as spawn2 } from "child_process";
-import { chmodSync as chmodSync5, mkdirSync as mkdirSync17, rmSync as rmSync10, writeFileSync as writeFileSync16 } from "fs";
+import { execFile as execFile4, execFileSync as execFileSync11, spawn as spawn3 } from "child_process";
+import { chmodSync as chmodSync6, mkdirSync as mkdirSync19, rmSync as rmSync12, writeFileSync as writeFileSync17 } from "fs";
 import { userInfo } from "os";
-import { join as join20 } from "path";
+import { join as join23 } from "path";
 function safePath(p) {
   return /^(?:[A-Za-z]:[\\/]|\/)/.test(p) && !/[\r\n\0"'`$%;]/.test(p);
 }
@@ -4208,14 +4922,14 @@ var defaultGuiDeps = () => ({
   env: process.env,
   macManager: () => {
     try {
-      return execFileSync9("launchctl", ["managername"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 3e3 });
+      return execFileSync11("launchctl", ["managername"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 3e3 });
     } catch {
       return "";
     }
   },
   macConsoleUser: () => {
     try {
-      return execFileSync9("stat", ["-f", "%Su", "/dev/console"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 3e3 });
+      return execFileSync11("stat", ["-f", "%Su", "/dev/console"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 3e3 });
     } catch {
       return "";
     }
@@ -4229,7 +4943,7 @@ var defaultGuiDeps = () => ({
   },
   winSessionId: () => {
     try {
-      const out = execFileSync9("tasklist", ["/FI", `PID eq ${process.pid}`, "/FO", "CSV", "/NH"], {
+      const out = execFileSync11("tasklist", ["/FI", `PID eq ${process.pid}`, "/FO", "CSV", "/NH"], {
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"],
         windowsHide: true,
@@ -4246,11 +4960,11 @@ var defaultGuiDeps = () => ({
 var defaultOpenerDeps = (findWt2) => ({
   platform: process.platform,
   findWt: findWt2,
-  run: (file, args) => new Promise((resolve5, reject) => {
-    execFile3(file, args, { windowsHide: true, timeout: 15e3 }, (err) => err ? reject(err) : resolve5());
+  run: (file, args) => new Promise((resolve6, reject) => {
+    execFile4(file, args, { windowsHide: true, timeout: 15e3 }, (err) => err ? reject(err) : resolve6());
   }),
   spawnDetached: (file, args) => {
-    const c = spawn2(file, args, { detached: true, stdio: "ignore", shell: false, windowsHide: false });
+    const c = spawn3(file, args, { detached: true, stdio: "ignore", shell: false, windowsHide: false });
     c.on("error", () => {
     });
     c.unref();
@@ -4259,10 +4973,10 @@ var defaultOpenerDeps = (findWt2) => ({
 async function openTerminal(t, d) {
   checkTarget(t);
   if (d.platform === "darwin") {
-    mkdirSync17(launchDir(t.home), { recursive: true, mode: 448 });
-    const file = join20(launchDir(t.home), `${t.runId}.command`);
-    writeFileSync16(file, macCommandScript(t), { encoding: "utf8", mode: 448 });
-    chmodSync5(file, 448);
+    mkdirSync19(launchDir(t.home), { recursive: true, mode: 448 });
+    const file = join23(launchDir(t.home), `${t.runId}.command`);
+    writeFileSync17(file, macCommandScript(t), { encoding: "utf8", mode: 448 });
+    chmodSync6(file, 448);
     await d.run("open", ["-a", "Terminal", file]);
     return "terminal";
   }
@@ -4280,14 +4994,14 @@ async function openTerminal(t, d) {
 function removeCommandFile(home, runId) {
   if (!RUN_ID_RE.test(runId)) return;
   try {
-    rmSync10(join20(launchDir(home), `${runId}.command`), { force: true });
+    rmSync12(join23(launchDir(home), `${runId}.command`), { force: true });
   } catch {
   }
 }
 
 // src/daemon/wake.ts
 import { randomBytes as randomBytes6 } from "crypto";
-import { rmSync as rmSync11 } from "fs";
+import { rmSync as rmSync13 } from "fs";
 import { createServer as createServer3 } from "net";
 var BUSY_STATES = /* @__PURE__ */ new Set(["watch", "ask_approval"]);
 var STOP_MIN_MS = 1500;
@@ -4312,6 +5026,14 @@ var WakeHub = class {
     const s = this.#slots.get(sessionId);
     return !!s && (!!s.reg || !!s.flight);
   }
+  /**
+   * 有没有 daemon 交出去、还没落定的指令（排队中 / 交付中 / 唤醒后正在跑的那一轮）。
+   * 只登记着等待者不算忙：那是用户自己的窗口。自动升级的空闲判定用（spec 2026-10-01 §4.3）
+   */
+  get busy() {
+    for (const s of this.#slots.values()) if (s.queue.length > 0 || s.flight || s.reg?.pending) return true;
+    return false;
+  }
   /** 交给唤醒路由。返回 false = 这个会话没有等待者，调用方走别的路 */
   submit(cmd, sessionId) {
     if (cmd.tool !== "claude_code") return false;
@@ -4574,11 +5296,11 @@ function startWakeServer(path, hub, secret, platform = process.platform) {
   if (platform !== "win32") {
     if (!ensureChannelDir(path)) return Promise.resolve(null);
     try {
-      rmSync11(path, { force: true });
+      rmSync13(path, { force: true });
     } catch {
     }
   }
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const server = createServer3((sock) => {
       sock.on("error", () => {
       });
@@ -4664,18 +5386,19 @@ function startWakeServer(path, hub, secret, platform = process.platform) {
     };
     server.once("error", () => {
       restore();
-      resolve5(null);
+      resolve6(null);
     });
     server.listen(path, () => {
       restore();
       server.on("error", () => {
       });
-      resolve5(server);
+      resolve6(server);
     });
   });
 }
 
 // src/daemon/index.ts
+var UPDATING_REASON = "updating";
 var IDLE_TIMEOUT_MS = 150 * 1e3;
 var POLICY_VIOLATION = 1008;
 var PING_FRAME_SERVICE = "ping";
@@ -4691,7 +5414,7 @@ function defaultCodexAppServers() {
   return cfg.enabledTools.includes("codex") ? discoverAppServers(cfg.codexAppServer) : [];
 }
 function opencodeReady() {
-  return isOcPluginInstalled(opencodePluginPath()) && existsSync10(ocPluginModule(installedHookPath()));
+  return isOcPluginInstalled(opencodePluginPath()) && existsSync13(ocPluginModule(installedHookPath()));
 }
 function orphanResumeText(summary2) {
   return `\uFF08\u4F60\u5728\u8BBE\u5907\u4E0A\u5DF2\u6279\u51C6\uFF1A${summary2}\uFF09\u8BF7\u7EE7\u7EED\u521A\u624D\u88AB\u4E2D\u65AD\u7684\u64CD\u4F5C\u3002`;
@@ -4726,6 +5449,10 @@ var Daemon = class {
   #codex = /* @__PURE__ */ new Map();
   #codexStarted = false;
   #codexReportTimer = null;
+  /** daemon 交出去、还没有结局的指令流程数（开窗 / 写进窗口 / 经 app-server 发一轮）。空闲判定用 */
+  #inflight = 0;
+  /** 自动升级排空中：不再接新指令、新授权请求 */
+  #draining = false;
   constructor(deps = {}) {
     this.#deps = {
       connect: deps.connect ?? ((url) => new WebSocket2(url)),
@@ -4754,6 +5481,8 @@ var Daemon = class {
       windowReadyMs: deps.windowReadyMs ?? WINDOW_READY_MS,
       wakePath: deps.wakePath === void 0 ? wakeChannelPath() : deps.wakePath,
       onWindowDone: deps.onWindowDone ?? (() => {
+      }),
+      onLink: deps.onLink ?? (() => {
       })
     };
     this.#wake = new WakeHub({
@@ -4946,6 +5675,45 @@ var Daemon = class {
   get coordinator() {
     return this.#coord;
   }
+  /** 把一段异步的指令流程记进 #inflight，结束（成功或失败）时减掉 */
+  #track(p) {
+    this.#inflight++;
+    return p.finally(() => {
+      this.#inflight--;
+    });
+  }
+  /**
+   * 进入排空（判定空闲之后、交给新版本切换之前）：新指令回报 rejected/updating 且不记 seen，
+   * gate 请求直接拒（远程模式本来也没有在跑的进程；窗口模式拒了会退回窗口里本地确认）
+   */
+  beginDrain() {
+    this.#draining = true;
+    this.#gate.refusing = true;
+    log("\u8FDB\u5165\u5347\u7EA7\u6392\u7A7A\uFF1A\u4E0D\u518D\u63A5\u65B0\u6307\u4EE4");
+  }
+  /** 退出排空（切换失败） */
+  endDrain() {
+    if (!this.#draining) return;
+    this.#draining = false;
+    this.#gate.refusing = false;
+    log("\u9000\u51FA\u5347\u7EA7\u6392\u7A7A\uFF0C\u6062\u590D\u63A5\u6307\u4EE4");
+  }
+  get draining() {
+    return this.#draining;
+  }
+  /**
+   * 能不能现在重启（自动升级 spec 2026-10-01 §4.3）：daemon 手上没有任何在途的设备指令、没有挂着的授权请求。
+   * 用户自己窗口里的会话不算忙 —— 它们不是 daemon 的子进程，重启不影响
+   */
+  idleState() {
+    const busy = [];
+    if (this.#queue.activeSessions > 0) busy.push(`\u540E\u53F0\u6307\u4EE4\u961F\u5217 ${this.#queue.activeSessions} \u4E2A\u4F1A\u8BDD`);
+    if (this.#runsDone.size > 0) busy.push(`${this.#runsDone.size} \u4E2A\u540E\u53F0\u8FDB\u7A0B\u5728\u8DD1`);
+    if (this.#gate.inflight > 0) busy.push(`${this.#gate.inflight} \u4E2A\u6388\u6743\u8BF7\u6C42\u6302\u7740`);
+    if (this.#opening.size > 0 || this.#inflight > 0) busy.push(`${this.#opening.size + this.#inflight} \u6761\u6307\u4EE4\u6B63\u5728\u5F00\u7A97 / \u4EA4\u7ED9\u7A97\u53E3`);
+    if (this.#wake.busy) busy.push("\u5524\u9192\u7A97\u53E3\u91CC\u6709\u6392\u961F\u6216\u5728\u8DD1\u7684\u6307\u4EE4");
+    return busy.length === 0 ? { idle: true, why: "" } : { idle: false, why: busy.join("\uFF0C") };
+  }
   stop() {
     this.#stopped = true;
     this.#clearIdle();
@@ -5004,6 +5772,7 @@ var Daemon = class {
       this.#attempt = 0;
       log("\u5DF2\u8FDE\u4E0A");
       this.#armIdle();
+      this.#deps.onLink(true);
       void this.#coord.syncPending();
       void this.#reportDirs(true);
     });
@@ -5019,6 +5788,7 @@ var Daemon = class {
     ws.on("close", (code, reason) => {
       this.#clearIdle();
       this.#ws = null;
+      this.#deps.onLink(false);
       if (code === POLICY_VIOLATION) {
         log(`\u670D\u52A1\u7AEF\u62D2\u7EDD\u8FDE\u63A5(${code} ${reason?.toString() || ""})\uFF1A\u6388\u6743\u5DF2\u5931\u6548\uFF0C\u505C\u6B62\u91CD\u8FDE\u3002\u8BF7\u91CD\u65B0\u8FD0\u884C deskbuddy setup`);
         this.#stopped = true;
@@ -5054,6 +5824,10 @@ var Daemon = class {
     }
     const ap = parseApprovalFrame(frame);
     if (ap) {
+      if (this.#draining) {
+        log(`\u6B63\u5728\u5347\u7EA7\uFF0C\u6388\u6743\u51B3\u5B9A ${ap.approvalId} \u7559\u7ED9\u91CD\u542F\u540E\u7684\u5B88\u62A4\u8FDB\u7A0B\u8865\u6536`);
+        return;
+      }
       if (!this.#seen.remember(ap.instructionId)) return;
       this.#seen.save();
       log(`\u6536\u5230\u6388\u6743\u51B3\u5B9A ${ap.approvalId} ${ap.decision}`);
@@ -5062,6 +5836,11 @@ var Daemon = class {
     }
     const cmd = parseCommand(frame);
     if (!cmd) return;
+    if (this.#draining) {
+      log(`\u6307\u4EE4 ${cmd.instructionId} \u5230\u8FBE\u65F6\u6B63\u5728\u5347\u7EA7\u91CD\u542F\uFF0C\u62D2\u7EDD\uFF08\u53EF\u91CD\u53D1\uFF09`);
+      this.#report(cmd, cmd.sessionId, "rejected", "", UPDATING_REASON);
+      return;
+    }
     if (!this.#seen.remember(cmd.instructionId)) {
       log(`\u6307\u4EE4 ${cmd.instructionId} \u5DF2\u5904\u7406\u8FC7\uFF0C\u4E22\u5F03`);
       return;
@@ -5093,7 +5872,7 @@ var Daemon = class {
         win = null;
       }
       if (win) {
-        void this.#toWindow(cmd, sid, win);
+        void this.#track(this.#toWindow(cmd, sid, win));
         return;
       }
       if (cmd.tool === "codex" && !this.#queue.busy(sid)) {
@@ -5109,7 +5888,7 @@ var Daemon = class {
           return;
         }
         if (route) {
-          void this.#toCodexWindow(cmd, sid, route);
+          void this.#track(this.#toCodexWindow(cmd, sid, route));
           return;
         }
       }
@@ -5126,7 +5905,7 @@ var Daemon = class {
       if (this.#wake.submit(cmd, sid)) return;
     }
     if (cmd.tool === "claude_code" && !isExpired(cmd, this.#deps.now())) {
-      void this.#openOrDispatch(cmd).catch((e) => {
+      void this.#track(this.#openOrDispatch(cmd)).catch((e) => {
         log(`\u6307\u4EE4 ${cmd.instructionId} \u5F00\u7A97\u6D41\u7A0B\u51FA\u9519\uFF1A${e?.stack ?? String(e)}`);
         this.#report(cmd, cmd.sessionId, "failed", "", "window_failed");
       });
@@ -5462,7 +6241,7 @@ var Daemon = class {
       this.#report(cmd, sessionId, "rejected", "", "tool_unsupported");
       return;
     }
-    log(`\u6267\u884C ${cmd.instructionId} tool=${cmd.tool} ${sessionId ? "resume" : "new"} cwd=\u2026/${basename6(cwd)} len=${cmd.text.length}`);
+    log(`\u6267\u884C ${cmd.instructionId} tool=${cmd.tool} ${sessionId ? "resume" : "new"} cwd=\u2026/${basename7(cwd)} len=${cmd.text.length}`);
     const result = await this.#run(plan, cmd.tool, runId, sessionId, cwd, () => this.#report(cmd, sessionId, "started", "headless"));
     if ("fail" in result) {
       log(
@@ -5536,7 +6315,7 @@ var Daemon = class {
    * 起不了（关卡不可用 / 找不到可执行文件）返回 {fail}；进程起来那一刻调 onStarted
    */
   async #run(plan, tool, runId, sessionId, cwd, onStarted) {
-    if (!existsSync10(this.#deps.nodePath) || !existsSync10(this.#deps.gateScript)) {
+    if (!existsSync13(this.#deps.nodePath) || !existsSync13(this.#deps.gateScript)) {
       log(`\u6388\u6743\u5173\u5361\u4E0D\u53EF\u7528\uFF08node \u6216 gate.cjs \u627E\u4E0D\u5230\uFF09\uFF0C\u62D2\u7EDD\u6267\u884C ${tool}`);
       return { fail: "gate_unavailable" };
     }
@@ -5581,6 +6360,22 @@ async function runDaemon(deps = {}) {
 }
 
 // src/commands/daemon.ts
+var VERIFY_CONNECTED_MS = 3 * 60 * 1e3;
+function verifyOnLink(version, opts = {}) {
+  let timer = null;
+  return (up) => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (!up) return;
+    timer = setTimeout(() => {
+      timer = null;
+      if ((opts.markGood ?? markGood)(version)) log(`[\u81EA\u52A8\u5347\u7EA7] ${version} \u5DF2\u8FDE\u6EE1 3 \u5206\u949F\uFF0C\u9A8C\u8BC1\u901A\u8FC7`);
+    }, opts.delayMs ?? VERIFY_CONNECTED_MS);
+    timer.unref?.();
+  };
+}
 async function runDaemonCommand(opts = {}) {
   const cfg = loadConfig();
   if (!cfg.boundAt) {
@@ -5589,23 +6384,37 @@ async function runDaemonCommand(opts = {}) {
   }
   if (opts.foreground) process.env.DESKBUDDY_DAEMON_FOREGROUND = "1";
   try {
-    writeFileSync17(pidFilePath(), String(process.pid), "utf8");
+    writeFileSync18(pidFilePath(), String(process.pid), "utf8");
   } catch {
   }
   let daemon;
   try {
-    daemon = await runDaemon();
+    daemon = await runDaemon({ onLink: verifyOnLink(packageVersion()) });
   } catch (e) {
     log(`\u5B88\u62A4\u8FDB\u7A0B\u542F\u52A8\u5931\u8D25\uFF1A${e.message}`);
     process.stderr.write(`\u2717 \u5B88\u62A4\u8FDB\u7A0B\u542F\u52A8\u5931\u8D25\uFF1A${e.message}
 `);
     return 1;
   }
+  const d = daemon;
+  const updater = opts.foreground ? null : new AutoUpdater({
+    currentVersion: packageVersion(),
+    fetchPolicy: async () => (await api.toolRegistry())?.cli,
+    config: () => loadConfig(),
+    install: (target) => installVersion(target, { log: (l) => log(`[\u81EA\u52A8\u5347\u7EA7] ${l}`) }),
+    idle: () => d.idleState(),
+    beginDrain: () => d.beginDrain(),
+    endDrain: () => d.endDrain(),
+    switchTo: (cliPath, _target, onExit) => spawnSwitch(cliPath, daemonLogPath(), { version: packageVersion(), cliPath: defaultCliPath() }, onExit),
+    log: (l) => log(`[\u81EA\u52A8\u5347\u7EA7] ${l}`)
+  });
+  updater?.start();
   const shutdown = (sig) => {
     log(`\u6536\u5230 ${sig}\uFF0C\u9000\u51FA`);
+    updater?.stop();
     daemon.stop();
     try {
-      rmSync12(pidFilePath(), { force: true });
+      rmSync14(pidFilePath(), { force: true });
     } catch {
     }
     process.exit(0);
@@ -5622,8 +6431,8 @@ async function runDaemonCommand(opts = {}) {
 }
 
 // src/core/registry.ts
-import { mkdirSync as mkdirSync18, readFileSync as readFileSync16, writeFileSync as writeFileSync18 } from "fs";
-import { join as join21 } from "path";
+import { mkdirSync as mkdirSync20, readFileSync as readFileSync17, writeFileSync as writeFileSync19 } from "fs";
+import { join as join24 } from "path";
 var FALLBACK = {
   version: "builtin",
   tools: {
@@ -5705,11 +6514,11 @@ var FALLBACK = {
   }
 };
 function registryCachePath() {
-  return join21(deskbuddyHome(), "tool-registry.json");
+  return join24(deskbuddyHome(), "tool-registry.json");
 }
 function loadRegistry() {
   try {
-    return JSON.parse(readFileSync16(registryCachePath(), "utf8"));
+    return JSON.parse(readFileSync17(registryCachePath(), "utf8"));
   } catch {
     return FALLBACK;
   }
@@ -5717,15 +6526,15 @@ function loadRegistry() {
 async function refreshRegistry() {
   try {
     const registry = await api.toolRegistry();
-    mkdirSync18(deskbuddyHome(), { recursive: true });
-    writeFileSync18(registryCachePath(), JSON.stringify(registry, null, 2), "utf8");
+    mkdirSync20(deskbuddyHome(), { recursive: true });
+    writeFileSync19(registryCachePath(), JSON.stringify(registry, null, 2), "utf8");
   } catch {
   }
 }
 
 // src/adapters/ccHook.ts
-import { chmodSync as chmodSync6, existsSync as existsSync11, mkdirSync as mkdirSync19, readFileSync as readFileSync17, renameSync as renameSync14, rmSync as rmSync13, statSync as statSync6, writeFileSync as writeFileSync19 } from "fs";
-import { dirname as dirname6, join as join22 } from "path";
+import { chmodSync as chmodSync7, existsSync as existsSync14, mkdirSync as mkdirSync21, readFileSync as readFileSync18, renameSync as renameSync15, rmSync as rmSync15, statSync as statSync7, writeFileSync as writeFileSync20 } from "fs";
+import { dirname as dirname9, join as join25 } from "path";
 var CC_EVENTS = [
   "UserPromptSubmit",
   "PreToolUse",
@@ -5735,8 +6544,8 @@ var CC_EVENTS = [
   "SessionEnd"
 ];
 function readSettings(path) {
-  if (!existsSync11(path)) return {};
-  const raw = readFileSync17(path, "utf8");
+  if (!existsSync14(path)) return {};
+  const raw = readFileSync18(path, "utf8");
   if (raw.trim() === "") return {};
   try {
     return JSON.parse(raw);
@@ -5745,17 +6554,17 @@ function readSettings(path) {
   }
 }
 function writeSettings(path, settings) {
-  mkdirSync19(dirname6(path), { recursive: true });
+  mkdirSync21(dirname9(path), { recursive: true });
   let mode;
   try {
-    mode = statSync6(path).mode & 511;
+    mode = statSync7(path).mode & 511;
   } catch {
     mode = void 0;
   }
   const tmp = path + ".deskbuddy.tmp";
-  writeFileSync19(tmp, JSON.stringify(settings, null, 2), "utf8");
-  if (mode !== void 0) chmodSync6(tmp, mode);
-  renameSync14(tmp, path);
+  writeFileSync20(tmp, JSON.stringify(settings, null, 2), "utf8");
+  if (mode !== void 0) chmodSync7(tmp, mode);
+  renameSync15(tmp, path);
 }
 function mentions(command, script) {
   return !!command && (command.includes(script) || command.includes(fwdSlash(script)));
@@ -5858,8 +6667,8 @@ function installCcRewake(settingsPath, wakePath, platform = process.platform) {
 function uninstallCcHook(settingsPath, hookPath) {
   const settings = readSettings(settingsPath);
   if (!settings.hooks) return;
-  const gatePath = join22(dirname6(hookPath), "gate.cjs");
-  const wakePath = join22(dirname6(hookPath), "wake.cjs");
+  const gatePath = join25(dirname9(hookPath), "gate.cjs");
+  const wakePath = join25(dirname9(hookPath), "wake.cjs");
   for (const event of Object.keys(settings.hooks)) {
     const groups = settings.hooks[event] ?? [];
     const kept = [];
@@ -5873,14 +6682,14 @@ function uninstallCcHook(settingsPath, hookPath) {
   }
   writeSettings(settingsPath, settings);
   try {
-    rmSync13(join22(dirname6(hookPath), "wake", "tokens"), { recursive: true, force: true });
+    rmSync15(join25(dirname9(hookPath), "wake", "tokens"), { recursive: true, force: true });
   } catch {
   }
 }
 
 // src/adapters/codexHook.ts
-import { chmodSync as chmodSync7, existsSync as existsSync12, mkdirSync as mkdirSync20, readFileSync as readFileSync18, renameSync as renameSync15, statSync as statSync7, writeFileSync as writeFileSync20 } from "fs";
-import { dirname as dirname7, join as join23 } from "path";
+import { chmodSync as chmodSync8, existsSync as existsSync15, mkdirSync as mkdirSync22, readFileSync as readFileSync19, renameSync as renameSync16, statSync as statSync8, writeFileSync as writeFileSync21 } from "fs";
+import { dirname as dirname10, join as join26 } from "path";
 var CODEX_MARKER_BEGIN = "# >>> deskbuddy >>>";
 var CODEX_MARKER_END = "# <<< deskbuddy <<<";
 var CODEX_EVENTS = [
@@ -5893,7 +6702,7 @@ var CODEX_EVENTS = [
 ];
 var CODEX_TRUST_NOTICE = "\u26A0\uFE0F  \u4E0B\u6B21\u542F\u52A8 Codex \u65F6\u4F1A\u8981\u6C42\u4F60\u786E\u8BA4\u4FE1\u4EFB\u8FD9\u4E2A hook\uFF0C\u8BF7\u9009\u62E9\u540C\u610F\u2014\u2014\u4E0D\u786E\u8BA4\u7684\u8BDD Codex \u4E0D\u4F1A\u6267\u884C\u5B83\u3002\n   Codex \u7ECF `--remote` \u8FDE\u5E38\u9A7B app-server \u4F7F\u7528\u65F6\uFF0C\u7A97\u53E3\u91CC\u7684\u6388\u6743\u6846\u4E5F\u80FD\u5728\u8BBE\u5907\u4E0A\u786E\u8BA4\uFF08\u5B88\u62A4\u8FDB\u7A0B\u5728\u8DD1\u65F6\u751F\u6548\uFF09";
 function codexConfigPath() {
-  return join23(codexHome(), "config.toml");
+  return join26(codexHome(), "config.toml");
 }
 function renderBlock(hookPath, events, tool, platform) {
   const command = JSON.stringify(`node ${platform === "win32" ? winPsPath(hookPath) : hookPath} ${tool}`);
@@ -5912,17 +6721,17 @@ function renderBlock(hookPath, events, tool, platform) {
   return lines2.join("\n");
 }
 function writeAtomic(path, content) {
-  mkdirSync20(dirname7(path), { recursive: true });
+  mkdirSync22(dirname10(path), { recursive: true });
   let mode;
   try {
-    mode = statSync7(path).mode & 511;
+    mode = statSync8(path).mode & 511;
   } catch {
     mode = void 0;
   }
   const tmp = path + ".deskbuddy.tmp";
-  writeFileSync20(tmp, content, "utf8");
-  if (mode !== void 0) chmodSync7(tmp, mode);
-  renameSync15(tmp, path);
+  writeFileSync21(tmp, content, "utf8");
+  if (mode !== void 0) chmodSync8(tmp, mode);
+  renameSync16(tmp, path);
 }
 function assertSafeToAppend(raw, path) {
   for (const quote of ['"""', "'''"]) {
@@ -5932,7 +6741,7 @@ function assertSafeToAppend(raw, path) {
   }
 }
 function installCodexHook(configPath2, hookPath, events = CODEX_EVENTS, tool = "codex", platform = process.platform) {
-  const raw = existsSync12(configPath2) ? readFileSync18(configPath2, "utf8") : "";
+  const raw = existsSync15(configPath2) ? readFileSync19(configPath2, "utf8") : "";
   if (raw.includes(CODEX_MARKER_BEGIN)) return;
   assertSafeToAppend(raw, configPath2);
   const block = renderBlock(hookPath, events, tool, platform);
@@ -5940,8 +6749,8 @@ function installCodexHook(configPath2, hookPath, events = CODEX_EVENTS, tool = "
   writeAtomic(configPath2, head + block + "\n");
 }
 function uninstallCodexHook(configPath2) {
-  if (!existsSync12(configPath2)) return;
-  const raw = readFileSync18(configPath2, "utf8");
+  if (!existsSync15(configPath2)) return;
+  const raw = readFileSync19(configPath2, "utf8");
   const lines2 = raw.split("\n");
   const begin = lines2.findIndex((l) => l.trim() === CODEX_MARKER_BEGIN);
   if (begin === -1) return;
@@ -5955,11 +6764,11 @@ function uninstallCodexHook(configPath2) {
 }
 
 // src/commands/tools.ts
-import { existsSync as existsSync13, readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync20 } from "fs";
 function fileContains(path, needle) {
   try {
-    if (!existsSync13(path)) return false;
-    return readFileSync19(path, "utf8").includes(needle);
+    if (!existsSync16(path)) return false;
+    return readFileSync20(path, "utf8").includes(needle);
   } catch {
     return false;
   }
@@ -6033,13 +6842,13 @@ function subscribedEvents(registry, tool, fallback) {
 }
 
 // src/commands/enable.ts
-import { dirname as dirname9, join as join26 } from "path";
+import { dirname as dirname11, join as join28 } from "path";
 
 // src/wrap/shim.ts
-import { execFileSync as execFileSync10 } from "child_process";
-import { chmodSync as chmodSync8, existsSync as existsSync14, mkdirSync as mkdirSync21, readdirSync as readdirSync5, readFileSync as readFileSync20, rmdirSync, rmSync as rmSync14, writeFileSync as writeFileSync21 } from "fs";
+import { execFileSync as execFileSync12 } from "child_process";
+import { chmodSync as chmodSync9, existsSync as existsSync17, mkdirSync as mkdirSync23, readdirSync as readdirSync6, readFileSync as readFileSync21, rmdirSync, rmSync as rmSync16, writeFileSync as writeFileSync22 } from "fs";
 import { homedir as homedir6 } from "os";
-import { delimiter as delimiter2, join as join24, resolve as resolve2 } from "path";
+import { delimiter as delimiter2, join as join27, resolve as resolve3 } from "path";
 var SHIM_FALLBACK_EXIT = 213;
 var WIN_SHIM_ENABLED = false;
 var SHIM_COMMANDS = { claude_code: "claude", codex: "codex" };
@@ -6049,10 +6858,10 @@ var RC_END = "# <<< deskbuddy <<<";
 var RC_FILES = [".zshrc", ".bashrc"];
 var WIN_PENDING = "Windows \u7A97\u53E3\u63A5\u7BA1\u5F85\u9A8C\u8BC1\uFF0C\u6682\u672A\u5F00\u542F";
 function shimDir() {
-  return join24(deskbuddyHome(), "bin");
+  return join27(deskbuddyHome(), "bin");
 }
 function shimFile(binDir, command, platform = process.platform) {
-  return join24(binDir, platform === "win32" ? `${command}.cmd` : command);
+  return join27(binDir, platform === "win32" ? `${command}.cmd` : command);
 }
 function shQuote3(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
@@ -6140,7 +6949,7 @@ function cmdScript(tool, command, node, cli, bin) {
   ].join("\r\n");
 }
 function rcBlock(binDir, rcHome) {
-  const std = resolve2(rcHome, ".deskbuddy", "bin") === resolve2(binDir);
+  const std = resolve3(rcHome, ".deskbuddy", "bin") === resolve3(binDir);
   const dir = std ? "$HOME/.deskbuddy/bin" : binDir.replace(/(["\\$`])/g, "\\$1");
   return [
     RC_BEGIN,
@@ -6181,10 +6990,10 @@ function removeRcBlock(content) {
   return content.slice(0, start) + content.slice(end);
 }
 function readRc(p) {
-  return readFileSync20(p).toString("latin1");
+  return readFileSync21(p).toString("latin1");
 }
 function writeRc(p, latin1) {
-  writeFileSync21(p, Buffer.from(latin1, "latin1"));
+  writeFileSync22(p, Buffer.from(latin1, "latin1"));
 }
 function toLatin1(utf8) {
   return Buffer.from(utf8, "utf8").toString("latin1");
@@ -6206,7 +7015,7 @@ function removePathEntry(value, dir) {
 var PS_READ = "$k=[Microsoft.Win32.Registry]::CurrentUser.OpenSubKey('Environment');$v='';if($k){$v=$k.GetValue('Path','',[Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames)};[Console]::Out.Write([Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes([string]$v)))";
 var PS_WRITE = "$k=[Microsoft.Win32.Registry]::CurrentUser.CreateSubKey('Environment');$kind=[Microsoft.Win32.RegistryValueKind]::ExpandString;try{$kind=$k.GetValueKind('Path')}catch{};if([string]::IsNullOrEmpty($env:DESKBUDDY_NEW_PATH)){$k.DeleteValue('Path',$false)}else{$k.SetValue('Path',$env:DESKBUDDY_NEW_PATH,$kind)};[Environment]::SetEnvironmentVariable('DESKBUDDY_PATH_REFRESH','1','User');[Environment]::SetEnvironmentVariable('DESKBUDDY_PATH_REFRESH',$null,'User')";
 function psWinPath() {
-  const ps = (script, env) => execFileSync10("powershell.exe", ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script], {
+  const ps = (script, env) => execFileSync12("powershell.exe", ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "ignore"],
     windowsHide: true,
@@ -6253,12 +7062,12 @@ function installShim(tool, e) {
     if (!node || !cli || !bin) {
       return { ok: false, message: "\u7A97\u53E3\u63A5\u7BA1\u6CA1\u88C5\uFF1A\u5B89\u88C5\u8DEF\u5F84\u91CC\u6709\u975E ASCII \u5B57\u7B26\uFF0CWindows \u7684 .cmd \u8BFB\u4E0D\u4E86\uFF08\u4E0D\u5F71\u54CD\u5176\u5B83\u529F\u80FD\uFF09" };
     }
-    mkdirSync21(e.binDir, { recursive: true });
-    writeFileSync21(file, cmdScript(tool, command, node, cli, bin), "utf8");
+    mkdirSync23(e.binDir, { recursive: true });
+    writeFileSync22(file, cmdScript(tool, command, node, cli, bin), "utf8");
   } else {
-    mkdirSync21(e.binDir, { recursive: true, mode: 448 });
-    writeFileSync21(file, shScript(tool, command, e.nodePath, e.cliPath, e.binDir), { encoding: "utf8", mode: 493 });
-    chmodSync8(file, 493);
+    mkdirSync23(e.binDir, { recursive: true, mode: 448 });
+    writeFileSync22(file, shScript(tool, command, e.nodePath, e.cliPath, e.binDir), { encoding: "utf8", mode: 493 });
+    chmodSync9(file, 493);
   }
   const touched = [];
   if (e.platform === "win32") {
@@ -6272,8 +7081,8 @@ function installShim(tool, e) {
   } else if (e.rcHome) {
     const block = toLatin1(rcBlock(e.binDir, e.rcHome));
     for (const name of RC_FILES) {
-      const rc = join24(e.rcHome, name);
-      if (!existsSync14(rc)) continue;
+      const rc = join27(e.rcHome, name);
+      if (!existsSync17(rc)) continue;
       const next = addRcBlock(readRc(rc), block);
       if (next !== null) writeRc(rc, next);
       touched.push(`~/${name}`);
@@ -6293,13 +7102,13 @@ function installShim(tool, e) {
 function ourShims(binDir) {
   let names;
   try {
-    names = readdirSync5(binDir);
+    names = readdirSync6(binDir);
   } catch {
     return [];
   }
   return names.filter((n) => {
     try {
-      return readFileSync20(join24(binDir, n), "utf8").includes(SHIM_MARKER);
+      return readFileSync21(join27(binDir, n), "utf8").includes(SHIM_MARKER);
     } catch {
       return false;
     }
@@ -6311,8 +7120,8 @@ function uninstallShim(tool, e) {
   let removed = false;
   const file = shimFile(e.binDir, command, e.platform);
   try {
-    if (existsSync14(file) && readFileSync20(file, "utf8").includes(SHIM_MARKER)) {
-      rmSync14(file, { force: true });
+    if (existsSync17(file) && readFileSync21(file, "utf8").includes(SHIM_MARKER)) {
+      rmSync16(file, { force: true });
       removed = true;
     }
   } catch {
@@ -6330,8 +7139,8 @@ function uninstallShim(tool, e) {
     }
   } else if (e.rcHome) {
     for (const name of RC_FILES) {
-      const rc = join24(e.rcHome, name);
-      if (!existsSync14(rc)) continue;
+      const rc = join27(e.rcHome, name);
+      if (!existsSync17(rc)) continue;
       const next = removeRcBlock(readRc(rc));
       if (next !== null) {
         writeRc(rc, next);
@@ -6340,7 +7149,7 @@ function uninstallShim(tool, e) {
     }
   }
   try {
-    if (existsSync14(e.binDir) && readdirSync5(e.binDir).length === 0) rmdirSync(e.binDir);
+    if (existsSync17(e.binDir) && readdirSync6(e.binDir).length === 0) rmdirSync(e.binDir);
   } catch {
   }
   if (!removed && touched.length === 0) return { ok: true, message: "" };
@@ -6352,7 +7161,7 @@ function shimState(tool, binDir, pathEnv, platform = process.platform) {
   const file = shimFile(binDir, command, platform);
   let installed = false;
   try {
-    installed = readFileSync20(file, "utf8").includes(SHIM_MARKER);
+    installed = readFileSync21(file, "utf8").includes(SHIM_MARKER);
   } catch {
     installed = false;
   }
@@ -6362,72 +7171,6 @@ function shimState(tool, binDir, pathEnv, platform = process.platform) {
   return { installed, inPath };
 }
 
-// src/wrap/pty.ts
-import { chmodSync as chmodSync9, existsSync as existsSync15, statSync as statSync8 } from "fs";
-import { createRequire as createRequire2 } from "module";
-import { dirname as dirname8, join as join25 } from "path";
-var req = createRequire2(import.meta.url);
-function fixSpawnHelper() {
-  if (process.platform !== "darwin") return;
-  try {
-    const dir = join25(dirname8(req.resolve("node-pty/package.json")), "prebuilds", `darwin-${process.arch}`);
-    const helper = join25(dir, "spawn-helper");
-    if (existsSync15(helper) && (statSync8(helper).mode & 73) === 0) chmodSync9(helper, 493);
-  } catch {
-  }
-}
-function loadPty() {
-  try {
-    fixSpawnHelper();
-    const m = req("node-pty");
-    return typeof m?.spawn === "function" ? m : null;
-  } catch {
-    return null;
-  }
-}
-function loadHeadless() {
-  try {
-    const m = req("@xterm/headless");
-    return typeof m?.Terminal === "function" ? m.Terminal : null;
-  } catch {
-    return null;
-  }
-}
-function screenLines(term) {
-  const b = term.buffer.active;
-  const out = [];
-  for (let i = b.viewportY; i < b.viewportY + term.rows; i++) {
-    const l = b.getLine(i);
-    out.push(l ? l.translateToString(true) : "");
-  }
-  return out;
-}
-function screenLinesUndimmed(term) {
-  const b = term.buffer.active;
-  const out = [];
-  for (let i = b.viewportY; i < b.viewportY + term.rows; i++) {
-    const l = b.getLine(i);
-    if (!l) {
-      out.push("");
-      continue;
-    }
-    if (typeof l.getCell !== "function") {
-      out.push(l.translateToString(true));
-      continue;
-    }
-    let s = "";
-    for (let x = 0; x < term.cols; x++) {
-      const c = l.getCell(x);
-      if (!c) break;
-      const w = c.getWidth();
-      if (w === 0) continue;
-      s += c.isDim() ? " ".repeat(w) : c.getChars() || " ";
-    }
-    out.push(s.trimEnd());
-  }
-  return out;
-}
-
 // src/commands/enable.ts
 function stdout(line) {
   process.stdout.write(line + "\n");
@@ -6492,14 +7235,14 @@ function installTools(tools, out, shim = defaultShimEnvForInstall()) {
     installed.push(tool);
     out(`\u2705 ${tool}\uFF1Ahook \u5DF2\u88C5\u8FDB ${configPath2}\uFF08${events.length} \u4E2A\u4E8B\u4EF6\uFF09`);
     try {
-      if (adapter.installWindowGate?.(configPath2, join26(dirname9(hookPath), "gate.cjs"), tool)) {
+      if (adapter.installWindowGate?.(configPath2, join28(dirname11(hookPath), "gate.cjs"), tool)) {
         out(`   \u7A97\u53E3\u91CC\u5F39\u6388\u6743\u6846\u65F6\uFF0C\u8BBE\u5907\u4E0A\u4E5F\u80FD\u786E\u8BA4\uFF08\u5B88\u62A4\u8FDB\u7A0B\u5728\u8DD1\u65F6\u751F\u6548\uFF09`);
       }
     } catch (e) {
       out(`\u26A0\uFE0F  ${tool}\uFF1A\u8BBE\u5907\u786E\u8BA4\u6388\u6743\u6CA1\u88C5\u4E0A\uFF1A${e.message}`);
     }
     try {
-      if (adapter.installRewake?.(configPath2, join26(dirname9(hookPath), "wake.cjs"), tool)) {
+      if (adapter.installRewake?.(configPath2, join28(dirname11(hookPath), "wake.cjs"), tool)) {
         out(`   \u7A97\u53E3\u5F00\u7740\u65F6\uFF0C\u8BBE\u5907\u6307\u4EE4\u76F4\u63A5\u5728\u8FD9\u4E2A\u7A97\u53E3\u91CC\u6267\u884C\uFF08\u5B88\u62A4\u8FDB\u7A0B\u5728\u8DD1\u65F6\u751F\u6548\uFF09`);
       }
     } catch (e) {
@@ -6526,8 +7269,9 @@ async function runEnable(tools, opts = {}) {
   if (!opts.skipRefresh) await refreshRegistry();
   const { failed } = installTools(tools, out, opts.shim === void 0 ? defaultShimEnvForInstall() : opts.shim);
   if (!opts.skipAutostart) {
-    const r = await installAutostart({ execPath: process.execPath, cliPath: defaultCliPath() });
     out("");
+    const target = autostartTarget(out);
+    const r = process.env.DESKBUDDY_SKIP_AUTOSTART === "1" ? { ok: false, message: "\u5DF2\u6309 DESKBUDDY_SKIP_AUTOSTART \u8DF3\u8FC7\u5F00\u673A\u81EA\u542F" } : await installAutostart(target);
     out(r.ok ? `\u2705 ${r.message}` : `\u26A0\uFE0F  ${r.message}`);
   }
   out("");
@@ -6599,12 +7343,12 @@ async function runDisable(tools, opts = {}) {
 }
 
 // src/commands/install.ts
-import { mkdirSync as mkdirSync22, rmSync as rmSync15, writeFileSync as writeFileSync22 } from "fs";
-import { join as join27 } from "path";
+import { mkdirSync as mkdirSync24, rmSync as rmSync17, writeFileSync as writeFileSync23 } from "fs";
+import { join as join29 } from "path";
 
 // src/core/detect.ts
-import { existsSync as existsSync16 } from "fs";
-import { dirname as dirname10 } from "path";
+import { existsSync as existsSync18 } from "fs";
+import { dirname as dirname12 } from "path";
 var ALL_TOOLS = ["claude_code", "codex", "workbuddy", "qoder", "opencode"];
 function toolConfigDir(tool) {
   switch (tool) {
@@ -6613,18 +7357,18 @@ function toolConfigDir(tool) {
     case "codex":
       return codexHome();
     case "workbuddy":
-      return dirname10(workbuddySettingsPath());
+      return dirname12(workbuddySettingsPath());
     case "qoder":
-      return dirname10(qoderSettingsPath());
+      return dirname12(qoderSettingsPath());
     case "opencode":
-      return dirname10(dirname10(opencodePluginPath()));
+      return dirname12(dirname12(opencodePluginPath()));
     default:
       return null;
   }
 }
 var defaultDetectDeps = () => ({
   located: (tool) => locate(tool) != null,
-  exists: existsSync16,
+  exists: existsSync18,
   env: process.env
 });
 function callerTool(env) {
@@ -6645,19 +7389,19 @@ function detectTools(d = defaultDetectDeps()) {
 import qrcode from "qrcode-terminal";
 
 // src/commands/remoteCwd.ts
-import { existsSync as existsSync17, statSync as statSync9 } from "fs";
+import { existsSync as existsSync19, statSync as statSync9 } from "fs";
 import { createInterface } from "readline";
 import { homedir as homedir7 } from "os";
-import { isAbsolute as isAbsolute2, resolve as resolve3 } from "path";
+import { isAbsolute as isAbsolute2, resolve as resolve4 } from "path";
 function normalizePath(raw, home = homedir7()) {
   const s = (raw || "").trim();
   if (!s) return null;
-  const expanded = s === "~" ? home : s.startsWith("~/") || process.platform === "win32" && s.startsWith("~\\") ? resolve3(home, s.slice(2)) : s;
-  const abs = isAbsolute2(expanded) ? expanded : resolve3(process.cwd(), expanded);
+  const expanded = s === "~" ? home : s.startsWith("~/") || process.platform === "win32" && s.startsWith("~\\") ? resolve4(home, s.slice(2)) : s;
+  const abs = isAbsolute2(expanded) ? expanded : resolve4(process.cwd(), expanded);
   return abs;
 }
 function checkPath(abs) {
-  if (!existsSync17(abs)) return "missing";
+  if (!existsSync19(abs)) return "missing";
   try {
     return statSync9(abs).isDirectory() ? "ok" : "not_a_dir";
   } catch {
@@ -6863,11 +7607,11 @@ function inSandbox(env) {
 }
 function precheckWritable(dirs) {
   for (const dir of dirs) {
-    const probe = join27(dir, `.deskbuddy-probe-${process.pid}`);
+    const probe = join29(dir, `.deskbuddy-probe-${process.pid}`);
     try {
-      mkdirSync22(dir, { recursive: true });
-      writeFileSync22(probe, "");
-      rmSync15(probe, { force: true });
+      mkdirSync24(dir, { recursive: true });
+      writeFileSync23(probe, "");
+      rmSync17(probe, { force: true });
     } catch (e) {
       return { ok: false, dir, error: e.message };
     }
@@ -6884,7 +7628,7 @@ var defaultInstallDeps = () => ({
   refreshRegistry: () => refreshRegistry().catch(() => void 0),
   installTools,
   // DESKBUDDY_SKIP_AUTOSTART=1 只给端到端测试用：自启会真去动 launchd / systemd，并停掉本机正在跑的 daemon
-  autostart: () => process.env.DESKBUDDY_SKIP_AUTOSTART === "1" ? Promise.resolve({ ok: false, message: "\u5DF2\u6309 DESKBUDDY_SKIP_AUTOSTART \u8DF3\u8FC7" }) : installAutostart({ execPath: process.execPath, cliPath: defaultCliPath() })
+  autostart: () => process.env.DESKBUDDY_SKIP_AUTOSTART === "1" ? Promise.resolve({ ok: false, message: "\u5DF2\u6309 DESKBUDDY_SKIP_AUTOSTART \u8DF3\u8FC7" }) : installAutostart(autostartTarget())
 });
 function summary(out, lines2) {
   out("");
@@ -6996,16 +7740,16 @@ async function runInstall(opts, deps = defaultInstallDeps()) {
 
 // src/commands/logout.ts
 import { createInterface as createInterface2 } from "readline";
-import { existsSync as existsSync18, rmSync as rmSync16 } from "fs";
+import { existsSync as existsSync20, rmSync as rmSync18 } from "fs";
 function stdout4(line) {
   process.stdout.write(line + "\n");
 }
 function askYesNo(question) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const rl = createInterface2({ input: process.stdin, output: process.stdout });
     rl.question(question, (answer) => {
       rl.close();
-      resolve5(/^(y|yes)$/i.test(answer.trim()));
+      resolve6(/^(y|yes)$/i.test(answer.trim()));
     });
   });
 }
@@ -7027,8 +7771,8 @@ async function runLogout(opts = {}) {
     }
   }
   await runDisable([], { out, brief: true, keepAutostart: opts.keepAutostart });
-  if (existsSync18(home)) {
-    rmSync16(home, { recursive: true, force: true });
+  if (existsSync20(home)) {
+    rmSync18(home, { recursive: true, force: true });
   }
   out("");
   out("\u2705 \u5DF2\u6E05\u9664\u672C\u673A\u7684 DeskBuddy \u6570\u636E\u3002");
@@ -7172,6 +7916,7 @@ function stdout6(line) {
   process.stdout.write(line + "\n");
 }
 async function runUpdate(opts = {}) {
+  if (opts.auto) return runAutoSwitch(opts);
   const out = opts.out ?? stdout6;
   const cfg = loadConfig();
   if (!cfg.boundAt) {
@@ -7186,11 +7931,35 @@ async function runUpdate(opts = {}) {
   out("");
   return runEnable([...cfg.enabledTools], opts);
 }
+async function runAutoSwitch(opts) {
+  const out = opts.out ?? ((line) => log(`[\u81EA\u52A8\u5347\u7EA7] ${line}`));
+  const cfg = loadConfig();
+  if (!cfg.boundAt) {
+    out("\u8FD8\u6CA1\u6709\u6388\u6743\uFF0C\u4E0D\u5207\u6362");
+    return 1;
+  }
+  out(`\u5207\u6362\u5230 ${packageVersion()}`);
+  if (cfg.enabledTools.length > 0) {
+    try {
+      installTools([...cfg.enabledTools], out, opts.shim);
+    } catch (e) {
+      out(`\u91CD\u88C5 hook \u51FA\u9519\uFF1A${e.message}\uFF08\u7EE7\u7EED\u5207\u6362\uFF09`);
+    }
+  }
+  const from = switchFromEnv();
+  delete process.env[FROM_VERSION_ENV];
+  delete process.env[FROM_CLI_ENV];
+  const target = autostartTarget(out, from);
+  if (opts.skipAutostart || process.env.DESKBUDDY_SKIP_AUTOSTART === "1") return 0;
+  const r = await installAutostart(target, process.platform, { auto: true });
+  out(r.message);
+  return r.ok ? 0 : 1;
+}
 
 // src/wrap/run.ts
 import { randomBytes as randomBytes8 } from "crypto";
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync24, statSync as statSync11, truncateSync as truncateSync3 } from "fs";
-import { join as join29 } from "path";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync26, statSync as statSync11, truncateSync as truncateSync3 } from "fs";
+import { join as join31 } from "path";
 import { StringDecoder } from "string_decoder";
 
 // src/wrap/injector.ts
@@ -7438,10 +8207,10 @@ var Injector = class {
 };
 
 // src/wrap/passthrough.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { realpathSync as realpathSync3 } from "fs";
 import { constants as constants2 } from "os";
-import { dirname as dirname11, resolve as resolve4 } from "path";
+import { dirname as dirname13, resolve as resolve5 } from "path";
 var CLAUDE_SUBCOMMANDS = /* @__PURE__ */ new Set([
   "agents",
   "attach",
@@ -7492,7 +8261,7 @@ function passthroughReason(i) {
   return null;
 }
 function norm2(p, win) {
-  const r = resolve4(p).replace(/[\\/]+$/, "");
+  const r = resolve5(p).replace(/[\\/]+$/, "");
   return win ? r.replace(/\//g, "\\").toLowerCase() : r;
 }
 function real(p) {
@@ -7505,7 +8274,7 @@ function real(p) {
 function findReal(tool, d = defaultLocateDeps(), skip = shimDir()) {
   const win = (d.platform ?? process.platform) === "win32";
   const skipKeys = /* @__PURE__ */ new Set([norm2(skip, win), norm2(real(skip), win)]);
-  const inSkip = (file) => skipKeys.has(norm2(dirname11(file), win)) || skipKeys.has(norm2(dirname11(real(file)), win));
+  const inSkip = (file) => skipKeys.has(norm2(dirname13(file), win)) || skipKeys.has(norm2(dirname13(real(file)), win));
   const dd = { ...d, skipDirs: [...d.skipDirs ?? [], skip] };
   const name = SHIM_COMMANDS[tool];
   if (!name) {
@@ -7534,7 +8303,7 @@ function runDirect(real2, args, env = process.env) {
   return new Promise((done) => {
     let child;
     try {
-      child = spawn3(real2.file, [...real2.prefixArgs, ...args], {
+      child = spawn4(real2.file, [...real2.prefixArgs, ...args], {
         stdio: "inherit",
         // 🔴 再经过垫片也直接放行，不会绕回来
         env: withoutShimFlag({ ...env, DESKBUDDY_WRAPPED: "1" }),
@@ -7584,21 +8353,21 @@ function runDirect(real2, args, env = process.env) {
 }
 
 // src/wrap/codexLaunch.ts
-import { spawn as spawn4 } from "child_process";
-import { closeSync as closeSync3, mkdirSync as mkdirSync23, openSync as openSync3, readdirSync as readdirSync6, readFileSync as readFileSync21, rmSync as rmSync17, statSync as statSync10, truncateSync as truncateSync2, writeFileSync as writeFileSync23, renameSync as renameSync16 } from "fs";
+import { spawn as spawn5 } from "child_process";
+import { closeSync as closeSync4, mkdirSync as mkdirSync25, openSync as openSync4, readdirSync as readdirSync7, readFileSync as readFileSync22, rmSync as rmSync19, statSync as statSync10, truncateSync as truncateSync2, writeFileSync as writeFileSync24, renameSync as renameSync17 } from "fs";
 import { request } from "http";
 import { createServer as createServer4 } from "net";
-import { join as join28 } from "path";
+import { join as join30 } from "path";
 
 // src/core/codexServer.ts
-import { execFileSync as execFileSync11 } from "child_process";
+import { execFileSync as execFileSync13 } from "child_process";
 function isAppServerArgs(args, url) {
   return /\bapp-server\b/.test(args) && new RegExp(`--listen[= ]${url.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?:\\s|$)`).test(args);
 }
 function processArgs(pid) {
   if (process.platform === "win32") return null;
   try {
-    const out = execFileSync11("ps", ["-ww", "-o", "args=", "-p", String(pid)], {
+    const out = execFileSync13("ps", ["-ww", "-o", "args=", "-p", String(pid)], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -7756,12 +8525,12 @@ async function runCodexWindow(real2, args, d) {
 }
 var MAX_LOG_BYTES2 = 1024 * 1024;
 function appServerLogPath() {
-  return join28(deskbuddyHome(), "codex-app-server.log");
+  return join30(deskbuddyHome(), "codex-app-server.log");
 }
 function windowsDir2() {
-  return join28(deskbuddyHome(), "codex-windows");
+  return join30(deskbuddyHome(), "codex-windows");
 }
-function pidAlive(pid) {
+function pidAlive2(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -7772,50 +8541,50 @@ function pidAlive(pid) {
 function daemonAlive(pidFile = pidFilePath(), args = processArgs) {
   let pid = 0;
   try {
-    pid = Number(readFileSync21(pidFile, "utf8").trim());
+    pid = Number(readFileSync22(pidFile, "utf8").trim());
   } catch {
     return false;
   }
-  if (!Number.isInteger(pid) || pid <= 0 || !pidAlive(pid)) return false;
+  if (!Number.isInteger(pid) || pid <= 0 || !pidAlive2(pid)) return false;
   const a = args(pid);
   return !!a && /cli\.js daemon(?:\s|$)/.test(a);
 }
 function probeReady(url) {
   const port = Number(url.slice(url.lastIndexOf(":") + 1));
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const req2 = request({ host: "127.0.0.1", port, path: "/readyz", method: "GET", timeout: 800 }, (res) => {
       res.resume();
-      resolve5((res.statusCode ?? 0) >= 200 && (res.statusCode ?? 0) < 300);
+      resolve6((res.statusCode ?? 0) >= 200 && (res.statusCode ?? 0) < 300);
     });
     req2.on("timeout", () => req2.destroy());
-    req2.on("error", () => resolve5(false));
+    req2.on("error", () => resolve6(false));
     req2.end();
   });
 }
 function freePort() {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const srv = createServer4();
     srv.unref();
     srv.on("error", reject);
     srv.listen(0, "127.0.0.1", () => {
       const addr = srv.address();
       const port = typeof addr === "object" && addr ? addr.port : 0;
-      srv.close(() => port ? resolve5(port) : reject(new Error("no port")));
+      srv.close(() => port ? resolve6(port) : reject(new Error("no port")));
     });
   });
 }
 function startServer(real2, url, env, cwd) {
   const logPath2 = appServerLogPath();
-  mkdirSync23(deskbuddyHome(), { recursive: true });
+  mkdirSync25(deskbuddyHome(), { recursive: true });
   try {
     if (statSync10(logPath2).size > MAX_LOG_BYTES2) truncateSync2(logPath2, 0);
   } catch {
   }
-  const fd = openSync3(logPath2, "a");
+  const fd = openSync4(logPath2, "a");
   try {
     const childEnv2 = { ...env, DESKBUDDY_WRAPPED: "1" };
     delete childEnv2.DESKBUDDY_SHIM;
-    const child = spawn4(real2.file, [...real2.prefixArgs, "app-server", "--listen", url], {
+    const child = spawn5(real2.file, [...real2.prefixArgs, "app-server", "--listen", url], {
       detached: true,
       stdio: ["ignore", fd, fd],
       cwd,
@@ -7826,7 +8595,7 @@ function startServer(real2, url, env, cwd) {
     child.unref();
     return child.pid ?? null;
   } finally {
-    closeSync3(fd);
+    closeSync4(fd);
   }
 }
 function killServer(pid) {
@@ -7840,41 +8609,41 @@ function killOwnServer(pid, url) {
   if (a && isAppServerArgs(a, url)) killServer(pid);
 }
 function recordPath(rec) {
-  return join28(windowsDir2(), `${rec.server}.json`);
+  return join30(windowsDir2(), `${rec.server}.json`);
 }
 function writeRecord(rec) {
   try {
-    mkdirSync23(windowsDir2(), { recursive: true, mode: 448 });
+    mkdirSync25(windowsDir2(), { recursive: true, mode: 448 });
     const p = recordPath(rec);
-    writeFileSync23(p + ".tmp", JSON.stringify(rec), { encoding: "utf8", mode: 384 });
-    renameSync16(p + ".tmp", p);
+    writeFileSync24(p + ".tmp", JSON.stringify(rec), { encoding: "utf8", mode: 384 });
+    renameSync17(p + ".tmp", p);
   } catch {
   }
 }
 function removeRecord(rec) {
   try {
-    rmSync17(recordPath(rec), { force: true });
+    rmSync19(recordPath(rec), { force: true });
   } catch {
   }
 }
-function reapWindows(dir = windowsDir2(), alive = pidAlive, args = processArgs, kill = killServer) {
+function reapWindows(dir = windowsDir2(), alive = pidAlive2, args = processArgs, kill = killServer) {
   let names = [];
   try {
-    names = readdirSync6(dir).filter((n) => n.endsWith(".json"));
+    names = readdirSync7(dir).filter((n) => n.endsWith(".json"));
   } catch {
     return;
   }
   for (const n of names) {
-    const p = join28(dir, n);
+    const p = join30(dir, n);
     let rec;
     try {
-      rec = JSON.parse(readFileSync21(p, "utf8"));
+      rec = JSON.parse(readFileSync22(p, "utf8"));
     } catch {
-      rmSync17(p, { force: true });
+      rmSync19(p, { force: true });
       continue;
     }
     if (typeof rec.supervisor !== "number" || typeof rec.server !== "number" || typeof rec.url !== "string") {
-      rmSync17(p, { force: true });
+      rmSync19(p, { force: true });
       continue;
     }
     if (alive(rec.supervisor)) continue;
@@ -7882,13 +8651,13 @@ function reapWindows(dir = windowsDir2(), alive = pidAlive, args = processArgs,
       const a = args(rec.server);
       if (a && isAppServerArgs(a, rec.url)) kill(rec.server);
     }
-    rmSync17(p, { force: true });
+    rmSync19(p, { force: true });
   }
 }
 function launchLog(line) {
   try {
-    mkdirSync23(deskbuddyHome(), { recursive: true });
-    writeFileSync23(join28(deskbuddyHome(), "wrap.log"), `${(/* @__PURE__ */ new Date()).toISOString()} [codex ${process.pid}] ${line}
+    mkdirSync25(deskbuddyHome(), { recursive: true });
+    writeFileSync24(join30(deskbuddyHome(), "wrap.log"), `${(/* @__PURE__ */ new Date()).toISOString()} [codex ${process.pid}] ${line}
 `, { flag: "a" });
   } catch {
   }
@@ -7928,8 +8697,8 @@ function childEnv(src, windowId) {
 }
 function wrapLog(line) {
   try {
-    const p = join29(deskbuddyHome(), "wrap.log");
-    mkdirSync24(deskbuddyHome(), { recursive: true });
+    const p = join31(deskbuddyHome(), "wrap.log");
+    mkdirSync26(deskbuddyHome(), { recursive: true });
     try {
       if (statSync11(p).size > MAX_LOG_BYTES3) truncateSync3(p, 0);
     } catch {
@@ -8219,7 +8988,7 @@ function runAttached(tool, p, term0, windowId, deps, launched = false) {
     injector.tick().catch(() => {
     });
   }, TICK_MS);
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     let degraded = false;
     const onFatal = (e) => {
       deps.log(`\u5305\u88C5\u5C42\u5F02\u5E38\uFF1A${e?.stack ?? String(e)}`);
@@ -8270,8 +9039,8 @@ ${WRAP_HINT}\uFF08\u8BBE\u5907\u56DE\u590D\u6682\u65F6\u5199\u4E0D\u8FDB\u8FD9\u
       restoreTerminal();
       process.removeListener("uncaughtException", onFatal);
       for (const [s, h] of sigHandlers) process.removeListener(s, h);
-      if (pending > 0) setTimeout(() => resolve5(code), 150);
-      else resolve5(code);
+      if (pending > 0) setTimeout(() => resolve6(code), 150);
+      else resolve6(code);
     }
     process.on("uncaughtException", onFatal);
     for (const [s, h] of sigHandlers) {
@@ -8298,7 +9067,8 @@ var USAGE = `deskbuddy \u2014\u2014 \u628A AI \u7F16\u7801\u667A\u80FD\u4F53\u6B
   deskbuddy enable <tool[,tool]>        \u5B89\u88C5\u91C7\u96C6 hook\uFF08\u5982 claude_code,codex\uFF09
   deskbuddy disable [tool[,tool]]       \u79FB\u9664\u91C7\u96C6 hook\uFF08\u4E0D\u5E26\u53C2\u6570=\u5168\u90E8\uFF09
   deskbuddy update                      \u5347\u7EA7\u5230\u5F53\u524D\u8FD9\u7248\uFF1A\u91CD\u88C5\u5DF2\u542F\u7528\u5DE5\u5177\u7684 hook\u3001\u91CD\u542F daemon
-                                        \uFF08npx deskbuddy@<\u7248\u672C> update\uFF09
+                                        \uFF08npx deskbuddy@<\u7248\u672C> update\uFF1B\u4E4B\u540E\u7531 daemon \u81EA\u52A8\u5347\u7EA7\uFF0C
+                                        config.json \u91CC "autoUpdate": false \u53EF\u5173\u95ED\uFF09
   deskbuddy daemon [--foreground]       \u5E38\u9A7B\u6536\u53D6\u8BBE\u5907\u4E0B\u53D1\u7684\u6307\u4EE4\uFF08\u5F00\u673A\u81EA\u542F\u4F1A\u81EA\u52A8\u62C9\u8D77\uFF09
   deskbuddy status                      \u770B\u91C7\u96C6\u5230\u4E86\u4EC0\u4E48\u3001\u4E0A\u62A5\u4E86\u54EA\u4E9B\u5B57\u6BB5
   deskbuddy logout [--yes]              \u79FB\u9664 hook \u5E76\u6E05\u9664\u672C\u673A\u6570\u636E
@@ -8338,7 +9108,7 @@ async function main(argv) {
     case "disable":
       return runDisable(parseTools(arg));
     case "update":
-      return runUpdate();
+      return runUpdate({ auto: argv.includes("--auto") });
     case "daemon":
       return runDaemonCommand({ foreground: argv.includes("--foreground") || argv.includes("-f") });
     case "status":