agent-loft 0.2.32 → 0.2.33

package/README.md

@@ -49,17 +49,21 @@ Logo 就是这个意思：一大两小几颗星（多个 agent）站在同一张
   - 滚动和 ChatGPT 一样：发出的问题顶到最上面、下面留白，回复长到屏幕底部才跟着往下滚；回复过程中自己滚动了就不再自动滚，下次发消息再恢复。
   - 定时发送：右上角「更多」→「定时发送」，默认排在 5 小时额度重置后 5 分钟（弹窗里提示 5 小时 / 7 天额度的重置时间），由服务端到点发出，关掉页面也会发。适合额度用完、要等刷新才能接着干活的时候。
   - 侧栏分「最近」和「项目」两组：Web 会话按工作目录归类（目录可以拖动排序，右键可置顶），飞书机器人各占一行（右键看历史会话）；分叉出来的会话用虚线挂在原会话下面；会话标题由 agent 自动生成，双击重命名。
-  - 侧栏底部显示 Claude / Codex 的订阅额度（5 小时 / 7 天窗口，以及多久后重置）。
+  - 回复过程中接着发的消息排队，标着「排队中」，上一条回复完自动接着处理；点「打断并发送」停掉正在进行的回复、马上处理这条；点停止则连排着的一起取消（标「没有发出」）。
+  - 太长的消息先收起，点「展开显示」看全文；对话里有 3 条以上消息时，右边有一列快速定位，鼠标移上去列出每条消息的开头，点一下跳过去。
+  - 侧栏按页加载：「最近」先显示 10 条、每个项目目录先显示 5 条，点「展开显示」每次再拉 10 条。
+  - 侧栏底部显示 Claude / Codex 的订阅额度（5 小时 / 7 天窗口，以及多久后重置）；关了额度查询就整块不显示。
+  - 右上角「更多」最下面显示当前会话累计消耗的 token 分布（输入 / 缓存写入 / 缓存读取 / 输出，Claude 还有按 API 价格估算的费用）。设置也在「更多」里。在桌面端里，这个菜单并进桌面端顶栏的「更多」，排在最上面。
   - 「添加到主屏幕」后当 App 用；切到后台再回来会自动重连，补上错过的内容。
 - **系统通知**：Web 会话回复完成、出错、需要授权或提问时推送到手机 / 电脑（设置 → 通知 → 「在此设备开启通知」，可以发测试通知）。飞书会话由飞书提醒，正在前台看着的会话不推。需要 HTTPS 访问，iPhone 需 iOS 16.4+ 且从主屏幕图标打开。
 - **跨渠道同步**：飞书里的会话在 Web 上也能打开接着聊。同一个授权请求同时出现在飞书卡片和网页上，哪边先点算哪边，另一边自动变成「已处理」。
 - **授权**：允许一次 / 本会话全部允许 / 总是允许（按钮上写明放行范围）/ 拒绝。`/autoedit on` 让 Claude Code 在这条会话里改工作目录内的文件不再询问（Bash 仍询问）。超时一律按拒绝处理。
 - **设置都在网页上**：工作目录、会话闲置过期时间、局域网访问和端口、各 agent 的默认模型和思考程度、可选模型、Codex 沙箱、飞书机器人、配对批准、Claude 的「总是允许」名单、通知设备、登录设备管理、用户管理、服务端升级。
 - **多用户**（信任型）：管理员在 设置 → 用户 里给别人建账号。每个人只看得到自己的对话、授权和通知，设置只有管理员能改，见下面「安全」。
-- **聊天模式 / 工作模式**：右上角的「💬 聊天 / 🛠 工作」，或者发 `/chat`、`/work`，同一条对话随时切换、上下文接着。聊天模式换成精简的系统提示，只留联网搜索，不加载技能、MCP、插件，不执行命令、不读写本机文件（文本附件的内容直接放进消息），每轮的固定开销小得多：实测一句话 Claude 约 1.6 万 → 2 千 token，Codex 约 2 万 → 1.2 万（Codex 的基础指令改不了）。适合日常聊天、查资料；要动手干活时切回工作模式。切换后第一轮要重建提示缓存，会贵一些；在工作模式里读过的大段内容还留在历史里。
+- **聊天模式 / 工作模式**：右上角「更多」里的「聊天模式」，或者发 `/chat`、`/work`，同一条对话随时切换、上下文接着。聊天模式换成精简的系统提示，只留联网搜索，不加载技能、MCP、插件，不执行命令、不读写本机文件（文本附件的内容直接放进消息），每轮的固定开销小得多：实测一句话 Claude 约 1.6 万 → 2 千 token，Codex 约 2 万 → 1.2 万（Codex 的基础指令改不了）。适合日常聊天、查资料；要动手干活时切回工作模式。切换后第一轮要重建提示缓存，会贵一些；在工作模式里读过的大段内容还留在历史里。
 - **记忆**：像 ChatGPT 的记忆，设置 → 记忆。「关于我」加上一条条记住的事，每次对话都带上；agent 在聊天里遇到长期有用的信息会自己用 `remember` 记一条（回复里会说），记错了用 `forget` 删。**自动整理**：把上次整理之后新说的话交给模型（不留会话记录的一次性调用），补充、更新或删掉过时的记忆，用户自己加的条目它不动。什么时候整理每个人自己定：每天一次（默认凌晨 4 点，把当天的对话合起来一次整理，最省）／每段对话聊完后（停多久可选，改了什么会在对话里说一声）／只在点「现在整理」时／不整理；整理哪些对话也能选：全部／只整理聊天模式的／只整理工作模式的；用哪个 agent 的哪个模型也能选，默认 Claude Haiku，没有 Claude 就用 Codex 的默认模型、思考程度 low。**参考以前的聊天**：agent 遇到「上次说的那个……」会用 `search_past_chats` 搜你以前的对话（关键词搜索，只有你自己的、没被删掉的对话；第一次用时会把已有对话收录进来）。两项都能在设置里单独关。每个用户一份，Claude 和 Codex、Web 和飞书共用。只用在有主人的对话里：你的 Web 对话，以及绑定了飞书账号后和机器人的私聊；飞书群聊不用。别人（包括管理员）看不到你的记忆，管理员只能清空它；删用户时记忆一起删，不转给管理员。
 - **定时任务**：像 ChatGPT 的 Tasks，侧栏「最近」上面的「定时任务」。到点把一段提示词交给 agent，结果发回对话：一次 / 每天 / 工作日 / 每周 / 每月 / 每隔几小时 / 自定义 cron，按服务端时区，两次至少隔 15 分钟。**有需要才提醒**（默认）：agent 自己判断这次有没有要告诉你的事（比如「有新版本才告诉我」），没有就在回复第一行写 `[[静默]]`，推送、飞书都不发，对话里折叠成一行；没写暗号一律照常提醒。结果发到**专用对话**（任务自己的一条对话，第一次运行时新建、之后续用，可选聊天 / 工作模式和目录），或者**原来的对话**。也能直接在对话里说「每天早上 9 点帮我……」：agent 用 `create_task` / `update_task` / `delete_task` / `list_tasks` 工具管理，新建、修改、删除都会先弹授权卡让你确认（只有暂停不用；没有「总是允许」），任务自己运行的那一轮里不能再建、改、删任务。按人隔离：每人只看得到、改得了自己的任务（最多 30 个），删用户时一起删；到点再核对一次对话还是不是他的，对话被删或换了主人就暂停任务。到点对话在忙（正在回复或挂着授权）就等它，最多 30 分钟；服务停着时错过 2 小时以内的启动后补跑一次。工具和记忆一样只给有主人的对话，飞书群聊里没有。
-- **技能（skills）**：侧栏「定时任务」下面的「技能」。技能就是 Claude Code / Codex 用的那种 SKILL.md（可以带脚本和资料），由 agent-loft 按人管理，两个 agent 都能用。**来源**：在页面上写、上传技能包（`.zip` / `.skill` / 单个 SKILL.md / 整个文件夹），或者在对话里让 agent「把刚才的做法存成技能」（agent 用 `create_skill` / `update_skill`，先弹授权卡）。**分享**：作者选谁看得到——仅自己 / 指定的人 / 所有人；看得到的人在「技能广场」里安装。装的是作者那一份本身，作者改了，装了的人下一条消息起就用上新的；作者取消分享或删掉，装了的人也就没了。管理员能下架别人分享出来的技能，看不到别人私有的。**使用**：工作模式下 agent 遇到对得上的事自己用；在输入框或定时任务的「要做的事」里打 `@` 选技能，点名这次用哪个（聊天模式下会把技能内容直接附上）；飞书里发 `/skills` 看能 @ 哪些。**变量**：技能可以声明要用的环境变量（接口地址、密钥），每个人填自己的值，只注入自己的会话；密钥再写上「只允许发往」的地址就成了**受保护的密钥**——不进环境变量，agent 看不到值，只能用 `skill_request` 工具让 agent-loft 代发请求（在地址、请求头、请求体里写 `{{变量名}}`），只发往你确认过的地址、不跟随跳转、响应里出现的值会被抹掉；作者后来改了地址，要你再确认一次才放行。**机器上原有的技能**（`~/.claude/skills`、`~/.agents/skills`、插件市场和 claude.ai 同步的）只给管理员：成员的会话里看不到、调不了（Claude 用技能白名单，`/技能名` 也会被拦下；Codex 关掉它自己的技能清单），管理员在技能页的「本机技能」里能看到。
+- **技能（skills）**：设置 → 技能。技能就是 Claude Code / Codex 用的那种 SKILL.md（可以带脚本和资料），由 agent-loft 按人管理，两个 agent 都能用。**来源**：在页面上写、上传技能包（`.zip` / `.skill` / 单个 SKILL.md / 整个文件夹），或者在对话里让 agent「把刚才的做法存成技能」（agent 用 `create_skill` / `update_skill`，先弹授权卡）。每人管自己的，不做分享和技能广场（以前从别人那装过的照常能用，可以卸载）。**使用**：工作模式下 agent 遇到对得上的事自己用；在输入框或定时任务的「要做的事」里打 `@` 选技能，点名这次用哪个（聊天模式下会把技能内容直接附上）；飞书里发 `/skills` 看能 @ 哪些。**变量**：技能可以声明要用的环境变量（接口地址、密钥），每个人填自己的值，只注入自己的会话；密钥再写上「只允许发往」的地址就成了**受保护的密钥**——不进环境变量，agent 看不到值，只能用 `skill_request` 工具让 agent-loft 代发请求（在地址、请求头、请求体里写 `{{变量名}}`），只发往你确认过的地址、不跟随跳转、响应里出现的值会被抹掉；作者后来改了地址，要你再确认一次才放行。**机器上原有的技能**（`~/.claude/skills`、`~/.agents/skills`、插件市场和 claude.ai 同步的）只给管理员：成员的会话里看不到、调不了（Claude 用技能白名单，`/技能名` 也会被拦下；Codex 关掉它自己的技能清单），管理员在「设置 → 技能 → 本机技能」里能看到。
 - **飞书账号绑定**：设置 → 账号 → 飞书账号 →「生成绑定码」，再在飞书私聊机器人发 `/bind 绑定码`（10 分钟内有效，群里发不算）。绑定后这个私聊就是你的个人会话：用你的记忆，`/sessions` 只列你的会话，`/web` 只能接上你自己的 Web 会话，管理员在 Web 上也看不到它。必须本人在两边各操作一次，管理员不能替人绑定（只能解除），否则就能借飞书读到别人的记忆。
 
 ## 安装

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-loft",
-  "version": "0.2.32",
+  "version": "0.2.33",
   "type": "module",
   "description": "多个 agent 的工作台：把本机 Claude Code / Codex 放到一处统一管理，用飞书和 Web 页面随时驱动——会话、审批、模型切换都共用",
   "keywords": [

package/src/agents/claude/driver.ts

@@ -23,6 +23,7 @@ import type {
   HistoryMessage,
   InteractionHost,
   ModelInfo,
+  QuestionSpec,
   QuotaInfo,
   RuntimeInfo,
   SessionOptions,
@@ -32,6 +33,7 @@ import { describeUsage, readUsage, toQuota } from "./account.js";
 import { cachedProbe, withProbe } from "./probe.js";
 import { diagnose } from "./errors.js";
 import { claudeBuiltins, ClaudeSession, describeToolUse, summarize, toModelInfo } from "./session.js";
+import { parseQuestions } from "./permissions.js";
 
 /** 模型列表几乎不变，缓存 10 分钟；读失败抛给设置页，让它退回手填 */
 const readCatalog = cachedProbe(10 * 60_000, "模型列表", () => withProbe(async (q) => toModelInfo(await q.supportedModels())));
@@ -79,7 +81,55 @@ function titleOf(info: { customTitle?: string; summary?: string; firstPrompt?: s
   return raw.length > 60 ? `${raw.slice(0, 60)}…` : raw;
 }
 
-type Block = { type?: string; text?: string; name?: string; input?: unknown; thinking?: string };
+type Block = {
+  type?: string;
+  text?: string;
+  name?: string;
+  input?: unknown;
+  thinking?: string;
+  id?: string;
+  tool_use_id?: string;
+  content?: unknown;
+  is_error?: boolean;
+};
+
+/** tool_result 的内容：字符串，或者一组 text 块 */
+function resultText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((b) => (typeof b?.text === "string" ? b.text : "")).join("");
+}
+
+/**
+ * 从 AskUserQuestion 的工具结果里取回答。Claude Code 写的是
+ * Your questions have been answered: "问题1"="答案1", "问题2"="答案2". You can now continue…
+ * 问题原文已知（工具参数里有），按顺序切开，答案里有引号、逗号也不怕。多选的答案是「a, b」
+ */
+export function parseQuestionAnswers(text: string, questions: QuestionSpec[]): { selections: number[][]; freeText: Record<number, string> } | null {
+  const body = text.replace(/^[\s\S]*?answered:\s*/, "").replace(/\.\s*You can now continue[\s\S]*$/, "");
+  const selections: number[][] = questions.map(() => []);
+  const freeText: Record<number, string> = {};
+  let found = false;
+  questions.forEach((q, i) => {
+    const head = `"${q.question}"="`;
+    const start = body.indexOf(head);
+    if (start < 0) return;
+    const from = start + head.length;
+    const nextQ = questions[i + 1];
+    const next = nextQ ? body.indexOf(`", "${nextQ.question}"="`, from) : -1;
+    const answer = body.slice(from, next >= 0 ? next : body.lastIndexOf('"')).trim();
+    if (!answer) return;
+    found = true;
+    const index = (label: string) => q.options.findIndex((o) => o.label === label);
+    // 整句就是一个选项（选项文字里本身带逗号）→ 按「, 」拆开都是选项（多选）→ 都不是就是自由作答
+    const whole = index(answer);
+    const parts = answer.split(", ").map(index);
+    if (whole >= 0) selections[i] = [whole];
+    else if (parts.every((n) => n >= 0)) selections[i] = parts;
+    else freeText[i] = answer;
+  });
+  return found ? { selections, freeText } : null;
+}
 
 function blocksOf(message: unknown): Block[] {
   const content = (message as { content?: unknown } | null)?.content;
@@ -135,6 +185,8 @@ export class ClaudeDriver implements AgentDriver {
    * 把会话记录整理成「一问一答」：用户一条，助手把这一轮所有文本拼成一条，
    * 中间的工具调用作为过程摘要挂在助手那条上。工具结果（type=user 的 tool_result）
    * 和子 agent 的消息不算对话。
+   * 例外是 AskUserQuestion：在那里把这一轮切开，中间放一条 question（问了什么、你怎么答的），
+   * 和实时看到的一样；还没答的不放（它还挂着，页面从待处理里拿）。
    */
   async readHistory(id: string, cwd: string): Promise<HistoryMessage[]> {
     if (!SESSION_ID.test(id)) return [];
@@ -145,12 +197,22 @@ export class ClaudeDriver implements AgentDriver {
       if (assistant && (assistant.text.trim() || assistant.steps?.length)) out.push(assistant);
       assistant = null;
     };
+    /** 问了、还没对上回答的：tool_use id → 那条 question */
+    const asked = new Map<string, HistoryMessage>();
     for (const msg of raw) {
       if (msg.parent_tool_use_id) continue;
       const blocks = blocksOf(msg.message);
       // 运行时带着 timestamp（ISO 字符串），类型声明里没有
       const ts = Date.parse((msg as { timestamp?: string }).timestamp ?? "");
       if (msg.type === "user") {
+        for (const b of blocks) {
+          const q = b.type === "tool_result" && b.tool_use_id ? asked.get(b.tool_use_id) : undefined;
+          if (!q?.question) continue;
+          asked.delete(b.tool_use_id!);
+          const answers = b.is_error ? null : parseQuestionAnswers(resultText(b.content), q.question.questions);
+          if (answers) Object.assign(q.question, answers);
+          else q.question.skipped = true;
+        }
         // Claude Code 自己塞进记录的「用户消息」不是人发的：后台命令跑完的 <task-notification> 等，
         // 记录里 origin.kind 不是 human。老记录可能没有 origin，再按正文开头兜底
         const origin = (msg as { origin?: { kind?: string } }).origin;
@@ -184,6 +246,21 @@ export class ClaudeDriver implements AgentDriver {
         for (const b of blocks) {
           if (b.type === "text" && b.text?.trim()) {
             assistant.text += (assistant.text ? "\n\n" : "") + b.text;
+          } else if (b.type === "tool_use" && b.name === "AskUserQuestion" && b.id) {
+            const questions = parseQuestions((b.input ?? {}) as Record<string, unknown>);
+            if (!questions) continue;
+            // 前半段封口，提问卡放中间，之后的输出另起一条
+            assistant.segment = true;
+            flush();
+            const q: HistoryMessage = {
+              role: "question",
+              text: "",
+              question: { id: `hist:${b.id}`, title: "Claude 想确认一下", questions, selections: questions.map(() => []), freeText: {} },
+              ...(Number.isFinite(ts) ? { ts } : {}),
+            };
+            asked.set(b.id, q);
+            out.push(q);
+            assistant = { role: "assistant", text: "", steps: [] };
           } else if (b.type === "tool_use" && b.name) {
             assistant.steps!.push(`🔧 ${describeToolUse(b.name, b.input)}`);
           } else if (b.type === "thinking" && b.thinking) {
@@ -194,7 +271,8 @@ export class ClaudeDriver implements AgentDriver {
       }
     }
     flush();
-    return out;
+    // 还没答的提问不放：它还挂着，页面从待处理里拿；进程挂了没答上的，也就不显示了
+    return out.filter((m) => m.role !== "question" || !asked.has(m.question!.id.slice(5)));
   }
 
   async forkAt(id: string, cwd: string, anchor?: string): Promise<string> {

package/src/agents/claude/session.ts

@@ -7,6 +7,7 @@ import fs from "node:fs";
 import {
   query,
   type McpServerConfig,
+  type ModelUsage,
   type Options,
   type PermissionResult,
   type Query,
@@ -26,7 +27,9 @@ import type {
   ModelInfo,
   RuntimeInfo,
   SavedAttachment,
+  InterruptOptions,
   SessionOptions,
+  TokenUsage,
   UserInput,
 } from "../../core/types.js";
 import {
@@ -226,12 +229,19 @@ export class ClaudeSession implements AgentSession {
    * 恢复历史、进程重启），就重新逐条询问。
    */
   private allowAll = false;
+  /**
+   * 上一轮结束时的累计费用。result 里的 total_cost_usd 是这个会话到目前的累计值，这一轮的 = 差值。
+   * 恢复 / 分叉来的会话第一轮不知道之前累计了多少，这一轮先不报费用
+   */
+  private costSoFar: number | undefined;
 
   constructor(
     private readonly opts: SessionOptions,
     private readonly events: AgentEvents,
     private readonly host: InteractionHost,
-  ) {}
+  ) {
+    this.costSoFar = opts.resumeId ? undefined : 0;
+  }
 
   get sessionId(): string | undefined {
     return this.currentId;
@@ -336,10 +346,12 @@ export class ClaudeSession implements AgentSession {
     }
 
     if (message.type === "result") {
+      const costUsd = this.turnCost(message.total_cost_usd);
+      this.reportUsage(message.modelUsage);
       if (message.subtype === "success") {
         this.events.onResult({
           text: message.result,
-          costUsd: message.total_cost_usd,
+          ...(costUsd !== undefined ? { costUsd } : {}),
           durationMs: message.duration_ms,
           ...(this.lastAssistantUuid ? { anchor: this.lastAssistantUuid } : {}),
         });
@@ -351,6 +363,32 @@ export class ClaudeSession implements AgentSession {
     }
   }
 
+  /** 这一轮的费用 = 累计费用的差值。崩溃时的 result 费用是 0，不当成新的起点 */
+  private turnCost(total: number | undefined): number | undefined {
+    if (typeof total !== "number" || !(total > 0)) return undefined;
+    const prev = this.costSoFar;
+    this.costSoFar = total;
+    return prev !== undefined && total >= prev ? total - prev : undefined;
+  }
+
+  /**
+   * 报这个会话到目前的累计用量。用 modelUsage 而不是 usage：usage 只有主循环这一轮的，
+   * modelUsage 含子 agent、压缩等所有调用，而且是累计值（恢复的会话接着原来的总数算）
+   */
+  private reportUsage(modelUsage: Record<string, ModelUsage> | undefined): void {
+    const sum: TokenUsage = { input: 0, cacheRead: 0, cacheWrite: 0, output: 0, reasoning: 0, costUsd: 0 };
+    for (const m of Object.values(modelUsage ?? {})) {
+      sum.input += m.inputTokens || 0;
+      sum.cacheRead += m.cacheReadInputTokens || 0;
+      sum.cacheWrite += m.cacheCreationInputTokens || 0;
+      sum.output += m.outputTokens || 0;
+      sum.reasoning! += m.thinkingTokens || 0;
+      sum.costUsd! += m.costUSD || 0;
+    }
+    // 崩溃时的 result 全是 0
+    if (sum.input + sum.cacheRead + sum.cacheWrite + sum.output > 0) this.events.onUsage?.(sum, true);
+  }
+
   /**
    * 一轮结束后问一次上下文占用（和 /context 同一份数据）。summary 模式只用上一次响应的
    * usage 加本地估算，不额外调 token 计数接口，很便宜。读不到就算了，只是少个指示器。
@@ -537,11 +575,17 @@ export class ClaudeSession implements AgentSession {
     return this.runtime;
   }
 
-  async interrupt(): Promise<void> {
-    // 停止 = 这一轮和排着队的都不要了
-    const dropped = this.pending.length + this.queue.clear();
-    this.pending = [];
-    if (dropped > 0) this.events.onDropped?.(dropped);
+  async interrupt(opts: InterruptOptions = {}): Promise<void> {
+    if (opts.keepQueue) {
+      // 打断并发送：排着的留着，选中的挪到最前面，这一轮出结果后 onTurnEnd 就交出它
+      const i = opts.first ? this.pending.indexOf(opts.first) : -1;
+      if (i > 0) this.pending.unshift(...this.pending.splice(i, 1));
+    } else {
+      // 停止 = 这一轮和排着队的都不要了
+      const dropped = this.pending.length + this.queue.clear();
+      this.pending = [];
+      if (dropped > 0) this.events.onDropped?.(dropped);
+    }
     if (!this.q) return;
     try {
       await this.q.interrupt();

package/src/agents/codex/session.ts

@@ -16,6 +16,7 @@ import type {
   InteractionHost,
   InteractionOutcome,
   InteractionSpec,
+  InterruptOptions,
   QuestionSpec,
   RuntimeInfo,
   SavedAttachment,
@@ -182,6 +183,16 @@ function allowed(s: Settlement): boolean {
 
 type ParsedQuestion = QuestionSpec & { secret: boolean };
 
+/** thread/tokenUsage/updated 里的一份用量（app-server 的 TokenUsageBreakdown） */
+type TokenBreakdown = {
+  totalTokens?: number;
+  inputTokens?: number;
+  cachedInputTokens?: number;
+  cacheWriteInputTokens?: number;
+  outputTokens?: number;
+  reasoningOutputTokens?: number;
+};
+
 function parseQuestions(raw: unknown): ParsedQuestion[] | null {
   if (!Array.isArray(raw) || raw.length === 0) return null;
   const specs: ParsedQuestion[] = [];
@@ -251,6 +262,10 @@ export class CodexSession implements AgentSession {
   private allowAll = false;
   private replyText = "";
   private lastTokens: number | undefined;
+  /** 上次看到的 thread 累计 token 数：变了才说明有新的模型请求（同一次请求可能报好几遍） */
+  private seenTotal: number | undefined;
+  /** 这个对象里开始过轮次：恢复 thread 时补报的旧用量不算新的消耗 */
+  private turnSeen = false;
   /** 分叉已经真正完成（拿到并接管了新 thread）。失败了不算，重试还要接着分叉 */
   private forked = false;
   /** agentMessage 的 itemId → 是不是旁白（commentary 属于过程，不流式到正文里） */
@@ -601,9 +616,15 @@ export class CodexSession implements AgentSession {
     return this.runtime;
   }
 
-  async interrupt(): Promise<void> {
-    // 停止 = 这一轮和排着队的都不要了
-    this.queue = [];
+  async interrupt(opts: InterruptOptions = {}): Promise<void> {
+    if (opts.keepQueue) {
+      // 打断并发送：排着的留着，选中的挪到最前面，这一轮结束后 drainQueue 就开它
+      const i = opts.first ? this.queue.indexOf(opts.first) : -1;
+      if (i > 0) this.queue.unshift(...this.queue.splice(i, 1));
+    } else {
+      // 停止 = 这一轮和排着队的都不要了
+      this.queue = [];
+    }
     if (this.phase === "starting" && !this.turnId) {
       // 轮次还没真正开始：记下来，拿到轮次 id 立刻中断
       this.stopRequested = true;
@@ -757,6 +778,7 @@ export class CodexSession implements AgentSession {
         if (this.phase === "idle" || (id && this.endedTurns.has(id))) return;
         if (id) this.onTurnId(id);
         this.commentaryItems.clear();
+        this.turnSeen = true;
         this.events.onTurnStart?.();
         return;
       }
@@ -776,10 +798,24 @@ export class CodexSession implements AgentSession {
       }
 
       case "thread/tokenUsage/updated": {
-        // last 是这一轮的用量，total 是整条 thread 的累计；页脚显示这一轮的
-        const usage = (
-          params as { tokenUsage?: { last?: { totalTokens?: number }; modelContextWindow?: number | null } }
-        ).tokenUsage;
+        // last 是最近一次模型请求的用量，total 是整条 thread 的累计；页脚显示最近一次的
+        const usage = (params as { tokenUsage?: { total?: TokenBreakdown; last?: TokenBreakdown; modelContextWindow?: number | null } })
+          .tokenUsage;
+        const total = usage?.total?.totalTokens;
+        if (this.turnSeen && usage?.last && typeof total === "number" && total !== this.seenTotal) {
+          const l = usage.last;
+          // OpenAI 的 inputTokens 含命中缓存的部分，拆出来
+          const cached = l.cachedInputTokens ?? 0;
+          const written = l.cacheWriteInputTokens ?? 0;
+          this.events.onUsage?.({
+            input: Math.max(0, (l.inputTokens ?? 0) - cached - written),
+            cacheRead: cached,
+            cacheWrite: written,
+            output: l.outputTokens ?? 0,
+            reasoning: l.reasoningOutputTokens ?? 0,
+          });
+        }
+        if (typeof total === "number") this.seenTotal = total;
         const turnTokens = usage?.last?.totalTokens;
         if (typeof turnTokens === "number") this.lastTokens = turnTokens;
         // 最近一次请求的用量 ≈ 当前上下文大小（Codex 自己的「剩余上下文」也是这么算的）

package/src/channels/feishu/bot.ts

@@ -272,9 +272,9 @@ export class FeishuBot {
     // 最近几句：读历史可能要一会儿，读不到也不影响接上
     const history = await hub.history(webKey).catch(() => []);
     const recent = history
-      .filter((m) => m.text.trim())
+      .filter((m) => m.role !== "question" && m.text.trim())
       .slice(-4)
-      .map((m) => ({ role: m.role, text: m.text }));
+      .map((m) => ({ role: m.role === "user" ? ("user" as const) : ("assistant" as const), text: m.text }));
     await this.client.sendCard(
       chatId,
       attachedCard({ conv: entry, recent, sessionKey: feishuKey, ctx: this.cardCtx(feishuKey, chatId) }),

package/src/channels/web/api.ts

@@ -61,6 +61,7 @@ import {
   takeAttempt,
 } from "./auth.js";
 import { canSeeConv, pushOwnedBy, sessionVisibleTo } from "./access.js";
+import { clampLimit, dirsOf, inDir, inRecent, pageOf, parseCursor } from "./conv-pages.js";
 import { clientIp, cookies, HttpError, isHttps, readBody, readJsonBody, SECURITY_HEADERS, sendJson } from "./http.js";
 import { handleTasksApi } from "./tasks-api.js";
 import { handleSkillsApi } from "./skills-api.js";
@@ -469,6 +470,45 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
 
   // ----- 总览 -----
   if (p === "/api/bootstrap" && method === "GET") {
+    // 会话只给侧栏第一屏要的（见 conv-pages.ts）：「最近」的前 recent 棵树、展开着的目录各自的前几棵，
+    // 每个飞书机器人最近的一条，再加上正在跑的、等你处理的（侧栏要显示状态）。其余点「展开显示」再拉
+    const all = hub.list(visible).filter((c) => !c.hidden);
+    const pending = interactions.listPending().filter((i) => visible(getConversation(i.convKey)));
+    const recent = pageOf(all.filter(inRecent), null, clampLimit(url.searchParams.get("recent"), 10));
+    let open: [string, number][] = [];
+    try {
+      const raw: unknown = JSON.parse(url.searchParams.get("open") ?? "[]");
+      if (Array.isArray(raw)) {
+        open = raw
+          .slice(0, 50)
+          .filter((x): x is [string, unknown] => Array.isArray(x) && typeof x[0] === "string")
+          .map(([dir, n]) => [dir, clampLimit(n, 5)]);
+      }
+    } catch {
+      // 参数坏了就当没有展开的目录
+    }
+    const dirPages = new Map(open.map(([dir, n]) => [dir, pageOf(all.filter(inDir(dir)), null, n)]));
+    const byKey = new Map(all.map((c) => [c.key, c]));
+    const keep = new Map(recent.conversations.map((c) => [c.key, c]));
+    for (const page of dirPages.values()) for (const c of page.conversations) keep.set(c.key, c);
+    const asking = new Set(pending.map((i) => i.convKey));
+    const bots = new Set<string>();
+    for (const c of all) {
+      // all 已按活跃时间从新到旧：每个机器人遇到的第一条就是它最近的
+      if (c.channel === "feishu" && !bots.has(c.channelId)) {
+        bots.add(c.channelId);
+        keep.set(c.key, c);
+      }
+      if (c.busy || asking.has(c.key)) keep.set(c.key, c);
+    }
+    // 正开着的会话（可能是后面几页里的，重连时页面上还显示着它）
+    const current = byKey.get(url.searchParams.get("current") ?? "");
+    if (current) keep.set(current.key, current);
+    // 分叉来源：提示里要写它的标题
+    for (const c of [...keep.values()]) {
+      const parent = c.forkOf ? byKey.get(c.forkOf) : undefined;
+      if (parent) keep.set(parent.key, parent);
+    }
     sendJson(res, 200, {
       agents: [...AGENT_IDS].map((id) => {
         const d = hub.driver(id);
@@ -488,8 +528,13 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
       workspaceRoot: config().workspaceRoot,
       quotaRefreshMin: config().web.quotaRefreshMin,
       quotaEnabled: config().web.quotaEnabled,
-      conversations: hub.list(visible),
-      pending: interactions.listPending().filter((i) => visible(getConversation(i.convKey))),
+      conversations: [...keep.values()],
+      sidebar: {
+        recent: { next: recent.next },
+        // 展开着的目录带上翻页游标（没带 next 的目录前端还没拉过）
+        dirs: dirsOf(all).map((d) => (dirPages.has(d.dir) ? { ...d, next: dirPages.get(d.dir)!.next } : d)),
+      },
+      pending,
       user: publicMe(user),
       serverTime: Date.now(),
     });
@@ -539,6 +584,21 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
   }
 
   // ----- 会话 -----
+  // 侧栏按页拉：scope=recent（最近）/ dir（某个项目目录）按树分页；bot（某个飞书机器人的全部聊天）平铺
+  if (p === "/api/conversations/page" && method === "GET") {
+    const all = hub.list(visible).filter((c) => !c.hidden);
+    const scope = url.searchParams.get("scope");
+    if (scope === "bot") {
+      const bot = url.searchParams.get("bot") ?? "";
+      sendJson(res, 200, { conversations: all.filter((c) => c.channel === "feishu" && c.channelId === bot).slice(0, 200), next: null });
+      return;
+    }
+    if (scope !== "recent" && scope !== "dir") throw new HttpError(400, "scope 只能是 recent / dir / bot");
+    const list = scope === "recent" ? all.filter(inRecent) : all.filter(inDir(url.searchParams.get("dir") ?? ""));
+    const before = parseCursor(url.searchParams.get("at"), url.searchParams.get("key"));
+    sendJson(res, 200, pageOf(list, before, clampLimit(url.searchParams.get("limit"), 10)));
+    return;
+  }
   if (p === "/api/conversations" && method === "GET") {
     sendJson(res, 200, hub.list(visible));
     return;
@@ -653,6 +713,8 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
         info: hub.info(key),
         messages,
         live,
+        // 进行中这一轮弹过的卡（已经处理了的也要）：重放到 ix 事件时放回原位
+        interactions: live.flatMap((e) => (e.ev.type === "ix" ? [interactions.get(e.ev.id)].filter((i) => !!i) : [])),
         seq,
         pending: interactions.listPending(key),
         allowedAgents: allowedAgentsFor(key),
@@ -738,6 +800,10 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
         case "stop":
           text = await hub.stop(key);
           break;
+        // 打断并发送：value 是排队中那条消息的编号
+        case "jump":
+          text = await hub.jump(key, value);
+          break;
         case "cd":
           text = await hub.cd(key, value);
           break;

package/src/channels/web/conv-pages.ts

@@ -0,0 +1,68 @@
+// 侧栏会话列表分页：打开页面只拿第一页，点「展开显示」再按页拉。
+//
+// 一页按「树」算：主对话连同从它分叉出来的对话算一条（和前端 sidebar.js 的 forkForest 一样），
+// 按整棵树里最近的活跃时间从新到旧排。翻页用游标（上一页最后一棵树的活跃时间 + 根的 key），
+// 期间有会话变活跃、被删，也不会漏掉或重复一页的边界。
+import type { ConversationInfo } from "../../core/hub.js";
+
+export type Cursor = { at: number; key: string };
+export type Page = { conversations: ConversationInfo[]; next: Cursor | null };
+type Tree = { root: ConversationInfo; convs: ConversationInfo[]; at: number };
+
+/** 最近：飞书以外的会话（飞书按机器人各占一行，另外给） */
+export const inRecent = (c: ConversationInfo): boolean => c.channel !== "feishu";
+/** 项目：Web 会话按工作目录分组 */
+export const inDir = (dir: string) => (c: ConversationInfo): boolean => c.channel === "web" && c.cwd === dir;
+
+/** 按分叉关系成树：父对话也在这一组里的挂到下面，其余的是根。父链绕回自己（数据坏了）就当根 */
+export function forkTrees(list: ConversationInfo[]): Tree[] {
+  const byKey = new Map(list.map((c) => [c.key, c]));
+  const rootOf = (c: ConversationInfo): ConversationInfo => {
+    let cur = c;
+    for (let n = 0; n < 50; n++) {
+      const parent = cur.forkOf ? byKey.get(cur.forkOf) : undefined;
+      if (!parent || parent.key === c.key) return cur;
+      cur = parent;
+    }
+    return c;
+  };
+  const trees = new Map<string, Tree>();
+  for (const c of list) {
+    const root = rootOf(c);
+    let t = trees.get(root.key);
+    if (!t) trees.set(root.key, (t = { root, convs: [], at: 0 }));
+    t.convs.push(c);
+    t.at = Math.max(t.at, c.activeAt);
+  }
+  return [...trees.values()].sort((a, b) => b.at - a.at || (a.root.key < b.root.key ? 1 : -1));
+}
+
+/** 游标之后的 limit 棵树 */
+export function pageOf(list: ConversationInfo[], before: Cursor | null, limit: number): Page {
+  const trees = forkTrees(list);
+  const start = before ? trees.findIndex((t) => t.at < before.at || (t.at === before.at && t.root.key < before.key)) : 0;
+  if (start < 0) return { conversations: [], next: null };
+  const slice = trees.slice(start, start + limit);
+  const last = slice[slice.length - 1];
+  return {
+    conversations: slice.flatMap((t) => t.convs),
+    next: last && start + limit < trees.length ? { at: last.at, key: last.root.key } : null,
+  };
+}
+
+/** 项目目录：每个目录最近的活跃时间（目录行本身要全部显示，会话再按需拉） */
+export function dirsOf(list: ConversationInfo[]): { dir: string; at: number }[] {
+  const at = new Map<string, number>();
+  for (const c of list) if (c.channel === "web") at.set(c.cwd, Math.max(at.get(c.cwd) ?? 0, c.activeAt));
+  return [...at].map(([dir, t]) => ({ dir, at: t })).sort((a, b) => b.at - a.at);
+}
+
+export function parseCursor(at: string | null, key: string | null): Cursor | null {
+  const n = Number(at);
+  return key && Number.isFinite(n) ? { at: n, key } : null;
+}
+
+export const clampLimit = (v: unknown, def: number): number => {
+  const n = Math.floor(Number(v));
+  return Number.isFinite(n) && n > 0 ? Math.min(n, 200) : def;
+};

package/src/channels/web/server.ts

@@ -143,6 +143,8 @@ type Client = {
   /** 页面在前台，且正看着哪条会话（前端在切会话、切前后台时上报） */
   visible: boolean;
   viewing: string | null;
+  /** 最后一次收到这个页面的消息（含 ping） */
+  seen: number;
 };
 
 /** 每次进程启动换一个：客户端发现变了，就知道 seq 已经从头计数，得整页重拉 */
@@ -187,16 +189,22 @@ function broadcastTasks(owner: string): void {
   for (const client of clients) if (client.user.id === owner) send(client, { t: "tasks" });
 }
 
-/** 技能变了：技能广场谁都可能在看，通知所有人重新拉（列表很小） */
+/** 技能变了：以前装过别人技能的人也受影响，通知所有人重新拉（列表很小） */
 function broadcastSkills(): void {
   for (const client of clients) send(client, { t: "skills" });
 }
 
 // ---------- 系统通知（Web Push） ----------
 
-/** 有页面正在前台看着这条会话：人就在眼前，不用推 */
+/**
+ * 有页面正在前台看着这条会话：人就在眼前，不用推。
+ * 页面每 25 秒发一次 ping；40 秒没收到它的任何消息就不算（手机切走后网络断了，连接还没被心跳清掉，
+ * 最后报的还是「在看」）
+ */
+const SEEN_MS = 40_000;
 function watching(key: string): boolean {
-  for (const client of clients) if (client.visible && client.viewing === key) return true;
+  const now = Date.now();
+  for (const client of clients) if (client.visible && client.viewing === key && now - client.seen < SEEN_MS) return true;
   return false;
 }
 
@@ -275,6 +283,7 @@ function handleClientMessage(client: Client, raw: string): void {
   // 每条消息都复查登录态：握手时有效不代表现在还有效（改了密码、被踢了）
   const user = checkClient(client);
   if (!user) return;
+  client.seen = Date.now();
   let msg: Record<string, unknown>;
   try {
     const parsed: unknown = JSON.parse(raw);
@@ -448,7 +457,7 @@ export async function startWeb(): Promise<void> {
       }
       const token = cookies(req)[COOKIE] ?? "";
       wss!.handleUpgrade(req, socket, head, (ws) => {
-        const client: Client = { ws, subs: new Set(), alive: true, token, user, visible: false, viewing: null };
+        const client: Client = { ws, subs: new Set(), alive: true, token, user, visible: false, viewing: null, seen: Date.now() };
         clients.add(client);
         ws.on("pong", () => (client.alive = true));
         ws.on("message", (data) => {