sessix-server 0.4.9 → 0.5.3

package/dist/index.js

@@ -302,16 +302,18 @@ function t(key, params) {
 }
 
 // src/server.ts
-var import_uuid9 = require("uuid");
+var import_uuid8 = require("uuid");
 var import_promises7 = require("fs/promises");
 var import_node_os9 = require("os");
 var import_node_path9 = require("path");
 var import_node_child_process12 = require("child_process");
 var import_node_util3 = require("util");
+var import_node_v8 = require("v8");
+var import_node_vm = require("vm");
 
 // src/providers/ProcessProvider.ts
 var import_child_process = require("child_process");
-var import_readline = require("readline");
+var import_readline2 = require("readline");
 var import_events = require("events");
 var import_node_os2 = require("os");
 var import_uuid = require("uuid");
@@ -362,12 +364,60 @@ function isNormalExit(code, signal) {
 }
 
 // src/utils/claudePath.ts
+function resolveStable(candidate) {
+  if (!candidate) return null;
+  try {
+    const real = (0, import_node_fs.realpathSync)(candidate.trim());
+    (0, import_node_fs.accessSync)(real, import_node_fs.constants.X_OK);
+    return real;
+  } catch {
+    return null;
+  }
+}
+function resolveViaLoginShell() {
+  if (isWindows) return null;
+  const shell = process.env.SHELL || "/bin/zsh";
+  try {
+    const out = (0, import_node_child_process2.execSync)(`${shell} -ilc 'command -v claude' 2>/dev/null`, {
+      encoding: "utf-8",
+      timeout: 8e3
+    }).trim().split("\n").filter(Boolean).pop();
+    return resolveStable(out);
+  } catch {
+    return null;
+  }
+}
+function resolveViaFnm() {
+  if (isWindows) return null;
+  const base = (0, import_node_path.join)((0, import_node_os.homedir)(), ".fnm", "node-versions");
+  try {
+    const versions = (0, import_node_fs.readdirSync)(base).filter((v) => /^v?\d+\./.test(v)).sort(
+      (a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })
+    );
+    for (const v of versions) {
+      const p = resolveStable((0, import_node_path.join)(base, v, "installation", "bin", "claude"));
+      if (p) return p;
+    }
+  } catch {
+  }
+  return null;
+}
+var cached = null;
 function findClaudePath() {
+  if (cached) return cached;
+  const override = resolveStable(process.env.SESSIX_CLAUDE_PATH);
+  if (override) return cached = log(override, "env:SESSIX_CLAUDE_PATH");
   try {
     const cmd = isWindows ? "where claude" : "which claude";
-    return (0, import_node_child_process2.execSync)(cmd, { encoding: "utf-8" }).trim().split("\n")[0];
+    const which = (0, import_node_child_process2.execSync)(cmd, { encoding: "utf-8" }).trim().split("\n")[0];
+    const stable = resolveStable(which);
+    if (stable) return cached = log(stable, "which");
   } catch {
   }
+  const fnm = resolveViaFnm();
+  if (fnm) return cached = log(fnm, "fnm-scan");
+  const viaShell = resolveViaLoginShell();
+  if (viaShell) return cached = log(viaShell, "login-shell");
   const candidates = isWindows ? [
     (0, import_node_path.join)(process.env.LOCALAPPDATA ?? "", "Programs", "claude", "claude.exe"),
     (0, import_node_path.join)((0, import_node_os.homedir)(), "AppData", "Local", "Programs", "claude", "claude.exe"),
@@ -378,631 +428,936 @@ function findClaudePath() {
     "/opt/homebrew/bin/claude"
   ];
   for (const candidate of candidates) {
-    try {
-      (0, import_node_fs.accessSync)(candidate, import_node_fs.constants.X_OK);
-      return candidate;
-    } catch {
-    }
+    const stable = resolveStable(candidate);
+    if (stable) return cached = log(stable, "candidate");
   }
-  return "claude";
+  console.warn(
+    "[claudePath] \u672A\u80FD\u5B9A\u4F4D claude\uFF0C\u515C\u5E95\u4F7F\u7528\u88F8 'claude'\uFF08PATH \u4E0D\u542B claude \u65F6\u4F1A\u5931\u8D25\uFF09"
+  );
+  return cached = "claude";
+}
+function log(path2, via) {
+  console.log(`[claudePath] \u89E3\u6790\u5230 claude: ${path2} (via ${via})`);
+  return path2;
 }
 
-// src/providers/ProcessProvider.ts
-var CLAUDE_PATH = findClaudePath();
-var ProcessProvider = class {
-  /** 活跃会话映射表：sessionId -> { session, process } */
-  activeSessions = /* @__PURE__ */ new Map();
-  /** 事件发射器，用于分发 Claude 事件流 */
-  emitter = new import_events.EventEmitter();
-  /** 已发射的 AskUserQuestion toolUseId 集合，按会话隔离（避免 partial message 重复触发） */
-  emittedQuestionToolUseIds = /* @__PURE__ */ new Map();
-  /**
-   * 启动新会话或恢复已有会话
-   *
-   * 会 spawn 一个 `claude` CLI 进程，设置工作目录和环境变量，
-   * 并开始监听 stdout 的 NDJSON 输出。
-   */
-  async startSession(opts) {
-    const { projectPath, message, sessionId: existingSessionId, model, permissionMode, effort, images, fallbackModel, maxBudgetUsd } = opts;
-    const sessionId = existingSessionId ?? (0, import_uuid.v4)();
-    if (this.activeSessions.has(sessionId)) {
-      await this.killSession(sessionId);
-    }
-    const projectId = projectPath.split("/").filter(Boolean).pop() ?? "unknown";
-    const session = {
-      id: sessionId,
-      projectId,
-      projectPath,
-      status: "running",
-      createdAt: Date.now(),
-      lastActiveAt: Date.now(),
-      summary: message.slice(0, 80)
-    };
-    const resume = opts.resume ?? !!existingSessionId;
-    const proc = this.spawnClaudeProcess(sessionId, projectPath, resume, model, permissionMode, effort, fallbackModel, maxBudgetUsd);
-    this.writeUserMessage(proc, message, sessionId, images);
-    session.pid = proc.pid;
-    this.activeSessions.set(sessionId, { session, process: proc, model, permissionMode, effort, fallbackModel, maxBudgetUsd });
-    proc.on("error", (err) => {
-      console.error(`[ProcessProvider] Session ${sessionId} process error:`, err.message);
-      this.activeSessions.delete(sessionId);
-      const syntheticResult = {
-        type: "result",
-        subtype: "error",
-        result: `Process spawn failed: ${err.message}`,
-        session_id: sessionId,
-        duration_ms: 0,
-        is_error: true,
-        num_turns: 0
-      };
-      this.emitter.emit(this.getEventName(sessionId), syntheticResult);
+// src/session/ProjectReader.ts
+var import_promises = require("fs/promises");
+var import_readline = require("readline");
+var import_path = require("path");
+var import_os = require("os");
+var CLAUDE_PROJECTS_DIR = (0, import_path.join)((0, import_os.homedir)(), ".claude", "projects");
+function getSessionFilePath(projectPath, sessionId) {
+  return (0, import_path.join)(CLAUDE_PROJECTS_DIR, encodeDirName(projectPath), `${sessionId}.jsonl`);
+}
+async function getSessionModel(projectPath, sessionId) {
+  const filePath = getSessionFilePath(projectPath, sessionId);
+  let fileHandle;
+  try {
+    fileHandle = await (0, import_promises.open)(filePath, "r");
+    const rl = (0, import_readline.createInterface)({
+      input: fileHandle.createReadStream({ encoding: "utf-8" }),
+      crlfDelay: Infinity
     });
-    this.attachStdoutListener(sessionId, proc);
-    this.attachStderrListener(sessionId, proc);
-    this.attachExitListener(sessionId, proc);
-    return session;
-  }
-  /**
-   * 终止指定会话
-   *
-   * kill 进程并从活跃映射中移除。
-   */
-  async killSession(sessionId) {
-    const entry = this.activeSessions.get(sessionId);
-    if (!entry) {
-      return;
-    }
-    if (entry.process.exitCode === null && entry.process.signalCode === null) {
+    let lastModel;
+    for await (const line of rl) {
+      if (!line.trim()) continue;
       try {
-        entry.process.stdin?.end();
+        const obj = JSON.parse(line);
+        if (obj.type !== "assistant" || !obj.message) continue;
+        const model = obj.message.model;
+        if (typeof model === "string" && model && model !== "unknown") {
+          lastModel = model;
+        }
       } catch {
       }
-      await killProcessCrossPlatform(entry.process);
     }
-    this.emittedQuestionToolUseIds.delete(sessionId);
-    this.activeSessions.delete(sessionId);
+    return lastModel;
+  } catch (err) {
+    if (err.code === "ENOENT") return void 0;
+    throw err;
+  } finally {
+    await fileHandle?.close();
   }
-  /**
-   * 向已有会话发送新消息
-   *
-   * 快速路径：进程存活时直接写 stdin（毫秒级响应）。
-   * 慢速路径：进程已退出时 respawn 并 --resume。
-   */
-  async sendMessage(sessionId, message, permissionMode, images) {
-    const entry = this.activeSessions.get(sessionId);
-    if (!entry) {
-      throw new Error(`Session ${sessionId} not found or already ended`);
+}
+async function getProjects() {
+  try {
+    const dirExists = await directoryExists(CLAUDE_PROJECTS_DIR);
+    if (!dirExists) {
+      return { ok: true, value: [] };
     }
-    const modeChanged = permissionMode != null && permissionMode !== (entry.permissionMode ?? "default");
-    if (!modeChanged && entry.process.exitCode === null && entry.process.signalCode === null && !entry.process.stdin?.destroyed) {
-      entry.session.status = "running";
-      entry.session.lastActiveAt = Date.now();
-      this.writeUserMessage(entry.process, message, sessionId, images);
-      return;
+    const entries = await (0, import_promises.readdir)(CLAUDE_PROJECTS_DIR, { withFileTypes: true });
+    const projects = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) {
+        continue;
+      }
+      const encodedPath = entry.name;
+      const decodedPath = decodeDirName(encodedPath);
+      const name = decodedPath.split("/").filter(Boolean).pop() ?? encodedPath;
+      const projectDir = (0, import_path.join)(CLAUDE_PROJECTS_DIR, encodedPath);
+      const { count: sessionCount, latestMtime } = await countJsonlFilesWithMtime(projectDir);
+      projects.push({
+        id: encodedPath,
+        path: decodedPath,
+        name,
+        sessionCount,
+        lastActiveAt: latestMtime
+      });
     }
-    if (modeChanged) {
-      console.log(`[ProcessProvider] Session ${sessionId}: permission mode change ${entry.permissionMode ?? "default"} \u2192 ${permissionMode}, respawn`);
-      if (entry.process.exitCode === null && entry.process.signalCode === null) {
+    projects.sort((a, b) => a.name.localeCompare(b.name));
+    return { ok: true, value: projects };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err : new Error(String(err))
+    };
+  }
+}
+async function getHistoricalSessions(projectPath) {
+  try {
+    const encodedPath = encodeDirName(projectPath);
+    const projectDir = (0, import_path.join)(CLAUDE_PROJECTS_DIR, encodedPath);
+    const dirExists = await directoryExists(projectDir);
+    if (!dirExists) {
+      return { ok: true, value: [] };
+    }
+    const entries = await (0, import_promises.readdir)(projectDir, { withFileTypes: true });
+    const jsonlFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl"));
+    const mtimeMap = /* @__PURE__ */ new Map();
+    await Promise.all(
+      jsonlFiles.map(async (entry) => {
+        const sessionId = entry.name.slice(0, -6);
+        const filePath = (0, import_path.join)(projectDir, entry.name);
         try {
-          entry.process.stdin?.end();
+          const contentTs = await extractLastTimestamp(filePath);
+          if (contentTs) {
+            mtimeMap.set(sessionId, contentTs);
+          } else {
+            const fileStat = await (0, import_promises.stat)(filePath);
+            mtimeMap.set(sessionId, fileStat.mtimeMs);
+          }
         } catch {
+          mtimeMap.set(sessionId, 0);
         }
-        killProcessCrossPlatform(entry.process);
+      })
+    );
+    const uuidDirs = entries.filter(
+      (e) => e.isDirectory() && UUID_RE.test(e.name) && !mtimeMap.has(e.name)
+    );
+    for (const entry of uuidDirs) {
+      try {
+        const fileStat = await (0, import_promises.stat)((0, import_path.join)(projectDir, entry.name));
+        mtimeMap.set(entry.name, fileStat.mtimeMs);
+      } catch {
+        mtimeMap.set(entry.name, 0);
       }
-    } else {
-      console.log(`[ProcessProvider] Session ${sessionId}: process exited, respawning`);
     }
-    const savedPendingQuestion = entry.pendingQuestion;
-    const newMode = permissionMode ?? entry.permissionMode;
-    const proc = this.spawnClaudeProcess(sessionId, entry.session.projectPath, true, entry.model, newMode, entry.effort, entry.fallbackModel, entry.maxBudgetUsd);
-    this.writeUserMessage(proc, message, sessionId, images);
-    entry.session.status = "running";
-    entry.session.lastActiveAt = Date.now();
-    entry.session.pid = proc.pid;
-    entry.process = proc;
-    entry.permissionMode = newMode;
-    entry.pendingQuestion = savedPendingQuestion;
-    proc.on("error", (err) => {
-      console.error(`[ProcessProvider] Session ${sessionId} sendMessage process error:`, err.message);
-      this.activeSessions.delete(sessionId);
-      const syntheticResult = {
-        type: "result",
-        subtype: "error",
-        result: `Failed to send message: ${err.message}`,
-        session_id: sessionId,
-        duration_ms: 0,
-        is_error: true,
-        num_turns: 0
-      };
-      this.emitter.emit(this.getEventName(sessionId), syntheticResult);
+    const indexPath = (0, import_path.join)(projectDir, "sessions-index.json");
+    const sessionMap = /* @__PURE__ */ new Map();
+    try {
+      const indexContent = await (0, import_promises.readFile)(indexPath, "utf-8");
+      const indexData = JSON.parse(indexContent);
+      if (indexData.version === 1 && Array.isArray(indexData.entries)) {
+        for (const entry of indexData.entries) {
+          const mtime = mtimeMap.get(entry.sessionId) ?? entry.fileMtime ?? (entry.modified ? new Date(entry.modified).getTime() : 0);
+          sessionMap.set(entry.sessionId, {
+            sessionId: entry.sessionId,
+            lastModified: mtime,
+            summary: entry.summary,
+            firstPrompt: entry.firstPrompt,
+            messageCount: entry.messageCount
+          });
+        }
+        await Promise.all(
+          Array.from(sessionMap.values()).filter((s) => (s.messageCount ?? 0) > 0 && !s.summary && !s.firstPrompt).map(async (s) => {
+            const filePath = (0, import_path.join)(projectDir, `${s.sessionId}.jsonl`);
+            const firstPrompt = await extractFirstPrompt(filePath).catch(() => void 0);
+            if (firstPrompt) s.firstPrompt = firstPrompt;
+          })
+        );
+      }
+    } catch {
+    }
+    const uuidDirSet = new Set(uuidDirs.map((e) => e.name));
+    for (const [sessionId, mtime] of mtimeMap) {
+      if (!sessionMap.has(sessionId)) {
+        if (uuidDirSet.has(sessionId)) {
+          sessionMap.set(sessionId, { sessionId, lastModified: mtime, messageCount: -1 });
+        } else {
+          const filePath = (0, import_path.join)(projectDir, `${sessionId}.jsonl`);
+          const firstPrompt = await extractFirstPrompt(filePath).catch(() => void 0);
+          sessionMap.set(sessionId, { sessionId, lastModified: mtime, firstPrompt });
+        }
+      }
+    }
+    const sessions = Array.from(sessionMap.values()).filter((s) => {
+      if (s.messageCount === 0) return false;
+      if (s.messageCount === -1) return true;
+      if (s.firstPrompt === void 0 && s.messageCount === void 0) return false;
+      return true;
     });
-    this.attachStdoutListener(sessionId, proc);
-    this.attachStderrListener(sessionId, proc);
-    this.attachExitListener(sessionId, proc);
-  }
-  /**
-   * 订阅指定会话的 Claude 事件流
-   *
-   * @returns 取消订阅函数
-   */
-  onEvent(sessionId, callback) {
-    const eventName = this.getEventName(sessionId);
-    this.emitter.on(eventName, callback);
-    return () => {
-      this.emitter.off(eventName, callback);
+    sessions.sort((a, b) => b.lastModified - a.lastModified);
+    return { ok: true, value: sessions };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err : new Error(String(err))
     };
   }
-  /**
-   * 获取当前所有活跃会话列表
-   */
-  getActiveSessions() {
-    return Array.from(this.activeSessions.values()).map((entry) => entry.session);
-  }
-  /**
-   * 清理空闲进程
-   *
-   * 找出所有 status='idle' 且 lastActiveAt 距今超过 maxIdleMs 的活跃进程，
-   * kill 进程释放内存。entry 保留在 activeSessions 中，用户下次 sendMessage
-   * 走 slow path 自动 --resume 重启进程。
-   *
-   * @returns 被 sweep 的 sessionId 列表
-   */
-  async sweepIdleProcesses(maxIdleMs) {
-    const now = Date.now();
-    const swept = [];
-    for (const [sessionId, entry] of this.activeSessions) {
-      if (entry.process.exitCode !== null || entry.process.signalCode !== null) continue;
-      if (entry.session.status !== "idle") continue;
-      if (now - entry.session.lastActiveAt < maxIdleMs) continue;
-      const idleMin = Math.round((now - entry.session.lastActiveAt) / 6e4);
-      console.log(`[ProcessProvider] sweeping idle process: ${sessionId} (idle ${idleMin}m)`);
+}
+async function getSessionHistory(projectPath, sessionId) {
+  let fileHandle;
+  try {
+    const encodedPath = encodeDirName(projectPath);
+    const filePath = (0, import_path.join)(CLAUDE_PROJECTS_DIR, encodedPath, `${sessionId}.jsonl`);
+    try {
+      fileHandle = await (0, import_promises.open)(filePath, "r");
+    } catch (err) {
+      if (err.code === "ENOENT") return { ok: true, value: [] };
+      throw err;
+    }
+    const rl = (0, import_readline.createInterface)({
+      input: fileHandle.createReadStream({ encoding: "utf-8" }),
+      crlfDelay: Infinity
+    });
+    const events = [];
+    for await (const line of rl) {
+      if (!line.trim()) continue;
       try {
-        entry.process.stdin?.end();
+        const obj = JSON.parse(line);
+        const type = obj.type;
+        if (type === "user" && obj.message) {
+          const msgContent = obj.message.content;
+          if (typeof msgContent === "string") {
+            if (msgContent.includes("<local-command") || msgContent.includes("<command-name>")) continue;
+          } else if (Array.isArray(msgContent)) {
+            const hasText = msgContent.some(
+              (b) => b.type === "text" && !b.text?.includes("<local-command") && !b.text?.includes("<command-name>")
+            );
+            if (!hasText) continue;
+          }
+          const normalizedContent = typeof msgContent === "string" ? [{ type: "text", text: msgContent }] : Array.isArray(msgContent) ? msgContent.filter((b) => b.type === "text" && typeof b.text === "string") : [];
+          if (normalizedContent.length === 0) continue;
+          events.push({
+            type: "user",
+            message: {
+              ...obj.message,
+              content: normalizedContent
+            },
+            session_id: sessionId
+          });
+        } else if (type === "assistant" && obj.message) {
+          const content = (obj.message.content ?? []).filter(
+            (b) => b.type === "text" || b.type === "tool_use" || b.type === "thinking"
+          );
+          if (content.length === 0) continue;
+          events.push({
+            type: "assistant",
+            message: {
+              id: obj.message.id ?? obj.uuid ?? `hist-${events.length}`,
+              model: obj.message.model ?? "unknown",
+              role: "assistant",
+              content,
+              stop_reason: obj.message.stop_reason,
+              usage: obj.message.usage
+            },
+            session_id: sessionId
+          });
+        }
       } catch {
       }
-      try {
-        await killProcessCrossPlatform(entry.process);
-      } catch (err) {
-        console.error(`[ProcessProvider] sweep kill failed for ${sessionId}:`, err);
-        continue;
+    }
+    if (events.length > 0) {
+      let totalInputTokens = 0;
+      let totalOutputTokens = 0;
+      for (const ev of events) {
+        if (ev.type === "assistant" && ev.message.usage) {
+          totalInputTokens += ev.message.usage.input_tokens ?? 0;
+          totalOutputTokens += ev.message.usage.output_tokens ?? 0;
+        }
+      }
+      if (totalInputTokens > 0 || totalOutputTokens > 0) {
+        events.push({
+          type: "result",
+          subtype: "success",
+          is_error: false,
+          duration_ms: 0,
+          num_turns: events.filter((e) => e.type === "user").length,
+          result: "",
+          session_id: sessionId,
+          usage: { input_tokens: totalInputTokens, output_tokens: totalOutputTokens }
+        });
       }
-      swept.push(sessionId);
     }
-    return swept;
+    return { ok: true, value: events };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err : new Error(String(err))
+    };
+  } finally {
+    await fileHandle?.close();
   }
-  /**
-   * LRU 上限清理
-   *
-   * 当活跃进程数超过 maxAlive 时，按 lastActiveAt 升序（最久未用优先）kill
-   * 状态为 idle 的进程，直到活跃数回到上限以内。
-   * running / waiting_question 状态的进程永远不会被 kill。
-   *
-   * @returns 被 sweep 的 sessionId 列表
-   */
-  async sweepLruProcesses(maxAlive) {
-    const swept = [];
-    if (maxAlive <= 0) return swept;
-    const aliveEntries = Array.from(this.activeSessions.entries()).filter(
-      ([, e]) => e.process.exitCode === null && e.process.signalCode === null
-    );
-    if (aliveEntries.length <= maxAlive) return swept;
-    const idleSorted = aliveEntries.filter(([, e]) => e.session.status === "idle").sort((a, b) => a[1].session.lastActiveAt - b[1].session.lastActiveAt);
-    let aliveCount = aliveEntries.length;
-    for (const [sessionId, entry] of idleSorted) {
-      if (aliveCount <= maxAlive) break;
-      const idleMin = Math.round((Date.now() - entry.session.lastActiveAt) / 6e4);
-      console.log(`[ProcessProvider] LRU sweep: ${sessionId} (idle ${idleMin}m, alive=${aliveCount}/${maxAlive})`);
+}
+async function extractLastTimestamp(filePath) {
+  let fileHandle;
+  try {
+    fileHandle = await (0, import_promises.open)(filePath, "r");
+    const fileStat = await fileHandle.stat();
+    const readSize = Math.min(fileStat.size, 8192);
+    const buffer = Buffer.alloc(readSize);
+    await fileHandle.read(buffer, 0, readSize, fileStat.size - readSize);
+    const tail = buffer.toString("utf-8");
+    const lines = tail.split("\n").filter((l) => l.trim());
+    for (let i = lines.length - 1; i >= 0; i--) {
       try {
-        entry.process.stdin?.end();
+        const obj = JSON.parse(lines[i]);
+        if (obj.timestamp) {
+          const ts = new Date(obj.timestamp).getTime();
+          if (!isNaN(ts)) return ts;
+        }
       } catch {
       }
+    }
+  } catch {
+  } finally {
+    await fileHandle?.close();
+  }
+  return void 0;
+}
+async function extractFirstPrompt(filePath) {
+  let fileHandle;
+  try {
+    fileHandle = await (0, import_promises.open)(filePath, "r");
+    const rl = (0, import_readline.createInterface)({
+      input: fileHandle.createReadStream({ encoding: "utf-8" }),
+      crlfDelay: Infinity
+    });
+    let lineCount = 0;
+    for await (const line of rl) {
+      if (++lineCount > 20) break;
+      if (!line.trim()) continue;
       try {
-        await killProcessCrossPlatform(entry.process);
-        swept.push(sessionId);
-        aliveCount--;
-      } catch (err) {
-        console.error(`[ProcessProvider] LRU kill failed for ${sessionId}:`, err);
+        const obj = JSON.parse(line);
+        if (obj.type === "user" && obj.message) {
+          const msgContent = obj.message.content;
+          let text = "";
+          if (typeof msgContent === "string") {
+            text = msgContent;
+          } else if (Array.isArray(msgContent)) {
+            const textBlock = msgContent.find((b) => b.type === "text" && typeof b.text === "string");
+            text = textBlock?.text ?? "";
+          }
+          if (text && !text.includes("<local-command") && !text.includes("<command-name>")) {
+            text = text.replace(/<ide_opened_file>[\s\S]*?<\/ide_opened_file>/gi, "");
+            text = text.replace(/<[^>]+>/g, "").trim();
+            rl.close();
+            return text.length > 80 ? text.slice(0, 80) + "..." : text;
+          }
+        }
+      } catch {
       }
     }
-    if (aliveCount > maxAlive) {
-      console.warn(`[ProcessProvider] LRU sweep: ${aliveCount} alive after sweep > limit ${maxAlive}; remaining are running/waiting`);
-    }
-    return swept;
+  } catch {
+  } finally {
+    await fileHandle?.close();
   }
-  // ============================================
-  // 私有方法
-  // ============================================
-  /**
-   * 启动 claude CLI 进程（持久模式，stdin 保持开放接收多条消息）
-   */
-  spawnClaudeProcess(sessionId, projectPath, resume = false, model, permissionMode, effort, fallbackModel, maxBudgetUsd) {
-    const args = [
-      "--input-format",
-      "stream-json",
-      "--output-format",
-      "stream-json",
-      "--verbose",
-      "--include-partial-messages",
-      "--include-hook-events"
-    ];
-    if (resume) {
-      args.push("--resume", sessionId);
-    } else {
-      args.push("--session-id", sessionId);
-    }
-    if (model) {
-      args.push("--model", model);
-    }
-    if (permissionMode && permissionMode !== "default") {
-      args.push("--permission-mode", permissionMode);
-    }
-    if (effort) {
-      args.push("--effort", effort);
-    }
-    if (fallbackModel) {
-      args.push("--fallback-model", fallbackModel);
-    }
-    if (maxBudgetUsd != null) {
-      args.push("--max-budget-usd", String(maxBudgetUsd));
-    }
-    const env = { ...process.env, SESSIX_SESSION_ID: sessionId };
-    delete env.CLAUDECODE;
-    const proc = (0, import_child_process.spawn)(CLAUDE_PATH, args, {
-      cwd: projectPath,
-      env,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return proc;
+  return void 0;
+}
+function decodeDirName(dirName) {
+  const placeholder = "\0";
+  const escaped = dirName.replace(/--/g, placeholder);
+  const decoded = escaped.replace(/-/g, "/");
+  return decoded.replace(new RegExp(placeholder, "g"), "-");
+}
+function encodeDirName(path2) {
+  const escaped = path2.replace(/-/g, "--");
+  return escaped.replace(/\//g, "-");
+}
+async function directoryExists(dirPath) {
+  try {
+    const s = await (0, import_promises.stat)(dirPath);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+async function countJsonlFilesWithMtime(dirPath) {
+  try {
+    const entries = await (0, import_promises.readdir)(dirPath, { withFileTypes: true });
+    const jsonlNames = new Set(
+      entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => e.name.slice(0, -6))
+    );
+    const uuidDirs = entries.filter(
+      (e) => e.isDirectory() && UUID_RE.test(e.name) && !jsonlNames.has(e.name)
+    );
+    let latestMtime = 0;
+    const jsonlEntries = entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl"));
+    await Promise.all([
+      ...jsonlEntries.map(async (entry) => {
+        try {
+          const contentTs = await extractLastTimestamp((0, import_path.join)(dirPath, entry.name));
+          const ts = contentTs ?? (await (0, import_promises.stat)((0, import_path.join)(dirPath, entry.name))).mtimeMs;
+          if (ts > latestMtime) latestMtime = ts;
+        } catch {
+        }
+      }),
+      ...uuidDirs.map(async (entry) => {
+        try {
+          const fileStat = await (0, import_promises.stat)((0, import_path.join)(dirPath, entry.name));
+          if (fileStat.mtimeMs > latestMtime) latestMtime = fileStat.mtimeMs;
+        } catch {
+        }
+      })
+    ]);
+    return { count: jsonlNames.size + uuidDirs.length, latestMtime };
+  } catch {
+    return { count: 0, latestMtime: 0 };
   }
+}
+
+// src/providers/ProcessProvider.ts
+var CLAUDE_PATH = findClaudePath();
+var ProcessProvider = class {
+  /** 活跃会话映射表：sessionId -> { session, process } */
+  activeSessions = /* @__PURE__ */ new Map();
+  /** 事件发射器，用于分发 Claude 事件流 */
+  emitter = new import_events.EventEmitter();
   /**
-   * 向持久进程的 stdin 写入一条用户消息（NDJSON 格式）
+   * 启动新会话或恢复已有会话
    *
-   * 写入失败时合成 error result 事件，确保 SessionManager 能感知到失败。
+   * 会 spawn 一个 `claude` CLI 进程，设置工作目录和环境变量，
+   * 并开始监听 stdout 的 NDJSON 输出。
    */
-  writeUserMessage(proc, message, sessionId, images) {
-    const content = [];
-    if (images?.length) {
-      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 }
-        });
-      }
+  async startSession(opts) {
+    const { projectPath, message, sessionId: existingSessionId, model, permissionMode, effort, images, fallbackModel, maxBudgetUsd } = opts;
+    const sessionId = existingSessionId ?? (0, import_uuid.v4)();
+    if (this.activeSessions.has(sessionId)) {
+      await this.killSession(sessionId);
     }
-    content.push({ type: "text", text: message });
-    const payload = JSON.stringify({
-      type: "user",
-      session_id: "",
-      message: { role: "user", content },
-      parent_tool_use_id: null
-    });
-    if (!proc.stdin || proc.stdin.destroyed) {
-      console.error(`[ProcessProvider] stdin unavailable, message lost`);
-      if (sessionId) {
-        this.emitWriteError(sessionId, "Process stdin closed, message not delivered");
+    const projectId = projectPath.split("/").filter(Boolean).pop() ?? "unknown";
+    const session = {
+      id: sessionId,
+      projectId,
+      projectPath,
+      status: "running",
+      createdAt: Date.now(),
+      lastActiveAt: Date.now(),
+      summary: message.slice(0, 80)
+    };
+    const resume = opts.resume ?? !!existingSessionId;
+    let effectiveModel = model;
+    if (resume && !effectiveModel) {
+      effectiveModel = await getSessionModel(projectPath, sessionId).catch(() => void 0);
+      if (effectiveModel) {
+        console.log(`[ProcessProvider] Session ${sessionId}: resume restored original model "${effectiveModel}"`);
       }
-      return;
     }
-    proc.stdin.write(payload + "\n", (err) => {
-      if (err && sessionId) {
-        console.error(`[ProcessProvider] Session ${sessionId} stdin write failed:`, err.message);
-        this.emitWriteError(sessionId, `Failed to send message: ${err.message}`);
-      }
-    });
-    if (sessionId) {
-      const syntheticUser = {
-        type: "user",
+    const proc = this.spawnClaudeProcess(sessionId, projectPath, resume, effectiveModel, permissionMode, effort, fallbackModel, maxBudgetUsd);
+    this.writeUserMessage(proc, message, sessionId, images);
+    session.pid = proc.pid;
+    this.activeSessions.set(sessionId, { session, process: proc, model: effectiveModel, permissionMode, effort, fallbackModel, maxBudgetUsd });
+    proc.on("error", (err) => {
+      console.error(`[ProcessProvider] Session ${sessionId} process error:`, err.message);
+      this.activeSessions.delete(sessionId);
+      const syntheticResult = {
+        type: "result",
+        subtype: "error",
+        result: `Process spawn failed: ${err.message}`,
         session_id: sessionId,
-        message: { role: "user", content }
+        duration_ms: 0,
+        is_error: true,
+        num_turns: 0
       };
-      this.emitter.emit(this.getEventName(sessionId), syntheticUser);
-    }
-  }
-  /**
-   * 发出写入失败的合成错误事件
-   */
-  emitWriteError(sessionId, message) {
-    const syntheticResult = {
-      type: "result",
-      subtype: "error",
-      result: message,
-      session_id: sessionId,
-      duration_ms: 0,
-      is_error: true,
-      num_turns: 0
-    };
-    this.emitter.emit(this.getEventName(sessionId), syntheticResult);
+      this.emitter.emit(this.getEventName(sessionId), syntheticResult);
+    });
+    this.attachStdoutListener(sessionId, proc);
+    this.attachStderrListener(sessionId, proc);
+    this.attachExitListener(sessionId, proc);
+    return session;
   }
   /**
-   * 挂载 stdout 监听器，逐行解析 NDJSON
+   * 终止指定会话
+   *
+   * kill 进程并从活跃映射中移除。
    */
-  attachStdoutListener(sessionId, proc) {
-    if (!proc.stdout) {
-      console.warn(`[ProcessProvider] Session ${sessionId}: stdout unavailable`);
-      return;
-    }
-    const rl = (0, import_readline.createInterface)({
-      input: proc.stdout,
-      crlfDelay: Infinity
-    });
+  async killSession(sessionId) {
     const entry = this.activeSessions.get(sessionId);
-    if (entry) {
-      entry.rl = rl;
+    if (!entry) {
+      return;
     }
-    rl.on("line", (line) => {
-      const trimmed = line.trim();
-      if (!trimmed) return;
-      const result = this.parseLine(trimmed);
-      if (result.ok) {
-        const event = result.value;
-        if (event.type === "assistant") {
-          for (const block of event.message.content) {
-            if (block.type === "tool_use") {
-              const isQuestion = block.name === "AskUserQuestion" || block.name === "AskFollowupQuestion";
-              if (!isQuestion) continue;
-              const input = block.input;
-              let question = "";
-              let options;
-              let questions;
-              if (typeof input.question === "string") {
-                question = input.question;
-                options = Array.isArray(input.options) ? input.options : void 0;
-              } else if (Array.isArray(input.questions) && input.questions.length > 0) {
-                questions = input.questions.map((q) => {
-                  const item = {
-                    question: typeof q.question === "string" ? q.question : "",
-                    header: typeof q.header === "string" ? q.header : void 0,
-                    multiSelect: typeof q.multiSelect === "boolean" ? q.multiSelect : void 0
-                  };
-                  if (Array.isArray(q.options)) {
-                    item.options = q.options.map((o) => ({
-                      label: typeof o.label === "string" ? o.label : String(o),
-                      description: typeof o.description === "string" ? o.description : void 0
-                    }));
-                  }
-                  return item;
-                });
-                const first = questions[0];
-                question = first.question;
-                options = first.options?.map((o) => o.label);
-              }
-              if (!question) continue;
-              const prevKey = `${block.id}:${question}:${JSON.stringify(options ?? [])}`;
-              let sessionSet = this.emittedQuestionToolUseIds.get(sessionId);
-              if (!sessionSet) {
-                sessionSet = /* @__PURE__ */ new Set();
-                this.emittedQuestionToolUseIds.set(sessionId, sessionSet);
-              }
-              if (sessionSet.has(prevKey)) continue;
-              sessionSet.add(prevKey);
-              console.log(`[ProcessProvider] Session ${sessionId}: detected ${block.name} (toolUseId=${block.id})`);
-              this.emitter.emit(this.getQuestionEventName(sessionId), {
-                toolUseId: block.id,
-                question,
-                options,
-                questions
-              });
-            }
-          }
-        }
-        this.updateSessionStatus(sessionId, event);
-        this.emitter.emit(this.getEventName(sessionId), event);
-      } else {
-        console.warn(
-          `[ProcessProvider] Session ${sessionId}: failed to parse line: ${trimmed.substring(0, 100)}`
-        );
-      }
-    });
-  }
-  /**
-   * 挂载 stderr 监听器，记录日志
-   */
-  attachStderrListener(sessionId, proc) {
-    if (!proc.stderr) return;
-    proc.stderr.on("data", (data) => {
-      const text = data.toString().trim();
-      if (text) {
-        console.error(`[ProcessProvider] Session ${sessionId} stderr: ${text}`);
+    if (entry.process.exitCode === null && entry.process.signalCode === null) {
+      try {
+        entry.process.stdin?.end();
+      } catch {
       }
-    });
+      await killProcessCrossPlatform(entry.process);
+    }
+    this.activeSessions.delete(sessionId);
   }
   /**
-   * 挂载进程退出监听器
+   * 向已有会话发送新消息
    *
-   * 当进程退出时发出合成的 result 事件，确保 SessionManager 能感知到退出。
-   * 正常退出时 Claude 会先通过 stdout 发送真实 result 事件，
-   * updateSessionStatus 会将 session.status 更新为 idle/error。
-   * 此时合成事件会重复触发，导致手机端出现两张总结卡。
-   * 修复：已收到真实 result（status 已为 idle/error）时跳过合成事件。
-   * 异常退出时（crash/OOM/killed）没有真实 result 事件，合成事件确保状态正确广播。
+   * 快速路径：进程存活时直接写 stdin（毫秒级响应）。
+   * 慢速路径：进程已退出时 respawn 并 --resume。
    */
-  attachExitListener(sessionId, proc) {
-    proc.once("exit", (code, signal) => {
-      const entry = this.activeSessions.get(sessionId);
-      if (!entry) return;
-      if (entry.process !== proc) return;
-      if (entry.rl) {
-        entry.rl.close();
-        entry.rl = void 0;
-      }
-      entry.session.pid = void 0;
+  async sendMessage(sessionId, message, permissionMode, images) {
+    const entry = this.activeSessions.get(sessionId);
+    if (!entry) {
+      throw new Error(`Session ${sessionId} not found or already ended`);
+    }
+    const modeChanged = permissionMode != null && permissionMode !== (entry.permissionMode ?? "default");
+    if (!modeChanged && entry.process.exitCode === null && entry.process.signalCode === null && !entry.process.stdin?.destroyed) {
+      entry.session.status = "running";
       entry.session.lastActiveAt = Date.now();
-      const alreadyHasResult = entry.session.status === "idle" || entry.session.status === "error";
-      if (alreadyHasResult) return;
-      const isNormal = isNormalExit(code, signal);
-      entry.session.status = isNormal ? "idle" : "error";
-      if (!isNormal) {
-        console.error(
-          `[ProcessProvider] Session ${sessionId}: process exited abnormally code=${code} signal=${signal}`
-        );
+      this.writeUserMessage(entry.process, message, sessionId, images);
+      return;
+    }
+    if (modeChanged) {
+      console.log(`[ProcessProvider] Session ${sessionId}: permission mode change ${entry.permissionMode ?? "default"} \u2192 ${permissionMode}, respawn`);
+      if (entry.process.exitCode === null && entry.process.signalCode === null) {
+        try {
+          entry.process.stdin?.end();
+        } catch {
+        }
+        killProcessCrossPlatform(entry.process);
       }
+    } else {
+      console.log(`[ProcessProvider] Session ${sessionId}: process exited, respawning`);
+    }
+    const newMode = permissionMode ?? entry.permissionMode;
+    const proc = this.spawnClaudeProcess(sessionId, entry.session.projectPath, true, entry.model, newMode, entry.effort, entry.fallbackModel, entry.maxBudgetUsd);
+    this.writeUserMessage(proc, message, sessionId, images);
+    entry.session.status = "running";
+    entry.session.lastActiveAt = Date.now();
+    entry.session.pid = proc.pid;
+    entry.process = proc;
+    entry.permissionMode = newMode;
+    proc.on("error", (err) => {
+      console.error(`[ProcessProvider] Session ${sessionId} sendMessage process error:`, err.message);
+      this.activeSessions.delete(sessionId);
       const syntheticResult = {
         type: "result",
-        subtype: isNormal ? "success" : "error",
+        subtype: "error",
+        result: `Failed to send message: ${err.message}`,
         session_id: sessionId,
-        is_error: !isNormal,
-        result: isNormal ? "" : `Process exited code=${code} signal=${signal}`,
         duration_ms: 0,
+        is_error: true,
         num_turns: 0
       };
       this.emitter.emit(this.getEventName(sessionId), syntheticResult);
     });
+    this.attachStdoutListener(sessionId, proc);
+    this.attachStderrListener(sessionId, proc);
+    this.attachExitListener(sessionId, proc);
   }
   /**
-   * 解析一行 NDJSON 文本为 ClaudeStreamEvent
+   * 订阅指定会话的 Claude 事件流
+   *
+   * @returns 取消订阅函数
    */
-  parseLine(line) {
-    try {
-      const parsed = JSON.parse(line);
-      return { ok: true, value: parsed };
-    } catch (err) {
-      return {
-        ok: false,
-        error: err instanceof Error ? err : new Error(String(err))
-      };
-    }
+  onEvent(sessionId, callback) {
+    const eventName = this.getEventName(sessionId);
+    this.emitter.on(eventName, callback);
+    return () => {
+      this.emitter.off(eventName, callback);
+    };
   }
   /**
-   * 根据 Claude 事件更新会话状态
+   * 获取当前所有活跃会话列表
    */
-  updateSessionStatus(sessionId, event) {
-    const entry = this.activeSessions.get(sessionId);
-    if (!entry) return;
-    entry.session.lastActiveAt = Date.now();
-    switch (event.type) {
-      case "system":
-        if (event.subtype === "init") {
-          entry.session.status = "running";
-        }
-        break;
-      case "assistant":
-        entry.session.status = "running";
-        break;
-      case "result":
-        entry.session.status = event.is_error ? "error" : "idle";
-        break;
-    }
+  getActiveSessions() {
+    return Array.from(this.activeSessions.values()).map((entry) => entry.session);
   }
   /**
-   * 根据对话上下文生成下一步建议指令
+   * 清理空闲进程
    *
-   * 使用 --output-format text 做一次性调用，返回纯文本结果。
+   * 找出所有 status='idle' 且 lastActiveAt 距今超过 maxIdleMs 的活跃进程，
+   * kill 进程释放内存。entry 保留在 activeSessions 中，用户下次 sendMessage
+   * 走 slow path 自动 --resume 重启进程。
+   *
+   * @returns 被 sweep 的 sessionId 列表
    */
-  async generateSuggestion(context) {
-    const prompt = `You are an AI coding assistant. Based on the following Claude Code conversation context, suggest the most valuable next instruction for the user (give the instruction directly, no explanation, no quotes):
-
-${context}`;
-    return new Promise((resolve, reject) => {
-      const env = { ...process.env };
-      delete env.CLAUDECODE;
-      const proc = (0, import_child_process.spawn)(CLAUDE_PATH, ["-p", prompt, "--output-format", "text"], {
-        cwd: (0, import_node_os2.homedir)(),
-        env,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      proc.stdin.end();
-      let output = "";
-      proc.stdout?.on("data", (data) => {
-        output += data.toString();
-      });
-      proc.once("exit", (code) => {
-        if (code === 0) {
-          resolve(output.trim());
-        } else {
-          reject(new Error(`generateSuggestion process exit code: ${code}`));
-        }
-      });
-      proc.once("error", reject);
-    });
+  async sweepIdleProcesses(maxIdleMs) {
+    const now = Date.now();
+    const swept = [];
+    for (const [sessionId, entry] of this.activeSessions) {
+      if (entry.process.exitCode !== null || entry.process.signalCode !== null) continue;
+      if (entry.session.status !== "idle") continue;
+      if (now - entry.session.lastActiveAt < maxIdleMs) continue;
+      const idleMin = Math.round((now - entry.session.lastActiveAt) / 6e4);
+      console.log(`[ProcessProvider] sweeping idle process: ${sessionId} (idle ${idleMin}m)`);
+      try {
+        entry.process.stdin?.end();
+      } catch {
+      }
+      try {
+        await killProcessCrossPlatform(entry.process);
+      } catch (err) {
+        console.error(`[ProcessProvider] sweep kill failed for ${sessionId}:`, err);
+        continue;
+      }
+      swept.push(sessionId);
+    }
+    return swept;
   }
   /**
-   * 向正在等待中的 AskUserQuestion 提供答案
+   * LRU 上限清理
+   *
+   * 当活跃进程数超过 maxAlive 时，按 lastActiveAt 升序（最久未用优先）kill
+   * 状态为 idle 的进程，直到活跃数回到上限以内。
+   * running / waiting_question 状态的进程永远不会被 kill。
    *
-   * 将答案写入 Claude 进程的 stdin（作为 tool_result），
-   * Claude 收到后继续执行。
+   * @returns 被 sweep 的 sessionId 列表
    */
-  async answerQuestion(sessionId, toolUseId, answer) {
-    const entry = this.activeSessions.get(sessionId);
-    if (!entry) {
-      throw new Error(`Session ${sessionId} not found`);
+  async sweepLruProcesses(maxAlive) {
+    const swept = [];
+    if (maxAlive <= 0) return swept;
+    const aliveEntries = Array.from(this.activeSessions.entries()).filter(
+      ([, e]) => e.process.exitCode === null && e.process.signalCode === null
+    );
+    if (aliveEntries.length <= maxAlive) return swept;
+    const idleSorted = aliveEntries.filter(([, e]) => e.session.status === "idle").sort((a, b) => a[1].session.lastActiveAt - b[1].session.lastActiveAt);
+    let aliveCount = aliveEntries.length;
+    for (const [sessionId, entry] of idleSorted) {
+      if (aliveCount <= maxAlive) break;
+      const idleMin = Math.round((Date.now() - entry.session.lastActiveAt) / 6e4);
+      console.log(`[ProcessProvider] LRU sweep: ${sessionId} (idle ${idleMin}m, alive=${aliveCount}/${maxAlive})`);
+      try {
+        entry.process.stdin?.end();
+      } catch {
+      }
+      try {
+        await killProcessCrossPlatform(entry.process);
+        swept.push(sessionId);
+        aliveCount--;
+      } catch (err) {
+        console.error(`[ProcessProvider] LRU kill failed for ${sessionId}:`, err);
+      }
     }
-    if (!entry.process.stdin || entry.process.stdin.destroyed) {
-      throw new Error(`Session ${sessionId} stdin unavailable`);
+    if (aliveCount > maxAlive) {
+      console.warn(`[ProcessProvider] LRU sweep: ${aliveCount} alive after sweep > limit ${maxAlive}; remaining are running/waiting`);
     }
-    const toolResult = JSON.stringify({
-      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) => {
-        if (err) reject(err);
-        else resolve();
-      });
-    });
-    console.log(`[ProcessProvider] Session ${sessionId}: AskUserQuestion answered (toolUseId=${toolUseId})`);
+    return swept;
   }
   /**
-   * 订阅指定会话的 AskUserQuestion 事件
+   * 枚举可淘汰的老会话
    *
-   * @returns 取消订阅函数
+   * 进程已退出（已被空闲 GC kill）且空闲超过 maxIdleMs 的会话——其 entry 与各 Map
+   * 仍长期占内存。调用方对返回 id 执行 killSession 彻底清除；淘汰后手机端发消息
+   * 会自动走 resume 路径（--resume + JSONL），不影响继续对话。
+   *
+   * @returns 可淘汰的 sessionId 列表（仅枚举，不删除）
    */
-  onQuestion(sessionId, callback) {
-    const eventName = this.getQuestionEventName(sessionId);
-    this.emitter.on(eventName, callback);
-    return () => {
-      this.emitter.off(eventName, callback);
-    };
+  listEvictableSessions(maxIdleMs) {
+    if (maxIdleMs <= 0) return [];
+    const now = Date.now();
+    const evictable = [];
+    for (const [sessionId, entry] of this.activeSessions) {
+      if (entry.process.exitCode === null && entry.process.signalCode === null) continue;
+      if (entry.session.status === "running" || entry.session.status === "waiting_question" || entry.session.status === "waiting_approval") continue;
+      if (now - entry.session.lastActiveAt < maxIdleMs) continue;
+      evictable.push(sessionId);
+    }
+    return evictable;
   }
+  // ============================================
+  // 私有方法
+  // ============================================
   /**
-   * 生成事件名称
+   * 启动 claude CLI 进程（持久模式，stdin 保持开放接收多条消息）
    */
-  getEventName(sessionId) {
-    return `claude:${sessionId}`;
+  spawnClaudeProcess(sessionId, projectPath, resume = false, model, permissionMode, effort, fallbackModel, maxBudgetUsd) {
+    const args = [
+      "--input-format",
+      "stream-json",
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--include-partial-messages",
+      "--include-hook-events"
+    ];
+    if (resume) {
+      args.push("--resume", sessionId);
+    } else {
+      args.push("--session-id", sessionId);
+    }
+    if (model) {
+      args.push("--model", model);
+    }
+    if (permissionMode && permissionMode !== "default") {
+      args.push("--permission-mode", permissionMode);
+    }
+    if (effort) {
+      args.push("--effort", effort);
+    }
+    if (fallbackModel) {
+      args.push("--fallback-model", fallbackModel);
+    }
+    if (maxBudgetUsd != null) {
+      args.push("--max-budget-usd", String(maxBudgetUsd));
+    }
+    const env = { ...process.env, SESSIX_SESSION_ID: sessionId };
+    delete env.CLAUDECODE;
+    const proc = (0, import_child_process.spawn)(CLAUDE_PATH, args, {
+      cwd: projectPath,
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return proc;
   }
   /**
-   * 生成 AskUserQuestion 内部事件名称
+   * 向持久进程的 stdin 写入一条用户消息（NDJSON 格式）
+   *
+   * 写入失败时合成 error result 事件，确保 SessionManager 能感知到失败。
    */
-  getQuestionEventName(sessionId) {
-    return `question:${sessionId}`;
-  }
-};
-
-// src/providers/CodexProvider.ts
-var import_child_process2 = require("child_process");
-var import_readline2 = require("readline");
-var import_events2 = require("events");
-var import_fs = require("fs");
-var import_path = require("path");
-var import_os = require("os");
-var import_uuid2 = require("uuid");
-
-// src/utils/codexPath.ts
-var import_node_child_process3 = require("child_process");
-var import_node_fs2 = require("fs");
-var import_node_path2 = require("path");
-var import_node_os3 = require("os");
+  writeUserMessage(proc, message, sessionId, images) {
+    const content = [];
+    if (images?.length) {
+      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 }
+        });
+      }
+    }
+    content.push({ type: "text", text: message });
+    const payload = JSON.stringify({
+      type: "user",
+      session_id: "",
+      message: { role: "user", content },
+      parent_tool_use_id: null
+    });
+    if (!proc.stdin || proc.stdin.destroyed) {
+      console.error(`[ProcessProvider] stdin unavailable, message lost`);
+      if (sessionId) {
+        this.emitWriteError(sessionId, "Process stdin closed, message not delivered");
+      }
+      return;
+    }
+    proc.stdin.write(payload + "\n", (err) => {
+      if (err && sessionId) {
+        console.error(`[ProcessProvider] Session ${sessionId} stdin write failed:`, err.message);
+        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);
+    }
+  }
+  /**
+   * 发出写入失败的合成错误事件
+   */
+  emitWriteError(sessionId, message) {
+    const syntheticResult = {
+      type: "result",
+      subtype: "error",
+      result: message,
+      session_id: sessionId,
+      duration_ms: 0,
+      is_error: true,
+      num_turns: 0
+    };
+    this.emitter.emit(this.getEventName(sessionId), syntheticResult);
+  }
+  /**
+   * 挂载 stdout 监听器，逐行解析 NDJSON
+   */
+  attachStdoutListener(sessionId, proc) {
+    if (!proc.stdout) {
+      console.warn(`[ProcessProvider] Session ${sessionId}: stdout unavailable`);
+      return;
+    }
+    const rl = (0, import_readline2.createInterface)({
+      input: proc.stdout,
+      crlfDelay: Infinity
+    });
+    const entry = this.activeSessions.get(sessionId);
+    if (entry) {
+      entry.rl = rl;
+    }
+    rl.on("line", (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      const result = this.parseLine(trimmed);
+      if (result.ok) {
+        const event = result.value;
+        this.updateSessionStatus(sessionId, event);
+        this.emitter.emit(this.getEventName(sessionId), event);
+      } else {
+        console.warn(
+          `[ProcessProvider] Session ${sessionId}: failed to parse line: ${trimmed.substring(0, 100)}`
+        );
+      }
+    });
+  }
+  /**
+   * 挂载 stderr 监听器，记录日志
+   */
+  attachStderrListener(sessionId, proc) {
+    if (!proc.stderr) return;
+    proc.stderr.on("data", (data) => {
+      const text = data.toString().trim();
+      if (text) {
+        console.error(`[ProcessProvider] Session ${sessionId} stderr: ${text}`);
+      }
+    });
+  }
+  /**
+   * 挂载进程退出监听器
+   *
+   * 当进程退出时发出合成的 result 事件，确保 SessionManager 能感知到退出。
+   * 正常退出时 Claude 会先通过 stdout 发送真实 result 事件，
+   * updateSessionStatus 会将 session.status 更新为 idle/error。
+   * 此时合成事件会重复触发，导致手机端出现两张总结卡。
+   * 修复：已收到真实 result（status 已为 idle/error）时跳过合成事件。
+   * 异常退出时（crash/OOM/killed）没有真实 result 事件，合成事件确保状态正确广播。
+   */
+  attachExitListener(sessionId, proc) {
+    proc.once("exit", (code, signal) => {
+      const entry = this.activeSessions.get(sessionId);
+      if (!entry) return;
+      if (entry.process !== proc) return;
+      if (entry.rl) {
+        entry.rl.close();
+        entry.rl = void 0;
+      }
+      entry.session.pid = void 0;
+      entry.session.lastActiveAt = Date.now();
+      const alreadyHasResult = entry.session.status === "idle" || entry.session.status === "error";
+      if (alreadyHasResult) return;
+      const isNormal = isNormalExit(code, signal);
+      entry.session.status = isNormal ? "idle" : "error";
+      if (!isNormal) {
+        console.error(
+          `[ProcessProvider] Session ${sessionId}: process exited abnormally code=${code} signal=${signal}`
+        );
+      }
+      const syntheticResult = {
+        type: "result",
+        subtype: isNormal ? "success" : "error",
+        session_id: sessionId,
+        is_error: !isNormal,
+        result: isNormal ? "" : `Process exited code=${code} signal=${signal}`,
+        duration_ms: 0,
+        num_turns: 0
+      };
+      this.emitter.emit(this.getEventName(sessionId), syntheticResult);
+    });
+  }
+  /**
+   * 解析一行 NDJSON 文本为 ClaudeStreamEvent
+   */
+  parseLine(line) {
+    try {
+      const parsed = JSON.parse(line);
+      return { ok: true, value: parsed };
+    } catch (err) {
+      return {
+        ok: false,
+        error: err instanceof Error ? err : new Error(String(err))
+      };
+    }
+  }
+  /**
+   * 根据 Claude 事件更新会话状态
+   */
+  updateSessionStatus(sessionId, event) {
+    const entry = this.activeSessions.get(sessionId);
+    if (!entry) return;
+    entry.session.lastActiveAt = Date.now();
+    switch (event.type) {
+      case "system":
+        if (event.subtype === "init") {
+          entry.session.status = "running";
+        }
+        break;
+      case "assistant":
+        entry.session.status = "running";
+        break;
+      case "result":
+        entry.session.status = event.is_error ? "error" : "idle";
+        break;
+    }
+  }
+  /**
+   * 根据对话上下文生成下一步建议指令
+   *
+   * 使用 --output-format text 做一次性调用，返回纯文本结果。
+   */
+  async generateSuggestion(context) {
+    const prompt = `You are an AI coding assistant. Based on the following Claude Code conversation context, suggest the most valuable next instruction for the user (give the instruction directly, no explanation, no quotes):
+
+${context}`;
+    return new Promise((resolve, reject) => {
+      const env = { ...process.env };
+      delete env.CLAUDECODE;
+      const proc = (0, import_child_process.spawn)(CLAUDE_PATH, ["-p", prompt, "--output-format", "text"], {
+        cwd: (0, import_node_os2.homedir)(),
+        env,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      proc.stdin.end();
+      let output = "";
+      proc.stdout?.on("data", (data) => {
+        output += data.toString();
+      });
+      proc.once("exit", (code) => {
+        if (code === 0) {
+          resolve(output.trim());
+        } else {
+          reject(new Error(`generateSuggestion process exit code: ${code}`));
+        }
+      });
+      proc.once("error", reject);
+    });
+  }
+  /**
+   * 生成事件名称
+   */
+  getEventName(sessionId) {
+    return `claude:${sessionId}`;
+  }
+};
+
+// src/providers/CodexProvider.ts
+var import_child_process2 = require("child_process");
+var import_readline3 = require("readline");
+var import_events2 = require("events");
+var import_fs = require("fs");
+var import_path2 = require("path");
+var import_os2 = require("os");
+var import_uuid2 = require("uuid");
+
+// src/utils/codexPath.ts
+var import_node_child_process3 = require("child_process");
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var import_node_os3 = require("os");
 function findCodexPath() {
   try {
     const cmd = isWindows ? "where codex" : "which codex";
@@ -1074,9 +1429,9 @@ function isCodexAvailable() {
 }
 
 // src/providers/CodexProvider.ts
-var SESSIX_DIR = (0, import_path.join)((0, import_os.homedir)(), ".sessix");
-var CODEX_SESSIONS_FILE = (0, import_path.join)(SESSIX_DIR, "codex-sessions.json");
-var CODEX_EVENTS_DIR = (0, import_path.join)(SESSIX_DIR, "codex-events");
+var SESSIX_DIR = (0, import_path2.join)((0, import_os2.homedir)(), ".sessix");
+var CODEX_SESSIONS_FILE = (0, import_path2.join)(SESSIX_DIR, "codex-sessions.json");
+var CODEX_EVENTS_DIR = (0, import_path2.join)(SESSIX_DIR, "codex-events");
 var SESSION_EXPIRY_MS = 30 * 24 * 60 * 60 * 1e3;
 var CodexProvider = class {
   activeSessions = /* @__PURE__ */ new Map();
@@ -1223,12 +1578,6 @@ var CodexProvider = class {
   async generateSuggestion(_context) {
     return "";
   }
-  async answerQuestion(_sessionId, _toolUseId, _answer) {
-  }
-  onQuestion(_sessionId, _callback) {
-    return () => {
-    };
-  }
   // ============================================
   // 私有方法
   // ============================================
@@ -1280,7 +1629,7 @@ var CodexProvider = class {
    */
   attachStdoutListener(sessionId, proc) {
     if (!proc.stdout) return;
-    const rl = (0, import_readline2.createInterface)({ input: proc.stdout, crlfDelay: Infinity });
+    const rl = (0, import_readline3.createInterface)({ input: proc.stdout, crlfDelay: Infinity });
     const entry = this.activeSessions.get(sessionId);
     if (entry) entry.rl = rl;
     rl.on("line", (line) => {
@@ -1562,9 +1911,9 @@ var CodexProvider = class {
    * 优先从内存读，miss 时从磁盘加载
    */
   getSessionHistory(sessionId) {
-    const cached = this.sessionEvents.get(sessionId);
-    if (cached && cached.length > 0) return cached;
-    const filePath = (0, import_path.join)(CODEX_EVENTS_DIR, `${sessionId}.json`);
+    const cached2 = this.sessionEvents.get(sessionId);
+    if (cached2 && cached2.length > 0) return cached2;
+    const filePath = (0, import_path2.join)(CODEX_EVENTS_DIR, `${sessionId}.json`);
     try {
       if (!(0, import_fs.existsSync)(filePath)) return [];
       const data = JSON.parse((0, import_fs.readFileSync)(filePath, "utf-8"));
@@ -1585,7 +1934,7 @@ var CodexProvider = class {
         (0, import_fs.mkdirSync)(CODEX_EVENTS_DIR, { recursive: true });
       }
       (0, import_fs.writeFileSync)(
-        (0, import_path.join)(CODEX_EVENTS_DIR, `${sessionId}.json`),
+        (0, import_path2.join)(CODEX_EVENTS_DIR, `${sessionId}.json`),
         JSON.stringify(events),
         "utf-8"
       );
@@ -1610,7 +1959,7 @@ var CodexProvider = class {
         if (now - m.lastActiveAt > SESSION_EXPIRY_MS) {
           expiredCount++;
           try {
-            const eventsFile = (0, import_path.join)(CODEX_EVENTS_DIR, `${sessionId}.json`);
+            const eventsFile = (0, import_path2.join)(CODEX_EVENTS_DIR, `${sessionId}.json`);
             if ((0, import_fs.existsSync)(eventsFile)) (0, import_fs.unlinkSync)(eventsFile);
           } catch {
           }
@@ -1723,7 +2072,6 @@ var ProviderFactory = class {
 };
 
 // src/session/SessionManager.ts
-var import_uuid3 = require("uuid");
 var BUFFER_MAX = 5e3;
 var SessionManager = class {
   provider;
@@ -1731,10 +2079,18 @@ var SessionManager = class {
   sessionAgentType = /* @__PURE__ */ new Map();
   /** 事件回调列表（事件会被转发到 WsBridge） */
   eventCallbacks = [];
+  /** 会话被移除（kill / 淘汰）时的回调列表（用于释放外部模块的会话级状态，如 NotificationService） */
+  sessionRemovedCallbacks = [];
   /** 每个会话的事件流取消订阅函数 */
   unsubscribeMap = /* @__PURE__ */ new Map();
   /** 每个会话的事件缓冲区（用于新订阅者重放）*/
   sessionEventBuffers = /* @__PURE__ */ new Map();
+  /**
+   * 每个会话最近一次 AskUserQuestion tool_use 的真实 id（从 claude_event 流捕获）。
+   * PreToolUse hook payload 不含 tool_use_id，但内联卡片需要它来匹配状态，
+   * 故在转发流事件时记录，askQuestion 时兜底回填。
+   */
+  lastAskQuestionToolUseId = /* @__PURE__ */ new Map();
   /** AskUserQuestion 问题映射：requestId → resolve 回调 + 原始问题内容 */
   pendingQuestions = /* @__PURE__ */ new Map();
   /**
@@ -1843,6 +2199,7 @@ var SessionManager = class {
     this.bufferTruncated.delete(sessionId);
     this.sessionProjectPaths.delete(sessionId);
     this.sessionStats.delete(sessionId);
+    this.lastAskQuestionToolUseId.delete(sessionId);
     const pending = this.pendingAssistantEvents.get(sessionId);
     if (pending) {
       clearTimeout(pending.timer);
@@ -1851,6 +2208,13 @@ var SessionManager = class {
     const provider = this.getProviderForSession(sessionId);
     await provider.killSession(sessionId);
     this.sessionAgentType.delete(sessionId);
+    for (const cb of this.sessionRemovedCallbacks) {
+      try {
+        cb(sessionId);
+      } catch (err) {
+        console.error("[SessionManager] sessionRemoved callback failed:", err);
+      }
+    }
     console.log(`[SessionManager] Session killed: ${sessionId}`);
   }
   /**
@@ -1903,7 +2267,22 @@ var SessionManager = class {
     }
   }
   /**
-   * 获取指定会话的所有待回答问题（用于重连时恢复）
+   * 幂等清理单个待回答问题（由 ApprovalProxy onQuestionResolved 触发：
+   * 答案到达 / 325s 超时 / 会话 kill / 服务关闭）。
+   * 已不存在则静默返回（不打 warn，与 handleQuestionResponse 区分）。
+   */
+  clearPendingQuestion(requestId) {
+    const pending = this.pendingQuestions.get(requestId);
+    if (!pending) return;
+    const { sessionId } = pending;
+    this.pendingQuestions.delete(requestId);
+    pending.resolve("");
+    if (!this.hasPendingQuestionsForSession(sessionId)) {
+      this.updateSessionStatus(sessionId, "running");
+    }
+  }
+  /**
+   * 获取指定会话的所有待回答问题（用于重连时恢复）
    */
   getPendingQuestionsForSession(sessionId) {
     const result = [];
@@ -2026,6 +2405,21 @@ var SessionManager = class {
       }
     };
   }
+  /**
+   * 注册"会话被移除"回调（会话 kill 或淘汰时触发，传入 sessionId）。
+   * 用于让外部模块释放会话级状态，如 NotificationService.releaseSession。
+   *
+   * @returns 取消注册的函数
+   */
+  onSessionRemoved(callback) {
+    this.sessionRemovedCallbacks.push(callback);
+    return () => {
+      const index = this.sessionRemovedCallbacks.indexOf(callback);
+      if (index !== -1) {
+        this.sessionRemovedCallbacks.splice(index, 1);
+      }
+    };
+  }
   /**
    * 清理所有资源
    */
@@ -2043,31 +2437,28 @@ var SessionManager = class {
       clearTimeout(pending.timer);
     }
     this.pendingAssistantEvents.clear();
+    for (const pending of this.pendingQuestions.values()) {
+      pending.resolve("");
+    }
     this.pendingQuestions.clear();
     this.lastBroadcastStatus.clear();
     this.eventCallbacks.length = 0;
+    this.sessionRemovedCallbacks.length = 0;
     console.log("[SessionManager] Destroyed");
   }
   // ============================================
   // 内部方法
   // ============================================
   /**
-   * 订阅指定会话的事件流（包括 AskUserQuestion 问题事件）
+   * 订阅指定会话的事件流（AskUserQuestion 已改由 ApprovalProxy hook 驱动）
    */
   subscribeToSession(sessionId) {
     const provider = this.getProviderForSession(sessionId);
     const unsubscribeEvent = provider.onEvent(sessionId, (event) => {
       this.handleClaudeEvent(sessionId, event);
     });
-    const unsubscribeQuestion = provider.onQuestion(
-      sessionId,
-      ({ toolUseId, question, options, questions }) => {
-        this.handleAskUserQuestion(sessionId, toolUseId, question, options, questions);
-      }
-    );
     this.unsubscribeMap.set(sessionId, () => {
       unsubscribeEvent();
-      unsubscribeQuestion();
     });
   }
   /**
@@ -2101,6 +2492,13 @@ var SessionManager = class {
         console.log(`[SessionManager] \u{1F9E0} thinking block detected in ${sessionId}: msgId=${event.message.id}, blocks=${thinkingBlocks.length}, len=${thinkingBlocks.map((b) => (b.thinking || "").length).join(",")}`);
       }
     }
+    if (event.type === "assistant" && Array.isArray(event.message?.content)) {
+      for (const block of event.message.content) {
+        if (block.type === "tool_use" && (block.name === "AskUserQuestion" || block.name === "AskFollowupQuestion") && typeof block.id === "string") {
+          this.lastAskQuestionToolUseId.set(sessionId, block.id);
+        }
+      }
+    }
     switch (event.type) {
       case "assistant":
         this.bufferAssistantEvent(sessionId, event);
@@ -2216,55 +2614,35 @@ var SessionManager = class {
     return runningStartedAt ? { ...base, runningStartedAt } : base;
   }
   /**
-   * 处理 AskUserQuestion 事件：广播问题请求到手机，等待用户回答
+   * 由 ApprovalProxy 在 PreToolUse hook 拦截到 AskUserQuestion 时调用。
+   * 登记 pendingQuestion、广播 question_request、置 waiting_question，
+   * 返回的 Promise 在 handleQuestionResponse 时 resolve。
    */
-  handleAskUserQuestion(sessionId, toolUseId, question, options, questions) {
-    const existingEntry = Array.from(this.pendingQuestions.entries()).find(
-      ([, v]) => v.toolUseId === toolUseId
-    );
-    if (existingEntry) {
-      const [existingRequestId, existingPending] = existingEntry;
-      existingPending.question = question;
-      existingPending.options = options;
-      existingPending.questions = questions;
-      existingPending.createdAt = Date.now();
-      const updatedRequest = {
-        id: existingRequestId,
-        sessionId,
-        toolUseId,
-        question,
-        options,
-        questions,
-        createdAt: existingPending.createdAt
-      };
-      this.emit({ type: "question_request", request: updatedRequest });
-      console.log(`[SessionManager] Session ${sessionId}: AskUserQuestion updated (requestId=${existingRequestId})`);
-      return;
-    }
-    const requestId = (0, import_uuid3.v4)();
+  askQuestion(sessionId, toolUseId, questions, requestId) {
+    const resolvedToolUseId = toolUseId || this.lastAskQuestionToolUseId.get(sessionId) || "";
     const request = {
       id: requestId,
       sessionId,
-      toolUseId,
-      question,
-      options,
+      toolUseId: resolvedToolUseId,
+      question: questions[0]?.question ?? "",
+      options: questions[0]?.options?.map((o) => o.label),
       questions,
       createdAt: Date.now()
     };
     this.updateSessionStatus(sessionId, "waiting_question");
     this.emit({ type: "question_request", request });
-    const answerPromise = new Promise((resolve) => {
-      this.pendingQuestions.set(requestId, { sessionId, toolUseId, question, options, questions, createdAt: request.createdAt, resolve });
-    });
-    answerPromise.then(async (answer) => {
-      try {
-        const provider = this.getProviderForSession(sessionId);
-        await provider.answerQuestion(sessionId, toolUseId, answer);
-      } catch (err) {
-        console.error(`[SessionManager] answerQuestion failed (${sessionId}):`, err);
-      }
-    }).catch((err) => console.error("[SessionManager] answerPromise rejected:", err));
     console.log(`[SessionManager] Session ${sessionId}: AskUserQuestion pushed (requestId=${requestId})`);
+    return new Promise((resolve) => {
+      this.pendingQuestions.set(requestId, {
+        sessionId,
+        toolUseId: resolvedToolUseId,
+        question: request.question,
+        options: request.options,
+        questions,
+        createdAt: request.createdAt,
+        resolve
+      });
+    });
   }
   /**
    * 清除指定会话的所有待回答问题
@@ -2277,6 +2655,7 @@ var SessionManager = class {
       }
     }
     for (const requestId of toRemove) {
+      this.pendingQuestions.get(requestId)?.resolve("");
       this.pendingQuestions.delete(requestId);
     }
   }
@@ -2296,7 +2675,7 @@ var SessionManager = class {
 
 // src/session/SessionFileWatcher.ts
 var import_chokidar = __toESM(require("chokidar"));
-var import_promises = require("fs/promises");
+var import_promises2 = require("fs/promises");
 var import_node_readline = require("readline");
 var SessionFileWatcher = class {
   watchers = /* @__PURE__ */ new Map();
@@ -2375,7 +2754,7 @@ var SessionFileWatcher = class {
     let fileHandle;
     let rl;
     try {
-      fileHandle = await (0, import_promises.open)(entry.filePath, "r");
+      fileHandle = await (0, import_promises2.open)(entry.filePath, "r");
       const fileStat = await fileHandle.stat();
       const newSize = fileStat.size;
       if (newSize <= entry.byteOffset) return;
@@ -2685,7 +3064,7 @@ var import_node_http = __toESM(require("http"));
 var import_node_fs3 = __toESM(require("fs"));
 var import_node_path3 = __toESM(require("path"));
 var import_node_os4 = __toESM(require("os"));
-var import_uuid4 = require("uuid");
+var import_uuid3 = require("uuid");
 var ApprovalProxy = class _ApprovalProxy {
   server;
   token;
@@ -2693,10 +3072,16 @@ var ApprovalProxy = class _ApprovalProxy {
   settingsPath = import_node_path3.default.join(import_node_os4.default.homedir(), ".claude", "settings.json");
   /** 待处理的审批请求：requestId -> { resolve, timer, request } */
   pendingApprovals = /* @__PURE__ */ new Map();
+  /** 待回答的 AskUserQuestion：requestId -> { resolve, timer, request } */
+  pendingQuestions = /* @__PURE__ */ new Map();
+  /** 由外部注入：把问题推给手机并等待答案（返回用户答案文本） */
+  questionHandler = null;
   /** 审批请求回调（通知外部推送到手机） */
   approvalRequestCallbacks = [];
   /** 审批 resolve 回调（任何来源的 resolve 都会触发，用于 WS 广播清理 */
   approvalResolvedCallbacks = [];
+  /** 问题 resolve 回调（任何来源的 resolve 都会触发，用于 SessionManager 清理） */
+  questionResolvedCallbacks = [];
   /** Hook 通知回调（PreCompact / PermissionDenied / 等非阻塞 hook） */
   notifyCallbacks = [];
   /** YOLO 模式状态：sessionId -> enabled */
@@ -2760,6 +3145,30 @@ var ApprovalProxy = class _ApprovalProxy {
       }
     }
   }
+  /**
+   * 注册问题 resolve 回调
+   *
+   * 任何来源的 resolve 都会触发：
+   * - resolveQuestion（手机端答案到达）
+   * - 325s 超时自动空答案
+   * - clearPendingQuestionsForSession（会话被 kill）
+   * - close()（服务关闭）
+   *
+   * 用于通知 SessionManager 清理 pendingQuestions，避免会话卡在 waiting_question。
+   */
+  onQuestionResolved(callback) {
+    this.questionResolvedCallbacks.push(callback);
+  }
+  /** 通知所有问题 resolve 回调（内部调用） */
+  notifyQuestionResolved(requestId) {
+    for (const cb of this.questionResolvedCallbacks) {
+      try {
+        cb(requestId);
+      } catch (err) {
+        console.error("[ApprovalProxy] question resolved callback error:", err);
+      }
+    }
+  }
   /**
    * 注册非阻塞 hook 通知回调（如 PreCompact、PermissionDenied）
    *
@@ -2814,6 +3223,42 @@ var ApprovalProxy = class _ApprovalProxy {
     this.notifyApprovalResolved(requestId, decision);
     return true;
   }
+  /** 注入问题处理器（server.ts 接到 SessionManager.askQuestion） */
+  setQuestionHandler(handler) {
+    this.questionHandler = handler;
+  }
+  /** 解析一个待回答问题（手机端答案到达时由 server.ts 调用） */
+  resolveQuestion(requestId, answer) {
+    const pending = this.pendingQuestions.get(requestId);
+    if (!pending) {
+      console.warn(`[ApprovalProxy] Question request not found: ${requestId}`);
+      return false;
+    }
+    clearTimeout(pending.timer);
+    pending.resolve(answer);
+    this.pendingQuestions.delete(requestId);
+    console.log(`[ApprovalProxy] Question answered: ${requestId}`);
+    this.notifyQuestionResolved(requestId);
+    return true;
+  }
+  /** 清理会话的待回答问题（会话被 kill 时，给空答案让 hook 不再阻塞） */
+  clearPendingQuestionsForSession(sessionId) {
+    const toRemove = [];
+    for (const [requestId, pending] of this.pendingQuestions) {
+      if (pending.request.sessionId === sessionId) {
+        toRemove.push(requestId);
+      }
+    }
+    for (const requestId of toRemove) {
+      const pending = this.pendingQuestions.get(requestId);
+      if (!pending) continue;
+      clearTimeout(pending.timer);
+      pending.resolve("");
+      this.pendingQuestions.delete(requestId);
+      console.log(`[ApprovalProxy] Session ${sessionId} killed, cleared pending question ${requestId}`);
+      this.notifyQuestionResolved(requestId);
+    }
+  }
   /** 获取当前待处理的审批数量 */
   getPendingCount() {
     return this.pendingApprovals.size;
@@ -2935,6 +3380,13 @@ var ApprovalProxy = class _ApprovalProxy {
         pending.resolve({ decision: "deny", reason: t("approval.serverClosed") });
       }
       this.pendingApprovals.clear();
+      const pendingQuestionEntries = Array.from(this.pendingQuestions.entries());
+      for (const [requestId, pending] of pendingQuestionEntries) {
+        clearTimeout(pending.timer);
+        pending.resolve("");
+        this.notifyQuestionResolved(requestId);
+      }
+      this.pendingQuestions.clear();
       this.server.close((err) => {
         if (err) {
           reject(err);
@@ -2990,7 +3442,7 @@ var ApprovalProxy = class _ApprovalProxy {
     try {
       const body = await this.parseJsonBody(req);
       const payload = body.payload ?? body;
-      const requestId = (0, import_uuid4.v4)();
+      const requestId = (0, import_uuid3.v4)();
       const projectPath = String(body.projectPath ?? "unknown");
       const toolName = String(payload.tool_name ?? body.tool_name ?? "unknown");
       const toolInput = payload.tool_input ?? body.tool_input ?? {};
@@ -3004,6 +3456,51 @@ var ApprovalProxy = class _ApprovalProxy {
         createdAt: Date.now()
       };
       console.log(`[ApprovalProxy] ${t("approval.received")}: ${requestId} (${approvalRequest.toolName})`);
+      if ((approvalRequest.toolName === "AskUserQuestion" || approvalRequest.toolName === "AskFollowupQuestion") && this.questionHandler) {
+        const questions = parseQuestionsFromInput(toolInput);
+        if (questions.length === 0) {
+          this.sendJson(res, 200, { decision: "allow" });
+          return;
+        }
+        const toolUseId = String(
+          payload.tool_use_id ?? body.tool_use_id ?? ""
+        );
+        const qRequest = {
+          id: requestId,
+          sessionId: approvalRequest.sessionId,
+          toolUseId,
+          question: questions[0].question,
+          options: questions[0].options?.map((o) => o.label),
+          questions,
+          createdAt: Date.now()
+        };
+        const answer = await new Promise((resolve) => {
+          const timer = setTimeout(() => {
+            this.pendingQuestions.delete(requestId);
+            console.log(`[ApprovalProxy] Question timeout: ${requestId}`);
+            resolve("");
+            this.notifyQuestionResolved(requestId);
+          }, 325e3);
+          this.pendingQuestions.set(requestId, { resolve, timer, request: qRequest });
+          this.questionHandler(qRequest.sessionId, toolUseId, questions, requestId).then((ans) => {
+            if (ans && this.pendingQuestions.has(requestId)) this.resolveQuestion(requestId, ans);
+          }).catch((err) => console.error("[ApprovalProxy] questionHandler error:", err));
+        });
+        if (!answer) {
+          this.sendJson(res, 200, {
+            decision: "deny",
+            reason: "\u7528\u6237\u672A\u5728\u9650\u5B9A\u65F6\u95F4\u5185\u56DE\u7B54\u8BE5\u95EE\u9898\u3002\u8BF7\u57FA\u4E8E\u73B0\u6709\u4FE1\u606F\u81EA\u884C\u51B3\u7B56\u540E\u7EE7\u7EED\uFF0C\u4E0D\u8981\u91CD\u590D\u8C03\u7528 AskUserQuestion\u3002",
+            systemMessage: "\u7528\u6237\u672A\u56DE\u7B54 AskUserQuestion\uFF1B\u8BF7\u52FF\u91CD\u8BD5\u8BE5\u5DE5\u5177\uFF0C\u81EA\u884C\u51B3\u7B56\u7EE7\u7EED\u3002"
+          });
+          return;
+        }
+        this.sendJson(res, 200, {
+          decision: "deny",
+          reason: formatQuestionAnswer(questions, answer),
+          systemMessage: "\u7528\u6237\u5DF2\u901A\u8FC7 Sessix \u79FB\u52A8\u7AEF\u56DE\u7B54\u4E86 AskUserQuestion\uFF0C\u56DE\u7B54\u5728\u5DE5\u5177\u53CD\u9988\u4E2D\u7ED9\u51FA\u3002\u8BF7\u5C06\u5176\u89C6\u4E3A\u8BE5\u5DE5\u5177\u7684\u6709\u6548\u8FD4\u56DE\u76F4\u63A5\u7EE7\u7EED\uFF0C\u4E0D\u8981\u518D\u6B21\u8C03\u7528 AskUserQuestion/AskFollowupQuestion\u3002"
+        });
+        return;
+      }
       if (this.isToolAlwaysAllowed(approvalRequest.toolName, projectPath !== "unknown" ? projectPath : void 0)) {
         console.log(`[ApprovalProxy] ${t("approval.alwaysAllowPassThrough", { tool: approvalRequest.toolName })}`);
         this.sendJson(res, 200, { decision: "allow" });
@@ -3193,6 +3690,49 @@ var ApprovalProxy = class _ApprovalProxy {
     res.end(body);
   }
 };
+function parseQuestionsFromInput(input) {
+  if (Array.isArray(input.questions) && input.questions.length > 0) {
+    return input.questions.map((q) => {
+      const item = {
+        question: typeof q.question === "string" ? q.question : "",
+        header: typeof q.header === "string" ? q.header : void 0,
+        multiSelect: typeof q.multiSelect === "boolean" ? q.multiSelect : void 0
+      };
+      if (Array.isArray(q.options)) {
+        item.options = q.options.map((o) => ({
+          label: typeof o.label === "string" ? o.label : "",
+          description: typeof o.description === "string" ? o.description : void 0
+        }));
+      }
+      return item;
+    });
+  }
+  if (typeof input.question === "string") {
+    const opts = Array.isArray(input.options) ? input.options.map((o) => ({ label: String(o) })) : void 0;
+    return [{ question: input.question, options: opts }];
+  }
+  return [];
+}
+function formatQuestionAnswer(questions, raw) {
+  let pairs = [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && parsed.answers && typeof parsed.answers === "object") {
+      const answers = parsed.answers;
+      pairs = questions.length > 0 ? questions.map((item) => ({ q: item.question, a: String(answers[item.question] ?? "") })) : Object.entries(answers).map(([q, a]) => ({ q, a: String(a) }));
+    }
+  } catch {
+  }
+  if (pairs.length === 0) {
+    pairs = [{ q: questions[0]?.question ?? "\uFF08\u672A\u77E5\u95EE\u9898\uFF09", a: raw }];
+  }
+  const body = pairs.map((p, i) => `${i + 1}. \u95EE\u9898\uFF1A${p.q}
+   \u7528\u6237\u56DE\u7B54\uFF1A${p.a}`).join("\n");
+  return `\u3010\u7528\u6237\u5DF2\u901A\u8FC7 Sessix \u56DE\u7B54\u3011
+${body}
+
+\u8BF7\u5C06\u4EE5\u4E0A\u56DE\u7B54\u89C6\u4E3A AskUserQuestion \u7684\u6709\u6548\u8FD4\u56DE\uFF0C\u76F4\u63A5\u636E\u6B64\u7EE7\u7EED\u5B8C\u6210\u4EFB\u52A1\uFF0C\u4E0D\u8981\u518D\u6B21\u8C03\u7528 AskUserQuestion/AskFollowupQuestion\u3002`;
+}
 
 // src/mdns/MdnsService.ts
 var import_node_child_process5 = require("child_process");
@@ -3358,7 +3898,7 @@ function getLanAddresses(networkInterfacesFn) {
 }
 
 // src/hooks/HookInstaller.ts
-var import_promises2 = require("fs/promises");
+var import_promises3 = require("fs/promises");
 var import_node_path4 = require("path");
 var import_node_os6 = require("os");
 var SESSIX_HOOKS_DIR = (0, import_node_path4.join)((0, import_node_os6.homedir)(), ".sessix", "hooks");
@@ -3378,7 +3918,7 @@ var LEGACY_HOOK_COMMANDS = [
   "~/.sessix/hooks/permission-accept.sh"
 ];
 var HOOK_SCRIPT_TEMPLATE = `#!/usr/bin/env node
-// Sessix Approval Hook
+// Sessix Approval Hook v2 (systemMessage passthrough)
 // \u4EC5\u5728 Sessix \u7BA1\u7406\u7684\u4F1A\u8BDD\u4E2D\u6FC0\u6D3B
 
 const sessionId = process.env.SESSIX_SESSION_ID
@@ -3409,6 +3949,9 @@ process.stdin.on('end', async () => {
     if (decision === 'deny' && data.reason) {
       output.hookSpecificOutput.permissionDecisionReason = String(data.reason)
     }
+    if (data.systemMessage) {
+      output.systemMessage = String(data.systemMessage)
+    }
     process.stdout.write(JSON.stringify(output))
     process.exit(0)
   } catch {
@@ -3548,17 +4091,17 @@ var HookInstaller = class {
    * 4. 更新 Claude Code settings.json 添加 hook 配置
    */
   async install() {
-    await (0, import_promises2.mkdir)(SESSIX_HOOKS_DIR, { recursive: true });
-    await (0, import_promises2.writeFile)(HOOK_SCRIPT_PATH, HOOK_SCRIPT_TEMPLATE, "utf-8");
-    await (0, import_promises2.writeFile)(PERMISSION_ACCEPT_PATH, PERMISSION_ACCEPT_TEMPLATE, "utf-8");
-    await (0, import_promises2.writeFile)(COMPACT_HOOK_PATH, COMPACT_HOOK_TEMPLATE, "utf-8");
-    await (0, import_promises2.writeFile)(POST_COMPACT_HOOK_PATH, POST_COMPACT_HOOK_TEMPLATE, "utf-8");
-    await (0, import_promises2.writeFile)(PERMISSION_DENIED_HOOK_PATH, PERMISSION_DENIED_HOOK_TEMPLATE, "utf-8");
-    await (0, import_promises2.chmod)(HOOK_SCRIPT_PATH, 493);
-    await (0, import_promises2.chmod)(PERMISSION_ACCEPT_PATH, 493);
-    await (0, import_promises2.chmod)(COMPACT_HOOK_PATH, 493);
-    await (0, import_promises2.chmod)(POST_COMPACT_HOOK_PATH, 493);
-    await (0, import_promises2.chmod)(PERMISSION_DENIED_HOOK_PATH, 493);
+    await (0, import_promises3.mkdir)(SESSIX_HOOKS_DIR, { recursive: true });
+    await (0, import_promises3.writeFile)(HOOK_SCRIPT_PATH, HOOK_SCRIPT_TEMPLATE, "utf-8");
+    await (0, import_promises3.writeFile)(PERMISSION_ACCEPT_PATH, PERMISSION_ACCEPT_TEMPLATE, "utf-8");
+    await (0, import_promises3.writeFile)(COMPACT_HOOK_PATH, COMPACT_HOOK_TEMPLATE, "utf-8");
+    await (0, import_promises3.writeFile)(POST_COMPACT_HOOK_PATH, POST_COMPACT_HOOK_TEMPLATE, "utf-8");
+    await (0, import_promises3.writeFile)(PERMISSION_DENIED_HOOK_PATH, PERMISSION_DENIED_HOOK_TEMPLATE, "utf-8");
+    await (0, import_promises3.chmod)(HOOK_SCRIPT_PATH, 493);
+    await (0, import_promises3.chmod)(PERMISSION_ACCEPT_PATH, 493);
+    await (0, import_promises3.chmod)(COMPACT_HOOK_PATH, 493);
+    await (0, import_promises3.chmod)(POST_COMPACT_HOOK_PATH, 493);
+    await (0, import_promises3.chmod)(PERMISSION_DENIED_HOOK_PATH, 493);
     await this.addHookToSettings();
     console.log("[HookInstaller] Hook installation complete");
   }
@@ -3588,33 +4131,34 @@ var HookInstaller = class {
     let postCompactScriptExists = false;
     let permissionDeniedScriptExists = false;
     try {
-      approvalScriptContent = await (0, import_promises2.readFile)(HOOK_SCRIPT_PATH, "utf-8");
+      approvalScriptContent = await (0, import_promises3.readFile)(HOOK_SCRIPT_PATH, "utf-8");
     } catch {
     }
     try {
-      await (0, import_promises2.access)(PERMISSION_ACCEPT_PATH);
+      await (0, import_promises3.access)(PERMISSION_ACCEPT_PATH);
       permissionScriptExists = true;
     } catch {
     }
     try {
-      await (0, import_promises2.access)(COMPACT_HOOK_PATH);
+      await (0, import_promises3.access)(COMPACT_HOOK_PATH);
       compactScriptExists = true;
     } catch {
     }
     try {
-      await (0, import_promises2.access)(POST_COMPACT_HOOK_PATH);
+      await (0, import_promises3.access)(POST_COMPACT_HOOK_PATH);
       postCompactScriptExists = true;
     } catch {
     }
     try {
-      await (0, import_promises2.access)(PERMISSION_DENIED_HOOK_PATH);
+      await (0, import_promises3.access)(PERMISSION_DENIED_HOOK_PATH);
       permissionDeniedScriptExists = true;
     } catch {
     }
-    const isLatestVersion = approvalScriptContent.includes("permissionDecision");
+    const isLatestVersion = approvalScriptContent.includes("permissionDecision") && approvalScriptContent.includes("Sessix Approval Hook v2");
     const settings = await this.readClaudeSettings();
     const configExists = this.hasHookConfig(settings);
-    return isLatestVersion && permissionScriptExists && compactScriptExists && postCompactScriptExists && permissionDeniedScriptExists && configExists;
+    const hasLegacyHook = this.hasHookEntry(settings?.hooks?.PreToolUse, LEGACY_HOOK_COMMANDS[0]) || this.hasHookEntry(settings?.hooks?.PermissionRequest, LEGACY_HOOK_COMMANDS[1]);
+    return isLatestVersion && permissionScriptExists && compactScriptExists && postCompactScriptExists && permissionDeniedScriptExists && configExists && !hasLegacyHook;
   }
   // ============================================
   // 内部方法
@@ -3626,8 +4170,14 @@ var HookInstaller = class {
     let settings = await this.readClaudeSettings();
     let changed = false;
     for (const cmd of LEGACY_HOOK_COMMANDS) {
-      this.removeHookCommand(settings, "PreToolUse", cmd);
-      this.removeHookCommand(settings, "PermissionRequest", cmd);
+      if (this.hasHookEntry(settings?.hooks?.PreToolUse, cmd)) {
+        this.removeHookCommand(settings, "PreToolUse", cmd);
+        changed = true;
+      }
+      if (this.hasHookEntry(settings?.hooks?.PermissionRequest, cmd)) {
+        this.removeHookCommand(settings, "PermissionRequest", cmd);
+        changed = true;
+      }
     }
     if (!settings.hooks) {
       settings.hooks = {};
@@ -3719,7 +4269,7 @@ var HookInstaller = class {
    */
   async readClaudeSettings() {
     try {
-      const content = await (0, import_promises2.readFile)(CLAUDE_SETTINGS_PATH, "utf-8");
+      const content = await (0, import_promises3.readFile)(CLAUDE_SETTINGS_PATH, "utf-8");
       return JSON.parse(content);
     } catch {
       return {};
@@ -3729,8 +4279,8 @@ var HookInstaller = class {
    * 写入 Claude Code settings.json
    */
   async writeClaudeSettings(settings) {
-    await (0, import_promises2.mkdir)((0, import_node_path4.join)((0, import_node_os6.homedir)(), ".claude"), { recursive: true });
-    await (0, import_promises2.writeFile)(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    await (0, import_promises3.mkdir)((0, import_node_path4.join)((0, import_node_os6.homedir)(), ".claude"), { recursive: true });
+    await (0, import_promises3.writeFile)(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n", "utf-8");
   }
   /**
    * 检查 settings 中是否已包含所有 Sessix hook 配置
@@ -3771,7 +4321,7 @@ var HookInstaller = class {
 var import_node_path5 = require("path");
 var RECENT_ACTIVITY_MAX = 6;
 var ACTIVITY_PUSH_THROTTLE_MS = 4e3;
-var NotificationService = class {
+var NotificationService = class _NotificationService {
   constructor(sessionManager, expoChannel = null) {
     this.sessionManager = sessionManager;
     this.expoChannel = expoChannel;
@@ -3813,6 +4363,14 @@ var NotificationService = class {
    * token 注册时启动，flushActivityEnd / removeActivityPushToken 时停止。
    */
   laHeartbeatTimers = /* @__PURE__ */ new Map();
+  /**
+   * 上次推送的内容指纹（status + recentActivity + approvalId）。
+   * 只在内容实际变化时发 priority-10 推送；未变化时低频刷新（30s），
+   * 节省 APNs push budget，避免 iOS 节流导致 LA 停滞。
+   */
+  lastPushedFingerprint = /* @__PURE__ */ new Map();
+  /** 内容未变化时低频刷新间隔（仅刷新 stats/timer，不含内容变化） */
+  static STATS_REFRESH_INTERVAL_MS = 3e4;
   /** 添加通知渠道（id 唯一，可用于后续动态开关） */
   addChannel(id, channel, enabled = true) {
     this.channelMap.set(id, { channel, enabled });
@@ -3869,6 +4427,7 @@ var NotificationService = class {
     this.recentActivityState.delete(sessionId);
     this.lastActivityPushAt.delete(sessionId);
     this.activityCounters.delete(sessionId);
+    this.lastPushedFingerprint.delete(sessionId);
   }
   /** 注入"会话 → 待审批列表"提供器（server.ts 启动时调用） */
   setPendingApprovalsProvider(fn) {
@@ -4015,10 +4574,39 @@ var NotificationService = class {
     this.latestAssistantText.clear();
     for (const timer of this.activityPushTimers.values()) clearTimeout(timer);
     this.activityPushTimers.clear();
+    for (const timer of this.idleEndTimers.values()) clearTimeout(timer);
+    this.idleEndTimers.clear();
+    for (const timer of this.laHeartbeatTimers.values()) clearInterval(timer);
+    this.laHeartbeatTimers.clear();
     this.recentActivityState.clear();
     this.lastActivityPushAt.clear();
     this.pendingPriority.clear();
     this.activityCounters.clear();
+    this.lastPushedFingerprint.clear();
+  }
+  /**
+   * 释放单个会话的全部内存状态（会话被 kill 或淘汰时调用）。
+   * 由 SessionManager.onSessionRemoved 钩子触发，覆盖用户主动 kill 和自动淘汰两条路径。
+   * 幂等：重复调用或对未知会话调用都安全。
+   */
+  releaseSession(sessionId) {
+    this.clearActivityPushTimer(sessionId);
+    this.cancelIdleEndTimer(sessionId);
+    this.stopLaHeartbeat(sessionId);
+    this.clearSessionActivityState(sessionId);
+    this.yoloModeState.delete(sessionId);
+    this.lastActivityPushAt.delete(sessionId);
+    this.lastPushedFingerprint.delete(sessionId);
+    this.pendingPriority.delete(sessionId);
+  }
+  /**
+   * 清空单会话可重建的重状态（recentActivity / 计数器 / 最新文本）。
+   * 会话走到 idle 时调用即可释放内存——resume 后这些状态会随新事件自动重建。
+   */
+  clearSessionActivityState(sessionId) {
+    this.recentActivityState.delete(sessionId);
+    this.activityCounters.delete(sessionId);
+    this.latestAssistantText.delete(sessionId);
   }
   // ============================================
   // 内部方法
@@ -4057,6 +4645,7 @@ var NotificationService = class {
               badge: this.getGlobalPendingCount(),
               data: { type: "task_complete", sessionId: event.sessionId }
             });
+            this.clearSessionActivityState(event.sessionId);
           }
         } else if (event.status === "running" || event.status === "waiting_approval" || event.status === "waiting_question") {
           this.cancelIdleEndTimer(event.sessionId);
@@ -4119,6 +4708,8 @@ var NotificationService = class {
         while (state2.history.length > RECENT_ACTIVITY_MAX) state2.history.shift();
         state2.currentEntries = [];
         state2.currentMessageId = null;
+        state2.accumulatedText = "";
+        state2.countedToolIds = /* @__PURE__ */ new Set();
       }
       return;
     }
@@ -4127,7 +4718,7 @@ var NotificationService = class {
     if (!Array.isArray(msg.content)) return;
     let state = this.recentActivityState.get(sessionId);
     if (!state) {
-      state = { history: [], currentMessageId: null, currentEntries: [] };
+      state = { history: [], currentMessageId: null, currentEntries: [], accumulatedText: "", countedToolIds: /* @__PURE__ */ new Set() };
       this.recentActivityState.set(sessionId, state);
     }
     if (state.currentMessageId !== msg.id) {
@@ -4137,16 +4728,25 @@ var NotificationService = class {
       }
       state.currentEntries = [];
       state.currentMessageId = msg.id;
+      state.accumulatedText = "";
+      state.countedToolIds = /* @__PURE__ */ new Set();
+    }
+    for (const block of msg.content) {
+      if (block.type === "text" && typeof block.text === "string") {
+        state.accumulatedText += block.text;
+      }
     }
     const next = [];
+    const accText = this.summarizeText(state.accumulatedText);
+    if (accText.length >= 4) next.push(accText);
     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") {
+      if (block.type === "tool_use") {
         const line = this.summarizeToolCall(block.name, block.input ?? {});
         if (line) next.push(line);
-        this.incrementCounter(sessionId, block.name);
+        if (!state.countedToolIds.has(block.id)) {
+          state.countedToolIds.add(block.id);
+          this.incrementCounter(sessionId, block.name);
+        }
       }
     }
     state.currentEntries = next;
@@ -4262,7 +4862,7 @@ var NotificationService = class {
         return;
       }
       if (session.status === "running" || session.status === "waiting_approval" || session.status === "waiting_question") {
-        this.scheduleActivityPush(sessionId);
+        this.scheduleActivityPush(sessionId, true);
       }
     }, ACTIVITY_PUSH_THROTTLE_MS);
     this.laHeartbeatTimers.set(sessionId, timer);
@@ -4334,17 +4934,38 @@ var NotificationService = class {
       });
     }
     this.stopLaHeartbeat(sessionId);
-    this.recentActivityState.delete(sessionId);
+    this.clearSessionActivityState(sessionId);
     this.lastActivityPushAt.delete(sessionId);
-    this.activityCounters.delete(sessionId);
+    this.lastPushedFingerprint.delete(sessionId);
     console.log(`[NotificationService] \u{1F3C1} LA end (${reason}) session=${sessionId.slice(0, 8)}\u2026`);
   }
+  /**
+   * 计算内容指纹：status + recentActivity + latestApproval。
+   * 用于判断 LA 内容是否实际变化，避免重复推送消耗 APNs budget。
+   */
+  computeContentFingerprint(sessionId) {
+    const activity = this.getRecentActivity(sessionId);
+    const session = this.sessionManager.getActiveSessions().find((s) => s.id === sessionId);
+    const approvals = this.pendingApprovalsProvider?.(sessionId) ?? [];
+    const latestApproval = approvals[approvals.length - 1];
+    return `${session?.status ?? ""}|${activity.join("	")}|${latestApproval?.id ?? ""}`;
+  }
   /** 真正发送一次 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 fingerprint = this.computeContentFingerprint(sessionId);
+    const lastFingerprint = this.lastPushedFingerprint.get(sessionId);
+    const contentChanged = fingerprint !== lastFingerprint;
+    if (!contentChanged) {
+      const lastPush = this.lastActivityPushAt.get(sessionId) ?? 0;
+      if (Date.now() - lastPush < _NotificationService.STATS_REFRESH_INTERVAL_MS) {
+        return;
+      }
+    }
+    this.lastPushedFingerprint.set(sessionId, fingerprint);
     const recentActivity = this.getRecentActivity(sessionId);
     const latestMessage = recentActivity[recentActivity.length - 1] ?? this.latestAssistantText.get(sessionId) ?? "";
     const sessionTitle = this.getSessionTitle(sessionId);
@@ -4373,13 +4994,14 @@ var NotificationService = class {
       };
     }
     contentState.stats = this.buildStatsPayload(session);
-    const priority = this.pendingPriority.get(sessionId) ?? "5";
+    const explicitPriority = this.pendingPriority.get(sessionId);
+    const priority = explicitPriority ?? (contentChanged ? "10" : "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}`);
+        console.log(`[NotificationService] \u{1F4E1} LA push \u2713 session=${sessionId.slice(0, 8)}\u2026 status=${status} p=${priority} changed=${contentChanged} lines=${lineCount}`);
       }
     }).catch((err) => {
       console.warn(`[NotificationService] \u{1F4E1} LA push \u2717 session=${sessionId.slice(0, 8)}\u2026:`, err instanceof Error ? err.message : err);
@@ -4508,6 +5130,8 @@ var DesktopNotificationChannel = class {
 
 // src/notification/ExpoNotificationChannel.ts
 var EXPO_PUSH_API = "https://exp.host/--/api/v2/push/send";
+var EXPO_RECEIPT_API = "https://exp.host/--/api/v2/push/getReceipts";
+var RECEIPT_CHECK_DELAY_MS = 1e4;
 var ExpoNotificationChannel = class {
   tokens = /* @__PURE__ */ new Set();
   /** push token → WebSocket 连接映射，用于前台抑制 */
@@ -4555,6 +5179,7 @@ var ExpoNotificationChannel = class {
       if (prefs) {
         const notifType = payload.data?.type ?? "";
         if (notifType === "approval_request" && prefs.approval) sound = prefs.approval;
+        else if (notifType === "question_request" && prefs.approval) sound = prefs.approval;
         else if (notifType === "task_complete" && prefs.taskComplete) sound = prefs.taskComplete;
         else if (notifType === "task_error" && prefs.taskError) sound = prefs.taskError;
       }
@@ -4585,6 +5210,7 @@ var ExpoNotificationChannel = class {
           console.warn(`[ExpoNotificationChannel] ${t("notification.pushApiFormatError")}`, JSON.stringify(body));
           return;
         }
+        const receiptIdToToken = /* @__PURE__ */ new Map();
         for (let i = 0; i < body.data.length; i++) {
           const ticket = body.data[i];
           if (ticket.status === "error") {
@@ -4597,13 +5223,63 @@ var ExpoNotificationChannel = class {
               this.soundPreferences.delete(staleToken);
               console.warn(`[ExpoNotificationChannel] \u26A0\uFE0F  \u5DF2\u79FB\u9664\u5931\u6548 token\uFF08DeviceNotRegistered\uFF09\u3002\u82E5\u901A\u77E5\u672A\u6062\u590D\uFF0C\u8BF7\u91CD\u542F App \u91CD\u65B0\u6CE8\u518C push token\u3002`);
             }
+          } else if (ticket.status === "ok" && typeof ticket.id === "string" && targetTokens[i]) {
+            receiptIdToToken.set(ticket.id, targetTokens[i]);
           }
         }
+        this.scheduleReceiptCheck(receiptIdToToken);
       }
     } catch (err) {
       console.warn(`[ExpoNotificationChannel] ${t("notification.sendFailed")}`, err);
     }
   }
+  /**
+   * Expo push 二阶段：延迟查 receipt，暴露 ticket 阶段看不到的 APNs 投递失败。
+   *
+   * 关键诊断点：InvalidCredentials / MismatchSenderId 表示 Expo 项目的 APNs
+   * 凭证配置问题（不是用户机器问题）——这正是"只有开发者能收到推送"的根因，
+   * 且 ticket 全为 ok、不查 receipt 永远静默。
+   */
+  scheduleReceiptCheck(receiptIdToToken) {
+    if (receiptIdToToken.size === 0) return;
+    const timer = setTimeout(async () => {
+      try {
+        const ids = Array.from(receiptIdToToken.keys());
+        const res = await fetch(EXPO_RECEIPT_API, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", Accept: "application/json" },
+          body: JSON.stringify({ ids })
+        });
+        const body = await res.json();
+        if (!res.ok || !body?.data || typeof body.data !== "object") {
+          console.warn("[ExpoNotificationChannel] \u26A0\uFE0F  push receipt \u67E5\u8BE2\u5931\u8D25", res.status, JSON.stringify(body));
+          return;
+        }
+        const receipts = body.data;
+        for (const [receiptId, receipt] of Object.entries(receipts)) {
+          if (receipt?.status !== "error") continue;
+          const errorCode = receipt.details?.error ?? "unknown";
+          const token = receiptIdToToken.get(receiptId);
+          console.error(
+            `[ExpoNotificationChannel] \u274C APNs \u6295\u9012\u5931\u8D25 receipt=${receiptId} error=${errorCode}` + (receipt.message ? ` \u2014 ${receipt.message}` : "")
+          );
+          if (errorCode === "DeviceNotRegistered" && token) {
+            this.tokens.delete(token);
+            this.tokenWsMap.delete(token);
+            this.soundPreferences.delete(token);
+            console.warn("[ExpoNotificationChannel] \u26A0\uFE0F  \u5DF2\u79FB\u9664\u5931\u6548 token\uFF08receipt DeviceNotRegistered\uFF09\u3002\u91CD\u542F App \u53EF\u91CD\u65B0\u6CE8\u518C\u3002");
+          } else if (errorCode === "InvalidCredentials" || errorCode === "MismatchSenderId") {
+            console.error(
+              "[ExpoNotificationChannel] \u26A0\uFE0F  \u8FD9\u662F Expo \u9879\u76EE\u7684 APNs \u51ED\u8BC1\u914D\u7F6E\u95EE\u9898\uFF08\u4E0D\u662F\u7528\u6237\u673A\u5668\u95EE\u9898\uFF09\uFF1A\n  Expo \u63A5\u53D7\u4E86\u63A8\u9001\u4F46 APNs \u62D2\u6295\uFF0C\u901A\u5E38\u56E0\u4E3A\u8BE5 Expo \u9879\u76EE\u672A\u914D\u7F6E\u53EF\u6295\u9012\u5230\u3010\u751F\u4EA7\u73AF\u5883\u3011\u7684 APNs Auth Key\u3002\n  \u6392\u67E5\uFF1Acd packages/mobile && npx eas credentials -p ios \u2014\u2014 \u786E\u8BA4\u5B58\u5728\u8986\u76D6\u751F\u4EA7\u7684 APNs Push Key(.p8)\u3002"
+            );
+          }
+        }
+      } catch (err) {
+        console.warn("[ExpoNotificationChannel] \u26A0\uFE0F  push receipt \u67E5\u8BE2\u5F02\u5E38:", err);
+      }
+    }, RECEIPT_CHECK_DELAY_MS);
+    timer.unref?.();
+  }
 };
 
 // src/notification/ActivityPushChannel.ts
@@ -4898,470 +5574,134 @@ var ActivityPushChannel = class {
         const reason = err instanceof ApnsError ? JSON.parse(err.responseBody || "{}")?.reason ?? err.statusCode : String(err);
         console.log(`[ActivityPushChannel] \u{1F50D} probe ${env} failed: ${reason}`);
         if (isProviderTokenError(err)) {
-          console.error(
-            `[ActivityPushChannel] \u274C APNs Auth Key \u5DF2\u5931\u6548\uFF08${reason}\uFF09\u3002\u8BF7\u5230 Apple Developer \u4E0B\u8F7D\u65B0\u7684 .p8 \u6587\u4EF6\uFF0C\u5E76\u66F4\u65B0 ~/.sessix/apns.json \u4E2D\u7684 keyId \u548C authKeyPath\uFF0C\u7136\u540E\u91CD\u542F\u670D\u52A1\u7AEF\u3002`
-          );
-          throw err;
-        }
-        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 = opts.topic ?? `${this.bundleId}.push-type.liveactivity`;
-    const pushType = opts.pushType ?? "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(env);
-      } catch (err) {
-        return reject(err);
-      }
-      const headers = {
-        ":method": "POST",
-        ":path": `/3/device/${deviceToken}`,
-        "authorization": `bearer ${jwt}`,
-        "apns-topic": topic,
-        "apns-push-type": pushType,
-        "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", (headers2) => {
-        statusCode = Number(headers2[":status"] ?? 0);
-      });
-      req.on("data", (chunk) => {
-        responseData += chunk;
-      });
-      req.on("end", () => {
-        if (statusCode === 200) {
-          resolve();
-        } else {
-          if (statusCode === 0) {
-            const c = this.http2Clients[env];
-            c?.destroy();
-            delete this.http2Clients[env];
-          }
-          reject(new ApnsError(statusCode, responseData));
-        }
-      });
-      req.on("error", (err) => {
-        reject(err);
-      });
-      req.write(payloadStr);
-      req.end();
-    });
-  }
-  /** 生成或获取缓存的 APNs JWT token */
-  getJWT() {
-    const now = Math.floor(Date.now() / 1e3);
-    if (this.cachedJwt && this.cachedJwt.expiresAt > now) {
-      return this.cachedJwt.token;
-    }
-    const header = Buffer.from(JSON.stringify({
-      alg: "ES256",
-      kid: this.keyId
-    })).toString("base64url");
-    const claims = Buffer.from(JSON.stringify({
-      iss: this.teamId,
-      iat: now
-    })).toString("base64url");
-    const signingInput = `${header}.${claims}`;
-    const sign = crypto.createSign("SHA256");
-    sign.update(signingInput);
-    const signature = sign.sign({ key: this.authKey, dsaEncoding: "ieee-p1363" }, "base64url");
-    const token = `${signingInput}.${signature}`;
-    this.cachedJwt = { token, expiresAt: now + 3e3 };
-    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 isProviderTokenError(err) {
-  if (!(err instanceof ApnsError)) return false;
-  if (err.statusCode !== 403) return false;
-  try {
-    const parsed = JSON.parse(err.responseBody);
-    return parsed.reason === "InvalidProviderToken" || parsed.reason === "ExpiredProviderToken";
-  } catch {
-    return false;
-  }
-}
-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");
-var import_readline3 = require("readline");
-var import_path2 = require("path");
-var import_os2 = require("os");
-var CLAUDE_PROJECTS_DIR = (0, import_path2.join)((0, import_os2.homedir)(), ".claude", "projects");
-function getSessionFilePath(projectPath, sessionId) {
-  return (0, import_path2.join)(CLAUDE_PROJECTS_DIR, encodeDirName(projectPath), `${sessionId}.jsonl`);
-}
-async function getProjects() {
-  try {
-    const dirExists = await directoryExists(CLAUDE_PROJECTS_DIR);
-    if (!dirExists) {
-      return { ok: true, value: [] };
-    }
-    const entries = await (0, import_promises3.readdir)(CLAUDE_PROJECTS_DIR, { withFileTypes: true });
-    const projects = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory() || entry.name.startsWith(".")) {
-        continue;
-      }
-      const encodedPath = entry.name;
-      const decodedPath = decodeDirName(encodedPath);
-      const name = decodedPath.split("/").filter(Boolean).pop() ?? encodedPath;
-      const projectDir = (0, import_path2.join)(CLAUDE_PROJECTS_DIR, encodedPath);
-      const { count: sessionCount, latestMtime } = await countJsonlFilesWithMtime(projectDir);
-      projects.push({
-        id: encodedPath,
-        path: decodedPath,
-        name,
-        sessionCount,
-        lastActiveAt: latestMtime
-      });
-    }
-    projects.sort((a, b) => a.name.localeCompare(b.name));
-    return { ok: true, value: projects };
-  } catch (err) {
-    return {
-      ok: false,
-      error: err instanceof Error ? err : new Error(String(err))
-    };
-  }
-}
-async function getHistoricalSessions(projectPath) {
-  try {
-    const encodedPath = encodeDirName(projectPath);
-    const projectDir = (0, import_path2.join)(CLAUDE_PROJECTS_DIR, encodedPath);
-    const dirExists = await directoryExists(projectDir);
-    if (!dirExists) {
-      return { ok: true, value: [] };
-    }
-    const entries = await (0, import_promises3.readdir)(projectDir, { withFileTypes: true });
-    const jsonlFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl"));
-    const mtimeMap = /* @__PURE__ */ new Map();
-    await Promise.all(
-      jsonlFiles.map(async (entry) => {
-        const sessionId = entry.name.slice(0, -6);
-        const filePath = (0, import_path2.join)(projectDir, entry.name);
-        try {
-          const contentTs = await extractLastTimestamp(filePath);
-          if (contentTs) {
-            mtimeMap.set(sessionId, contentTs);
-          } else {
-            const fileStat = await (0, import_promises3.stat)(filePath);
-            mtimeMap.set(sessionId, fileStat.mtimeMs);
-          }
-        } catch {
-          mtimeMap.set(sessionId, 0);
-        }
-      })
-    );
-    const uuidDirs = entries.filter(
-      (e) => e.isDirectory() && UUID_RE.test(e.name) && !mtimeMap.has(e.name)
-    );
-    for (const entry of uuidDirs) {
-      try {
-        const fileStat = await (0, import_promises3.stat)((0, import_path2.join)(projectDir, entry.name));
-        mtimeMap.set(entry.name, fileStat.mtimeMs);
-      } catch {
-        mtimeMap.set(entry.name, 0);
-      }
-    }
-    const indexPath = (0, import_path2.join)(projectDir, "sessions-index.json");
-    const sessionMap = /* @__PURE__ */ new Map();
-    try {
-      const indexContent = await (0, import_promises3.readFile)(indexPath, "utf-8");
-      const indexData = JSON.parse(indexContent);
-      if (indexData.version === 1 && Array.isArray(indexData.entries)) {
-        for (const entry of indexData.entries) {
-          const mtime = mtimeMap.get(entry.sessionId) ?? entry.fileMtime ?? (entry.modified ? new Date(entry.modified).getTime() : 0);
-          sessionMap.set(entry.sessionId, {
-            sessionId: entry.sessionId,
-            lastModified: mtime,
-            summary: entry.summary,
-            firstPrompt: entry.firstPrompt,
-            messageCount: entry.messageCount
-          });
-        }
-        await Promise.all(
-          Array.from(sessionMap.values()).filter((s) => (s.messageCount ?? 0) > 0 && !s.summary && !s.firstPrompt).map(async (s) => {
-            const filePath = (0, import_path2.join)(projectDir, `${s.sessionId}.jsonl`);
-            const firstPrompt = await extractFirstPrompt(filePath).catch(() => void 0);
-            if (firstPrompt) s.firstPrompt = firstPrompt;
-          })
-        );
-      }
-    } catch {
-    }
-    const uuidDirSet = new Set(uuidDirs.map((e) => e.name));
-    for (const [sessionId, mtime] of mtimeMap) {
-      if (!sessionMap.has(sessionId)) {
-        if (uuidDirSet.has(sessionId)) {
-          sessionMap.set(sessionId, { sessionId, lastModified: mtime, messageCount: -1 });
-        } else {
-          const filePath = (0, import_path2.join)(projectDir, `${sessionId}.jsonl`);
-          const firstPrompt = await extractFirstPrompt(filePath).catch(() => void 0);
-          sessionMap.set(sessionId, { sessionId, lastModified: mtime, firstPrompt });
-        }
-      }
-    }
-    const sessions = Array.from(sessionMap.values()).filter((s) => {
-      if (s.messageCount === 0) return false;
-      if (s.messageCount === -1) return true;
-      if (s.firstPrompt === void 0 && s.messageCount === void 0) return false;
-      return true;
-    });
-    sessions.sort((a, b) => b.lastModified - a.lastModified);
-    return { ok: true, value: sessions };
-  } catch (err) {
-    return {
-      ok: false,
-      error: err instanceof Error ? err : new Error(String(err))
-    };
-  }
-}
-async function getSessionHistory(projectPath, sessionId) {
-  try {
-    const encodedPath = encodeDirName(projectPath);
-    const filePath = (0, import_path2.join)(CLAUDE_PROJECTS_DIR, encodedPath, `${sessionId}.jsonl`);
-    const raw = await (0, import_promises3.readFile)(filePath, "utf-8").catch((err) => {
-      if (err.code === "ENOENT") return null;
-      throw err;
-    });
-    if (raw === null) return { ok: true, value: [] };
-    const lines = raw.split("\n").filter((l) => l.trim());
-    const events = [];
-    for (const line of lines) {
-      try {
-        const obj = JSON.parse(line);
-        const type = obj.type;
-        if (type === "user" && obj.message) {
-          const msgContent = obj.message.content;
-          if (typeof msgContent === "string") {
-            if (msgContent.includes("<local-command") || msgContent.includes("<command-name>")) continue;
-          } else if (Array.isArray(msgContent)) {
-            const hasText = msgContent.some(
-              (b) => b.type === "text" && !b.text?.includes("<local-command") && !b.text?.includes("<command-name>")
-            );
-            if (!hasText) continue;
-          }
-          const normalizedContent = typeof msgContent === "string" ? [{ type: "text", text: msgContent }] : Array.isArray(msgContent) ? msgContent.filter((b) => b.type === "text" && typeof b.text === "string") : [];
-          if (normalizedContent.length === 0) continue;
-          events.push({
-            type: "user",
-            message: {
-              ...obj.message,
-              content: normalizedContent
-            },
-            session_id: sessionId
-          });
-        } else if (type === "assistant" && obj.message) {
-          const content = (obj.message.content ?? []).filter(
-            (b) => b.type === "text" || b.type === "tool_use" || b.type === "thinking"
-          );
-          if (content.length === 0) continue;
-          events.push({
-            type: "assistant",
-            message: {
-              id: obj.message.id ?? obj.uuid ?? `hist-${events.length}`,
-              model: obj.message.model ?? "unknown",
-              role: "assistant",
-              content,
-              stop_reason: obj.message.stop_reason,
-              usage: obj.message.usage
-            },
-            session_id: sessionId
-          });
+          console.error(
+            `[ActivityPushChannel] \u274C APNs Auth Key \u5DF2\u5931\u6548\uFF08${reason}\uFF09\u3002\u8BF7\u5230 Apple Developer \u4E0B\u8F7D\u65B0\u7684 .p8 \u6587\u4EF6\uFF0C\u5E76\u66F4\u65B0 ~/.sessix/apns.json \u4E2D\u7684 keyId \u548C authKeyPath\uFF0C\u7136\u540E\u91CD\u542F\u670D\u52A1\u7AEF\u3002`
+          );
+          throw err;
         }
-      } catch {
-      }
-    }
-    if (events.length > 0) {
-      let totalInputTokens = 0;
-      let totalOutputTokens = 0;
-      for (const ev of events) {
-        if (ev.type === "assistant" && ev.message.usage) {
-          totalInputTokens += ev.message.usage.input_tokens ?? 0;
-          totalOutputTokens += ev.message.usage.output_tokens ?? 0;
+        if (!isBadDeviceTokenError(err)) {
+          throw err;
         }
       }
-      if (totalInputTokens > 0 || totalOutputTokens > 0) {
-        events.push({
-          type: "result",
-          subtype: "success",
-          is_error: false,
-          duration_ms: 0,
-          num_turns: events.filter((e) => e.type === "user").length,
-          result: "",
-          session_id: sessionId,
-          usage: { input_tokens: totalInputTokens, output_tokens: totalOutputTokens }
-        });
-      }
     }
-    return { ok: true, value: events };
-  } catch (err) {
-    return {
-      ok: false,
-      error: err instanceof Error ? err : new Error(String(err))
-    };
-  }
-}
-async function extractLastTimestamp(filePath) {
-  let fileHandle;
-  try {
-    fileHandle = await (0, import_promises3.open)(filePath, "r");
-    const fileStat = await fileHandle.stat();
-    const readSize = Math.min(fileStat.size, 8192);
-    const buffer = Buffer.alloc(readSize);
-    await fileHandle.read(buffer, 0, readSize, fileStat.size - readSize);
-    const tail = buffer.toString("utf-8");
-    const lines = tail.split("\n").filter((l) => l.trim());
-    for (let i = lines.length - 1; i >= 0; i--) {
-      try {
-        const obj = JSON.parse(lines[i]);
-        if (obj.timestamp) {
-          const ts = new Date(obj.timestamp).getTime();
-          if (!isNaN(ts)) return ts;
-        }
-      } catch {
+    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;
       }
     }
-  } catch {
-  } finally {
-    await fileHandle?.close();
+    throw lastErr ?? new Error("APNs send failed: all environments rejected token");
   }
-  return void 0;
-}
-async function extractFirstPrompt(filePath) {
-  let fileHandle;
-  try {
-    fileHandle = await (0, import_promises3.open)(filePath, "r");
-    const rl = (0, import_readline3.createInterface)({
-      input: fileHandle.createReadStream({ encoding: "utf-8" }),
-      crlfDelay: Infinity
-    });
-    let lineCount = 0;
-    for await (const line of rl) {
-      if (++lineCount > 20) break;
-      if (!line.trim()) continue;
+  /** 单次 APNs HTTP/2 请求（内部 helper，不做探测） */
+  async sendToAPNsOnce(deviceToken, payload, opts, env) {
+    const topic = opts.topic ?? `${this.bundleId}.push-type.liveactivity`;
+    const pushType = opts.pushType ?? "liveactivity";
+    const jwt = this.getJWT();
+    const payloadStr = JSON.stringify(payload);
+    const priority = opts.priority ?? "10";
+    return new Promise((resolve, reject) => {
+      let client;
       try {
-        const obj = JSON.parse(line);
-        if (obj.type === "user" && obj.message) {
-          const msgContent = obj.message.content;
-          let text = "";
-          if (typeof msgContent === "string") {
-            text = msgContent;
-          } else if (Array.isArray(msgContent)) {
-            const textBlock = msgContent.find((b) => b.type === "text" && typeof b.text === "string");
-            text = textBlock?.text ?? "";
-          }
-          if (text && !text.includes("<local-command") && !text.includes("<command-name>")) {
-            text = text.replace(/<ide_opened_file>[\s\S]*?<\/ide_opened_file>/gi, "");
-            text = text.replace(/<[^>]+>/g, "").trim();
-            rl.close();
-            return text.length > 80 ? text.slice(0, 80) + "..." : text;
+        client = this.getHttp2Client(env);
+      } catch (err) {
+        return reject(err);
+      }
+      const headers = {
+        ":method": "POST",
+        ":path": `/3/device/${deviceToken}`,
+        "authorization": `bearer ${jwt}`,
+        "apns-topic": topic,
+        "apns-push-type": pushType,
+        "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);
+      req.setTimeout(1e4, () => {
+        req.close(http2.constants.NGHTTP2_CANCEL);
+      });
+      let statusCode = 0;
+      let responseData = "";
+      req.on("response", (headers2) => {
+        statusCode = Number(headers2[":status"] ?? 0);
+      });
+      req.on("data", (chunk) => {
+        responseData += chunk;
+      });
+      req.on("end", () => {
+        if (statusCode === 200) {
+          resolve();
+        } else {
+          if (statusCode === 0) {
+            const c = this.http2Clients[env];
+            c?.destroy();
+            delete this.http2Clients[env];
           }
+          reject(new ApnsError(statusCode, responseData));
         }
-      } catch {
-      }
+      });
+      req.on("error", (err) => {
+        reject(err);
+      });
+      req.write(payloadStr);
+      req.end();
+    });
+  }
+  /** 生成或获取缓存的 APNs JWT token */
+  getJWT() {
+    const now = Math.floor(Date.now() / 1e3);
+    if (this.cachedJwt && this.cachedJwt.expiresAt > now) {
+      return this.cachedJwt.token;
     }
-  } catch {
-  } finally {
-    await fileHandle?.close();
+    const header = Buffer.from(JSON.stringify({
+      alg: "ES256",
+      kid: this.keyId
+    })).toString("base64url");
+    const claims = Buffer.from(JSON.stringify({
+      iss: this.teamId,
+      iat: now
+    })).toString("base64url");
+    const signingInput = `${header}.${claims}`;
+    const sign = crypto.createSign("SHA256");
+    sign.update(signingInput);
+    const signature = sign.sign({ key: this.authKey, dsaEncoding: "ieee-p1363" }, "base64url");
+    const token = `${signingInput}.${signature}`;
+    this.cachedJwt = { token, expiresAt: now + 3e3 };
+    return token;
   }
-  return void 0;
-}
-function decodeDirName(dirName) {
-  const placeholder = "\0";
-  const escaped = dirName.replace(/--/g, placeholder);
-  const decoded = escaped.replace(/-/g, "/");
-  return decoded.replace(new RegExp(placeholder, "g"), "-");
-}
-function encodeDirName(path2) {
-  const escaped = path2.replace(/-/g, "--");
-  return escaped.replace(/\//g, "-");
-}
-async function directoryExists(dirPath) {
+};
+var ApnsError = class extends Error {
+  constructor(statusCode, responseBody) {
+    super(`APNs returned ${statusCode}: ${responseBody}`);
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+    this.name = "ApnsError";
+  }
+};
+function isProviderTokenError(err) {
+  if (!(err instanceof ApnsError)) return false;
+  if (err.statusCode !== 403) return false;
   try {
-    const s = await (0, import_promises3.stat)(dirPath);
-    return s.isDirectory();
+    const parsed = JSON.parse(err.responseBody);
+    return parsed.reason === "InvalidProviderToken" || parsed.reason === "ExpiredProviderToken";
   } catch {
     return false;
   }
 }
-var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-async function countJsonlFilesWithMtime(dirPath) {
+function isBadDeviceTokenError(err) {
+  if (!(err instanceof ApnsError)) return false;
+  if (err.statusCode !== 400 && err.statusCode !== 403 && err.statusCode !== 410) return false;
   try {
-    const entries = await (0, import_promises3.readdir)(dirPath, { withFileTypes: true });
-    const jsonlNames = new Set(
-      entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => e.name.slice(0, -6))
-    );
-    const uuidDirs = entries.filter(
-      (e) => e.isDirectory() && UUID_RE.test(e.name) && !jsonlNames.has(e.name)
-    );
-    let latestMtime = 0;
-    const jsonlEntries = entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl"));
-    await Promise.all([
-      ...jsonlEntries.map(async (entry) => {
-        try {
-          const contentTs = await extractLastTimestamp((0, import_path2.join)(dirPath, entry.name));
-          const ts = contentTs ?? (await (0, import_promises3.stat)((0, import_path2.join)(dirPath, entry.name))).mtimeMs;
-          if (ts > latestMtime) latestMtime = ts;
-        } catch {
-        }
-      }),
-      ...uuidDirs.map(async (entry) => {
-        try {
-          const fileStat = await (0, import_promises3.stat)((0, import_path2.join)(dirPath, entry.name));
-          if (fileStat.mtimeMs > latestMtime) latestMtime = fileStat.mtimeMs;
-        } catch {
-        }
-      })
-    ]);
-    return { count: jsonlNames.size + uuidDirs.length, latestMtime };
+    const parsed = JSON.parse(err.responseBody);
+    return parsed.reason === "BadDeviceToken" || parsed.reason === "BadEnvironmentKeyInToken" || parsed.reason === "Unregistered";
   } catch {
-    return { count: 0, latestMtime: 0 };
+    return false;
   }
 }
 
@@ -5487,7 +5827,10 @@ var AuthManager = class extends import_events3.EventEmitter {
         email: parsed.email,
         authMethod: parsed.authMethod
       };
-    } catch {
+    } catch (err) {
+      console.warn(
+        `[AuthManager] checkAuth \u5931\u8D25 (claudePath=${CLAUDE_PATH2}): ${err instanceof Error ? err.message : String(err)}`
+      );
       return { loggedIn: false };
     }
   }
@@ -5583,7 +5926,7 @@ var AuthManager = class extends import_events3.EventEmitter {
 
 // src/terminal/TerminalExecutor.ts
 var import_node_child_process8 = require("child_process");
-var import_uuid5 = require("uuid");
+var import_uuid4 = require("uuid");
 var EXEC_TIMEOUT_MS = 30 * 60 * 1e3;
 var TerminalExecutor = class {
   processes = /* @__PURE__ */ new Map();
@@ -5605,7 +5948,7 @@ var TerminalExecutor = class {
     }
   }
   exec(sessionId, command, cwd) {
-    const execId = (0, import_uuid5.v4)();
+    const execId = (0, import_uuid4.v4)();
     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, {
@@ -5682,7 +6025,7 @@ 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 import_uuid5 = require("uuid");
 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;
@@ -5693,7 +6036,6 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
   "DerivedData",
   "Pods",
   ".build",
-  "build",
   "dist",
   "__pycache__",
   ".next",
@@ -5870,7 +6212,7 @@ ${e.stderr ?? ""}`);
       return null;
     }
     if (override) await this.saveConfig(projectPath, override);
-    const buildId = (0, import_uuid6.v4)();
+    const buildId = (0, import_uuid5.v4)();
     const args = buildArgs(config);
     const proc = (0, import_node_child_process9.spawn)("xcodebuild", args, {
       cwd: projectPath,
@@ -5934,7 +6276,7 @@ ${e.stderr ?? ""}`);
       this.emitInstallError(sessionId, "", "\u672A\u627E\u5230\u6784\u5EFA\u914D\u7F6E\uFF0C\u8BF7\u5148\u6784\u5EFA\u4E00\u6B21\n");
       return null;
     }
-    const installId = (0, import_uuid6.v4)();
+    const installId = (0, import_uuid5.v4)();
     let appPath;
     try {
       appPath = await this.getAppPath(projectPath, config);
@@ -6505,7 +6847,7 @@ function sourceWeight(s) {
 // src/git/GitExecutor.ts
 var import_node_child_process10 = require("child_process");
 var import_node_util2 = require("util");
-var import_uuid7 = require("uuid");
+var import_uuid6 = require("uuid");
 var execAsync2 = (0, import_node_util2.promisify)(import_node_child_process10.exec);
 var STATUS_TIMEOUT_MS = 15e3;
 var COMMIT_TIMEOUT_MS = 6e4;
@@ -6625,7 +6967,7 @@ var GitExecutor = class {
    * - 若未提供 files：默认 git add -A（提交所有变更）
    */
   async commit(sessionId, projectPath, message, files, alsoPush) {
-    const opId = (0, import_uuid7.v4)();
+    const opId = (0, import_uuid6.v4)();
     this.runSequence(sessionId, opId, "commit", projectPath, [
       files && files.length > 0 ? ["git", "add", "--", ...files] : ["git", "add", "-A"],
       ["git", "commit", "-m", message]
@@ -6641,7 +6983,7 @@ var GitExecutor = class {
     return opId;
   }
   async push(sessionId, projectPath) {
-    const opId = (0, import_uuid7.v4)();
+    const opId = (0, import_uuid6.v4)();
     this.runSequence(sessionId, opId, "push", projectPath, [
       ["git", "push"]
     ], PUSH_TIMEOUT_MS).catch((err) => {
@@ -6719,7 +7061,7 @@ var GitExecutor = class {
 var import_promises6 = require("fs/promises");
 var import_node_os8 = require("os");
 var import_node_path8 = require("path");
-var import_uuid8 = require("uuid");
+var import_uuid7 = require("uuid");
 var MAX_TIMEOUT_MS = 2147483647;
 var ScheduledSessionManager = class {
   tasks = /* @__PURE__ */ new Map();
@@ -6757,7 +7099,7 @@ var ScheduledSessionManager = class {
   /** 注册一个定时任务（payload 由调用方校验） */
   schedule(scheduledAt, payload) {
     const task = {
-      id: (0, import_uuid8.v4)(),
+      id: (0, import_uuid7.v4)(),
       scheduledAt,
       createdAt: Date.now(),
       payload
@@ -6861,10 +7203,11 @@ function isValidTask(value) {
 // src/utils/cliCapabilities.ts
 var import_node_child_process11 = require("child_process");
 var DEFAULT_MODELS = [
-  { value: "opus", label: "Opus 4.7", sublabel: "Most capable for ambitious work" },
-  { value: "claude-opus-4-6", label: "Opus 4.6", sublabel: "Previous generation flagship" },
-  { value: "sonnet", label: "Sonnet 4.6", sublabel: "Most efficient for everyday tasks" },
-  { value: "haiku", label: "Haiku 4.5", sublabel: "Fastest for quick answers" }
+  { value: "opus", label: "Opus 4.8", sublabel: "Most capable for ambitious work", maxEffort: "max", defaultEffort: "xhigh" },
+  { value: "claude-opus-4-7", label: "Opus 4.7", sublabel: "Previous generation flagship", maxEffort: "max", defaultEffort: "xhigh" },
+  { value: "claude-opus-4-6", label: "Opus 4.6", sublabel: "Earlier generation flagship", maxEffort: "max", defaultEffort: "xhigh" },
+  { value: "sonnet", label: "Sonnet 4.6", sublabel: "Most efficient for everyday tasks", maxEffort: "high", defaultEffort: "high" },
+  { value: "haiku", label: "Haiku 4.5", sublabel: "Fastest for quick answers", maxEffort: "medium", defaultEffort: "medium" }
 ];
 var DEFAULT_CAPABILITIES = {
   effortLevels: ["low", "medium", "high", "xhigh", "max"],
@@ -6997,7 +7340,7 @@ async function start(opts = {}) {
       try {
         token = (await (0, import_promises7.readFile)(tokenFile, "utf8")).trim();
       } catch {
-        token = (0, import_uuid9.v4)();
+        token = (0, import_uuid8.v4)();
         await (0, import_promises7.mkdir)(configDir, { recursive: true });
         await (0, import_promises7.writeFile)(tokenFile, token, "utf8");
       }
@@ -7032,6 +7375,7 @@ 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);
+  sessionManager.onSessionRemoved((sessionId) => notificationService.releaseSession(sessionId));
   const activityPushOpts = opts.activityPush ?? await loadApnsConfigFromFile();
   if (activityPushOpts) {
     try {
@@ -7189,6 +7533,7 @@ async function start(opts = {}) {
         case "kill_session": {
           wsBridge.broadcast({ type: "status_change", sessionId: event.sessionId, status: "idle" });
           approvalProxy.clearPendingForSession(event.sessionId);
+          approvalProxy.clearPendingQuestionsForSession(event.sessionId);
           await sessionManager.killSession(event.sessionId);
           wsBridge.broadcast({
             type: "session_list",
@@ -7207,6 +7552,7 @@ async function start(opts = {}) {
         }
         case "answer_question": {
           sessionManager.handleQuestionResponse(event.requestId, event.answer);
+          approvalProxy.resolveQuestion(event.requestId, event.answer);
           break;
         }
         case "subscribe": {
@@ -7636,6 +7982,9 @@ async function start(opts = {}) {
       decision: decision.decision
     });
   });
+  approvalProxy.onQuestionResolved((requestId) => {
+    sessionManager.clearPendingQuestion(requestId);
+  });
   approvalProxy.onApprovalRequest((request) => {
     wsBridge.broadcast({ type: "approval_request", request });
     setTimeout(() => {
@@ -7652,6 +8001,9 @@ async function start(opts = {}) {
       notificationService.notifyApproval(request, pendingCount);
     }, 6e4);
   });
+  approvalProxy.setQuestionHandler(
+    (sessionId, toolUseId, questions, requestId) => sessionManager.askQuestion(sessionId, toolUseId, questions, requestId)
+  );
   sessionManager.onEvent((event) => {
     if (event.type !== "question_request") return;
     const { request } = event;
@@ -7712,8 +8064,30 @@ async function start(opts = {}) {
   const idleTimeoutMs = Number(process.env.SESSIX_IDLE_TIMEOUT_MS ?? 30 * 60 * 1e3);
   const idleSweepIntervalMs = Number(process.env.SESSIX_IDLE_SWEEP_INTERVAL_MS ?? 5 * 60 * 1e3);
   const maxActiveProcesses = Number(process.env.SESSIX_MAX_ACTIVE_PROCESSES ?? 15);
+  const sessionEvictMs = Number(process.env.SESSIX_SESSION_EVICT_MS ?? 2 * 60 * 60 * 1e3);
+  let gcFn;
+  const maybeGc = () => {
+    if (gcFn === void 0) {
+      gcFn = globalThis.gc ?? null;
+      if (!gcFn) {
+        try {
+          (0, import_node_v8.setFlagsFromString)("--expose-gc");
+          const fn = (0, import_node_vm.runInNewContext)("gc");
+          gcFn = typeof fn === "function" ? fn : null;
+        } catch {
+          gcFn = null;
+        }
+      }
+    }
+    if (gcFn) {
+      try {
+        gcFn();
+      } catch {
+      }
+    }
+  };
   let idleSweepTimer = null;
-  if (idleSweepIntervalMs > 0 && (idleTimeoutMs > 0 || maxActiveProcesses > 0)) {
+  if (idleSweepIntervalMs > 0 && (idleTimeoutMs > 0 || maxActiveProcesses > 0 || sessionEvictMs > 0)) {
     idleSweepTimer = setInterval(async () => {
       try {
         let totalSwept = 0;
@@ -7732,7 +8106,18 @@ async function start(opts = {}) {
             swept.forEach(broadcastShrink);
             totalSwept += swept.length;
           }
+          if (sessionEvictMs > 0 && typeof provider.listEvictableSessions === "function") {
+            const evictable = provider.listEvictableSessions(sessionEvictMs);
+            for (const id of evictable) {
+              await sessionManager.killSession(id);
+            }
+            if (evictable.length > 0) {
+              console.log(`[Server] Idle GC: evicted ${evictable.length} stale session(s)`);
+              totalSwept += evictable.length;
+            }
+          }
         }
+        const hasRunning = sessionManager.getActiveSessions().some((s) => s.status === "running");
         if (totalSwept > 0) {
           console.log(`[Server] Idle GC: swept ${totalSwept} idle session(s)`);
           wsBridge.broadcast({
@@ -7740,6 +8125,9 @@ async function start(opts = {}) {
             sessions: sessionManager.getActiveSessions()
           });
         }
+        if (totalSwept > 0 || !hasRunning) {
+          maybeGc();
+        }
       } catch (err) {
         console.error("[Server] Idle GC failed:", err);
       }
@@ -7794,7 +8182,7 @@ async function start(opts = {}) {
     openPairing: (duration) => pairingManager.open(duration),
     closePairing: () => pairingManager.close(),
     regenerateToken: async () => {
-      const newToken = (0, import_uuid9.v4)();
+      const newToken = (0, import_uuid8.v4)();
       await (0, import_promises7.mkdir)(configDir, { recursive: true });
       await (0, import_promises7.writeFile)(tokenFile, newToken, "utf8");
       instance.token = newToken;