sessix-server 0.4.3 → 0.4.6

package/dist/server.js

@@ -311,7 +311,7 @@ var import_uuid9 = require("uuid");
 var import_promises7 = require("fs/promises");
 var import_node_os9 = require("os");
 var import_node_path9 = require("path");
-var import_node_child_process11 = require("child_process");
+var import_node_child_process12 = require("child_process");
 var import_node_util3 = require("util");
 
 // src/providers/ProcessProvider.ts
@@ -667,7 +667,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 }
@@ -694,6 +711,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);
+    }
   }
   /**
    * 发出写入失败的合成错误事件
@@ -927,9 +952,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) => {
@@ -2940,6 +2969,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") {
@@ -3005,6 +3036,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 通知端点
    *
@@ -3715,6 +3774,8 @@ var HookInstaller = class {
 
 // src/notification/NotificationService.ts
 var import_node_path5 = require("path");
+var RECENT_ACTIVITY_MAX = 6;
+var ACTIVITY_PUSH_THROTTLE_MS = 4e3;
 var NotificationService = class {
   constructor(sessionManager, expoChannel = null) {
     this.sessionManager = sessionManager;
@@ -3733,6 +3794,30 @@ 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();
+  /** 挂起的优先级提升请求（状态变化时设为 '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 });
@@ -3760,11 +3845,27 @@ 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);
+    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) {
+    this.pendingApprovalsProvider = fn;
   }
   /** 设置全局待审批总数提供者 */
   setGlobalPendingCountProvider(provider) {
@@ -3779,7 +3880,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;
@@ -3787,12 +3888,16 @@ var NotificationService = class {
     if (this.activityPushChannel?.hasToken(request.sessionId)) {
       const dangerLevel2 = this.getDangerLevel(request.toolName);
       const isYoloMode = this.getYoloMode(request.sessionId);
-      this.activityPushChannel.updateActivityWithAlert(
+      const recentActivity = this.getRecentActivity(request.sessionId);
+      const latestMessage = recentActivity[recentActivity.length - 1] ?? "";
+      const session = this.sessionManager.getActiveSessions().find((s) => s.id === request.sessionId);
+      const sent = await this.activityPushChannel.updateActivityWithAlert(
         request.sessionId,
         {
           status: "waitingApproval",
           sessionTitle,
-          latestMessage: "",
+          latestMessage,
+          recentActivity,
           approvalInfo: {
             requestId: request.id,
             toolName: request.toolName,
@@ -3801,11 +3906,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 }
       );
-      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";
@@ -3838,17 +3954,25 @@ 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);
+      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 }
       );
+      this.lastActivityPushAt.set(request.sessionId, Date.now());
       return;
     }
     this.notify({
@@ -3882,6 +4006,12 @@ 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();
+    this.pendingPriority.clear();
+    this.activityCounters.clear();
   }
   // ============================================
   // 内部方法
@@ -3890,29 +4020,29 @@ 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);
-          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,
-              isYoloMode,
-              updatedAt: Date.now()
-            });
+            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,
@@ -3921,28 +4051,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,
-              isYoloMode,
-              updatedAt: Date.now()
-            });
-          } 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;
       }
@@ -3975,6 +4089,383 @@ 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);
+        this.incrementCounter(sessionId, block.name);
+      }
+    }
+    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);
+  }
+  /** 工具名 → 计数器类别映射 */
+  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, 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;
+    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 心跳（每 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;
+    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(),
+      displayMode: "summary",
+      activitySummary: this.buildActivitySummary(sessionId),
+      startedAt: session.createdAt
+    };
+    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
+      };
+    }
+    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, { 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);
+    });
+  }
+  /** 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
@@ -4031,12 +4522,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) {
@@ -4058,7 +4550,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" },
@@ -4088,100 +4580,151 @@ 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();
+  /**
+   * 两个环境都拒绝的 token（Live Activity 已销毁/过期）。
+   * 标记后跳过所有发送尝试，避免无意义的 HTTP/2 请求。
+   * 当同一 session 注册新 token 时自动清除旧 token 的标记。
+   */
+  deadTokens = /* @__PURE__ */ new Set();
+  /** 首次探测顺序（来自配置 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 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 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);
+      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: Math.floor(Date.now() / 1e3),
+        timestamp: now,
         event: "update",
-        "content-state": contentState
+        "content-state": contentState,
+        "stale-date": now + 600
       }
     };
     try {
-      await this.sendToAPNs(token, payload);
+      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: Math.floor(Date.now() / 1e3),
+        timestamp: now,
         event: "update",
         "content-state": contentState,
+        "stale-date": now + 600,
         alert,
         sound: "default"
       }
     };
     try {
-      await this.sendToAPNs(token, payload);
+      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 payload = {
-      aps: {
-        timestamp: Math.floor(Date.now() / 1e3),
-        event: "end",
-        "content-state": contentState
-      }
+    const now = Math.floor(Date.now() / 1e3);
+    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);
+      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);
   }
@@ -4189,33 +4732,81 @@ var ActivityPushChannel = class {
   hasToken(sessionId) {
     return this.tokens.has(sessionId);
   }
-  /** 发送 APNs HTTP/2 请求 */
-  async sendToAPNs(deviceToken, payload) {
+  /**
+   * 发送 APNs，自动处理环境探测。
+   * 对每个 token：先用已确认的环境（如有）；否则按 probeOrder 顺序探测，
+   * 收到 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);
+        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，不做探测） */
+  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);
       }
-      const req = client.request({
+      const headers = {
         ":method": "POST",
         ":path": `/3/device/${deviceToken}`,
         "authorization": `bearer ${jwt}`,
         "apns-topic": topic,
         "apns-push-type": "liveactivity",
-        "apns-priority": "10",
-        "apns-expiration": String(Math.floor(Date.now() / 1e3) + 30),
+        "apns-priority": priority,
+        "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;
@@ -4225,10 +4816,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) => {
@@ -4261,6 +4853,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 !== 403 && err.statusCode !== 410) return false;
+  try {
+    const parsed = JSON.parse(err.responseBody);
+    return parsed.reason === "BadDeviceToken" || parsed.reason === "BadEnvironmentKeyInToken" || parsed.reason === "Unregistered";
+  } catch {
+    return false;
+  }
+}
 
 // src/session/ProjectReader.ts
 var import_promises3 = require("fs/promises");
@@ -4660,6 +5270,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");
@@ -4778,13 +5427,10 @@ var AuthManager = class extends import_events3.EventEmitter {
   }
 };
 
-// src/server.ts
-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 = [];
@@ -4806,9 +5452,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 }
@@ -4845,6 +5491,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);
@@ -4869,13 +5523,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");
@@ -5064,7 +5718,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" }
@@ -5160,7 +5814,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"]
     });
@@ -5567,15 +6221,16 @@ var CommandDiscovery = class {
         const cmd = sanitizeBashLine(rawLine);
         if (!cmd) continue;
         const { command: cleanCmd, inlineComment } = splitInlineComment(cmd);
-        const title = synthesizeTitle(cleanCmd);
+        const { cwd: cdCwd, command: finalCmd } = splitCdPrefix(cleanCmd);
+        const title = synthesizeTitle(finalCmd);
         out.push(makeCommand({
           title,
-          command: cleanCmd,
-          cwd: "",
+          command: finalCmd,
+          cwd: cdCwd,
           source,
           sourceFile: fileName,
           description: inlineComment ?? blockHeading,
-          category: classifyByCommand(cleanCmd)
+          category: classifyByCommand(finalCmd)
         }));
       }
     }
@@ -5620,6 +6275,19 @@ function synthesizeTitle(cmd) {
   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;
@@ -5681,10 +6349,10 @@ function sourceWeight(s) {
 }
 
 // src/git/GitExecutor.ts
-var import_node_child_process9 = require("child_process");
+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_process9.exec);
+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;
@@ -5857,7 +6525,7 @@ var GitExecutor = class {
       });
       let proc;
       try {
-        proc = (0, import_node_child_process9.spawn)(cmd[0], cmd.slice(1), {
+        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" }
@@ -6037,9 +6705,15 @@ function isValidTask(value) {
 }
 
 // src/utils/cliCapabilities.ts
-var import_node_child_process10 = 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();
@@ -6065,7 +6739,7 @@ async function parseCliCapabilities() {
 }
 function runCli(path2, args) {
   return new Promise((resolve) => {
-    (0, import_node_child_process10.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);
@@ -6079,7 +6753,7 @@ function runCli(path2, args) {
 // src/server.ts
 var WS_PORT = 3745;
 var HTTP_PORT = 3746;
-var execAsync3 = (0, import_node_util3.promisify)(import_node_child_process11.exec);
+var execAsync3 = (0, import_node_util3.promisify)(import_node_child_process12.exec);
 async function killPortProcess(port) {
   try {
     if (isWindows) {
@@ -6107,6 +6781,39 @@ async function killPortProcess(port) {
   } 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();
@@ -6121,6 +6828,7 @@ async function createWithRetry(label, port, factory) {
   }
 }
 async function start(opts = {}) {
+  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;
@@ -6169,9 +6877,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) {
@@ -6206,6 +6915,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;
@@ -6218,7 +6930,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,
@@ -6276,7 +6989,7 @@ 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() });
@@ -6286,7 +6999,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(
@@ -6346,38 +7060,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 });
@@ -6474,7 +7194,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 {
               }
@@ -6558,6 +7278,9 @@ async function start(opts = {}) {
           wsBridge.clearViewingSession(ws);
           break;
         }
+        case "approval_displayed": {
+          break;
+        }
         case "always_allow_tool": {
           approvalProxy.addToClaudeSettings(event.projectPath, event.toolName);
           break;
@@ -6755,14 +7478,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);
+    }, 3e3);
     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);
@@ -6774,13 +7495,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);