sessix-server 0.4.1 → 0.4.3

package/dist/server.js

@@ -307,12 +307,12 @@ function t(key, params) {
 }
 
 // src/server.ts
-var import_uuid7 = require("uuid");
-var import_promises5 = require("fs/promises");
-var import_node_os8 = require("os");
-var import_node_path7 = require("path");
-var import_node_child_process10 = require("child_process");
-var import_node_util2 = require("util");
+var import_uuid9 = require("uuid");
+var import_promises7 = require("fs/promises");
+var import_node_os9 = require("os");
+var import_node_path9 = require("path");
+var import_node_child_process11 = require("child_process");
+var import_node_util3 = require("util");
 
 // src/providers/ProcessProvider.ts
 var import_child_process = require("child_process");
@@ -543,6 +543,77 @@ var ProcessProvider = class {
   getActiveSessions() {
     return Array.from(this.activeSessions.values()).map((entry) => entry.session);
   }
+  /**
+   * 清理空闲进程
+   *
+   * 找出所有 status='idle' 且 lastActiveAt 距今超过 maxIdleMs 的活跃进程，
+   * kill 进程释放内存。entry 保留在 activeSessions 中，用户下次 sendMessage
+   * 走 slow path 自动 --resume 重启进程。
+   *
+   * @returns 被 sweep 的 sessionId 列表
+   */
+  async sweepIdleProcesses(maxIdleMs) {
+    const now = Date.now();
+    const swept = [];
+    for (const [sessionId, entry] of this.activeSessions) {
+      if (entry.process.exitCode !== null || entry.process.signalCode !== null) continue;
+      if (entry.session.status !== "idle") continue;
+      if (now - entry.session.lastActiveAt < maxIdleMs) continue;
+      const idleMin = Math.round((now - entry.session.lastActiveAt) / 6e4);
+      console.log(`[ProcessProvider] sweeping idle process: ${sessionId} (idle ${idleMin}m)`);
+      try {
+        entry.process.stdin?.end();
+      } catch {
+      }
+      try {
+        await killProcessCrossPlatform(entry.process);
+      } catch (err) {
+        console.error(`[ProcessProvider] sweep kill failed for ${sessionId}:`, err);
+        continue;
+      }
+      swept.push(sessionId);
+    }
+    return swept;
+  }
+  /**
+   * LRU 上限清理
+   *
+   * 当活跃进程数超过 maxAlive 时，按 lastActiveAt 升序（最久未用优先）kill
+   * 状态为 idle 的进程，直到活跃数回到上限以内。
+   * running / waiting_question 状态的进程永远不会被 kill。
+   *
+   * @returns 被 sweep 的 sessionId 列表
+   */
+  async sweepLruProcesses(maxAlive) {
+    const swept = [];
+    if (maxAlive <= 0) return swept;
+    const aliveEntries = Array.from(this.activeSessions.entries()).filter(
+      ([, e]) => e.process.exitCode === null && e.process.signalCode === null
+    );
+    if (aliveEntries.length <= maxAlive) return swept;
+    const idleSorted = aliveEntries.filter(([, e]) => e.session.status === "idle").sort((a, b) => a[1].session.lastActiveAt - b[1].session.lastActiveAt);
+    let aliveCount = aliveEntries.length;
+    for (const [sessionId, entry] of idleSorted) {
+      if (aliveCount <= maxAlive) break;
+      const idleMin = Math.round((Date.now() - entry.session.lastActiveAt) / 6e4);
+      console.log(`[ProcessProvider] LRU sweep: ${sessionId} (idle ${idleMin}m, alive=${aliveCount}/${maxAlive})`);
+      try {
+        entry.process.stdin?.end();
+      } catch {
+      }
+      try {
+        await killProcessCrossPlatform(entry.process);
+        swept.push(sessionId);
+        aliveCount--;
+      } catch (err) {
+        console.error(`[ProcessProvider] LRU kill failed for ${sessionId}:`, err);
+      }
+    }
+    if (aliveCount > maxAlive) {
+      console.warn(`[ProcessProvider] LRU sweep: ${aliveCount} alive after sweep > limit ${maxAlive}; remaining are running/waiting`);
+    }
+    return swept;
+  }
   // ============================================
   // 私有方法
   // ============================================
@@ -1770,6 +1841,20 @@ var SessionManager = class {
   isBufferTruncated(sessionId) {
     return this.bufferTruncated.has(sessionId);
   }
+  /**
+   * 缩减指定会话的事件缓冲区到最后 N 条，并标记 truncated
+   *
+   * 用于空闲进程被 sweep 后释放内存：缓冲区只为新订阅者重放服务，
+   * 进程已死的会话可以通过 JSONL 文件补全完整历史，不需要保留全部内存事件。
+   * 设置 bufferTruncated 后，客户端 subscribe 收到 session_history 时会从 JSONL 补齐。
+   */
+  shrinkSessionBuffer(sessionId, keepLast = 100) {
+    const buffer = this.sessionEventBuffers.get(sessionId);
+    if (!buffer || buffer.length <= keepLast) return;
+    buffer.splice(0, buffer.length - keepLast);
+    this.bufferTruncated.add(sessionId);
+    console.log(`[SessionManager] Session ${sessionId}: buffer shrunk to ${keepLast}, marked truncated`);
+  }
   /**
    * 获取会话的项目路径（用于截断时从 JSONL 补全历史）
    */
@@ -1855,6 +1940,54 @@ var SessionManager = class {
       return stats ? { ...session, stats } : session;
     });
   }
+  /**
+   * 接入 ApprovalProxy 的非阻塞 hook 通知，将其映射为 ServerEvent 转发。
+   *
+   * 仅转发为 shared 类型定义中的字段，不把 hook 原始 payload 透传出去（隐私 + 体积）。
+   * 当前覆盖：
+   * - PreCompact (`type: 'compact'`)         → `session_compact`
+   * - PermissionDenied (`type: 'permission_denied'`) → `permission_denied`
+   * - Subagent  (`type: 'subagent'`)         → `subagent_event`（骨架预留，本任务不发）
+   */
+  attachApprovalProxy(approvalProxy) {
+    approvalProxy.onNotify((notification) => {
+      const serverEvent = this.mapHookNotificationToServerEvent(notification);
+      if (serverEvent) this.emit(serverEvent);
+    });
+  }
+  /** 将 hook 通知映射为 ServerEvent；不识别的 type 返回 null */
+  mapHookNotificationToServerEvent(n) {
+    switch (n.type) {
+      case "compact": {
+        const subtype = n.subtype === "completed" || n.subtype === "blocked" ? n.subtype : "started";
+        return { type: "session_compact", sessionId: n.sessionId, subtype };
+      }
+      case "permission_denied": {
+        const source = n.source === "hook" || n.source === "rule" ? n.source : "classifier";
+        return {
+          type: "permission_denied",
+          sessionId: n.sessionId,
+          toolName: n.toolName ?? "unknown",
+          reason: n.reason ?? "",
+          source
+        };
+      }
+      case "subagent": {
+        const phase = n.subtype === "completed" ? "completed" : "started";
+        return {
+          type: "subagent_event",
+          sessionId: n.sessionId,
+          parentToolUseId: typeof n.parentToolUseId === "string" ? n.parentToolUseId : "",
+          subAgentId: typeof n.subAgentId === "string" ? n.subAgentId : "",
+          phase,
+          task: typeof n.task === "string" ? n.task : void 0
+        };
+      }
+      default:
+        console.warn(`[SessionManager] Unknown hook notification type: ${n.type}`);
+        return null;
+    }
+  }
   /**
    * 注册事件回调（事件会被转发到 WsBridge）
    *
@@ -2540,6 +2673,8 @@ var ApprovalProxy = class _ApprovalProxy {
   approvalRequestCallbacks = [];
   /** 审批 resolve 回调（任何来源的 resolve 都会触发，用于 WS 广播清理 */
   approvalResolvedCallbacks = [];
+  /** Hook 通知回调（PreCompact / PermissionDenied / 等非阻塞 hook） */
+  notifyCallbacks = [];
   /** YOLO 模式状态：sessionId -> enabled */
   yoloSessions = /* @__PURE__ */ new Map();
   /** 内存缓存：已被"始终允许"的工具名（避免每次读 settings.json） */
@@ -2601,6 +2736,24 @@ var ApprovalProxy = class _ApprovalProxy {
       }
     }
   }
+  /**
+   * 注册非阻塞 hook 通知回调（如 PreCompact、PermissionDenied）
+   *
+   * 这些 hook 不需要返回决策给 Claude Code，仅作为 ServerEvent 转发到手机端。
+   */
+  onNotify(callback) {
+    this.notifyCallbacks.push(callback);
+  }
+  /** 触发所有 notify 回调（内部调用） */
+  fireNotify(notification) {
+    for (const callback of this.notifyCallbacks) {
+      try {
+        callback(notification);
+      } catch (err) {
+        console.error("[ApprovalProxy] Notify callback error:", err);
+      }
+    }
+  }
   /** 设置状态信息提供者（用于 /health 端点） */
   setStatusInfoProvider(provider) {
     this.statusInfoProvider = provider;
@@ -2785,6 +2938,8 @@ var ApprovalProxy = class _ApprovalProxy {
     const pathname = url.pathname;
     if (req.method === "POST" && pathname === "/hook/approval") {
       this.handleApprovalHook(req, res);
+    } else if (req.method === "POST" && pathname === "/hook/notify") {
+      this.handleHookNotify(req, res);
     } else if (req.method === "POST" && pathname === "/pair") {
       this.handlePair(req, res);
     } else if (req.method === "GET" && pathname === "/health") {
@@ -2850,6 +3005,51 @@ var ApprovalProxy = class _ApprovalProxy {
       this.sendJson(res, 200, { decision: "deny", reason: "Server failed to process request" });
     }
   }
+  /**
+   * 非阻塞 hook 通知端点
+   *
+   * 用于 PreCompact、PostCompact、PermissionDenied 等 fire-and-forget 的 hook：
+   * 立即返回 {"ok":true}，再异步分发到 notifyCallbacks（最终广播为 ServerEvent）。
+   *
+   * 鉴权策略：仅允许 loopback（本机 hook 脚本）访问，避免远端注入伪造事件。
+   */
+  async handleHookNotify(req, res) {
+    if (!this.isLoopbackRequest(req)) {
+      this.sendJson(res, 403, { ok: false, reason: "forbidden" });
+      return;
+    }
+    try {
+      const body = await this.parseJsonBody(req);
+      const sessionId = String(body.sessionId ?? "").trim();
+      const type = String(body.type ?? "").trim();
+      if (!sessionId || !type) {
+        this.sendJson(res, 400, { error: "sessionId and type are required" });
+        return;
+      }
+      const notification = {
+        sessionId,
+        type
+      };
+      if (typeof body.subtype === "string") notification.subtype = body.subtype;
+      if (typeof body.toolName === "string") notification.toolName = body.toolName;
+      if (typeof body.reason === "string") notification.reason = body.reason;
+      if (typeof body.source === "string") notification.source = body.source;
+      if (typeof body.parentToolUseId === "string") notification.parentToolUseId = body.parentToolUseId;
+      if (typeof body.subAgentId === "string") notification.subAgentId = body.subAgentId;
+      if (body.phase === "started" || body.phase === "completed") notification.phase = body.phase;
+      if (typeof body.task === "string") notification.task = body.task;
+      this.sendJson(res, 200, { ok: true });
+      setImmediate(() => this.fireNotify(notification));
+    } catch (err) {
+      console.error("[ApprovalProxy] Hook notify failed:", err);
+      this.sendJson(res, 200, { ok: false });
+    }
+  }
+  /** 判断请求是否来自本机 loopback（127.0.0.1 / ::1 / IPv4-mapped IPv6） */
+  isLoopbackRequest(req) {
+    const remoteAddress = req.socket.remoteAddress;
+    return remoteAddress === "127.0.0.1" || remoteAddress === "::1" || remoteAddress === "::ffff:127.0.0.1";
+  }
   /** 健康检查端点 */
   handleHealth(_req, res) {
     const info = this.statusInfoProvider?.() ?? { connections: 0, activeSessions: 0 };
@@ -2882,9 +3082,7 @@ var ApprovalProxy = class _ApprovalProxy {
   }
   /** 返回连接 token（仅本机访问） */
   handleToken(req, res) {
-    const remoteAddress = req.socket.remoteAddress;
-    const isLocal = remoteAddress === "127.0.0.1" || remoteAddress === "::1" || remoteAddress === "::ffff:127.0.0.1";
-    if (!isLocal) {
+    if (!this.isLoopbackRequest(req)) {
       this.sendJson(res, 403, { error: t("approval.forbidden") });
       return;
     }
@@ -3112,9 +3310,15 @@ var import_node_os6 = require("os");
 var SESSIX_HOOKS_DIR = (0, import_node_path4.join)((0, import_node_os6.homedir)(), ".sessix", "hooks");
 var HOOK_SCRIPT_PATH = (0, import_node_path4.join)(SESSIX_HOOKS_DIR, "approval-hook.js");
 var PERMISSION_ACCEPT_PATH = (0, import_node_path4.join)(SESSIX_HOOKS_DIR, "permission-accept.js");
+var COMPACT_HOOK_PATH = (0, import_node_path4.join)(SESSIX_HOOKS_DIR, "compact-hook.js");
+var POST_COMPACT_HOOK_PATH = (0, import_node_path4.join)(SESSIX_HOOKS_DIR, "post-compact-hook.js");
+var PERMISSION_DENIED_HOOK_PATH = (0, import_node_path4.join)(SESSIX_HOOKS_DIR, "permission-denied-hook.js");
 var CLAUDE_SETTINGS_PATH = (0, import_node_path4.join)((0, import_node_os6.homedir)(), ".claude", "settings.json");
 var HOOK_COMMAND = "node ~/.sessix/hooks/approval-hook.js";
 var PERMISSION_ACCEPT_COMMAND = "node ~/.sessix/hooks/permission-accept.js";
+var COMPACT_HOOK_COMMAND = "node ~/.sessix/hooks/compact-hook.js";
+var POST_COMPACT_HOOK_COMMAND = "node ~/.sessix/hooks/post-compact-hook.js";
+var PERMISSION_DENIED_HOOK_COMMAND = "node ~/.sessix/hooks/permission-denied-hook.js";
 var LEGACY_HOOK_COMMANDS = [
   "~/.sessix/hooks/approval-hook.sh",
   "~/.sessix/hooks/permission-accept.sh"
@@ -3174,6 +3378,112 @@ if (!process.env.SESSIX_SESSION_ID) process.exit(0)
 process.stdout.write('{"decision":"allow"}\\n')
 process.exit(0)
 `;
+var COMPACT_HOOK_TEMPLATE = `#!/usr/bin/env node
+// Sessix PreCompact \u901A\u77E5 hook
+// \u4EC5\u5728 Sessix \u7BA1\u7406\u7684\u4F1A\u8BDD\u4E2D\u6FC0\u6D3B
+
+const sessionId = process.env.SESSIX_SESSION_ID
+if (!sessionId) {
+  process.stdout.write('{}')
+  process.exit(0)
+}
+
+let raw = ''
+process.stdin.on('data', (chunk) => { raw += chunk })
+process.stdin.on('end', () => {
+  // \u8BFB\u53D6\u5E76\u4E22\u5F03 stdin payload\uFF08PreCompact \u6807\u51C6\u8F93\u5165\uFF09\uFF0Cserver \u7AEF\u4E0D\u9700\u8981\u5B83
+  try { JSON.parse(raw) } catch {}
+  // fire-and-forget\uFF1A\u4E0D\u7B49\u5F85\u54CD\u5E94\uFF0C\u907F\u514D\u963B\u585E compact
+  try {
+    fetch('http://localhost:3746/hook/notify', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        sessionId,
+        type: 'compact',
+        subtype: 'started',
+      }),
+      signal: AbortSignal.timeout(2000),
+    }).catch(() => {})
+  } catch {}
+  // \u7ACB\u5373\u8FD4\u56DE\u7A7A JSON\uFF0C\u4E0D\u963B\u585E compact
+  process.stdout.write('{}')
+  process.exit(0)
+})
+`;
+var POST_COMPACT_HOOK_TEMPLATE = `#!/usr/bin/env node
+// Sessix PostCompact \u901A\u77E5 hook
+// \u4EC5\u5728 Sessix \u7BA1\u7406\u7684\u4F1A\u8BDD\u4E2D\u6FC0\u6D3B
+
+const sessionId = process.env.SESSIX_SESSION_ID
+if (!sessionId) {
+  process.stdout.write('{}')
+  process.exit(0)
+}
+
+let raw = ''
+process.stdin.on('data', (chunk) => { raw += chunk })
+process.stdin.on('end', () => {
+  // \u8BFB\u53D6\u5E76\u4E22\u5F03 stdin payload\uFF0Cserver \u7AEF\u4E0D\u9700\u8981\u5B83
+  try { JSON.parse(raw) } catch {}
+  // fire-and-forget\uFF1A\u4E0D\u7B49\u5F85\u54CD\u5E94
+  try {
+    fetch('http://localhost:3746/hook/notify', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        sessionId,
+        type: 'compact',
+        subtype: 'completed',
+      }),
+      signal: AbortSignal.timeout(2000),
+    }).catch(() => {})
+  } catch {}
+  process.stdout.write('{}')
+  process.exit(0)
+})
+`;
+var PERMISSION_DENIED_HOOK_TEMPLATE = `#!/usr/bin/env node
+// Sessix PermissionDenied \u901A\u77E5 hook
+// \u4EC5\u5728 Sessix \u7BA1\u7406\u7684\u4F1A\u8BDD\u4E2D\u6FC0\u6D3B
+
+const sessionId = process.env.SESSIX_SESSION_ID
+if (!sessionId) {
+  process.stdout.write('{}')
+  process.exit(0)
+}
+
+let raw = ''
+process.stdin.on('data', (chunk) => { raw += chunk })
+process.stdin.on('end', () => {
+  let payload = {}
+  try { payload = JSON.parse(raw) } catch {}
+  const toolName = String(payload.tool_name || 'unknown')
+  // Claude Code PermissionDenied \u7531 classifier \u89E6\u53D1\uFF0C\u6240\u4EE5 source \u9ED8\u8BA4 'classifier'
+  const reason = String(
+    payload.reason ||
+    payload.permission_decision_reason ||
+    payload.permissionDecisionReason ||
+    ''
+  )
+  try {
+    fetch('http://localhost:3746/hook/notify', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        sessionId,
+        type: 'permission_denied',
+        toolName,
+        reason,
+        source: 'classifier',
+      }),
+      signal: AbortSignal.timeout(2000),
+    }).catch(() => {})
+  } catch {}
+  process.stdout.write('{}')
+  process.exit(0)
+})
+`;
 var HookInstaller = class {
   /**
    * 安装 hook
@@ -3187,8 +3497,14 @@ var HookInstaller = class {
     await (0, import_promises2.mkdir)(SESSIX_HOOKS_DIR, { recursive: true });
     await (0, import_promises2.writeFile)(HOOK_SCRIPT_PATH, HOOK_SCRIPT_TEMPLATE, "utf-8");
     await (0, import_promises2.writeFile)(PERMISSION_ACCEPT_PATH, PERMISSION_ACCEPT_TEMPLATE, "utf-8");
+    await (0, import_promises2.writeFile)(COMPACT_HOOK_PATH, COMPACT_HOOK_TEMPLATE, "utf-8");
+    await (0, import_promises2.writeFile)(POST_COMPACT_HOOK_PATH, POST_COMPACT_HOOK_TEMPLATE, "utf-8");
+    await (0, import_promises2.writeFile)(PERMISSION_DENIED_HOOK_PATH, PERMISSION_DENIED_HOOK_TEMPLATE, "utf-8");
     await (0, import_promises2.chmod)(HOOK_SCRIPT_PATH, 493);
     await (0, import_promises2.chmod)(PERMISSION_ACCEPT_PATH, 493);
+    await (0, import_promises2.chmod)(COMPACT_HOOK_PATH, 493);
+    await (0, import_promises2.chmod)(POST_COMPACT_HOOK_PATH, 493);
+    await (0, import_promises2.chmod)(PERMISSION_DENIED_HOOK_PATH, 493);
     await this.addHookToSettings();
     console.log("[HookInstaller] Hook installation complete");
   }
@@ -3214,6 +3530,9 @@ var HookInstaller = class {
   async isInstalled() {
     let approvalScriptContent = "";
     let permissionScriptExists = false;
+    let compactScriptExists = false;
+    let postCompactScriptExists = false;
+    let permissionDeniedScriptExists = false;
     try {
       approvalScriptContent = await (0, import_promises2.readFile)(HOOK_SCRIPT_PATH, "utf-8");
     } catch {
@@ -3223,10 +3542,25 @@ var HookInstaller = class {
       permissionScriptExists = true;
     } catch {
     }
+    try {
+      await (0, import_promises2.access)(COMPACT_HOOK_PATH);
+      compactScriptExists = true;
+    } catch {
+    }
+    try {
+      await (0, import_promises2.access)(POST_COMPACT_HOOK_PATH);
+      postCompactScriptExists = true;
+    } catch {
+    }
+    try {
+      await (0, import_promises2.access)(PERMISSION_DENIED_HOOK_PATH);
+      permissionDeniedScriptExists = true;
+    } catch {
+    }
     const isLatestVersion = approvalScriptContent.includes("permissionDecision");
     const settings = await this.readClaudeSettings();
     const configExists = this.hasHookConfig(settings);
-    return isLatestVersion && permissionScriptExists && configExists;
+    return isLatestVersion && permissionScriptExists && compactScriptExists && postCompactScriptExists && permissionDeniedScriptExists && configExists;
   }
   // ============================================
   // 内部方法
@@ -3264,6 +3598,36 @@ var HookInstaller = class {
       });
       changed = true;
     }
+    if (!this.hasPreCompactConfig(settings)) {
+      if (!settings.hooks.PreCompact) {
+        settings.hooks.PreCompact = [];
+      }
+      settings.hooks.PreCompact.push({
+        matcher: "",
+        hooks: [{ type: "command", command: COMPACT_HOOK_COMMAND }]
+      });
+      changed = true;
+    }
+    if (!this.hasPostCompactConfig(settings)) {
+      if (!settings.hooks.PostCompact) {
+        settings.hooks.PostCompact = [];
+      }
+      settings.hooks.PostCompact.push({
+        matcher: "",
+        hooks: [{ type: "command", command: POST_COMPACT_HOOK_COMMAND }]
+      });
+      changed = true;
+    }
+    if (!this.hasPermissionDeniedConfig(settings)) {
+      if (!settings.hooks.PermissionDenied) {
+        settings.hooks.PermissionDenied = [];
+      }
+      settings.hooks.PermissionDenied.push({
+        matcher: "",
+        hooks: [{ type: "command", command: PERMISSION_DENIED_HOOK_COMMAND }]
+      });
+      changed = true;
+    }
     if (changed) {
       await this.writeClaudeSettings(settings);
     } else {
@@ -3278,6 +3642,9 @@ var HookInstaller = class {
     if (!settings.hooks) return;
     this.removeHookCommand(settings, "PreToolUse", HOOK_COMMAND);
     this.removeHookCommand(settings, "PermissionRequest", PERMISSION_ACCEPT_COMMAND);
+    this.removeHookCommand(settings, "PreCompact", COMPACT_HOOK_COMMAND);
+    this.removeHookCommand(settings, "PostCompact", POST_COMPACT_HOOK_COMMAND);
+    this.removeHookCommand(settings, "PermissionDenied", PERMISSION_DENIED_HOOK_COMMAND);
     if (Object.keys(settings.hooks).length === 0) {
       delete settings.hooks;
     }
@@ -3315,7 +3682,7 @@ var HookInstaller = class {
    * 检查 settings 中是否已包含所有 Sessix hook 配置
    */
   hasHookConfig(settings) {
-    return this.hasPreToolUseConfig(settings) && this.hasPermissionRequestConfig(settings);
+    return this.hasPreToolUseConfig(settings) && this.hasPermissionRequestConfig(settings) && this.hasPreCompactConfig(settings) && this.hasPostCompactConfig(settings) && this.hasPermissionDeniedConfig(settings);
   }
   /** 检查 PreToolUse 中是否有 approval-hook.js */
   hasPreToolUseConfig(settings) {
@@ -3325,6 +3692,18 @@ var HookInstaller = class {
   hasPermissionRequestConfig(settings) {
     return this.hasHookEntry(settings?.hooks?.PermissionRequest, PERMISSION_ACCEPT_COMMAND);
   }
+  /** 检查 PreCompact 中是否有 compact-hook.js */
+  hasPreCompactConfig(settings) {
+    return this.hasHookEntry(settings?.hooks?.PreCompact, COMPACT_HOOK_COMMAND);
+  }
+  /** 检查 PostCompact 中是否有 post-compact-hook.js */
+  hasPostCompactConfig(settings) {
+    return this.hasHookEntry(settings?.hooks?.PostCompact, POST_COMPACT_HOOK_COMMAND);
+  }
+  /** 检查 PermissionDenied 中是否有 permission-denied-hook.js */
+  hasPermissionDeniedConfig(settings) {
+    return this.hasHookEntry(settings?.hooks?.PermissionDenied, PERMISSION_DENIED_HOOK_COMMAND);
+  }
   /** 检查 hook 数组中是否包含指定命令 */
   hasHookEntry(hookArray, command) {
     if (!Array.isArray(hookArray)) return false;
@@ -4400,7 +4779,7 @@ var AuthManager = class extends import_events3.EventEmitter {
 };
 
 // src/server.ts
-var import_promises6 = require("fs/promises");
+var import_promises8 = require("fs/promises");
 
 // src/terminal/TerminalExecutor.ts
 var import_node_child_process7 = require("child_process");
@@ -4903,8 +5282,762 @@ function kindOrder(k) {
   return k === "device" ? 0 : k === "simulator" ? 1 : k === "mac" ? 2 : 3;
 }
 
-// src/utils/cliCapabilities.ts
+// src/commands/CommandDiscovery.ts
+var import_promises5 = require("fs/promises");
+var import_node_path7 = require("path");
+var import_node_crypto = require("crypto");
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var MAX_README_BYTES = 256 * 1024;
+var SUBPACKAGE_DIRS = ["packages", "apps", "crates", "services"];
+var MAX_SCAN_PER_DIR = 30;
+var CommandDiscovery = class {
+  cache = /* @__PURE__ */ new Map();
+  async scan(projectPath, refresh = false) {
+    if (!refresh) {
+      const hit = this.cache.get(projectPath);
+      if (hit && hit.expiresAt > Date.now()) return hit.commands;
+    }
+    const collector = [];
+    await Promise.all([
+      this.scanPackageJson(projectPath, "", collector),
+      this.scanMakefile(projectPath, "", collector),
+      this.scanJustfile(projectPath, "", collector),
+      this.scanCargo(projectPath, "", collector),
+      this.scanCompose(projectPath, "", collector),
+      this.scanReadme(projectPath, "README.md", "readme", collector),
+      this.scanReadme(projectPath, "CLAUDE.md", "claude.md", collector)
+    ]);
+    for (const sub of SUBPACKAGE_DIRS) {
+      const subRoot = (0, import_node_path7.join)(projectPath, sub);
+      let entries;
+      try {
+        entries = await (0, import_promises5.readdir)(subRoot);
+      } catch {
+        continue;
+      }
+      let scanned = 0;
+      for (const name of entries) {
+        if (name.startsWith(".") || scanned >= MAX_SCAN_PER_DIR) continue;
+        const childAbs = (0, import_node_path7.join)(subRoot, name);
+        try {
+          const s = await (0, import_promises5.stat)(childAbs);
+          if (!s.isDirectory()) continue;
+        } catch {
+          continue;
+        }
+        scanned++;
+        const rel = `${sub}/${name}`;
+        await Promise.all([
+          this.scanPackageJson(projectPath, rel, collector),
+          this.scanCargo(projectPath, rel, collector)
+        ]);
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = [];
+    for (const c of collector) {
+      if (seen.has(c.id)) continue;
+      seen.add(c.id);
+      deduped.push(c);
+    }
+    deduped.sort((a, b) => {
+      const ca = categoryWeight(a.category) - categoryWeight(b.category);
+      if (ca !== 0) return ca;
+      const sa = sourceWeight(a.source) - sourceWeight(b.source);
+      if (sa !== 0) return sa;
+      return a.title.localeCompare(b.title);
+    });
+    this.cache.set(projectPath, { commands: deduped, expiresAt: Date.now() + CACHE_TTL_MS });
+    return deduped;
+  }
+  invalidate(projectPath) {
+    if (projectPath) this.cache.delete(projectPath);
+    else this.cache.clear();
+  }
+  // ============================================
+  // 各来源扫描器
+  // ============================================
+  async scanPackageJson(rootPath, subDir, out) {
+    const file = subDir ? `${subDir}/package.json` : "package.json";
+    const abs = (0, import_node_path7.join)(rootPath, file);
+    let raw;
+    try {
+      raw = await (0, import_promises5.readFile)(abs, "utf8");
+    } catch {
+      return;
+    }
+    let pkg;
+    try {
+      pkg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (!pkg.scripts) return;
+    for (const [name, script] of Object.entries(pkg.scripts)) {
+      if (typeof script !== "string") continue;
+      const command = subDir ? `npm --workspace=${subDir} run ${name}` : `npm run ${name}`;
+      const title = subDir ? `${pkg.name ?? subDir.split("/").pop()}: ${name}` : name;
+      out.push(makeCommand({
+        title,
+        command,
+        cwd: "",
+        source: "package.json",
+        sourceFile: file,
+        description: script,
+        category: classifyByName(name) ?? classifyByCommand(script)
+      }));
+    }
+  }
+  async scanMakefile(rootPath, subDir, out) {
+    const file = subDir ? `${subDir}/Makefile` : "Makefile";
+    const abs = (0, import_node_path7.join)(rootPath, file);
+    let raw;
+    try {
+      raw = await (0, import_promises5.readFile)(abs, "utf8");
+    } catch {
+      return;
+    }
+    const lines = raw.split("\n");
+    let lastComment;
+    const targetRegex = /^([a-zA-Z][a-zA-Z0-9_-]*)\s*:(?!=)/;
+    for (const line of lines) {
+      const trim = line.trim();
+      if (trim.startsWith("#")) {
+        lastComment = trim.replace(/^#+\s?/, "").trim() || void 0;
+        continue;
+      }
+      if (trim === "") {
+        lastComment = void 0;
+        continue;
+      }
+      const match = targetRegex.exec(line);
+      if (!match) {
+        lastComment = void 0;
+        continue;
+      }
+      const target = match[1];
+      if (target === ".PHONY" || target === "default" && trim.startsWith("default:")) continue;
+      out.push(makeCommand({
+        title: target,
+        command: `make ${target}`,
+        cwd: subDir,
+        source: "makefile",
+        sourceFile: file,
+        description: lastComment,
+        category: classifyByName(target)
+      }));
+      lastComment = void 0;
+    }
+  }
+  async scanJustfile(rootPath, subDir, out) {
+    const file = subDir ? `${subDir}/justfile` : "justfile";
+    const abs = (0, import_node_path7.join)(rootPath, file);
+    let raw;
+    try {
+      raw = await (0, import_promises5.readFile)(abs, "utf8");
+    } catch {
+      return;
+    }
+    const lines = raw.split("\n");
+    let lastComment;
+    const recipeRegex = /^([a-zA-Z][a-zA-Z0-9_-]*)\s*(?:[a-zA-Z0-9_=" ]*)?\s*:/;
+    for (const line of lines) {
+      const trim = line.trim();
+      if (trim.startsWith("#")) {
+        lastComment = trim.replace(/^#+\s?/, "").trim() || void 0;
+        continue;
+      }
+      if (trim === "") {
+        lastComment = void 0;
+        continue;
+      }
+      if (line.startsWith(" ") || line.startsWith("	")) continue;
+      const match = recipeRegex.exec(line);
+      if (!match) {
+        lastComment = void 0;
+        continue;
+      }
+      const recipe = match[1];
+      out.push(makeCommand({
+        title: recipe,
+        command: `just ${recipe}`,
+        cwd: subDir,
+        source: "justfile",
+        sourceFile: file,
+        description: lastComment,
+        category: classifyByName(recipe)
+      }));
+      lastComment = void 0;
+    }
+  }
+  async scanCargo(rootPath, subDir, out) {
+    const file = subDir ? `${subDir}/Cargo.toml` : "Cargo.toml";
+    const abs = (0, import_node_path7.join)(rootPath, file);
+    try {
+      await (0, import_promises5.stat)(abs);
+    } catch {
+      return;
+    }
+    const presets = [
+      { title: "cargo build", command: "cargo build", category: "build", description: "Compile in debug mode" },
+      { title: "cargo build --release", command: "cargo build --release", category: "build", description: "Compile in release mode" },
+      { title: "cargo run", command: "cargo run", category: "dev", description: "Build and run" },
+      { title: "cargo test", command: "cargo test", category: "test", description: "Run all tests" },
+      { title: "cargo check", command: "cargo check", category: "lint", description: "Type-check without producing binary" },
+      { title: "cargo clippy", command: "cargo clippy", category: "lint", description: "Lint with clippy" },
+      { title: "cargo fmt", command: "cargo fmt", category: "lint", description: "Format source" }
+    ];
+    for (const p of presets) {
+      out.push(makeCommand({
+        title: subDir ? `${subDir.split("/").pop()}: ${p.title}` : p.title,
+        command: p.command,
+        cwd: subDir,
+        source: "cargo",
+        sourceFile: file,
+        description: p.description,
+        category: p.category
+      }));
+    }
+  }
+  async scanCompose(rootPath, subDir, out) {
+    for (const name of ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"]) {
+      const file = subDir ? `${subDir}/${name}` : name;
+      try {
+        await (0, import_promises5.stat)((0, import_node_path7.join)(rootPath, file));
+      } catch {
+        continue;
+      }
+      const presets = [
+        { title: "docker compose up", cmd: "docker compose up", cat: "dev", desc: "Start services" },
+        { title: "docker compose up -d", cmd: "docker compose up -d", cat: "dev", desc: "Start services in background" },
+        { title: "docker compose down", cmd: "docker compose down", cat: "other", desc: "Stop and remove services" },
+        { title: "docker compose build", cmd: "docker compose build", cat: "build", desc: "Build service images" },
+        { title: "docker compose logs -f", cmd: "docker compose logs -f", cat: "other", desc: "Tail service logs" }
+      ];
+      for (const p of presets) {
+        out.push(makeCommand({
+          title: p.title,
+          command: p.cmd,
+          cwd: subDir,
+          source: "compose",
+          sourceFile: file,
+          description: p.desc,
+          category: p.cat
+        }));
+      }
+      return;
+    }
+  }
+  async scanReadme(rootPath, fileName, source, out) {
+    const abs = (0, import_node_path7.join)(rootPath, fileName);
+    let raw;
+    try {
+      const s = await (0, import_promises5.stat)(abs);
+      if (s.size > MAX_README_BYTES) return;
+      raw = await (0, import_promises5.readFile)(abs, "utf8");
+    } catch {
+      return;
+    }
+    const fenceRegex = /```(?:bash|sh|shell|zsh)\s*\n([\s\S]*?)```/gi;
+    let match;
+    while ((match = fenceRegex.exec(raw)) !== null) {
+      const block = match[1];
+      const blockLines = block.split("\n");
+      let blockHeading;
+      const beforeText = raw.slice(0, match.index).split("\n").reverse();
+      for (const prev of beforeText) {
+        const t2 = prev.trim();
+        if (t2 === "") continue;
+        const head = /^#{1,6}\s+(.+)$/.exec(t2);
+        if (head) blockHeading = head[1].replace(/[#*`]/g, "").trim();
+        break;
+      }
+      const merged = [];
+      let pending = "";
+      for (const rawLine of blockLines) {
+        if (rawLine.trimEnd().endsWith("\\")) {
+          pending += rawLine.trimEnd().slice(0, -1) + " ";
+          continue;
+        }
+        merged.push(pending + rawLine);
+        pending = "";
+      }
+      if (pending) merged.push(pending);
+      for (const rawLine of merged) {
+        const cmd = sanitizeBashLine(rawLine);
+        if (!cmd) continue;
+        const { command: cleanCmd, inlineComment } = splitInlineComment(cmd);
+        const title = synthesizeTitle(cleanCmd);
+        out.push(makeCommand({
+          title,
+          command: cleanCmd,
+          cwd: "",
+          source,
+          sourceFile: fileName,
+          description: inlineComment ?? blockHeading,
+          category: classifyByCommand(cleanCmd)
+        }));
+      }
+    }
+  }
+};
+function makeCommand(input) {
+  const id = (0, import_node_crypto.createHash)("sha1").update(`${input.source}|${input.sourceFile}|${input.command}|${input.cwd}`).digest("hex").slice(0, 12);
+  return {
+    id,
+    title: input.title,
+    command: input.command,
+    cwd: input.cwd,
+    source: input.source,
+    sourceFile: input.sourceFile,
+    description: input.description,
+    category: input.category ?? classifyByCommand(input.command) ?? "other"
+  };
+}
+function sanitizeBashLine(line) {
+  let l = line.trim();
+  if (!l) return null;
+  if (l.startsWith("#")) return null;
+  l = l.replace(/^[$>]\s*/, "");
+  if (!l) return null;
+  if (/^[A-Z_]+=/.test(l) && !/\s/.test(l)) return null;
+  if (l === "EOF" || l === "EOT") return null;
+  if (l.startsWith("//") || l.startsWith("//#")) return null;
+  if (l.length > 400) return null;
+  if (/<.+>/.test(l) && /your[-_]/.test(l.toLowerCase())) return null;
+  return l;
+}
+function synthesizeTitle(cmd) {
+  let work = cmd;
+  while (/^[A-Z_][A-Z0-9_]*=/.test(work)) {
+    const m = /^[A-Z_][A-Z0-9_]*=(?:"[^"]*"|'[^']*'|\S+)\s+/.exec(work);
+    if (!m) break;
+    work = work.slice(m[0].length);
+  }
+  const cdMatch = /^cd\s+\S+\s*&&\s*(.+)$/.exec(work);
+  if (cdMatch) work = cdMatch[1];
+  const tokens = work.split(/\s+/).filter(Boolean);
+  const head = tokens.slice(0, 3).join(" ");
+  return head.length > 60 ? head.slice(0, 60) + "\u2026" : head;
+}
+function splitInlineComment(line) {
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (ch === "'" && !inDouble) inSingle = !inSingle;
+    else if (ch === '"' && !inSingle) inDouble = !inDouble;
+    else if (ch === "#" && !inSingle && !inDouble && (i === 0 || /\s/.test(line[i - 1]))) {
+      const cmd = line.slice(0, i).trim();
+      const comment = line.slice(i + 1).trim();
+      return { command: cmd, inlineComment: comment.length > 0 ? comment : void 0 };
+    }
+  }
+  return { command: line };
+}
+function classifyByName(name) {
+  const lower = name.toLowerCase();
+  if (/(^|[:_-])(build|compile|bundle|prebuild)([:_-]|$)/.test(lower)) return "build";
+  if (/(^|[:_-])(test|spec|jest|vitest|e2e)([:_-]|$)/.test(lower)) return "test";
+  if (/(^|[:_-])(dev|start|serve|watch|run)([:_-]|$)/.test(lower)) return "dev";
+  if (/(^|[:_-])(lint|format|fmt|check|typecheck)([:_-]|$)/.test(lower)) return "lint";
+  if (/(^|[:_-])(install|setup|init|bootstrap)([:_-]|$)/.test(lower)) return "install";
+  if (/(^|[:_-])(deploy|publish|release|ship)([:_-]|$)/.test(lower)) return "deploy";
+  return void 0;
+}
+function classifyByCommand(cmd) {
+  const lower = cmd.toLowerCase();
+  if (/\b(build|compile|bundle|prebuild|tsup|webpack|esbuild|vite build|next build)\b/.test(lower)) return "build";
+  if (/\b(test|jest|vitest|mocha|pytest|cargo test|go test)\b/.test(lower)) return "test";
+  if (/\b(dev|start|serve|watch|nodemon|tsx watch|next dev|expo start)\b/.test(lower)) return "dev";
+  if (/\b(lint|eslint|tsc|tslint|fmt|format|prettier|clippy)\b/.test(lower)) return "lint";
+  if (/\b(install|setup|bootstrap)\b/.test(lower) && !/\binstall\s+/.test(lower)) return "install";
+  if (/^npm install\b|^pnpm install\b|^yarn install\b|^yarn\s*$|^pnpm\s*$/.test(lower)) return "install";
+  if (/\b(deploy|publish|release)\b/.test(lower)) return "deploy";
+  return "other";
+}
+function categoryWeight(c) {
+  return {
+    dev: 0,
+    build: 1,
+    test: 2,
+    lint: 3,
+    install: 4,
+    deploy: 5,
+    other: 6
+  }[c];
+}
+function sourceWeight(s) {
+  return {
+    "package.json": 0,
+    makefile: 1,
+    justfile: 2,
+    taskfile: 3,
+    cargo: 4,
+    compose: 5,
+    readme: 6,
+    "claude.md": 7
+  }[s];
+}
+
+// src/git/GitExecutor.ts
 var import_node_child_process9 = require("child_process");
+var import_node_util2 = require("util");
+var import_uuid7 = require("uuid");
+var execAsync2 = (0, import_node_util2.promisify)(import_node_child_process9.exec);
+var STATUS_TIMEOUT_MS = 15e3;
+var COMMIT_TIMEOUT_MS = 6e4;
+var PUSH_TIMEOUT_MS = 5 * 60 * 1e3;
+var GitExecutor = class {
+  eventCallbacks = [];
+  onEvent(callback) {
+    this.eventCallbacks.push(callback);
+    return () => {
+      const idx = this.eventCallbacks.indexOf(callback);
+      if (idx !== -1) this.eventCallbacks.splice(idx, 1);
+    };
+  }
+  emit(event) {
+    for (const cb of this.eventCallbacks) {
+      try {
+        cb(event);
+      } catch (err) {
+        console.error("[GitExecutor] Event callback error:", err);
+      }
+    }
+  }
+  async detectStatus(projectPath) {
+    const opts = { cwd: projectPath, timeout: STATUS_TIMEOUT_MS, maxBuffer: 4 * 1024 * 1024 };
+    try {
+      await execAsync2("git rev-parse --is-inside-work-tree", opts);
+    } catch {
+      return { isRepo: false, hasRemote: false, changes: [] };
+    }
+    let root;
+    try {
+      const { stdout } = await execAsync2("git rev-parse --show-toplevel", opts);
+      root = stdout.trim();
+    } catch {
+    }
+    let branch;
+    try {
+      const { stdout } = await execAsync2("git symbolic-ref --short HEAD", opts);
+      branch = stdout.trim();
+    } catch {
+      branch = void 0;
+    }
+    let upstream;
+    try {
+      const { stdout } = await execAsync2("git rev-parse --abbrev-ref --symbolic-full-name @{u}", opts);
+      upstream = stdout.trim();
+    } catch {
+    }
+    let hasRemote = false;
+    try {
+      const { stdout } = await execAsync2("git remote", opts);
+      hasRemote = stdout.trim().length > 0;
+    } catch {
+    }
+    let ahead;
+    let behind;
+    if (upstream) {
+      try {
+        const { stdout } = await execAsync2("git rev-list --left-right --count HEAD...@{u}", opts);
+        const [a, b] = stdout.trim().split(/\s+/);
+        ahead = Number(a);
+        behind = Number(b);
+      } catch {
+      }
+    }
+    const changes = await this.parsePorcelain(projectPath);
+    return {
+      isRepo: true,
+      root,
+      branch,
+      upstream,
+      hasRemote,
+      changes,
+      ahead,
+      behind
+    };
+  }
+  async parsePorcelain(projectPath) {
+    let stdout;
+    try {
+      const r = await execAsync2("git status --porcelain=v1 -z", {
+        cwd: projectPath,
+        timeout: STATUS_TIMEOUT_MS,
+        maxBuffer: 8 * 1024 * 1024
+      });
+      stdout = r.stdout;
+    } catch {
+      return [];
+    }
+    const changes = [];
+    const records = stdout.split("\0");
+    for (let i = 0; i < records.length; i++) {
+      const rec = records[i];
+      if (!rec) continue;
+      if (rec.length < 3) continue;
+      const x = rec.charAt(0);
+      const y = rec.charAt(1);
+      const path2 = rec.slice(3);
+      const isRename = x === "R" || x === "C";
+      if (isRename) {
+        i += 1;
+      }
+      const untracked = x === "?" && y === "?";
+      const staged = !untracked && x !== " " && x !== "?";
+      changes.push({
+        path: path2,
+        staged,
+        untracked,
+        code: `${x}${y}`
+      });
+    }
+    return changes;
+  }
+  /**
+   * 执行 commit（可选连带 push）。
+   * - 若提供 files：先 git add 这些路径
+   * - 若未提供 files：默认 git add -A（提交所有变更）
+   */
+  async commit(sessionId, projectPath, message, files, alsoPush) {
+    const opId = (0, import_uuid7.v4)();
+    this.runSequence(sessionId, opId, "commit", projectPath, [
+      files && files.length > 0 ? ["git", "add", "--", ...files] : ["git", "add", "-A"],
+      ["git", "commit", "-m", message]
+    ], COMMIT_TIMEOUT_MS).then(async (ok) => {
+      if (ok && alsoPush) {
+        await this.runSequence(sessionId, opId, "push", projectPath, [
+          ["git", "push"]
+        ], PUSH_TIMEOUT_MS);
+      }
+    }).catch((err) => {
+      console.error("[GitExecutor] commit error:", err);
+    });
+    return opId;
+  }
+  async push(sessionId, projectPath) {
+    const opId = (0, import_uuid7.v4)();
+    this.runSequence(sessionId, opId, "push", projectPath, [
+      ["git", "push"]
+    ], PUSH_TIMEOUT_MS).catch((err) => {
+      console.error("[GitExecutor] push error:", err);
+    });
+    return opId;
+  }
+  /**
+   * 顺序执行一组命令，任一失败则停止。返回是否全部成功。
+   * 每条命令的输出和最后一条命令的退出事件统一打到同一 phase。
+   */
+  async runSequence(sessionId, opId, phase, projectPath, commands, timeoutMs) {
+    let lastCode = 0;
+    let lastSignal = null;
+    for (const cmd of commands) {
+      const { code, signal } = await this.runOne(sessionId, opId, phase, projectPath, cmd, timeoutMs);
+      lastCode = code;
+      lastSignal = signal;
+      if (code !== 0) break;
+    }
+    this.emit({ type: "git_exit", sessionId, opId, phase, code: lastCode, signal: lastSignal });
+    return lastCode === 0;
+  }
+  runOne(sessionId, opId, phase, projectPath, cmd, timeoutMs) {
+    return new Promise((resolve) => {
+      const display = cmd.map((p) => /\s/.test(p) ? `"${p}"` : p).join(" ");
+      this.emit({
+        type: "git_output",
+        sessionId,
+        opId,
+        phase,
+        stream: "stdout",
+        data: `$ ${display}
+`
+      });
+      let proc;
+      try {
+        proc = (0, import_node_child_process9.spawn)(cmd[0], cmd.slice(1), {
+          cwd: projectPath,
+          stdio: ["ignore", "pipe", "pipe"],
+          env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        this.emit({ type: "git_output", sessionId, opId, phase, stream: "stderr", data: `[spawn error] ${msg}
+` });
+        resolve({ code: 1, signal: null });
+        return;
+      }
+      proc.stdout?.on("data", (chunk) => {
+        this.emit({ type: "git_output", sessionId, opId, phase, stream: "stdout", data: chunk.toString() });
+      });
+      proc.stderr?.on("data", (chunk) => {
+        this.emit({ type: "git_output", sessionId, opId, phase, stream: "stderr", data: chunk.toString() });
+      });
+      proc.on("error", (err) => {
+        this.emit({ type: "git_output", sessionId, opId, phase, stream: "stderr", data: `[error] ${err.message}
+` });
+      });
+      const timer = setTimeout(() => {
+        try {
+          proc.kill("SIGTERM");
+        } catch {
+        }
+      }, timeoutMs);
+      proc.on("exit", (code, signal) => {
+        clearTimeout(timer);
+        resolve({ code, signal });
+      });
+    });
+  }
+};
+
+// src/scheduling/ScheduledSessionManager.ts
+var import_promises6 = require("fs/promises");
+var import_node_os8 = require("os");
+var import_node_path8 = require("path");
+var import_uuid8 = require("uuid");
+var MAX_TIMEOUT_MS = 2147483647;
+var ScheduledSessionManager = class {
+  tasks = /* @__PURE__ */ new Map();
+  storeFile;
+  onFire;
+  onChange;
+  onFired;
+  persistTimer = null;
+  constructor(opts) {
+    this.storeFile = opts.storeFile ?? (0, import_node_path8.join)((0, import_node_os8.homedir)(), ".sessix", "scheduled-sessions.json");
+    this.onFire = opts.onFire;
+    this.onChange = opts.onChange;
+    this.onFired = opts.onFired;
+  }
+  /** 启动时从磁盘恢复任务表，已过期的立刻触发 */
+  async load() {
+    let raw;
+    try {
+      raw = await (0, import_promises6.readFile)(this.storeFile, "utf8");
+    } catch {
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (!Array.isArray(parsed)) return;
+    for (const item of parsed) {
+      if (!isValidTask(item)) continue;
+      this.scheduleTimer(item);
+    }
+  }
+  /** 注册一个定时任务（payload 由调用方校验） */
+  schedule(scheduledAt, payload) {
+    const task = {
+      id: (0, import_uuid8.v4)(),
+      scheduledAt,
+      createdAt: Date.now(),
+      payload
+    };
+    this.scheduleTimer(task);
+    this.persist();
+    this.notifyChange();
+    return task;
+  }
+  /** 取消任务，返回是否成功 */
+  cancel(id) {
+    const entry = this.tasks.get(id);
+    if (!entry) return false;
+    clearTimeout(entry.timer);
+    this.tasks.delete(id);
+    this.persist();
+    this.notifyChange();
+    return true;
+  }
+  /** 列出所有未触发的任务（按时间升序） */
+  list() {
+    return [...this.tasks.values()].map((e) => e.task).sort((a, b) => a.scheduledAt - b.scheduledAt);
+  }
+  /** 优雅关闭（清空定时器，不删除磁盘任务） */
+  destroy() {
+    for (const { timer } of this.tasks.values()) clearTimeout(timer);
+    this.tasks.clear();
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+      this.persistTimer = null;
+    }
+  }
+  // ============================================
+  // 内部
+  // ============================================
+  scheduleTimer(task) {
+    const delay = Math.max(0, task.scheduledAt - Date.now());
+    const armDelay = Math.min(delay, MAX_TIMEOUT_MS);
+    const timer = setTimeout(() => {
+      const remaining = task.scheduledAt - Date.now();
+      if (remaining > 1e3) {
+        this.scheduleTimer(task);
+        return;
+      }
+      this.fire(task).catch((err) => {
+        console.error("[ScheduledSessionManager] fire error:", err);
+      });
+    }, armDelay);
+    this.tasks.set(task.id, { task, timer });
+  }
+  async fire(task) {
+    const entry = this.tasks.get(task.id);
+    if (!entry) return;
+    clearTimeout(entry.timer);
+    this.tasks.delete(task.id);
+    this.persist();
+    this.notifyChange();
+    try {
+      const result = await this.onFire(task);
+      this.onFired?.({ id: task.id, sessionId: result.sessionId });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[ScheduledSessionManager] fire failed for task ${task.id}: ${message}`);
+      this.onFired?.({ id: task.id, error: message });
+    }
+  }
+  notifyChange() {
+    if (!this.onChange) return;
+    this.onChange(this.list());
+  }
+  /** 防抖持久化（500ms） */
+  persist() {
+    if (this.persistTimer) clearTimeout(this.persistTimer);
+    this.persistTimer = setTimeout(() => {
+      this.persistTimer = null;
+      const tasks = [...this.tasks.values()].map((e) => e.task);
+      (0, import_promises6.mkdir)((0, import_node_path8.join)(this.storeFile, ".."), { recursive: true }).then(() => (0, import_promises6.writeFile)(this.storeFile, JSON.stringify(tasks, null, 2), "utf8")).catch((err) => {
+        console.error("[ScheduledSessionManager] persist error:", err);
+      });
+    }, 500);
+  }
+};
+function isValidTask(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  if (typeof v.id !== "string" || typeof v.scheduledAt !== "number" || typeof v.createdAt !== "number") {
+    return false;
+  }
+  const payload = v.payload;
+  if (!payload || typeof payload !== "object") return false;
+  const p = payload;
+  if (p.kind === "create") {
+    return typeof p.projectPath === "string" && typeof p.message === "string";
+  }
+  if (p.kind === "send") {
+    return typeof p.sessionId === "string" && typeof p.message === "string";
+  }
+  return false;
+}
+
+// src/utils/cliCapabilities.ts
+var import_node_child_process10 = require("child_process");
 var DEFAULT_CAPABILITIES = {
   effortLevels: ["low", "medium", "high", "xhigh", "max"]
 };
@@ -4932,7 +6065,7 @@ async function parseCliCapabilities() {
 }
 function runCli(path2, args) {
   return new Promise((resolve) => {
-    (0, import_node_child_process9.execFile)(path2, args, { timeout: 5e3 }, (err, stdout) => {
+    (0, import_node_child_process10.execFile)(path2, args, { timeout: 5e3 }, (err, stdout) => {
       if (err) {
         console.warn(`[CliCapabilities] Failed to run ${path2} ${args.join(" ")}:`, err.message);
         resolve(null);
@@ -4946,11 +6079,11 @@ function runCli(path2, args) {
 // src/server.ts
 var WS_PORT = 3745;
 var HTTP_PORT = 3746;
-var execAsync2 = (0, import_node_util2.promisify)(import_node_child_process10.exec);
+var execAsync3 = (0, import_node_util3.promisify)(import_node_child_process11.exec);
 async function killPortProcess(port) {
   try {
     if (isWindows) {
-      const { stdout } = await execAsync2(
+      const { stdout } = await execAsync3(
         `netstat -ano | findstr :${port} | findstr LISTENING`
       );
       const pids = /* @__PURE__ */ new Set();
@@ -4960,14 +6093,14 @@ async function killPortProcess(port) {
         if (pid && /^\d+$/.test(pid) && pid !== "0") pids.add(pid);
       }
       for (const pid of pids) {
-        await execAsync2(`taskkill /PID ${pid} /F`).catch(() => {
+        await execAsync3(`taskkill /PID ${pid} /F`).catch(() => {
         });
       }
     } else {
-      const { stdout } = await execAsync2(`lsof -ti :${port}`);
+      const { stdout } = await execAsync3(`lsof -ti :${port}`);
       const pids = stdout.trim().split("\n").filter((p) => p && /^\d+$/.test(p));
       if (pids.length > 0) {
-        await execAsync2(`kill -9 ${pids.join(" ")}`);
+        await execAsync3(`kill -9 ${pids.join(" ")}`);
       }
     }
     await new Promise((resolve) => setTimeout(resolve, 600));
@@ -4988,8 +6121,8 @@ async function createWithRetry(label, port, factory) {
   }
 }
 async function start(opts = {}) {
-  const configDir = (0, import_node_path7.join)((0, import_node_os8.homedir)(), ".sessix");
-  const tokenFile = (0, import_node_path7.join)(configDir, "token");
+  const configDir = (0, import_node_path9.join)((0, import_node_os9.homedir)(), ".sessix");
+  const tokenFile = (0, import_node_path9.join)(configDir, "token");
   let token;
   if (opts.token !== void 0) {
     token = opts.token;
@@ -4999,11 +6132,11 @@ async function start(opts = {}) {
       token = envToken;
     } else {
       try {
-        token = (await (0, import_promises5.readFile)(tokenFile, "utf8")).trim();
+        token = (await (0, import_promises7.readFile)(tokenFile, "utf8")).trim();
       } catch {
-        token = (0, import_uuid7.v4)();
-        await (0, import_promises5.mkdir)(configDir, { recursive: true });
-        await (0, import_promises5.writeFile)(tokenFile, token, "utf8");
+        token = (0, import_uuid9.v4)();
+        await (0, import_promises7.mkdir)(configDir, { recursive: true });
+        await (0, import_promises7.writeFile)(tokenFile, token, "utf8");
       }
     }
   }
@@ -5011,6 +6144,9 @@ async function start(opts = {}) {
   const sessionManager = new SessionManager(providerFactory);
   const terminalExecutor = new TerminalExecutor();
   const xcodeBuildExecutor = new XcodeBuildExecutor();
+  const commandDiscovery = new CommandDiscovery();
+  const gitExecutor = new GitExecutor();
+  let scheduledManager = null;
   const approvalProxy = await createWithRetry(
     "ApprovalProxy",
     HTTP_PORT,
@@ -5049,11 +6185,12 @@ async function start(opts = {}) {
   let mdnsService = null;
   const pairingManager = new PairingManager({
     token,
-    serverName: (0, import_node_os8.hostname)(),
+    serverName: (0, import_node_os9.hostname)(),
     version: "0.2.0",
     onStateChange: (state) => mdnsService?.updatePairingState(state)
   });
   approvalProxy.setPairingManager(pairingManager);
+  sessionManager.attachApprovalProxy(approvalProxy);
   const authManager = new AuthManager();
   authManager.on("login_url", (url) => {
     wsBridge.broadcast({ type: "auth_login_url", url });
@@ -5077,6 +6214,49 @@ async function start(opts = {}) {
   const broadcastUnreadSessions = () => {
     wsBridge.broadcast({ type: "unread_sessions", sessionIds: Array.from(unreadSessionIds) });
   };
+  scheduledManager = new ScheduledSessionManager({
+    onFire: async (task) => {
+      const p = task.payload;
+      if (p.kind === "create") {
+        await (0, import_promises7.mkdir)(p.projectPath, { recursive: true });
+        const session = await sessionManager.createSession(
+          p.projectPath,
+          p.message,
+          p.resumeSessionId,
+          p.newSessionId,
+          p.model,
+          p.permissionMode,
+          p.effort,
+          void 0,
+          p.agentType
+        );
+        wsBridge.broadcast({ type: "session_list", sessions: sessionManager.getActiveSessions() });
+        return { sessionId: session.id };
+      }
+      const active = sessionManager.getActiveSessions().find((s) => s.id === p.sessionId);
+      if (active) {
+        await sessionManager.sendMessage(p.sessionId, p.message, p.permissionMode);
+      } else {
+        await sessionManager.createSession(
+          p.projectPath,
+          p.message,
+          p.sessionId,
+          void 0,
+          void 0,
+          p.permissionMode
+        );
+      }
+      wsBridge.broadcast({ type: "session_list", sessions: sessionManager.getActiveSessions() });
+      return { sessionId: p.sessionId };
+    },
+    onChange: (tasks) => {
+      wsBridge.broadcast({ type: "scheduled_session_list", tasks });
+    },
+    onFired: (event) => {
+      wsBridge.broadcast({ type: "scheduled_session_fired", ...event });
+    }
+  });
+  await scheduledManager.load();
   wsBridge.onConnection(async (ws) => {
     const result = await getProjects();
     if (result.ok) {
@@ -5098,12 +6278,15 @@ async function start(opts = {}) {
     if (cliCapabilities) {
       wsBridge.send(ws, { type: "cli_info", effortLevels: cliCapabilities.effortLevels, version: cliCapabilities.version });
     }
+    if (scheduledManager) {
+      wsBridge.send(ws, { type: "scheduled_session_list", tasks: scheduledManager.list() });
+    }
   });
   wsBridge.onClientEvent(async (event, ws) => {
     try {
       switch (event.type) {
         case "create_session": {
-          await (0, import_promises5.mkdir)(event.projectPath, { recursive: true });
+          await (0, import_promises7.mkdir)(event.projectPath, { recursive: true });
           const resumeId = event.resumeSessionId ?? event.newSessionId;
           if (resumeId) sessionFileWatcher.unwatch(resumeId);
           await sessionManager.createSession(
@@ -5291,7 +6474,7 @@ async function start(opts = {}) {
             if (!isStreaming) {
               const filePath = getSessionFilePath(event.projectPath, event.sessionId);
               try {
-                const fileStat = await (0, import_promises6.stat)(filePath);
+                const fileStat = await (0, import_promises8.stat)(filePath);
                 sessionFileWatcher.watch(event.sessionId, filePath, fileStat.size);
               } catch {
               }
@@ -5454,6 +6637,66 @@ async function start(opts = {}) {
           xcodeBuildExecutor.killInstall(event.installId);
           break;
         }
+        case "schedule_session": {
+          if (!scheduledManager) break;
+          const scheduledAt = Number(event.scheduledAt);
+          if (!Number.isFinite(scheduledAt)) {
+            wsBridge.send(ws, { type: "error", code: "INVALID_MESSAGE", message: "Invalid scheduledAt" });
+            break;
+          }
+          scheduledManager.schedule(scheduledAt, event.payload);
+          break;
+        }
+        case "cancel_scheduled_session": {
+          scheduledManager?.cancel(event.id);
+          break;
+        }
+        case "list_scheduled_sessions": {
+          if (scheduledManager) {
+            wsBridge.send(ws, { type: "scheduled_session_list", tasks: scheduledManager.list() });
+          }
+          break;
+        }
+        case "git_status": {
+          const status = await gitExecutor.detectStatus(event.projectPath);
+          wsBridge.send(ws, { type: "git_status_result", sessionId: event.sessionId, status });
+          break;
+        }
+        case "git_commit": {
+          await gitExecutor.commit(
+            event.sessionId,
+            event.projectPath,
+            event.message,
+            event.files,
+            event.alsoPush
+          );
+          break;
+        }
+        case "git_push": {
+          await gitExecutor.push(event.sessionId, event.projectPath);
+          break;
+        }
+        case "list_project_commands": {
+          try {
+            const commands = await commandDiscovery.scan(event.projectPath, event.refresh ?? false);
+            wsBridge.send(ws, {
+              type: "commands_result",
+              sessionId: event.sessionId,
+              projectPath: event.projectPath,
+              commands
+            });
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            wsBridge.send(ws, {
+              type: "commands_result",
+              sessionId: event.sessionId,
+              projectPath: event.projectPath,
+              commands: [],
+              error: message
+            });
+          }
+          break;
+        }
         default: {
           wsBridge.send(ws, {
             type: "error",
@@ -5492,6 +6735,9 @@ async function start(opts = {}) {
   xcodeBuildExecutor.onEvent((event) => {
     wsBridge.broadcast(event);
   });
+  gitExecutor.onEvent((event) => {
+    wsBridge.broadcast(event);
+  });
   wsBridge.onDisconnect(() => {
     if (wsBridge.getConnectionCount() === 0 && approvalProxy.getPendingCount() > 0) {
       approvalProxy.approveAll(t("server.phoneDisconnected"));
@@ -5581,6 +6827,42 @@ async function start(opts = {}) {
     console.error(`[Server] ${t("server.hookInstallFailed")}`, err);
     console.log(`[Server] ${t("server.hookContinue")}`);
   }
+  const idleTimeoutMs = Number(process.env.SESSIX_IDLE_TIMEOUT_MS ?? 30 * 60 * 1e3);
+  const idleSweepIntervalMs = Number(process.env.SESSIX_IDLE_SWEEP_INTERVAL_MS ?? 5 * 60 * 1e3);
+  const maxActiveProcesses = Number(process.env.SESSIX_MAX_ACTIVE_PROCESSES ?? 15);
+  let idleSweepTimer = null;
+  if (idleSweepIntervalMs > 0 && (idleTimeoutMs > 0 || maxActiveProcesses > 0)) {
+    idleSweepTimer = setInterval(async () => {
+      try {
+        let totalSwept = 0;
+        const broadcastShrink = (sessionId) => {
+          sessionManager.shrinkSessionBuffer(sessionId, 100);
+        };
+        for (const agentType of ["claude-code", "codex"]) {
+          const provider = providerFactory.getProvider(agentType);
+          if (idleTimeoutMs > 0 && typeof provider.sweepIdleProcesses === "function") {
+            const swept = await provider.sweepIdleProcesses(idleTimeoutMs);
+            swept.forEach(broadcastShrink);
+            totalSwept += swept.length;
+          }
+          if (maxActiveProcesses > 0 && typeof provider.sweepLruProcesses === "function") {
+            const swept = await provider.sweepLruProcesses(maxActiveProcesses);
+            swept.forEach(broadcastShrink);
+            totalSwept += swept.length;
+          }
+        }
+        if (totalSwept > 0) {
+          console.log(`[Server] Idle GC: swept ${totalSwept} idle session(s)`);
+          wsBridge.broadcast({
+            type: "session_list",
+            sessions: sessionManager.getActiveSessions()
+          });
+        }
+      } catch (err) {
+        console.error("[Server] Idle GC failed:", err);
+      }
+    }, idleSweepIntervalMs);
+  }
   const stop = async () => {
     console.log(`[Server] ${t("server.shuttingDown")}`);
     const errors = [];
@@ -5592,6 +6874,7 @@ async function start(opts = {}) {
         errors.push(err);
       }
     };
+    if (idleSweepTimer) clearInterval(idleSweepTimer);
     await attempt(() => authManager.destroy(), "AuthManager");
     await attempt(() => stopMdns(), "mDNS");
     await attempt(() => pairingManager.destroy(), "PairingManager");
@@ -5602,6 +6885,7 @@ async function start(opts = {}) {
     await attempt(() => xcodeBuildExecutor.destroy(), "XcodeBuildExecutor");
     await attempt(() => notificationService.destroy(), "NotificationService");
     await attempt(() => sessionFileWatcher.destroy(), "SessionFileWatcher");
+    await attempt(() => scheduledManager?.destroy(), "ScheduledSessionManager");
     if (errors.length > 0) {
       console.error(`[Server] ${t("server.shutdownWithErrors", { count: errors.length })}`);
       throw errors[0];
@@ -5628,9 +6912,9 @@ async function start(opts = {}) {
     openPairing: (duration) => pairingManager.open(duration),
     closePairing: () => pairingManager.close(),
     regenerateToken: async () => {
-      const newToken = (0, import_uuid7.v4)();
-      await (0, import_promises5.mkdir)(configDir, { recursive: true });
-      await (0, import_promises5.writeFile)(tokenFile, newToken, "utf8");
+      const newToken = (0, import_uuid9.v4)();
+      await (0, import_promises7.mkdir)(configDir, { recursive: true });
+      await (0, import_promises7.writeFile)(tokenFile, newToken, "utf8");
       instance.token = newToken;
       wsBridge.updateToken(newToken);
       approvalProxy.updateToken(newToken);