deskbuddy 0.2.0-beta.2 → 0.2.0-beta.3

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/commands/daemon.ts
-import { writeFileSync as writeFileSync13, rmSync as rmSync7 } from "fs";
+import { writeFileSync as writeFileSync14, rmSync as rmSync9 } from "fs";
 
 // src/core/config.ts
 import { randomUUID } from "crypto";
@@ -406,7 +406,7 @@ function pidFilePath() {
 }
 
 // src/daemon/index.ts
-import { randomBytes as randomBytes5 } from "crypto";
+import { randomBytes as randomBytes6 } from "crypto";
 import { existsSync as existsSync10 } from "fs";
 import { basename as basename6 } from "path";
 import WebSocket2 from "ws";
@@ -620,7 +620,7 @@ function atomicCopy(from, to) {
 function syncHookFile(opts = {}) {
   const target = opts.target ?? installedHookPath();
   const version = opts.version ?? packageVersion();
-  const SIBLINGS = ["gate.cjs", "opencode.mjs"];
+  const SIBLINGS = ["gate.cjs", "opencode.mjs", "wake.cjs"];
   const siblingMissing = () => SIBLINGS.some((name) => {
     if (existsSync5(join5(dirname3(target), name))) return false;
     try {
@@ -1295,7 +1295,7 @@ function buildSpawnPlan(cmd, cwd, gate, home = homedir4()) {
         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 };
+      return { file, args: claudePlan(cmd, gate), cwd, env: { DESKBUDDY_NO_WAKE: "1" } };
   }
 }
 function materialize(plan, tool, d = defaultLocateDeps()) {
@@ -2437,10 +2437,14 @@ var SessionQueue = class {
    * rejected promise，后续所有指令都会跟着被拒 —— 一次失败让这个会话**永久**
    * 收不到指令，而且没有任何报错。
    */
-  enqueue(sessionId, job) {
+  enqueue(sessionId, job, onError) {
     const key = sessionId || "";
     const prev = this.#tails.get(key) ?? Promise.resolve();
-    const next = prev.then(job).catch(() => {
+    const next = prev.then(job).catch((e) => {
+      try {
+        onError?.(e);
+      } catch {
+      }
     });
     this.#tails.set(key, next);
     void next.then(() => {
@@ -3553,6 +3557,590 @@ function windowForSession(sessionId) {
   return id;
 }
 
+// src/core/wake.ts
+import { execFileSync as execFileSync7 } from "child_process";
+import { createHash as createHash3, createHmac as createHmac2, timingSafeEqual as timingSafeEqual2 } from "crypto";
+import { chmodSync as chmodSync4, closeSync, mkdirSync as mkdirSync14, openSync, readdirSync as readdirSync3, readFileSync as readFileSync13, readSync, renameSync as renameSync11, rmSync as rmSync7, statSync as statSync4, writeFileSync as writeFileSync13 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join17 } from "path";
+function wakeDir(home = deskbuddyHome()) {
+  return join17(home, "wake");
+}
+function marksDir(home = deskbuddyHome()) {
+  return join17(wakeDir(home), "marks");
+}
+function safeSid2(sessionId) {
+  return String(sessionId).replace(/[^A-Za-z0-9_-]/g, "");
+}
+function homeTag(home) {
+  return createHash3("sha1").update(home).digest("hex").slice(0, 16);
+}
+function wakeChannelPath(platform = process.platform, home = deskbuddyHome()) {
+  if (platform === "win32") return `\\\\.\\pipe\\deskbuddy-wake-${homeTag(home)}`;
+  const primary = join17(wakeDir(home), "wake.sock");
+  if (Buffer.byteLength(primary) <= 103) return primary;
+  const uid = typeof process.getuid === "function" ? process.getuid() : 0;
+  return join17(tmpdir2(), `deskbuddy-${uid}`, `wake-${homeTag(home)}.sock`);
+}
+function pidExists(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function writeWakeMark(sessionId, agentPid, now = Date.now()) {
+  const safe = safeSid2(sessionId);
+  if (!safe) return;
+  try {
+    mkdirSync14(marksDir(), { recursive: true, mode: 448 });
+    const file = join17(marksDir(), `${safe}.json`);
+    const tmp = `${file}.${process.pid}.tmp`;
+    writeFileSync13(tmp, JSON.stringify({ agentPid: agentPid ?? 0, daemonPid: process.pid, at: now }), { encoding: "utf8", mode: 384 });
+    renameSync11(tmp, file);
+  } catch {
+  }
+}
+function removeWakeMark(sessionId) {
+  const safe = safeSid2(sessionId);
+  if (!safe) return;
+  try {
+    rmSync7(join17(marksDir(), `${safe}.json`), { force: true });
+  } catch {
+  }
+}
+function clearWakeMarks() {
+  let names = [];
+  try {
+    names = readdirSync3(marksDir());
+  } catch {
+    return;
+  }
+  for (const n of names) {
+    try {
+      rmSync7(join17(marksDir(), n), { force: true });
+    } catch {
+    }
+  }
+}
+function isWakeMarked(sessionId, alive = pidExists) {
+  const safe = safeSid2(sessionId);
+  if (!safe) return false;
+  try {
+    const m = JSON.parse(readFileSync13(join17(marksDir(), `${safe}.json`), "utf8"));
+    const daemonPid = Number(m?.daemonPid) || 0;
+    if (!daemonPid || !alive(daemonPid)) return false;
+    const pid = Number(m?.agentPid) || 0;
+    return pid > 0 ? alive(pid) : true;
+  } catch {
+    return false;
+  }
+}
+function withWake(states, alive) {
+  return states.map((s) => s.remoteWindow === true || !isWakeMarked(s.sessionId, alive) ? s : { ...s, remoteWindow: true });
+}
+function wakeSecretPath(home = deskbuddyHome()) {
+  return join17(wakeDir(home), "secret");
+}
+function writeWakeSecret(hex, platform = process.platform) {
+  const file = wakeSecretPath();
+  mkdirSync14(wakeDir(), { recursive: true, mode: 448 });
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync13(tmp, hex, { encoding: "utf8", mode: 384 });
+  if (platform === "win32") {
+    try {
+      execFileSync7("icacls", [tmp, "/inheritance:r", "/grant:r", `${currentUserSid()}:F`], { stdio: "ignore", windowsHide: true });
+    } catch {
+      renameSync11(tmp, file);
+      return "\u7A97\u53E3\u5524\u9192\u5BC6\u94A5\u6587\u4EF6\u7684\u6743\u9650\u6CA1\u80FD\u6536\u7D27\uFF08icacls \u5931\u8D25\uFF09";
+    }
+  } else {
+    chmodSync4(tmp, 384);
+  }
+  renameSync11(tmp, file);
+  return "";
+}
+function currentUserSid() {
+  try {
+    const out = execFileSync7("whoami", ["/user", "/fo", "csv", "/nh"], { encoding: "utf8", windowsHide: true });
+    const m = /"(S-1-[0-9-]+)"/.exec(out);
+    if (m) return `*${m[1]}`;
+  } catch {
+  }
+  return String(process.env.USERNAME);
+}
+function canonicalJson(v) {
+  if (Array.isArray(v)) return "[" + v.map(canonicalJson).join(",") + "]";
+  if (v && typeof v === "object") {
+    const o = v;
+    return "{" + Object.keys(o).filter((k) => o[k] !== void 0).sort().map((k) => JSON.stringify(k) + ":" + canonicalJson(o[k])).join(",") + "}";
+  }
+  return JSON.stringify(v === void 0 ? null : v);
+}
+function wakeMac(secret, ...parts) {
+  return createHmac2("sha256", secret).update(parts.join("|"), "utf8").digest("hex");
+}
+var MAC_RE = /^[0-9a-f]{64}$/;
+function macEqual(a, b) {
+  if (typeof a !== "string" || typeof b !== "string" || !MAC_RE.test(a) || !MAC_RE.test(b)) return false;
+  return timingSafeEqual2(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
+}
+var WAKE_MARK_RE = /\[DeskBuddy#([0-9A-Za-z_-]{1,64})(?::[0-9a-f]{32})?\]/;
+var INTERRUPT_RE = /^\[Request interrupted by user/;
+var TRANSCRIPT_TAIL = 256 * 1024;
+function userText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((x) => x && x.type === "text").map((x) => String(x.text ?? "")).join("\n");
+}
+function analyzeTranscript(file) {
+  if (!file) return null;
+  let fd;
+  try {
+    const size = statSync4(file).size;
+    const len = Math.min(size, TRANSCRIPT_TAIL);
+    const buf = Buffer.alloc(len);
+    fd = openSync(file, "r");
+    readSync(fd, buf, 0, len, size - len);
+    const lines2 = buf.toString("utf8").split("\n");
+    let seg = false;
+    let reply = null;
+    let humanAfter = false;
+    let interrupted = null;
+    for (let i = lines2.length - 1; i >= 0; i--) {
+      const line = lines2[i];
+      if (line.indexOf('"assistant"') === -1 && line.indexOf('"user"') === -1) continue;
+      let o;
+      try {
+        o = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!o || !o.message) continue;
+      if (o.type === "assistant") {
+        const t = userText(o.message.content).trim();
+        if (t) {
+          seg = true;
+          if (reply === null) reply = t;
+        }
+        continue;
+      }
+      if (o.type !== "user") continue;
+      const text = userText(o.message.content);
+      if (!text) continue;
+      const m = WAKE_MARK_RE.exec(text);
+      if (!m && (o.isMeta === true || text.trim().startsWith("<"))) continue;
+      if (m) return { id: m[1], answered: seg, humanAfter, interrupted: interrupted === true, reply: reply ?? "" };
+      if (interrupted === null) interrupted = INTERRUPT_RE.test(text.trim());
+      humanAfter = true;
+      seg = false;
+      reply = null;
+    }
+    return interrupted === null ? null : { id: "", answered: false, humanAfter, interrupted, reply: "" };
+  } catch {
+    return null;
+  } finally {
+    if (fd !== void 0) {
+      try {
+        closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+
+// src/daemon/wake.ts
+import { randomBytes as randomBytes5 } from "crypto";
+import { rmSync as rmSync8 } from "fs";
+import { createServer as createServer3 } from "net";
+var BUSY_STATES = /* @__PURE__ */ new Set(["watch", "ask_approval"]);
+var STOP_MIN_MS = 1500;
+var WAKE_MAX_QUEUE_MS = 30 * 60 * 1e3;
+var WATCH_STALE_MS = 30 * 60 * 1e3;
+var INTERRUPTED_REASON = "exec_failed";
+var WakeHub = class {
+  #slots = /* @__PURE__ */ new Map();
+  #d;
+  constructor(deps) {
+    this.#d = {
+      ackTimeoutMs: 3e3,
+      maxQueueMs: WAKE_MAX_QUEUE_MS,
+      flightLimitMs: EXEC_TIMEOUT_MS,
+      watchStaleMs: WATCH_STALE_MS,
+      analyze: analyzeTranscript,
+      ...deps
+    };
+  }
+  /** 这个会话有没有登记中的等待者（或刚唤醒、正在跑的那一轮） */
+  has(sessionId) {
+    const s = this.#slots.get(sessionId);
+    return !!s && (!!s.reg || !!s.flight);
+  }
+  /** 交给唤醒路由。返回 false = 这个会话没有等待者，调用方走别的路 */
+  submit(cmd, sessionId) {
+    if (cmd.tool !== "claude_code") return false;
+    const slot = this.#slots.get(sessionId);
+    if (!slot || !slot.reg && !slot.flight) return false;
+    slot.queue.push({ cmd, sessionId, queuedAt: this.#d.now() });
+    this.#d.log(`\u6307\u4EE4 ${cmd.instructionId} \u4EA4\u7ED9\u7A97\u53E3\u5524\u9192\uFF08${slot.flight ? "\u4E0A\u4E00\u6761\u8FD8\u5728\u8DD1" : slot.reg ? "\u6709\u7B49\u5F85\u8005" : "\u65E0\u7B49\u5F85\u8005"}\uFF09`);
+    this.#settle(sessionId, slot);
+    return true;
+  }
+  onHello(peer, h) {
+    const sid = h.sessionId;
+    if (!isValidId(sid)) {
+      peer.close();
+      return;
+    }
+    const slot = this.#slot(sid);
+    if (h.transcript) slot.transcript = h.transcript;
+    if (h.event === "Stop" && !h.re) {
+      slot.lastStopAt = this.#d.now();
+      const f = slot.flight;
+      if (f) this.#onStop(sid, slot, f, h);
+    }
+    if (h.agentPid) {
+      for (const [other, s] of this.#slots) {
+        if (other === sid || !s.reg || s.agentPid !== h.agentPid || s.reg.pending) continue;
+        this.#evict(s);
+        for (const j of s.queue.splice(0)) {
+          j.sessionId = sid;
+          slot.queue.push(j);
+        }
+        this.#settle(other, s);
+      }
+    }
+    const old = slot.reg;
+    if (old && old.peer !== peer) {
+      if (old.pending || h.re) {
+        peer.send({ t: "dup" });
+        peer.close();
+        this.#settle(sid, slot);
+        return;
+      }
+      this.#evict(slot);
+    }
+    slot.reg = { peer, hello: h };
+    if (h.agentPid) slot.agentPid = h.agentPid;
+    peer.send({ t: "ok" });
+    this.#settle(sid, slot);
+  }
+  /**
+   * 🔴 必须确认是被唤醒的那一轮结束了：一轮结束时 hook.cjs 先写 done，tick 可能抢在这一轮的 Stop 等待者登记前
+   *    把排队指令发给上一个等待者，紧接着登记的 Stop 带的是上一轮的回复（2026-09-30 e2e 实测）
+   */
+  #onStop(sid, slot, f, h) {
+    const id = f.job.cmd.instructionId;
+    const t = h.tail;
+    if (!t) {
+      if ((h.stopAt ?? this.#d.now()) - f.firedAt < STOP_MIN_MS) {
+        this.#d.log(`\u6307\u4EE4 ${id} \u5DF2\u5524\u9192\uFF0C\u8FD9\u6B21 Stop \u591A\u534A\u662F\u4E0A\u4E00\u8F6E\u7684\uFF0C\u7EE7\u7EED\u7B49`);
+        return;
+      }
+    } else if (t.id !== id || !t.answered && !t.humanAfter) {
+      this.#d.log(`\u6307\u4EE4 ${id} \u5DF2\u5524\u9192\uFF0C\u8FD9\u6B21 Stop \u662F\u4E0A\u4E00\u8F6E\u7684\uFF0C\u7EE7\u7EED\u7B49`);
+      return;
+    } else if (t.humanAfter) {
+      this.#interrupted(sid, slot, f, "Stop \u663E\u793A\u5524\u9192\u4E4B\u540E\u53C8\u6709\u4EBA\u7C7B\u6D88\u606F");
+      return;
+    }
+    slot.flight = void 0;
+    this.#d.log(`\u6307\u4EE4 ${id} \u7A97\u53E3\u8FD9\u4E00\u8F6E\u5DF2\u7ED3\u675F\uFF0C\u56DE\u590D ${(h.last ?? "").length} \u5B57`);
+    this.#d.done(f.job.cmd, sid, h.last ?? "");
+  }
+  #interrupted(sid, slot, f, why) {
+    slot.flight = void 0;
+    this.#d.log(`\u6307\u4EE4 ${f.job.cmd.instructionId} \u88AB\u5524\u9192\u7684\u90A3\u4E00\u8F6E\u88AB\u6253\u65AD\uFF08${why}\uFF09`);
+    this.#d.report(f.job.cmd, sid, "failed", INTERRUPTED_REASON);
+  }
+  onMessage(peer, m) {
+    const found = this.#find(peer);
+    if (!found) return;
+    const [sid, slot, reg] = found;
+    const p = reg.pending;
+    if (!p || m.id !== p.job.cmd.instructionId) return;
+    clearTimeout(p.timer);
+    reg.pending = void 0;
+    if (m.t === "fired") {
+      const now = this.#d.now();
+      slot.flight = { job: p.job, firedAt: now, paused: 0, lastTick: now };
+      slot.reg = void 0;
+      this.#d.log(`\u6307\u4EE4 ${p.job.cmd.instructionId} \u5DF2\u5524\u9192\u7A97\u53E3 len=${p.job.cmd.text.length}`);
+      this.#d.report(p.job.cmd, sid, "started");
+    } else {
+      slot.reg = void 0;
+      this.#d.log(`\u6307\u4EE4 ${p.job.cmd.instructionId} \u7B49\u5F85\u8005\u8BF4\u7A97\u53E3\u5DF2\u4E0D\u5728\uFF0C\u6539\u8D70\u540E\u53F0`);
+      this.#d.fallback(p.job.cmd);
+    }
+    this.#settle(sid, slot);
+  }
+  onClose(peer) {
+    const found = this.#find(peer);
+    if (!found) return;
+    const [sid, slot, reg] = found;
+    if (reg.pending) {
+      const job = reg.pending.job;
+      clearTimeout(reg.pending.timer);
+      reg.pending = void 0;
+      this.#d.log(`\u6307\u4EE4 ${job.cmd.instructionId} \u4EA4\u7ED9\u7B49\u5F85\u8005\u540E\u6CA1\u6536\u5230\u786E\u8BA4\uFF0C\u6309\u5931\u8D25\u5904\u7406`);
+      this.#d.report(job.cmd, sid, "failed", "window_failed");
+    }
+    slot.reg = void 0;
+    this.#settle(sid, slot);
+  }
+  /** 每秒一次：过期、窗口关闭、打断、等结果超时、忙转闲 */
+  tick() {
+    const now = this.#d.now();
+    for (const [sid, slot] of [...this.#slots]) {
+      if (slot.agentPid && !this.#d.alive(slot.agentPid)) {
+        if (slot.reg) this.#evict(slot, sid);
+        slot.flight = void 0;
+        slot.agentPid = void 0;
+        this.#drain(slot, "\u6392\u961F\u65F6\u7A97\u53E3\u5173\u4E86");
+      }
+      const f = slot.flight;
+      if (f) {
+        const t = slot.transcript ? this.#d.analyze(slot.transcript) : null;
+        if (t && t.id === f.job.cmd.instructionId && t.interrupted) {
+          this.#interrupted(sid, slot, f, "Esc");
+        } else {
+          const st = this.#d.readState(sid);
+          if (st?.state === "ask_approval") f.paused += now - f.lastTick;
+          f.lastTick = now;
+          if (now - f.firedAt - f.paused > this.#d.flightLimitMs) {
+            this.#d.log(`\u6307\u4EE4 ${f.job.cmd.instructionId} \u5524\u9192\u540E\u8FDF\u8FDF\u6CA1\u7B49\u5230\u8FD9\u4E00\u8F6E\u7ED3\u675F\uFF0C\u4E0D\u518D\u7B49\u7ED3\u679C`);
+            slot.flight = void 0;
+          }
+        }
+      }
+      this.#settle(sid, slot);
+    }
+  }
+  logError(msg) {
+    this.#d.log(msg);
+  }
+  /** 关掉全部连接（daemon 退出） */
+  closeAll() {
+    for (const slot of this.#slots.values()) {
+      if (slot.reg?.pending) clearTimeout(slot.reg.pending.timer);
+      slot.reg?.peer.close();
+    }
+    this.#slots.clear();
+  }
+  #slot(sid) {
+    let s = this.#slots.get(sid);
+    if (!s) {
+      s = { queue: [], lastStopAt: 0, marked: false };
+      this.#slots.set(sid, s);
+    }
+    return s;
+  }
+  #find(peer) {
+    for (const [sid, s] of this.#slots) if (s.reg && s.reg.peer === peer) return [sid, s, s.reg];
+    return null;
+  }
+  #evict(slot, sid) {
+    const r = slot.reg;
+    if (!r) return;
+    slot.reg = void 0;
+    if (r.pending) {
+      clearTimeout(r.pending.timer);
+      this.#d.log(`\u6307\u4EE4 ${r.pending.job.cmd.instructionId} \u4EA4\u4ED8\u4E2D\u7B49\u5F85\u8005\u88AB\u8BF7\u8D70\uFF0C\u6309\u5931\u8D25\u5904\u7406`);
+      this.#d.report(r.pending.job.cmd, sid ?? r.pending.job.sessionId, "failed", "window_failed");
+      r.pending = void 0;
+    }
+    r.peer.send({ t: "bye" });
+    r.peer.close();
+  }
+  /** 没碰过窗口的排队指令按原顺序交回后台 */
+  #drain(slot, why) {
+    for (const j of slot.queue.splice(0)) {
+      this.#d.log(`\u6307\u4EE4 ${j.cmd.instructionId} ${why}\uFF0C\u6539\u8D70\u540E\u53F0`);
+      this.#d.fallback(j.cmd);
+    }
+  }
+  #busy(sid, slot) {
+    if (slot.flight || slot.reg?.pending) return true;
+    const st = this.#d.readState(sid);
+    if (!st || !BUSY_STATES.has(st.state) || st.updatedAt <= slot.lastStopAt) return false;
+    if (slot.transcript && this.#d.analyze(slot.transcript)?.interrupted) return false;
+    return this.#d.now() - st.updatedAt <= this.#d.watchStaleMs;
+  }
+  #expired(job, now) {
+    return job.cmd.expireAt > 0 ? isExpired(job.cmd, now) : now - job.queuedAt > this.#d.maxQueueMs;
+  }
+  /** 排队 / 发出 / 过期 */
+  #pump(sid, slot) {
+    const now = this.#d.now();
+    for (const j of [...slot.queue]) {
+      if (!this.#expired(j, now)) continue;
+      slot.queue.splice(slot.queue.indexOf(j), 1);
+      this.#d.log(`\u6307\u4EE4 ${j.cmd.instructionId} \u6392\u961F\u5230\u8FC7\u671F\u4E5F\u6CA1\u7B49\u5230\u7A97\u53E3\u7A7A\u95F2`);
+      this.#d.report(j.cmd, sid, "rejected", "expired");
+    }
+    if (slot.queue.length === 0) return;
+    if (!slot.reg || this.#busy(sid, slot)) {
+      for (const j of slot.queue) {
+        if (j.queuedSent) continue;
+        j.queuedSent = true;
+        this.#d.log(`\u6307\u4EE4 ${j.cmd.instructionId} ${slot.reg ? "\u7A97\u53E3\u6B63\u5FD9" : "\u6682\u65E0\u7B49\u5F85\u8005"}\uFF0C\u6392\u961F`);
+        this.#d.report(j.cmd, sid, "queued");
+      }
+      return;
+    }
+    const job = slot.queue.shift();
+    const reg = slot.reg;
+    reg.pending = {
+      job,
+      timer: setTimeout(() => {
+        if (reg.pending?.job === job) reg.peer.close();
+      }, this.#d.ackTimeoutMs)
+    };
+    reg.pending.timer.unref?.();
+    reg.peer.send({ t: "fire", id: job.cmd.instructionId, text: job.cmd.text });
+  }
+  /** 等待者没了、又没有在跑的唤醒轮：排队的交回后台；然后排队 / 发出；同步标记；清空闲槽 */
+  #settle(sid, slot) {
+    if (!slot.reg && !slot.flight && slot.queue.length > 0) this.#drain(slot, "\u7B49\u5F85\u8005\u6CA1\u4E86");
+    this.#pump(sid, slot);
+    const on = !!slot.reg || !!slot.flight;
+    if (on !== slot.marked) {
+      slot.marked = on;
+      this.#d.mark(sid, slot.agentPid, on);
+    }
+    if (!on && slot.queue.length === 0 && !slot.reg) this.#slots.delete(sid);
+  }
+};
+function parseTail(v) {
+  if (!v || typeof v !== "object") return void 0;
+  const t = v;
+  if (typeof t.id !== "string" || t.id !== "" && !isValidId(t.id)) return void 0;
+  return { id: t.id, answered: t.answered === true, humanAfter: t.humanAfter === true, interrupted: t.interrupted === true };
+}
+function parseHello(m) {
+  if (m.t !== "hello" || typeof m.sessionId !== "string") return null;
+  const num = (v) => typeof v === "number" && Number.isInteger(v) && v > 0 ? v : void 0;
+  return {
+    sessionId: m.sessionId,
+    agentPid: num(m.agentPid),
+    waiterPid: num(m.waiterPid),
+    event: typeof m.event === "string" ? m.event : void 0,
+    last: typeof m.last === "string" ? m.last : void 0,
+    tail: parseTail(m.tail),
+    transcript: typeof m.transcript === "string" && m.transcript.endsWith(".jsonl") ? m.transcript : void 0,
+    stopAt: num(m.stopAt),
+    re: m.re === true
+  };
+}
+var NONCE_RE = /^[0-9a-f]{32}$/;
+var AUTH_TIMEOUT_MS = 5e3;
+function startWakeServer(path, hub, secret, platform = process.platform) {
+  if (platform !== "win32") {
+    if (!ensureChannelDir(path)) return Promise.resolve(null);
+    try {
+      rmSync8(path, { force: true });
+    } catch {
+    }
+  }
+  return new Promise((resolve5) => {
+    const server = createServer3((sock) => {
+      sock.on("error", () => {
+      });
+      let phase = "hello";
+      let nonceW = "";
+      let nonceD = "";
+      let regSid = "";
+      const authTimer = setTimeout(() => {
+        if (phase !== "ready") sock.destroy();
+      }, AUTH_TIMEOUT_MS);
+      authTimer.unref();
+      const raw = (msg) => {
+        if (sock.destroyed || !sock.writable) return;
+        try {
+          sock.write(JSON.stringify(msg) + "\n");
+        } catch {
+        }
+      };
+      const peer = {
+        send(msg) {
+          if (msg.t === "fire") raw({ ...msg, sid: regSid, mac: wakeMac(secret, nonceW, regSid, String(msg.id), String(msg.text)) });
+          else raw(msg);
+        },
+        close() {
+          sock.end();
+          setTimeout(() => sock.destroy(), 200).unref();
+        }
+      };
+      sock.on("close", () => {
+        clearTimeout(authTimer);
+        if (phase === "ready") {
+          try {
+            hub.onClose(peer);
+          } catch (e) {
+            hub.logError(`\u7B49\u5F85\u8005\u65AD\u5F00\u65F6\u5904\u7406\u51FA\u9519\uFF1A${e?.stack ?? String(e)}`);
+          }
+        }
+      });
+      const onLine = (line) => {
+        const m = JSON.parse(line);
+        if (!m || typeof m !== "object") throw new Error("bad frame");
+        if (phase === "hello") {
+          if (m.t !== "hello" || typeof m.nonceW !== "string" || !NONCE_RE.test(m.nonceW)) {
+            sock.destroy();
+            return;
+          }
+          nonceW = m.nonceW;
+          nonceD = randomBytes5(16).toString("hex");
+          phase = "auth2";
+          raw({ t: "auth", nonceD, mac: wakeMac(secret, "d", nonceW, nonceD) });
+          return;
+        }
+        if (phase === "auth2") {
+          const reg = m.reg && typeof m.reg === "object" ? m.reg : null;
+          const hello = reg ? parseHello({ ...reg, t: "hello" }) : null;
+          if (m.t !== "auth2" || !hello || !macEqual(m.mac, wakeMac(secret, "w", nonceD, canonicalJson(reg)))) {
+            sock.destroy();
+            return;
+          }
+          regSid = hello.sessionId;
+          phase = "ready";
+          clearTimeout(authTimer);
+          hub.onHello(peer, hello);
+          return;
+        }
+        if (m.t !== "fired" && m.t !== "refuse" || typeof m.id !== "string" || !macEqual(m.mac, wakeMac(secret, "u", nonceD, m.t, m.id))) {
+          sock.destroy();
+          return;
+        }
+        hub.onMessage(peer, m);
+      };
+      lines(sock, (line) => {
+        try {
+          onLine(line);
+        } catch {
+          sock.destroy();
+        }
+      });
+    });
+    const oldMask = platform === "win32" ? null : process.umask(127);
+    const restore = () => {
+      if (oldMask !== null) process.umask(oldMask);
+    };
+    server.once("error", () => {
+      restore();
+      resolve5(null);
+    });
+    server.listen(path, () => {
+      restore();
+      server.on("error", () => {
+      });
+      resolve5(server);
+    });
+  });
+}
+
 // src/daemon/index.ts
 var IDLE_TIMEOUT_MS = 150 * 1e3;
 var POLICY_VIOLATION = 1008;
@@ -3587,6 +4175,10 @@ var Daemon = class {
   #windowScan = null;
   #aliveReport = null;
   #codexTimer = null;
+  #wake;
+  #wakeServer = null;
+  #wakeTimer = null;
+  #wakeReport = null;
   /** url → 连着它的 CodexWatch。插入顺序 = 发现顺序（DeskBuddy 管的在前） */
   #codex = /* @__PURE__ */ new Map();
   #codexStarted = false;
@@ -3607,8 +4199,26 @@ var Daemon = class {
       codexRoute: deps.codexRoute ?? ((tid) => this.#codexRouteFor(tid)),
       report: deps.report ?? ((p) => api.commandResult(p)),
       windowFor: deps.windowFor ?? windowForSession,
-      sendToWindow: deps.sendToWindow ?? ((id, req2, onReply) => sendToWindow(channelPath(id), req2, onReply))
+      sendToWindow: deps.sendToWindow ?? ((id, req2, onReply) => sendToWindow(channelPath(id), req2, onReply)),
+      wakePath: deps.wakePath === void 0 ? wakeChannelPath() : deps.wakePath,
+      onWindowDone: deps.onWindowDone ?? (() => {
+      })
     };
+    this.#wake = new WakeHub({
+      now: this.#deps.now,
+      readState,
+      alive: (pid) => isAlive(pid),
+      report: (cmd, sid, status, reason) => this.#report(cmd, sid, status, "window", reason ?? ""),
+      fallback: (cmd) => this.#dispatch(cmd),
+      done: (cmd, sid, text) => this.#deps.onWindowDone({ instructionId: cmd.instructionId, sessionId: sid, tool: cmd.tool, text }),
+      mark: (sid, pid, on) => {
+        if (on) writeWakeMark(sid, pid, this.#deps.now());
+        else removeWakeMark(sid);
+        log(`\u4F1A\u8BDD ${sid} ${on ? "\u53EF\u4EE5" : "\u4E0D\u518D\u80FD"}\u88AB\u8BBE\u5907\u6307\u4EE4\u5524\u9192`);
+        this.#scheduleWakeReport();
+      },
+      log
+    });
     this.#store.prune(this.#deps.now());
     this.#coord = new ApprovalCoordinator({
       store: this.#store,
@@ -3632,8 +4242,55 @@ var Daemon = class {
     this.#codexTick();
     this.#codexTimer = setInterval(() => this.#codexTick(), CODEX_WATCH_MS);
     this.#codexTimer.unref();
+    await this.startWake();
     return port;
   }
+  /**
+   * 起窗口唤醒通道（Claude Code asyncRewake 等待者连这里，见 hook/wake.cjs 与 ./wake.ts）。
+   * 先清上次残留的标记：还活着的等待者几秒内会重连重新登记
+   */
+  async startWake() {
+    const path = this.#deps.wakePath;
+    if (!path) return;
+    clearWakeMarks();
+    const secret = randomBytes6(32);
+    let warn = "";
+    try {
+      warn = writeWakeSecret(secret.toString("hex"));
+    } catch (e) {
+      log(`\u7A97\u53E3\u5524\u9192\u5BC6\u94A5\u5199\u4E0D\u8FDB\u53BB\uFF0C\u4E0D\u8D77\u5524\u9192\u901A\u9053\uFF1A${e.message}`);
+      return;
+    }
+    if (warn) log(`\u26A0\uFE0F \u5B89\u5168\u544A\u8B66\uFF1A${warn}`);
+    this.#wakeServer = await startWakeServer(path, this.#wake, secret);
+    if (this.#wakeServer) log("\u7A97\u53E3\u5524\u9192\u901A\u9053\u5DF2\u5C31\u7EEA");
+    else if (process.platform === "win32")
+      log("\u26A0\uFE0F \u5B89\u5168\u544A\u8B66\uFF1A\u7A97\u53E3\u5524\u9192\u7BA1\u9053\u76D1\u542C\u5931\u8D25\uFF0C\u53EF\u80FD\u5DF2\u88AB\u5176\u4ED6\u8FDB\u7A0B\u62A2\u6CE8\uFF1B\u5DF2\u505C\u7528\u7A97\u53E3\u5524\u9192\uFF08\u7B49\u5F85\u8005\u8BA4\u8BC1\u4E0D\u8FC7\u4E0D\u4F1A\u6267\u884C\u4EFB\u4F55\u4E1C\u897F\uFF09");
+    else log("\u7A97\u53E3\u5524\u9192\u901A\u9053\u6CA1\u8D77\u6765\uFF08\u4E0D\u5F71\u54CD\u5176\u5B83\u529F\u80FD\uFF09");
+    this.#wakeTimer = setInterval(() => this.#wake.tick(), 1e3);
+    this.#wakeTimer.unref();
+  }
+  /** 唤醒能力变了：300ms 内合并，报一次 Claude Code 的快照（remoteWindow 跟着变） */
+  #scheduleWakeReport() {
+    if (this.#wakeReport) return;
+    this.#wakeReport = setTimeout(() => {
+      this.#wakeReport = null;
+      void this.#reportTool("claude_code");
+    }, 300);
+    this.#wakeReport.unref();
+  }
+  async #reportTool(tool) {
+    const cfg = loadConfig();
+    if (!cfg.clientId || !cfg.boundAt || !cfg.enabledTools.includes(tool)) return;
+    try {
+      await postReport(buildSnapshot(withWake(readAliveStates(tool)), tool, cfg, this.#deps.now()));
+    } catch (e) {
+      log(`\u4E0A\u62A5 ${tool} \u4F1A\u8BDD\u5931\u8D25\uFF1A${e.message}`);
+    }
+  }
+  get wake() {
+    return this.#wake;
+  }
   /** 找 app-server：新出现的连上，不在了且已断开的丢掉；连着的各自 tick */
   #codexTick() {
     let urls = [];
@@ -3728,7 +4385,9 @@ var Daemon = class {
     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(), tool === "codex" ? this.#codexLoaded() : null));
+      await postReport(
+        buildSnapshot(withWake(readAliveStates(tool)), tool, cfg, this.#deps.now(), tool === "codex" ? this.#codexLoaded() : null)
+      );
     }
     if (++this.#dirsTick % 10 === 0) await this.#reportDirs();
   }
@@ -3741,6 +4400,10 @@ var Daemon = class {
     if (this.#windowScan) clearInterval(this.#windowScan);
     if (this.#aliveReport) clearInterval(this.#aliveReport);
     if (this.#codexTimer) clearInterval(this.#codexTimer);
+    if (this.#wakeTimer) clearInterval(this.#wakeTimer);
+    if (this.#wakeReport) clearTimeout(this.#wakeReport);
+    this.#wake.closeAll();
+    this.#wakeServer?.close();
     if (this.#codexReportTimer) clearTimeout(this.#codexReportTimer);
     for (const w of this.#codex.values()) w.stop();
     this.#codex.clear();
@@ -3794,7 +4457,11 @@ var Daemon = class {
     });
     ws.on("message", (raw) => {
       this.#armIdle();
-      this.#onMessage(String(raw));
+      try {
+        this.#onMessage(String(raw));
+      } catch (e) {
+        log(`\u5904\u7406\u4E0B\u884C\u5E27\u51FA\u9519\uFF1A${e.stack ?? e.message}`);
+      }
     });
     ws.on("error", (e) => log(`\u8FDE\u63A5\u51FA\u9519: ${e.message}`));
     ws.on("close", (code, reason) => {
@@ -3878,6 +4545,17 @@ var Daemon = class {
         }
       }
     }
+    this.#afterPty(cmd);
+  }
+  /**
+   * pty 窗口接管之外的两条路：窗口里有登记中的唤醒等待者 → 交给它（忙时排队）；否则原来的后台路径。
+   * 🔴 一条指令只走一条路：交给等待者之后的任何结局都由 WakeHub 负责，不再回到这里
+   */
+  #afterPty(cmd) {
+    if (cmd.tool === "claude_code" && cmd.sessionId && !isExpired(cmd, this.#deps.now())) {
+      const sid = resolveAlias(cmd.sessionId);
+      if (this.#wake.submit(cmd, sid)) return;
+    }
     this.#dispatch(cmd);
   }
   /**
@@ -3954,7 +4632,7 @@ var Daemon = class {
     const fallback = () => {
       if (fellBack) return;
       fellBack = true;
-      this.#dispatch(cmd);
+      this.#afterPty(cmd);
     };
     const req2 = { instructionId: cmd.instructionId, sessionId, text: cmd.text, expireAt: cmd.expireAt };
     let r;
@@ -3998,7 +4676,14 @@ var Daemon = class {
       return;
     }
     if (target.sessionId) this.#coord.cancelSession(target.sessionId);
-    this.#queue.enqueue(target.sessionId, () => this.#execute(cmd, target.sessionId, target.cwd, target.handleKey));
+    this.#queue.enqueue(
+      target.sessionId,
+      () => this.#execute(cmd, target.sessionId, target.cwd, target.handleKey),
+      (e) => {
+        log(`\u6307\u4EE4 ${cmd.instructionId} \u6267\u884C\u65F6\u51FA\u9519\uFF1A${e?.stack ?? String(e)}`);
+        this.#report(cmd, target.sessionId, "failed", "", "exec_failed");
+      }
+    );
   }
   async #execute(cmd, sessionId, cwd, handleKey = cmd.tool) {
     if (sessionId) {
@@ -4050,7 +4735,13 @@ var Daemon = class {
       return;
     }
     const origin = this.#runsDone.get(r.runId) ?? Promise.resolve();
-    void origin.then(() => this.#queue.enqueue(r.sessionId, () => this.#resume(r, kind)));
+    void origin.then(
+      () => this.#queue.enqueue(
+        r.sessionId,
+        () => this.#resume(r, kind),
+        (e) => log(`\u7EED\u8DD1\u4F1A\u8BDD ${r.sessionId} \u51FA\u9519\uFF1A${e?.stack ?? String(e)}`)
+      )
+    );
   }
   async #resume(r, kind) {
     if (kind === "deferred" && r.consumed) {
@@ -4119,7 +4810,7 @@ var Daemon = class {
   }
 };
 function newRunId() {
-  return randomBytes5(12).toString("hex");
+  return randomBytes6(12).toString("hex");
 }
 async function runDaemon(deps = {}) {
   const d = new Daemon(deps);
@@ -4137,7 +4828,7 @@ async function runDaemonCommand(opts = {}) {
   }
   if (opts.foreground) process.env.DESKBUDDY_DAEMON_FOREGROUND = "1";
   try {
-    writeFileSync13(pidFilePath(), String(process.pid), "utf8");
+    writeFileSync14(pidFilePath(), String(process.pid), "utf8");
   } catch {
   }
   let daemon;
@@ -4153,7 +4844,7 @@ async function runDaemonCommand(opts = {}) {
     log(`\u6536\u5230 ${sig}\uFF0C\u9000\u51FA`);
     daemon.stop();
     try {
-      rmSync7(pidFilePath(), { force: true });
+      rmSync9(pidFilePath(), { force: true });
     } catch {
     }
     process.exit(0);
@@ -4170,8 +4861,8 @@ async function runDaemonCommand(opts = {}) {
 }
 
 // src/core/registry.ts
-import { mkdirSync as mkdirSync14, readFileSync as readFileSync13, writeFileSync as writeFileSync14 } from "fs";
-import { join as join17 } from "path";
+import { mkdirSync as mkdirSync15, readFileSync as readFileSync14, writeFileSync as writeFileSync15 } from "fs";
+import { join as join18 } from "path";
 var FALLBACK = {
   version: "builtin",
   tools: {
@@ -4249,11 +4940,11 @@ var FALLBACK = {
   }
 };
 function registryCachePath() {
-  return join17(deskbuddyHome(), "tool-registry.json");
+  return join18(deskbuddyHome(), "tool-registry.json");
 }
 function loadRegistry() {
   try {
-    return JSON.parse(readFileSync13(registryCachePath(), "utf8"));
+    return JSON.parse(readFileSync14(registryCachePath(), "utf8"));
   } catch {
     return FALLBACK;
   }
@@ -4261,15 +4952,15 @@ function loadRegistry() {
 async function refreshRegistry() {
   try {
     const registry = await api.toolRegistry();
-    mkdirSync14(deskbuddyHome(), { recursive: true });
-    writeFileSync14(registryCachePath(), JSON.stringify(registry, null, 2), "utf8");
+    mkdirSync15(deskbuddyHome(), { recursive: true });
+    writeFileSync15(registryCachePath(), JSON.stringify(registry, null, 2), "utf8");
   } catch {
   }
 }
 
 // src/adapters/ccHook.ts
-import { chmodSync as chmodSync4, existsSync as existsSync11, mkdirSync as mkdirSync15, readFileSync as readFileSync14, renameSync as renameSync11, statSync as statSync4, writeFileSync as writeFileSync15 } from "fs";
-import { dirname as dirname6, join as join18 } from "path";
+import { chmodSync as chmodSync5, existsSync as existsSync11, mkdirSync as mkdirSync16, readFileSync as readFileSync15, renameSync as renameSync12, rmSync as rmSync10, statSync as statSync5, writeFileSync as writeFileSync16 } from "fs";
+import { dirname as dirname6, join as join19 } from "path";
 var CC_EVENTS = [
   "UserPromptSubmit",
   "PreToolUse",
@@ -4280,7 +4971,7 @@ var CC_EVENTS = [
 ];
 function readSettings(path) {
   if (!existsSync11(path)) return {};
-  const raw = readFileSync14(path, "utf8");
+  const raw = readFileSync15(path, "utf8");
   if (raw.trim() === "") return {};
   try {
     return JSON.parse(raw);
@@ -4289,17 +4980,17 @@ function readSettings(path) {
   }
 }
 function writeSettings(path, settings) {
-  mkdirSync15(dirname6(path), { recursive: true });
+  mkdirSync16(dirname6(path), { recursive: true });
   let mode;
   try {
-    mode = statSync4(path).mode & 511;
+    mode = statSync5(path).mode & 511;
   } catch {
     mode = void 0;
   }
   const tmp = path + ".deskbuddy.tmp";
-  writeFileSync15(tmp, JSON.stringify(settings, null, 2), "utf8");
-  if (mode !== void 0) chmodSync4(tmp, mode);
-  renameSync11(tmp, path);
+  writeFileSync16(tmp, JSON.stringify(settings, null, 2), "utf8");
+  if (mode !== void 0) chmodSync5(tmp, mode);
+  renameSync12(tmp, path);
 }
 function mentions(command, script) {
   return !!command && (command.includes(script) || command.includes(fwdSlash(script)));
@@ -4333,25 +5024,98 @@ function installCcWindowGate(settingsPath, gatePath, tool = "claude_code", platf
   });
   writeSettings(settingsPath, settings);
 }
+var REWAKE_TIMEOUT_S = 20 * 24 * 60 * 60;
+var REWAKE_MESSAGE = "\u4EE5\u4E0B\u662F\u4E00\u6761 DeskBuddy \u8BBE\u5907\u6307\u4EE4\uFF08\u6309\u4F1A\u8BDD\u5F00\u5934 DeskBuddy \u8BF4\u660E\u91CC\u7684\u53E3\u4EE4\u6838\u5BF9\uFF0C\u53E3\u4EE4\u4E00\u81F4\u624D\u7167\u5E38\u6267\u884C\uFF0C\u5B8C\u6210\u540E\u7B80\u8981\u56DE\u590D\u7ED3\u679C\uFF09\uFF1A";
+var REWAKE_SUMMARY = "DeskBuddy \u8BBE\u5907\u6307\u4EE4";
+var REWAKE_EVENTS = ["SessionStart", "Stop"];
+var REWAKE_CONTEXT_TIMEOUT_S = 10;
+function rewakeCommand(wakePath, platform = process.platform) {
+  if (platform === "win32") return `node ${winCmdPath(wakePath)}; exit $LASTEXITCODE`;
+  return `node ${shQuote2(wakePath)}`;
+}
+function rewakeContextCommand(wakePath, platform = process.platform) {
+  return `node ${platform === "win32" ? winCmdPath(wakePath) : shQuote2(wakePath)} --context`;
+}
+function rewakeKind(h) {
+  return /\s--context(\s|$)/.test(h.command) ? "context" : "wait";
+}
+function installCcRewake(settingsPath, wakePath, platform = process.platform) {
+  const settings = readSettings(settingsPath);
+  settings.hooks ??= {};
+  const entries = {
+    wait: {
+      type: "command",
+      command: rewakeCommand(wakePath, platform),
+      asyncRewake: true,
+      timeout: REWAKE_TIMEOUT_S,
+      rewakeMessage: REWAKE_MESSAGE,
+      rewakeSummary: REWAKE_SUMMARY
+    },
+    context: { type: "command", command: rewakeContextCommand(wakePath, platform), timeout: REWAKE_CONTEXT_TIMEOUT_S }
+  };
+  if (platform === "win32") {
+    entries.wait.shell = "powershell";
+    entries.context.shell = "powershell";
+  }
+  const wanted = { SessionStart: ["context", "wait"], Stop: ["wait"] };
+  let changed = false;
+  for (const event of REWAKE_EVENTS) {
+    const groups = settings.hooks[event] ??= [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const g of groups) {
+      const hooks = g.hooks ?? [];
+      for (let i = hooks.length - 1; i >= 0; i--) {
+        if (!mentions(hooks[i].command, wakePath)) continue;
+        const kind = rewakeKind(hooks[i]);
+        if (!wanted[event].includes(kind) || seen.has(kind)) {
+          hooks.splice(i, 1);
+          changed = true;
+          continue;
+        }
+        seen.add(kind);
+        if (JSON.stringify(hooks[i]) !== JSON.stringify(entries[kind])) {
+          hooks[i] = { ...entries[kind] };
+          changed = true;
+        }
+      }
+    }
+    const before = groups.length;
+    settings.hooks[event] = groups.filter((g) => (g.hooks ?? []).length > 0);
+    if (settings.hooks[event].length !== before) changed = true;
+    for (const kind of wanted[event]) {
+      if (seen.has(kind)) continue;
+      settings.hooks[event].push({ hooks: [{ ...entries[kind] }] });
+      changed = true;
+    }
+  }
+  if (changed) writeSettings(settingsPath, settings);
+}
 function uninstallCcHook(settingsPath, hookPath) {
   const settings = readSettings(settingsPath);
   if (!settings.hooks) return;
-  const gatePath = join18(dirname6(hookPath), "gate.cjs");
+  const gatePath = join19(dirname6(hookPath), "gate.cjs");
+  const wakePath = join19(dirname6(hookPath), "wake.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) => !mentions(h.command, hookPath) && !mentions(h.command, gatePath));
+      const hooks = (g.hooks ?? []).filter(
+        (h) => !mentions(h.command, hookPath) && !mentions(h.command, gatePath) && !mentions(h.command, wakePath)
+      );
       if (hooks.length > 0) kept.push({ ...g, hooks });
     }
     settings.hooks[event] = kept;
   }
   writeSettings(settingsPath, settings);
+  try {
+    rmSync10(join19(dirname6(hookPath), "wake", "tokens"), { recursive: true, force: true });
+  } catch {
+  }
 }
 
 // src/adapters/codexHook.ts
-import { chmodSync as chmodSync5, existsSync as existsSync12, mkdirSync as mkdirSync16, readFileSync as readFileSync15, renameSync as renameSync12, statSync as statSync5, writeFileSync as writeFileSync16 } from "fs";
-import { dirname as dirname7, join as join19 } from "path";
+import { chmodSync as chmodSync6, existsSync as existsSync12, mkdirSync as mkdirSync17, readFileSync as readFileSync16, renameSync as renameSync13, statSync as statSync6, writeFileSync as writeFileSync17 } from "fs";
+import { dirname as dirname7, join as join20 } from "path";
 var CODEX_MARKER_BEGIN = "# >>> deskbuddy >>>";
 var CODEX_MARKER_END = "# <<< deskbuddy <<<";
 var CODEX_EVENTS = [
@@ -4364,7 +5128,7 @@ var CODEX_EVENTS = [
 ];
 var CODEX_TRUST_NOTICE = "\u26A0\uFE0F  \u4E0B\u6B21\u542F\u52A8 Codex \u65F6\u4F1A\u8981\u6C42\u4F60\u786E\u8BA4\u4FE1\u4EFB\u8FD9\u4E2A hook\uFF0C\u8BF7\u9009\u62E9\u540C\u610F\u2014\u2014\u4E0D\u786E\u8BA4\u7684\u8BDD Codex \u4E0D\u4F1A\u6267\u884C\u5B83\u3002\n   Codex \u7ECF `--remote` \u8FDE\u5E38\u9A7B app-server \u4F7F\u7528\u65F6\uFF0C\u7A97\u53E3\u91CC\u7684\u6388\u6743\u6846\u4E5F\u80FD\u5728\u8BBE\u5907\u4E0A\u786E\u8BA4\uFF08\u5B88\u62A4\u8FDB\u7A0B\u5728\u8DD1\u65F6\u751F\u6548\uFF09";
 function codexConfigPath() {
-  return join19(codexHome(), "config.toml");
+  return join20(codexHome(), "config.toml");
 }
 function renderBlock(hookPath, events, tool, platform) {
   const command = JSON.stringify(`node ${platform === "win32" ? winPsPath(hookPath) : hookPath} ${tool}`);
@@ -4383,17 +5147,17 @@ function renderBlock(hookPath, events, tool, platform) {
   return lines2.join("\n");
 }
 function writeAtomic(path, content) {
-  mkdirSync16(dirname7(path), { recursive: true });
+  mkdirSync17(dirname7(path), { recursive: true });
   let mode;
   try {
-    mode = statSync5(path).mode & 511;
+    mode = statSync6(path).mode & 511;
   } catch {
     mode = void 0;
   }
   const tmp = path + ".deskbuddy.tmp";
-  writeFileSync16(tmp, content, "utf8");
-  if (mode !== void 0) chmodSync5(tmp, mode);
-  renameSync12(tmp, path);
+  writeFileSync17(tmp, content, "utf8");
+  if (mode !== void 0) chmodSync6(tmp, mode);
+  renameSync13(tmp, path);
 }
 function assertSafeToAppend(raw, path) {
   for (const quote of ['"""', "'''"]) {
@@ -4403,7 +5167,7 @@ function assertSafeToAppend(raw, path) {
   }
 }
 function installCodexHook(configPath2, hookPath, events = CODEX_EVENTS, tool = "codex", platform = process.platform) {
-  const raw = existsSync12(configPath2) ? readFileSync15(configPath2, "utf8") : "";
+  const raw = existsSync12(configPath2) ? readFileSync16(configPath2, "utf8") : "";
   if (raw.includes(CODEX_MARKER_BEGIN)) return;
   assertSafeToAppend(raw, configPath2);
   const block = renderBlock(hookPath, events, tool, platform);
@@ -4412,7 +5176,7 @@ function installCodexHook(configPath2, hookPath, events = CODEX_EVENTS, tool = "
 }
 function uninstallCodexHook(configPath2) {
   if (!existsSync12(configPath2)) return;
-  const raw = readFileSync15(configPath2, "utf8");
+  const raw = readFileSync16(configPath2, "utf8");
   const lines2 = raw.split("\n");
   const begin = lines2.findIndex((l) => l.trim() === CODEX_MARKER_BEGIN);
   if (begin === -1) return;
@@ -4426,11 +5190,11 @@ function uninstallCodexHook(configPath2) {
 }
 
 // src/commands/tools.ts
-import { existsSync as existsSync13, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync17 } from "fs";
 function fileContains(path, needle) {
   try {
     if (!existsSync13(path)) return false;
-    return readFileSync16(path, "utf8").includes(needle);
+    return readFileSync17(path, "utf8").includes(needle);
   } catch {
     return false;
   }
@@ -4454,6 +5218,12 @@ var ADAPTERS = {
       if (tool !== "claude_code" && tool !== "qoder") return false;
       installCcWindowGate(p, gate, tool);
       return true;
+    },
+    // asyncRewake 只有 Claude Code 认（2.1.280 实测）；别家当成同步 hook 会一直等
+    installRewake: (p, wake, tool) => {
+      if (tool !== "claude_code") return false;
+      installCcRewake(p, wake);
+      return true;
     }
   },
   "codex-toml": {
@@ -4498,13 +5268,13 @@ function subscribedEvents(registry, tool, fallback) {
 }
 
 // src/commands/enable.ts
-import { dirname as dirname9, join as join22 } from "path";
+import { dirname as dirname9, join as join23 } from "path";
 
 // src/wrap/shim.ts
-import { execFileSync as execFileSync7 } from "child_process";
-import { chmodSync as chmodSync6, existsSync as existsSync14, mkdirSync as mkdirSync17, readdirSync as readdirSync3, readFileSync as readFileSync17, rmdirSync, rmSync as rmSync8, writeFileSync as writeFileSync17 } from "fs";
+import { execFileSync as execFileSync8 } from "child_process";
+import { chmodSync as chmodSync7, existsSync as existsSync14, mkdirSync as mkdirSync18, readdirSync as readdirSync4, readFileSync as readFileSync18, rmdirSync, rmSync as rmSync11, writeFileSync as writeFileSync18 } from "fs";
 import { homedir as homedir5 } from "os";
-import { delimiter as delimiter2, join as join20, resolve as resolve2 } from "path";
+import { delimiter as delimiter2, join as join21, resolve as resolve2 } from "path";
 var SHIM_FALLBACK_EXIT = 213;
 var WIN_SHIM_ENABLED = false;
 var SHIM_COMMANDS = { claude_code: "claude", codex: "codex" };
@@ -4514,10 +5284,10 @@ var RC_END = "# <<< deskbuddy <<<";
 var RC_FILES = [".zshrc", ".bashrc"];
 var WIN_PENDING = "Windows \u7A97\u53E3\u63A5\u7BA1\u5F85\u9A8C\u8BC1\uFF0C\u6682\u672A\u5F00\u542F";
 function shimDir() {
-  return join20(deskbuddyHome(), "bin");
+  return join21(deskbuddyHome(), "bin");
 }
 function shimFile(binDir, command, platform = process.platform) {
-  return join20(binDir, platform === "win32" ? `${command}.cmd` : command);
+  return join21(binDir, platform === "win32" ? `${command}.cmd` : command);
 }
 function shQuote3(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
@@ -4646,10 +5416,10 @@ function removeRcBlock(content) {
   return content.slice(0, start) + content.slice(end);
 }
 function readRc(p) {
-  return readFileSync17(p).toString("latin1");
+  return readFileSync18(p).toString("latin1");
 }
 function writeRc(p, latin1) {
-  writeFileSync17(p, Buffer.from(latin1, "latin1"));
+  writeFileSync18(p, Buffer.from(latin1, "latin1"));
 }
 function toLatin1(utf8) {
   return Buffer.from(utf8, "utf8").toString("latin1");
@@ -4671,7 +5441,7 @@ function removePathEntry(value, dir) {
 var PS_READ = "$k=[Microsoft.Win32.Registry]::CurrentUser.OpenSubKey('Environment');$v='';if($k){$v=$k.GetValue('Path','',[Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames)};[Console]::Out.Write([Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes([string]$v)))";
 var PS_WRITE = "$k=[Microsoft.Win32.Registry]::CurrentUser.CreateSubKey('Environment');$kind=[Microsoft.Win32.RegistryValueKind]::ExpandString;try{$kind=$k.GetValueKind('Path')}catch{};if([string]::IsNullOrEmpty($env:DESKBUDDY_NEW_PATH)){$k.DeleteValue('Path',$false)}else{$k.SetValue('Path',$env:DESKBUDDY_NEW_PATH,$kind)};[Environment]::SetEnvironmentVariable('DESKBUDDY_PATH_REFRESH','1','User');[Environment]::SetEnvironmentVariable('DESKBUDDY_PATH_REFRESH',$null,'User')";
 function psWinPath() {
-  const ps = (script, env) => execFileSync7("powershell.exe", ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script], {
+  const ps = (script, env) => execFileSync8("powershell.exe", ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "ignore"],
     windowsHide: true,
@@ -4718,12 +5488,12 @@ function installShim(tool, e) {
     if (!node || !cli || !bin) {
       return { ok: false, message: "\u7A97\u53E3\u63A5\u7BA1\u6CA1\u88C5\uFF1A\u5B89\u88C5\u8DEF\u5F84\u91CC\u6709\u975E ASCII \u5B57\u7B26\uFF0CWindows \u7684 .cmd \u8BFB\u4E0D\u4E86\uFF08\u4E0D\u5F71\u54CD\u5176\u5B83\u529F\u80FD\uFF09" };
     }
-    mkdirSync17(e.binDir, { recursive: true });
-    writeFileSync17(file, cmdScript(tool, command, node, cli, bin), "utf8");
+    mkdirSync18(e.binDir, { recursive: true });
+    writeFileSync18(file, cmdScript(tool, command, node, cli, bin), "utf8");
   } else {
-    mkdirSync17(e.binDir, { recursive: true, mode: 448 });
-    writeFileSync17(file, shScript(tool, command, e.nodePath, e.cliPath, e.binDir), { encoding: "utf8", mode: 493 });
-    chmodSync6(file, 493);
+    mkdirSync18(e.binDir, { recursive: true, mode: 448 });
+    writeFileSync18(file, shScript(tool, command, e.nodePath, e.cliPath, e.binDir), { encoding: "utf8", mode: 493 });
+    chmodSync7(file, 493);
   }
   const touched = [];
   if (e.platform === "win32") {
@@ -4737,7 +5507,7 @@ function installShim(tool, e) {
   } else if (e.rcHome) {
     const block = toLatin1(rcBlock(e.binDir, e.rcHome));
     for (const name of RC_FILES) {
-      const rc = join20(e.rcHome, name);
+      const rc = join21(e.rcHome, name);
       if (!existsSync14(rc)) continue;
       const next = addRcBlock(readRc(rc), block);
       if (next !== null) writeRc(rc, next);
@@ -4758,13 +5528,13 @@ function installShim(tool, e) {
 function ourShims(binDir) {
   let names;
   try {
-    names = readdirSync3(binDir);
+    names = readdirSync4(binDir);
   } catch {
     return [];
   }
   return names.filter((n) => {
     try {
-      return readFileSync17(join20(binDir, n), "utf8").includes(SHIM_MARKER);
+      return readFileSync18(join21(binDir, n), "utf8").includes(SHIM_MARKER);
     } catch {
       return false;
     }
@@ -4776,8 +5546,8 @@ function uninstallShim(tool, e) {
   let removed = false;
   const file = shimFile(e.binDir, command, e.platform);
   try {
-    if (existsSync14(file) && readFileSync17(file, "utf8").includes(SHIM_MARKER)) {
-      rmSync8(file, { force: true });
+    if (existsSync14(file) && readFileSync18(file, "utf8").includes(SHIM_MARKER)) {
+      rmSync11(file, { force: true });
       removed = true;
     }
   } catch {
@@ -4795,7 +5565,7 @@ function uninstallShim(tool, e) {
     }
   } else if (e.rcHome) {
     for (const name of RC_FILES) {
-      const rc = join20(e.rcHome, name);
+      const rc = join21(e.rcHome, name);
       if (!existsSync14(rc)) continue;
       const next = removeRcBlock(readRc(rc));
       if (next !== null) {
@@ -4805,7 +5575,7 @@ function uninstallShim(tool, e) {
     }
   }
   try {
-    if (existsSync14(e.binDir) && readdirSync3(e.binDir).length === 0) rmdirSync(e.binDir);
+    if (existsSync14(e.binDir) && readdirSync4(e.binDir).length === 0) rmdirSync(e.binDir);
   } catch {
   }
   if (!removed && touched.length === 0) return { ok: true, message: "" };
@@ -4817,7 +5587,7 @@ function shimState(tool, binDir, pathEnv, platform = process.platform) {
   const file = shimFile(binDir, command, platform);
   let installed = false;
   try {
-    installed = readFileSync17(file, "utf8").includes(SHIM_MARKER);
+    installed = readFileSync18(file, "utf8").includes(SHIM_MARKER);
   } catch {
     installed = false;
   }
@@ -4828,16 +5598,16 @@ function shimState(tool, binDir, pathEnv, platform = process.platform) {
 }
 
 // src/wrap/pty.ts
-import { chmodSync as chmodSync7, existsSync as existsSync15, statSync as statSync6 } from "fs";
+import { chmodSync as chmodSync8, existsSync as existsSync15, statSync as statSync7 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import { dirname as dirname8, join as join21 } from "path";
+import { dirname as dirname8, join as join22 } from "path";
 var req = createRequire2(import.meta.url);
 function fixSpawnHelper() {
   if (process.platform !== "darwin") return;
   try {
-    const dir = join21(dirname8(req.resolve("node-pty/package.json")), "prebuilds", `darwin-${process.arch}`);
-    const helper = join21(dir, "spawn-helper");
-    if (existsSync15(helper) && (statSync6(helper).mode & 73) === 0) chmodSync7(helper, 493);
+    const dir = join22(dirname8(req.resolve("node-pty/package.json")), "prebuilds", `darwin-${process.arch}`);
+    const helper = join22(dir, "spawn-helper");
+    if (existsSync15(helper) && (statSync7(helper).mode & 73) === 0) chmodSync8(helper, 493);
   } catch {
   }
 }
@@ -4932,12 +5702,19 @@ function installTools(tools, out, shim = defaultShimEnvForInstall()) {
     installed.push(tool);
     out(`\u2705 ${tool}\uFF1Ahook \u5DF2\u88C5\u8FDB ${configPath2}\uFF08${events.length} \u4E2A\u4E8B\u4EF6\uFF09`);
     try {
-      if (adapter.installWindowGate?.(configPath2, join22(dirname9(hookPath), "gate.cjs"), tool)) {
+      if (adapter.installWindowGate?.(configPath2, join23(dirname9(hookPath), "gate.cjs"), tool)) {
         out(`   \u7A97\u53E3\u91CC\u5F39\u6388\u6743\u6846\u65F6\uFF0C\u8BBE\u5907\u4E0A\u4E5F\u80FD\u786E\u8BA4\uFF08\u5B88\u62A4\u8FDB\u7A0B\u5728\u8DD1\u65F6\u751F\u6548\uFF09`);
       }
     } catch (e) {
       out(`\u26A0\uFE0F  ${tool}\uFF1A\u8BBE\u5907\u786E\u8BA4\u6388\u6743\u6CA1\u88C5\u4E0A\uFF1A${e.message}`);
     }
+    try {
+      if (adapter.installRewake?.(configPath2, join23(dirname9(hookPath), "wake.cjs"), tool)) {
+        out(`   \u7A97\u53E3\u5F00\u7740\u65F6\uFF0C\u8BBE\u5907\u6307\u4EE4\u76F4\u63A5\u5728\u8FD9\u4E2A\u7A97\u53E3\u91CC\u6267\u884C\uFF08\u5B88\u62A4\u8FDB\u7A0B\u5728\u8DD1\u65F6\u751F\u6548\uFF09`);
+      }
+    } catch (e) {
+      out(`\u26A0\uFE0F  ${tool}\uFF1A\u7A97\u53E3\u5524\u9192\u6CA1\u88C5\u4E0A\uFF1A${e.message}\uFF08\u8BBE\u5907\u6307\u4EE4\u4ECD\u8D70\u540E\u53F0\uFF09`);
+    }
     if (adapter.notice) out(adapter.notice);
   }
   cfg.enabledTools = [...enabled];
@@ -5032,8 +5809,8 @@ async function runDisable(tools, opts = {}) {
 }
 
 // src/commands/install.ts
-import { mkdirSync as mkdirSync18, rmSync as rmSync9, writeFileSync as writeFileSync18 } from "fs";
-import { join as join23 } from "path";
+import { mkdirSync as mkdirSync19, rmSync as rmSync12, writeFileSync as writeFileSync19 } from "fs";
+import { join as join24 } from "path";
 
 // src/core/detect.ts
 import { existsSync as existsSync16 } from "fs";
@@ -5078,7 +5855,7 @@ function detectTools(d = defaultDetectDeps()) {
 import qrcode from "qrcode-terminal";
 
 // src/commands/remoteCwd.ts
-import { existsSync as existsSync17, statSync as statSync7 } from "fs";
+import { existsSync as existsSync17, statSync as statSync8 } from "fs";
 import { createInterface } from "readline";
 import { homedir as homedir6 } from "os";
 import { isAbsolute as isAbsolute2, resolve as resolve3 } from "path";
@@ -5092,7 +5869,7 @@ function normalizePath(raw, home = homedir6()) {
 function checkPath(abs) {
   if (!existsSync17(abs)) return "missing";
   try {
-    return statSync7(abs).isDirectory() ? "ok" : "not_a_dir";
+    return statSync8(abs).isDirectory() ? "ok" : "not_a_dir";
   } catch {
     return "missing";
   }
@@ -5294,11 +6071,11 @@ function inSandbox(env) {
 }
 function precheckWritable(dirs) {
   for (const dir of dirs) {
-    const probe = join23(dir, `.deskbuddy-probe-${process.pid}`);
+    const probe = join24(dir, `.deskbuddy-probe-${process.pid}`);
     try {
-      mkdirSync18(dir, { recursive: true });
-      writeFileSync18(probe, "");
-      rmSync9(probe, { force: true });
+      mkdirSync19(dir, { recursive: true });
+      writeFileSync19(probe, "");
+      rmSync12(probe, { force: true });
     } catch (e) {
       return { ok: false, dir, error: e.message };
     }
@@ -5427,7 +6204,7 @@ async function runInstall(opts, deps = defaultInstallDeps()) {
 
 // src/commands/logout.ts
 import { createInterface as createInterface2 } from "readline";
-import { existsSync as existsSync18, rmSync as rmSync10 } from "fs";
+import { existsSync as existsSync18, rmSync as rmSync13 } from "fs";
 function stdout4(line) {
   process.stdout.write(line + "\n");
 }
@@ -5459,7 +6236,7 @@ async function runLogout(opts = {}) {
   }
   await runDisable([], { out, brief: true, keepAutostart: opts.keepAutostart });
   if (existsSync18(home)) {
-    rmSync10(home, { recursive: true, force: true });
+    rmSync13(home, { recursive: true, force: true });
   }
   out("");
   out("\u2705 \u5DF2\u6E05\u9664\u672C\u673A\u7684 DeskBuddy \u6570\u636E\u3002");
@@ -5619,9 +6396,9 @@ async function runUpdate(opts = {}) {
 }
 
 // src/wrap/run.ts
-import { randomBytes as randomBytes6 } from "crypto";
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync20, statSync as statSync9, truncateSync as truncateSync3 } from "fs";
-import { join as join25 } from "path";
+import { randomBytes as randomBytes7 } from "crypto";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync21, statSync as statSync10, truncateSync as truncateSync3 } from "fs";
+import { join as join26 } from "path";
 import { StringDecoder } from "string_decoder";
 
 // src/wrap/screen.ts
@@ -5976,20 +6753,20 @@ function runDirect(real2, args, env = process.env) {
 
 // src/wrap/codexLaunch.ts
 import { spawn as spawn3 } from "child_process";
-import { closeSync, mkdirSync as mkdirSync19, openSync, readdirSync as readdirSync4, readFileSync as readFileSync18, rmSync as rmSync11, statSync as statSync8, truncateSync as truncateSync2, writeFileSync as writeFileSync19, renameSync as renameSync13 } from "fs";
+import { closeSync as closeSync2, mkdirSync as mkdirSync20, openSync as openSync2, readdirSync as readdirSync5, readFileSync as readFileSync19, rmSync as rmSync14, statSync as statSync9, truncateSync as truncateSync2, writeFileSync as writeFileSync20, renameSync as renameSync14 } from "fs";
 import { request } from "http";
-import { createServer as createServer3 } from "net";
-import { join as join24 } from "path";
+import { createServer as createServer4 } from "net";
+import { join as join25 } from "path";
 
 // src/core/codexServer.ts
-import { execFileSync as execFileSync8 } from "child_process";
+import { execFileSync as execFileSync9 } from "child_process";
 function isAppServerArgs(args, url) {
   return /\bapp-server\b/.test(args) && new RegExp(`--listen[= ]${url.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?:\\s|$)`).test(args);
 }
 function processArgs(pid) {
   if (process.platform === "win32") return null;
   try {
-    const out = execFileSync8("ps", ["-ww", "-o", "args=", "-p", String(pid)], {
+    const out = execFileSync9("ps", ["-ww", "-o", "args=", "-p", String(pid)], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -6147,10 +6924,10 @@ async function runCodexWindow(real2, args, d) {
 }
 var MAX_LOG_BYTES2 = 1024 * 1024;
 function appServerLogPath() {
-  return join24(deskbuddyHome(), "codex-app-server.log");
+  return join25(deskbuddyHome(), "codex-app-server.log");
 }
 function windowsDir2() {
-  return join24(deskbuddyHome(), "codex-windows");
+  return join25(deskbuddyHome(), "codex-windows");
 }
 function pidAlive(pid) {
   try {
@@ -6163,7 +6940,7 @@ function pidAlive(pid) {
 function daemonAlive(pidFile = pidFilePath(), args = processArgs) {
   let pid = 0;
   try {
-    pid = Number(readFileSync18(pidFile, "utf8").trim());
+    pid = Number(readFileSync19(pidFile, "utf8").trim());
   } catch {
     return false;
   }
@@ -6185,7 +6962,7 @@ function probeReady(url) {
 }
 function freePort() {
   return new Promise((resolve5, reject) => {
-    const srv = createServer3();
+    const srv = createServer4();
     srv.unref();
     srv.on("error", reject);
     srv.listen(0, "127.0.0.1", () => {
@@ -6197,12 +6974,12 @@ function freePort() {
 }
 function startServer(real2, url, env, cwd) {
   const logPath2 = appServerLogPath();
-  mkdirSync19(deskbuddyHome(), { recursive: true });
+  mkdirSync20(deskbuddyHome(), { recursive: true });
   try {
-    if (statSync8(logPath2).size > MAX_LOG_BYTES2) truncateSync2(logPath2, 0);
+    if (statSync9(logPath2).size > MAX_LOG_BYTES2) truncateSync2(logPath2, 0);
   } catch {
   }
-  const fd = openSync(logPath2, "a");
+  const fd = openSync2(logPath2, "a");
   try {
     const childEnv2 = { ...env, DESKBUDDY_WRAPPED: "1" };
     delete childEnv2.DESKBUDDY_SHIM;
@@ -6217,7 +6994,7 @@ function startServer(real2, url, env, cwd) {
     child.unref();
     return child.pid ?? null;
   } finally {
-    closeSync(fd);
+    closeSync2(fd);
   }
 }
 function killServer(pid) {
@@ -6231,41 +7008,41 @@ function killOwnServer(pid, url) {
   if (a && isAppServerArgs(a, url)) killServer(pid);
 }
 function recordPath(rec) {
-  return join24(windowsDir2(), `${rec.server}.json`);
+  return join25(windowsDir2(), `${rec.server}.json`);
 }
 function writeRecord(rec) {
   try {
-    mkdirSync19(windowsDir2(), { recursive: true, mode: 448 });
+    mkdirSync20(windowsDir2(), { recursive: true, mode: 448 });
     const p = recordPath(rec);
-    writeFileSync19(p + ".tmp", JSON.stringify(rec), { encoding: "utf8", mode: 384 });
-    renameSync13(p + ".tmp", p);
+    writeFileSync20(p + ".tmp", JSON.stringify(rec), { encoding: "utf8", mode: 384 });
+    renameSync14(p + ".tmp", p);
   } catch {
   }
 }
 function removeRecord(rec) {
   try {
-    rmSync11(recordPath(rec), { force: true });
+    rmSync14(recordPath(rec), { force: true });
   } catch {
   }
 }
 function reapWindows(dir = windowsDir2(), alive = pidAlive, args = processArgs, kill = killServer) {
   let names = [];
   try {
-    names = readdirSync4(dir).filter((n) => n.endsWith(".json"));
+    names = readdirSync5(dir).filter((n) => n.endsWith(".json"));
   } catch {
     return;
   }
   for (const n of names) {
-    const p = join24(dir, n);
+    const p = join25(dir, n);
     let rec;
     try {
-      rec = JSON.parse(readFileSync18(p, "utf8"));
+      rec = JSON.parse(readFileSync19(p, "utf8"));
     } catch {
-      rmSync11(p, { force: true });
+      rmSync14(p, { force: true });
       continue;
     }
     if (typeof rec.supervisor !== "number" || typeof rec.server !== "number" || typeof rec.url !== "string") {
-      rmSync11(p, { force: true });
+      rmSync14(p, { force: true });
       continue;
     }
     if (alive(rec.supervisor)) continue;
@@ -6273,13 +7050,13 @@ function reapWindows(dir = windowsDir2(), alive = pidAlive, args = processArgs,
       const a = args(rec.server);
       if (a && isAppServerArgs(a, rec.url)) kill(rec.server);
     }
-    rmSync11(p, { force: true });
+    rmSync14(p, { force: true });
   }
 }
 function launchLog(line) {
   try {
-    mkdirSync19(deskbuddyHome(), { recursive: true });
-    writeFileSync19(join24(deskbuddyHome(), "wrap.log"), `${(/* @__PURE__ */ new Date()).toISOString()} [codex ${process.pid}] ${line}
+    mkdirSync20(deskbuddyHome(), { recursive: true });
+    writeFileSync20(join25(deskbuddyHome(), "wrap.log"), `${(/* @__PURE__ */ new Date()).toISOString()} [codex ${process.pid}] ${line}
 `, { flag: "a" });
   } catch {
   }
@@ -6319,10 +7096,10 @@ function childEnv(src, windowId) {
 }
 function wrapLog(line) {
   try {
-    const p = join25(deskbuddyHome(), "wrap.log");
-    mkdirSync20(deskbuddyHome(), { recursive: true });
+    const p = join26(deskbuddyHome(), "wrap.log");
+    mkdirSync21(deskbuddyHome(), { recursive: true });
     try {
-      if (statSync9(p).size > MAX_LOG_BYTES3) truncateSync3(p, 0);
+      if (statSync10(p).size > MAX_LOG_BYTES3) truncateSync3(p, 0);
     } catch {
     }
     appendFileSync2(p, `${(/* @__PURE__ */ new Date()).toISOString()} [${process.pid}] ${line}
@@ -6409,7 +7186,7 @@ async function wrapInPty(tool, real2, args, deps) {
     return null;
   }
   const { stdout: stdout7 } = deps;
-  const windowId = randomBytes6(16).toString("hex");
+  const windowId = randomBytes7(16).toString("hex");
   const cols = stdout7.columns || 80;
   const rows = stdout7.rows || 24;
   const term = new Headless({ cols, rows, allowProposedApi: true });