deskbuddy 0.1.0 → 0.2.0-beta.1

package/dist/cli.js

@@ -1,10 +1,16 @@
 #!/usr/bin/env node
 
+// src/commands/daemon.ts
+import { writeFileSync as writeFileSync11, rmSync as rmSync4 } from "fs";
+
 // src/core/config.ts
 import { randomUUID } from "crypto";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
 import { homedir, hostname } from "os";
 import { join } from "path";
+function defaultRemoteCwd(home = homedir()) {
+  return join(home, "Desktop");
+}
 var PROD_API_BASE = "https://api.shifengintelli.com";
 var TEST_API_BASE = "https://test-api.shifengintelli.com";
 var DEFAULT_API_BASE = process.env.DESKBUDDY_API_BASE || PROD_API_BASE;
@@ -38,6 +44,16 @@ function claudeHome() {
 function claudeSettingsPath() {
   return join(claudeHome(), "settings.json");
 }
+function workbuddySettingsPath() {
+  return join(process.env.CODEBUDDY_CONFIG_DIR || join(homedir(), ".workbuddy"), "settings.json");
+}
+function qoderSettingsPath() {
+  return join(process.env.DESKBUDDY_QODER_DIR || join(homedir(), ".qoder-cn"), "settings.json");
+}
+function opencodePluginPath() {
+  const base = process.env.DESKBUDDY_OPENCODE_DIR || join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "opencode");
+  return join(base, "plugin", "deskbuddy.js");
+}
 function codexHome() {
   return process.env.CODEX_HOME || join(homedir(), ".codex");
 }
@@ -64,7 +80,10 @@ function loadConfig() {
       // ⚠️ 这里是逐字段重建对象，不是展开 parsed —— 新增字段【必须】在这里也加一行，
       // 否则它写得进 config.json、却永远读不出来（saveConfig 存的是本函数的返回值，
       // 于是下一次保存还会把它抹掉），而且全程不报错
-      boundApiBase: parsed.boundApiBase
+      boundApiBase: parsed.boundApiBase,
+      remoteCwd: parsed.remoteCwd,
+      // 不认识的值一律回落默认，不能让一个手滑写错的配置变成"全放行"或"全拦"
+      approvalPolicy: parsed.approvalPolicy === "all" ? "all" : parsed.approvalPolicy === "commands" ? "commands" : void 0
     };
   } catch {
     return fallback;
@@ -85,33 +104,321 @@ function ensureClientId() {
   return config.clientId;
 }
 
-// src/core/registry.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { join as join3 } from "path";
+// src/daemon/autostart.ts
+import { execFile } from "child_process";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { fileURLToPath } from "url";
+import { basename, dirname, join as join2 } from "path";
+import { promisify } from "util";
+var run = promisify(execFile);
+var LAUNCH_LABEL = "com.deskbuddy.daemon";
+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;
+  return sibling;
+}
+function xmlEscape(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function launchAgentPlist(t) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${LAUNCH_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${xmlEscape(t.execPath)}</string>
+    <string>${xmlEscape(t.cliPath)}</string>
+    <string>daemon</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key>
+  <dict><key>SuccessfulExit</key><false/></dict>
+  <key>ProcessType</key><string>Background</string>
+</dict>
+</plist>
+`;
+}
+function systemdUnit(t) {
+  return `[Unit]
+Description=DeskBuddy daemon
 
-// src/core/api.ts
+[Service]
+ExecStart=${t.execPath} ${t.cliPath} daemon
+Restart=on-failure
+RestartSec=10
+
+[Install]
+WantedBy=default.target
+`;
+}
+function launchAgentPath(home = homedir2()) {
+  return join2(home, "Library", "LaunchAgents", `${LAUNCH_LABEL}.plist`);
+}
+function systemdUnitPath(home = homedir2()) {
+  return join2(home, ".config", "systemd", "user", SYSTEMD_UNIT);
+}
+function write(path, content) {
+  mkdirSync2(dirname(path), { recursive: true });
+  writeFileSync2(path, content, "utf8");
+}
+var BOOTSTRAP_RETRIES = 10;
+var BOOTSTRAP_RETRY_MS = 500;
+async function installAutostart(t, platform = process.platform) {
+  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));
+        }
+      }
+      return { ok: true, message: "\u5DF2\u8BBE\u7F6E\u5F00\u673A\u81EA\u542F\uFF08launchd\uFF09" };
+    }
+    if (platform === "linux") {
+      write(systemdUnitPath(), systemdUnit(t));
+      await run("systemctl", ["--user", "daemon-reload"]);
+      await run("systemctl", ["--user", "enable", "--now", SYSTEMD_UNIT]);
+      await run("systemctl", ["--user", "restart", SYSTEMD_UNIT]);
+      return { ok: true, message: "\u5DF2\u8BBE\u7F6E\u5F00\u673A\u81EA\u542F\uFF08systemd --user\uFF09" };
+    }
+    if (platform === "win32") {
+      await run("schtasks", [
+        "/create",
+        "/f",
+        "/sc",
+        "onlogon",
+        "/rl",
+        "LIMITED",
+        "/tn",
+        SCHTASK_NAME,
+        "/tr",
+        `"${t.execPath}" "${t.cliPath}" daemon`
+      ]);
+      return { ok: true, message: "\u5DF2\u8BBE\u7F6E\u5F00\u673A\u81EA\u542F\uFF08\u8BA1\u5212\u4EFB\u52A1\uFF09" };
+    }
+    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) {
+    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` };
+  }
+}
+async function uninstallAutostart(platform = process.platform) {
+  try {
+    if (platform === "darwin") {
+      await run("launchctl", ["bootout", `gui/${process.getuid?.() ?? 501}/${LAUNCH_LABEL}`]).catch(() => {
+      });
+      const p = launchAgentPath();
+      if (existsSync2(p)) rmSync(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 });
+      await run("systemctl", ["--user", "daemon-reload"]).catch(() => {
+      });
+      return { ok: true, message: "\u5DF2\u53D6\u6D88\u5F00\u673A\u81EA\u542F" };
+    }
+    if (platform === "win32") {
+      await run("schtasks", ["/delete", "/f", "/tn", SCHTASK_NAME]).catch(() => {
+      });
+      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 join2(deskbuddyHome(), "daemon.pid");
+}
+
+// src/daemon/index.ts
+import { randomBytes as randomBytes5 } from "crypto";
+import { existsSync as existsSync10 } from "fs";
+import { basename as basename6 } from "path";
+import WebSocket2 from "ws";
+
+// src/adapters/ocPlugin.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+var OC_MARKER = "// deskbuddy:opencode-plugin";
+function ocPluginSource(pluginModule, nodePath) {
+  return [
+    OC_MARKER,
+    "// \u7531 deskbuddy enable opencode \u751F\u6210\uFF0Cdeskbuddy disable opencode \u4F1A\u5220\u6389\u5B83\u3002",
+    `import { make } from ${JSON.stringify(pluginModule)}`,
+    `export const DeskBuddy = make({ node: ${JSON.stringify(nodePath)} })`,
+    ""
+  ].join("\n");
+}
+function ocPluginModule(hookPath) {
+  return join3(dirname2(hookPath), "opencode.mjs");
+}
+function installOcPlugin(pluginPath, hookPath, nodePath) {
+  if (existsSync3(pluginPath) && !readFileSync2(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 });
+  const tmp = pluginPath + ".deskbuddy.tmp";
+  writeFileSync3(tmp, ocPluginSource(ocPluginModule(hookPath), nodePath), "utf8");
+  renameSync2(tmp, pluginPath);
+}
+function uninstallOcPlugin(pluginPath) {
+  try {
+    if (readFileSync2(pluginPath, "utf8").includes(OC_MARKER)) unlinkSync(pluginPath);
+  } catch {
+  }
+}
+function isOcPluginInstalled(pluginPath) {
+  try {
+    return readFileSync2(pluginPath, "utf8").includes(OC_MARKER);
+  } catch {
+    return false;
+  }
+}
+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 mkdirSync4, readdirSync, readFileSync as readFileSync3, renameSync as renameSync3, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
+import { join as join4 } from "path";
+
+// src/core/process.ts
 import { execFileSync } from "child_process";
+function processName(pid) {
+  try {
+    const out = execFileSync("ps", ["-p", String(pid), "-o", "comm="], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const name = out.trim();
+    return name === "" ? null : name;
+  } catch {
+    return null;
+  }
+}
+function isAlive(pid, expectName) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+  } catch {
+    return false;
+  }
+  if (!expectName) return true;
+  const name = processName(pid);
+  return name != null && name.toLowerCase().includes(expectName.toLowerCase());
+}
+
+// src/core/state.ts
+function stateDir() {
+  return join4(deskbuddyHome(), "state");
+}
+function statePath(sessionId) {
+  const safe = sessionId.replace(/[^A-Za-z0-9_-]/g, "");
+  return join4(stateDir(), `${safe || "unknown"}.json`);
+}
+function readState(sessionId) {
+  try {
+    return JSON.parse(readFileSync3(statePath(sessionId), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function removeState(sessionId) {
+  try {
+    rmSync2(statePath(sessionId), { force: true });
+  } catch {
+  }
+}
+function readAliveStates(tool) {
+  if (!existsSync4(stateDir())) return [];
+  const alive = [];
+  for (const file of readdirSync(stateDir())) {
+    if (!file.endsWith(".json")) continue;
+    let s;
+    try {
+      s = JSON.parse(readFileSync3(join4(stateDir(), file), "utf8"));
+    } catch {
+      rmSync2(join4(stateDir(), file), { force: true });
+      continue;
+    }
+    if (s.tool !== tool) continue;
+    if (s.pid && !isAlive(s.pid, s.pidName)) {
+      removeState(s.sessionId);
+      continue;
+    }
+    alive.push(s);
+  }
+  return alive;
+}
+function noticeDir() {
+  return join4(deskbuddyHome(), "notice");
+}
+function writeNotice(sessionId, text, now = Date.now()) {
+  try {
+    const safe = sessionId.replace(/[^A-Za-z0-9_-]/g, "");
+    if (!safe) return;
+    mkdirSync4(noticeDir(), { recursive: true });
+    const file = join4(noticeDir(), `${safe}.json`);
+    writeFileSync4(file + ".tmp", JSON.stringify({ text, at: now }), "utf8");
+    renameSync3(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(readFileSync3(join4(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 execFileSync2 } from "child_process";
 import { createHash, randomBytes, randomUUID as randomUUID2 } from "crypto";
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import { release } from "os";
 
 // src/core/hookFile.ts
-import { copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { copyFileSync, existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync4, renameSync as renameSync4, writeFileSync as writeFileSync5 } from "fs";
 import { createRequire } from "module";
-import { dirname, join as join2 } from "path";
-import { fileURLToPath } from "url";
-var here = dirname(fileURLToPath(import.meta.url));
+import { dirname as dirname3, join as join5 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var here = dirname3(fileURLToPath2(import.meta.url));
 function packagedHookPath() {
   const candidates = [
-    join2(here, "hook.cjs"),
+    join5(here, "hook.cjs"),
     // dist/cli.js 旁边（发布形态）
-    join2(here, "..", "hook", "hook.cjs"),
+    join5(here, "..", "hook", "hook.cjs"),
     // dist/../hook/
-    join2(here, "..", "..", "hook", "hook.cjs")
+    join5(here, "..", "..", "hook", "hook.cjs")
     // src/core/../../hook/（开发形态）
   ];
   for (const c of candidates) {
-    if (existsSync2(c)) return c;
+    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");
 }
@@ -127,23 +434,41 @@ function packageVersion() {
   return "0.0.0-dev";
 }
 function hookVersionPath(target = installedHookPath()) {
-  return join2(dirname(target), "hook-version");
+  return join5(dirname3(target), "hook-version");
 }
 function installedHookVersion(target = installedHookPath()) {
   try {
-    return readFileSync2(hookVersionPath(target), "utf8").trim() || null;
+    return readFileSync4(hookVersionPath(target), "utf8").trim() || null;
   } catch {
     return null;
   }
 }
+function atomicCopy(from, to) {
+  const tmp = `${to}.${process.pid}.tmp`;
+  copyFileSync(from, tmp);
+  renameSync4(tmp, to);
+}
 function syncHookFile(opts = {}) {
   const target = opts.target ?? installedHookPath();
   const version = opts.version ?? packageVersion();
-  if (installedHookVersion(target) === version && existsSync2(target)) return false;
+  const SIBLINGS = ["gate.cjs", "opencode.mjs"];
+  const siblingMissing = () => SIBLINGS.some((name) => {
+    if (existsSync5(join5(dirname3(target), name))) return false;
+    try {
+      return existsSync5(join5(dirname3(opts.source ?? packagedHookPath()), name));
+    } catch {
+      return false;
+    }
+  });
+  if (installedHookVersion(target) === version && existsSync5(target) && !siblingMissing()) return false;
   const source = opts.source ?? packagedHookPath();
-  mkdirSync2(dirname(target), { recursive: true });
-  copyFileSync(source, target);
-  writeFileSync2(hookVersionPath(target), version, "utf8");
+  mkdirSync5(dirname3(target), { recursive: true });
+  atomicCopy(source, target);
+  for (const name of SIBLINGS) {
+    const from = join5(dirname3(source), name);
+    if (existsSync5(from)) atomicCopy(from, join5(dirname3(target), name));
+  }
+  writeFileSync5(hookVersionPath(target), version, "utf8");
   return true;
 }
 
@@ -156,6 +481,12 @@ var SERVICES = {
   /** App 扫码确认时调的，CLI 用不到，列在这里只为对照 */
   confirmAuth: "com.shifeng.api.service.api.v2.deskbuddy.deskbuddyconfirmauthapi"
 };
+var DIRS_SERVICE = "com.shifeng.api.service.api.v2.deskbuddy.deskbuddyclientdirsreportapi";
+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";
@@ -206,88 +537,2422 @@ var ApiError = class extends Error {
     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;
+  code;
+};
+function humanOs(platform = process.platform) {
+  const known = {
+    darwin: "macOS",
+    win32: "Windows",
+    linux: "Linux"
+  };
+  return known[platform] ?? platform;
+}
+var defaultOsVersionDeps = {
+  runSwVers: () => execFileSync2("sw_vers", ["-productVersion"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: 2e3
+  }),
+  readOsRelease: () => readFileSync5("/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)
+};
+
+// src/core/report.ts
+async function postReport(payload) {
+  try {
+    await api.report(payload);
+  } catch {
+  }
+}
+
+// src/core/snapshot.ts
+import { basename as basename2 } from "path";
+var KEEPALIVE_MS = 2 * 60 * 1e3;
+var MAX_SESSIONS = 20;
+function buildSnapshot(states, tool, cfg, nowMs) {
+  const sessions = states.filter((s) => s.tool === tool).sort((a, b) => b.updatedAt - a.updatedAt).slice(0, MAX_SESSIONS).map((s) => ({
+    sessionId: s.sessionId,
+    title: s.title,
+    // 隐私：只带目录名，不带全路径——全路径会暴露公司目录结构与用户名
+    project: basename2(s.project || ""),
+    state: s.state,
+    startedAt: s.startedAt,
+    updatedAt: s.updatedAt,
+    interactive: s.interactive === true
+  }));
+  return { clientId: cfg.clientId, hostName: cfg.hostName, tool, snapshotAt: nowMs, sessions };
+}
+
+// src/core/dirs.ts
+import { createHmac, randomBytes as randomBytes2 } from "crypto";
+import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "fs";
+import { basename as basename3, join as join6 } from "path";
+var DIRS_REPORT_MAX = 10;
+function dirsPath() {
+  return join6(deskbuddyHome(), "dirs.json");
+}
+function dirSecret() {
+  const file = join6(deskbuddyHome(), "dir-secret");
+  try {
+    const s2 = readFileSync6(file, "utf8").trim();
+    if (s2) return s2;
+  } catch {
+  }
+  const s = randomBytes2(32).toString("hex");
+  try {
+    mkdirSync6(deskbuddyHome(), { recursive: true });
+    writeFileSync6(file, s, { encoding: "utf8", mode: 384 });
+    chmodSync(file, 384);
+  } catch {
+  }
+  return s;
+}
+function dirRef(path) {
+  return createHmac("sha256", dirSecret()).update(path).digest("hex").slice(0, 16);
+}
+function readMap() {
+  try {
+    const m = JSON.parse(readFileSync6(dirsPath(), "utf8"));
+    const out = {};
+    for (const [k, v] of Object.entries(m ?? {})) if (typeof v === "number") out[k] = v;
+    return out;
+  } catch {
+    return {};
+  }
+}
+function recentDirs(limit = DIRS_REPORT_MAX, exists = existsSync6) {
+  const list = Object.entries(readMap()).filter(([p]) => 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);
+  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 };
+  });
+}
+function dirOf(ref, exists = existsSync6) {
+  for (const p of Object.keys(readMap())) if (dirRef(p) === ref && exists(p)) return p;
+  return "";
+}
+
+// src/daemon/backoff.ts
+var BASE_DELAY_MS = 1e3;
+var MAX_DELAY_MS = 6e4;
+var JITTER_RATIO = 0.2;
+function backoffDelay(attempt, rand = Math.random) {
+  const n = Math.max(1, Math.floor(attempt));
+  const base = Math.min(BASE_DELAY_MS * 2 ** (n - 1), MAX_DELAY_MS);
+  const jitter = base * JITTER_RATIO * (rand() * 2 - 1);
+  return Math.max(100, Math.round(base + jitter));
+}
+
+// src/daemon/command.ts
+var SERVICE_COMMAND = "deskbuddy.command";
+var TYPE_TEXT = "text";
+var MAX_TEXT_LENGTH = 2e3;
+var MAX_ID_LENGTH = 64;
+function str(v) {
+  return typeof v === "string" ? v : "";
+}
+function parseMillis(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  const s = str(v).trim();
+  if (!/^\d{1,16}$/.test(s)) return 0;
+  const n = Number(s);
+  return Number.isSafeInteger(n) ? n : 0;
+}
+function isValidId(v) {
+  return v.length > 0 && v.length <= MAX_ID_LENGTH && /^[0-9a-zA-Z_-]+$/.test(v);
+}
+function sanitizeText(raw) {
+  return raw.replace(/\r\n?/g, "\n").replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F]/g, "").trim();
+}
+function parseCommand(frame) {
+  const f = frame;
+  if (!f || str(f.service) !== SERVICE_COMMAND) return null;
+  const d = f.data;
+  if (!d || typeof d !== "object") return null;
+  const instructionId = str(d.instructionId);
+  if (!isValidId(instructionId)) return null;
+  const type = str(d.type);
+  if (type !== TYPE_TEXT) return null;
+  const tool = str(d.tool);
+  if (!isValidId(tool)) return null;
+  const sessionId = str(d.sessionId);
+  if (sessionId && !isValidId(sessionId)) return null;
+  const text = sanitizeText(str(d.text));
+  if (!text || text.length > MAX_TEXT_LENGTH) return null;
+  const rawDir = str(d.dirRef);
+  const dirRef2 = !sessionId && /^[0-9a-f]{16}$/.test(rawDir) ? rawDir : "";
+  return { instructionId, type, sessionId, tool, text, expireAt: parseMillis(d.expireAt), dirRef: dirRef2 };
+}
+var TYPE_APPROVAL = "approval";
+function parseApprovalFrame(frame) {
+  const f = frame;
+  if (!f || str(f.service) !== SERVICE_COMMAND) return null;
+  const d = f.data;
+  if (!d || typeof d !== "object" || str(d.type) !== TYPE_APPROVAL) return null;
+  const instructionId = str(d.instructionId);
+  if (!isValidId(instructionId)) return null;
+  const approvalId = str(d.approvalId);
+  if (!isValidId(approvalId)) return null;
+  const decision = str(d.decision);
+  if (decision !== "allow" && decision !== "deny" && decision !== "allow_always") return null;
+  return { instructionId, approvalId, decision, deviceName: cleanDeviceName(d.deviceName) };
+}
+function cleanDeviceName(v) {
+  return typeof v === "string" ? v.replace(/[\u0000-\u001f\u007f]/g, "").trim().slice(0, 32) : "";
+}
+function isExpired(cmd, now = Date.now()) {
+  return cmd.expireAt > 0 && now > cmd.expireAt;
+}
+
+// src/daemon/executor.ts
+import { execFile as execFile2 } from "child_process";
+import { homedir as homedir4 } from "os";
+import { join as join8 } from "path";
+
+// src/daemon/gate/settings.ts
+import { existsSync as existsSync7 } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var GATE_HOOK_TIMEOUT_S = 7 * 24 * 60 * 60;
+function waitModeFor(tool) {
+  return tool === "claude_code" ? "defer" : "hold";
+}
+function shQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function defaultGateScript() {
+  const candidates = [
+    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];
+}
+function gateCommand(t) {
+  return `${shQuote(t.nodePath)} ${shQuote(t.gateScript)} --run ${t.runId} || exit 2`;
+}
+function ccSettingsJson(t) {
+  return JSON.stringify({
+    hooks: {
+      PreToolUse: [
+        { matcher: "*", hooks: [{ type: "command", command: gateCommand(t), timeout: GATE_HOOK_TIMEOUT_S }] }
+      ]
+    }
+  });
+}
+function codexGateArgs(t) {
+  const hook = `hooks.PreToolUse=[{matcher="*",hooks=[{type="command",command=${JSON.stringify(gateCommand(t))},timeout=${GATE_HOOK_TIMEOUT_S}}]}]`;
+  return [
+    "--dangerously-bypass-hook-trust",
+    "-c",
+    'sandbox_mode="workspace-write"',
+    "-c",
+    "sandbox_workspace_write.network_access=true",
+    "-c",
+    hook
+  ];
+}
+
+// src/daemon/locate.ts
+import { accessSync, constants, existsSync as existsSync8, statSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { delimiter, dirname as dirname4, join as join7 } from "path";
+var defaultLocateDeps = () => ({
+  home: homedir3(),
+  path: process.env.PATH ?? "",
+  nodePath: process.execPath,
+  isExecutable: (p) => {
+    try {
+      if (!statSync(p).isFile()) return false;
+      accessSync(p, constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  exists: (p) => existsSync8(p)
+});
+function extraBinDirs(home, nodePath = "") {
+  return [
+    join7(home, ".local", "bin"),
+    join7(home, ".claude", "local"),
+    join7(home, ".npm-global", "bin"),
+    join7(home, ".bun", "bin"),
+    join7(home, ".volta", "bin"),
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    ...nodePath ? [dirname4(nodePath)] : []
+  ];
+}
+function whichIn(name, d) {
+  const dirs = [...d.path.split(delimiter).filter(Boolean), ...extraBinDirs(d.home, d.nodePath)];
+  for (const dir of dirs) {
+    const p = join7(dir, name);
+    if (d.isExecutable(p)) return p;
+  }
+  return null;
+}
+function appDirs(home) {
+  return ["/Applications", join7(home, "Applications")];
+}
+var WORKBUDDY_CLI_IN_APP = "WorkBuddy.app/Contents/Resources/app.asar.unpacked/cli/bin/codebuddy";
+var QODER_CN_WORKER_IN_APP = "Qoder CN.app/Contents/Resources/app.asar.unpacked/node_modules/@qoder-ai/qoder-cn-agent-sdk/dist/_worker/qoder-worker-runtime.obf.mjs";
+function locate(tool, d = defaultLocateDeps()) {
+  const plain = (name) => {
+    const f = whichIn(name, d);
+    return f ? { file: f, prefixArgs: [] } : null;
+  };
+  switch (tool) {
+    case "claude_code":
+      return plain("claude");
+    case "codex":
+      return plain("codex");
+    case "workbuddy": {
+      for (const dir of appDirs(d.home)) {
+        const p = join7(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 = join7(dir, QODER_CN_WORKER_IN_APP);
+        if (d.exists(p)) return { file: d.nodePath, prefixArgs: [p] };
+      }
+      return plain("qodercli");
+    }
+    case "opencode": {
+      const p = join7(d.home, ".opencode", "bin", "opencode");
+      if (d.isExecutable(p)) return { file: p, prefixArgs: [] };
+      return plain("opencode");
+    }
+    default:
+      return null;
+  }
+}
+function childPath(d = defaultLocateDeps()) {
+  const seen = /* @__PURE__ */ new Set();
+  return [...d.path.split(delimiter), ...extraBinDirs(d.home, d.nodePath)].filter((p) => p && !seen.has(p) && (seen.add(p), true)).join(delimiter);
+}
+
+// src/daemon/executor.ts
+var EXEC_TIMEOUT_MS = 10 * 60 * 1e3;
+var EXEC_MAX_BUFFER = 32 * 1024 * 1024;
+function claudePlan(cmd, gate) {
+  const args = [];
+  if (cmd.sessionId) args.push("--resume", cmd.sessionId);
+  args.push("-p");
+  if (cmd.text) args.push(cmd.text);
+  args.push("--output-format", "json");
+  if (gate) args.push("--settings", ccSettingsJson(gate));
+  return args;
+}
+function codexPlan(cmd, gate) {
+  const args = ["exec"];
+  if (cmd.sessionId) args.push("resume", cmd.sessionId);
+  args.push("--json", "--skip-git-repo-check");
+  if (gate) args.push(...codexGateArgs(gate));
+  args.push(cmd.text);
+  return args;
+}
+function workbuddyPlan(cmd, gate) {
+  const args = [];
+  if (cmd.sessionId) args.push("-r", cmd.sessionId);
+  args.push("-p", cmd.text, "--output-format", "json");
+  if (gate) args.push("--settings", ccSettingsJson(gate));
+  return args;
+}
+function qoderPlan(cmd, gate) {
+  const args = [];
+  if (cmd.sessionId) args.push("-r", cmd.sessionId);
+  args.push("-p", cmd.text, "-o", "json", "--permission-mode", "bypass_permissions");
+  args.push("--settings", ccSettingsJson(gate));
+  return args;
+}
+var OPENCODE_GATED_KEYS = [
+  "*",
+  "bash",
+  "edit",
+  "write",
+  "read",
+  "glob",
+  "grep",
+  "list",
+  "task",
+  "webfetch",
+  "websearch",
+  "codesearch",
+  "external_directory",
+  "todowrite",
+  "todoread",
+  "lsp",
+  "skill",
+  "doom_loop",
+  "patch",
+  "apply_patch"
+];
+var DENY_RULES = Object.fromEntries(OPENCODE_GATED_KEYS.map((k) => [k, "deny"]));
+var OPENCODE_DENY_ALL = JSON.stringify({ permission: DENY_RULES, agent: { build: { permission: DENY_RULES } } });
+function opencodePlan(cmd) {
+  const args = ["run", "--format", "json", "--agent", "build"];
+  if (cmd.sessionId) args.push("-s", cmd.sessionId);
+  args.push("--", cmd.text);
+  return args;
+}
+var TOOL_BINARY = {
+  claude_code: "claude",
+  codex: "codex",
+  workbuddy: "codebuddy",
+  qoder: "qodercli",
+  opencode: "opencode"
+};
+function buildSpawnPlan(cmd, cwd, gate, home = homedir4()) {
+  const file = TOOL_BINARY[cmd.tool];
+  if (!file) return null;
+  switch (cmd.tool) {
+    case "codex":
+      return { file, args: codexPlan(cmd, gate), cwd };
+    case "workbuddy":
+      return { file, args: workbuddyPlan(cmd, gate), cwd, env: { CODEBUDDY_CONFIG_DIR: join8(home, ".workbuddy") } };
+    case "qoder":
+      return gate ? { file, args: qoderPlan(cmd, gate), cwd } : null;
+    case "opencode":
+      return gate ? {
+        file,
+        args: opencodePlan(cmd),
+        cwd,
+        env: { DESKBUDDY_GATE_RUN: gate.runId, DESKBUDDY_NODE: gate.nodePath, OPENCODE_CONFIG_CONTENT: OPENCODE_DENY_ALL }
+      } : null;
+    default:
+      return { file, args: claudePlan(cmd, gate), cwd };
+  }
+}
+function materialize(plan, tool, d = defaultLocateDeps()) {
+  const loc = locate(tool, d);
+  if (!loc) return null;
+  return {
+    file: loc.file,
+    args: [...loc.prefixArgs, ...plan.args],
+    cwd: plan.cwd,
+    env: { ...plan.env, PATH: childPath(d) }
+  };
+}
+function isDeferred(stdout7) {
+  try {
+    return JSON.parse(stdout7).stop_reason === "tool_deferred";
+  } catch {
+    return false;
+  }
+}
+function parseClaudeSessionId(stdout7) {
+  const pick = (o) => {
+    const d = o ?? {};
+    const v = d.session_id ?? d.sessionId;
+    return typeof v === "string" && v ? v : null;
+  };
+  try {
+    const d = JSON.parse(stdout7);
+    if (Array.isArray(d)) {
+      for (const m of d) {
+        const id = pick(m);
+        if (id) return id;
+      }
+      return null;
+    }
+    return pick(d);
+  } catch {
+    return null;
+  }
+}
+function parseCodexSessionId(stdout7) {
+  for (const line of stdout7.split("\n")) {
+    const t = line.trim();
+    if (!t) continue;
+    try {
+      const d = JSON.parse(t);
+      if (d.type === "thread.started" && typeof d.thread_id === "string" && d.thread_id) {
+        return d.thread_id;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function parseOpencodeSessionId(stdout7) {
+  for (const line of stdout7.split("\n")) {
+    const t = line.trim();
+    if (!t) continue;
+    try {
+      const d = JSON.parse(t);
+      const v = d.sessionID ?? d.part?.sessionID;
+      if (typeof v === "string" && /^ses_[0-9A-Za-z]{1,64}$/.test(v)) return v;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function parseSessionId(tool, stdout7) {
+  if (tool === "codex") return parseCodexSessionId(stdout7);
+  if (tool === "opencode") return parseOpencodeSessionId(stdout7);
+  return parseClaudeSessionId(stdout7);
+}
+function startCommand(plan, tool, limitMs = EXEC_TIMEOUT_MS) {
+  let remaining = limitMs;
+  let startedAt = Date.now();
+  let paused = 0;
+  let timer = null;
+  let finished = false;
+  let child = null;
+  const arm = () => {
+    startedAt = Date.now();
+    timer = setTimeout(() => {
+      timedOut = true;
+      child?.kill("SIGTERM");
+    }, Math.max(0, remaining));
+  };
+  let timedOut = false;
+  const done = new Promise((resolve3) => {
+    child = execFile2(
+      plan.file,
+      plan.args,
+      {
+        cwd: plan.cwd,
+        maxBuffer: EXEC_MAX_BUFFER,
+        // agent 自己要读 PATH 里的东西，环境原样继承
+        env: { ...process.env, ...plan.env }
+      },
+      (err, stdout7) => {
+        finished = true;
+        if (timer) clearTimeout(timer);
+        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;
+          resolve3({ ok: false, sessionId: parseSessionId(tool, out), stdout: out, error: msg });
+          return;
+        }
+        resolve3({ ok: true, sessionId: parseSessionId(tool, out), stdout: out });
+      }
+    );
+    child?.stdin?.end();
+    arm();
+  });
+  return {
+    done,
+    pauseTimeout() {
+      if (finished) return;
+      if (paused++ === 0 && timer) {
+        clearTimeout(timer);
+        timer = null;
+        remaining -= Date.now() - startedAt;
+      }
+    },
+    resumeTimeout() {
+      if (finished || paused === 0) return;
+      if (--paused === 0) arm();
+    }
+  };
+}
+
+// src/daemon/gate/approvals.ts
+import { createHash as createHash2 } from "crypto";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync7, renameSync as renameSync5, writeFileSync as writeFileSync7 } from "fs";
+import { join as join9 } from "path";
+var RETAIN_MS = 7 * 24 * 60 * 60 * 1e3;
+function fingerprint(toolName, toolInput) {
+  let input = "";
+  try {
+    input = JSON.stringify(toolInput ?? null);
+  } catch {
+    input = String(toolInput);
+  }
+  return createHash2("sha256").update(toolName).update("\0").update(input).digest("hex");
+}
+function storePath() {
+  return join9(deskbuddyHome(), "approvals.json");
+}
+var ApprovalStore = class _ApprovalStore {
+  #records;
+  constructor(records = []) {
+    this.#records = records;
+  }
+  static load() {
+    try {
+      const raw = JSON.parse(readFileSync7(storePath(), "utf8"));
+      return new _ApprovalStore(Array.isArray(raw) ? raw : []);
+    } catch {
+      return new _ApprovalStore();
+    }
+  }
+  save() {
+    try {
+      mkdirSync7(deskbuddyHome(), { recursive: true });
+      const tmp = storePath() + ".tmp";
+      writeFileSync7(tmp, JSON.stringify(this.#records), { encoding: "utf8", mode: 384 });
+      renameSync5(tmp, storePath());
+    } catch {
+    }
+  }
+  add(r) {
+    this.#records.push(r);
+  }
+  get(approvalId) {
+    return this.#records.find((r) => r.approvalId === approvalId);
+  }
+  all() {
+    return this.#records;
+  }
+  pending() {
+    return this.#records.filter((r) => r.status === "pending");
+  }
+  pendingForSession(sessionId) {
+    return sessionId ? this.#records.filter((r) => r.status === "pending" && r.sessionId === sessionId) : [];
+  }
+  /**
+   * 同会话、同指纹、还没被用掉的最新一条。gate 在 defer 续跑时靠它决定放行还是拒绝。
+   * 取最新的：同一条命令被拒过一次、用户后来又让它跑并批准了，应当以后者为准。
+   */
+  latestFor(sessionId, fp) {
+    for (let i = this.#records.length - 1; i >= 0; i--) {
+      const r = this.#records[i];
+      if (r.mode === "window") continue;
+      if (r.sessionId === sessionId && r.fingerprint === fp && !r.consumed) return r;
+    }
+    return void 0;
+  }
+  /** 清掉超期的。pending 超期也清 —— 服务端那边同样视为过期了 */
+  prune(now = Date.now()) {
+    const before = this.#records.length;
+    this.#records = this.#records.filter((r) => now - r.createdAt < RETAIN_MS);
+    return before - this.#records.length;
+  }
+};
+
+// src/daemon/gate/backend.ts
+import { basename as basename4 } from "path";
+function serverBackend(client = api) {
+  return {
+    create: (r) => client.approvalCreate({
+      approvalId: r.approvalId,
+      tool: r.tool,
+      sessionId: r.sessionId,
+      kind: r.kind,
+      summary: r.summary,
+      cwdName: basename4(r.cwd),
+      source: r.mode === "window" ? "window" : "remote",
+      ...r.remember ? { remember: r.remember } : {}
+    }),
+    cancel: (approvalId, reason) => client.approvalCancel(approvalId, reason),
+    sync: async (ids) => {
+      const res = await client.approvalSync(ids);
+      const out = [];
+      for (const a of res?.approvals ?? []) {
+        if (typeof a?.approvalId !== "string") continue;
+        const d = mapStatus(a.status);
+        if (d) out.push({ approvalId: a.approvalId, decision: d, deviceName: cleanDeviceName(a.deviceName) });
+      }
+      return out;
+    }
+  };
+}
+function mapStatus(s) {
+  switch (s) {
+    case "APPROVED":
+      return "allow";
+    case "DENIED":
+      return "deny";
+    case "CANCELLED":
+      return "cancelled";
+    default:
+      return null;
+  }
+}
+
+// src/daemon/gate/coordinator.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { existsSync as existsSync9, realpathSync } from "fs";
+import { basename as basename5, dirname as dirname5, join as join10 } from "path";
+
+// src/daemon/gate/classify.ts
+import { isAbsolute, relative, resolve, sep } from "path";
+var SUMMARY_MAX = 200;
+var READ_TOOLS = /* @__PURE__ */ new Set([
+  "Read",
+  "Glob",
+  "Grep",
+  "LS",
+  "NotebookRead",
+  "TodoWrite",
+  // Task 起的子智能体，它自己的每次工具调用还会再过一遍本关卡
+  "Task",
+  "WebSearch",
+  "WebFetch"
+]);
+var EDIT_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
+var SHELL_TOOLS = /* @__PURE__ */ new Set(["Bash", "shell", "exec_command"]);
+var PATCH_TOOLS = /* @__PURE__ */ new Set(["apply_patch"]);
+function str2(v) {
+  return typeof v === "string" ? v : "";
+}
+function truncate(s, max = SUMMARY_MAX) {
+  const oneLine = s.replace(/\s+/g, " ").trim();
+  if (oneLine.length <= max) return oneLine;
+  const keep = max - 3;
+  const head = Math.ceil(keep * 0.55);
+  return `${oneLine.slice(0, head)} \u2026 ${oneLine.slice(oneLine.length - (keep - head))}`;
+}
+var PROTECTED_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".claude",
+  ".codex",
+  ".qoder",
+  ".qoder-cn",
+  ".codebuddy",
+  ".workbuddy",
+  ".vscode",
+  ".idea",
+  ".husky"
+]);
+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());
+  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));
+  if (rel === "") return true;
+  return !rel.startsWith("..") && !isAbsolute(rel);
+}
+function patchPaths(patch) {
+  const out = [];
+  for (const line of patch.split("\n")) {
+    const m = /^\*\*\* (?:Add File|Update File|Delete File|Move to): (.+)$/.exec(line.trim());
+    if (m) out.push(m[1].trim());
+  }
+  return out;
+}
+var SHELL_META = /[;&><`$()\n\r\\'"*?[\]{}~]/;
+var GIT_READ = /* @__PURE__ */ new Set(["status", "log", "diff", "show"]);
+var GIT_BRANCH_FLAGS = /* @__PURE__ */ new Set(["-a", "-v", "-vv", "-r", "--list", "--all"]);
+var FIND_DANGER = /* @__PURE__ */ new Set(["-exec", "-execdir", "-ok", "-okdir", "-delete", "-fprint", "-fprint0", "-fprintf", "-fls"]);
+function segmentIsReadOnly(seg) {
+  const t = seg.trim().split(/\s+/).filter(Boolean);
+  if (t.length === 0) return false;
+  const [cmd, ...rest] = t;
+  switch (cmd) {
+    case "ls":
+    case "cat":
+    case "head":
+    case "tail":
+    case "wc":
+    case "pwd":
+    case "grep":
+      return true;
+    case "rg":
+      return !rest.some((a) => a.startsWith("--pre") || a.startsWith("--hostname-bin"));
+    case "find":
+      return !rest.some((a) => FIND_DANGER.has(a));
+    case "sed":
+      return rest[0] === "-n" && /^[0-9]+(,[0-9]+)?p$/.test(rest[1] ?? "") && rest.slice(2).every((a) => !a.startsWith("-"));
+    case "git": {
+      const [sub, ...args] = rest;
+      if (args.some((a) => a.startsWith("--output"))) return false;
+      if (GIT_READ.has(sub)) return true;
+      if (sub === "branch") return args.every((a) => GIT_BRANCH_FLAGS.has(a));
+      return false;
+    }
+    default:
+      return false;
+  }
+}
+function isReadOnlyCommand(command) {
+  const c = command.trim();
+  if (!c || SHELL_META.test(c)) return false;
+  return c.split("|").every(segmentIsReadOnly);
+}
+function classify(toolName, toolInput, cwd, policy = "commands", opts = {}) {
+  const roots = (Array.isArray(cwd) ? cwd : [cwd]).filter(Boolean);
+  const real = opts.real;
+  const inside = (p) => {
+    if (!roots.some((r) => isInside(r, p))) return false;
+    if (!real) return true;
+    const rp = real(resolve(roots[0] ?? "/", p));
+    return roots.some((r) => isInside(real(r), rp));
+  };
+  const rel = (p) => {
+    const r = roots.find((x) => isInside(x, p)) ?? roots[0] ?? "";
+    return relative(resolve(r), resolve(r, p));
+  };
+  const input = toolInput && typeof toolInput === "object" ? toolInput : {};
+  if (READ_TOOLS.has(toolName)) return { action: "auto" };
+  if (SHELL_TOOLS.has(toolName)) {
+    const command = str2(input.command);
+    if (isReadOnlyCommand(command)) return { action: "auto" };
+    return { action: "ask", kind: "command", summary: truncate(command || toolName) };
+  }
+  const paths = EDIT_TOOLS.has(toolName) ? [str2(input.file_path) || str2(input.notebook_path)].filter(Boolean) : PATCH_TOOLS.has(toolName) ? patchPaths(str2(input.command) || str2(input.patch) || str2(input.input)) : null;
+  if (paths) {
+    const allInside = paths.length > 0 && paths.every(inside);
+    const touchesProtected = paths.some(
+      (p) => isProtectedPath(roots[0] ?? "/", p) || (real ? isProtectedPath("/", real(resolve(roots[0] ?? "/", p))) : false)
+    );
+    if (policy === "commands" && allInside && !touchesProtected) return { action: "auto" };
+    const shown = paths.map((p) => inside(p) ? rel(p) : p);
+    return { action: "ask", kind: "edit", summary: truncate(shown.join(", ") || toolName) };
+  }
+  let detail = "";
+  try {
+    detail = JSON.stringify(input);
+  } catch {
+    detail = "";
+  }
+  return { action: "ask", kind: "other", summary: truncate(`${toolName} ${detail}`) };
+}
+function describe(toolName, toolInput, cwd) {
+  const v = classify(toolName, toolInput, cwd, "all");
+  if (v.action === "ask") return { kind: v.kind, summary: v.summary };
+  const input = toolInput && typeof toolInput === "object" ? toolInput : {};
+  const detail = str2(input.command) || str2(input.file_path) || str2(input.path) || str2(input.pattern) || str2(input.url);
+  return { kind: SHELL_TOOLS.has(toolName) ? "command" : "other", summary: truncate(detail ? `${toolName} ${detail}` : toolName) };
+}
+
+// src/daemon/gate/procs.ts
+import { execFileSync as execFileSync3 } from "child_process";
+function listDescendants(rootPid) {
+  let out = "";
+  try {
+    out = execFileSync3("ps", ["-A", "-ww", "-o", "pid=,ppid=,args="], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      maxBuffer: 16 * 1024 * 1024
+    });
+  } catch {
+    return [];
+  }
+  const kids = /* @__PURE__ */ new Map();
+  for (const line of out.split("\n")) {
+    const m = line.match(/^\s*(\d+)\s+(\d+)\s+(.*)$/);
+    if (!m) continue;
+    const pp = Number(m[2]);
+    const list = kids.get(pp) ?? [];
+    list.push({ pid: Number(m[1]), args: m[3] });
+    kids.set(pp, list);
+  }
+  const res = [];
+  const stack = [rootPid];
+  while (stack.length > 0) {
+    for (const c of kids.get(stack.pop()) ?? []) {
+      res.push(c);
+      stack.push(c.pid);
+    }
+  }
+  return res;
+}
+function normalizeCmd(s) {
+  return s.replace(/['"\\]/g, "").replace(/\s+/g, " ").trim();
+}
+var CMD_MATCH_MIN = 6;
+var CMD_MATCH_LEN = 80;
+
+// src/daemon/gate/coordinator.ts
+function pickRememberSuggestion(suggestions) {
+  if (!Array.isArray(suggestions)) return null;
+  for (const s of suggestions) {
+    if (!s || s.type !== "addRules" || s.behavior !== "allow" || !Array.isArray(s.rules) || s.rules.length === 0) continue;
+    if (s.destination !== "session" && s.destination !== "localSettings") continue;
+    const raw = s.rules;
+    if (raw.some((r) => typeof r?.ruleContent !== "string" || !r.ruleContent)) continue;
+    const rules = raw.map((r) => r.ruleContent);
+    const scope = s.destination === "session" ? "\u8FD9\u6B21\u4F1A\u8BDD\u91CC" : "\u8FD9\u4E2A\u9879\u76EE\u91CC";
+    const text = `\u4EE5\u540E\u5728${scope}\u90FD\u5141\u8BB8\uFF1A${rules.join("\u3001")}`;
+    return { suggestion: s, text: text.length > 100 ? text.slice(0, 99) + "\u2026" : text };
+  }
+  return null;
+}
+var DEVICE_FALLBACK = "\u684C\u9762\u642D\u5B50";
+function windowNotice(decision, summary, deviceName = "") {
+  const who = deviceName ? `\u300C${deviceName}\u300D` : DEVICE_FALLBACK;
+  const what = summary.length > 60 ? summary.slice(0, 59) + "\u2026" : summary;
+  return decision === "allow" ? `\u2705 \u5DF2\u5728${who}\u4E0A\u5141\u8BB8\uFF1A${what}` : `\u274C \u5DF2\u5728${who}\u4E0A\u62D2\u7EDD\uFF1A${what}`;
+}
+var WINDOW_SKIP_TOOLS = /* @__PURE__ */ new Set(["AskUserQuestion", "ExitPlanMode"]);
+var WINDOW_SETTLED_EVENTS = /* @__PURE__ */ new Set(["UserPromptSubmit", "Stop"]);
+var WINDOW_TOOL_DONE_EVENTS = /* @__PURE__ */ new Set(["PostToolUse", "PostToolUseFailure"]);
+var WINDOW_PROC_WATCH_MS = 10 * 60 * 1e3;
+var REASON_DENIED = "\u7528\u6237\u5728\u8BBE\u5907\u4E0A\u62D2\u7EDD\u4E86\u8FD9\u4E00\u6B65";
+var REASON_SUPERSEDED = "\u7528\u6237\u5728\u8BBE\u5907\u4E0A\u4E0B\u4E86\u65B0\u7684\u6307\u4EE4\uFF0C\u6CA1\u6709\u6279\u51C6\u8FD9\u4E00\u6B65";
+var REASON_UNKNOWN_RUN = "\u8FD9\u4E0D\u662F DeskBuddy \u5B88\u62A4\u8FDB\u7A0B\u53D1\u8D77\u7684\u4EFB\u52A1";
+var ApprovalCoordinator = class {
+  #d;
+  #runs = /* @__PURE__ */ new Map();
+  /** hold 模式下挂着的 gate 请求：approvalId → 让它返回 */
+  #waiters = /* @__PURE__ */ new Map();
+  /** 窗口待批准的撤卡依据：approvalId → 工具名 + 创建时状态文件在不在 */
+  #windows = /* @__PURE__ */ new Map();
+  constructor(deps) {
+    this.#d = deps;
+  }
+  #now() {
+    return this.#d.now ? this.#d.now() : Date.now();
+  }
+  registerRun(run2) {
+    this.#runs.set(run2.runId, run2);
+  }
+  unregisterRun(runId) {
+    this.#runs.delete(runId);
+  }
+  /** run 学到的会话 id（新建任务是从 gate 请求里学到的）。没有返回空串 */
+  sessionOf(runId) {
+    return this.#runs.get(runId)?.sessionId ?? "";
+  }
+  async onGate(req, signal) {
+    if (req.window) return this.#onWindow(req.hook, signal, req.tool || "claude_code");
+    const run2 = this.#runs.get(req.runId ?? "");
+    if (!run2) return { decision: "deny", reason: REASON_UNKNOWN_RUN };
+    if (run2.superseded) return { decision: "deny", reason: REASON_SUPERSEDED };
+    const toolName = typeof req.hook.tool_name === "string" ? req.hook.tool_name : "";
+    const sessionId = typeof req.hook.session_id === "string" && req.hook.session_id || run2.sessionId || "";
+    if (sessionId && !run2.sessionId) run2.sessionId = sessionId;
+    const v = classify(toolName, req.hook.tool_input, cwdForms(run2.cwd), this.#d.policy(), { real: realpathNearest });
+    if (v.action === "auto") return { decision: "allow" };
+    const fp = fingerprint(toolName, req.hook.tool_input);
+    const store = this.#d.store;
+    if (run2.mode === "defer" && sessionId) {
+      const prev = store.latestFor(sessionId, fp);
+      if (prev && prev.status !== "pending") {
+        prev.consumed = true;
+        store.save();
+        if (prev.status === "approved") return { decision: "allow" };
+        return { decision: "deny", reason: prev.status === "cancelled" ? REASON_SUPERSEDED : REASON_DENIED };
+      }
+      if (prev) return { decision: "defer", reason: "\u7B49\u5F85\u8BBE\u5907\u6388\u6743" };
+    }
+    const rec = {
+      approvalId: randomUUID3(),
+      runId: run2.runId,
+      tool: run2.tool,
+      sessionId,
+      cwd: run2.cwd,
+      fingerprint: fp,
+      kind: v.kind,
+      summary: v.summary,
+      mode: run2.mode,
+      status: "pending",
+      createdAt: this.#now()
+    };
+    store.add(rec);
+    store.save();
+    let early = null;
+    let settle;
+    const decided = new Promise((resolve3) => settle = resolve3);
+    this.#waiters.set(rec.approvalId, (r) => {
+      early = r;
+      settle(r);
+    });
+    try {
+      await this.#d.backend.create(rec);
+    } catch (e) {
+      this.#waiters.delete(rec.approvalId);
+      rec.status = "cancelled";
+      rec.consumed = true;
+      store.save();
+      this.#d.log(`\u6388\u6743\u8BF7\u6C42 ${rec.approvalId} \u53D1\u4E0D\u5230\u670D\u52A1\u7AEF\uFF1A${e.message}`);
+      void this.#cancelRemote(rec.approvalId, "\u6388\u6743\u8BF7\u6C42\u53D1\u9001\u5931\u8D25");
+      return { decision: "deny", reason: "\u6388\u6743\u8BF7\u6C42\u6CA1\u80FD\u53D1\u5230\u8BBE\u5907\u4E0A\uFF0C\u8FD9\u4E00\u6B65\u6CA1\u6709\u6267\u884C" };
+    }
+    this.#d.log(`\u6388\u6743\u8BF7\u6C42 ${rec.approvalId} \u5DF2\u63A8\u5230\u8BBE\u5907 tool=${rec.tool} kind=${rec.kind} mode=${rec.mode}`);
+    if (early) return early;
+    if (run2.mode === "defer") {
+      this.#waiters.delete(rec.approvalId);
+      return { decision: "defer", reason: "\u7B49\u5F85\u8BBE\u5907\u6388\u6743" };
+    }
+    run2.onWaitStart?.();
+    try {
+      return await new Promise((resolve3) => {
+        void decided.then(resolve3);
+        const onAbort = () => {
+          if (!this.#waiters.delete(rec.approvalId)) return;
+          if (rec.status === "pending") {
+            rec.status = "cancelled";
+            rec.consumed = true;
+            store.save();
+            void this.#cancelRemote(rec.approvalId, "\u667A\u80FD\u4F53\u8FDB\u7A0B\u5DF2\u7ED3\u675F");
+          }
+          resolve3({ decision: "deny", reason: "\u5DF2\u53D6\u6D88" });
+        };
+        if (signal.aborted) onAbort();
+        else signal.addEventListener("abort", onAbort, { once: true });
+      });
+    } finally {
+      run2.onWaitEnd?.();
+    }
+  }
+  /**
+   * 用户自己窗口里的授权框（S10）。挂住直到设备答复，或人在电脑上先处理了（{@link scanWindows}）。
+   *
+   * 🔴 这里的所有"失败"都回 `none`（不表态）而不是 deny：窗口里的授权框照常在，
+   * 由电脑前的人决定。回 deny 等于替用户点了拒绝 —— daemon 一出问题，他窗口里每个授权都会被自动拒掉
+   */
+  async #onWindow(hook, signal, tool) {
+    const none = { decision: "none" };
+    const toolName = typeof hook.tool_name === "string" ? hook.tool_name : "";
+    const sessionId = typeof hook.session_id === "string" ? hook.session_id : "";
+    const cwd = typeof hook.cwd === "string" ? hook.cwd : "";
+    if (!toolName || !sessionId || WINDOW_SKIP_TOOLS.has(toolName)) return none;
+    for (const run2 of this.#runs.values()) if (run2.sessionId === sessionId) return none;
+    const store = this.#d.store;
+    const { kind, summary } = describe(toolName, hook.tool_input, cwd ? cwdForms(cwd) : []);
+    const remember = tool === "claude_code" ? pickRememberSuggestion(hook.permission_suggestions) : null;
+    const rec = {
+      approvalId: randomUUID3(),
+      runId: "",
+      tool,
+      sessionId,
+      cwd,
+      fingerprint: fingerprint(toolName, hook.tool_input),
+      kind,
+      summary,
+      mode: "window",
+      status: "pending",
+      createdAt: this.#now(),
+      ...remember ? { remember: remember.text, rememberSuggestion: remember.suggestion } : {}
+    };
+    store.add(rec);
+    store.save();
+    const st0 = this.#readState(sessionId);
+    const rawCmd = hook.tool_input && typeof hook.tool_input === "object" ? hook.tool_input.command : void 0;
+    const cmd = typeof rawCmd === "string" ? normalizeCmd(rawCmd).slice(0, CMD_MATCH_LEN) : "";
+    const pid = typeof st0?.pid === "number" && st0.pid > 0 ? st0.pid : void 0;
+    const watchProcs = kind === "command" && pid !== void 0 && cmd.length >= CMD_MATCH_MIN;
+    this.#windows.set(rec.approvalId, {
+      toolName,
+      hadState: st0 != null,
+      ...watchProcs ? { pid, cmd, baseline: new Set(this.#descendants(pid).map((p) => p.pid)) } : {}
+    });
+    let settle;
+    const decided = new Promise((resolve3) => settle = resolve3);
+    this.#waiters.set(rec.approvalId, settle);
+    try {
+      await this.#d.backend.create(rec);
+    } catch (e) {
+      this.#waiters.delete(rec.approvalId);
+      this.#windows.delete(rec.approvalId);
+      rec.status = "cancelled";
+      rec.consumed = true;
+      store.save();
+      this.#d.log(`\u7A97\u53E3\u6388\u6743 ${rec.approvalId} \u53D1\u4E0D\u5230\u670D\u52A1\u7AEF\uFF1A${e.message}`);
+      void this.#cancelRemote(rec.approvalId, "\u6388\u6743\u8BF7\u6C42\u53D1\u9001\u5931\u8D25");
+      return none;
+    }
+    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((resolve3) => {
+      void decided.then(resolve3);
+      const onAbort = () => {
+        if (this.#waiters.has(rec.approvalId)) this.#settleWindow(rec, "hook \u5DF2\u7ED3\u675F");
+        resolve3(none);
+      };
+      if (signal.aborted) onAbort();
+      else signal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  /**
+   * 每秒调一次：窗口待批准里，人已经在电脑上处理掉的，撤掉设备卡片、放掉挂着的 hook（S10 W3）。
+   * 依据是 hook.cjs 落的状态文件里授权创建之后的事件（{@link WINDOW_SETTLED_EVENTS}、同名工具的 PostToolUse），
+   * 或者状态文件被删了（SessionEnd）
+   */
+  scanWindows() {
+    const procCache = /* @__PURE__ */ new Map();
+    const procsOf = (pid) => {
+      let v = procCache.get(pid);
+      if (!v) procCache.set(pid, v = this.#descendants(pid));
+      return v;
+    };
+    for (const rec of this.#d.store.pending()) {
+      if (rec.mode !== "window") continue;
+      const w = this.#windows.get(rec.approvalId);
+      if (!w) continue;
+      const st = this.#readState(rec.sessionId);
+      if (!st) {
+        if (w.hadState) this.#settleWindow(rec, "\u4F1A\u8BDD\u5DF2\u7ED3\u675F");
+        continue;
+      }
+      const fp = rec.fingerprint.slice(0, 16);
+      const settled = (st.recent ?? []).some(
+        (e) => e.at > rec.createdAt && (WINDOW_SETTLED_EVENTS.has(e.e) || // 跑完的必须正是这一步：并行的同名工具不算（评审 #2）。老版 hook 没有 fp 时退回只比工具名
+        WINDOW_TOOL_DONE_EVENTS.has(e.e) && e.tool === w.toolName && (e.fp === void 0 || e.fp === fp))
+      );
+      if (settled) {
+        this.#settleWindow(rec, "\u7535\u8111\u4E0A\u5DF2\u5904\u7406");
+        continue;
+      }
+      if (w.pid !== void 0 && w.cmd && w.baseline && this.#now() - rec.createdAt < WINDOW_PROC_WATCH_MS) {
+        const started = procsOf(w.pid).some(
+          (p) => !w.baseline?.has(p.pid) && normalizeCmd(p.args).includes(w.cmd)
+        );
+        if (started) this.#settleWindow(rec, "\u7535\u8111\u4E0A\u5DF2\u5141\u8BB8\uFF0C\u547D\u4EE4\u5DF2\u5F00\u59CB\u6267\u884C");
+      }
+    }
+  }
+  #descendants(pid) {
+    try {
+      return (this.#d.listDescendants ?? listDescendants)(pid);
+    } catch {
+      return [];
+    }
+  }
+  /** 窗口待批准作废：本地回 none、撤设备卡片 */
+  #settleWindow(rec, reason) {
+    this.#d.log(`\u7A97\u53E3\u6388\u6743 ${rec.approvalId} \u64A4\u9500\uFF1A${reason}`);
+    rec.status = "cancelled";
+    rec.decidedAt = this.#now();
+    rec.consumed = true;
+    this.#d.store.save();
+    this.#windows.delete(rec.approvalId);
+    const waiter = this.#waiters.get(rec.approvalId);
+    if (waiter) {
+      this.#waiters.delete(rec.approvalId);
+      waiter({ decision: "none" });
+    }
+    void this.#cancelRemote(rec.approvalId, reason);
+  }
+  #readState(sessionId) {
+    try {
+      return (this.#d.readState ?? readState)(sessionId);
+    } catch {
+      return null;
+    }
+  }
+  /** 设备上按了允许/拒绝（经服务端下发，或重连后 sync 补到） */
+  onDecision(approvalId, decision, deviceName = "") {
+    const rec = this.#d.store.get(approvalId);
+    if (!rec) {
+      this.#d.log(`\u6536\u5230\u672A\u77E5\u6388\u6743 ${approvalId} \u7684\u51B3\u5B9A\uFF0C\u5FFD\u7565`);
+      return;
+    }
+    if (rec.status !== "pending") return;
+    const always = decision === "allow_always" && rec.mode === "window" && rec.rememberSuggestion !== void 0;
+    if (decision === "allow_always") decision = "allow";
+    rec.status = decision === "allow" ? "approved" : "denied";
+    rec.decidedAt = this.#now();
+    const waiter = this.#waiters.get(approvalId);
+    if (waiter) {
+      this.#waiters.delete(approvalId);
+      this.#windows.delete(approvalId);
+      rec.consumed = true;
+      this.#d.store.save();
+      if (rec.mode === "window") {
+        const notice = windowNotice(decision, rec.summary, deviceName) + (always ? "\uFF08\u5DF2\u8BB0\u4F4F\uFF09" : "");
+        try {
+          ;
+          (this.#d.writeNotice ?? writeNotice)(rec.sessionId, notice);
+        } catch {
+        }
+        waiter(
+          decision === "allow" ? { decision: "allow", notice, ...always ? { updatedPermissions: [rec.rememberSuggestion] } : {} } : (
+            // 🔴 交给模型的原因里不带设备名：名字是家庭成员在 App 里起的，别让它进提示词。设备名只进给人看的回显
+            { decision: "deny", reason: "\u7528\u6237\u5728 DeskBuddy \u8BBE\u5907\u4E0A\u62D2\u7EDD\u4E86\u8FD9\u4E00\u6B65\uFF0C\u4E0D\u8981\u91CD\u8BD5\u8FD9\u4E2A\u64CD\u4F5C", notice }
+          )
+        );
+      } else {
+        waiter(decision === "allow" ? { decision: "allow" } : { decision: "deny", reason: REASON_DENIED });
+      }
+      return;
+    }
+    this.#d.store.save();
+    if (rec.mode === "window") {
+      rec.consumed = true;
+      this.#windows.delete(approvalId);
+      this.#d.store.save();
+      return;
+    }
+    if (rec.mode === "defer") {
+      this.#d.resume(rec, "deferred");
+      return;
+    }
+    rec.consumed = true;
+    this.#d.store.save();
+    if (decision === "allow") this.#d.resume(rec, "orphan");
+  }
+  /**
+   * 同一会话来了新指令：等待中的那一步按"没批准"处理（spec E9，和窗口里弹框时直接打字一样）。
+   * 🔴 必须在新指令【入队之前】调：hold 模式下旧进程还占着这个会话的串行队列，
+   * 不先放掉它，新指令会排在一个永远等不到批准的进程后面。
+   */
+  cancelSession(sessionId) {
+    for (const run2 of this.#runs.values()) {
+      if (run2.sessionId === sessionId) run2.superseded = true;
+    }
+    for (const rec of this.#d.store.pendingForSession(sessionId)) {
+      rec.status = "cancelled";
+      rec.decidedAt = this.#now();
+      const waiter = this.#waiters.get(rec.approvalId);
+      if (waiter) {
+        this.#waiters.delete(rec.approvalId);
+        rec.consumed = true;
+        waiter(rec.mode === "window" ? { decision: "none" } : { decision: "deny", reason: REASON_SUPERSEDED });
+      }
+      if (rec.mode === "window") {
+        rec.consumed = true;
+        this.#windows.delete(rec.approvalId);
+      }
+      void this.#cancelRemote(rec.approvalId, "\u540C\u4E00\u4F1A\u8BDD\u6536\u5230\u4E86\u65B0\u6307\u4EE4");
+    }
+    this.#d.store.save();
+  }
+  /**
+   * 一次 run 结束（评审 S3）：它名下还在原地等（hold）的请求全部撤掉。
+   * 智能体被 SIGKILL 时它起的 gate 子进程未必跟着死，socket 一直开着、abort 永远不来 ——
+   * 不在这里兜，等待表和设备上的卡片就一直留着。
+   * defer 的不动：进程正常退出后本来就该留着等批准。
+   */
+  endRun(runId) {
+    this.#runs.delete(runId);
+    let changed = false;
+    for (const rec of this.#d.store.pending()) {
+      if (rec.runId !== runId || rec.mode !== "hold") continue;
+      rec.status = "cancelled";
+      rec.decidedAt = this.#now();
+      rec.consumed = true;
+      changed = true;
+      const waiter = this.#waiters.get(rec.approvalId);
+      if (waiter) {
+        this.#waiters.delete(rec.approvalId);
+        waiter({ decision: "deny", reason: "\u5DF2\u53D6\u6D88" });
+      }
+      void this.#cancelRemote(rec.approvalId, "\u667A\u80FD\u4F53\u8FDB\u7A0B\u5DF2\u7ED3\u675F");
+    }
+    if (changed) this.#d.store.save();
+  }
+  /**
+   * 这个会话的一次 run 跑完了：在它【开始之前】就已有结果、却还没被用掉的记录，作废（评审 S2）。
+   *
+   * 🔴 否则一条已批准的记录可能留 7 天（续跑失败 / 模型换了写法没再发同一个调用），
+   * 之后同一会话里一模一样的命令会被它静默放行。
+   * 只作废 run 开始前就定了的：run 期间才到的决定，对应的续跑可能还排在队里没跑
+   */
+  settleSession(sessionId, runStartedAt) {
+    if (!sessionId) return;
+    let changed = false;
+    for (const rec of this.#d.store.all()) {
+      if (rec.sessionId !== sessionId || rec.consumed || rec.status === "pending") continue;
+      if ((rec.decidedAt ?? 0) >= runStartedAt) continue;
+      rec.consumed = true;
+      changed = true;
+    }
+    if (changed) this.#d.store.save();
+  }
+  /** 重连后补收离线期间做的决定 */
+  async syncPending() {
+    for (const rec of this.#d.store.pending()) {
+      if (rec.mode === "window" && !this.#waiters.has(rec.approvalId)) this.#settleWindow(rec, "\u5B88\u62A4\u8FDB\u7A0B\u91CD\u542F\u8FC7");
+    }
+    for (const rec of this.#d.store.all()) {
+      if (rec.cancelPending) void this.#cancelRemote(rec.approvalId, rec.cancelPending);
+    }
+    const ids = this.#d.store.pending().map((r) => r.approvalId);
+    for (let i = 0; i < ids.length; i += 50) {
+      try {
+        const got = await this.#d.backend.sync(ids.slice(i, i + 50));
+        for (const g of got) {
+          if (g.decision === "cancelled") this.#markCancelled(g.approvalId);
+          else this.onDecision(g.approvalId, g.decision, g.deviceName);
+        }
+      } catch (e) {
+        this.#d.log(`\u540C\u6B65\u6388\u6743\u72B6\u6001\u5931\u8D25\uFF1A${e.message}`);
+        return;
+      }
+    }
+  }
+  /**
+   * 服务端说这条已经取消了（本地的 cancel 已送达，但本地记录没落上盘之类）：
+   * 本地跟着标掉，不续跑。hold 还挂着的话按拒绝放掉
+   */
+  #markCancelled(approvalId) {
+    const rec = this.#d.store.get(approvalId);
+    if (!rec || rec.status !== "pending") return;
+    rec.status = "cancelled";
+    rec.decidedAt = this.#now();
+    const waiter = this.#waiters.get(approvalId);
+    if (waiter) {
+      this.#waiters.delete(approvalId);
+      rec.consumed = true;
+      waiter(rec.mode === "window" ? { decision: "none" } : { decision: "deny", reason: REASON_SUPERSEDED });
+    }
+    if (rec.mode === "window") {
+      rec.consumed = true;
+      this.#windows.delete(approvalId);
+    }
+    this.#d.store.save();
+  }
+  async #cancelRemote(approvalId, reason) {
+    const rec = this.#d.store.get(approvalId);
+    try {
+      await this.#d.backend.cancel(approvalId, reason);
+      if (rec?.cancelPending) {
+        rec.cancelPending = void 0;
+        this.#d.store.save();
+      }
+    } catch (e) {
+      if (rec) {
+        rec.cancelPending = reason;
+        this.#d.store.save();
+      }
+      this.#d.log(`\u64A4\u9500\u6388\u6743\u8BF7\u6C42 ${approvalId} \u5931\u8D25\uFF0C\u91CD\u8FDE\u540E\u91CD\u8BD5\uFF1A${e.message}`);
+    }
+  }
+  /** 只给测试和诊断用 */
+  get waiting() {
+    return this.#waiters.size;
+  }
+};
+function realpathNearest(p) {
+  let cur = p;
+  const tail = [];
+  for (let i = 0; i < 64; i++) {
+    try {
+      if (existsSync9(cur)) return join10(realpathSync(cur), ...tail.reverse());
+    } catch {
+      return p;
+    }
+    const parent = dirname5(cur);
+    if (parent === cur) return p;
+    tail.push(basename5(cur));
+    cur = parent;
+  }
+  return p;
+}
+function cwdForms(cwd) {
+  try {
+    const real = realpathSync(cwd);
+    return real === cwd ? [cwd] : [cwd, real];
+  } catch {
+    return [cwd];
+  }
+}
+
+// src/daemon/gate/server.ts
+import { randomBytes as randomBytes3, timingSafeEqual } from "crypto";
+import { createServer } from "http";
+import { mkdirSync as mkdirSync8, renameSync as renameSync6, rmSync as rmSync3, writeFileSync as writeFileSync8 } from "fs";
+import { join as join11 } from "path";
+var MAX_BODY_BYTES = 8 * 1024 * 1024;
+function gateConfPath() {
+  return join11(deskbuddyHome(), "gate.json");
+}
+function tokenEquals(a, b) {
+  const x = Buffer.from(a);
+  const y = Buffer.from(b);
+  return x.length === y.length && timingSafeEqual(x, y);
+}
+var GateServer = class {
+  #handler;
+  #token = randomBytes3(32).toString("hex");
+  #server = null;
+  constructor(handler) {
+    this.#handler = handler;
+  }
+  get token() {
+    return this.#token;
+  }
+  /** 起监听并写 gate.json。返回实际端口 */
+  async start() {
+    const server = createServer((req, res) => void this.#serve(req, res));
+    await new Promise((resolve3, reject) => {
+      server.once("error", reject);
+      server.listen(0, "127.0.0.1", () => resolve3());
+    });
+    this.#server = server;
+    const addr = server.address();
+    const port = typeof addr === "object" && addr ? addr.port : 0;
+    mkdirSync8(deskbuddyHome(), { recursive: true });
+    const tmp = gateConfPath() + ".tmp";
+    writeFileSync8(tmp, JSON.stringify({ port, token: this.#token, pid: process.pid }), {
+      encoding: "utf8",
+      mode: 384
+    });
+    renameSync6(tmp, gateConfPath());
+    return port;
+  }
+  async stop() {
+    try {
+      rmSync3(gateConfPath(), { force: true });
+    } catch {
+    }
+    const s = this.#server;
+    this.#server = null;
+    if (s) await new Promise((resolve3) => s.close(() => resolve3()));
+  }
+  async #serve(req, res) {
+    const reply = (status, body2) => {
+      if (res.writableEnded || res.destroyed) return;
+      res.writeHead(status, { "content-type": "application/json" });
+      res.end(body2 ? JSON.stringify(body2) : "");
+    };
+    if (req.method !== "POST" || req.url !== "/gate") return reply(404);
+    const token = req.headers["x-gate-token"];
+    if (typeof token !== "string" || !tokenEquals(token, this.#token)) return reply(403);
+    let body = "";
+    let size = 0;
+    try {
+      for await (const chunk of req) {
+        size += chunk.length;
+        if (size > MAX_BODY_BYTES) return reply(413);
+        body += String(chunk);
+      }
+    } catch {
+      return reply(400);
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      return reply(400);
+    }
+    if (!parsed.hook || typeof parsed.hook !== "object") return reply(400);
+    const window = parsed.mode === "window";
+    if (!window && typeof parsed.runId !== "string") return reply(400);
+    const ac = new AbortController();
+    res.on("close", () => {
+      if (!res.writableEnded) ac.abort();
+    });
+    try {
+      const req2 = window ? {
+        window: true,
+        tool: typeof parsed.tool === "string" && /^[a-z_]{1,32}$/.test(parsed.tool) ? parsed.tool : "claude_code",
+        hook: parsed.hook
+      } : { runId: parsed.runId, hook: parsed.hook };
+      const out = await this.#handler(req2, ac.signal);
+      reply(200, out);
+    } catch {
+      reply(500);
+    }
+  }
+};
+
+// src/daemon/handshake.ts
+import { randomBytes as randomBytes4 } from "crypto";
+var PARAM = {
+  appId: "ShiFeng-AppId",
+  timestamp: "ShiFeng-Timestamp",
+  signature: "ShiFeng-Signature",
+  deviceId: "ShiFeng-Device-ID",
+  deviceName: "ShiFeng-Device-Name",
+  nonce: "ShiFeng-Nonce"
+};
+var WS_PATH = "/deskbuddy";
+function sanitizeParamValue(value) {
+  return (value || "").replace(/[=&]/g, "-");
+}
+function buildHandshakeParts(cfg, opts = {}) {
+  const timestamp = opts.timestamp || String(Date.now());
+  const nonce = opts.nonce || randomBytes4(8).toString("hex");
+  const deviceId = sanitizeParamValue(cfg.clientId);
+  const deviceName = sanitizeParamValue(cfg.hostName);
+  return {
+    timestamp,
+    nonce,
+    deviceId,
+    deviceName,
+    signature: sign({
+      appId: APP_ID,
+      appSecret: APP_SECRET,
+      timestamp,
+      deviceId,
+      deviceName,
+      nonce,
+      body: ""
+      // ← 建连没有 body，服务端也是拿空串参与签名
+    })
+  };
+}
+function toWsOrigin(apiBase) {
+  const trimmed = (apiBase || "").replace(/\/+$/, "");
+  if (trimmed.startsWith("https://")) return "wss://" + trimmed.slice("https://".length);
+  if (trimmed.startsWith("http://")) return "ws://" + trimmed.slice("http://".length);
+  return trimmed;
+}
+function buildHandshakeUrl(cfg, opts = {}) {
+  const p = buildHandshakeParts(cfg, opts);
+  const query = [
+    [PARAM.appId, APP_ID],
+    [PARAM.timestamp, p.timestamp],
+    [PARAM.signature, p.signature],
+    [PARAM.deviceId, p.deviceId],
+    [PARAM.deviceName, p.deviceName],
+    [PARAM.nonce, p.nonce]
+  ].map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
+  return `${toWsOrigin(cfg.apiBase)}${WS_PATH}?${query}`;
+}
+
+// src/daemon/log.ts
+import { appendFileSync, mkdirSync as mkdirSync9, statSync as statSync2, truncateSync } from "fs";
+import { join as join12 } from "path";
+var MAX_LOG_BYTES = 2 * 1024 * 1024;
+function logPath() {
+  return join12(deskbuddyHome(), "daemon.log");
+}
+function rotateIfNeeded(path) {
+  try {
+    if (statSync2(path).size > MAX_LOG_BYTES) truncateSync(path, 0);
+  } catch {
+  }
+}
+function log(line) {
+  const stamped = `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+`;
+  try {
+    mkdirSync9(deskbuddyHome(), { recursive: true });
+    const p = logPath();
+    rotateIfNeeded(p);
+    appendFileSync(p, stamped, "utf8");
+  } catch {
+  }
+  if (process.env.DESKBUDDY_DAEMON_FOREGROUND === "1") {
+    process.stdout.write(stamped);
+  }
+}
+function daemonLogPath() {
+  return logPath();
+}
+
+// src/daemon/queue.ts
+var SessionQueue = class {
+  /** sessionId → 该会话的队尾 promise。空闲后会被清掉，不会无限增长 */
+  #tails = /* @__PURE__ */ new Map();
+  /**
+   * 把一个任务排到该 sessionId 的队尾。返回的 promise 在**这个任务**结束时落定
+   * （成功或失败都落定为 fulfilled，失败信息由调用方在 job 内部自己处理）。
+   *
+   * 🔴 链上必须 catch：一条指令抛异常而不吞掉的话，这个 sessionId 的队尾会变成
+   * rejected promise，后续所有指令都会跟着被拒 —— 一次失败让这个会话**永久**
+   * 收不到指令，而且没有任何报错。
+   */
+  enqueue(sessionId, job) {
+    const key = sessionId || "";
+    const prev = this.#tails.get(key) ?? Promise.resolve();
+    const next = prev.then(job).catch(() => {
+    });
+    this.#tails.set(key, next);
+    void next.then(() => {
+      if (this.#tails.get(key) === next) this.#tails.delete(key);
+    });
+    return next;
+  }
+  /** 当前有多少个会话still有在跑/排队的任务。只给测试和诊断用 */
+  get activeSessions() {
+    return this.#tails.size;
+  }
+  /** 等所有会话都排空。只给测试和优雅退出用 */
+  async drain() {
+    while (this.#tails.size > 0) {
+      await Promise.all([...this.#tails.values()]);
+    }
+  }
+};
+
+// src/daemon/remote.ts
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync8, renameSync as renameSync7, writeFileSync as writeFileSync9 } from "fs";
+import { join as join13 } from "path";
+function handleDir() {
+  return join13(deskbuddyHome(), "remote");
+}
+function handlePath(tool) {
+  const safe = (tool || "").replace(/[^0-9a-zA-Z_-]/g, "");
+  return join13(handleDir(), `${safe || "unknown"}.json`);
+}
+function readHandle(tool) {
+  try {
+    const h = JSON.parse(readFileSync8(handlePath(tool), "utf8"));
+    if (typeof h?.sessionId !== "string" || !h.sessionId) return null;
+    if (typeof h?.cwd !== "string" || !h.cwd) return null;
+    return h;
+  } catch {
+    return null;
+  }
+}
+function writeHandle(tool, handle) {
+  try {
+    mkdirSync10(handleDir(), { recursive: true });
+    const tmp = handlePath(tool) + ".tmp";
+    writeFileSync9(tmp, JSON.stringify(handle), "utf8");
+    renameSync7(tmp, handlePath(tool));
+  } catch {
+  }
+}
+function handleIsUsable(handle) {
+  const s = readState(handle.sessionId);
+  if (!s) return false;
+  if (s.pid && !isAlive(s.pid, s.pidName)) return false;
+  return true;
+}
+
+// src/daemon/resolve.ts
+function resolveTarget(cmd, deps) {
+  if (cmd.sessionId) {
+    const sessionId = deps.alias ? deps.alias(cmd.sessionId) : cmd.sessionId;
+    const state = deps.readState(sessionId);
+    if (!state) return { ok: false, reason: "session_gone" };
+    if (!state.cwd) return { ok: false, reason: "no_cwd" };
+    if (deps.windowOpen?.(state)) return { ok: false, reason: "window_open" };
+    return { ok: true, sessionId, cwd: state.cwd, handleKey: cmd.tool };
+  }
+  let dirCwd = "";
+  if (cmd.dirRef) {
+    dirCwd = deps.dirOf ? deps.dirOf(cmd.dirRef) : "";
+    if (!dirCwd) return { ok: false, reason: "dir_gone" };
+  }
+  const handleKey = cmd.dirRef ? `${cmd.tool}_${cmd.dirRef}` : cmd.tool;
+  const handle = deps.readHandle(handleKey);
+  const handleState = handle ? deps.readState(handle.sessionId) : null;
+  const handleInWindow = !!(handleState && deps.windowOpen?.(handleState));
+  if (handle && !handleInWindow && deps.handleIsUsable(handle)) {
+    return { ok: true, sessionId: handle.sessionId, cwd: handle.cwd, handleKey };
+  }
+  const cwd = dirCwd || deps.remoteCwd();
+  if (!cwd) return { ok: false, reason: "no_remote_cwd" };
+  return { ok: true, sessionId: "", cwd, handleKey };
+}
+function failureMessage(reason) {
+  switch (reason) {
+    case "session_gone":
+      return "\u8FD9\u4E2A\u4F1A\u8BDD\u5DF2\u7ECF\u4E0D\u5728\u4E86";
+    case "no_cwd":
+      return "\u8FD9\u4E2A\u4F1A\u8BDD\u9700\u8981\u66F4\u65B0 DeskBuddy \u540E\u624D\u80FD\u8FDC\u7A0B\u64CD\u4F5C";
+    case "no_remote_cwd":
+      return "\u8FD8\u6CA1\u8BBE\u7F6E\u8FDC\u7A0B\u4EFB\u52A1\u7684\u5DE5\u4F5C\u76EE\u5F55\uFF0C\u8BF7\u5728\u7535\u8111\u4E0A\u8DD1\u4E00\u6B21 deskbuddy setup";
+    case "window_open":
+      return "\u8FD9\u4E2A\u4EFB\u52A1\u6B63\u5728\u7535\u8111\u4E0A\u6253\u5F00\uFF0C\u8BF7\u5728\u7535\u8111\u4E0A\u7EE7\u7EED\uFF0C\u6216\u65B0\u5EFA\u4EFB\u52A1";
+    case "dir_gone":
+      return "\u7535\u8111\u4E0A\u627E\u4E0D\u5230\u8FD9\u4E2A\u76EE\u5F55\u4E86\uFF0C\u8BF7\u6362\u4E00\u4E2A\u76EE\u5F55";
+  }
+}
+
+// src/daemon/seen.ts
+import { mkdirSync as mkdirSync11, readFileSync as readFileSync9, renameSync as renameSync8, writeFileSync as writeFileSync10 } from "fs";
+import { join as join14 } from "path";
+var SEEN_CAPACITY = 200;
+function seenPath() {
+  return join14(deskbuddyHome(), "seen.json");
+}
+var SeenIds = class _SeenIds {
+  #ids = [];
+  #set = /* @__PURE__ */ new Set();
+  constructor(initial = []) {
+    for (const id of initial) this.#push(id);
+  }
+  #push(id) {
+    if (this.#set.has(id)) return;
+    this.#ids.push(id);
+    this.#set.add(id);
+    while (this.#ids.length > SEEN_CAPACITY) {
+      const dropped = this.#ids.shift();
+      if (dropped !== void 0) this.#set.delete(dropped);
+    }
+  }
+  has(id) {
+    return this.#set.has(id);
+  }
+  /** 记下来。返回 true 表示这是**新的**（之前没见过） */
+  remember(id) {
+    if (this.#set.has(id)) return false;
+    this.#push(id);
+    return true;
+  }
+  snapshot() {
+    return [...this.#ids];
+  }
+  static load() {
+    try {
+      const raw = JSON.parse(readFileSync9(seenPath(), "utf8"));
+      return new _SeenIds(Array.isArray(raw?.ids) ? raw.ids.filter((x) => typeof x === "string") : []);
+    } catch {
+      return new _SeenIds();
+    }
+  }
+  save() {
+    try {
+      mkdirSync11(deskbuddyHome(), { recursive: true });
+      const tmp = seenPath() + ".tmp";
+      writeFileSync10(tmp, JSON.stringify({ ids: this.#ids }), "utf8");
+      renameSync8(tmp, seenPath());
+    } catch {
+    }
+  }
+};
+
+// src/daemon/codexWatch.ts
+import { execFileSync as execFileSync4 } from "child_process";
+import WebSocket from "ws";
+var RESUME_RETRY_MS = 1e3;
+var RESUME_MAX_TRIES = 120;
+var REQUEST_TIMEOUT_MS = 30 * 1e3;
+function isLoopbackWs(url) {
+  try {
+    const u = new URL(url);
+    return (u.protocol === "ws:" || u.protocol === "wss:") && ["127.0.0.1", "localhost", "[::1]"].includes(u.hostname);
+  } catch {
+    return false;
+  }
+}
+function parseAppServerUrls(psOutput) {
+  const urls = [];
+  for (const line of psOutput.split("\n")) {
+    if (!/\bcodex\b/.test(line) || !/\bapp-server\b/.test(line)) continue;
+    const m = line.match(/--listen[= ](ws:\/\/\S+)/);
+    if (m && isLoopbackWs(m[1]) && !urls.includes(m[1])) urls.push(m[1]);
+  }
+  return urls;
+}
+function discoverAppServer(configured) {
+  if (configured) return isLoopbackWs(configured) ? configured : null;
+  try {
+    const out = execFileSync4("ps", ["-A", "-ww", "-o", "args="], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    return parseAppServerUrls(out)[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+function unwrapShell(command) {
+  const m = command.match(/^\/bin\/(?:ba|z)?sh -lc '([\s\S]*)'$/);
+  return m ? m[1].replace(/'\\''/g, "'") : command;
+}
+var CodexWatch = class {
+  #d;
+  #ws = null;
+  #url = "";
+  #nextId = 1;
+  #calls = /* @__PURE__ */ new Map();
+  /** 已订阅的会话 */
+  #subscribed = /* @__PURE__ */ new Set();
+  /** 正在重试订阅的会话 → 已试次数 */
+  #retrying = /* @__PURE__ */ new Map();
+  #cwd = /* @__PURE__ */ new Map();
+  /** fileChange 条目 → 改动的文件（授权请求本身不带文件，从 item/started 记） */
+  #changes = /* @__PURE__ */ new Map();
+  /** 服务端请求 id → 放掉等待的开关、所属会话 */
+  #pending = /* @__PURE__ */ new Map();
+  #stopped = false;
+  /** 已空闲的会话（有卡片在等时暂缓退订，卡片了结后补退） */
+  #idle = /* @__PURE__ */ new Set();
+  /** 连接代数：断线重连后，上一条连接遗留的订阅重试不再跑 */
+  #gen = 0;
+  constructor(deps) {
+    this.#d = { connect: (url) => new WebSocket(url), ...deps };
+  }
+  get connected() {
+    return this.#ws !== null;
+  }
+  /** 定时调：没连上就找一次 app-server 连上去；连着时 codex 被 disable 了就断开 */
+  tick() {
+    if (this.#stopped) return;
+    if (this.#ws) {
+      if (this.#d.enabled && !this.#d.enabled()) this.#teardown();
+      return;
+    }
+    const url = (this.#d.discover ?? (() => discoverAppServer()))();
+    if (!url || !isLoopbackWs(url)) return;
+    this.#open(url);
+  }
+  stop() {
+    this.#stopped = true;
+    this.#teardown();
+  }
+  #open(url) {
+    let ws;
+    try {
+      ws = this.#d.connect(url);
+    } catch {
+      return;
+    }
+    this.#ws = ws;
+    this.#url = url;
+    this.#gen++;
+    ws.on("open", () => void this.#onOpen());
+    ws.on("message", (buf) => this.#onMessage(String(buf)));
+    ws.on("close", () => this.#teardown());
+    ws.on("error", () => this.#teardown());
+  }
+  #teardown() {
+    const ws = this.#ws;
+    if (!ws) return;
+    this.#ws = null;
+    try {
+      ws.terminate();
+    } catch {
+    }
+    for (const c of this.#calls.values()) {
+      clearTimeout(c.timer);
+      c.resolve({ error: { message: "disconnected" } });
+    }
+    this.#calls.clear();
+    for (const { ac } of this.#pending.values()) ac.abort();
+    this.#pending.clear();
+    this.#subscribed.clear();
+    this.#retrying.clear();
+    this.#cwd.clear();
+    this.#changes.clear();
+    this.#idle.clear();
+    this.#d.log(`\u5DF2\u65AD\u5F00 Codex app-server ${this.#url}`);
+  }
+  #send(obj) {
+    try {
+      this.#ws?.send(JSON.stringify({ jsonrpc: "2.0", ...obj }));
+    } catch {
+    }
+  }
+  #request(method, params) {
+    const id = this.#nextId++;
+    return new Promise((resolve3) => {
+      const timer = setTimeout(() => {
+        this.#calls.delete(id);
+        resolve3({ error: { message: "timeout" } });
+      }, REQUEST_TIMEOUT_MS);
+      timer.unref?.();
+      this.#calls.set(id, { resolve: resolve3, timer });
+      this.#send({ id, method, params });
+    });
+  }
+  async #onOpen() {
+    const r = await this.#request("initialize", { clientInfo: { name: "deskbuddy", version: "1" } });
+    if (r.error) {
+      this.#d.log(`Codex app-server \u521D\u59CB\u5316\u5931\u8D25\uFF1A${JSON.stringify(r.error).slice(0, 120)}`);
+      this.#teardown();
+      return;
+    }
+    this.#send({ method: "initialized" });
+    this.#d.log(`\u5DF2\u8FDE\u4E0A Codex app-server ${this.#url}\uFF0C\u7A97\u53E3\u6388\u6743\u53EF\u63A8\u5230\u8BBE\u5907`);
+  }
+  #subscribe(threadId) {
+    if (this.#subscribed.has(threadId) || this.#retrying.has(threadId)) return;
+    this.#retrying.set(threadId, 0);
+    const gen = this.#gen;
+    const attempt = async () => {
+      if (!this.#ws || gen !== this.#gen || !this.#retrying.has(threadId)) return;
+      const r = await this.#request("thread/resume", { threadId });
+      if (gen !== this.#gen || !this.#retrying.has(threadId)) {
+        if (!r.error && gen === this.#gen) void this.#request("thread/unsubscribe", { threadId });
+        return;
+      }
+      if (!r.error) {
+        this.#retrying.delete(threadId);
+        this.#subscribed.add(threadId);
+        const cwd = r.result?.thread?.cwd;
+        if (typeof cwd === "string") this.#cwd.set(threadId, cwd);
+        return;
+      }
+      const n = (this.#retrying.get(threadId) ?? 0) + 1;
+      if (n >= RESUME_MAX_TRIES) {
+        this.#retrying.delete(threadId);
+        return;
+      }
+      this.#retrying.set(threadId, n);
+      setTimeout(() => void attempt(), RESUME_RETRY_MS).unref?.();
+    };
+    void attempt();
+  }
+  /** 会话空闲了：退订，让 app-server 能在窗口关掉后卸载它。还有设备卡片在等的先不退 */
+  #unsubscribe(threadId) {
+    this.#retrying.delete(threadId);
+    if (!this.#subscribed.has(threadId)) return;
+    for (const p of this.#pending.values()) if (p.threadId === threadId) return;
+    this.#subscribed.delete(threadId);
+    void this.#request("thread/unsubscribe", { threadId });
+  }
+  #onMessage(raw) {
+    let m;
+    try {
+      m = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    const id = m.id;
+    const method = typeof m.method === "string" ? m.method : "";
+    if (id !== void 0 && !method) {
+      const c = this.#calls.get(id);
+      if (c) {
+        clearTimeout(c.timer);
+        this.#calls.delete(id);
+        c.resolve(m);
+      }
+      return;
+    }
+    const params = m.params && typeof m.params === "object" ? m.params : {};
+    if (id !== void 0) {
+      this.#onServerRequest(id, method, params);
+      return;
+    }
+    this.#onNotification(method, params);
+  }
+  #onNotification(method, p) {
+    switch (method) {
+      case "thread/started": {
+        const t = p.thread;
+        if (t && typeof t.id === "string" && typeof t.cwd === "string") this.#cwd.set(t.id, t.cwd);
+        return;
+      }
+      case "thread/status/changed": {
+        const id = typeof p.threadId === "string" ? p.threadId : "";
+        const type = p.status?.type;
+        if (!id) return;
+        if (type === "active") {
+          this.#idle.delete(id);
+          this.#subscribe(id);
+        } else {
+          this.#idle.add(id);
+          this.#unsubscribe(id);
+        }
+        return;
+      }
+      case "thread/closed":
+        if (typeof p.threadId === "string") {
+          this.#idle.delete(p.threadId);
+          this.#subscribed.delete(p.threadId);
+          this.#retrying.delete(p.threadId);
+          this.#cwd.delete(p.threadId);
+        }
+        return;
+      case "item/started": {
+        const item = p.item;
+        if (item && item.type === "fileChange" && typeof item.id === "string" && Array.isArray(item.changes)) {
+          const paths = item.changes.map((c) => typeof c?.path === "string" ? c.path : "").filter(Boolean);
+          this.#changes.set(item.id, paths);
+        }
+        return;
+      }
+      case "item/completed": {
+        const item = p.item;
+        if (item && typeof item.id === "string") this.#changes.delete(item.id);
+        return;
+      }
+      case "serverRequest/resolved": {
+        const key = String(p.requestId);
+        const pend = this.#pending.get(key);
+        if (pend) {
+          this.#pending.delete(key);
+          pend.ac.abort();
+          if (this.#idle.has(pend.threadId)) this.#unsubscribe(pend.threadId);
+        }
+        return;
+      }
+      default:
+    }
+  }
+  #onServerRequest(id, method, p) {
+    const threadId = typeof p.threadId === "string" ? p.threadId : "";
+    if (!threadId) return;
+    let hook;
+    if (method === "item/commandExecution/requestApproval") {
+      const command = typeof p.command === "string" ? unwrapShell(p.command) : "";
+      if (!command) return;
+      hook = { tool_name: "Bash", tool_input: { command }, cwd: typeof p.cwd === "string" ? p.cwd : this.#cwd.get(threadId) ?? "" };
+    } else if (method === "item/fileChange/requestApproval") {
+      if (typeof p.grantRoot === "string" && p.grantRoot) return;
+      const paths = typeof p.itemId === "string" && this.#changes.get(p.itemId) || [];
+      const shown = paths.join(", ");
+      if (!shown) return;
+      hook = { tool_name: "Edit", tool_input: { file_path: shown }, cwd: this.#cwd.get(threadId) ?? "" };
+    } else {
+      return;
+    }
+    const key = String(id);
+    const ac = new AbortController();
+    const entry = { ac, threadId };
+    this.#pending.set(key, entry);
+    const req = {
+      window: true,
+      tool: "codex",
+      hook: { hook_event_name: "PermissionRequest", session_id: threadId, ...hook }
+    };
+    const settled = () => {
+      if (this.#idle.has(threadId)) this.#unsubscribe(threadId);
+    };
+    void this.#d.gate(req, ac.signal).then((reply) => {
+      if (this.#pending.get(key) !== entry) return;
+      this.#pending.delete(key);
+      if (reply.decision === "allow") this.#send({ id, result: { decision: "accept" } });
+      else if (reply.decision === "deny") this.#send({ id, result: { decision: "decline" } });
+      settled();
+    }).catch(() => {
+      if (this.#pending.get(key) === entry) this.#pending.delete(key);
+      settled();
+    });
+  }
+};
+
+// src/daemon/index.ts
+var IDLE_TIMEOUT_MS = 150 * 1e3;
+var POLICY_VIOLATION = 1008;
+var PING_FRAME_SERVICE = "ping";
+var PONG_FRAME = JSON.stringify({ service: "pong", version: "1.0" });
+var CODEX_WATCH_MS = 5 * 1e3;
+function defaultCodexAppServer() {
+  const cfg = loadConfig();
+  return cfg.enabledTools.includes("codex") ? discoverAppServer(cfg.codexAppServer) : null;
+}
+function opencodeReady() {
+  return isOcPluginInstalled(opencodePluginPath()) && existsSync10(ocPluginModule(installedHookPath()));
+}
+function orphanResumeText(summary) {
+  return `\uFF08\u4F60\u5728\u8BBE\u5907\u4E0A\u5DF2\u6279\u51C6\uFF1A${summary}\uFF09\u8BF7\u7EE7\u7EED\u521A\u624D\u88AB\u4E2D\u65AD\u7684\u64CD\u4F5C\u3002`;
+}
+var ALIVE_REPORT_MS = 60 * 1e3;
+var Daemon = class {
+  #queue = new SessionQueue();
+  #seen = SeenIds.load();
+  #deps;
+  #store = ApprovalStore.load();
+  #coord;
+  #gate;
+  /** runId → 这次 run 结束的 promise。defer 续跑要等原进程真退出了再起（见 #scheduleResume） */
+  #runsDone = /* @__PURE__ */ new Map();
+  #attempt = 0;
+  #stopped = false;
+  #ws = null;
+  #idleTimer = null;
+  #windowScan = null;
+  #aliveReport = null;
+  #codexTimer = null;
+  #codex = null;
+  constructor(deps = {}) {
+    this.#deps = {
+      connect: deps.connect ?? ((url) => new WebSocket2(url)),
+      now: deps.now ?? (() => Date.now()),
+      backend: deps.backend ?? serverBackend(),
+      gateScript: deps.gateScript ?? defaultGateScript(),
+      // 🔴 优先用 PATH 上那个稳定的 node（如 /opt/homebrew/bin/node 这种链接），不用 process.execPath：
+      //    后者是 Cellar 里的真实路径，`brew upgrade node` 之后就被删了，而 daemon 还活着、
+      //    hook 命令里写的还是旧路径 —— hook 起不来，Qoder 在 bypass 下就是全放行（评审 R3）
+      nodePath: deps.nodePath ?? whichIn("node", defaultLocateDeps()) ?? process.execPath,
+      materialize: deps.materialize ?? ((plan, tool) => materialize(plan, tool)),
+      opencodeReady: deps.opencodeReady ?? opencodeReady,
+      codexAppServer: deps.codexAppServer ?? defaultCodexAppServer
+    };
+    this.#store.prune(this.#deps.now());
+    this.#coord = new ApprovalCoordinator({
+      store: this.#store,
+      backend: this.#deps.backend,
+      policy: () => loadConfig().approvalPolicy ?? "commands",
+      resume: (r, kind) => this.#scheduleResume(r, kind),
+      log,
+      now: this.#deps.now
+    });
+    this.#gate = new GateServer((req, signal) => this.#coord.onGate(req, signal));
+  }
+  /** 起本地授权端点。必须在执行任何指令之前起好 —— 否则 gate 连不上，全部 exit 2 */
+  async startGate() {
+    const port = await this.#gate.start();
+    log(`\u6388\u6743\u7AEF\u70B9\u5DF2\u5C31\u7EEA 127.0.0.1:${port}`);
+    this.#windowScan = setInterval(() => this.#coord.scanWindows(), 1e3);
+    this.#windowScan.unref();
+    this.#aliveReport = setInterval(() => void this.#reportAlive(), ALIVE_REPORT_MS);
+    this.#aliveReport.unref();
+    this.#codex = new CodexWatch({
+      gate: (req, signal) => this.#coord.onGate(req, signal),
+      log,
+      discover: () => this.#deps.codexAppServer(),
+      enabled: () => loadConfig().enabledTools.includes("codex")
+    });
+    this.#codex.tick();
+    this.#codexTimer = setInterval(() => this.#codex?.tick(), CODEX_WATCH_MS);
+    this.#codexTimer.unref();
+    return port;
+  }
+  #lastDirs = "";
+  #dirsTick = 0;
+  /**
+   * 上报最近目录（二期 P6）：连上时一次，之后每 10 分钟；内容没变不报。
+   * 🔴 只报目录名与 ref，全路径不出本机
+   */
+  async #reportDirs(force = false) {
+    const cfg = loadConfig();
+    if (!cfg.clientId || !cfg.boundAt) return;
+    const dirs = recentDirs().map(({ ref, name, lastUsedAt }) => ({ ref, name, lastUsedAt }));
+    const fp = JSON.stringify(dirs.map((d) => [d.ref, d.name]));
+    if (!force && fp === this.#lastDirs) return;
+    try {
+      await api.dirsReport({ clientId: cfg.clientId, dirs });
+      this.#lastDirs = fp;
+    } catch (e) {
+      log(`\u4E0A\u62A5\u6700\u8FD1\u76EE\u5F55\u5931\u8D25\uFF1A${e.message}`);
+    }
+  }
+  /** 按已启用的工具各报一次存活会话快照（readAliveStates 顺手剔除死进程） */
+  async #reportAlive() {
+    const cfg = loadConfig();
+    if (!cfg.clientId || !cfg.boundAt) return;
+    for (const tool of cfg.enabledTools) {
+      await postReport(buildSnapshot(readAliveStates(tool), tool, cfg, this.#deps.now()));
+    }
+    if (++this.#dirsTick % 10 === 0) await this.#reportDirs();
+  }
+  get coordinator() {
+    return this.#coord;
+  }
+  stop() {
+    this.#stopped = true;
+    this.#clearIdle();
+    if (this.#windowScan) clearInterval(this.#windowScan);
+    if (this.#aliveReport) clearInterval(this.#aliveReport);
+    if (this.#codexTimer) clearInterval(this.#codexTimer);
+    this.#codex?.stop();
+    this.#ws?.close();
+    void this.#gate.stop();
+  }
+  #clearIdle() {
+    if (this.#idleTimer) {
+      clearTimeout(this.#idleTimer);
+      this.#idleTimer = null;
+    }
+  }
+  /**
+   * 空闲超时兜底。
+   *
+   * 光靠 ws 的 'close' 事件不够：网络被静默掐断（睡眠唤醒、切 Wi-Fi、NAT 超时）时
+   * TCP 连接会僵在那儿，close 事件永远不来，于是守护进程"看起来连着"、实际收不到
+   * 任何指令，而且没有任何症状。
+   */
+  #armIdle() {
+    this.#clearIdle();
+    this.#idleTimer = setTimeout(() => {
+      log("idle \u8D85\u65F6\u672A\u6536\u5230\u4EFB\u4F55\u5E27\uFF0C\u4E3B\u52A8\u65AD\u5F00\u91CD\u8FDE");
+      this.#ws?.terminate();
+    }, IDLE_TIMEOUT_MS);
+  }
+  connect() {
+    if (this.#stopped) return;
+    const cfg = loadConfig();
+    if (!cfg.boundAt) {
+      log("\u5C1A\u672A\u6388\u6743\uFF08\u6CA1\u6709 boundAt\uFF09\uFF0C\u4E0D\u5EFA\u8FDE\u3002\u5148\u8DD1 deskbuddy setup");
+      return;
+    }
+    const url = buildHandshakeUrl(cfg);
+    log(`\u5EFA\u8FDE\u4E2D ${cfg.apiBase}`);
+    let ws;
+    try {
+      ws = this.#deps.connect(url);
+    } catch (e) {
+      this.#scheduleReconnect(`\u5EFA\u8FDE\u629B\u5F02\u5E38: ${e.message}`);
+      return;
+    }
+    this.#ws = ws;
+    ws.on("open", () => {
+      this.#attempt = 0;
+      log("\u5DF2\u8FDE\u4E0A");
+      this.#armIdle();
+      void this.#coord.syncPending();
+      void this.#reportDirs(true);
+    });
+    ws.on("message", (raw) => {
+      this.#armIdle();
+      this.#onMessage(String(raw));
+    });
+    ws.on("error", (e) => log(`\u8FDE\u63A5\u51FA\u9519: ${e.message}`));
+    ws.on("close", (code, reason) => {
+      this.#clearIdle();
+      this.#ws = null;
+      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;
+        return;
+      }
+      this.#scheduleReconnect(`\u8FDE\u63A5\u5173\u95ED(${code})`);
+    });
+  }
+  #sendPong() {
+    try {
+      this.#ws?.send(PONG_FRAME);
+    } catch (e) {
+      log(`\u56DE pong \u5931\u8D25: ${e.message}`);
+    }
+  }
+  #scheduleReconnect(why) {
+    if (this.#stopped) return;
+    this.#attempt++;
+    const delay = backoffDelay(this.#attempt);
+    log(`${why}\uFF0C${delay}ms \u540E\u91CD\u8FDE\uFF08\u7B2C ${this.#attempt} \u6B21\uFF09`);
+    setTimeout(() => this.connect(), delay).unref?.();
+  }
+  #onMessage(raw) {
+    let frame;
+    try {
+      frame = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (frame?.service === PING_FRAME_SERVICE) {
+      this.#sendPong();
+      return;
+    }
+    const ap = parseApprovalFrame(frame);
+    if (ap) {
+      if (!this.#seen.remember(ap.instructionId)) return;
+      this.#seen.save();
+      log(`\u6536\u5230\u6388\u6743\u51B3\u5B9A ${ap.approvalId} ${ap.decision}`);
+      this.#coord.onDecision(ap.approvalId, ap.decision, ap.deviceName);
+      return;
+    }
+    const cmd = parseCommand(frame);
+    if (!cmd) return;
+    if (!this.#seen.remember(cmd.instructionId)) {
+      log(`\u6307\u4EE4 ${cmd.instructionId} \u5DF2\u5904\u7406\u8FC7\uFF0C\u4E22\u5F03`);
+      return;
+    }
+    this.#seen.save();
+    if (isExpired(cmd, this.#deps.now())) {
+      log(`\u6307\u4EE4 ${cmd.instructionId} \u5DF2\u8FC7\u671F\uFF0C\u4E22\u5F03`);
+      return;
+    }
+    const target = resolveTarget(cmd, {
+      readState,
+      readHandle,
+      handleIsUsable,
+      remoteCwd: () => loadConfig().remoteCwd || "",
+      alias: resolveAlias,
+      dirOf: (ref) => dirOf(ref),
+      windowOpen: (s) => s.interactive === true && !!s.pid && isAlive(s.pid, s.pidName)
+    });
+    if (!target.ok) {
+      log(`\u6307\u4EE4 ${cmd.instructionId} \u65E0\u6CD5\u6267\u884C\uFF1A${failureMessage(target.reason)}`);
+      return;
+    }
+    if (target.sessionId) this.#coord.cancelSession(target.sessionId);
+    this.#queue.enqueue(target.sessionId, () => this.#execute(cmd, target.sessionId, target.cwd, target.handleKey));
+  }
+  async #execute(cmd, sessionId, cwd, handleKey = cmd.tool) {
+    if (sessionId) {
+      const fresh = readState(sessionId);
+      if (!fresh) {
+        log(`\u6307\u4EE4 ${cmd.instructionId} \u653E\u5F03\uFF1A\u4F1A\u8BDD ${sessionId} \u5728\u6267\u884C\u524D\u5DF2\u6D88\u5931`);
+        return;
+      }
+    }
+    const runId = newRunId();
+    const plan = buildSpawnPlan({ ...cmd, sessionId }, cwd, this.#gateTarget(runId));
+    if (!plan) {
+      log(`\u6307\u4EE4 ${cmd.instructionId} \u653E\u5F03\uFF1A\u672C\u673A\u4E0D\u652F\u6301\u8FDC\u7A0B\u6267\u884C ${cmd.tool}`);
+      return;
+    }
+    log(`\u6267\u884C ${cmd.instructionId} tool=${cmd.tool} ${sessionId ? "resume" : "new"} cwd=\u2026/${basename6(cwd)} len=${cmd.text.length}`);
+    const result = await this.#run(plan, cmd.tool, runId, sessionId, cwd);
+    if (!result) {
+      log(`\u6307\u4EE4 ${cmd.instructionId} \u653E\u5F03\uFF1A\u672C\u673A\u627E\u4E0D\u5230 ${cmd.tool} \u7684\u53EF\u6267\u884C\u6587\u4EF6`);
+      return;
+    }
+    if (isDeferred(result.stdout)) log(`\u6307\u4EE4 ${cmd.instructionId} \u505C\u5728\u7B49\u8BBE\u5907\u6388\u6743\u4E0A\uFF0C\u8FDB\u7A0B\u5DF2\u9000\u51FA`);
+    if (!result.ok) {
+      log(`\u6307\u4EE4 ${cmd.instructionId} \u6267\u884C\u5931\u8D25\uFF1A${result.error}`);
+    }
+    if (!sessionId) {
+      const newId = result.sessionId ?? parseSessionId(cmd.tool, result.stdout);
+      if (newId) {
+        writeHandle(handleKey, { sessionId: newId, cwd, createdAt: this.#deps.now() });
+        log(`\u6307\u4EE4 ${cmd.instructionId} \u5EFA\u51FA\u4F1A\u8BDD ${newId}\uFF0C\u5DF2\u8BB0\u4E3A ${cmd.tool} \u7684\u8FDC\u7A0B\u4F1A\u8BDD`);
+      } else {
+        log(`\u6307\u4EE4 ${cmd.instructionId} \u672A\u80FD\u89E3\u6790\u51FA\u4F1A\u8BDD id\uFF0C\u4E0B\u6B21\u4ECD\u4F1A\u65B0\u5EFA`);
       }
     }
-  } catch {
   }
-  try {
-    return deps.kernelRelease();
-  } catch {
-    return "";
+  #gateTarget(runId) {
+    return { runId, nodePath: this.#deps.nodePath, gateScript: this.#deps.gateScript };
   }
-}
-var machineInfoCache = null;
-function machineInfo() {
-  if (!machineInfoCache) {
-    machineInfoCache = {
-      os: humanOs(),
-      osVersion: productOsVersion(),
-      arch: process.arch,
-      cliVersion: packageVersion()
-    };
+  /** 设备上有了决定、需要续会话。排进该会话的串行队列，和普通指令一样不会并发打同一个会话 */
+  #scheduleResume(r, kind) {
+    if (!r.sessionId) {
+      log(`\u6388\u6743 ${r.approvalId} \u6CA1\u6709\u4F1A\u8BDD id\uFF0C\u65E0\u6CD5\u7EED\u8DD1`);
+      return;
+    }
+    const origin = this.#runsDone.get(r.runId) ?? Promise.resolve();
+    void origin.then(() => this.#queue.enqueue(r.sessionId, () => this.#resume(r, kind)));
   }
-  return machineInfoCache;
+  async #resume(r, kind) {
+    if (kind === "deferred" && r.consumed) {
+      log(`\u6388\u6743 ${r.approvalId} \u5DF2\u5728\u524D\u4E00\u6B21\u7EED\u8DD1\u4E2D\u5904\u7406\uFF0C\u8DF3\u8FC7`);
+      return;
+    }
+    const runId = newRunId();
+    const text = kind === "deferred" ? "" : orphanResumeText(r.summary);
+    const plan = buildSpawnPlan(
+      { instructionId: `resume-${r.approvalId}`, type: "text", sessionId: r.sessionId, tool: r.tool, text, expireAt: 0 },
+      r.cwd,
+      this.#gateTarget(runId)
+    );
+    if (!plan) {
+      log(`\u6388\u6743 ${r.approvalId} \u7EED\u8DD1\u653E\u5F03\uFF1A\u672C\u673A\u4E0D\u652F\u6301\u8FDC\u7A0B\u6267\u884C ${r.tool}`);
+      return;
+    }
+    log(`\u7EED\u8DD1\u4F1A\u8BDD ${r.sessionId}\uFF08\u6388\u6743 ${r.approvalId} ${r.status}\uFF0C${kind}\uFF09`);
+    const result = await this.#run(plan, r.tool, runId, r.sessionId, r.cwd);
+    if (!r.consumed) {
+      r.consumed = true;
+      this.#store.save();
+    }
+    if (!result) log(`\u7EED\u8DD1\u4F1A\u8BDD ${r.sessionId} \u653E\u5F03\uFF1A\u672C\u673A\u627E\u4E0D\u5230 ${r.tool} \u7684\u53EF\u6267\u884C\u6587\u4EF6`);
+    else if (isDeferred(result.stdout)) log(`\u4F1A\u8BDD ${r.sessionId} \u53C8\u505C\u5728\u4E86\u4E0B\u4E00\u4E2A\u7B49\u6388\u6743\u7684\u64CD\u4F5C\u4E0A`);
+    else if (!result.ok) log(`\u7EED\u8DD1\u4F1A\u8BDD ${r.sessionId} \u5931\u8D25\uFF1A${result.error}`);
+    else log(`\u7EED\u8DD1\u4F1A\u8BDD ${r.sessionId} \u5B8C\u6210`);
+  }
+  /**
+   * 起进程并在授权协调器里登记这次 run（gate 靠 runId 认人）。
+   * 找不到可执行文件返回 null。
+   */
+  async #run(plan, tool, runId, sessionId, cwd) {
+    if (!existsSync10(this.#deps.nodePath) || !existsSync10(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 null;
+    }
+    if (tool === "opencode" && !this.#deps.opencodeReady()) {
+      log("opencode \u63D2\u4EF6\u4E0D\u5728\uFF08deskbuddy enable opencode \u6CA1\u88C5\u6216\u5DF2\u5378\u8F7D\uFF09\uFF0C\u62D2\u7EDD\u6267\u884C opencode");
+      return null;
+    }
+    const real = this.#deps.materialize(plan, tool);
+    if (!real) return null;
+    const startedAt = this.#deps.now();
+    const rc = startCommand(real, tool);
+    this.#coord.registerRun({
+      runId,
+      tool,
+      cwd,
+      mode: waitModeFor(tool),
+      sessionId,
+      // 原地等设备批准的时间不算执行时间（spec §5.5）
+      onWaitStart: () => rc.pauseTimeout(),
+      onWaitEnd: () => rc.resumeTimeout()
+    });
+    this.#runsDone.set(runId, rc.done);
+    try {
+      return await rc.done;
+    } finally {
+      this.#runsDone.delete(runId);
+      const sid = sessionId || this.#coord.sessionOf(runId);
+      this.#coord.endRun(runId);
+      this.#coord.settleSession(sid, startedAt);
+    }
+  }
+};
+function newRunId() {
+  return randomBytes5(12).toString("hex");
 }
-async function call(service, data, timeoutMs = DEFAULT_TIMEOUT_MS) {
+async function runDaemon(deps = {}) {
+  const d = new Daemon(deps);
+  await d.startGate();
+  d.connect();
+  return d;
+}
+
+// src/commands/daemon.ts
+async function runDaemonCommand(opts = {}) {
   const cfg = loadConfig();
-  const body = buildGatewayBody(service, data);
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  if (!cfg.boundAt) {
+    process.stderr.write("\u2717 \u8FD8\u6CA1\u6388\u6743\u3002\u5148\u8DD1 deskbuddy setup\n");
+    return 1;
+  }
+  if (opts.foreground) process.env.DESKBUDDY_DAEMON_FOREGROUND = "1";
   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 ?? "");
+    writeFileSync11(pidFilePath(), String(process.pid), "utf8");
+  } catch {
+  }
+  let daemon;
+  try {
+    daemon = await runDaemon();
+  } 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 shutdown = (sig) => {
+    log(`\u6536\u5230 ${sig}\uFF0C\u9000\u51FA`);
+    daemon.stop();
+    try {
+      rmSync4(pidFilePath(), { force: true });
+    } catch {
     }
-    return json?.data;
-  } finally {
-    clearTimeout(timer);
+    process.exit(0);
+  };
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  if (opts.foreground) {
+    process.stdout.write(`\u5B88\u62A4\u8FDB\u7A0B\u5DF2\u542F\u52A8\uFF08pid ${process.pid}\uFF09\uFF0C\u65E5\u5FD7\uFF1A${daemonLogPath()}
+\u6309 Ctrl+C \u9000\u51FA
+`);
   }
+  return new Promise(() => {
+  });
 }
-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)
-};
 
 // src/core/registry.ts
+import { mkdirSync as mkdirSync12, readFileSync as readFileSync10, writeFileSync as writeFileSync12 } from "fs";
+import { join as join15 } from "path";
 var FALLBACK = {
   version: "builtin",
   tools: {
@@ -295,7 +2960,16 @@ var FALLBACK = {
       format: "cc-hook",
       processNames: ["claude"],
       titleSources: ["cc-ai-title", "git-branch", "project"],
-      events: { UserPromptSubmit: "watch", PreToolUse: "watch", PostToolUse: "watch", Stop: "done" },
+      events: {
+        UserPromptSubmit: "watch",
+        PreToolUse: "watch",
+        PostToolUse: "watch",
+        // 工具跑失败时 Claude Code 发这个而不是 PostToolUse；窗口待批准撤卡也要认它
+        PostToolUseFailure: "watch",
+        Stop: "done",
+        // 窗口里弹授权框的那一刻就是待确认（S10），不等之后那条权限通知
+        PermissionRequest: "ask_approval"
+      },
       lifecycle: { SessionStart: "ignore", SessionEnd: "remove" }
     },
     codex: {
@@ -312,15 +2986,55 @@ var FALLBACK = {
         PermissionRequest: "ask_approval"
       },
       lifecycle: { SessionStart: "ignore", SessionEnd: "remove" }
+    },
+    workbuddy: {
+      format: "cc-hook",
+      processNames: ["WorkBuddy"],
+      titleSources: ["git-branch", "project"],
+      events: {
+        UserPromptSubmit: "watch",
+        PreToolUse: "watch",
+        PostToolUse: "watch",
+        Stop: "done",
+        PermissionRequest: "ask_approval"
+      },
+      lifecycle: { SessionStart: "ignore", SessionEnd: "remove" }
+    },
+    qoder: {
+      format: "cc-hook",
+      processNames: ["Qoder CN"],
+      titleSources: ["git-branch", "project"],
+      events: {
+        UserPromptSubmit: "watch",
+        PreToolUse: "watch",
+        PostToolUse: "watch",
+        Stop: "done",
+        PermissionRequest: "ask_approval"
+      },
+      lifecycle: { SessionStart: "ignore", SessionEnd: "remove" }
+    },
+    opencode: {
+      format: "oc-plugin",
+      processNames: ["opencode"],
+      // opencode 自带的会话标题是模型对提问的摘要，违反隐私约束（spec §6.4），不用
+      titleSources: ["git-branch", "project"],
+      events: {
+        UserPromptSubmit: "watch",
+        PreToolUse: "watch",
+        PostToolUse: "watch",
+        Stop: "done",
+        PermissionRequest: "ask_approval"
+      },
+      lifecycle: { SessionEnd: "remove" }
     }
   }
 };
 function registryCachePath() {
-  return join3(deskbuddyHome(), "tool-registry.json");
+  return join15(deskbuddyHome(), "tool-registry.json");
 }
 function loadRegistry() {
   try {
-    return JSON.parse(readFileSync4(registryCachePath(), "utf8"));
+    return JSON.parse(readFileSync10(registryCachePath(), "utf8"));
   } catch {
     return FALLBACK;
   }
@@ -328,15 +3042,15 @@ function loadRegistry() {
 async function refreshRegistry() {
   try {
     const registry = await api.toolRegistry();
-    mkdirSync3(deskbuddyHome(), { recursive: true });
-    writeFileSync3(registryCachePath(), JSON.stringify(registry, null, 2), "utf8");
+    mkdirSync12(deskbuddyHome(), { recursive: true });
+    writeFileSync12(registryCachePath(), JSON.stringify(registry, null, 2), "utf8");
   } catch {
   }
 }
 
 // src/adapters/ccHook.ts
-import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync5, renameSync as renameSync2, statSync, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname2 } from "path";
+import { chmodSync as chmodSync2, existsSync as existsSync11, mkdirSync as mkdirSync13, readFileSync as readFileSync11, renameSync as renameSync9, statSync as statSync3, writeFileSync as writeFileSync13 } from "fs";
+import { dirname as dirname6, join as join16 } from "path";
 var CC_EVENTS = [
   "UserPromptSubmit",
   "PreToolUse",
@@ -346,8 +3060,8 @@ var CC_EVENTS = [
   "SessionEnd"
 ];
 function readSettings(path) {
-  if (!existsSync3(path)) return {};
-  const raw = readFileSync5(path, "utf8");
+  if (!existsSync11(path)) return {};
+  const raw = readFileSync11(path, "utf8");
   if (raw.trim() === "") return {};
   try {
     return JSON.parse(raw);
@@ -356,17 +3070,17 @@ function readSettings(path) {
   }
 }
 function writeSettings(path, settings) {
-  mkdirSync4(dirname2(path), { recursive: true });
+  mkdirSync13(dirname6(path), { recursive: true });
   let mode;
   try {
-    mode = statSync(path).mode & 511;
+    mode = statSync3(path).mode & 511;
   } catch {
     mode = void 0;
   }
   const tmp = path + ".deskbuddy.tmp";
-  writeFileSync4(tmp, JSON.stringify(settings, null, 2), "utf8");
-  if (mode !== void 0) chmodSync(tmp, mode);
-  renameSync2(tmp, path);
+  writeFileSync13(tmp, JSON.stringify(settings, null, 2), "utf8");
+  if (mode !== void 0) chmodSync2(tmp, mode);
+  renameSync9(tmp, path);
 }
 function installCcHook(settingsPath, hookPath, events = CC_EVENTS, tool = "claude_code") {
   const settings = readSettings(settingsPath);
@@ -379,14 +3093,30 @@ function installCcHook(settingsPath, hookPath, events = CC_EVENTS, tool = "claud
   }
   writeSettings(settingsPath, settings);
 }
+var WINDOW_GATE_TIMEOUT_S = 7 * 24 * 60 * 60;
+function shQuote2(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function installCcWindowGate(settingsPath, gatePath, tool = "claude_code") {
+  const settings = readSettings(settingsPath);
+  settings.hooks ??= {};
+  const groups = settings.hooks.PermissionRequest ??= [];
+  if (groups.some((g) => g.hooks?.some((h) => h.command?.includes(gatePath)))) return;
+  const toolArg = tool === "claude_code" ? "" : ` --tool ${tool}`;
+  groups.push({
+    hooks: [{ type: "command", command: `node ${shQuote2(gatePath)} --window${toolArg}`, timeout: WINDOW_GATE_TIMEOUT_S }]
+  });
+  writeSettings(settingsPath, settings);
+}
 function uninstallCcHook(settingsPath, hookPath) {
   const settings = readSettings(settingsPath);
   if (!settings.hooks) return;
+  const gatePath = join16(dirname6(hookPath), "gate.cjs");
   for (const event of Object.keys(settings.hooks)) {
     const groups = settings.hooks[event] ?? [];
     const kept = [];
     for (const g of groups) {
-      const hooks = (g.hooks ?? []).filter((h) => !h.command?.includes(hookPath));
+      const hooks = (g.hooks ?? []).filter((h) => !h.command?.includes(hookPath) && !h.command?.includes(gatePath));
       if (hooks.length > 0) kept.push({ ...g, hooks });
     }
     settings.hooks[event] = kept;
@@ -395,8 +3125,8 @@ function uninstallCcHook(settingsPath, hookPath) {
 }
 
 // src/adapters/codexHook.ts
-import { chmodSync as chmodSync2, existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync6, renameSync as renameSync3, statSync as statSync2, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname3, join as join4 } from "path";
+import { chmodSync as chmodSync3, existsSync as existsSync12, mkdirSync as mkdirSync14, readFileSync as readFileSync12, renameSync as renameSync10, statSync as statSync4, writeFileSync as writeFileSync14 } from "fs";
+import { dirname as dirname7, join as join17 } from "path";
 var CODEX_MARKER_BEGIN = "# >>> deskbuddy >>>";
 var CODEX_MARKER_END = "# <<< deskbuddy <<<";
 var CODEX_EVENTS = [
@@ -407,9 +3137,9 @@ var CODEX_EVENTS = [
   "SessionEnd",
   "PermissionRequest"
 ];
-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";
+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 join4(codexHome(), "config.toml");
+  return join17(codexHome(), "config.toml");
 }
 function renderBlock(hookPath, events, tool) {
   const command = JSON.stringify(`node ${hookPath} ${tool}`);
@@ -428,17 +3158,17 @@ function renderBlock(hookPath, events, tool) {
   return lines.join("\n");
 }
 function writeAtomic(path, content) {
-  mkdirSync5(dirname3(path), { recursive: true });
+  mkdirSync14(dirname7(path), { recursive: true });
   let mode;
   try {
-    mode = statSync2(path).mode & 511;
+    mode = statSync4(path).mode & 511;
   } catch {
     mode = void 0;
   }
   const tmp = path + ".deskbuddy.tmp";
-  writeFileSync5(tmp, content, "utf8");
-  if (mode !== void 0) chmodSync2(tmp, mode);
-  renameSync3(tmp, path);
+  writeFileSync14(tmp, content, "utf8");
+  if (mode !== void 0) chmodSync3(tmp, mode);
+  renameSync10(tmp, path);
 }
 function assertSafeToAppend(raw, path) {
   for (const quote of ['"""', "'''"]) {
@@ -448,7 +3178,7 @@ function assertSafeToAppend(raw, path) {
   }
 }
 function installCodexHook(configPath2, hookPath, events = CODEX_EVENTS, tool = "codex") {
-  const raw = existsSync4(configPath2) ? readFileSync6(configPath2, "utf8") : "";
+  const raw = existsSync12(configPath2) ? readFileSync12(configPath2, "utf8") : "";
   if (raw.includes(CODEX_MARKER_BEGIN)) return;
   assertSafeToAppend(raw, configPath2);
   const block = renderBlock(hookPath, events, tool);
@@ -456,8 +3186,8 @@ function installCodexHook(configPath2, hookPath, events = CODEX_EVENTS, tool = "
   writeAtomic(configPath2, head + block + "\n");
 }
 function uninstallCodexHook(configPath2) {
-  if (!existsSync4(configPath2)) return;
-  const raw = readFileSync6(configPath2, "utf8");
+  if (!existsSync12(configPath2)) return;
+  const raw = readFileSync12(configPath2, "utf8");
   const lines = raw.split("\n");
   const begin = lines.findIndex((l) => l.trim() === CODEX_MARKER_BEGIN);
   if (begin === -1) return;
@@ -471,31 +3201,55 @@ function uninstallCodexHook(configPath2) {
 }
 
 // src/commands/tools.ts
-import { existsSync as existsSync5, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync13 } from "fs";
 function fileContains(path, needle) {
   try {
-    if (!existsSync5(path)) return false;
-    return readFileSync7(path, "utf8").includes(needle);
+    if (!existsSync13(path)) return false;
+    return readFileSync13(path, "utf8").includes(needle);
   } catch {
     return false;
   }
 }
+var CC_CONFIG_PATHS = {
+  claude_code: claudeSettingsPath,
+  workbuddy: workbuddySettingsPath,
+  qoder: qoderSettingsPath
+};
 var ADAPTERS = {
   "cc-hook": {
-    configPath: claudeSettingsPath,
+    configPath: (tool) => CC_CONFIG_PATHS[tool]?.() ?? null,
     install: (p, hook, events, tool) => installCcHook(p, hook, events, tool),
     uninstall: (p, hook) => uninstallCcHook(p, hook),
     isInstalled: (p, hook) => fileContains(p, hook),
-    defaultEvents: CC_EVENTS
+    defaultEvents: CC_EVENTS,
+    // 实测 PermissionRequest 与窗口授权框并行的：Claude Code（S10 §2）、Qoder CN 桌面端（二期 V8）。
+    // WorkBuddy 桌面端弹授权框不触发 PermissionRequest；Codex 的 hook 会阻塞授权框——都不装
+    installWindowGate: (p, gate, tool) => {
+      if (tool !== "claude_code" && tool !== "qoder") return false;
+      installCcWindowGate(p, gate, tool);
+      return true;
+    }
   },
   "codex-toml": {
-    configPath: codexConfigPath,
+    configPath: (tool) => tool === "codex" ? codexConfigPath() : null,
     install: (p, hook, events, tool) => installCodexHook(p, hook, events, tool),
     uninstall: (p) => uninstallCodexHook(p),
     isInstalled: (p) => fileContains(p, CODEX_MARKER_BEGIN),
     defaultEvents: CODEX_EVENTS,
     // 🔴 不打这句的话，用户会遇到「装成功了但没数据」，然后当成装失败
     notice: CODEX_TRUST_NOTICE
+  },
+  // opencode（二期 P9）：插件形态，事件翻译、窗口确认、远程关卡都在插件里；events 参数用不上
+  "oc-plugin": {
+    configPath: (tool) => tool === "opencode" ? opencodePluginPath() : null,
+    // 🔴 node 用 PATH 上稳定的那个（/opt/homebrew/bin/node 这种链接），同 daemon 的 nodePath
+    install: (p, hook) => installOcPlugin(p, hook, whichIn("node", defaultLocateDeps()) ?? process.execPath),
+    uninstall: (p) => uninstallOcPlugin(p),
+    isInstalled: (p) => isOcPluginInstalled(p),
+    defaultEvents: [],
+    notice: OC_NOTICE,
+    // 窗口确认就在插件里，不用另装
+    installWindowGate: () => true
   }
 };
 function adapterFor(registry, tool) {
@@ -539,7 +3293,8 @@ async function runDisable(tools, opts = {}) {
     if (!adapter) {
       continue;
     }
-    const configPath2 = adapter.configPath();
+    const configPath2 = adapter.configPath(tool);
+    if (!configPath2) continue;
     try {
       adapter.uninstall(configPath2, hookPath);
       out(`\u2705 ${tool}\uFF1A\u5DF2\u4ECE ${configPath2} \u79FB\u9664`);
@@ -552,6 +3307,10 @@ async function runDisable(tools, opts = {}) {
   }
   cfg.enabledTools = [...enabled];
   saveConfig(cfg);
+  if (enabled.size === 0 && !opts.keepAutostart) {
+    const r = await uninstallAutostart();
+    if (r.message) out(r.ok ? `\u2705 ${r.message}` : `\u26A0\uFE0F  ${r.message}`);
+  }
   if (!opts.brief) {
     out("");
     out("\u5DF2\u505C\u6B62\u91C7\u96C6\u3002\u6388\u6743\u4E0E clientId \u4ECD\u4FDD\u7559\uFF0C\u91CD\u65B0 deskbuddy enable \u5373\u53EF\u6062\u590D\u3002");
@@ -561,6 +3320,7 @@ async function runDisable(tools, opts = {}) {
 }
 
 // src/commands/enable.ts
+import { dirname as dirname8, join as join18 } from "path";
 function stdout2(line) {
   process.stdout.write(line + "\n");
 }
@@ -592,7 +3352,12 @@ async function runEnable(tools, opts = {}) {
       failed += 1;
       continue;
     }
-    const configPath2 = adapter.configPath();
+    const configPath2 = adapter.configPath(tool);
+    if (!configPath2) {
+      out(`\u2717 ${tool}\uFF1A\u672C\u5BA2\u6237\u7AEF\u4E0D\u77E5\u9053\u5B83\u7684\u914D\u7F6E\u6587\u4EF6\u5728\u54EA\uFF0C\u5DF2\u8DF3\u8FC7`);
+      failed += 1;
+      continue;
+    }
     const events = subscribedEvents(registry, tool, adapter.defaultEvents);
     try {
       adapter.install(configPath2, hookPath, events, tool);
@@ -603,28 +3368,41 @@ async function runEnable(tools, opts = {}) {
     }
     enabled.add(tool);
     out(`\u2705 ${tool}\uFF1Ahook \u5DF2\u88C5\u8FDB ${configPath2}\uFF08${events.length} \u4E2A\u4E8B\u4EF6\uFF09`);
+    try {
+      if (adapter.installWindowGate?.(configPath2, join18(dirname8(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}`);
+    }
     if (adapter.notice) out(adapter.notice);
   }
   cfg.enabledTools = [...enabled];
   saveConfig(cfg);
+  if (!opts.skipAutostart) {
+    const r = await installAutostart({ execPath: process.execPath, cliPath: defaultCliPath() });
+    out("");
+    out(r.ok ? `\u2705 ${r.message}` : `\u26A0\uFE0F  ${r.message}`);
+  }
   out("");
-  out("\u88C5\u5B8C\u4E86\u3002\u6CA1\u6709\u5E38\u9A7B\u8FDB\u7A0B \u2014\u2014 \u53EA\u662F\u5F80\u5404\u667A\u80FD\u4F53\u7684 hook \u914D\u7F6E\u91CC\u52A0\u4E86\u4E00\u6761\u8BB0\u5F55\u3002");
+  out("\u88C5\u5B8C\u4E86\u3002\u72B6\u6001\u91C7\u96C6\u9760 hook\uFF0C\u4E0D\u9700\u8981\u5E38\u9A7B\u8FDB\u7A0B\uFF1B");
+  out("\u5B88\u62A4\u8FDB\u7A0B\u53EA\u5728\u300C\u786C\u4EF6\u4E0A\u7ED9\u8FD9\u53F0\u7535\u8111\u4E0B\u6307\u4EE4\u300D\u65F6\u624D\u7528\u5F97\u7740\uFF0C\u5DF2\u968F\u4E0A\u9762\u4E00\u6B65\u8BBE\u597D\u5F00\u673A\u81EA\u542F\u3002");
   out("\u968F\u65F6\u53EF\u4EE5 deskbuddy status \u770B\u91C7\u96C6\u5230\u4E86\u4EC0\u4E48\u3001deskbuddy disable \u5E72\u51C0\u79FB\u9664\u3002");
   return failed > 0 ? 1 : 0;
 }
 
 // src/commands/logout.ts
 import { createInterface } from "readline";
-import { existsSync as existsSync6, rmSync } from "fs";
+import { existsSync as existsSync14, rmSync as rmSync5 } from "fs";
 function stdout3(line) {
   process.stdout.write(line + "\n");
 }
 function askYesNo(question) {
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     rl.question(question, (answer) => {
       rl.close();
-      resolve(/^(y|yes)$/i.test(answer.trim()));
+      resolve3(/^(y|yes)$/i.test(answer.trim()));
     });
   });
 }
@@ -645,9 +3423,9 @@ async function runLogout(opts = {}) {
       return 1;
     }
   }
-  await runDisable([], { out, brief: true });
-  if (existsSync6(home)) {
-    rmSync(home, { recursive: true, force: true });
+  await runDisable([], { out, brief: true, keepAutostart: opts.keepAutostart });
+  if (existsSync14(home)) {
+    rmSync5(home, { recursive: true, force: true });
   }
   out("");
   out("\u2705 \u5DF2\u6E05\u9664\u672C\u673A\u7684 DeskBuddy \u6570\u636E\u3002");
@@ -656,6 +3434,63 @@ async function runLogout(opts = {}) {
 
 // src/commands/setup.ts
 import qrcode from "qrcode-terminal";
+
+// src/commands/remoteCwd.ts
+import { existsSync as existsSync15, statSync as statSync5 } from "fs";
+import { createInterface as createInterface2 } from "readline";
+import { homedir as homedir5 } from "os";
+import { isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
+function normalizePath(raw, home = homedir5()) {
+  const s = (raw || "").trim();
+  if (!s) return null;
+  const expanded = s === "~" ? home : s.startsWith("~/") ? resolve2(home, s.slice(2)) : s;
+  const abs = isAbsolute2(expanded) ? expanded : resolve2(process.cwd(), expanded);
+  return abs;
+}
+function checkPath(abs) {
+  if (!existsSync15(abs)) return "missing";
+  try {
+    return statSync5(abs).isDirectory() ? "ok" : "not_a_dir";
+  } catch {
+    return "missing";
+  }
+}
+function resolveAnswer(raw, deps) {
+  const check = deps.check ?? checkPath;
+  const abs = normalizePath(raw, deps.home) ?? deps.defaultPath;
+  const verdict = check(abs);
+  return verdict === "ok" ? { ok: true, path: abs } : { ok: false, reason: verdict, path: abs };
+}
+function verdictMessage(reason, path) {
+  return reason === "not_a_dir" ? `${path} \u4E0D\u662F\u4E00\u4E2A\u76EE\u5F55` : `${path} \u4E0D\u5B58\u5728`;
+}
+var MAX_ATTEMPTS = 3;
+async function askRemoteCwd(deps) {
+  const defaultPath = deps.defaultPath ?? defaultRemoteCwd();
+  for (let i = 0; i < MAX_ATTEMPTS; i++) {
+    const raw = await deps.ask(`\u8FDC\u7A0B\u300C\u65B0\u5EFA\u4EFB\u52A1\u300D\u7684\u5DE5\u4F5C\u76EE\u5F55 [${defaultPath}]\uFF1A`);
+    if (raw === null) {
+      return defaultPath;
+    }
+    const r = resolveAnswer(raw, { defaultPath, check: deps.check });
+    if (r.ok) return r.path;
+    deps.out(`  \u2717 ${verdictMessage(r.reason, r.path)}\uFF0C\u8BF7\u91CD\u65B0\u8F93\u5165`);
+  }
+  deps.out(`  \u7528\u9ED8\u8BA4\u503C\uFF1A${defaultPath}`);
+  return defaultPath;
+}
+function terminalAsk(prompt) {
+  if (!process.stdin.isTTY) return Promise.resolve(null);
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  return new Promise((res) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      res(answer);
+    });
+  });
+}
+
+// src/commands/setup.ts
 var AUTH_CODE_INVALID = "8250";
 var DEFAULT_INTERVAL_SEC = 5;
 var SETUP_TIMEOUT_MS = 5 * 6e4;
@@ -752,76 +3587,18 @@ async function runSetup(opts = {}) {
   markBound();
   await refreshRegistry();
   out("");
+  out("\u5728\u786C\u4EF6\u4E0A\u300C\u65B0\u5EFA\u4EFB\u52A1\u300D\u65F6\uFF0Cagent \u4F1A\u5728\u4E0B\u9762\u8FD9\u4E2A\u76EE\u5F55\u91CC\u5E72\u6D3B\u3002");
+  out("\uFF08\u56DE\u590D\u67D0\u4E2A\u5DF2\u6709\u4F1A\u8BDD\u65F6\u7528\u7684\u662F\u90A3\u4E2A\u4F1A\u8BDD\u81EA\u5DF1\u7684\u76EE\u5F55\uFF0C\u4E0D\u53D7\u8FD9\u91CC\u5F71\u54CD\uFF09");
+  const remoteCwd = await askRemoteCwd({ out, ask: terminalAsk });
+  const bound = loadConfig();
+  bound.remoteCwd = remoteCwd;
+  saveConfig(bound);
+  out(`  \u5DF2\u8BB0\u4E0B\uFF1A${remoteCwd}`);
+  out("");
   out("\u2705 \u6388\u6743\u6210\u529F\u3002\u63A5\u4E0B\u6765\u8FD0\u884C\uFF1Adeskbuddy enable claude_code,codex");
   return 0;
 }
 
-// src/core/state.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync6, readdirSync, readFileSync as readFileSync8, renameSync as renameSync4, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
-import { join as join5 } from "path";
-
-// src/core/process.ts
-import { execFileSync as execFileSync2 } from "child_process";
-function processName(pid) {
-  try {
-    const out = execFileSync2("ps", ["-p", String(pid), "-o", "comm="], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    const name = out.trim();
-    return name === "" ? null : name;
-  } catch {
-    return null;
-  }
-}
-function isAlive(pid, expectName) {
-  if (!Number.isFinite(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-  } catch {
-    return false;
-  }
-  if (!expectName) return true;
-  const name = processName(pid);
-  return name != null && name.toLowerCase().includes(expectName.toLowerCase());
-}
-
-// 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 removeState(sessionId) {
-  try {
-    rmSync2(statePath(sessionId), { force: true });
-  } catch {
-  }
-}
-function readAliveStates(tool) {
-  if (!existsSync7(stateDir())) return [];
-  const alive = [];
-  for (const file of readdirSync(stateDir())) {
-    if (!file.endsWith(".json")) continue;
-    let s;
-    try {
-      s = JSON.parse(readFileSync8(join5(stateDir(), file), "utf8"));
-    } catch {
-      rmSync2(join5(stateDir(), file), { force: true });
-      continue;
-    }
-    if (s.tool !== tool) continue;
-    if (s.pid && !isAlive(s.pid, s.pidName)) {
-      removeState(s.sessionId);
-      continue;
-    }
-    alive.push(s);
-  }
-  return alive;
-}
-
 // src/commands/status.ts
 function fmtTime(ms) {
   const d = new Date(ms);
@@ -903,7 +3680,8 @@ function collectStatus(now = Date.now()) {
   for (const tool of config.enabledTools) {
     const adapter = adapterFor(registry, tool);
     if (!adapter) continue;
-    const configPath2 = adapter.configPath();
+    const configPath2 = adapter.configPath(tool);
+    if (!configPath2) continue;
     const installed = adapter.isInstalled(configPath2, hookPath);
     tools.push({
       tool,
@@ -929,6 +3707,26 @@ function runStatus(opts = {}) {
   return 0;
 }
 
+// src/commands/update.ts
+function stdout6(line) {
+  process.stdout.write(line + "\n");
+}
+async function runUpdate(opts = {}) {
+  const out = opts.out ?? stdout6;
+  const cfg = loadConfig();
+  if (!cfg.boundAt) {
+    out("\u8FD8\u6CA1\u6709\u6388\u6743\u3002\u8BF7\u5148\u8FD0\u884C\uFF1Adeskbuddy setup");
+    return 1;
+  }
+  if (cfg.enabledTools.length === 0) {
+    out("\u672C\u673A\u8FD8\u6CA1\u6709\u542F\u7528\u4EFB\u4F55\u5DE5\u5177\uFF0C\u6CA1\u4EC0\u4E48\u8981\u5347\u7EA7\u7684\u3002\u7528 deskbuddy enable <tool> \u542F\u7528");
+    return 1;
+  }
+  out(`\u5347\u7EA7\u5230 DeskBuddy ${packageVersion()}\uFF0C\u91CD\u88C5\u5DF2\u542F\u7528\u7684\uFF1A${cfg.enabledTools.join(", ")}`);
+  out("");
+  return runEnable([...cfg.enabledTools], opts);
+}
+
 // src/cli.ts
 var USAGE = `deskbuddy \u2014\u2014 \u628A AI \u7F16\u7801\u667A\u80FD\u4F53\u6BCF\u4E2A\u4F1A\u8BDD\u7A97\u53E3\u7684\u72B6\u6001\u540C\u6B65\u5230\u684C\u9762\u786C\u4EF6\u5C4F\u5E55
 
@@ -936,10 +3734,14 @@ var USAGE = `deskbuddy \u2014\u2014 \u628A AI \u7F16\u7801\u667A\u80FD\u4F53\u6B
   deskbuddy setup [--api-base <url>]    \u626B\u7801\u6388\u6743\uFF08--api-base \u6307\u5B9A\u7F51\u5173\u5E76\u8BB0\u4F4F\uFF0C\u9ED8\u8BA4\u751F\u4EA7\uFF09
   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
+  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
 
-\u88C5\u5B8C\u6CA1\u6709\u4EFB\u4F55\u5E38\u9A7B\u8FDB\u7A0B\uFF1A\u53EA\u662F\u5F80\u5404\u667A\u80FD\u4F53\u7684 hook \u914D\u7F6E\u91CC\u52A0\u4E86\u4E00\u6761\u8BB0\u5F55\u3002
+\u72B6\u6001\u91C7\u96C6\u4E0D\u9700\u8981\u5E38\u9A7B\u8FDB\u7A0B\uFF08\u53EA\u662F\u5F80\u5404\u667A\u80FD\u4F53\u7684 hook \u914D\u7F6E\u91CC\u52A0\u4E86\u4E00\u6761\u8BB0\u5F55\uFF09\uFF1B
+\u8981\u5728\u786C\u4EF6\u4E0A\u7ED9\u7535\u8111\u4E0B\u6307\u4EE4\uFF0C\u624D\u9700\u8981 daemon \u5E38\u9A7B\u2014\u2014setup \u65F6\u4F1A\u5E2E\u4F60\u8BBE\u597D\u5F00\u673A\u81EA\u542F\u3002
 \u5F53\u524D\u8FDE\u7684\u662F\u54EA\u4E2A\u73AF\u5883\uFF0C\u7528 deskbuddy status \u770B\u7B2C\u4E8C\u884C\u3002
 `;
 async function main(argv) {
@@ -968,6 +3770,10 @@ async function main(argv) {
       return runEnable(parseTools(arg));
     case "disable":
       return runDisable(parseTools(arg));
+    case "update":
+      return runUpdate();
+    case "daemon":
+      return runDaemonCommand({ foreground: argv.includes("--foreground") || argv.includes("-f") });
     case "status":
       return runStatus();
     case "logout":