sessix-server 0.4.2 → 0.4.5

package/dist/index.js

@@ -24,10 +24,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var import_node_os9 = require("os");
+var import_node_os10 = require("os");
 var import_node_fs4 = require("fs");
-var import_node_path8 = require("path");
-var import_node_child_process11 = require("child_process");
+var import_node_path10 = require("path");
+var import_node_child_process13 = require("child_process");
 
 // src/i18n/locales/zh.ts
 var zh = {
@@ -302,12 +302,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_process12 = require("child_process");
+var import_node_util3 = require("util");
 
 // src/providers/ProcessProvider.ts
 var import_child_process = require("child_process");
@@ -538,6 +538,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;
+  }
   // ============================================
   // 私有方法
   // ============================================
@@ -591,7 +662,24 @@ var ProcessProvider = class {
   writeUserMessage(proc, message, sessionId, images) {
     const content = [];
     if (images?.length) {
-      for (const img of images) {
+      const ALLOWED_TYPES = /* @__PURE__ */ new Set(["image/jpeg", "image/png", "image/webp", "image/gif"]);
+      const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+      for (let i = 0; i < images.length; i++) {
+        const img = images[i];
+        if (!ALLOWED_TYPES.has(img.media_type)) {
+          if (sessionId) {
+            this.emitWriteError(sessionId, `Image #${i + 1} rejected: unsupported media_type "${img.media_type}". Only JPEG/PNG/WebP/GIF are accepted.`);
+          }
+          return;
+        }
+        const sizeBytes = Math.floor(img.data.length * 0.75);
+        if (sizeBytes > MAX_IMAGE_BYTES) {
+          if (sessionId) {
+            const sizeMb = (sizeBytes / (1024 * 1024)).toFixed(1);
+            this.emitWriteError(sessionId, `Image #${i + 1} rejected: ${sizeMb}MB exceeds 5MB per-image limit.`);
+          }
+          return;
+        }
         content.push({
           type: "image",
           source: { type: "base64", media_type: img.media_type, data: img.data }
@@ -618,6 +706,14 @@ var ProcessProvider = class {
         this.emitWriteError(sessionId, `Failed to send message: ${err.message}`);
       }
     });
+    if (sessionId) {
+      const syntheticUser = {
+        type: "user",
+        session_id: sessionId,
+        message: { role: "user", content }
+      };
+      this.emitter.emit(this.getEventName(sessionId), syntheticUser);
+    }
   }
   /**
    * 发出写入失败的合成错误事件
@@ -1765,6 +1861,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 补全历史）
    */
@@ -3625,6 +3735,8 @@ var HookInstaller = class {
 
 // src/notification/NotificationService.ts
 var import_node_path5 = require("path");
+var RECENT_ACTIVITY_MAX = 6;
+var ACTIVITY_PUSH_THROTTLE_MS = 2500;
 var NotificationService = class {
   constructor(sessionManager, expoChannel = null) {
     this.sessionManager = sessionManager;
@@ -3643,6 +3755,14 @@ var NotificationService = class {
   latestAssistantText = /* @__PURE__ */ new Map();
   /** 获取全局待审批总数的回调（跨所有会话） */
   globalPendingCountProvider = null;
+  /** sessionId → 最近活动状态（用于 LA content push） */
+  recentActivityState = /* @__PURE__ */ new Map();
+  /** sessionId → 节流定时器（LA content push） */
+  activityPushTimers = /* @__PURE__ */ new Map();
+  /** 上次推送 LA content 的时间戳（用于节流；首次立即推送） */
+  lastActivityPushAt = /* @__PURE__ */ new Map();
+  /** 提供器：根据 sessionId 取该会话的待审批列表（由 server.ts 注入） */
+  pendingApprovalsProvider = null;
   /** 添加通知渠道（id 唯一，可用于后续动态开关） */
   addChannel(id, channel, enabled = true) {
     this.channelMap.set(id, { channel, enabled });
@@ -3670,11 +3790,24 @@ var NotificationService = class {
   }
   /** 注册 ActivityKit push token（由手机端启动 Live Activity 后上报） */
   addActivityPushToken(sessionId, token) {
-    this.activityPushChannel?.addToken(sessionId, token);
+    if (!this.activityPushChannel) {
+      console.warn(`[NotificationService] \u26A0\uFE0F  \u6536\u5230 LA push token \u4F46 ActivityPushChannel \u672A\u521D\u59CB\u5316 (session=${sessionId.slice(0, 8)}\u2026) \u2014 \u68C0\u67E5 ~/.sessix/apns.json`);
+      return;
+    }
+    this.activityPushChannel.addToken(sessionId, token);
+    console.log(`[NotificationService] \u2705 LA push token \u5DF2\u6CE8\u518C (session=${sessionId.slice(0, 8)}\u2026, token=${token.slice(0, 16)}\u2026)`);
+    this.scheduleActivityPush(sessionId, true);
   }
   /** 移除 ActivityKit push token */
   removeActivityPushToken(sessionId) {
     this.activityPushChannel?.removeToken(sessionId);
+    this.clearActivityPushTimer(sessionId);
+    this.recentActivityState.delete(sessionId);
+    this.lastActivityPushAt.delete(sessionId);
+  }
+  /** 注入"会话 → 待审批列表"提供器（server.ts 启动时调用） */
+  setPendingApprovalsProvider(fn) {
+    this.pendingApprovalsProvider = fn;
   }
   /** 设置全局待审批总数提供者 */
   setGlobalPendingCountProvider(provider) {
@@ -3697,12 +3830,15 @@ var NotificationService = class {
     if (this.activityPushChannel?.hasToken(request.sessionId)) {
       const dangerLevel2 = this.getDangerLevel(request.toolName);
       const isYoloMode = this.getYoloMode(request.sessionId);
+      const recentActivity = this.getRecentActivity(request.sessionId);
+      const latestMessage = recentActivity[recentActivity.length - 1] ?? "";
       this.activityPushChannel.updateActivityWithAlert(
         request.sessionId,
         {
           status: "waitingApproval",
           sessionTitle,
-          latestMessage: "",
+          latestMessage,
+          recentActivity,
           approvalInfo: {
             requestId: request.id,
             toolName: request.toolName,
@@ -3715,6 +3851,7 @@ var NotificationService = class {
         },
         { title, body }
       );
+      this.lastActivityPushAt.set(request.sessionId, Date.now());
       return;
     }
     const dangerLevel = this.getDangerLevel(request.toolName);
@@ -3748,17 +3885,20 @@ var NotificationService = class {
     const body = `\u2753 ${request.question.slice(0, 80)}`;
     if (this.activityPushChannel?.hasToken(request.sessionId)) {
       const isYoloMode = this.getYoloMode(request.sessionId);
+      const recentActivity = this.getRecentActivity(request.sessionId);
       this.activityPushChannel.updateActivityWithAlert(
         request.sessionId,
         {
           status: "waitingApproval",
           sessionTitle,
           latestMessage: request.question.slice(0, 80),
+          recentActivity,
           isYoloMode,
           updatedAt: Date.now()
         },
         { title: sessionTitle, body }
       );
+      this.lastActivityPushAt.set(request.sessionId, Date.now());
       return;
     }
     this.notify({
@@ -3792,6 +3932,10 @@ var NotificationService = class {
     this.unsubscribe = null;
     this.yoloModeState.clear();
     this.latestAssistantText.clear();
+    for (const timer of this.activityPushTimers.values()) clearTimeout(timer);
+    this.activityPushTimers.clear();
+    this.recentActivityState.clear();
+    this.lastActivityPushAt.clear();
   }
   // ============================================
   // 内部方法
@@ -3800,15 +3944,20 @@ var NotificationService = class {
     switch (event.type) {
       case "claude_event": {
         this.trackAssistantText(event.sessionId, event.event);
+        this.updateRecentActivity(event.sessionId, event.event);
+        this.scheduleActivityPush(event.sessionId);
         break;
       }
       case "claude_events": {
         for (const e of event.events) {
           this.trackAssistantText(event.sessionId, e);
+          this.updateRecentActivity(event.sessionId, e);
         }
+        this.scheduleActivityPush(event.sessionId);
         break;
       }
       case "status_change": {
+        this.clearActivityPushTimer(event.sessionId);
         if (event.status === "idle") {
           const sessionTitle = this.getSessionTitle(event.sessionId);
           const latestMsg = this.latestAssistantText.get(event.sessionId);
@@ -3819,9 +3968,12 @@ var NotificationService = class {
               status: "idle",
               sessionTitle,
               latestMessage: body,
+              recentActivity: this.getRecentActivity(event.sessionId),
               isYoloMode,
               updatedAt: Date.now()
             });
+            this.recentActivityState.delete(event.sessionId);
+            this.lastActivityPushAt.delete(event.sessionId);
           } else {
             this.notify({
               title: sessionTitle,
@@ -3841,9 +3993,12 @@ var NotificationService = class {
               status: "error",
               sessionTitle,
               latestMessage: body,
+              recentActivity: this.getRecentActivity(event.sessionId),
               isYoloMode,
               updatedAt: Date.now()
             });
+            this.recentActivityState.delete(event.sessionId);
+            this.lastActivityPushAt.delete(event.sessionId);
           } else {
             this.notify({
               title: sessionTitle,
@@ -3885,6 +4040,229 @@ var NotificationService = class {
   getYoloMode(sessionId) {
     return this.yoloModeState.get(sessionId) ?? false;
   }
+  // ============================================
+  // Live Activity 内容推送（后台 LA 实时刷新）
+  // ============================================
+  /**
+   * 把一个 ClaudeStreamEvent 折算到 recentActivity 列表里。
+   * 同一 message.id 内多次 assistant 事件视为流式更新，整段重建 currentEntries；
+   * 切换 message.id 视为新 turn，旧条目沉淀到 history。
+   */
+  updateRecentActivity(sessionId, event) {
+    if (event.type === "result") {
+      const state2 = this.recentActivityState.get(sessionId);
+      if (state2 && state2.currentEntries.length > 0) {
+        state2.history.push(...state2.currentEntries);
+        while (state2.history.length > RECENT_ACTIVITY_MAX) state2.history.shift();
+        state2.currentEntries = [];
+        state2.currentMessageId = null;
+      }
+      return;
+    }
+    if (event.type !== "assistant") return;
+    const msg = event.message;
+    if (!Array.isArray(msg.content)) return;
+    let state = this.recentActivityState.get(sessionId);
+    if (!state) {
+      state = { history: [], currentMessageId: null, currentEntries: [] };
+      this.recentActivityState.set(sessionId, state);
+    }
+    if (state.currentMessageId !== msg.id) {
+      if (state.currentEntries.length > 0) {
+        state.history.push(...state.currentEntries);
+        while (state.history.length > RECENT_ACTIVITY_MAX) state.history.shift();
+      }
+      state.currentEntries = [];
+      state.currentMessageId = msg.id;
+    }
+    const next = [];
+    for (const block of msg.content) {
+      if (block.type === "text") {
+        const line = this.summarizeText(block.text);
+        if (line.length >= 4) next.push(line);
+      } else if (block.type === "tool_use") {
+        const line = this.summarizeToolCall(block.name, block.input ?? {});
+        if (line) next.push(line);
+      }
+    }
+    state.currentEntries = next;
+  }
+  /** 取该会话当前的 recentActivity（history + currentEntries），保留末尾 N 条 */
+  getRecentActivity(sessionId) {
+    const state = this.recentActivityState.get(sessionId);
+    if (!state) return [];
+    const combined = [...state.history, ...state.currentEntries];
+    return combined.slice(-RECENT_ACTIVITY_MAX);
+  }
+  /** 节流调度 LA content push；首次立即推，后续合并到 throttle window 末尾 */
+  scheduleActivityPush(sessionId, force = false) {
+    if (!this.activityPushChannel?.hasToken(sessionId)) return;
+    const now = Date.now();
+    const last = this.lastActivityPushAt.get(sessionId) ?? 0;
+    const elapsed = now - last;
+    if (force || elapsed >= ACTIVITY_PUSH_THROTTLE_MS) {
+      this.clearActivityPushTimer(sessionId);
+      this.flushActivityPush(sessionId);
+      return;
+    }
+    if (this.activityPushTimers.has(sessionId)) return;
+    const wait = ACTIVITY_PUSH_THROTTLE_MS - elapsed;
+    this.activityPushTimers.set(
+      sessionId,
+      setTimeout(() => {
+        this.activityPushTimers.delete(sessionId);
+        this.flushActivityPush(sessionId);
+      }, wait)
+    );
+  }
+  clearActivityPushTimer(sessionId) {
+    const timer = this.activityPushTimers.get(sessionId);
+    if (timer) {
+      clearTimeout(timer);
+      this.activityPushTimers.delete(sessionId);
+    }
+  }
+  /** 真正发送一次 LA content push（无 alert） */
+  flushActivityPush(sessionId) {
+    const channel = this.activityPushChannel;
+    if (!channel?.hasToken(sessionId)) return;
+    const session = this.sessionManager.getActiveSessions().find((s) => s.id === sessionId);
+    if (!session) return;
+    const recentActivity = this.getRecentActivity(sessionId);
+    const latestMessage = recentActivity[recentActivity.length - 1] ?? this.latestAssistantText.get(sessionId) ?? "";
+    const sessionTitle = this.getSessionTitle(sessionId);
+    const isYoloMode = this.getYoloMode(sessionId);
+    const pendingApprovals = this.pendingApprovalsProvider?.(sessionId) ?? [];
+    const latestApproval = pendingApprovals[pendingApprovals.length - 1];
+    const status = latestApproval ? "waitingApproval" : this.mapSessionStatus(session.status);
+    const contentState = {
+      status,
+      sessionTitle,
+      latestMessage,
+      recentActivity,
+      isYoloMode,
+      updatedAt: Date.now()
+    };
+    if (latestApproval) {
+      contentState.approvalInfo = {
+        requestId: latestApproval.id,
+        toolName: latestApproval.toolName,
+        description: String(latestApproval.description ?? "").slice(0, 80),
+        dangerLevel: this.getDangerLevel(latestApproval.toolName),
+        pendingCount: pendingApprovals.length
+      };
+    }
+    if (session.stats) {
+      contentState.stats = {
+        totalInputTokens: session.stats.totalInputTokens,
+        totalOutputTokens: session.stats.totalOutputTokens,
+        totalCostUsd: session.stats.totalCostUsd
+      };
+    }
+    this.lastActivityPushAt.set(sessionId, Date.now());
+    const lineCount = recentActivity.length;
+    channel.updateActivity(sessionId, contentState).then(() => {
+      console.log(`[NotificationService] \u{1F4E1} LA push \u2713 session=${sessionId.slice(0, 8)}\u2026 status=${status} lines=${lineCount}`);
+    }).catch((err) => {
+      console.warn(`[NotificationService] \u{1F4E1} LA push \u2717 session=${sessionId.slice(0, 8)}\u2026:`, err instanceof Error ? err.message : err);
+    });
+  }
+  /** SessionStatus → LiveActivity status 字符串映射（与客户端 mapStatus 一致） */
+  mapSessionStatus(status) {
+    switch (status) {
+      case "running":
+        return "running";
+      case "waiting_approval":
+        return "waitingApproval";
+      case "waiting_question":
+        return "waitingQuestion";
+      case "idle":
+        return "completed";
+      case "completed":
+        return "completed";
+      case "error":
+        return "error";
+      default:
+        return "idle";
+    }
+  }
+  /** 文本块清洗：去多余空白 + 截断到 70 字符 */
+  summarizeText(raw) {
+    if (typeof raw !== "string") return "";
+    const cleaned = raw.replace(/\s+/g, " ").trim();
+    return cleaned.length > 70 ? cleaned.slice(0, 70) + "\u2026" : cleaned;
+  }
+  /** 工具调用摘要（与客户端 summarizeToolCall 行为对齐，简化版只输出中文） */
+  summarizeToolCall(name, input) {
+    const str = (v) => typeof v === "string" ? v : "";
+    const baseName = (p) => {
+      const cleaned = p.split(/[?#]/)[0];
+      const parts = cleaned.split("/");
+      return parts[parts.length - 1] || cleaned;
+    };
+    const trunc = (s, n) => s.length > n ? s.slice(0, n) + "\u2026" : s;
+    switch (name) {
+      case "Bash": {
+        const cmd = str(input.command).split("\n")[0];
+        return cmd ? `\u8FD0\u884C: ${trunc(cmd, 60)}` : "\u6267\u884C\u547D\u4EE4";
+      }
+      case "Edit": {
+        const fp = baseName(str(input.file_path));
+        return fp ? `\u7F16\u8F91 ${fp}` : "\u7F16\u8F91\u6587\u4EF6";
+      }
+      case "MultiEdit": {
+        const fp = baseName(str(input.file_path));
+        return fp ? `\u6279\u91CF\u7F16\u8F91 ${fp}` : "\u6279\u91CF\u7F16\u8F91\u6587\u4EF6";
+      }
+      case "Write": {
+        const fp = baseName(str(input.file_path));
+        return fp ? `\u5199\u5165 ${fp}` : "\u5199\u5165\u6587\u4EF6";
+      }
+      case "Read":
+      case "NotebookEdit": {
+        const fp = baseName(str(input.file_path) || str(input.notebook_path));
+        return fp ? `\u9605\u8BFB ${fp}` : "\u9605\u8BFB\u6587\u4EF6";
+      }
+      case "Grep": {
+        const p = str(input.pattern);
+        return p ? `\u641C\u7D22: ${trunc(p, 50)}` : "\u641C\u7D22\u4EE3\u7801";
+      }
+      case "Glob": {
+        const p = str(input.pattern);
+        return p ? `\u67E5\u627E: ${trunc(p, 50)}` : "\u67E5\u627E\u6587\u4EF6";
+      }
+      case "WebFetch": {
+        const url = str(input.url);
+        let host = url;
+        try {
+          host = new URL(url).hostname;
+        } catch {
+        }
+        return host ? `\u8BF7\u6C42 ${trunc(host, 50)}` : "\u8BF7\u6C42\u7F51\u9875";
+      }
+      case "WebSearch": {
+        const q = str(input.query);
+        return q ? `\u641C\u7D22\u7F51\u9875: ${trunc(q, 50)}` : "\u641C\u7D22\u7F51\u9875";
+      }
+      case "TodoWrite":
+        return "\u66F4\u65B0\u4EFB\u52A1\u6E05\u5355";
+      case "Task":
+      case "Agent": {
+        const desc = str(input.description) || str(input.subagent_type);
+        return desc ? `\u6D3E\u53D1\u4EFB\u52A1: ${trunc(desc, 50)}` : "\u6D3E\u53D1\u5B50\u4EFB\u52A1";
+      }
+      case "ExitPlanMode":
+        return "\u63D0\u4EA4\u8BA1\u5212";
+      case "Skill": {
+        const skill = str(input.skill);
+        return skill ? `\u8C03\u7528\u6280\u80FD: ${trunc(skill, 40)}` : "\u8C03\u7528\u6280\u80FD";
+      }
+      default: {
+        const summary = trunc(JSON.stringify(input), 50);
+        return name ? `${name}: ${summary}` : summary;
+      }
+    }
+  }
 };
 
 // src/notification/DesktopNotificationChannel.ts
@@ -3998,62 +4376,82 @@ var ExpoNotificationChannel = class {
 var http2 = __toESM(require("http2"));
 var fs2 = __toESM(require("fs"));
 var crypto = __toESM(require("crypto"));
+var APNS_HOSTS = {
+  production: "api.push.apple.com",
+  sandbox: "api.sandbox.push.apple.com"
+};
 var ActivityPushChannel = class {
   /** sessionId -> activityPushToken */
   tokens = /* @__PURE__ */ new Map();
+  /**
+   * 每个 token 已确认工作的 APNs 环境。
+   * Debug build (aps-environment=development) 的 token 仅在 sandbox 端有效；
+   * Release build (aps-environment=production) 的 token 仅在 production 端有效。
+   * 同时维护两个连接 + 探测机制，避免环境配错时静默失败。
+   */
+  tokenEnv = /* @__PURE__ */ new Map();
+  /** 首次探测顺序（来自配置 hint），未配置则先试 sandbox（开发场景占多数） */
+  probeOrder;
   teamId;
   keyId;
   authKey;
-  apnsHost;
   /** 缓存的 JWT token + 过期时间 */
   cachedJwt = null;
-  /** 复用的 HTTP/2 长连接 */
-  http2Client = null;
+  /** 每个环境一条 HTTP/2 长连接 */
+  http2Clients = {};
   constructor(config) {
     this.teamId = config.teamId;
     this.keyId = config.keyId;
     this.authKey = fs2.readFileSync(config.authKeyPath, "utf-8");
-    this.apnsHost = config.sandbox ? "api.sandbox.push.apple.com" : "api.push.apple.com";
-    console.log(`[ActivityPushChannel] Initialized (${config.sandbox ? "sandbox" : "production"} mode)`);
-  }
-  /** 获取或新建 HTTP/2 长连接 */
-  getHttp2Client() {
-    if (this.http2Client && !this.http2Client.destroyed && !this.http2Client.closed) {
-      return this.http2Client;
-    }
-    this.http2Client = http2.connect(`https://${this.apnsHost}`);
-    this.http2Client.on("error", (err) => {
-      console.warn("[ActivityPushChannel] HTTP/2 connection error, will reconnect on next request:", err.message);
-      this.http2Client?.destroy();
-      this.http2Client = null;
+    this.probeOrder = config.sandbox === false ? ["production", "sandbox"] : ["sandbox", "production"];
+    console.log(`[ActivityPushChannel] Initialized (probe order: ${this.probeOrder.join(" \u2192 ")})`);
+  }
+  /** 获取或新建指定环境的 HTTP/2 长连接 */
+  getHttp2Client(env) {
+    const existing = this.http2Clients[env];
+    if (existing && !existing.destroyed && !existing.closed) {
+      return existing;
+    }
+    const client = http2.connect(`https://${APNS_HOSTS[env]}`);
+    client.on("error", (err) => {
+      console.warn(`[ActivityPushChannel] HTTP/2 (${env}) error, will reconnect on next request:`, err.message);
+      client.destroy();
+      if (this.http2Clients[env] === client) delete this.http2Clients[env];
     });
-    this.http2Client.on("close", () => {
-      this.http2Client = null;
+    client.on("close", () => {
+      if (this.http2Clients[env] === client) delete this.http2Clients[env];
     });
-    return this.http2Client;
+    this.http2Clients[env] = client;
+    return client;
   }
   /** 注册 Activity push token */
   addToken(sessionId, token) {
+    const existed = this.tokens.has(sessionId);
     this.tokens.set(sessionId, token);
-    console.log(`[ActivityPushChannel] Token registered: session=${sessionId}`);
+    console.log(`[ActivityPushChannel] Token ${existed ? "updated" : "registered"}: session=${sessionId.slice(0, 8)}\u2026 token=${token.slice(0, 16)}\u2026`);
   }
   /** 移除 Activity push token */
   removeToken(sessionId) {
+    const tok = this.tokens.get(sessionId);
     this.tokens.delete(sessionId);
+    if (tok) this.tokenEnv.delete(tok);
   }
-  /** 发送 content-state 更新到指定会话的 Live Activity */
+  /** 发送 content-state 更新到指定会话的 Live Activity（纯内容刷新，不响通知） */
   async updateActivity(sessionId, contentState) {
     const token = this.tokens.get(sessionId);
     if (!token) return;
+    const now = Math.floor(Date.now() / 1e3);
     const payload = {
       aps: {
-        timestamp: Math.floor(Date.now() / 1e3),
+        timestamp: now,
         event: "update",
-        "content-state": contentState
+        "content-state": contentState,
+        // 2 分钟没新内容就让 LA 进入 stale 状态（系统自动灰化），避免显示陈旧数据
+        "stale-date": now + 120
       }
     };
     try {
-      await this.sendToAPNs(token, payload);
+      await this.sendToAPNs(token, payload, { priority: "5" });
     } catch (err) {
       console.warn(`[ActivityPushChannel] Update failed session=${sessionId}:`, err);
     }
@@ -4062,17 +4460,19 @@ var ActivityPushChannel = class {
   async updateActivityWithAlert(sessionId, contentState, alert) {
     const token = this.tokens.get(sessionId);
     if (!token) return;
+    const now = Math.floor(Date.now() / 1e3);
     const payload = {
       aps: {
-        timestamp: Math.floor(Date.now() / 1e3),
+        timestamp: now,
         event: "update",
         "content-state": contentState,
+        "stale-date": now + 120,
         alert,
         sound: "default"
       }
     };
     try {
-      await this.sendToAPNs(token, payload);
+      await this.sendToAPNs(token, payload, { priority: "10" });
     } catch (err) {
       console.warn(`[ActivityPushChannel] Alert update failed session=${sessionId}:`, err);
     }
@@ -4081,15 +4481,16 @@ var ActivityPushChannel = class {
   async endActivity(sessionId, contentState) {
     const token = this.tokens.get(sessionId);
     if (!token) return;
+    const now = Math.floor(Date.now() / 1e3);
     const payload = {
       aps: {
-        timestamp: Math.floor(Date.now() / 1e3),
+        timestamp: now,
         event: "end",
         "content-state": contentState
       }
     };
     try {
-      await this.sendToAPNs(token, payload);
+      await this.sendToAPNs(token, payload, { priority: "10" });
     } catch (err) {
       console.warn(`[ActivityPushChannel] End failed session=${sessionId}:`, err);
     }
@@ -4099,15 +4500,44 @@ var ActivityPushChannel = class {
   hasToken(sessionId) {
     return this.tokens.has(sessionId);
   }
-  /** 发送 APNs HTTP/2 请求 */
-  async sendToAPNs(deviceToken, payload) {
+  /**
+   * 发送 APNs，自动处理环境探测。
+   * 对每个 token：先用已确认的环境（如有）；否则按 probeOrder 顺序探测，
+   * 收到 BadDeviceToken 自动切到另一个环境，并把成功的环境绑定到该 token。
+   */
+  async sendToAPNs(deviceToken, payload, opts = {}) {
+    const known = this.tokenEnv.get(deviceToken);
+    if (known) {
+      return this.sendToAPNsOnce(deviceToken, payload, opts, known);
+    }
+    let lastErr = null;
+    for (const env of this.probeOrder) {
+      try {
+        await this.sendToAPNsOnce(deviceToken, payload, opts, env);
+        this.tokenEnv.set(deviceToken, env);
+        if (env !== this.probeOrder[0]) {
+          console.log(`[ActivityPushChannel] Token bound to ${env} after probe (token=${deviceToken.slice(0, 16)}\u2026)`);
+        }
+        return;
+      } catch (err) {
+        lastErr = err;
+        if (!isBadDeviceTokenError(err)) {
+          throw err;
+        }
+      }
+    }
+    throw lastErr ?? new Error("APNs send failed: all environments rejected token");
+  }
+  /** 单次 APNs HTTP/2 请求（内部 helper，不做探测） */
+  async sendToAPNsOnce(deviceToken, payload, opts, env) {
     const topic = "com.kachun.sessix.push-type.liveactivity";
     const jwt = this.getJWT();
     const payloadStr = JSON.stringify(payload);
+    const priority = opts.priority ?? "10";
     return new Promise((resolve, reject) => {
       let client;
       try {
-        client = this.getHttp2Client();
+        client = this.getHttp2Client(env);
       } catch (err) {
         return reject(err);
       }
@@ -4117,7 +4547,7 @@ var ActivityPushChannel = class {
         "authorization": `bearer ${jwt}`,
         "apns-topic": topic,
         "apns-push-type": "liveactivity",
-        "apns-priority": "10",
+        "apns-priority": priority,
         "apns-expiration": String(Math.floor(Date.now() / 1e3) + 30),
         "content-type": "application/json",
         "content-length": Buffer.byteLength(payloadStr)
@@ -4135,10 +4565,11 @@ var ActivityPushChannel = class {
           resolve();
         } else {
           if (statusCode === 0) {
-            this.http2Client?.destroy();
-            this.http2Client = null;
+            const c = this.http2Clients[env];
+            c?.destroy();
+            delete this.http2Clients[env];
           }
-          reject(new Error(`APNs returned ${statusCode}: ${responseData}`));
+          reject(new ApnsError(statusCode, responseData));
         }
       });
       req.on("error", (err) => {
@@ -4171,6 +4602,24 @@ var ActivityPushChannel = class {
     return token;
   }
 };
+var ApnsError = class extends Error {
+  constructor(statusCode, responseBody) {
+    super(`APNs returned ${statusCode}: ${responseBody}`);
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+    this.name = "ApnsError";
+  }
+};
+function isBadDeviceTokenError(err) {
+  if (!(err instanceof ApnsError)) return false;
+  if (err.statusCode !== 400 && err.statusCode !== 410) return false;
+  try {
+    const parsed = JSON.parse(err.responseBody);
+    return parsed.reason === "BadDeviceToken" || parsed.reason === "Unregistered";
+  } catch {
+    return false;
+  }
+}
 
 // src/session/ProjectReader.ts
 var import_promises3 = require("fs/promises");
@@ -4570,6 +5019,45 @@ var PairingManager = class {
   }
 };
 
+// src/utils/shellPath.ts
+var import_node_child_process7 = require("child_process");
+var fixed = false;
+function fixShellPath() {
+  if (fixed || isWindows) {
+    fixed = true;
+    return;
+  }
+  fixed = true;
+  const shell = process.env.SHELL || "/bin/zsh";
+  const isFish = /\/fish$/.test(shell);
+  const printPathCmd = isFish ? "string join : $PATH" : 'printf "%s" "$PATH"';
+  let raw;
+  try {
+    raw = (0, import_node_child_process7.execFileSync)(shell, ["-l", "-c", printPathCmd], {
+      encoding: "utf8",
+      timeout: 3e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch (err) {
+    console.warn("[fixShellPath] failed to read login shell PATH:", err);
+    return;
+  }
+  const fromShell = raw.trim();
+  if (!fromShell) return;
+  process.env.PATH = mergePath(fromShell, process.env.PATH || "");
+}
+function mergePath(primary, secondary) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const seg of primary.split(":").concat(secondary.split(":"))) {
+    if (!seg) continue;
+    if (seen.has(seg)) continue;
+    seen.add(seg);
+    out.push(seg);
+  }
+  return out.join(":");
+}
+
 // src/auth/AuthManager.ts
 var import_child_process3 = require("child_process");
 var import_child_process4 = require("child_process");
@@ -4689,12 +5177,12 @@ 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");
+var import_node_child_process8 = require("child_process");
 var import_uuid5 = require("uuid");
-var EXEC_TIMEOUT_MS = 5 * 60 * 1e3;
+var EXEC_TIMEOUT_MS = 30 * 60 * 1e3;
 var TerminalExecutor = class {
   processes = /* @__PURE__ */ new Map();
   eventCallbacks = [];
@@ -4716,9 +5204,9 @@ var TerminalExecutor = class {
   }
   exec(sessionId, command, cwd) {
     const execId = (0, import_uuid5.v4)();
-    const shell = isWindows ? "powershell" : "bash";
-    const args = isWindows ? ["-Command", command] : ["-c", command];
-    const proc = (0, import_node_child_process7.spawn)(shell, args, {
+    const shell = isWindows ? "powershell" : process.env.SHELL || "/bin/zsh";
+    const args = isWindows ? ["-Command", command] : ["-l", "-c", command];
+    const proc = (0, import_node_child_process8.spawn)(shell, args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       env: { ...process.env }
@@ -4755,6 +5243,14 @@ var TerminalExecutor = class {
     });
     const timer = setTimeout(() => {
       if (this.processes.has(execId)) {
+        this.emit({
+          type: "terminal_output",
+          sessionId,
+          execId,
+          stream: "stderr",
+          data: `[killed: timeout ${Math.round(EXEC_TIMEOUT_MS / 6e4)}m]
+`
+        });
         killProcessCrossPlatform(proc);
       }
     }, EXEC_TIMEOUT_MS);
@@ -4779,13 +5275,13 @@ var TerminalExecutor = class {
 };
 
 // src/xcode/XcodeBuildExecutor.ts
-var import_node_child_process8 = require("child_process");
+var import_node_child_process9 = require("child_process");
 var import_node_util = require("util");
 var import_promises4 = require("fs/promises");
 var import_node_path6 = require("path");
 var import_node_os7 = require("os");
 var import_uuid6 = require("uuid");
-var execAsync = (0, import_node_util.promisify)(import_node_child_process8.exec);
+var execAsync = (0, import_node_util.promisify)(import_node_child_process9.exec);
 var BUILD_TIMEOUT_MS = 30 * 60 * 1e3;
 var INSTALL_TIMEOUT_MS = 5 * 60 * 1e3;
 var CONFIG_FILE = (0, import_node_path6.join)((0, import_node_os7.homedir)(), ".sessix", "xcode-config.json");
@@ -4974,7 +5470,7 @@ ${e.stderr ?? ""}`);
     if (override) await this.saveConfig(projectPath, override);
     const buildId = (0, import_uuid6.v4)();
     const args = buildArgs(config);
-    const proc = (0, import_node_child_process8.spawn)("xcodebuild", args, {
+    const proc = (0, import_node_child_process9.spawn)("xcodebuild", args, {
       cwd: projectPath,
       stdio: ["ignore", "pipe", "pipe"],
       env: { ...process.env, NSUnbufferedIO: "YES" }
@@ -5070,7 +5566,7 @@ ${e.stderr ?? ""}`);
 
 `
     });
-    const proc = (0, import_node_child_process8.spawn)(installCmd[0], installCmd.slice(1), {
+    const proc = (0, import_node_child_process9.spawn)(installCmd[0], installCmd.slice(1), {
       cwd: projectPath,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -5192,10 +5688,784 @@ function kindOrder(k) {
   return k === "device" ? 0 : k === "simulator" ? 1 : k === "mac" ? 2 : 3;
 }
 
+// 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 { cwd: cdCwd, command: finalCmd } = splitCdPrefix(cleanCmd);
+        const title = synthesizeTitle(finalCmd);
+        out.push(makeCommand({
+          title,
+          command: finalCmd,
+          cwd: cdCwd,
+          source,
+          sourceFile: fileName,
+          description: inlineComment ?? blockHeading,
+          category: classifyByCommand(finalCmd)
+        }));
+      }
+    }
+  }
+};
+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 splitCdPrefix(cmd) {
+  const m = /^cd\s+(\S+)\s*&&\s*(.+)$/.exec(cmd);
+  if (!m) return { cwd: "", command: cmd };
+  const path2 = m[1];
+  if (!path2) return { cwd: "", command: cmd };
+  if (path2.startsWith("/") || path2.startsWith("~") || path2.startsWith("-")) {
+    return { cwd: "", command: cmd };
+  }
+  if (path2.split("/").some((seg) => seg === "..")) {
+    return { cwd: "", command: cmd };
+  }
+  return { cwd: path2, command: m[2].trim() };
+}
+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_process10 = require("child_process");
+var import_node_util2 = require("util");
+var import_uuid7 = require("uuid");
+var execAsync2 = (0, import_node_util2.promisify)(import_node_child_process10.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_process10.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_process9 = require("child_process");
+var import_node_child_process11 = require("child_process");
+var DEFAULT_MODELS = [
+  { value: "opus", label: "Opus 4.7", sublabel: "Most capable for ambitious work" },
+  { value: "sonnet", label: "Sonnet 4.6", sublabel: "Most efficient for everyday tasks" },
+  { value: "haiku", label: "Haiku 4.5", sublabel: "Fastest for quick answers" }
+];
 var DEFAULT_CAPABILITIES = {
-  effortLevels: ["low", "medium", "high", "xhigh", "max"]
+  effortLevels: ["low", "medium", "high", "xhigh", "max"],
+  models: DEFAULT_MODELS
 };
 async function parseCliCapabilities() {
   const claudePath = findClaudePath();
@@ -5221,7 +6491,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_process11.execFile)(path2, args, { timeout: 5e3 }, (err, stdout) => {
       if (err) {
         console.warn(`[CliCapabilities] Failed to run ${path2} ${args.join(" ")}:`, err.message);
         resolve(null);
@@ -5235,11 +6505,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_process12.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();
@@ -5249,20 +6519,53 @@ 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));
   } catch {
   }
 }
+async function loadApnsConfigFromFile() {
+  const path2 = (0, import_node_path9.join)((0, import_node_os9.homedir)(), ".sessix", "apns.json");
+  try {
+    const raw = await (0, import_promises7.readFile)(path2, "utf8");
+    const cfg = JSON.parse(raw);
+    if (typeof cfg.teamId !== "string" || typeof cfg.keyId !== "string" || typeof cfg.authKeyPath !== "string") {
+      console.warn(`[Server] \u26A0\uFE0F  ${path2} \u7F3A\u5C11\u5FC5\u9700\u5B57\u6BB5 (teamId / keyId / authKeyPath)\uFF0CLA \u540E\u53F0\u63A8\u9001\u5DF2\u7981\u7528`);
+      return null;
+    }
+    try {
+      await (0, import_promises7.readFile)(cfg.authKeyPath, "utf8");
+    } catch (err) {
+      console.warn(`[Server] \u26A0\uFE0F  \u65E0\u6CD5\u8BFB\u53D6 APNs Auth Key: ${cfg.authKeyPath}`, err);
+      return null;
+    }
+    console.log(`[Server] \u2705 \u5DF2\u52A0\u8F7D APNs \u914D\u7F6E (${path2})`);
+    console.log(`[Server]    teamId=${cfg.teamId} keyId=${cfg.keyId} sandbox=${cfg.sandbox === true}`);
+    return {
+      teamId: cfg.teamId,
+      keyId: cfg.keyId,
+      authKeyPath: cfg.authKeyPath,
+      sandbox: cfg.sandbox === true
+    };
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      console.log(`[Server] \u2139\uFE0F  ${path2} \u4E0D\u5B58\u5728\uFF0CLA \u540E\u53F0\u63A8\u9001\u672A\u542F\u7528\uFF08\u524D\u53F0 App \u4ECD\u80FD\u7528\u672C\u5730 Activity.update\uFF09`);
+    } else {
+      console.warn(`[Server] \u26A0\uFE0F  \u8BFB\u53D6 ${path2} \u5931\u8D25:`, err);
+    }
+    return null;
+  }
+}
 async function createWithRetry(label, port, factory) {
   try {
     return await factory();
@@ -5277,8 +6580,9 @@ 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");
+  fixShellPath();
+  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;
@@ -5288,11 +6592,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");
       }
     }
   }
@@ -5300,6 +6604,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,
@@ -5322,9 +6629,10 @@ async function start(opts = {}) {
   const notificationService = new NotificationService(sessionManager, expoChannel);
   notificationService.addChannel("expo", expoChannel, opts.enableExpoPush !== false);
   notificationService.addChannel("mac", new DesktopNotificationChannel(), opts.enableMacNotification !== false);
-  if (opts.activityPush) {
+  const activityPushOpts = opts.activityPush ?? await loadApnsConfigFromFile();
+  if (activityPushOpts) {
     try {
-      const activityChannel = new ActivityPushChannel(opts.activityPush);
+      const activityChannel = new ActivityPushChannel(activityPushOpts);
       notificationService.setActivityPushChannel(activityChannel);
       console.log(`[Server] ${t("server.activityPushEnabled")}`);
     } catch (err) {
@@ -5338,7 +6646,7 @@ 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)
   });
@@ -5359,6 +6667,9 @@ async function start(opts = {}) {
   notificationService.setGlobalPendingCountProvider(
     () => approvalProxy.getPendingCount() + sessionManager.getAllPendingQuestions().length + unreadSessionIds.size
   );
+  notificationService.setPendingApprovalsProvider(
+    (sessionId) => approvalProxy.getPendingRequestsForSession(sessionId)
+  );
   let cliCapabilities = null;
   parseCliCapabilities().then((caps) => {
     cliCapabilities = caps;
@@ -5367,6 +6678,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) {
@@ -5386,14 +6740,17 @@ async function start(opts = {}) {
       wsBridge.send(ws, { type: "unread_sessions", sessionIds: Array.from(unreadSessionIds) });
     }
     if (cliCapabilities) {
-      wsBridge.send(ws, { type: "cli_info", effortLevels: cliCapabilities.effortLevels, version: cliCapabilities.version });
+      wsBridge.send(ws, { type: "cli_info", effortLevels: cliCapabilities.effortLevels, version: cliCapabilities.version, models: cliCapabilities.models });
+    }
+    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(
@@ -5581,7 +6938,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 {
               }
@@ -5744,6 +7101,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",
@@ -5782,6 +7199,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"));
@@ -5799,14 +7219,12 @@ async function start(opts = {}) {
     setTimeout(() => {
       if (!approvalProxy.isPending(request.id)) return;
       if (wsBridge.isViewingSession(request.sessionId)) return;
-      if (wsBridge.getConnectionCount() > 0) return;
       const pendingCount = approvalProxy.getPendingRequestsForSession(request.sessionId).length;
       notificationService.notifyApproval(request, pendingCount);
     }, 5e3);
     setTimeout(() => {
       if (!approvalProxy.isPending(request.id)) return;
       if (wsBridge.isViewingSession(request.sessionId)) return;
-      if (wsBridge.getConnectionCount() > 0) return;
       console.log(`[Server] ${t("server.approvalRetry", { id: request.id })}`);
       const pendingCount = approvalProxy.getPendingRequestsForSession(request.sessionId).length;
       notificationService.notifyApproval(request, pendingCount);
@@ -5818,13 +7236,11 @@ async function start(opts = {}) {
     setTimeout(() => {
       if (!sessionManager.isQuestionPending(request.id)) return;
       if (wsBridge.isViewingSession(request.sessionId)) return;
-      if (wsBridge.getConnectionCount() > 0) return;
       notificationService.notifyQuestion(request);
     }, 5e3);
     setTimeout(() => {
       if (!sessionManager.isQuestionPending(request.id)) return;
       if (wsBridge.isViewingSession(request.sessionId)) return;
-      if (wsBridge.getConnectionCount() > 0) return;
       console.log(`[Server] Question ${request.id} not answered in 60s, retrying push`);
       notificationService.notifyQuestion(request);
     }, 6e4);
@@ -5871,6 +7287,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 = [];
@@ -5882,6 +7334,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");
@@ -5892,6 +7345,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];
@@ -5918,9 +7372,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);
@@ -5937,7 +7391,7 @@ async function start(opts = {}) {
 var import_qrcode_terminal = __toESM(require("qrcode-terminal"));
 function getPackageVersion() {
   try {
-    const pkg = JSON.parse((0, import_node_fs4.readFileSync)((0, import_node_path8.join)(__dirname, "..", "package.json"), "utf8"));
+    const pkg = JSON.parse((0, import_node_fs4.readFileSync)((0, import_node_path10.join)(__dirname, "..", "package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -5975,7 +7429,7 @@ async function autoUpdateIfNeeded() {
   console.log(`  \u{1F4E6} ${t("startup.autoUpdating", { current: PKG_VERSION, latest })}`);
   console.log();
   try {
-    (0, import_node_child_process11.execFileSync)("npx", [`sessix-server@${latest}`], {
+    (0, import_node_child_process13.execFileSync)("npx", [`sessix-server@${latest}`], {
       stdio: "inherit",
       env: { ...process.env, __SESSIX_UPDATED: "1" }
     });
@@ -6081,7 +7535,7 @@ ${t("startup.pairingReopened")}`);
   }
 }
 function getLocalIp() {
-  const interfaces = (0, import_node_os9.networkInterfaces)();
+  const interfaces = (0, import_node_os10.networkInterfaces)();
   for (const iface of Object.values(interfaces)) {
     for (const addr of iface ?? []) {
       if (addr.family === "IPv4" && !addr.internal) {