sessix-server 0.4.5 → 0.4.6

package/dist/index.js

@@ -947,9 +947,13 @@ ${context}`;
       throw new Error(`Session ${sessionId} stdin unavailable`);
     }
     const toolResult = JSON.stringify({
-      type: "tool_result",
-      tool_use_id: toolUseId,
-      content: answer
+      type: "user",
+      session_id: "",
+      message: {
+        role: "user",
+        content: [{ type: "tool_result", tool_use_id: toolUseId, content: answer }]
+      },
+      parent_tool_use_id: toolUseId
     });
     await new Promise((resolve, reject) => {
       entry.process.stdin.write(toolResult + "\n", (err) => {
@@ -2960,6 +2964,8 @@ var ApprovalProxy = class _ApprovalProxy {
       this.handleApprovalHook(req, res);
     } else if (req.method === "POST" && pathname === "/hook/notify") {
       this.handleHookNotify(req, res);
+    } else if (req.method === "POST" && pathname === "/api/resolve") {
+      this.handleApiResolve(req, res);
     } else if (req.method === "POST" && pathname === "/pair") {
       this.handlePair(req, res);
     } else if (req.method === "GET" && pathname === "/health") {
@@ -3025,6 +3031,34 @@ var ApprovalProxy = class _ApprovalProxy {
       this.sendJson(res, 200, { decision: "deny", reason: "Server failed to process request" });
     }
   }
+  /**
+   * 移动端 API 端点：Widget Extension / Watch 直接提交审批决策
+   *
+   * 绕过 WebSocket 链路，让 iOS Widget Extension 的 AppIntent 在 App 挂起时
+   * 仍能直接将审批结果提交到服务端。使用 Bearer token 鉴权（与 WS 同一 token）。
+   */
+  async handleApiResolve(req, res) {
+    const authHeader = req.headers.authorization ?? "";
+    const bearerToken = authHeader.startsWith("Bearer ") ? authHeader.slice(7) : "";
+    if (bearerToken !== this.token) {
+      this.sendJson(res, 401, { ok: false, error: "Unauthorized" });
+      return;
+    }
+    try {
+      const body = await this.parseJsonBody(req);
+      const requestId = String(body.requestId ?? "").trim();
+      const decision = String(body.decision ?? "").trim();
+      if (!requestId || decision !== "allow" && decision !== "deny") {
+        this.sendJson(res, 400, { ok: false, error: "requestId and decision (allow|deny) required" });
+        return;
+      }
+      const resolved = this.resolveApproval(requestId, { decision });
+      this.sendJson(res, 200, { ok: resolved });
+    } catch (err) {
+      console.error("[ApprovalProxy] /api/resolve error:", err);
+      this.sendJson(res, 500, { ok: false, error: "Internal error" });
+    }
+  }
   /**
    * 非阻塞 hook 通知端点
    *
@@ -3736,7 +3770,7 @@ 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 ACTIVITY_PUSH_THROTTLE_MS = 4e3;
 var NotificationService = class {
   constructor(sessionManager, expoChannel = null) {
     this.sessionManager = sessionManager;
@@ -3761,8 +3795,24 @@ var NotificationService = class {
   activityPushTimers = /* @__PURE__ */ new Map();
   /** 上次推送 LA content 的时间戳（用于节流；首次立即推送） */
   lastActivityPushAt = /* @__PURE__ */ new Map();
+  /** 挂起的优先级提升请求（状态变化时设为 '10'，flush 后清除） */
+  pendingPriority = /* @__PURE__ */ new Map();
+  /** sessionId → 累计活动计数器（用于 summary 模式的 activitySummary） */
+  activityCounters = /* @__PURE__ */ new Map();
   /** 提供器：根据 sessionId 取该会话的待审批列表（由 server.ts 注入） */
   pendingApprovalsProvider = null;
+  /**
+   * sessionId → idle 结束定时器。
+   * 会话变为 idle 时启动（30 秒）；用户发新消息重回 running 时取消。
+   * 30 秒内无新消息 → 调 endActivity 关闭 LA，同时发横幅通知告知完成。
+   */
+  idleEndTimers = /* @__PURE__ */ new Map();
+  /**
+   * sessionId → LA 心跳定时器（setInterval）。
+   * 确保 Agent 子任务等长时间无 claude_event 的场景下 LA 仍持续更新。
+   * token 注册时启动，flushActivityEnd / removeActivityPushToken 时停止。
+   */
+  laHeartbeatTimers = /* @__PURE__ */ new Map();
   /** 添加通知渠道（id 唯一，可用于后续动态开关） */
   addChannel(id, channel, enabled = true) {
     this.channelMap.set(id, { channel, enabled });
@@ -3797,13 +3847,16 @@ var NotificationService = class {
     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);
+    this.startLaHeartbeat(sessionId);
   }
   /** 移除 ActivityKit push token */
   removeActivityPushToken(sessionId) {
+    this.stopLaHeartbeat(sessionId);
     this.activityPushChannel?.removeToken(sessionId);
     this.clearActivityPushTimer(sessionId);
     this.recentActivityState.delete(sessionId);
     this.lastActivityPushAt.delete(sessionId);
+    this.activityCounters.delete(sessionId);
   }
   /** 注入"会话 → 待审批列表"提供器（server.ts 启动时调用） */
   setPendingApprovalsProvider(fn) {
@@ -3822,7 +3875,7 @@ var NotificationService = class {
     this.yoloModeState.set(sessionId, enabled);
   }
   /** 直接触发审批通知（由 ApprovalProxy 回调调用） */
-  notifyApproval(request, pendingCount) {
+  async notifyApproval(request, pendingCount) {
     if (this.yoloModeState.get(request.sessionId)) return;
     const sessionTitle = this.getSessionTitle(request.sessionId);
     const title = pendingCount > 1 ? t("notification.pendingApprovals", { title: sessionTitle, count: pendingCount }) : sessionTitle;
@@ -3832,7 +3885,8 @@ var NotificationService = class {
       const isYoloMode = this.getYoloMode(request.sessionId);
       const recentActivity = this.getRecentActivity(request.sessionId);
       const latestMessage = recentActivity[recentActivity.length - 1] ?? "";
-      this.activityPushChannel.updateActivityWithAlert(
+      const session = this.sessionManager.getActiveSessions().find((s) => s.id === request.sessionId);
+      const sent = await this.activityPushChannel.updateActivityWithAlert(
         request.sessionId,
         {
           status: "waitingApproval",
@@ -3847,12 +3901,22 @@ var NotificationService = class {
             pendingCount
           },
           isYoloMode,
-          updatedAt: Date.now()
+          updatedAt: Date.now(),
+          displayMode: "summary",
+          activitySummary: this.buildActivitySummary(request.sessionId),
+          startedAt: session?.createdAt,
+          stats: this.buildStatsPayload(session)
         },
         { title, body }
       );
-      this.lastActivityPushAt.set(request.sessionId, Date.now());
-      return;
+      if (sent) {
+        console.log(`[NotificationService] \u{1F4E1} approval via ActivityKit push session=${request.sessionId.slice(0, 8)}\u2026 tool=${request.toolName}`);
+        this.lastActivityPushAt.set(request.sessionId, Date.now());
+        return;
+      }
+      console.warn(`[NotificationService] \u26A0\uFE0F  ActivityKit push \u5931\u8D25\uFF0C\u964D\u7EA7\u5230 Expo push session=${request.sessionId.slice(0, 8)}\u2026`);
+    } else {
+      console.log(`[NotificationService] \u{1F4F2} approval via Expo push session=${request.sessionId.slice(0, 8)}\u2026 tool=${request.toolName}`);
     }
     const dangerLevel = this.getDangerLevel(request.toolName);
     const isDangerous = dangerLevel === "danger" || dangerLevel === "write";
@@ -3886,15 +3950,20 @@ var NotificationService = class {
     if (this.activityPushChannel?.hasToken(request.sessionId)) {
       const isYoloMode = this.getYoloMode(request.sessionId);
       const recentActivity = this.getRecentActivity(request.sessionId);
+      const session = this.sessionManager.getActiveSessions().find((s) => s.id === request.sessionId);
       this.activityPushChannel.updateActivityWithAlert(
         request.sessionId,
         {
-          status: "waitingApproval",
+          status: "waitingQuestion",
           sessionTitle,
           latestMessage: request.question.slice(0, 80),
           recentActivity,
           isYoloMode,
-          updatedAt: Date.now()
+          updatedAt: Date.now(),
+          displayMode: "summary",
+          activitySummary: this.buildActivitySummary(request.sessionId),
+          startedAt: session?.createdAt,
+          stats: this.buildStatsPayload(session)
         },
         { title: sessionTitle, body }
       );
@@ -3936,6 +4005,8 @@ var NotificationService = class {
     this.activityPushTimers.clear();
     this.recentActivityState.clear();
     this.lastActivityPushAt.clear();
+    this.pendingPriority.clear();
+    this.activityCounters.clear();
   }
   // ============================================
   // 内部方法
@@ -3959,22 +4030,14 @@ var NotificationService = class {
       case "status_change": {
         this.clearActivityPushTimer(event.sessionId);
         if (event.status === "idle") {
-          const sessionTitle = this.getSessionTitle(event.sessionId);
-          const latestMsg = this.latestAssistantText.get(event.sessionId);
-          const body = latestMsg ? `\u2705 ${latestMsg.slice(0, 80)}` : t("notification.taskComplete");
-          const isYoloMode = this.getYoloMode(event.sessionId);
+          this.cancelIdleEndTimer(event.sessionId);
           if (this.activityPushChannel?.hasToken(event.sessionId)) {
-            this.activityPushChannel.endActivity(event.sessionId, {
-              status: "idle",
-              sessionTitle,
-              latestMessage: body,
-              recentActivity: this.getRecentActivity(event.sessionId),
-              isYoloMode,
-              updatedAt: Date.now()
-            });
-            this.recentActivityState.delete(event.sessionId);
-            this.lastActivityPushAt.delete(event.sessionId);
+            this.scheduleActivityPush(event.sessionId, true, "10");
+            this.scheduleIdleEnd(event.sessionId, 3e4);
           } else {
+            const sessionTitle = this.getSessionTitle(event.sessionId);
+            const latestMsg = this.latestAssistantText.get(event.sessionId);
+            const body = latestMsg ? `\u2705 ${latestMsg.slice(0, 80)}` : t("notification.taskComplete");
             this.notify({
               title: sessionTitle,
               body,
@@ -3983,31 +4046,12 @@ var NotificationService = class {
               data: { type: "task_complete", sessionId: event.sessionId }
             });
           }
+        } else if (event.status === "running" || event.status === "waiting_approval" || event.status === "waiting_question") {
+          this.cancelIdleEndTimer(event.sessionId);
+          this.scheduleActivityPush(event.sessionId, true, "10");
         } else if (event.status === "error") {
-          const sessionTitle = this.getSessionTitle(event.sessionId);
-          const latestMsg = this.latestAssistantText.get(event.sessionId);
-          const body = latestMsg ? `\u274C ${latestMsg.slice(0, 80)}` : t("notification.taskError");
-          const isYoloMode = this.getYoloMode(event.sessionId);
-          if (this.activityPushChannel?.hasToken(event.sessionId)) {
-            this.activityPushChannel.endActivity(event.sessionId, {
-              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,
-              body,
-              sound: "default",
-              badge: this.getGlobalPendingCount(),
-              data: { type: "task_error", sessionId: event.sessionId }
-            });
-          }
+          this.cancelIdleEndTimer(event.sessionId);
+          this.flushActivityEnd(event.sessionId, "error");
         }
         break;
       }
@@ -4083,6 +4127,7 @@ var NotificationService = class {
       } else if (block.type === "tool_use") {
         const line = this.summarizeToolCall(block.name, block.input ?? {});
         if (line) next.push(line);
+        this.incrementCounter(sessionId, block.name);
       }
     }
     state.currentEntries = next;
@@ -4094,9 +4139,66 @@ var NotificationService = class {
     const combined = [...state.history, ...state.currentEntries];
     return combined.slice(-RECENT_ACTIVITY_MAX);
   }
+  /** 工具名 → 计数器类别映射 */
+  incrementCounter(sessionId, toolName) {
+    let c = this.activityCounters.get(sessionId);
+    if (!c) {
+      c = { filesEdited: 0, commandsRun: 0, searches: 0, filesRead: 0, messagesReceived: 0 };
+      this.activityCounters.set(sessionId, c);
+    }
+    switch (toolName) {
+      case "Edit":
+      case "MultiEdit":
+      case "Write":
+      case "NotebookEdit":
+        c.filesEdited++;
+        break;
+      case "Bash":
+        c.commandsRun++;
+        break;
+      case "Grep":
+      case "Glob":
+      case "WebSearch":
+      case "WebFetch":
+        c.searches++;
+        break;
+      case "Read":
+        c.filesRead++;
+        break;
+      default:
+        break;
+    }
+  }
+  /** 把累计计数器格式化为可读摘要（如"已编辑 3 个文件 · 运行 5 条命令"） */
+  buildActivitySummary(sessionId) {
+    const c = this.activityCounters.get(sessionId);
+    if (!c) return "";
+    const parts = [];
+    if (c.filesEdited > 0) parts.push(`\u5DF2\u7F16\u8F91 ${c.filesEdited} \u4E2A\u6587\u4EF6`);
+    if (c.commandsRun > 0) parts.push(`\u8FD0\u884C ${c.commandsRun} \u6761\u547D\u4EE4`);
+    if (c.searches > 0) parts.push(`\u641C\u7D22 ${c.searches} \u6B21`);
+    if (c.filesRead > 0) parts.push(`\u9605\u8BFB ${c.filesRead} \u4E2A\u6587\u4EF6`);
+    return parts.join(" \xB7 ") || "\u4F1A\u8BDD\u8FDB\u884C\u4E2D\u2026";
+  }
+  buildStatsPayload(session) {
+    return {
+      totalInputTokens: session?.stats?.totalInputTokens ?? 0,
+      totalOutputTokens: session?.stats?.totalOutputTokens ?? 0,
+      totalCostUsd: session?.stats?.totalCostUsd,
+      totalDurationMs: session?.stats?.totalDurationMs,
+      runningStartedAt: session?.stats?.runningStartedAt
+    };
+  }
   /** 节流调度 LA content push；首次立即推，后续合并到 throttle window 末尾 */
-  scheduleActivityPush(sessionId, force = false) {
-    if (!this.activityPushChannel?.hasToken(sessionId)) return;
+  scheduleActivityPush(sessionId, force = false, priority) {
+    if (!this.activityPushChannel) return;
+    if (!this.activityPushChannel.hasToken(sessionId)) {
+      console.warn(`[NotificationService] \u26A0\uFE0F  skip LA push: session=${sessionId.slice(0, 8)}\u2026 token \u672A\u6CE8\u518C`);
+      return;
+    }
+    if (priority === "10") {
+      this.pendingPriority.set(sessionId, "10");
+    }
     const now = Date.now();
     const last = this.lastActivityPushAt.get(sessionId) ?? 0;
     const elapsed = now - last;
@@ -4122,6 +4224,101 @@ var NotificationService = class {
       this.activityPushTimers.delete(sessionId);
     }
   }
+  /**
+   * 启动 LA 心跳（每 ACTIVITY_PUSH_THROTTLE_MS 触发一次 scheduleActivityPush）。
+   * 确保 Agent 子会话等长时间无 claude_event 的情况下 LA 仍持续更新。
+   * 心跳只在会话活跃状态（running/waitingApproval/waitingQuestion）下发推送；
+   * scheduleActivityPush 自带节流，心跳与正常事件驱动不冲突。
+   */
+  startLaHeartbeat(sessionId) {
+    if (this.laHeartbeatTimers.has(sessionId)) return;
+    const timer = setInterval(() => {
+      if (!this.activityPushChannel?.hasToken(sessionId)) {
+        this.stopLaHeartbeat(sessionId);
+        return;
+      }
+      const session = this.sessionManager.getActiveSessions().find((s) => s.id === sessionId);
+      if (!session) {
+        this.stopLaHeartbeat(sessionId);
+        return;
+      }
+      if (session.status === "running" || session.status === "waiting_approval" || session.status === "waiting_question") {
+        this.scheduleActivityPush(sessionId);
+      }
+    }, ACTIVITY_PUSH_THROTTLE_MS);
+    this.laHeartbeatTimers.set(sessionId, timer);
+  }
+  /** 停止 LA 心跳 */
+  stopLaHeartbeat(sessionId) {
+    const timer = this.laHeartbeatTimers.get(sessionId);
+    if (timer) {
+      clearInterval(timer);
+      this.laHeartbeatTimers.delete(sessionId);
+    }
+  }
+  /** 取消 idle 结束定时器 */
+  cancelIdleEndTimer(sessionId) {
+    const timer = this.idleEndTimers.get(sessionId);
+    if (timer) {
+      clearTimeout(timer);
+      this.idleEndTimers.delete(sessionId);
+    }
+  }
+  /**
+   * 启动 idle 结束定时器：delayMs 后若会话仍 idle，调 endActivity + 发通知。
+   * 保证多轮对话期间（idle→running→idle）LA 不会过早消失。
+   */
+  scheduleIdleEnd(sessionId, delayMs) {
+    const timer = setTimeout(() => {
+      this.idleEndTimers.delete(sessionId);
+      this.flushActivityEnd(sessionId, "idle");
+    }, delayMs);
+    this.idleEndTimers.set(sessionId, timer);
+  }
+  /**
+   * 结束 LA 并发完成通知。有 LA token → APNs event:end（带横幅）；
+   * 无 token → 普通 Expo push。清理所有相关状态。
+   */
+  flushActivityEnd(sessionId, reason) {
+    const sessionTitle = this.getSessionTitle(sessionId);
+    const latestMsg = this.latestAssistantText.get(sessionId);
+    const isError = reason === "error";
+    const body = isError ? `\u274C ${latestMsg?.slice(0, 80) ?? t("notification.taskError")}` : `\u2705 ${latestMsg?.slice(0, 80) ?? t("notification.taskComplete")}`;
+    const isYoloMode = this.getYoloMode(sessionId);
+    const session = this.sessionManager.getActiveSessions().find((s) => s.id === sessionId);
+    this.notify({
+      title: sessionTitle,
+      body,
+      sound: "default",
+      badge: this.getGlobalPendingCount(),
+      data: { type: isError ? "task_error" : "task_complete", sessionId }
+    });
+    if (this.activityPushChannel?.hasToken(sessionId)) {
+      this.activityPushChannel.endActivity(
+        sessionId,
+        {
+          status: isError ? "error" : "completed",
+          sessionTitle,
+          latestMessage: body,
+          recentActivity: this.getRecentActivity(sessionId),
+          isYoloMode,
+          updatedAt: Date.now(),
+          displayMode: "summary",
+          activitySummary: this.buildActivitySummary(sessionId),
+          startedAt: session?.createdAt,
+          stats: this.buildStatsPayload(session)
+        }
+        // 不传 alert——Expo push 已处理通知，event:end 仅用于关闭 LA
+      ).catch((err) => {
+        console.warn("[NotificationService] endActivity (close LA) failed, LA may linger:", err);
+      });
+    }
+    this.stopLaHeartbeat(sessionId);
+    this.recentActivityState.delete(sessionId);
+    this.lastActivityPushAt.delete(sessionId);
+    this.activityCounters.delete(sessionId);
+    console.log(`[NotificationService] \u{1F3C1} LA end (${reason}) session=${sessionId.slice(0, 8)}\u2026`);
+  }
   /** 真正发送一次 LA content push（无 alert） */
   flushActivityPush(sessionId) {
     const channel = this.activityPushChannel;
@@ -4141,7 +4338,10 @@ var NotificationService = class {
       latestMessage,
       recentActivity,
       isYoloMode,
-      updatedAt: Date.now()
+      updatedAt: Date.now(),
+      displayMode: "summary",
+      activitySummary: this.buildActivitySummary(sessionId),
+      startedAt: session.createdAt
     };
     if (latestApproval) {
       contentState.approvalInfo = {
@@ -4152,17 +4352,15 @@ var NotificationService = class {
         pendingCount: pendingApprovals.length
       };
     }
-    if (session.stats) {
-      contentState.stats = {
-        totalInputTokens: session.stats.totalInputTokens,
-        totalOutputTokens: session.stats.totalOutputTokens,
-        totalCostUsd: session.stats.totalCostUsd
-      };
-    }
+    contentState.stats = this.buildStatsPayload(session);
+    const priority = this.pendingPriority.get(sessionId) ?? "5";
+    this.pendingPriority.delete(sessionId);
     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}`);
+    channel.updateActivity(sessionId, contentState, { priority }).then((ok) => {
+      if (ok) {
+        console.log(`[NotificationService] \u{1F4E1} LA push \u2713 session=${sessionId.slice(0, 8)}\u2026 status=${status} p=${priority} lines=${lineCount}`);
+      }
     }).catch((err) => {
       console.warn(`[NotificationService] \u{1F4E1} LA push \u2717 session=${sessionId.slice(0, 8)}\u2026:`, err instanceof Error ? err.message : err);
     });
@@ -4319,12 +4517,13 @@ var ExpoNotificationChannel = class {
   }
   async send(payload) {
     if (this.tokens.size === 0) return;
-    const offlineTokens = Array.from(this.tokens).filter((token) => {
+    const isCompletionNotif = payload.data?.type === "task_complete" || payload.data?.type === "task_error";
+    const targetTokens = isCompletionNotif ? Array.from(this.tokens) : Array.from(this.tokens).filter((token) => {
       const ws = this.tokenWsMap.get(token);
       return !ws || ws.readyState !== ws.OPEN;
     });
-    if (offlineTokens.length === 0) return;
-    const messages = offlineTokens.map((to) => {
+    if (targetTokens.length === 0) return;
+    const messages = targetTokens.map((to) => {
       let sound = payload.sound ?? "default";
       const prefs = this.soundPreferences.get(to);
       if (prefs) {
@@ -4346,7 +4545,7 @@ var ExpoNotificationChannel = class {
       };
     });
     try {
-      console.log(`[ExpoNotificationChannel] ${t("notification.sendingPush")} (${offlineTokens.length}/${this.tokens.size} devices)`, offlineTokens);
+      console.log(`[ExpoNotificationChannel] ${t("notification.sendingPush")} (${targetTokens.length}/${this.tokens.size} devices${isCompletionNotif ? ", forced" : ""})`, targetTokens);
       const res = await fetch(EXPO_PUSH_API, {
         method: "POST",
         headers: { "Content-Type": "application/json", Accept: "application/json" },
@@ -4390,6 +4589,12 @@ var ActivityPushChannel = class {
    * 同时维护两个连接 + 探测机制，避免环境配错时静默失败。
    */
   tokenEnv = /* @__PURE__ */ new Map();
+  /**
+   * 两个环境都拒绝的 token（Live Activity 已销毁/过期）。
+   * 标记后跳过所有发送尝试，避免无意义的 HTTP/2 请求。
+   * 当同一 session 注册新 token 时自动清除旧 token 的标记。
+   */
+  deadTokens = /* @__PURE__ */ new Set();
   /** 首次探测顺序（来自配置 hint），未配置则先试 sandbox（开发场景占多数） */
   probeOrder;
   teamId;
@@ -4426,6 +4631,11 @@ var ActivityPushChannel = class {
   }
   /** 注册 Activity push token */
   addToken(sessionId, token) {
+    const oldToken = this.tokens.get(sessionId);
+    if (oldToken && oldToken !== token) {
+      this.tokenEnv.delete(oldToken);
+      this.deadTokens.delete(oldToken);
+    }
     const existed = this.tokens.has(sessionId);
     this.tokens.set(sessionId, token);
     console.log(`[ActivityPushChannel] Token ${existed ? "updated" : "registered"}: session=${sessionId.slice(0, 8)}\u2026 token=${token.slice(0, 16)}\u2026`);
@@ -4434,65 +4644,82 @@ var ActivityPushChannel = class {
   removeToken(sessionId) {
     const tok = this.tokens.get(sessionId);
     this.tokens.delete(sessionId);
-    if (tok) this.tokenEnv.delete(tok);
+    if (tok) {
+      this.tokenEnv.delete(tok);
+      this.deadTokens.delete(tok);
+    }
   }
-  /** 发送 content-state 更新到指定会话的 Live Activity（纯内容刷新，不响通知） */
-  async updateActivity(sessionId, contentState) {
+  /** 发送 content-state 更新到指定会话的 Live Activity（纯内容刷新，不响通知）。返回 true 表示实际发出 */
+  async updateActivity(sessionId, contentState, opts) {
     const token = this.tokens.get(sessionId);
-    if (!token) return;
+    if (!token) return false;
     const now = Math.floor(Date.now() / 1e3);
+    const priority = opts?.priority ?? "5";
     const payload = {
       aps: {
         timestamp: now,
         event: "update",
         "content-state": contentState,
-        // 2 分钟没新内容就让 LA 进入 stale 状态（系统自动灰化），避免显示陈旧数据
-        "stale-date": now + 120
+        "stale-date": now + 600
       }
     };
     try {
-      await this.sendToAPNs(token, payload, { priority: "5" });
+      await this.sendToAPNs(token, payload, {
+        priority,
+        collapseId: `state-${sessionId.slice(0, 54)}`
+      });
+      return true;
     } catch (err) {
       console.warn(`[ActivityPushChannel] Update failed session=${sessionId}:`, err);
+      return false;
     }
   }
-  /** 发送带通知的 content-state 更新（审批请求时使用） */
+  /** 发送带通知的 content-state 更新（审批请求时使用），返回是否发送成功 */
   async updateActivityWithAlert(sessionId, contentState, alert) {
     const token = this.tokens.get(sessionId);
-    if (!token) return;
+    if (!token) return false;
     const now = Math.floor(Date.now() / 1e3);
     const payload = {
       aps: {
         timestamp: now,
         event: "update",
         "content-state": contentState,
-        "stale-date": now + 120,
+        "stale-date": now + 600,
         alert,
         sound: "default"
       }
     };
     try {
       await this.sendToAPNs(token, payload, { priority: "10" });
+      return true;
     } catch (err) {
       console.warn(`[ActivityPushChannel] Alert update failed session=${sessionId}:`, err);
+      return false;
     }
   }
-  /** 结束指定会话的 Live Activity */
-  async endActivity(sessionId, contentState) {
+  /**
+   * 结束指定会话的 Live Activity。
+   * 可选 alert：APNs event=end 时同时推送横幅通知 + 声音，用于在会话完成时提醒用户。
+   */
+  async endActivity(sessionId, contentState, opts) {
     const token = this.tokens.get(sessionId);
     if (!token) return;
     const now = Math.floor(Date.now() / 1e3);
-    const payload = {
-      aps: {
-        timestamp: now,
-        event: "end",
-        "content-state": contentState
-      }
+    const aps = {
+      timestamp: now,
+      event: "end",
+      "content-state": contentState
     };
+    if (opts?.alert) {
+      aps.alert = opts.alert;
+      aps.sound = "default";
+    }
+    const payload = { aps };
     try {
       await this.sendToAPNs(token, payload, { priority: "10" });
     } catch (err) {
-      console.warn(`[ActivityPushChannel] End failed session=${sessionId}:`, err);
+      this.tokens.delete(sessionId);
+      throw err;
     }
     this.tokens.delete(sessionId);
   }
@@ -4503,29 +4730,44 @@ var ActivityPushChannel = class {
   /**
    * 发送 APNs，自动处理环境探测。
    * 对每个 token：先用已确认的环境（如有）；否则按 probeOrder 顺序探测，
-   * 收到 BadDeviceToken 自动切到另一个环境，并把成功的环境绑定到该 token。
+   * 收到 BadDeviceToken / BadEnvironmentKeyInToken 自动切到另一个环境，
+   * 并把成功的环境绑定到该 token。
    */
   async sendToAPNs(deviceToken, payload, opts = {}) {
+    if (this.deadTokens.has(deviceToken)) {
+      throw new Error(`token permanently dead (Activity ended): ${deviceToken.slice(0, 16)}\u2026`);
+    }
     const known = this.tokenEnv.get(deviceToken);
     if (known) {
       return this.sendToAPNsOnce(deviceToken, payload, opts, known);
     }
+    const short = deviceToken.slice(0, 16);
+    console.log(`[ActivityPushChannel] \u{1F50D} probe start token=${short}\u2026 order=[${this.probeOrder.join(",")}]`);
     let lastErr = null;
     for (const env of this.probeOrder) {
       try {
+        console.log(`[ActivityPushChannel] \u{1F50D} probe try ${env} token=${short}\u2026`);
         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)`);
-        }
+        console.log(`[ActivityPushChannel] \u2705 probe bound to ${env} (token=${short}\u2026)`);
         return;
       } catch (err) {
         lastErr = err;
+        const reason = err instanceof ApnsError ? JSON.parse(err.responseBody || "{}")?.reason ?? err.statusCode : String(err);
+        console.log(`[ActivityPushChannel] \u{1F50D} probe ${env} failed: ${reason}`);
         if (!isBadDeviceTokenError(err)) {
           throw err;
         }
       }
     }
+    this.deadTokens.add(deviceToken);
+    for (const [sid, tok] of this.tokens) {
+      if (tok === deviceToken) {
+        this.tokens.delete(sid);
+        console.warn(`[ActivityPushChannel] \u2620\uFE0F dead token, session removed: session=${sid.slice(0, 8)}\u2026 token=${short}\u2026 (Activity ended/iOS reinstalled)`);
+        break;
+      }
+    }
     throw lastErr ?? new Error("APNs send failed: all environments rejected token");
   }
   /** 单次 APNs HTTP/2 请求（内部 helper，不做探测） */
@@ -4541,21 +4783,25 @@ var ActivityPushChannel = class {
       } catch (err) {
         return reject(err);
       }
-      const req = client.request({
+      const headers = {
         ":method": "POST",
         ":path": `/3/device/${deviceToken}`,
         "authorization": `bearer ${jwt}`,
         "apns-topic": topic,
         "apns-push-type": "liveactivity",
         "apns-priority": priority,
-        "apns-expiration": String(Math.floor(Date.now() / 1e3) + 30),
+        "apns-expiration": String(Math.floor(Date.now() / 1e3) + 300),
         "content-type": "application/json",
         "content-length": Buffer.byteLength(payloadStr)
-      });
+      };
+      if (opts.collapseId) {
+        headers["apns-collapse-id"] = opts.collapseId;
+      }
+      const req = client.request(headers);
       let statusCode = 0;
       let responseData = "";
-      req.on("response", (headers) => {
-        statusCode = Number(headers[":status"] ?? 0);
+      req.on("response", (headers2) => {
+        statusCode = Number(headers2[":status"] ?? 0);
       });
       req.on("data", (chunk) => {
         responseData += chunk;
@@ -4612,10 +4858,10 @@ var ApnsError = class extends Error {
 };
 function isBadDeviceTokenError(err) {
   if (!(err instanceof ApnsError)) return false;
-  if (err.statusCode !== 400 && err.statusCode !== 410) return false;
+  if (err.statusCode !== 400 && err.statusCode !== 403 && err.statusCode !== 410) return false;
   try {
     const parsed = JSON.parse(err.responseBody);
-    return parsed.reason === "BadDeviceToken" || parsed.reason === "Unregistered";
+    return parsed.reason === "BadDeviceToken" || parsed.reason === "BadEnvironmentKeyInToken" || parsed.reason === "Unregistered";
   } catch {
     return false;
   }
@@ -5176,9 +5422,6 @@ var AuthManager = class extends import_events3.EventEmitter {
   }
 };
 
-// src/server.ts
-var import_promises8 = require("fs/promises");
-
 // src/terminal/TerminalExecutor.ts
 var import_node_child_process8 = require("child_process");
 var import_uuid5 = require("uuid");
@@ -6682,7 +6925,8 @@ async function start(opts = {}) {
     onFire: async (task) => {
       const p = task.payload;
       if (p.kind === "create") {
-        await (0, import_promises7.mkdir)(p.projectPath, { recursive: true });
+        const dirExists = await (0, import_promises7.stat)(p.projectPath).then((s) => s.isDirectory()).catch(() => false);
+        if (!dirExists) await (0, import_promises7.mkdir)(p.projectPath, { recursive: true });
         const session = await sessionManager.createSession(
           p.projectPath,
           p.message,
@@ -6750,7 +6994,8 @@ async function start(opts = {}) {
     try {
       switch (event.type) {
         case "create_session": {
-          await (0, import_promises7.mkdir)(event.projectPath, { recursive: true });
+          const dirExists = await (0, import_promises7.stat)(event.projectPath).then((s) => s.isDirectory()).catch(() => false);
+          if (!dirExists) await (0, import_promises7.mkdir)(event.projectPath, { recursive: true });
           const resumeId = event.resumeSessionId ?? event.newSessionId;
           if (resumeId) sessionFileWatcher.unwatch(resumeId);
           await sessionManager.createSession(
@@ -6810,38 +7055,44 @@ async function start(opts = {}) {
             sessions: sessionManager.getActiveSessions()
           });
           sessionManager.flushPendingAssistant(event.sessionId);
-          const bufferedEvents = [...sessionManager.getSessionEvents(event.sessionId)];
           if (sessionManager.isBufferTruncated(event.sessionId)) {
             const projectPath = sessionManager.getSessionProjectPath(event.sessionId);
             if (projectPath) {
               const historyResult = await getSessionHistory(projectPath, event.sessionId);
+              const buffered = [...sessionManager.getSessionEvents(event.sessionId)];
               if (historyResult.ok && historyResult.value.length > 0) {
-                const merged = [...historyResult.value, ...bufferedEvents];
+                const merged = [...historyResult.value, ...buffered];
                 wsBridge.send(ws, {
                   type: "session_history",
                   sessionId: event.sessionId,
                   events: merged
                 });
-              } else if (bufferedEvents.length > 0) {
+              } else if (buffered.length > 0) {
                 wsBridge.send(ws, {
                   type: "session_history",
                   sessionId: event.sessionId,
-                  events: bufferedEvents
+                  events: buffered
                 });
               }
-            } else if (bufferedEvents.length > 0) {
+            } else {
+              const buffered = [...sessionManager.getSessionEvents(event.sessionId)];
+              if (buffered.length > 0) {
+                wsBridge.send(ws, {
+                  type: "session_history",
+                  sessionId: event.sessionId,
+                  events: buffered
+                });
+              }
+            }
+          } else {
+            const buffered = [...sessionManager.getSessionEvents(event.sessionId)];
+            if (buffered.length > 0) {
               wsBridge.send(ws, {
                 type: "session_history",
                 sessionId: event.sessionId,
-                events: bufferedEvents
+                events: buffered
               });
             }
-          } else if (bufferedEvents.length > 0) {
-            wsBridge.send(ws, {
-              type: "session_history",
-              sessionId: event.sessionId,
-              events: bufferedEvents
-            });
           }
           for (const req of approvalProxy.getPendingRequestsForSession(event.sessionId)) {
             wsBridge.send(ws, { type: "approval_request", request: req });
@@ -6938,7 +7189,7 @@ async function start(opts = {}) {
             if (!isStreaming) {
               const filePath = getSessionFilePath(event.projectPath, event.sessionId);
               try {
-                const fileStat = await (0, import_promises8.stat)(filePath);
+                const fileStat = await (0, import_promises7.stat)(filePath);
                 sessionFileWatcher.watch(event.sessionId, filePath, fileStat.size);
               } catch {
               }
@@ -7022,6 +7273,9 @@ async function start(opts = {}) {
           wsBridge.clearViewingSession(ws);
           break;
         }
+        case "approval_displayed": {
+          break;
+        }
         case "always_allow_tool": {
           approvalProxy.addToClaudeSettings(event.projectPath, event.toolName);
           break;
@@ -7221,7 +7475,7 @@ async function start(opts = {}) {
       if (wsBridge.isViewingSession(request.sessionId)) return;
       const pendingCount = approvalProxy.getPendingRequestsForSession(request.sessionId).length;
       notificationService.notifyApproval(request, pendingCount);
-    }, 5e3);
+    }, 3e3);
     setTimeout(() => {
       if (!approvalProxy.isPending(request.id)) return;
       if (wsBridge.isViewingSession(request.sessionId)) return;